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 (at) 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 * 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 500
