• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Mesa 3-D graphics library
3  *
4  * Copyright (C) 1999-2007  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 /**
27  * \file stencil.c
28  * Stencil operations.
29  *
30  * Note: There's some conflict between GL_EXT_stencil_two_side and
31  * OpenGL 2.0's two-sided stencil feature.
32  *
33  * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the
34  * front OR back face state (as set by glActiveStencilFaceEXT) is set.
35  *
36  * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the
37  * front AND back state.
38  *
39  * Also, note that GL_ATI_separate_stencil is different as well:
40  * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...)  vs.
41  * glStencilFuncSeparate(GLenum face, GLenum func, ...).
42  *
43  * This problem is solved by keeping three sets of stencil state:
44  *  state[0] = GL_FRONT state.
45  *  state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state.
46  *  state[2] = GL_EXT_stencil_two_side GL_BACK state.
47  */
48 
49 
50 #include "glheader.h"
51 #include "imports.h"
52 #include "context.h"
53 #include "macros.h"
54 #include "stencil.h"
55 #include "mtypes.h"
56 
57 
58 static GLboolean
validate_stencil_op(struct gl_context * ctx,GLenum op)59 validate_stencil_op(struct gl_context *ctx, GLenum op)
60 {
61    switch (op) {
62    case GL_KEEP:
63    case GL_ZERO:
64    case GL_REPLACE:
65    case GL_INCR:
66    case GL_DECR:
67    case GL_INVERT:
68    case GL_INCR_WRAP:
69    case GL_DECR_WRAP:
70       return GL_TRUE;
71    default:
72       return GL_FALSE;
73    }
74 }
75 
76 
77 static GLboolean
validate_stencil_func(struct gl_context * ctx,GLenum func)78 validate_stencil_func(struct gl_context *ctx, GLenum func)
79 {
80    switch (func) {
81    case GL_NEVER:
82    case GL_LESS:
83    case GL_LEQUAL:
84    case GL_GREATER:
85    case GL_GEQUAL:
86    case GL_EQUAL:
87    case GL_NOTEQUAL:
88    case GL_ALWAYS:
89       return GL_TRUE;
90    default:
91       return GL_FALSE;
92    }
93 }
94 
95 
96 /**
97  * Set the clear value for the stencil buffer.
98  *
99  * \param s clear value.
100  *
101  * \sa glClearStencil().
102  *
103  * Updates gl_stencil_attrib::Clear. On change
104  * flushes the vertices and notifies the driver via
105  * the dd_function_table::ClearStencil callback.
106  */
107 void GLAPIENTRY
_mesa_ClearStencil(GLint s)108 _mesa_ClearStencil( GLint s )
109 {
110    GET_CURRENT_CONTEXT(ctx);
111 
112    if (MESA_VERBOSE & VERBOSE_API)
113       _mesa_debug(ctx, "glClearStencil(%d)\n", s);
114 
115    ctx->Stencil.Clear = (GLuint) s;
116 }
117 
118 
119 /**
120  * Set the function and reference value for stencil testing.
121  *
122  * \param frontfunc front test function.
123  * \param backfunc back test function.
124  * \param ref front and back reference value.
125  * \param mask front and back bitmask.
126  *
127  * \sa glStencilFunc().
128  *
129  * Verifies the parameters and updates the respective values in
130  * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies
131  * the driver via the dd_function_table::StencilFunc callback.
132  */
133 void GLAPIENTRY
_mesa_StencilFuncSeparateATI(GLenum frontfunc,GLenum backfunc,GLint ref,GLuint mask)134 _mesa_StencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask )
135 {
136    GET_CURRENT_CONTEXT(ctx);
137 
138    if (MESA_VERBOSE & VERBOSE_API)
139       _mesa_debug(ctx, "glStencilFuncSeparateATI()\n");
140 
141    if (!validate_stencil_func(ctx, frontfunc)) {
142       _mesa_error(ctx, GL_INVALID_ENUM,
143                   "glStencilFuncSeparateATI(frontfunc)");
144       return;
145    }
146    if (!validate_stencil_func(ctx, backfunc)) {
147       _mesa_error(ctx, GL_INVALID_ENUM,
148                   "glStencilFuncSeparateATI(backfunc)");
149       return;
150    }
151 
152    /* set both front and back state */
153    if (ctx->Stencil.Function[0] == frontfunc &&
154        ctx->Stencil.Function[1] == backfunc &&
155        ctx->Stencil.ValueMask[0] == mask &&
156        ctx->Stencil.ValueMask[1] == mask &&
157        ctx->Stencil.Ref[0] == ref &&
158        ctx->Stencil.Ref[1] == ref)
159       return;
160    FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
161    ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
162    ctx->Stencil.Function[0]  = frontfunc;
163    ctx->Stencil.Function[1]  = backfunc;
164    ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;
165    ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;
166    if (ctx->Driver.StencilFuncSeparate) {
167       ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT,
168                                       frontfunc, ref, mask);
169       ctx->Driver.StencilFuncSeparate(ctx, GL_BACK,
170                                       backfunc, ref, mask);
171    }
172 }
173 
174 
175 /**
176  * Set the function and reference value for stencil testing.
177  *
178  * \param func test function.
179  * \param ref reference value.
180  * \param mask bitmask.
181  *
182  * \sa glStencilFunc().
183  *
184  * Verifies the parameters and updates the respective values in
185  * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies
186  * the driver via the dd_function_table::StencilFunc callback.
187  */
188 static void
stencil_func(struct gl_context * ctx,GLenum func,GLint ref,GLuint mask)189 stencil_func(struct gl_context *ctx, GLenum func, GLint ref, GLuint mask)
190 {
191    const GLint face = ctx->Stencil.ActiveFace;
192 
193    if (face != 0) {
194       if (ctx->Stencil.Function[face] == func &&
195           ctx->Stencil.ValueMask[face] == mask &&
196           ctx->Stencil.Ref[face] == ref)
197          return;
198       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
199       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
200       ctx->Stencil.Function[face] = func;
201       ctx->Stencil.Ref[face] = ref;
202       ctx->Stencil.ValueMask[face] = mask;
203 
204       /* Only propagate the change to the driver if EXT_stencil_two_side
205        * is enabled.
206        */
207       if (ctx->Driver.StencilFuncSeparate && ctx->Stencil.TestTwoSide) {
208          ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, func, ref, mask);
209       }
210    }
211    else {
212       /* set both front and back state */
213       if (ctx->Stencil.Function[0] == func &&
214           ctx->Stencil.Function[1] == func &&
215           ctx->Stencil.ValueMask[0] == mask &&
216           ctx->Stencil.ValueMask[1] == mask &&
217           ctx->Stencil.Ref[0] == ref &&
218           ctx->Stencil.Ref[1] == ref)
219          return;
220       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
221       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
222       ctx->Stencil.Function[0]  = ctx->Stencil.Function[1]  = func;
223       ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;
224       ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;
225       if (ctx->Driver.StencilFuncSeparate) {
226          ctx->Driver.StencilFuncSeparate(ctx,
227 					 ((ctx->Stencil.TestTwoSide)
228 					  ? GL_FRONT : GL_FRONT_AND_BACK),
229                                          func, ref, mask);
230       }
231    }
232 }
233 
234 
235 void GLAPIENTRY
_mesa_StencilFunc_no_error(GLenum func,GLint ref,GLuint mask)236 _mesa_StencilFunc_no_error(GLenum func, GLint ref, GLuint mask)
237 {
238    GET_CURRENT_CONTEXT(ctx);
239    stencil_func(ctx, func, ref, mask);
240 }
241 
242 
243 void GLAPIENTRY
_mesa_StencilFunc(GLenum func,GLint ref,GLuint mask)244 _mesa_StencilFunc(GLenum func, GLint ref, GLuint mask)
245 {
246    GET_CURRENT_CONTEXT(ctx);
247 
248    if (MESA_VERBOSE & VERBOSE_API)
249       _mesa_debug(ctx, "glStencilFunc()\n");
250 
251    if (!validate_stencil_func(ctx, func)) {
252       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFunc(func)");
253       return;
254    }
255 
256    stencil_func(ctx, func, ref, mask);
257 }
258 
259 
260 /**
261  * Set the stencil writing mask.
262  *
263  * \param mask bit-mask to enable/disable writing of individual bits in the
264  * stencil planes.
265  *
266  * \sa glStencilMask().
267  *
268  * Updates gl_stencil_attrib::WriteMask. On change flushes the vertices and
269  * notifies the driver via the dd_function_table::StencilMask callback.
270  */
271 void GLAPIENTRY
_mesa_StencilMask(GLuint mask)272 _mesa_StencilMask( GLuint mask )
273 {
274    GET_CURRENT_CONTEXT(ctx);
275    const GLint face = ctx->Stencil.ActiveFace;
276 
277    if (MESA_VERBOSE & VERBOSE_API)
278       _mesa_debug(ctx, "glStencilMask()\n");
279 
280    if (face != 0) {
281       /* Only modify the EXT_stencil_two_side back-face state.
282        */
283       if (ctx->Stencil.WriteMask[face] == mask)
284          return;
285       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
286       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
287       ctx->Stencil.WriteMask[face] = mask;
288 
289       /* Only propagate the change to the driver if EXT_stencil_two_side
290        * is enabled.
291        */
292       if (ctx->Driver.StencilMaskSeparate && ctx->Stencil.TestTwoSide) {
293          ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, mask);
294       }
295    }
296    else {
297       /* set both front and back state */
298       if (ctx->Stencil.WriteMask[0] == mask &&
299           ctx->Stencil.WriteMask[1] == mask)
300          return;
301       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
302       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
303       ctx->Stencil.WriteMask[0] = ctx->Stencil.WriteMask[1] = mask;
304       if (ctx->Driver.StencilMaskSeparate) {
305          ctx->Driver.StencilMaskSeparate(ctx,
306 					 ((ctx->Stencil.TestTwoSide)
307 					  ? GL_FRONT : GL_FRONT_AND_BACK),
308 					  mask);
309       }
310    }
311 }
312 
313 
314 /**
315  * Set the stencil test actions.
316  *
317  * \param fail action to take when stencil test fails.
318  * \param zfail action to take when stencil test passes, but depth test fails.
319  * \param zpass action to take when stencil test passes and the depth test
320  * passes (or depth testing is not enabled).
321  *
322  * \sa glStencilOp().
323  *
324  * Verifies the parameters and updates the respective fields in
325  * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies
326  * the driver via the dd_function_table::StencilOp callback.
327  */
328 static void
stencil_op(struct gl_context * ctx,GLenum fail,GLenum zfail,GLenum zpass)329 stencil_op(struct gl_context *ctx, GLenum fail, GLenum zfail, GLenum zpass)
330 {
331    const GLint face = ctx->Stencil.ActiveFace;
332 
333    if (face != 0) {
334       /* only set active face state */
335       if (ctx->Stencil.ZFailFunc[face] == zfail &&
336           ctx->Stencil.ZPassFunc[face] == zpass &&
337           ctx->Stencil.FailFunc[face] == fail)
338          return;
339       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
340       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
341       ctx->Stencil.ZFailFunc[face] = zfail;
342       ctx->Stencil.ZPassFunc[face] = zpass;
343       ctx->Stencil.FailFunc[face] = fail;
344 
345       /* Only propagate the change to the driver if EXT_stencil_two_side
346        * is enabled.
347        */
348       if (ctx->Driver.StencilOpSeparate && ctx->Stencil.TestTwoSide) {
349          ctx->Driver.StencilOpSeparate(ctx, GL_BACK, fail, zfail, zpass);
350       }
351    }
352    else {
353       /* set both front and back state */
354       if (ctx->Stencil.ZFailFunc[0] == zfail &&
355           ctx->Stencil.ZFailFunc[1] == zfail &&
356           ctx->Stencil.ZPassFunc[0] == zpass &&
357           ctx->Stencil.ZPassFunc[1] == zpass &&
358           ctx->Stencil.FailFunc[0] == fail &&
359           ctx->Stencil.FailFunc[1] == fail)
360          return;
361       FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
362       ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
363       ctx->Stencil.ZFailFunc[0] = ctx->Stencil.ZFailFunc[1] = zfail;
364       ctx->Stencil.ZPassFunc[0] = ctx->Stencil.ZPassFunc[1] = zpass;
365       ctx->Stencil.FailFunc[0]  = ctx->Stencil.FailFunc[1]  = fail;
366       if (ctx->Driver.StencilOpSeparate) {
367          ctx->Driver.StencilOpSeparate(ctx,
368 				       ((ctx->Stencil.TestTwoSide)
369 					? GL_FRONT : GL_FRONT_AND_BACK),
370                                        fail, zfail, zpass);
371       }
372    }
373 }
374 
375 
376 void GLAPIENTRY
_mesa_StencilOp_no_error(GLenum fail,GLenum zfail,GLenum zpass)377 _mesa_StencilOp_no_error(GLenum fail, GLenum zfail, GLenum zpass)
378 {
379    GET_CURRENT_CONTEXT(ctx);
380    stencil_op(ctx, fail, zfail, zpass);
381 }
382 
383 
384 void GLAPIENTRY
_mesa_StencilOp(GLenum fail,GLenum zfail,GLenum zpass)385 _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
386 {
387    GET_CURRENT_CONTEXT(ctx);
388 
389    if (MESA_VERBOSE & VERBOSE_API)
390       _mesa_debug(ctx, "glStencilOp()\n");
391 
392    if (!validate_stencil_op(ctx, fail)) {
393       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(sfail)");
394       return;
395    }
396 
397    if (!validate_stencil_op(ctx, zfail)) {
398       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zfail)");
399       return;
400    }
401 
402    if (!validate_stencil_op(ctx, zpass)) {
403       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zpass)");
404       return;
405    }
406 
407    stencil_op(ctx, fail, zfail, zpass);
408 }
409 
410 
411 /* GL_EXT_stencil_two_side */
412 void GLAPIENTRY
_mesa_ActiveStencilFaceEXT(GLenum face)413 _mesa_ActiveStencilFaceEXT(GLenum face)
414 {
415    GET_CURRENT_CONTEXT(ctx);
416 
417    if (MESA_VERBOSE & VERBOSE_API)
418       _mesa_debug(ctx, "glActiveStencilFaceEXT()\n");
419 
420    if (!ctx->Extensions.EXT_stencil_two_side) {
421       _mesa_error(ctx, GL_INVALID_OPERATION, "glActiveStencilFaceEXT");
422       return;
423    }
424 
425    if (face == GL_FRONT || face == GL_BACK) {
426       ctx->Stencil.ActiveFace = (face == GL_FRONT) ? 0 : 2;
427    }
428    else {
429       _mesa_error(ctx, GL_INVALID_ENUM, "glActiveStencilFaceEXT(face)");
430    }
431 }
432 
433 
434 static void
stencil_op_separate(struct gl_context * ctx,GLenum face,GLenum sfail,GLenum zfail,GLenum zpass)435 stencil_op_separate(struct gl_context *ctx, GLenum face, GLenum sfail,
436                     GLenum zfail, GLenum zpass)
437 {
438    GLboolean set = GL_FALSE;
439 
440    if (face != GL_BACK) {
441       /* set front */
442       if (ctx->Stencil.ZFailFunc[0] != zfail ||
443           ctx->Stencil.ZPassFunc[0] != zpass ||
444           ctx->Stencil.FailFunc[0] != sfail){
445          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
446          ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
447          ctx->Stencil.ZFailFunc[0] = zfail;
448          ctx->Stencil.ZPassFunc[0] = zpass;
449          ctx->Stencil.FailFunc[0] = sfail;
450          set = GL_TRUE;
451       }
452    }
453 
454    if (face != GL_FRONT) {
455       /* set back */
456       if (ctx->Stencil.ZFailFunc[1] != zfail ||
457           ctx->Stencil.ZPassFunc[1] != zpass ||
458           ctx->Stencil.FailFunc[1] != sfail) {
459          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
460          ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
461          ctx->Stencil.ZFailFunc[1] = zfail;
462          ctx->Stencil.ZPassFunc[1] = zpass;
463          ctx->Stencil.FailFunc[1] = sfail;
464          set = GL_TRUE;
465       }
466    }
467 
468    if (set && ctx->Driver.StencilOpSeparate) {
469       ctx->Driver.StencilOpSeparate(ctx, face, sfail, zfail, zpass);
470    }
471 }
472 
473 
474 void GLAPIENTRY
_mesa_StencilOpSeparate_no_error(GLenum face,GLenum sfail,GLenum zfail,GLenum zpass)475 _mesa_StencilOpSeparate_no_error(GLenum face, GLenum sfail, GLenum zfail,
476                                  GLenum zpass)
477 {
478    GET_CURRENT_CONTEXT(ctx);
479    stencil_op_separate(ctx, face, sfail, zfail, zpass);
480 }
481 
482 
483 void GLAPIENTRY
_mesa_StencilOpSeparate(GLenum face,GLenum sfail,GLenum zfail,GLenum zpass)484 _mesa_StencilOpSeparate(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass)
485 {
486    GET_CURRENT_CONTEXT(ctx);
487 
488    if (MESA_VERBOSE & VERBOSE_API)
489       _mesa_debug(ctx, "glStencilOpSeparate()\n");
490 
491    if (!validate_stencil_op(ctx, sfail)) {
492       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(sfail)");
493       return;
494    }
495 
496    if (!validate_stencil_op(ctx, zfail)) {
497       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zfail)");
498       return;
499    }
500 
501    if (!validate_stencil_op(ctx, zpass)) {
502       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zpass)");
503       return;
504    }
505 
506    if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
507       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(face)");
508       return;
509    }
510 
511    stencil_op_separate(ctx, face, sfail, zfail, zpass);
512 }
513 
514 
515 static void
stencil_func_separate(struct gl_context * ctx,GLenum face,GLenum func,GLint ref,GLuint mask)516 stencil_func_separate(struct gl_context *ctx, GLenum face, GLenum func,
517                       GLint ref, GLuint mask)
518 {
519    FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
520    ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
521 
522    if (face != GL_BACK) {
523       /* set front */
524       ctx->Stencil.Function[0] = func;
525       ctx->Stencil.Ref[0] = ref;
526       ctx->Stencil.ValueMask[0] = mask;
527    }
528 
529    if (face != GL_FRONT) {
530       /* set back */
531       ctx->Stencil.Function[1] = func;
532       ctx->Stencil.Ref[1] = ref;
533       ctx->Stencil.ValueMask[1] = mask;
534    }
535 
536    if (ctx->Driver.StencilFuncSeparate) {
537       ctx->Driver.StencilFuncSeparate(ctx, face, func, ref, mask);
538    }
539 }
540 
541 
542 /* OpenGL 2.0 */
543 void GLAPIENTRY
_mesa_StencilFuncSeparate_no_error(GLenum face,GLenum func,GLint ref,GLuint mask)544 _mesa_StencilFuncSeparate_no_error(GLenum face, GLenum func, GLint ref,
545                                    GLuint mask)
546 {
547    GET_CURRENT_CONTEXT(ctx);
548    stencil_func_separate(ctx, face, func, ref, mask);
549 }
550 
551 
552 void GLAPIENTRY
_mesa_StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)553 _mesa_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
554 {
555    GET_CURRENT_CONTEXT(ctx);
556 
557    if (MESA_VERBOSE & VERBOSE_API)
558       _mesa_debug(ctx, "glStencilFuncSeparate()\n");
559 
560    if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
561       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(face)");
562       return;
563    }
564 
565    if (!validate_stencil_func(ctx, func)) {
566       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(func)");
567       return;
568    }
569 
570    stencil_func_separate(ctx, face, func, ref, mask);
571 }
572 
573 
574 static void
stencil_mask_separate(struct gl_context * ctx,GLenum face,GLuint mask)575 stencil_mask_separate(struct gl_context *ctx, GLenum face, GLuint mask)
576 {
577    FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
578    ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
579 
580    if (face != GL_BACK) {
581       ctx->Stencil.WriteMask[0] = mask;
582    }
583 
584    if (face != GL_FRONT) {
585       ctx->Stencil.WriteMask[1] = mask;
586    }
587 
588    if (ctx->Driver.StencilMaskSeparate) {
589       ctx->Driver.StencilMaskSeparate(ctx, face, mask);
590    }
591 }
592 
593 
594 /* OpenGL 2.0 */
595 void GLAPIENTRY
_mesa_StencilMaskSeparate_no_error(GLenum face,GLuint mask)596 _mesa_StencilMaskSeparate_no_error(GLenum face, GLuint mask)
597 {
598    GET_CURRENT_CONTEXT(ctx);
599    stencil_mask_separate(ctx, face, mask);
600 }
601 
602 
603 void GLAPIENTRY
_mesa_StencilMaskSeparate(GLenum face,GLuint mask)604 _mesa_StencilMaskSeparate(GLenum face, GLuint mask)
605 {
606    GET_CURRENT_CONTEXT(ctx);
607 
608    if (MESA_VERBOSE & VERBOSE_API)
609       _mesa_debug(ctx, "glStencilMaskSeparate()\n");
610 
611    if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
612       _mesa_error(ctx, GL_INVALID_ENUM, "glStencilaMaskSeparate(face)");
613       return;
614    }
615 
616    stencil_mask_separate(ctx, face, mask);
617 }
618 
619 
620 /**
621  * Initialize the context stipple state.
622  *
623  * \param ctx GL context.
624  *
625  * Initializes __struct gl_contextRec::Stencil attribute group.
626  */
627 void
_mesa_init_stencil(struct gl_context * ctx)628 _mesa_init_stencil(struct gl_context *ctx)
629 {
630    ctx->Stencil.Enabled = GL_FALSE;
631    ctx->Stencil.TestTwoSide = GL_FALSE;
632    ctx->Stencil.ActiveFace = 0;  /* 0 = GL_FRONT, 2 = GL_BACK */
633    ctx->Stencil.Function[0] = GL_ALWAYS;
634    ctx->Stencil.Function[1] = GL_ALWAYS;
635    ctx->Stencil.Function[2] = GL_ALWAYS;
636    ctx->Stencil.FailFunc[0] = GL_KEEP;
637    ctx->Stencil.FailFunc[1] = GL_KEEP;
638    ctx->Stencil.FailFunc[2] = GL_KEEP;
639    ctx->Stencil.ZPassFunc[0] = GL_KEEP;
640    ctx->Stencil.ZPassFunc[1] = GL_KEEP;
641    ctx->Stencil.ZPassFunc[2] = GL_KEEP;
642    ctx->Stencil.ZFailFunc[0] = GL_KEEP;
643    ctx->Stencil.ZFailFunc[1] = GL_KEEP;
644    ctx->Stencil.ZFailFunc[2] = GL_KEEP;
645    ctx->Stencil.Ref[0] = 0;
646    ctx->Stencil.Ref[1] = 0;
647    ctx->Stencil.Ref[2] = 0;
648 
649    /* 4.1.4 Stencil Test section of the GL-ES 3.0 specification says:
650     *
651     *     "In the initial state, [...] the front and back stencil mask are both
652     *     set to the value 2^s − 1, where s is greater than or equal to the
653     *     number of bits in the deepest stencil buffer* supported by the GL
654     *     implementation."
655     *
656     * Since the maximum supported precision for stencil buffers is 8 bits,
657     * mask values should be initialized to 2^8 - 1 = 0xFF.
658     */
659    ctx->Stencil.ValueMask[0] = 0xFF;
660    ctx->Stencil.ValueMask[1] = 0xFF;
661    ctx->Stencil.ValueMask[2] = 0xFF;
662    ctx->Stencil.WriteMask[0] = 0xFF;
663    ctx->Stencil.WriteMask[1] = 0xFF;
664    ctx->Stencil.WriteMask[2] = 0xFF;
665 
666    ctx->Stencil.Clear = 0;
667    ctx->Stencil._BackFace = 1;
668 }
669