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