-/* $Id: s_span.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+/* $Id: s_span.c,v 1.6 2001/01/05 21:28:31 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "s_alpha.h"
#include "s_alphabuf.h"
#include "s_blend.h"
+#include "s_context.h"
#include "s_depth.h"
#include "s_fog.h"
#include "s_logic.h"
static void stipple_polygon_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, GLubyte mask[] )
{
- register GLuint i, m, stipple, highbit=0x80000000;
+ const GLuint highbit = 0x80000000;
+ GLuint i, m, stipple;
stipple = ctx->PolygonStipple[y % 32];
m = highbit >> (GLuint) (x % 32);
- for (i=0;i<n;i++) {
- if ((m & stipple)==0) {
- mask[i] = 0;
+ for (i = 0; i < n; i++) {
+ if ((m & stipple) == 0) {
+ mask[i] = 0;
}
m = m >> 1;
- if (m==0) {
- m = 0x80000000;
+ if (m == 0) {
+ m = highbit;
}
}
}
/*
* Clip a pixel span to the current buffer/window boundaries.
- * Return: 0 = all pixels clipped
- * 1 = at least one pixel is visible
+ * Return: 'n' such that pixel 'n', 'n+1' etc. are clipped,
+ * as a special case:
+ * 0 = all pixels clipped
*/
static GLuint clip_span( GLcontext *ctx,
GLint n, GLint x, GLint y, GLubyte mask[] )
{
- GLint i;
-
/* Clip to top and bottom */
if (y < 0 || y >= ctx->DrawBuffer->Height) {
return 0;
}
- /* Clip to left and right */
- if (x >= 0 && x + n <= ctx->DrawBuffer->Width) {
- /* no clipping needed */
- return 1;
- }
- else if (x + n <= 0) {
- /* completely off left side */
- return 0;
- }
- else if (x >= ctx->DrawBuffer->Width) {
- /* completely off right side */
- return 0;
+ /* Clip to the left */
+ if (x < 0) {
+ if (x + n <= 0) {
+ /* completely off left side */
+ return 0;
+ }
+ else {
+ /* partially off left side */
+ MEMSET(mask, 0, -x);
+ }
}
- else {
- /* clip-test each pixel, this could be done better */
- for (i=0;i<n;i++) {
- if (x + i < 0 || x + i >= ctx->DrawBuffer->Width) {
- mask[i] = 0;
- }
+
+ /* Clip to right */
+ if (x + n > ctx->DrawBuffer->Width) {
+ if (x >= ctx->DrawBuffer->Width) {
+ /* completely off right side */
+ return 0;
+ }
+ else {
+ /* partially off right side */
+ return ctx->DrawBuffer->Width - x;
}
- return 1;
}
+
+ return n;
}
GLubyte mask[MAX_WIDTH];
GLuint indexBackup[MAX_WIDTH];
GLuint *index; /* points to indexIn or indexBackup */
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx,n,x,y,mask)==0) {
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n = clip_span(ctx,n,x,y,mask)) == 0) {
return;
}
}
- if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
- || (ctx->RasterMask & MULTI_DRAW_BIT)) {
+ if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+ || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
/* Make copy of color indexes */
MEMCPY( indexBackup, indexIn, n * sizeof(GLuint) );
index = indexBackup;
index = indexIn;
}
- /* Per-pixel fog */
- if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
- _mesa_fog_ci_pixels( ctx, n, fog, index );
- else
- _mesa_depth_fog_ci_pixels( ctx, n, z, index );
- }
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
}
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0) return;
+ if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+ return;
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && !swrast->_PreferPixelFog)
+ _mesa_fog_ci_pixels( ctx, n, fog, index );
+ else
+ _mesa_depth_fog_ci_pixels( ctx, n, z, index );
+ }
+
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
multi_write_index_span( ctx, n, x, y, index, mask );
}
const GLfixed fog[],
GLuint index, GLenum primitive )
{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
GLubyte mask[MAX_WIDTH];
GLuint i;
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx, n, x, y, mask)==0) {
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n = clip_span( ctx, n, x, y, mask)) == 0) {
return;
}
}
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
}
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0) return;
+ if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+ return;
}
/* if we get here, something passed the depth test */
|| ctx->Color.IndexMask != 0xffffffff) {
/* different index per pixel */
GLuint indexes[MAX_WIDTH];
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
indexes[i] = index;
}
if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
+ if (fog && !swrast->_PreferPixelFog)
_mesa_fog_ci_pixels( ctx, n, fog, indexes );
else
_mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
_mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
}
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
multi_write_index_span( ctx, n, x, y, indexes, mask );
}
/* same color index for all pixels */
ASSERT(!ctx->Color.IndexLogicOpEnabled);
ASSERT(ctx->Color.IndexMask == 0xffffffff);
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
GLuint indexes[MAX_WIDTH];
- for (i=0;i<n;i++)
+ for (i = 0; i < n; i++)
indexes[i] = index;
multi_write_index_span( ctx, n, x, y, indexes, mask );
}
else {
/* normal situation: draw to exactly one buffer */
- (*ctx->Driver.WriteMonoCISpan)( ctx, n, x, y, mask );
+ (*ctx->Driver.WriteMonoCISpan)( ctx, n, x, y, index, mask );
}
}
}
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLuint bufferBit;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (ctx->Color.DrawBuffer == GL_NONE)
return;
(*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
(const GLchan (*)[4]) rgbaTmp, mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_alpha_span( ctx, n, x, y,
(const GLchan (*)[4])rgbaTmp, mask );
}
GLchan rgbaBackup[MAX_WIDTH][4];
GLchan (*rgba)[4];
const GLubyte *Null = 0;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx,n,x,y,mask)==0) {
- return;
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
+ return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
- if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
- || (ctx->RasterMask & MULTI_DRAW_BIT)) {
+ if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+ || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
/* must make a copy of the colors since they may be modified */
MEMCPY( rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan) );
rgba = rgbaBackup;
rgba = rgbaIn;
}
- /* Per-pixel fog */
- if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
- else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
write_all = GL_FALSE;
/* Do the alpha test */
if (ctx->Color.AlphaEnabled) {
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask )==0) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
return;
}
write_all = GL_FALSE;
else if (ctx->Depth.Test) {
/* regular depth testing */
GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m==0) {
+ if (m == 0) {
return;
}
- if (m<n) {
+ if (m < n) {
write_all = GL_FALSE;
}
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
}
else {
(const GLchan (*)[4]) rgba,
write_all ? Null : mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_alpha_span( ctx, n, x, y,
(const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
-
}
}
GLboolean write_all = GL_TRUE;
GLchan rgba[MAX_WIDTH][4];
const GLubyte *Null = 0;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx,n,x,y,mask)==0) {
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
write_all = GL_FALSE;
/* Do the alpha test */
if (ctx->Color.AlphaEnabled) {
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
rgba[i][ACOMP] = color[ACOMP];
}
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask )==0) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
return;
}
write_all = GL_FALSE;
else if (ctx->Depth.Test) {
/* regular depth testing */
GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m==0) {
+ if (m == 0) {
return;
}
- if (m<n) {
+ if (m < n) {
write_all = GL_FALSE;
}
}
}
if (ctx->Color.ColorLogicOpEnabled || colorMask != 0xffffffff ||
- (ctx->RasterMask & (BLEND_BIT | FOG_BIT))) {
+ (swrast->_RasterMask & (BLEND_BIT | FOG_BIT))) {
/* assign same color to each pixel */
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
COPY_CHAN4(rgba[i], color);
}
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
+ if (fog && !swrast->_PreferPixelFog)
_mesa_fog_rgba_pixels( ctx, n, fog, rgba );
else
_mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y,
(const GLchan (*)[4]) rgba, mask );
}
(*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
(const GLchan (*)[4]) rgba,
write_all ? Null : mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_alpha_span( ctx, n, x, y,
(const GLchan (*)[4]) rgba,
write_all ? Null : mask );
ASSERT(!ctx->Color.BlendEnabled);
ASSERT(!ctx->Color.ColorLogicOpEnabled);
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
- for (i=0;i<n;i++) {
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
COPY_CHAN4(rgba[i], color);
}
(const GLchan (*)[4]) rgba, mask );
}
else {
- (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, color, mask );
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_mono_alpha_span( ctx, n, x, y, (GLchan) color[ACOMP],
write_all ? Null : mask );
}
static void add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
{
GLuint i;
- for (i=0; i<n; i++) {
+ for (i = 0; i < n; i++) {
GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
GLchan rgbaBackup[MAX_WIDTH][4];
GLchan (*rgba)[4]; /* points to either rgbaIn or rgbaBackup */
const GLubyte *Null = 0;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx, n, x, y, mask)==0) {
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
- if (primitive==GL_BITMAP || (ctx->RasterMask & MULTI_DRAW_BIT)) {
+ if (primitive==GL_BITMAP || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
/* must make a copy of the colors since they may be modified */
MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
rgba = rgbaBackup;
rgba = rgbaIn;
}
- /* Texture */
- ASSERT(ctx->Texture.ReallyEnabled);
- gl_texture_pixels( ctx, 0, n, s, t, u, lambda, rgba, rgba );
-
- /* Add base and specular colors */
- if (spec && ctx->Light.Enabled
- && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
-
- /* Per-pixel fog */
- if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
- else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
write_all = GL_FALSE;
stipple_polygon_span( ctx, n, x, y, mask );
write_all = GL_FALSE;
}
-
- /* Do the alpha test */
+
+ /* Texture with alpha test*/
if (ctx->Color.AlphaEnabled) {
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask )==0) {
- return;
+ /* Texturing without alpha is done after depth-testing which
+ gives a potential speed-up. */
+ ASSERT(ctx->Texture._ReallyEnabled);
+ _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda, rgba, rgba );
+
+ /* Do the alpha test */
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+ return;
}
write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m==0) {
+ if (m == 0) {
return;
}
- if (m<n) {
+ if (m < n) {
write_all = GL_FALSE;
}
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* Texture without alpha test */
+ if (! ctx->Color.AlphaEnabled) {
+ ASSERT(ctx->Texture._ReallyEnabled);
+ _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda, rgba, rgba );
+ }
+
+ /* Add base and specular colors */
+ if (spec &&
+ (ctx->Fog.ColorSumEnabled ||
+ (ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
+ add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
}
else {
(*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
write_all ? Null : mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
GLuint i;
const GLubyte *Null = 0;
const GLuint texUnits = ctx->Const.MaxTextureUnits;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
- if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx, n, x, y, mask)==0) {
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
- if (primitive==GL_BITMAP || (ctx->RasterMask & MULTI_DRAW_BIT)
+ if (primitive==GL_BITMAP || (swrast->_RasterMask & MULTI_DRAW_BIT)
|| texUnits > 1) {
/* must make a copy of the colors since they may be modified */
MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
rgba = rgbaIn;
}
- /* Texture */
- ASSERT(ctx->Texture.ReallyEnabled);
- for (i = 0; i < texUnits; i++)
- gl_texture_pixels( ctx, i, n, s[i], t[i], u[i], lambda[i], rgbaIn, rgba );
-
- /* Add base and specular colors */
- if (spec && ctx->Light.Enabled
- && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
-
- /* Per-pixel fog */
- if (ctx->Fog.Enabled) {
- if (fog && ctx->Hint.Fog != GL_NICEST)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
- else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ if (gl_scissor_span( ctx, n, x, y, mask ) == 0) {
return;
}
write_all = GL_FALSE;
write_all = GL_FALSE;
}
- /* Do the alpha test */
+ /* Texture with alpha test*/
if (ctx->Color.AlphaEnabled) {
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask )==0) {
- return;
+ /* Texturing without alpha is done after depth-testing which
+ * gives a potential speed-up.
+ */
+ ASSERT(ctx->Texture._ReallyEnabled);
+ for (i = 0; i < texUnits; i++)
+ _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i],
+ lambda[i], rgbaIn, rgba );
+
+ /* Do the alpha test */
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
+ return;
}
write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m==0) {
+ if (m == 0) {
return;
}
- if (m<n) {
+ if (m < n) {
write_all = GL_FALSE;
}
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
- if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* Texture without alpha test */
+ if (! ctx->Color.AlphaEnabled) {
+ ASSERT(ctx->Texture._ReallyEnabled);
+ for (i = 0; i < texUnits; i++)
+ _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i],
+ lambda[i], rgbaIn, rgba );
+ }
+
+ /* Add base and specular colors */
+ if (spec &&
+ (ctx->Fog.ColorSumEnabled ||
+ (ctx->Light.Enabled &&
+ ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
+ add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
}
else {
_mesa_mask_rgba_span( ctx, n, x, y, rgba );
}
- (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba, write_all ? Null : mask );
- if (ctx->RasterMask & ALPHABUF_BIT) {
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
+ write_all ? Null : mask );
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
_mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4])rgba,
write_all ? Null : mask );
}
projects / mesa.git / blobdiff