Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4358 | Serge | 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 |
||
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 (_ASMAPIP 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 * |
||
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 * |
||
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 * |
||
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 * |
||
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 * |
||
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 |
||
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 |
||
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 * |
||
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=>=>=>>><>><>><>>>>>>>>>>>>>>>>>>>>>> |