KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clean-up and remove dead code related to depth/stecil testing.

This commit is contained in:
Brian Paul 2002-02-04 15:59:29 +00:00
parent ac8c241e64
commit 79c2f53491
4 changed files with 153 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
src/mesa/swrast/s_depth.c
View File

@ -1,4 +1,4 @@
/* $Id: s_depth.c,v 1.15 2002/02/02 21:40:33 brianp Exp $ */ /* $Id: s_depth.c,v 1.16 2002/02/04 15:59:29 brianp Exp $ */
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
@ -34,9 +34,7 @@
#include "s_context.h" #include "s_context.h"
/**
/*
* Return address of depth buffer value for given window coord. * Return address of depth buffer value for given window coord.
*/ */
GLvoid * GLvoid *
@ -532,58 +530,29 @@ depth_test_span32( GLcontext *ctx, GLuint n,
GLuint
_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], GLubyte mask[] )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Driver.ReadDepthSpan) {
/* hardware-based depth buffer */
GLdepth zbuffer[MAX_WIDTH];
GLuint passed;
(*swrast->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
passed = depth_test_span32(ctx, n, zbuffer, z, mask);
assert(swrast->Driver.WriteDepthSpan);
(*swrast->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, mask);
return passed;
}
else {
/* software depth buffer */
if (ctx->Visual.depthBits <= 16) {
GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, x, y);
GLuint passed = depth_test_span16(ctx, n, zptr, z, mask);
return passed;
}
else {
GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, x, y);
GLuint passed = depth_test_span32(ctx, n, zptr, z, mask);
return passed;
}
}
}
/* /*
* Apply depth test to span of fragments. Hardware or software z buffer. * Apply depth test to span of fragments. Hardware or software z buffer.
*/ */
static GLuint static GLuint
depth_test_span( GLcontext *ctx, struct sw_span *span) depth_test_span( GLcontext *ctx, struct sw_span *span)
{ {
const GLint x = span->x;
const GLint y = span->y;
const GLuint n = span->end;
SWcontext *swrast = SWRAST_CONTEXT(ctx); SWcontext *swrast = SWRAST_CONTEXT(ctx);
ASSERT((span->arrayMask & SPAN_XY) == 0);
ASSERT(span->arrayMask & SPAN_Z); ASSERT(span->arrayMask & SPAN_Z);
if (swrast->Driver.ReadDepthSpan) { if (swrast->Driver.ReadDepthSpan) {
/* hardware-based depth buffer */ /* hardware-based depth buffer */
GLdepth zbuffer[MAX_WIDTH]; GLdepth zbuffer[MAX_WIDTH];
GLuint passed; GLuint passed;
(*swrast->Driver.ReadDepthSpan)(ctx, span->end, span->x, span->y, zbuffer); (*swrast->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
passed = depth_test_span32(ctx, span->end, passed = depth_test_span32(ctx, n, zbuffer, span->zArray, span->mask);
zbuffer, span->zArray, span->mask);
ASSERT(swrast->Driver.WriteDepthSpan); ASSERT(swrast->Driver.WriteDepthSpan);
(*swrast->Driver.WriteDepthSpan)(ctx, span->end, span->x, span->y, zbuffer, span->mask); (*swrast->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, span->mask);
if (passed < span->end) if (passed < n)
span->writeAll = GL_FALSE; span->writeAll = GL_FALSE;
return passed; return passed;
} }
@ -591,12 +560,12 @@ depth_test_span( GLcontext *ctx, struct sw_span *span)
GLuint passed; GLuint passed;
/* software depth buffer */ /* software depth buffer */
if (ctx->Visual.depthBits <= 16) { if (ctx->Visual.depthBits <= 16) {
GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, span->x, span->y); GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, x, y);
passed = depth_test_span16(ctx, span->end, zptr, span->zArray, span->mask); passed = depth_test_span16(ctx, n, zptr, span->zArray, span->mask);
} }
else { else {
GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, span->x, span->y); GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, x, y);
passed = depth_test_span32(ctx, span->end, zptr, span->zArray, span->mask); passed = depth_test_span32(ctx, n, zptr, span->zArray, span->mask);
} }
if (passed < span->end) if (passed < span->end)
span->writeAll = GL_FALSE; span->writeAll = GL_FALSE;
@ -1331,12 +1300,18 @@ hardware_depth_test_pixels( GLcontext *ctx, GLuint n, GLdepth zbuffer[],
} }
} }
void
_mesa_depth_test_pixels( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[], static GLuint
const GLdepth z[], GLubyte mask[] ) depth_test_pixels( GLcontext *ctx, struct sw_span *span )
{ {
SWcontext *swrast = SWRAST_CONTEXT(ctx); SWcontext *swrast = SWRAST_CONTEXT(ctx);
const GLuint n = span->end;
const GLint *x = span->xArray;
const GLint *y = span->xArray;
const GLdepth *z = span->zArray;
GLubyte *mask = span->mask;
if (swrast->Driver.ReadDepthPixels) { if (swrast->Driver.ReadDepthPixels) {
/* read depth values from hardware Z buffer */ /* read depth values from hardware Z buffer */
GLdepth zbuffer[MAX_WIDTH]; GLdepth zbuffer[MAX_WIDTH];
@ -1355,22 +1330,21 @@ _mesa_depth_test_pixels( GLcontext *ctx,
else else
software_depth_test_pixels32(ctx, n, x, y, z, mask); software_depth_test_pixels32(ctx, n, x, y, z, mask);
} }
return n; /* not really correct, but OK */
} }
/**
* Apply depth (Z) buffer testing to the span.
* \return approx number of pixels that passed (only zero is reliable)
*/
GLuint GLuint
_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span) _mesa_depth_test_span( GLcontext *ctx, struct sw_span *span)
{ {
if (span->arrayMask & SPAN_XY) { if (span->arrayMask & SPAN_XY)
_mesa_depth_test_pixels(ctx, span->end, return depth_test_pixels(ctx, span);
span->xArray, span->yArray, else
span->zArray, span->mask);
return 1;
}
else {
return depth_test_span(ctx, span); return depth_test_span(ctx, span);
}
} }
@ -1380,7 +1354,7 @@ _mesa_depth_test_span( GLcontext *ctx, struct sw_span *span)
/**********************************************************************/ /**********************************************************************/
/* /**
* Read a span of depth values from the depth buffer. * Read a span of depth values from the depth buffer.
* This function does clipping before calling the device driver function. * This function does clipping before calling the device driver function.
*/ */
@ -1450,7 +1424,7 @@ _mesa_read_depth_span( GLcontext *ctx,
/* /**
* Return a span of depth values from the depth buffer as floats in [0,1]. * Return a span of depth values from the depth buffer as floats in [0,1].
* This is used for both hardware and software depth buffers. * This is used for both hardware and software depth buffers.
* Input: n - how many pixels * Input: n - how many pixels
@ -1533,7 +1507,7 @@ _mesa_read_depth_span_float( GLcontext *ctx,
/* /**
* Allocate a new depth buffer. If there's already a depth buffer allocated * Allocate a new depth buffer. If there's already a depth buffer allocated
* it will be free()'d. The new depth buffer will be uniniitalized. * it will be free()'d. The new depth buffer will be uniniitalized.
* This function is only called through Driver.alloc_depth_buffer. * This function is only called through Driver.alloc_depth_buffer.
@ -1570,9 +1544,7 @@ _mesa_alloc_depth_buffer( GLcontext *ctx )
} }
/**
/*
* Clear the depth buffer. If the depth buffer doesn't exist yet we'll * Clear the depth buffer. If the depth buffer doesn't exist yet we'll
* allocate it now. * allocate it now.
* This function is only called through Driver.clear_depth_buffer. * This function is only called through Driver.clear_depth_buffer.

15
src/mesa/swrast/s_depth.h
View File

@ -1,10 +1,10 @@
/* $Id: s_depth.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */ /* $Id: s_depth.h,v 1.5 2002/02/04 15:59:29 brianp Exp $ */
/* /*
* Mesa 3-D graphics library * 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 * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -37,16 +37,10 @@ extern GLvoid *
_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y); _mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y);
extern GLuint
_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], GLubyte mask[] );
extern GLuint extern GLuint
_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span); _mesa_depth_test_span( GLcontext *ctx, struct sw_span *span);
extern void
_mesa_depth_test_pixels( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLdepth z[], GLubyte mask[] );
extern void extern void
@ -67,5 +61,4 @@ extern void
_mesa_clear_depth_buffer( GLcontext* ctx ); _mesa_clear_depth_buffer( GLcontext* ctx );
#endif #endif

43
src/mesa/swrast/s_span.c
View File

@ -1,4 +1,4 @@
/* $Id: s_span.c,v 1.30 2002/02/02 21:40:33 brianp Exp $ */ /* $Id: s_span.c,v 1.31 2002/02/04 15:59:29 brianp Exp $ */
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
@ -25,12 +25,13 @@
*/ */
/* /**
* pixel span rasterization: * \file vpstate.c
* These functions implement the rasterization pipeline. * \brief Span processing functions used by all rasterization functions.
* This is where all the per-fragment tests are performed
* \author Brian Paul
*/ */
#include "glheader.h" #include "glheader.h"
#include "colormac.h" #include "colormac.h"
#include "context.h" #include "context.h"
@ -50,7 +51,7 @@
#include "s_texture.h" #include "s_texture.h"
/* /**
* Init span's Z interpolation values to the RasterPos Z. * Init span's Z interpolation values to the RasterPos Z.
* Used during setup for glDraw/CopyPixels. * Used during setup for glDraw/CopyPixels.
*/ */
@ -66,7 +67,7 @@ _mesa_span_default_z( GLcontext *ctx, struct sw_span *span )
} }
/* /**
* Init span's fog interpolation values to the RasterPos fog. * Init span's fog interpolation values to the RasterPos fog.
* Used during setup for glDraw/CopyPixels. * Used during setup for glDraw/CopyPixels.
*/ */
@ -82,7 +83,7 @@ _mesa_span_default_fog( GLcontext *ctx, struct sw_span *span )
} }
/* /**
* Init span's color or index interpolation values to the RasterPos color. * Init span's color or index interpolation values to the RasterPos color.
* Used during setup for glDraw/CopyPixels. * Used during setup for glDraw/CopyPixels.
*/ */
@ -382,7 +383,7 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
} }
/* /**
* Apply the current polygon stipple pattern to a span of pixels. * Apply the current polygon stipple pattern to a span of pixels.
*/ */
static void static void
@ -410,7 +411,7 @@ stipple_polygon_span( GLcontext *ctx, struct sw_span *span )
} }
/* /**
* Clip a pixel span to the current buffer/window boundaries: * Clip a pixel span to the current buffer/window boundaries:
* DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax. This will accomplish * DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax. This will accomplish
* window clipping and scissoring. * window clipping and scissoring.
@ -479,7 +480,7 @@ clip_span( GLcontext *ctx, struct sw_span *span )
/* /**
* Draw to more than one color buffer (or none). * Draw to more than one color buffer (or none).
*/ */
static void static void
@ -533,7 +534,7 @@ multi_write_index_span( GLcontext *ctx, struct sw_span *span )
} }
/* /**
* Draw to more than one RGBA color buffer (or none). * Draw to more than one RGBA color buffer (or none).
* All fragment operations, up to (but not) blending/logicop should * All fragment operations, up to (but not) blending/logicop should
* have been done first. * have been done first.
@ -620,7 +621,7 @@ multi_write_rgba_span( GLcontext *ctx, struct sw_span *span )
/* /**
* This function may modify any of the array values in the span. * This function may modify any of the array values in the span.
* span->interpMask and span->arrayMask may be changed but will be restored * span->interpMask and span->arrayMask may be changed but will be restored
* to their original values before returning. * to their original values before returning.
@ -679,14 +680,14 @@ _mesa_write_index_span( GLcontext *ctx, struct sw_span *span,
interpolate_z(ctx, span); interpolate_z(ctx, span);
if (ctx->Stencil.Enabled) { if (ctx->Stencil.Enabled) {
if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE) { if (!_mesa_stencil_and_ztest_span(ctx, span)) {
span->arrayMask = origArrayMask; span->arrayMask = origArrayMask;
return; return;
} }
} }
else { else {
ASSERT(ctx->Depth.Test); ASSERT(ctx->Depth.Test);
if (_mesa_depth_test_span(ctx, span) == 0) { if (!_mesa_depth_test_span(ctx, span)) {
span->arrayMask = origArrayMask; span->arrayMask = origArrayMask;
return; return;
} }
@ -782,7 +783,7 @@ _mesa_write_index_span( GLcontext *ctx, struct sw_span *span,
} }
/* /**
* This function may modify any of the array values in the span. * This function may modify any of the array values in the span.
* span->interpMask and span->arrayMask may be changed but will be restored * span->interpMask and span->arrayMask may be changed but will be restored
* to their original values before returning. * to their original values before returning.
@ -992,7 +993,7 @@ _mesa_write_rgba_span( GLcontext *ctx, struct sw_span *span,
} }
/* /**
* Add specular color to base color. This is used only when * Add specular color to base color. This is used only when
* GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR. * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
*/ */
@ -1018,7 +1019,7 @@ add_colors(GLuint n, GLchan rgba[][4], GLchan specular[][4] )
} }
/* /**
* This function may modify any of the array values in the span. * This function may modify any of the array values in the span.
* span->interpMask and span->arrayMask may be changed but will be restored * span->interpMask and span->arrayMask may be changed but will be restored
* to their original values before returning. * to their original values before returning.
@ -1225,7 +1226,7 @@ _mesa_write_texture_span( GLcontext *ctx, struct sw_span *span,
/* /**
* Read RGBA pixels from frame buffer. Clipping will be done to prevent * Read RGBA pixels from frame buffer. Clipping will be done to prevent
* reading ouside the buffer's boundaries. * reading ouside the buffer's boundaries.
*/ */
@ -1277,9 +1278,7 @@ _mesa_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
} }
/**
/*
* Read CI pixels from frame buffer. Clipping will be done to prevent * Read CI pixels from frame buffer. Clipping will be done to prevent
* reading ouside the buffer's boundaries. * reading ouside the buffer's boundaries.
*/ */

