1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * \file swrast/s_context.h
28 * \brief Software rasterization context and private types.
29 * \author Keith Whitwell <keithw@vmware.com>
30 */
31
32 /**
33 * \mainpage swrast module
34 *
35 * This module, software rasterization, contains the software fallback
36 * routines for drawing points, lines, triangles, bitmaps and images.
37 * All rendering boils down to writing spans (arrays) of pixels with
38 * particular colors. The span-writing routines must be implemented
39 * by the device driver.
40 */
41
42
43 #ifndef S_CONTEXT_H
44 #define S_CONTEXT_H
45
46 #include "main/compiler.h"
47 #include "main/mtypes.h"
48 #include "main/texcompress.h"
49 #include "program/prog_execute.h"
50 #include "swrast.h"
51 #include "s_fragprog.h"
52 #include "s_span.h"
53
54
55 typedef void (*texture_sample_func)(struct gl_context *ctx,
56 const struct gl_sampler_object *samp,
57 const struct gl_texture_object *tObj,
58 GLuint n, const GLfloat texcoords[][4],
59 const GLfloat lambda[], GLfloat rgba[][4]);
60
61 typedef void (*blend_func)(struct gl_context *ctx, GLuint n,
62 const GLubyte mask[],
63 GLvoid *src, const GLvoid *dst,
64 GLenum chanType);
65
66 typedef void (*swrast_point_func)( struct gl_context *ctx, const SWvertex *);
67
68 typedef void (*swrast_line_func)( struct gl_context *ctx,
69 const SWvertex *, const SWvertex *);
70
71 typedef void (*swrast_tri_func)( struct gl_context *ctx, const SWvertex *,
72 const SWvertex *, const SWvertex *);
73
74
75 typedef void (*validate_texture_image_func)(struct gl_context *ctx,
76 struct gl_texture_object *texObj,
77 GLuint face, GLuint level);
78
79
80 /**
81 * \defgroup Bitmasks
82 * Bitmasks to indicate which rasterization options are enabled
83 * (RasterMask)
84 */
85 /*@{*/
86 #define ALPHATEST_BIT 0x001 /**< Alpha-test pixels */
87 #define BLEND_BIT 0x002 /**< Blend pixels */
88 #define DEPTH_BIT 0x004 /**< Depth-test pixels */
89 #define FOG_BIT 0x008 /**< Fog pixels */
90 #define LOGIC_OP_BIT 0x010 /**< Apply logic op in software */
91 #define CLIP_BIT 0x020 /**< Scissor or window clip pixels */
92 #define STENCIL_BIT 0x040 /**< Stencil pixels */
93 #define MASKING_BIT 0x080 /**< Do glColorMask or glIndexMask */
94 #define MULTI_DRAW_BIT 0x400 /**< Write to more than one color- */
95 /**< buffer or no buffers. */
96 #define OCCLUSION_BIT 0x800 /**< GL_HP_occlusion_test enabled */
97 #define TEXTURE_BIT 0x1000 /**< Texturing really enabled */
98 #define FRAGPROG_BIT 0x2000 /**< Fragment program enabled */
99 #define ATIFRAGSHADER_BIT 0x4000 /**< ATI Fragment shader enabled */
100 #define CLAMPING_BIT 0x8000 /**< Clamp colors to [0,1] */
101 /*@}*/
102
103 #define _SWRAST_NEW_RASTERMASK (_NEW_BUFFERS| \
104 _NEW_SCISSOR| \
105 _NEW_COLOR| \
106 _NEW_DEPTH| \
107 _NEW_FOG| \
108 _NEW_PROGRAM| \
109 _NEW_STENCIL| \
110 _NEW_TEXTURE| \
111 _NEW_VIEWPORT| \
112 _NEW_DEPTH)
113
114
115 struct swrast_texture_image;
116
117
118 /**
119 * Fetch a texel from texture image at given position.
120 */
121 typedef void (*FetchTexelFunc)(const struct swrast_texture_image *texImage,
122 GLint col, GLint row, GLint img,
123 GLfloat *texelOut);
124
125
126 /**
127 * Subclass of gl_texture_image.
128 * We need extra fields/info to keep tracking of mapped texture buffers,
129 * strides and Fetch functions.
130 */
131 struct swrast_texture_image
132 {
133 struct gl_texture_image Base;
134
135 GLboolean _IsPowerOfTwo; /**< Are all dimensions powers of two? */
136
137 /** used for mipmap LOD computation */
138 GLfloat WidthScale, HeightScale, DepthScale;
139
140 /**
141 * Byte stride between rows in ImageSlices.
142 *
143 * For compressed textures, this is the byte stride between one row of
144 * blocks and the next row of blocks.
145 *
146 * Only valid while one of the ImageSlices is mapped, and must be the same
147 * between all slices.
148 */
149 GLint RowStride;
150 /**
151 * When a texture image is mapped for swrast, this array contains pointers
152 * to the beginning of each slice.
153 *
154 * For swrast-allocated textures, these pointers will always stay
155 * initialized to point within Buffer.
156 */
157 void **ImageSlices;
158
159 /** Malloc'd texture memory */
160 GLubyte *Buffer;
161
162 FetchTexelFunc FetchTexel;
163
164 /** For fetching texels from compressed textures */
165 compressed_fetch_func FetchCompressedTexel;
166 };
167
168
169 /** cast wrapper */
170 static inline struct swrast_texture_image *
swrast_texture_image(struct gl_texture_image * img)171 swrast_texture_image(struct gl_texture_image *img)
172 {
173 return (struct swrast_texture_image *) img;
174 }
175
176 /** cast wrapper */
177 static inline const struct swrast_texture_image *
swrast_texture_image_const(const struct gl_texture_image * img)178 swrast_texture_image_const(const struct gl_texture_image *img)
179 {
180 return (const struct swrast_texture_image *) img;
181 }
182
183
184 /**
185 * Subclass of gl_renderbuffer with extra fields needed for software
186 * rendering.
187 */
188 struct swrast_renderbuffer
189 {
190 struct gl_renderbuffer Base;
191
192 GLubyte *Buffer; /**< The malloc'd memory for buffer */
193
194 /** These fields are only valid while buffer is mapped for rendering */
195 GLubyte *Map;
196 GLint RowStride; /**< in bytes */
197
198 /** For span rendering */
199 GLenum ColorType;
200 };
201
202
203 /** cast wrapper */
204 static inline struct swrast_renderbuffer *
swrast_renderbuffer(struct gl_renderbuffer * img)205 swrast_renderbuffer(struct gl_renderbuffer *img)
206 {
207 return (struct swrast_renderbuffer *) img;
208 }
209
210
211
212 /**
213 * \struct SWcontext
214 * \brief Per-context state that's private to the software rasterizer module.
215 */
216 typedef struct
217 {
218 /** Driver interface:
219 */
220 struct swrast_device_driver Driver;
221
222 /** Configuration mechanisms to make software rasterizer match
223 * characteristics of the hardware rasterizer (if present):
224 */
225 GLboolean AllowVertexFog;
226 GLboolean AllowPixelFog;
227
228 /** Derived values, invalidated on statechanges, updated from
229 * _swrast_validate_derived():
230 */
231 GLbitfield _RasterMask;
232 GLfloat _BackfaceSign; /** +1 or -1 */
233 GLfloat _BackfaceCullSign; /** +1, 0, or -1 */
234 GLboolean _PreferPixelFog; /* Compute fog blend factor per fragment? */
235 GLboolean _TextureCombinePrimary;
236 GLboolean _FogEnabled;
237 GLboolean _DeferredTexture;
238
239 /** List/array of the fragment attributes to interpolate */
240 GLuint _ActiveAttribs[VARYING_SLOT_MAX];
241 /** Same info, but as a bitmask of VARYING_BIT_x bits */
242 GLbitfield64 _ActiveAttribMask;
243 /** Number of fragment attributes to interpolate */
244 GLuint _NumActiveAttribs;
245 /** Indicates how each attrib is to be interpolated (lines/tris) */
246 GLenum _InterpMode[VARYING_SLOT_MAX]; /* GL_FLAT or GL_SMOOTH (for now) */
247
248 /* Working values:
249 */
250 GLuint StippleCounter; /**< Line stipple counter */
251 GLuint PointLineFacing;
252 GLbitfield NewState;
253 GLuint StateChanges;
254 GLenum Primitive; /* current primitive being drawn (ala glBegin) */
255 GLboolean SpecularVertexAdd; /**< Add specular/secondary color per vertex */
256
257 void (*InvalidateState)( struct gl_context *ctx, GLbitfield new_state );
258
259 /**
260 * When the NewState mask intersects these masks, we invalidate the
261 * Point/Line/Triangle function pointers below.
262 */
263 /*@{*/
264 GLbitfield InvalidatePointMask;
265 GLbitfield InvalidateLineMask;
266 GLbitfield InvalidateTriangleMask;
267 /*@}*/
268
269 /**
270 * Device drivers plug in functions for these callbacks.
271 * Will be called when the GL state change mask intersects the above masks.
272 */
273 /*@{*/
274 void (*choose_point)( struct gl_context * );
275 void (*choose_line)( struct gl_context * );
276 void (*choose_triangle)( struct gl_context * );
277 /*@}*/
278
279 /**
280 * Current point, line and triangle drawing functions.
281 */
282 /*@{*/
283 swrast_point_func Point;
284 swrast_line_func Line;
285 swrast_tri_func Triangle;
286 /*@}*/
287
288 /**
289 * Placeholders for when separate specular (or secondary color) is
290 * enabled but texturing is not.
291 */
292 /*@{*/
293 swrast_point_func SpecPoint;
294 swrast_line_func SpecLine;
295 swrast_tri_func SpecTriangle;
296 /*@}*/
297
298 /**
299 * Typically, we'll allocate a sw_span structure as a local variable
300 * and set its 'array' pointer to point to this object. The reason is
301 * this object is big and causes problems when allocated on the stack
302 * on some systems.
303 */
304 SWspanarrays *SpanArrays;
305 SWspanarrays *ZoomedArrays; /**< For pixel zooming */
306
307 /**
308 * Used to buffer N GL_POINTS, instead of rendering one by one.
309 */
310 SWspan PointSpan;
311
312 /** Internal hooks, kept up to date by the same mechanism as above.
313 */
314 blend_func BlendFunc;
315 texture_sample_func TextureSample[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
316
317 /** Buffer for saving the sampled texture colors.
318 * Needed for GL_ARB_texture_env_crossbar implementation.
319 */
320 GLfloat *TexelBuffer;
321
322 validate_texture_image_func ValidateTextureImage;
323
324 /** State used during execution of fragment programs */
325 struct gl_program_machine FragProgMachine;
326
327 /** Temporary arrays for stencil operations. To avoid large stack
328 * allocations.
329 */
330 struct {
331 GLubyte *buf1, *buf2, *buf3, *buf4;
332 } stencil_temp;
333
334 } SWcontext;
335
336
337 extern void
338 _swrast_validate_derived( struct gl_context *ctx );
339
340 extern void
341 _swrast_update_texture_samplers(struct gl_context *ctx);
342
343
344 /** Return SWcontext for the given struct gl_context */
345 static inline SWcontext *
SWRAST_CONTEXT(struct gl_context * ctx)346 SWRAST_CONTEXT(struct gl_context *ctx)
347 {
348 return (SWcontext *) ctx->swrast_context;
349 }
350
351 /** const version of above */
352 static inline const SWcontext *
CONST_SWRAST_CONTEXT(const struct gl_context * ctx)353 CONST_SWRAST_CONTEXT(const struct gl_context *ctx)
354 {
355 return (const SWcontext *) ctx->swrast_context;
356 }
357
358
359 /**
360 * Called prior to framebuffer reading/writing.
361 * For drivers that rely on swrast for fallback rendering, this is the
362 * driver's opportunity to map renderbuffers and textures.
363 */
364 static inline void
swrast_render_start(struct gl_context * ctx)365 swrast_render_start(struct gl_context *ctx)
366 {
367 SWcontext *swrast = SWRAST_CONTEXT(ctx);
368 if (swrast->Driver.SpanRenderStart)
369 swrast->Driver.SpanRenderStart(ctx);
370 }
371
372
373 /** Called after framebuffer reading/writing */
374 static inline void
swrast_render_finish(struct gl_context * ctx)375 swrast_render_finish(struct gl_context *ctx)
376 {
377 SWcontext *swrast = SWRAST_CONTEXT(ctx);
378 if (swrast->Driver.SpanRenderFinish)
379 swrast->Driver.SpanRenderFinish(ctx);
380 }
381
382
383 extern void
384 _swrast_span_render_start(struct gl_context *ctx);
385
386 extern void
387 _swrast_span_render_finish(struct gl_context *ctx);
388
389 extern void
390 _swrast_map_textures(struct gl_context *ctx);
391
392 extern void
393 _swrast_unmap_textures(struct gl_context *ctx);
394
395 extern unsigned int
396 _swrast_teximage_slice_height(struct gl_texture_image *texImage);
397
398 extern void
399 _swrast_map_texture(struct gl_context *ctx, struct gl_texture_object *texObj);
400
401 extern void
402 _swrast_unmap_texture(struct gl_context *ctx, struct gl_texture_object *texObj);
403
404
405 extern void
406 _swrast_map_renderbuffers(struct gl_context *ctx);
407
408 extern void
409 _swrast_unmap_renderbuffers(struct gl_context *ctx);
410
411
412 /**
413 * Size of an RGBA pixel, in bytes, for given datatype.
414 */
415 #define RGBA_PIXEL_SIZE(TYPE) \
416 ((TYPE == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) : \
417 ((TYPE == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort) \
418 : 4 * sizeof(GLfloat)))
419
420
421
422 /*
423 * Fixed point arithmetic macros
424 */
425 #ifndef FIXED_FRAC_BITS
426 #define FIXED_FRAC_BITS 11
427 #endif
428
429 #define FIXED_SHIFT FIXED_FRAC_BITS
430 #define FIXED_ONE (1 << FIXED_SHIFT)
431 #define FIXED_HALF (1 << (FIXED_SHIFT-1))
432 #define FIXED_FRAC_MASK (FIXED_ONE - 1)
433 #define FIXED_INT_MASK (~FIXED_FRAC_MASK)
434 #define FIXED_EPSILON 1
435 #define FIXED_SCALE ((float) FIXED_ONE)
436 #define FIXED_DBL_SCALE ((double) FIXED_ONE)
437 #define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))
438 #define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE))
439 #define IntToFixed(I) ((I) << FIXED_SHIFT)
440 #define FixedToInt(X) ((X) >> FIXED_SHIFT)
441 #define FixedToUns(X) (((unsigned int)(X)) >> FIXED_SHIFT)
442 #define FixedCeil(X) (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
443 #define FixedFloor(X) ((X) & FIXED_INT_MASK)
444 #define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))
445 #define PosFloatToFixed(X) FloatToFixed(X)
446 #define SignedFloatToFixed(X) FloatToFixed(X)
447
448
449
450 /*
451 * XXX these macros are just bandages for now in order to make
452 * CHAN_BITS==32 compile cleanly.
453 * These should probably go elsewhere at some point.
454 */
455 #if CHAN_TYPE == GL_FLOAT
456 #define ChanToFixed(X) (X)
457 #define FixedToChan(X) (X)
458 #else
459 #define ChanToFixed(X) IntToFixed(X)
460 #define FixedToChan(X) FixedToInt(X)
461 #endif
462
463
464 /**
465 * For looping over fragment attributes in the pointe, line
466 * triangle rasterizers.
467 */
468 #define ATTRIB_LOOP_BEGIN \
469 { \
470 GLuint a; \
471 for (a = 0; a < swrast->_NumActiveAttribs; a++) { \
472 const GLuint attr = swrast->_ActiveAttribs[a];
473
474 #define ATTRIB_LOOP_END } }
475
476
477 /**
478 * Return the address of a pixel value in a mapped renderbuffer.
479 */
480 static inline GLubyte *
_swrast_pixel_address(struct gl_renderbuffer * rb,GLint x,GLint y)481 _swrast_pixel_address(struct gl_renderbuffer *rb, GLint x, GLint y)
482 {
483 struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
484 const GLint bpp = _mesa_get_format_bytes(rb->Format);
485 const GLint rowStride = srb->RowStride;
486 assert(x >= 0);
487 assert(y >= 0);
488 /* NOTE: using <= only because of s_tritemp.h which gets a pixel
489 * address but doesn't necessarily access it.
490 */
491 assert(x <= (GLint) rb->Width);
492 assert(y <= (GLint) rb->Height);
493 assert(srb->Map);
494 return (GLubyte *) srb->Map + y * rowStride + x * bpp;
495 }
496
497
498
499 #endif
500