projects / mesa.git / blob
? search:


42724c72b8efd79ea7cdebbbb444c5330ebfbdf5
[mesa.git] / src / mesa / swrast / s_depth.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.2.1
4 *
5 * Copyright (C) 1999-2008 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 #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->Viewport.Near < ctx->Viewport.Far) {
175 min_f = ctx->Viewport.Near;
176 max_f = ctx->Viewport.Far;
177 } else {
178 min_f = ctx->Viewport.Far;
179 max_f = ctx->Viewport.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 const GLint w = rb->Width, h = rb->Height;
216 const GLubyte *map = (const GLubyte *) rb->Data;
217 GLuint i;
218
219 if (rb->Format == MESA_FORMAT_Z32) {
220 const GLint rowStride = rb->RowStride * 4;
221 for (i = 0; i < count; i++) {
222 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
223 zbuffer[i] = *((GLuint *) (map + y[i] * rowStride + x[i] * 4));
224 }
225 }
226 }
227 else {
228 const GLint bpp = _mesa_get_format_bytes(rb->Format);
229 const GLint rowStride = rb->RowStride * bpp;
230 for (i = 0; i < count; i++) {
231 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
232 const GLubyte *src = map + y[i] * rowStride+ x[i] * bpp;
233 _mesa_unpack_uint_z_row(rb->Format, 1, src, &zbuffer[i]);
234 }
235 }
236 }
237 }
238
239
240 /**
241 * Put an array of 32-bit z values into the depth buffer.
242 * Note: the z values are always in the range [0, 2^32-1].
243 */
244 static void
245 put_z32_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
246 GLuint count, const GLint x[], const GLint y[],
247 const GLuint zvalues[], const GLubyte mask[])
248 {
249 const GLint w = rb->Width, h = rb->Height;
250 GLubyte *map = (GLubyte *) rb->Data;
251 GLuint i;
252
253 if (rb->Format == MESA_FORMAT_Z32) {
254 const GLuint rowStride = rb->RowStride * 4;
255 for (i = 0; i < count; i++) {
256 if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
257 GLuint *dst = (GLuint *) (map + y[i] * rowStride + x[i] * 4);
258 *dst = zvalues[i];
259 }
260 }
261 }
262 else {
263 gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format);
264 const GLint bpp = _mesa_get_format_bytes(rb->Format);
265 const GLint rowStride = rb->RowStride * bpp;
266 for (i = 0; i < count; i++) {
267 if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
268 void *dst = map + y[i] * rowStride + x[i] * bpp;
269 packZ(zvalues + i, dst);
270 }
271 }
272 }
273 }
274
275
276 /**
277 * Apply depth (Z) buffer testing to the span.
278 * \return approx number of pixels that passed (only zero is reliable)
279 */
280 GLuint
281 _swrast_depth_test_span(struct gl_context *ctx, SWspan *span)
282 {
283 struct gl_framebuffer *fb = ctx->DrawBuffer;
284 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
285 const GLint bpp = _mesa_get_format_bytes(rb->Format);
286 void *zStart = _swrast_pixel_address(rb, span->x, span->y);
287 const GLuint count = span->end;
288 const GLuint *fragZ = span->array->z;
289 GLubyte *mask = span->array->mask;
290 void *zBufferVals;
291 GLuint *zBufferTemp = NULL;
292 GLuint passed;
293 GLuint zBits = _mesa_get_format_bits(rb->Format, GL_DEPTH_BITS);
294 GLboolean ztest16 = GL_FALSE;
295
296 if (rb->Format == MESA_FORMAT_Z16 && !(span->arrayMask & SPAN_XY)) {
297 /* directly read/write row of 16-bit Z values */
298 zBufferVals = zStart;
299 ztest16 = GL_TRUE;
300 }
301 else if (rb->Format == MESA_FORMAT_Z32 && !(span->arrayMask & SPAN_XY)) {
302 /* directly read/write row of 32-bit Z values */
303 zBufferVals = zStart;
304 }
305 else {
306 /* copy Z buffer values into temp buffer (32-bit Z values) */
307 zBufferTemp = (GLuint *) malloc(count * sizeof(GLuint));
308 if (!zBufferTemp)
309 return 0;
310
311 if (span->arrayMask & SPAN_XY) {
312 get_z32_values(ctx, rb, count,
313 span->array->x, span->array->y, zBufferTemp);
314 }
315 else {
316 _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp);
317 }
318
319 if (zBits == 24) {
320 GLuint i;
321 /* Convert depth buffer values from 32 to 24 bits to match the
322 * fragment Z values generated by rasterization.
323 */
324 for (i = 0; i < count; i++) {
325 zBufferTemp[i] >>= 8;
326 }
327 }
328 else if (zBits == 16) {
329 GLuint i;
330 /* Convert depth buffer values from 32 to 16 bits */
331 for (i = 0; i < count; i++) {
332 zBufferTemp[i] >>= 16;
333 }
334 }
335 else {
336 assert(zBits == 32);
337 }
338
339 zBufferVals = zBufferTemp;
340 }
341
342 /* do the depth test either with 16 or 32-bit values */
343 if (ztest16)
344 passed = depth_test_span16(ctx, count, zBufferVals, fragZ, mask);
345 else
346 passed = depth_test_span32(ctx, count, zBufferVals, fragZ, mask);
347
348 if (zBufferTemp) {
349 /* need to write temp Z values back into the buffer */
350
351 /* Convert depth buffer values back to 32-bit values. The least
352 * significant bits don't matter since they'll get dropped when
353 * they're packed back into the depth buffer.
354 */
355 if (zBits == 24) {
356 GLuint i;
357 for (i = 0; i < count; i++) {
358 zBufferTemp[i] = (zBufferTemp[i] << 8);
359 }
360 }
361 else if (zBits == 16) {
362 GLuint i;
363 for (i = 0; i < count; i++) {
364 zBufferTemp[i] = zBufferTemp[i] << 16;
365 }
366 }
367
368 if (span->arrayMask & SPAN_XY) {
369 /* random locations */
370 put_z32_values(ctx, rb, count, span->array->x, span->array->y,
371 zBufferTemp, mask);
372 }
373 else {
374 /* horizontal row */
375 gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format);
376 GLubyte *dst = zStart;
377 GLuint i;
378 for (i = 0; i < count; i++) {
379 if (mask[i]) {
380 packZ(&zBufferTemp[i], dst);
381 }
382 dst += bpp;
383 }
384 }
385
386 free(zBufferTemp);
387 }
388
389 if (passed < count) {
390 span->writeAll = GL_FALSE;
391 }
392 return passed;
393 }
394
395
396 /**
397 * GL_EXT_depth_bounds_test extension.
398 * Discard fragments depending on whether the corresponding Z-buffer
399 * values are outside the depth bounds test range.
400 * Note: we test the Z buffer values, not the fragment Z values!
401 * \return GL_TRUE if any fragments pass, GL_FALSE if no fragments pass
402 */
403 GLboolean
404 _swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span )
405 {
406 struct gl_framebuffer *fb = ctx->DrawBuffer;
407 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
408 const GLint bpp = _mesa_get_format_bytes(rb->Format);
409 const GLint rowStride = rb->RowStride * bpp;
410 GLubyte *zStart = (GLubyte*) rb->Data + span->y * rowStride + span->x * bpp;
411 GLuint zMin = (GLuint) (ctx->Depth.BoundsMin * fb->_DepthMaxF + 0.5F);
412 GLuint zMax = (GLuint) (ctx->Depth.BoundsMax * fb->_DepthMaxF + 0.5F);
413 GLubyte *mask = span->array->mask;
414 const GLuint count = span->end;
415 GLuint i;
416 GLboolean anyPass = GL_FALSE;
417 GLuint zBufferTemp[MAX_WIDTH];
418 const GLuint *zBufferVals;
419
420 if (rb->Format == MESA_FORMAT_Z32 && !(span->arrayMask & SPAN_XY)) {
421 /* directly access 32-bit values in the depth buffer */
422 zBufferVals = (const GLuint *) zStart;
423 }
424 else {
425 /* unpack Z values into a temporary array */
426 if (span->arrayMask & SPAN_XY) {
427 get_z32_values(ctx, rb, count, span->array->x, span->array->y,
428 zBufferTemp);
429 }
430 else {
431 _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp);
432 }
433 zBufferVals = zBufferTemp;
434 }
435
436 /* Now do the tests */
437 for (i = 0; i < count; i++) {
438 if (mask[i]) {
439 if (zBufferVals[i] < zMin || zBufferVals[i] > zMax)
440 mask[i] = GL_FALSE;
441 else
442 anyPass = GL_TRUE;
443 }
444 }
445
446 return anyPass;
447 }
448
449
450
451 /**********************************************************************/
452 /***** Read Depth Buffer *****/
453 /**********************************************************************/
454
455
456 /**
457 * Read a span of depth values from the given depth renderbuffer, returning
458 * the values as GLfloats.
459 * This function does clipping to prevent reading outside the depth buffer's
460 * bounds.
461 */
462 void
463 _swrast_read_depth_span_float(struct gl_context *ctx,
464 struct gl_renderbuffer *rb,
465 GLint n, GLint x, GLint y, GLfloat depth[])
466 {
467 if (!rb) {
468 /* really only doing this to prevent FP exceptions later */
469 memset(depth, 0, n * sizeof(GLfloat));
470 return;
471 }
472
473 if (y < 0 || y >= (GLint) rb->Height ||
474 x + n <= 0 || x >= (GLint) rb->Width) {
475 /* span is completely outside framebuffer */
476 memset(depth, 0, n * sizeof(GLfloat));
477 return;
478 }
479
480 if (x < 0) {
481 GLint dx = -x;
482 GLint i;
483 for (i = 0; i < dx; i++)
484 depth[i] = 0.0;
485 x = 0;
486 n -= dx;
487 depth += dx;
488 }
489 if (x + n > (GLint) rb->Width) {
490 GLint dx = x + n - (GLint) rb->Width;
491 GLint i;
492 for (i = 0; i < dx; i++)
493 depth[n - i - 1] = 0.0;
494 n -= dx;
495 }
496 if (n <= 0) {
497 return;
498 }
499
500 _mesa_unpack_float_z_row(rb->Format, n, _swrast_pixel_address(rb, x, y),
501 depth);
502 }
503
504
505 /**
506 * Clear the given z/depth renderbuffer. If the buffer is a combined
507 * depth+stencil buffer, only the Z bits will be touched.
508 */
509 void
510 _swrast_clear_depth_buffer(struct gl_context *ctx)
511 {
512 struct gl_renderbuffer *rb =
513 ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
514 GLint x, y, width, height;
515 GLubyte *map;
516 GLint rowStride, i, j;
517 GLbitfield mapMode;
518
519 if (!rb || !ctx->Depth.Mask) {
520 /* no depth buffer, or writing to it is disabled */
521 return;
522 }
523
524 /* compute region to clear */
525 x = ctx->DrawBuffer->_Xmin;
526 y = ctx->DrawBuffer->_Ymin;
527 width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
528 height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
529
530 mapMode = GL_MAP_WRITE_BIT;
531 if (rb->Format == MESA_FORMAT_S8_Z24 ||
532 rb->Format == MESA_FORMAT_X8_Z24 ||
533 rb->Format == MESA_FORMAT_Z24_S8 ||
534 rb->Format == MESA_FORMAT_Z24_X8) {
535 mapMode |= GL_MAP_READ_BIT;
536 }
537
538 ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
539 mapMode, &map, &rowStride);
540 if (!map) {
541 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth)");
542 return;
543 }
544
545 switch (rb->Format) {
546 case MESA_FORMAT_Z16:
547 {
548 GLfloat clear = (GLfloat) ctx->Depth.Clear;
549 GLushort clearVal = 0;
550 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
551 if (clearVal == 0xffff && width * 2 == rowStride) {
552 /* common case */
553 memset(map, 0xff, width * height * 2);
554 }
555 else {
556 for (i = 0; i < height; i++) {
557 GLushort *row = (GLushort *) map;
558 for (j = 0; j < width; j++) {
559 row[j] = clearVal;
560 }
561 map += rowStride;
562 }
563 }
564 }
565 break;
566 case MESA_FORMAT_Z32:
567 case MESA_FORMAT_Z32_FLOAT:
568 {
569 GLfloat clear = (GLfloat) ctx->Depth.Clear;
570 GLuint clearVal = 0;
571 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
572 for (i = 0; i < height; i++) {
573 GLuint *row = (GLuint *) map;
574 for (j = 0; j < width; j++) {
575 row[j] = clearVal;
576 }
577 map += rowStride;
578 }
579 }
580 break;
581 case MESA_FORMAT_S8_Z24:
582 case MESA_FORMAT_X8_Z24:
583 case MESA_FORMAT_Z24_S8:
584 case MESA_FORMAT_Z24_X8:
585 {
586 GLfloat clear = (GLfloat) ctx->Depth.Clear;
587 GLuint clearVal = 0;
588 GLuint mask;
589
590 if (rb->Format == MESA_FORMAT_S8_Z24 ||
591 rb->Format == MESA_FORMAT_X8_Z24)
592 mask = 0xff000000;
593 else
594 mask = 0xff;
595
596 _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
597 for (i = 0; i < height; i++) {
598 GLuint *row = (GLuint *) map;
599 for (j = 0; j < width; j++) {
600 row[j] = (row[j] & mask) | clearVal;
601 }
602 map += rowStride;
603 }
604
605 }
606 break;
607 case MESA_FORMAT_Z32_FLOAT_X24S8:
608 /* XXX untested */
609 {
610 GLfloat clearVal = (GLfloat) ctx->Depth.Clear;
611 for (i = 0; i < height; i++) {
612 GLfloat *row = (GLfloat *) map;
613 for (j = 0; j < width; j++) {
614 row[j * 2] = clearVal;
615 }
616 map += rowStride;
617 }
618 }
619 break;
620 default:
621 _mesa_problem(ctx, "Unexpected depth buffer format %s"
622 " in _swrast_clear_depth_buffer()",
623 _mesa_get_format_name(rb->Format));
624 }
625
626 ctx->Driver.UnmapRenderbuffer(ctx, rb);
627 }
628
629
630
631
632 /**
633 * Clear both depth and stencil values in a combined depth+stencil buffer.
634 */
635 void
636 _swrast_clear_depth_stencil_buffer(struct gl_context *ctx)
637 {
638 const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits;
639 const GLuint writeMask = ctx->Stencil.WriteMask[0];
640 const GLuint stencilMax = (1 << stencilBits) - 1;
641 struct gl_renderbuffer *rb =
642 ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
643 GLint x, y, width, height;
644 GLbitfield mapMode;
645 GLubyte *map;
646 GLint rowStride, i, j;
647
648 /* check that we really have a combined depth+stencil buffer */
649 assert(rb == ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer);
650
651 /* compute region to clear */
652 x = ctx->DrawBuffer->_Xmin;
653 y = ctx->DrawBuffer->_Ymin;
654 width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
655 height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
656
657 mapMode = GL_MAP_WRITE_BIT;
658 if ((writeMask & stencilMax) != stencilMax) {
659 /* need to mask stencil values */
660 mapMode |= GL_MAP_READ_BIT;
661 }
662
663 ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
664 mapMode, &map, &rowStride);
665 if (!map) {
666 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth+stencil)");
667 return;
668 }
669
670 switch (rb->Format) {
671 case MESA_FORMAT_S8_Z24:
672 case MESA_FORMAT_Z24_S8:
673 {
674 GLfloat zClear = (GLfloat) ctx->Depth.Clear;
675 GLuint clear = 0, mask;
676
677 _mesa_pack_float_z_row(rb->Format, 1, &zClear, &clear);
678
679 if (rb->Format == MESA_FORMAT_S8_Z24) {
680 mask = ((~writeMask) & 0xff) << 24;
681 clear |= (ctx->Stencil.Clear & writeMask & 0xff) << 24;
682 }
683 else {
684 mask = ((~writeMask) & 0xff);
685 clear |= (ctx->Stencil.Clear & writeMask & 0xff);
686 }
687
688 for (i = 0; i < height; i++) {
689 GLuint *row = (GLuint *) map;
690 if (mask != 0x0) {
691 for (j = 0; j < width; j++) {
692 row[j] = (row[j] & mask) | clear;
693 }
694 }
695 else {
696 for (j = 0; j < width; j++) {
697 row[j] = clear;
698 }
699 }
700 map += rowStride;
701 }
702 }
703 break;
704 case MESA_FORMAT_Z32_FLOAT_X24S8:
705 /* XXX untested */
706 {
707 const GLfloat zClear = (GLfloat) ctx->Depth.Clear;
708 const GLuint sClear = ctx->Stencil.Clear & writeMask;
709 const GLuint sMask = (~writeMask) & 0xff;
710 for (i = 0; i < height; i++) {
711 GLfloat *zRow = (GLfloat *) map;
712 GLuint *sRow = (GLuint *) map;
713 for (j = 0; j < width; j++) {
714 zRow[j * 2 + 0] = zClear;
715 }
716 if (sMask != 0) {
717 for (j = 0; j < width; j++) {
718 sRow[j * 2 + 1] = (sRow[j * 2 + 1] & sMask) | sClear;
719 }
720 }
721 else {
722 for (j = 0; j < width; j++) {
723 sRow[j * 2 + 1] = sClear;
724 }
725 }
726 map += rowStride;
727 }
728 }
729 break;
730 default:
731 _mesa_problem(ctx, "Unexpected depth buffer format %s"
732 " in _swrast_clear_depth_buffer()",
733 _mesa_get_format_name(rb->Format));
734 }
735
736 ctx->Driver.UnmapRenderbuffer(ctx, rb);
737
738 }