stencil.c File Reference

#include <stdlib.h>
#include <string.h>
#include "context.h"
#include "dlist.h"
#include "macros.h"
#include "pb.h"
#include "stencil.h"
#include "types.h"

Include dependency graph for stencil.c:

Go to the source code of this file.

Macros
#define	STENCIL_ADDRESS(X, Y)   (ctx->Buffer->Stencil + ctx->Buffer->Width * (Y) + (X))

Functions
void	gl_ClearStencil (GLcontext *ctx, GLint s)
void	gl_StencilFunc (GLcontext *ctx, GLenum func, GLint ref, GLuint mask)
void	gl_StencilMask (GLcontext *ctx, GLuint mask)
void	gl_StencilOp (GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass)
static void	apply_stencil_op_to_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLenum oper, GLubyte mask[])
GLint	gl_stencil_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte mask[])
void	gl_depth_stencil_span (GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], GLubyte mask[])
static void	apply_stencil_op_to_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLenum oper, GLubyte mask[])
GLint	gl_stencil_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte mask[])
void	gl_depth_stencil_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLdepth z[], GLubyte mask[])
void	gl_read_stencil_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte stencil[])
void	gl_write_stencil_span (GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte stencil[])
void	gl_alloc_stencil_buffer (GLcontext *ctx)
void	gl_clear_stencil_buffer (GLcontext *ctx)

Macro Definition Documentation

STENCIL_ADDRESS

#define STENCIL_ADDRESS	(		X,
			Y
	)		(ctx->Buffer->Stencil + ctx->Buffer->Width * (Y) + (X))

Definition at line 70 of file stencil.c.

Function Documentation

apply_stencil_op_to_pixels()

static void apply_stencil_op_to_pixels ( GLcontext *  ctx, GLuint  n, const GLint  x[], const GLint  y[], GLenum  oper, GLubyte  mask[]  )

static

Definition at line 570 of file stencil.c.

{
   GLint i;
   GLstencil ref;
   GLstencil wrtmask, invmask;
 
   wrtmask = ctx->Stencil.WriteMask;
   invmask = ~ctx->Stencil.WriteMask;
 
   ref = ctx->Stencil.Ref;
 
   switch (oper) {
      case GL_KEEP:
         /* do nothing */
         break;
      case GL_ZERO:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
                  *sptr = 0;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          *sptr = invmask & *sptr;
           }
        }
     }
     break;
      case GL_REPLACE:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
                  *sptr = ref;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          *sptr = (invmask & *sptr ) | (wrtmask & ref);
           }
        }
     }
     break;
      case GL_INCR:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          if (*sptr < 0xff) {
             *sptr = *sptr + 1;
          }
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          if (*sptr<0xff) {
             *sptr = (invmask & *sptr) | (wrtmask & (*sptr+1));
          }
           }
        }
     }
     break;
      case GL_DECR:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          if (*sptr>0) {
             *sptr = *sptr - 1;
          }
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
          if (*sptr>0) {
             *sptr = (invmask & *sptr) | (wrtmask & (*sptr-1));
          }
           }
        }
     }
     break;
      case GL_INVERT:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
                  *sptr = ~*sptr;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
                  *sptr = (invmask & *sptr) | (wrtmask & ~*sptr);
           }
        }
     }
     break;
      default:
         gl_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
   }
}

Referenced by gl_depth_stencil_pixels(), and gl_stencil_pixels().

apply_stencil_op_to_span()

static void apply_stencil_op_to_span ( GLcontext *  ctx, GLuint  n, GLint  x, GLint  y, GLenum  oper, GLubyte  mask[]  )

static

Definition at line 207 of file stencil.c.

{
   GLint i;
   GLstencil s, ref;
   GLstencil wrtmask, invmask;
   GLstencil *stencil;
 
   wrtmask = ctx->Stencil.WriteMask;
   invmask = ~ctx->Stencil.WriteMask;
   ref = ctx->Stencil.Ref;
   stencil = STENCIL_ADDRESS( x, y );
 
   switch (oper) {
      case GL_KEEP:
         /* do nothing */
         break;
      case GL_ZERO:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          stencil[i] = 0;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          stencil[i] = stencil[i] & invmask;
           }
        }
     }
     break;
      case GL_REPLACE:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
                  stencil[i] = ref;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          s = stencil[i];
          stencil[i] = (invmask & s ) | (wrtmask & ref);
           }
        }
     }
     break;
      case GL_INCR:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          s = stencil[i];
          if (s<0xff) {
             stencil[i] = s+1;
          }
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          /* VERIFY logic of adding 1 to a write-masked value */
          s = stencil[i];
          if (s<0xff) {
             stencil[i] = (invmask & s) | (wrtmask & (s+1));
          }
           }
        }
     }
     break;
      case GL_DECR:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          s = stencil[i];
          if (s>0) {
             stencil[i] = s-1;
          }
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          /* VERIFY logic of subtracting 1 to a write-masked value */
          s = stencil[i];
          if (s>0) {
             stencil[i] = (invmask & s) | (wrtmask & (s-1));
          }
           }
        }
     }
     break;
      case GL_INVERT:
     if (invmask==0) {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          s = stencil[i];
          stencil[i] = ~s;
           }
        }
     }
     else {
        for (i=0;i<n;i++) {
           if (mask[i]) {
          s = stencil[i];
          stencil[i] = (invmask & s) | (wrtmask & ~s);
           }
        }
     }
     break;
      default:
         gl_problem(ctx, "Bad stencilop in apply_stencil_op_to_span");
   }
}

