projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: Add "OR COPYRIGHT HOLDERS" to license text disclaiming liability.
[mesa.git] / src / mesa / swrast / s_stencil.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.1
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 * THE AUTHORS OR COPYRIGHT HOLDERS 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/imports.h"
29 #include "main/format_pack.h"
30 #include "main/format_unpack.h"
31
32 #include "s_context.h"
33 #include "s_depth.h"
34 #include "s_stencil.h"
35 #include "s_span.h"
36
37
38
39 /* Stencil Logic:
40
41 IF stencil test fails THEN
42 Apply fail-op to stencil value
43 Don't write the pixel (RGBA,Z)
44 ELSE
45 IF doing depth test && depth test fails THEN
46 Apply zfail-op to stencil value
47 Write RGBA and Z to appropriate buffers
48 ELSE
49 Apply zpass-op to stencil value
50 ENDIF
51
52 */
53
54
55
56 /**
57 * Compute/return the offset of the stencil value in a pixel.
58 * For example, if the format is Z24+S8, the position of the stencil bits
59 * within the 4-byte pixel will be either 0 or 3.
60 */
61 static GLint
62 get_stencil_offset(gl_format format)
63 {
64 const GLubyte one = 1;
65 GLubyte pixel[MAX_PIXEL_BYTES];
66 GLint bpp = _mesa_get_format_bytes(format);
67 GLint i;
68
69 assert(_mesa_get_format_bits(format, GL_STENCIL_BITS) == 8);
70 memset(pixel, 0, sizeof(pixel));
71 _mesa_pack_ubyte_stencil_row(format, 1, &one, pixel);
72
73 for (i = 0; i < bpp; i++) {
74 if (pixel[i])
75 return i;
76 }
77
78 _mesa_problem(NULL, "get_stencil_offset() failed\n");
79 return 0;
80 }
81
82
83 /** Clamp the stencil value to [0, 255] */
84 static inline GLubyte
85 clamp(GLint val)
86 {
87 if (val < 0)
88 return 0;
89 else if (val > 255)
90 return 255;
91 else
92 return val;
93 }
94
95
96 #define STENCIL_OP(NEW_VAL) \
97 if (invmask == 0) { \
98 for (i = j = 0; i < n; i++, j += stride) { \
99 if (mask[i]) { \
100 GLubyte s = stencil[j]; \
101 (void) s; \
102 stencil[j] = (GLubyte) (NEW_VAL); \
103 } \
104 } \
105 } \
106 else { \
107 for (i = j = 0; i < n; i++, j += stride) { \
108 if (mask[i]) { \
109 GLubyte s = stencil[j]; \
110 stencil[j] = (GLubyte) ((invmask & s) | (wrtmask & (NEW_VAL))); \
111 } \
112 } \
113 }
114
115
116 /**
117 * Apply the given stencil operator to the array of stencil values.
118 * Don't touch stencil[i] if mask[i] is zero.
119 * @param n number of stencil values
120 * @param oper the stencil buffer operator
121 * @param face 0 or 1 for front or back face operation
122 * @param stencil array of stencil values (in/out)
123 * @param mask array [n] of flag: 1=apply operator, 0=don't apply operator
124 * @param stride stride between stencil values
125 */
126 static void
127 apply_stencil_op(const struct gl_context *ctx, GLenum oper, GLuint face,
128 GLuint n, GLubyte stencil[], const GLubyte mask[],
129 GLint stride)
130 {
131 const GLubyte ref = ctx->Stencil.Ref[face];
132 const GLubyte wrtmask = ctx->Stencil.WriteMask[face];
133 const GLubyte invmask = (GLubyte) (~wrtmask);
134 GLuint i, j;
135
136 switch (oper) {
137 case GL_KEEP:
138 /* do nothing */
139 break;
140 case GL_ZERO:
141 /* replace stencil buf values with zero */
142 STENCIL_OP(0);
143 break;
144 case GL_REPLACE:
145 /* replace stencil buf values with ref value */
146 STENCIL_OP(ref);
147 break;
148 case GL_INCR:
149 /* increment stencil buf values, with clamping */
150 STENCIL_OP(clamp(s + 1));
151 break;
152 case GL_DECR:
153 /* increment stencil buf values, with clamping */
154 STENCIL_OP(clamp(s - 1));
155 break;
156 case GL_INCR_WRAP_EXT:
157 /* increment stencil buf values, without clamping */
158 STENCIL_OP(s + 1);
159 break;
160 case GL_DECR_WRAP_EXT:
161 /* increment stencil buf values, without clamping */
162 STENCIL_OP(s - 1);
163 break;
164 case GL_INVERT:
165 /* replace stencil buf values with inverted value */
166 STENCIL_OP(~s);
167 break;
168 default:
169 _mesa_problem(ctx, "Bad stencil op in apply_stencil_op");
170 }
171 }
172
173
174
175 #define STENCIL_TEST(FUNC) \
176 for (i = j = 0; i < n; i++, j += stride) { \
177 if (mask[i]) { \
178 s = (GLubyte) (stencil[j] & valueMask); \
179 if (FUNC) { \
180 /* stencil pass */ \
181 fail[i] = 0; \
182 } \
183 else { \
184 /* stencil fail */ \
185 fail[i] = 1; \
186 mask[i] = 0; \
187 } \
188 } \
189 else { \
190 fail[i] = 0; \
191 } \
192 }
193
194
195
196 /**
197 * Apply stencil test to an array of stencil values (before depth buffering).
198 * For the values that fail, we'll apply the GL_STENCIL_FAIL operator to
199 * the stencil values.
200 *
201 * @param face 0 or 1 for front or back-face polygons
202 * @param n number of pixels in the array
203 * @param stencil array of [n] stencil values (in/out)
204 * @param mask array [n] of flag: 0=skip the pixel, 1=stencil the pixel,
205 * values are set to zero where the stencil test fails.
206 * @param stride stride between stencil values
207 * @return GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
208 */
209 static GLboolean
210 do_stencil_test(struct gl_context *ctx, GLuint face, GLuint n,
211 GLubyte stencil[], GLubyte mask[], GLint stride)
212 {
213 SWcontext *swrast = SWRAST_CONTEXT(ctx);
214 GLubyte *fail = swrast->stencil_temp.buf2;
215 GLboolean allfail = GL_FALSE;
216 GLuint i, j;
217 const GLuint valueMask = ctx->Stencil.ValueMask[face];
218 const GLubyte ref = (GLubyte) (ctx->Stencil.Ref[face] & valueMask);
219 GLubyte s;
220
221 /*
222 * Perform stencil test. The results of this operation are stored
223 * in the fail[] array:
224 * IF fail[i] is non-zero THEN
225 * the stencil fail operator is to be applied
226 * ELSE
227 * the stencil fail operator is not to be applied
228 * ENDIF
229 */
230 switch (ctx->Stencil.Function[face]) {
231 case GL_NEVER:
232 STENCIL_TEST(0);
233 allfail = GL_TRUE;
234 break;
235 case GL_LESS:
236 STENCIL_TEST(ref < s);
237 break;
238 case GL_LEQUAL:
239 STENCIL_TEST(ref <= s);
240 break;
241 case GL_GREATER:
242 STENCIL_TEST(ref > s);
243 break;
244 case GL_GEQUAL:
245 STENCIL_TEST(ref >= s);
246 break;
247 case GL_EQUAL:
248 STENCIL_TEST(ref == s);
249 break;
250 case GL_NOTEQUAL:
251 STENCIL_TEST(ref != s);
252 break;
253 case GL_ALWAYS:
254 STENCIL_TEST(1);
255 break;
256 default:
257 _mesa_problem(ctx, "Bad stencil func in gl_stencil_span");
258 return 0;
259 }
260
261 if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
262 apply_stencil_op(ctx, ctx->Stencil.FailFunc[face], face, n, stencil,
263 fail, stride);
264 }
265
266 return !allfail;
267 }
268
269
270 /**
271 * Compute the zpass/zfail masks by comparing the pre- and post-depth test
272 * masks.
273 */
274 static inline void
275 compute_pass_fail_masks(GLuint n, const GLubyte origMask[],
276 const GLubyte newMask[],
277 GLubyte passMask[], GLubyte failMask[])
278 {
279 GLuint i;
280 for (i = 0; i < n; i++) {
281 ASSERT(newMask[i] == 0 || newMask[i] == 1);
282 passMask[i] = origMask[i] & newMask[i];
283 failMask[i] = origMask[i] & (newMask[i] ^ 1);
284 }
285 }
286
287
288 /**
289 * Get 8-bit stencil values from random locations in the stencil buffer.
290 */
291 static void
292 get_s8_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
293 GLuint count, const GLint x[], const GLint y[],
294 GLubyte stencil[])
295 {
296 struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
297 const GLint w = rb->Width, h = rb->Height;
298 const GLubyte *map = _swrast_pixel_address(rb, 0, 0);
299 GLuint i;
300
301 if (rb->Format == MESA_FORMAT_S8) {
302 const GLint rowStride = srb->RowStride;
303 for (i = 0; i < count; i++) {
304 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
305 stencil[i] = *(map + y[i] * rowStride + x[i]);
306 }
307 }
308 }
309 else {
310 const GLint bpp = _mesa_get_format_bytes(rb->Format);
311 const GLint rowStride = srb->RowStride;
312 for (i = 0; i < count; i++) {
313 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
314 const GLubyte *src = map + y[i] * rowStride + x[i] * bpp;
315 _mesa_unpack_ubyte_stencil_row(rb->Format, 1, src, &stencil[i]);
316 }
317 }
318 }
319 }
320
321
322 /**
323 * Put 8-bit stencil values at random locations into the stencil buffer.
324 */
325 static void
326 put_s8_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
327 GLuint count, const GLint x[], const GLint y[],
328 const GLubyte stencil[])
329 {
330 const GLint w = rb->Width, h = rb->Height;
331 gl_pack_ubyte_stencil_func pack_stencil =
332 _mesa_get_pack_ubyte_stencil_func(rb->Format);
333 GLuint i;
334
335 for (i = 0; i < count; i++) {
336 if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
337 GLubyte *dst = _swrast_pixel_address(rb, x[i], y[i]);
338 pack_stencil(&stencil[i], dst);
339 }
340 }
341 }
342
343
344 /**
345 * /return GL_TRUE = one or more fragments passed,
346 * GL_FALSE = all fragments failed.
347 */
348 GLboolean
349 _swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span)
350 {
351 SWcontext *swrast = SWRAST_CONTEXT(ctx);
352 struct gl_framebuffer *fb = ctx->DrawBuffer;
353 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
354 const GLint stencilOffset = get_stencil_offset(rb->Format);
355 const GLint stencilStride = _mesa_get_format_bytes(rb->Format);
356 const GLuint face = (span->facing == 0) ? 0 : ctx->Stencil._BackFace;
357 const GLuint count = span->end;
358 GLubyte *mask = span->array->mask;
359 GLubyte *stencilTemp = swrast->stencil_temp.buf1;
360 GLubyte *stencilBuf;
361
362 if (span->arrayMask & SPAN_XY) {
363 /* read stencil values from random locations */
364 get_s8_values(ctx, rb, count, span->array->x, span->array->y,
365 stencilTemp);
366 stencilBuf = stencilTemp;
367 }
368 else {
369 /* Processing a horizontal run of pixels. Since stencil is always
370 * 8 bits for all MESA_FORMATs, we just need to use the right offset
371 * and stride to access them.
372 */
373 stencilBuf = _swrast_pixel_address(rb, span->x, span->y) + stencilOffset;
374 }
375
376 /*
377 * Apply the stencil test to the fragments.
378 * failMask[i] is 1 if the stencil test failed.
379 */
380 if (!do_stencil_test(ctx, face, count, stencilBuf, mask, stencilStride)) {
381 /* all fragments failed the stencil test, we're done. */
382 span->writeAll = GL_FALSE;
383 if (span->arrayMask & SPAN_XY) {
384 /* need to write the updated stencil values back to the buffer */
385 put_s8_values(ctx, rb, count, span->array->x, span->array->y,
386 stencilTemp);
387 }
388 return GL_FALSE;
389 }
390
391 /*
392 * Some fragments passed the stencil test, apply depth test to them
393 * and apply Zpass and Zfail stencil ops.
394 */
395 if (ctx->Depth.Test == GL_FALSE ||
396 ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer == NULL) {
397 /*
398 * No depth buffer, just apply zpass stencil function to active pixels.
399 */
400 apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face, count,
401 stencilBuf, mask, stencilStride);
402 }
403 else {
404 /*
405 * Perform depth buffering, then apply zpass or zfail stencil function.
406 */
407 SWcontext *swrast = SWRAST_CONTEXT(ctx);
408 GLubyte *passMask = swrast->stencil_temp.buf2;
409 GLubyte *failMask = swrast->stencil_temp.buf3;
410 GLubyte *origMask = swrast->stencil_temp.buf4;
411
412 /* save the current mask bits */
413 memcpy(origMask, mask, count * sizeof(GLubyte));
414
415 /* apply the depth test */
416 _swrast_depth_test_span(ctx, span);
417
418 compute_pass_fail_masks(count, origMask, mask, passMask, failMask);
419
420 /* apply the pass and fail operations */
421 if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
422 apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face,
423 count, stencilBuf, failMask, stencilStride);
424 }
425 if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
426 apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
427 count, stencilBuf, passMask, stencilStride);
428 }
429 }
430
431 /* Write updated stencil values back into hardware stencil buffer */
432 if (span->arrayMask & SPAN_XY) {
433 put_s8_values(ctx, rb, count, span->array->x, span->array->y,
434 stencilBuf);
435 }
436
437 span->writeAll = GL_FALSE;
438
439 return GL_TRUE; /* one or more fragments passed both tests */
440 }
441
442
443
444
445 /**
446 * Return a span of stencil values from the stencil buffer.
447 * Used for glRead/CopyPixels
448 * Input: n - how many pixels
449 * x,y - location of first pixel
450 * Output: stencil - the array of stencil values
451 */
452 void
453 _swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb,
454 GLint n, GLint x, GLint y, GLubyte stencil[])
455 {
456 GLubyte *src;
457
458 if (y < 0 || y >= (GLint) rb->Height ||
459 x + n <= 0 || x >= (GLint) rb->Width) {
460 /* span is completely outside framebuffer */
461 return; /* undefined values OK */
462 }
463
464 if (x < 0) {
465 GLint dx = -x;
466 x = 0;
467 n -= dx;
468 stencil += dx;
469 }
470 if (x + n > (GLint) rb->Width) {
471 GLint dx = x + n - rb->Width;
472 n -= dx;
473 }
474 if (n <= 0) {
475 return;
476 }
477
478 src = _swrast_pixel_address(rb, x, y);
479 _mesa_unpack_ubyte_stencil_row(rb->Format, n, src, stencil);
480 }
481
482
483
484 /**
485 * Write a span of stencil values to the stencil buffer. This function
486 * applies the stencil write mask when needed.
487 * Used for glDraw/CopyPixels
488 * Input: n - how many pixels
489 * x, y - location of first pixel
490 * stencil - the array of stencil values
491 */
492 void
493 _swrast_write_stencil_span(struct gl_context *ctx, GLint n, GLint x, GLint y,
494 const GLubyte stencil[] )
495 {
496 SWcontext *swrast = SWRAST_CONTEXT(ctx);
497 struct gl_framebuffer *fb = ctx->DrawBuffer;
498 struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
499 const GLuint stencilMax = (1 << fb->Visual.stencilBits) - 1;
500 const GLuint stencilMask = ctx->Stencil.WriteMask[0];
501 GLubyte *stencilBuf;
502
503 if (y < 0 || y >= (GLint) rb->Height ||
504 x + n <= 0 || x >= (GLint) rb->Width) {
505 /* span is completely outside framebuffer */
506 return; /* undefined values OK */
507 }
508 if (x < 0) {
509 GLint dx = -x;
510 x = 0;
511 n -= dx;
512 stencil += dx;
513 }
514 if (x + n > (GLint) rb->Width) {
515 GLint dx = x + n - rb->Width;
516 n -= dx;
517 }
518 if (n <= 0) {
519 return;
520 }
521
522 stencilBuf = _swrast_pixel_address(rb, x, y);
523
524 if ((stencilMask & stencilMax) != stencilMax) {
525 /* need to apply writemask */
526 GLubyte *destVals = swrast->stencil_temp.buf1;
527 GLubyte *newVals = swrast->stencil_temp.buf2;
528 GLint i;
529
530 _mesa_unpack_ubyte_stencil_row(rb->Format, n, stencilBuf, destVals);
531 for (i = 0; i < n; i++) {
532 newVals[i]
533 = (stencil[i] & stencilMask) | (destVals[i] & ~stencilMask);
534 }
535 _mesa_pack_ubyte_stencil_row(rb->Format, n, newVals, stencilBuf);
536 }
537 else {
538 _mesa_pack_ubyte_stencil_row(rb->Format, n, stencil, stencilBuf);
539 }
540 }
541
542
543
544 /**
545 * Clear the stencil buffer. If the buffer is a combined
546 * depth+stencil buffer, only the stencil bits will be touched.
547 */
548 void
549 _swrast_clear_stencil_buffer(struct gl_context *ctx)
550 {
551 struct gl_renderbuffer *rb =
552 ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
553 const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits;
554 const GLuint writeMask = ctx->Stencil.WriteMask[0];
555 const GLuint stencilMax = (1 << stencilBits) - 1;
556 GLint x, y, width, height;
557 GLubyte *map;
558 GLint rowStride, i, j;
559 GLbitfield mapMode;
560
561 if (!rb || writeMask == 0)
562 return;
563
564 /* compute region to clear */
565 x = ctx->DrawBuffer->_Xmin;
566 y = ctx->DrawBuffer->_Ymin;
567 width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
568 height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
569
570 mapMode = GL_MAP_WRITE_BIT;
571 if ((writeMask & stencilMax) != stencilMax) {
572 /* need to mask stencil values */
573 mapMode |= GL_MAP_READ_BIT;
574 }
575 else if (_mesa_get_format_bits(rb->Format, GL_DEPTH_BITS) > 0) {
576 /* combined depth+stencil, need to mask Z values */
577 mapMode |= GL_MAP_READ_BIT;
578 }
579
580 ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
581 mapMode, &map, &rowStride);
582 if (!map) {
583 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(stencil)");
584 return;
585 }
586
587 switch (rb->Format) {
588 case MESA_FORMAT_S8:
589 {
590 GLubyte clear = ctx->Stencil.Clear & writeMask & 0xff;
591 GLubyte mask = (~writeMask) & 0xff;
592 if (mask != 0) {
593 /* masked clear */
594 for (i = 0; i < height; i++) {
595 GLubyte *row = map;
596 for (j = 0; j < width; j++) {
597 row[j] = (row[j] & mask) | clear;
598 }
599 map += rowStride;
600 }
601 }
602 else if (rowStride == width) {
603 /* clear whole buffer */
604 memset(map, clear, width * height);
605 }
606 else {
607 /* clear scissored */
608 for (i = 0; i < height; i++) {
609 memset(map, clear, width);
610 map += rowStride;
611 }
612 }
613 }
614 break;
615 case MESA_FORMAT_S8_Z24:
616 {
617 GLuint clear = (ctx->Stencil.Clear & writeMask & 0xff) << 24;
618 GLuint mask = (((~writeMask) & 0xff) << 24) | 0xffffff;
619 for (i = 0; i < height; i++) {
620 GLuint *row = (GLuint *) map;
621 for (j = 0; j < width; j++) {
622 row[j] = (row[j] & mask) | clear;
623 }
624 map += rowStride;
625 }
626 }
627 break;
628 case MESA_FORMAT_Z24_S8:
629 {
630 GLuint clear = ctx->Stencil.Clear & writeMask & 0xff;
631 GLuint mask = 0xffffff00 | ((~writeMask) & 0xff);
632 for (i = 0; i < height; i++) {
633 GLuint *row = (GLuint *) map;
634 for (j = 0; j < width; j++) {
635 row[j] = (row[j] & mask) | clear;
636 }
637 map += rowStride;
638 }
639 }
640 break;
641 default:
642 _mesa_problem(ctx, "Unexpected stencil buffer format %s"
643 " in _swrast_clear_stencil_buffer()",
644 _mesa_get_format_name(rb->Format));
645 }
646
647 ctx->Driver.UnmapRenderbuffer(ctx, rb);
648 }