diff options
| author | Keith Whitwell <keith@tungstengraphics.com> | 2000-11-05 18:24:40 +0000 |
|---|---|---|
| committer | Keith Whitwell <keith@tungstengraphics.com> | 2000-11-05 18:24:40 +0000 |
| commit | cd03ed4f54444d96e4e47cdb118a3dfd94d92bb0 (patch) | |
| tree | 57d9620635286b4ee4b8adf950014113d5961017 /src/mesa | |
| parent | 7c20642b1091df1aab7d9076a3fe2fb11c6f011c (diff) | |
Reorganized software rasterizer as a module which manages its own state,
with tighter interfaces with the rest of the world.
Proper documentation to come.
Diffstat (limited to 'src/mesa')
33 files changed, 2578 insertions, 2104 deletions
diff --git a/src/mesa/swrast/s_aatriangle.c b/src/mesa/swrast/s_aatriangle.c index 347322cf65..c8f321c0c6 100644 --- a/src/mesa/swrast/s_aatriangle.c +++ b/src/mesa/swrast/s_aatriangle.c @@ -1,4 +1,4 @@ -/* $Id: s_aatriangle.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_aatriangle.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -31,6 +31,7 @@ #include "s_aatriangle.h" +#include "s_context.h" #include "s_span.h" @@ -297,7 +298,10 @@ compute_coveragei(const GLfloat v0[3], const GLfloat v1[3], static void -rgba_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +rgba_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_RGBA @@ -306,7 +310,10 @@ rgba_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) static void -index_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +index_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_INDEX @@ -334,7 +341,10 @@ compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4], static void -tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +tex_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_RGBA @@ -344,7 +354,10 @@ tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) static void -spec_tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +spec_tex_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_RGBA @@ -355,7 +368,10 @@ spec_tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) static void -multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +multitex_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_RGBA @@ -364,7 +380,10 @@ multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) } static void -spec_multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv) +spec_multitex_aa_tri(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2) { #define DO_Z #define DO_RGBA @@ -382,32 +401,34 @@ void _mesa_set_aa_triangle_function(GLcontext *ctx) { ASSERT(ctx->Polygon.SmoothFlag); - if (ctx->Texture.ReallyEnabled) { + + if (ctx->Texture._ReallyEnabled) { if (ctx->Light.Enabled && - ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) { - if (ctx->Texture.MultiTextureEnabled) { - ctx->Driver.TriangleFunc = spec_multitex_aa_tri; + (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR || + ctx->Fog.ColorSumEnabled)) { + if (ctx->Texture._MultiTextureEnabled) { + SWRAST_CONTEXT(ctx)->Triangle = spec_multitex_aa_tri; } else { - ctx->Driver.TriangleFunc = spec_tex_aa_tri; + SWRAST_CONTEXT(ctx)->Triangle = spec_tex_aa_tri; } } else { - if (ctx->Texture.MultiTextureEnabled) { - ctx->Driver.TriangleFunc = multitex_aa_tri; + if (ctx->Texture._MultiTextureEnabled) { + SWRAST_CONTEXT(ctx)->Triangle = multitex_aa_tri; } else { - ctx->Driver.TriangleFunc = tex_aa_tri; + SWRAST_CONTEXT(ctx)->Triangle = tex_aa_tri; } } } else { if (ctx->Visual.RGBAflag) { - ctx->Driver.TriangleFunc = rgba_aa_tri; + SWRAST_CONTEXT(ctx)->Triangle = rgba_aa_tri; } else { - ctx->Driver.TriangleFunc = index_aa_tri; + SWRAST_CONTEXT(ctx)->Triangle = index_aa_tri; } } - ASSERT(ctx->Driver.TriangleFunc); + ASSERT(SWRAST_CONTEXT(ctx)->Triangle); } diff --git a/src/mesa/swrast/s_aatritemp.h b/src/mesa/swrast/s_aatritemp.h index 30cc1647c7..bc4fe74497 100644 --- a/src/mesa/swrast/s_aatritemp.h +++ b/src/mesa/swrast/s_aatritemp.h @@ -1,4 +1,4 @@ -/* $Id: s_aatritemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_aatritemp.h,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -44,11 +44,10 @@ /*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/ { - const struct vertex_buffer *VB = ctx->VB; - const GLfloat *p0 = VB->Win.data[v0]; - const GLfloat *p1 = VB->Win.data[v1]; - const GLfloat *p2 = VB->Win.data[v2]; - GLint vMin, vMid, vMax; + const GLfloat *p0 = v0->win; + const GLfloat *p1 = v1->win; + const GLfloat *p2 = v2->win; + SWvertex *vMin, *vMid, *vMax; GLint iyMin, iyMax; GLfloat yMin, yMax; GLboolean ltor; @@ -87,13 +86,13 @@ GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH]; GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH]; #endif - GLfloat bf = ctx->backface_sign; + GLfloat bf = ctx->_backface_sign; /* determine bottom to top order of vertices */ { - GLfloat y0 = VB->Win.data[v0][1]; - GLfloat y1 = VB->Win.data[v1][1]; - GLfloat y2 = VB->Win.data[v2][1]; + GLfloat y0 = v0->win[1]; + GLfloat y1 = v1->win[1]; + GLfloat y2 = v2->win[1]; if (y0 <= y1) { if (y1 <= y2) { vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */ @@ -118,12 +117,12 @@ } } - majDx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0]; - majDy = VB->Win.data[vMax][1] - VB->Win.data[vMin][1]; + majDx = vMax->win[0] - vMin->win[0]; + majDy = vMax->win[1] - vMin->win[1]; { - const GLfloat botDx = VB->Win.data[vMid][0] - VB->Win.data[vMin][0]; - const GLfloat botDy = VB->Win.data[vMid][1] - VB->Win.data[vMin][1]; + const GLfloat botDx = vMid->win[0] - vMin->win[0]; + const GLfloat botDy = vMid->win[1] - vMin->win[1]; const GLfloat area = majDx * botDy - botDx * majDy; ltor = (GLboolean) (area < 0.0F); /* Do backface culling */ @@ -139,64 +138,60 @@ #ifdef DO_Z compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane); compute_plane(p0, p1, p2, - VB->FogCoordPtr->data[v0], - VB->FogCoordPtr->data[v1], - VB->FogCoordPtr->data[v2], + v0->fog, + v1->fog, + v2->fog, fogPlane); #endif #ifdef DO_RGBA if (ctx->Light.ShadeModel == GL_SMOOTH) { - GLchan (*rgba)[4] = VB->ColorPtr->data; - compute_plane(p0, p1, p2, rgba[v0][0], rgba[v1][0], rgba[v2][0], rPlane); - compute_plane(p0, p1, p2, rgba[v0][1], rgba[v1][1], rgba[v2][1], gPlane); - compute_plane(p0, p1, p2, rgba[v0][2], rgba[v1][2], rgba[v2][2], bPlane); - compute_plane(p0, p1, p2, rgba[v0][3], rgba[v1][3], rgba[v2][3], aPlane); + compute_plane(p0, p1, p2, v0->color[0], v1->color[0], v2->color[0], rPlane); + compute_plane(p0, p1, p2, v0->color[1], v1->color[1], v2->color[1], gPlane); + compute_plane(p0, p1, p2, v0->color[2], v1->color[2], v2->color[2], bPlane); + compute_plane(p0, p1, p2, v0->color[3], v1->color[3], v2->color[3], aPlane); } else { - constant_plane(VB->ColorPtr->data[pv][RCOMP], rPlane); - constant_plane(VB->ColorPtr->data[pv][GCOMP], gPlane); - constant_plane(VB->ColorPtr->data[pv][BCOMP], bPlane); - constant_plane(VB->ColorPtr->data[pv][ACOMP], aPlane); + constant_plane(v0->color[RCOMP], rPlane); + constant_plane(v0->color[GCOMP], gPlane); + constant_plane(v0->color[BCOMP], bPlane); + constant_plane(v0->color[ACOMP], aPlane); } #endif #ifdef DO_INDEX if (ctx->Light.ShadeModel == GL_SMOOTH) { - compute_plane(p0, p1, p2, VB->IndexPtr->data[v0], - VB->IndexPtr->data[v1], VB->IndexPtr->data[v2], iPlane); + compute_plane(p0, p1, p2, v0->index, + v1->index, v2->index, iPlane); } else { - constant_plane(VB->IndexPtr->data[pv], iPlane); + constant_plane(v0->index, iPlane); } #endif #ifdef DO_SPEC { - GLchan (*spec)[4] = VB->SecondaryColorPtr->data; - compute_plane(p0, p1, p2, spec[v0][0], spec[v1][0], spec[v2][0],srPlane); - compute_plane(p0, p1, p2, spec[v0][1], spec[v1][1], spec[v2][1],sgPlane); - compute_plane(p0, p1, p2, spec[v0][2], spec[v1][2], spec[v2][2],sbPlane); + compute_plane(p0, p1, p2, v0->specular[0], v1->specular[0], v2->specular[0],srPlane); + compute_plane(p0, p1, p2, v0->specular[1], v1->specular[1], v2->specular[1],sgPlane); + compute_plane(p0, p1, p2, v0->specular[2], v1->specular[2], v2->specular[2],sbPlane); } #endif #ifdef DO_TEX { - const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; + const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current; const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel]; - const GLint tSize = 3; - const GLfloat invW0 = VB->Win.data[v0][3]; - const GLfloat invW1 = VB->Win.data[v1][3]; - const GLfloat invW2 = VB->Win.data[v2][3]; - GLfloat (*texCoord)[4] = VB->TexCoordPtr[0]->data; - const GLfloat s0 = texCoord[v0][0] * invW0; - const GLfloat s1 = texCoord[v1][0] * invW1; - const GLfloat s2 = texCoord[v2][0] * invW2; - const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F; - const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F; - const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F; - const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F; - const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F; - const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F; - const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0; - const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1; - const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2; + const GLfloat invW0 = v0->win[3]; + const GLfloat invW1 = v1->win[3]; + const GLfloat invW2 = v2->win[3]; + const GLfloat s0 = v0->texcoord[0][0] * invW0; + const GLfloat s1 = v1->texcoord[0][0] * invW1; + const GLfloat s2 = v2->texcoord[0][0] * invW2; + const GLfloat t0 = v0->texcoord[0][1] * invW0; + const GLfloat t1 = v1->texcoord[0][1] * invW1; + const GLfloat t2 = v2->texcoord[0][1] * invW2; + const GLfloat r0 = v0->texcoord[0][2] * invW0; + const GLfloat r1 = v1->texcoord[0][2] * invW1; + const GLfloat r2 = v2->texcoord[0][2] * invW2; + const GLfloat q0 = v0->texcoord[0][3] * invW0; + const GLfloat q1 = v1->texcoord[0][3] * invW1; + const GLfloat q2 = v2->texcoord[0][3] * invW2; compute_plane(p0, p1, p2, s0, s1, s2, sPlane); compute_plane(p0, p1, p2, t0, t1, t2, tPlane); compute_plane(p0, p1, p2, r0, r1, r2, uPlane); @@ -208,26 +203,24 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - const struct gl_texture_object *obj = ctx->Texture.Unit[u].Current; + if (ctx->Texture.Unit[u]._ReallyEnabled) { + const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current; const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel]; - const GLint tSize = VB->TexCoordPtr[u]->size; - const GLfloat invW0 = VB->Win.data[v0][3]; - const GLfloat invW1 = VB->Win.data[v1][3]; - const GLfloat invW2 = VB->Win.data[v2][3]; - GLfloat (*texCoord)[4] = VB->TexCoordPtr[u]->data; - const GLfloat s0 = texCoord[v0][0] * invW0; - const GLfloat s1 = texCoord[v1][0] * invW1; - const GLfloat s2 = texCoord[v2][0] * invW2; - const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F; - const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F; - const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F; - const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F; - const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F; - const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F; - const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0; - const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1; - const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2; + const GLfloat invW0 = v0->win[3]; + const GLfloat invW1 = v1->win[3]; + const GLfloat invW2 = v2->win[3]; + const GLfloat s0 = v0->texcoord[u][0] * invW0; + const GLfloat s1 = v1->texcoord[u][0] * invW1; + const GLfloat s2 = v2->texcoord[u][0] * invW2; + const GLfloat t0 = v0->texcoord[u][1] * invW0; + const GLfloat t1 = v1->texcoord[u][1] * invW1; + const GLfloat t2 = v2->texcoord[u][1] * invW2; + const GLfloat r0 = v0->texcoord[u][2] * invW0; + const GLfloat r1 = v1->texcoord[u][2] * invW1; + const GLfloat r2 = v2->texcoord[u][2] * invW2; + const GLfloat q0 = v0->texcoord[u][3] * invW0; + const GLfloat q1 = v1->texcoord[u][3] * invW1; + const GLfloat q2 = v2->texcoord[u][3] * invW2; compute_plane(p0, p1, p2, s0, s1, s2, sPlane[u]); compute_plane(p0, p1, p2, t0, t1, t2, tPlane[u]); compute_plane(p0, p1, p2, r0, r1, r2, uPlane[u]); @@ -239,19 +232,19 @@ } #endif - yMin = VB->Win.data[vMin][1]; - yMax = VB->Win.data[vMax][1]; + yMin = vMin->win[1]; + yMax = vMax->win[1]; iyMin = (int) yMin; iyMax = (int) yMax + 1; if (ltor) { /* scan left to right */ - const float *pMin = VB->Win.data[vMin]; - const float *pMid = VB->Win.data[vMid]; - const float *pMax = VB->Win.data[vMax]; + const float *pMin = vMin->win; + const float *pMid = vMid->win; + const float *pMax = vMax->win; const float dxdy = majDx / majDy; const float xAdj = dxdy < 0.0F ? -dxdy : 0.0F; - float x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy; + float x = vMin->win[0] - (yMin - iyMin) * dxdy; int iy; for (iy = iyMin; iy < iyMax; iy++, x += dxdy) { GLint ix, startX = (GLint) (x - xAdj); @@ -304,7 +297,7 @@ { GLuint unit; for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit].ReallyEnabled) { + if (ctx->Texture.Unit[unit]._ReallyEnabled) { GLfloat invQ = solve_plane_recip(ix, iy, vPlane[unit]); s[unit][count] = solve_plane(ix, iy, sPlane[unit]) * invQ; t[unit][count] = solve_plane(ix, iy, tPlane[unit]) * invQ; @@ -356,12 +349,12 @@ } else { /* scan right to left */ - const GLfloat *pMin = VB->Win.data[vMin]; - const GLfloat *pMid = VB->Win.data[vMid]; - const GLfloat *pMax = VB->Win.data[vMax]; + const GLfloat *pMin = vMin->win; + const GLfloat *pMid = vMid->win; + const GLfloat *pMax = vMax->win; const GLfloat dxdy = majDx / majDy; const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F; - GLfloat x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy; + GLfloat x = vMin->win[0] - (yMin - iyMin) * dxdy; GLint iy; for (iy = iyMin; iy < iyMax; iy++, x += dxdy) { GLint ix, left, startX = (GLint) (x + xAdj); @@ -414,7 +407,7 @@ { GLuint unit; for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit].ReallyEnabled) { + if (ctx->Texture.Unit[unit]._ReallyEnabled) { GLfloat invQ = solve_plane_recip(ix, iy, vPlane[unit]); s[unit][ix] = solve_plane(ix, iy, sPlane[unit]) * invQ; t[unit][ix] = solve_plane(ix, iy, tPlane[unit]) * invQ; @@ -436,7 +429,7 @@ { GLuint unit; for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit].ReallyEnabled) { + if (ctx->Texture.Unit[unit]._ReallyEnabled) { GLint j; for (j = 0; j < n; j++) { s[unit][j] = s[unit][j + left]; diff --git a/src/mesa/swrast/s_accum.c b/src/mesa/swrast/s_accum.c index 21ac29153c..ff12c53050 100644 --- a/src/mesa/swrast/s_accum.c +++ b/src/mesa/swrast/s_accum.c @@ -1,4 +1,4 @@ -/* $Id: s_accum.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_accum.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -30,6 +30,7 @@ #include "mem.h" #include "s_accum.h" +#include "s_context.h" #include "s_masking.h" #include "s_span.h" @@ -119,6 +120,116 @@ static void rescale_accum( GLcontext *ctx ) + + + +/* + * Clear the accumulation Buffer. + */ +void +_mesa_clear_accum_buffer( GLcontext *ctx ) +{ + GLuint buffersize; + GLfloat acc_scale; + + if (ctx->Visual.AccumRedBits==0) { + /* No accumulation buffer! */ + return; + } + + if (sizeof(GLaccum)==1) { + acc_scale = 127.0; + } + else if (sizeof(GLaccum)==2) { + acc_scale = 32767.0; + } + else { + /* sizeof(GLaccum) > 2 (Cray) */ + acc_scale = (float) SHRT_MAX; + } + + /* number of pixels */ + buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height; + + if (!ctx->DrawBuffer->Accum) { + /* try to alloc accumulation buffer */ + ctx->DrawBuffer->Accum = (GLaccum *) + MALLOC( buffersize * 4 * sizeof(GLaccum) ); + } + + if (ctx->DrawBuffer->Accum) { + if (ctx->Scissor.Enabled) { + /* Limit clear to scissor box */ + GLaccum r, g, b, a; + GLint i, j; + GLint width, height; + GLaccum *row; + r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale); + g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale); + b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale); + a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale); + /* size of region to clear */ + width = 4 * (ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin); + height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin; + /* ptr to first element to clear */ + row = ctx->DrawBuffer->Accum + + 4 * (ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width + + ctx->DrawBuffer->Xmin); + for (j=0;j<height;j++) { + for (i=0;i<width;i+=4) { + row[i+0] = r; + row[i+1] = g; + row[i+2] = b; + row[i+3] = a; + } + row += 4 * ctx->DrawBuffer->Width; + } + } + else { + /* clear whole buffer */ + if (ctx->Accum.ClearColor[0]==0.0 && + ctx->Accum.ClearColor[1]==0.0 && + ctx->Accum.ClearColor[2]==0.0 && + ctx->Accum.ClearColor[3]==0.0) { + /* Black */ + BZERO( ctx->DrawBuffer->Accum, buffersize * 4 * sizeof(GLaccum) ); + } + else { + /* Not black */ + GLaccum *acc, r, g, b, a; + GLuint i; + + acc = ctx->DrawBuffer->Accum; + r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale); + g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale); + b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale); + a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale); + for (i=0;i<buffersize;i++) { + *acc++ = r; + *acc++ = g; + *acc++ = b; + *acc++ = a; + } + } + } + + /* update optimized accum state vars */ + if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 && + ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) { +#ifdef USE_OPTIMIZED_ACCUM + ctx->IntegerAccumMode = GL_TRUE; +#else + ctx->IntegerAccumMode = GL_FALSE; +#endif + ctx->IntegerAccumScaler = 0.0; /* denotes empty accum buffer */ + } + else { + ctx->IntegerAccumMode = GL_FALSE; + } + } +} + + void _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value, GLint xpos, GLint ypos, @@ -133,8 +244,13 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value, const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1; + if (SWRAST_CONTEXT(ctx)->NewState) + _swrast_validate_derived( ctx ); + if (!ctx->DrawBuffer->Accum) { - _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer (low memory?)"); + _mesa_warning(ctx, + "Calling glAccum() without an accumulation " + "buffer (low memory?)"); return; } @@ -389,111 +505,3 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value, gl_error( ctx, GL_INVALID_ENUM, "glAccum" ); } } - - - -/* - * Clear the accumulation Buffer. - */ -void -_mesa_clear_accum_buffer( GLcontext *ctx ) -{ - GLuint buffersize; - GLfloat acc_scale; - - if (ctx->Visual.AccumRedBits==0) { - /* No accumulation buffer! */ - return; - } - - if (sizeof(GLaccum)==1) { - acc_scale = 127.0; - } - else if (sizeof(GLaccum)==2) { - acc_scale = 32767.0; - } - else { - /* sizeof(GLaccum) > 2 (Cray) */ - acc_scale = (float) SHRT_MAX; - } - - /* number of pixels */ - buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height; - - if (!ctx->DrawBuffer->Accum) { - /* try to alloc accumulation buffer */ - ctx->DrawBuffer->Accum = (GLaccum *) - MALLOC( buffersize * 4 * sizeof(GLaccum) ); - } - - if (ctx->DrawBuffer->Accum) { - if (ctx->Scissor.Enabled) { - /* Limit clear to scissor box */ - GLaccum r, g, b, a; - GLint i, j; - GLint width, height; - GLaccum *row; - r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale); - g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale); - b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale); - a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale); - /* size of region to clear */ - width = 4 * (ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin); - height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin; - /* ptr to first element to clear */ - row = ctx->DrawBuffer->Accum - + 4 * (ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width - + ctx->DrawBuffer->Xmin); - for (j=0;j<height;j++) { - for (i=0;i<width;i+=4) { - row[i+0] = r; - row[i+1] = g; - row[i+2] = b; - row[i+3] = a; - } - row += 4 * ctx->DrawBuffer->Width; - } - } - else { - /* clear whole buffer */ - if (ctx->Accum.ClearColor[0]==0.0 && - ctx->Accum.ClearColor[1]==0.0 && - ctx->Accum.ClearColor[2]==0.0 && - ctx->Accum.ClearColor[3]==0.0) { - /* Black */ - BZERO( ctx->DrawBuffer->Accum, buffersize * 4 * sizeof(GLaccum) ); - } - else { - /* Not black */ - GLaccum *acc, r, g, b, a; - GLuint i; - - acc = ctx->DrawBuffer->Accum; - r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale); - g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale); - b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale); - a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale); - for (i=0;i<buffersize;i++) { - *acc++ = r; - *acc++ = g; - *acc++ = b; - *acc++ = a; - } - } - } - - /* update optimized accum state vars */ - if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 && - ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) { -#ifdef USE_OPTIMIZED_ACCUM - ctx->IntegerAccumMode = GL_TRUE; -#else - ctx->IntegerAccumMode = GL_FALSE; -#endif - ctx->IntegerAccumScaler = 0.0; /* denotes empty accum buffer */ - } - else { - ctx->IntegerAccumMode = GL_FALSE; - } - } -} diff --git a/src/mesa/swrast/s_bitmap.c b/src/mesa/swrast/s_bitmap.c index 646081b83e..f11186baed 100644 --- a/src/mesa/swrast/s_bitmap.c +++ b/src/mesa/swrast/s_bitmap.c @@ -1,4 +1,4 @@ -/* $Id: s_bitmap.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_bitmap.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -30,6 +30,7 @@ #include "macros.h" #include "pixel.h" +#include "s_context.h" #include "s_fog.h" #include "s_pb.h" @@ -44,7 +45,7 @@ _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py, const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap ) { - struct pixel_buffer *PB = ctx->PB; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; GLint row, col; GLdepth fragZ; GLfixed fogCoord; @@ -52,9 +53,12 @@ _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py, ASSERT(ctx->RenderMode == GL_RENDER); ASSERT(bitmap); - if (ctx->PB->primitive != GL_BITMAP) { + if (SWRAST_CONTEXT(ctx)->NewState) + _swrast_validate_derived( ctx ); + + if (PB->primitive != GL_BITMAP) { gl_flush_pb( ctx ); - ctx->PB->primitive = GL_BITMAP; + PB->primitive = GL_BITMAP; } /* Set bitmap drawing color */ diff --git a/src/mesa/swrast/s_blend.c b/src/mesa/swrast/s_blend.c index 0e65229c4a..9b13a10903 100644 --- a/src/mesa/swrast/s_blend.c +++ b/src/mesa/swrast/s_blend.c @@ -1,4 +1,4 @@ -/* $Id: s_blend.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_blend.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -32,16 +32,20 @@ #include "s_alphabuf.h" #include "s_blend.h" +#include "s_context.h" #include "s_pb.h" #include "s_span.h" -#ifdef USE_MMX_ASM +#if defined(USE_MMX_ASM) +#include "X86/mmx.h" +#include "X86/common_x86_asm.h" #define _BLENDAPI _ASMAPI #else #define _BLENDAPI #endif + /* * Common transparency blending mode. */ @@ -547,17 +551,13 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], -#if defined(USE_MMX_ASM) -#include "X86/mmx.h" -#include "X86/common_x86_asm.h" -#endif /* * Analyze current blending parameters to pick fastest blending function. * Result: the ctx->Color.BlendFunc pointer is updated. */ -static void set_blend_function( GLcontext *ctx ) +void _swrast_choose_blend_func( GLcontext *ctx ) { const GLenum eq = ctx->Color.BlendEquation; const GLenum srcRGB = ctx->Color.BlendSrcRGB; @@ -565,40 +565,38 @@ static void set_blend_function( GLcontext *ctx ) const GLenum srcA = ctx->Color.BlendSrcA; const GLenum dstA = ctx->Color.BlendDstA; -#if defined(USE_MMX_ASM) - /* Hmm. A table here would have 12^4 == way too many entries. - * Provide a hook for MMX instead. - */ - if ( cpu_has_mmx ) { - gl_mmx_set_blend_function( ctx ); - } - else -#endif if (srcRGB != srcA || dstRGB != dstA) { - ctx->Color.BlendFunc = blend_general; + SWRAST_CONTEXT(ctx)->BlendFunc = blend_general; } else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA - && dstRGB==GL_ONE_MINUS_SRC_ALPHA) { - ctx->Color.BlendFunc = blend_transparency; + && dstRGB==GL_ONE_MINUS_SRC_ALPHA) + { +#if defined(USE_MMX_ASM) + if ( cpu_has_mmx ) { + SWRAST_CONTEXT(ctx)->BlendFunc = gl_mmx_blend_transparency; + } + else +#endif + SWRAST_CONTEXT(ctx)->BlendFunc = blend_transparency; } else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) { - ctx->Color.BlendFunc = blend_add; + SWRAST_CONTEXT(ctx)->BlendFunc = blend_add; } else if (((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_REVERSE_SUBTRACT_EXT) - && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR)) - || - ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT) - && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) { - ctx->Color.BlendFunc = blend_modulate; + && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR)) + || + ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT) + && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) { + SWRAST_CONTEXT(ctx)->BlendFunc = blend_modulate; } else if (eq==GL_MIN_EXT) { - ctx->Color.BlendFunc = blend_min; + SWRAST_CONTEXT(ctx)->BlendFunc = blend_min; } else if (eq==GL_MAX_EXT) { - ctx->Color.BlendFunc = blend_max; + SWRAST_CONTEXT(ctx)->BlendFunc = blend_max; } else { - ctx->Color.BlendFunc = blend_general; + SWRAST_CONTEXT(ctx)->BlendFunc = blend_general; } } @@ -626,10 +624,8 @@ _mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y, /* Read span of current frame buffer pixels */ gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest ); - if (!ctx->Color.BlendFunc) - set_blend_function(ctx); - - (*ctx->Color.BlendFunc)( ctx, n, mask, rgba, (const GLchan (*)[4])dest ); + SWRAST_CONTEXT(ctx)->BlendFunc( ctx, n, mask, rgba, + (const GLchan (*)[4])dest ); } @@ -646,6 +642,7 @@ _mesa_blend_pixels( GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLchan rgba[][4], const GLubyte mask[] ) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); GLchan dest[PB_SIZE][4]; /* Check if device driver can do the work */ @@ -656,12 +653,11 @@ _mesa_blend_pixels( GLcontext *ctx, /* Read pixels from current color buffer */ (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask ); - if (ctx->RasterMask & ALPHABUF_BIT) { + if (swrast->_RasterMask & ALPHABUF_BIT) { _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask ); } - if (!ctx->Color.BlendFunc) - set_blend_function(ctx); - - (*ctx->Color.BlendFunc)( ctx, n, mask, rgba, (const GLchan (*)[4])dest ); + swrast->BlendFunc( ctx, n, mask, rgba, (const GLchan (*)[4])dest ); } + + diff --git a/src/mesa/swrast/s_blend.h b/src/mesa/swrast/s_blend.h index 45c32f9088..1323ed15dc 100644 --- a/src/mesa/swrast/s_blend.h +++ b/src/mesa/swrast/s_blend.h @@ -1,4 +1,4 @@ -/* $Id: s_blend.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_blend.h,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -44,6 +44,8 @@ _mesa_blend_pixels( GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLchan rgba[][4], const GLubyte mask[] ); +extern void +_swrast_choose_blend_func( GLcontext *ctx ); #endif diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c index 87a2001849..b17b6052db 100644 --- a/src/mesa/swrast/s_context.c +++ b/src/mesa/swrast/s_context.c @@ -1,4 +1,4 @@ -/* $Id: s_context.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_context.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -22,28 +22,365 @@ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@valinux.com> */ - #include "glheader.h" +#include "types.h" +#include "mem.h" #include "s_pb.h" +#include "s_points.h" +#include "s_lines.h" +#include "s_triangle.h" +#include "s_quads.h" +#include "s_blend.h" +#include "s_context.h" +#include "s_texture.h" -GLboolean -_swrast_create_context( GLcontext *ctx ) + + + +/* + * Recompute the value of swrast->_RasterMask, etc. according to + * the current context. + */ +static void +_swrast_update_rasterflags( GLcontext *ctx ) { - ctx->PB = gl_alloc_pb(); - if (!ctx->PB) return GL_FALSE; + GLuint RasterMask = 0; - return GL_TRUE; + if (ctx->Color.AlphaEnabled) RasterMask |= ALPHATEST_BIT; + if (ctx->Color.BlendEnabled) RasterMask |= BLEND_BIT; + if (ctx->Depth.Test) RasterMask |= DEPTH_BIT; + if (ctx->Fog.Enabled) RasterMask |= FOG_BIT; + if (ctx->Scissor.Enabled) RasterMask |= SCISSOR_BIT; + if (ctx->Stencil.Enabled) RasterMask |= STENCIL_BIT; + if (ctx->Visual.RGBAflag) { + const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); + if (colorMask != 0xffffffff) RasterMask |= MASKING_BIT; + if (ctx->Color.ColorLogicOpEnabled) RasterMask |= LOGIC_OP_BIT; + if (ctx->Texture._ReallyEnabled) RasterMask |= TEXTURE_BIT; + } + else { + if (ctx->Color.IndexMask != 0xffffffff) RasterMask |= MASKING_BIT; + if (ctx->Color.IndexLogicOpEnabled) RasterMask |= LOGIC_OP_BIT; + } + + if (ctx->DrawBuffer->UseSoftwareAlphaBuffers + && ctx->Color.ColorMask[ACOMP] + && ctx->Color.DrawBuffer != GL_NONE) + RasterMask |= ALPHABUF_BIT; + + if ( ctx->Viewport.X < 0 + || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width + || ctx->Viewport.Y < 0 + || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) { + RasterMask |= WINCLIP_BIT; + } + + if (ctx->Depth.OcclusionTest) + RasterMask |= OCCLUSION_BIT; + + + /* If we're not drawing to exactly one color buffer set the + * MULTI_DRAW_BIT flag. Also set it if we're drawing to no + * buffers or the RGBA or CI mask disables all writes. + */ + if (ctx->Color.MultiDrawBuffer) { + RasterMask |= MULTI_DRAW_BIT; + } + else if (ctx->Color.DrawBuffer==GL_NONE) { + RasterMask |= MULTI_DRAW_BIT; + } + else if (ctx->Visual.RGBAflag && *((GLuint *) ctx->Color.ColorMask) == 0) { + RasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */ + } + else if (!ctx->Visual.RGBAflag && ctx->Color.IndexMask==0) { + RasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */ + } + + if ( ctx->Viewport.X<0 + || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width + || ctx->Viewport.Y<0 + || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) { + RasterMask |= WINCLIP_BIT; + } + + SWRAST_CONTEXT(ctx)->_RasterMask = RasterMask; +} + + + +#define _SWRAST_NEW_TRIANGLE (_NEW_RENDERMODE| \ + _NEW_POLYGON| \ + _NEW_DEPTH| \ + _NEW_STENCIL| \ + _NEW_COLOR| \ + _NEW_TEXTURE| \ + _NEW_HINT| \ + _SWRAST_NEW_RASTERMASK| \ + _NEW_LIGHT| \ + _NEW_FOG) + +#define _SWRAST_NEW_LINE (_NEW_RENDERMODE| \ + _NEW_LINE| \ + _NEW_TEXTURE| \ + _NEW_LIGHT| \ + _NEW_FOG| \ + _NEW_DEPTH) + +#define _SWRAST_NEW_POINT (_NEW_RENDERMODE | \ + _NEW_POINT | \ + _NEW_TEXTURE | \ + _NEW_LIGHT | \ + _NEW_FOG) + +#define _SWRAST_NEW_QUAD 0 + +#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE + +#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR + + + +/* Stub for swrast->Triangle to select a true triangle function + * after a state change. + */ +static void +_swrast_validate_quad( GLcontext *ctx, + SWvertex *v0, SWvertex *v1, SWvertex *v2, SWvertex *v3 ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + swrast->choose_quad( ctx ); + + swrast->Quad( ctx, v0, v1, v2, v3 ); +} + +static void +_swrast_validate_triangle( GLcontext *ctx, + SWvertex *v0, SWvertex *v1, SWvertex *v2 ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + swrast->choose_triangle( ctx ); + + swrast->Triangle( ctx, v0, v1, v2 ); } +static void +_swrast_validate_line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + swrast->choose_line( ctx ); + + swrast->Line( ctx, v0, v1 ); +} + +static void +_swrast_validate_point( GLcontext *ctx, SWvertex *v0 ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + swrast->choose_point( ctx ); + + swrast->Point( ctx, v0 ); +} + +void +_swrast_validate_blend_func( GLcontext *ctx, GLuint n, + const GLubyte mask[], + GLchan src[][4], + CONST GLchan dst[][4] ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + _swrast_choose_blend_func( ctx ); + + swrast->BlendFunc( ctx, n, mask, src, dst ); +} + + +void +_swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, + GLuint n, + const GLfloat s[], const GLfloat t[], + const GLfloat u[], const GLfloat lambda[], + GLchan rgba[][4] ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + _swrast_validate_derived( ctx ); + _swrast_choose_texture_sample_func( ctx, texUnit, tObj ); + + swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, s, t, u, + lambda, rgba ); +} + + +static void +_swrast_sleep( GLcontext *ctx, GLuint new_state ) +{ +} + + +static void +_swrast_invalidate_state( GLcontext *ctx, GLuint new_state ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GLuint i; + + swrast->NewState |= new_state; + + /* After 10 statechanges without any swrast functions being called, + * put the module to sleep. + */ + if (++swrast->StateChanges > 10) { + swrast->InvalidateState = _swrast_sleep; + swrast->NewState = ~0; + new_state = ~0; + } + + if (new_state & swrast->invalidate_triangle) + swrast->Triangle = _swrast_validate_triangle; + + if (new_state & swrast->invalidate_line) + swrast->Line = _swrast_validate_line; + + if (new_state & swrast->invalidate_point) + swrast->Point = _swrast_validate_point; + + if (new_state & swrast->invalidate_quad) + swrast->Quad = _swrast_validate_quad; + + if (new_state & _SWRAST_NEW_BLEND_FUNC) + swrast->BlendFunc = _swrast_validate_blend_func; + + if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC) + for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) + swrast->TextureSample[i] = _swrast_validate_texture_sample; +} + + + void -_swrast_destroy_context( GLcontext *ctx ) +_swrast_validate_derived( GLcontext *ctx ) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (swrast->NewState) + { + if (swrast->NewState & _SWRAST_NEW_RASTERMASK) + _swrast_update_rasterflags( ctx ); + + swrast->NewState = 0; + swrast->StateChanges = 0; + swrast->InvalidateState = _swrast_invalidate_state; + } } +/* Public entrypoints: See also s_accum.c, s_bitmap.c, etc. + */ +void +_swrast_Quad( GLcontext *ctx, + SWvertex *v0, SWvertex *v1, SWvertex *v2, SWvertex *v3 ) +{ + SWRAST_CONTEXT(ctx)->Quad( ctx, v0, v1, v2, v3 ); +} + +void +_swrast_Triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2 ) +{ + SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 ); +} + +void +_swrast_Line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ) +{ + SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 ); +} + +void +_swrast_Point( GLcontext *ctx, SWvertex *v0 ) +{ + SWRAST_CONTEXT(ctx)->Point( ctx, v0 ); +} + +void +_swrast_InvalidateState( GLcontext *ctx, GLuint new_state ) +{ + SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state ); +} + + +GLuint * +_swrast_get_stipple_counter_ref( GLcontext *ctx ) +{ + return &SWRAST_CONTEXT(ctx)->StippleCounter; +} + + +GLboolean +_swrast_CreateContext( GLcontext *ctx ) +{ + GLuint i; + SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext)); + if (!swrast) + return GL_FALSE; + + swrast->PB = gl_alloc_pb(); + if (!swrast->PB) { + FREE(swrast); + return GL_FALSE; + } + + swrast->NewState = ~0; + + swrast->choose_point = _swrast_choose_point; + swrast->choose_line = _swrast_choose_line; + swrast->choose_triangle = _swrast_choose_triangle; + swrast->choose_quad = _swrast_choose_quad; + + swrast->invalidate_point = _SWRAST_NEW_POINT; + swrast->invalidate_line = _SWRAST_NEW_LINE; + swrast->invalidate_triangle = _SWRAST_NEW_TRIANGLE; + swrast->invalidate_quad = _SWRAST_NEW_QUAD; + + swrast->Point = _swrast_validate_point; + swrast->Line = _swrast_validate_line; + swrast->Triangle = _swrast_validate_triangle; + swrast->Quad = _swrast_validate_quad; + swrast->InvalidateState = _swrast_sleep; + swrast->BlendFunc = _swrast_validate_blend_func; + + for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) + swrast->TextureSample[i] = _swrast_validate_texture_sample; + + ctx->swrast_context = swrast; + return GL_TRUE; +} + +void +_swrast_DestroyContext( GLcontext *ctx ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + FREE( swrast->PB ); + FREE( swrast ); + + ctx->swrast_context = 0; +} diff --git a/src/mesa/swrast/s_context.h b/src/mesa/swrast/s_context.h new file mode 100644 index 0000000000..493758ad69 --- /dev/null +++ b/src/mesa/swrast/s_context.h @@ -0,0 +1,145 @@ +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999 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 + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@valinux.com> + */ + +#ifndef S_CONTEXT_H +#define S_CONTEXT_H + +#include "types.h" +#include "swrast.h" + +/* + * For texture sampling: + */ +typedef void (*TextureSampleFunc)( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, + GLuint n, + const GLfloat s[], const GLfloat t[], + const GLfloat u[], const GLfloat lambda[], + GLchan rgba[][4] ); + + + +/* + * Blending function + */ +#ifdef USE_MMX_ASM +typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n, + const GLubyte mask[], + GLchan src[][4], CONST GLchan dst[][4] ); +#else +typedef void (*blend_func)( GLcontext *ctx, GLuint n, const GLubyte mask[], + GLchan src[][4], CONST GLchan dst[][4] ); +#endif + +typedef void (*swrast_tri_func)( GLcontext *ctx, + SWvertex *, SWvertex *, SWvertex *); +typedef void (*swrast_line_func)( GLcontext *ctx, SWvertex *, SWvertex *); +typedef void (*swrast_point_func)( GLcontext *ctx, SWvertex *); + +/* + * Bitmasks to indicate which rasterization options are enabled (RasterMask) + */ +#define ALPHATEST_BIT 0x001 /* Alpha-test pixels */ +#define BLEND_BIT 0x002 /* Blend pixels */ +#define DEPTH_BIT 0x004 /* Depth-test pixels */ +#define FOG_BIT 0x008 /* Fog pixels */ +#define LOGIC_OP_BIT 0x010 /* Apply logic op in software */ +#define SCISSOR_BIT 0x020 /* Scissor pixels */ +#define STENCIL_BIT 0x040 /* Stencil pixels */ +#define MASKING_BIT 0x080 /* Do glColorMask or glIndexMask */ +#define ALPHABUF_BIT 0x100 /* Using software alpha buffer */ +#define WINCLIP_BIT 0x200 /* Clip pixels/primitives to window */ +#define MULTI_DRAW_BIT 0x400 /* Write to more than one color- */ + /* buffer or no buffers. */ +#define OCCLUSION_BIT 0x800 /* GL_HP_occlusion_test enabled */ +#define TEXTURE_BIT 0x1000 /* Texturing really enabled */ + + +#define _SWRAST_NEW_RASTERMASK (_NEW_BUFFERS| \ + _NEW_SCISSOR| \ + _NEW_COLOR| \ + _NEW_DEPTH| \ + _NEW_FOG| \ + _NEW_STENCIL| \ + _NEW_TEXTURE| \ + _NEW_VIEWPORT| \ + _NEW_DEPTH) + + + +typedef struct +{ + GLuint NewState; + GLuint StateChanges; + + GLuint _RasterMask; + GLuint _MinMagThresh[MAX_TEXTURE_UNITS]; + + struct pixel_buffer* PB; + GLuint StippleCounter; /* Line stipple counter */ + + + /* Mechanism to allow driver (like X11) to register further + * software rasterization routines. + */ + void (*choose_point)( GLcontext * ); + void (*choose_line)( GLcontext * ); + void (*choose_triangle)( GLcontext * ); + void (*choose_quad)( GLcontext * ); + + GLuint invalidate_point; + GLuint invalidate_line; + GLuint invalidate_triangle; + GLuint invalidate_quad; + + + /* Function pointers for dispatch behind public entrypoints. + */ + void (*InvalidateState)( GLcontext *ctx, GLuint new_state ); + void (*Point)( GLcontext *ctx, SWvertex *v ); + void (*Line)( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ); + void (*Triangle)( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2 ); + void (*Quad)( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2, + SWvertex *v3); + + /* Internal hooks, kept uptodate by the same mechanism as above. + */ + blend_func BlendFunc; + TextureSampleFunc TextureSample[MAX_TEXTURE_UNITS]; + +} SWcontext; + + +void +_swrast_validate_derived( GLcontext *ctx ); + + +#define SWRAST_CONTEXT(ctx) ((SWcontext *)ctx->swrast_context) + + + +#endif diff --git a/src/mesa/swrast/s_copypix.c b/src/mesa/swrast/s_copypix.c index baa9b0454d..a379cf0d5c 100644 --- a/src/mesa/swrast/s_copypix.c +++ b/src/mesa/swrast/s_copypix.c @@ -1,4 +1,4 @@ -/* $Id: s_copypix.c,v 1.2 2000/10/31 23:11:06 brianp Exp $ */ +/* $Id: s_copypix.c,v 1.3 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -35,6 +35,7 @@ #include "mmath.h" #include "pixel.h" +#include "s_context.h" #include "s_depth.h" #include "s_imaging.h" #include "s_pixeltex.h" @@ -81,7 +82,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, GLboolean changeBuffer; GLchan *saveReadAlpha; const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; - const GLuint transferOps = ctx->ImageTransferState; + const GLuint transferOps = ctx->_ImageTransferState; GLfloat *dest, *tmpImage, *convImage; if (ctx->Depth.Test || ctx->Fog.Enabled) { @@ -94,7 +95,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, } } - if (ctx->RasterMask == 0 + if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && destx >= 0 && destx + width <= ctx->DrawBuffer->Width) { @@ -231,7 +232,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX); } - if (ctx->Texture.ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { + if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH]; GLchan primary_rgba[MAX_WIDTH][4]; GLuint unit; @@ -284,7 +285,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, GLchan *saveReadAlpha; const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; GLint overlapping; - const GLuint transferOps = ctx->ImageTransferState; + const GLuint transferOps = ctx->_ImageTransferState; if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) { copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty); @@ -316,7 +317,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, } } - if (ctx->RasterMask == 0 + if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && destx >= 0 && destx + width <= ctx->DrawBuffer->Width) { @@ -461,7 +462,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy, } } - if (ctx->Texture.ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { + if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH]; GLchan primary_rgba[MAX_WIDTH][4]; GLuint unit; @@ -817,6 +818,9 @@ _swrast_CopyPixels( GLcontext *ctx, GLint destx, GLint desty, GLenum type ) { + if (SWRAST_CONTEXT(ctx)->NewState) + _swrast_validate_derived( ctx ); + if (type == GL_COLOR && ctx->Visual.RGBAflag) { copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty ); } diff --git a/src/mesa/swrast/s_depth.c b/src/mesa/swrast/s_depth.c index e9dd63093c..3186f8ea27 100644 --- a/src/mesa/swrast/s_depth.c +++ b/src/mesa/swrast/s_depth.c @@ -1,4 +1,4 @@ -/* $Id: s_depth.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_depth.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -31,6 +31,7 @@ #include "mem.h" #include "s_depth.h" +#include "s_context.h" #include "s_pb.h" diff --git a/src/mesa/swrast/s_drawpix.c b/src/mesa/swrast/s_drawpix.c index ba6ea07e54..4d119eff1e 100644 --- a/src/mesa/swrast/s_drawpix.c +++ b/src/mesa/swrast/s_drawpix.c @@ -1,4 +1,4 @@ -/* $Id: s_drawpix.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_drawpix.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -35,6 +35,7 @@ #include "mmath.h" #include "pixel.h" +#include "s_context.h" #include "s_pixeltex.h" #include "s_span.h" #include "s_stencil.h" @@ -110,8 +111,8 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; /* no-op */ } - if ((ctx->RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0 - && ctx->Texture.ReallyEnabled == 0 + if ((SWRAST_CONTEXT(ctx)->_RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0 + && ctx->Texture._ReallyEnabled == 0 && unpack->Alignment == 1 && !unpack->SwapBytes && !unpack->LsbFirst) { @@ -204,7 +205,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, */ if (format == GL_RGBA && type == CHAN_TYPE - && ctx->ImageTransferState==0) { + && ctx->_ImageTransferState==0) { if (ctx->Visual.RGBAflag) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels) * 4; @@ -242,7 +243,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; } else if (format == GL_RGB && type == CHAN_TYPE - && ctx->ImageTransferState == 0) { + && ctx->_ImageTransferState == 0) { if (ctx->Visual.RGBAflag) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels) * 3; @@ -279,7 +280,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; } else if (format == GL_LUMINANCE && type == CHAN_TYPE - && ctx->ImageTransferState==0) { + && ctx->_ImageTransferState==0) { if (ctx->Visual.RGBAflag) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels); @@ -338,7 +339,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; } else if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE - && ctx->ImageTransferState == 0) { + && ctx->_ImageTransferState == 0) { if (ctx->Visual.RGBAflag) { GLchan *src = (GLchan *) pixels + (skipRows * rowLength + skipPixels)*2; @@ -448,7 +449,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, return GL_TRUE; } } - else if (ctx->ImageTransferState==0) { + else if (ctx->_ImageTransferState==0) { /* write CI data to CI frame buffer */ GLint row; if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { @@ -512,7 +513,7 @@ draw_index_pixels( GLcontext *ctx, GLint x, GLint y, pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); _mesa_unpack_index_span(ctx, drawWidth, GL_UNSIGNED_INT, indexes, type, source, &ctx->Unpack, - ctx->ImageTransferState); + ctx->_ImageTransferState); if (zoom) { gl_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, 0, indexes, desty); } @@ -559,8 +560,8 @@ draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); _mesa_unpack_index_span(ctx, drawWidth, destType, values, type, source, &ctx->Unpack, - ctx->ImageTransferState); - if (ctx->ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { + ctx->_ImageTransferState); + if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { _mesa_shift_and_offset_stencil( ctx, drawWidth, values ); } if (ctx->Pixel.MapStencilFlag) { @@ -658,7 +659,7 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, const GLvoid *src = _mesa_image_address(&ctx->Unpack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); _mesa_unpack_depth_span( ctx, drawWidth, zspan, type, src, - &ctx->Unpack, ctx->ImageTransferState ); + &ctx->Unpack, ctx->_ImageTransferState ); if (ctx->Visual.RGBAflag) { if (zoom) { gl_write_zoomed_rgba_span(ctx, width, x, y, zspan, 0, @@ -698,7 +699,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, GLdepth zspan[MAX_WIDTH]; GLboolean quickDraw; GLfloat *convImage = NULL; - GLuint transferOps = ctx->ImageTransferState; + GLuint transferOps = ctx->_ImageTransferState; if (!_mesa_is_legal_format_and_type(format, type)) { gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)"); @@ -720,7 +721,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, } - if (ctx->RasterMask == 0 && !zoom && x >= 0 && y >= 0 + if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && x >= 0 && y >= 0 && x + width <= ctx->DrawBuffer->Width && y + height <= ctx->DrawBuffer->Height) { quickDraw = GL_TRUE; @@ -799,7 +800,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink)) continue; - if (ctx->Texture.ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { + if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH]; GLchan primary_rgba[MAX_WIDTH][4]; GLuint unit; @@ -808,7 +809,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan)); for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit].ReallyEnabled) { + if (ctx->Texture.Unit[unit]._ReallyEnabled) { _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba, s, t, r, q); gl_texture_pixels(ctx, unit, width, s, t, r, NULL, @@ -852,6 +853,9 @@ _swrast_DrawPixels( GLcontext *ctx, { (void) unpack; + if (SWRAST_CONTEXT(ctx)->NewState) + _swrast_validate_derived( ctx ); + switch (format) { case GL_STENCIL_INDEX: draw_stencil_pixels( ctx, x, y, width, height, type, pixels ); diff --git a/src/mesa/swrast/s_feedback.c b/src/mesa/swrast/s_feedback.c new file mode 100644 index 0000000000..501f3721c6 --- /dev/null +++ b/src/mesa/swrast/s_feedback.c @@ -0,0 +1,153 @@ +/* $Id: s_feedback.c,v 1.1 2000/11/05 18:24:40 keithw Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 3.3 + * + * Copyright (C) 1999-2000 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 + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "enums.h" +#include "feedback.h" +#include "macros.h" +#include "mmath.h" + +#include "s_context.h" +#include "s_feedback.h" +#include "s_triangle.h" + + +#define FB_3D 0x01 +#define FB_4D 0x02 +#define FB_INDEX 0x04 +#define FB_COLOR 0x08 +#define FB_TEXTURE 0X10 + + + + +static void feedback_vertex( GLcontext *ctx, SWvertex *v ) +{ + GLfloat win[4]; + GLfloat color[4]; + GLfloat tc[4]; + GLuint texUnit = ctx->Texture.CurrentTransformUnit; + GLuint index; + + win[0] = v->win[0]; + win[1] = v->win[1]; + win[2] = v->win[2] / ctx->Visual.DepthMaxF; + win[3] = 1.0 / v->win[3]; + + color[0] = CHAN_TO_FLOAT(v->color[0]); + color[1] = CHAN_TO_FLOAT(v->color[1]); + color[2] = CHAN_TO_FLOAT(v->color[2]); + color[3] = CHAN_TO_FLOAT(v->color[3]); + + if (v->texcoord[texUnit][3] != 1.0 && + v->texcoord[texUnit][3] != 0.0) { + GLfloat invq = 1.0F / v->texcoord[texUnit][3]; + tc[0] = v->texcoord[texUnit][0] * invq; + tc[1] = v->texcoord[texUnit][1] * invq; + tc[2] = v->texcoord[texUnit][2] * invq; + tc[3] = v->texcoord[texUnit][3]; + } + else { + COPY_4V(tc, v->texcoord[texUnit]); + } + + index = v->index; + + gl_feedback_vertex( ctx, win, color, index, tc ); +} + + +/* + * Put triangle in feedback buffer. + */ +void gl_feedback_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, + SWvertex *v2) +{ + if (gl_cull_triangle( ctx, v0, v1, v2 )) { + FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN ); + FEEDBACK_TOKEN( ctx, (GLfloat) 3 ); /* three vertices */ + + feedback_vertex( ctx, v0 ); + feedback_vertex( ctx, v1 ); + feedback_vertex( ctx, v2 ); + } +} + + +void gl_feedback_line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ) +{ + GLenum token = GL_LINE_TOKEN; + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (swrast->StippleCounter==0) + token = GL_LINE_RESET_TOKEN; + + FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token ); + + feedback_vertex( ctx, v0 ); + feedback_vertex( ctx, v1 ); + + swrast->StippleCounter++; +} + + +void gl_feedback_point( GLcontext *ctx, SWvertex *v ) +{ + FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN ); + feedback_vertex( ctx, v ); +} + + +void gl_select_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, + SWvertex *v2) +{ + if (gl_cull_triangle( ctx, v0, v1, v2 )) { + const GLfloat zs = 1.0F / ctx->Visual.DepthMaxF; + gl_update_hitflag( ctx, v0->win[2] * zs ); + gl_update_hitflag( ctx, v1->win[2] * zs ); + gl_update_hitflag( ctx, v2->win[2] * zs ); + } +} + + +void gl_select_line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ) +{ + const GLfloat zs = 1.0F / ctx->Visual.DepthMaxF; + gl_update_hitflag( ctx, v0->win[2] * zs ); + gl_update_hitflag( ctx, v1->win[2] * zs ); +} + + +void gl_select_point( GLcontext *ctx, SWvertex *v ) +{ + const GLfloat zs = 1.0F / ctx->Visual.DepthMaxF; + gl_update_hitflag( ctx, v->win[2] * zs ); +} + + + diff --git a/src/mesa/swrast/s_feedback.h b/src/mesa/swrast/s_feedback.h new file mode 100644 index 0000000000..f32dcc86f9 --- /dev/null +++ b/src/mesa/swrast/s_feedback.h @@ -0,0 +1,47 @@ +/* $Id: s_feedback.h,v 1.1 2000/11/05 18:24:40 keithw Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 3.3 + * + * Copyright (C) 1999 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 + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#ifndef S_FEEDBACK_H +#define S_FEEDBACK_H + + +#include "types.h" +#include "swrast.h" + + +extern void gl_feedback_point( GLcontext *ctx, SWvertex *v ); +extern void gl_feedback_line( GLcontext *ctx, SWvertex *v1, SWvertex *v2 ); +extern void gl_feedback_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, + SWvertex *v2 ); + +extern void gl_select_point( GLcontext *ctx, SWvertex *v ); +extern void gl_select_line( GLcontext *ctx, SWvertex *v1, SWvertex *v2 ); +extern void gl_select_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, + SWvertex *v2 ); + +#endif + diff --git a/src/mesa/swrast/s_fog.c b/src/mesa/swrast/s_fog.c index 32fafe617c..4cfea675d6 100644 --- a/src/mesa/swrast/s_fog.c +++ b/src/mesa/swrast/s_fog.c @@ -1,4 +1,4 @@ -/* $Id: s_fog.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_fog.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -31,6 +31,7 @@ #include "macros.h" #include "mmath.h" +#include "s_context.h" #include "s_fog.h" @@ -105,8 +106,8 @@ _mesa_win_fog_coords_from_z( const GLcontext *ctx, GLfloat d = ctx->ProjectionMatrix.m[14]; GLuint i; - GLfloat tz = ctx->Viewport.WindowMap.m[MAT_TZ]; - GLfloat szInv = 1.0F / ctx->Viewport.WindowMap.m[MAT_SZ]; + GLfloat tz = ctx->Viewport._WindowMap.m[MAT_TZ]; + GLfloat szInv = 1.0F / ctx->Viewport._WindowMap.m[MAT_SZ]; switch (ctx->Fog.Mode) { case GL_LINEAR: diff --git a/src/mesa/swrast/s_imaging.c b/src/mesa/swrast/s_imaging.c index 672d163d8c..1b83a3c54c 100644 --- a/src/mesa/swrast/s_imaging.c +++ b/src/mesa/swrast/s_imaging.c @@ -1,4 +1,4 @@ -/* $Id: s_imaging.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_imaging.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -36,6 +36,7 @@ #include "image.h" #include "mmath.h" +#include "s_context.h" #include "s_imaging.h" #include "s_span.h" diff --git a/src/mesa/swrast/s_lines.c b/src/mesa/swrast/s_lines.c index 75a01cf12e..eaf4e8a2fa 100644 --- a/src/mesa/swrast/s_lines.c +++ b/src/mesa/swrast/s_lines.c @@ -1,4 +1,4 @@ -/* $Id: s_lines.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_lines.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -26,13 +26,15 @@ #include "glheader.h" -#include "feedback.h" #include "macros.h" #include "mmath.h" #include "vb.h" #include "s_pb.h" +#include "s_context.h" #include "s_depth.h" +#include "s_lines.h" +#include "s_feedback.h" @@ -53,7 +55,6 @@ /* * All line drawing functions have the same arguments: * v1, v2 - indexes of first and second endpoints into vertex buffer arrays - * pv - provoking vertex: which vertex color/index to use for flat shading. */ @@ -70,12 +71,15 @@ /* Flat, color index line */ static void flat_ci_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] ); + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + + PB_SET_INDEX( PB, vert0->index ); #define INTERP_XY 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, 0, 0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, 0, 0); #include "s_linetemp.h" @@ -86,13 +90,15 @@ static void flat_ci_line( GLcontext *ctx, /* Flat, color index line with Z interpolation/testing */ static void flat_ci_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] ); + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + PB_SET_INDEX( PB, vert0->index ); #define INTERP_XY 1 #define INTERP_Z 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); #include "s_linetemp.h" @@ -103,13 +109,15 @@ static void flat_ci_z_line( GLcontext *ctx, /* Flat-shaded, RGBA line */ static void flat_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - const GLchan *color = ctx->VB->ColorPtr->data[pvert]; - PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] ); + const GLchan *color = vert0->color; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] ); #define INTERP_XY 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, 0, 0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, 0, 0); #include "s_linetemp.h" @@ -120,14 +128,16 @@ static void flat_rgba_line( GLcontext *ctx, /* Flat-shaded, RGBA line with Z interpolation/testing */ static void flat_rgba_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - const GLchan *color = ctx->VB->ColorPtr->data[pvert]; - PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] ); + const GLchan *color = vert0->color; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] ); #define INTERP_XY 1 #define INTERP_Z 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); #include "s_linetemp.h" @@ -138,15 +148,16 @@ static void flat_rgba_z_line( GLcontext *ctx, /* Smooth shaded, color index line */ static void smooth_ci_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLuint *pbi = ctx->PB->index; - (void) pvert; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLuint *pbi = PB->index; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; #define INTERP_XY 1 #define INTERP_INDEX 1 @@ -159,7 +170,7 @@ static void smooth_ci_line( GLcontext *ctx, #include "s_linetemp.h" - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -167,16 +178,17 @@ static void smooth_ci_line( GLcontext *ctx, /* Smooth shaded, color index line with Z interpolation/testing */ static void smooth_ci_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLuint *pbi = ctx->PB->index; - (void) pvert; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLuint *pbi = PB->index; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; #define INTERP_XY 1 #define INTERP_Z 1 @@ -191,7 +203,7 @@ static void smooth_ci_z_line( GLcontext *ctx, #include "s_linetemp.h" - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -199,15 +211,16 @@ static void smooth_ci_z_line( GLcontext *ctx, /* Smooth-shaded, RGBA line */ static void smooth_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLchan (*pbrgba)[4] = ctx->PB->rgba; - (void) pvert; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLchan (*pbrgba)[4] = PB->rgba; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; #define INTERP_XY 1 #define INTERP_RGB 1 @@ -224,7 +237,7 @@ static void smooth_rgba_line( GLcontext *ctx, #include "s_linetemp.h" - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -232,18 +245,19 @@ static void smooth_rgba_line( GLcontext *ctx, /* Smooth-shaded, RGBA line with Z interpolation/testing */ static void smooth_rgba_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLchan (*pbrgba)[4] = ctx->PB->rgba; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLchan (*pbrgba)[4] = PB->rgba; - (void) pvert; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; #define INTERP_XY 1 #define INTERP_Z 1 @@ -263,33 +277,34 @@ static void smooth_rgba_z_line( GLcontext *ctx, #include "s_linetemp.h" - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } #define CHECK_FULL(count) \ if (count >= PB_SIZE-MAX_WIDTH) { \ - ctx->PB->count = count; \ + PB->count = count; \ gl_flush_pb(ctx); \ - count = ctx->PB->count; \ + count = PB->count; \ } /* Smooth shaded, color index, any width, maybe stippled */ static void general_smooth_ci_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLuint *pbi = ctx->PB->index; - (void) pvert; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLuint *pbi = PB->index; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; if (ctx->Line.StippleFlag) { /* stippled */ @@ -351,22 +366,24 @@ static void general_smooth_ci_line( GLcontext *ctx, } } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } /* Flat shaded, color index, any width, maybe stippled */ static void general_flat_ci_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; GLint count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] ); - count = ctx->PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + PB_SET_INDEX( PB, vert0->index ); + count = PB->count; if (ctx->Line.StippleFlag) { /* stippled, any width */ @@ -421,25 +438,25 @@ static void general_flat_ci_line( GLcontext *ctx, } } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } static void general_smooth_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLchan (*pbrgba)[4] = ctx->PB->rgba; - - (void) pvert; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLchan (*pbrgba)[4] = PB->rgba; - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; if (ctx->Line.StippleFlag) { /* stippled */ @@ -524,16 +541,18 @@ static void general_smooth_rgba_line( GLcontext *ctx, } } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } static void general_flat_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - const GLchan *color = ctx->VB->ColorPtr->data[pvert]; - PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] ); + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + const GLchan *color = vert0->color; + PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] ); if (ctx->Line.StippleFlag) { /* stippled */ @@ -541,7 +560,7 @@ static void general_flat_rgba_line( GLcontext *ctx, #define INTERP_Z 1 #define WIDE 1 #define STIPPLE 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); #include "s_linetemp.h" } else { @@ -550,10 +569,10 @@ static void general_flat_rgba_line( GLcontext *ctx, /* special case: unstippled and width=2 */ #define INTERP_XY 1 #define INTERP_Z 1 -#define XMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); \ - PB_WRITE_PIXEL(ctx->PB, X, Y+1, Z, fog0); -#define YMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); \ - PB_WRITE_PIXEL(ctx->PB, X+1, Y, Z, fog0); +#define XMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); \ + PB_WRITE_PIXEL(PB, X, Y+1, Z, fog0); +#define YMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); \ + PB_WRITE_PIXEL(PB, X+1, Y, Z, fog0); #include "s_linetemp.h" } else { @@ -561,7 +580,7 @@ static void general_flat_rgba_line( GLcontext *ctx, #define INTERP_XY 1 #define INTERP_Z 1 #define WIDE 1 -#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0); +#define PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); #include "s_linetemp.h" } } @@ -572,19 +591,21 @@ static void general_flat_rgba_line( GLcontext *ctx, /* Flat-shaded, textured, any width, maybe stippled */ static void flat_textured_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) + SWvertex *vert0, + SWvertex *vert1 ) { + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; GLint count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLfloat *pbs = ctx->PB->s[0]; - GLfloat *pbt = ctx->PB->t[0]; - GLfloat *pbu = ctx->PB->u[0]; - GLchan *color = ctx->VB->ColorPtr->data[pv]; - PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] ); - count = ctx->PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLfloat *pbs = PB->s[0]; + GLfloat *pbt = PB->t[0]; + GLfloat *pbu = PB->u[0]; + GLchan *color = vert0->color; + PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] ); + count = PB->count; if (ctx->Line.StippleFlag) { /* stippled */ @@ -628,7 +649,7 @@ static void flat_textured_line( GLcontext *ctx, #include "s_linetemp.h" } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -636,20 +657,21 @@ static void flat_textured_line( GLcontext *ctx, /* Smooth-shaded, textured, any width, maybe stippled */ static void smooth_textured_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLfloat *pbs = ctx->PB->s[0]; - GLfloat *pbt = ctx->PB->t[0]; - GLfloat *pbu = ctx->PB->u[0]; - GLchan (*pbrgba)[4] = ctx->PB->rgba; - (void) pvert; - - ctx->PB->mono = GL_FALSE; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLfloat *pbs = PB->s[0]; + GLfloat *pbt = PB->t[0]; + GLfloat *pbu = PB->u[0]; + GLchan (*pbrgba)[4] = PB->rgba; + + PB->mono = GL_FALSE; if (ctx->Line.StippleFlag) { /* stippled */ @@ -705,7 +727,7 @@ static void smooth_textured_line( GLcontext *ctx, #include "s_linetemp.h" } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -714,19 +736,19 @@ static void smooth_textured_line( GLcontext *ctx, * color interpolation. */ static void smooth_multitextured_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLchan (*pbrgba)[4] = ctx->PB->rgba; - GLchan (*pbspec)[3] = ctx->PB->spec; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLchan (*pbrgba)[4] = PB->rgba; + GLchan (*pbspec)[3] = PB->spec; - (void) pvert; - - ctx->PB->mono = GL_FALSE; + PB->mono = GL_FALSE; if (ctx->Line.StippleFlag) { /* stippled */ @@ -753,11 +775,11 @@ static void smooth_multitextured_line( GLcontext *ctx, pbspec[count][GCOMP] = FixedToInt(sg0); \ pbspec[count][BCOMP] = FixedToInt(sb0); \ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \ - if (ctx->Texture.Unit[u].ReallyEnabled) { \ - ctx->PB->s[u][0] = fragTexcoord[u][0]; \ - ctx->PB->s[u][1] = fragTexcoord[u][1]; \ - ctx->PB->s[u][2] = fragTexcoord[u][2]; \ - ctx->PB->s[u][3] = fragTexcoord[u][3]; \ + if (ctx->Texture.Unit[u]._ReallyEnabled) { \ + PB->s[u][0] = fragTexcoord[u][0]; \ + PB->s[u][1] = fragTexcoord[u][1]; \ + PB->s[u][2] = fragTexcoord[u][2]; \ + PB->s[u][3] = fragTexcoord[u][3]; \ } \ } \ count++; \ @@ -789,11 +811,11 @@ static void smooth_multitextured_line( GLcontext *ctx, pbspec[count][GCOMP] = FixedToInt(sg0); \ pbspec[count][BCOMP] = FixedToInt(sb0); \ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \ - if (ctx->Texture.Unit[u].ReallyEnabled) { \ - ctx->PB->s[u][0] = fragTexcoord[u][0]; \ - ctx->PB->s[u][1] = fragTexcoord[u][1]; \ - ctx->PB->s[u][2] = fragTexcoord[u][2]; \ - ctx->PB->s[u][3] = fragTexcoord[u][3]; \ + if (ctx->Texture.Unit[u]._ReallyEnabled) { \ + PB->s[u][0] = fragTexcoord[u][0]; \ + PB->s[u][1] = fragTexcoord[u][1]; \ + PB->s[u][2] = fragTexcoord[u][2]; \ + PB->s[u][3] = fragTexcoord[u][3]; \ } \ } \ count++; \ @@ -802,7 +824,7 @@ static void smooth_multitextured_line( GLcontext *ctx, #include "s_linetemp.h" } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -811,23 +833,23 @@ static void smooth_multitextured_line( GLcontext *ctx, * color interpolation. */ static void flat_multitextured_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { - GLint count = ctx->PB->count; - GLint *pbx = ctx->PB->x; - GLint *pby = ctx->PB->y; - GLdepth *pbz = ctx->PB->z; - GLfixed *pbfog = ctx->PB->fog; - GLchan (*pbrgba)[4] = ctx->PB->rgba; - GLchan (*pbspec)[3] = ctx->PB->spec; - GLchan *color = ctx->VB->ColorPtr->data[pvert]; - GLchan sRed = ctx->VB->SecondaryColorPtr->data ? ctx->VB->SecondaryColorPtr->data[pvert][0] : 0; - GLchan sGreen = ctx->VB->SecondaryColorPtr->data ? ctx->VB->SecondaryColorPtr->data[pvert][1] : 0; - GLchan sBlue = ctx->VB->SecondaryColorPtr->data ? ctx->VB->SecondaryColorPtr->data[pvert][2] : 0; - - (void) pvert; - - ctx->PB->mono = GL_FALSE; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + GLint count = PB->count; + GLint *pbx = PB->x; + GLint *pby = PB->y; + GLdepth *pbz = PB->z; + GLfixed *pbfog = PB->fog; + GLchan (*pbrgba)[4] = PB->rgba; + GLchan (*pbspec)[3] = PB->spec; + GLchan *color = vert0->color; + GLchan sRed = vert0->specular[0]; + GLchan sGreen = vert0->specular[1]; + GLchan sBlue = vert0->specular[2]; + + PB->mono = GL_FALSE; if (ctx->Line.StippleFlag) { /* stippled */ @@ -852,11 +874,11 @@ static void flat_multitextured_line( GLcontext *ctx, pbspec[count][GCOMP] = sGreen; \ pbspec[count][BCOMP] = sBlue; \ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \ - if (ctx->Texture.Unit[u].ReallyEnabled) { \ - ctx->PB->s[u][0] = fragTexcoord[u][0]; \ - ctx->PB->s[u][1] = fragTexcoord[u][1]; \ - ctx->PB->s[u][2] = fragTexcoord[u][2]; \ - ctx->PB->s[u][3] = fragTexcoord[u][3]; \ + if (ctx->Texture.Unit[u]._ReallyEnabled) { \ + PB->s[u][0] = fragTexcoord[u][0]; \ + PB->s[u][1] = fragTexcoord[u][1]; \ + PB->s[u][2] = fragTexcoord[u][2]; \ + PB->s[u][3] = fragTexcoord[u][3]; \ } \ } \ count++; \ @@ -886,11 +908,11 @@ static void flat_multitextured_line( GLcontext *ctx, pbspec[count][GCOMP] = sGreen; \ pbspec[count][BCOMP] = sBlue; \ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \ - if (ctx->Texture.Unit[u].ReallyEnabled) { \ - ctx->PB->s[u][0] = fragTexcoord[u][0]; \ - ctx->PB->s[u][1] = fragTexcoord[u][1]; \ - ctx->PB->s[u][2] = fragTexcoord[u][2]; \ - ctx->PB->s[u][3] = fragTexcoord[u][3]; \ + if (ctx->Texture.Unit[u]._ReallyEnabled) { \ + PB->s[u][0] = fragTexcoord[u][0]; \ + PB->s[u][1] = fragTexcoord[u][1]; \ + PB->s[u][2] = fragTexcoord[u][2]; \ + PB->s[u][3] = fragTexcoord[u][3]; \ } \ } \ count++; \ @@ -899,7 +921,7 @@ static void flat_multitextured_line( GLcontext *ctx, #include "s_linetemp.h" } - ctx->PB->count = count; + PB->count = count; gl_flush_pb(ctx); } @@ -914,7 +936,8 @@ static void flat_multitextured_line( GLcontext *ctx, * to the specification. */ static void aa_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { #define INTERP_RGBA 1 #define PLOT(x, y) \ @@ -933,7 +956,8 @@ static void aa_rgba_line( GLcontext *ctx, * to the specification. */ static void aa_tex_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { #define INTERP_RGBA 1 #define INTERP_TEX 1 @@ -955,7 +979,8 @@ static void aa_tex_rgba_line( GLcontext *ctx, * to the specification. */ static void aa_multitex_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { #define INTERP_RGBA 1 #define INTERP_SPEC 1 @@ -974,7 +999,8 @@ static void aa_multitex_rgba_line( GLcontext *ctx, * Antialiased CI line. Same comments for RGBA antialiased lines apply. */ static void aa_ci_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) + SWvertex *vert0, + SWvertex *vert1 ) { #define INTERP_INDEX 1 #define PLOT(x, y) \ @@ -985,68 +1011,56 @@ static void aa_ci_line( GLcontext *ctx, } -/* - * Null rasterizer for measuring transformation speed. - */ -static void null_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv ) -{ - (void) ctx; - (void) v1; - (void) v2; - (void) pv; -} - - #ifdef DEBUG void _mesa_print_line_function(GLcontext *ctx) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); + printf("Line Func == "); - if (ctx->Driver.LineFunc == flat_ci_line) + if (swrast->Line == flat_ci_line) printf("flat_ci_line\n"); - else if (ctx->Driver.LineFunc == flat_ci_z_line) + else if (swrast->Line == flat_ci_z_line) printf("flat_ci_z_line\n"); - else if (ctx->Driver.LineFunc == flat_rgba_line) + else if (swrast->Line == flat_rgba_line) printf("flat_rgba_line\n"); - else if (ctx->Driver.LineFunc == flat_rgba_z_line) + else if (swrast->Line == flat_rgba_z_line) printf("flat_rgba_z_line\n"); - else if (ctx->Driver.LineFunc == smooth_ci_line) + else if (swrast->Line == smooth_ci_line) printf("smooth_ci_line\n"); - else if (ctx->Driver.LineFunc == smooth_ci_z_line) + else if (swrast->Line == smooth_ci_z_line) printf("smooth_ci_z_line\n"); - else if (ctx->Driver.LineFunc == smooth_rgba_line) + else if (swrast->Line == smooth_rgba_line) printf("smooth_rgba_line\n"); - else if (ctx->Driver.LineFunc == smooth_rgba_z_line) + else if (swrast->Line == smooth_rgba_z_line) printf("smooth_rgba_z_line\n"); - else if (ctx->Driver.LineFunc == general_smooth_ci_line) + else if (swrast->Line == general_smooth_ci_line) printf("general_smooth_ci_line\n"); - else if (ctx->Driver.LineFunc == general_flat_ci_line) + else if (swrast->Line == general_flat_ci_line) printf("general_flat_ci_line\n"); - else if (ctx->Driver.LineFunc == general_smooth_rgba_line) + else if (swrast->Line == general_smooth_rgba_line) printf("general_smooth_rgba_line\n"); - else if (ctx->Driver.LineFunc == general_flat_rgba_line) + else if (swrast->Line == general_flat_rgba_line) printf("general_flat_rgba_line\n"); - else if (ctx->Driver.LineFunc == flat_textured_line) + else if (swrast->Line == flat_textured_line) printf("flat_textured_line\n"); - else if (ctx->Driver.LineFunc == smooth_textured_line) + else if (swrast->Line == smooth_textured_line) printf("smooth_textured_line\n"); - else if (ctx->Driver.LineFunc == smooth_multitextured_line) + else if (swrast->Line == smooth_multitextured_line) printf("smooth_multitextured_line\n"); - else if (ctx->Driver.LineFunc == flat_multitextured_line) + else if (swrast->Line == flat_multitextured_line) printf("flat_multitextured_line\n"); - else if (ctx->Driver.LineFunc == aa_rgba_line) + else if (swrast->Line == aa_rgba_line) printf("aa_rgba_line\n"); - else if (ctx->Driver.LineFunc == aa_tex_rgba_line) + else if (swrast->Line == aa_tex_rgba_line) printf("aa_tex_rgba_line\n"); - else if (ctx->Driver.LineFunc == aa_multitex_rgba_line) + else if (swrast->Line == aa_multitex_rgba_line) printf("aa_multitex_rgba_line\n"); - else if (ctx->Driver.LineFunc == aa_ci_line) + else if (swrast->Line == aa_ci_line) printf("aa_ci_line\n"); - else if (ctx->Driver.LineFunc == null_line) - printf("null_line\n"); else - printf("Driver func %p\n", ctx->Driver.LineFunc); + printf("Driver func %p\n", swrast->Line); } #endif @@ -1060,56 +1074,49 @@ _mesa_print_line_function(GLcontext *ctx) * tests to this code. */ void -_swrast_set_line_function( GLcontext *ctx ) +_swrast_choose_line( GLcontext *ctx ) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GLboolean rgbmode = ctx->Visual.RGBAflag; /* TODO: antialiased lines */ if (ctx->RenderMode==GL_RENDER) { - if (ctx->NoRaster) { - ctx->Driver.LineFunc = null_line; - return; - } - if (ctx->Driver.LineFunc) { - /* Device driver will draw lines. */ - return; - } - if (ctx->Line.SmoothFlag) { /* antialiased lines */ if (rgbmode) { - if (ctx->Texture.ReallyEnabled) { - if (ctx->Texture.MultiTextureEnabled + if (ctx->Texture._ReallyEnabled) { + if (ctx->Texture._MultiTextureEnabled || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR || ctx->Fog.ColorSumEnabled) /* Multitextured! */ - ctx->Driver.LineFunc = aa_multitex_rgba_line; + swrast->Line = aa_multitex_rgba_line; else - ctx->Driver.LineFunc = aa_tex_rgba_line; + swrast->Line = aa_tex_rgba_line; } else { - ctx->Driver.LineFunc = aa_rgba_line; + swrast->Line = aa_rgba_line; } } else { - ctx->Driver.LineFunc = aa_ci_line; + swrast->Line = aa_ci_line; } } - else if (ctx->Texture.ReallyEnabled) { - if (ctx->Texture.MultiTextureEnabled + else if (ctx->Texture._ReallyEnabled) { + if (ctx->Texture._MultiTextureEnabled || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR || ctx->Fog.ColorSumEnabled) { /* multi-texture and/or separate specular color */ if (ctx->Light.ShadeModel==GL_SMOOTH) - ctx->Driver.LineFunc = smooth_multitextured_line; + swrast->Line = smooth_multitextured_line; else - ctx->Driver.LineFunc = flat_multitextured_line; + swrast->Line = flat_multitextured_line; } else { if (ctx->Light.ShadeModel==GL_SMOOTH) { - ctx->Driver.LineFunc = smooth_textured_line; + swrast->Line = smooth_textured_line; } else { - ctx->Driver.LineFunc = flat_textured_line; + swrast->Line = flat_textured_line; } } } @@ -1117,15 +1124,15 @@ _swrast_set_line_function( GLcontext *ctx ) || ctx->Line.SmoothFlag) { if (ctx->Light.ShadeModel==GL_SMOOTH) { if (rgbmode) - ctx->Driver.LineFunc = general_smooth_rgba_line; + swrast->Line = general_smooth_rgba_line; else - ctx->Driver.LineFunc = general_smooth_ci_line; + swrast->Line = general_smooth_ci_line; } else { if (rgbmode) - ctx->Driver.LineFunc = general_flat_rgba_line; + swrast->Line = general_flat_rgba_line; else - ctx->Driver.LineFunc = general_flat_ci_line; + swrast->Line = general_flat_ci_line; } } else { @@ -1133,41 +1140,43 @@ _swrast_set_line_function( GLcontext *ctx ) /* Width==1, non-stippled, smooth-shaded */ if (ctx->Depth.Test || ctx->Fog.Enabled) { if (rgbmode) - ctx->Driver.LineFunc = smooth_rgba_z_line; + swrast->Line = smooth_rgba_z_line; else - ctx->Driver.LineFunc = smooth_ci_z_line; + swrast->Line = smooth_ci_z_line; } else { if (rgbmode) - ctx->Driver.LineFunc = smooth_rgba_line; + swrast->Line = smooth_rgba_line; else - ctx->Driver.LineFunc = smooth_ci_line; + swrast->Line = smooth_ci_line; } } else { /* Width==1, non-stippled, flat-shaded */ if (ctx->Depth.Test || ctx->Fog.Enabled) { if (rgbmode) - ctx->Driver.LineFunc = flat_rgba_z_line; + swrast->Line = flat_rgba_z_line; else - ctx->Driver.LineFunc = flat_ci_z_line; + swrast->Line = flat_ci_z_line; } else { if (rgbmode) - ctx->Driver.LineFunc = flat_rgba_line; + swrast->Line = flat_rgba_line; else - ctx->Driver.LineFunc = flat_ci_line; + swrast->Line = flat_ci_line; } } } } else if (ctx->RenderMode==GL_FEEDBACK) { - ctx->Driver.LineFunc = gl_feedback_line; + swrast->Line = gl_feedback_line; } else { /* GL_SELECT mode */ - ctx->Driver.LineFunc = gl_select_line; + swrast->Line = gl_select_line; } /*_mesa_print_line_function(ctx);*/ } + + diff --git a/src/mesa/swrast/s_lines.h b/src/mesa/swrast/s_lines.h new file mode 100644 index 0000000000..efbb59d2d6 --- /dev/null +++ b/src/mesa/swrast/s_lines.h @@ -0,0 +1,10 @@ +#ifndef S_LINES_H +#define S_LINES_H + +#include "types.h" + +void +_swrast_choose_line( GLcontext *ctx ); + + +#endif diff --git a/src/mesa/swrast/s_linetemp.h b/src/mesa/swrast/s_linetemp.h index a79badbff1..1605f880a1 100644 --- a/src/mesa/swrast/s_linetemp.h +++ b/src/mesa/swrast/s_linetemp.h @@ -1,4 +1,4 @@ -/* $Id: s_linetemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_linetemp.h,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -73,13 +73,12 @@ */ -/*void line( GLcontext *ctx, GLuint vert0, GLuint vert1, GLuint pvert )*/ +/*void line( GLcontext *ctx, SWvertex *vert0, SWvertex *vert1 )*/ { - const struct vertex_buffer *VB = ctx->VB; - GLint x0 = (GLint) VB->Win.data[vert0][0]; - GLint x1 = (GLint) VB->Win.data[vert1][0]; - GLint y0 = (GLint) VB->Win.data[vert0][1]; - GLint y1 = (GLint) VB->Win.data[vert1][1]; + GLint x0 = (GLint) vert0->win[0]; + GLint x1 = (GLint) vert1->win[0]; + GLint y0 = (GLint) vert0->win[1]; + GLint y1 = (GLint) vert1->win[1]; GLint dx, dy; #ifdef INTERP_XY GLint xstep, ystep; @@ -90,46 +89,46 @@ const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0; # define FixedToDepth(F) ((F) >> fixedToDepthShift) # ifdef DEPTH_TYPE - GLint zPtrXstep, zPtrYstep; - DEPTH_TYPE *zPtr; + GLint zPtrXstep, zPtrYstep; + DEPTH_TYPE *zPtr; # endif - GLfixed fog0 = FloatToFixed(VB->FogCoordPtr->data[vert0]); - GLfixed dfog = FloatToFixed(VB->FogCoordPtr->data[vert1]) - fog0; + GLfixed fog0 = FloatToFixed(vert0->fog); + GLfixed dfog = FloatToFixed(vert1->fog) - fog0; #endif #ifdef INTERP_RGB - GLfixed r0 = IntToFixed(VB->ColorPtr->data[vert0][0]); - GLfixed dr = IntToFixed(VB->ColorPtr->data[vert1][0]) - r0; - GLfixed g0 = IntToFixed(VB->ColorPtr->data[vert0][1]); - GLfixed dg = IntToFixed(VB->ColorPtr->data[vert1][1]) - g0; - GLfixed b0 = IntToFixed(VB->ColorPtr->data[vert0][2]); - GLfixed db = IntToFixed(VB->ColorPtr->data[vert1][2]) - b0; + GLfixed r0 = IntToFixed(vert0->color[0]); + GLfixed dr = IntToFixed(vert1->color[0]) - r0; + GLfixed g0 = IntToFixed(vert0->color[1]); + GLfixed dg = IntToFixed(vert1->color[1]) - g0; + GLfixed b0 = IntToFixed(vert0->color[2]); + GLfixed db = IntToFixed(vert1->color[2]) - b0; #endif #ifdef INTERP_SPEC - GLfixed sr0 = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert0][0]) : 0; - GLfixed dsr = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert1][0]) - sr0 : 0; - GLfixed sg0 = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert0][1]) : 0; - GLfixed dsg = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert1][1]) - sg0 : 0; - GLfixed sb0 = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert0][2]) : 0; - GLfixed dsb = VB->SecondaryColorPtr->data ? IntToFixed(VB->SecondaryColorPtr->data[vert1][2]) - sb0 : 0; + GLfixed sr0 = IntToFixed(vert0->specular[0]); + GLfixed dsr = IntToFixed(vert1->specular[0]) - sr0; + GLfixed sg0 = IntToFixed(vert0->specular[1]); + GLfixed dsg = IntToFixed(vert1->specular[1]) - sg0; + GLfixed sb0 = IntToFixed(vert0->specular[2]); + GLfixed dsb = IntToFixed(vert1->specular[2]) - sb0; #endif #ifdef INTERP_ALPHA - GLfixed a0 = IntToFixed(VB->ColorPtr->data[vert0][3]); - GLfixed da = IntToFixed(VB->ColorPtr->data[vert1][3]) - a0; + GLfixed a0 = IntToFixed(vert0->color[3]); + GLfixed da = IntToFixed(vert1->color[3]) - a0; #endif #ifdef INTERP_INDEX - GLint i0 = VB->IndexPtr->data[vert0] << 8; - GLint di = (GLint) (VB->IndexPtr->data[vert1] << 8) - i0; + GLint i0 = vert0->index << 8; + GLint di = (GLint) (vert1->index << 8) - i0; #endif #ifdef INTERP_TEX - const GLfloat invw0 = VB->Win.data[vert0][3]; - const GLfloat invw1 = VB->Win.data[vert1][3]; + const GLfloat invw0 = vert0->win[3]; + const GLfloat invw1 = vert1->win[3]; GLfloat tex[4]; GLfloat dtex[4]; GLfloat fragTexcoord[4]; #endif #ifdef INTERP_MULTITEX - const GLfloat invw0 = VB->Win.data[vert0][3]; - const GLfloat invw1 = VB->Win.data[vert1][3]; + const GLfloat invw0 = vert0->win[3]; + const GLfloat invw1 = vert1->win[3]; GLfloat tex[MAX_TEXTURE_UNITS][4]; GLfloat dtex[MAX_TEXTURE_UNITS][4]; GLfloat fragTexcoord[MAX_TEXTURE_UNITS][4]; @@ -138,6 +137,9 @@ PIXEL_TYPE *pixelPtr; GLint pixelXstep, pixelYstep; #endif +#ifdef STIPPLE + SWcontext *swrast = SWRAST_CONTEXT(ctx); +#endif #ifdef WIDE /* for wide lines, draw all X in [x+min, x+max] or Y in [y+min, y+max] */ GLint width, min, max; @@ -147,66 +149,30 @@ #endif #ifdef INTERP_TEX { - tex[0] = invw0 * VB->TexCoordPtr[0]->data[vert0][0]; - dtex[0] = invw1 * VB->TexCoordPtr[0]->data[vert1][0] - tex[0]; - if (VB->TexCoordPtr[0]->size > 1) { - tex[1] = invw0 * VB->TexCoordPtr[0]->data[vert0][1]; - dtex[1] = invw1 * VB->TexCoordPtr[0]->data[vert1][1] - tex[1]; - } - else { - tex[1] = 0.0; - dtex[1] = 0.0; - } - if (VB->TexCoordPtr[0]->size > 2) { - tex[2] = invw0 * VB->TexCoordPtr[0]->data[vert0][2]; - dtex[2] = invw1 * VB->TexCoordPtr[0]->data[vert1][2] - tex[2]; - } - else { - tex[2] = 0.0; - dtex[2] = 0.0; - } - if (VB->TexCoordPtr[0]->size > 3) { - tex[3] = invw0 * VB->TexCoordPtr[0]->data[vert0][3]; - dtex[3] = invw1 * VB->TexCoordPtr[0]->data[vert1][3] - tex[3]; - } - else { - tex[3] = invw0; - dtex[3] = invw1 - invw0; - } + tex[0] = invw0 * vert0->texcoord[0][0]; + dtex[0] = invw1 * vert1->texcoord[0][0] - tex[0]; + tex[1] = invw0 * vert0->texcoord[0][1]; + dtex[1] = invw1 * vert1->texcoord[0][1] - tex[1]; + tex[2] = invw0 * vert0->texcoord[0][2]; + dtex[2] = invw1 * vert1->texcoord[0][2] - tex[2]; + tex[3] = invw0 * vert0->texcoord[0][3]; + dtex[3] = invw1 * vert1->texcoord[0][3] - tex[3]; } #endif #ifdef INTERP_MULTITEX { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - tex[u][0] = invw0 * VB->TexCoordPtr[u]->data[vert0][0]; - dtex[u][0] = invw1 * VB->TexCoordPtr[u]->data[vert1][0] - tex[u][0]; - if (VB->TexCoordPtr[u]->size > 1) { - tex[u][1] = invw0 * VB->TexCoordPtr[u]->data[vert0][1]; - dtex[u][1] = invw1 * VB->TexCoordPtr[u]->data[vert1][1] - tex[u][1]; - } - else { - tex[u][1] = 0.0; - dtex[u][1] = 0.0; - } - if (VB->TexCoordPtr[u]->size > 2) { - tex[u][2] = invw0 * VB->TexCoordPtr[u]->data[vert0][2]; - dtex[u][2] = invw1 * VB->TexCoordPtr[u]->data[vert1][2] - tex[u][2]; - } - else { - tex[u][2] = 0.0; - dtex[u][2] = 0.0; - } - if (VB->TexCoordPtr[u]->size > 3) { - tex[u][3] = invw0 * VB->TexCoordPtr[u]->data[vert0][3]; - dtex[u][3] = invw1 * VB->TexCoordPtr[u]->data[vert1][3] - tex[u][3]; - } - else { - tex[u][3] = invw0; - dtex[u][3] = invw1 - invw0; - } - } + if (ctx->Texture.Unit[u]._ReallyEnabled) { + tex[u][0] = invw0 * vert0->texcoord[u][0]; + dtex[u][0] = invw1 * vert1->texcoord[u][0] - tex[u][0]; + tex[u][1] = invw0 * vert0->texcoord[u][1]; + dtex[u][1] = invw1 * vert1->texcoord[u][1] - tex[u][1]; + tex[u][2] = invw0 * vert0->texcoord[u][2]; + dtex[u][2] = invw1 * vert1->texcoord[u][2] - tex[u][2]; + tex[u][3] = invw0 * vert0->texcoord[u][3]; + dtex[u][3] = invw1 * vert1->texcoord[u][3] - tex[u][3]; + } } } #endif @@ -255,12 +221,12 @@ zPtr = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, x0, y0); # endif if (depthBits <= 16) { - z0 = FloatToFixed(VB->Win.data[vert0][2] + ctx->LineZoffset); - z1 = FloatToFixed(VB->Win.data[vert1][2] + ctx->LineZoffset); + z0 = FloatToFixed(vert0->win[2]); + z1 = FloatToFixed(vert1->win[2]); } else { - z0 = (int) VB->Win.data[vert0][2] + ctx->LineZoffset; - z1 = (int) VB->Win.data[vert1][2] + ctx->LineZoffset; + z0 = (int) vert0->win[2]; + z1 = (int) vert1->win[2]; } #endif #ifdef PIXEL_ADDRESS @@ -359,7 +325,7 @@ const GLfloat invDx = 1.0F / (GLfloat) dx; GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { dtex[u][0] *= invDx; dtex[u][1] *= invDx; dtex[u][2] *= invDx; @@ -372,7 +338,7 @@ for (i=0;i<dx;i++) { #ifdef STIPPLE GLushort m; - m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf); + m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf); if (ctx->Line.StipplePattern & m) { #endif #ifdef INTERP_Z @@ -393,7 +359,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { const GLfloat invQ = 1.0F / tex[u][3]; fragTexcoord[u][0] = tex[u][0] * invQ; fragTexcoord[u][1] = tex[u][1] * invQ; @@ -420,7 +386,7 @@ #endif /*WIDE*/ #ifdef STIPPLE } - ctx->StippleCounter++; + swrast->StippleCounter++; #endif #ifdef INTERP_XY x0 += xstep; @@ -458,7 +424,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { tex[u][0] += dtex[u][0]; tex[u][1] += dtex[u][1]; tex[u][2] += dtex[u][2]; @@ -528,7 +494,7 @@ const GLfloat invDy = 1.0F / (GLfloat) dy; GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { dtex[u][0] *= invDy; dtex[u][1] *= invDy; dtex[u][2] *= invDy; @@ -541,7 +507,7 @@ for (i=0;i<dy;i++) { #ifdef STIPPLE GLushort m; - m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf); + m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf); if (ctx->Line.StipplePattern & m) { #endif #ifdef INTERP_Z @@ -562,7 +528,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { const GLfloat invQ = 1.0F / tex[u][3]; fragTexcoord[u][0] = tex[u][0] * invQ; fragTexcoord[u][1] = tex[u][1] * invQ; @@ -589,7 +555,7 @@ #endif /*WIDE*/ #ifdef STIPPLE } - ctx->StippleCounter++; + swrast->StippleCounter++; #endif #ifdef INTERP_XY y0 += ystep; @@ -627,7 +593,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { tex[u][0] += dtex[u][0]; tex[u][1] += dtex[u][1]; tex[u][2] += dtex[u][2]; diff --git a/src/mesa/swrast/s_logic.c b/src/mesa/swrast/s_logic.c index 760d7e7065..0e80159763 100644 --- a/src/mesa/swrast/s_logic.c +++ b/src/mesa/swrast/s_logic.c @@ -1,4 +1,4 @@ -/* $Id: s_logic.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_logic.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -30,6 +30,7 @@ #include "macros.h" #include "s_alphabuf.h" +#include "s_context.h" #include "s_logic.h" #include "s_pb.h" #include "s_span.h" @@ -353,7 +354,7 @@ _mesa_logicop_rgba_pixels( GLcontext *ctx, { GLchan dest[PB_SIZE][4]; (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask ); - if (ctx->RasterMask & ALPHABUF_BIT) { + if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) { _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask ); } rgba_logicop( ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest ); diff --git a/src/mesa/swrast/s_masking.c b/src/mesa/swrast/s_masking.c index 5831edf9c0..b246da2053 100644 --- a/src/mesa/swrast/s_masking.c +++ b/src/mesa/swrast/s_masking.c @@ -1,4 +1,4 @@ -/* $Id: s_masking.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_masking.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -35,6 +35,7 @@ #include "macros.h" #include "s_alphabuf.h" +#include "s_context.h" #include "s_masking.h" #include "s_pb.h" #include "s_span.h" @@ -101,7 +102,7 @@ _mesa_mask_rgba_pixels( GLcontext *ctx, GLuint *dest32 = (GLuint *) dest; (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask ); - if (ctx->RasterMask & ALPHABUF_BIT) { + if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) { _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask ); } @@ -117,7 +118,7 @@ _mesa_mask_rgba_pixels( GLcontext *ctx, const GLint aMask = ctx->Color.ColorMask[ACOMP]; (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask ); - if (ctx->RasterMask & ALPHABUF_BIT) { + if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) { _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask ); } diff --git a/src/mesa/swrast/s_pixeltex.c b/src/mesa/swrast/s_pixeltex.c index 854482a251..a9cf425ffb 100644 --- a/src/mesa/swrast/s_pixeltex.c +++ b/src/mesa/swrast/s_pixeltex.c @@ -1,4 +1,4 @@ -/* $Id: s_pixeltex.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_pixeltex.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -36,6 +36,7 @@ #include "glheader.h" #include "colormac.h" +#include "s_context.h" #include "s_pixeltex.h" diff --git a/src/mesa/swrast/s_points.c b/src/mesa/swrast/s_points.c index b24fc642ac..a4a889e2dd 100644 --- a/src/mesa/swrast/s_points.c +++ b/src/mesa/swrast/s_points.c @@ -1,4 +1,4 @@ -/* $Id: s_points.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_points.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -27,13 +27,15 @@ #include "glheader.h" #include "context.h" -#include "feedback.h" #include "macros.h" #include "mmath.h" #include "texstate.h" #include "vb.h" +#include "s_context.h" +#include "s_feedback.h" #include "s_pb.h" +#include "s_points.h" #include "s_span.h" @@ -48,9 +50,6 @@ * 2. size1: size=1 and any rasterization functions * 3. general: any size and rasterization functions (slowest) * - * All point rendering functions take the same two arguments: first and - * last which specify that the points specified by VB[first] through - * VB[last] are to be rendered. */ @@ -61,33 +60,22 @@ * CI points with size == 1.0 */ static void -size1_ci_points( GLcontext *ctx, GLuint first, GLuint last ) +size1_ci_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLfloat *win, *fog; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; GLint *pbx = PB->x, *pby = PB->y; GLdepth *pbz = PB->z; GLfixed *pbfog = PB->fog; GLuint *pbi = PB->index; GLuint pbcount = PB->count; - GLuint i; - - win = &VB->Win.data[first][0]; - fog = &VB->FogCoordPtr->data[first]; - - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - pbx[pbcount] = (GLint) win[0]; - pby[pbcount] = (GLint) win[1]; - pbz[pbcount] = (GLint) (win[2] + ctx->PointZoffset); - pbfog[pbcount] = FloatToFixed(fog[i]); - pbi[pbcount] = VB->IndexPtr->data[i]; - pbcount++; - } - win += 3; - } - PB->count = pbcount; + + pbx[pbcount] = (GLint) vert->win[0]; + pby[pbcount] = (GLint) vert->win[1]; + pbz[pbcount] = (GLint) vert->win[2]; + pbfog[pbcount] = FloatToFixed(vert->fog); + pbi[pbcount] = vert->index; + + PB->count++; PB_CHECK_FLUSH(ctx, PB); } @@ -97,32 +85,20 @@ size1_ci_points( GLcontext *ctx, GLuint first, GLuint last ) * RGBA points with size == 1.0 */ static void -size1_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +size1_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLuint i; - - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLint x, y, z; - GLint fog; - GLint red, green, blue, alpha; - - x = (GLint) VB->Win.data[i][0]; - y = (GLint) VB->Win.data[i][1]; - z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - - fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - red = VB->ColorPtr->data[i][0]; - green = VB->ColorPtr->data[i][1]; - blue = VB->ColorPtr->data[i][2]; - alpha = VB->ColorPtr->data[i][3]; - - PB_WRITE_RGBA_PIXEL( PB, x, y, z, fog, red, green, blue, alpha ); - } - } + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); + GLfixed fog = FloatToFixed( vert->fog ); + GLubyte red = vert->color[0]; + GLubyte green = vert->color[1]; + GLubyte blue = vert->color[2]; + GLubyte alpha = vert->color[3]; + + PB_WRITE_RGBA_PIXEL( PB, x, y, z, fog, red, green, blue, alpha ); PB_CHECK_FLUSH(ctx, PB); } @@ -132,50 +108,44 @@ size1_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) * General CI points. */ static void -general_ci_points( GLcontext *ctx, GLuint first, GLuint last ) +general_ci_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLint isize = (GLint) (ctx->Point.Size + 0.5F); GLint radius = isize >> 1; - GLuint i; - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLint x0, x1, y0, y1; - GLint ix, iy; + GLint x0, x1, y0, y1; + GLint ix, iy; - GLint x = (GLint) VB->Win.data[i][0]; - GLint y = (GLint) VB->Win.data[i][1]; - GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); + GLfixed fog = FloatToFixed( vert->fog ); - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } - PB_SET_INDEX( PB, VB->IndexPtr->data[i] ); + PB_SET_INDEX( PB, vert->index ); - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - PB_WRITE_PIXEL( PB, ix, iy, z, fog ); - } - } - PB_CHECK_FLUSH(ctx,PB); + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + PB_WRITE_PIXEL( PB, ix, iy, z, fog ); } } + PB_CHECK_FLUSH(ctx,PB); } @@ -183,54 +153,48 @@ general_ci_points( GLcontext *ctx, GLuint first, GLuint last ) * General RGBA points. */ static void -general_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +general_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; GLint isize = (GLint) (ctx->Point.Size + 0.5F); GLint radius = isize >> 1; - GLuint i; - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLint x0, x1, y0, y1; - GLint ix, iy; + GLint x0, x1, y0, y1; + GLint ix, iy; - GLint x = (GLint) VB->Win.data[i][0]; - GLint y = (GLint) VB->Win.data[i][1]; - GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); + GLfixed fog = FloatToFixed( vert->fog ); - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } - PB_SET_COLOR( PB, - VB->ColorPtr->data[i][0], - VB->ColorPtr->data[i][1], - VB->ColorPtr->data[i][2], - VB->ColorPtr->data[i][3] ); + PB_SET_COLOR( PB, + vert->color[0], + vert->color[1], + vert->color[2], + vert->color[3] ); - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - PB_WRITE_PIXEL( PB, ix, iy, z, fog ); - } - } - PB_CHECK_FLUSH(ctx,PB); + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + PB_WRITE_PIXEL( PB, ix, iy, z, fog ); } } + PB_CHECK_FLUSH(ctx,PB); } @@ -240,185 +204,142 @@ general_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) * Textured RGBA points. */ static void -textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +textured_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLuint i; - - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLint x0, x1, y0, y1; - GLint ix, iy, radius; - GLint red, green, blue, alpha; - GLfloat s, t, u; - - GLint x = (GLint) VB->Win.data[i][0]; - GLint y = (GLint) VB->Win.data[i][1]; - GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - GLint isize = (GLint) (ctx->Point.Size + 0.5F); - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - if (isize < 1) { - isize = 1; - } - radius = isize >> 1; - - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; - red = VB->ColorPtr->data[i][0]; - green = VB->ColorPtr->data[i][1]; - blue = VB->ColorPtr->data[i][2]; - alpha = VB->ColorPtr->data[i][3]; - - switch (VB->TexCoordPtr[0]->size) { - case 4: - s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3]; - t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3]; - u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3]; - break; - case 3: - s = VB->TexCoordPtr[0]->data[i][0]; - t = VB->TexCoordPtr[0]->data[i][1]; - u = VB->TexCoordPtr[0]->data[i][2]; - break; - case 2: - s = VB->TexCoordPtr[0]->data[i][0]; - t = VB->TexCoordPtr[0]->data[i][1]; - u = 0.0; - break; - case 1: - s = VB->TexCoordPtr[0]->data[i][0]; - t = 0.0; - u = 0.0; - break; - default: - /* should never get here */ - s = t = u = 0.0; - gl_problem(ctx, "unexpected texcoord size in textured_rgba_points()"); - } + GLint x0, x1, y0, y1; + GLint ix, iy, radius; + GLint red, green, blue, alpha; + GLfloat s, t, u; - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - PB_WRITE_TEX_PIXEL( PB, ix, iy, z, fog, red, green, blue, alpha, - s, t, u ); - } - } + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); + GLint isize = (GLint) (ctx->Point.Size + 0.5F); + + GLfixed fog = FloatToFixed( vert->fog ); - PB_CHECK_FLUSH(ctx, PB); + if (isize < 1) { + isize = 1; + } + radius = isize >> 1; + + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } + + red = vert->color[0]; + green = vert->color[1]; + blue = vert->color[2]; + alpha = vert->color[3]; + + if (vert->texcoord[0][3] != 1.0) { + s = vert->texcoord[0][0]/vert->texcoord[0][3]; + t = vert->texcoord[0][1]/vert->texcoord[0][3]; + u = vert->texcoord[0][2]/vert->texcoord[0][3]; + } else { + s = vert->texcoord[0][0]; + t = vert->texcoord[0][1]; + u = vert->texcoord[0][2]; + } + + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + PB_WRITE_TEX_PIXEL( PB, ix, iy, z, fog, red, green, blue, alpha, + s, t, u ); } } + + PB_CHECK_FLUSH(ctx, PB); } + /* * Multitextured RGBA points. */ static void -multitextured_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +multitextured_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLuint i; - - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - const GLint red = VB->ColorPtr->data[i][0]; - const GLint green = VB->ColorPtr->data[i][1]; - const GLint blue = VB->ColorPtr->data[i][2]; - const GLint alpha = VB->ColorPtr->data[i][3]; - const GLint sRed = VB->SecondaryColorPtr->data ? VB->SecondaryColorPtr->data[i][0] : 0; - const GLint sGreen = VB->SecondaryColorPtr->data ? VB->SecondaryColorPtr->data[i][1] : 0; - const GLint sBlue = VB->SecondaryColorPtr->data ? VB->SecondaryColorPtr->data[i][2] : 0; - const GLint x = (GLint) VB->Win.data[i][0]; - const GLint y = (GLint) VB->Win.data[i][1]; - const GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - GLint x0, x1, y0, y1; - GLint ix, iy; - GLfloat texcoord[MAX_TEXTURE_UNITS][4]; - GLint radius, u; - GLint isize = (GLint) (ctx->Point.Size + 0.5F); - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - if (isize < 1) { - isize = 1; - } - radius = isize >> 1; - - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; + + const GLint red = vert->color[0]; + const GLint green = vert->color[1]; + const GLint blue = vert->color[2]; + const GLint alpha = vert->color[3]; + const GLint sRed = vert->specular[0]; + const GLint sGreen = vert->specular[1]; + const GLint sBlue = vert->specular[2]; + const GLint x = (GLint) vert->win[0]; + const GLint y = (GLint) vert->win[1]; + const GLint z = (GLint) (vert->win[2]); + GLint x0, x1, y0, y1; + GLint ix, iy; + GLfloat texcoord[MAX_TEXTURE_UNITS][4]; + GLint radius, u; + GLint isize = (GLint) (ctx->Point.Size + 0.5F); - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - switch (VB->TexCoordPtr[0]->size) { - case 4: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2] / - VB->TexCoordPtr[u]->data[i][3]; - break; - case 3: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2]; - break; - case 2: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = 0.0; - break; - case 1: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = 0.0; - texcoord[u][2] = 0.0; - break; - default: - /* should never get here */ - gl_problem(ctx, "unexpected texcoord size"); - } - } - } + GLfixed fog = FloatToFixed( vert->fog ); - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - PB_WRITE_MULTITEX_SPEC_PIXEL( PB, ix, iy, z, fog, - red, green, blue, alpha, - sRed, sGreen, sBlue, - texcoord ); - } - } - PB_CHECK_FLUSH(ctx, PB); + if (isize < 1) { + isize = 1; + } + radius = isize >> 1; + + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } + + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { + if (vert->texcoord[u][3] != 1.0) { + texcoord[u][0] = vert->texcoord[u][0] / + vert->texcoord[u][3]; + texcoord[u][1] = vert->texcoord[u][1] / + vert->texcoord[u][3]; + texcoord[u][2] = vert->texcoord[u][2] / + vert->texcoord[u][3]; + } + else { + texcoord[u][0] = vert->texcoord[u][0]; + texcoord[u][1] = vert->texcoord[u][1]; + texcoord[u][2] = vert->texcoord[u][2]; + } } } + + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + PB_WRITE_MULTITEX_SPEC_PIXEL( PB, ix, iy, z, fog, + red, green, blue, alpha, + sRed, sGreen, sBlue, + texcoord ); + } + } + PB_CHECK_FLUSH(ctx, PB); } @@ -439,214 +360,140 @@ multitextured_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) * Antialiased points with or without texture mapping. */ static void -antialiased_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +antialiased_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLfloat radius = ctx->Point.Size * 0.5F; const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ const GLfloat rmax = radius + 0.7071F; const GLfloat rmin2 = MAX2(0.0, rmin * rmin); const GLfloat rmax2 = rmax * rmax; const GLfloat cscale = 256.0F / (rmax2 - rmin2); - GLuint i; - - if (ctx->Texture.ReallyEnabled) { - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLint x, y; - GLfloat vx = VB->Win.data[i][0]; - GLfloat vy = VB->Win.data[i][1]; - const GLint xmin = (GLint) (vx - radius); - const GLint xmax = (GLint) (vx + radius); - const GLint ymin = (GLint) (vy - radius); - const GLint ymax = (GLint) (vy + radius); - const GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - const GLint red = VB->ColorPtr->data[i][0]; - const GLint green = VB->ColorPtr->data[i][1]; - const GLint blue = VB->ColorPtr->data[i][2]; - GLfloat texcoord[MAX_TEXTURE_UNITS][4]; - GLint u, alpha; - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - switch (VB->TexCoordPtr[0]->size) { - case 4: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2] / - VB->TexCoordPtr[u]->data[i][3]; - break; - case 3: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2]; - break; - case 2: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = 0.0; - break; - case 1: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = 0.0; - texcoord[u][2] = 0.0; - break; - default: - /* should never get here */ - gl_problem(ctx, "unexpected texcoord size in antialiased_rgba_points()"); - } - } - } - /* translate by a half pixel to simplify math below */ - vx -= 0.5F; - vx -= 0.5F; - - for (y = ymin; y <= ymax; y++) { - for (x = xmin; x <= xmax; x++) { - const GLfloat dx = x - vx; - const GLfloat dy = y - vy; - const GLfloat dist2 = dx*dx + dy*dy; - if (dist2 < rmax2) { - alpha = VB->ColorPtr->data[i][3]; - if (dist2 >= rmin2) { - GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); - /* coverage is in [0,256] */ - alpha = (alpha * coverage) >> 8; - } - if (ctx->Texture.MultiTextureEnabled) { - PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, fog, - red, green, blue, - alpha, texcoord ); - } - else { - PB_WRITE_TEX_PIXEL( PB, x,y,z, fog, - red, green, blue, alpha, - texcoord[0][0], - texcoord[0][1], - texcoord[0][2] ); - } - } - } - } + if (ctx->Texture._ReallyEnabled) { + GLint x, y; + GLfloat vx = vert->win[0]; + GLfloat vy = vert->win[1]; + const GLint xmin = (GLint) (vx - radius); + const GLint xmax = (GLint) (vx + radius); + const GLint ymin = (GLint) (vy - radius); + const GLint ymax = (GLint) (vy + radius); + const GLint z = (GLint) (vert->win[2]); + const GLint red = vert->color[0]; + const GLint green = vert->color[1]; + const GLint blue = vert->color[2]; + GLfloat texcoord[MAX_TEXTURE_UNITS][4]; + GLint u, alpha; + + GLfixed fog = FloatToFixed( vert->fog ); + + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { + if (texcoord[u][3] != 1.0) { + texcoord[u][0] = (vert->texcoord[u][0] / + vert->texcoord[u][3]); + texcoord[u][1] = (vert->texcoord[u][1] / + vert->texcoord[u][3]); + texcoord[u][2] = (vert->texcoord[u][2] / + vert->texcoord[u][3]); + } + else { + texcoord[u][0] = vert->texcoord[u][0]; + texcoord[u][1] = vert->texcoord[u][1]; + texcoord[u][2] = vert->texcoord[u][2]; + } + } + } - PB_CHECK_FLUSH(ctx,PB); - } + /* translate by a half pixel to simplify math below */ + vx -= 0.5F; + vx -= 0.5F; + + for (y = ymin; y <= ymax; y++) { + for (x = xmin; x <= xmax; x++) { + const GLfloat dx = x - vx; + const GLfloat dy = y - vy; + const GLfloat dist2 = dx*dx + dy*dy; + if (dist2 < rmax2) { + alpha = vert->color[3]; + if (dist2 >= rmin2) { + GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); + /* coverage is in [0,256] */ + alpha = (alpha * coverage) >> 8; + } + if (ctx->Texture._MultiTextureEnabled) { + PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, fog, + red, green, blue, + alpha, texcoord ); + } + else { + PB_WRITE_TEX_PIXEL( PB, x,y,z, fog, + red, green, blue, alpha, + texcoord[0][0], + texcoord[0][1], + texcoord[0][2] ); + } + } + } } + + PB_CHECK_FLUSH(ctx,PB); } else { /* Not texture mapped */ - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - const GLint xmin = (GLint) (VB->Win.data[i][0] - 0.0 - radius); - const GLint xmax = (GLint) (VB->Win.data[i][0] - 0.0 + radius); - const GLint ymin = (GLint) (VB->Win.data[i][1] - 0.0 - radius); - const GLint ymax = (GLint) (VB->Win.data[i][1] - 0.0 + radius); - const GLint red = VB->ColorPtr->data[i][0]; - const GLint green = VB->ColorPtr->data[i][1]; - const GLint blue = VB->ColorPtr->data[i][2]; - const GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - GLint x, y; - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - /* - printf("point %g, %g\n", VB->Win.data[i][0], VB->Win.data[i][1]); - printf("%d..%d X %d..%d\n", xmin, xmax, ymin, ymax); - */ - for (y = ymin; y <= ymax; y++) { - for (x = xmin; x <= xmax; x++) { - const GLfloat dx = x + 0.5F - VB->Win.data[i][0]; - const GLfloat dy = y + 0.5F - VB->Win.data[i][1]; - const GLfloat dist2 = dx*dx + dy*dy; - if (dist2 < rmax2) { - GLint alpha = VB->ColorPtr->data[i][3]; - if (dist2 >= rmin2) { - GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); - /* coverage is in [0,256] */ - alpha = (alpha * coverage) >> 8; - } - PB_WRITE_RGBA_PIXEL(PB, x, y, z, fog, - red, green, blue, alpha); - } - } - } - PB_CHECK_FLUSH(ctx,PB); + const GLint xmin = (GLint) (vert->win[0] - 0.0 - radius); + const GLint xmax = (GLint) (vert->win[0] - 0.0 + radius); + const GLint ymin = (GLint) (vert->win[1] - 0.0 - radius); + const GLint ymax = (GLint) (vert->win[1] - 0.0 + radius); + const GLint red = vert->color[0]; + const GLint green = vert->color[1]; + const GLint blue = vert->color[2]; + const GLint z = (GLint) (vert->win[2]); + GLint x, y; + + GLfixed fog = FloatToFixed( vert->fog ); + + /* + printf("point %g, %g\n", vert->win[0], vert->win[1]); + printf("%d..%d X %d..%d\n", xmin, xmax, ymin, ymax); + */ + for (y = ymin; y <= ymax; y++) { + for (x = xmin; x <= xmax; x++) { + const GLfloat dx = x + 0.5F - vert->win[0]; + const GLfloat dy = y + 0.5F - vert->win[1]; + const GLfloat dist2 = dx*dx + dy*dy; + if (dist2 < rmax2) { + GLint alpha = vert->color[3]; + if (dist2 >= rmin2) { + GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); + /* coverage is in [0,256] */ + alpha = (alpha * coverage) >> 8; + } + PB_WRITE_RGBA_PIXEL(PB, x, y, z, fog, + red, green, blue, alpha); + } } } + PB_CHECK_FLUSH(ctx,PB); } } -/* - * Null rasterizer for measuring transformation speed. - */ -static void -null_points( GLcontext *ctx, GLuint first, GLuint last ) -{ - (void) ctx; - (void) first; - (void) last; -} - - - /* Definition of the functions for GL_EXT_point_parameters */ /* Calculates the distance attenuation formula of a vector of points in * eye space coordinates */ -static void -dist3(GLfloat *out, GLuint first, GLuint last, - const GLcontext *ctx, const GLvector4f *v) -{ - GLuint stride = v->stride; - const GLfloat *p = VEC_ELT(v, GLfloat, first); - GLuint i; - - for (i = first ; i <= last ; i++, STRIDE_F(p, stride) ) { - GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]); - out[i] = 1.0F / (ctx->Point.Params[0] + - dist * (ctx->Point.Params[1] + - dist * ctx->Point.Params[2])); - } -} - - -static void -dist2(GLfloat *out, GLuint first, GLuint last, - const GLcontext *ctx, const GLvector4f *v) +static GLfloat attenuation_distance(const GLcontext *ctx, const GLfloat *pos) { - GLuint stride = v->stride; - const GLfloat *p = VEC_ELT(v, GLfloat, first); - GLuint i; - - for (i = first ; i <= last ; i++, STRIDE_F(p, stride) ) { - GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]); - out[i] = 1.0F / (ctx->Point.Params[0] + - dist * (ctx->Point.Params[1] + - dist * ctx->Point.Params[2])); - } + GLfloat dist = GL_SQRT(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]); + return 1.0F / (ctx->Point.Params[0] + + dist * (ctx->Point.Params[1] + + dist * ctx->Point.Params[2])); } -typedef void (*dist_func)(GLfloat *out, GLuint first, GLuint last, - const GLcontext *ctx, const GLvector4f *v); - - -static dist_func eye_dist_tab[5] = { - 0, - 0, - dist2, - dist3, - dist3 -}; @@ -654,465 +501,389 @@ static dist_func eye_dist_tab[5] = { * Distance Attenuated General CI points. */ static void -dist_atten_general_ci_points( GLcontext *ctx, GLuint first, GLuint last ) +dist_atten_general_ci_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLfloat dist[VB_SIZE]; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLfloat psize = ctx->Point.Size; - GLuint i; - - ASSERT(ctx->NeedEyeCoords); - (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr ); - - - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - GLint x0, x1, y0, y1; - GLint ix, iy; - GLint isize, radius; - GLint x = (GLint) VB->Win.data[i][0]; - GLint y = (GLint) VB->Win.data[i][1]; - GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - GLfloat dsize = psize * dist[i]; - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - if (dsize >= ctx->Point.Threshold) { - isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F); - } - else { - isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F); - } - radius = isize >> 1; - - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + GLfloat dist = attenuation_distance( ctx, vert->eye ); + GLint x0, x1, y0, y1; + GLint ix, iy; + GLint isize, radius; + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); + GLfloat dsize = psize * dist; + + GLfixed fog = FloatToFixed( vert->fog ); + + if (dsize >= ctx->Point.Threshold) { + isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F); + } + else { + isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F); + } + radius = isize >> 1; + + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } - PB_SET_INDEX( PB, VB->IndexPtr->data[i] ); + PB_SET_INDEX( PB, vert->index ); - for (iy=y0;iy<=y1;iy++) { - for (ix=x0;ix<=x1;ix++) { - PB_WRITE_PIXEL( PB, ix, iy, z, fog ); - } - } - PB_CHECK_FLUSH(ctx,PB); + for (iy=y0;iy<=y1;iy++) { + for (ix=x0;ix<=x1;ix++) { + PB_WRITE_PIXEL( PB, ix, iy, z, fog ); } } + PB_CHECK_FLUSH(ctx,PB); } /* * Distance Attenuated General RGBA points. */ static void -dist_atten_general_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +dist_atten_general_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLfloat dist[VB_SIZE]; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLfloat psize = ctx->Point.Size; - GLuint i; - - ASSERT (ctx->NeedEyeCoords); - (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr ); - - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - GLint x0, x1, y0, y1; - GLint ix, iy; - GLint isize, radius; - GLint x = (GLint) VB->Win.data[i][0]; - GLint y = (GLint) VB->Win.data[i][1]; - GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - GLfloat dsize=psize*dist[i]; - GLchan alpha; - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - if (dsize >= ctx->Point.Threshold) { - isize = (GLint) (MIN2(dsize,ctx->Point.MaxSize)+0.5F); - alpha = VB->ColorPtr->data[i][3]; - } - else { - isize = (GLint) (MAX2(ctx->Point.Threshold,ctx->Point.MinSize)+0.5F); - dsize /= ctx->Point.Threshold; - alpha = (GLint) (VB->ColorPtr->data[i][3]* (dsize*dsize)); - } - radius = isize >> 1; - - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + GLfloat dist = attenuation_distance( ctx, vert->eye ); + GLint x0, x1, y0, y1; + GLint ix, iy; + GLint isize, radius; + GLint x = (GLint) vert->win[0]; + GLint y = (GLint) vert->win[1]; + GLint z = (GLint) (vert->win[2]); + GLfloat dsize=psize*dist; + GLchan alpha; + GLfixed fog = FloatToFixed( vert->fog ); + + if (dsize >= ctx->Point.Threshold) { + isize = (GLint) (MIN2(dsize,ctx->Point.MaxSize)+0.5F); + alpha = vert->color[3]; + } + else { + isize = (GLint) (MAX2(ctx->Point.Threshold,ctx->Point.MinSize)+0.5F); + dsize /= ctx->Point.Threshold; + alpha = (GLint) (vert->color[3]* (dsize*dsize)); + } + radius = isize >> 1; + + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } - PB_SET_COLOR( PB, - VB->ColorPtr->data[i][0], - VB->ColorPtr->data[i][1], - VB->ColorPtr->data[i][2], - alpha ); + PB_SET_COLOR( PB, + vert->color[0], + vert->color[1], + vert->color[2], + alpha ); - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - PB_WRITE_PIXEL( PB, ix, iy, z, fog ); - } - } - PB_CHECK_FLUSH(ctx,PB); + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + PB_WRITE_PIXEL( PB, ix, iy, z, fog ); } } + PB_CHECK_FLUSH(ctx,PB); } /* * Distance Attenuated Textured RGBA points. */ static void -dist_atten_textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +dist_atten_textured_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLfloat dist[VB_SIZE]; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLfloat psize = ctx->Point.Size; - GLuint i; - - ASSERT(ctx->NeedEyeCoords); - (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr ); - - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - const GLint x = (GLint) VB->Win.data[i][0]; - const GLint y = (GLint) VB->Win.data[i][1]; - const GLint z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - const GLint red = VB->ColorPtr->data[i][0]; - const GLint green = VB->ColorPtr->data[i][1]; - const GLint blue = VB->ColorPtr->data[i][2]; - GLfloat texcoord[MAX_TEXTURE_UNITS][4]; - GLint x0, x1, y0, y1; - GLint ix, iy, alpha, u; - GLint isize, radius; - GLfloat dsize = psize*dist[i]; - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - /* compute point size and alpha */ - if (dsize >= ctx->Point.Threshold) { - isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F); - alpha = VB->ColorPtr->data[i][3]; - } - else { - isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F); - dsize /= ctx->Point.Threshold; - alpha = (GLint) (VB->ColorPtr->data[i][3] * (dsize * dsize)); - } - if (isize < 1) { - isize = 1; - } - radius = isize >> 1; - - if (isize & 1) { - /* odd size */ - x0 = x - radius; - x1 = x + radius; - y0 = y - radius; - y1 = y + radius; - } - else { - /* even size */ - x0 = (GLint) (x + 1.5F) - radius; - x1 = x0 + isize - 1; - y0 = (GLint) (y + 1.5F) - radius; - y1 = y0 + isize - 1; - } + GLfloat dist = attenuation_distance( ctx, vert->eye ); + + const GLint x = (GLint) vert->win[0]; + const GLint y = (GLint) vert->win[1]; + const GLint z = (GLint) (vert->win[2]); + const GLint red = vert->color[0]; + const GLint green = vert->color[1]; + const GLint blue = vert->color[2]; + GLfloat texcoord[MAX_TEXTURE_UNITS][4]; + GLint x0, x1, y0, y1; + GLint ix, iy, alpha, u; + GLint isize, radius; + GLfloat dsize = psize*dist; + + GLfixed fog = FloatToFixed( vert->fog ); + + /* compute point size and alpha */ + if (dsize >= ctx->Point.Threshold) { + isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F); + alpha = vert->color[3]; + } + else { + isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F); + dsize /= ctx->Point.Threshold; + alpha = (GLint) (vert->color[3] * (dsize * dsize)); + } + if (isize < 1) { + isize = 1; + } + radius = isize >> 1; + + if (isize & 1) { + /* odd size */ + x0 = x - radius; + x1 = x + radius; + y0 = y - radius; + y1 = y + radius; + } + else { + /* even size */ + x0 = (GLint) (x + 1.5F) - radius; + x1 = x0 + isize - 1; + y0 = (GLint) (y + 1.5F) - radius; + y1 = y0 + isize - 1; + } - /* get texture coordinates */ - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - switch (VB->TexCoordPtr[0]->size) { - case 4: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2] / - VB->TexCoordPtr[u]->data[i][3]; - break; - case 3: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2]; - break; - case 2: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = 0.0; - break; - case 1: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = 0.0; - texcoord[u][2] = 0.0; - break; - default: - /* should never get here */ - gl_problem(ctx, "unexpected texcoord size"); - } - } - } + /* get texture coordinates */ + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { + if (texcoord[u][3] != 1.0) { + texcoord[u][0] = vert->texcoord[u][0] / + vert->texcoord[u][3]; + texcoord[u][1] = vert->texcoord[u][1] / + vert->texcoord[u][3]; + texcoord[u][2] = vert->texcoord[u][2] / + vert->texcoord[u][3]; + } + else { + texcoord[u][0] = vert->texcoord[u][0]; + texcoord[u][1] = vert->texcoord[u][1]; + texcoord[u][2] = vert->texcoord[u][2]; + } + } + } - for (iy = y0; iy <= y1; iy++) { - for (ix = x0; ix <= x1; ix++) { - if (ctx->Texture.MultiTextureEnabled) { - PB_WRITE_MULTITEX_PIXEL( PB, ix, iy, z, fog, - red, green, blue, alpha, - texcoord ); - } - else { - PB_WRITE_TEX_PIXEL( PB, ix, iy, z, fog, - red, green, blue, alpha, - texcoord[0][0], - texcoord[0][1], - texcoord[0][2] ); - } - } - } - PB_CHECK_FLUSH(ctx,PB); + for (iy = y0; iy <= y1; iy++) { + for (ix = x0; ix <= x1; ix++) { + if (ctx->Texture._MultiTextureEnabled) { + PB_WRITE_MULTITEX_PIXEL( PB, ix, iy, z, fog, + red, green, blue, alpha, + texcoord ); + } + else { + PB_WRITE_TEX_PIXEL( PB, ix, iy, z, fog, + red, green, blue, alpha, + texcoord[0][0], + texcoord[0][1], + texcoord[0][2] ); + } } } + PB_CHECK_FLUSH(ctx,PB); } /* * Distance Attenuated Antialiased points with or without texture mapping. */ static void -dist_atten_antialiased_rgba_points( GLcontext *ctx, GLuint first, GLuint last ) +dist_atten_antialiased_rgba_point( GLcontext *ctx, SWvertex *vert ) { - struct vertex_buffer *VB = ctx->VB; - struct pixel_buffer *PB = ctx->PB; - GLfloat dist[VB_SIZE]; + struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB; const GLfloat psize = ctx->Point.Size; - GLuint i; - - ASSERT(ctx->NeedEyeCoords); - (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr ); - - if (ctx->Texture.ReallyEnabled) { - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf; - GLint xmin, ymin, xmax, ymax; - GLint x, y, z; - GLint red, green, blue, alpha; - GLfloat texcoord[MAX_TEXTURE_UNITS][4]; - GLfloat dsize = psize * dist[i]; - GLint u; - - GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - if (dsize >= ctx->Point.Threshold) { - radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F; - alphaf = 1.0F; - } - else { - radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F); - dsize /= ctx->Point.Threshold; - alphaf = (dsize*dsize); - } - rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ - rmax = radius + 0.7071F; - rmin2 = MAX2(0.0, rmin * rmin); - rmax2 = rmax * rmax; - cscale = 256.0F / (rmax2 - rmin2); - - xmin = (GLint) (VB->Win.data[i][0] - radius); - xmax = (GLint) (VB->Win.data[i][0] + radius); - ymin = (GLint) (VB->Win.data[i][1] - radius); - ymax = (GLint) (VB->Win.data[i][1] + radius); - z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - - red = VB->ColorPtr->data[i][0]; - green = VB->ColorPtr->data[i][1]; - blue = VB->ColorPtr->data[i][2]; + GLfloat dist = attenuation_distance( ctx, vert->eye ); + + if (ctx->Texture._ReallyEnabled) { + GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf; + GLint xmin, ymin, xmax, ymax; + GLint x, y, z; + GLint red, green, blue, alpha; + GLfloat texcoord[MAX_TEXTURE_UNITS][4]; + GLfloat dsize = psize * dist; + GLint u; + + GLfixed fog = FloatToFixed( vert->fog ); + + if (dsize >= ctx->Point.Threshold) { + radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F; + alphaf = 1.0F; + } + else { + radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F); + dsize /= ctx->Point.Threshold; + alphaf = (dsize*dsize); + } + rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ + rmax = radius + 0.7071F; + rmin2 = MAX2(0.0, rmin * rmin); + rmax2 = rmax * rmax; + cscale = 256.0F / (rmax2 - rmin2); + + xmin = (GLint) (vert->win[0] - radius); + xmax = (GLint) (vert->win[0] + radius); + ymin = (GLint) (vert->win[1] - radius); + ymax = (GLint) (vert->win[1] + radius); + z = (GLint) (vert->win[2]); + + red = vert->color[0]; + green = vert->color[1]; + blue = vert->color[2]; - /* get texture coordinates */ - for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - switch (VB->TexCoordPtr[0]->size) { - case 4: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1] / - VB->TexCoordPtr[u]->data[i][3]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2] / - VB->TexCoordPtr[u]->data[i][3]; - break; - case 3: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = VB->TexCoordPtr[u]->data[i][2]; - break; - case 2: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = VB->TexCoordPtr[u]->data[i][1]; - texcoord[u][2] = 0.0; - break; - case 1: - texcoord[u][0] = VB->TexCoordPtr[u]->data[i][0]; - texcoord[u][1] = 0.0; - texcoord[u][2] = 0.0; - break; - default: - /* should never get here */ - gl_problem(ctx, "unexpected texcoord size"); - } - } - } + /* get texture coordinates */ + for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { + if (vert->texcoord[u][3] != 1.0 && vert->texcoord[u][3] != 0.0) { + texcoord[u][0] = vert->texcoord[u][0] / vert->texcoord[u][3]; + texcoord[u][1] = vert->texcoord[u][1] / vert->texcoord[u][3]; + texcoord[u][2] = vert->texcoord[u][2] / vert->texcoord[u][3]; + } + else { + texcoord[u][0] = vert->texcoord[u][0]; + texcoord[u][1] = vert->texcoord[u][1]; + texcoord[u][2] = vert->texcoord[u][2]; + } + } + } - for (y = ymin; y <= ymax; y++) { - for (x = xmin; x <= xmax; x++) { - const GLfloat dx = x + 0.5F - VB->Win.data[i][0]; - const GLfloat dy = y + 0.5F - VB->Win.data[i][1]; - const GLfloat dist2 = dx*dx + dy*dy; - if (dist2 < rmax2) { - alpha = VB->ColorPtr->data[i][3]; - if (dist2 >= rmin2) { - GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); - /* coverage is in [0,256] */ - alpha = (alpha * coverage) >> 8; - } - alpha = (GLint) (alpha * alphaf); - if (ctx->Texture.MultiTextureEnabled) { - PB_WRITE_MULTITEX_PIXEL( PB, x, y, z, fog, - red, green, blue, alpha, - texcoord ); - } - else { - PB_WRITE_TEX_PIXEL( PB, x,y,z, fog, - red, green, blue, alpha, - texcoord[0][0], - texcoord[0][1], - texcoord[0][2] ); - } - } - } - } - PB_CHECK_FLUSH(ctx,PB); - } + for (y = ymin; y <= ymax; y++) { + for (x = xmin; x <= xmax; x++) { + const GLfloat dx = x + 0.5F - vert->win[0]; + const GLfloat dy = y + 0.5F - vert->win[1]; + const GLfloat dist2 = dx*dx + dy*dy; + if (dist2 < rmax2) { + alpha = vert->color[3]; + if (dist2 >= rmin2) { + GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); + /* coverage is in [0,256] */ + alpha = (alpha * coverage) >> 8; + } + alpha = (GLint) (alpha * alphaf); + if (ctx->Texture._MultiTextureEnabled) { + PB_WRITE_MULTITEX_PIXEL( PB, x, y, z, fog, + red, green, blue, alpha, + texcoord ); + } + else { + PB_WRITE_TEX_PIXEL( PB, x,y,z, fog, + red, green, blue, alpha, + texcoord[0][0], + texcoord[0][1], + texcoord[0][2] ); + } + } + } } + PB_CHECK_FLUSH(ctx,PB); } else { /* Not texture mapped */ - for (i = first; i <= last; i++) { - if (VB->ClipMask[i] == 0) { - GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf; - GLint xmin, ymin, xmax, ymax; - GLint x, y, z; - GLfixed fog; - GLint red, green, blue, alpha; - GLfloat dsize = psize * dist[i]; - - if (dsize >= ctx->Point.Threshold) { - radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F; - alphaf = 1.0F; - } - else { - radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F); - dsize /= ctx->Point.Threshold; - alphaf = dsize * dsize; - } - rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ - rmax = radius + 0.7071F; - rmin2 = MAX2(0.0, rmin * rmin); - rmax2 = rmax * rmax; - cscale = 256.0F / (rmax2 - rmin2); - - xmin = (GLint) (VB->Win.data[i][0] - radius); - xmax = (GLint) (VB->Win.data[i][0] + radius); - ymin = (GLint) (VB->Win.data[i][1] - radius); - ymax = (GLint) (VB->Win.data[i][1] + radius); - z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset); - - fog = FloatToFixed( VB->FogCoordPtr->data[i] ); - - red = VB->ColorPtr->data[i][0]; - green = VB->ColorPtr->data[i][1]; - blue = VB->ColorPtr->data[i][2]; - - for (y = ymin; y <= ymax; y++) { - for (x = xmin; x <= xmax; x++) { - const GLfloat dx = x + 0.5F - VB->Win.data[i][0]; - const GLfloat dy = y + 0.5F - VB->Win.data[i][1]; - const GLfloat dist2 = dx * dx + dy * dy; - if (dist2 < rmax2) { - alpha = VB->ColorPtr->data[i][3]; - if (dist2 >= rmin2) { - GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); - /* coverage is in [0,256] */ - alpha = (alpha * coverage) >> 8; - } - alpha = (GLint) (alpha * alphaf); - PB_WRITE_RGBA_PIXEL(PB, x, y, z, fog, - red, green, blue, alpha); - } - } - } - PB_CHECK_FLUSH(ctx,PB); + GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf; + GLint xmin, ymin, xmax, ymax; + GLint x, y, z; + GLfixed fog; + GLint red, green, blue, alpha; + GLfloat dsize = psize * dist; + + if (dsize >= ctx->Point.Threshold) { + radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F; + alphaf = 1.0F; + } + else { + radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F); + dsize /= ctx->Point.Threshold; + alphaf = dsize * dsize; + } + rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ + rmax = radius + 0.7071F; + rmin2 = MAX2(0.0, rmin * rmin); + rmax2 = rmax * rmax; + cscale = 256.0F / (rmax2 - rmin2); + + xmin = (GLint) (vert->win[0] - radius); + xmax = (GLint) (vert->win[0] + radius); + ymin = (GLint) (vert->win[1] - radius); + ymax = (GLint) (vert->win[1] + radius); + z = (GLint) (vert->win[2]); + + fog = FloatToFixed( vert->fog ); + + red = vert->color[0]; + green = vert->color[1]; + blue = vert->color[2]; + + for (y = ymin; y <= ymax; y++) { + for (x = xmin; x <= xmax; x++) { + const GLfloat dx = x + 0.5F - vert->win[0]; + const GLfloat dy = y + 0.5F - vert->win[1]; + const GLfloat dist2 = dx * dx + dy * dy; + if (dist2 < rmax2) { + alpha = vert->color[3]; + if (dist2 >= rmin2) { + GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale); + /* coverage is in [0,256] */ + alpha = (alpha * coverage) >> 8; + } + alpha = (GLint) (alpha * alphaf); + PB_WRITE_RGBA_PIXEL(PB, x, y, z, fog, + red, green, blue, alpha); + } } } + PB_CHECK_FLUSH(ctx,PB); } } #ifdef DEBUG void -_mesa_print_points_function(GLcontext *ctx) +_mesa_print_point_function(GLcontext *ctx) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); + printf("Point Func == "); - if (ctx->Driver.PointsFunc == size1_ci_points) - printf("size1_ci_points\n"); - else if (ctx->Driver.PointsFunc == size1_rgba_points) - printf("size1_rgba_points\n"); - else if (ctx->Driver.PointsFunc == general_ci_points) - printf("general_ci_points\n"); - else if (ctx->Driver.PointsFunc == general_rgba_points) - printf("general_rgba_points\n"); - else if (ctx->Driver.PointsFunc == textured_rgba_points) - printf("textured_rgba_points\n"); - else if (ctx->Driver.PointsFunc == multitextured_rgba_points) - printf("multitextured_rgba_points\n"); - else if (ctx->Driver.PointsFunc == antialiased_rgba_points) - printf("antialiased_rgba_points\n"); - else if (ctx->Driver.PointsFunc == null_points) - printf("null_points\n"); - else if (ctx->Driver.PointsFunc == dist_atten_general_ci_points) - printf("dist_atten_general_ci_points\n"); - else if (ctx->Driver.PointsFunc == dist_atten_general_rgba_points) - printf("dist_atten_general_rgba_points\n"); - else if (ctx->Driver.PointsFunc == dist_atten_textured_rgba_points) - printf("dist_atten_textured_rgba_points\n"); - else if (ctx->Driver.PointsFunc == dist_atten_antialiased_rgba_points) - printf("dist_atten_antialiased_rgba_points\n"); - else if (!ctx->Driver.PointsFunc) + if (swrast->Point == size1_ci_point) + printf("size1_ci_point\n"); + else if (swrast->Point == size1_rgba_point) + printf("size1_rgba_point\n"); + else if (swrast->Point == general_ci_point) + printf("general_ci_point\n"); + else if (swrast->Point == general_rgba_point) + printf("general_rgba_point\n"); + else if (swrast->Point == textured_rgba_point) + printf("textured_rgba_point\n"); + else if (swrast->Point == multitextured_rgba_point) + printf("multitextured_rgba_point\n"); + else if (swrast->Point == antialiased_rgba_point) + printf("antialiased_rgba_point\n"); + else if (swrast->Point == dist_atten_general_ci_point) + printf("dist_atten_general_ci_point\n"); + else if (swrast->Point == dist_atten_general_rgba_point) + printf("dist_atten_general_rgba_point\n"); + else if (swrast->Point == dist_atten_textured_rgba_point) + printf("dist_atten_textured_rgba_point\n"); + else if (swrast->Point == dist_atten_antialiased_rgba_point) + printf("dist_atten_antialiased_rgba_point\n"); + else if (!swrast->Point) printf("NULL\n"); else - printf("Driver func %p\n", ctx->Driver.PointsFunc); + printf("Driver func %p\n", swrast->Point); } #endif @@ -1122,70 +893,61 @@ _mesa_print_points_function(GLcontext *ctx) * should be used. */ void -_swrast_set_point_function( GLcontext *ctx ) +_swrast_choose_point( GLcontext *ctx ) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); GLboolean rgbmode = ctx->Visual.RGBAflag; if (ctx->RenderMode==GL_RENDER) { - if (ctx->NoRaster) { - ctx->Driver.PointsFunc = null_points; - return; - } - if (ctx->Driver.PointsFunc) { - /* Device driver will draw points. */ - ctx->IndirectTriangles &= ~DD_POINT_SW_RASTERIZE; - return; - } - - if (!ctx->Point.Attenuated) { + if (!ctx->Point._Attenuated) { if (ctx->Point.SmoothFlag && rgbmode) { - ctx->Driver.PointsFunc = antialiased_rgba_points; + swrast->Point = antialiased_rgba_point; } - else if (ctx->Texture.ReallyEnabled) { - if (ctx->Texture.MultiTextureEnabled || + else if (ctx->Texture._ReallyEnabled) { + if (ctx->Texture._MultiTextureEnabled || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR || ctx->Fog.ColorSumEnabled) { - ctx->Driver.PointsFunc = multitextured_rgba_points; + swrast->Point = multitextured_rgba_point; } else { - ctx->Driver.PointsFunc = textured_rgba_points; + swrast->Point = textured_rgba_point; } } else if (ctx->Point.Size==1.0) { /* size=1, any raster ops */ if (rgbmode) - ctx->Driver.PointsFunc = size1_rgba_points; + swrast->Point = size1_rgba_point; else - ctx->Driver.PointsFunc = size1_ci_points; + swrast->Point = size1_ci_point; } else { /* every other kind of point rendering */ if (rgbmode) - ctx->Driver.PointsFunc = general_rgba_points; + swrast->Point = general_rgba_point; else - ctx->Driver.PointsFunc = general_ci_points; + swrast->Point = general_ci_point; } } else if(ctx->Point.SmoothFlag && rgbmode) { - ctx->Driver.PointsFunc = dist_atten_antialiased_rgba_points; + swrast->Point = dist_atten_antialiased_rgba_point; } - else if (ctx->Texture.ReallyEnabled) { - ctx->Driver.PointsFunc = dist_atten_textured_rgba_points; + else if (ctx->Texture._ReallyEnabled) { + swrast->Point = dist_atten_textured_rgba_point; } else { /* every other kind of point rendering */ if (rgbmode) - ctx->Driver.PointsFunc = dist_atten_general_rgba_points; + swrast->Point = dist_atten_general_rgba_point; else - ctx->Driver.PointsFunc = dist_atten_general_ci_points; + swrast->Point = dist_atten_general_ci_point; } } else if (ctx->RenderMode==GL_FEEDBACK) { - ctx->Driver.PointsFunc = gl_feedback_points; + swrast->Point = gl_feedback_point; } else { /* GL_SELECT mode */ - ctx->Driver.PointsFunc = gl_select_points; + swrast->Point = gl_select_point; } /*_mesa_print_points_function(ctx);*/ diff --git a/src/mesa/swrast/s_points.h b/src/mesa/swrast/s_points.h new file mode 100644 index 0000000000..1c1af1a89f --- /dev/null +++ b/src/mesa/swrast/s_points.h @@ -0,0 +1,10 @@ +#ifndef S_POINTS_H +#define S_POINTS_H + +#include "types.h" + +void +_swrast_choose_point( GLcontext *ctx ); + + +#endif diff --git a/src/mesa/swrast/s_readpix.c b/src/mesa/swrast/s_readpix.c index 74a4d68266..ba3aca5392 100644 --- a/src/mesa/swrast/s_readpix.c +++ b/src/mesa/swrast/s_readpix.c @@ -1,4 +1,4 @@ -/* $Id: s_readpix.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_readpix.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -36,6 +36,7 @@ #include "pixel.h" #include "s_alphabuf.h" +#include "s_context.h" #include "s_depth.h" #include "s_span.h" #include "s_stencil.h" @@ -497,7 +498,7 @@ read_fast_rgba_pixels( GLcontext *ctx, const struct gl_pixelstore_attrib *packing ) { /* can't do scale, bias, mapping, etc */ - if (ctx->ImageTransferState) + if (ctx->_ImageTransferState) return GL_FALSE; /* can't do fancy pixel packing */ @@ -636,7 +637,7 @@ static void read_rgba_pixels( GLcontext *ctx, } if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) { - const GLuint transferOps = ctx->ImageTransferState; + const GLuint transferOps = ctx->_ImageTransferState; GLfloat *dest, *src, *tmpImage, *convImage; GLint row; @@ -717,7 +718,7 @@ static void read_rgba_pixels( GLcontext *ctx, format, type, 0, row, 0); _mesa_pack_rgba_span(ctx, readWidth, (const GLchan (*)[4]) rgba, format, type, dst, packing, - ctx->ImageTransferState); + ctx->_ImageTransferState); } } @@ -735,6 +736,9 @@ _swrast_ReadPixels( GLcontext *ctx, { (void) pack; + if (SWRAST_CONTEXT(ctx)->NewState) + _swrast_validate_derived( ctx ); + switch (format) { case GL_COLOR_INDEX: read_index_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack); diff --git a/src/mesa/swrast/s_span.c b/src/mesa/swrast/s_span.c index ca02802ceb..a115199ab8 100644 --- a/src/mesa/swrast/s_span.c +++ b/src/mesa/swrast/s_span.c @@ -1,4 +1,4 @@ -/* $Id: s_span.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_span.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -39,6 +39,7 @@ #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" @@ -182,18 +183,19 @@ void gl_write_index_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (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; @@ -236,7 +238,7 @@ void gl_write_index_span( GLcontext *ctx, /* if we get here, something passed the depth test */ ctx->OcclusionResult = GL_TRUE; - 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, index, mask ); } @@ -267,13 +269,14 @@ void gl_write_monoindex_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (clip_span( ctx, n, x, y, mask)==0) { return; } @@ -330,7 +333,7 @@ void gl_write_monoindex_span( GLcontext *ctx, _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 ); } @@ -352,7 +355,7 @@ void gl_write_monoindex_span( GLcontext *ctx, /* 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++) @@ -377,6 +380,7 @@ static void multi_write_rgba_span( GLcontext *ctx, GLuint n, { const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask); GLuint bufferBit; + SWcontext *swrast = SWRAST_CONTEXT(ctx); if (ctx->Color.DrawBuffer == GL_NONE) return; @@ -422,7 +426,7 @@ static void multi_write_rgba_span( GLcontext *ctx, GLuint n, (*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 ); } @@ -448,19 +452,20 @@ void gl_write_rgba_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (clip_span( ctx,n,x,y,mask)==0) { return; } 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; @@ -520,7 +525,7 @@ void gl_write_rgba_span( GLcontext *ctx, /* if we get here, something passed the depth test */ ctx->OcclusionResult = GL_TRUE; - 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 ); } else { @@ -548,7 +553,7 @@ void gl_write_rgba_span( GLcontext *ctx, (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 ); @@ -581,11 +586,12 @@ void gl_write_monocolor_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (clip_span( ctx,n,x,y,mask)==0) { return; } @@ -644,7 +650,7 @@ void gl_write_monocolor_span( GLcontext *ctx, } 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++) { if (mask[i]) { @@ -660,7 +666,7 @@ void gl_write_monocolor_span( GLcontext *ctx, _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 ); } @@ -685,7 +691,7 @@ void gl_write_monocolor_span( GLcontext *ctx, (*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 ); @@ -697,7 +703,7 @@ void gl_write_monocolor_span( GLcontext *ctx, ASSERT(!ctx->Color.BlendEnabled); ASSERT(!ctx->Color.ColorLogicOpEnabled); - if (ctx->RasterMask & MULTI_DRAW_BIT) { + if (swrast->_RasterMask & MULTI_DRAW_BIT) { for (i=0;i<n;i++) { if (mask[i]) { COPY_CHAN4(rgba[i], color); @@ -708,7 +714,7 @@ void gl_write_monocolor_span( GLcontext *ctx, } else { (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, mask ); - if (ctx->RasterMask & ALPHABUF_BIT) { + if (swrast->_RasterMask & ALPHABUF_BIT) { _mesa_write_mono_alpha_span( ctx, n, x, y, (GLchan) color[ACOMP], write_all ? Null : mask ); } @@ -763,11 +769,12 @@ void gl_write_texture_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (clip_span(ctx, n, x, y, mask)==0) { return; } @@ -775,7 +782,7 @@ void gl_write_texture_span( GLcontext *ctx, } - 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; @@ -785,7 +792,7 @@ void gl_write_texture_span( GLcontext *ctx, } /* Texture */ - ASSERT(ctx->Texture.ReallyEnabled); + ASSERT(ctx->Texture._ReallyEnabled); gl_texture_pixels( ctx, 0, n, s, t, u, lambda, rgba, rgba ); /* Add base and specular colors */ @@ -844,7 +851,7 @@ void gl_write_texture_span( GLcontext *ctx, /* if we get here, something passed the depth test */ ctx->OcclusionResult = GL_TRUE; - 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 ); } else { @@ -864,7 +871,7 @@ void gl_write_texture_span( GLcontext *ctx, (*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 ); } @@ -896,11 +903,12 @@ gl_write_multitexture_span( GLcontext *ctx, 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 ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) { if (clip_span(ctx, n, x, y, mask)==0) { return; } @@ -908,7 +916,7 @@ gl_write_multitexture_span( GLcontext *ctx, } - 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)); @@ -919,7 +927,7 @@ gl_write_multitexture_span( GLcontext *ctx, } /* Texture */ - ASSERT(ctx->Texture.ReallyEnabled); + 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 ); @@ -979,7 +987,7 @@ gl_write_multitexture_span( GLcontext *ctx, /* if we get here, something passed the depth test */ ctx->OcclusionResult = GL_TRUE; - 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 ); } else { @@ -1001,7 +1009,7 @@ gl_write_multitexture_span( GLcontext *ctx, } (*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 ); } diff --git a/src/mesa/swrast/s_stencil.c b/src/mesa/swrast/s_stencil.c index c957a683a1..80839451cb 100644 --- a/src/mesa/swrast/s_stencil.c +++ b/src/mesa/swrast/s_stencil.c @@ -1,4 +1,4 @@ -/* $Id: s_stencil.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_stencil.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -30,6 +30,7 @@ #include "macros.h" #include "mem.h" +#include "s_context.h" #include "s_depth.h" #include "s_pb.h" #include "s_stencil.h" diff --git a/src/mesa/swrast/s_texture.c b/src/mesa/swrast/s_texture.c index 04f8645b97..e2fa421492 100644 --- a/src/mesa/swrast/s_texture.c +++ b/src/mesa/swrast/s_texture.c @@ -1,4 +1,4 @@ -/* $Id: s_texture.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_texture.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -33,6 +33,7 @@ #include "mem.h" #include "teximage.h" +#include "s_context.h" #include "s_pb.h" #include "s_texture.h" @@ -174,8 +175,8 @@ static void palette_sample(const struct gl_texture_object *tObj, { \ if (lambda < 0.0F) \ lambda = 0.0F; \ - else if (lambda > tObj->M) \ - lambda = tObj->M; \ + else if (lambda > tObj->_M) \ + lambda = tObj->_M; \ level = (GLint) (tObj->BaseLevel + lambda); \ } @@ -187,11 +188,11 @@ static void palette_sample(const struct gl_texture_object *tObj, { \ if (lambda <= 0.5F) \ lambda = 0.0F; \ - else if (lambda > tObj->M + 0.4999F) \ - lambda = tObj->M + 0.4999F; \ + else if (lambda > tObj->_M + 0.4999F) \ + lambda = tObj->_M + 0.4999F; \ level = (GLint) (tObj->BaseLevel + lambda + 0.5F); \ - if (level > tObj->P) \ - level = tObj->P; \ + if (level > tObj->_P) \ + level = tObj->_P; \ } @@ -432,8 +433,8 @@ sample_1d_nearest_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_1d_nearest( tObj, tObj->Image[tObj->P], s, rgba ); + if (level >= tObj->_P) { + sample_1d_nearest( tObj, tObj->Image[tObj->_P], s, rgba ); } else { GLchan t0[4], t1[4]; @@ -458,8 +459,8 @@ sample_1d_linear_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_1d_linear( tObj, tObj->Image[tObj->P], s, rgba ); + if (level >= tObj->_P) { + sample_1d_linear( tObj, tObj->Image[tObj->_P], s, rgba ); } else { GLchan t0[4], t1[4]; @@ -475,7 +476,8 @@ sample_1d_linear_mipmap_linear( const struct gl_texture_object *tObj, -static void sample_nearest_1d( const struct gl_texture_object *tObj, GLuint n, +static void sample_nearest_1d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -492,7 +494,8 @@ static void sample_nearest_1d( const struct gl_texture_object *tObj, GLuint n, -static void sample_linear_1d( const struct gl_texture_object *tObj, GLuint n, +static void sample_linear_1d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -513,18 +516,20 @@ static void sample_linear_1d( const struct gl_texture_object *tObj, GLuint n, * return a texture sample. * */ -static void sample_lambda_1d( const struct gl_texture_object *tObj, GLuint n, +static void sample_lambda_1d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) { + GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit]; GLuint i; (void) t; (void) u; for (i=0;i<n;i++) { - if (lambda[i] > tObj->MinMagThresh) { + if (lambda[i] > MinMagThresh) { /* minification */ switch (tObj->MinFilter) { case GL_NEAREST: @@ -806,8 +811,8 @@ sample_2d_nearest_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_2d_nearest( tObj, tObj->Image[tObj->P], s, t, rgba ); + if (level >= tObj->_P) { + sample_2d_nearest( tObj, tObj->Image[tObj->_P], s, t, rgba ); } else { GLchan t0[4], t1[4]; /* texels */ @@ -832,8 +837,8 @@ sample_2d_linear_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_2d_linear( tObj, tObj->Image[tObj->P], s, t, rgba ); + if (level >= tObj->_P) { + sample_2d_linear( tObj, tObj->Image[tObj->_P], s, t, rgba ); } else { GLchan t0[4], t1[4]; /* texels */ @@ -849,7 +854,8 @@ sample_2d_linear_mipmap_linear( const struct gl_texture_object *tObj, -static void sample_nearest_2d( const struct gl_texture_object *tObj, GLuint n, +static void sample_nearest_2d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -865,7 +871,8 @@ static void sample_nearest_2d( const struct gl_texture_object *tObj, GLuint n, -static void sample_linear_2d( const struct gl_texture_object *tObj, GLuint n, +static void sample_linear_2d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -884,16 +891,18 @@ static void sample_linear_2d( const struct gl_texture_object *tObj, GLuint n, * Given an (s,t) texture coordinate and lambda (level of detail) value, * return a texture sample. */ -static void sample_lambda_2d( const struct gl_texture_object *tObj, +static void sample_lambda_2d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) { + GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit]; GLuint i; (void) u; for (i=0;i<n;i++) { - if (lambda[i] > tObj->MinMagThresh) { + if (lambda[i] > MinMagThresh) { /* minification */ switch (tObj->MinFilter) { case GL_NEAREST: @@ -943,7 +952,8 @@ static void sample_lambda_2d( const struct gl_texture_object *tObj, * No border * Format = GL_RGB */ -static void opt_sample_rgb_2d( const struct gl_texture_object *tObj, +static void opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -984,7 +994,8 @@ static void opt_sample_rgb_2d( const struct gl_texture_object *tObj, * No border * Format = GL_RGBA */ -static void opt_sample_rgba_2d( const struct gl_texture_object *tObj, +static void opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -1303,8 +1314,8 @@ sample_3d_nearest_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_3d_nearest( tObj, tObj->Image[tObj->P], s, t, r, rgba ); + if (level >= tObj->_P) { + sample_3d_nearest( tObj, tObj->Image[tObj->_P], s, t, r, rgba ); } else { GLchan t0[4], t1[4]; /* texels */ @@ -1328,8 +1339,8 @@ sample_3d_linear_mipmap_linear( const struct gl_texture_object *tObj, COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level); - if (level >= tObj->P) { - sample_3d_linear( tObj, tObj->Image[tObj->P], s, t, r, rgba ); + if (level >= tObj->_P) { + sample_3d_linear( tObj, tObj->Image[tObj->_P], s, t, r, rgba ); } else { GLchan t0[4], t1[4]; /* texels */ @@ -1344,7 +1355,8 @@ sample_3d_linear_mipmap_linear( const struct gl_texture_object *tObj, } -static void sample_nearest_3d( const struct gl_texture_object *tObj, GLuint n, +static void sample_nearest_3d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -1359,7 +1371,8 @@ static void sample_nearest_3d( const struct gl_texture_object *tObj, GLuint n, -static void sample_linear_3d( const struct gl_texture_object *tObj, GLuint n, +static void sample_linear_3d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) @@ -1377,16 +1390,18 @@ static void sample_linear_3d( const struct gl_texture_object *tObj, GLuint n, * Given an (s,t,r) texture coordinate and lambda (level of detail) value, * return a texture sample. */ -static void sample_lambda_3d( const struct gl_texture_object *tObj, GLuint n, +static void sample_lambda_3d( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4] ) { GLuint i; + GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit]; for (i=0;i<n;i++) { - if (lambda[i] > tObj->MinMagThresh) { + if (lambda[i] > MinMagThresh) { /* minification */ switch (tObj->MinFilter) { case GL_NEAREST: @@ -1507,7 +1522,8 @@ choose_cube_face(const struct gl_texture_object *texObj, static void -sample_nearest_cube(const struct gl_texture_object *tObj, GLuint n, +sample_nearest_cube(GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4]) @@ -1524,7 +1540,8 @@ sample_nearest_cube(const struct gl_texture_object *tObj, GLuint n, static void -sample_linear_cube(const struct gl_texture_object *tObj, GLuint n, +sample_linear_cube(GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, const GLfloat s[], const GLfloat t[], const GLfloat u[], const GLfloat lambda[], GLchan rgba[][4]) @@ -1585,8 +1602,8 @@ sample_cube_nearest_mipmap_linear( const struct gl_texture_object *tObj, images = choose_cube_face(tObj, s, t, u, &newS, &newT); - if (level >= tObj->P) { - sample_2d_nearest( tObj, images[tObj->P], newS, newT, rgba ); + if (level >= tObj->_P) { + sample_2d_nearest( tObj, images[tObj->_P], newS, newT, rgba ); } else { GLchan t0[4], t1[4]; /* texels */ @@ -1614,8 +1631,8 @@ sample_cube_linear_mipmap_linear( const struct gl_texture_object *tObj, images = choose_cube_face(tObj, s, t, u, &newS, &newT); - if (level >= tObj->P) { - sample_2d_linear( tObj, images[tObj->P], newS, newT, rgba ); + if (level >= tObj->_P) { + sample_2d_linear( tObj, images[tObj->_P], newS, newT, rgba ); } else { GLchan t0[4], t1[4]; @@ -1631,15 +1648,17 @@ sample_cube_linear_mipmap_linear( const struct gl_texture_object *tObj, static void -sample_lambda_cube(const struct gl_texture_object *tObj, GLuint n, - const GLfloat s[], const GLfloat t[], - const GLfloat u[], const GLfloat lambda[], - GLchan rgba[][4]) +sample_lambda_cube( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, + const GLfloat s[], const GLfloat t[], + const GLfloat u[], const GLfloat lambda[], + GLchan rgba[][4]) { + GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit]; GLuint i; for (i = 0; i < n; i++) { - if (lambda[i] > tObj->MinMagThresh) { + if (lambda[i] > MinMagThresh) { /* minification */ switch (tObj->MinFilter) { case GL_NEAREST: @@ -1704,6 +1723,14 @@ sample_lambda_cube(const struct gl_texture_object *tObj, GLuint n, } } +static void +null_sample_func( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *tObj, GLuint n, + const GLfloat s[], const GLfloat t[], + const GLfloat u[], const GLfloat lambda[], + GLchan rgba[][4]) +{ +} /**********************************************************************/ /* Texture Sampling Setup */ @@ -1714,10 +1741,13 @@ sample_lambda_cube(const struct gl_texture_object *tObj, GLuint n, * Setup the texture sampling function for this texture object. */ void -_swrast_set_texture_sampler( struct gl_texture_object *t ) +_swrast_choose_texture_sample_func( GLcontext *ctx, GLuint texUnit, + const struct gl_texture_object *t ) { - if (!t->Complete) { - t->SampleFunc = NULL; + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (!t->Complete) { + swrast->TextureSample[texUnit] = null_sample_func; } else { GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter); @@ -1727,69 +1757,69 @@ _swrast_set_texture_sampler( struct gl_texture_object *t ) if (t->MagFilter==GL_LINEAR && (t->MinFilter==GL_NEAREST_MIPMAP_NEAREST || t->MinFilter==GL_LINEAR_MIPMAP_NEAREST)) { - t->MinMagThresh = 0.5F; + swrast->_MinMagThresh[texUnit] = 0.5F; } else { - t->MinMagThresh = 0.0F; + swrast->_MinMagThresh[texUnit] = 0.0F; } } switch (t->Dimensions) { case 1: if (needLambda) { - t->SampleFunc = sample_lambda_1d; + swrast->TextureSample[texUnit] = sample_lambda_1d; } else if (t->MinFilter==GL_LINEAR) { - t->SampleFunc = sample_linear_1d; + swrast->TextureSample[texUnit] = sample_linear_1d; } else { ASSERT(t->MinFilter==GL_NEAREST); - t->SampleFunc = sample_nearest_1d; + swrast->TextureSample[texUnit] = sample_nearest_1d; } break; case 2: if (needLambda) { - t->SampleFunc = sample_lambda_2d; + swrast->TextureSample[texUnit] = sample_lambda_2d; } else if (t->MinFilter==GL_LINEAR) { - t->SampleFunc = sample_linear_2d; + swrast->TextureSample[texUnit] = sample_linear_2d; } else { ASSERT(t->MinFilter==GL_NEAREST); if (t->WrapS==GL_REPEAT && t->WrapT==GL_REPEAT && t->Image[0]->Border==0 && t->Image[0]->Format==GL_RGB) { - t->SampleFunc = opt_sample_rgb_2d; + swrast->TextureSample[texUnit] = opt_sample_rgb_2d; } else if (t->WrapS==GL_REPEAT && t->WrapT==GL_REPEAT && t->Image[0]->Border==0 && t->Image[0]->Format==GL_RGBA) { - t->SampleFunc = opt_sample_rgba_2d; + swrast->TextureSample[texUnit] = opt_sample_rgba_2d; } else - t->SampleFunc = sample_nearest_2d; + swrast->TextureSample[texUnit] = sample_nearest_2d; } break; case 3: if (needLambda) { - t->SampleFunc = sample_lambda_3d; + swrast->TextureSample[texUnit] = sample_lambda_3d; } else if (t->MinFilter==GL_LINEAR) { - t->SampleFunc = sample_linear_3d; + swrast->TextureSample[texUnit] = sample_linear_3d; } else { ASSERT(t->MinFilter==GL_NEAREST); - t->SampleFunc = sample_nearest_3d; + swrast->TextureSample[texUnit] = sample_nearest_3d; } break; case 6: /* cube map */ if (needLambda) { - t->SampleFunc = sample_lambda_cube; + swrast->TextureSample[texUnit] = sample_lambda_cube; } else if (t->MinFilter==GL_LINEAR) { - t->SampleFunc = sample_linear_cube; + swrast->TextureSample[texUnit] = sample_linear_cube; } else { ASSERT(t->MinFilter==GL_NEAREST); - t->SampleFunc = sample_nearest_cube; + swrast->TextureSample[texUnit] = sample_nearest_cube; } break; default: @@ -2116,12 +2146,12 @@ apply_texture( const GLcontext *ctx, GLenum format; ASSERT(texUnit); - ASSERT(texUnit->Current); + ASSERT(texUnit->_Current); - baseLevel = texUnit->Current->BaseLevel; - ASSERT(texUnit->Current->Image[baseLevel]); + baseLevel = texUnit->_Current->BaseLevel; + ASSERT(texUnit->_Current->Image[baseLevel]); - format = texUnit->Current->Image[baseLevel]->Format; + format = texUnit->_Current->Image[baseLevel]->Format; if (format==GL_COLOR_INDEX) { format = GL_RGBA; /* XXXX a hack! */ @@ -2496,10 +2526,10 @@ void gl_texture_pixels( GLcontext *ctx, GLuint texUnit, GLuint n, { const GLuint mask = TEXTURE0_ANY << (texUnit * 4); - if (ctx->Texture.ReallyEnabled & mask) { + if (ctx->Texture._ReallyEnabled & mask) { const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit]; - if (textureUnit->Current && textureUnit->Current->SampleFunc) { + if (textureUnit->_Current) { GLchan texel[PB_SIZE][4]; if (textureUnit->LodBias != 0.0F) { @@ -2510,11 +2540,11 @@ void gl_texture_pixels( GLcontext *ctx, GLuint texUnit, GLuint n, } } - if (textureUnit->Current->MinLod != -1000.0 - || textureUnit->Current->MaxLod != 1000.0) { + if (textureUnit->_Current->MinLod != -1000.0 + || textureUnit->_Current->MaxLod != 1000.0) { /* apply LOD clamping to lambda */ - GLfloat min = textureUnit->Current->MinLod; - GLfloat max = textureUnit->Current->MaxLod; + GLfloat min = textureUnit->_Current->MinLod; + GLfloat max = textureUnit->_Current->MaxLod; GLuint i; for (i=0;i<n;i++) { GLfloat l = lambda[i]; @@ -2524,14 +2554,16 @@ void gl_texture_pixels( GLcontext *ctx, GLuint texUnit, GLuint n, /* fetch texture images from device driver, if needed */ if (ctx->Driver.GetTexImage) { - if (!_mesa_get_teximages_from_driver(ctx, textureUnit->Current)) { + if (!_mesa_get_teximages_from_driver(ctx, textureUnit->_Current)) { return; } } /* Sample the texture. */ - (*textureUnit->Current->SampleFunc)( textureUnit->Current, n, - s, t, r, lambda, texel ); + SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit, + textureUnit->_Current, + n, s, t, r, + lambda, texel ); apply_texture( ctx, textureUnit, n, primary_rgba, texel, rgba ); } diff --git a/src/mesa/swrast/s_texture.h b/src/mesa/swrast/s_texture.h index 8bb5662333..f22f08a1e6 100644 --- a/src/mesa/swrast/s_texture.h +++ b/src/mesa/swrast/s_texture.h @@ -1,4 +1,4 @@ -/* $Id: s_texture.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_texture.h,v 1.2 2000/11/05 18:24:41 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -41,6 +41,10 @@ extern void gl_texture_pixels( GLcontext *ctx, GLuint texSet, GLuint n, const GLfloat r[], GLfloat lambda[], GLchan primary_rgba[][4], GLchan rgba[][4] ); +extern void +_swrast_choose_texture_sample_func( GLcontext *ctx, + GLuint texUnit, + const struct gl_texture_object *tObj ); #endif diff --git a/src/mesa/swrast/s_triangle.c b/src/mesa/swrast/s_triangle.c index 4b00d8aff9..267a0f2c8e 100644 --- a/src/mesa/swrast/s_triangle.c +++ b/src/mesa/swrast/s_triangle.c @@ -1,4 +1,4 @@ -/* $Id: s_triangle.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_triangle.c,v 1.2 2000/11/05 18:24:41 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -34,7 +34,6 @@ #include "glheader.h" #include "context.h" -#include "feedback.h" #include "macros.h" #include "mem.h" #include "mmath.h" @@ -42,21 +41,24 @@ #include "texstate.h" #include "s_aatriangle.h" +#include "s_context.h" #include "s_depth.h" +#include "s_feedback.h" #include "s_span.h" - -static GLboolean cull_triangle( GLcontext *ctx, - GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +#include "s_triangle.h" + +GLboolean gl_cull_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { - struct vertex_buffer *VB = ctx->VB; - GLfloat (*win)[4] = VB->Win.data; - GLfloat ex = win[v1][0] - win[v0][0]; - GLfloat ey = win[v1][1] - win[v0][1]; - GLfloat fx = win[v2][0] - win[v0][0]; - GLfloat fy = win[v2][1] - win[v0][1]; + GLfloat ex = v1->win[0] - v0->win[0]; + GLfloat ey = v1->win[1] - v0->win[1]; + GLfloat fx = v2->win[0] - v0->win[0]; + GLfloat fy = v2->win[1] - v0->win[1]; GLfloat c = ex*fy-ey*fx; - if (c * ctx->backface_sign > 0) + if (c * ctx->_backface_sign > 0) return 0; return 1; @@ -67,11 +69,13 @@ static GLboolean cull_triangle( GLcontext *ctx, * Render a flat-shaded color index triangle. */ static void flat_ci_triangle( GLcontext *ctx, - GLuint v0, GLuint v1, GLuint v2, GLuint pv ) + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define SETUP_CODE \ - GLuint index = VB->IndexPtr->data[pv]; \ + GLuint index = v0->index; \ if (1) { \ /* set the color index */ \ (*ctx->Driver.Index)( ctx, index ); \ @@ -104,9 +108,10 @@ static void flat_ci_triangle( GLcontext *ctx, * Render a smooth-shaded color index triangle. */ static void smooth_ci_triangle( GLcontext *ctx, - GLuint v0, GLuint v1, GLuint v2, GLuint pv ) + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { - (void) pv; #define INTERP_Z 1 #define INTERP_INDEX 1 @@ -140,7 +145,9 @@ static void smooth_ci_triangle( GLcontext *ctx, * Render a flat-shaded RGBA triangle. */ static void flat_rgba_triangle( GLcontext *ctx, - GLuint v0, GLuint v1, GLuint v2, GLuint pv ) + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -148,10 +155,10 @@ static void flat_rgba_triangle( GLcontext *ctx, #define SETUP_CODE \ if (1) { \ /* set the color */ \ - GLchan r = VB->ColorPtr->data[pv][0]; \ - GLchan g = VB->ColorPtr->data[pv][1]; \ - GLchan b = VB->ColorPtr->data[pv][2]; \ - GLchan a = VB->ColorPtr->data[pv][3]; \ + GLchan r = v0->color[0]; \ + GLchan g = v0->color[1]; \ + GLchan b = v0->color[2]; \ + GLchan a = v0->color[3]; \ (*ctx->Driver.Color)( ctx, r, g, b, a ); \ } @@ -170,14 +177,14 @@ static void flat_rgba_triangle( GLcontext *ctx, } \ gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, \ fogspan, \ - VB->ColorPtr->data[pv], \ + v0->color, \ GL_POLYGON ); \ } \ } #include "s_tritemp.h" - ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */ + ASSERT(!ctx->Texture._ReallyEnabled); /* texturing must be off */ ASSERT(ctx->Light.ShadeModel==GL_FLAT); } @@ -187,9 +194,11 @@ static void flat_rgba_triangle( GLcontext *ctx, * Render a smooth-shaded RGBA triangle. */ static void smooth_rgba_triangle( GLcontext *ctx, - GLuint v0, GLuint v1, GLuint v2, GLuint pv ) + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { - (void) pv; + #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define INTERP_RGB 1 @@ -226,7 +235,7 @@ static void smooth_rgba_triangle( GLcontext *ctx, #include "s_tritemp.h" - ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */ + ASSERT(!ctx->Texture._ReallyEnabled); /* texturing must be off */ ASSERT(ctx->Light.ShadeModel==GL_SMOOTH); } @@ -237,8 +246,10 @@ static void smooth_rgba_triangle( GLcontext *ctx, * * No fog. */ -static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void simple_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_INT_TEX 1 #define S_SCALE twidth @@ -252,7 +263,6 @@ static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLchan *texture = obj->Image[b]->Data; \ GLint smask = obj->Image[b]->Width - 1; \ GLint tmask = obj->Image[b]->Height - 1; \ - (void) pv; \ if (!texture) { \ if (!_mesa_get_teximages_from_driver(ctx, obj)) \ return; \ @@ -295,8 +305,10 @@ static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, * * No fog. */ -static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void simple_z_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -312,7 +324,6 @@ static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLchan *texture = obj->Image[b]->Data; \ GLint smask = obj->Image[b]->Width - 1; \ GLint tmask = obj->Image[b]->Height - 1; \ - (void) pv; \ if (!texture) { \ if (!_mesa_get_teximages_from_driver(ctx, obj)) \ return; \ @@ -363,8 +374,10 @@ static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, /* * Render an RGB/RGBA textured triangle without perspective correction. */ -static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void affine_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -423,7 +436,7 @@ static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, } \ tbytesline = obj->Image[b]->Width * comp; \ tsize = theight * tbytesline; - (void) pv; + /* Instead of defining a function for each mode, a test is done * between the outer and inner loops. This is to reduce code size @@ -683,8 +696,10 @@ static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, * This function written by Klaus Niederkrueger <klaus@math.leidenuniv.nl> * Send all questions and bug reports to him. */ -static void near_persp_textured_triangle(GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void near_persp_textured_triangle(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { /* The BIAS value is used to shift negative values into positive values. * Without this, negative texture values don't GL_REPEAT correctly at just @@ -712,7 +727,6 @@ static void near_persp_textured_triangle(GLcontext *ctx, GLuint v0, GLuint v1, const GLint format = obj->Image[b]->Format; \ const GLint envmode = unit->EnvMode; \ GLfloat sscale, tscale; \ - /*GLint comp, tbytesline, tsize; */ \ GLfixed er, eg, eb, ea; \ GLint tr, tg, tb, ta; \ if (!texture) { \ @@ -727,30 +741,9 @@ static void near_persp_textured_triangle(GLcontext *ctx, GLuint v0, GLuint v1, eb = FloatToFixed(unit->EnvColor[2]); \ ea = FloatToFixed(unit->EnvColor[3]); \ } \ - /*switch (format) { \ - case GL_ALPHA: \ - case GL_LUMINANCE: \ - case GL_INTENSITY: \ - comp = 1; \ - break; \ - case GL_LUMINANCE_ALPHA: \ - comp = 2; \ - break; \ - case GL_RGB: \ - comp = 3; \ - break; \ - case GL_RGBA: \ - comp = 4; \ - break; \ - default: \ - gl_problem(NULL, "Bad texture format in near_persp_texture_triangle"); \ - return; \ - } */ \ sscale = twidth; \ tscale = theight; \ - /*tbytesline = obj->Image[b]->Width * comp; \ - tsize = theight * tbytesline;*/ - (void) pv; + #define OLD_SPAN(DO_TEX,COMP) \ for (i=0;i<n;i++) { \ @@ -1443,8 +1436,10 @@ static void near_persp_textured_triangle(GLcontext *ctx, GLuint v0, GLuint v1, * This function written by Klaus Niederkrueger <klaus@math.leidenuniv.nl> * Send all questions and bug reports to him. */ -static void lin_persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void lin_persp_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -1502,7 +1497,7 @@ static void lin_persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, tscale = FIXED_SCALE * theight; \ tbytesline = obj->Image[b]->Width * comp; \ tsize = theight * tbytesline; - (void) pv; + #define SPAN(DO_TEX,COMP) \ for (i=0;i<n;i++) { \ @@ -1620,8 +1615,10 @@ static void lin_persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because * R is already used for red. */ -static void general_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void general_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -1632,10 +1629,10 @@ static void general_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a; \ if (flat_shade) { \ - r = VB->ColorPtr->data[pv][0]; \ - g = VB->ColorPtr->data[pv][1]; \ - b = VB->ColorPtr->data[pv][2]; \ - a = VB->ColorPtr->data[pv][3]; \ + r = v0->color[0]; \ + g = v0->color[1]; \ + b = v0->color[2]; \ + a = v0->color[3]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ @@ -1708,8 +1705,10 @@ static void general_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because * R is already used for red. */ -static void general_textured_spec_triangle1( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv, +static void general_textured_spec_triangle1( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2, GLdepth zspan[MAX_WIDTH], GLfixed fogspan[MAX_WIDTH], GLchan rgba[MAX_WIDTH][4], @@ -1725,13 +1724,13 @@ static void general_textured_spec_triangle1( GLcontext *ctx, GLuint v0, GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a, sr, sg, sb; \ if (flat_shade) { \ - r = VB->ColorPtr->data[pv][0]; \ - g = VB->ColorPtr->data[pv][1]; \ - b = VB->ColorPtr->data[pv][2]; \ - a = VB->ColorPtr->data[pv][3]; \ - sr = VB->SecondaryColorPtr->data[pv][0]; \ - sg = VB->SecondaryColorPtr->data[pv][1]; \ - sb = VB->SecondaryColorPtr->data[pv][2]; \ + r = v0->color[0]; \ + g = v0->color[1]; \ + b = v0->color[2]; \ + a = v0->color[3]; \ + sr = v0->specular[0]; \ + sg = v0->specular[1]; \ + sb = v0->specular[2]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ @@ -1831,8 +1830,10 @@ compute_lambda( GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy, * minification or magnification filter. If minification and using * mipmaps, lambda is also used to select the texture level of detail. */ -static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv, +static void lambda_textured_triangle1( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2, GLfloat s[MAX_WIDTH], GLfloat t[MAX_WIDTH], GLfloat u[MAX_WIDTH] ) @@ -1844,7 +1845,7 @@ static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1, #define INTERP_TEX 1 #define SETUP_CODE \ - const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ + const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current; \ const GLint baseLevel = obj->BaseLevel; \ const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ const GLfloat twidth = (GLfloat) texImage->Width; \ @@ -1852,10 +1853,10 @@ static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1, const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a; \ if (flat_shade) { \ - r = VB->ColorPtr->data[pv][0]; \ - g = VB->ColorPtr->data[pv][1]; \ - b = VB->ColorPtr->data[pv][2]; \ - a = VB->ColorPtr->data[pv][3]; \ + r = v0->color[0]; \ + g = v0->color[1]; \ + b = v0->color[2]; \ + a = v0->color[3]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ @@ -1933,8 +1934,10 @@ static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1, * minification or magnification filter. If minification and using * mipmaps, lambda is also used to select the texture level of detail. */ -static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv, +static void lambda_textured_spec_triangle1( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2, GLfloat s[MAX_WIDTH], GLfloat t[MAX_WIDTH], GLfloat u[MAX_WIDTH] ) @@ -1947,7 +1950,7 @@ static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0, #define INTERP_TEX 1 #define SETUP_CODE \ - const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ + const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current; \ const GLint baseLevel = obj->BaseLevel; \ const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ const GLfloat twidth = (GLfloat) texImage->Width; \ @@ -1955,13 +1958,13 @@ static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0, const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a, sr, sg, sb; \ if (flat_shade) { \ - r = VB->ColorPtr->data[pv][0]; \ - g = VB->ColorPtr->data[pv][1]; \ - b = VB->ColorPtr->data[pv][2]; \ - a = VB->ColorPtr->data[pv][3]; \ - sr = VB->SecondaryColorPtr->data[pv][0]; \ - sg = VB->SecondaryColorPtr->data[pv][1]; \ - sb = VB->SecondaryColorPtr->data[pv][2]; \ + r = v0->color[0]; \ + g = v0->color[1]; \ + b = v0->color[2]; \ + a = v0->color[3]; \ + sr = v0->specular[0]; \ + sg = v0->specular[1]; \ + sb = v0->specular[2]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ @@ -2047,12 +2050,14 @@ static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0, * Interpolate Z, RGB, Alpha, and two sets of texture coordinates. * Yup, it's slow. */ -static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv, - GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH], - GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH], - GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH] - ) +static void +lambda_multitextured_triangle1( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2, + GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH]) { #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE @@ -2066,16 +2071,16 @@ static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, GLfloat twidth[MAX_TEXTURE_UNITS], theight[MAX_TEXTURE_UNITS]; \ GLint r, g, b, a; \ if (flat_shade) { \ - r = VB->ColorPtr->data[pv][0]; \ - g = VB->ColorPtr->data[pv][1]; \ - b = VB->ColorPtr->data[pv][2]; \ - a = VB->ColorPtr->data[pv][3]; \ + r = v0->color[0]; \ + g = v0->color[1]; \ + b = v0->color[2]; \ + a = v0->color[3]; \ } \ { \ GLuint unit; \ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ - if (ctx->Texture.Unit[unit].ReallyEnabled) { \ - const struct gl_texture_object *obj = ctx->Texture.Unit[unit].Current; \ + if (ctx->Texture.Unit[unit]._ReallyEnabled) { \ + const struct gl_texture_object *obj = ctx->Texture.Unit[unit]._Current; \ const GLint baseLevel = obj->BaseLevel; \ const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ twidth[unit] = (GLfloat) texImage->Width; \ @@ -2107,7 +2112,7 @@ static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, { \ GLuint unit; \ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ - if (ctx->Texture.Unit[unit].ReallyEnabled) { \ + if (ctx->Texture.Unit[unit]._ReallyEnabled) { \ GLdouble invQ = 1.0 / vv[unit]; \ s[unit][i] = ss[unit] * invQ; \ t[unit][i] = tt[unit] * invQ; \ @@ -2141,7 +2146,7 @@ static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, { \ GLuint unit; \ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ - if (ctx->Texture.Unit[unit].ReallyEnabled) { \ + if (ctx->Texture.Unit[unit]._ReallyEnabled) { \ GLdouble invQ = 1.0 / vv[unit]; \ s[unit][i] = ss[unit] * invQ; \ t[unit][i] = tt[unit] * invQ; \ @@ -2175,34 +2180,42 @@ static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, * on Mac / PowerPC systems. */ -static void general_textured_spec_triangle(GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv) +static void general_textured_spec_triangle(GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { GLdepth zspan[MAX_WIDTH]; GLfixed fogspan[MAX_WIDTH]; GLchan rgba[MAX_WIDTH][4], spec[MAX_WIDTH][4]; - general_textured_spec_triangle1(ctx,v0,v1,v2,pv,zspan,fogspan,rgba,spec); + general_textured_spec_triangle1(ctx,v0,v1,v2,zspan,fogspan,rgba,spec); } -static void lambda_textured_triangle( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv ) +static void lambda_textured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; - lambda_textured_triangle1(ctx,v0,v1,v2,pv,s,t,u); + lambda_textured_triangle1(ctx,v0,v1,v2,s,t,u); } -static void lambda_textured_spec_triangle( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv ) +static void lambda_textured_spec_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { GLfloat s[MAX_WIDTH]; GLfloat t[MAX_WIDTH]; GLfloat u[MAX_WIDTH]; - lambda_textured_spec_triangle1(ctx,v0,v1,v2,pv,s,t,u); + lambda_textured_spec_triangle1(ctx,v0,v1,v2,s,t,u); } -static void lambda_multitextured_triangle( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv) +static void lambda_multitextured_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH]; @@ -2210,17 +2223,18 @@ static void lambda_multitextured_triangle( GLcontext *ctx, GLuint v0, DEFMARRAY(GLfloat,u,MAX_TEXTURE_UNITS,MAX_WIDTH); CHECKARRAY(u,return); - lambda_multitextured_triangle1(ctx,v0,v1,v2,pv,s,t,u); + lambda_multitextured_triangle1(ctx,v0,v1,v2,s,t,u); UNDEFARRAY(u); } -static void occlusion_zless_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void occlusion_zless_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2 ) { - (void)pv; if (ctx->OcclusionResult) { return; } @@ -2247,18 +2261,6 @@ static void occlusion_zless_triangle( GLcontext *ctx, GLuint v0, GLuint v1, -/* - * Null rasterizer for measuring transformation speed. - */ -static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) -{ - (void) ctx; - (void) v0; - (void) v1; - (void) v2; - (void) pv; -} #if 0 @@ -2277,24 +2279,16 @@ static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1, * remove tests to this code. */ void -_swrast_set_triangle_function( GLcontext *ctx ) +_swrast_choose_triangle( GLcontext *ctx ) { + SWcontext *swrast = SWRAST_CONTEXT(ctx); const GLboolean rgbmode = ctx->Visual.RGBAflag; if (ctx->RenderMode==GL_RENDER) { - if (ctx->NoRaster) { - ctx->Driver.TriangleFunc = null_triangle; - return; - } - if (ctx->Driver.TriangleFunc) { - /* Device driver will draw triangles. */ - dputs("Driver triangle"); - return; - } if (ctx->Polygon.SmoothFlag) { _mesa_set_aa_triangle_function(ctx); - ASSERT(ctx->Driver.TriangleFunc); + ASSERT(swrast->Triangle); return; } @@ -2311,18 +2305,18 @@ _swrast_set_triangle_function( GLcontext *ctx ) || (!rgbmode && ctx->Color.IndexMask == 0)) { dputs("occlusion_test_triangle"); - ctx->Driver.TriangleFunc = occlusion_zless_triangle; + swrast->Triangle = occlusion_zless_triangle; return; } } - if (ctx->Texture.ReallyEnabled) { + if (ctx->Texture._ReallyEnabled) { /* Ugh, we do a _lot_ of tests to pick the best textured tri func */ GLint format, filter; const struct gl_texture_object *current2Dtex = ctx->Texture.Unit[0].CurrentD[2]; const struct gl_texture_image *image; /* First see if we can used an optimized 2-D texture function */ - if (ctx->Texture.ReallyEnabled==TEXTURE0_2D + if (ctx->Texture._ReallyEnabled==TEXTURE0_2D && current2Dtex->WrapS==GL_REPEAT && current2Dtex->WrapT==GL_REPEAT && ((image = current2Dtex->Image[current2Dtex->BaseLevel]) != 0) /* correct! */ @@ -2338,39 +2332,39 @@ _swrast_set_triangle_function( GLcontext *ctx ) && format==GL_RGB && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE || ctx->Texture.Unit[0].EnvMode==GL_DECAL) - && ((ctx->RasterMask==DEPTH_BIT + && ((swrast->_RasterMask==DEPTH_BIT && ctx->Depth.Func==GL_LESS && ctx->Depth.Mask==GL_TRUE) - || ctx->RasterMask==0) + || swrast->_RasterMask==0) && ctx->Polygon.StippleFlag==GL_FALSE) { - if (ctx->RasterMask==DEPTH_BIT) { - ctx->Driver.TriangleFunc = simple_z_textured_triangle; + if (swrast->_RasterMask==DEPTH_BIT) { + swrast->Triangle = simple_z_textured_triangle; dputs("simple_z_textured_triangle"); } else { - ctx->Driver.TriangleFunc = simple_textured_triangle; + swrast->Triangle = simple_textured_triangle; dputs("simple_textured_triangle"); } } else { if (ctx->Texture.Unit[0].EnvMode==GL_ADD) { - ctx->Driver.TriangleFunc = general_textured_triangle; + swrast->Triangle = general_textured_triangle; dputs("general_textured_triangle"); } else { - ctx->Driver.TriangleFunc = affine_textured_triangle; + swrast->Triangle = affine_textured_triangle; dputs("affine_textured_triangle"); } } } else { if (filter==GL_NEAREST) { - ctx->Driver.TriangleFunc = near_persp_textured_triangle; + swrast->Triangle = near_persp_textured_triangle; dputs("near_persp_textured_triangle"); } else { - ctx->Driver.TriangleFunc = lin_persp_textured_triangle; + swrast->Triangle = lin_persp_textured_triangle; dputs("lin_persp_textured_triangle"); } } @@ -2379,13 +2373,13 @@ _swrast_set_triangle_function( GLcontext *ctx ) /* More complicated textures (mipmap, multi-tex, sep specular) */ GLboolean needLambda; /* if mag filter != min filter we need to compute lambda */ - const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; + const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current; if (obj && obj->MinFilter != obj->MagFilter) needLambda = GL_TRUE; else needLambda = GL_FALSE; - if (ctx->Texture.MultiTextureEnabled) { - ctx->Driver.TriangleFunc = lambda_multitextured_triangle; + if (ctx->Texture._MultiTextureEnabled) { + swrast->Triangle = lambda_multitextured_triangle; dputs("lambda_multitextured_triangle"); } else if ((ctx->Light.Enabled && @@ -2393,21 +2387,21 @@ _swrast_set_triangle_function( GLcontext *ctx ) || ctx->Fog.ColorSumEnabled) { /* separate specular color interpolation */ if (needLambda) { - ctx->Driver.TriangleFunc = lambda_textured_spec_triangle; + swrast->Triangle = lambda_textured_spec_triangle; dputs("lambda_textured_spec_triangle"); } else { - ctx->Driver.TriangleFunc = general_textured_spec_triangle; + swrast->Triangle = general_textured_spec_triangle; dputs("general_textured_spec_triangle"); } } else { if (needLambda) { - ctx->Driver.TriangleFunc = lambda_textured_triangle; + swrast->Triangle = lambda_textured_triangle; dputs("lambda_textured_triangle"); } else { - ctx->Driver.TriangleFunc = general_textured_triangle; + swrast->Triangle = general_textured_triangle; dputs("general_textured_triangle"); } } @@ -2418,31 +2412,31 @@ _swrast_set_triangle_function( GLcontext *ctx ) /* smooth shaded, no texturing, stippled or some raster ops */ if (rgbmode) { dputs("smooth_rgba_triangle"); - ctx->Driver.TriangleFunc = smooth_rgba_triangle; + swrast->Triangle = smooth_rgba_triangle; } else { dputs("smooth_ci_triangle"); - ctx->Driver.TriangleFunc = smooth_ci_triangle; + swrast->Triangle = smooth_ci_triangle; } } else { /* flat shaded, no texturing, stippled or some raster ops */ if (rgbmode) { dputs("flat_rgba_triangle"); - ctx->Driver.TriangleFunc = flat_rgba_triangle; + swrast->Triangle = flat_rgba_triangle; } else { dputs("flat_ci_triangle"); - ctx->Driver.TriangleFunc = flat_ci_triangle; + swrast->Triangle = flat_ci_triangle; } } } } else if (ctx->RenderMode==GL_FEEDBACK) { - ctx->Driver.TriangleFunc = gl_feedback_triangle; + swrast->Triangle = gl_feedback_triangle; } else { /* GL_SELECT mode */ - ctx->Driver.TriangleFunc = gl_select_triangle; + swrast->Triangle = gl_select_triangle; } } diff --git a/src/mesa/swrast/s_triangle.h b/src/mesa/swrast/s_triangle.h index 71c79a4a7c..eaff79532c 100644 --- a/src/mesa/swrast/s_triangle.h +++ b/src/mesa/swrast/s_triangle.h @@ -1,4 +1,4 @@ -/* $Id: s_triangle.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_triangle.h,v 1.2 2000/11/05 18:24:41 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -36,8 +36,14 @@ #include "swrast.h" -void gl_set_triangle_function( GLcontext *ctx ); -GLboolean gl_cull_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ); +GLboolean gl_cull_triangle( GLcontext *ctx, + SWvertex *v0, + SWvertex *v1, + SWvertex *v2); + + +void +_swrast_choose_triangle( GLcontext *ctx ); #endif diff --git a/src/mesa/swrast/s_tritemp.h b/src/mesa/swrast/s_tritemp.h index 21e7ceef5a..a87b24c40c 100644 --- a/src/mesa/swrast/s_tritemp.h +++ b/src/mesa/swrast/s_tritemp.h @@ -1,4 +1,4 @@ -/* $Id: s_tritemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ +/* $Id: s_tritemp.h,v 1.2 2000/11/05 18:24:41 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -73,10 +73,10 @@ */ -/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/ +/*void triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2 )*/ { typedef struct { - GLint v0, v1; /* Y(v0) < Y(v1) */ + SWvertex *v0, *v1; /* Y(v0) < Y(v1) */ GLfloat dx; /* X(v1) - X(v0) */ GLfloat dy; /* Y(v1) - Y(v0) */ GLfixed fdxdy; /* dx/dy in fixed-point */ @@ -93,17 +93,16 @@ const GLfloat maxDepth = ctx->Visual.DepthMaxF; #define FixedToDepth(F) ((F) >> fixedToDepthShift) #endif - const struct vertex_buffer *VB = ctx->VB; EdgeT eMaj, eTop, eBot; GLfloat oneOverArea; - int vMin, vMid, vMax; /* vertex indexes: Y(vMin)<=Y(vMid)<=Y(vMax) */ - float bf = ctx->backface_sign; + SWvertex *vMin, *vMid, *vMax; /* Y(vMin)<=Y(vMid)<=Y(vMax) */ + float bf = ctx->_backface_sign; /* find the order of the 3 vertices along the Y axis */ { - GLfloat y0 = VB->Win.data[v0][1]; - GLfloat y1 = VB->Win.data[v1][1]; - GLfloat y2 = VB->Win.data[v2][1]; + GLfloat y0 = v0->win[1]; + GLfloat y1 = v1->win[1]; + GLfloat y2 = v2->win[1]; if (y0<=y1) { if (y1<=y2) { @@ -135,12 +134,12 @@ eBot.v0 = vMin; eBot.v1 = vMid; /* compute deltas for each edge: vertex[v1] - vertex[v0] */ - eMaj.dx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0]; - eMaj.dy = VB->Win.data[vMax][1] - VB->Win.data[vMin][1]; - eTop.dx = VB->Win.data[vMax][0] - VB->Win.data[vMid][0]; - eTop.dy = VB->Win.data[vMax][1] - VB->Win.data[vMid][1]; - eBot.dx = VB->Win.data[vMid][0] - VB->Win.data[vMin][0]; - eBot.dy = VB->Win.data[vMid][1] - VB->Win.data[vMin][1]; + eMaj.dx = vMax->win[0] - vMin->win[0]; + eMaj.dy = vMax->win[1] - vMin->win[1]; + eTop.dx = vMax->win[0] - vMid->win[0]; + eTop.dy = vMax->win[1] - vMid->win[1]; + eBot.dx = vMid->win[0] - vMin->win[0]; + eBot.dy = vMid->win[1] - vMin->win[1]; /* compute oneOverArea */ { @@ -167,11 +166,11 @@ /* Edge setup. For a triangle strip these could be reused... */ { /* fixed point Y coordinates */ - GLfixed vMin_fx = FloatToFixed(VB->Win.data[vMin][0] + 0.5F); - GLfixed vMin_fy = FloatToFixed(VB->Win.data[vMin][1] - 0.5F); - GLfixed vMid_fx = FloatToFixed(VB->Win.data[vMid][0] + 0.5F); - GLfixed vMid_fy = FloatToFixed(VB->Win.data[vMid][1] - 0.5F); - GLfixed vMax_fy = FloatToFixed(VB->Win.data[vMax][1] - 0.5F); + GLfixed vMin_fx = FloatToFixed(vMin->win[0] + 0.5F); + GLfixed vMin_fy = FloatToFixed(vMin->win[1] - 0.5F); + GLfixed vMid_fx = FloatToFixed(vMid->win[0] + 0.5F); + GLfixed vMid_fy = FloatToFixed(vMid->win[1] - 0.5F); + GLfixed vMax_fy = FloatToFixed(vMax->win[1] - 0.5F); eMaj.fsy = FixedCeil(vMin_fy); eMaj.lines = FixedToInt(vMax_fy + FIXED_ONE - FIXED_EPSILON - eMaj.fsy); @@ -293,8 +292,8 @@ #ifdef INTERP_Z { GLfloat eMaj_dz, eBot_dz; - eMaj_dz = VB->Win.data[vMax][2] - VB->Win.data[vMin][2]; - eBot_dz = VB->Win.data[vMid][2] - VB->Win.data[vMin][2]; + eMaj_dz = vMax->win[2] - vMin->win[2]; + eBot_dz = vMid->win[2] - vMin->win[2]; dzdx = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz); if (dzdx > maxDepth || dzdx < -maxDepth) { /* probably a sliver triangle */ @@ -311,8 +310,8 @@ } { GLfloat eMaj_dfog, eBot_dfog; - eMaj_dfog = (VB->FogCoordPtr->data[vMax] - VB->FogCoordPtr->data[vMin]) * 256; - eBot_dfog = (VB->FogCoordPtr->data[vMid] - VB->FogCoordPtr->data[vMin]) * 256; + eMaj_dfog = (vMax->fog - vMin->fog) * 256; + eBot_dfog = (vMid->fog - vMin->fog) * 256; dfogdx = oneOverArea * (eMaj_dfog * eBot.dy - eMaj.dy * eBot_dfog); fdfogdx = SignedFloatToFixed(dfogdx); dfogdy = oneOverArea * (eMaj.dx * eBot_dfog - eMaj_dfog * eBot.dx); @@ -321,30 +320,30 @@ #ifdef INTERP_RGB { GLfloat eMaj_dr, eBot_dr; - eMaj_dr = (GLint) VB->ColorPtr->data[vMax][0] - - (GLint) VB->ColorPtr->data[vMin][0]; - eBot_dr = (GLint) VB->ColorPtr->data[vMid][0] - - (GLint) VB->ColorPtr->data[vMin][0]; + eMaj_dr = (GLint) vMax->color[0] + - (GLint) vMin->color[0]; + eBot_dr = (GLint) vMid->color[0] + - (GLint) vMin->color[0]; drdx = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr); fdrdx = SignedFloatToFixed(drdx); drdy = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx); } { GLfloat eMaj_dg, eBot_dg; - eMaj_dg = (GLint) VB->ColorPtr->data[vMax][1] - - (GLint) VB->ColorPtr->data[vMin][1]; - eBot_dg = (GLint) VB->ColorPtr->data[vMid][1] - - (GLint) VB->ColorPtr->data[vMin][1]; + eMaj_dg = (GLint) vMax->color[1] + - (GLint) vMin->color[1]; + eBot_dg = (GLint) vMid->color[1] + - (GLint) vMin->color[1]; dgdx = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg); fdgdx = SignedFloatToFixed(dgdx); dgdy = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx); } { GLfloat eMaj_db, eBot_db; - eMaj_db = (GLint) VB->ColorPtr->data[vMax][2] - - (GLint) VB->ColorPtr->data[vMin][2]; - eBot_db = (GLint) VB->ColorPtr->data[vMid][2] - - (GLint) VB->ColorPtr->data[vMin][2]; + eMaj_db = (GLint) vMax->color[2] + - (GLint) vMin->color[2]; + eBot_db = (GLint) vMid->color[2] + - (GLint) vMin->color[2]; dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db); fdbdx = SignedFloatToFixed(dbdx); dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx); @@ -353,30 +352,30 @@ #ifdef INTERP_SPEC { GLfloat eMaj_dsr, eBot_dsr; - eMaj_dsr = (GLint) VB->SecondaryColorPtr->data[vMax][0] - - (GLint) VB->SecondaryColorPtr->data[vMin][0]; - eBot_dsr = (GLint) VB->SecondaryColorPtr->data[vMid][0] - - (GLint) VB->SecondaryColorPtr->data[vMin][0]; + eMaj_dsr = (GLint) vMax->specular[0] + - (GLint) vMin->specular[0]; + eBot_dsr = (GLint) vMid->specular[0] + - (GLint) vMin->specular[0]; dsrdx = oneOverArea * (eMaj_dsr * eBot.dy - eMaj.dy * eBot_dsr); fdsrdx = SignedFloatToFixed(dsrdx); dsrdy = oneOverArea * (eMaj.dx * eBot_dsr - eMaj_dsr * eBot.dx); } { GLfloat eMaj_dsg, eBot_dsg; - eMaj_dsg = (GLint) VB->SecondaryColorPtr->data[vMax][1] - - (GLint) VB->SecondaryColorPtr->data[vMin][1]; - eBot_dsg = (GLint) VB->SecondaryColorPtr->data[vMid][1] - - (GLint) VB->SecondaryColorPtr->data[vMin][1]; + eMaj_dsg = (GLint) vMax->specular[1] + - (GLint) vMin->specular[1]; + eBot_dsg = (GLint) vMid->specular[1] + - (GLint) vMin->specular[1]; dsgdx = oneOverArea * (eMaj_dsg * eBot.dy - eMaj.dy * eBot_dsg); fdsgdx = SignedFloatToFixed(dsgdx); dsgdy = oneOverArea * (eMaj.dx * eBot_dsg - eMaj_dsg * eBot.dx); } { GLfloat eMaj_dsb, eBot_dsb; - eMaj_dsb = (GLint) VB->SecondaryColorPtr->data[vMax][2] - - (GLint) VB->SecondaryColorPtr->data[vMin][2]; - eBot_dsb = (GLint) VB->SecondaryColorPtr->data[vMid][2] - - (GLint) VB->SecondaryColorPtr->data[vMin][2]; + eMaj_dsb = (GLint) vMax->specular[2] + - (GLint) vMin->specular[2]; + eBot_dsb = (GLint) vMid->specular[2] + - (GLint) vMin->specular[2]; dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb); fdsbdx = SignedFloatToFixed(dsbdx); dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx); @@ -385,10 +384,10 @@ #ifdef INTERP_ALPHA { GLfloat eMaj_da, eBot_da; - eMaj_da = (GLint) VB->ColorPtr->data[vMax][3] - - (GLint) VB->ColorPtr->data[vMin][3]; - eBot_da = (GLint) VB->ColorPtr->data[vMid][3] - - (GLint) VB->ColorPtr->data[vMin][3]; + eMaj_da = (GLint) vMax->color[3] + - (GLint) vMin->color[3]; + eBot_da = (GLint) vMid->color[3] + - (GLint) vMin->color[3]; dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da); fdadx = SignedFloatToFixed(dadx); dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx); @@ -397,10 +396,10 @@ #ifdef INTERP_INDEX { GLfloat eMaj_di, eBot_di; - eMaj_di = (GLint) VB->IndexPtr->data[vMax] - - (GLint) VB->IndexPtr->data[vMin]; - eBot_di = (GLint) VB->IndexPtr->data[vMid] - - (GLint) VB->IndexPtr->data[vMin]; + eMaj_di = (GLint) vMax->index + - (GLint) vMin->index; + eBot_di = (GLint) vMid->index + - (GLint) vMin->index; didx = oneOverArea * (eMaj_di * eBot.dy - eMaj.dy * eBot_di); fdidx = SignedFloatToFixed(didx); didy = oneOverArea * (eMaj.dx * eBot_di - eMaj_di * eBot.dx); @@ -409,150 +408,94 @@ #ifdef INTERP_INT_TEX { GLfloat eMaj_ds, eBot_ds; - eMaj_ds = (VB->TexCoordPtr[0]->data[vMax][0] - - VB->TexCoordPtr[0]->data[vMin][0]) * S_SCALE; - eBot_ds = (VB->TexCoordPtr[0]->data[vMid][0] - - VB->TexCoordPtr[0]->data[vMin][0]) * S_SCALE; + eMaj_ds = (vMax->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE; + eBot_ds = (vMid->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE; dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); fdsdx = SignedFloatToFixed(dsdx); dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); } - if (VB->TexCoordPtr[0]->size > 1) { + { GLfloat eMaj_dt, eBot_dt; - eMaj_dt = (VB->TexCoordPtr[0]->data[vMax][1] - - VB->TexCoordPtr[0]->data[vMin][1]) * T_SCALE; - eBot_dt = (VB->TexCoordPtr[0]->data[vMid][1] - - VB->TexCoordPtr[0]->data[vMin][1]) * T_SCALE; + eMaj_dt = (vMax->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE; + eBot_dt = (vMid->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE; dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); fdtdx = SignedFloatToFixed(dtdx); dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); } - else { - dtdx = 0; - fdtdx = SignedFloatToFixed(dtdx); - dtdy = 0; - } #endif #ifdef INTERP_TEX { - GLfloat wMax = VB->Win.data[vMax][3]; - GLfloat wMin = VB->Win.data[vMin][3]; - GLfloat wMid = VB->Win.data[vMid][3]; + GLfloat wMax = vMax->win[3]; + GLfloat wMin = vMin->win[3]; + GLfloat wMid = vMid->win[3]; GLfloat eMaj_ds, eBot_ds; GLfloat eMaj_dt, eBot_dt; GLfloat eMaj_du, eBot_du; GLfloat eMaj_dv, eBot_dv; - eMaj_ds = VB->TexCoordPtr[0]->data[vMax][0] * wMax - - VB->TexCoordPtr[0]->data[vMin][0] * wMin; - eBot_ds = VB->TexCoordPtr[0]->data[vMid][0] * wMid - - VB->TexCoordPtr[0]->data[vMin][0] * wMin; + eMaj_ds = vMax->texcoord[0][0] * wMax - vMin->texcoord[0][0] * wMin; + eBot_ds = vMid->texcoord[0][0] * wMid - vMin->texcoord[0][0] * wMin; dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); - if (VB->TexCoordPtr[0]->size > 1) { - eMaj_dt = VB->TexCoordPtr[0]->data[vMax][1] * wMax - - VB->TexCoordPtr[0]->data[vMin][1] * wMin; - eBot_dt = VB->TexCoordPtr[0]->data[vMid][1] * wMid - - VB->TexCoordPtr[0]->data[vMin][1] * wMin; - dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); - dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); - } - else { - dtdx = 0; - dtdy = 0; - } + eMaj_dt = vMax->texcoord[0][1] * wMax - vMin->texcoord[0][1] * wMin; + eBot_dt = vMid->texcoord[0][1] * wMid - vMin->texcoord[0][1] * wMin; + dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); + dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); + + eMaj_du = vMax->texcoord[0][2] * wMax - vMin->texcoord[0][2] * wMin; + eBot_du = vMid->texcoord[0][2] * wMid - vMin->texcoord[0][2] * wMin; + dudx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); + dudy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); - if (VB->TexCoordPtr[0]->size > 2) { - eMaj_du = VB->TexCoordPtr[0]->data[vMax][2] * wMax - - VB->TexCoordPtr[0]->data[vMin][2] * wMin; - eBot_du = VB->TexCoordPtr[0]->data[vMid][2] * wMid - - VB->TexCoordPtr[0]->data[vMin][2] * wMin; - dudx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); - dudy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); - } - else { - dudx = 0; - dudy = 0; - } - if (VB->TexCoordPtr[0]->size > 3) { - eMaj_dv = VB->TexCoordPtr[0]->data[vMax][3] * wMax - - VB->TexCoordPtr[0]->data[vMin][3] * wMin; - eBot_dv = VB->TexCoordPtr[0]->data[vMid][3] * wMid - - VB->TexCoordPtr[0]->data[vMin][3] * wMin; - dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); - dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); - } - else { - eMaj_dv = wMax - wMin; - eBot_dv = wMid - wMin; - dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); - dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); - } + eMaj_dv = vMax->texcoord[0][3] * wMax - vMin->texcoord[0][3] * wMin; + eBot_dv = vMid->texcoord[0][3] * wMid - vMin->texcoord[0][3] * wMin; + dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); + dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); } #endif #ifdef INTERP_MULTITEX { - GLfloat wMax = VB->Win.data[vMax][3]; - GLfloat wMin = VB->Win.data[vMin][3]; - GLfloat wMid = VB->Win.data[vMid][3]; + GLfloat wMax = vMax->win[3]; + GLfloat wMin = vMin->win[3]; + GLfloat wMid = vMid->win[3]; GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { GLfloat eMaj_ds, eBot_ds; GLfloat eMaj_dt, eBot_dt; GLfloat eMaj_du, eBot_du; GLfloat eMaj_dv, eBot_dv; - eMaj_ds = VB->TexCoordPtr[u]->data[vMax][0] * wMax - - VB->TexCoordPtr[u]->data[vMin][0] * wMin; - eBot_ds = VB->TexCoordPtr[u]->data[vMid][0] * wMid - - VB->TexCoordPtr[u]->data[vMin][0] * wMin; + eMaj_ds = vMax->texcoord[u][0] * wMax + - vMin->texcoord[u][0] * wMin; + eBot_ds = vMid->texcoord[u][0] * wMid + - vMin->texcoord[u][0] * wMin; dsdx[u] = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds); dsdy[u] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx); - if (VB->TexCoordPtr[u]->size > 1) { - eMaj_dt = VB->TexCoordPtr[u]->data[vMax][1] * wMax - - VB->TexCoordPtr[u]->data[vMin][1] * wMin; - eBot_dt = VB->TexCoordPtr[u]->data[vMid][1] * wMid - - VB->TexCoordPtr[u]->data[vMin][1] * wMin; - dtdx[u] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); - dtdy[u] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); - } - else { - dtdx[u] = 0.0; - dtdy[u] = 0.0; - } - - if (VB->TexCoordPtr[u]->size > 2) { - eMaj_du = VB->TexCoordPtr[u]->data[vMax][2] * wMax - - VB->TexCoordPtr[u]->data[vMin][2] * wMin; - eBot_du = VB->TexCoordPtr[u]->data[vMid][2] * wMid - - VB->TexCoordPtr[u]->data[vMin][2] * wMin; - dudx[u] = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); - dudy[u] = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); - } - else { - dudx[u] = 0.0; - dudy[u] = 0.0; - } - - if (VB->TexCoordPtr[u]->size > 3) { - eMaj_dv = VB->TexCoordPtr[u]->data[vMax][3] * wMax - - VB->TexCoordPtr[u]->data[vMin][3] * wMin; - eBot_dv = VB->TexCoordPtr[u]->data[vMid][3] * wMid - - VB->TexCoordPtr[u]->data[vMin][3] * wMin; - dvdx[u] = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); - dvdy[u] = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); - } - else { - eMaj_dv = wMax - wMin; - eBot_dv = wMid - wMin; - dvdx[u] = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); - dvdy[u] = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); - } + eMaj_dt = vMax->texcoord[u][1] * wMax + - vMin->texcoord[u][1] * wMin; + eBot_dt = vMid->texcoord[u][1] * wMid + - vMin->texcoord[u][1] * wMin; + dtdx[u] = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt); + dtdy[u] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx); + + eMaj_du = vMax->texcoord[u][2] * wMax + - vMin->texcoord[u][2] * wMin; + eBot_du = vMid->texcoord[u][2] * wMid + - vMin->texcoord[u][2] * wMin; + dudx[u] = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du); + dudy[u] = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx); + + eMaj_dv = vMax->texcoord[u][3] * wMax + - vMin->texcoord[u][3] * wMin; + eBot_dv = vMid->texcoord[u][3] * wMid + - vMin->texcoord[u][3] * wMin; + dvdx[u] = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv); + dvdy[u] = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx); } } } @@ -707,7 +650,7 @@ } if (setupLeft && eLeft->lines > 0) { - GLint vLower; + SWvertex *vLower; GLfixed fsx = eLeft->fsx; fx = FixedCeil(fsx); fError = fx - fsx - FIXED_ONE; @@ -749,7 +692,7 @@ #ifdef INTERP_Z { - GLfloat z0 = VB->Win.data[vLower][2] + ctx->PolygonZoffset; + GLfloat z0 = vLower->win[2]; if (depthBits <= 16) { /* interpolate fixed-pt values */ GLfloat tmp = (z0 * FIXED_SCALE + @@ -770,95 +713,71 @@ dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE); # endif } - ffog = FloatToFixed(VB->FogCoordPtr->data[vLower]) * 256 + dfogdx * adjx + dfogdy * adjy + FIXED_HALF; + ffog = FloatToFixed(vLower->fog) * 256 + dfogdx * adjx + dfogdy * adjy + FIXED_HALF; fdfogOuter = SignedFloatToFixed(dfogdy + dxOuter * dfogdx); #endif #ifdef INTERP_RGB - fr = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][0]) + fr = (GLfixed)(IntToFixed(vLower->color[0]) + drdx * adjx + drdy * adjy) + FIXED_HALF; fdrOuter = SignedFloatToFixed(drdy + dxOuter * drdx); - fg = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][1]) + fg = (GLfixed)(IntToFixed(vLower->color[1]) + dgdx * adjx + dgdy * adjy) + FIXED_HALF; fdgOuter = SignedFloatToFixed(dgdy + dxOuter * dgdx); - fb = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][2]) + fb = (GLfixed)(IntToFixed(vLower->color[2]) + dbdx * adjx + dbdy * adjy) + FIXED_HALF; fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx); #endif #ifdef INTERP_SPEC - fsr = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][0]) + fsr = (GLfixed)(IntToFixed(vLower->specular[0]) + dsrdx * adjx + dsrdy * adjy) + FIXED_HALF; fdsrOuter = SignedFloatToFixed(dsrdy + dxOuter * dsrdx); - fsg = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][1]) + fsg = (GLfixed)(IntToFixed(vLower->specular[1]) + dsgdx * adjx + dsgdy * adjy) + FIXED_HALF; fdsgOuter = SignedFloatToFixed(dsgdy + dxOuter * dsgdx); - fsb = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][2]) + fsb = (GLfixed)(IntToFixed(vLower->specular[2]) + dsbdx * adjx + dsbdy * adjy) + FIXED_HALF; fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx); #endif #ifdef INTERP_ALPHA - fa = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][3]) + fa = (GLfixed)(IntToFixed(vLower->color[3]) + dadx * adjx + dady * adjy) + FIXED_HALF; fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx); #endif #ifdef INTERP_INDEX - fi = (GLfixed)(VB->IndexPtr->data[vLower] * FIXED_SCALE + fi = (GLfixed)(vLower->index * FIXED_SCALE + didx * adjx + didy * adjy) + FIXED_HALF; fdiOuter = SignedFloatToFixed(didy + dxOuter * didx); #endif #ifdef INTERP_INT_TEX { GLfloat s0, t0; - s0 = VB->TexCoordPtr[0]->data[vLower][0] * S_SCALE; + s0 = vLower->texcoord[0][0] * S_SCALE; fs = (GLfixed)(s0 * FIXED_SCALE + dsdx * adjx + dsdy * adjy) + FIXED_HALF; fdsOuter = SignedFloatToFixed(dsdy + dxOuter * dsdx); - if (VB->TexCoordPtr[0]->size > 1) - { - t0 = VB->TexCoordPtr[0]->data[vLower][1] * T_SCALE; - ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF; - fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx); - } - else - { - t0 = 0; - ft = (GLfixed) FIXED_HALF; - fdtOuter = SignedFloatToFixed(0); - } + t0 = vLower->texcoord[0][1] * T_SCALE; + ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF; + fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx); } #endif #ifdef INTERP_TEX { - GLfloat invW = VB->Win.data[vLower][3]; + GLfloat invW = vLower->win[3]; GLfloat s0, t0, u0, v0; - s0 = VB->TexCoordPtr[0]->data[vLower][0] * invW; + s0 = vLower->texcoord[0][0] * invW; sLeft = s0 + (dsdx * adjx + dsdy * adjy) * (1.0F/FIXED_SCALE); dsOuter = dsdy + dxOuter * dsdx; - if (VB->TexCoordPtr[0]->size > 1) { - t0 = VB->TexCoordPtr[0]->data[vLower][1] * invW; - tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE); - dtOuter = dtdy + dxOuter * dtdx; - } - else { - tLeft = dtOuter = 0.0; - } - if (VB->TexCoordPtr[0]->size > 2) { - u0 = VB->TexCoordPtr[0]->data[vLower][2] * invW; - uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE); - duOuter = dudy + dxOuter * dudx; - } - else { - uLeft = duOuter = 0.0; - } - if (VB->TexCoordPtr[0]->size > 3) { - v0 = VB->TexCoordPtr[0]->data[vLower][3] * invW; - } - else { - v0 = invW; - } + t0 = vLower->texcoord[0][1] * invW; + tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE); + dtOuter = dtdy + dxOuter * dtdx; + u0 = vLower->texcoord[0][2] * invW; + uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE); + duOuter = dudy + dxOuter * dudx; + v0 = vLower->texcoord[0][3] * invW; vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE); dvOuter = dvdy + dxOuter * dvdx; } @@ -867,34 +786,19 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { - GLfloat invW = VB->Win.data[vLower][3]; + if (ctx->Texture.Unit[u]._ReallyEnabled) { + GLfloat invW = vLower->win[3]; GLfloat s0, t0, u0, v0; - s0 = VB->TexCoordPtr[u]->data[vLower][0] * invW; + s0 = vLower->texcoord[u][0] * invW; sLeft[u] = s0 + (dsdx[u] * adjx + dsdy[u] * adjy) * (1.0F/FIXED_SCALE); dsOuter[u] = dsdy[u] + dxOuter * dsdx[u]; - if (VB->TexCoordPtr[u]->size > 1) { - t0 = VB->TexCoordPtr[u]->data[vLower][1] * invW; - tLeft[u] = t0 + (dtdx[u] * adjx + dtdy[u] * adjy) * (1.0F/FIXED_SCALE); - dtOuter[u] = dtdy[u] + dxOuter * dtdx[u]; - } - else { - tLeft[u] = dtOuter[u] = 0.0; - } - if (VB->TexCoordPtr[u]->size > 2) { - u0 = VB->TexCoordPtr[u]->data[vLower][2] * invW; - uLeft[u] = u0 + (dudx[u] * adjx + dudy[u] * adjy) * (1.0F/FIXED_SCALE); - duOuter[u] = dudy[u] + dxOuter * dudx[u]; - } - else { - uLeft[u] = duOuter[u] = 0.0; - } - if (VB->TexCoordPtr[u]->size > 3) { - v0 = VB->TexCoordPtr[u]->data[vLower][3] * invW; - } - else { - v0 = invW; - } + t0 = vLower->texcoord[u][1] * invW; + tLeft[u] = t0 + (dtdx[u] * adjx + dtdy[u] * adjy) * (1.0F/FIXED_SCALE); + dtOuter[u] = dtdy[u] + dxOuter * dtdx[u]; + u0 = vLower->texcoord[u][2] * invW; + uLeft[u] = u0 + (dudx[u] * adjx + dudy[u] * adjy) * (1.0F/FIXED_SCALE); + duOuter[u] = dudy[u] + dxOuter * dudx[u]; + v0 = vLower->texcoord[u][3] * invW; vLeft[u] = v0 + (dvdx[u] * adjx + dvdy[u] * adjy) * (1.0F/FIXED_SCALE); dvOuter[u] = dvdy[u] + dxOuter * dvdx[u]; } @@ -956,7 +860,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { dsInner[u] = dsOuter[u] + dsdx[u]; dtInner[u] = dtOuter[u] + dtdx[u]; duInner[u] = duOuter[u] + dudx[u]; @@ -1001,7 +905,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { ss[u] = sLeft[u]; tt[u] = tLeft[u]; uu[u] = uLeft[u]; @@ -1103,7 +1007,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { sLeft[u] += dsOuter[u]; tLeft[u] += dtOuter[u]; uLeft[u] += duOuter[u]; @@ -1149,7 +1053,7 @@ { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (ctx->Texture.Unit[u].ReallyEnabled) { + if (ctx->Texture.Unit[u]._ReallyEnabled) { sLeft[u] += dsInner[u]; tLeft[u] += dtInner[u]; uLeft[u] += duInner[u]; diff --git a/src/mesa/swrast/s_zoom.c b/src/mesa/swrast/s_zoom.c index 3520fd506a..890adb1c61 100644 --- a/src/mesa/swrast/s_zoom.c +++ b/src/mesa/swrast/s_zoom.c @@ -1,4 +1,4 @@ -/* $Id: s_zoom.c,v 1.1 2000/10/31 18:00:05 keithw Exp $ */ +/* $Id: s_zoom.c,v 1.2 2000/11/05 18:24:41 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -27,6 +27,7 @@ #include "glheader.h" #include "macros.h" +#include "s_context.h" #include "s_span.h" #include "s_stencil.h" #include "s_zoom.h" diff --git a/src/mesa/swrast/swrast.h b/src/mesa/swrast/swrast.h index 4e8627e695..c567d79978 100644 --- a/src/mesa/swrast/swrast.h +++ b/src/mesa/swrast/swrast.h @@ -1,13 +1,83 @@ +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999 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 + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@valinux.com> + */ + #ifndef SWRAST_H #define SWRAST_H #include "types.h" -/* These are the functions exported from swrast. (more to come) +/* The software rasterizer now uses this format for vertices. Thus a + * 'RasterSetup' stage or other translation is required between the + * tnl module and the swrast rasterization functions. This serves to + * isolate the swrast module from the internals of the tnl module, and + * improve its usefulness as a fallback mechanism for hardware + * drivers. + * + * Full software drivers: + * - Register the rastersetup and triangle functions from + * utils/software_helper. + * - On statechange, update the rasterization pointers in that module. + * + * Rasterization hardware drivers: + * - Keep native rastersetup. + * - Implement native twoside,offset and unfilled triangle setup. + * - Implement a translator from native vertices to swrast vertices. + * - On partial fallback (mix of accelerated and unaccelerated + * prims), call a pass-through function which translates native + * vertices to SWvertices and calls the appropriate swrast function. + * - On total fallback (vertex format insufficient for state or all + * primitives unaccelerated), hook in swrast_setup instead. + */ +typedef struct { + GLfloat win[4]; + GLfloat eye[4]; /* for GL_EXT_point_param only */ + GLfloat texcoord[MAX_TEXTURE_UNITS][4]; + GLchan color[4]; + GLchan specular[4]; + GLfloat fog; + GLuint index; +} SWvertex; + + + + +/* These are the public-access functions exported from swrast. */ void _swrast_alloc_buffers( GLcontext *ctx ); +GLboolean +_swrast_CreateContext( GLcontext *ctx ); + +void +_swrast_DestroyContext( GLcontext *ctx ); + + + void _swrast_Bitmap( GLcontext *ctx, @@ -47,62 +117,35 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value, GLint xpos, GLint ypos, GLint width, GLint height ); -void -_swrast_set_line_function( GLcontext *ctx ); - -void -_swrast_set_point_function( GLcontext *ctx ); - -void -_swrast_set_triangle_function( GLcontext *ctx ); - -void -_swrast_set_quad_function( GLcontext *ctx ); - -void -_swrast_flush( GLcontext *ctx ); - -GLboolean -_swrast_create_context( GLcontext *ctx ); - -void -_swrast_destroy_context( GLcontext *ctx ); +/* Get a pointer to the stipple counter. + */ +GLuint * +_swrast_get_stipple_counter_ref( GLcontext *ctx ); -/* Replace: +/* These will always render the correct point/line/triangle for the + * current state. */ void -_swrast_set_texture_sampler( struct gl_texture_object *t ); - - +_swrast_Point( GLcontext *ctx, SWvertex *v ); -#define _SWRAST_NEW_TRIANGLE (_NEW_RENDERMODE| \ - _NEW_POLYGON| \ - _NEW_DEPTH| \ - _NEW_STENCIL| \ - _NEW_COLOR| \ - _NEW_TEXTURE| \ - _NEW_HINT| \ - _SWRAST_NEW_RASTERMASK| \ - _NEW_LIGHT| \ - _NEW_FOG) - -#define _SWRAST_NEW_LINE (_NEW_RENDERMODE| \ - _NEW_LINE| \ - _NEW_TEXTURE| \ - _NEW_LIGHT| \ - _NEW_FOG| \ - _NEW_DEPTH) - -#define _SWRAST_NEW_POINT (_NEW_RENDERMODE | \ - _NEW_POINT | \ - _NEW_TEXTURE | \ - _NEW_LIGHT | \ - _NEW_FOG) +void +_swrast_Line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 ); +void +_swrast_Triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2 ); +void +_swrast_Quad( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2, + SWvertex *v3); +void +_swrast_flush( GLcontext *ctx ); +/* Tell the software rasterizer about core state changes. + */ +void +_swrast_InvalidateState( GLcontext *ctx, GLuint new_state ); #endif |