X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fstencil.c;h=15c98e2015668db089dfaea90fb3697c8ed0474f;hb=9b70c33e735ff060ddad7d0b501d19c670f41618;hp=e3529996be740fe04e1cb7c451fa81ef7046201b;hpb=bd5cdaf4442872d3cd2ff94eeafadd481d27fcfb;p=mesa.git diff --git a/src/mesa/main/stencil.c b/src/mesa/main/stencil.c index e3529996be7..15c98e20156 100644 --- a/src/mesa/main/stencil.c +++ b/src/mesa/main/stencil.c @@ -1,21 +1,19 @@ -/* $Id: stencil.c,v 1.6 1999/10/13 18:42:50 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.1 - * - * Copyright (C) 1999 Brian Paul All Rights Reserved. - * + * Version: 7.1 + * + * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -25,1090 +23,568 @@ */ -/* $XFree86: xc/lib/GL/mesa/src/stencil.c,v 1.3 1999/04/04 00:20:32 dawes Exp $ */ +/** + * \file stencil.c + * Stencil operations. + * + * Note: There's some conflict between GL_EXT_stencil_two_side and + * OpenGL 2.0's two-sided stencil feature. + * + * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the + * front OR back face state (as set by glActiveStencilFaceEXT) is set. + * + * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the + * front AND back state. + * + * Also, note that GL_ATI_separate_stencil is different as well: + * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...) vs. + * glStencilFuncSeparate(GLenum face, GLenum func, ...). + * + * This problem is solved by keeping three sets of stencil state: + * state[0] = GL_FRONT state. + * state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state. + * state[2] = GL_EXT_stencil_two_side GL_BACK state. + */ -#ifdef PC_HEADER -#include "all.h" -#else -#ifndef XFree86Server -#include -#include -#else -#include "GL/xf86glx.h" -#endif + +#include "glheader.h" +#include "imports.h" #include "context.h" #include "macros.h" -#include "pb.h" #include "stencil.h" -#include "types.h" -#include "enable.h" -#ifdef XFree86Server -#include "GL/xf86glx.h" -#endif -#endif +#include "mtypes.h" -#if STENCIL_BITS==8 -# define STENCIL_MAX 0xff -#elif STENCIL_BITS==16 -# define STENCIL_MAX 0xffff -#else - illegal number of stencil bits -#endif +static GLboolean +validate_stencil_op(GLcontext *ctx, GLenum op) +{ + switch (op) { + case GL_KEEP: + case GL_ZERO: + case GL_REPLACE: + case GL_INCR: + case GL_DECR: + case GL_INVERT: + return GL_TRUE; + case GL_INCR_WRAP_EXT: + case GL_DECR_WRAP_EXT: + if (ctx->Extensions.EXT_stencil_wrap) { + return GL_TRUE; + } + /* FALL-THROUGH */ + default: + return GL_FALSE; + } +} + +static GLboolean +validate_stencil_func(GLcontext *ctx, GLenum func) +{ + switch (func) { + case GL_NEVER: + case GL_LESS: + case GL_LEQUAL: + case GL_GREATER: + case GL_GEQUAL: + case GL_EQUAL: + case GL_NOTEQUAL: + case GL_ALWAYS: + return GL_TRUE; + default: + return GL_FALSE; + } +} -/* - * Return the address of a stencil buffer value given the window coords: +/** + * Set the clear value for the stencil buffer. + * + * \param s clear value. + * + * \sa glClearStencil(). + * + * Updates gl_stencil_attrib::Clear. On change + * flushes the vertices and notifies the driver via + * the dd_function_table::ClearStencil callback. */ -#define STENCIL_ADDRESS(X,Y) (ctx->Buffer->Stencil + ctx->Buffer->Width * (Y) + (X)) +void GLAPIENTRY +_mesa_ClearStencil( GLint s ) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + if (ctx->Stencil.Clear == (GLuint) s) + return; -void gl_ClearStencil( GLcontext *ctx, GLint s ) -{ - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearStencil"); - ctx->Stencil.Clear = (GLstencil) s; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.Clear = (GLuint) s; if (ctx->Driver.ClearStencil) { - (*ctx->Driver.ClearStencil)( ctx, s ); + ctx->Driver.ClearStencil( ctx, s ); } } - -void gl_StencilFunc( GLcontext *ctx, GLenum func, GLint ref, GLuint mask ) +/** + * Set the function and reference value for stencil testing. + * + * \param frontfunc front test function. + * \param backfunc back test function. + * \param ref front and back reference value. + * \param mask front and back bitmask. + * + * \sa glStencilFunc(). + * + * Verifies the parameters and updates the respective values in + * __GLcontextRec::Stencil. On change flushes the vertices and notifies the + * driver via the dd_function_table::StencilFunc callback. + */ +void GLAPIENTRY +_mesa_StencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask ) { - GLint maxref; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilFunc"); + GET_CURRENT_CONTEXT(ctx); + const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1; + ASSERT_OUTSIDE_BEGIN_END(ctx); - switch (func) { - case GL_NEVER: - case GL_LESS: - case GL_LEQUAL: - case GL_GREATER: - case GL_GEQUAL: - case GL_EQUAL: - case GL_NOTEQUAL: - case GL_ALWAYS: - ctx->Stencil.Function = func; - break; - default: - gl_error( ctx, GL_INVALID_ENUM, "glStencilFunc" ); - return; + if (!validate_stencil_func(ctx, frontfunc)) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glStencilFuncSeparateATI(frontfunc)"); + return; + } + if (!validate_stencil_func(ctx, backfunc)) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glStencilFuncSeparateATI(backfunc)"); + return; } - maxref = (1 << STENCIL_BITS) - 1; - ctx->Stencil.Ref = CLAMP( ref, 0, maxref ); - ctx->Stencil.ValueMask = mask; + ref = CLAMP( ref, 0, stencilMax ); - if (ctx->Driver.StencilFunc) { - (*ctx->Driver.StencilFunc)( ctx, func, ctx->Stencil.Ref, mask ); + /* set both front and back state */ + if (ctx->Stencil.Function[0] == frontfunc && + ctx->Stencil.Function[1] == backfunc && + ctx->Stencil.ValueMask[0] == mask && + ctx->Stencil.ValueMask[1] == mask && + ctx->Stencil.Ref[0] == ref && + ctx->Stencil.Ref[1] == ref) + return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.Function[0] = frontfunc; + ctx->Stencil.Function[1] = backfunc; + ctx->Stencil.Ref[0] = ctx->Stencil.Ref[1] = ref; + ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask; + if (ctx->Driver.StencilFuncSeparate) { + ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT, + frontfunc, ref, mask); + ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, + backfunc, ref, mask); } } - -void gl_StencilMask( GLcontext *ctx, GLuint mask ) +/** + * Set the function and reference value for stencil testing. + * + * \param func test function. + * \param ref reference value. + * \param mask bitmask. + * + * \sa glStencilFunc(). + * + * Verifies the parameters and updates the respective values in + * __GLcontextRec::Stencil. On change flushes the vertices and notifies the + * driver via the dd_function_table::StencilFunc callback. + */ +void GLAPIENTRY +_mesa_StencilFunc( GLenum func, GLint ref, GLuint mask ) { - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilMask"); - ctx->Stencil.WriteMask = (GLstencil) mask; + GET_CURRENT_CONTEXT(ctx); + const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1; + const GLint face = ctx->Stencil.ActiveFace; + ASSERT_OUTSIDE_BEGIN_END(ctx); - if (ctx->Driver.StencilMask) { - (*ctx->Driver.StencilMask)( ctx, mask ); + if (!validate_stencil_func(ctx, func)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFunc(func)"); + return; } -} + ref = CLAMP( ref, 0, stencilMax ); - -void gl_StencilOp( GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass ) -{ - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilOp"); - switch (fail) { - case GL_KEEP: - case GL_ZERO: - case GL_REPLACE: - case GL_INCR: - case GL_DECR: - case GL_INVERT: - case GL_INCR_WRAP_EXT: - case GL_DECR_WRAP_EXT: - ctx->Stencil.FailFunc = fail; - break; - default: - gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" ); - return; - } - switch (zfail) { - case GL_KEEP: - case GL_ZERO: - case GL_REPLACE: - case GL_INCR: - case GL_DECR: - case GL_INVERT: - case GL_INCR_WRAP_EXT: - case GL_DECR_WRAP_EXT: - ctx->Stencil.ZFailFunc = zfail; - break; - default: - gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" ); + if (face != 0) { + if (ctx->Stencil.Function[face] == func && + ctx->Stencil.ValueMask[face] == mask && + ctx->Stencil.Ref[face] == ref) return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.Function[face] = func; + ctx->Stencil.Ref[face] = ref; + ctx->Stencil.ValueMask[face] = mask; + + /* Only propagate the change to the driver if EXT_stencil_two_side + * is enabled. + */ + if (ctx->Driver.StencilFuncSeparate && ctx->Stencil.TestTwoSide) { + ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, func, ref, mask); + } } - switch (zpass) { - case GL_KEEP: - case GL_ZERO: - case GL_REPLACE: - case GL_INCR: - case GL_DECR: - case GL_INVERT: - case GL_INCR_WRAP_EXT: - case GL_DECR_WRAP_EXT: - ctx->Stencil.ZPassFunc = zpass; - break; - default: - gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" ); + else { + /* set both front and back state */ + if (ctx->Stencil.Function[0] == func && + ctx->Stencil.Function[1] == func && + ctx->Stencil.ValueMask[0] == mask && + ctx->Stencil.ValueMask[1] == mask && + ctx->Stencil.Ref[0] == ref && + ctx->Stencil.Ref[1] == ref) return; - } - - if (ctx->Driver.StencilOp) { - (*ctx->Driver.StencilOp)( ctx, fail, zfail, zpass ); + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.Function[0] = ctx->Stencil.Function[1] = func; + ctx->Stencil.Ref[0] = ctx->Stencil.Ref[1] = ref; + ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask; + if (ctx->Driver.StencilFuncSeparate) { + ctx->Driver.StencilFuncSeparate(ctx, + ((ctx->Stencil.TestTwoSide) + ? GL_FRONT : GL_FRONT_AND_BACK), + func, ref, mask); + } } } - -/* Stencil Logic: - -IF stencil test fails THEN - Don't write the pixel (RGBA,Z) - Execute FailOp -ELSE - Write the pixel -ENDIF - -Perform Depth Test - -IF depth test passes OR no depth buffer THEN - Execute ZPass - Write the pixel -ELSE - Execute ZFail -ENDIF - -*/ - - - - -/* - * Apply the given stencil operator for each pixel in the span whose - * mask flag is set. - * Input: n - number of pixels in the span - * x, y - location of leftmost pixel in the span - * oper - the stencil buffer operator - * mask - array [n] of flag: 1=apply operator, 0=don't apply operator +/** + * Set the stencil writing mask. + * + * \param mask bit-mask to enable/disable writing of individual bits in the + * stencil planes. + * + * \sa glStencilMask(). + * + * Updates gl_stencil_attrib::WriteMask. On change flushes the vertices and + * notifies the driver via the dd_function_table::StencilMask callback. */ -static void apply_stencil_op_to_span( GLcontext *ctx, - GLuint n, GLint x, GLint y, - GLenum oper, GLubyte mask[] ) +void GLAPIENTRY +_mesa_StencilMask( GLuint mask ) { - const GLstencil ref = ctx->Stencil.Ref; - const GLstencil wrtmask = ctx->Stencil.WriteMask; - const GLstencil invmask = ~ctx->Stencil.WriteMask; - GLstencil *stencil = STENCIL_ADDRESS( x, y ); - GLuint i; + GET_CURRENT_CONTEXT(ctx); + const GLint face = ctx->Stencil.ActiveFace; - switch (oper) { - case GL_KEEP: - /* do nothing */ - break; - case GL_ZERO: - if (invmask==0) { - for (i=0;i0) { - stencil[i] = s-1; - } - } - } - } - else { - for (i=0;i0) { - stencil[i] = (invmask & s) | (wrtmask & (s-1)); - } - } - } - } - break; - case GL_INCR_WRAP_EXT: - if (invmask==0) { - for (i=0;iStencil.WriteMask[face] == mask) + return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.WriteMask[face] = mask; + /* Only propagate the change to the driver if EXT_stencil_two_side + * is enabled. + */ + if (ctx->Driver.StencilMaskSeparate && ctx->Stencil.TestTwoSide) { + ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, mask); + } + } + else { + /* set both front and back state */ + if (ctx->Stencil.WriteMask[0] == mask && + ctx->Stencil.WriteMask[1] == mask) + return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.WriteMask[0] = ctx->Stencil.WriteMask[1] = mask; + if (ctx->Driver.StencilMaskSeparate) { + ctx->Driver.StencilMaskSeparate(ctx, + ((ctx->Stencil.TestTwoSide) + ? GL_FRONT : GL_FRONT_AND_BACK), + mask); + } + } +} -/* - * Apply stencil test to a span of pixels before depth buffering. - * Input: n - number of pixels in the span - * x, y - coordinate of left-most pixel in the span - * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel - * Output: mask - pixels which fail the stencil test will have their - * mask flag set to 0. - * Return: 0 = all pixels failed, 1 = zero or more pixels passed. +/** + * Set the stencil test actions. + * + * \param fail action to take when stencil test fails. + * \param zfail action to take when stencil test passes, but depth test fails. + * \param zpass action to take when stencil test passes and the depth test + * passes (or depth testing is not enabled). + * + * \sa glStencilOp(). + * + * Verifies the parameters and updates the respective fields in + * __GLcontextRec::Stencil. On change flushes the vertices and notifies the + * driver via the dd_function_table::StencilOp callback. */ -GLint gl_stencil_span( GLcontext *ctx, - GLuint n, GLint x, GLint y, GLubyte mask[] ) +void GLAPIENTRY +_mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { - GLubyte fail[MAX_WIDTH]; - GLint allfail = 0; - GLuint i; - GLstencil r, s; - GLstencil *stencil; + GET_CURRENT_CONTEXT(ctx); + const GLint face = ctx->Stencil.ActiveFace; - stencil = STENCIL_ADDRESS( x, y ); + ASSERT_OUTSIDE_BEGIN_END(ctx); - /* - * Perform stencil test. The results of this operation are stored - * in the fail[] array: - * IF fail[i] is non-zero THEN - * the stencil fail operator is to be applied - * ELSE - * the stencil fail operator is not to be applied - * ENDIF - */ - switch (ctx->Stencil.Function) { - case GL_NEVER: - /* always fail */ - for (i=0;iStencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r < s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_LEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r <= s) { - /* pass */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_GREATER: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r > s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_GEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r >= s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_EQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r == s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_NOTEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r != s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_ALWAYS: - /* always pass */ - for (i=0;iStencil.FailFunc, fail ); - - return (allfail) ? 0 : 1; -} - - - + if (face != 0) { + /* only set active face state */ + if (ctx->Stencil.ZFailFunc[face] == zfail && + ctx->Stencil.ZPassFunc[face] == zpass && + ctx->Stencil.FailFunc[face] == fail) + return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.ZFailFunc[face] = zfail; + ctx->Stencil.ZPassFunc[face] = zpass; + ctx->Stencil.FailFunc[face] = fail; -/* - * Apply the combination depth-buffer/stencil operator to a span of pixels. - * Input: n - number of pixels in the span - * x, y - location of leftmost pixel in span - * z - array [n] of z values - * Input: mask - array [n] of flags (1=test this pixel, 0=skip the pixel) - * Output: mask - array [n] of flags (1=depth test passed, 0=failed) - */ -void gl_depth_stencil_span( GLcontext *ctx, - GLuint n, GLint x, GLint y, const GLdepth z[], - GLubyte mask[] ) -{ - if (ctx->Depth.Test==GL_FALSE) { - /* - * No depth buffer, just apply zpass stencil function to active pixels. + /* Only propagate the change to the driver if EXT_stencil_two_side + * is enabled. */ - apply_stencil_op_to_span( ctx, n, x, y, ctx->Stencil.ZPassFunc, mask ); + if (ctx->Driver.StencilOpSeparate && ctx->Stencil.TestTwoSide) { + ctx->Driver.StencilOpSeparate(ctx, GL_BACK, fail, zfail, zpass); + } } else { - /* - * Perform depth buffering, then apply zpass or zfail stencil function. - */ - GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH]; - GLuint i; - - /* init pass and fail masks to zero, copy mask[] to oldmask[] */ - for (i=0;iDriver.DepthTestSpan) - (*ctx->Driver.DepthTestSpan)( ctx, n, x, y, z, mask ); - - /* set the stencil pass/fail flags according to result of depth test */ - for (i=0;iStencil.ZFailFunc[0] == zfail && + ctx->Stencil.ZFailFunc[1] == zfail && + ctx->Stencil.ZPassFunc[0] == zpass && + ctx->Stencil.ZPassFunc[1] == zpass && + ctx->Stencil.FailFunc[0] == fail && + ctx->Stencil.FailFunc[1] == fail) + return; + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.ZFailFunc[0] = ctx->Stencil.ZFailFunc[1] = zfail; + ctx->Stencil.ZPassFunc[0] = ctx->Stencil.ZPassFunc[1] = zpass; + ctx->Stencil.FailFunc[0] = ctx->Stencil.FailFunc[1] = fail; + if (ctx->Driver.StencilOpSeparate) { + ctx->Driver.StencilOpSeparate(ctx, + ((ctx->Stencil.TestTwoSide) + ? GL_FRONT : GL_FRONT_AND_BACK), + fail, zfail, zpass); } - - /* apply the pass and fail operations */ - apply_stencil_op_to_span( ctx, n, x, y, ctx->Stencil.ZFailFunc, failmask ); - apply_stencil_op_to_span( ctx, n, x, y, ctx->Stencil.ZPassFunc, passmask ); } } - -/* - * Apply the given stencil operator for each pixel in the array whose - * mask flag is set. - * Input: n - number of pixels in the span - * x, y - array of [n] pixels - * operator - the stencil buffer operator - * mask - array [n] of flag: 1=apply operator, 0=don't apply operator - */ -static void apply_stencil_op_to_pixels( GLcontext *ctx, - GLuint n, const GLint x[], - const GLint y[], - GLenum oper, GLubyte mask[] ) +#if _HAVE_FULL_GL +/* GL_EXT_stencil_two_side */ +void GLAPIENTRY +_mesa_ActiveStencilFaceEXT(GLenum face) { - GLuint i; - GLstencil ref; - GLstencil wrtmask, invmask; - - wrtmask = ctx->Stencil.WriteMask; - invmask = ~ctx->Stencil.WriteMask; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); - ref = ctx->Stencil.Ref; + if (!ctx->Extensions.EXT_stencil_two_side) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glActiveStencilFaceEXT"); + return; + } - switch (oper) { - case GL_KEEP: - /* do nothing */ - break; - case GL_ZERO: - if (invmask==0) { - for (i=0;i0) { - *sptr = *sptr - 1; - } - } - } - } - else { - for (i=0;i0) { - *sptr = (invmask & *sptr) | (wrtmask & (*sptr-1)); - } - } - } - } - break; - case GL_INCR_WRAP_EXT: - if (invmask==0) { - for (i=0;iStencil.ActiveFace = (face == GL_FRONT) ? 0 : 2; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glActiveStencilFaceEXT(face)"); } } +#endif -/* - * Apply stencil test to an array of pixels before depth buffering. - * Input: n - number of pixels in the span - * x, y - array of [n] pixels to stencil - * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel - * Output: mask - pixels which fail the stencil test will have their - * mask flag set to 0. - * Return: 0 = all pixels failed, 1 = zero or more pixels passed. +/** + * OpenGL 2.0 function. + * \todo Make StencilOp() call this function. And eventually remove the + * ctx->Driver.StencilOp function and use ctx->Driver.StencilOpSeparate + * instead. */ -GLint gl_stencil_pixels( GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLubyte mask[] ) +void GLAPIENTRY +_mesa_StencilOpSeparate(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass) { - GLubyte fail[PB_SIZE]; - GLstencil r, s; - GLuint i; - GLint allfail = 0; - - /* - * Perform stencil test. The results of this operation are stored - * in the fail[] array: - * IF fail[i] is non-zero THEN - * the stencil fail operator is to be applied - * ELSE - * the stencil fail operator is not to be applied - * ENDIF - */ + GLboolean set = GL_FALSE; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); - switch (ctx->Stencil.Function) { - case GL_NEVER: - /* always fail */ - for (i=0;iStencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r < s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_LEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r <= s) { - /* pass */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_GREATER: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r > s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_GEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r >= s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_EQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r == s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_NOTEQUAL: - r = ctx->Stencil.Ref & ctx->Stencil.ValueMask; - for (i=0;iStencil.ValueMask; - if (r != s) { - /* passed */ - fail[i] = 0; - } - else { - fail[i] = 1; - mask[i] = 0; - } - } - else { - fail[i] = 0; - } - } - break; - case GL_ALWAYS: - /* always pass */ - for (i=0;iStencil.FailFunc, fail ); - - return (allfail) ? 0 : 1; -} - - - - -/* - * Apply the combination depth-buffer/stencil operator to a span of pixels. - * Input: n - number of pixels in the span - * x, y - array of [n] pixels to stencil - * z - array [n] of z values - * Input: mask - array [n] of flags (1=test this pixel, 0=skip the pixel) - * Output: mask - array [n] of flags (1=depth test passed, 0=failed) - */ -void gl_depth_stencil_pixels( GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ) -{ - if (ctx->Depth.Test==GL_FALSE) { - /* - * No depth buffer, just apply zpass stencil function to active pixels. - */ - apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.ZPassFunc, mask ); + if (!validate_stencil_op(ctx, zfail)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zfail)"); + return; + } + if (!validate_stencil_op(ctx, zpass)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zpass)"); + return; + } + if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(face)"); + return; } - else { - /* - * Perform depth buffering, then apply zpass or zfail stencil function. - */ - GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE]; - GLuint i; - /* init pass and fail masks to zero */ - for (i=0;iStencil.ZFailFunc[0] != zfail || + ctx->Stencil.ZPassFunc[0] != zpass || + ctx->Stencil.FailFunc[0] != sfail){ + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.ZFailFunc[0] = zfail; + ctx->Stencil.ZPassFunc[0] = zpass; + ctx->Stencil.FailFunc[0] = sfail; + set = GL_TRUE; } - - /* apply the depth test */ - if (ctx->Driver.DepthTestPixels) - (*ctx->Driver.DepthTestPixels)( ctx, n, x, y, z, mask ); - - /* set the stencil pass/fail flags according to result of depth test */ - for (i=0;iStencil.ZFailFunc[1] != zfail || + ctx->Stencil.ZPassFunc[1] != zpass || + ctx->Stencil.FailFunc[1] != sfail) { + FLUSH_VERTICES(ctx, _NEW_STENCIL); + ctx->Stencil.ZFailFunc[1] = zfail; + ctx->Stencil.ZPassFunc[1] = zpass; + ctx->Stencil.FailFunc[1] = sfail; + set = GL_TRUE; } - - /* apply the pass and fail operations */ - apply_stencil_op_to_pixels( ctx, n, x, y, - ctx->Stencil.ZFailFunc, failmask ); - apply_stencil_op_to_pixels( ctx, n, x, y, - ctx->Stencil.ZPassFunc, passmask ); } - + if (set && ctx->Driver.StencilOpSeparate) { + ctx->Driver.StencilOpSeparate(ctx, face, sfail, zfail, zpass); + } } - -/* - * Return a span of stencil values from the stencil buffer. - * Input: n - how many pixels - * x,y - location of first pixel - * Output: stencil - the array of stencil values - */ -void gl_read_stencil_span( GLcontext *ctx, - GLuint n, GLint x, GLint y, GLstencil stencil[] ) +/* OpenGL 2.0 */ +void GLAPIENTRY +_mesa_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { - if (ctx->Buffer->Stencil) { - const GLstencil *s = STENCIL_ADDRESS( x, y ); -#if STENCIL_BITS == 8 - MEMCPY( stencil, s, n * sizeof(GLstencil) ); -#else - GLuint i; - for (i=0;iDrawBuffer->Visual.stencilBits) - 1; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(face)"); + return; + } + if (!validate_stencil_func(ctx, func)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(func)"); + return; } -} + ref = CLAMP(ref, 0, stencilMax); + FLUSH_VERTICES(ctx, _NEW_STENCIL); -/* - * Write a span of stencil values to the stencil buffer. - * Input: n - how many pixels - * x,y - location of first pixel - * stencil - the array of stencil values - */ -void gl_write_stencil_span( GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLstencil stencil[] ) -{ - if (ctx->Buffer->Stencil) { - GLstencil *s = STENCIL_ADDRESS( x, y ); -#if STENCIL_BITS == 8 - MEMCPY( s, stencil, n * sizeof(GLstencil) ); -#else - GLuint i; - for (i=0;iStencil.Function[0] = func; + ctx->Stencil.Ref[0] = ref; + ctx->Stencil.ValueMask[0] = mask; + } + if (face != GL_FRONT) { + /* set back */ + ctx->Stencil.Function[1] = func; + ctx->Stencil.Ref[1] = ref; + ctx->Stencil.ValueMask[1] = mask; + } + if (ctx->Driver.StencilFuncSeparate) { + ctx->Driver.StencilFuncSeparate(ctx, face, func, ref, mask); } } - -/* - * Allocate a new stencil buffer. If there's an old one it will be - * deallocated first. The new stencil buffer will be uninitialized. - */ -void gl_alloc_stencil_buffer( GLcontext *ctx ) +/* OpenGL 2.0 */ +void GLAPIENTRY +_mesa_StencilMaskSeparate(GLenum face, GLuint mask) { - GLuint buffersize = ctx->Buffer->Width * ctx->Buffer->Height; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); - /* deallocate current stencil buffer if present */ - if (ctx->Buffer->Stencil) { - FREE(ctx->Buffer->Stencil); - ctx->Buffer->Stencil = NULL; + if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) { + _mesa_error(ctx, GL_INVALID_ENUM, "glStencilaMaskSeparate(face)"); + return; } - /* allocate new stencil buffer */ - ctx->Buffer->Stencil = (GLstencil *) MALLOC(buffersize * sizeof(GLstencil)); - if (!ctx->Buffer->Stencil) { - /* out of memory */ - gl_set_enable( ctx, GL_STENCIL_TEST, GL_FALSE ); - gl_error( ctx, GL_OUT_OF_MEMORY, "gl_alloc_stencil_buffer" ); + FLUSH_VERTICES(ctx, _NEW_STENCIL); + + if (face != GL_BACK) { + ctx->Stencil.WriteMask[0] = mask; + } + if (face != GL_FRONT) { + ctx->Stencil.WriteMask[1] = mask; + } + if (ctx->Driver.StencilMaskSeparate) { + ctx->Driver.StencilMaskSeparate(ctx, face, mask); } } +/** + * Update derived stencil state. + */ +void +_mesa_update_stencil(GLcontext *ctx) +{ + const GLint face = ctx->Stencil._BackFace; + + ctx->Stencil._Enabled = (ctx->Stencil.Enabled && + ctx->DrawBuffer->Visual.stencilBits > 0); + + ctx->Stencil._TestTwoSide = + ctx->Stencil._Enabled && + (ctx->Stencil.Function[0] != ctx->Stencil.Function[face] || + ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[face] || + ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[face] || + ctx->Stencil.ZFailFunc[0] != ctx->Stencil.ZFailFunc[face] || + ctx->Stencil.Ref[0] != ctx->Stencil.Ref[face] || + ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[face] || + ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[face]); +} -/* - * Clear the stencil buffer. If the stencil buffer doesn't exist yet we'll - * allocate it now. +/** + * Initialize the context stipple state. + * + * \param ctx GL context. + * + * Initializes __GLcontextRec::Stencil attribute group. */ -void gl_clear_stencil_buffer( GLcontext *ctx ) +void +_mesa_init_stencil(GLcontext *ctx) { - if (ctx->Visual->StencilBits==0 || !ctx->Buffer->Stencil) { - /* no stencil buffer */ - return; - } - - if (ctx->Scissor.Enabled) { - /* clear scissor region only */ - GLint y; - GLint width = ctx->Buffer->Xmax - ctx->Buffer->Xmin + 1; - for (y=ctx->Buffer->Ymin; y<=ctx->Buffer->Ymax; y++) { - GLstencil *ptr = STENCIL_ADDRESS( ctx->Buffer->Xmin, y ); -#if STENCIL_BITS==8 - MEMSET( ptr, ctx->Stencil.Clear, width * sizeof(GLstencil) ); -#else - GLint x; - for (x = 0; x < width; x++) - ptr[x] = ctx->Stencil.Clear; -#endif - } - } - else { - /* clear whole stencil buffer */ -#if STENCIL_BITS==8 - MEMSET( ctx->Buffer->Stencil, ctx->Stencil.Clear, - ctx->Buffer->Width * ctx->Buffer->Height * sizeof(GLstencil) ); -#else - GLuint i; - GLuint pixels = ctx->Buffer->Width * ctx->Buffer->Height; - GLstencil *buffer = ctx->Buffer->Stencil; - for (i = 0; i < pixels; i++) - ptr[i] = ctx->Stencil.Clear; -#endif - } + ctx->Stencil.Enabled = GL_FALSE; + ctx->Stencil.TestTwoSide = GL_FALSE; + ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 2 = GL_BACK */ + ctx->Stencil.Function[0] = GL_ALWAYS; + ctx->Stencil.Function[1] = GL_ALWAYS; + ctx->Stencil.Function[2] = GL_ALWAYS; + ctx->Stencil.FailFunc[0] = GL_KEEP; + ctx->Stencil.FailFunc[1] = GL_KEEP; + ctx->Stencil.FailFunc[2] = GL_KEEP; + ctx->Stencil.ZPassFunc[0] = GL_KEEP; + ctx->Stencil.ZPassFunc[1] = GL_KEEP; + ctx->Stencil.ZPassFunc[2] = GL_KEEP; + ctx->Stencil.ZFailFunc[0] = GL_KEEP; + ctx->Stencil.ZFailFunc[1] = GL_KEEP; + ctx->Stencil.ZFailFunc[2] = GL_KEEP; + ctx->Stencil.Ref[0] = 0; + ctx->Stencil.Ref[1] = 0; + ctx->Stencil.Ref[2] = 0; + ctx->Stencil.ValueMask[0] = ~0U; + ctx->Stencil.ValueMask[1] = ~0U; + ctx->Stencil.ValueMask[2] = ~0U; + ctx->Stencil.WriteMask[0] = ~0U; + ctx->Stencil.WriteMask[1] = ~0U; + ctx->Stencil.WriteMask[2] = ~0U; + ctx->Stencil.Clear = 0; + ctx->Stencil._BackFace = 1; }