-/* $Id: s_span.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
+/* $Id: s_span.c,v 1.10 2001/03/03 20:33:30 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2001 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"),
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 */
+ BZERO(mask, -x * sizeof(GLubyte));
+ }
}
- 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;
}
* index - array of [n] color indexes
* primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
*/
-void gl_write_index_span( GLcontext *ctx,
+void _mesa_write_index_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
const GLfixed fog[],
GLuint indexIn[], GLenum primitive )
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx,n,x,y,mask)==0) {
- return;
+ if ((n = clip_span(ctx,n,x,y,mask)) == 0) {
+ return;
}
}
index = indexIn;
}
- /* 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 );
- }
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
- return;
+ if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
}
}
if (ctx->Stencil.Enabled) {
/* first stencil test */
if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
- return;
+ 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;
+ /* 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 );
-void gl_write_monoindex_span( GLcontext *ctx,
+void _mesa_write_monoindex_span( GLcontext *ctx,
GLuint n, GLint x, GLint y,
const GLdepth z[],
const GLfixed fog[],
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx, n, x, y, mask)==0) {
+ 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) {
- return;
+ if ((n = _mesa_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;
}
_mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
}
- if (ctx->Color.IndexLogicOpEnabled) {
- _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
- }
-
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
multi_write_index_span( ctx, n, x, y, indexes, mask );
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 );
}
}
}
-void gl_write_rgba_span( GLcontext *ctx,
+void _mesa_write_rgba_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
const GLfixed *fog,
GLchan rgbaIn[][4],
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx,n,x,y,mask)==0) {
- return;
+ 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 && (swrast->_RasterMask & modBits))
rgba = rgbaIn;
}
- /* 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 );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
- return;
+ if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
/* Polygon Stippling */
/* 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;
+ /* 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 );
}
(const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
-
}
}
* r, g, b, a - the color of the pixels
* primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
*/
-void gl_write_monocolor_span( GLcontext *ctx,
+void _mesa_write_monocolor_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
const GLfixed fog[],
const GLchan color[4],
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span( ctx,n,x,y,mask)==0) {
+ 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) {
- return;
+ if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
/* Polygon Stippling */
/* 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 ||
(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);
}
ASSERT(!ctx->Color.ColorLogicOpEnabled);
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- for (i=0;i<n;i++) {
+ 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 );
+ (*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];
* rgba - array of [n] color components
* primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
*/
-void gl_write_texture_span( GLcontext *ctx,
+void _mesa_write_texture_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
const GLfixed fog[],
const GLfloat s[], const GLfloat t[],
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx, n, x, y, mask)==0) {
+ if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
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->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 );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
- return;
+ if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
/* Polygon Stippling */
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,
+ (CONST GLchan (*)[4]) 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;
+ /* Texture without alpha test */
+ if (! ctx->Color.AlphaEnabled) {
+ ASSERT(ctx->Texture._ReallyEnabled);
+ _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+ (CONST GLchan (*)[4]) 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 );
}
* As above but perform multiple stages of texture application.
*/
void
-gl_write_multitexture_span( GLcontext *ctx,
+_mesa_write_multitexture_span( GLcontext *ctx,
GLuint n, GLint x, GLint y,
const GLdepth z[],
const GLfixed fog[],
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if (clip_span(ctx, n, x, y, mask)==0) {
+ if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
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->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 );
- }
-
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if (gl_scissor_span( ctx, n, x, y, mask )==0) {
- return;
+ if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
}
- write_all = GL_FALSE;
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
}
/* Polygon Stippling */
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],
+ (CONST GLchan (*)[4]) 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;
+ /* 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],
+ (CONST GLchan (*)[4]) 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 );
}
_mesa_mask_rgba_span( ctx, n, x, y, rgba );
}
- (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba, write_all ? Null : mask );
+ (*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 );
* Read RGBA pixels from frame buffer. Clipping will be done to prevent
* reading ouside the buffer's boundaries.
*/
-void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+void _mesa_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
GLuint n, GLint x, GLint y,
GLchan rgba[][4] )
{
* Read CI pixels from frame buffer. Clipping will be done to prevent
* reading ouside the buffer's boundaries.
*/
-void gl_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+void _mesa_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
GLuint n, GLint x, GLint y, GLuint indx[] )
{
if (y < 0 || y >= buffer->Height
projects / mesa.git / blobdiff