Referenced by gl_depth_stencil_span(), and gl_stencil_span().

gl_alloc_stencil_buffer()

void gl_alloc_stencil_buffer

(

GLcontext *

ctx

)

Definition at line 975 of file stencil.c.

{
   GLuint buffersize = ctx->Buffer->Width * ctx->Buffer->Height;
 
   /* deallocate current stencil buffer if present */
   if (ctx->Buffer->Stencil) {
      free(ctx->Buffer->Stencil);
      ctx->Buffer->Stencil = NULL;
   }
 
   /* allocate new stencil buffer */
   ctx->Buffer->Stencil = (GLstencil *) malloc(buffersize * sizeof(GLstencil));
   if (!ctx->Buffer->Stencil) {
      /* out of memory */
      ctx->Stencil.Enabled = GL_FALSE;
      gl_error( ctx, GL_OUT_OF_MEMORY, "gl_alloc_stencil_buffer" );
   }
}

Referenced by gl_ResizeBuffersMESA().

gl_clear_stencil_buffer()

void gl_clear_stencil_buffer

(

GLcontext *

ctx

)

Definition at line 1001 of file stencil.c.

{
   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 );
         MEMSET( ptr, ctx->Stencil.Clear, width * sizeof(GLstencil) );
      }
   }
   else {
      /* clear whole stencil buffer */
      MEMSET( ctx->Buffer->Stencil, ctx->Stencil.Clear,
              ctx->Buffer->Width * ctx->Buffer->Height * sizeof(GLstencil) );
   }
}

Referenced by gl_Clear().

gl_ClearStencil()

void gl_ClearStencil	(	GLcontext *	ctx,
		GLint	s
	)

Definition at line 73 of file stencil.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glClearStencil" );
      return;
   }
   ctx->Stencil.Clear = (GLstencil) s;
}

Referenced by execute_list(), and init_exec_pointers().

gl_depth_stencil_pixels()

void gl_depth_stencil_pixels	(	GLcontext *	ctx,
		GLuint	n,
		const GLint	x[],
		const GLint	y[],
		const GLdepth	z[],
		GLubyte	mask[]
	)

Definition at line 882 of file stencil.c.

{
   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 );
   }
   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;i<n;i++) {
     passmask[i] = failmask[i] = 0;
         oldmask[i] = mask[i];
      }
 
      /* 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;i<n;i++) {
         if (oldmask[i]) {
            if (mask[i]) {
               passmask[i] = 1;
            }
            else {
               failmask[i] = 1;
            }
         }
      }
 
      /* 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 );
   }
 
}

Referenced by gl_flush_pb().

gl_depth_stencil_span()

void gl_depth_stencil_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		const GLdepth	z[],
		GLubyte	mask[]
	)

Definition at line 514 of file stencil.c.

{
   if (ctx->Depth.Test==GL_FALSE) {
      /*
       * No depth buffer, just apply zpass stencil function to active pixels.
       */
      apply_stencil_op_to_span( ctx, n, x, y, ctx->Stencil.ZPassFunc, mask );
   }
   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;i<n;i++) {
     passmask[i] = failmask[i] = 0;
         oldmask[i] = mask[i];
      }
 
      /* apply the depth test */
      if (ctx->Driver.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;i<n;i++) {
         if (oldmask[i]) {
            if (mask[i]) {
               passmask[i] = 1;
            }
            else {
               failmask[i] = 1;
            }
         }
      }
 
      /* 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 );
   }
}

Referenced by gl_write_color_span(), gl_write_index_span(), gl_write_monocolor_span(), gl_write_monoindex_span(), and gl_write_texture_span().

gl_read_stencil_span()

void gl_read_stencil_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		GLubyte	stencil[]
	)

Definition at line 938 of file stencil.c.

{
   GLstencil *s;
 
   if (ctx->Buffer->Stencil) {
      s = STENCIL_ADDRESS( x, y );
      MEMCPY( stencil, s, n * sizeof(GLubyte) );
   }
}

Referenced by copy_stencil_pixels(), and read_stencil_pixels().

gl_stencil_pixels()

GLint gl_stencil_pixels	(	GLcontext *	ctx,
		GLuint	n,
		const GLint	x[],
		const GLint	y[],
		GLubyte	mask[]
	)

Definition at line 702 of file stencil.c.

{
   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
    */
 
   switch (ctx->Stencil.Function) {
      case GL_NEVER:
         /* always fail */
         for (i=0;i<n;i++) {
        if (mask[i]) {
           mask[i] = 0;
           fail[i] = 1;
        }
        else {
           fail[i] = 0;
        }
     }
     allfail = 1;
     break;
      case GL_LESS:
     r = ctx->Stencil.Ref & ctx->Stencil.ValueMask;
     for (i=0;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
           s = *sptr & ctx->Stencil.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;i<n;i++) {
        fail[i] = 0;
     }
     break;
      default:
         gl_problem(ctx, "Bad stencil func in gl_stencil_pixels");
         return 0;
   }
 
   apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
 
   return (allfail) ? 0 : 1;
}

