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
depth_test_span16(struct gl_context * ctx,GLuint n,GLushort zbuffer[],const GLuint zfrag[],GLubyte mask[])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
depth_test_span32(struct gl_context * ctx,GLuint n,GLuint zbuffer[],const GLuint zfrag[],GLubyte mask[])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
_swrast_depth_clamp_span(struct gl_context * ctx,SWspan * span)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
get_z32_values(struct gl_context * ctx,struct gl_renderbuffer * rb,GLuint count,const GLint x[],const GLint y[],GLuint zbuffer[])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
put_z32_values(struct gl_context * ctx,struct gl_renderbuffer * rb,GLuint count,const GLint x[],const GLint y[],const GLuint zvalues[],const GLubyte mask[])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
_swrast_depth_test_span(struct gl_context * ctx,SWspan * span)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
_swrast_depth_bounds_test(struct gl_context * ctx,SWspan * span)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
_swrast_read_depth_span_float(struct gl_context * ctx,struct gl_renderbuffer * rb,GLint n,GLint x,GLint y,GLfloat depth[])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
_swrast_clear_depth_buffer(struct gl_context * ctx)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
_swrast_clear_depth_stencil_buffer(struct gl_context * ctx)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