/*
* Mesa 3-D graphics library
- * Version: 6.5
+ * Version: 7.1
*
- * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2007 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"),
/**
- * Init span's Z interpolation values to the RasterPos Z.
- * Used during setup for glDraw/CopyPixels.
+ * Set default fragment attributes for the span using the
+ * current raster values. Used prior to glDraw/CopyPixels
+ * and glBitmap.
*/
void
-_swrast_span_default_z( GLcontext *ctx, SWspan *span )
+_swrast_span_default_attribs(GLcontext *ctx, SWspan *span)
{
- const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
- if (ctx->DrawBuffer->Visual.depthBits <= 16)
- span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);
- else
- span->z = (GLint) (ctx->Current.RasterPos[2] * depthMax + 0.5F);
- span->zStep = 0;
- span->interpMask |= SPAN_Z;
-}
-
-
-/**
- * Init span's fog interpolation values to the RasterPos fog.
- * Used during setup for glDraw/CopyPixels.
- */
-void
-_swrast_span_default_fog( GLcontext *ctx, SWspan *span )
-{
- span->attrStart[FRAG_ATTRIB_FOGC][0]
- = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
- span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;
- span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;
- span->interpMask |= SPAN_FOG;
-}
+ /* Z*/
+ {
+ const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
+ if (ctx->DrawBuffer->Visual.depthBits <= 16)
+ span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);
+ else
+ span->z = (GLint) (ctx->Current.RasterPos[2] * depthMax + 0.5F);
+ span->zStep = 0;
+ span->interpMask |= SPAN_Z;
+ }
+ /* W (for perspective correction) */
+ span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0;
+ span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0;
+ span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0;
-/**
- * Init span's rgba or index interpolation values to the RasterPos color.
- * Used during setup for glDraw/CopyPixels.
- */
-void
-_swrast_span_default_color( GLcontext *ctx, SWspan *span )
-{
+ /* primary color, or color index */
if (ctx->Visual.rgbMode) {
GLchan r, g, b, a;
UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);
span->blueStep = 0;
span->alphaStep = 0;
span->interpMask |= SPAN_RGBA;
+
+ COPY_4V(span->attrStart[FRAG_ATTRIB_COL0], ctx->Current.RasterColor);
+ ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
+ ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
}
else {
span->index = FloatToFixed(ctx->Current.RasterIndex);
span->indexStep = 0;
span->interpMask |= SPAN_INDEX;
}
-}
+ /* Secondary color */
+ if (ctx->Visual.rgbMode && (ctx->Light.Enabled || ctx->Fog.ColorSumEnabled))
+ {
+ COPY_4V(span->attrStart[FRAG_ATTRIB_COL1], ctx->Current.RasterSecondaryColor);
+ ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
+ ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
+ }
+
+ /* fog */
+ {
+ const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLfloat fogVal; /* a coord or a blend factor */
+ if (swrast->_PreferPixelFog) {
+ /* fog blend factors will be computed from fog coordinates per pixel */
+ fogVal = ctx->Current.RasterDistance;
+ }
+ else {
+ /* fog blend factor should be computed from fogcoord now */
+ fogVal = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+ }
+ span->attrStart[FRAG_ATTRIB_FOGC][0] = fogVal;
+ span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;
+ span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;
+ }
-void
-_swrast_span_default_secondary_color(GLcontext *ctx, SWspan *span)
-{
- if (ctx->Visual.rgbMode) {
- GLchan r, g, b, a;
- UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterSecondaryColor[0]);
- UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterSecondaryColor[1]);
- UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterSecondaryColor[2]);
- UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterSecondaryColor[3]);
-#if CHAN_TYPE == GL_FLOAT
- span->specRed = r;
- span->specGreen = g;
- span->specBlue = b;
- /*span->specAlpha = a;*/
-#else
- span->specRed = IntToFixed(r);
- span->specGreen = IntToFixed(g);
- span->specBlue = IntToFixed(b);
- /*span->specAlpha = IntToFixed(a);*/
-#endif
- span->specRedStep = 0;
- span->specGreenStep = 0;
- span->specBlueStep = 0;
- /*span->specAlphaStep = 0;*/
- span->interpMask |= SPAN_SPEC;
+ /* texcoords */
+ {
+ GLuint i;
+ for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
+ const GLuint attr = FRAG_ATTRIB_TEX0 + i;
+ const GLfloat *tc = ctx->Current.RasterTexCoords[i];
+ if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {
+ COPY_4V(span->attrStart[attr], tc);
+ }
+ else if (tc[3] > 0.0F) {
+ /* use (s/q, t/q, r/q, 1) */
+ span->attrStart[attr][0] = tc[0] / tc[3];
+ span->attrStart[attr][1] = tc[1] / tc[3];
+ span->attrStart[attr][2] = tc[2] / tc[3];
+ span->attrStart[attr][3] = 1.0;
+ }
+ else {
+ ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);
+ }
+ ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);
+ ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);
+ }
}
}
/**
- * Init span's texcoord interpolation values to the RasterPos texcoords.
- * Used during setup for glDraw/CopyPixels.
+ * Interpolate the active attributes (and'd with attrMask) to
+ * fill in span->array->attribs[].
+ * Perspective correction will be done. The point/line/triangle function
+ * should have computed attrStart/Step values for FRAG_ATTRIB_WPOS[3]!
*/
-void
-_swrast_span_default_texcoords( GLcontext *ctx, SWspan *span )
+static INLINE void
+interpolate_active_attribs(GLcontext *ctx, SWspan *span, GLbitfield attrMask)
{
- GLuint i;
- for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
- const GLuint attr = FRAG_ATTRIB_TEX0 + i;
- const GLfloat *tc = ctx->Current.RasterTexCoords[i];
- if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {
- COPY_4V(span->attrStart[attr], tc);
- }
- else if (tc[3] > 0.0F) {
- /* use (s/q, t/q, r/q, 1) */
- span->attrStart[attr][0] = tc[0] / tc[3];
- span->attrStart[attr][1] = tc[1] / tc[3];
- span->attrStart[attr][2] = tc[2] / tc[3];
- span->attrStart[attr][3] = 1.0;
- }
- else {
- ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);
+ const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ /*
+ * Don't overwrite existing array values, such as colors that may have
+ * been produced by glDraw/CopyPixels.
+ */
+ attrMask &= ~span->arrayAttribs;
+
+ ATTRIB_LOOP_BEGIN
+ if (attrMask & (1 << attr)) {
+ const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
+ GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];
+ const GLfloat dv0dx = span->attrStepX[attr][0];
+ const GLfloat dv1dx = span->attrStepX[attr][1];
+ const GLfloat dv2dx = span->attrStepX[attr][2];
+ const GLfloat dv3dx = span->attrStepX[attr][3];
+ GLfloat v0 = span->attrStart[attr][0];
+ GLfloat v1 = span->attrStart[attr][1];
+ GLfloat v2 = span->attrStart[attr][2];
+ GLfloat v3 = span->attrStart[attr][3];
+ GLuint k;
+ for (k = 0; k < span->end; k++) {
+ const GLfloat invW = 1.0f / w;
+ span->array->attribs[attr][k][0] = v0 * invW;
+ span->array->attribs[attr][k][1] = v1 * invW;
+ span->array->attribs[attr][k][2] = v2 * invW;
+ span->array->attribs[attr][k][3] = v3 * invW;
+ v0 += dv0dx;
+ v1 += dv1dx;
+ v2 += dv2dx;
+ v3 += dv3dx;
+ w += dwdx;
+ }
+ ASSERT((span->arrayAttribs & (1 << attr)) == 0);
+ span->arrayAttribs |= (1 << attr);
}
- ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);
- ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);
- }
- span->interpMask |= SPAN_TEXTURE;
+ ATTRIB_LOOP_END
}
/**
- * Interpolate primary colors to fill in the span->array->color array.
+ * Interpolate primary colors to fill in the span->array->rgba8 (or rgb16)
+ * color array.
*/
static INLINE void
-interpolate_colors(SWspan *span)
+interpolate_int_colors(GLcontext *ctx, SWspan *span)
{
const GLuint n = span->end;
GLuint i;
- ASSERT((span->interpMask & SPAN_RGBA) &&
- !(span->arrayMask & SPAN_RGBA));
+#if CHAN_BITS != 32
+ ASSERT(!(span->arrayMask & SPAN_RGBA));
+#endif
switch (span->array->ChanType) {
#if CHAN_BITS != 32
case GL_UNSIGNED_BYTE:
{
- GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
+ GLubyte (*rgba)[4] = span->array->rgba8;
if (span->interpMask & SPAN_FLAT) {
GLubyte color[4];
color[RCOMP] = FixedToInt(span->red);
break;
case GL_UNSIGNED_SHORT:
{
- GLushort (*rgba)[4] = span->array->color.sz2.rgba;
+ GLushort (*rgba)[4] = span->array->rgba16;
if (span->interpMask & SPAN_FLAT) {
GLushort color[4];
color[RCOMP] = FixedToInt(span->red);
}
}
else {
- GLushort (*rgba)[4] = span->array->color.sz2.rgba;
+ GLushort (*rgba)[4] = span->array->rgba16;
GLfixed r, g, b, a;
GLint dr, dg, db, da;
r = span->red;
break;
#endif
case GL_FLOAT:
- {
- GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
- GLfloat r, g, b, a, dr, dg, db, da;
- r = span->red;
- g = span->green;
- b = span->blue;
- a = span->alpha;
- if (span->interpMask & SPAN_FLAT) {
- dr = dg = db = da = 0.0;
- }
- else {
- dr = span->redStep;
- dg = span->greenStep;
- db = span->blueStep;
- da = span->alphaStep;
- }
- for (i = 0; i < n; i++) {
- rgba[i][RCOMP] = r;
- rgba[i][GCOMP] = g;
- rgba[i][BCOMP] = b;
- rgba[i][ACOMP] = a;
- r += dr;
- g += dg;
- b += db;
- a += da;
- }
- }
+ interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
break;
default:
- _mesa_problem(NULL, "bad datatype in interpolate_colors");
+ _mesa_problem(NULL, "bad datatype in interpolate_int_colors");
}
span->arrayMask |= SPAN_RGBA;
}
/**
- * Interpolate specular/secondary colors.
+ * Populate the FRAG_ATTRIB_COL0 array.
*/
static INLINE void
-interpolate_specular(SWspan *span)
+interpolate_float_colors(SWspan *span)
{
+ GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
const GLuint n = span->end;
GLuint i;
- switch (span->array->ChanType) {
-#if CHAN_BITS != 32
- case GL_UNSIGNED_BYTE:
- {
- GLubyte (*spec)[4] = span->array->color.sz1.spec;
- if (span->interpMask & SPAN_FLAT) {
- GLubyte color[4];
- color[RCOMP] = FixedToInt(span->specRed);
- color[GCOMP] = FixedToInt(span->specGreen);
- color[BCOMP] = FixedToInt(span->specBlue);
- color[ACOMP] = 0;
- for (i = 0; i < n; i++) {
- COPY_4UBV(spec[i], color);
- }
- }
- else {
- GLfixed r = span->specRed;
- GLfixed g = span->specGreen;
- GLfixed b = span->specBlue;
- GLint dr = span->specRedStep;
- GLint dg = span->specGreenStep;
- GLint db = span->specBlueStep;
- for (i = 0; i < n; i++) {
- spec[i][RCOMP] = CLAMP(FixedToChan(r), 0, 255);
- spec[i][GCOMP] = CLAMP(FixedToChan(g), 0, 255);
- spec[i][BCOMP] = CLAMP(FixedToChan(b), 0, 255);
- spec[i][ACOMP] = 0;
- r += dr;
- g += dg;
- b += db;
- }
- }
+ assert(!(span->arrayAttribs & FRAG_BIT_COL0));
+
+ if (span->arrayMask & SPAN_RGBA) {
+ /* convert array of int colors */
+ for (i = 0; i < n; i++) {
+ col0[i][0] = UBYTE_TO_FLOAT(span->array->rgba8[i][0]);
+ col0[i][1] = UBYTE_TO_FLOAT(span->array->rgba8[i][1]);
+ col0[i][2] = UBYTE_TO_FLOAT(span->array->rgba8[i][2]);
+ col0[i][3] = UBYTE_TO_FLOAT(span->array->rgba8[i][3]);
}
- break;
- case GL_UNSIGNED_SHORT:
- {
- GLushort (*spec)[4] = span->array->color.sz2.spec;
- if (span->interpMask & SPAN_FLAT) {
- GLushort color[4];
- color[RCOMP] = FixedToInt(span->specRed);
- color[GCOMP] = FixedToInt(span->specGreen);
- color[BCOMP] = FixedToInt(span->specBlue);
- color[ACOMP] = 0;
- for (i = 0; i < n; i++) {
- COPY_4V(spec[i], color);
- }
- }
- else {
- GLfixed r = FloatToFixed(span->specRed);
- GLfixed g = FloatToFixed(span->specGreen);
- GLfixed b = FloatToFixed(span->specBlue);
- GLint dr = FloatToFixed(span->specRedStep);
- GLint dg = FloatToFixed(span->specGreenStep);
- GLint db = FloatToFixed(span->specBlueStep);
- for (i = 0; i < n; i++) {
- spec[i][RCOMP] = FixedToInt(r);
- spec[i][GCOMP] = FixedToInt(g);
- spec[i][BCOMP] = FixedToInt(b);
- spec[i][ACOMP] = 0;
- r += dr;
- g += dg;
- b += db;
- }
+ }
+ else {
+ /* interpolate red/green/blue/alpha to get float colors */
+ ASSERT(span->interpMask & SPAN_RGBA);
+ if (span->interpMask & SPAN_FLAT) {
+ GLfloat r = FixedToFloat(span->red);
+ GLfloat g = FixedToFloat(span->green);
+ GLfloat b = FixedToFloat(span->blue);
+ GLfloat a = FixedToFloat(span->alpha);
+ for (i = 0; i < n; i++) {
+ ASSIGN_4V(col0[i], r, g, b, a);
}
}
- break;
-#endif
- case GL_FLOAT:
- {
- GLfloat (*spec)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
-#if CHAN_BITS <= 16
- GLfloat r = CHAN_TO_FLOAT(FixedToChan(span->specRed));
- GLfloat g = CHAN_TO_FLOAT(FixedToChan(span->specGreen));
- GLfloat b = CHAN_TO_FLOAT(FixedToChan(span->specBlue));
-#else
- GLfloat r = span->specRed;
- GLfloat g = span->specGreen;
- GLfloat b = span->specBlue;
-#endif
- GLfloat dr, dg, db;
- if (span->interpMask & SPAN_FLAT) {
- dr = dg = db = 0.0;
- }
- else {
-#if CHAN_BITS <= 16
- dr = CHAN_TO_FLOAT(FixedToChan(span->specRedStep));
- dg = CHAN_TO_FLOAT(FixedToChan(span->specGreenStep));
- db = CHAN_TO_FLOAT(FixedToChan(span->specBlueStep));
-#else
- dr = span->specRedStep;
- dg = span->specGreenStep;
- db = span->specBlueStep;
-#endif
- }
+ else {
+ GLfloat r = FixedToFloat(span->red);
+ GLfloat g = FixedToFloat(span->green);
+ GLfloat b = FixedToFloat(span->blue);
+ GLfloat a = FixedToFloat(span->alpha);
+ GLfloat dr = FixedToFloat(span->redStep);
+ GLfloat dg = FixedToFloat(span->greenStep);
+ GLfloat db = FixedToFloat(span->blueStep);
+ GLfloat da = FixedToFloat(span->alphaStep);
for (i = 0; i < n; i++) {
- spec[i][RCOMP] = r;
- spec[i][GCOMP] = g;
- spec[i][BCOMP] = b;
- spec[i][ACOMP] = 0.0F;
+ col0[i][0] = r;
+ col0[i][1] = g;
+ col0[i][2] = b;
+ col0[i][3] = a;
r += dr;
g += dg;
b += db;
+ a += da;
}
}
- break;
- default:
- _mesa_problem(NULL, "bad datatype in interpolate_specular");
}
- span->arrayMask |= SPAN_SPEC;
+
+ span->arrayAttribs |= FRAG_BIT_COL0;
+ span->array->ChanType = GL_FLOAT;
}
+
/* Fill in the span.color.index array from the interpolation values */
static INLINE void
interpolate_indexes(GLcontext *ctx, SWspan *span)
GLuint *indexes = span->array->index;
GLuint i;
(void) ctx;
- ASSERT((span->interpMask & SPAN_INDEX) &&
- !(span->arrayMask & SPAN_INDEX));
+
+ ASSERT(!(span->arrayMask & SPAN_INDEX));
if ((span->interpMask & SPAN_FLAT) || (indexStep == 0)) {
/* constant color */
}
-/* Fill in the span.array.fog values from the interpolation values */
-static INLINE void
-interpolate_fog(const GLcontext *ctx, SWspan *span)
-{
- GLfloat (*fog)[4] = span->array->attribs[FRAG_ATTRIB_FOGC];
- const GLfloat fogStep = span->attrStepX[FRAG_ATTRIB_FOGC][0];
- GLfloat fogCoord = span->attrStart[FRAG_ATTRIB_FOGC][0];
- const GLuint haveW = (span->interpMask & SPAN_W);
- const GLfloat wStep = haveW ? span->attrStepX[FRAG_ATTRIB_WPOS][3] : 0.0F;
- GLfloat w = haveW ? span->attrStart[FRAG_ATTRIB_WPOS][3] : 1.0F;
- GLuint i;
- for (i = 0; i < span->end; i++) {
- fog[i][0] = fogCoord / w;
- fogCoord += fogStep;
- w += wStep;
- }
- span->arrayMask |= SPAN_FOG;
-}
-
-
-/* Fill in the span.zArray array from the interpolation values */
+/**
+ * Fill in the span.zArray array from the span->z, zStep values.
+ */
void
_swrast_span_interpolate_z( const GLcontext *ctx, SWspan *span )
{
const GLuint n = span->end;
GLuint i;
- ASSERT((span->interpMask & SPAN_Z) &&
- !(span->arrayMask & SPAN_Z));
+ ASSERT(!(span->arrayMask & SPAN_Z));
if (ctx->DrawBuffer->Visual.depthBits <= 16) {
GLfixed zval = span->z;
}
-/*
+/**
+ * Compute mipmap LOD from partial derivatives.
* This the ideal solution, as given in the OpenGL spec.
*/
#if 0
#endif
-/*
- * This is a faster approximation
+/**
+ * Compute mipmap LOD from partial derivatives.
+ * This is a faster approximation than above function.
*/
GLfloat
_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
/**
- * Fill in the span.texcoords array from the interpolation values.
+ * Fill in the span.array->attrib[FRAG_ATTRIB_TEXn] arrays from the
+ * using the attrStart/Step values.
+ *
+ * This function only used during fixed-function fragment processing.
+ *
* Note: in the places where we divide by Q (or mult by invQ) we're
* really doing two things: perspective correction and texcoord
* projection. Remember, for texcoord (s,t,r,q) we need to index
* texels with (s/q, t/q, r/q).
- * If we're using a fragment program, we never do the division
- * for texcoord projection. That's done by the TXP instruction
- * or user-written code.
*/
static void
interpolate_texcoords(GLcontext *ctx, SWspan *span)
= (ctx->Texture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1;
GLuint u;
- ASSERT(span->interpMask & SPAN_TEXTURE);
- ASSERT(!(span->arrayMask & SPAN_TEXTURE));
-
- span->arrayMask |= SPAN_TEXTURE;
-
/* XXX CoordUnits vs. ImageUnits */
for (u = 0; u < maxUnit; u++) {
if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
}
-
-/**
- * Fill in the arrays->attribs[FRAG_ATTRIB_VARx] arrays from the
- * interpolation values.
- * XXX since interpolants/arrays are getting uniformed, we might merge
- * this with interpolate_texcoords(), interpolate_Fog(), etc. someday.
- */
-static INLINE void
-interpolate_varying(GLcontext *ctx, SWspan *span)
-{
- GLuint var;
- const GLbitfield inputsUsed = ctx->FragmentProgram._Current->Base.InputsRead;
-
- ASSERT(span->interpMask & SPAN_VARYING);
- ASSERT(!(span->arrayMask & SPAN_VARYING));
-
- span->arrayMask |= SPAN_VARYING;
-
- for (var = 0; var < MAX_VARYING; var++) {
- if (inputsUsed & FRAG_BIT_VAR(var)) {
- const GLuint attr = FRAG_ATTRIB_VAR0 + var;
- const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
- GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];
- const GLfloat dv0dx = span->attrStepX[attr][0];
- const GLfloat dv1dx = span->attrStepX[attr][1];
- const GLfloat dv2dx = span->attrStepX[attr][2];
- const GLfloat dv3dx = span->attrStepX[attr][3];
- GLfloat v0 = span->attrStart[attr][0];
- GLfloat v1 = span->attrStart[attr][1];
- GLfloat v2 = span->attrStart[attr][2];
- GLfloat v3 = span->attrStart[attr][3];
- GLuint k;
- for (k = 0; k < span->end; k++) {
- GLfloat invW = 1.0f / w;
- span->array->attribs[attr][k][0] = v0 * invW;
- span->array->attribs[attr][k][1] = v1 * invW;
- span->array->attribs[attr][k][2] = v2 * invW;
- span->array->attribs[attr][k][3] = v3 * invW;
- v0 += dv0dx;
- v1 += dv1dx;
- v2 += dv2dx;
- v3 += dv3dx;
- w += dwdx;
- }
- }
- }
-}
-
-
/**
* Fill in the arrays->attribs[FRAG_ATTRIB_WPOS] array.
*/
{
GLfloat (*wpos)[4] = span->array->attribs[FRAG_ATTRIB_WPOS];
GLuint i;
+ const GLfloat zScale = 1.0 / ctx->DrawBuffer->_DepthMaxF;
+ GLfloat w, dw;
+
if (span->arrayMask & SPAN_XY) {
for (i = 0; i < span->end; i++) {
wpos[i][0] = (GLfloat) span->array->x[i];
wpos[i][1] = (GLfloat) span->y;
}
}
+
+ w = span->attrStart[FRAG_ATTRIB_WPOS][3];
+ dw = span->attrStepX[FRAG_ATTRIB_WPOS][3];
for (i = 0; i < span->end; i++) {
- wpos[i][2] = (GLfloat) span->array->z[i] / ctx->DrawBuffer->_DepthMaxF;
- wpos[i][3] = span->attrStart[FRAG_ATTRIB_WPOS][3]
- + i * span->attrStepX[FRAG_ATTRIB_WPOS][3];
+ wpos[i][2] = (GLfloat) span->array->z[i] * zScale;
+ wpos[i][3] = w;
+ w += dw;
}
}
ASSERT(span->primitive == GL_POINT || span->primitive == GL_LINE ||
span->primitive == GL_POLYGON || span->primitive == GL_BITMAP);
ASSERT((span->interpMask | span->arrayMask) & SPAN_INDEX);
+ /*
ASSERT((span->interpMask & span->arrayMask) == 0);
+ */
if (span->arrayMask & SPAN_MASK) {
/* mask was initialized by caller, probably glBitmap */
/* Stencil and Z testing */
if (ctx->Depth.Test || ctx->Stencil.Enabled) {
- if (span->interpMask & SPAN_Z)
+ if (!(span->arrayMask & SPAN_Z))
_swrast_span_interpolate_z(ctx, span);
if (ctx->Stencil.Enabled) {
ctx->Color.IndexLogicOpEnabled ||
ctx->Color.IndexMask != 0xffffffff ||
(span->arrayMask & SPAN_COVERAGE)) {
- if (span->interpMask & SPAN_INDEX) {
+ if (!(span->arrayMask & SPAN_INDEX) /*span->interpMask & SPAN_INDEX*/) {
interpolate_indexes(ctx, span);
}
}
_swrast_mask_ci_span(ctx, rb, span);
}
- if ((span->interpMask & SPAN_INDEX) && span->indexStep == 0) {
+ if (!(span->arrayMask & SPAN_INDEX) && span->indexStep == 0) {
/* all fragments have same color index */
GLubyte index8;
GLushort index16;
/**
- * Add specular color to base color. This is used only when
- * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
+ * Add specular colors to primary colors.
+ * Only called during fixed-function operation.
+ * Result is float color array (FRAG_ATTRIB_COL0).
*/
static INLINE void
add_specular(GLcontext *ctx, SWspan *span)
{
- switch (span->array->ChanType) {
- case GL_UNSIGNED_BYTE:
- {
- GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
- GLubyte (*spec)[4] = span->array->color.sz1.spec;
- GLuint i;
- for (i = 0; i < span->end; i++) {
- GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
- GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
- GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
- GLint a = rgba[i][ACOMP] + spec[i][ACOMP];
- rgba[i][RCOMP] = MIN2(r, 255);
- rgba[i][GCOMP] = MIN2(g, 255);
- rgba[i][BCOMP] = MIN2(b, 255);
- rgba[i][ACOMP] = MIN2(a, 255);
- }
+ const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ const GLubyte *mask = span->array->mask;
+ GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
+ GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
+ GLuint i;
+
+ ASSERT(!ctx->FragmentProgram._Current);
+ ASSERT(span->arrayMask & SPAN_RGBA);
+ ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);
+
+ if (span->array->ChanType == GL_FLOAT) {
+ if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+ interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
}
- break;
- case GL_UNSIGNED_SHORT:
- {
- GLushort (*rgba)[4] = span->array->color.sz2.rgba;
- GLushort (*spec)[4] = span->array->color.sz2.spec;
- GLuint i;
- for (i = 0; i < span->end; i++) {
- GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
- GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
- GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
- GLint a = rgba[i][ACOMP] + spec[i][ACOMP];
- rgba[i][RCOMP] = MIN2(r, 65535);
- rgba[i][GCOMP] = MIN2(g, 65535);
- rgba[i][BCOMP] = MIN2(b, 65535);
- rgba[i][ACOMP] = MIN2(a, 65535);
- }
+ }
+ else {
+ /* need float colors */
+ if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+ interpolate_float_colors(span);
}
- break;
- case GL_FLOAT:
- {
- GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
- GLfloat (*spec)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
- GLuint i;
- for (i = 0; i < span->end; i++) {
- rgba[i][RCOMP] += spec[i][RCOMP];
- rgba[i][GCOMP] += spec[i][GCOMP];
- rgba[i][BCOMP] += spec[i][BCOMP];
- rgba[i][ACOMP] += spec[i][ACOMP];
- }
+ }
+
+ if ((span->arrayAttribs & FRAG_BIT_COL1) == 0) {
+ /* XXX could avoid this and interpolate COL1 in the loop below */
+ interpolate_active_attribs(ctx, span, FRAG_BIT_COL1);
+ }
+
+ ASSERT(span->arrayAttribs & FRAG_BIT_COL0);
+ ASSERT(span->arrayAttribs & FRAG_BIT_COL1);
+
+ for (i = 0; i < span->end; i++) {
+ if (mask[i]) {
+ col0[i][0] += col1[i][0];
+ col0[i][1] += col1[i][1];
+ col0[i][2] += col1[i][2];
}
- break;
- default:
- _mesa_problem(ctx, "Invalid datatype in add_specular");
}
+
+ span->array->ChanType = GL_FLOAT;
}
const GLfloat *coverage = span->array->coverage;
GLuint i;
if (span->array->ChanType == GL_UNSIGNED_BYTE) {
- GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
+ GLubyte (*rgba)[4] = span->array->rgba8;
for (i = 0; i < span->end; i++) {
const GLfloat a = rgba[i][ACOMP] * coverage[i];
rgba[i][ACOMP] = (GLubyte) CLAMP(a, 0.0, 255.0);
}
}
else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
- GLushort (*rgba)[4] = span->array->color.sz2.rgba;
+ GLushort (*rgba)[4] = span->array->rgba16;
for (i = 0; i < span->end; i++) {
const GLfloat a = rgba[i][ACOMP] * coverage[i];
rgba[i][ACOMP] = (GLushort) CLAMP(a, 0.0, 65535.0);
GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
for (i = 0; i < span->end; i++) {
rgba[i][ACOMP] = rgba[i][ACOMP] * coverage[i];
+ /* clamp later */
}
}
}
span->array->ChanType = GL_FLOAT;
}
else if (span->array->ChanType == GL_UNSIGNED_BYTE) {
- src = span->array->color.sz1.rgba;
+ src = span->array->rgba8;
}
else {
ASSERT(span->array->ChanType == GL_UNSIGNED_SHORT);
- src = span->array->color.sz2.rgba;
+ src = span->array->rgba16;
}
if (newType == GL_UNSIGNED_BYTE) {
- dst = span->array->color.sz1.rgba;
+ dst = span->array->rgba8;
}
else if (newType == GL_UNSIGNED_SHORT) {
- dst = span->array->color.sz2.rgba;
+ dst = span->array->rgba16;
}
else {
dst = span->array->attribs[FRAG_ATTRIB_COL0];
span->end, span->array->mask);
span->array->ChanType = newType;
+ span->array->rgba = dst;
}
inputsRead = ~0;
}
- if ((inputsRead & FRAG_BIT_COL0) && (span->interpMask & SPAN_RGBA))
- interpolate_colors(span);
-
- if (ctx->Texture._EnabledCoordUnits && (span->interpMask & SPAN_TEXTURE))
- interpolate_texcoords(ctx, span);
-
if (ctx->FragmentProgram._Current ||
ctx->ATIFragmentShader._Enabled) {
- /* use float colors if running a fragment program or shader */
- const GLenum oldType = span->array->ChanType;
- const GLenum newType = GL_FLOAT;
-
- if ((inputsRead & FRAG_BIT_COL0) && (oldType != newType)) {
- GLvoid *src = (oldType == GL_UNSIGNED_BYTE)
- ? (GLvoid *) span->array->color.sz1.rgba
- : (GLvoid *) span->array->color.sz2.rgba;
- assert(span->arrayMask & SPAN_RGBA);
- _mesa_convert_colors(oldType, src,
- newType, span->array->attribs[FRAG_ATTRIB_COL0],
- span->end, span->array->mask);
+ /* programmable shading */
+ if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {
+ convert_color_type(span, GL_FLOAT, 0);
}
- span->array->ChanType = newType;
-
- /* fragment programs/shaders may need specular, fog and Z coords */
- if ((inputsRead & FRAG_BIT_COL1) && (span->interpMask & SPAN_SPEC))
- interpolate_specular(span);
-
- if ((inputsRead & FRAG_BIT_FOGC) && (span->interpMask & SPAN_FOG))
- interpolate_fog(ctx, span);
+ if (span->primitive != GL_POINT) {
+ /* for points, we populated the arrays already */
+ interpolate_active_attribs(ctx, span, ~0);
+ }
+ span->array->ChanType = GL_FLOAT;
- if (span->interpMask & SPAN_Z)
+ if (!(span->arrayMask & SPAN_Z))
_swrast_span_interpolate_z (ctx, span);
- if ((inputsRead >= FRAG_BIT_VAR0) && (span->interpMask & SPAN_VARYING))
- interpolate_varying(ctx, span);
-
+#if 0
if (inputsRead & FRAG_BIT_WPOS)
+#else
+ /* XXX always interpolate wpos so that DDX/DDY work */
+#endif
interpolate_wpos(ctx, span);
/* Run fragment program/shader now */
_swrast_exec_fragment_shader(ctx, span);
}
}
- else if (ctx->Texture._EnabledUnits && (span->arrayMask & SPAN_TEXTURE)) {
+ else if (ctx->Texture._EnabledUnits) {
/* conventional texturing */
+
+#if CHAN_BITS == 32
+ if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+ interpolate_int_colors(ctx, span);
+ }
+#else
+ if (!(span->arrayMask & SPAN_RGBA))
+ interpolate_int_colors(ctx, span);
+#endif
+ if ((span->arrayAttribs & FRAG_BITS_TEX_ANY) == 0x0)
+ interpolate_texcoords(ctx, span);
+
_swrast_texture_span(ctx, span);
}
}
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
const GLbitfield origInterpMask = span->interpMask;
const GLbitfield origArrayMask = span->arrayMask;
- const GLenum chanType = span->array->ChanType;
+ const GLbitfield origArrayAttribs = span->arrayAttribs;
+ const GLenum origChanType = span->array->ChanType;
+ void * const origRgba = span->array->rgba;
const GLboolean shader = (ctx->FragmentProgram._Current
|| ctx->ATIFragmentShader._Enabled);
const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledUnits;
struct gl_framebuffer *fb = ctx->DrawBuffer;
GLuint output;
- GLboolean deferredTexture;
/*
printf("%s() interp 0x%x array 0x%x\n", __FUNCTION__,
span->primitive == GL_POLYGON ||
span->primitive == GL_BITMAP);
ASSERT(span->end <= MAX_WIDTH);
- ASSERT((span->interpMask & span->arrayMask) == 0);
- ASSERT((span->interpMask & SPAN_RGBA) ^ (span->arrayMask & SPAN_RGBA));
-
- /* check for conditions that prevent deferred shading */
- if (ctx->Color.AlphaEnabled) {
- /* alpha test depends on post-texture/shader colors */
- deferredTexture = GL_FALSE;
- }
- else if (shaderOrTexture) {
- if (ctx->FragmentProgram._Current) {
- if (ctx->FragmentProgram._Current->Base.OutputsWritten
- & (1 << FRAG_RESULT_DEPR)) {
- /* Z comes from fragment program/shader */
- deferredTexture = GL_FALSE;
- }
- else {
- deferredTexture = GL_TRUE;
- }
- }
- else {
- /* ATI frag shader or conventional texturing */
- deferredTexture = GL_TRUE;
- }
- }
- else {
- /* no texturing or shadering */
- deferredTexture = GL_FALSE;
- }
/* Fragment write masks */
if (span->arrayMask & SPAN_MASK) {
stipple_polygon_span(ctx, span);
}
- /* This is the normal place to compute the resulting fragment color/Z.
- * As an optimization, we try to defer this until after Z/stencil
- * testing in order to try to avoid computing colors that we won't
- * actually need.
+ /* This is the normal place to compute the fragment color/Z
+ * from texturing or shading.
*/
- if (shaderOrTexture && !deferredTexture) {
+ if (shaderOrTexture && !swrast->_DeferredTexture) {
shade_texture_span(ctx, span);
}
/* Stencil and Z testing */
if (ctx->Stencil.Enabled || ctx->Depth.Test) {
- if (span->interpMask & SPAN_Z)
+ if (!(span->arrayMask & SPAN_Z))
_swrast_span_interpolate_z(ctx, span);
if (ctx->Stencil.Enabled && fb->Visual.stencilBits > 0) {
* a good chance that many fragments will have already been killed by
* Z/stencil testing.
*/
- if (deferredTexture) {
- ASSERT(shaderOrTexture);
+ if (shaderOrTexture && swrast->_DeferredTexture) {
shade_texture_span(ctx, span);
}
+#if CHAN_BITS == 32
+ if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+ interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
+ }
+#else
if ((span->arrayMask & SPAN_RGBA) == 0) {
- interpolate_colors(span);
+ interpolate_int_colors(ctx, span);
}
+#endif
ASSERT(span->arrayMask & SPAN_RGBA);
if (ctx->Fog.ColorSumEnabled ||
(ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
- if (span->interpMask & SPAN_SPEC) {
- interpolate_specular(span);
- }
- if (span->arrayMask & SPAN_SPEC) {
- add_specular(ctx, span);
- }
- else {
- /* We probably added the base/specular colors during the
- * vertex stage!
- */
- }
+ add_specular(ctx, span);
}
}
/* restore these values before returning */
span->interpMask = origInterpMask;
span->arrayMask = origArrayMask;
- span->array->ChanType = chanType;
+ span->arrayAttribs = origArrayAttribs;
+ span->array->ChanType = origChanType;
+ span->array->rgba = origRgba;
}
void *rbPixels;
/*
- * Determine pixel size (in bytes).
* Point rbPixels to a temporary space (use specular color arrays).
*/
- if (span->array->ChanType == GL_UNSIGNED_BYTE) {
- rbPixels = span->array->color.sz1.spec;
- }
- else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
- rbPixels = span->array->color.sz2.spec;
- }
- else {
- rbPixels = span->array->attribs[FRAG_ATTRIB_COL1];
- }
+ rbPixels = span->array->attribs[FRAG_ATTRIB_COL1];
/* Get destination values from renderbuffer */
if (span->arrayMask & SPAN_XY) {
projects / mesa.git / blobdiff