Referenced by gl_flush_pb().

gl_stencil_span()

GLint gl_stencil_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		GLubyte	mask[]
	)

Definition at line 339 of file stencil.c.

{
   GLubyte fail[MAX_WIDTH];
   GLint allfail = 0;
   GLuint i;
   GLstencil r, s;
   GLstencil *stencil;
 
   stencil = STENCIL_ADDRESS( x, y );
 
   /*
    * 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;i<n;i++) {
        if (mask[i]) {
           mask[i] = 0;
           fail[i] = 1;
        }
        else {
           fail[i] = 0;
        }
     }
     allfail = 1;
     break;
      case GL_LESS:
     r = ctx->Stencil.Ref & ctx->Stencil.ValueMask;
     for (i=0;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        if (mask[i]) {
           s = stencil[i] & ctx->Stencil.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;i<n;i++) {
        fail[i] = 0;
     }
     break;
      default:
         gl_problem(ctx, "Bad stencil func in gl_stencil_span");
         return 0;
   }
 
   apply_stencil_op_to_span( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
 
   return (allfail) ? 0 : 1;
}

Referenced by gl_write_color_span(), gl_write_index_span(), gl_write_monocolor_span(), gl_write_monoindex_span(), and gl_write_texture_span().

gl_StencilFunc()

void gl_StencilFunc	(	GLcontext *	ctx,
		GLenum	func,
		GLint	ref,
		GLuint	mask
	)

Definition at line 84 of file stencil.c.

{
   GLint maxref;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glStencilFunc" );
      return;
   }
 
   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;
   }
 
   maxref = (1 << STENCIL_BITS) - 1;
   ctx->Stencil.Ref = CLAMP( ref, 0, maxref );
   ctx->Stencil.ValueMask = mask;
}

Referenced by execute_list(), and init_exec_pointers().

gl_StencilMask()

void gl_StencilMask	(	GLcontext *	ctx,
		GLuint	mask
	)

Definition at line 116 of file stencil.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glStencilMask" );
      return;
   }
   ctx->Stencil.WriteMask = (GLstencil) mask;
}

Referenced by execute_list(), and init_exec_pointers().

gl_StencilOp()

void gl_StencilOp	(	GLcontext *	ctx,
		GLenum	fail,
		GLenum	zfail,
		GLenum	zpass
	)

Definition at line 127 of file stencil.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glStencilOp" );
      return;
   }
   switch (fail) {
      case GL_KEEP:
      case GL_ZERO:
      case GL_REPLACE:
      case GL_INCR:
      case GL_DECR:
      case GL_INVERT:
         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:
         ctx->Stencil.ZFailFunc = zfail;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" );
         return;
   }
   switch (zpass) {
      case GL_KEEP:
      case GL_ZERO:
      case GL_REPLACE:
      case GL_INCR:
      case GL_DECR:
      case GL_INVERT:
         ctx->Stencil.ZPassFunc = zpass;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" );
         return;
   }
}

Referenced by execute_list(), and init_exec_pointers().

gl_write_stencil_span()

void gl_write_stencil_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		const GLubyte	stencil[]
	)

Definition at line 957 of file stencil.c.

{
   GLstencil *s;
 
   if (ctx->Buffer->Stencil) {
      s = STENCIL_ADDRESS( x, y );
      MEMCPY( s, stencil, n * sizeof(GLubyte) );
   }
}

Referenced by copy_stencil_pixels(), draw_stencil_pixels(), and gl_write_zoomed_stencil_span().