1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 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 #include "main/glheader.h" 27 #include "main/context.h" 28 #include "main/formats.h" 29 #include "main/format_unpack.h" 30 #include "main/format_pack.h" 31 #include "main/macros.h" 32 #include "main/imports.h" 33 34 #include "s_context.h" 35 #include "s_depth.h" 36 #include "s_span.h" 37 38 39 40 #define Z_TEST(COMPARE) \ 41 do { \ 42 GLuint i; \ 43 for (i = 0; i < n; i++) { \ 44 if (mask[i]) { \ 45 if (COMPARE) { \ 46 /* pass */ \ 47 if (write) { \ 48 zbuffer[i] = zfrag[i]; \ 49 } \ 50 passed++; \ 51 } \ 52 else { \ 53 /* fail */ \ 54 mask[i] = 0; \ 55 } \ 56 } \ 57 } \ 58 } while (0) 59 60 61 /** 62 * Do depth test for an array of 16-bit Z values. 63 * @param zbuffer array of Z buffer values (16-bit) 64 * @param zfrag array of fragment Z values (use 16-bit in 32-bit uint) 65 * @param mask which fragments are alive, killed afterward 66 * @return number of fragments which pass the test. 67 */ 68 static GLuint 69 depth_test_span16( struct gl_context *ctx, GLuint n, 70 GLushort zbuffer[], const GLuint zfrag[], GLubyte mask[] ) 71 { 72 const GLboolean write = ctx->Depth.Mask; 73 GLuint passed = 0; 74 75 /* switch cases ordered from most frequent to less frequent */ 76 switch (ctx->Depth.Func) { 77 case GL_LESS: 78 Z_TEST(zfrag[i] < zbuffer[i]); 79 break; 80 case GL_LEQUAL: 81 Z_TEST(zfrag[i] <= zbuffer[i]); 82 break; 83 case GL_GEQUAL: 84 Z_TEST(zfrag[i] >= zbuffer[i]); 85 break; 86 case GL_GREATER: 87 Z_TEST(zfrag[i] > zbuffer[i]); 88 break; 89 case GL_NOTEQUAL: 90 Z_TEST(zfrag[i] != zbuffer[i]); 91 break; 92 case GL_EQUAL: 93 Z_TEST(zfrag[i] == zbuffer[i]); 94 break; 95 case GL_ALWAYS: 96 Z_TEST(1); 97 break; 98 case GL_NEVER: 99 memset(mask, 0, n * sizeof(GLubyte)); 100 break; 101 default: 102 _mesa_problem(ctx, "Bad depth func in depth_test_span16"); 103 } 104 105 return passed; 106 } 107 108 109 /** 110 * Do depth test for an array of 32-bit Z values. 111 * @param zbuffer array of Z buffer values (32-bit) 112 * @param zfrag array of fragment Z values (use 32-bits in 32-bit uint) 113 * @param mask which fragments are alive, killed afterward 114 * @return number of fragments which pass the test. 115 */ 116 static GLuint 117 depth_test_span32( struct gl_context *ctx, GLuint n, 118 GLuint zbuffer[], const GLuint zfrag[], GLubyte mask[]) 119 { 120 const GLboolean write = ctx->Depth.Mask; 121 GLuint passed = 0; 122 123 /* switch cases ordered from most frequent to less frequent */ 124 switch (ctx->Depth.Func) { 125 case GL_LESS: 126 Z_TEST(zfrag[i] < zbuffer[i]); 127 break; 128 case GL_LEQUAL: 129 Z_TEST(zfrag[i] <= zbuffer[i]); 130 break; 131 case GL_GEQUAL: 132 Z_TEST(zfrag[i] >= zbuffer[i]); 133 break; 134 case GL_GREATER: 135 Z_TEST(zfrag[i] > zbuffer[i]); 136 break; 137 case GL_NOTEQUAL: 138 Z_TEST(zfrag[i] != zbuffer[i]); 139 break; 140 case GL_EQUAL: 141 Z_TEST(zfrag[i] == zbuffer[i]); 142 break; 143 case GL_ALWAYS: 144 Z_TEST(1); 145 break; 146 case GL_NEVER: 147 memset(mask, 0, n * sizeof(GLubyte)); 148 break; 149 default: 150 _mesa_problem(ctx, "Bad depth func in depth_test_span32"); 151 } 152 153 return passed; 154 } 155 156 157 /** 158 * Clamp fragment Z values to the depth near/far range (glDepthRange()). 159 * This is used when GL_ARB_depth_clamp/GL_DEPTH_CLAMP is turned on. 160 * In that case, vertexes are not clipped against the near/far planes 161 * so rasterization will produce fragment Z values outside the usual 162 * [0,1] range. 163 */ 164 void 165 _swrast_depth_clamp_span( struct gl_context *ctx, SWspan *span ) 166 { 167 struct gl_framebuffer *fb = ctx->DrawBuffer; 168 const GLuint count = span->end; 169 GLint *zValues = (GLint *) span->array->z; /* sign change */ 170 GLint min, max; 171 GLfloat min_f, max_f; 172 GLuint i; 173 174 if (ctx->ViewportArray[0].Near < ctx->ViewportArray[0].Far) { 175 min_f = ctx->ViewportArray[0].Near; 176 max_f = ctx->ViewportArray[0].Far; 177 } else { 178 min_f = ctx->ViewportArray[0].Far; 179 max_f = ctx->ViewportArray[0].Near; 180 } 181 182 /* Convert floating point values in [0,1] to device Z coordinates in 183 * [0, DepthMax]. 184 * ex: If the Z buffer has 24 bits, DepthMax = 0xffffff. 185 * 186 * XXX this all falls apart if we have 31 or more bits of Z because 187 * the triangle rasterization code produces unsigned Z values. Negative 188 * vertex Z values come out as large fragment Z uints. 189 */ 190 min = (GLint) (min_f * fb->_DepthMaxF); 191 max = (GLint) (max_f * fb->_DepthMaxF); 192 if (max < 0) 193 max = 0x7fffffff; /* catch over flow for 30-bit z */ 194 195 /* Note that we do the comparisons here using signed integers. 196 */ 197 for (i = 0; i < count; i++) { 198 if (zValues[i] < min) 199 zValues[i] = min; 200 if (zValues[i] > max) 201 zValues[i] = max; 202 } 203 } 204 205 206 /** 207 * Get array of 32-bit z values from the depth buffer. With clipping. 208 * Note: the returned values are always in the range [0, 2^32-1]. 209 */ 210 static void 211 get_z32_values(struct gl_context *ctx, struct gl_renderbuffer *rb, 212 GLuint count, const GLint x[], const GLint y[], 213 GLuint zbuffer[]) 214 { 215 struct swrast_renderbuffer *srb = swrast_renderbuffer(rb); 216 const GLint w = rb->Width, h = rb->Height; 217 const GLubyte *map = _swrast_pixel_address(rb, 0, 0); 218 GLuint i; 219 220 if (rb->Format == MESA_FORMAT_Z_UNORM32) { 221 const GLint rowStride = srb->RowStride; 222 for (i = 0; i < count; i++) { 223 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { 224 zbuffer[i] = *((GLuint *) (map + y[i] * rowStride + x[i] * 4)); 225 } 226 } 227 } 228 else { 229 const GLint bpp = _mesa_get_format_bytes(rb->Format); 230 const GLint rowStride = srb->RowStride; 231 for (i = 0; i < count; i++) { 232 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { 233 const GLubyte *src = map + y[i] * rowStride+ x[i] * bpp; 234 _mesa_unpack_uint_z_row(rb->Format, 1, src, &zbuffer[i]); 235 } 236 } 237 } 238 } 239 240 241 /** 242 * Put an array of 32-bit z values into the depth buffer. 243 * Note: the z values are always in the range [0, 2^32-1]. 244 */ 245 static void 246 put_z32_values(struct gl_context *ctx, struct gl_renderbuffer *rb, 247 GLuint count, const GLint x[], const GLint y[], 248 const GLuint zvalues[], const GLubyte mask[]) 249 { 250 struct swrast_renderbuffer *srb = swrast_renderbuffer(rb); 251 const GLint w = rb->Width, h = rb->Height; 252 GLubyte *map = _swrast_pixel_address(rb, 0, 0); 253 GLuint i; 254 255 if (rb->Format == MESA_FORMAT_Z_UNORM32) { 256 const GLint rowStride = srb->RowStride; 257 for (i = 0; i < count; i++) { 258 if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { 259 GLuint *dst = (GLuint *) (map + y[i] * rowStride + x[i] * 4); 260 *dst = zvalues[i]; 261 } 262 } 263 } 264 else { 265 gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format); 266 const GLint bpp = _mesa_get_format_bytes(rb->Format); 267 const GLint rowStride = srb->RowStride; 268 for (i = 0; i < count; i++) { 269 if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { 270 void *dst = map + y[i] * rowStride + x[i] * bpp; 271 packZ(zvalues + i, dst); 272 } 273 } 274 } 275 } 276 277 278 /** 279 * Apply depth (Z) buffer testing to the span. 280 * \return approx number of pixels that passed (only zero is reliable) 281 */ 282 GLuint 283 _swrast_depth_test_span(struct gl_context *ctx, SWspan *span) 284 { 285 struct gl_framebuffer *fb = ctx->DrawBuffer; 286 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; 287 const GLint bpp = _mesa_get_format_bytes(rb->Format); 288 void *zStart; 289 const GLuint count = span->end; 290 const GLuint *fragZ = span->array->z; 291 GLubyte *mask = span->array->mask; 292 void *zBufferVals; 293 GLuint *zBufferTemp = NULL; 294 GLuint passed; 295 GLuint zBits = _mesa_get_format_bits(rb->Format, GL_DEPTH_BITS); 296 GLboolean ztest16 = GL_FALSE; 297 298 if (span->arrayMask & SPAN_XY) 299 zStart = NULL; 300 else 301 zStart = _swrast_pixel_address(rb, span->x, span->y); 302 303 if (rb->Format == MESA_FORMAT_Z_UNORM16 && !(span->arrayMask & SPAN_XY)) { 304 /* directly read/write row of 16-bit Z values */ 305 zBufferVals = zStart; 306 ztest16 = GL_TRUE; 307 } 308 else if (rb->Format == MESA_FORMAT_Z_UNORM32 && !(span->arrayMask & SPAN_XY)) { 309 /* directly read/write row of 32-bit Z values */ 310 zBufferVals = zStart; 311 } 312 else { 313 if (_mesa_get_format_datatype(rb->Format) != GL_UNSIGNED_NORMALIZED) { 314 _mesa_problem(ctx, "Incorrectly writing swrast's integer depth " 315 "values to %s depth buffer", 316 _mesa_get_format_name(rb->Format)); 317 } 318 319 /* copy Z buffer values into temp buffer (32-bit Z values) */ 320 zBufferTemp = malloc(count * sizeof(GLuint)); 321 if (!zBufferTemp) 322 return 0; 323 324 if (span->arrayMask & SPAN_XY) { 325 get_z32_values(ctx, rb, count, 326 span->array->x, span->array->y, zBufferTemp); 327 } 328 else { 329 _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp); 330 } 331 332 if (zBits == 24) { 333 GLuint i; 334 /* Convert depth buffer values from 32 to 24 bits to match the 335 * fragment Z values generated by rasterization. 336 */ 337 for (i = 0; i < count; i++) { 338 zBufferTemp[i] >>= 8; 339 } 340 } 341 else if (zBits == 16) { 342 GLuint i; 343 /* Convert depth buffer values from 32 to 16 bits */ 344 for (i = 0; i < count; i++) { 345 zBufferTemp[i] >>= 16; 346 } 347 } 348 else { 349 assert(zBits == 32); 350 } 351 352 zBufferVals = zBufferTemp; 353 } 354 355 /* do the depth test either with 16 or 32-bit values */ 356 if (ztest16) 357 passed = depth_test_span16(ctx, count, zBufferVals, fragZ, mask); 358 else 359 passed = depth_test_span32(ctx, count, zBufferVals, fragZ, mask); 360 361 if (zBufferTemp) { 362 /* need to write temp Z values back into the buffer */ 363 364 /* Convert depth buffer values back to 32-bit values. The least 365 * significant bits don't matter since they'll get dropped when 366 * they're packed back into the depth buffer. 367 */ 368 if (zBits == 24) { 369 GLuint i; 370 for (i = 0; i < count; i++) { 371 zBufferTemp[i] = (zBufferTemp[i] << 8); 372 } 373 } 374 else if (zBits == 16) { 375 GLuint i; 376 for (i = 0; i < count; i++) { 377 zBufferTemp[i] = zBufferTemp[i] << 16; 378 } 379 } 380 381 if (span->arrayMask & SPAN_XY) { 382 /* random locations */ 383 put_z32_values(ctx, rb, count, span->array->x, span->array->y, 384 zBufferTemp, mask); 385 } 386 else { 387 /* horizontal row */ 388 gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format); 389 GLubyte *dst = zStart; 390 GLuint i; 391 for (i = 0; i < count; i++) { 392 if (mask[i]) { 393 packZ(&zBufferTemp[i], dst); 394 } 395 dst += bpp; 396 } 397 } 398 399 free(zBufferTemp); 400 } 401 402 if (passed < count) { 403 span->writeAll = GL_FALSE; 404 } 405 return passed; 406 } 407 408 409 /** 410 * GL_EXT_depth_bounds_test extension. 411 * Discard fragments depending on whether the corresponding Z-buffer 412 * values are outside the depth bounds test range. 413 * Note: we test the Z buffer values, not the fragment Z values! 414 * \return GL_TRUE if any fragments pass, GL_FALSE if no fragments pass 415 */ 416 GLboolean 417 _swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span ) 418 { 419 struct gl_framebuffer *fb = ctx->DrawBuffer; 420 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; 421 GLubyte *zStart; 422 GLuint zMin = (GLuint)((double)ctx->Depth.BoundsMin * 0xffffffff); 423 GLuint zMax = (GLuint)((double)ctx->Depth.BoundsMax * 0xffffffff); 424 GLubyte *mask = span->array->mask; 425 const GLuint count = span->end; 426 GLuint i; 427 GLboolean anyPass = GL_FALSE; 428 GLuint *zBufferTemp; 429 const GLuint *zBufferVals; 430 431 zBufferTemp = malloc(count * sizeof(GLuint)); 432 if (!zBufferTemp) { 433 /* don't generate a stream of OUT_OF_MEMORY errors here */ 434 return GL_FALSE; 435 } 436 437 if (span->arrayMask & SPAN_XY) 438 zStart = NULL; 439 else 440 zStart = _swrast_pixel_address(rb, span->x, span->y); 441 442 if (rb->Format == MESA_FORMAT_Z_UNORM32 && !(span->arrayMask & SPAN_XY)) { 443 /* directly access 32-bit values in the depth buffer */ 444 zBufferVals = (const GLuint *) zStart; 445 } 446 else { 447 /* Round the bounds to the precision of the zbuffer. */ 448 if (rb->Format == MESA_FORMAT_Z_UNORM16) { 449 zMin = (zMin & 0xffff0000) | (zMin >> 16); 450 zMax = (zMax & 0xffff0000) | (zMax >> 16); 451 } else { 452 /* 24 bits */ 453 zMin = (zMin & 0xffffff00) | (zMin >> 24); 454 zMax = (zMax & 0xffffff00) | (zMax >> 24); 455 } 456 457 /* unpack Z values into a temporary array */ 458 if (span->arrayMask & SPAN_XY) { 459 get_z32_values(ctx, rb, count, span->array->x, span->array->y, 460 zBufferTemp); 461 } 462 else { 463 _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp); 464 } 465 zBufferVals = zBufferTemp; 466 } 467 468 /* Now do the tests */ 469 for (i = 0; i < count; i++) { 470 if (mask[i]) { 471 if (zBufferVals[i] < zMin || zBufferVals[i] > zMax) 472 mask[i] = GL_FALSE; 473 else 474 anyPass = GL_TRUE; 475 } 476 } 477 478 free(zBufferTemp); 479 480 return anyPass; 481 } 482 483 484 485 /**********************************************************************/ 486 /***** Read Depth Buffer *****/ 487 /**********************************************************************/ 488 489 490 /** 491 * Read a span of depth values from the given depth renderbuffer, returning 492 * the values as GLfloats. 493 * This function does clipping to prevent reading outside the depth buffer's 494 * bounds. 495 */ 496 void 497 _swrast_read_depth_span_float(struct gl_context *ctx, 498 struct gl_renderbuffer *rb, 499 GLint n, GLint x, GLint y, GLfloat depth[]) 500 { 501 if (!rb) { 502 /* really only doing this to prevent FP exceptions later */ 503 memset(depth, 0, n * sizeof(GLfloat)); 504 return; 505 } 506 507 if (y < 0 || y >= (GLint) rb->Height || 508 x + n <= 0 || x >= (GLint) rb->Width) { 509 /* span is completely outside framebuffer */ 510 memset(depth, 0, n * sizeof(GLfloat)); 511 return; 512 } 513 514 if (x < 0) { 515 GLint dx = -x; 516 GLint i; 517 for (i = 0; i < dx; i++) 518 depth[i] = 0.0; 519 x = 0; 520 n -= dx; 521 depth += dx; 522 } 523 if (x + n > (GLint) rb->Width) { 524 GLint dx = x + n - (GLint) rb->Width; 525 GLint i; 526 for (i = 0; i < dx; i++) 527 depth[n - i - 1] = 0.0; 528 n -= dx; 529 } 530 if (n <= 0) { 531 return; 532 } 533 534 _mesa_unpack_float_z_row(rb->Format, n, _swrast_pixel_address(rb, x, y), 535 depth); 536 } 537 538 539 /** 540 * Clear the given z/depth renderbuffer. If the buffer is a combined 541 * depth+stencil buffer, only the Z bits will be touched. 542 */ 543 void 544 _swrast_clear_depth_buffer(struct gl_context *ctx) 545 { 546 struct gl_renderbuffer *rb = 547 ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer; 548 GLint x, y, width, height; 549 GLubyte *map; 550 GLint rowStride, i, j; 551 GLbitfield mapMode; 552 553 if (!rb || !ctx->Depth.Mask) { 554 /* no depth buffer, or writing to it is disabled */ 555 return; 556 } 557 558 /* compute region to clear */ 559 x = ctx->DrawBuffer->_Xmin; 560 y = ctx->DrawBuffer->_Ymin; 561 width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin; 562 height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin; 563 564 mapMode = GL_MAP_WRITE_BIT; 565 if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT || 566 rb->Format == MESA_FORMAT_Z24_UNORM_X8_UINT || 567 rb->Format == MESA_FORMAT_S8_UINT_Z24_UNORM || 568 rb->Format == MESA_FORMAT_X8_UINT_Z24_UNORM) { 569 mapMode |= GL_MAP_READ_BIT; 570 } 571 572 ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, 573 mapMode, &map, &rowStride); 574 if (!map) { 575 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth)"); 576 return; 577 } 578 579 switch (rb->Format) { 580 case MESA_FORMAT_Z_UNORM16: 581 { 582 GLfloat clear = (GLfloat) ctx->Depth.Clear; 583 GLushort clearVal = 0; 584 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal); 585 if (clearVal == 0xffff && width * 2 == rowStride) { 586 /* common case */ 587 memset(map, 0xff, width * height * 2); 588 } 589 else { 590 for (i = 0; i < height; i++) { 591 GLushort *row = (GLushort *) map; 592 for (j = 0; j < width; j++) { 593 row[j] = clearVal; 594 } 595 map += rowStride; 596 } 597 } 598 } 599 break; 600 case MESA_FORMAT_Z_UNORM32: 601 case MESA_FORMAT_Z_FLOAT32: 602 { 603 GLfloat clear = (GLfloat) ctx->Depth.Clear; 604 GLuint clearVal = 0; 605 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal); 606 for (i = 0; i < height; i++) { 607 GLuint *row = (GLuint *) map; 608 for (j = 0; j < width; j++) { 609 row[j] = clearVal; 610 } 611 map += rowStride; 612 } 613 } 614 break; 615 case MESA_FORMAT_Z24_UNORM_S8_UINT: 616 case MESA_FORMAT_Z24_UNORM_X8_UINT: 617 case MESA_FORMAT_S8_UINT_Z24_UNORM: 618 case MESA_FORMAT_X8_UINT_Z24_UNORM: 619 { 620 GLfloat clear = (GLfloat) ctx->Depth.Clear; 621 GLuint clearVal = 0; 622 GLuint mask; 623 624 if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT || 625 rb->Format == MESA_FORMAT_Z24_UNORM_X8_UINT) 626 mask = 0xff000000; 627 else 628 mask = 0xff; 629 630 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal); 631 for (i = 0; i < height; i++) { 632 GLuint *row = (GLuint *) map; 633 for (j = 0; j < width; j++) { 634 row[j] = (row[j] & mask) | clearVal; 635 } 636 map += rowStride; 637 } 638 639 } 640 break; 641 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 642 /* XXX untested */ 643 { 644 GLfloat clearVal = (GLfloat) ctx->Depth.Clear; 645 for (i = 0; i < height; i++) { 646 GLfloat *row = (GLfloat *) map; 647 for (j = 0; j < width; j++) { 648 row[j * 2] = clearVal; 649 } 650 map += rowStride; 651 } 652 } 653 break; 654 default: 655 _mesa_problem(ctx, "Unexpected depth buffer format %s" 656 " in _swrast_clear_depth_buffer()", 657 _mesa_get_format_name(rb->Format)); 658 } 659 660 ctx->Driver.UnmapRenderbuffer(ctx, rb); 661 } 662 663 664 665 666 /** 667 * Clear both depth and stencil values in a combined depth+stencil buffer. 668 */ 669 void 670 _swrast_clear_depth_stencil_buffer(struct gl_context *ctx) 671 { 672 const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits; 673 const GLuint writeMask = ctx->Stencil.WriteMask[0]; 674 const GLuint stencilMax = (1 << stencilBits) - 1; 675 struct gl_renderbuffer *rb = 676 ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer; 677 GLint x, y, width, height; 678 GLbitfield mapMode; 679 GLubyte *map; 680 GLint rowStride, i, j; 681 682 /* check that we really have a combined depth+stencil buffer */ 683 assert(rb == ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer); 684 685 /* compute region to clear */ 686 x = ctx->DrawBuffer->_Xmin; 687 y = ctx->DrawBuffer->_Ymin; 688 width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin; 689 height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin; 690 691 mapMode = GL_MAP_WRITE_BIT; 692 if ((writeMask & stencilMax) != stencilMax) { 693 /* need to mask stencil values */ 694 mapMode |= GL_MAP_READ_BIT; 695 } 696 697 ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, 698 mapMode, &map, &rowStride); 699 if (!map) { 700 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth+stencil)"); 701 return; 702 } 703 704 switch (rb->Format) { 705 case MESA_FORMAT_Z24_UNORM_S8_UINT: 706 case MESA_FORMAT_S8_UINT_Z24_UNORM: 707 { 708 GLfloat zClear = (GLfloat) ctx->Depth.Clear; 709 GLuint clear = 0, mask; 710 711 _mesa_pack_float_z_row(rb->Format, 1, &zClear, &clear); 712 713 if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT) { 714 mask = ((~writeMask) & 0xff) << 24; 715 clear |= (ctx->Stencil.Clear & writeMask & 0xff) << 24; 716 } 717 else { 718 mask = ((~writeMask) & 0xff); 719 clear |= (ctx->Stencil.Clear & writeMask & 0xff); 720 } 721 722 for (i = 0; i < height; i++) { 723 GLuint *row = (GLuint *) map; 724 if (mask != 0x0) { 725 for (j = 0; j < width; j++) { 726 row[j] = (row[j] & mask) | clear; 727 } 728 } 729 else { 730 for (j = 0; j < width; j++) { 731 row[j] = clear; 732 } 733 } 734 map += rowStride; 735 } 736 } 737 break; 738 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 739 /* XXX untested */ 740 { 741 const GLfloat zClear = (GLfloat) ctx->Depth.Clear; 742 const GLuint sClear = ctx->Stencil.Clear & writeMask; 743 const GLuint sMask = (~writeMask) & 0xff; 744 for (i = 0; i < height; i++) { 745 GLfloat *zRow = (GLfloat *) map; 746 GLuint *sRow = (GLuint *) map; 747 for (j = 0; j < width; j++) { 748 zRow[j * 2 + 0] = zClear; 749 } 750 if (sMask != 0) { 751 for (j = 0; j < width; j++) { 752 sRow[j * 2 + 1] = (sRow[j * 2 + 1] & sMask) | sClear; 753 } 754 } 755 else { 756 for (j = 0; j < width; j++) { 757 sRow[j * 2 + 1] = sClear; 758 } 759 } 760 map += rowStride; 761 } 762 } 763 break; 764 default: 765 _mesa_problem(ctx, "Unexpected depth buffer format %s" 766 " in _swrast_clear_depth_buffer()", 767 _mesa_get_format_name(rb->Format)); 768 } 769 770 ctx->Driver.UnmapRenderbuffer(ctx, rb); 771 772 } 773
