X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_stencil.c;h=dd438e8dcbae6c98233b79956abd56ad8425ba90;hb=612fc012934d9ec61972c3cfd914923937339611;hp=2b7bb91f73664a4e062cd04f39346186115a0b99;hpb=709892459922a32096fe9dd8261d0d92337bb02f;p=mesa.git diff --git a/src/mesa/swrast/s_stencil.c b/src/mesa/swrast/s_stencil.c index 2b7bb91f736..dd438e8dcba 100644 --- a/src/mesa/swrast/s_stencil.c +++ b/src/mesa/swrast/s_stencil.c @@ -1,10 +1,10 @@ -/* $Id: s_stencil.c,v 1.11 2001/03/19 02:25:36 keithw Exp $ */ +/* $Id: s_stencil.c,v 1.20 2002/02/04 15:59:30 brianp Exp $ */ /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 4.1 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2002 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"), @@ -32,13 +32,10 @@ #include "s_context.h" #include "s_depth.h" -#include "s_pb.h" #include "s_stencil.h" - - /* Stencil Logic: IF stencil test fails THEN @@ -55,8 +52,6 @@ ENDIF */ - - /* * Return the address of a stencil buffer value given the window coords: */ @@ -65,7 +60,7 @@ ENDIF -/* +/** * Apply the given stencil operator to the array of stencil values. * Don't touch stencil[i] if mask[i] is zero. * Input: n - size of stencil array @@ -74,9 +69,9 @@ ENDIF * mask - array [n] of flag: 1=apply operator, 0=don't apply operator * Output: stencil - modified values */ -static void apply_stencil_op( const GLcontext *ctx, GLenum oper, - GLuint n, GLstencil stencil[], - const GLubyte mask[] ) +static void +apply_stencil_op( const GLcontext *ctx, GLenum oper, + GLuint n, GLstencil stencil[], const GLubyte mask[] ) { const GLstencil ref = ctx->Stencil.Ref; const GLstencil wrtmask = ctx->Stencil.WriteMask; @@ -226,7 +221,7 @@ static void apply_stencil_op( const GLcontext *ctx, GLenum oper, -/* +/** * Apply stencil test to an array of stencil values (before depth buffering). * Input: n - number of pixels in the array * stencil - array of [n] stencil values @@ -240,12 +235,12 @@ static GLboolean do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[], GLubyte mask[] ) { - GLubyte fail[PB_SIZE]; + GLubyte fail[MAX_WIDTH]; GLboolean allfail = GL_FALSE; GLuint i; GLstencil r, s; - ASSERT(n <= PB_SIZE); + ASSERT(n <= MAX_WIDTH); /* * Perform stencil test. The results of this operation are stored @@ -258,7 +253,7 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[], */ switch (ctx->Stencil.Function) { case GL_NEVER: - /* always fail */ + /* never pass; always fail */ for (i=0;iStencil.Enabled); - ASSERT(n <= PB_SIZE); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GLstencil stencilRow[MAX_WIDTH]; + GLstencil *stencil; + const GLuint n = span->end; + const GLint x = span->x; + const GLint y = span->y; + GLubyte *mask = span->mask; + ASSERT((span->arrayMask & SPAN_XY) == 0); + ASSERT(ctx->Stencil.Enabled); + ASSERT(n <= MAX_WIDTH); +#ifdef DEBUG + if (ctx->Depth.Test) { + ASSERT(span->arrayMask & SPAN_Z); + } +#endif + + /* Get initial stencil values */ + if (swrast->Driver.WriteStencilSpan) { + /* Get stencil values from the hardware stencil buffer */ + ASSERT(swrast->Driver.ReadStencilSpan); + (*swrast->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow); + stencil = stencilRow; + } + else { + /* Get pointer into software stencil buffer */ + stencil = STENCIL_ADDRESS(x, y); + } + /* * Apply the stencil test to the fragments. * failMask[i] is 1 if the stencil test failed. */ if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) { /* all fragments failed the stencil test, we're done. */ + span->writeAll = GL_FALSE; return GL_FALSE; } - /* * Some fragments passed the stencil test, apply depth test to them * and apply Zpass and Zfail stencil ops. */ - if (ctx->Depth.Test==GL_FALSE) { + if (ctx->Depth.Test == GL_FALSE) { /* * No depth buffer, just apply zpass stencil function to active pixels. */ @@ -457,7 +474,7 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y, MEMCPY(oldmask, mask, n * sizeof(GLubyte)); /* apply the depth test */ - _mesa_depth_test_span(ctx, n, x, y, z, mask); + _mesa_depth_test_span(ctx, span); /* Set the stencil pass/fail flags according to result of depth testing. * if oldmask[i] == 0 then @@ -484,64 +501,26 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y, } } - return GL_TRUE; /* one or more fragments passed both tests */ -} - - - -/* - * Apply stencil and depth testing to the span of pixels. - * Both software and hardware stencil buffers are acceptable. - * Input: n - number of pixels in the span - * x, y - location of leftmost pixel in span - * z - array [n] of z values - * mask - array [n] of flags (1=test this pixel, 0=skip the pixel) - * Output: mask - array [n] of flags (1=stencil and depth test passed) - * Return: GL_TRUE - all fragments failed the testing - * GL_FALSE - one or more fragments passed the testing - * - */ -GLboolean -_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y, - const GLdepth z[], GLubyte mask[] ) -{ - SWcontext *swrast = SWRAST_CONTEXT(ctx); - GLstencil stencilRow[MAX_WIDTH]; - GLstencil *stencil; - GLboolean result; - - ASSERT(ctx->Stencil.Enabled); - ASSERT(n <= MAX_WIDTH); - - /* Get initial stencil values */ - if (swrast->Driver.WriteStencilSpan) { - ASSERT(swrast->Driver.ReadStencilSpan); - /* Get stencil values from the hardware stencil buffer */ - (*swrast->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow); - stencil = stencilRow; - } - else { - /* software stencil buffer */ - stencil = STENCIL_ADDRESS(x, y); - } - - /* do all the stencil/depth testing/updating */ - result = stencil_and_ztest_span( ctx, n, x, y, z, stencil, mask ); - + /* + * Write updated stencil values back into hardware stencil buffer. + */ if (swrast->Driver.WriteStencilSpan) { - /* Write updated stencil values into hardware stencil buffer */ + ASSERT(stencil == stencilRow); (swrast->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask ); } - - return result; + + span->writeAll = GL_FALSE; + + return GL_TRUE; /* one or more fragments passed both tests */ } -/* +/** * Apply the given stencil operator for each pixel in the array whose - * mask flag is set. This is for software stencil buffers only. + * mask flag is set. + * \note This is for software stencil buffers only. * Input: n - number of pixels in the span * x, y - array of [n] pixels * operator - the stencil buffer operator @@ -704,26 +683,30 @@ apply_stencil_op_to_pixels( const GLcontext *ctx, -/* +/** * Apply stencil test to an array of pixels before depth buffering. - * Used for software stencil buffer only. + * + * \note Used for software stencil buffer only. * 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. + * \return GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed. */ static GLboolean stencil_test_pixels( GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte mask[] ) { - GLubyte fail[PB_SIZE]; + GLubyte fail[MAX_WIDTH]; GLstencil r, s; GLuint i; GLboolean allfail = GL_FALSE; - ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan); /* software stencil buffer only! */ + /* software stencil buffer only! */ + ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer); + ASSERT(!SWRAST_CONTEXT(ctx)->Driver.ReadStencilSpan); + ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan); /* * Perform stencil test. The results of this operation are stored @@ -890,7 +873,7 @@ stencil_test_pixels( GLcontext *ctx, GLuint n, -/* +/** * Apply stencil and depth testing to an array of pixels. * This is used both for software and hardware stencil buffers. * @@ -903,23 +886,28 @@ stencil_test_pixels( GLcontext *ctx, GLuint n, * z - array [n] of z values * mask - array [n] of flags (1=test this pixel, 0=skip the pixel) * Output: mask - array [n] of flags (1=stencil and depth test passed) - * Return: GL_TRUE - all fragments failed the testing - * GL_FALSE - one or more fragments passed the testing + * Return: GL_FALSE - all fragments failed the testing + * GL_TRUE - one or more fragments passed the testing */ -GLboolean -_mesa_stencil_and_ztest_pixels( GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ) +static GLboolean +stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span ) { + const GLuint n = span->end; + const GLint *x = span->xArray; + const GLint *y = span->yArray; + GLubyte *mask = span->mask; SWcontext *swrast = SWRAST_CONTEXT(ctx); + + ASSERT(span->arrayMask & SPAN_XY); ASSERT(ctx->Stencil.Enabled); - ASSERT(n <= PB_SIZE); + ASSERT(n <= MAX_WIDTH); if (swrast->Driver.WriteStencilPixels) { /*** Hardware stencil buffer ***/ - GLstencil stencil[PB_SIZE]; - GLubyte origMask[PB_SIZE]; + GLstencil stencil[MAX_WIDTH]; + GLubyte origMask[MAX_WIDTH]; + ASSERT(!ctx->DrawBuffer->UseSoftwareStencilBuffer); ASSERT(swrast->Driver.ReadStencilPixels); (*swrast->Driver.ReadStencilPixels)(ctx, n, x, y, stencil); @@ -931,10 +919,10 @@ _mesa_stencil_and_ztest_pixels( GLcontext *ctx, apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, mask); } else { - _mesa_depth_test_pixels(ctx, n, x, y, z, mask); + _mesa_depth_test_span(ctx, span); if (ctx->Stencil.ZFailFunc != GL_KEEP) { - GLubyte failmask[PB_SIZE]; + GLubyte failmask[MAX_WIDTH]; GLuint i; for (i = 0; i < n; i++) { ASSERT(mask[i] == 0 || mask[i] == 1); @@ -944,7 +932,7 @@ _mesa_stencil_and_ztest_pixels( GLcontext *ctx, n, stencil, failmask); } if (ctx->Stencil.ZPassFunc != GL_KEEP) { - GLubyte passmask[PB_SIZE]; + GLubyte passmask[MAX_WIDTH]; GLuint i; for (i = 0; i < n; i++) { ASSERT(mask[i] == 0 || mask[i] == 1); @@ -963,6 +951,8 @@ _mesa_stencil_and_ztest_pixels( GLcontext *ctx, else { /*** Software stencil buffer ***/ + ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer); + if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) { /* all fragments failed the stencil test, we're done. */ return GL_FALSE; @@ -973,12 +963,12 @@ _mesa_stencil_and_ztest_pixels( GLcontext *ctx, ctx->Stencil.ZPassFunc, mask); } else { - GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE]; + GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH]; GLuint i; MEMCPY(oldmask, mask, n * sizeof(GLubyte)); - _mesa_depth_test_pixels(ctx, n, x, y, z, mask); + _mesa_depth_test_span(ctx, span); for (i=0;iarrayMask & SPAN_XY) + return stencil_and_ztest_pixels(ctx, span); + else + return stencil_and_ztest_span(ctx, span); +} -/* + +/** * Return a span of stencil values from the stencil buffer. * Used for glRead/CopyPixels * Input: n - how many pixels @@ -1053,7 +1056,7 @@ _mesa_read_stencil_span( GLcontext *ctx, -/* +/** * Write a span of stencil values to the stencil buffer. * Used for glDraw/CopyPixels * Input: n - how many pixels @@ -1065,6 +1068,8 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y, const GLstencil stencil[] ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); + const GLstencil *ssrc = stencil; + if (y < 0 || y >= ctx->DrawBuffer->Height || x + n <= 0 || x >= ctx->DrawBuffer->Width) { /* span is completely outside framebuffer */ @@ -1075,7 +1080,7 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y, GLint dx = -x; x = 0; n -= dx; - stencil += dx; + ssrc += dx; } if (x + n > ctx->DrawBuffer->Width) { GLint dx = x + n - ctx->DrawBuffer->Width; @@ -1086,23 +1091,23 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y, } if (swrast->Driver.WriteStencilSpan) { - (*swrast->Driver.WriteStencilSpan)( ctx, n, x, y, stencil, NULL ); + (*swrast->Driver.WriteStencilSpan)( ctx, n, x, y, ssrc, NULL ); } else if (ctx->DrawBuffer->Stencil) { GLstencil *s = STENCIL_ADDRESS( x, y ); #if STENCIL_BITS == 8 - MEMCPY( s, stencil, n * sizeof(GLstencil) ); + MEMCPY( s, ssrc, n * sizeof(GLstencil) ); #else GLuint i; for (i=0;iDrawBuffer->Width; - const GLint height = ctx->DrawBuffer->Width; + const GLint height = ctx->DrawBuffer->Height; const GLint x = ctx->DrawBuffer->_Xmin; GLstencil stencil[MAX_WIDTH]; GLint y, i; @@ -1292,8 +1297,8 @@ clear_hardware_stencil_buffer( GLcontext *ctx ) -/* - * Clear the stencil buffer. +/** + * Clear the stencil buffer (hardware or software). */ void _mesa_clear_stencil_buffer( GLcontext *ctx )