198
src/mesa/swrast/s_stencil.c
View File

@ -1,4 +1,4 @@
/* $Id: s_stencil.c,v 1.19 2002/02/02 21:40:33 brianp Exp $ */ /* $Id: s_stencil.c,v 1.20 2002/02/04 15:59:30 brianp Exp $ */
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
@ -60,7 +60,7 @@ ENDIF
/* /**
* Apply the given stencil operator to the array of stencil values. * Apply the given stencil operator to the array of stencil values.
* Don't touch stencil[i] if mask[i] is zero. * Don't touch stencil[i] if mask[i] is zero.
* Input: n - size of stencil array * Input: n - size of stencil array
@ -69,9 +69,9 @@ ENDIF
* mask - array [n] of flag: 1=apply operator, 0=don't apply operator * mask - array [n] of flag: 1=apply operator, 0=don't apply operator
* Output: stencil - modified values * Output: stencil - modified values
*/ */
static void apply_stencil_op( const GLcontext *ctx, GLenum oper, static void
GLuint n, GLstencil stencil[], apply_stencil_op( const GLcontext *ctx, GLenum oper,
const GLubyte mask[] ) GLuint n, GLstencil stencil[], const GLubyte mask[] )
{ {
const GLstencil ref = ctx->Stencil.Ref; const GLstencil ref = ctx->Stencil.Ref;
const GLstencil wrtmask = ctx->Stencil.WriteMask; const GLstencil wrtmask = ctx->Stencil.WriteMask;
@ -221,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). * Apply stencil test to an array of stencil values (before depth buffering).
* Input: n - number of pixels in the array * Input: n - number of pixels in the array
* stencil - array of [n] stencil values * stencil - array of [n] stencil values
@ -253,7 +253,7 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
*/ */
switch (ctx->Stencil.Function) { switch (ctx->Stencil.Function) {
case GL_NEVER: case GL_NEVER:
/* always fail */ /* never pass; always fail */
for (i=0;i<n;i++) { for (i=0;i<n;i++) {
if (mask[i]) { if (mask[i]) {
mask[i] = 0; mask[i] = 0;
@ -399,43 +399,65 @@ do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
/**
/* * Apply stencil and depth testing to the span of pixels.
* Apply stencil and depth testing to an array of pixels. * Both software and hardware stencil buffers are acceptable.
* Hardware or software stencil buffer acceptable.
* Input: n - number of pixels in the span * Input: n - number of pixels in the span
* x, y - location of leftmost pixel in span
* z - array [n] of z values * z - array [n] of z values
* stencil - array [n] of stencil values
* mask - array [n] of flags (1=test this pixel, 0=skip the pixel) * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
* Output: stencil - modified stencil values * Output: mask - array [n] of flags (1=stencil and depth test passed)
* mask - array [n] of flags (1=stencil and depth test passed) * Return: GL_FALSE - all fragments failed the testing
* Return: GL_TRUE - all fragments failed the testing * GL_TRUE - one or more fragments passed the testing
* GL_FALSE - one or more fragments passed the testing
* *
*/ */
static GLboolean static GLboolean
stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y, stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
const GLdepth z[], GLstencil stencil[],
GLubyte mask[] )
{ {
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(ctx->Stencil.Enabled);
ASSERT(n <= MAX_WIDTH); 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. * Apply the stencil test to the fragments.
* failMask[i] is 1 if the stencil test failed. * failMask[i] is 1 if the stencil test failed.
*/ */
if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) { if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
/* all fragments failed the stencil test, we're done. */ /* all fragments failed the stencil test, we're done. */
span->writeAll = GL_FALSE;
return GL_FALSE; return GL_FALSE;
} }
/* /*
* Some fragments passed the stencil test, apply depth test to them * Some fragments passed the stencil test, apply depth test to them
* and apply Zpass and Zfail stencil ops. * 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. * No depth buffer, just apply zpass stencil function to active pixels.
*/ */
@ -452,7 +474,7 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
MEMCPY(oldmask, mask, n * sizeof(GLubyte)); MEMCPY(oldmask, mask, n * sizeof(GLubyte));
/* apply the depth test */ /* apply the depth test */
_old_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. /* Set the stencil pass/fail flags according to result of depth testing.
* if oldmask[i] == 0 then * if oldmask[i] == 0 then
@ -479,72 +501,26 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
} }
} }
return GL_TRUE; /* one or more fragments passed both tests */ /*
} * Write updated stencil values back into hardware stencil buffer.
*/
/*
* 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
*
*/
static GLboolean
stencil_and_ztest_span2(GLcontext *ctx, struct sw_span *span)
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
GLstencil stencilRow[MAX_WIDTH];
GLstencil *stencil;
GLboolean result;
ASSERT(ctx->Stencil.Enabled);
ASSERT(span->end <= MAX_WIDTH);
#ifdef DEBUG
if (ctx->Depth.Test) {
ASSERT(span->arrayMask & SPAN_Z);
}
#endif
/* Get initial stencil values */
if (swrast->Driver.WriteStencilSpan) { if (swrast->Driver.WriteStencilSpan) {
ASSERT(swrast->Driver.ReadStencilSpan); ASSERT(stencil == stencilRow);
/* Get stencil values from the hardware stencil buffer */ (swrast->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask );
(*swrast->Driver.ReadStencilSpan)(ctx, span->end, span->x, span->y, stencilRow);
stencil = stencilRow;
}
else {
/* software stencil buffer */
stencil = STENCIL_ADDRESS(span->x, span->y);
}
/* do all the stencil/depth testing/updating */
result = stencil_and_ztest_span( ctx, span->end, span->x, span->y,
span->zArray, stencil, span->mask );
if (swrast->Driver.WriteStencilSpan) {
/* Write updated stencil values into hardware stencil buffer */
(swrast->Driver.WriteStencilSpan)(ctx, span->end, span->x,
span->y, stencil, span->mask );
} }
span->writeAll = GL_FALSE; span->writeAll = GL_FALSE;
return result; return GL_TRUE; /* one or more fragments passed both tests */
} }
/* /**
* Apply the given stencil operator for each pixel in the array whose * 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 * Input: n - number of pixels in the span
* x, y - array of [n] pixels * x, y - array of [n] pixels
* operator - the stencil buffer operator * operator - the stencil buffer operator
@ -707,15 +683,16 @@ apply_stencil_op_to_pixels( const GLcontext *ctx,
/* /**
* Apply stencil test to an array of pixels before depth buffering. * 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 * Input: n - number of pixels in the span
* x, y - array of [n] pixels to stencil * x, y - array of [n] pixels to stencil
* mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel
* Output: mask - pixels which fail the stencil test will have their * Output: mask - pixels which fail the stencil test will have their
* mask flag set to 0. * 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 static GLboolean
stencil_test_pixels( GLcontext *ctx, GLuint n, stencil_test_pixels( GLcontext *ctx, GLuint n,
@ -726,7 +703,10 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
GLuint i; GLuint i;
GLboolean allfail = GL_FALSE; 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 * Perform stencil test. The results of this operation are stored
@ -893,7 +873,7 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
/* /**
* Apply stencil and depth testing to an array of pixels. * Apply stencil and depth testing to an array of pixels.
* This is used both for software and hardware stencil buffers. * This is used both for software and hardware stencil buffers.
* *
@ -906,15 +886,19 @@ stencil_test_pixels( GLcontext *ctx, GLuint n,
* z - array [n] of z values * z - array [n] of z values
* mask - array [n] of flags (1=test this pixel, 0=skip the pixel) * 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) * Output: mask - array [n] of flags (1=stencil and depth test passed)
* Return: GL_TRUE - all fragments failed the testing * Return: GL_FALSE - all fragments failed the testing
* GL_FALSE - one or more fragments passed the testing * GL_TRUE - one or more fragments passed the testing
*/ */
static GLboolean static GLboolean
stencil_and_ztest_pixels( GLcontext *ctx, stencil_and_ztest_pixels( GLcontext *ctx, struct sw_span *span )
GLuint n, const GLint x[], const GLint y[],
const GLdepth z[], GLubyte mask[] )
{ {
const GLuint n = span->end;
const GLint *x = span->xArray;
const GLint *y = span->yArray;
GLubyte *mask = span->mask;
SWcontext *swrast = SWRAST_CONTEXT(ctx); SWcontext *swrast = SWRAST_CONTEXT(ctx);
ASSERT(span->arrayMask & SPAN_XY);
ASSERT(ctx->Stencil.Enabled); ASSERT(ctx->Stencil.Enabled);
ASSERT(n <= MAX_WIDTH); ASSERT(n <= MAX_WIDTH);
@ -923,6 +907,7 @@ stencil_and_ztest_pixels( GLcontext *ctx,
GLstencil stencil[MAX_WIDTH]; GLstencil stencil[MAX_WIDTH];
GLubyte origMask[MAX_WIDTH]; GLubyte origMask[MAX_WIDTH];
ASSERT(!ctx->DrawBuffer->UseSoftwareStencilBuffer);
ASSERT(swrast->Driver.ReadStencilPixels); ASSERT(swrast->Driver.ReadStencilPixels);
(*swrast->Driver.ReadStencilPixels)(ctx, n, x, y, stencil); (*swrast->Driver.ReadStencilPixels)(ctx, n, x, y, stencil);
@ -934,7 +919,7 @@ stencil_and_ztest_pixels( GLcontext *ctx,
apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, mask); apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, mask);
} }
else { else {
_mesa_depth_test_pixels(ctx, n, x, y, z, mask); _mesa_depth_test_span(ctx, span);
if (ctx->Stencil.ZFailFunc != GL_KEEP) { if (ctx->Stencil.ZFailFunc != GL_KEEP) {
GLubyte failmask[MAX_WIDTH]; GLubyte failmask[MAX_WIDTH];
@ -966,6 +951,8 @@ stencil_and_ztest_pixels( GLcontext *ctx,
else { else {
/*** Software stencil buffer ***/ /*** Software stencil buffer ***/
ASSERT(ctx->DrawBuffer->UseSoftwareStencilBuffer);
if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) { if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) {
/* all fragments failed the stencil test, we're done. */ /* all fragments failed the stencil test, we're done. */
return GL_FALSE; return GL_FALSE;
@ -981,7 +968,7 @@ stencil_and_ztest_pixels( GLcontext *ctx,
MEMCPY(oldmask, mask, n * sizeof(GLubyte)); 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;i<n;i++) { for (i=0;i<n;i++) {
ASSERT(mask[i] == 0 || mask[i] == 1); ASSERT(mask[i] == 0 || mask[i] == 1);
@ -1004,22 +991,21 @@ stencil_and_ztest_pixels( GLcontext *ctx,
} }
/**
* /return GL_TRUE = one or more fragments passed,
* GL_FALSE = all fragments failed.
*/
GLboolean GLboolean
_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span) _mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
{ {
if (span->arrayMask & SPAN_XY) { if (span->arrayMask & SPAN_XY)
return stencil_and_ztest_pixels(ctx, span->end, return stencil_and_ztest_pixels(ctx, span);
span->xArray, span->yArray, else
span->zArray, span->mask); return stencil_and_ztest_span(ctx, span);
}
else {
return stencil_and_ztest_span2(ctx, span);
}
} }
/* /**
* Return a span of stencil values from the stencil buffer. * Return a span of stencil values from the stencil buffer.
* Used for glRead/CopyPixels * Used for glRead/CopyPixels
* Input: n - how many pixels * Input: n - how many pixels
@ -1070,7 +1056,7 @@ _mesa_read_stencil_span( GLcontext *ctx,
/* /**
* Write a span of stencil values to the stencil buffer. * Write a span of stencil values to the stencil buffer.
* Used for glDraw/CopyPixels * Used for glDraw/CopyPixels
* Input: n - how many pixels * Input: n - how many pixels
@ -1121,7 +1107,7 @@ _mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
/* /**
* Allocate a new stencil buffer. If there's an old one it will be * Allocate a new stencil buffer. If there's an old one it will be
* deallocated first. The new stencil buffer will be uninitialized. * deallocated first. The new stencil buffer will be uninitialized.
*/ */
@ -1147,7 +1133,7 @@ _mesa_alloc_stencil_buffer( GLcontext *ctx )
/* /**
* Clear the software (malloc'd) stencil buffer. * Clear the software (malloc'd) stencil buffer.
*/ */
static void static void
@ -1223,7 +1209,7 @@ clear_software_stencil_buffer( GLcontext *ctx )
/* /**
* Clear the hardware (in graphics card) stencil buffer. * Clear the hardware (in graphics card) stencil buffer.
* This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan() * This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan()
* functions. * functions.
@ -1311,8 +1297,8 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
/* /**
* Clear the stencil buffer. * Clear the stencil buffer (hardware or software).
*/ */
void void
_mesa_clear_stencil_buffer( GLcontext *ctx ) _mesa_clear_stencil_buffer( GLcontext *ctx )