-/* $Id: s_span.c,v 1.6 2001/01/05 21:28:31 brianp Exp $ */
+/* $Id: s_span.c,v 1.15 2001/06/18 23:55:18 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"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
- *
+ *
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
- *
+ *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-
/*
* Apply the current polygon stipple pattern to a span of pixels.
*/
-static void stipple_polygon_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y, GLubyte mask[] )
+static void
+stipple_polygon_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLubyte mask[] )
{
const GLuint highbit = 0x80000000;
GLuint i, m, stipple;
* as a special case:
* 0 = all pixels clipped
*/
-static GLuint clip_span( GLcontext *ctx,
- GLint n, GLint x, GLint y, GLubyte mask[] )
+static GLuint
+clip_span( GLcontext *ctx, GLint n, GLint x, GLint y, GLubyte mask[] )
{
/* Clip to top and bottom */
if (y < 0 || y >= ctx->DrawBuffer->Height) {
}
else {
/* partially off left side */
- MEMSET(mask, 0, -x);
+ BZERO(mask, -x * sizeof(GLubyte));
}
}
/*
* Draw to more than one color buffer (or none).
*/
-static void multi_write_index_span( GLcontext *ctx, GLuint n,
- GLint x, GLint y, const GLuint indexes[],
- const GLubyte mask[] )
+static void
+multi_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLuint indexes[], const GLubyte mask[] )
{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
GLuint bufferBit;
if (ctx->Color.DrawBuffer == GL_NONE)
else if (ctx->Color.IndexMask != 0xffffffff) {
_mesa_mask_index_span( ctx, n, x, y, indexTmp );
}
- (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexTmp, mask );
+ (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, indexTmp, mask );
}
}
* Input: n - number of pixels in the span
* x, y - location of leftmost pixel in the span
* z - array of [n] z-values
+ * fog - array of fog factor values in [0,1]
* index - array of [n] color indexes
* primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
*/
-void gl_write_index_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y, const GLdepth z[],
- const GLfixed fog[],
- GLuint indexIn[], GLenum primitive )
+void
+_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLuint indexIn[], const GLint coverage[],
+ GLenum primitive )
{
const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT | LOGIC_OP_BIT;
GLubyte mask[MAX_WIDTH];
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
if ((n = clip_span(ctx,n,x,y,mask)) == 0) {
- return;
+ 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;
}
}
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) {
_mesa_depth_fog_ci_pixels( ctx, n, z, index );
}
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ ASSERT(coverage[i] < 16);
+ index[i] = (index[i] & ~0xf) | coverage[i];
+ }
+ }
+
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
multi_write_index_span( ctx, n, x, y, index, mask );
}
/* write pixels */
- (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, index, mask );
+ (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, index, mask );
}
}
-void gl_write_monoindex_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLdepth z[],
- const GLfixed fog[],
- GLuint index, GLenum primitive )
+void
+_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLuint index, const GLint coverage[],
+ GLenum primitive )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
GLubyte mask[MAX_WIDTH];
/* 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->Fog.Enabled
|| ctx->Color.IndexLogicOpEnabled
- || ctx->Color.IndexMask != 0xffffffff) {
+ || ctx->Color.IndexMask != 0xffffffff
+ || coverage) {
/* different index per pixel */
GLuint indexes[MAX_WIDTH];
for (i = 0; i < n; i++) {
_mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
}
- if (ctx->Color.IndexLogicOpEnabled) {
- _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ ASSERT(coverage[i] < 16);
+ indexes[i] = (indexes[i] & ~0xf) | coverage[i];
+ }
}
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
else if (ctx->Color.IndexMask != 0xffffffff) {
_mesa_mask_index_span( ctx, n, x, y, indexes );
}
- (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
+ (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
}
}
else {
}
else {
/* normal situation: draw to exactly one buffer */
- (*ctx->Driver.WriteMonoCISpan)( ctx, n, x, y, index, mask );
+ (*swrast->Driver.WriteMonoCISpan)( ctx, n, x, y, index, mask );
}
}
}
/*
* Draw to more than one RGBA color buffer (or none).
*/
-static void multi_write_rgba_span( GLcontext *ctx, GLuint n,
- GLint x, GLint y, CONST GLchan rgba[][4],
- const GLubyte mask[] )
+static void
+multi_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLuint bufferBit;
_mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
}
- (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
(const GLchan (*)[4]) rgbaTmp, mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y,
+ _mesa_write_alpha_span( ctx, n, x, y,
(const GLchan (*)[4])rgbaTmp, mask );
}
}
-void gl_write_rgba_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y, const GLdepth z[],
- const GLfixed *fog,
- GLchan rgbaIn[][4],
- GLenum primitive )
+void
+_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLchan rgbaIn[][4], const GLfloat coverage[],
+ GLenum primitive )
{
const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
LOGIC_OP_BIT | TEXTURE_BIT;
/* 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 */
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
+ if (fog && !swrast->_PreferPixelFog)
_mesa_fog_rgba_pixels( ctx, n, fog, rgba );
else
_mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ }
+ }
+
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
}
}
/* write pixels */
- (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
- (const GLchan (*)[4]) rgba,
+ (*swrast->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,
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
}
* Input: n - number of pixels in the span
* x, y - location of leftmost pixel in the span
* z - array of [n] z-values
+ * fog - array of fog factor values in [0,1]
* 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,
- GLuint n, GLint x, GLint y, const GLdepth z[],
- const GLfixed fog[],
- const GLchan color[4],
- GLenum primitive )
+void
+_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ const GLchan color[4], const GLfloat coverage[],
+ GLenum primitive )
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLuint i;
/* 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 */
}
if (ctx->Color.ColorLogicOpEnabled || colorMask != 0xffffffff ||
- (swrast->_RasterMask & (BLEND_BIT | FOG_BIT))) {
+ (swrast->_RasterMask & (BLEND_BIT | FOG_BIT)) || coverage) {
/* assign same color to each pixel */
for (i = 0; i < n; i++) {
if (mask[i]) {
_mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ }
+ }
+
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
multi_write_rgba_span( ctx, n, x, y,
(const GLchan (*)[4]) rgba, mask );
}
/* write pixels */
- (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
- (const GLchan (*)[4]) rgba,
+ (*swrast->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,
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
}
COPY_CHAN4(rgba[i], color);
}
}
- multi_write_rgba_span( ctx, n, x, y,
+ multi_write_rgba_span( ctx, n, x, y,
(const GLchan (*)[4]) rgba, mask );
}
else {
- (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, color, mask );
+ (*swrast->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 );
* Add specular color to base color. This is used only when
* GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
*/
-static void add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
+static void
+add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
{
GLuint i;
for (i = 0; i < n; i++) {
* rgba - array of [n] color components
* primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
*/
-void gl_write_texture_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y, const GLdepth z[],
- const GLfixed fog[],
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], GLfloat lambda[],
- GLchan rgbaIn[][4], CONST GLchan spec[][4],
- GLenum primitive )
+void
+_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], GLfloat lambda[],
+ GLchan rgbaIn[][4], CONST GLchan spec[][4],
+ const GLfloat coverage[], GLenum primitive )
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLubyte mask[MAX_WIDTH];
/* 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;
}
-
+
/* Texture with alpha test*/
if (ctx->Color.AlphaEnabled) {
/* 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 );
-
+ _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;
/* Texture without alpha test */
if (! ctx->Color.AlphaEnabled) {
ASSERT(ctx->Texture._ReallyEnabled);
- _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda, rgba, rgba );
+ _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+ (CONST GLchan (*)[4]) rgba, rgba );
}
/* Add base and specular colors */
- if (spec &&
+ if (spec &&
(ctx->Fog.ColorSumEnabled ||
- (ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
- add_colors( n, rgba, spec ); /* rgba = rgba + 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) {
_mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ }
+ }
+
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,
+ (*swrast->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,
+ _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4]) rgba,
write_all ? Null : mask );
}
}
* As above but perform multiple stages of texture application.
*/
void
-gl_write_multitexture_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLdepth z[],
- const GLfixed fog[],
- CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
- GLfloat lambda[][MAX_WIDTH],
- GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
- CONST GLchan spec[MAX_TEXTURE_UNITS][4],
- GLenum primitive )
+_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ GLfloat lambda[][MAX_WIDTH],
+ GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
+ CONST GLchan spec[MAX_TEXTURE_UNITS][4],
+ const GLfloat coverage[],
+ GLenum primitive )
{
GLubyte mask[MAX_WIDTH];
GLboolean write_all = GL_TRUE;
/* 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 */
*/
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 );
-
+ _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;
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 );
+ _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 &&
+ if (spec &&
(ctx->Fog.ColorSumEnabled ||
- (ctx->Light.Enabled &&
+ (ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
add_colors( n, rgba, spec ); /* rgba = rgba + spec */
_mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ }
+ }
+
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,
+ (*swrast->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,
* 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,
- GLuint n, GLint x, GLint y,
- GLchan rgba[][4] )
+void
+_mesa_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y, GLchan rgba[][4] )
{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (y < 0 || y >= buffer->Height
|| x + (GLint) n < 0 || x >= buffer->Width) {
/* completely above, below, or right */
length = (GLint) n;
}
- (*ctx->Driver.ReadRGBASpan)( ctx, length, x + skip, y, rgba + skip );
+ (*swrast->Driver.ReadRGBASpan)( ctx, length, x + skip, y, rgba + skip );
if (buffer->UseSoftwareAlphaBuffers) {
_mesa_read_alpha_span( ctx, length, x + skip, y, rgba + skip );
}
* 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,
- GLuint n, GLint x, GLint y, GLuint indx[] )
+void
+_mesa_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y, GLuint indx[] )
{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (y < 0 || y >= buffer->Height
|| x + (GLint) n < 0 || x >= buffer->Width) {
/* completely above, below, or right */
length = (GLint) n;
}
- (*ctx->Driver.ReadCI32Span)( ctx, length, skip + x, y, indx + skip );
+ (*swrast->Driver.ReadCI32Span)( ctx, length, skip + x, y, indx + skip );
}
}
projects / mesa.git / blobdiff