projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Header file clean-up:
[mesa.git] / src / mesa / swrast / s_stencil.c
1 /* $Id: s_stencil.c,v 1.28 2002/10/24 23:57:24 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 4.1
6 *
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #include "glheader.h"
29 #include "context.h"
30 #include "macros.h"
31 #include "imports.h"
32
33 #include "s_context.h"
34 #include "s_depth.h"
35 #include "s_stencil.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 * Return the address of a stencil buffer value given the window coords:
57 */
58 #define STENCIL_ADDRESS(X,Y) \
59 (ctx->DrawBuffer->Stencil + ctx->DrawBuffer->Width * (Y) + (X))
60
61
62
63 /**
64 * Apply the given stencil operator to the array of stencil values.
65 * Don't touch stencil[i] if mask[i] is zero.
66 * Input: n - size of stencil array
67 * oper - the stencil buffer operator
68 * face - 0 or 1 for front or back face operation
69 * stencil - array of stencil values
70 * mask - array [n] of flag: 1=apply operator, 0=don't apply operator
71 * Output: stencil - modified values
72 */
73 static void
74 apply_stencil_op( const GLcontext *ctx, GLenum oper, GLuint face,
75 GLuint n, GLstencil stencil[], const GLubyte mask[] )
76 {
77 const GLstencil ref = ctx->Stencil.Ref[face];
78 const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
79 const GLstencil invmask = (GLstencil) (~wrtmask);
80 GLuint i;
81
82 switch (oper) {
83 case GL_KEEP:
84 /* do nothing */
85 break;
86 case GL_ZERO:
87 if (invmask==0) {
88 for (i=0;i<n;i++) {
89 if (mask[i]) {
90 stencil[i] = 0;
91 }
92 }
93 }
94 else {
95 for (i=0;i<n;i++) {
96 if (mask[i]) {
97 stencil[i] = (GLstencil) (stencil[i] & invmask);
98 }
99 }
100 }
101 break;
102 case GL_REPLACE:
103 if (invmask==0) {
104 for (i=0;i<n;i++) {
105 if (mask[i]) {
106 stencil[i] = ref;
107 }
108 }
109 }
110 else {
111 for (i=0;i<n;i++) {
112 if (mask[i]) {
113 GLstencil s = stencil[i];
114 stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));
115 }
116 }
117 }
118 break;
119 case GL_INCR:
120 if (invmask==0) {
121 for (i=0;i<n;i++) {
122 if (mask[i]) {
123 GLstencil s = stencil[i];
124 if (s < STENCIL_MAX) {
125 stencil[i] = (GLstencil) (s+1);
126 }
127 }
128 }
129 }
130 else {
131 for (i=0;i<n;i++) {
132 if (mask[i]) {
133 /* VERIFY logic of adding 1 to a write-masked value */
134 GLstencil s = stencil[i];
135 if (s < STENCIL_MAX) {
136 stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
137 }
138 }
139 }
140 }
141 break;
142 case GL_DECR:
143 if (invmask==0) {
144 for (i=0;i<n;i++) {
145 if (mask[i]) {
146 GLstencil s = stencil[i];
147 if (s>0) {
148 stencil[i] = (GLstencil) (s-1);
149 }
150 }
151 }
152 }
153 else {
154 for (i=0;i<n;i++) {
155 if (mask[i]) {
156 /* VERIFY logic of subtracting 1 to a write-masked value */
157 GLstencil s = stencil[i];
158 if (s>0) {
159 stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
160 }
161 }
162 }
163 }
164 break;
165 case GL_INCR_WRAP_EXT:
166 if (invmask==0) {
167 for (i=0;i<n;i++) {
168 if (mask[i]) {
169 stencil[i]++;
170 }
171 }
172 }
173 else {
174 for (i=0;i<n;i++) {
175 if (mask[i]) {
176 GLstencil s = stencil[i];
177 stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
178 }
179 }
180 }
181 break;
182 case GL_DECR_WRAP_EXT:
183 if (invmask==0) {
184 for (i=0;i<n;i++) {
185 if (mask[i]) {
186 stencil[i]--;
187 }
188 }
189 }
190 else {
191 for (i=0;i<n;i++) {
192 if (mask[i]) {
193 GLstencil s = stencil[i];
194 stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
195 }
196 }
197 }
198 break;
199 case GL_INVERT:
200 if (invmask==0) {
201 for (i=0;i<n;i++) {
202 if (mask[i]) {
203 GLstencil s = stencil[i];
204 stencil[i] = (GLstencil) ~s;
205 }
206 }
207 }
208 else {
209 for (i=0;i<n;i++) {
210 if (mask[i]) {
211 GLstencil s = stencil[i];
212 stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));
213 }
214 }
215 }
216 break;
217 default:
218 _mesa_problem(ctx, "Bad stencil op in apply_stencil_op");
219 }
220 }
221
222
223
224
225 /**
226 * Apply stencil test to an array of stencil values (before depth buffering).
227 * Input: face - 0 or 1 for front or back-face polygons
228 * n - number of pixels in the array
229 * stencil - array of [n] stencil values
230 * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel
231 * Output: mask - pixels which fail the stencil test will have their
232 * mask flag set to 0.
233 * stencil - updated stencil values (where the test passed)
234 * Return: GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
235 */
236 static GLboolean
237 do_stencil_test( GLcontext *ctx, GLuint face, GLuint n, GLstencil stencil[],
238 GLubyte mask[] )
239 {
240 GLubyte fail[MAX_WIDTH];
241 GLboolean allfail = GL_FALSE;
242 GLuint i;
243 GLstencil r, s;
244 const GLuint valueMask = ctx->Stencil.ValueMask[face];
245
246 ASSERT(n <= MAX_WIDTH);
247
248 /*
249 * Perform stencil test. The results of this operation are stored
250 * in the fail[] array:
251 * IF fail[i] is non-zero THEN
252 * the stencil fail operator is to be applied
253 * ELSE
254 * the stencil fail operator is not to be applied
255 * ENDIF
256 */
257 switch (ctx->Stencil.Function[face]) {
258 case GL_NEVER:
259 /* never pass; always fail */
260 for (i=0;i<n;i++) {
261 if (mask[i]) {
262 mask[i] = 0;
263 fail[i] = 1;
264 }
265 else {
266 fail[i] = 0;
267 }
268 }
269 allfail = GL_TRUE;
270 break;
271 case GL_LESS:
272 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
273 for (i=0;i<n;i++) {
274 if (mask[i]) {
275 s = (GLstencil) (stencil[i] & valueMask);
276 if (r < s) {
277 /* passed */
278 fail[i] = 0;
279 }
280 else {
281 fail[i] = 1;
282 mask[i] = 0;
283 }
284 }
285 else {
286 fail[i] = 0;
287 }
288 }
289 break;
290 case GL_LEQUAL:
291 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
292 for (i=0;i<n;i++) {
293 if (mask[i]) {
294 s = (GLstencil) (stencil[i] & valueMask);
295 if (r <= s) {
296 /* pass */
297 fail[i] = 0;
298 }
299 else {
300 fail[i] = 1;
301 mask[i] = 0;
302 }
303 }
304 else {
305 fail[i] = 0;
306 }
307 }
308 break;
309 case GL_GREATER:
310 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
311 for (i=0;i<n;i++) {
312 if (mask[i]) {
313 s = (GLstencil) (stencil[i] & valueMask);
314 if (r > s) {
315 /* passed */
316 fail[i] = 0;
317 }
318 else {
319 fail[i] = 1;
320 mask[i] = 0;
321 }
322 }
323 else {
324 fail[i] = 0;
325 }
326 }
327 break;
328 case GL_GEQUAL:
329 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
330 for (i=0;i<n;i++) {
331 if (mask[i]) {
332 s = (GLstencil) (stencil[i] & valueMask);
333 if (r >= s) {
334 /* passed */
335 fail[i] = 0;
336 }
337 else {
338 fail[i] = 1;
339 mask[i] = 0;
340 }
341 }
342 else {
343 fail[i] = 0;
344 }
345 }
346 break;
347 case GL_EQUAL:
348 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
349 for (i=0;i<n;i++) {
350 if (mask[i]) {
351 s = (GLstencil) (stencil[i] & valueMask);
352 if (r == s) {
353 /* passed */
354 fail[i] = 0;
355 }
356 else {
357 fail[i] = 1;
358 mask[i] = 0;
359 }
360 }
361 else {
362 fail[i] = 0;
363 }
364 }
365 break;
366 case GL_NOTEQUAL:
367 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
368 for (i=0;i<n;i++) {
369 if (mask[i]) {
370 s = (GLstencil) (stencil[i] & valueMask);
371 if (r != s) {
372 /* passed */
373 fail[i] = 0;
374 }
375 else {
376 fail[i] = 1;
377 mask[i] = 0;
378 }
379 }
380 else {
381 fail[i] = 0;
382 }
383 }
384 break;
385 case GL_ALWAYS:
386 /* always pass */
387 for (i=0;i<n;i++) {
388 fail[i] = 0;
389 }
390 break;
391 default:
392 _mesa_problem(ctx, "Bad stencil func in gl_stencil_span");
393 return 0;
394 }
395
396 if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
397 apply_stencil_op( ctx, ctx->Stencil.FailFunc[face], face, n, stencil, fail );
398 }
399
400 return !allfail;
401 }
402
403
404
405 /**
406 * Apply stencil and depth testing to the span of pixels.
407 * Both software and hardware stencil buffers are acceptable.
408 * Input: n - number of pixels in the span
409 * x, y - location of leftmost pixel in span
410 * z - array [n] of z values
411 * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
412 * Output: mask - array [n] of flags (1=stencil and depth test passed)
413 * Return: GL_FALSE - all fragments failed the testing
414 * GL_TRUE - one or more fragments passed the testing
415 *
416 */
417 static GLboolean
418 stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span, GLuint face)
419 {
420 SWcontext *swrast = SWRAST_CONTEXT(ctx);
421 GLstencil stencilRow[MAX_WIDTH];
422 GLstencil *stencil;
423 const GLuint n = span->end;
424 const GLint x = span->x;
425 const GLint y = span->y;
426 GLubyte *mask = span->array->mask;
427
428 ASSERT((span->arrayMask & SPAN_XY) == 0);
429 ASSERT(ctx->Stencil.Enabled);
430 ASSERT(n <= MAX_WIDTH);
431 #ifdef DEBUG
432 if (ctx->Depth.Test) {
433 ASSERT(span->arrayMask & SPAN_Z);
434 }
435 #endif
436
437 /* Get initial stencil values */
438 if (swrast->Driver.WriteStencilSpan) {
439 /* Get stencil values from the hardware stencil buffer */
440 ASSERT(swrast->Driver.ReadStencilSpan);
441 (*swrast->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow);
442 stencil = stencilRow;
443 }
444 else {
445 /* Get pointer into software stencil buffer */
446 stencil = STENCIL_ADDRESS(x, y);
447 }
448
449 /*
450 * Apply the stencil test to the fragments.
451 * failMask[i] is 1 if the stencil test failed.
452 */
453 if (do_stencil_test( ctx, face, n, stencil, mask ) == GL_FALSE) {
454 /* all fragments failed the stencil test, we're done. */
455 span->writeAll = GL_FALSE;
456 return GL_FALSE;
457 }
458
459 /*
460 * Some fragments passed the stencil test, apply depth test to them
461 * and apply Zpass and Zfail stencil ops.
462 */
463 if (ctx->Depth.Test == GL_FALSE) {
464 /*
465 * No depth buffer, just apply zpass stencil function to active pixels.
466 */
467 apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face, n, stencil, mask );
468 }
469 else {
470 /*
471 * Perform depth buffering, then apply zpass or zfail stencil function.
472 */
473 GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
474 GLuint i;
475
476 /* save the current mask bits */
477 MEMCPY(oldmask, mask, n * sizeof(GLubyte));
478
479 /* apply the depth test */
480 _mesa_depth_test_span(ctx, span);
481
482 /* Set the stencil pass/fail flags according to result of depth testing.
483 * if oldmask[i] == 0 then
484 * Don't touch the stencil value
485 * else if oldmask[i] and newmask[i] then
486 * Depth test passed
487 * else
488 * assert(oldmask[i] && !newmask[i])
489 * Depth test failed
490 * endif
491 */
492 for (i=0;i<n;i++) {
493 ASSERT(mask[i] == 0 || mask[i] == 1);
494 passmask[i] = oldmask[i] & mask[i];
495 failmask[i] = oldmask[i] & (mask[i] ^ 1);
496 }
497
498 /* apply the pass and fail operations */
499 if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
500 apply_stencil_op( ctx, ctx->Stencil.ZFailFunc[face], face,
501 n, stencil, failmask );
502 }
503 if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
504 apply_stencil_op( ctx, ctx->Stencil.ZPassFunc[face], face,
505 n, stencil, passmask );
506 }
507 }
508
509 /*
510 * Write updated stencil values back into hardware stencil buffer.
511 */
512 if (swrast->Driver.WriteStencilSpan) {
513 ASSERT(stencil == stencilRow);
514 (swrast->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask );
515 }
516
517 span->writeAll = GL_FALSE;
518
519 return GL_TRUE; /* one or more fragments passed both tests */
520 }
521
522
523
524
525 /**
526 * Apply the given stencil operator for each pixel in the array whose
527 * mask flag is set.
528 * \note This is for software stencil buffers only.
529 * Input: n - number of pixels in the span
530 * x, y - array of [n] pixels
531 * operator - the stencil buffer operator
532 * mask - array [n] of flag: 1=apply operator, 0=don't apply operator
533 */
534 static void
535 apply_stencil_op_to_pixels( const GLcontext *ctx,
536 GLuint n, const GLint x[], const GLint y[],
537 GLenum oper, GLuint face, const GLubyte mask[] )
538 {
539 const GLstencil ref = ctx->Stencil.Ref[face];
540 const GLstencil wrtmask = ctx->Stencil.WriteMask[face];
541 const GLstencil invmask = (GLstencil) (~wrtmask);
542 GLuint i;
543
544 ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan); /* software stencil buffer only! */
545
546 switch (oper) {
547 case GL_KEEP:
548 /* do nothing */
549 break;
550 case GL_ZERO:
551 if (invmask==0) {
552 for (i=0;i<n;i++) {
553 if (mask[i]) {
554 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
555 *sptr = 0;
556 }
557 }
558 }
559 else {
560 for (i=0;i<n;i++) {
561 if (mask[i]) {
562 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
563 *sptr = (GLstencil) (invmask & *sptr);
564 }
565 }
566 }
567 break;
568 case GL_REPLACE:
569 if (invmask==0) {
570 for (i=0;i<n;i++) {
571 if (mask[i]) {
572 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
573 *sptr = ref;
574 }
575 }
576 }
577 else {
578 for (i=0;i<n;i++) {
579 if (mask[i]) {
580 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
581 *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));
582 }
583 }
584 }
585 break;
586 case GL_INCR:
587 if (invmask==0) {
588 for (i=0;i<n;i++) {
589 if (mask[i]) {
590 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
591 if (*sptr < STENCIL_MAX) {
592 *sptr = (GLstencil) (*sptr + 1);
593 }
594 }
595 }
596 }
597 else {
598 for (i=0;i<n;i++) {
599 if (mask[i]) {
600 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
601 if (*sptr < STENCIL_MAX) {
602 *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
603 }
604 }
605 }
606 }
607 break;
608 case GL_DECR:
609 if (invmask==0) {
610 for (i=0;i<n;i++) {
611 if (mask[i]) {
612 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
613 if (*sptr>0) {
614 *sptr = (GLstencil) (*sptr - 1);
615 }
616 }
617 }
618 }
619 else {
620 for (i=0;i<n;i++) {
621 if (mask[i]) {
622 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
623 if (*sptr>0) {
624 *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
625 }
626 }
627 }
628 }
629 break;
630 case GL_INCR_WRAP_EXT:
631 if (invmask==0) {
632 for (i=0;i<n;i++) {
633 if (mask[i]) {
634 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
635 *sptr = (GLstencil) (*sptr + 1);
636 }
637 }
638 }
639 else {
640 for (i=0;i<n;i++) {
641 if (mask[i]) {
642 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
643 *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
644 }
645 }
646 }
647 break;
648 case GL_DECR_WRAP_EXT:
649 if (invmask==0) {
650 for (i=0;i<n;i++) {
651 if (mask[i]) {
652 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
653 *sptr = (GLstencil) (*sptr - 1);
654 }
655 }
656 }
657 else {
658 for (i=0;i<n;i++) {
659 if (mask[i]) {
660 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
661 *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
662 }
663 }
664 }
665 break;
666 case GL_INVERT:
667 if (invmask==0) {
668 for (i=0;i<n;i++) {
669 if (mask[i]) {
670 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
671 *sptr = (GLstencil) (~*sptr);
672 }
673 }
674 }
675 else {
676 for (i=0;i<n;i++) {
677 if (mask[i]) {
678 GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
679 *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));
680 }
681 }
682 }
683 break;
684 default:
685 _mesa_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
686 }
687 }
688
689
690
691 /**
692 * Apply stencil test to an array of pixels before depth buffering.
693 *
694 * \note Used for software stencil buffer only.
695 * Input: n - number of pixels in the span
696 * x, y - array of [n] pixels to stencil
697 * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel
698 * Output: mask - pixels which fail the stencil test will have their
699 * mask flag set to 0.
700 * \return GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
701 */
702 static GLboolean
703 stencil_test_pixels( GLcontext *ctx, GLuint face, GLuint n,
704 const GLint x[], const GLint y[], GLubyte mask[] )
705 {
706 GLubyte fail[MAX_WIDTH];
707 GLstencil r, s;
708 GLuint i;
709 GLboolean allfail = GL_FALSE;
710 const GLuint valueMask = ctx->Stencil.ValueMask[face];
711
712 /* software stencil buffer only! */
713 ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer);
714 ASSERT(!SWRAST_CONTEXT(ctx)->Driver.ReadStencilSpan);
715 ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan);
716
717 /*
718 * Perform stencil test. The results of this operation are stored
719 * in the fail[] array:
720 * IF fail[i] is non-zero THEN
721 * the stencil fail operator is to be applied
722 * ELSE
723 * the stencil fail operator is not to be applied
724 * ENDIF
725 */
726
727 switch (ctx->Stencil.Function[face]) {
728 case GL_NEVER:
729 /* always fail */
730 for (i=0;i<n;i++) {
731 if (mask[i]) {
732 mask[i] = 0;
733 fail[i] = 1;
734 }
735 else {
736 fail[i] = 0;
737 }
738 }
739 allfail = GL_TRUE;
740 break;
741 case GL_LESS:
742 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
743 for (i=0;i<n;i++) {
744 if (mask[i]) {
745 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
746 s = (GLstencil) (*sptr & valueMask);
747 if (r < s) {
748 /* passed */
749 fail[i] = 0;
750 }
751 else {
752 fail[i] = 1;
753 mask[i] = 0;
754 }
755 }
756 else {
757 fail[i] = 0;
758 }
759 }
760 break;
761 case GL_LEQUAL:
762 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
763 for (i=0;i<n;i++) {
764 if (mask[i]) {
765 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
766 s = (GLstencil) (*sptr & valueMask);
767 if (r <= s) {
768 /* pass */
769 fail[i] = 0;
770 }
771 else {
772 fail[i] = 1;
773 mask[i] = 0;
774 }
775 }
776 else {
777 fail[i] = 0;
778 }
779 }
780 break;
781 case GL_GREATER:
782 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
783 for (i=0;i<n;i++) {
784 if (mask[i]) {
785 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
786 s = (GLstencil) (*sptr & valueMask);
787 if (r > s) {
788 /* passed */
789 fail[i] = 0;
790 }
791 else {
792 fail[i] = 1;
793 mask[i] = 0;
794 }
795 }
796 else {
797 fail[i] = 0;
798 }
799 }
800 break;
801 case GL_GEQUAL:
802 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
803 for (i=0;i<n;i++) {
804 if (mask[i]) {
805 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
806 s = (GLstencil) (*sptr & valueMask);
807 if (r >= s) {
808 /* passed */
809 fail[i] = 0;
810 }
811 else {
812 fail[i] = 1;
813 mask[i] = 0;
814 }
815 }
816 else {
817 fail[i] = 0;
818 }
819 }
820 break;
821 case GL_EQUAL:
822 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
823 for (i=0;i<n;i++) {
824 if (mask[i]) {
825 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
826 s = (GLstencil) (*sptr & valueMask);
827 if (r == s) {
828 /* passed */
829 fail[i] = 0;
830 }
831 else {
832 fail[i] = 1;
833 mask[i] = 0;
834 }
835 }
836 else {
837 fail[i] = 0;
838 }
839 }
840 break;
841 case GL_NOTEQUAL:
842 r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask);
843 for (i=0;i<n;i++) {
844 if (mask[i]) {
845 GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
846 s = (GLstencil) (*sptr & valueMask);
847 if (r != s) {
848 /* passed */
849 fail[i] = 0;
850 }
851 else {
852 fail[i] = 1;
853 mask[i] = 0;
854 }
855 }
856 else {
857 fail[i] = 0;
858 }
859 }
860 break;
861 case GL_ALWAYS:
862 /* always pass */
863 for (i=0;i<n;i++) {
864 fail[i] = 0;
865 }
866 break;
867 default:
868 _mesa_problem(ctx, "Bad stencil func in gl_stencil_pixels");
869 return 0;
870 }
871
872 if (ctx->Stencil.FailFunc[face] != GL_KEEP) {
873 apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc[face],
874 face, fail );
875 }
876
877 return !allfail;
878 }
879
880
881
882
883 /**
884 * Apply stencil and depth testing to an array of pixels.
885 * This is used both for software and hardware stencil buffers.
886 *
887 * The comments in this function are a bit sparse but the code is
888 * almost identical to stencil_and_ztest_span(), which is well
889 * commented.
890 *
891 * Input: n - number of pixels in the array
892 * x, y - array of [n] pixel positions
893 * z - array [n] of z values
894 * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
895 * Output: mask - array [n] of flags (1=stencil and depth test passed)
896 * Return: GL_FALSE - all fragments failed the testing
897 * GL_TRUE - one or more fragments passed the testing
898 */
899 static GLboolean
900 stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span, GLuint face )
901 {
902 const GLuint n = span->end;
903 const GLint *x = span->array->x;
904 const GLint *y = span->array->y;
905 GLubyte *mask = span->array->mask;
906 SWcontext *swrast = SWRAST_CONTEXT(ctx);
907
908 ASSERT(span->arrayMask & SPAN_XY);
909 ASSERT(ctx->Stencil.Enabled);
910 ASSERT(n <= MAX_WIDTH);
911
912 if (swrast->Driver.WriteStencilPixels) {
913 /*** Hardware stencil buffer ***/
914 GLstencil stencil[MAX_WIDTH];
915 GLubyte origMask[MAX_WIDTH];
916
917 ASSERT(!ctx->DrawBuffer->UseSoftwareStencilBuffer);
918 ASSERT(swrast->Driver.ReadStencilPixels);
919 (*swrast->Driver.ReadStencilPixels)(ctx, n, x, y, stencil);
920
921 MEMCPY(origMask, mask, n * sizeof(GLubyte));
922
923 (void) do_stencil_test(ctx, face, n, stencil, mask);
924
925 if (ctx->Depth.Test == GL_FALSE) {
926 apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
927 n, stencil, mask);
928 }
929 else {
930 _mesa_depth_test_span(ctx, span);
931
932 if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
933 GLubyte failmask[MAX_WIDTH];
934 GLuint i;
935 for (i = 0; i < n; i++) {
936 ASSERT(mask[i] == 0 || mask[i] == 1);
937 failmask[i] = origMask[i] & (mask[i] ^ 1);
938 }
939 apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face,
940 n, stencil, failmask);
941 }
942 if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
943 GLubyte passmask[MAX_WIDTH];
944 GLuint i;
945 for (i = 0; i < n; i++) {
946 ASSERT(mask[i] == 0 || mask[i] == 1);
947 passmask[i] = origMask[i] & mask[i];
948 }
949 apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face,
950 n, stencil, passmask);
951 }
952 }
953
954 /* Write updated stencil values into hardware stencil buffer */
955 (swrast->Driver.WriteStencilPixels)(ctx, n, x, y, stencil, origMask);
956
957 return GL_TRUE;
958 }
959 else {
960 /*** Software stencil buffer ***/
961
962 ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer);
963
964 if (stencil_test_pixels(ctx, face, n, x, y, mask) == GL_FALSE) {
965 /* all fragments failed the stencil test, we're done. */
966 return GL_FALSE;
967 }
968
969 if (ctx->Depth.Test==GL_FALSE) {
970 apply_stencil_op_to_pixels(ctx, n, x, y,
971 ctx->Stencil.ZPassFunc[face], face, mask);
972 }
973 else {
974 GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
975 GLuint i;
976
977 MEMCPY(oldmask, mask, n * sizeof(GLubyte));
978
979 _mesa_depth_test_span(ctx, span);
980
981 for (i=0;i<n;i++) {
982 ASSERT(mask[i] == 0 || mask[i] == 1);
983 passmask[i] = oldmask[i] & mask[i];
984 failmask[i] = oldmask[i] & (mask[i] ^ 1);
985 }
986
987 if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) {
988 apply_stencil_op_to_pixels(ctx, n, x, y,
989 ctx->Stencil.ZFailFunc[face],
990 face, failmask);
991 }
992 if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) {
993 apply_stencil_op_to_pixels(ctx, n, x, y,
994 ctx->Stencil.ZPassFunc[face],
995 face, passmask);
996 }
997 }
998
999 return GL_TRUE; /* one or more fragments passed both tests */
1000 }
1001 }
1002
1003
1004 /**
1005 * /return GL_TRUE = one or more fragments passed,
1006 * GL_FALSE = all fragments failed.
1007 */
1008 GLboolean
1009 _mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
1010 {
1011 /* span->facing can only be non-zero if using two-sided stencil */
1012 ASSERT(ctx->Stencil.TestTwoSide || span->facing == 0);
1013 if (span->arrayMask & SPAN_XY)
1014 return stencil_and_ztest_pixels(ctx, span, span->facing);
1015 else
1016 return stencil_and_ztest_span(ctx, span, span->facing);
1017 }
1018
1019
1020 /**
1021 * Return a span of stencil values from the stencil buffer.
1022 * Used for glRead/CopyPixels
1023 * Input: n - how many pixels
1024 * x,y - location of first pixel
1025 * Output: stencil - the array of stencil values
1026 */
1027 void
1028 _mesa_read_stencil_span( GLcontext *ctx,
1029 GLint n, GLint x, GLint y, GLstencil stencil[] )
1030 {
1031 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1032 const GLint bufWidth = (GLint) ctx->DrawBuffer->Width;
1033 const GLint bufHeight = (GLint) ctx->DrawBuffer->Height;
1034
1035 if (y < 0 || y >= bufHeight || x + n <= 0 || x >= bufWidth) {
1036 /* span is completely outside framebuffer */
1037 return; /* undefined values OK */
1038 }
1039
1040 if (x < 0) {
1041 GLint dx = -x;
1042 x = 0;
1043 n -= dx;
1044 stencil += dx;
1045 }
1046 if (x + n > bufWidth) {
1047 GLint dx = x + n - bufWidth;
1048 n -= dx;
1049 }
1050 if (n <= 0) {
1051 return;
1052 }
1053
1054
1055 ASSERT(n >= 0);
1056 if (swrast->Driver.ReadStencilSpan) {
1057 (*swrast->Driver.ReadStencilSpan)( ctx, (GLuint) n, x, y, stencil );
1058 }
1059 else if (ctx->DrawBuffer->Stencil) {
1060 const GLstencil *s = STENCIL_ADDRESS( x, y );
1061 #if STENCIL_BITS == 8
1062 MEMCPY( stencil, s, n * sizeof(GLstencil) );
1063 #else
1064 GLuint i;
1065 for (i=0;i<n;i++)
1066 stencil[i] = s[i];
1067 #endif
1068 }
1069 }
1070
1071
1072
1073 /**
1074 * Write a span of stencil values to the stencil buffer.
1075 * Used for glDraw/CopyPixels
1076 * Input: n - how many pixels
1077 * x, y - location of first pixel
1078 * stencil - the array of stencil values
1079 */
1080 void
1081 _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
1082 const GLstencil stencil[] )
1083 {
1084 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1085 const GLstencil *ssrc = stencil;
1086 const GLint bufWidth = (GLint) ctx->DrawBuffer->Width;
1087 const GLint bufHeight = (GLint) ctx->DrawBuffer->Height;
1088
1089 if (y < 0 || y >= bufHeight || x + n <= 0 || x >= bufWidth) {
1090 /* span is completely outside framebuffer */
1091 return; /* undefined values OK */
1092 }
1093
1094 if (x < 0) {
1095 GLint dx = -x;
1096 x = 0;
1097 n -= dx;
1098 ssrc += dx;
1099 }
1100 if (x + n > bufWidth) {
1101 GLint dx = x + n - bufWidth;
1102 n -= dx;
1103 }
1104 if (n <= 0) {
1105 return;
1106 }
1107
1108 if (swrast->Driver.WriteStencilSpan) {
1109 (*swrast->Driver.WriteStencilSpan)( ctx, n, x, y, ssrc, NULL );
1110 }
1111 else if (ctx->DrawBuffer->Stencil) {
1112 GLstencil *s = STENCIL_ADDRESS( x, y );
1113 #if STENCIL_BITS == 8
1114 MEMCPY( s, ssrc, n * sizeof(GLstencil) );
1115 #else
1116 GLuint i;
1117 for (i=0;i<n;i++)
1118 s[i] = ssrc[i];
1119 #endif
1120 }
1121 }
1122
1123
1124
1125 /**
1126 * Allocate a new stencil buffer. If there's an old one it will be
1127 * deallocated first. The new stencil buffer will be uninitialized.
1128 */
1129 void
1130 _mesa_alloc_stencil_buffer( GLframebuffer *buffer )
1131 {
1132 /* deallocate current stencil buffer if present */
1133 if (buffer->Stencil) {
1134 MESA_PBUFFER_FREE(buffer->Stencil);
1135 buffer->Stencil = NULL;
1136 }
1137
1138 /* allocate new stencil buffer */
1139 buffer->Stencil = (GLstencil *)
1140 MESA_PBUFFER_ALLOC(buffer->Width * buffer->Height * sizeof(GLstencil));
1141 if (!buffer->Stencil) {
1142 /* out of memory */
1143 _mesa_error( NULL, GL_OUT_OF_MEMORY, "_mesa_alloc_stencil_buffer" );
1144 }
1145 }
1146
1147
1148
1149 /**
1150 * Clear the software (malloc'd) stencil buffer.
1151 */
1152 static void
1153 clear_software_stencil_buffer( GLcontext *ctx )
1154 {
1155 if (ctx->Visual.stencilBits==0 || !ctx->DrawBuffer->Stencil) {
1156 /* no stencil buffer */
1157 return;
1158 }
1159
1160 if (ctx->Scissor.Enabled) {
1161 /* clear scissor region only */
1162 const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
1163 if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
1164 /* must apply mask to the clear */
1165 GLint y;
1166 for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
1167 const GLstencil mask = ctx->Stencil.WriteMask[0];
1168 const GLstencil invMask = ~mask;
1169 const GLstencil clearVal = (ctx->Stencil.Clear & mask);
1170 GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
1171 GLint i;
1172 for (i = 0; i < width; i++) {
1173 stencil[i] = (stencil[i] & invMask) | clearVal;
1174 }
1175 }
1176 }
1177 else {
1178 /* no masking */
1179 GLint y;
1180 for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
1181 GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
1182 #if STENCIL_BITS==8
1183 MEMSET( stencil, ctx->Stencil.Clear, width * sizeof(GLstencil) );
1184 #else
1185 GLint i;
1186 for (i = 0; i < width; i++)
1187 stencil[x] = ctx->Stencil.Clear;
1188 #endif
1189 }
1190 }
1191 }
1192 else {
1193 /* clear whole stencil buffer */
1194 if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
1195 /* must apply mask to the clear */
1196 const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
1197 GLstencil *stencil = ctx->DrawBuffer->Stencil;
1198 const GLstencil mask = ctx->Stencil.WriteMask[0];
1199 const GLstencil invMask = ~mask;
1200 const GLstencil clearVal = (ctx->Stencil.Clear & mask);
1201 GLuint i;
1202 for (i = 0; i < n; i++) {
1203 stencil[i] = (stencil[i] & invMask) | clearVal;
1204 }
1205 }
1206 else {
1207 /* clear whole buffer without masking */
1208 const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
1209 GLstencil *stencil = ctx->DrawBuffer->Stencil;
1210
1211 #if STENCIL_BITS==8
1212 MEMSET(stencil, ctx->Stencil.Clear, n * sizeof(GLstencil) );
1213 #else
1214 GLuint i;
1215 for (i = 0; i < n; i++) {
1216 stencil[i] = ctx->Stencil.Clear;
1217 }
1218 #endif
1219 }
1220 }
1221 }
1222
1223
1224
1225 /**
1226 * Clear the hardware (in graphics card) stencil buffer.
1227 * This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan()
1228 * functions.
1229 * Actually, if there is a hardware stencil buffer it really should have
1230 * been cleared in Driver.Clear()! However, if the hardware does not
1231 * support scissored clears or masked clears (i.e. glStencilMask) then
1232 * we have to use the span-based functions.
1233 */
1234 static void
1235 clear_hardware_stencil_buffer( GLcontext *ctx )
1236 {
1237 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1238 ASSERT(swrast->Driver.WriteStencilSpan);
1239 ASSERT(swrast->Driver.ReadStencilSpan);
1240
1241 if (ctx->Scissor.Enabled) {
1242 /* clear scissor region only */
1243 const GLint x = ctx->DrawBuffer->_Xmin;
1244 const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
1245 if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
1246 /* must apply mask to the clear */
1247 GLint y;
1248 for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
1249 const GLstencil mask = ctx->Stencil.WriteMask[0];
1250 const GLstencil invMask = ~mask;
1251 const GLstencil clearVal = (ctx->Stencil.Clear & mask);
1252 GLstencil stencil[MAX_WIDTH];
1253 GLint i;
1254 (*swrast->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
1255 for (i = 0; i < width; i++) {
1256 stencil[i] = (stencil[i] & invMask) | clearVal;
1257 }
1258 (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
1259 }
1260 }
1261 else {
1262 /* no masking */
1263 GLstencil stencil[MAX_WIDTH];
1264 GLint y, i;
1265 for (i = 0; i < width; i++) {
1266 stencil[i] = ctx->Stencil.Clear;
1267 }
1268 for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
1269 (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
1270 }
1271 }
1272 }
1273 else {
1274 /* clear whole stencil buffer */
1275 if (ctx->Stencil.WriteMask[0] != STENCIL_MAX) {
1276 /* must apply mask to the clear */
1277 const GLstencil mask = ctx->Stencil.WriteMask[0];
1278 const GLstencil invMask = ~mask;
1279 const GLstencil clearVal = (ctx->Stencil.Clear & mask);
1280 const GLint width = ctx->DrawBuffer->Width;
1281 const GLint height = ctx->DrawBuffer->Height;
1282 const GLint x = ctx->DrawBuffer->_Xmin;
1283 GLint y;
1284 for (y = 0; y < height; y++) {
1285 GLstencil stencil[MAX_WIDTH];
1286 GLint i;
1287 (*swrast->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
1288 for (i = 0; i < width; i++) {
1289 stencil[i] = (stencil[i] & invMask) | clearVal;
1290 }
1291 (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
1292 }
1293 }
1294 else {
1295 /* clear whole buffer without masking */
1296 const GLint width = ctx->DrawBuffer->Width;
1297 const GLint height = ctx->DrawBuffer->Height;
1298 const GLint x = ctx->DrawBuffer->_Xmin;
1299 GLstencil stencil[MAX_WIDTH];
1300 GLint y, i;
1301 for (i = 0; i < width; i++) {
1302 stencil[i] = ctx->Stencil.Clear;
1303 }
1304 for (y = 0; y < height; y++) {
1305 (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
1306 }
1307 }
1308 }
1309 }
1310
1311
1312
1313 /**
1314 * Clear the stencil buffer (hardware or software).
1315 */
1316 void
1317 _mesa_clear_stencil_buffer( GLcontext *ctx )
1318 {
1319 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1320 if (swrast->Driver.WriteStencilSpan) {
1321 ASSERT(swrast->Driver.ReadStencilSpan);
1322 clear_hardware_stencil_buffer(ctx);
1323 }
1324 else {
1325 clear_software_stencil_buffer(ctx);
1326 }
1327 }