--- /dev/null
+/* $Id: s_aatriangle.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Antialiased Triangle rasterizers
+ */
+
+
+#include "s_aatriangle.h"
+#include "s_span.h"
+
+
+/*
+ * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
+ * vertices and the given Z values.
+ */
+static INLINE void
+compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
+ GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])
+{
+ const GLfloat px = v1[0] - v0[0];
+ const GLfloat py = v1[1] - v0[1];
+ const GLfloat pz = z1 - z0;
+
+ const GLfloat qx = v2[0] - v0[0];
+ const GLfloat qy = v2[1] - v0[1];
+ const GLfloat qz = z2 - z0;
+
+ const GLfloat a = py * qz - pz * qy;
+ const GLfloat b = pz * qx - px * qz;
+ const GLfloat c = px * qy - py * qx;
+ const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
+
+ plane[0] = a;
+ plane[1] = b;
+ plane[2] = c;
+ plane[3] = d;
+}
+
+
+/*
+ * Compute coefficients of a plane with a constant Z value.
+ */
+static INLINE void
+constant_plane(GLfloat value, GLfloat plane[4])
+{
+ plane[0] = 0.0;
+ plane[1] = 0.0;
+ plane[2] = -1.0;
+ plane[3] = value;
+}
+
+#define CONSTANT_PLANE(VALUE, PLANE) \
+do { \
+ PLANE[0] = 0.0F; \
+ PLANE[1] = 0.0F; \
+ PLANE[2] = -1.0F; \
+ PLANE[3] = VALUE; \
+} while (0)
+
+
+
+/*
+ * Solve plane equation for Z at (X,Y).
+ */
+static INLINE GLfloat
+solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+ GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
+ return z;
+}
+
+
+#define SOLVE_PLANE(X, Y, PLANE) \
+ ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
+
+
+/*
+ * Return 1 / solve_plane().
+ */
+static INLINE GLfloat
+solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+ GLfloat z = -plane[2] / (plane[3] + plane[0] * x + plane[1] * y);
+ return z;
+}
+
+
+
+/*
+ * Solve plane and return clamped GLchan value.
+ */
+static INLINE GLchan
+solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+ GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2] + 0.5F;
+ if (z < 0.0F)
+ return 0;
+ else if (z > CHAN_MAXF)
+ return CHAN_MAXF;
+ return (GLchan) (GLint) z;
+}
+
+
+
+/*
+ * Compute how much (area) of the given pixel is inside the triangle.
+ * Vertices MUST be specified in counter-clockwise order.
+ * Return: coverage in [0, 1].
+ */
+static GLfloat
+compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
+ const GLfloat v2[3], GLint winx, GLint winy)
+{
+ static const GLfloat samples[16][2] = {
+ /* start with the four corners */
+ { 0.00, 0.00 },
+ { 0.75, 0.00 },
+ { 0.00, 0.75 },
+ { 0.75, 0.75 },
+ /* continue with interior samples */
+ { 0.25, 0.00 },
+ { 0.50, 0.00 },
+ { 0.00, 0.25 },
+ { 0.25, 0.25 },
+ { 0.50, 0.25 },
+ { 0.75, 0.25 },
+ { 0.00, 0.50 },
+ { 0.25, 0.50 },
+ { 0.50, 0.50 },
+ { 0.75, 0.50 },
+ { 0.25, 0.75 },
+ { 0.50, 0.75 }
+ };
+ const GLfloat x = (GLfloat) winx;
+ const GLfloat y = (GLfloat) winy;
+ const GLfloat dx0 = v1[0] - v0[0];
+ const GLfloat dy0 = v1[1] - v0[1];
+ const GLfloat dx1 = v2[0] - v1[0];
+ const GLfloat dy1 = v2[1] - v1[1];
+ const GLfloat dx2 = v0[0] - v2[0];
+ const GLfloat dy2 = v0[1] - v2[1];
+ GLint stop = 4, i;
+ GLfloat insideCount = 16.0F;
+
+#ifdef DEBUG
+ {
+ const GLfloat area = dx0 * dy1 - dx1 * dy0;
+ assert(area >= 0.0);
+ }
+#endif
+
+ for (i = 0; i < stop; i++) {
+ const GLfloat sx = x + samples[i][0];
+ const GLfloat sy = y + samples[i][1];
+ const GLfloat fx0 = sx - v0[0];
+ const GLfloat fy0 = sy - v0[1];
+ const GLfloat fx1 = sx - v1[0];
+ const GLfloat fy1 = sy - v1[1];
+ const GLfloat fx2 = sx - v2[0];
+ const GLfloat fy2 = sy - v2[1];
+ /* cross product determines if sample is inside or outside each edge */
+ GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
+ GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
+ GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
+ /* Check if the sample is exactly on an edge. If so, let cross be a
+ * positive or negative value depending on the direction of the edge.
+ */
+ if (cross0 == 0.0F)
+ cross0 = dx0 + dy0;
+ if (cross1 == 0.0F)
+ cross1 = dx1 + dy1;
+ if (cross2 == 0.0F)
+ cross2 = dx2 + dy2;
+ if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
+ /* point is outside triangle */
+ insideCount -= 1.0F;
+ stop = 16;
+ }
+ }
+ if (stop == 4)
+ return 1.0F;
+ else
+ return insideCount * (1.0F / 16.0F);
+}
+
+
+
+/*
+ * Compute how much (area) of the given pixel is inside the triangle.
+ * Vertices MUST be specified in counter-clockwise order.
+ * Return: coverage in [0, 15].
+ */
+static GLint
+compute_coveragei(const GLfloat v0[3], const GLfloat v1[3],
+ const GLfloat v2[3], GLint winx, GLint winy)
+{
+ /* NOTE: 15 samples instead of 16.
+ * A better sample distribution could be used.
+ */
+ static const GLfloat samples[15][2] = {
+ /* start with the four corners */
+ { 0.00, 0.00 },
+ { 0.75, 0.00 },
+ { 0.00, 0.75 },
+ { 0.75, 0.75 },
+ /* continue with interior samples */
+ { 0.25, 0.00 },
+ { 0.50, 0.00 },
+ { 0.00, 0.25 },
+ { 0.25, 0.25 },
+ { 0.50, 0.25 },
+ { 0.75, 0.25 },
+ { 0.00, 0.50 },
+ { 0.25, 0.50 },
+ /*{ 0.50, 0.50 },*/
+ { 0.75, 0.50 },
+ { 0.25, 0.75 },
+ { 0.50, 0.75 }
+ };
+ const GLfloat x = (GLfloat) winx;
+ const GLfloat y = (GLfloat) winy;
+ const GLfloat dx0 = v1[0] - v0[0];
+ const GLfloat dy0 = v1[1] - v0[1];
+ const GLfloat dx1 = v2[0] - v1[0];
+ const GLfloat dy1 = v2[1] - v1[1];
+ const GLfloat dx2 = v0[0] - v2[0];
+ const GLfloat dy2 = v0[1] - v2[1];
+ GLint stop = 4, i;
+ GLint insideCount = 15;
+
+#ifdef DEBUG
+ {
+ const GLfloat area = dx0 * dy1 - dx1 * dy0;
+ assert(area >= 0.0);
+ }
+#endif
+
+ for (i = 0; i < stop; i++) {
+ const GLfloat sx = x + samples[i][0];
+ const GLfloat sy = y + samples[i][1];
+ const GLfloat fx0 = sx - v0[0];
+ const GLfloat fy0 = sy - v0[1];
+ const GLfloat fx1 = sx - v1[0];
+ const GLfloat fy1 = sy - v1[1];
+ const GLfloat fx2 = sx - v2[0];
+ const GLfloat fy2 = sy - v2[1];
+ /* cross product determines if sample is inside or outside each edge */
+ GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
+ GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
+ GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
+ /* Check if the sample is exactly on an edge. If so, let cross be a
+ * positive or negative value depending on the direction of the edge.
+ */
+ if (cross0 == 0.0F)
+ cross0 = dx0 + dy0;
+ if (cross1 == 0.0F)
+ cross1 = dx1 + dy1;
+ if (cross2 == 0.0F)
+ cross2 = dx2 + dy2;
+ if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
+ /* point is outside triangle */
+ insideCount--;
+ stop = 15;
+ }
+ }
+ if (stop == 4)
+ return 15;
+ else
+ return insideCount;
+}
+
+
+
+static void
+rgba_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_RGBA
+#include "s_aatritemp.h"
+}
+
+
+static void
+index_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_INDEX
+#include "s_aatritemp.h"
+}
+
+
+/*
+ * Compute mipmap level of detail.
+ */
+static INLINE GLfloat
+compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
+ GLfloat invQ, GLfloat width, GLfloat height)
+{
+ GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
+ GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
+ GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
+ GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
+ GLfloat r1 = dudx * dudx + dudy * dudy;
+ GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+ GLfloat rho2 = r1 + r2;
+ /* return log base 2 of rho */
+ return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2) */
+}
+
+
+static void
+tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_RGBA
+#define DO_TEX
+#include "s_aatritemp.h"
+}
+
+
+static void
+spec_tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_RGBA
+#define DO_TEX
+#define DO_SPEC
+#include "s_aatritemp.h"
+}
+
+
+static void
+multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_RGBA
+#define DO_MULTITEX
+#include "s_aatritemp.h"
+}
+
+static void
+spec_multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
+{
+#define DO_Z
+#define DO_RGBA
+#define DO_MULTITEX
+#define DO_SPEC
+#include "s_aatritemp.h"
+}
+
+
+/*
+ * Examine GL state and set ctx->Driver.TriangleFunc to an
+ * appropriate antialiased triangle rasterizer function.
+ */
+void
+_mesa_set_aa_triangle_function(GLcontext *ctx)
+{
+ ASSERT(ctx->Polygon.SmoothFlag);
+ 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;
+ }
+ else {
+ ctx->Driver.TriangleFunc = spec_tex_aa_tri;
+ }
+ }
+ else {
+ if (ctx->Texture.MultiTextureEnabled) {
+ ctx->Driver.TriangleFunc = multitex_aa_tri;
+ }
+ else {
+ ctx->Driver.TriangleFunc = tex_aa_tri;
+ }
+ }
+ }
+ else {
+ if (ctx->Visual.RGBAflag) {
+ ctx->Driver.TriangleFunc = rgba_aa_tri;
+ }
+ else {
+ ctx->Driver.TriangleFunc = index_aa_tri;
+ }
+ }
+ ASSERT(ctx->Driver.TriangleFunc);
+}
--- /dev/null
+/* $Id: s_aatriangle.h,v 1.1 2000/10/31 18:00:04 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.
+ */
+
+
+#ifndef S_AATRIANGLE_H
+#define S_AATRIANGLE_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_set_aa_triangle_function(GLcontext *ctx);
+
+
+#endif
--- /dev/null
+/* $Id: s_aatritemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Antialiased Triangle Rasterizer Template
+ *
+ * This file is #include'd to generate custom AA triangle rasterizers.
+ * NOTE: this code hasn't been optimized yet. That'll come after it
+ * works correctly.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be copmuted across the triangle:
+ * DO_Z - if defined, compute Z values
+ * DO_RGBA - if defined, compute RGBA values
+ * DO_INDEX - if defined, compute color index values
+ * DO_SPEC - if defined, compute specular RGB values
+ * DO_TEX - if defined, compute unit 0 STRQ texcoords
+ * DO_MULTITEX - if defined, compute all unit's STRQ texcoords
+ */
+
+/*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;
+ GLint iyMin, iyMax;
+ GLfloat yMin, yMax;
+ GLboolean ltor;
+ GLfloat majDx, majDy;
+#ifdef DO_Z
+ GLfloat zPlane[4]; /* Z (depth) */
+ GLdepth z[MAX_WIDTH];
+ GLfloat fogPlane[4];
+ GLfixed fog[MAX_WIDTH];
+#endif
+#ifdef DO_RGBA
+ GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4]; /* color */
+ GLchan rgba[MAX_WIDTH][4];
+#endif
+#ifdef DO_INDEX
+ GLfloat iPlane[4]; /* color index */
+ GLuint index[MAX_WIDTH];
+#endif
+#ifdef DO_SPEC
+ GLfloat srPlane[4], sgPlane[4], sbPlane[4]; /* spec color */
+ GLchan spec[MAX_WIDTH][4];
+#endif
+#ifdef DO_TEX
+ GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
+ GLfloat texWidth, texHeight;
+ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH];
+ GLfloat lambda[MAX_WIDTH];
+#elif defined(DO_MULTITEX)
+ GLfloat sPlane[MAX_TEXTURE_UNITS][4];
+ GLfloat tPlane[MAX_TEXTURE_UNITS][4];
+ GLfloat uPlane[MAX_TEXTURE_UNITS][4];
+ GLfloat vPlane[MAX_TEXTURE_UNITS][4];
+ GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
+ GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
+#endif
+ 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];
+ if (y0 <= y1) {
+ if (y1 <= y2) {
+ vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */
+ }
+ else if (y2 <= y0) {
+ vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */
+ }
+ else {
+ vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */
+ }
+ }
+ else {
+ if (y0 <= y2) {
+ vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */
+ }
+ else if (y2 <= y1) {
+ vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */
+ }
+ else {
+ vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */
+ }
+ }
+ }
+
+ majDx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0];
+ majDy = VB->Win.data[vMax][1] - VB->Win.data[vMin][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 area = majDx * botDy - botDx * majDy;
+ ltor = (GLboolean) (area < 0.0F);
+ /* Do backface culling */
+ if (area * bf < 0 || area * area < .0025)
+ return;
+ }
+
+#ifndef DO_OCCLUSION_TEST
+ ctx->OcclusionResult = GL_TRUE;
+#endif
+
+ /* plane setup */
+#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],
+ 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);
+ }
+ 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);
+ }
+#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);
+ }
+ else {
+ constant_plane(VB->IndexPtr->data[pv], 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);
+ }
+#endif
+#ifdef DO_TEX
+ {
+ 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;
+ 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);
+ compute_plane(p0, p1, p2, q0, q1, q2, vPlane);
+ texWidth = (GLfloat) texImage->Width;
+ texHeight = (GLfloat) texImage->Height;
+ }
+#elif defined(DO_MULTITEX)
+ {
+ 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;
+ 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;
+ 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]);
+ compute_plane(p0, p1, p2, q0, q1, q2, vPlane[u]);
+ texWidth[u] = (GLfloat) texImage->Width;
+ texHeight[u] = (GLfloat) texImage->Height;
+ }
+ }
+ }
+#endif
+
+ yMin = VB->Win.data[vMin][1];
+ yMax = VB->Win.data[vMax][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 dxdy = majDx / majDy;
+ const float xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
+ float x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
+ int iy;
+ for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
+ GLint ix, startX = (GLint) (x - xAdj);
+ GLuint count, n;
+ GLfloat coverage = 0.0F;
+ /* skip over fragments with zero coverage */
+ while (startX < MAX_WIDTH) {
+ coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
+ if (coverage > 0.0F)
+ break;
+ startX++;
+ }
+
+ /* enter interior of triangle */
+ ix = startX;
+ count = 0;
+ while (coverage > 0.0F) {
+#ifdef DO_Z
+ z[count] = (GLdepth) solve_plane(ix, iy, zPlane);
+ fog[count] = FloatToFixed(solve_plane(ix, iy, fogPlane));
+#endif
+#ifdef DO_RGBA
+ rgba[count][RCOMP] = solve_plane_chan(ix, iy, rPlane);
+ rgba[count][GCOMP] = solve_plane_chan(ix, iy, gPlane);
+ rgba[count][BCOMP] = solve_plane_chan(ix, iy, bPlane);
+ rgba[count][ACOMP] = (GLchan) (solve_plane_chan(ix, iy, aPlane) * coverage);
+#endif
+#ifdef DO_INDEX
+ {
+ GLint frac = compute_coveragei(pMin, pMid, pMax, ix, iy);
+ GLint indx = (GLint) solve_plane(ix, iy, iPlane);
+ index[count] = (indx & ~0xf) | frac;
+ }
+#endif
+#ifdef DO_SPEC
+ spec[count][RCOMP] = solve_plane_chan(ix, iy, srPlane);
+ spec[count][GCOMP] = solve_plane_chan(ix, iy, sgPlane);
+ spec[count][BCOMP] = solve_plane_chan(ix, iy, sbPlane);
+#endif
+#ifdef DO_TEX
+ {
+ GLfloat invQ = solve_plane_recip(ix, iy, vPlane);
+ s[count] = solve_plane(ix, iy, sPlane) * invQ;
+ t[count] = solve_plane(ix, iy, tPlane) * invQ;
+ u[count] = solve_plane(ix, iy, uPlane) * invQ;
+ lambda[count] = compute_lambda(sPlane, tPlane, invQ,
+ texWidth, texHeight);
+ }
+#elif defined(DO_MULTITEX)
+ {
+ GLuint unit;
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+ 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;
+ u[unit][count] = solve_plane(ix, iy, uPlane[unit]) * invQ;
+ lambda[unit][count] = compute_lambda(sPlane[unit],
+ tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+ }
+ }
+ }
+#endif
+ ix++;
+ count++;
+ coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
+ }
+
+ n = (GLuint) ix - (GLuint) startX;
+#ifdef DO_MULTITEX
+# ifdef DO_SPEC
+ gl_write_multitexture_span(ctx, n, startX, iy, z, fog,
+ (const GLfloat (*)[MAX_WIDTH]) s,
+ (const GLfloat (*)[MAX_WIDTH]) t,
+ (const GLfloat (*)[MAX_WIDTH]) u,
+ (GLfloat (*)[MAX_WIDTH]) lambda,
+ rgba, (const GLchan (*)[4]) spec,
+ GL_POLYGON);
+# else
+ gl_write_multitexture_span(ctx, n, startX, iy, z, fog,
+ (const GLfloat (*)[MAX_WIDTH]) s,
+ (const GLfloat (*)[MAX_WIDTH]) t,
+ (const GLfloat (*)[MAX_WIDTH]) u,
+ lambda, rgba, NULL, GL_POLYGON);
+# endif
+#elif defined(DO_TEX)
+# ifdef DO_SPEC
+ gl_write_texture_span(ctx, n, startX, iy, z, fog,
+ s, t, u, lambda, rgba,
+ (const GLchan (*)[4]) spec, GL_POLYGON);
+# else
+ gl_write_texture_span(ctx, n, startX, iy, z, fog,
+ s, t, u, lambda,
+ rgba, NULL, GL_POLYGON);
+# endif
+#elif defined(DO_RGBA)
+ gl_write_rgba_span(ctx, n, startX, iy, z, fog, rgba, GL_POLYGON);
+#elif defined(DO_INDEX)
+ gl_write_index_span(ctx, n, startX, iy, z, fog, index, GL_POLYGON);
+#endif
+ }
+ }
+ 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 dxdy = majDx / majDy;
+ const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
+ GLfloat x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
+ GLint iy;
+ for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
+ GLint ix, left, startX = (GLint) (x + xAdj);
+ GLuint count, n;
+ GLfloat coverage = 0.0F;
+ /* skip fragments with zero coverage */
+ while (startX >= 0) {
+ coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
+ if (coverage > 0.0F)
+ break;
+ startX--;
+ }
+
+ /* enter interior of triangle */
+ ix = startX;
+ count = 0;
+ while (coverage > 0.0F) {
+#ifdef DO_Z
+ z[ix] = (GLdepth) solve_plane(ix, iy, zPlane);
+ fog[ix] = FloatToFixed(solve_plane(ix, iy, fogPlane));
+#endif
+#ifdef DO_RGBA
+ rgba[ix][RCOMP] = solve_plane_chan(ix, iy, rPlane);
+ rgba[ix][GCOMP] = solve_plane_chan(ix, iy, gPlane);
+ rgba[ix][BCOMP] = solve_plane_chan(ix, iy, bPlane);
+ rgba[ix][ACOMP] = (GLchan) (solve_plane_chan(ix, iy, aPlane) * coverage);
+#endif
+#ifdef DO_INDEX
+ {
+ GLint frac = compute_coveragei(pMin, pMax, pMid, ix, iy);
+ GLint indx = (GLint) solve_plane(ix, iy, iPlane);
+ index[ix] = (indx & ~0xf) | frac;
+ }
+#endif
+#ifdef DO_SPEC
+ spec[ix][RCOMP] = solve_plane_chan(ix, iy, srPlane);
+ spec[ix][GCOMP] = solve_plane_chan(ix, iy, sgPlane);
+ spec[ix][BCOMP] = solve_plane_chan(ix, iy, sbPlane);
+#endif
+#ifdef DO_TEX
+ {
+ GLfloat invQ = solve_plane_recip(ix, iy, vPlane);
+ s[ix] = solve_plane(ix, iy, sPlane) * invQ;
+ t[ix] = solve_plane(ix, iy, tPlane) * invQ;
+ u[ix] = solve_plane(ix, iy, uPlane) * invQ;
+ lambda[ix] = compute_lambda(sPlane, tPlane, invQ,
+ texWidth, texHeight);
+ }
+#elif defined(DO_MULTITEX)
+ {
+ GLuint unit;
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+ 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;
+ u[unit][ix] = solve_plane(ix, iy, uPlane[unit]) * invQ;
+ lambda[unit][ix] = compute_lambda(sPlane[unit],
+ tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+ }
+ }
+ }
+#endif
+ ix--;
+ count++;
+ coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
+ }
+
+ n = (GLuint) startX - (GLuint) ix;
+ left = ix + 1;
+#ifdef DO_MULTITEX
+ {
+ GLuint unit;
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+ if (ctx->Texture.Unit[unit].ReallyEnabled) {
+ GLint j;
+ for (j = 0; j < n; j++) {
+ s[unit][j] = s[unit][j + left];
+ t[unit][j] = t[unit][j + left];
+ u[unit][j] = u[unit][j + left];
+ lambda[unit][j] = lambda[unit][j + left];
+ }
+ }
+ }
+ }
+# ifdef DO_SPEC
+ gl_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+ (const GLfloat (*)[MAX_WIDTH]) s,
+ (const GLfloat (*)[MAX_WIDTH]) t,
+ (const GLfloat (*)[MAX_WIDTH]) u,
+ lambda, rgba + left,
+ (const GLchan (*)[4]) (spec + left),
+ GL_POLYGON);
+# else
+ gl_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+ (const GLfloat (*)[MAX_WIDTH]) s,
+ (const GLfloat (*)[MAX_WIDTH]) t,
+ (const GLfloat (*)[MAX_WIDTH]) u,
+ lambda,
+ rgba + left, NULL, GL_POLYGON);
+# endif
+#elif defined(DO_TEX)
+# ifdef DO_SPEC
+ gl_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+ s + left, t + left, u + left,
+ lambda + left, rgba + left,
+ (const GLchan (*)[4]) (spec + left),
+ GL_POLYGON);
+# else
+ gl_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+ s + left, t + left,
+ u + left, lambda + left,
+ rgba + left, NULL, GL_POLYGON);
+# endif
+#elif defined(DO_RGBA)
+ gl_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
+ rgba + left, GL_POLYGON);
+#elif defined(DO_INDEX)
+ gl_write_index_span(ctx, n, left, iy, z + left, fog + left,
+ index + left, GL_POLYGON);
+#endif
+ }
+ }
+}
+
+
+#ifdef DO_Z
+#undef DO_Z
+#endif
+
+#ifdef DO_RGBA
+#undef DO_RGBA
+#endif
+
+#ifdef DO_INDEX
+#undef DO_INDEX
+#endif
+
+#ifdef DO_SPEC
+#undef DO_SPEC
+#endif
+
+#ifdef DO_TEX
+#undef DO_TEX
+#endif
+
+#ifdef DO_MULTITEX
+#undef DO_MULTITEX
+#endif
+
+#ifdef DO_OCCLUSION_TEST
+#undef DO_OCCLUSION_TEST
+#endif
--- /dev/null
+/* $Id: s_accum.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_accum.h"
+#include "s_masking.h"
+#include "s_span.h"
+
+
+/*
+ * Accumulation buffer notes
+ *
+ * Normally, accumulation buffer values are GLshorts with values in
+ * [-32767, 32767] which represent floating point colors in [-1, 1],
+ * as suggested by the OpenGL specification.
+ *
+ * We optimize for the common case used for full-scene antialiasing:
+ * // start with accum buffer cleared to zero
+ * glAccum(GL_LOAD, w); // or GL_ACCUM the first image
+ * glAccum(GL_ACCUM, w);
+ * ...
+ * glAccum(GL_ACCUM, w);
+ * glAccum(GL_RETURN, 1.0);
+ * That is, we start with an empty accumulation buffer and accumulate
+ * n images, each with weight w = 1/n.
+ * In this scenario, we can simply store unscaled integer values in
+ * the accum buffer instead of scaled integers. We'll also keep track
+ * of the w value so when we do GL_RETURN we simply divide the accumulated
+ * values by n (=1/w).
+ * This lets us avoid _many_ int->float->int conversions.
+ */
+
+
+#if CHAN_BITS == 8
+#define USE_OPTIMIZED_ACCUM /* enable the optimization */
+#endif
+
+
+
+void
+_mesa_alloc_accum_buffer( GLcontext *ctx )
+{
+ GLint n;
+
+ if (ctx->DrawBuffer->Accum) {
+ FREE( ctx->DrawBuffer->Accum );
+ ctx->DrawBuffer->Accum = NULL;
+ }
+
+ /* allocate accumulation buffer if not already present */
+ n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4 * sizeof(GLaccum);
+ ctx->DrawBuffer->Accum = (GLaccum *) MALLOC( n );
+ if (!ctx->DrawBuffer->Accum) {
+ /* unable to setup accumulation buffer */
+ gl_error( ctx, GL_OUT_OF_MEMORY, "glAccum" );
+ }
+#ifdef USE_OPTIMIZED_ACCUM
+ ctx->IntegerAccumMode = GL_TRUE;
+#else
+ ctx->IntegerAccumMode = GL_FALSE;
+#endif
+ ctx->IntegerAccumScaler = 0.0;
+}
+
+
+
+
+
+
+/*
+ * This is called when we fall out of optimized/unscaled accum buffer mode.
+ * That is, we convert each unscaled accum buffer value into a scaled value
+ * representing the range[-1, 1].
+ */
+static void rescale_accum( GLcontext *ctx )
+{
+ const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4;
+ const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
+ const GLfloat s = ctx->IntegerAccumScaler * (32767.0 / fChanMax);
+ GLaccum *accum = ctx->DrawBuffer->Accum;
+ GLuint i;
+
+ assert(ctx->IntegerAccumMode);
+ assert(accum);
+
+ for (i = 0; i < n; i++) {
+ accum[i] = (GLaccum) (accum[i] * s);
+ }
+
+ ctx->IntegerAccumMode = GL_FALSE;
+}
+
+
+
+void
+_swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
+ GLint xpos, GLint ypos,
+ GLint width, GLint height )
+
+{
+ GLuint width4;
+ GLfloat acc_scale;
+ GLchan rgba[MAX_WIDTH][4];
+ const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+ const GLint iChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
+ const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
+
+
+ if (!ctx->DrawBuffer->Accum) {
+ _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer (low memory?)");
+ 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;
+ }
+
+ width4 = 4 * width;
+
+ switch (op) {
+ case GL_ADD:
+ if (value != 0.0F) {
+ const GLaccum intVal = (GLaccum) (value * acc_scale);
+ GLuint j;
+ /* Leave optimized accum buffer mode */
+ if (ctx->IntegerAccumMode)
+ rescale_accum(ctx);
+ for (j = 0; j < height; j++) {
+ GLaccum * acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
+ GLuint i;
+ for (i = 0; i < width4; i++) {
+ acc[i] += intVal;
+ }
+ ypos++;
+ }
+ }
+ break;
+
+ case GL_MULT:
+ if (value != 1.0F) {
+ GLuint j;
+ /* Leave optimized accum buffer mode */
+ if (ctx->IntegerAccumMode)
+ rescale_accum(ctx);
+ for (j = 0; j < height; j++) {
+ GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
+ GLuint i;
+ for (i = 0; i < width4; i++) {
+ acc[i] = (GLaccum) ( (GLfloat) acc[i] * value );
+ }
+ ypos++;
+ }
+ }
+ break;
+
+ case GL_ACCUM:
+ if (value == 0.0F)
+ return;
+
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+
+ /* May have to leave optimized accum buffer mode */
+ if (ctx->IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
+ ctx->IntegerAccumScaler = value;
+ if (ctx->IntegerAccumMode && value != ctx->IntegerAccumScaler)
+ rescale_accum(ctx);
+
+ RENDER_START(ctx);
+
+ if (ctx->IntegerAccumMode) {
+ /* simply add integer color values into accum buffer */
+ GLuint j;
+ GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+ assert(ctx->IntegerAccumScaler > 0.0);
+ assert(ctx->IntegerAccumScaler <= 1.0);
+ for (j = 0; j < height; j++) {
+
+ GLuint i, i4;
+ gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+ for (i = i4 = 0; i < width; i++, i4+=4) {
+ acc[i4+0] += rgba[i][RCOMP];
+ acc[i4+1] += rgba[i][GCOMP];
+ acc[i4+2] += rgba[i][BCOMP];
+ acc[i4+3] += rgba[i][ACOMP];
+ }
+ acc += width4;
+ ypos++;
+ }
+ }
+ else {
+ /* scaled integer accum buffer */
+ const GLfloat rscale = value * acc_scale / fChanMax;
+ const GLfloat gscale = value * acc_scale / fChanMax;
+ const GLfloat bscale = value * acc_scale / fChanMax;
+ const GLfloat ascale = value * acc_scale / fChanMax;
+ GLuint j;
+ for (j=0;j<height;j++) {
+ GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+ GLuint i;
+ gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+ for (i=0;i<width;i++) {
+ *acc += (GLaccum) ( (GLfloat) rgba[i][RCOMP] * rscale ); acc++;
+ *acc += (GLaccum) ( (GLfloat) rgba[i][GCOMP] * gscale ); acc++;
+ *acc += (GLaccum) ( (GLfloat) rgba[i][BCOMP] * bscale ); acc++;
+ *acc += (GLaccum) ( (GLfloat) rgba[i][ACOMP] * ascale ); acc++;
+ }
+ ypos++;
+ }
+ }
+ /* restore read buffer = draw buffer (the default) */
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+ ctx->Color.DriverDrawBuffer );
+ RENDER_FINISH(ctx);
+ break;
+
+ case GL_LOAD:
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+
+ /* This is a change to go into optimized accum buffer mode */
+ if (value > 0.0 && value <= 1.0) {
+#ifdef USE_OPTIMIZED_ACCUM
+ ctx->IntegerAccumMode = GL_TRUE;
+#else
+ ctx->IntegerAccumMode = GL_FALSE;
+#endif
+ ctx->IntegerAccumScaler = value;
+ }
+ else {
+ ctx->IntegerAccumMode = GL_FALSE;
+ ctx->IntegerAccumScaler = 0.0;
+ }
+
+ RENDER_START(ctx);
+ if (ctx->IntegerAccumMode) {
+ /* just copy values into accum buffer */
+ GLuint j;
+ GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+ assert(ctx->IntegerAccumScaler > 0.0);
+ assert(ctx->IntegerAccumScaler <= 1.0);
+ for (j = 0; j < height; j++) {
+ GLuint i, i4;
+ gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+ for (i = i4 = 0; i < width; i++, i4 += 4) {
+ acc[i4+0] = rgba[i][RCOMP];
+ acc[i4+1] = rgba[i][GCOMP];
+ acc[i4+2] = rgba[i][BCOMP];
+ acc[i4+3] = rgba[i][ACOMP];
+ }
+ acc += width4;
+ ypos++;
+ }
+ }
+ else {
+ /* scaled integer accum buffer */
+ const GLfloat rscale = value * acc_scale / fChanMax;
+ const GLfloat gscale = value * acc_scale / fChanMax;
+ const GLfloat bscale = value * acc_scale / fChanMax;
+ const GLfloat ascale = value * acc_scale / fChanMax;
+ const GLfloat d = 3.0 / acc_scale;
+ GLuint i, j;
+ for (j = 0; j < height; j++) {
+ GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+ gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+ for (i=0;i<width;i++) {
+ *acc++ = (GLaccum) ((GLfloat) rgba[i][RCOMP] * rscale + d);
+ *acc++ = (GLaccum) ((GLfloat) rgba[i][GCOMP] * gscale + d);
+ *acc++ = (GLaccum) ((GLfloat) rgba[i][BCOMP] * bscale + d);
+ *acc++ = (GLaccum) ((GLfloat) rgba[i][ACOMP] * ascale + d);
+ }
+ ypos++;
+ }
+ }
+
+ /* restore read buffer = draw buffer (the default) */
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+ ctx->Color.DriverDrawBuffer );
+ RENDER_FINISH(ctx);
+ break;
+
+ case GL_RETURN:
+ /* May have to leave optimized accum buffer mode */
+ if (ctx->IntegerAccumMode && value != 1.0)
+ rescale_accum(ctx);
+
+ RENDER_START(ctx);
+ if (ctx->IntegerAccumMode && ctx->IntegerAccumScaler > 0) {
+ /* build lookup table to avoid many floating point multiplies */
+ static GLchan multTable[32768];
+ static GLfloat prevMult = 0.0;
+ const GLfloat mult = ctx->IntegerAccumScaler;
+ const GLint max = MIN2((GLint) (256 / mult), 32767);
+ GLuint j;
+ if (mult != prevMult) {
+ for (j = 0; j < max; j++)
+ multTable[j] = (GLint) ((GLfloat) j * mult + 0.5F);
+ prevMult = mult;
+ }
+
+ assert(ctx->IntegerAccumScaler > 0.0);
+ assert(ctx->IntegerAccumScaler <= 1.0);
+ for (j = 0; j < height; j++) {
+ const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
+ GLuint i, i4;
+ for (i = i4 = 0; i < width; i++, i4 += 4) {
+ ASSERT(acc[i4+0] < max);
+ ASSERT(acc[i4+1] < max);
+ ASSERT(acc[i4+2] < max);
+ ASSERT(acc[i4+3] < max);
+ rgba[i][RCOMP] = multTable[acc[i4+0]];
+ rgba[i][GCOMP] = multTable[acc[i4+1]];
+ rgba[i][BCOMP] = multTable[acc[i4+2]];
+ rgba[i][ACOMP] = multTable[acc[i4+3]];
+ }
+ if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
+ }
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, xpos, ypos,
+ (const GLchan (*)[4])rgba, NULL );
+ ypos++;
+ }
+ }
+ else {
+ const GLfloat rscale = value / acc_scale * fChanMax;
+ const GLfloat gscale = value / acc_scale * fChanMax;
+ const GLfloat bscale = value / acc_scale * fChanMax;
+ const GLfloat ascale = value / acc_scale * fChanMax;
+ GLuint i, j;
+ for (j=0;j<height;j++) {
+ const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
+ for (i=0;i<width;i++) {
+ GLint r, g, b, a;
+ r = (GLint) ( (GLfloat) (*acc++) * rscale + 0.5F );
+ g = (GLint) ( (GLfloat) (*acc++) * gscale + 0.5F );
+ b = (GLint) ( (GLfloat) (*acc++) * bscale + 0.5F );
+ a = (GLint) ( (GLfloat) (*acc++) * ascale + 0.5F );
+ rgba[i][RCOMP] = CLAMP( r, 0, iChanMax );
+ rgba[i][GCOMP] = CLAMP( g, 0, iChanMax );
+ rgba[i][BCOMP] = CLAMP( b, 0, iChanMax );
+ rgba[i][ACOMP] = CLAMP( a, 0, iChanMax );
+ }
+ if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
+ }
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, xpos, ypos,
+ (const GLchan (*)[4])rgba, NULL );
+ ypos++;
+ }
+ }
+ RENDER_FINISH(ctx);
+ break;
+
+ default:
+ 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;
+ }
+ }
+}
--- /dev/null
+/* $Id: s_accum.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.1
+ *
+ * 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_ACCUM_H
+#define S_ACCUM_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_alloc_accum_buffer( GLcontext *ctx );
+
+
+extern void
+_mesa_clear_accum_buffer( GLcontext *ctx );
+
+
+
+#endif
--- /dev/null
+/* $Id: s_alpha.c,v 1.1 2000/10/31 18:00:04 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 "context.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mmath.h"
+
+#include "s_alpha.h"
+
+
+
+
+
+/*
+ * Apply the alpha test to a span of pixels.
+ * In: rgba - array of pixels
+ * In/Out: mask - current pixel mask. Pixels which fail the alpha test
+ * will set the corresponding mask flag to 0.
+ * Return: 0 = all pixels in the span failed the alpha test.
+ * 1 = one or more pixels passed the alpha test.
+ */
+GLint
+_mesa_alpha_test( const GLcontext *ctx,
+ GLuint n, CONST GLchan rgba[][4], GLubyte mask[] )
+{
+ GLuint i;
+ GLchan ref = ctx->Color.AlphaRef;
+
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Color.AlphaFunc) {
+ case GL_LESS:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] < ref);
+ }
+ return 1;
+ case GL_LEQUAL:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] <= ref);
+ }
+ return 1;
+ case GL_GEQUAL:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] >= ref);
+ }
+ return 1;
+ case GL_GREATER:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] > ref);
+ }
+ return 1;
+ case GL_NOTEQUAL:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] != ref);
+ }
+ return 1;
+ case GL_EQUAL:
+ for (i=0;i<n;i++) {
+ mask[i] &= (rgba[i][ACOMP] == ref);
+ }
+ return 1;
+ case GL_ALWAYS:
+ /* do nothing */
+ return 1;
+ case GL_NEVER:
+ /* caller should check for zero! */
+ return 0;
+ default:
+ gl_problem( ctx, "Invalid alpha test in gl_alpha_test" );
+ return 0;
+ }
+ /* Never get here */
+ /*return 1;*/
+}
--- /dev/null
+/* $Id: s_alpha.h,v 1.1 2000/10/31 18:00:04 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.
+ */
+
+
+#ifndef S_ALPHA_H
+#define S_ALPHA_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern GLint
+_mesa_alpha_test( const GLcontext *ctx, GLuint n,
+ CONST GLchan rgba[][4], GLubyte mask[] );
+
+
+
+#endif
--- /dev/null
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Software alpha planes. Many frame buffers don't have alpha bits so
+ * we simulate them in software.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "mem.h"
+
+#include "s_alphabuf.h"
+
+
+
+
+#define ALPHA_DRAW_ADDR(X,Y) \
+ (ctx->DrawBuffer->Alpha + (Y) * ctx->DrawBuffer->Width + (X))
+
+#define ALPHA_READ_ADDR(X,Y) \
+ (ctx->ReadBuffer->Alpha + (Y) * ctx->ReadBuffer->Width + (X))
+
+
+
+/*
+ * Allocate new front/back/left/right alpha buffers.
+ * Input: ctx - the context
+ *
+ */
+static void
+alloc_alpha_buffers( GLcontext *ctx, GLframebuffer *buf )
+{
+ GLint bytes = buf->Width * buf->Height * sizeof(GLchan);
+
+ ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
+
+ if (buf->FrontLeftAlpha) {
+ FREE( buf->FrontLeftAlpha );
+ }
+ buf->FrontLeftAlpha = (GLchan *) MALLOC( bytes );
+ if (!buf->FrontLeftAlpha) {
+ /* out of memory */
+ gl_error( ctx, GL_OUT_OF_MEMORY,
+ "Couldn't allocate front-left alpha buffer" );
+ }
+
+ if (ctx->Visual.DBflag) {
+ if (buf->BackLeftAlpha) {
+ FREE( buf->BackLeftAlpha );
+ }
+ buf->BackLeftAlpha = (GLchan *) MALLOC( bytes );
+ if (!buf->BackLeftAlpha) {
+ /* out of memory */
+ gl_error( ctx, GL_OUT_OF_MEMORY,
+ "Couldn't allocate back-left alpha buffer" );
+ }
+ }
+
+ if (ctx->Visual.StereoFlag) {
+ if (buf->FrontRightAlpha) {
+ FREE( buf->FrontRightAlpha );
+ }
+ buf->FrontRightAlpha = (GLchan *) MALLOC( bytes );
+ if (!buf->FrontRightAlpha) {
+ /* out of memory */
+ gl_error( ctx, GL_OUT_OF_MEMORY,
+ "Couldn't allocate front-right alpha buffer" );
+ }
+
+ if (ctx->Visual.DBflag) {
+ if (buf->BackRightAlpha) {
+ FREE( buf->BackRightAlpha );
+ }
+ buf->BackRightAlpha = (GLchan *) MALLOC( bytes );
+ if (!buf->BackRightAlpha) {
+ /* out of memory */
+ gl_error( ctx, GL_OUT_OF_MEMORY,
+ "Couldn't allocate back-right alpha buffer" );
+ }
+ }
+ }
+
+ if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT)
+ buf->Alpha = buf->FrontLeftAlpha;
+ else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT)
+ buf->Alpha = buf->BackLeftAlpha;
+ else if (ctx->Color.DriverDrawBuffer == GL_FRONT_RIGHT)
+ buf->Alpha = buf->FrontRightAlpha;
+ else if (ctx->Color.DriverDrawBuffer == GL_BACK_RIGHT)
+ buf->Alpha = buf->BackRightAlpha;
+}
+
+
+/*
+ * Allocate a new front and back alpha buffer.
+ */
+void
+_mesa_alloc_alpha_buffers( GLcontext *ctx )
+{
+ alloc_alpha_buffers( ctx, ctx->DrawBuffer );
+ if (ctx->ReadBuffer != ctx->DrawBuffer) {
+ alloc_alpha_buffers( ctx, ctx->ReadBuffer );
+ }
+}
+
+
+/*
+ * Clear all the alpha buffers
+ */
+void
+_mesa_clear_alpha_buffers( GLcontext *ctx )
+{
+ const GLchan aclear = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ GLuint bufferBit;
+
+ ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
+ ASSERT(ctx->Color.ColorMask[ACOMP]);
+
+ /* loop over four possible alpha buffers */
+ for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+ if (bufferBit & ctx->Color.DrawDestMask) {
+ GLchan *buffer;
+ if (bufferBit == FRONT_LEFT_BIT) {
+ buffer = ctx->DrawBuffer->FrontLeftAlpha;
+ }
+ else if (bufferBit == FRONT_RIGHT_BIT) {
+ buffer = ctx->DrawBuffer->FrontRightAlpha;
+ }
+ else if (bufferBit == BACK_LEFT_BIT) {
+ buffer = ctx->DrawBuffer->BackLeftAlpha;
+ }
+ else {
+ buffer = ctx->DrawBuffer->BackRightAlpha;
+ }
+
+ if (ctx->Scissor.Enabled) {
+ /* clear scissor region */
+ GLint j;
+ GLint rowLen = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
+ GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
+ GLchan *aptr = buffer
+ + ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
+ + ctx->DrawBuffer->Xmin;
+ for (j = 0; j < rows; j++) {
+#if CHAN_BITS == 8
+ MEMSET( aptr, aclear, rowLen );
+#elif CHAN_BITS == 16
+ MEMSET16( aptr, aclear, rowLen );
+#else
+#error unexpected CHAN_BITS value
+#endif
+ aptr += rowLen;
+ }
+ }
+ else {
+ /* clear whole buffer */
+ GLuint bytes = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ MEMSET( buffer, aclear, bytes );
+ }
+ }
+ }
+}
+
+
+
+void
+_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan *aptr = ALPHA_DRAW_ADDR( x, y );
+ GLuint i;
+
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ *aptr = rgba[i][ACOMP];
+ }
+ aptr++;
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ *aptr++ = rgba[i][ACOMP];
+ }
+ }
+}
+
+
+void
+_mesa_write_mono_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan alpha, const GLubyte mask[] )
+{
+ GLchan *aptr = ALPHA_DRAW_ADDR( x, y );
+ GLuint i;
+
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ *aptr = alpha;
+ }
+ aptr++;
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ *aptr++ = alpha;
+ }
+ }
+}
+
+
+void
+_mesa_write_alpha_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLuint i;
+
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+ *aptr = rgba[i][ACOMP];
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+ *aptr = rgba[i][ACOMP];
+ }
+ }
+}
+
+
+void
+_mesa_write_mono_alpha_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan alpha, const GLubyte mask[] )
+{
+ GLuint i;
+
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+ *aptr = alpha;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+ *aptr = alpha;
+ }
+ }
+}
+
+
+
+void
+_mesa_read_alpha_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLchan rgba[][4] )
+{
+ GLchan *aptr = ALPHA_READ_ADDR( x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][ACOMP] = *aptr++;
+ }
+}
+
+
+void
+_mesa_read_alpha_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLchan *aptr = ALPHA_READ_ADDR( x[i], y[i] );
+ rgba[i][ACOMP] = *aptr;
+ }
+ }
+}
+
+
+
--- /dev/null
+/* $Id: s_alphabuf.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_ALPHABUF_H
+#define S_ALPHABUF_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_alloc_alpha_buffers( GLcontext *ctx );
+
+
+extern void
+_mesa_clear_alpha_buffers( GLcontext *ctx );
+
+
+extern void
+_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_write_mono_alpha_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ GLchan alpha, const GLubyte mask[] );
+
+
+
+extern void
+_mesa_write_alpha_pixels( GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ CONST GLchan rgba[][4],
+ const GLubyte mask[] );
+
+
+extern void
+_mesa_write_mono_alpha_pixels( GLcontext* ctx,
+ GLuint n, const GLint x[],
+ const GLint y[], GLchan alpha,
+ const GLubyte mask[] );
+
+
+extern void
+_mesa_read_alpha_span( GLcontext* ctx,
+ GLuint n, GLint x, GLint y, GLchan rgba[][4] );
+
+
+extern void
+_mesa_read_alpha_pixels( GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+#endif
+
--- /dev/null
+/* $Id: s_bitmap.c,v 1.1 2000/10/31 18:00:04 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.
+ */
+
+
+#include "glheader.h"
+#include "image.h"
+#include "macros.h"
+#include "pixel.h"
+
+#include "s_fog.h"
+#include "s_pb.h"
+
+
+
+/*
+ * Render a bitmap.
+ */
+void
+_swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
+ GLsizei width, GLsizei height,
+ const struct gl_pixelstore_attrib *unpack,
+ const GLubyte *bitmap )
+{
+ struct pixel_buffer *PB = ctx->PB;
+ GLint row, col;
+ GLdepth fragZ;
+ GLfixed fogCoord;
+
+ ASSERT(ctx->RenderMode == GL_RENDER);
+ ASSERT(bitmap);
+
+ if (ctx->PB->primitive != GL_BITMAP) {
+ gl_flush_pb( ctx );
+ ctx->PB->primitive = GL_BITMAP;
+ }
+
+ /* Set bitmap drawing color */
+ if (ctx->Visual.RGBAflag) {
+ GLint r, g, b, a;
+ r = (GLint) (ctx->Current.RasterColor[0] * CHAN_MAXF);
+ g = (GLint) (ctx->Current.RasterColor[1] * CHAN_MAXF);
+ b = (GLint) (ctx->Current.RasterColor[2] * CHAN_MAXF);
+ a = (GLint) (ctx->Current.RasterColor[3] * CHAN_MAXF);
+ PB_SET_COLOR( PB, r, g, b, a );
+ }
+ else {
+ PB_SET_INDEX( PB, ctx->Current.RasterIndex );
+ }
+
+ fragZ = (GLdepth) ( ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF);
+
+ _mesa_win_fog_coords_from_z( ctx, 1, &fragZ, &fogCoord );
+
+ for (row=0; row<height; row++) {
+ const GLubyte *src = (const GLubyte *) _mesa_image_address( unpack,
+ bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
+
+ if (unpack->LsbFirst) {
+ /* Lsb first */
+ GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
+ for (col=0; col<width; col++) {
+ if (*src & mask) {
+ PB_WRITE_PIXEL( PB, px+col, py+row, fragZ, fogCoord );
+ }
+ if (mask == 128U) {
+ src++;
+ mask = 1U;
+ }
+ else {
+ mask = mask << 1;
+ }
+ }
+
+ PB_CHECK_FLUSH( ctx, PB );
+
+ /* get ready for next row */
+ if (mask != 1)
+ src++;
+ }
+ else {
+ /* Msb first */
+ GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
+ for (col=0; col<width; col++) {
+ if (*src & mask) {
+ PB_WRITE_PIXEL( PB, px+col, py+row, fragZ, fogCoord );
+ }
+ if (mask == 1U) {
+ src++;
+ mask = 128U;
+ }
+ else {
+ mask = mask >> 1;
+ }
+ }
+
+ PB_CHECK_FLUSH( ctx, PB );
+
+ /* get ready for next row */
+ if (mask != 128)
+ src++;
+ }
+ }
+
+ gl_flush_pb(ctx);
+}
+
+
+
--- /dev/null
+/* $Id: s_blend.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "context.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_blend.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+#ifdef USE_MMX_ASM
+#define _BLENDAPI _ASMAPI
+#else
+#define _BLENDAPI
+#endif
+
+/*
+ * Common transparency blending mode.
+ */
+static void _BLENDAPI
+blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLuint i;
+ ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+ ASSERT(ctx->Color.BlendSrcRGB==GL_SRC_ALPHA);
+ ASSERT(ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA);
+ (void) ctx;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ const GLint t = rgba[i][ACOMP]; /* t in [0, CHAN_MAX] */
+ if (t == 0) {
+ /* 0% alpha */
+ rgba[i][RCOMP] = dest[i][RCOMP];
+ rgba[i][GCOMP] = dest[i][GCOMP];
+ rgba[i][BCOMP] = dest[i][BCOMP];
+ rgba[i][ACOMP] = dest[i][ACOMP];
+ }
+ else if (t == CHAN_MAX) {
+ /* 100% alpha, no-op */
+ }
+ else {
+#if 0
+ /* This is pretty close, but Glean complains */
+ const GLint s = CHAN_MAX - t;
+ const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s + 1) >> 8;
+ const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s + 1) >> 8;
+ const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s + 1) >> 8;
+ const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s + 1) >> 8;
+#elif 0
+ /* This is slower but satisfies Glean */
+ const GLint s = CHAN_MAX - t;
+ const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / 255;
+ const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / 255;
+ const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / 255;
+ const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / 255;
+#else
+#if CHAN_BITS == 8
+ /* This satisfies Glean and should be reasonably fast */
+ /* Contributed by Nathan Hand */
+#define DIV255(X) (((X) << 8) + (X) + 256) >> 16
+ const GLint s = CHAN_MAX - t;
+ const GLint r = DIV255(rgba[i][RCOMP] * t + dest[i][RCOMP] * s);
+ const GLint g = DIV255(rgba[i][GCOMP] * t + dest[i][GCOMP] * s);
+ const GLint b = DIV255(rgba[i][BCOMP] * t + dest[i][BCOMP] * s);
+ const GLint a = DIV255(rgba[i][ACOMP] * t + dest[i][ACOMP] * s);
+#undef DIV255
+#else
+ const GLint s = CHAN_MAX - t;
+ const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / CHAN_MAX;
+ const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / CHAN_MAX;
+ const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / CHAN_MAX;
+ const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / CHAN_MAX;
+#endif
+#endif
+ ASSERT(r <= CHAN_MAX);
+ ASSERT(g <= CHAN_MAX);
+ ASSERT(b <= CHAN_MAX);
+ ASSERT(a <= CHAN_MAX);
+ rgba[i][RCOMP] = (GLchan) r;
+ rgba[i][GCOMP] = (GLchan) g;
+ rgba[i][BCOMP] = (GLchan) b;
+ rgba[i][ACOMP] = (GLchan) a;
+ }
+ }
+ }
+}
+
+
+
+/*
+ * Add src and dest.
+ */
+static void _BLENDAPI
+blend_add( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLuint i;
+ ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+ ASSERT(ctx->Color.BlendSrcRGB==GL_ONE);
+ ASSERT(ctx->Color.BlendDstRGB==GL_ONE);
+ (void) ctx;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
+ GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
+ GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
+ GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
+ rgba[i][RCOMP] = (GLchan) MIN2( r, CHAN_MAX );
+ rgba[i][GCOMP] = (GLchan) MIN2( g, CHAN_MAX );
+ rgba[i][BCOMP] = (GLchan) MIN2( b, CHAN_MAX );
+ rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAX );
+ }
+ }
+}
+
+
+
+/*
+ * Blend min function (for GL_EXT_blend_minmax)
+ */
+static void _BLENDAPI
+blend_min( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLuint i;
+ ASSERT(ctx->Color.BlendEquation==GL_MIN_EXT);
+ (void) ctx;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ rgba[i][RCOMP] = (GLchan) MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
+ rgba[i][GCOMP] = (GLchan) MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
+ rgba[i][BCOMP] = (GLchan) MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
+ rgba[i][ACOMP] = (GLchan) MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
+ }
+ }
+}
+
+
+
+/*
+ * Blend max function (for GL_EXT_blend_minmax)
+ */
+static void _BLENDAPI
+blend_max( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLuint i;
+ ASSERT(ctx->Color.BlendEquation==GL_MAX_EXT);
+ (void) ctx;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ rgba[i][RCOMP] = (GLchan) MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
+ rgba[i][GCOMP] = (GLchan) MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
+ rgba[i][BCOMP] = (GLchan) MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
+ rgba[i][ACOMP] = (GLchan) MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
+ }
+ }
+}
+
+
+
+/*
+ * Modulate: result = src * dest
+ */
+static void _BLENDAPI
+blend_modulate( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLuint i;
+ (void) ctx;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLint r = (rgba[i][RCOMP] * dest[i][RCOMP]) >> 8;
+ GLint g = (rgba[i][GCOMP] * dest[i][GCOMP]) >> 8;
+ GLint b = (rgba[i][BCOMP] * dest[i][BCOMP]) >> 8;
+ GLint a = (rgba[i][ACOMP] * dest[i][ACOMP]) >> 8;
+ rgba[i][RCOMP] = (GLchan) r;
+ rgba[i][GCOMP] = (GLchan) g;
+ rgba[i][BCOMP] = (GLchan) b;
+ rgba[i][ACOMP] = (GLchan) a;
+ }
+ }
+}
+
+
+
+/*
+ * General case blend pixels.
+ * Input: n - number of pixels
+ * mask - the usual write mask
+ * In/Out: rgba - the incoming and modified pixels
+ * Input: dest - the pixels from the dest color buffer
+ */
+static void _BLENDAPI
+blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+ GLfloat rscale = 1.0F / CHAN_MAXF;
+ GLfloat gscale = 1.0F / CHAN_MAXF;
+ GLfloat bscale = 1.0F / CHAN_MAXF;
+ GLfloat ascale = 1.0F / CHAN_MAXF;
+ GLuint i;
+
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLint Rs, Gs, Bs, As; /* Source colors */
+ GLint Rd, Gd, Bd, Ad; /* Dest colors */
+ GLfloat sR, sG, sB, sA; /* Source scaling */
+ GLfloat dR, dG, dB, dA; /* Dest scaling */
+ GLfloat r, g, b, a;
+
+ /* Source Color */
+ Rs = rgba[i][RCOMP];
+ Gs = rgba[i][GCOMP];
+ Bs = rgba[i][BCOMP];
+ As = rgba[i][ACOMP];
+
+ /* Frame buffer color */
+ Rd = dest[i][RCOMP];
+ Gd = dest[i][GCOMP];
+ Bd = dest[i][BCOMP];
+ Ad = dest[i][ACOMP];
+
+ /* Source RGB factor */
+ switch (ctx->Color.BlendSrcRGB) {
+ case GL_ZERO:
+ sR = sG = sB = 0.0F;
+ break;
+ case GL_ONE:
+ sR = sG = sB = 1.0F;
+ break;
+ case GL_DST_COLOR:
+ sR = (GLfloat) Rd * rscale;
+ sG = (GLfloat) Gd * gscale;
+ sB = (GLfloat) Bd * bscale;
+ break;
+ case GL_ONE_MINUS_DST_COLOR:
+ sR = 1.0F - (GLfloat) Rd * rscale;
+ sG = 1.0F - (GLfloat) Gd * gscale;
+ sB = 1.0F - (GLfloat) Bd * bscale;
+ break;
+ case GL_SRC_ALPHA:
+ sR = sG = sB = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ sR = sG = sB = (GLfloat) 1.0F - (GLfloat) As * ascale;
+ break;
+ case GL_DST_ALPHA:
+ sR = sG = sB = (GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_ALPHA:
+ sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ case GL_SRC_ALPHA_SATURATE:
+ if (As < CHAN_MAX - Ad) {
+ sR = sG = sB = (GLfloat) As * ascale;
+ }
+ else {
+ sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
+ }
+ break;
+ case GL_CONSTANT_COLOR:
+ sR = ctx->Color.BlendColor[0];
+ sG = ctx->Color.BlendColor[1];
+ sB = ctx->Color.BlendColor[2];
+ break;
+ case GL_ONE_MINUS_CONSTANT_COLOR:
+ sR = 1.0F - ctx->Color.BlendColor[0];
+ sG = 1.0F - ctx->Color.BlendColor[1];
+ sB = 1.0F - ctx->Color.BlendColor[2];
+ break;
+ case GL_CONSTANT_ALPHA:
+ sR = sG = sB = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_ALPHA:
+ sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_SRC_COLOR: /* GL_NV_blend_square */
+ sR = (GLfloat) Rs * rscale;
+ sG = (GLfloat) Gs * gscale;
+ sB = (GLfloat) Bs * bscale;
+ break;
+ case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+ sR = 1.0F - (GLfloat) Rs * rscale;
+ sG = 1.0F - (GLfloat) Gs * gscale;
+ sB = 1.0F - (GLfloat) Bs * bscale;
+ break;
+ default:
+ /* this should never happen */
+ gl_problem(ctx, "Bad blend source RGB factor in do_blend");
+ return;
+ }
+
+ /* Source Alpha factor */
+ switch (ctx->Color.BlendSrcA) {
+ case GL_ZERO:
+ sA = 0.0F;
+ break;
+ case GL_ONE:
+ sA = 1.0F;
+ break;
+ case GL_DST_COLOR:
+ sA = (GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_COLOR:
+ sA = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ case GL_SRC_ALPHA:
+ sA = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ sA = (GLfloat) 1.0F - (GLfloat) As * ascale;
+ break;
+ case GL_DST_ALPHA:
+ sA =(GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_ALPHA:
+ sA = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ case GL_SRC_ALPHA_SATURATE:
+ sA = 1.0;
+ break;
+ case GL_CONSTANT_COLOR:
+ sA = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_COLOR:
+ sA = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_CONSTANT_ALPHA:
+ sA = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_ALPHA:
+ sA = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_SRC_COLOR: /* GL_NV_blend_square */
+ sA = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+ sA = 1.0F - (GLfloat) As * ascale;
+ break;
+ default:
+ /* this should never happen */
+ sA = 0.0F;
+ gl_problem(ctx, "Bad blend source A factor in do_blend");
+ }
+
+ /* Dest RGB factor */
+ switch (ctx->Color.BlendDstRGB) {
+ case GL_ZERO:
+ dR = dG = dB = 0.0F;
+ break;
+ case GL_ONE:
+ dR = dG = dB = 1.0F;
+ break;
+ case GL_SRC_COLOR:
+ dR = (GLfloat) Rs * rscale;
+ dG = (GLfloat) Gs * gscale;
+ dB = (GLfloat) Bs * bscale;
+ break;
+ case GL_ONE_MINUS_SRC_COLOR:
+ dR = 1.0F - (GLfloat) Rs * rscale;
+ dG = 1.0F - (GLfloat) Gs * gscale;
+ dB = 1.0F - (GLfloat) Bs * bscale;
+ break;
+ case GL_SRC_ALPHA:
+ dR = dG = dB = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ dR = dG = dB = (GLfloat) 1.0F - (GLfloat) As * ascale;
+ break;
+ case GL_DST_ALPHA:
+ dR = dG = dB = (GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_ALPHA:
+ dR = dG = dB = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ case GL_CONSTANT_COLOR:
+ dR = ctx->Color.BlendColor[0];
+ dG = ctx->Color.BlendColor[1];
+ dB = ctx->Color.BlendColor[2];
+ break;
+ case GL_ONE_MINUS_CONSTANT_COLOR:
+ dR = 1.0F - ctx->Color.BlendColor[0];
+ dG = 1.0F - ctx->Color.BlendColor[1];
+ dB = 1.0F - ctx->Color.BlendColor[2];
+ break;
+ case GL_CONSTANT_ALPHA:
+ dR = dG = dB = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_ALPHA:
+ dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_DST_COLOR: /* GL_NV_blend_square */
+ dR = (GLfloat) Rd * rscale;
+ dG = (GLfloat) Gd * gscale;
+ dB = (GLfloat) Bd * bscale;
+ break;
+ case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+ dR = 1.0F - (GLfloat) Rd * rscale;
+ dG = 1.0F - (GLfloat) Gd * gscale;
+ dB = 1.0F - (GLfloat) Bd * bscale;
+ break;
+ default:
+ /* this should never happen */
+ dR = dG = dB = 0.0F;
+ gl_problem(ctx, "Bad blend dest RGB factor in do_blend");
+ }
+
+ /* Dest Alpha factor */
+ switch (ctx->Color.BlendDstA) {
+ case GL_ZERO:
+ dA = 0.0F;
+ break;
+ case GL_ONE:
+ dA = 1.0F;
+ break;
+ case GL_SRC_COLOR:
+ dA = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_COLOR:
+ dA = 1.0F - (GLfloat) As * ascale;
+ break;
+ case GL_SRC_ALPHA:
+ dA = (GLfloat) As * ascale;
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ dA = (GLfloat) 1.0F - (GLfloat) As * ascale;
+ break;
+ case GL_DST_ALPHA:
+ dA = (GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_ALPHA:
+ dA = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ case GL_CONSTANT_COLOR:
+ dA = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_COLOR:
+ dA = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_CONSTANT_ALPHA:
+ dA = ctx->Color.BlendColor[3];
+ break;
+ case GL_ONE_MINUS_CONSTANT_ALPHA:
+ dA = 1.0F - ctx->Color.BlendColor[3];
+ break;
+ case GL_DST_COLOR: /* GL_NV_blend_square */
+ dA = (GLfloat) Ad * ascale;
+ break;
+ case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+ dA = 1.0F - (GLfloat) Ad * ascale;
+ break;
+ default:
+ /* this should never happen */
+ dA = 0.0F;
+ gl_problem(ctx, "Bad blend dest A factor in do_blend");
+ return;
+ }
+
+ /* Due to round-off problems we have to clamp against zero. */
+ /* Optimization: we don't have to do this for all src & dst factors */
+ if (dA < 0.0F) dA = 0.0F;
+ if (dR < 0.0F) dR = 0.0F;
+ if (dG < 0.0F) dG = 0.0F;
+ if (dB < 0.0F) dB = 0.0F;
+ if (sA < 0.0F) sA = 0.0F;
+ if (sR < 0.0F) sR = 0.0F;
+ if (sG < 0.0F) sG = 0.0F;
+ if (sB < 0.0F) sB = 0.0F;
+
+ ASSERT( sR <= 1.0 );
+ ASSERT( sG <= 1.0 );
+ ASSERT( sB <= 1.0 );
+ ASSERT( sA <= 1.0 );
+ ASSERT( dR <= 1.0 );
+ ASSERT( dG <= 1.0 );
+ ASSERT( dB <= 1.0 );
+ ASSERT( dA <= 1.0 );
+
+ /* compute blended color */
+ if (ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+ r = Rs * sR + Rd * dR + 0.5F;
+ g = Gs * sG + Gd * dG + 0.5F;
+ b = Bs * sB + Bd * dB + 0.5F;
+ a = As * sA + Ad * dA + 0.5F;
+ }
+ else if (ctx->Color.BlendEquation==GL_FUNC_SUBTRACT_EXT) {
+ r = Rs * sR - Rd * dR + 0.5F;
+ g = Gs * sG - Gd * dG + 0.5F;
+ b = Bs * sB - Bd * dB + 0.5F;
+ a = As * sA - Ad * dA + 0.5F;
+ }
+ else if (ctx->Color.BlendEquation==GL_FUNC_REVERSE_SUBTRACT_EXT) {
+ r = Rd * dR - Rs * sR + 0.5F;
+ g = Gd * dG - Gs * sG + 0.5F;
+ b = Bd * dB - Bs * sB + 0.5F;
+ a = Ad * dA - As * sA + 0.5F;
+ }
+ else {
+ /* should never get here */
+ r = g = b = a = 0.0F; /* silence uninitialized var warning */
+ gl_problem(ctx, "unexpected BlendEquation in blend_general()");
+ }
+
+ /* final clamping */
+ rgba[i][RCOMP] = (GLchan) (GLint) CLAMP( r, 0.0F, CHAN_MAXF );
+ rgba[i][GCOMP] = (GLchan) (GLint) CLAMP( g, 0.0F, CHAN_MAXF );
+ rgba[i][BCOMP] = (GLchan) (GLint) CLAMP( b, 0.0F, CHAN_MAXF );
+ rgba[i][ACOMP] = (GLchan) (GLint) CLAMP( a, 0.0F, CHAN_MAXF );
+ }
+ }
+}
+
+
+
+#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 )
+{
+ const GLenum eq = ctx->Color.BlendEquation;
+ const GLenum srcRGB = ctx->Color.BlendSrcRGB;
+ const GLenum dstRGB = ctx->Color.BlendDstRGB;
+ 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;
+ }
+ else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA
+ && dstRGB==GL_ONE_MINUS_SRC_ALPHA) {
+ ctx->Color.BlendFunc = blend_transparency;
+ }
+ else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) {
+ ctx->Color.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;
+ }
+ else if (eq==GL_MIN_EXT) {
+ ctx->Color.BlendFunc = blend_min;
+ }
+ else if (eq==GL_MAX_EXT) {
+ ctx->Color.BlendFunc = blend_max;
+ }
+ else {
+ ctx->Color.BlendFunc = blend_general;
+ }
+}
+
+
+
+/*
+ * Apply the blending operator to a span of pixels.
+ * Input: n - number of pixels in span
+ * x, y - location of leftmost pixel in span in window coords.
+ * mask - boolean mask indicating which pixels to blend.
+ * In/Out: rgba - pixel values
+ */
+void
+_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan dest[MAX_WIDTH][4];
+
+ /* Check if device driver can do the work */
+ if (ctx->Color.BlendEquation==GL_LOGIC_OP &&
+ !ctx->Color.ColorLogicOpEnabled) {
+ return;
+ }
+
+ /* 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 );
+}
+
+
+
+/*
+ * Apply the blending operator to an array of pixels.
+ * Input: n - number of pixels in span
+ * x, y - array of pixel locations
+ * mask - boolean mask indicating which pixels to blend.
+ * In/Out: rgba - pixel values
+ */
+void
+_mesa_blend_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan dest[PB_SIZE][4];
+
+ /* Check if device driver can do the work */
+ if (ctx->Color.BlendEquation==GL_LOGIC_OP &&
+ !ctx->Color.ColorLogicOpEnabled) {
+ return;
+ }
+
+ /* Read pixels from current color buffer */
+ (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+ if (ctx->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 );
+}
--- /dev/null
+/* $Id: s_blend.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_BLEND_H
+#define S_BLEND_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+
+extern void
+_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_blend_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+
+#endif
--- /dev/null
+/* $Id: s_buffers.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "macros.h"
+#include "mem.h"
+
+#include "s_accum.h"
+#include "s_alphabuf.h"
+#include "s_depth.h"
+#include "s_masking.h"
+#include "s_stencil.h"
+
+
+
+
+/*
+ * Clear the color buffer when glColorMask or glIndexMask is in effect.
+ */
+static void
+clear_color_buffer_with_masking( GLcontext *ctx )
+{
+ const GLint x = ctx->DrawBuffer->Xmin;
+ const GLint y = ctx->DrawBuffer->Ymin;
+ const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+ const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+
+ if (ctx->Visual.RGBAflag) {
+ /* RGBA mode */
+ const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
+ const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
+ const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
+ const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ GLint i;
+ for (i = 0; i < height; i++) {
+ GLchan rgba[MAX_WIDTH][4];
+ GLint j;
+ for (j=0; j<width; j++) {
+ rgba[j][RCOMP] = r;
+ rgba[j][GCOMP] = g;
+ rgba[j][BCOMP] = b;
+ rgba[j][ACOMP] = a;
+ }
+ _mesa_mask_rgba_span( ctx, width, x, y + i, rgba );
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y + i,
+ (CONST GLchan (*)[4]) rgba, NULL );
+ }
+ }
+ else {
+ /* Color index mode */
+ GLuint span[MAX_WIDTH];
+ GLubyte mask[MAX_WIDTH];
+ GLint i, j;
+ MEMSET( mask, 1, width );
+ for (i=0;i<height;i++) {
+ for (j=0;j<width;j++) {
+ span[j] = ctx->Color.ClearIndex;
+ }
+ _mesa_mask_index_span( ctx, width, x, y + i, span );
+ (*ctx->Driver.WriteCI32Span)( ctx, width, x, y + i, span, mask );
+ }
+ }
+}
+
+
+
+/*
+ * Clear a color buffer without index/channel masking.
+ */
+static void
+clear_color_buffer(GLcontext *ctx)
+{
+ const GLint x = ctx->DrawBuffer->Xmin;
+ const GLint y = ctx->DrawBuffer->Ymin;
+ const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+ const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+
+ if (ctx->Visual.RGBAflag) {
+ /* RGBA mode */
+ const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
+ const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
+ const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
+ const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ GLchan span[MAX_WIDTH][4];
+ GLint i;
+
+ ASSERT(*((GLuint *) &ctx->Color.ColorMask) == 0xffffffff);
+
+ for (i = 0; i < width; i++) {
+ span[i][RCOMP] = r;
+ span[i][GCOMP] = g;
+ span[i][BCOMP] = b;
+ span[i][ACOMP] = a;
+ }
+ for (i = 0; i < height; i++) {
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y + i,
+ (CONST GLchan (*)[4]) span, NULL );
+ }
+ }
+ else {
+ /* Color index mode */
+ ASSERT(ctx->Color.IndexMask == ~0);
+ if (ctx->Visual.IndexBits == 8) {
+ /* 8-bit clear */
+ GLubyte span[MAX_WIDTH];
+ GLint i;
+ MEMSET(span, ctx->Color.ClearIndex, width);
+ for (i = 0; i < height; i++) {
+ (*ctx->Driver.WriteCI8Span)( ctx, width, x, y + i, span, NULL );
+ }
+ }
+ else {
+ /* non 8-bit clear */
+ GLuint span[MAX_WIDTH];
+ GLint i;
+ for (i = 0; i < width; i++) {
+ span[i] = ctx->Color.ClearIndex;
+ }
+ for (i = 0; i < height; i++) {
+ (*ctx->Driver.WriteCI32Span)( ctx, width, x, y + i, span, NULL );
+ }
+ }
+ }
+}
+
+
+
+/*
+ * Clear the front/back/left/right color buffers.
+ * This function is usually only called if we need to clear the
+ * buffers with masking.
+ */
+static void
+clear_color_buffers(GLcontext *ctx)
+{
+ const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+ GLuint bufferBit;
+
+ /* loop over four possible dest color buffers */
+ for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+ if (bufferBit & ctx->Color.DrawDestMask) {
+ if (bufferBit == FRONT_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+ (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_LEFT);
+ }
+ else if (bufferBit == FRONT_RIGHT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+ (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_RIGHT);
+ }
+ else if (bufferBit == BACK_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+ (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_LEFT);
+ }
+ else {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+ (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_RIGHT);
+ }
+
+ if (colorMask != 0xffffffff) {
+ clear_color_buffer_with_masking(ctx);
+ }
+ else {
+ clear_color_buffer(ctx);
+ }
+ }
+ }
+
+ /* restore default read/draw buffers */
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
+ (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer );
+}
+
+
+
+void
+_swrast_Clear( GLcontext *ctx, GLbitfield mask,
+ GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+
+#ifdef DEBUG
+ {
+ GLbitfield legalBits = DD_FRONT_LEFT_BIT |
+ DD_FRONT_RIGHT_BIT |
+ DD_BACK_LEFT_BIT |
+ DD_BACK_RIGHT_BIT |
+ DD_DEPTH_BIT |
+ DD_STENCIL_BIT |
+ DD_ACCUM_BIT;
+ assert((mask & (~legalBits)) == 0);
+ }
+#endif
+
+ RENDER_START(ctx);
+
+ /* do software clearing here */
+ if (mask) {
+ if (mask & ctx->Color.DrawDestMask) clear_color_buffers(ctx);
+ if (mask & GL_DEPTH_BUFFER_BIT) _mesa_clear_depth_buffer(ctx);
+ if (mask & GL_ACCUM_BUFFER_BIT) _mesa_clear_accum_buffer(ctx);
+ if (mask & GL_STENCIL_BUFFER_BIT) _mesa_clear_stencil_buffer(ctx);
+ }
+
+ /* clear software-based alpha buffer(s) */
+ if ( (mask & GL_COLOR_BUFFER_BIT)
+ && ctx->DrawBuffer->UseSoftwareAlphaBuffers
+ && ctx->Color.ColorMask[ACOMP]) {
+ _mesa_clear_alpha_buffers( ctx );
+ }
+
+ RENDER_FINISH(ctx);
+}
+
+
+void
+_swrast_alloc_buffers( GLcontext *ctx )
+{
+ /* Reallocate other buffers if needed. */
+ if (ctx->DrawBuffer->UseSoftwareDepthBuffer) {
+ _mesa_alloc_depth_buffer( ctx );
+ }
+ if (ctx->DrawBuffer->UseSoftwareStencilBuffer) {
+ _mesa_alloc_stencil_buffer( ctx );
+ }
+ if (ctx->DrawBuffer->UseSoftwareAccumBuffer) {
+ _mesa_alloc_accum_buffer( ctx );
+ }
+ if (ctx->DrawBuffer->UseSoftwareAlphaBuffers) {
+ _mesa_alloc_alpha_buffers( ctx );
+ }
+}
+
+
--- /dev/null
+/* $Id: s_context.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * 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.
+ */
+
+
+#include "glheader.h"
+
+#include "s_pb.h"
+
+
+GLboolean
+_swrast_create_context( GLcontext *ctx )
+{
+ ctx->PB = gl_alloc_pb();
+ if (!ctx->PB) return GL_FALSE;
+
+ return GL_TRUE;
+}
+
+void
+_swrast_destroy_context( GLcontext *ctx )
+{
+}
+
+
+
+
--- /dev/null
+/* $Id: s_copypix.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "convolve.h"
+#include "feedback.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "pixel.h"
+
+#include "s_depth.h"
+#include "s_imaging.h"
+#include "s_pixeltex.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Determine if there's overlap in an image copy
+ */
+static GLboolean
+regions_overlap(int srcx, int srcy, int dstx, int dsty, int width, int height,
+ float zoomX, float zoomY)
+{
+ if ((srcx > dstx + (width * zoomX) + 1) || (srcx + width + 1 < dstx)) {
+ return GL_FALSE;
+ }
+ else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
+ return GL_FALSE;
+ }
+ else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
+ return GL_FALSE;
+ }
+ else {
+ return GL_TRUE;
+ }
+}
+
+
+
+/*
+ * RGBA copypixels with convolution.
+ */
+static void
+copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
+ GLint width, GLint height, GLint destx, GLint desty)
+{
+ GLdepth zspan[MAX_WIDTH];
+ GLboolean quick_draw;
+ GLint row;
+ GLboolean changeBuffer;
+ GLchan *saveReadAlpha;
+ const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+ const GLuint transferOps = ctx->ImageTransferState;
+ GLfloat *dest, *tmpImage, *convImage;
+
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ /* fill in array of z values */
+ GLdepth z = (GLdepth)
+ (ctx->Current.RasterPos[2] * ctx->Visual.DepthMax);
+ GLint i;
+ for (i = 0; i < width; i++) {
+ zspan[i] = z;
+ }
+ }
+
+ if (ctx->RasterMask == 0
+ && !zoom
+ && destx >= 0
+ && destx + width <= ctx->DrawBuffer->Width) {
+ quick_draw = GL_TRUE;
+ }
+ else {
+ quick_draw = GL_FALSE;
+ }
+
+ /* If read and draw buffer are different we must do buffer switching */
+ saveReadAlpha = ctx->ReadBuffer->Alpha;
+ changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+ || ctx->DrawBuffer != ctx->ReadBuffer;
+
+
+ /* allocate space for GLfloat image */
+ tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!tmpImage) {
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
+ return;
+ }
+ convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!convImage) {
+ FREE(tmpImage);
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
+ return;
+ }
+
+ dest = tmpImage;
+
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+ if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+ else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+ else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+ else
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+ }
+
+ /* read source image */
+ dest = tmpImage;
+ for (row = 0; row < height; row++) {
+ GLchan rgba[MAX_WIDTH][4];
+ GLint i;
+ gl_read_rgba_span(ctx, ctx->ReadBuffer, width, srcx, srcy + row, rgba);
+ /* convert GLchan to GLfloat */
+ for (i = 0; i < width; i++) {
+ *dest++ = (GLfloat) rgba[i][RCOMP] * (1.0F / CHAN_MAXF);
+ *dest++ = (GLfloat) rgba[i][GCOMP] * (1.0F / CHAN_MAXF);
+ *dest++ = (GLfloat) rgba[i][BCOMP] * (1.0F / CHAN_MAXF);
+ *dest++ = (GLfloat) rgba[i][ACOMP] * (1.0F / CHAN_MAXF);
+ }
+ }
+
+ /* read from the draw buffer again (in case of blending) */
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+ ctx->Color.DriverDrawBuffer );
+ ctx->ReadBuffer->Alpha = saveReadAlpha;
+ }
+
+ /* do image transfer ops up until convolution */
+ for (row = 0; row < height; row++) {
+ GLfloat (*rgba)[4] = (GLfloat (*)[4]) tmpImage + row * width * 4;
+
+ /* scale & bias */
+ if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+ _mesa_scale_and_bias_rgba(ctx, width, rgba);
+ }
+ /* color map lookup */
+ if (transferOps & IMAGE_MAP_COLOR_BIT) {
+ _mesa_map_rgba(ctx, width, rgba);
+ }
+ /* GL_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->ColorTable, width, rgba);
+ }
+ }
+
+ /* do convolution */
+ if (ctx->Pixel.Convolution2DEnabled) {
+ _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
+ }
+ else {
+ ASSERT(ctx->Pixel.Separable2DEnabled);
+ _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
+ }
+ FREE(tmpImage);
+
+ /* do remaining image transfer ops */
+ for (row = 0; row < height; row++) {
+ GLfloat (*rgba)[4] = (GLfloat (*)[4]) convImage + row * width * 4;
+
+ /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgba);
+ }
+ /* color matrix */
+ if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
+ _mesa_transform_rgba(ctx, width, rgba);
+ }
+ /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgba);
+ }
+ /* update histogram count */
+ if (transferOps & IMAGE_HISTOGRAM_BIT) {
+ _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgba);
+ }
+ /* update min/max */
+ if (transferOps & IMAGE_MIN_MAX_BIT) {
+ _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgba);
+ }
+ }
+
+ for (row = 0; row < height; row++) {
+ const GLfloat *src = convImage + row * width * 4;
+ GLchan rgba[MAX_WIDTH][4];
+ GLint i, dy;
+
+ /* clamp to [0,1] and convert float back to chan */
+ for (i = 0; i < width; i++) {
+ GLint r = (GLint) (src[i * 4 + RCOMP] * CHAN_MAXF);
+ GLint g = (GLint) (src[i * 4 + GCOMP] * CHAN_MAXF);
+ GLint b = (GLint) (src[i * 4 + BCOMP] * CHAN_MAXF);
+ GLint a = (GLint) (src[i * 4 + ACOMP] * CHAN_MAXF);
+ rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
+ rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
+ }
+
+ 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;
+ /* XXX not sure how multitexture is supposed to work here */
+
+ MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+ for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++) {
+ _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
+ s, t, r, q);
+ gl_texture_pixels(ctx, unit, width, s, t, r, NULL,
+ primary_rgba, rgba);
+ }
+ }
+
+ /* write row to framebuffer */
+
+ dy = desty + row;
+ if (quick_draw && dy >= 0 && dy < ctx->DrawBuffer->Height) {
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, destx, dy,
+ (const GLchan (*)[4])rgba, NULL );
+ }
+ else if (zoom) {
+ gl_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, 0,
+ (const GLchan (*)[4])rgba, desty);
+ }
+ else {
+ gl_write_rgba_span( ctx, width, destx, dy, zspan, 0, rgba, GL_BITMAP );
+ }
+ }
+
+ FREE(convImage);
+}
+
+
+/*
+ * RGBA copypixels
+ */
+static void
+copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
+ GLint width, GLint height, GLint destx, GLint desty)
+{
+ GLdepth zspan[MAX_WIDTH];
+ GLchan rgba[MAX_WIDTH][4];
+ GLchan *tmpImage,*p;
+ GLboolean quick_draw;
+ GLint sy, dy, stepy;
+ GLint i, j;
+ GLboolean changeBuffer;
+ GLchan *saveReadAlpha;
+ const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+ GLint overlapping;
+ const GLuint transferOps = ctx->ImageTransferState;
+
+ if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+ copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty);
+ return;
+ }
+
+ /* Determine if copy should be done bottom-to-top or top-to-bottom */
+ if (srcy < desty) {
+ /* top-down max-to-min */
+ sy = srcy + height - 1;
+ dy = desty + height - 1;
+ stepy = -1;
+ }
+ else {
+ /* bottom-up min-to-max */
+ sy = srcy;
+ dy = desty;
+ stepy = 1;
+ }
+
+ overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+ ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ /* fill in array of z values */
+ GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMax);
+ for (i=0;i<width;i++) {
+ zspan[i] = z;
+ }
+ }
+
+ if (ctx->RasterMask == 0
+ && !zoom
+ && destx >= 0
+ && destx + width <= ctx->DrawBuffer->Width) {
+ quick_draw = GL_TRUE;
+ }
+ else {
+ quick_draw = GL_FALSE;
+ }
+
+ /* If read and draw buffer are different we must do buffer switching */
+ saveReadAlpha = ctx->ReadBuffer->Alpha;
+ changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+ || ctx->DrawBuffer != ctx->ReadBuffer;
+
+ if (overlapping) {
+ GLint ssy = sy;
+ tmpImage = (GLchan *) MALLOC(width * height * sizeof(GLchan) * 4);
+ if (!tmpImage) {
+ gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+ return;
+ }
+ p = tmpImage;
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+ if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+ else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+ else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+ else
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+ }
+ for (j = 0; j < height; j++, ssy += stepy) {
+ gl_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, ssy,
+ (GLchan (*)[4]) p );
+ p += (width * sizeof(GLchan) * 4);
+ }
+ p = tmpImage;
+ }
+ else {
+ tmpImage = NULL; /* silence compiler warnings */
+ p = NULL;
+ }
+
+ for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+ /* Get source pixels */
+ if (overlapping) {
+ /* get from buffered image */
+ MEMCPY(rgba, p, width * sizeof(GLchan) * 4);
+ p += (width * sizeof(GLchan) * 4);
+ }
+ else {
+ /* get from framebuffer */
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+ if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT) {
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+ }
+ else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT) {
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+ }
+ else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT) {
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+ }
+ else {
+ ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+ }
+ }
+ gl_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, sy, rgba );
+ }
+
+ if (changeBuffer) {
+ /* read from the draw buffer again (in case of blending) */
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+ ctx->Color.DriverDrawBuffer );
+ ctx->ReadBuffer->Alpha = saveReadAlpha;
+ }
+
+ if (transferOps) {
+ const GLfloat scale = (1.0F / CHAN_MAXF);
+ GLfloat rgbaFloat[MAX_WIDTH][4];
+ GLuint k;
+ /* convert chan to float */
+ for (k = 0; k < width; k++) {
+ rgbaFloat[k][RCOMP] = (GLfloat) rgba[k][RCOMP] * scale;
+ rgbaFloat[k][GCOMP] = (GLfloat) rgba[k][GCOMP] * scale;
+ rgbaFloat[k][BCOMP] = (GLfloat) rgba[k][BCOMP] * scale;
+ rgbaFloat[k][ACOMP] = (GLfloat) rgba[k][ACOMP] * scale;
+ }
+ /* scale & bias */
+ if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+ _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat);
+ }
+ /* color map lookup */
+ if (transferOps & IMAGE_MAP_COLOR_BIT) {
+ _mesa_map_rgba(ctx, width, rgbaFloat);
+ }
+ /* GL_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->ColorTable, width, rgbaFloat);
+ }
+ /* convolution */
+ if (transferOps & IMAGE_CONVOLUTION_BIT) {
+ /* XXX to do */
+ }
+ /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgbaFloat);
+ }
+ /* color matrix */
+ if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
+ _mesa_transform_rgba(ctx, width, rgbaFloat);
+ }
+ /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
+ if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
+ _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
+ }
+ /* update histogram count */
+ if (transferOps & IMAGE_HISTOGRAM_BIT) {
+ _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
+ }
+ /* update min/max */
+ if (transferOps & IMAGE_MIN_MAX_BIT) {
+ _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
+ }
+ /* clamp to [0,1] and convert float back to chan */
+ for (k = 0; k < width; k++) {
+ GLint r = (GLint) (rgbaFloat[k][RCOMP] * CHAN_MAXF);
+ GLint g = (GLint) (rgbaFloat[k][GCOMP] * CHAN_MAXF);
+ GLint b = (GLint) (rgbaFloat[k][BCOMP] * CHAN_MAXF);
+ GLint a = (GLint) (rgbaFloat[k][ACOMP] * CHAN_MAXF);
+ rgba[k][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
+ rgba[k][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
+ rgba[k][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
+ rgba[k][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
+ }
+ }
+
+ 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;
+ /* XXX not sure how multitexture is supposed to work here */
+
+ MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+ for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++) {
+ _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
+ s, t, r, q);
+ gl_texture_pixels(ctx, unit, width, s, t, r, NULL,
+ primary_rgba, rgba);
+ }
+ }
+
+ if (quick_draw && dy >= 0 && dy < ctx->DrawBuffer->Height) {
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, destx, dy,
+ (const GLchan (*)[4])rgba, NULL );
+ }
+ else if (zoom) {
+ gl_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, 0,
+ (const GLchan (*)[4])rgba, desty);
+ }
+ else {
+ gl_write_rgba_span( ctx, width, destx, dy, zspan, 0, rgba, GL_BITMAP );
+ }
+ }
+
+ if (overlapping)
+ FREE(tmpImage);
+}
+
+
+static void copy_ci_pixels( GLcontext *ctx,
+ GLint srcx, GLint srcy, GLint width, GLint height,
+ GLint destx, GLint desty )
+{
+ GLdepth zspan[MAX_WIDTH];
+ GLuint *tmpImage,*p;
+ GLint sy, dy, stepy;
+ GLint i, j;
+ GLboolean changeBuffer;
+ const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+ const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
+ GLint overlapping;
+
+ /* Determine if copy should be bottom-to-top or top-to-bottom */
+ if (srcy<desty) {
+ /* top-down max-to-min */
+ sy = srcy + height - 1;
+ dy = desty + height - 1;
+ stepy = -1;
+ }
+ else {
+ /* bottom-up min-to-max */
+ sy = srcy;
+ dy = desty;
+ stepy = 1;
+ }
+
+ overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+ ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ /* fill in array of z values */
+ GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMax);
+ for (i=0;i<width;i++) {
+ zspan[i] = z;
+ }
+ }
+
+ /* If read and draw buffer are different we must do buffer switching */
+ changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+ || ctx->DrawBuffer != ctx->ReadBuffer;
+
+ if (overlapping) {
+ GLint ssy = sy;
+ tmpImage = (GLuint *) MALLOC(width * height * sizeof(GLuint));
+ if (!tmpImage) {
+ gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+ return;
+ }
+ p = tmpImage;
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+ }
+ for (j = 0; j < height; j++, ssy += stepy) {
+ gl_read_index_span( ctx, ctx->ReadBuffer, width, srcx, ssy, p );
+ p += width;
+ }
+ p = tmpImage;
+ }
+ else {
+ tmpImage = NULL; /* silence compiler warning */
+ p = NULL;
+ }
+
+ for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+ GLuint indexes[MAX_WIDTH];
+ if (overlapping) {
+ MEMCPY(indexes, p, width * sizeof(GLuint));
+ p += width;
+ }
+ else {
+ if (changeBuffer) {
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+ ctx->Pixel.DriverReadBuffer );
+ }
+ gl_read_index_span( ctx, ctx->ReadBuffer, width, srcx, sy, indexes );
+ }
+
+ if (changeBuffer) {
+ /* set read buffer back to draw buffer (in case of logicops) */
+ (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+ ctx->Color.DriverDrawBuffer );
+ }
+
+ if (shift_or_offset) {
+ _mesa_shift_and_offset_ci( ctx, width, indexes );
+ }
+ if (ctx->Pixel.MapColorFlag) {
+ _mesa_map_ci( ctx, width, indexes );
+ }
+
+ if (zoom) {
+ gl_write_zoomed_index_span( ctx, width, destx, dy, zspan, 0, indexes, desty );
+ }
+ else {
+ gl_write_index_span(ctx, width, destx, dy, zspan, 0, indexes, GL_BITMAP);
+ }
+ }
+
+ if (overlapping)
+ FREE(tmpImage);
+}
+
+
+
+/*
+ * TODO: Optimize!!!!
+ */
+static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
+ GLint width, GLint height,
+ GLint destx, GLint desty )
+{
+ GLfloat depth[MAX_WIDTH];
+ GLdepth zspan[MAX_WIDTH];
+ GLfloat *p, *tmpImage;
+ GLuint indexes[MAX_WIDTH];
+ GLchan rgba[MAX_WIDTH][4];
+ GLint sy, dy, stepy;
+ GLint i, j;
+ const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+ GLint overlapping;
+
+ if (!ctx->ReadBuffer->DepthBuffer || !ctx->DrawBuffer->DepthBuffer) {
+ gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
+ return;
+ }
+
+ /* Determine if copy should be bottom-to-top or top-to-bottom */
+ if (srcy<desty) {
+ /* top-down max-to-min */
+ sy = srcy + height - 1;
+ dy = desty + height - 1;
+ stepy = -1;
+ }
+ else {
+ /* bottom-up min-to-max */
+ sy = srcy;
+ dy = desty;
+ stepy = 1;
+ }
+
+ overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+ ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+ /* setup colors or indexes */
+ if (ctx->Visual.RGBAflag) {
+ GLuint *rgba32 = (GLuint *) rgba;
+ GLuint color = *(GLuint*)( ctx->Current.Color );
+ for (i = 0; i < width; i++) {
+ rgba32[i] = color;
+ }
+ }
+ else {
+ for (i = 0; i < width; i++) {
+ indexes[i] = ctx->Current.Index;
+ }
+ }
+
+ if (overlapping) {
+ GLint ssy = sy;
+ tmpImage = (GLfloat *) MALLOC(width * height * sizeof(GLfloat));
+ if (!tmpImage) {
+ gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+ return;
+ }
+ p = tmpImage;
+ for (j = 0; j < height; j++, ssy += stepy) {
+ _mesa_read_depth_span_float(ctx, width, srcx, ssy, p);
+ p += width;
+ }
+ p = tmpImage;
+ }
+ else {
+ tmpImage = NULL; /* silence compiler warning */
+ p = NULL;
+ }
+
+ for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+ if (overlapping) {
+ MEMCPY(depth, p, width * sizeof(GLfloat));
+ p += width;
+ }
+ else {
+ _mesa_read_depth_span_float(ctx, width, srcx, sy, depth);
+ }
+
+ for (i = 0; i < width; i++) {
+ GLfloat d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+ zspan[i] = (GLdepth) (CLAMP(d, 0.0F, 1.0F) * ctx->Visual.DepthMax);
+ }
+
+ if (ctx->Visual.RGBAflag) {
+ if (zoom) {
+ gl_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, 0,
+ (const GLchan (*)[4])rgba, desty );
+ }
+ else {
+ gl_write_rgba_span( ctx, width, destx, dy, zspan, 0,
+ rgba, GL_BITMAP);
+ }
+ }
+ else {
+ if (zoom) {
+ gl_write_zoomed_index_span( ctx, width, destx, dy,
+ zspan, 0, indexes, desty );
+ }
+ else {
+ gl_write_index_span( ctx, width, destx, dy,
+ zspan, 0, indexes, GL_BITMAP );
+ }
+ }
+ }
+
+ if (overlapping)
+ FREE(tmpImage);
+}
+
+
+
+static void copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
+ GLint width, GLint height,
+ GLint destx, GLint desty )
+{
+ GLint sy, dy, stepy;
+ GLint j;
+ GLstencil *p, *tmpImage;
+ const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+ const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
+ GLint overlapping;
+
+ if (!ctx->DrawBuffer->Stencil || !ctx->ReadBuffer->Stencil) {
+ gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
+ return;
+ }
+
+ /* Determine if copy should be bottom-to-top or top-to-bottom */
+ if (srcy < desty) {
+ /* top-down max-to-min */
+ sy = srcy + height - 1;
+ dy = desty + height - 1;
+ stepy = -1;
+ }
+ else {
+ /* bottom-up min-to-max */
+ sy = srcy;
+ dy = desty;
+ stepy = 1;
+ }
+
+ overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+ ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+ if (overlapping) {
+ GLint ssy = sy;
+ tmpImage = (GLstencil *) MALLOC(width * height * sizeof(GLstencil));
+ if (!tmpImage) {
+ gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+ return;
+ }
+ p = tmpImage;
+ for (j = 0; j < height; j++, ssy += stepy) {
+ _mesa_read_stencil_span( ctx, width, srcx, ssy, p );
+ p += width;
+ }
+ p = tmpImage;
+ }
+ else {
+ tmpImage = NULL; /* silence compiler warning */
+ p = NULL;
+ }
+
+ for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+ GLstencil stencil[MAX_WIDTH];
+
+ if (overlapping) {
+ MEMCPY(stencil, p, width * sizeof(GLstencil));
+ p += width;
+ }
+ else {
+ _mesa_read_stencil_span( ctx, width, srcx, sy, stencil );
+ }
+
+ if (shift_or_offset) {
+ _mesa_shift_and_offset_stencil( ctx, width, stencil );
+ }
+ if (ctx->Pixel.MapStencilFlag) {
+ _mesa_map_stencil( ctx, width, stencil );
+ }
+
+ if (zoom) {
+ gl_write_zoomed_stencil_span( ctx, width, destx, dy, stencil, desty );
+ }
+ else {
+ _mesa_write_stencil_span( ctx, width, destx, dy, stencil );
+ }
+ }
+
+ if (overlapping)
+ FREE(tmpImage);
+}
+
+
+
+
+void
+_swrast_CopyPixels( GLcontext *ctx,
+ GLint srcx, GLint srcy, GLsizei width, GLsizei height,
+ GLint destx, GLint desty,
+ GLenum type )
+{
+ if (type == GL_COLOR && ctx->Visual.RGBAflag) {
+ copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
+ }
+ else if (type == GL_COLOR && !ctx->Visual.RGBAflag) {
+ copy_ci_pixels( ctx, srcx, srcy, width, height, destx, desty );
+ }
+ else if (type == GL_DEPTH) {
+ copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
+ }
+ else if (type == GL_STENCIL) {
+ copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
+ }
+ else {
+ gl_error( ctx, GL_INVALID_ENUM, "glCopyPixels" );
+ }
+}
--- /dev/null
+/* $Id: s_depth.c,v 1.1 2000/10/31 18:00:04 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 "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_depth.h"
+#include "s_pb.h"
+
+
+
+
+/*
+ * Return address of depth buffer value for given window coord.
+ */
+GLvoid *
+_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y)
+{
+ if (ctx->Visual.DepthBits <= 16)
+ return (GLushort *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
+ else
+ return (GLuint *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
+}
+
+
+#define Z_ADDRESS16( CTX, X, Y ) \
+ ( ((GLushort *) (CTX)->DrawBuffer->DepthBuffer) \
+ + (CTX)->DrawBuffer->Width * (Y) + (X) )
+
+#define Z_ADDRESS32( CTX, X, Y ) \
+ ( ((GLuint *) (CTX)->DrawBuffer->DepthBuffer) \
+ + (CTX)->DrawBuffer->Width * (Y) + (X) )
+
+
+
+/**********************************************************************/
+/***** Depth Testing Functions *****/
+/**********************************************************************/
+
+
+/*
+ * Do depth test for an array of fragments. This is used both for
+ * software and hardware Z buffers.
+ * Input: zbuffer - array of z values in the zbuffer
+ * z - array of fragment z values
+ * Return: number of fragments which pass the test.
+ */
+static GLuint
+depth_test_span16( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLushort zbuffer[], const GLdepth z[], GLubyte mask[] )
+{
+ GLuint passed = 0;
+
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Depth.Func) {
+ case GL_LESS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GREATER:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_EQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer or mask */
+ passed = n;
+ }
+ break;
+ case GL_NEVER:
+ BZERO(mask, n * sizeof(GLubyte));
+ break;
+ default:
+ gl_problem(ctx, "Bad depth func in depth_test_span16");
+ }
+
+ return passed;
+}
+
+
+static GLuint
+depth_test_span32( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLuint zbuffer[], const GLdepth z[], GLubyte mask[] )
+{
+ GLuint passed = 0;
+
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Depth.Func) {
+ case GL_LESS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GREATER:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_EQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ /* pass */
+ passed++;
+ }
+ else {
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ zbuffer[i] = z[i];
+ passed++;
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer or mask */
+ passed = n;
+ }
+ break;
+ case GL_NEVER:
+ BZERO(mask, n * sizeof(GLubyte));
+ break;
+ default:
+ gl_problem(ctx, "Bad depth func in depth_test_span32");
+ }
+
+ return passed;
+}
+
+
+
+/*
+ * Apply depth test to span of fragments. Hardware or software z buffer.
+ */
+GLuint
+_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] )
+{
+ if (ctx->Driver.ReadDepthSpan) {
+ /* hardware-based depth buffer */
+ GLdepth zbuffer[MAX_WIDTH];
+ GLuint passed;
+ (*ctx->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
+ passed = depth_test_span32(ctx, n, x, y, zbuffer, z, mask);
+ assert(ctx->Driver.WriteDepthSpan);
+ (*ctx->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, mask);
+ return passed;
+ }
+ else {
+ /* software depth buffer */
+ if (ctx->Visual.DepthBits <= 16) {
+ GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, x, y);
+ GLuint passed = depth_test_span16(ctx, n, x, y, zptr, z, mask);
+ return passed;
+ }
+ else {
+ GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, x, y);
+ GLuint passed = depth_test_span32(ctx, n, x, y, zptr, z, mask);
+ return passed;
+ }
+ }
+}
+
+
+
+
+/*
+ * Do depth testing for an array of fragments using software Z buffer.
+ */
+static void
+software_depth_test_pixels16( GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] )
+{
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Depth.Func) {
+ case GL_LESS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] < *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] < *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] <= *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] <= *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] >= *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] >= *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GREATER:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] > *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] > *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] != *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] != *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_EQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] == *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ if (z[i] == *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+ *zptr = z[i];
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer or mask */
+ }
+ break;
+ case GL_NEVER:
+ /* depth test never passes */
+ BZERO(mask, n * sizeof(GLubyte));
+ break;
+ default:
+ gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
+ }
+}
+
+
+
+/*
+ * Do depth testing for an array of fragments using software Z buffer.
+ */
+static void
+software_depth_test_pixels32( GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] )
+{
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Depth.Func) {
+ case GL_LESS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] < *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] < *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] <= *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] <= *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] >= *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] >= *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GREATER:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] > *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] > *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] != *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] != *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_EQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] == *zptr) {
+ /* pass */
+ *zptr = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ if (z[i] == *zptr) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+ *zptr = z[i];
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer or mask */
+ }
+ break;
+ case GL_NEVER:
+ /* depth test never passes */
+ BZERO(mask, n * sizeof(GLubyte));
+ break;
+ default:
+ gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
+ }
+}
+
+
+
+/*
+ * Do depth testing for an array of pixels using hardware Z buffer.
+ * Input/output: zbuffer - array of depth values from Z buffer
+ * Input: z - array of fragment z values.
+ */
+static void
+hardware_depth_test_pixels( GLcontext *ctx, GLuint n, GLdepth zbuffer[],
+ const GLdepth z[], GLubyte mask[] )
+{
+ /* switch cases ordered from most frequent to less frequent */
+ switch (ctx->Depth.Func) {
+ case GL_LESS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] < zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] <= zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] >= zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_GREATER:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] > zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] != zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_EQUAL:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ /* pass */
+ zbuffer[i] = z[i];
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ if (z[i] == zbuffer[i]) {
+ /* pass */
+ }
+ else {
+ /* fail */
+ mask[i] = 0;
+ }
+ }
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ if (ctx->Depth.Mask) {
+ /* Update Z buffer */
+ GLuint i;
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ zbuffer[i] = z[i];
+ }
+ }
+ }
+ else {
+ /* Don't update Z buffer or mask */
+ }
+ break;
+ case GL_NEVER:
+ /* depth test never passes */
+ BZERO(mask, n * sizeof(GLubyte));
+ break;
+ default:
+ gl_problem(ctx, "Bad depth func in hardware_depth_test_pixels");
+ }
+}
+
+
+
+void
+_mesa_depth_test_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] )
+{
+ if (ctx->Driver.ReadDepthPixels) {
+ /* read depth values from hardware Z buffer */
+ GLdepth zbuffer[PB_SIZE];
+ (*ctx->Driver.ReadDepthPixels)(ctx, n, x, y, zbuffer);
+
+ hardware_depth_test_pixels( ctx, n, zbuffer, z, mask );
+
+ /* update hardware Z buffer with new values */
+ assert(ctx->Driver.WriteDepthPixels);
+ (*ctx->Driver.WriteDepthPixels)(ctx, n, x, y, zbuffer, mask );
+ }
+ else {
+ /* software depth testing */
+ if (ctx->Visual.DepthBits <= 16)
+ software_depth_test_pixels16(ctx, n, x, y, z, mask);
+ else
+ software_depth_test_pixels32(ctx, n, x, y, z, mask);
+ }
+}
+
+
+
+
+
+/**********************************************************************/
+/***** Read Depth Buffer *****/
+/**********************************************************************/
+
+
+/*
+ * Read a span of depth values from the depth buffer.
+ * This function does clipping before calling the device driver function.
+ */
+void
+_mesa_read_depth_span( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLdepth depth[] )
+{
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ GLint i;
+ for (i = 0; i < n; i++)
+ depth[i] = 0;
+ return;
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[i] = 0;
+ x = 0;
+ n -= dx;
+ depth += dx;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[n - i - 1] = 0;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
+ if (ctx->DrawBuffer->DepthBuffer) {
+ /* read from software depth buffer */
+ if (ctx->Visual.DepthBits <= 16) {
+ const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = zptr[i];
+ }
+ }
+ else {
+ const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = zptr[i];
+ }
+ }
+ }
+ else if (ctx->Driver.ReadDepthSpan) {
+ /* read from hardware depth buffer */
+ (*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, depth );
+ }
+ else {
+ /* no depth buffer */
+ BZERO(depth, n * sizeof(GLfloat));
+ }
+
+}
+
+
+
+
+/*
+ * Return a span of depth values from the depth buffer as floats in [0,1].
+ * This is used for both hardware and software depth buffers.
+ * Input: n - how many pixels
+ * x,y - location of first pixel
+ * Output: depth - the array of depth values
+ */
+void
+_mesa_read_depth_span_float( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLfloat depth[] )
+{
+ const GLfloat scale = 1.0F / ctx->Visual.DepthMaxF;
+
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ GLint i;
+ for (i = 0; i < n; i++)
+ depth[i] = 0.0F;
+ return;
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[i] = 0.0F;
+ n -= dx;
+ x = 0;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[n - i - 1] = 0.0F;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
+ if (ctx->DrawBuffer->DepthBuffer) {
+ /* read from software depth buffer */
+ if (ctx->Visual.DepthBits <= 16) {
+ const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = (GLfloat) zptr[i] * scale;
+ }
+ }
+ else {
+ const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = (GLfloat) zptr[i] * scale;
+ }
+ }
+ }
+ else if (ctx->Driver.ReadDepthSpan) {
+ /* read from hardware depth buffer */
+ GLdepth d[MAX_WIDTH];
+ GLuint i;
+ assert(n <= MAX_WIDTH);
+ (*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, d );
+ for (i = 0; i < n; i++) {
+ depth[i] = d[i] * scale;
+ }
+ }
+ else {
+ /* no depth buffer */
+ BZERO(depth, n * sizeof(GLfloat));
+ }
+}
+
+
+
+/**********************************************************************/
+/***** Allocate and Clear Depth Buffer *****/
+/**********************************************************************/
+
+
+
+/*
+ * Allocate a new depth buffer. If there's already a depth buffer allocated
+ * it will be free()'d. The new depth buffer will be uniniitalized.
+ * This function is only called through Driver.alloc_depth_buffer.
+ */
+void
+_mesa_alloc_depth_buffer( GLcontext *ctx )
+{
+ /* deallocate current depth buffer if present */
+ if (ctx->DrawBuffer->UseSoftwareDepthBuffer) {
+ GLint bytesPerValue;
+
+ if (ctx->DrawBuffer->DepthBuffer) {
+ FREE(ctx->DrawBuffer->DepthBuffer);
+ ctx->DrawBuffer->DepthBuffer = NULL;
+ }
+
+ /* allocate new depth buffer, but don't initialize it */
+ if (ctx->Visual.DepthBits <= 16)
+ bytesPerValue = sizeof(GLushort);
+ else
+ bytesPerValue = sizeof(GLuint);
+
+ ctx->DrawBuffer->DepthBuffer = MALLOC( ctx->DrawBuffer->Width
+ * ctx->DrawBuffer->Height
+ * bytesPerValue );
+
+ if (!ctx->DrawBuffer->DepthBuffer) {
+ /* out of memory */
+ ctx->Depth.Test = GL_FALSE;
+ ctx->NewState |= _NEW_DEPTH;
+ gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
+ }
+ }
+}
+
+
+
+
+/*
+ * Clear the depth buffer. If the depth buffer doesn't exist yet we'll
+ * allocate it now.
+ * This function is only called through Driver.clear_depth_buffer.
+ */
+void
+_mesa_clear_depth_buffer( GLcontext *ctx )
+{
+ if (ctx->Visual.DepthBits == 0
+ || !ctx->DrawBuffer->DepthBuffer
+ || !ctx->Depth.Mask) {
+ /* no depth buffer, or writing to it is disabled */
+ return;
+ }
+
+ /* The loops in this function have been written so the IRIX 5.3
+ * C compiler can unroll them. Hopefully other compilers can too!
+ */
+
+ if (ctx->Scissor.Enabled) {
+ /* only clear scissor region */
+ if (ctx->Visual.DepthBits <= 16) {
+ const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual.DepthMax);
+ const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+ const GLint width = ctx->DrawBuffer->Width;
+ GLushort *dRow = (GLushort *) ctx->DrawBuffer->DepthBuffer
+ + ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
+ GLint i, j;
+ for (i = 0; i < rows; i++) {
+ for (j = 0; j < width; j++) {
+ dRow[j] = clearValue;
+ }
+ dRow += width;
+ }
+ }
+ else {
+ const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual.DepthMax);
+ const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+ const GLint width = ctx->DrawBuffer->Width;
+ GLuint *dRow = (GLuint *) ctx->DrawBuffer->DepthBuffer
+ + ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
+ GLint i, j;
+ for (i = 0; i < rows; i++) {
+ for (j = 0; j < width; j++) {
+ dRow[j] = clearValue;
+ }
+ dRow += width;
+ }
+ }
+ }
+ else {
+ /* clear whole buffer */
+ if (ctx->Visual.DepthBits <= 16) {
+ const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual.DepthMax);
+ if ((clearValue & 0xff) == (clearValue >> 8)) {
+ if (clearValue == 0) {
+ BZERO(ctx->DrawBuffer->DepthBuffer,
+ 2*ctx->DrawBuffer->Width*ctx->DrawBuffer->Height);
+ }
+ else {
+ /* lower and upper bytes of clear_value are same, use MEMSET */
+ MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
+ 2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
+ }
+ }
+ else {
+ GLushort *d = (GLushort *) ctx->DrawBuffer->DepthBuffer;
+ GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ while (n >= 16) {
+ d[0] = clearValue; d[1] = clearValue;
+ d[2] = clearValue; d[3] = clearValue;
+ d[4] = clearValue; d[5] = clearValue;
+ d[6] = clearValue; d[7] = clearValue;
+ d[8] = clearValue; d[9] = clearValue;
+ d[10] = clearValue; d[11] = clearValue;
+ d[12] = clearValue; d[13] = clearValue;
+ d[14] = clearValue; d[15] = clearValue;
+ d += 16;
+ n -= 16;
+ }
+ while (n > 0) {
+ *d++ = clearValue;
+ n--;
+ }
+ }
+ }
+ else {
+ /* >16 bit depth buffer */
+ const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual.DepthMax);
+ if (clearValue == 0) {
+ BZERO(ctx->DrawBuffer->DepthBuffer,
+ ctx->DrawBuffer->Width*ctx->DrawBuffer->Height*sizeof(GLuint));
+ }
+ else {
+ GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ GLuint *d = (GLuint *) ctx->DrawBuffer->DepthBuffer;
+ while (n >= 16) {
+ d[0] = clearValue; d[1] = clearValue;
+ d[2] = clearValue; d[3] = clearValue;
+ d[4] = clearValue; d[5] = clearValue;
+ d[6] = clearValue; d[7] = clearValue;
+ d[8] = clearValue; d[9] = clearValue;
+ d[10] = clearValue; d[11] = clearValue;
+ d[12] = clearValue; d[13] = clearValue;
+ d[14] = clearValue; d[15] = clearValue;
+ d += 16;
+ n -= 16;
+ }
+ while (n > 0) {
+ *d++ = clearValue;
+ n--;
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/* $Id: s_depth.h,v 1.1 2000/10/31 18:00:04 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.
+ */
+
+
+#ifndef S_DEPTH_H
+#define S_DEPTH_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern GLvoid *
+_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y);
+
+
+extern GLuint
+_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] );
+
+extern void
+_mesa_depth_test_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] );
+
+
+extern void
+_mesa_read_depth_span( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLdepth depth[] );
+
+
+extern void
+_mesa_read_depth_span_float( GLcontext *ctx, GLint n, GLint x, GLint y,
+ GLfloat depth[] );
+
+
+extern void
+_mesa_alloc_depth_buffer( GLcontext* ctx );
+
+
+extern void
+_mesa_clear_depth_buffer( GLcontext* ctx );
+
+
+
+#endif
--- /dev/null
+/* $Id: s_drawpix.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "convolve.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "pixel.h"
+
+#include "s_pixeltex.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Given the dest position, size and skipPixels and skipRows values
+ * for a glDrawPixels command, perform clipping of the image bounds
+ * so the result lies withing the context's buffer bounds.
+ * Return: GL_TRUE if image is ready for drawing
+ * GL_FALSE if image was completely clipped away (draw nothing)
+ */
+GLboolean
+_mesa_clip_pixelrect(const GLcontext *ctx,
+ GLint *destX, GLint *destY,
+ GLsizei *width, GLsizei *height,
+ GLint *skipPixels, GLint *skipRows)
+{
+ const GLframebuffer *buffer = ctx->DrawBuffer;
+
+ /* left clipping */
+ if (*destX < buffer->Xmin) {
+ *skipPixels += (buffer->Xmin - *destX);
+ *width -= (buffer->Xmin - *destX);
+ *destX = buffer->Xmin;
+ }
+ /* right clipping */
+ if (*destX + *width > buffer->Xmax)
+ *width -= (*destX + *width - buffer->Xmax);
+
+ if (*width <= 0)
+ return GL_FALSE;
+
+ /* bottom clipping */
+ if (*destY < buffer->Ymin) {
+ *skipRows += (buffer->Ymin - *destY);
+ *height -= (buffer->Ymin - *destY);
+ *destY = buffer->Ymin;
+ }
+ /* top clipping */
+ if (*destY + *height > buffer->Ymax)
+ *height -= (*destY + *height - buffer->Ymax);
+
+ if (*height <= 0)
+ return GL_TRUE;
+
+ return GL_TRUE;
+}
+
+
+
+/*
+ * Try to do a fast and simple RGB(a) glDrawPixels.
+ * Return: GL_TRUE if success, GL_FALSE if slow path must be used instead
+ */
+static GLboolean
+fast_draw_pixels(GLcontext *ctx, GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type, const GLvoid *pixels)
+{
+ const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
+ GLchan rgb[MAX_WIDTH][3];
+ GLchan rgba[MAX_WIDTH][4];
+
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glDrawPixels",
+ GL_FALSE);
+
+
+ if (!ctx->Current.RasterPosValid) {
+ return GL_TRUE; /* no-op */
+ }
+
+ if ((ctx->RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0
+ && ctx->Texture.ReallyEnabled == 0
+ && unpack->Alignment == 1
+ && !unpack->SwapBytes
+ && !unpack->LsbFirst) {
+
+ GLint destX = x;
+ GLint destY = y;
+ GLint drawWidth = width; /* actual width drawn */
+ GLint drawHeight = height; /* actual height drawn */
+ GLint skipPixels = unpack->SkipPixels;
+ GLint skipRows = unpack->SkipRows;
+ GLint rowLength;
+ GLdepth zSpan[MAX_WIDTH]; /* only used when zooming */
+ GLint zoomY0 = 0;
+
+ if (unpack->RowLength > 0)
+ rowLength = unpack->RowLength;
+ else
+ rowLength = width;
+
+ /* If we're not using pixel zoom then do all clipping calculations
+ * now. Otherwise, we'll let the gl_write_zoomed_*_span() functions
+ * handle the clipping.
+ */
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ /* horizontal clipping */
+ if (destX < ctx->DrawBuffer->Xmin) {
+ skipPixels += (ctx->DrawBuffer->Xmin - destX);
+ drawWidth -= (ctx->DrawBuffer->Xmin - destX);
+ destX = ctx->DrawBuffer->Xmin;
+ }
+ if (destX + drawWidth > ctx->DrawBuffer->Xmax)
+ drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax);
+ if (drawWidth <= 0)
+ return GL_TRUE;
+
+ /* vertical clipping */
+ if (destY < ctx->DrawBuffer->Ymin) {
+ skipRows += (ctx->DrawBuffer->Ymin - destY);
+ drawHeight -= (ctx->DrawBuffer->Ymin - destY);
+ destY = ctx->DrawBuffer->Ymin;
+ }
+ if (destY + drawHeight > ctx->DrawBuffer->Ymax)
+ drawHeight -= (destY + drawHeight - ctx->DrawBuffer->Ymax);
+ if (drawHeight <= 0)
+ return GL_TRUE;
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down image */
+ /* horizontal clipping */
+ if (destX < ctx->DrawBuffer->Xmin) {
+ skipPixels += (ctx->DrawBuffer->Xmin - destX);
+ drawWidth -= (ctx->DrawBuffer->Xmin - destX);
+ destX = ctx->DrawBuffer->Xmin;
+ }
+ if (destX + drawWidth > ctx->DrawBuffer->Xmax)
+ drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax);
+ if (drawWidth <= 0)
+ return GL_TRUE;
+
+ /* vertical clipping */
+ if (destY > ctx->DrawBuffer->Ymax) {
+ skipRows += (destY - ctx->DrawBuffer->Ymax);
+ drawHeight -= (destY - ctx->DrawBuffer->Ymax);
+ destY = ctx->DrawBuffer->Ymax;
+ }
+ if (destY - drawHeight < ctx->DrawBuffer->Ymin)
+ drawHeight -= (ctx->DrawBuffer->Ymin - (destY - drawHeight));
+ if (drawHeight <= 0)
+ return GL_TRUE;
+ }
+ else {
+ /* setup array of fragment Z value to pass to zoom function */
+ GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF);
+ GLint i;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (i=0; i<drawWidth; i++)
+ zSpan[i] = z;
+
+ /* save Y value of first row */
+ zoomY0 = (GLint) (ctx->Current.RasterPos[1] + 0.5F);
+ }
+
+
+ /*
+ * Ready to draw!
+ * The window region at (destX, destY) of size (drawWidth, drawHeight)
+ * will be written to.
+ * We'll take pixel data from buffer pointed to by "pixels" but we'll
+ * skip "skipRows" rows and skip "skipPixels" pixels/row.
+ */
+
+ if (format == GL_RGBA && type == CHAN_TYPE
+ && ctx->ImageTransferState==0) {
+ if (ctx->Visual.RGBAflag) {
+ GLchan *src = (GLchan *) pixels
+ + (skipRows * rowLength + skipPixels) * 4;
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ /* no zooming */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (void *) src, NULL);
+ src += rowLength * 4;
+ destY++;
+ }
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ destY--;
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (void *) src, NULL);
+ src += rowLength * 4;
+ }
+ }
+ else {
+ /* with zooming */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+ zSpan, 0, (void *) src, zoomY0);
+ src += rowLength * 4;
+ destY++;
+ }
+ }
+ }
+ return GL_TRUE;
+ }
+ else if (format == GL_RGB && type == CHAN_TYPE
+ && ctx->ImageTransferState == 0) {
+ if (ctx->Visual.RGBAflag) {
+ GLchan *src = (GLchan *) pixels
+ + (skipRows * rowLength + skipPixels) * 3;
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+ (void *) src, NULL);
+ src += rowLength * 3;
+ destY++;
+ }
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ destY--;
+ (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+ (void *) src, NULL);
+ src += rowLength * 3;
+ }
+ }
+ else {
+ /* with zooming */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ gl_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
+ zSpan, 0, (void *) src, zoomY0);
+ src += rowLength * 3;
+ destY++;
+ }
+ }
+ }
+ return GL_TRUE;
+ }
+ else if (format == GL_LUMINANCE && type == CHAN_TYPE
+ && ctx->ImageTransferState==0) {
+ if (ctx->Visual.RGBAflag) {
+ GLchan *src = (GLchan *) pixels
+ + (skipRows * rowLength + skipPixels);
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ /* no zooming */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLint i;
+ for (i=0;i<drawWidth;i++) {
+ rgb[i][0] = src[i];
+ rgb[i][1] = src[i];
+ rgb[i][2] = src[i];
+ }
+ (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+ (void *) rgb, NULL);
+ src += rowLength;
+ destY++;
+ }
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLint i;
+ for (i=0;i<drawWidth;i++) {
+ rgb[i][0] = src[i];
+ rgb[i][1] = src[i];
+ rgb[i][2] = src[i];
+ }
+ destY--;
+ (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+ (void *) rgb, NULL);
+ src += rowLength;
+ }
+ }
+ else {
+ /* with zooming */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLint i;
+ for (i=0;i<drawWidth;i++) {
+ rgb[i][0] = src[i];
+ rgb[i][1] = src[i];
+ rgb[i][2] = src[i];
+ }
+ gl_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
+ zSpan, 0, (void *) rgb, zoomY0);
+ src += rowLength;
+ destY++;
+ }
+ }
+ }
+ return GL_TRUE;
+ }
+ else if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE
+ && ctx->ImageTransferState == 0) {
+ if (ctx->Visual.RGBAflag) {
+ GLchan *src = (GLchan *) pixels
+ + (skipRows * rowLength + skipPixels)*2;
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ /* no zooming */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLint i;
+ GLchan *ptr = src;
+ for (i=0;i<drawWidth;i++) {
+ rgba[i][0] = *ptr;
+ rgba[i][1] = *ptr;
+ rgba[i][2] = *ptr++;
+ rgba[i][3] = *ptr++;
+ }
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (void *) rgba, NULL);
+ src += rowLength*2;
+ destY++;
+ }
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLint i;
+ GLchan *ptr = src;
+ for (i=0;i<drawWidth;i++) {
+ rgba[i][0] = *ptr;
+ rgba[i][1] = *ptr;
+ rgba[i][2] = *ptr++;
+ rgba[i][3] = *ptr++;
+ }
+ destY--;
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (void *) rgba, NULL);
+ src += rowLength*2;
+ }
+ }
+ else {
+ /* with zooming */
+ GLint row;
+ ASSERT(drawWidth < MAX_WIDTH);
+ for (row=0; row<drawHeight; row++) {
+ GLchan *ptr = src;
+ GLint i;
+ for (i=0;i<drawWidth;i++) {
+ rgba[i][0] = *ptr;
+ rgba[i][1] = *ptr;
+ rgba[i][2] = *ptr++;
+ rgba[i][3] = *ptr++;
+ }
+ gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+ zSpan, 0, (void *) rgba, zoomY0);
+ src += rowLength*2;
+ destY++;
+ }
+ }
+ }
+ return GL_TRUE;
+ }
+ else if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) {
+ GLubyte *src = (GLubyte *) pixels + skipRows * rowLength + skipPixels;
+ if (ctx->Visual.RGBAflag) {
+ /* convert CI data to RGBA */
+ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+ /* no zooming */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ ASSERT(drawWidth < MAX_WIDTH);
+ _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (const GLchan (*)[4]) rgba,
+ NULL);
+ src += rowLength;
+ destY++;
+ }
+ return GL_TRUE;
+ }
+ else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+ /* upside-down */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ ASSERT(drawWidth < MAX_WIDTH);
+ _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+ destY--;
+ (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+ (const GLchan (*)[4]) rgba,
+ NULL);
+ src += rowLength;
+ }
+ return GL_TRUE;
+ }
+ else {
+ /* with zooming */
+ GLint row;
+ for (row=0; row<drawHeight; row++) {
+ ASSERT(drawWidth < MAX_WIDTH);
+ _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+ gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+ zSpan, 0, (void *) rgba, zoomY0);
+ src += rowLength;
+ destY++;
+ }
+ return GL_TRUE;
+ }
+ }
+ 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) {
+ /* no zooming */
+ for (row=0; row<drawHeight; row++) {
+ (*ctx->Driver.WriteCI8Span)(ctx, drawWidth, destX, destY,
+ src, NULL);
+ src += rowLength;
+ destY++;
+ }
+ return GL_TRUE;
+ }
+ else {
+ /* with zooming */
+ return GL_FALSE;
+ }
+ }
+ }
+ else {
+ /* can't handle this pixel format and/or data type here */
+ return GL_FALSE;
+ }
+ }
+
+ /* can't do a simple draw, have to use slow path */
+ return GL_FALSE;
+}
+
+
+
+/*
+ * Do glDrawPixels of index pixels.
+ */
+static void
+draw_index_pixels( GLcontext *ctx, GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, const GLvoid *pixels )
+{
+ const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+ const GLint desty = y;
+ GLint row, drawWidth;
+ GLdepth zspan[MAX_WIDTH];
+
+ drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ /* Fragment depth values */
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ GLdepth zval = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF);
+ GLint i;
+ for (i = 0; i < drawWidth; i++) {
+ zspan[i] = zval;
+ }
+ }
+
+ /*
+ * General solution
+ */
+ for (row = 0; row < height; row++, y++) {
+ GLuint indexes[MAX_WIDTH];
+ const GLvoid *source = _mesa_image_address(&ctx->Unpack,
+ 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);
+ if (zoom) {
+ gl_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, 0, indexes, desty);
+ }
+ else {
+ gl_write_index_span(ctx, drawWidth, x, y, zspan, 0, indexes, GL_BITMAP);
+ }
+ }
+}
+
+
+
+/*
+ * Do glDrawPixels of stencil image. The image datatype may either
+ * be GLubyte or GLbitmap.
+ */
+static void
+draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, const GLvoid *pixels )
+{
+ const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+ const GLint desty = y;
+ GLint row, drawWidth;
+
+ if (type != GL_BYTE &&
+ type != GL_UNSIGNED_BYTE &&
+ type != GL_SHORT &&
+ type != GL_UNSIGNED_SHORT &&
+ type != GL_INT &&
+ type != GL_UNSIGNED_INT &&
+ type != GL_FLOAT &&
+ type != GL_BITMAP) {
+ gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(stencil type)");
+ return;
+ }
+
+ drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ for (row = 0; row < height; row++, y++) {
+ GLstencil values[MAX_WIDTH];
+ GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
+ ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
+ const GLvoid *source = _mesa_image_address(&ctx->Unpack,
+ 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) {
+ _mesa_shift_and_offset_stencil( ctx, drawWidth, values );
+ }
+ if (ctx->Pixel.MapStencilFlag) {
+ _mesa_map_stencil( ctx, drawWidth, values );
+ }
+
+ if (zoom) {
+ gl_write_zoomed_stencil_span( ctx, (GLuint) drawWidth, x, y,
+ values, desty );
+ }
+ else {
+ _mesa_write_stencil_span( ctx, (GLuint) drawWidth, x, y, values );
+ }
+ }
+}
+
+
+
+/*
+ * Do a glDrawPixels of depth values.
+ */
+static void
+draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, const GLvoid *pixels )
+{
+ const GLboolean bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
+ const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+ const GLint desty = y;
+ GLchan rgba[MAX_WIDTH][4];
+ GLuint ispan[MAX_WIDTH];
+ GLint drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ if (type != GL_BYTE
+ && type != GL_UNSIGNED_BYTE
+ && type != GL_SHORT
+ && type != GL_UNSIGNED_SHORT
+ && type != GL_INT
+ && type != GL_UNSIGNED_INT
+ && type != GL_FLOAT) {
+ gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(type)");
+ return;
+ }
+
+ /* Colors or indexes */
+ if (ctx->Visual.RGBAflag) {
+ GLint r = FLOAT_TO_CHAN(ctx->Current.RasterColor[0]);
+ GLint g = FLOAT_TO_CHAN(ctx->Current.RasterColor[1]);
+ GLint b = FLOAT_TO_CHAN(ctx->Current.RasterColor[2]);
+ GLint a = FLOAT_TO_CHAN(ctx->Current.RasterColor[3]);
+ GLint i;
+ for (i = 0; i < drawWidth; i++) {
+ rgba[i][RCOMP] = r;
+ rgba[i][GCOMP] = g;
+ rgba[i][BCOMP] = b;
+ rgba[i][ACOMP] = a;
+ }
+ }
+ else {
+ GLint i;
+ for (i = 0; i < drawWidth; i++) {
+ ispan[i] = ctx->Current.RasterIndex;
+ }
+ }
+
+ if (type==GL_UNSIGNED_SHORT && sizeof(GLdepth)==sizeof(GLushort)
+ && !bias_or_scale && !zoom && ctx->Visual.RGBAflag) {
+ /* Special case: directly write 16-bit depth values */
+ GLint row;
+ for (row = 0; row < height; row++, y++) {
+ GLdepth zspan[MAX_WIDTH];
+ const GLushort *zptr = _mesa_image_address(&ctx->Unpack,
+ pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0);
+ GLint i;
+ for (i = 0; i < width; i++)
+ zspan[i] = zptr[i];
+ gl_write_rgba_span( ctx, width, x, y, zspan, 0, rgba, GL_BITMAP );
+ }
+ }
+ else if (type==GL_UNSIGNED_INT && ctx->Visual.DepthBits == 32
+ && !bias_or_scale && !zoom && ctx->Visual.RGBAflag) {
+ /* Special case: directly write 32-bit depth values */
+ GLint row;
+ for (row = 0; row < height; row++, y++) {
+ const GLuint *zptr = _mesa_image_address(&ctx->Unpack,
+ pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0);
+ gl_write_rgba_span( ctx, width, x, y, zptr, 0, rgba, GL_BITMAP );
+ }
+ }
+ else {
+ /* General case */
+ GLint row;
+ for (row = 0; row < height; row++, y++) {
+ GLdepth zspan[MAX_WIDTH];
+ 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 );
+ if (ctx->Visual.RGBAflag) {
+ if (zoom) {
+ gl_write_zoomed_rgba_span(ctx, width, x, y, zspan, 0,
+ (const GLchan (*)[4]) rgba, desty);
+ }
+ else {
+ gl_write_rgba_span(ctx, width, x, y, zspan, 0, rgba, GL_BITMAP);
+ }
+ }
+ else {
+ if (zoom) {
+ gl_write_zoomed_index_span(ctx, width, x, y, zspan, 0,
+ ispan, GL_BITMAP);
+ }
+ else {
+ gl_write_index_span(ctx, width, x, y, zspan, 0,
+ ispan, GL_BITMAP);
+ }
+ }
+
+ }
+ }
+}
+
+
+/*
+ * Do glDrawPixels of RGBA pixels.
+ */
+static void
+draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type, const GLvoid *pixels )
+{
+ const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
+ const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+ const GLint desty = y;
+ GLdepth zspan[MAX_WIDTH];
+ GLboolean quickDraw;
+ GLfloat *convImage = NULL;
+ GLuint transferOps = ctx->ImageTransferState;
+
+ if (!_mesa_is_legal_format_and_type(format, type)) {
+ gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)");
+ return;
+ }
+
+ /* Try an optimized glDrawPixels first */
+ if (fast_draw_pixels(ctx, x, y, width, height, format, type, pixels))
+ return;
+
+ /* Fragment depth values */
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ /* fill in array of z values */
+ GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual.DepthMaxF);
+ GLint i;
+ for (i=0;i<width;i++) {
+ zspan[i] = z;
+ }
+ }
+
+
+ if (ctx->RasterMask == 0 && !zoom && x >= 0 && y >= 0
+ && x + width <= ctx->DrawBuffer->Width
+ && y + height <= ctx->DrawBuffer->Height) {
+ quickDraw = GL_TRUE;
+ }
+ else {
+ quickDraw = GL_FALSE;
+ }
+
+ if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+ /* Convolution has to be handled specially. We'll create an
+ * intermediate image, applying all pixel transfer operations
+ * up to convolution. Then we'll convolve the image. Then
+ * we'll proceed with the rest of the transfer operations and
+ * rasterize the image.
+ */
+ GLint row;
+ GLfloat *dest, *tmpImage;
+
+ tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!tmpImage) {
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
+ return;
+ }
+ convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!convImage) {
+ FREE(tmpImage);
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
+ return;
+ }
+
+ /* Unpack the image and apply transfer ops up to convolution */
+ dest = tmpImage;
+ for (row = 0; row < height; row++) {
+ const GLvoid *source = _mesa_image_address(unpack,
+ pixels, width, height, format, type, 0, row, 0);
+ _mesa_unpack_float_color_span(ctx, width, GL_RGBA, (void *) dest,
+ format, type, source, unpack,
+ transferOps & IMAGE_PRE_CONVOLUTION_BITS,
+ GL_FALSE);
+ dest += width * 4;
+ }
+
+ /* do convolution */
+ if (ctx->Pixel.Convolution2DEnabled) {
+ _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
+ }
+ else {
+ ASSERT(ctx->Pixel.Separable2DEnabled);
+ _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
+ }
+ FREE(tmpImage);
+
+ /* continue transfer ops and draw the convolved image */
+ unpack = &_mesa_native_packing;
+ pixels = convImage;
+ format = GL_RGBA;
+ type = GL_FLOAT;
+ transferOps &= IMAGE_POST_CONVOLUTION_BITS;
+ }
+
+ /*
+ * General solution
+ */
+ {
+ GLchan rgba[MAX_WIDTH][4];
+ GLint row;
+ if (width > MAX_WIDTH)
+ width = MAX_WIDTH;
+ for (row = 0; row < height; row++, y++) {
+ const GLvoid *source = _mesa_image_address(unpack,
+ pixels, width, height, format, type, 0, row, 0);
+ _mesa_unpack_chan_color_span(ctx, width, GL_RGBA, (void*) rgba,
+ format, type, source, unpack,
+ transferOps);
+ if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) ||
+ (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink))
+ continue;
+
+ 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;
+ /* XXX not sure how multitexture is supposed to work here */
+
+ MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+ 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,
+ primary_rgba, rgba);
+ }
+ }
+ }
+
+ if (quickDraw) {
+ (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y,
+ (CONST GLchan (*)[]) rgba, NULL);
+ }
+ else if (zoom) {
+ gl_write_zoomed_rgba_span( ctx, width, x, y, zspan, 0,
+ (CONST GLchan (*)[]) rgba, desty );
+ }
+ else {
+ gl_write_rgba_span( ctx, (GLuint) width, x, y, zspan, 0,
+ rgba, GL_BITMAP);
+ }
+ }
+ }
+
+ if (convImage) {
+ FREE(convImage);
+ }
+}
+
+
+
+/*
+ * Execute glDrawPixels
+ */
+void
+_swrast_DrawPixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ const struct gl_pixelstore_attrib *unpack,
+ const GLvoid *pixels )
+{
+ (void) unpack;
+
+ switch (format) {
+ case GL_STENCIL_INDEX:
+ draw_stencil_pixels( ctx, x, y, width, height, type, pixels );
+ break;
+ case GL_DEPTH_COMPONENT:
+ draw_depth_pixels( ctx, x, y, width, height, type, pixels );
+ break;
+ case GL_COLOR_INDEX:
+ if (ctx->Visual.RGBAflag)
+ draw_rgba_pixels(ctx, x,y, width, height, format, type, pixels);
+ else
+ draw_index_pixels(ctx, x, y, width, height, type, pixels);
+ break;
+ case GL_RED:
+ case GL_GREEN:
+ case GL_BLUE:
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_LUMINANCE_ALPHA:
+ case GL_RGB:
+ case GL_BGR:
+ case GL_RGBA:
+ case GL_BGRA:
+ case GL_ABGR_EXT:
+ draw_rgba_pixels(ctx, x, y, width, height, format, type, pixels);
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(format)" );
+ }
+}
+
--- /dev/null
+/* $Id: s_drawpix.h,v 1.1 2000/10/31 18:00:04 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_DRAWPIXELS_H
+#define S_DRAWPIXELS_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern GLboolean
+_mesa_clip_pixelrect(const GLcontext *ctx,
+ GLint *destX, GLint *destY,
+ GLsizei *width, GLsizei *height,
+ GLint *skipPixels, GLint *skipRows);
+
+#endif
--- /dev/null
+/* $Id: s_fog.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "macros.h"
+#include "mmath.h"
+
+#include "s_fog.h"
+
+
+/*
+ * Apply fog to an array of RGBA pixels.
+ * Input: n - number of pixels
+ * fog - array of interpolated screen-space fog coordinates in [0..1]
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_fog_rgba_pixels( const GLcontext *ctx,
+ GLuint n,
+ const GLfixed fog[],
+ GLchan rgba[][4] )
+{
+ GLfixed rFog = ctx->Fog.Color[0] * CHAN_MAXF;
+ GLfixed gFog = ctx->Fog.Color[1] * CHAN_MAXF;
+ GLfixed bFog = ctx->Fog.Color[2] * CHAN_MAXF;
+ GLuint i;
+
+ for (i=0;i<n;i++) {
+ GLfixed f = CLAMP(fog[i], 0, FIXED_ONE);
+ GLfixed g = FIXED_ONE - f;
+ rgba[i][0] = (f*rgba[i][0] + g*rFog) >> FIXED_SHIFT;
+ rgba[i][1] = (f*rgba[i][1] + g*gFog) >> FIXED_SHIFT;
+ rgba[i][2] = (f*rgba[i][2] + g*bFog) >> FIXED_SHIFT;
+ }
+}
+
+
+
+
+/*
+ * Apply fog to an array of color index pixels.
+ * Input: n - number of pixels
+ * z - array of integer depth values
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLfixed fog[], GLuint index[] )
+{
+ GLuint idx = ctx->Fog.Index;
+ GLuint i;
+
+ for (i=0;i<n;i++) {
+ GLfixed f = FixedToFloat(CLAMP(fog[i], 0, FIXED_ONE));
+ index[i] = (GLuint) ((GLfloat) index[i] + (1.0F-f) * idx);
+ }
+}
+
+
+
+/*
+ * Calculate fog coords from window z values
+ * Input: n - number of pixels
+ * z - array of integer depth values
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ *
+ * Use lookup table & interpolation?
+ */
+void
+_mesa_win_fog_coords_from_z( const GLcontext *ctx,
+ GLuint n,
+ const GLdepth z[],
+ GLfixed fogcoord[] )
+{
+ GLfloat c = ctx->ProjectionMatrix.m[10];
+ 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];
+
+ switch (ctx->Fog.Mode) {
+ case GL_LINEAR:
+ {
+ GLfloat fogEnd = ctx->Fog.End;
+ GLfloat fogScale = (GLfloat) FIXED_ONE / (ctx->Fog.End -
+ ctx->Fog.Start);
+ for (i=0;i<n;i++) {
+ GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+ GLfloat eyez = -d / (c+ndcz);
+ if (eyez < 0.0) eyez = -eyez;
+ fogcoord[i] = (GLint)(fogEnd - eyez) * fogScale;
+ }
+ }
+ break;
+ case GL_EXP:
+ for (i=0;i<n;i++) {
+ GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+ GLfloat eyez = d / (c+ndcz);
+ if (eyez < 0.0) eyez = -eyez;
+ fogcoord[i] = FloatToFixed(exp( -ctx->Fog.Density * eyez ));
+ }
+ break;
+ case GL_EXP2:
+ {
+ GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;
+ for (i=0;i<n;i++) {
+ GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+ GLfloat eyez = d / (c+ndcz);
+ GLfloat tmp = negDensitySquared * eyez * eyez;
+#if defined(__alpha__) || defined(__alpha)
+ /* XXX this underflow check may be needed for other systems */
+ if (tmp < FLT_MIN_10_EXP)
+ tmp = FLT_MIN_10_EXP;
+#endif
+ fogcoord[i] = FloatToFixed(exp( tmp ));
+ }
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad fog mode in _mesa_win_fog_coords_from_z");
+ return;
+ }
+}
+
+
+/*
+ * Apply fog to an array of RGBA pixels.
+ * Input: n - number of pixels
+ * z - array of integer depth values
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+ GLuint n, const GLdepth z[], GLchan rgba[][4] )
+{
+ GLfixed fog[MAX_WIDTH];
+ _mesa_win_fog_coords_from_z( ctx, n, z, fog );
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+}
+
+
+/*
+ * Apply fog to an array of color index pixels.
+ * Input: n - number of pixels
+ * z - array of integer depth values
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLdepth z[], GLuint index[] )
+{
+ GLfixed fog[MAX_WIDTH];
+ _mesa_win_fog_coords_from_z( ctx, n, z, fog );
+ _mesa_fog_ci_pixels( ctx, n, fog, index );
+}
+
--- /dev/null
+/* $Id: s_fog.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_FOG_H
+#define S_FOG_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+
+
+extern void
+_mesa_fog_rgba_pixels( const GLcontext *ctx,
+ GLuint n, const GLfixed fog[],
+ GLchan rgba[][4] );
+
+extern void
+_mesa_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLfixed fog[], GLuint indx[] );
+
+extern void
+_mesa_win_fog_coords_from_z( const GLcontext *ctx,
+ GLuint n,
+ const GLdepth z[],
+ GLfixed fogcoord[] );
+
+extern void
+_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+ GLuint n, const GLdepth z[], GLchan rgba[][4] );
+
+extern void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLdepth z[], GLuint index[] );
+
+
+
+#endif
--- /dev/null
+/* $Id: s_imaging.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.4
+ *
+ * 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.
+ */
+
+
+/*
+ * Histogram, Min/max and convolution for GL_ARB_imaging subset
+ *
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "image.h"
+#include "mmath.h"
+
+#include "s_imaging.h"
+#include "s_span.h"
+
+
+
+/*
+ * Update the min/max values from an array of fragment colors.
+ */
+void
+_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
+{
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ /* update mins */
+ if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP])
+ ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP];
+ if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP])
+ ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP];
+ if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP])
+ ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP];
+ if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP])
+ ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP];
+
+ /* update maxs */
+ if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP])
+ ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP];
+ if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP])
+ ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP];
+ if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP])
+ ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP];
+ if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP])
+ ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP];
+ }
+}
+
+
+/*
+ * Update the histogram values from an array of fragment colors.
+ */
+void
+_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
+{
+ const GLint max = ctx->Histogram.Width - 1;
+ GLfloat w = (GLfloat) max;
+ GLuint i;
+
+ if (ctx->Histogram.Width == 0)
+ return;
+
+ for (i = 0; i < n; i++) {
+ GLint ri = (GLint) (rgba[i][RCOMP] * w + 0.5F);
+ GLint gi = (GLint) (rgba[i][GCOMP] * w + 0.5F);
+ GLint bi = (GLint) (rgba[i][BCOMP] * w + 0.5F);
+ GLint ai = (GLint) (rgba[i][ACOMP] * w + 0.5F);
+ ri = CLAMP(ri, 0, max);
+ gi = CLAMP(gi, 0, max);
+ bi = CLAMP(bi, 0, max);
+ ai = CLAMP(ai, 0, max);
+ ctx->Histogram.Count[ri][RCOMP]++;
+ ctx->Histogram.Count[gi][GCOMP]++;
+ ctx->Histogram.Count[bi][BCOMP]++;
+ ctx->Histogram.Count[ai][ACOMP]++;
+ }
+}
+
+
+
--- /dev/null
+/* $Id: s_lines.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "feedback.h"
+#include "macros.h"
+#include "mmath.h"
+#include "vb.h"
+
+#include "s_pb.h"
+#include "s_depth.h"
+
+
+
+/**********************************************************************/
+/***** Rasterization *****/
+/**********************************************************************/
+
+
+/*
+ * There are 4 pairs (RGBA, CI) of line drawing functions:
+ * 1. simple: width=1 and no special rasterization functions (fastest)
+ * 2. flat: width=1, non-stippled, flat-shaded, any raster operations
+ * 3. smooth: width=1, non-stippled, smooth-shaded, any raster operations
+ * 4. general: any other kind of line (slowest)
+ */
+
+
+/*
+ * 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.
+ */
+
+
+
+
+
+
+#if MAX_WIDTH > MAX_HEIGHT
+# define MAXPOINTS MAX_WIDTH
+#else
+# define MAXPOINTS MAX_HEIGHT
+#endif
+
+
+/* Flat, color index line */
+static void flat_ci_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] );
+
+#define INTERP_XY 1
+#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, 0, 0);
+
+#include "s_linetemp.h"
+
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Flat, color index line with Z interpolation/testing */
+static void flat_ci_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] );
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0);
+
+#include "s_linetemp.h"
+
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Flat-shaded, RGBA line */
+static void flat_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ const GLchan *color = ctx->VB->ColorPtr->data[pvert];
+ PB_SET_COLOR( ctx->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);
+
+#include "s_linetemp.h"
+
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Flat-shaded, RGBA line with Z interpolation/testing */
+static void flat_rgba_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ const GLchan *color = ctx->VB->ColorPtr->data[pvert];
+ PB_SET_COLOR( ctx->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);
+
+#include "s_linetemp.h"
+
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Smooth shaded, color index line */
+static void smooth_ci_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ GLint count = ctx->PB->count;
+ GLint *pbx = ctx->PB->x;
+ GLint *pby = ctx->PB->y;
+ GLuint *pbi = ctx->PB->index;
+ (void) pvert;
+
+ ctx->PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_INDEX 1
+
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbi[count] = I; \
+ count++;
+
+#include "s_linetemp.h"
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Smooth shaded, color index line with Z interpolation/testing */
+static void smooth_ci_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ ctx->PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbi[count] = I; \
+ count++;
+
+#include "s_linetemp.h"
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, RGBA line */
+static void smooth_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ GLint count = ctx->PB->count;
+ GLint *pbx = ctx->PB->x;
+ GLint *pby = ctx->PB->y;
+ GLchan (*pbrgba)[4] = ctx->PB->rgba;
+ (void) pvert;
+
+ ctx->PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++;
+
+#include "s_linetemp.h"
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, RGBA line with Z interpolation/testing */
+static void smooth_rgba_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ ctx->PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++;
+
+#include "s_linetemp.h"
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+#define CHECK_FULL(count) \
+ if (count >= PB_SIZE-MAX_WIDTH) { \
+ ctx->PB->count = count; \
+ gl_flush_pb(ctx); \
+ count = ctx->PB->count; \
+ }
+
+
+
+/* Smooth shaded, color index, any width, maybe stippled */
+static void general_smooth_ci_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ ctx->PB->mono = GL_FALSE;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbi[count] = I; \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+ if (ctx->Line.Width==2.0F) {
+ /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define XMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X; \
+ pby[count] = Y; pby[count+1] = Y+1; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ pbi[count] = I; pbi[count+1] = I; \
+ count += 2; \
+ CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X+1; \
+ pby[count] = Y; pby[count+1] = Y; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ pbi[count] = I; pbi[count+1] = I; \
+ count += 2; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbi[count] = I; \
+ pbfog[count] = fog0; \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ }
+
+ ctx->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 )
+{
+ 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;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+ if (ctx->Line.Width==2.0F) {
+ /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define XMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X; \
+ pby[count] = Y; pby[count+1] = Y+1; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ count += 2; \
+ CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X+1; \
+ pby[count] = Y; pby[count+1] = Y; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ count += 2; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+static void general_smooth_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert)
+{
+ 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;
+
+ ctx->PB->mono = GL_FALSE;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+ if (ctx->Line.Width==2.0F) {
+ /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define XMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X; \
+ pby[count] = Y; pby[count+1] = Y+1; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ pbrgba[count+1][RCOMP] = FixedToInt(r0); \
+ pbrgba[count+1][GCOMP] = FixedToInt(g0); \
+ pbrgba[count+1][BCOMP] = FixedToInt(b0); \
+ pbrgba[count+1][ACOMP] = FixedToInt(a0); \
+ count += 2; \
+ CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y) \
+ pbx[count] = X; pbx[count+1] = X+1; \
+ pby[count] = Y; pby[count+1] = Y; \
+ pbz[count] = Z; pbz[count+1] = Z; \
+ pbfog[count] = fog0; pbfog[count+1] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ pbrgba[count+1][RCOMP] = FixedToInt(r0); \
+ pbrgba[count+1][GCOMP] = FixedToInt(g0); \
+ pbrgba[count+1][BCOMP] = FixedToInt(b0); \
+ pbrgba[count+1][ACOMP] = FixedToInt(a0); \
+ count += 2; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++; \
+ CHECK_FULL(count);
+#include "s_linetemp.h"
+ }
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+static void general_flat_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ const GLchan *color = ctx->VB->ColorPtr->data[pvert];
+ PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] );
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+ if (ctx->Line.Width==2.0F) {
+ /* 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);
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define WIDE 1
+#define PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z, fog0);
+#include "s_linetemp.h"
+ }
+ }
+
+ gl_flush_pb(ctx);
+}
+
+
+/* Flat-shaded, textured, any width, maybe stippled */
+static void flat_textured_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ 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;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ { \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbs[count] = fragTexcoord[0];\
+ pbt[count] = fragTexcoord[1];\
+ pbu[count] = fragTexcoord[2];\
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ { \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbs[count] = fragTexcoord[0];\
+ pbt[count] = fragTexcoord[1];\
+ pbu[count] = fragTexcoord[2];\
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, textured, any width, maybe stippled */
+static void smooth_textured_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ { \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbs[count] = fragTexcoord[0]; \
+ pbt[count] = fragTexcoord[1]; \
+ pbu[count] = fragTexcoord[2]; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ { \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbs[count] = fragTexcoord[0]; \
+ pbt[count] = fragTexcoord[1]; \
+ pbu[count] = fragTexcoord[2]; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+/* Smooth-shaded, multitextured, any width, maybe stippled, separate specular
+ * color interpolation.
+ */
+static void smooth_multitextured_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ (void) pvert;
+
+ ctx->PB->mono = GL_FALSE;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ { \
+ GLuint u; \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ pbspec[count][RCOMP] = FixedToInt(sr0); \
+ 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]; \
+ } \
+ } \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ { \
+ GLuint u; \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = FixedToInt(r0); \
+ pbrgba[count][GCOMP] = FixedToInt(g0); \
+ pbrgba[count][BCOMP] = FixedToInt(b0); \
+ pbrgba[count][ACOMP] = FixedToInt(a0); \
+ pbspec[count][RCOMP] = FixedToInt(sr0); \
+ 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]; \
+ } \
+ } \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+/* Flat-shaded, multitextured, any width, maybe stippled, separate specular
+ * color interpolation.
+ */
+static void flat_multitextured_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+ 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;
+
+ if (ctx->Line.StippleFlag) {
+ /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y) \
+ { \
+ GLuint u; \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = color[0]; \
+ pbrgba[count][GCOMP] = color[1]; \
+ pbrgba[count][BCOMP] = color[2]; \
+ pbrgba[count][ACOMP] = color[3]; \
+ pbspec[count][RCOMP] = sRed; \
+ 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]; \
+ } \
+ } \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+ else {
+ /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define PLOT(X,Y) \
+ { \
+ GLuint u; \
+ pbx[count] = X; \
+ pby[count] = Y; \
+ pbz[count] = Z; \
+ pbfog[count] = fog0; \
+ pbrgba[count][RCOMP] = color[0]; \
+ pbrgba[count][GCOMP] = color[1]; \
+ pbrgba[count][BCOMP] = color[2]; \
+ pbrgba[count][ACOMP] = color[3]; \
+ pbspec[count][RCOMP] = sRed; \
+ 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]; \
+ } \
+ } \
+ count++; \
+ CHECK_FULL(count); \
+ }
+#include "s_linetemp.h"
+ }
+
+ ctx->PB->count = count;
+ gl_flush_pb(ctx);
+}
+
+
+
+
+/*
+ * Antialiased RGBA line
+ *
+ * This AA line function isn't terribly efficient but it's pretty
+ * straight-forward to understand. Also, it doesn't exactly conform
+ * to the specification.
+ */
+static void aa_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+#define INTERP_RGBA 1
+#define PLOT(x, y) \
+ { \
+ PB_WRITE_RGBA_PIXEL( pb, (x), (y), z, fog0, \
+ red, green, blue, coverage ); \
+ }
+#include "s_lnaatemp.h"
+}
+
+/*
+ * Antialiased Textured RGBA line
+ *
+ * This AA line function isn't terribly efficient but it's pretty
+ * straight-forward to understand. Also, it doesn't exactly conform
+ * to the specification.
+ */
+static void aa_tex_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+#define INTERP_RGBA 1
+#define INTERP_TEX 1
+#define PLOT(x, y) \
+ { \
+ PB_WRITE_TEX_PIXEL( pb, (x), (y), z, fog0, \
+ red, green, blue, coverage, \
+ fragTexcoord[0], fragTexcoord[1], fragTexcoord[2] ); \
+ }
+#include "s_lnaatemp.h"
+}
+
+
+/*
+ * Antialiased Multitextured RGBA line
+ *
+ * This AA line function isn't terribly efficient but it's pretty
+ * straight-forward to understand. Also, it doesn't exactly conform
+ * to the specification.
+ */
+static void aa_multitex_rgba_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+#define INTERP_RGBA 1
+#define INTERP_SPEC 1
+#define INTERP_MULTITEX 1
+#define PLOT(x, y) \
+ { \
+ PB_WRITE_MULTITEX_SPEC_PIXEL( pb, (x), (y), z, fog0, \
+ red, green, blue, coverage, specRed, specGreen, specBlue, \
+ fragTexcoord ); \
+ }
+#include "s_lnaatemp.h"
+}
+
+
+/*
+ * Antialiased CI line. Same comments for RGBA antialiased lines apply.
+ */
+static void aa_ci_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pvert )
+{
+#define INTERP_INDEX 1
+#define PLOT(x, y) \
+ { \
+ PB_WRITE_CI_PIXEL( pb, (x), (y), z, fog0, index + coverage ); \
+ }
+#include "s_lnaatemp.h"
+}
+
+
+/*
+ * 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)
+{
+ printf("Line Func == ");
+ if (ctx->Driver.LineFunc == flat_ci_line)
+ printf("flat_ci_line\n");
+ else if (ctx->Driver.LineFunc == flat_ci_z_line)
+ printf("flat_ci_z_line\n");
+ else if (ctx->Driver.LineFunc == flat_rgba_line)
+ printf("flat_rgba_line\n");
+ else if (ctx->Driver.LineFunc == flat_rgba_z_line)
+ printf("flat_rgba_z_line\n");
+ else if (ctx->Driver.LineFunc == smooth_ci_line)
+ printf("smooth_ci_line\n");
+ else if (ctx->Driver.LineFunc == smooth_ci_z_line)
+ printf("smooth_ci_z_line\n");
+ else if (ctx->Driver.LineFunc == smooth_rgba_line)
+ printf("smooth_rgba_line\n");
+ else if (ctx->Driver.LineFunc == smooth_rgba_z_line)
+ printf("smooth_rgba_z_line\n");
+ else if (ctx->Driver.LineFunc == general_smooth_ci_line)
+ printf("general_smooth_ci_line\n");
+ else if (ctx->Driver.LineFunc == general_flat_ci_line)
+ printf("general_flat_ci_line\n");
+ else if (ctx->Driver.LineFunc == general_smooth_rgba_line)
+ printf("general_smooth_rgba_line\n");
+ else if (ctx->Driver.LineFunc == general_flat_rgba_line)
+ printf("general_flat_rgba_line\n");
+ else if (ctx->Driver.LineFunc == flat_textured_line)
+ printf("flat_textured_line\n");
+ else if (ctx->Driver.LineFunc == smooth_textured_line)
+ printf("smooth_textured_line\n");
+ else if (ctx->Driver.LineFunc == smooth_multitextured_line)
+ printf("smooth_multitextured_line\n");
+ else if (ctx->Driver.LineFunc == flat_multitextured_line)
+ printf("flat_multitextured_line\n");
+ else if (ctx->Driver.LineFunc == aa_rgba_line)
+ printf("aa_rgba_line\n");
+ else if (ctx->Driver.LineFunc == aa_tex_rgba_line)
+ printf("aa_tex_rgba_line\n");
+ else if (ctx->Driver.LineFunc == aa_multitex_rgba_line)
+ printf("aa_multitex_rgba_line\n");
+ else if (ctx->Driver.LineFunc == 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);
+}
+#endif
+
+
+
+/*
+ * Determine which line drawing function to use given the current
+ * rendering context.
+ *
+ * Please update the summary flag _SWRAST_NEW_LINE if you add or remove
+ * tests to this code.
+ */
+void
+_swrast_set_line_function( GLcontext *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
+ || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR
+ || ctx->Fog.ColorSumEnabled)
+ /* Multitextured! */
+ ctx->Driver.LineFunc = aa_multitex_rgba_line;
+ else
+ ctx->Driver.LineFunc = aa_tex_rgba_line;
+ } else {
+ ctx->Driver.LineFunc = aa_rgba_line;
+ }
+ }
+ else {
+ ctx->Driver.LineFunc = aa_ci_line;
+ }
+ }
+ 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;
+ else
+ ctx->Driver.LineFunc = flat_multitextured_line;
+ }
+ else {
+ if (ctx->Light.ShadeModel==GL_SMOOTH) {
+ ctx->Driver.LineFunc = smooth_textured_line;
+ }
+ else {
+ ctx->Driver.LineFunc = flat_textured_line;
+ }
+ }
+ }
+ else if (ctx->Line.Width!=1.0 || ctx->Line.StippleFlag
+ || ctx->Line.SmoothFlag) {
+ if (ctx->Light.ShadeModel==GL_SMOOTH) {
+ if (rgbmode)
+ ctx->Driver.LineFunc = general_smooth_rgba_line;
+ else
+ ctx->Driver.LineFunc = general_smooth_ci_line;
+ }
+ else {
+ if (rgbmode)
+ ctx->Driver.LineFunc = general_flat_rgba_line;
+ else
+ ctx->Driver.LineFunc = general_flat_ci_line;
+ }
+ }
+ else {
+ if (ctx->Light.ShadeModel==GL_SMOOTH) {
+ /* Width==1, non-stippled, smooth-shaded */
+ if (ctx->Depth.Test || ctx->Fog.Enabled) {
+ if (rgbmode)
+ ctx->Driver.LineFunc = smooth_rgba_z_line;
+ else
+ ctx->Driver.LineFunc = smooth_ci_z_line;
+ }
+ else {
+ if (rgbmode)
+ ctx->Driver.LineFunc = smooth_rgba_line;
+ else
+ ctx->Driver.LineFunc = 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;
+ else
+ ctx->Driver.LineFunc = flat_ci_z_line;
+ }
+ else {
+ if (rgbmode)
+ ctx->Driver.LineFunc = flat_rgba_line;
+ else
+ ctx->Driver.LineFunc = flat_ci_line;
+ }
+ }
+ }
+ }
+ else if (ctx->RenderMode==GL_FEEDBACK) {
+ ctx->Driver.LineFunc = gl_feedback_line;
+ }
+ else {
+ /* GL_SELECT mode */
+ ctx->Driver.LineFunc = gl_select_line;
+ }
+
+ /*_mesa_print_line_function(ctx);*/
+}
--- /dev/null
+/* $Id: s_linetemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Line Rasterizer Template
+ *
+ * This file is #include'd to generate custom line rasterizers.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be interplated along the line:
+ * INTERP_Z - if defined, interpolate Z and FOG values
+ * INTERP_RGB - if defined, interpolate RGB values
+ * INTERP_SPEC - if defined, interpolate specular RGB values
+ * INTERP_ALPHA - if defined, interpolate Alpha values
+ * INTERP_INDEX - if defined, interpolate color index values
+ * INTERP_TEX - if defined, interpolate unit 0 texcoords
+ * INTERP_MULTITEX - if defined, interpolate multi-texcoords
+ *
+ * When one can directly address pixels in the color buffer the following
+ * macros can be defined and used to directly compute pixel addresses during
+ * rasterization (see pixelPtr):
+ * PIXEL_TYPE - the datatype of a pixel (GLubyte, GLushort, GLuint)
+ * BYTES_PER_ROW - number of bytes per row in the color buffer
+ * PIXEL_ADDRESS(X,Y) - returns the address of pixel at (X,Y) where
+ * Y==0 at bottom of screen and increases upward.
+ *
+ * Similarly, for direct depth buffer access, this type is used for depth
+ * buffer addressing:
+ * DEPTH_TYPE - either GLushort or GLuint
+ *
+ * Optionally, one may provide one-time setup code
+ * SETUP_CODE - code which is to be executed once per line
+ *
+ * To enable line stippling define STIPPLE = 1
+ * To enable wide lines define WIDE = 1
+ *
+ * To actually "plot" each pixel either the PLOT macro or
+ * (XMAJOR_PLOT and YMAJOR_PLOT macros) must be defined...
+ * PLOT(X,Y) - code to plot a pixel. Example:
+ * if (Z < *zPtr) {
+ * *zPtr = Z;
+ * color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
+ * FixedToInt(b0) );
+ * put_pixel( X, Y, color );
+ * }
+ *
+ * This code was designed for the origin to be in the lower-left corner.
+ *
+ */
+
+
+/*void line( GLcontext *ctx, GLuint vert0, GLuint vert1, GLuint pvert )*/
+{
+ 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 dx, dy;
+#ifdef INTERP_XY
+ GLint xstep, ystep;
+#endif
+#ifdef INTERP_Z
+ GLint z0, z1, dz;
+ const GLint depthBits = ctx->Visual.DepthBits;
+ const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
+# define FixedToDepth(F) ((F) >> fixedToDepthShift)
+# ifdef DEPTH_TYPE
+ GLint zPtrXstep, zPtrYstep;
+ DEPTH_TYPE *zPtr;
+# endif
+ GLfixed fog0 = FloatToFixed(VB->FogCoordPtr->data[vert0]);
+ GLfixed dfog = FloatToFixed(VB->FogCoordPtr->data[vert1]) - 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;
+#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;
+#endif
+#ifdef INTERP_ALPHA
+ GLfixed a0 = IntToFixed(VB->ColorPtr->data[vert0][3]);
+ GLfixed da = IntToFixed(VB->ColorPtr->data[vert1][3]) - a0;
+#endif
+#ifdef INTERP_INDEX
+ GLint i0 = VB->IndexPtr->data[vert0] << 8;
+ GLint di = (GLint) (VB->IndexPtr->data[vert1] << 8) - i0;
+#endif
+#ifdef INTERP_TEX
+ const GLfloat invw0 = VB->Win.data[vert0][3];
+ const GLfloat invw1 = VB->Win.data[vert1][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];
+ GLfloat tex[MAX_TEXTURE_UNITS][4];
+ GLfloat dtex[MAX_TEXTURE_UNITS][4];
+ GLfloat fragTexcoord[MAX_TEXTURE_UNITS][4];
+#endif
+#ifdef PIXEL_ADDRESS
+ PIXEL_TYPE *pixelPtr;
+ GLint pixelXstep, pixelYstep;
+#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;
+ width = (GLint) CLAMP( ctx->Line.Width, MIN_LINE_WIDTH, MAX_LINE_WIDTH );
+ min = (width-1) / -2;
+ max = min + width - 1;
+#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;
+ }
+ }
+#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;
+ }
+ }
+ }
+ }
+#endif
+
+
+/*
+ * Despite being clipped to the view volume, the line's window coordinates
+ * may just lie outside the window bounds. That is, if the legal window
+ * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
+ * This quick and dirty code nudges the endpoints inside the window if
+ * necessary.
+ */
+#ifdef CLIP_HACK
+ {
+ GLint w = ctx->DrawBuffer->Width;
+ GLint h = ctx->DrawBuffer->Height;
+ if ((x0==w) | (x1==w)) {
+ if ((x0==w) & (x1==w))
+ return;
+ x0 -= x0==w;
+ x1 -= x1==w;
+ }
+ if ((y0==h) | (y1==h)) {
+ if ((y0==h) & (y1==h))
+ return;
+ y0 -= y0==h;
+ y1 -= y1==h;
+ }
+ }
+#endif
+ dx = x1 - x0;
+ dy = y1 - y0;
+ if (dx==0 && dy==0) {
+ return;
+ }
+
+ /*
+ * Setup
+ */
+#ifdef SETUP_CODE
+ SETUP_CODE
+#endif
+
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ 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);
+ }
+ else {
+ z0 = (int) VB->Win.data[vert0][2] + ctx->LineZoffset;
+ z1 = (int) VB->Win.data[vert1][2] + ctx->LineZoffset;
+ }
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
+#endif
+
+ if (dx<0) {
+ dx = -dx; /* make positive */
+#ifdef INTERP_XY
+ xstep = -1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
+#endif
+ }
+ else {
+#ifdef INTERP_XY
+ xstep = 1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
+#endif
+ }
+
+ if (dy<0) {
+ dy = -dy; /* make positive */
+#ifdef INTERP_XY
+ ystep = -1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtrYstep = -ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelYstep = BYTES_PER_ROW;
+#endif
+ }
+ else {
+#ifdef INTERP_XY
+ ystep = 1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtrYstep = ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelYstep = -(BYTES_PER_ROW);
+#endif
+ }
+
+ /*
+ * Draw
+ */
+
+ if (dx>dy) {
+ /*** X-major line ***/
+ GLint i;
+ GLint errorInc = dy+dy;
+ GLint error = errorInc-dx;
+ GLint errorDec = error-dx;
+#ifdef INTERP_Z
+ dz = (z1-z0) / dx;
+ dfog /= dx;
+#endif
+#ifdef INTERP_RGB
+ dr /= dx; /* convert from whole line delta to per-pixel delta */
+ dg /= dx;
+ db /= dx;
+#endif
+#ifdef INTERP_SPEC
+ dsr /= dx; /* convert from whole line delta to per-pixel delta */
+ dsg /= dx;
+ dsb /= dx;
+#endif
+#ifdef INTERP_ALPHA
+ da /= dx;
+#endif
+#ifdef INTERP_INDEX
+ di /= dx;
+#endif
+#ifdef INTERP_TEX
+ {
+ const GLfloat invDx = 1.0F / (GLfloat) dx;
+ dtex[0] *= invDx;
+ dtex[1] *= invDx;
+ dtex[2] *= invDx;
+ dtex[3] *= invDx;
+ }
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ const GLfloat invDx = 1.0F / (GLfloat) dx;
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ dtex[u][0] *= invDx;
+ dtex[u][1] *= invDx;
+ dtex[u][2] *= invDx;
+ dtex[u][3] *= invDx;
+ }
+ }
+ }
+#endif
+
+ for (i=0;i<dx;i++) {
+#ifdef STIPPLE
+ GLushort m;
+ m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf);
+ if (ctx->Line.StipplePattern & m) {
+#endif
+#ifdef INTERP_Z
+ GLdepth Z = FixedToDepth(z0);
+#endif
+#ifdef INTERP_INDEX
+ GLint I = i0 >> 8;
+#endif
+#ifdef INTERP_TEX
+ {
+ const GLfloat invQ = 1.0F / tex[3];
+ fragTexcoord[0] = tex[0] * invQ;
+ fragTexcoord[1] = tex[1] * invQ;
+ fragTexcoord[2] = tex[2] * invQ;
+ }
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ 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;
+ fragTexcoord[u][2] = tex[u][2] * invQ;
+ }
+ }
+ }
+#endif
+#ifdef WIDE
+ {
+ GLint yy;
+ GLint ymin = y0 + min;
+ GLint ymax = y0 + max;
+ for (yy=ymin;yy<=ymax;yy++) {
+ PLOT( x0, yy );
+ }
+ }
+#else
+# ifdef XMAJOR_PLOT
+ XMAJOR_PLOT( x0, y0 );
+# else
+ PLOT( x0, y0 );
+# endif
+#endif /*WIDE*/
+#ifdef STIPPLE
+ }
+ ctx->StippleCounter++;
+#endif
+#ifdef INTERP_XY
+ x0 += xstep;
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
+# endif
+ z0 += dz;
+ fog0 += dfog;
+#endif
+#ifdef INTERP_RGB
+ r0 += dr;
+ g0 += dg;
+ b0 += db;
+#endif
+#ifdef INTERP_SPEC
+ sr0 += dsr;
+ sg0 += dsg;
+ sb0 += dsb;
+#endif
+#ifdef INTERP_ALPHA
+ a0 += da;
+#endif
+#ifdef INTERP_INDEX
+ i0 += di;
+#endif
+#ifdef INTERP_TEX
+ tex[0] += dtex[0];
+ tex[1] += dtex[1];
+ tex[2] += dtex[2];
+ tex[3] += dtex[3];
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ tex[u][0] += dtex[u][0];
+ tex[u][1] += dtex[u][1];
+ tex[u][2] += dtex[u][2];
+ tex[u][3] += dtex[u][3];
+ }
+ }
+ }
+#endif
+
+#ifdef PIXEL_ADDRESS
+ pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
+#endif
+ if (error<0) {
+ error += errorInc;
+ }
+ else {
+ error += errorDec;
+#ifdef INTERP_XY
+ y0 += ystep;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
+#endif
+ }
+ }
+ }
+ else {
+ /*** Y-major line ***/
+ GLint i;
+ GLint errorInc = dx+dx;
+ GLint error = errorInc-dy;
+ GLint errorDec = error-dy;
+#ifdef INTERP_Z
+ dz = (z1-z0) / dy;
+ dfog /= dy;
+#endif
+#ifdef INTERP_RGB
+ dr /= dy; /* convert from whole line delta to per-pixel delta */
+ dg /= dy;
+ db /= dy;
+#endif
+#ifdef INTERP_SPEC
+ dsr /= dy; /* convert from whole line delta to per-pixel delta */
+ dsg /= dy;
+ dsb /= dy;
+#endif
+#ifdef INTERP_ALPHA
+ da /= dy;
+#endif
+#ifdef INTERP_INDEX
+ di /= dy;
+#endif
+#ifdef INTERP_TEX
+ {
+ const GLfloat invDy = 1.0F / (GLfloat) dy;
+ dtex[0] *= invDy;
+ dtex[1] *= invDy;
+ dtex[2] *= invDy;
+ dtex[3] *= invDy;
+ }
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ const GLfloat invDy = 1.0F / (GLfloat) dy;
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ dtex[u][0] *= invDy;
+ dtex[u][1] *= invDy;
+ dtex[u][2] *= invDy;
+ dtex[u][3] *= invDy;
+ }
+ }
+ }
+#endif
+
+ for (i=0;i<dy;i++) {
+#ifdef STIPPLE
+ GLushort m;
+ m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf);
+ if (ctx->Line.StipplePattern & m) {
+#endif
+#ifdef INTERP_Z
+ GLdepth Z = FixedToDepth(z0);
+#endif
+#ifdef INTERP_INDEX
+ GLint I = i0 >> 8;
+#endif
+#ifdef INTERP_TEX
+ {
+ const GLfloat invQ = 1.0F / tex[3];
+ fragTexcoord[0] = tex[0] * invQ;
+ fragTexcoord[1] = tex[1] * invQ;
+ fragTexcoord[2] = tex[2] * invQ;
+ }
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ 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;
+ fragTexcoord[u][2] = tex[u][2] * invQ;
+ }
+ }
+ }
+#endif
+#ifdef WIDE
+ {
+ GLint xx;
+ GLint xmin = x0 + min;
+ GLint xmax = x0 + max;
+ for (xx=xmin;xx<=xmax;xx++) {
+ PLOT( xx, y0 );
+ }
+ }
+#else
+# ifdef YMAJOR_PLOT
+ YMAJOR_PLOT( x0, y0 );
+# else
+ PLOT( x0, y0 );
+# endif
+#endif /*WIDE*/
+#ifdef STIPPLE
+ }
+ ctx->StippleCounter++;
+#endif
+#ifdef INTERP_XY
+ y0 += ystep;
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
+# endif
+ z0 += dz;
+ fog0 += dfog;
+#endif
+#ifdef INTERP_RGB
+ r0 += dr;
+ g0 += dg;
+ b0 += db;
+#endif
+#ifdef INTERP_SPEC
+ sr0 += dsr;
+ sg0 += dsg;
+ sb0 += dsb;
+#endif
+#ifdef INTERP_ALPHA
+ a0 += da;
+#endif
+#ifdef INTERP_INDEX
+ i0 += di;
+#endif
+#ifdef INTERP_TEX
+ tex[0] += dtex[0];
+ tex[1] += dtex[1];
+ tex[2] += dtex[2];
+ tex[3] += dtex[3];
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ tex[u][0] += dtex[u][0];
+ tex[u][1] += dtex[u][1];
+ tex[u][2] += dtex[u][2];
+ tex[u][3] += dtex[u][3];
+ }
+ }
+ }
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
+#endif
+ if (error<0) {
+ error += errorInc;
+ }
+ else {
+ error += errorDec;
+#ifdef INTERP_XY
+ x0 += xstep;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+ zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
+#endif
+#ifdef PIXEL_ADDRESS
+ pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
+#endif
+ }
+ }
+ }
+
+}
+
+
+#undef INTERP_XY
+#undef INTERP_Z
+#undef INTERP_RGB
+#undef INTERP_SPEC
+#undef INTERP_ALPHA
+#undef INTERP_TEX
+#undef INTERP_MULTITEX
+#undef INTERP_INDEX
+#undef PIXEL_ADDRESS
+#undef PIXEL_TYPE
+#undef DEPTH_TYPE
+#undef BYTES_PER_ROW
+#undef SETUP_CODE
+#undef PLOT
+#undef XMAJOR_PLOT
+#undef YMAJOR_PLOT
+#undef CLIP_HACK
+#undef STIPPLE
+#undef WIDE
+#undef FixedToDepth
--- /dev/null
+/* $Id: s_logic.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "context.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_logic.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+
+/*
+ * Apply logic op to array of CI pixels.
+ */
+static void index_logicop( GLcontext *ctx, GLuint n,
+ GLuint index[], const GLuint dest[],
+ const GLubyte mask[] )
+{
+ GLuint i;
+ switch (ctx->Color.LogicOp) {
+ case GL_CLEAR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = 0;
+ }
+ }
+ break;
+ case GL_SET:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = 1;
+ }
+ }
+ break;
+ case GL_COPY:
+ /* do nothing */
+ break;
+ case GL_COPY_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~index[i];
+ }
+ }
+ break;
+ case GL_NOOP:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = dest[i];
+ }
+ }
+ break;
+ case GL_INVERT:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~dest[i];
+ }
+ }
+ break;
+ case GL_AND:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] &= dest[i];
+ }
+ }
+ break;
+ case GL_NAND:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~(index[i] & dest[i]);
+ }
+ }
+ break;
+ case GL_OR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] |= dest[i];
+ }
+ }
+ break;
+ case GL_NOR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~(index[i] | dest[i]);
+ }
+ }
+ break;
+ case GL_XOR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] ^= dest[i];
+ }
+ }
+ break;
+ case GL_EQUIV:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~(index[i] ^ dest[i]);
+ }
+ }
+ break;
+ case GL_AND_REVERSE:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = index[i] & ~dest[i];
+ }
+ }
+ break;
+ case GL_AND_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~index[i] & dest[i];
+ }
+ }
+ break;
+ case GL_OR_REVERSE:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = index[i] | ~dest[i];
+ }
+ }
+ break;
+ case GL_OR_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ index[i] = ~index[i] | dest[i];
+ }
+ }
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "gl_logic error" );
+ }
+}
+
+
+
+/*
+ * Apply the current logic operator to a span of CI pixels. This is only
+ * used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_ci_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLuint index[], const GLubyte mask[] )
+{
+ GLuint dest[MAX_WIDTH];
+ /* Read dest values from frame buffer */
+ (*ctx->Driver.ReadCI32Span)( ctx, n, x, y, dest );
+ index_logicop( ctx, n, index, dest, mask );
+}
+
+
+
+/*
+ * Apply the current logic operator to an array of CI pixels. This is only
+ * used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_ci_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint index[], const GLubyte mask[] )
+{
+ GLuint dest[PB_SIZE];
+ /* Read dest values from frame buffer */
+ (*ctx->Driver.ReadCI32Pixels)( ctx, n, x, y, dest, mask );
+ index_logicop( ctx, n, index, dest, mask );
+}
+
+
+
+/*
+ * Apply logic operator to rgba pixels.
+ * Input: ctx - the context
+ * n - number of pixels
+ * mask - pixel mask array
+ * In/Out: src - incoming pixels which will be modified
+ * Input: dest - frame buffer values
+ *
+ * Note: Since the R, G, B, and A channels are all treated the same we
+ * process them as 4-byte GLuints instead of four GLubytes.
+ */
+static void rgba_logicop( const GLcontext *ctx, GLuint n,
+ const GLubyte mask[],
+ GLuint src[], const GLuint dest[] )
+{
+ GLuint i;
+ switch (ctx->Color.LogicOp) {
+ case GL_CLEAR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = 0;
+ }
+ }
+ break;
+ case GL_SET:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = 0xffffffff;
+ }
+ }
+ break;
+ case GL_COPY:
+ /* do nothing */
+ break;
+ case GL_COPY_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~src[i];
+ }
+ }
+ break;
+ case GL_NOOP:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = dest[i];
+ }
+ }
+ break;
+ case GL_INVERT:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~dest[i];
+ }
+ }
+ break;
+ case GL_AND:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] &= dest[i];
+ }
+ }
+ break;
+ case GL_NAND:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~(src[i] & src[i]);
+ }
+ }
+ break;
+ case GL_OR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i]|= dest[i];
+ }
+ }
+ break;
+ case GL_NOR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~(src[i] | dest[i]);
+ }
+ }
+ break;
+ case GL_XOR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] ^= dest[i];
+ }
+ }
+ break;
+ case GL_EQUIV:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~(src[i] ^ dest[i]);
+ }
+ }
+ break;
+ case GL_AND_REVERSE:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = src[i] & ~dest[i];
+ }
+ }
+ break;
+ case GL_AND_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~src[i] & dest[i];
+ }
+ }
+ break;
+ case GL_OR_REVERSE:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = src[i] | ~dest[i];
+ }
+ }
+ break;
+ case GL_OR_INVERTED:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ src[i] = ~src[i] | dest[i];
+ }
+ }
+ break;
+ default:
+ /* should never happen */
+ gl_problem(ctx, "Bad function in rgba_logicop");
+ }
+}
+
+
+
+/*
+ * Apply the current logic operator to a span of RGBA pixels.
+ * This is only used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan dest[MAX_WIDTH][4];
+ gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+ rgba_logicop( ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest );
+}
+
+
+
+/*
+ * Apply the current logic operator to an array of RGBA pixels.
+ * This is only used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_rgba_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan dest[PB_SIZE][4];
+ (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+ }
+ rgba_logicop( ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest );
+}
--- /dev/null
+/* $Id: s_logic.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_LOGIC_H
+#define S_LOGIC_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_logicop_ci_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLuint index[],
+ const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_ci_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint index[], const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_rgba_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+#endif
--- /dev/null
+/* $Id: s_masking.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Implement the effect of glColorMask and glIndexMask in software.
+ */
+
+
+#include "glheader.h"
+#include "enums.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_masking.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+/*
+ * Apply glColorMask to a span of RGBA pixels.
+ */
+void
+_mesa_mask_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLchan rgba[][4] )
+{
+ GLchan dest[MAX_WIDTH][4];
+ GLuint i;
+
+#if CHAN_BITS == 8
+
+ GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
+ GLuint dstMask = ~srcMask;
+ GLuint *rgba32 = (GLuint *) rgba;
+ GLuint *dest32 = (GLuint *) dest;
+
+ gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+ for (i = 0; i < n; i++) {
+ rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
+ }
+
+#else
+
+ const GLint rMask = ctx->Color.ColorMask[RCOMP];
+ const GLint gMask = ctx->Color.ColorMask[GCOMP];
+ const GLint bMask = ctx->Color.ColorMask[BCOMP];
+ const GLint aMask = ctx->Color.ColorMask[ACOMP];
+
+ gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+ for (i = 0; i < n; i++) {
+ if (!rMask) rgba[i][RCOMP] = dest[i][RCOMP];
+ if (!gMask) rgba[i][GCOMP] = dest[i][GCOMP];
+ if (!bMask) rgba[i][BCOMP] = dest[i][BCOMP];
+ if (!aMask) rgba[i][ACOMP] = dest[i][ACOMP];
+ }
+
+#endif
+}
+
+
+
+/*
+ * Apply glColorMask to an array of RGBA pixels.
+ */
+void
+_mesa_mask_rgba_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
+{
+ GLchan dest[PB_SIZE][4];
+ GLuint i;
+
+#if CHAN_BITS == 8
+
+ GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
+ GLuint dstMask = ~srcMask;
+ GLuint *rgba32 = (GLuint *) rgba;
+ GLuint *dest32 = (GLuint *) dest;
+
+ (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+ }
+
+ for (i=0; i<n; i++) {
+ rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
+ }
+
+#else
+
+ const GLint rMask = ctx->Color.ColorMask[RCOMP];
+ const GLint gMask = ctx->Color.ColorMask[GCOMP];
+ const GLint bMask = ctx->Color.ColorMask[BCOMP];
+ const GLint aMask = ctx->Color.ColorMask[ACOMP];
+
+ (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+ }
+
+ for (i = 0; i < n; i++) {
+ if (!rMask) rgba[i][RCOMP] = dest[i][RCOMP];
+ if (!gMask) rgba[i][GCOMP] = dest[i][GCOMP];
+ if (!bMask) rgba[i][BCOMP] = dest[i][BCOMP];
+ if (!aMask) rgba[i][ACOMP] = dest[i][ACOMP];
+ }
+
+#endif
+}
+
+
+
+/*
+ * Apply glIndexMask to a span of CI pixels.
+ */
+void
+_mesa_mask_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLuint index[] )
+{
+ GLuint i;
+ GLuint fbindexes[MAX_WIDTH];
+ GLuint msrc, mdest;
+
+ gl_read_index_span( ctx, ctx->DrawBuffer, n, x, y, fbindexes );
+
+ msrc = ctx->Color.IndexMask;
+ mdest = ~msrc;
+
+ for (i=0;i<n;i++) {
+ index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
+ }
+}
+
+
+
+/*
+ * Apply glIndexMask to an array of CI pixels.
+ */
+void
+_mesa_mask_index_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint index[], const GLubyte mask[] )
+{
+ GLuint i;
+ GLuint fbindexes[PB_SIZE];
+ GLuint msrc, mdest;
+
+ (*ctx->Driver.ReadCI32Pixels)( ctx, n, x, y, fbindexes, mask );
+
+ msrc = ctx->Color.IndexMask;
+ mdest = ~msrc;
+
+ for (i=0;i<n;i++) {
+ index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
+ }
+}
+
--- /dev/null
+/* $Id: s_masking.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_MASKING_H
+#define S_MASKING_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+/*
+ * Implement glColorMask for a span of RGBA pixels.
+ */
+extern void
+_mesa_mask_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] );
+
+
+
+/*
+ * Implement glColorMask for an array of RGBA pixels.
+ */
+extern void
+_mesa_mask_rgba_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] );
+
+
+
+/*
+ * Implement glIndexMask for a span of CI pixels.
+ */
+extern void
+_mesa_mask_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLuint index[] );
+
+
+
+/*
+ * Implement glIndexMask for an array of CI pixels.
+ */
+extern void
+_mesa_mask_index_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint index[], const GLubyte mask[] );
+
+
+
+#endif
+
--- /dev/null
+/* $Id: s_pixeltex.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * This file implements both the GL_SGIX_pixel_texture and
+ * GL_SIGS_pixel_texture extensions. Luckily, they pretty much
+ * overlap in functionality so we use the same state variables
+ * and execution code for both.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+
+#include "s_pixeltex.h"
+
+
+/*
+ * Convert RGBA values into strq texture coordinates.
+ */
+void
+_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLchan rgba[][4],
+ GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[])
+{
+ if (ctx->Pixel.FragmentRgbSource == GL_CURRENT_RASTER_COLOR) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ s[i] = ctx->Current.RasterColor[RCOMP];
+ t[i] = ctx->Current.RasterColor[GCOMP];
+ r[i] = ctx->Current.RasterColor[BCOMP];
+ }
+ }
+ else {
+ GLuint i;
+ ASSERT(ctx->Pixel.FragmentRgbSource == GL_PIXEL_GROUP_COLOR_SGIS);
+ for (i = 0; i < n; i++) {
+ s[i] = CHAN_TO_FLOAT(rgba[i][RCOMP]);
+ t[i] = CHAN_TO_FLOAT(rgba[i][GCOMP]);
+ r[i] = CHAN_TO_FLOAT(rgba[i][BCOMP]);
+ }
+ }
+
+ if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_COLOR) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ q[i] = ctx->Current.RasterColor[ACOMP];
+ }
+ }
+ else {
+ GLuint i;
+ ASSERT(ctx->Pixel.FragmentAlphaSource == GL_PIXEL_GROUP_COLOR_SGIS);
+ for (i = 0; i < n; i++) {
+ q[i] = CHAN_TO_FLOAT(rgba[i][ACOMP]);
+ }
+ }
+}
--- /dev/null
+/* $Id: s_pixeltex.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 noti_mesa_PixelTexGenParameterfvce 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_PIXELTEX_H
+#define S_PIXELTEX_H
+
+#include "types.h"
+#include "swrast.h"
+
+extern void
+_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLchan rgba[][4],
+ GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[]);
+
+
+#endif
--- /dev/null
+/* $Id: s_points.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.4
+ *
+ * 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 "context.h"
+#include "feedback.h"
+#include "macros.h"
+#include "mmath.h"
+#include "texstate.h"
+#include "vb.h"
+
+#include "s_pb.h"
+#include "s_span.h"
+
+
+/**********************************************************************/
+/***** Rasterization *****/
+/**********************************************************************/
+
+
+/*
+ * There are 3 pairs (RGBA, CI) of point rendering functions:
+ * 1. simple: size=1 and no special rasterization functions (fastest)
+ * 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.
+ */
+
+
+
+
+
+/*
+ * CI points with size == 1.0
+ */
+static void
+size1_ci_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = ctx->PB;
+ GLfloat *win, *fog;
+ 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;
+ PB_CHECK_FLUSH(ctx, PB);
+}
+
+
+
+/*
+ * RGBA points with size == 1.0
+ */
+static void
+size1_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ 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 );
+ }
+ }
+ PB_CHECK_FLUSH(ctx, PB);
+}
+
+
+
+/*
+ * General CI points.
+ */
+static void
+general_ci_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = 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 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);
+
+ GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] );
+
+ 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] );
+
+ 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);
+ }
+ }
+}
+
+
+/*
+ * General RGBA points.
+ */
+static void
+general_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = 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 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);
+
+ GLfixed fog = FloatToFixed( VB->FogCoordPtr->data[i] );
+
+ 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] );
+
+ 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);
+ }
+ }
+}
+
+
+
+
+/*
+ * Textured RGBA points.
+ */
+static void
+textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ 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;
+ }
+
+ 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()");
+ }
+
+ 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 )
+{
+ 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;
+ }
+
+ 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");
+ }
+ }
+ }
+
+ 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);
+ }
+ }
+}
+
+
+/*
+ * NOTES on aa point rasterization:
+ *
+ * Let d = distance of fragment center from vertex.
+ * if d < rmin2 then
+ * fragment has 100% coverage
+ * else if d > rmax2 then
+ * fragment has 0% coverage
+ * else
+ * fragement has % coverage = (d - rmin2) / (rmax2 - rmin2)
+ */
+
+
+/*
+ * Antialiased points with or without texture mapping.
+ */
+static void
+antialiased_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = 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] );
+ }
+ }
+ }
+ }
+
+ 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);
+ }
+ }
+ }
+}
+
+
+
+/*
+ * 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)
+{
+ 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]));
+ }
+}
+
+
+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
+};
+
+
+
+/*
+ * Distance Attenuated General CI points.
+ */
+static void
+dist_atten_general_ci_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = ctx->PB;
+ GLfloat dist[VB_SIZE];
+ 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;
+ }
+
+ PB_SET_INDEX( PB, VB->IndexPtr->data[i] );
+
+ 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 )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = ctx->PB;
+ GLfloat dist[VB_SIZE];
+ 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;
+ }
+
+ PB_SET_COLOR( PB,
+ VB->ColorPtr->data[i][0],
+ VB->ColorPtr->data[i][1],
+ VB->ColorPtr->data[i][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);
+ }
+ }
+}
+
+/*
+ * Distance Attenuated Textured RGBA points.
+ */
+static void
+dist_atten_textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = ctx->PB;
+ GLfloat dist[VB_SIZE];
+ 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;
+ }
+
+ /* 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");
+ }
+ }
+ }
+
+ 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 )
+{
+ struct vertex_buffer *VB = ctx->VB;
+ struct pixel_buffer *PB = ctx->PB;
+ GLfloat dist[VB_SIZE];
+ 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];
+
+ /* 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");
+ }
+ }
+ }
+
+ 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);
+ }
+ }
+ }
+ 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);
+ }
+ }
+ }
+}
+
+
+#ifdef DEBUG
+void
+_mesa_print_points_function(GLcontext *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)
+ printf("NULL\n");
+ else
+ printf("Driver func %p\n", ctx->Driver.PointsFunc);
+}
+#endif
+
+
+/*
+ * Examine the current context to determine which point drawing function
+ * should be used.
+ */
+void
+_swrast_set_point_function( GLcontext *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.SmoothFlag && rgbmode) {
+ ctx->Driver.PointsFunc = antialiased_rgba_points;
+ }
+ 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;
+ }
+ else {
+ ctx->Driver.PointsFunc = textured_rgba_points;
+ }
+ }
+ else if (ctx->Point.Size==1.0) {
+ /* size=1, any raster ops */
+ if (rgbmode)
+ ctx->Driver.PointsFunc = size1_rgba_points;
+ else
+ ctx->Driver.PointsFunc = size1_ci_points;
+ }
+ else {
+ /* every other kind of point rendering */
+ if (rgbmode)
+ ctx->Driver.PointsFunc = general_rgba_points;
+ else
+ ctx->Driver.PointsFunc = general_ci_points;
+ }
+ }
+ else if(ctx->Point.SmoothFlag && rgbmode) {
+ ctx->Driver.PointsFunc = dist_atten_antialiased_rgba_points;
+ }
+ else if (ctx->Texture.ReallyEnabled) {
+ ctx->Driver.PointsFunc = dist_atten_textured_rgba_points;
+ }
+ else {
+ /* every other kind of point rendering */
+ if (rgbmode)
+ ctx->Driver.PointsFunc = dist_atten_general_rgba_points;
+ else
+ ctx->Driver.PointsFunc = dist_atten_general_ci_points;
+ }
+ }
+ else if (ctx->RenderMode==GL_FEEDBACK) {
+ ctx->Driver.PointsFunc = gl_feedback_points;
+ }
+ else {
+ /* GL_SELECT mode */
+ ctx->Driver.PointsFunc = gl_select_points;
+ }
+
+ /*_mesa_print_points_function(ctx);*/
+}
+
--- /dev/null
+/* $Id: s_readpix.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "convolve.h"
+#include "context.h"
+#include "feedback.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "pixel.h"
+
+#include "s_alphabuf.h"
+#include "s_depth.h"
+#include "s_span.h"
+#include "s_stencil.h"
+
+
+
+/*
+ * Read a block of color index pixels.
+ */
+static void read_index_pixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, GLvoid *pixels,
+ const struct gl_pixelstore_attrib *packing )
+{
+ GLint i, j, readWidth;
+
+ /* error checking */
+ if (ctx->Visual.RGBAflag) {
+ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+ return;
+ }
+
+ ASSERT(ctx->Driver.SetReadBuffer);
+ (*ctx->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer);
+
+ readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ /* process image row by row */
+ for (j=0;j<height;j++,y++) {
+ GLuint index[MAX_WIDTH];
+ GLvoid *dest;
+
+ (*ctx->Driver.ReadCI32Span)( ctx, readWidth, x, y, index );
+
+ if (ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0) {
+ _mesa_shift_and_offset_ci( ctx, readWidth, index);
+ }
+
+ if (ctx->Pixel.MapColorFlag) {
+ _mesa_map_ci(ctx, readWidth, index);
+ }
+
+ dest = _mesa_image_address(packing, pixels,
+ width, height, GL_COLOR_INDEX, type, 0, j, 0);
+
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ {
+ GLubyte *dst = (GLubyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ *dst++ = (GLubyte) index[i];
+ }
+ }
+ break;
+ case GL_BYTE:
+ {
+ GLbyte *dst = (GLbyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLbyte) index[i];
+ }
+ }
+ break;
+ case GL_UNSIGNED_SHORT:
+ {
+ GLushort *dst = (GLushort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLushort) index[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_SHORT:
+ {
+ GLshort *dst = (GLshort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLshort) index[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_UNSIGNED_INT:
+ {
+ GLuint *dst = (GLuint *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLuint) index[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_INT:
+ {
+ GLint *dst = (GLint *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLint) index[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_FLOAT:
+ {
+ GLfloat *dst = (GLfloat *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLfloat) index[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
+ j = height + 1; /* exit loop */
+ }
+ }
+
+ (*ctx->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+static void read_depth_pixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, GLvoid *pixels,
+ const struct gl_pixelstore_attrib *packing )
+{
+ GLint i, j, readWidth;
+ GLboolean bias_or_scale;
+
+ /* Error checking */
+ if (ctx->Visual.DepthBits <= 0) {
+ /* No depth buffer */
+ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+ return;
+ }
+
+ readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ if (type != GL_BYTE &&
+ type != GL_UNSIGNED_BYTE &&
+ type != GL_SHORT &&
+ type != GL_UNSIGNED_SHORT &&
+ type != GL_INT &&
+ type != GL_UNSIGNED_INT &&
+ type != GL_FLOAT) {
+ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels(depth type)");
+ return;
+ }
+
+ bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
+
+ if (type==GL_UNSIGNED_SHORT && ctx->Visual.DepthBits == 16
+ && !bias_or_scale && !packing->SwapBytes) {
+ /* Special case: directly read 16-bit unsigned depth values. */
+ for (j=0;j<height;j++,y++) {
+ GLdepth depth[MAX_WIDTH];
+ GLushort *dst = (GLushort*) _mesa_image_address( packing, pixels,
+ width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
+ GLint i;
+ _mesa_read_depth_span(ctx, width, x, y, depth);
+ for (i = 0; i < width; i++)
+ dst[i] = depth[i];
+ }
+ }
+ else if (type==GL_UNSIGNED_INT && ctx->Visual.DepthBits == 32
+ && !bias_or_scale && !packing->SwapBytes) {
+ /* Special case: directly read 32-bit unsigned depth values. */
+ for (j=0;j<height;j++,y++) {
+ GLdepth *dst = (GLdepth *) _mesa_image_address( packing, pixels,
+ width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
+ _mesa_read_depth_span(ctx, width, x, y, dst);
+ }
+ }
+ else {
+ /* General case (slower) */
+ for (j=0;j<height;j++,y++) {
+ GLfloat depth[MAX_WIDTH];
+ GLvoid *dest;
+
+ _mesa_read_depth_span_float(ctx, readWidth, x, y, depth);
+
+ if (bias_or_scale) {
+ for (i=0;i<readWidth;i++) {
+ GLfloat d;
+ d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+ depth[i] = CLAMP( d, 0.0F, 1.0F );
+ }
+ }
+
+ dest = _mesa_image_address(packing, pixels,
+ width, height, GL_DEPTH_COMPONENT, type, 0, j, 0);
+
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ {
+ GLubyte *dst = (GLubyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_UBYTE( depth[i] );
+ }
+ }
+ break;
+ case GL_BYTE:
+ {
+ GLbyte *dst = (GLbyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_BYTE( depth[i] );
+ }
+ }
+ break;
+ case GL_UNSIGNED_SHORT:
+ {
+ GLushort *dst = (GLushort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_USHORT( depth[i] );
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_SHORT:
+ {
+ GLshort *dst = (GLshort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_SHORT( depth[i] );
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_UNSIGNED_INT:
+ {
+ GLuint *dst = (GLuint *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_UINT( depth[i] );
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_INT:
+ {
+ GLint *dst = (GLint *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = FLOAT_TO_INT( depth[i] );
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_FLOAT:
+ {
+ GLfloat *dst = (GLfloat *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = depth[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
+ }
+ }
+ }
+}
+
+
+
+static void read_stencil_pixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum type, GLvoid *pixels,
+ const struct gl_pixelstore_attrib *packing )
+{
+ GLboolean shift_or_offset;
+ GLint i, j, readWidth;
+
+ if (type != GL_BYTE &&
+ type != GL_UNSIGNED_BYTE &&
+ type != GL_SHORT &&
+ type != GL_UNSIGNED_SHORT &&
+ type != GL_INT &&
+ type != GL_UNSIGNED_INT &&
+ type != GL_FLOAT &&
+ type != GL_BITMAP) {
+ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels(stencil type)");
+ return;
+ }
+
+ readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ if (ctx->Visual.StencilBits<=0) {
+ /* No stencil buffer */
+ gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+ return;
+ }
+
+ shift_or_offset = ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0;
+
+ /* process image row by row */
+ for (j=0;j<height;j++,y++) {
+ GLvoid *dest;
+ GLstencil stencil[MAX_WIDTH];
+
+ _mesa_read_stencil_span( ctx, readWidth, x, y, stencil );
+
+ if (shift_or_offset) {
+ _mesa_shift_and_offset_stencil( ctx, readWidth, stencil );
+ }
+
+ if (ctx->Pixel.MapStencilFlag) {
+ _mesa_map_stencil( ctx, readWidth, stencil );
+ }
+
+ dest = _mesa_image_address( packing, pixels,
+ width, height, GL_STENCIL_INDEX, type, 0, j, 0 );
+
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ if (sizeof(GLstencil) == 8) {
+ MEMCPY( dest, stencil, readWidth );
+ }
+ else {
+ GLubyte *dst = (GLubyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLubyte) stencil[i];
+ }
+ }
+ break;
+ case GL_BYTE:
+ if (sizeof(GLstencil) == 8) {
+ MEMCPY( dest, stencil, readWidth );
+ }
+ else {
+ GLbyte *dst = (GLbyte *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLbyte) stencil[i];
+ }
+ }
+ break;
+ case GL_UNSIGNED_SHORT:
+ {
+ GLushort *dst = (GLushort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLushort) stencil[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_SHORT:
+ {
+ GLshort *dst = (GLshort *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLshort) stencil[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap2( (GLushort *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_UNSIGNED_INT:
+ {
+ GLuint *dst = (GLuint *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLuint) stencil[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_INT:
+ {
+ GLint *dst = (GLint *) dest;
+ for (i=0;i<readWidth;i++) {
+ *dst++ = (GLint) stencil[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_FLOAT:
+ {
+ GLfloat *dst = (GLfloat *) dest;
+ for (i=0;i<readWidth;i++) {
+ dst[i] = (GLfloat) stencil[i];
+ }
+ if (packing->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, readWidth );
+ }
+ }
+ break;
+ case GL_BITMAP:
+ if (packing->LsbFirst) {
+ GLubyte *dst = (GLubyte*) dest;
+ GLint shift = 0;
+ for (i = 0; i < readWidth; i++) {
+ if (shift == 0)
+ *dst = 0;
+ *dst |= ((stencil != 0) << shift);
+ shift++;
+ if (shift == 8) {
+ shift = 0;
+ dst++;
+ }
+ }
+ }
+ else {
+ GLubyte *dst = (GLubyte*) dest;
+ GLint shift = 7;
+ for (i = 0; i < readWidth; i++) {
+ if (shift == 7)
+ *dst = 0;
+ *dst |= ((stencil != 0) << shift);
+ shift--;
+ if (shift < 0) {
+ shift = 7;
+ dst++;
+ }
+ }
+ }
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
+ }
+ }
+}
+
+
+
+/*
+ * Optimized glReadPixels for particular pixel formats:
+ * GL_UNSIGNED_BYTE, GL_RGBA
+ * when pixel scaling, biasing and mapping are disabled.
+ */
+static GLboolean
+read_fast_rgba_pixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ GLvoid *pixels,
+ const struct gl_pixelstore_attrib *packing )
+{
+ /* can't do scale, bias, mapping, etc */
+ if (ctx->ImageTransferState)
+ return GL_FALSE;
+
+ /* can't do fancy pixel packing */
+ if (packing->Alignment != 1 || packing->SwapBytes || packing->LsbFirst)
+ return GL_FALSE;
+
+ {
+ GLint srcX = x;
+ GLint srcY = y;
+ GLint readWidth = width; /* actual width read */
+ GLint readHeight = height; /* actual height read */
+ GLint skipPixels = packing->SkipPixels;
+ GLint skipRows = packing->SkipRows;
+ GLint rowLength;
+
+ if (packing->RowLength > 0)
+ rowLength = packing->RowLength;
+ else
+ rowLength = width;
+
+ /* horizontal clipping */
+ if (srcX < ctx->ReadBuffer->Xmin) {
+ skipPixels += (ctx->ReadBuffer->Xmin - srcX);
+ readWidth -= (ctx->ReadBuffer->Xmin - srcX);
+ srcX = ctx->ReadBuffer->Xmin;
+ }
+ if (srcX + readWidth > ctx->ReadBuffer->Xmax)
+ readWidth -= (srcX + readWidth - ctx->ReadBuffer->Xmax);
+ if (readWidth <= 0)
+ return GL_TRUE;
+
+ /* vertical clipping */
+ if (srcY < ctx->ReadBuffer->Ymin) {
+ skipRows += (ctx->ReadBuffer->Ymin - srcY);
+ readHeight -= (ctx->ReadBuffer->Ymin - srcY);
+ srcY = ctx->ReadBuffer->Ymin;
+ }
+ if (srcY + readHeight > ctx->ReadBuffer->Ymax)
+ readHeight -= (srcY + readHeight - ctx->ReadBuffer->Ymax);
+ if (readHeight <= 0)
+ return GL_TRUE;
+
+ /*
+ * Ready to read!
+ * The window region at (destX, destY) of size (readWidth, readHeight)
+ * will be read back.
+ * We'll write pixel data to buffer pointed to by "pixels" but we'll
+ * skip "skipRows" rows and skip "skipPixels" pixels/row.
+ */
+#if CHAN_BITS == 8
+ if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+#elif CHAN_BITS == 16
+ if (format == GL_RGBA && type == GL_UNSIGNED_SHORT) {
+#else
+ if (0) {
+#endif
+ GLchan *dest = (GLchan *) pixels
+ + (skipRows * rowLength + skipPixels) * 4;
+ GLint row;
+ for (row=0; row<readHeight; row++) {
+ (*ctx->Driver.ReadRGBASpan)(ctx, readWidth, srcX, srcY,
+ (GLchan (*)[4]) dest);
+ if (ctx->DrawBuffer->UseSoftwareAlphaBuffers) {
+ _mesa_read_alpha_span(ctx, readWidth, srcX, srcY,
+ (GLchan (*)[4]) dest);
+ }
+ dest += rowLength * 4;
+ srcY++;
+ }
+ return GL_TRUE;
+ }
+ else {
+ /* can't do this format/type combination */
+ return GL_FALSE;
+ }
+ }
+}
+
+
+
+/*
+ * Read R, G, B, A, RGB, L, or LA pixels.
+ */
+static void read_rgba_pixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type, GLvoid *pixels,
+ const struct gl_pixelstore_attrib *packing )
+{
+ GLint readWidth;
+
+ (*ctx->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer);
+
+ /* Try optimized path first */
+ if (read_fast_rgba_pixels( ctx, x, y, width, height,
+ format, type, pixels, packing )) {
+
+ (*ctx->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
+ return; /* done! */
+ }
+
+ readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+ /* do error checking on pixel type, format was already checked by caller */
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ case GL_BYTE:
+ case GL_UNSIGNED_SHORT:
+ case GL_SHORT:
+ case GL_UNSIGNED_INT:
+ case GL_INT:
+ case GL_FLOAT:
+ case GL_UNSIGNED_BYTE_3_3_2:
+ case GL_UNSIGNED_BYTE_2_3_3_REV:
+ case GL_UNSIGNED_SHORT_5_6_5:
+ case GL_UNSIGNED_SHORT_5_6_5_REV:
+ case GL_UNSIGNED_SHORT_4_4_4_4:
+ case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+ case GL_UNSIGNED_SHORT_5_5_5_1:
+ case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+ case GL_UNSIGNED_INT_8_8_8_8:
+ case GL_UNSIGNED_INT_8_8_8_8_REV:
+ case GL_UNSIGNED_INT_10_10_10_2:
+ case GL_UNSIGNED_INT_2_10_10_10_REV:
+ /* valid pixel type */
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
+ return;
+ }
+
+ if (!_mesa_is_legal_format_and_type(format, type) ||
+ format == GL_INTENSITY) {
+ gl_error(ctx, GL_INVALID_OPERATION, "glReadPixels(format or type)");
+ return;
+ }
+
+ if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+ const GLuint transferOps = ctx->ImageTransferState;
+ GLfloat *dest, *src, *tmpImage, *convImage;
+ GLint row;
+
+ tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!tmpImage) {
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+ return;
+ }
+ convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+ if (!convImage) {
+ FREE(tmpImage);
+ gl_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+ return;
+ }
+
+ /* read full RGBA, FLOAT image */
+ dest = tmpImage;
+ for (row = 0; row < height; row++, y++) {
+ GLchan rgba[MAX_WIDTH][4];
+ if (ctx->Visual.RGBAflag) {
+ gl_read_rgba_span(ctx, ctx->ReadBuffer, readWidth, x, y, rgba);
+ }
+ else {
+ GLuint index[MAX_WIDTH];
+ (*ctx->Driver.ReadCI32Span)(ctx, readWidth, x, y, index);
+ if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset !=0 ) {
+ _mesa_map_ci(ctx, readWidth, index);
+ }
+ _mesa_map_ci_to_rgba_chan(ctx, readWidth, index, rgba);
+ }
+ _mesa_pack_rgba_span(ctx, readWidth, (const GLchan (*)[4]) rgba,
+ GL_RGBA, GL_FLOAT, dest, &_mesa_native_packing,
+ transferOps & IMAGE_PRE_CONVOLUTION_BITS);
+ dest += width * 4;
+ }
+
+ /* do convolution */
+ if (ctx->Pixel.Convolution2DEnabled) {
+ _mesa_convolve_2d_image(ctx, &readWidth, &height, tmpImage, convImage);
+ }
+ else {
+ ASSERT(ctx->Pixel.Separable2DEnabled);
+ _mesa_convolve_sep_image(ctx, &readWidth, &height, tmpImage, convImage);
+ }
+ FREE(tmpImage);
+
+ /* finish transfer ops and pack the resulting image */
+ src = convImage;
+ for (row = 0; row < height; row++) {
+ GLvoid *dest;
+ dest = _mesa_image_address(packing, pixels, width, height,
+ format, type, 0, row, 0);
+ _mesa_pack_float_rgba_span(ctx, readWidth,
+ (const GLfloat (*)[4]) src,
+ format, type, dest, packing,
+ transferOps & IMAGE_POST_CONVOLUTION_BITS);
+ src += readWidth * 4;
+ }
+ }
+ else {
+ /* no convolution */
+ GLint row;
+ for (row = 0; row < height; row++, y++) {
+ GLchan rgba[MAX_WIDTH][4];
+ GLvoid *dst;
+ if (ctx->Visual.RGBAflag) {
+ gl_read_rgba_span(ctx, ctx->ReadBuffer, readWidth, x, y, rgba);
+ }
+ else {
+ GLuint index[MAX_WIDTH];
+ (*ctx->Driver.ReadCI32Span)(ctx, readWidth, x, y, index);
+ if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
+ _mesa_map_ci(ctx, readWidth, index);
+ }
+ _mesa_map_ci_to_rgba_chan(ctx, readWidth, index, rgba);
+ }
+ dst = _mesa_image_address(packing, pixels, width, height,
+ format, type, 0, row, 0);
+ _mesa_pack_rgba_span(ctx, readWidth, (const GLchan (*)[4]) rgba,
+ format, type, dst, packing,
+ ctx->ImageTransferState);
+ }
+ }
+
+ (*ctx->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+void
+_swrast_ReadPixels( GLcontext *ctx,
+ GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ const struct gl_pixelstore_attrib *pack,
+ GLvoid *pixels )
+{
+ (void) pack;
+
+ switch (format) {
+ case GL_COLOR_INDEX:
+ read_index_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
+ break;
+ case GL_STENCIL_INDEX:
+ read_stencil_pixels(ctx, x,y, width,height, type, pixels, &ctx->Pack);
+ break;
+ case GL_DEPTH_COMPONENT:
+ read_depth_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
+ break;
+ case GL_RED:
+ case GL_GREEN:
+ case GL_BLUE:
+ case GL_ALPHA:
+ case GL_RGB:
+ case GL_LUMINANCE:
+ case GL_LUMINANCE_ALPHA:
+ case GL_RGBA:
+ case GL_BGR:
+ case GL_BGRA:
+ case GL_ABGR_EXT:
+ read_rgba_pixels(ctx, x, y, width, height,
+ format, type, pixels, &ctx->Pack);
+ break;
+ default:
+ gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(format)" );
+ }
+}
--- /dev/null
+/* $Id: s_span.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * pixel span rasterization:
+ * These functions implement the rasterization pipeline.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_alpha.h"
+#include "s_alphabuf.h"
+#include "s_blend.h"
+#include "s_depth.h"
+#include "s_fog.h"
+#include "s_logic.h"
+#include "s_masking.h"
+#include "s_scissor.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+
+
+
+
+/*
+ * Apply the current polygon stipple pattern to a span of pixels.
+ */
+static void stipple_polygon_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLubyte mask[] )
+{
+ register GLuint i, m, stipple, highbit=0x80000000;
+
+ stipple = ctx->PolygonStipple[y % 32];
+ m = highbit >> (GLuint) (x % 32);
+
+ for (i=0;i<n;i++) {
+ if ((m & stipple)==0) {
+ mask[i] = 0;
+ }
+ m = m >> 1;
+ if (m==0) {
+ m = 0x80000000;
+ }
+ }
+}
+
+
+
+/*
+ * Clip a pixel span to the current buffer/window boundaries.
+ * Return: 0 = all pixels clipped
+ * 1 = at least one pixel is visible
+ */
+static GLuint clip_span( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLubyte mask[] )
+{
+ GLint i;
+
+ /* Clip to top and bottom */
+ if (y < 0 || y >= ctx->DrawBuffer->Height) {
+ return 0;
+ }
+
+ /* Clip to left and right */
+ if (x >= 0 && x + n <= ctx->DrawBuffer->Width) {
+ /* no clipping needed */
+ return 1;
+ }
+ else if (x + n <= 0) {
+ /* completely off left side */
+ return 0;
+ }
+ else if (x >= ctx->DrawBuffer->Width) {
+ /* completely off right side */
+ return 0;
+ }
+ else {
+ /* clip-test each pixel, this could be done better */
+ for (i=0;i<n;i++) {
+ if (x + i < 0 || x + i >= ctx->DrawBuffer->Width) {
+ mask[i] = 0;
+ }
+ }
+ return 1;
+ }
+}
+
+
+
+/*
+ * Draw to more than one color buffer (or none).
+ */
+static void multi_write_index_span( GLcontext *ctx, GLuint n,
+ GLint x, GLint y, const GLuint indexes[],
+ const GLubyte mask[] )
+{
+ GLuint bufferBit;
+
+ if (ctx->Color.DrawBuffer == GL_NONE)
+ return;
+
+ /* loop over four possible dest color buffers */
+ for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+ if (bufferBit & ctx->Color.DrawDestMask) {
+ GLuint indexTmp[MAX_WIDTH];
+ ASSERT(n < MAX_WIDTH);
+
+ if (bufferBit == FRONT_LEFT_BIT)
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+ else if (bufferBit == FRONT_RIGHT_BIT)
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+ else if (bufferBit == BACK_LEFT_BIT)
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+ else
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+
+ /* make copy of incoming indexes */
+ MEMCPY( indexTmp, indexes, n * sizeof(GLuint) );
+ if (ctx->Color.IndexLogicOpEnabled) {
+ _mesa_logicop_ci_span( ctx, n, x, y, indexTmp, mask );
+ }
+ if (ctx->Color.IndexMask == 0) {
+ break;
+ }
+ else if (ctx->Color.IndexMask != 0xffffffff) {
+ _mesa_mask_index_span( ctx, n, x, y, indexTmp );
+ }
+ (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexTmp, mask );
+ }
+ }
+
+ /* restore default dest buffer */
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+/*
+ * Write a horizontal span of color index pixels to the frame buffer.
+ * Stenciling, Depth-testing, etc. are done as needed.
+ * Input: n - number of pixels in the span
+ * x, y - location of leftmost pixel in the span
+ * z - array of [n] z-values
+ * index - array of [n] color indexes
+ * primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
+ */
+void gl_write_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed fog[],
+ GLuint indexIn[], GLenum primitive )
+{
+ const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT | LOGIC_OP_BIT;
+ GLubyte mask[MAX_WIDTH];
+ GLuint indexBackup[MAX_WIDTH];
+ GLuint *index; /* points to indexIn or indexBackup */
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span(ctx,n,x,y,mask)==0) {
+ return;
+ }
+ }
+
+ if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
+ || (ctx->RasterMask & MULTI_DRAW_BIT)) {
+ /* Make copy of color indexes */
+ MEMCPY( indexBackup, indexIn, n * sizeof(GLuint) );
+ index = indexBackup;
+ }
+ else {
+ index = indexIn;
+ }
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_ci_pixels( ctx, n, fog, index );
+ else
+ _mesa_depth_fog_ci_pixels( ctx, n, z, index );
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0) return;
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* draw to zero or two or more buffers */
+ multi_write_index_span( ctx, n, x, y, index, mask );
+ }
+ else {
+ /* normal situation: draw to exactly one buffer */
+ if (ctx->Color.IndexLogicOpEnabled) {
+ _mesa_logicop_ci_span( ctx, n, x, y, index, mask );
+ }
+
+ if (ctx->Color.IndexMask == 0) {
+ return;
+ }
+ else if (ctx->Color.IndexMask != 0xffffffff) {
+ _mesa_mask_index_span( ctx, n, x, y, index );
+ }
+
+ /* write pixels */
+ (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, index, mask );
+ }
+}
+
+
+
+
+void gl_write_monoindex_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ GLuint index, GLenum primitive )
+{
+ GLubyte mask[MAX_WIDTH];
+ GLuint i;
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span( ctx, n, x, y, mask)==0) {
+ return;
+ }
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0) return;
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->Color.DrawBuffer == GL_NONE) {
+ /* write no pixels */
+ return;
+ }
+
+ if (ctx->Fog.Enabled
+ || ctx->Color.IndexLogicOpEnabled
+ || ctx->Color.IndexMask != 0xffffffff) {
+ /* different index per pixel */
+ GLuint indexes[MAX_WIDTH];
+ for (i=0;i<n;i++) {
+ indexes[i] = index;
+ }
+
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_ci_pixels( ctx, n, fog, indexes );
+ else
+ _mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
+ }
+
+ if (ctx->Color.IndexLogicOpEnabled) {
+ _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
+ }
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* draw to zero or two or more buffers */
+ multi_write_index_span( ctx, n, x, y, indexes, mask );
+ }
+ else {
+ /* normal situation: draw to exactly one buffer */
+ if (ctx->Color.IndexLogicOpEnabled) {
+ _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
+ }
+ if (ctx->Color.IndexMask == 0) {
+ return;
+ }
+ else if (ctx->Color.IndexMask != 0xffffffff) {
+ _mesa_mask_index_span( ctx, n, x, y, indexes );
+ }
+ (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
+ }
+ }
+ else {
+ /* same color index for all pixels */
+ ASSERT(!ctx->Color.IndexLogicOpEnabled);
+ ASSERT(ctx->Color.IndexMask == 0xffffffff);
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ /* draw to zero or two or more buffers */
+ GLuint indexes[MAX_WIDTH];
+ for (i=0;i<n;i++)
+ indexes[i] = index;
+ multi_write_index_span( ctx, n, x, y, indexes, mask );
+ }
+ else {
+ /* normal situation: draw to exactly one buffer */
+ (*ctx->Driver.WriteMonoCISpan)( ctx, n, x, y, mask );
+ }
+ }
+}
+
+
+
+/*
+ * Draw to more than one RGBA color buffer (or none).
+ */
+static void multi_write_rgba_span( GLcontext *ctx, GLuint n,
+ GLint x, GLint y, CONST GLchan rgba[][4],
+ const GLubyte mask[] )
+{
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+ GLuint bufferBit;
+
+ if (ctx->Color.DrawBuffer == GL_NONE)
+ return;
+
+ /* loop over four possible dest color buffers */
+ for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+ if (bufferBit & ctx->Color.DrawDestMask) {
+ GLchan rgbaTmp[MAX_WIDTH][4];
+ ASSERT(n < MAX_WIDTH);
+
+ if (bufferBit == FRONT_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
+ }
+ else if (bufferBit == FRONT_RIGHT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
+ }
+ else if (bufferBit == BACK_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
+ }
+ else {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
+ }
+
+ /* make copy of incoming colors */
+ MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLchan) );
+
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgbaTmp, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgbaTmp, mask );
+ }
+ if (colorMask == 0x0) {
+ break;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
+ }
+
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (const GLchan (*)[4]) rgbaTmp, mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4])rgbaTmp, mask );
+ }
+ }
+ }
+
+ /* restore default dest buffer */
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
+}
+
+
+
+void gl_write_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ GLchan rgbaIn[][4],
+ GLenum primitive )
+{
+ const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
+ LOGIC_OP_BIT | TEXTURE_BIT;
+ GLubyte mask[MAX_WIDTH];
+ GLboolean write_all = GL_TRUE;
+ GLchan rgbaBackup[MAX_WIDTH][4];
+ GLchan (*rgba)[4];
+ const GLubyte *Null = 0;
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span( ctx,n,x,y,mask)==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
+ || (ctx->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;
+ }
+ else {
+ rgba = rgbaIn;
+ }
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ write_all = GL_FALSE;
+ }
+
+ /* Do the alpha test */
+ if (ctx->Color.AlphaEnabled) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ if (m==0) {
+ return;
+ }
+ if (m<n) {
+ write_all = GL_FALSE;
+ }
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ /* normal: write to exactly one buffer */
+ /* logic op or blending */
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ }
+
+ /* Color component masking */
+ if (colorMask == 0x0) {
+ return;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ }
+
+ /* write pixels */
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? Null : mask );
+
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? Null : mask );
+ }
+
+ }
+}
+
+
+
+/*
+ * Write a horizontal span of color pixels to the frame buffer.
+ * The color is initially constant for the whole span.
+ * Alpha-testing, stenciling, depth-testing, and blending are done as needed.
+ * Input: n - number of pixels in the span
+ * x, y - location of leftmost pixel in the span
+ * z - array of [n] z-values
+ * r, g, b, a - the color of the pixels
+ * primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
+ */
+void gl_write_monocolor_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed fog[],
+ const GLchan color[4],
+ GLenum primitive )
+{
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+ GLuint i;
+ GLubyte mask[MAX_WIDTH];
+ GLboolean write_all = GL_TRUE;
+ GLchan rgba[MAX_WIDTH][4];
+ const GLubyte *Null = 0;
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span( ctx,n,x,y,mask)==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ write_all = GL_FALSE;
+ }
+
+ /* Do the alpha test */
+ if (ctx->Color.AlphaEnabled) {
+ for (i=0;i<n;i++) {
+ rgba[i][ACOMP] = color[ACOMP];
+ }
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ if (m==0) {
+ return;
+ }
+ if (m<n) {
+ write_all = GL_FALSE;
+ }
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->Color.DrawBuffer == GL_NONE) {
+ /* write no pixels */
+ return;
+ }
+
+ if (ctx->Color.ColorLogicOpEnabled || colorMask != 0xffffffff ||
+ (ctx->RasterMask & (BLEND_BIT | FOG_BIT))) {
+ /* assign same color to each pixel */
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ COPY_CHAN4(rgba[i], color);
+ }
+ }
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ multi_write_rgba_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ /* normal: write to exactly one buffer */
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ }
+
+ /* Color component masking */
+ if (colorMask == 0x0) {
+ return;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ }
+
+ /* write pixels */
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? Null : mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? Null : mask );
+ }
+ }
+ }
+ else {
+ /* same color for all pixels */
+ ASSERT(!ctx->Color.BlendEnabled);
+ ASSERT(!ctx->Color.ColorLogicOpEnabled);
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ COPY_CHAN4(rgba[i], color);
+ }
+ }
+ multi_write_rgba_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_mono_alpha_span( ctx, n, x, y, (GLchan) color[ACOMP],
+ write_all ? Null : mask );
+ }
+ }
+ }
+}
+
+
+
+/*
+ * Add specular color to base color. This is used only when
+ * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
+ */
+static void add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
+{
+ GLuint i;
+ for (i=0; i<n; i++) {
+ GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
+ GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
+ GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+ }
+}
+
+
+/*
+ * Write a horizontal span of textured pixels to the frame buffer.
+ * The color of each pixel is different.
+ * Alpha-testing, stenciling, depth-testing, and blending are done
+ * as needed.
+ * Input: n - number of pixels in the span
+ * x, y - location of leftmost pixel in the span
+ * z - array of [n] z-values
+ * s, t - array of (s,t) texture coordinates for each pixel
+ * lambda - array of texture lambda values
+ * rgba - array of [n] color components
+ * primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
+ */
+void gl_write_texture_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed fog[],
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], GLfloat lambda[],
+ GLchan rgbaIn[][4], CONST GLchan spec[][4],
+ GLenum primitive )
+{
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+ GLubyte mask[MAX_WIDTH];
+ GLboolean write_all = GL_TRUE;
+ GLchan rgbaBackup[MAX_WIDTH][4];
+ GLchan (*rgba)[4]; /* points to either rgbaIn or rgbaBackup */
+ const GLubyte *Null = 0;
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span(ctx, n, x, y, mask)==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+
+ if (primitive==GL_BITMAP || (ctx->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;
+ }
+ else {
+ rgba = rgbaIn;
+ }
+
+ /* Texture */
+ ASSERT(ctx->Texture.ReallyEnabled);
+ gl_texture_pixels( ctx, 0, n, s, t, u, lambda, rgba, rgba );
+
+ /* Add base and specular colors */
+ if (spec && ctx->Light.Enabled
+ && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+ add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ write_all = GL_FALSE;
+ }
+
+ /* Do the alpha test */
+ if (ctx->Color.AlphaEnabled) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ if (m==0) {
+ return;
+ }
+ if (m<n) {
+ write_all = GL_FALSE;
+ }
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ /* normal: write to exactly one buffer */
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ }
+ if (colorMask == 0x0) {
+ return;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ }
+
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
+ write_all ? Null : mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4]) rgba,
+ write_all ? Null : mask );
+ }
+ }
+}
+
+
+
+/*
+ * As above but perform multiple stages of texture application.
+ */
+void
+gl_write_multitexture_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ GLfloat lambda[][MAX_WIDTH],
+ GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
+ CONST GLchan spec[MAX_TEXTURE_UNITS][4],
+ GLenum primitive )
+{
+ GLubyte mask[MAX_WIDTH];
+ GLboolean write_all = GL_TRUE;
+ GLchan rgbaBackup[MAX_WIDTH][4];
+ GLchan (*rgba)[4]; /* points to either rgbaIn or rgbaBackup */
+ GLuint i;
+ const GLubyte *Null = 0;
+ const GLuint texUnits = ctx->Const.MaxTextureUnits;
+
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(mask, 1, n);
+
+ if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span(ctx, n, x, y, mask)==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+
+ if (primitive==GL_BITMAP || (ctx->RasterMask & MULTI_DRAW_BIT)
+ || texUnits > 1) {
+ /* must make a copy of the colors since they may be modified */
+ MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
+ rgba = rgbaBackup;
+ }
+ else {
+ rgba = rgbaIn;
+ }
+
+ /* Texture */
+ ASSERT(ctx->Texture.ReallyEnabled);
+ for (i = 0; i < texUnits; i++)
+ gl_texture_pixels( ctx, i, n, s[i], t[i], u[i], lambda[i], rgbaIn, rgba );
+
+ /* Add base and specular colors */
+ if (spec && ctx->Light.Enabled
+ && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+ add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && ctx->Hint.Fog != GL_NICEST)
+ _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (gl_scissor_span( ctx, n, x, y, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, n, x, y, mask );
+ write_all = GL_FALSE;
+ }
+
+ /* Do the alpha test */
+ if (ctx->Color.AlphaEnabled) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask )==0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ if (m==0) {
+ return;
+ }
+ if (m<n) {
+ write_all = GL_FALSE;
+ }
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->RasterMask & MULTI_DRAW_BIT) {
+ multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ /* normal: write to exactly one buffer */
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ }
+
+ if (colorMask == 0x0) {
+ return;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ }
+
+ (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba, write_all ? Null : mask );
+ if (ctx->RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4])rgba,
+ write_all ? Null : mask );
+ }
+ }
+}
+
+
+
+/*
+ * Read RGBA pixels from frame buffer. Clipping will be done to prevent
+ * reading ouside the buffer's boundaries.
+ */
+void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] )
+{
+ if (y < 0 || y >= buffer->Height
+ || x + (GLint) n < 0 || x >= buffer->Width) {
+ /* completely above, below, or right */
+ /* XXX maybe leave undefined? */
+ BZERO(rgba, 4 * n * sizeof(GLchan));
+ }
+ else {
+ GLint skip, length;
+ if (x < 0) {
+ /* left edge clippping */
+ skip = -x;
+ length = (GLint) n - skip;
+ if (length < 0) {
+ /* completely left of window */
+ return;
+ }
+ if (length > buffer->Width) {
+ length = buffer->Width;
+ }
+ }
+ else if ((GLint) (x + n) > buffer->Width) {
+ /* right edge clipping */
+ skip = 0;
+ length = buffer->Width - x;
+ if (length < 0) {
+ /* completely to right of window */
+ return;
+ }
+ }
+ else {
+ /* no clipping */
+ skip = 0;
+ length = (GLint) n;
+ }
+
+ (*ctx->Driver.ReadRGBASpan)( ctx, length, x + skip, y, rgba + skip );
+ if (buffer->UseSoftwareAlphaBuffers) {
+ _mesa_read_alpha_span( ctx, length, x + skip, y, rgba + skip );
+ }
+ }
+}
+
+
+
+
+/*
+ * Read CI pixels from frame buffer. Clipping will be done to prevent
+ * reading ouside the buffer's boundaries.
+ */
+void gl_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y, GLuint indx[] )
+{
+ if (y < 0 || y >= buffer->Height
+ || x + (GLint) n < 0 || x >= buffer->Width) {
+ /* completely above, below, or right */
+ BZERO(indx, n * sizeof(GLuint));
+ }
+ else {
+ GLint skip, length;
+ if (x < 0) {
+ /* left edge clippping */
+ skip = -x;
+ length = (GLint) n - skip;
+ if (length < 0) {
+ /* completely left of window */
+ return;
+ }
+ if (length > buffer->Width) {
+ length = buffer->Width;
+ }
+ }
+ else if ((GLint) (x + n) > buffer->Width) {
+ /* right edge clipping */
+ skip = 0;
+ length = buffer->Width - x;
+ if (length < 0) {
+ /* completely to right of window */
+ return;
+ }
+ }
+ else {
+ /* no clipping */
+ skip = 0;
+ length = (GLint) n;
+ }
+
+ (*ctx->Driver.ReadCI32Span)( ctx, length, skip + x, y, indx + skip );
+ }
+}
--- /dev/null
+/* $Id: s_span.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+
+
+
+#ifndef S_SPAN_H
+#define S_SPAN_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void gl_write_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed fog[],
+ GLuint index[], GLenum primitive );
+
+
+extern void gl_write_monoindex_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ GLuint index, GLenum primitive );
+
+
+extern void gl_write_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed fog[],
+ GLchan rgba[][4], GLenum primitive );
+
+
+extern void gl_write_monocolor_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ const GLchan color[4],
+ GLenum primitive );
+
+
+extern void gl_write_texture_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], GLfloat lambda[],
+ GLchan rgba[][4], CONST GLchan spec[][4],
+ GLenum primitive );
+
+
+extern void
+gl_write_multitexture_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLdepth z[],
+ const GLfixed fog[],
+ CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ GLchan rgba[][4],
+ CONST GLchan spec[][4],
+ GLenum primitive );
+
+
+extern void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] );
+
+
+extern void gl_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+ GLuint n, GLint x, GLint y, GLuint indx[] );
+
+
+#endif
--- /dev/null
+/* $Id: s_stencil.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_depth.h"
+#include "s_pb.h"
+#include "s_stencil.h"
+
+
+
+
+
+/* Stencil Logic:
+
+IF stencil test fails THEN
+ Apply fail-op to stencil value
+ Don't write the pixel (RGBA,Z)
+ELSE
+ IF doing depth test && depth test fails THEN
+ Apply zfail-op to stencil value
+ Write RGBA and Z to appropriate buffers
+ ELSE
+ Apply zpass-op to stencil value
+ENDIF
+
+*/
+
+
+
+
+/*
+ * Return the address of a stencil buffer value given the window coords:
+ */
+#define STENCIL_ADDRESS(X,Y) \
+ (ctx->DrawBuffer->Stencil + ctx->DrawBuffer->Width * (Y) + (X))
+
+
+
+/*
+ * Apply the given stencil operator to the array of stencil values.
+ * Don't touch stencil[i] if mask[i] is zero.
+ * Input: n - size of stencil array
+ * oper - the stencil buffer operator
+ * stencil - array of stencil values
+ * mask - array [n] of flag: 1=apply operator, 0=don't apply operator
+ * Output: stencil - modified values
+ */
+static void apply_stencil_op( const GLcontext *ctx, GLenum oper,
+ GLuint n, GLstencil stencil[],
+ const GLubyte mask[] )
+{
+ const GLstencil ref = ctx->Stencil.Ref;
+ const GLstencil wrtmask = ctx->Stencil.WriteMask;
+ const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+ GLuint i;
+
+ switch (oper) {
+ case GL_KEEP:
+ /* do nothing */
+ break;
+ case GL_ZERO:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ stencil[i] = 0;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ stencil[i] = (GLstencil) (stencil[i] & invmask);
+ }
+ }
+ }
+ break;
+ case GL_REPLACE:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ stencil[i] = ref;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));
+ }
+ }
+ }
+ break;
+ case GL_INCR:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ if (s < STENCIL_MAX) {
+ stencil[i] = (GLstencil) (s+1);
+ }
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ /* VERIFY logic of adding 1 to a write-masked value */
+ GLstencil s = stencil[i];
+ if (s < STENCIL_MAX) {
+ stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
+ }
+ }
+ }
+ }
+ break;
+ case GL_DECR:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ if (s>0) {
+ stencil[i] = (GLstencil) (s-1);
+ }
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ /* VERIFY logic of subtracting 1 to a write-masked value */
+ GLstencil s = stencil[i];
+ if (s>0) {
+ stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
+ }
+ }
+ }
+ }
+ break;
+ case GL_INCR_WRAP_EXT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ stencil[i]++;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
+ }
+ }
+ }
+ break;
+ case GL_DECR_WRAP_EXT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ stencil[i]--;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
+ }
+ }
+ }
+ break;
+ case GL_INVERT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ stencil[i] = (GLstencil) ~s;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil s = stencil[i];
+ stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));
+ }
+ }
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad stencil op in apply_stencil_op");
+ }
+}
+
+
+
+
+/*
+ * Apply stencil test to an array of stencil values (before depth buffering).
+ * Input: n - number of pixels in the array
+ * stencil - array of [n] stencil values
+ * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel
+ * Output: mask - pixels which fail the stencil test will have their
+ * mask flag set to 0.
+ * stencil - updated stencil values (where the test passed)
+ * Return: GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
+ */
+static GLboolean
+do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
+ GLubyte mask[] )
+{
+ GLubyte fail[PB_SIZE];
+ GLboolean allfail = GL_FALSE;
+ GLuint i;
+ GLstencil r, s;
+
+ ASSERT(n <= PB_SIZE);
+
+ /*
+ * Perform stencil test. The results of this operation are stored
+ * in the fail[] array:
+ * IF fail[i] is non-zero THEN
+ * the stencil fail operator is to be applied
+ * ELSE
+ * the stencil fail operator is not to be applied
+ * ENDIF
+ */
+ switch (ctx->Stencil.Function) {
+ case GL_NEVER:
+ /* always fail */
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ mask[i] = 0;
+ fail[i] = 1;
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ allfail = GL_TRUE;
+ break;
+ case GL_LESS:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r < s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r <= s) {
+ /* pass */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_GREATER:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r > s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r >= s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_EQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r == s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+ if (r != s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ /* always pass */
+ for (i=0;i<n;i++) {
+ fail[i] = 0;
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad stencil func in gl_stencil_span");
+ return 0;
+ }
+
+ if (ctx->Stencil.FailFunc != GL_KEEP) {
+ apply_stencil_op( ctx, ctx->Stencil.FailFunc, n, stencil, fail );
+ }
+
+ return !allfail;
+}
+
+
+
+
+/*
+ * Apply stencil and depth testing to an array of pixels.
+ * Hardware or software stencil buffer acceptable.
+ * Input: n - number of pixels in the span
+ * z - array [n] of z values
+ * stencil - array [n] of stencil values
+ * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
+ * Output: stencil - modified stencil values
+ * mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ * GL_FALSE - one or more fragments passed the testing
+ *
+ */
+static GLboolean
+stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLstencil stencil[],
+ GLubyte mask[] )
+{
+ ASSERT(ctx->Stencil.Enabled);
+ ASSERT(n <= PB_SIZE);
+
+ /*
+ * Apply the stencil test to the fragments.
+ * failMask[i] is 1 if the stencil test failed.
+ */
+ if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
+ /* all fragments failed the stencil test, we're done. */
+ return GL_FALSE;
+ }
+
+
+ /*
+ * Some fragments passed the stencil test, apply depth test to them
+ * and apply Zpass and Zfail stencil ops.
+ */
+ if (ctx->Depth.Test==GL_FALSE) {
+ /*
+ * No depth buffer, just apply zpass stencil function to active pixels.
+ */
+ apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
+ }
+ else {
+ /*
+ * Perform depth buffering, then apply zpass or zfail stencil function.
+ */
+ GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
+ GLuint i;
+
+ /* save the current mask bits */
+ MEMCPY(oldmask, mask, n * sizeof(GLubyte));
+
+ /* apply the depth test */
+ _mesa_depth_test_span(ctx, n, x, y, z, mask);
+
+ /* Set the stencil pass/fail flags according to result of depth testing.
+ * if oldmask[i] == 0 then
+ * Don't touch the stencil value
+ * else if oldmask[i] and newmask[i] then
+ * Depth test passed
+ * else
+ * assert(oldmask[i] && !newmask[i])
+ * Depth test failed
+ * endif
+ */
+ for (i=0;i<n;i++) {
+ ASSERT(mask[i] == 0 || mask[i] == 1);
+ passmask[i] = oldmask[i] & mask[i];
+ failmask[i] = oldmask[i] & (mask[i] ^ 1);
+ }
+
+ /* apply the pass and fail operations */
+ if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+ apply_stencil_op( ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask );
+ }
+ if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+ apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask );
+ }
+ }
+
+ return GL_TRUE; /* one or more fragments passed both tests */
+}
+
+
+
+/*
+ * Apply stencil and depth testing to the span of pixels.
+ * Both software and hardware stencil buffers are acceptable.
+ * Input: n - number of pixels in the span
+ * x, y - location of leftmost pixel in span
+ * z - array [n] of z values
+ * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
+ * Output: mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ * GL_FALSE - one or more fragments passed the testing
+ *
+ */
+GLboolean
+_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] )
+{
+ GLstencil stencilRow[MAX_WIDTH];
+ GLstencil *stencil;
+ GLboolean result;
+
+ ASSERT(ctx->Stencil.Enabled);
+ ASSERT(n <= MAX_WIDTH);
+
+ /* Get initial stencil values */
+ if (ctx->Driver.WriteStencilSpan) {
+ ASSERT(ctx->Driver.ReadStencilSpan);
+ /* Get stencil values from the hardware stencil buffer */
+ (*ctx->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow);
+ stencil = stencilRow;
+ }
+ else {
+ /* software stencil buffer */
+ stencil = STENCIL_ADDRESS(x, y);
+ }
+
+ /* do all the stencil/depth testing/updating */
+ result = stencil_and_ztest_span( ctx, n, x, y, z, stencil, mask );
+
+ if (ctx->Driver.WriteStencilSpan) {
+ /* Write updated stencil values into hardware stencil buffer */
+ (ctx->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask );
+ }
+
+ return result;
+}
+
+
+
+
+/*
+ * Apply the given stencil operator for each pixel in the array whose
+ * mask flag is set. This is for software stencil buffers only.
+ * Input: n - number of pixels in the span
+ * x, y - array of [n] pixels
+ * operator - the stencil buffer operator
+ * mask - array [n] of flag: 1=apply operator, 0=don't apply operator
+ */
+static void
+apply_stencil_op_to_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLenum oper, const GLubyte mask[] )
+{
+ const GLstencil ref = ctx->Stencil.Ref;
+ const GLstencil wrtmask = ctx->Stencil.WriteMask;
+ const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+ GLuint i;
+
+ ASSERT(!ctx->Driver.WriteStencilSpan); /* software stencil buffer only! */
+
+ switch (oper) {
+ case GL_KEEP:
+ /* do nothing */
+ break;
+ case GL_ZERO:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = 0;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) (invmask & *sptr);
+ }
+ }
+ }
+ break;
+ case GL_REPLACE:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = ref;
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));
+ }
+ }
+ }
+ break;
+ case GL_INCR:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ if (*sptr < STENCIL_MAX) {
+ *sptr = (GLstencil) (*sptr + 1);
+ }
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ if (*sptr < STENCIL_MAX) {
+ *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
+ }
+ }
+ }
+ }
+ break;
+ case GL_DECR:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ if (*sptr>0) {
+ *sptr = (GLstencil) (*sptr - 1);
+ }
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ if (*sptr>0) {
+ *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
+ }
+ }
+ }
+ }
+ break;
+ case GL_INCR_WRAP_EXT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) (*sptr + 1);
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
+ }
+ }
+ }
+ break;
+ case GL_DECR_WRAP_EXT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) (*sptr - 1);
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
+ }
+ }
+ }
+ break;
+ case GL_INVERT:
+ if (invmask==0) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) (~*sptr);
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+ *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));
+ }
+ }
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
+ }
+}
+
+
+
+/*
+ * Apply stencil test to an array of pixels before depth buffering.
+ * Used for software stencil buffer only.
+ * Input: n - number of pixels in the span
+ * x, y - array of [n] pixels to stencil
+ * mask - array [n] of flag: 0=skip the pixel, 1=stencil the pixel
+ * Output: mask - pixels which fail the stencil test will have their
+ * mask flag set to 0.
+ * Return: 0 = all pixels failed, 1 = zero or more pixels passed.
+ */
+static GLboolean
+stencil_test_pixels( GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[], GLubyte mask[] )
+{
+ GLubyte fail[PB_SIZE];
+ GLstencil r, s;
+ GLuint i;
+ GLboolean allfail = GL_FALSE;
+
+ ASSERT(!ctx->Driver.WriteStencilSpan); /* software stencil buffer only! */
+
+ /*
+ * Perform stencil test. The results of this operation are stored
+ * in the fail[] array:
+ * IF fail[i] is non-zero THEN
+ * the stencil fail operator is to be applied
+ * ELSE
+ * the stencil fail operator is not to be applied
+ * ENDIF
+ */
+
+ switch (ctx->Stencil.Function) {
+ case GL_NEVER:
+ /* always fail */
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ mask[i] = 0;
+ fail[i] = 1;
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ allfail = GL_TRUE;
+ break;
+ case GL_LESS:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r < s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_LEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r <= s) {
+ /* pass */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_GREATER:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r > s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_GEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r >= s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_EQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r == s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_NOTEQUAL:
+ r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+ s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+ if (r != s) {
+ /* passed */
+ fail[i] = 0;
+ }
+ else {
+ fail[i] = 1;
+ mask[i] = 0;
+ }
+ }
+ else {
+ fail[i] = 0;
+ }
+ }
+ break;
+ case GL_ALWAYS:
+ /* always pass */
+ for (i=0;i<n;i++) {
+ fail[i] = 0;
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad stencil func in gl_stencil_pixels");
+ return 0;
+ }
+
+ if (ctx->Stencil.FailFunc != GL_KEEP) {
+ apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
+ }
+
+ return !allfail;
+}
+
+
+
+
+/*
+ * Apply stencil and depth testing to an array of pixels.
+ * This is used both for software and hardware stencil buffers.
+ *
+ * The comments in this function are a bit sparse but the code is
+ * almost identical to stencil_and_ztest_span(), which is well
+ * commented.
+ *
+ * Input: n - number of pixels in the array
+ * x, y - array of [n] pixel positions
+ * z - array [n] of z values
+ * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
+ * Output: mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ * GL_FALSE - one or more fragments passed the testing
+ */
+GLboolean
+_mesa_stencil_and_ztest_pixels( GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] )
+{
+ ASSERT(ctx->Stencil.Enabled);
+ ASSERT(n <= PB_SIZE);
+
+ if (ctx->Driver.WriteStencilPixels) {
+ /*** Hardware stencil buffer ***/
+ GLstencil stencil[PB_SIZE];
+ GLubyte mask[PB_SIZE];
+
+ ASSERT(ctx->Driver.ReadStencilPixels);
+ (*ctx->Driver.ReadStencilPixels)(ctx, n, x, y, stencil);
+
+
+ if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
+ /* all fragments failed the stencil test, we're done. */
+ return GL_FALSE;
+ }
+
+ if (ctx->Depth.Test == GL_FALSE) {
+ apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
+ }
+ else {
+ GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE];
+ GLuint i;
+
+ MEMCPY(oldmask, mask, n * sizeof(GLubyte));
+
+ _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
+
+ for (i=0;i<n;i++) {
+ ASSERT(mask[i] == 0 || mask[i] == 1);
+ passmask[i] = oldmask[i] & mask[i];
+ failmask[i] = oldmask[i] & (mask[i] ^ 1);
+ }
+
+ if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+ apply_stencil_op( ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask );
+ }
+ if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+ apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask );
+ }
+ }
+
+ /* Write updated stencil values into hardware stencil buffer */
+ (ctx->Driver.WriteStencilPixels)(ctx, n, x, y, stencil, mask );
+
+ return GL_TRUE;
+
+ }
+ else {
+ /*** Software stencil buffer ***/
+
+ if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) {
+ /* all fragments failed the stencil test, we're done. */
+ return GL_FALSE;
+ }
+
+
+ if (ctx->Depth.Test==GL_FALSE) {
+ apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.ZPassFunc, mask );
+ }
+ else {
+ GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE];
+ GLuint i;
+
+ MEMCPY(oldmask, mask, n * sizeof(GLubyte));
+
+ _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
+
+ for (i=0;i<n;i++) {
+ ASSERT(mask[i] == 0 || mask[i] == 1);
+ passmask[i] = oldmask[i] & mask[i];
+ failmask[i] = oldmask[i] & (mask[i] ^ 1);
+ }
+
+ if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+ apply_stencil_op_to_pixels( ctx, n, x, y,
+ ctx->Stencil.ZFailFunc, failmask );
+ }
+ if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+ apply_stencil_op_to_pixels( ctx, n, x, y,
+ ctx->Stencil.ZPassFunc, passmask );
+ }
+ }
+
+ return GL_TRUE; /* one or more fragments passed both tests */
+ }
+}
+
+
+
+/*
+ * Return a span of stencil values from the stencil buffer.
+ * Used for glRead/CopyPixels
+ * Input: n - how many pixels
+ * x,y - location of first pixel
+ * Output: stencil - the array of stencil values
+ */
+void
+_mesa_read_stencil_span( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLstencil stencil[] )
+{
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ return; /* undefined values OK */
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ x = 0;
+ n -= dx;
+ stencil += dx;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
+
+ ASSERT(n >= 0);
+ if (ctx->Driver.ReadStencilSpan) {
+ (*ctx->Driver.ReadStencilSpan)( ctx, (GLuint) n, x, y, stencil );
+ }
+ else if (ctx->DrawBuffer->Stencil) {
+ const GLstencil *s = STENCIL_ADDRESS( x, y );
+#if STENCIL_BITS == 8
+ MEMCPY( stencil, s, n * sizeof(GLstencil) );
+#else
+ GLuint i;
+ for (i=0;i<n;i++)
+ stencil[i] = s[i];
+#endif
+ }
+}
+
+
+
+/*
+ * Write a span of stencil values to the stencil buffer.
+ * Used for glDraw/CopyPixels
+ * Input: n - how many pixels
+ * x, y - location of first pixel
+ * stencil - the array of stencil values
+ */
+void
+_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+ const GLstencil stencil[] )
+{
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ return; /* undefined values OK */
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ x = 0;
+ n -= dx;
+ stencil += dx;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
+ if (ctx->Driver.WriteStencilSpan) {
+ (*ctx->Driver.WriteStencilSpan)( ctx, n, x, y, stencil, NULL );
+ }
+ else if (ctx->DrawBuffer->Stencil) {
+ GLstencil *s = STENCIL_ADDRESS( x, y );
+#if STENCIL_BITS == 8
+ MEMCPY( s, stencil, n * sizeof(GLstencil) );
+#else
+ GLuint i;
+ for (i=0;i<n;i++)
+ s[i] = stencil[i];
+#endif
+ }
+}
+
+
+
+/*
+ * Allocate a new stencil buffer. If there's an old one it will be
+ * deallocated first. The new stencil buffer will be uninitialized.
+ */
+void
+_mesa_alloc_stencil_buffer( GLcontext *ctx )
+{
+ GLuint buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+
+ /* deallocate current stencil buffer if present */
+ if (ctx->DrawBuffer->Stencil) {
+ FREE(ctx->DrawBuffer->Stencil);
+ ctx->DrawBuffer->Stencil = NULL;
+ }
+
+ /* allocate new stencil buffer */
+ ctx->DrawBuffer->Stencil = (GLstencil *) MALLOC(buffersize * sizeof(GLstencil));
+ if (!ctx->DrawBuffer->Stencil) {
+ /* out of memory */
+/* _mesa_set_enable( ctx, GL_STENCIL_TEST, GL_FALSE ); */
+ gl_error( ctx, GL_OUT_OF_MEMORY, "_mesa_alloc_stencil_buffer" );
+ }
+}
+
+
+
+/*
+ * Clear the software (malloc'd) stencil buffer.
+ */
+static void
+clear_software_stencil_buffer( GLcontext *ctx )
+{
+ if (ctx->Visual.StencilBits==0 || !ctx->DrawBuffer->Stencil) {
+ /* no stencil buffer */
+ return;
+ }
+
+ if (ctx->Scissor.Enabled) {
+ /* clear scissor region only */
+ const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+ if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+ /* must apply mask to the clear */
+ GLint y;
+ for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+ const GLstencil mask = ctx->Stencil.WriteMask;
+ const GLstencil invMask = ~mask;
+ const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+ GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
+ GLint i;
+ for (i = 0; i < width; i++) {
+ stencil[i] = (stencil[i] & invMask) | clearVal;
+ }
+ }
+ }
+ else {
+ /* no masking */
+ GLint y;
+ for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+ GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
+#if STENCIL_BITS==8
+ MEMSET( stencil, ctx->Stencil.Clear, width * sizeof(GLstencil) );
+#else
+ GLint i;
+ for (i = 0; i < width; i++)
+ stencil[x] = ctx->Stencil.Clear;
+#endif
+ }
+ }
+ }
+ else {
+ /* clear whole stencil buffer */
+ if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+ /* must apply mask to the clear */
+ const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ GLstencil *stencil = ctx->DrawBuffer->Stencil;
+ const GLstencil mask = ctx->Stencil.WriteMask;
+ const GLstencil invMask = ~mask;
+ const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ stencil[i] = (stencil[i] & invMask) | clearVal;
+ }
+ }
+ else {
+ /* clear whole buffer without masking */
+ const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ GLstencil *stencil = ctx->DrawBuffer->Stencil;
+
+#if STENCIL_BITS==8
+ MEMSET(stencil, ctx->Stencil.Clear, n * sizeof(GLstencil) );
+#else
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ stencil[i] = ctx->Stencil.Clear;
+ }
+#endif
+ }
+ }
+}
+
+
+
+/*
+ * Clear the hardware (in graphics card) stencil buffer.
+ * This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan()
+ * functions.
+ * Actually, if there is a hardware stencil buffer it really should have
+ * been cleared in Driver.Clear()! However, if the hardware does not
+ * support scissored clears or masked clears (i.e. glStencilMask) then
+ * we have to use the span-based functions.
+ */
+static void
+clear_hardware_stencil_buffer( GLcontext *ctx )
+{
+ ASSERT(ctx->Driver.WriteStencilSpan);
+ ASSERT(ctx->Driver.ReadStencilSpan);
+
+ if (ctx->Scissor.Enabled) {
+ /* clear scissor region only */
+ const GLint x = ctx->DrawBuffer->Xmin;
+ const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+ if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+ /* must apply mask to the clear */
+ GLint y;
+ for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+ const GLstencil mask = ctx->Stencil.WriteMask;
+ const GLstencil invMask = ~mask;
+ const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+ GLstencil stencil[MAX_WIDTH];
+ GLint i;
+ (*ctx->Driver.ReadStencilSpan)(ctx, x, y, width, stencil);
+ for (i = 0; i < width; i++) {
+ stencil[i] = (stencil[i] & invMask) | clearVal;
+ }
+ (*ctx->Driver.WriteStencilSpan)(ctx, x, y, width, stencil, NULL);
+ }
+ }
+ else {
+ /* no masking */
+ GLstencil stencil[MAX_WIDTH];
+ GLint y, i;
+ for (i = 0; i < width; i++) {
+ stencil[i] = ctx->Stencil.Clear;
+ }
+ for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+ (*ctx->Driver.WriteStencilSpan)(ctx, x, y, width, stencil, NULL);
+ }
+ }
+ }
+ else {
+ /* clear whole stencil buffer */
+ if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+ /* must apply mask to the clear */
+ const GLstencil mask = ctx->Stencil.WriteMask;
+ const GLstencil invMask = ~mask;
+ const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+ const GLint width = ctx->DrawBuffer->Width;
+ const GLint height = ctx->DrawBuffer->Height;
+ const GLint x = ctx->DrawBuffer->Xmin;
+ GLint y;
+ for (y = 0; y < height; y++) {
+ GLstencil stencil[MAX_WIDTH];
+ GLuint i;
+ (*ctx->Driver.ReadStencilSpan)(ctx, x, y, width, stencil);
+ for (i = 0; i < width; i++) {
+ stencil[i] = (stencil[i] & invMask) | clearVal;
+ }
+ (*ctx->Driver.WriteStencilSpan)(ctx, x, y, width, stencil, NULL);
+ }
+ }
+ else {
+ /* clear whole buffer without masking */
+ const GLint width = ctx->DrawBuffer->Width;
+ const GLint height = ctx->DrawBuffer->Width;
+ const GLint x = ctx->DrawBuffer->Xmin;
+ GLstencil stencil[MAX_WIDTH];
+ GLint y, i;
+ for (i = 0; i < width; i++) {
+ stencil[i] = ctx->Stencil.Clear;
+ }
+ for (y = 0; y < height; y++) {
+ (*ctx->Driver.WriteStencilSpan)(ctx, x, y, width, stencil, NULL);
+ }
+ }
+ }
+}
+
+
+
+/*
+ * Clear the stencil buffer.
+ */
+void
+_mesa_clear_stencil_buffer( GLcontext *ctx )
+{
+ if (ctx->Driver.WriteStencilSpan) {
+ ASSERT(ctx->Driver.ReadStencilSpan);
+ clear_hardware_stencil_buffer(ctx);
+ }
+ else {
+ clear_software_stencil_buffer(ctx);
+ }
+}
+
--- /dev/null
+/* $Id: s_stencil.h,v 1.1 2000/10/31 18:00:04 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.
+ */
+
+
+#ifndef S_STENCIL_H
+#define S_STENCIL_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern GLboolean
+_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] );
+
+extern GLboolean
+_mesa_stencil_and_ztest_pixels( GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[],
+ const GLdepth z[], GLubyte mask[] );
+
+
+extern void
+_mesa_read_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+ GLstencil stencil[] );
+
+
+extern void
+_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+ const GLstencil stencil[] );
+
+
+extern void
+_mesa_alloc_stencil_buffer( GLcontext *ctx );
+
+
+extern void
+_mesa_clear_stencil_buffer( GLcontext *ctx );
+
+
+#endif
--- /dev/null
+/* $Id: s_texture.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "context.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mem.h"
+#include "teximage.h"
+
+#include "s_pb.h"
+#include "s_texture.h"
+
+
+
+
+/*
+ * Paletted texture sampling.
+ * Input: tObj - the texture object
+ * index - the palette index (8-bit only)
+ * Output: red, green, blue, alpha - the texel color
+ */
+static void palette_sample(const struct gl_texture_object *tObj,
+ GLint index, GLchan rgba[4] )
+{
+ GLcontext *ctx = _mesa_get_current_context(); /* THIS IS A HACK */
+ const GLchan *palette;
+ GLenum format;
+
+ if (ctx->Texture.SharedPalette) {
+ ASSERT(!ctx->Texture.Palette.FloatTable);
+ palette = (const GLchan *) ctx->Texture.Palette.Table;
+ format = ctx->Texture.Palette.Format;
+ }
+ else {
+ ASSERT(!tObj->Palette.FloatTable);
+ palette = (const GLchan *) tObj->Palette.Table;
+ format = tObj->Palette.Format;
+ }
+
+ switch (format) {
+ case GL_ALPHA:
+ rgba[ACOMP] = palette[index];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = palette[index];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ rgba[RCOMP] = palette[(index << 1) + 0];
+ rgba[ACOMP] = palette[(index << 1) + 1];
+ return;
+ case GL_RGB:
+ rgba[RCOMP] = palette[index * 3 + 0];
+ rgba[GCOMP] = palette[index * 3 + 1];
+ rgba[BCOMP] = palette[index * 3 + 2];
+ return;
+ case GL_RGBA:
+ rgba[RCOMP] = palette[(index << 2) + 0];
+ rgba[GCOMP] = palette[(index << 2) + 1];
+ rgba[BCOMP] = palette[(index << 2) + 2];
+ rgba[ACOMP] = palette[(index << 2) + 3];
+ return;
+ default:
+ gl_problem(NULL, "Bad palette format in palette_sample");
+ }
+}
+
+
+
+/*
+ * These values are used in the fixed-point arithmetic used
+ * for linear filtering.
+ */
+#define WEIGHT_SCALE 65536.0F
+#define WEIGHT_SHIFT 16
+
+
+/*
+ * Used to compute texel locations for linear sampling.
+ */
+#define COMPUTE_LINEAR_TEXEL_LOCATIONS(wrapMode, S, U, SIZE, I0, I1) \
+{ \
+ if (wrapMode == GL_REPEAT) { \
+ U = S * SIZE - 0.5F; \
+ I0 = ((GLint) myFloor(U)) & (SIZE - 1); \
+ I1 = (I0 + 1) & (SIZE - 1); \
+ } \
+ else { \
+ U = S * SIZE; \
+ if (U < 0.0F) \
+ U = 0.0F; \
+ else if (U >= SIZE) \
+ U = SIZE; \
+ U -= 0.5F; \
+ I0 = (GLint) myFloor(U); \
+ I1 = I0 + 1; \
+ if (wrapMode == GL_CLAMP_TO_EDGE) { \
+ if (I0 < 0) \
+ I0 = 0; \
+ if (I1 >= SIZE) \
+ I1 = SIZE - 1; \
+ } \
+ } \
+}
+
+
+/*
+ * Used to compute texel location for nearest sampling.
+ */
+#define COMPUTE_NEAREST_TEXEL_LOCATION(wrapMode, S, SIZE, I) \
+{ \
+ if (wrapMode == GL_REPEAT) { \
+ /* s limited to [0,1) */ \
+ /* i limited to [0,width-1] */ \
+ I = (GLint) (S * SIZE); \
+ if (S < 0.0F) \
+ I -= 1; \
+ I &= (SIZE - 1); \
+ } \
+ else if (wrapMode == GL_CLAMP_TO_EDGE) { \
+ const GLfloat min = 1.0F / (2.0F * SIZE); \
+ const GLfloat max = 1.0F - min; \
+ if (S < min) \
+ I = 0; \
+ else if (S > max) \
+ I = SIZE - 1; \
+ else \
+ I = (GLint) (S * SIZE); \
+ } \
+ else { \
+ ASSERT(wrapMode == GL_CLAMP); \
+ /* s limited to [0,1] */ \
+ /* i limited to [0,width-1] */ \
+ if (S <= 0.0F) \
+ I = 0; \
+ else if (S >= 1.0F) \
+ I = SIZE - 1; \
+ else \
+ I = (GLint) (S * SIZE); \
+ } \
+}
+
+
+/*
+ * Compute linear mipmap levels for given lambda.
+ */
+#define COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level) \
+{ \
+ if (lambda < 0.0F) \
+ lambda = 0.0F; \
+ else if (lambda > tObj->M) \
+ lambda = tObj->M; \
+ level = (GLint) (tObj->BaseLevel + lambda); \
+}
+
+
+/*
+ * Compute nearest mipmap level for given lambda.
+ */
+#define COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level) \
+{ \
+ if (lambda <= 0.5F) \
+ lambda = 0.0F; \
+ 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; \
+}
+
+
+
+
+/*
+ * Bitflags for texture border color sampling.
+ */
+#define I0BIT 1
+#define I1BIT 2
+#define J0BIT 4
+#define J1BIT 8
+#define K0BIT 16
+#define K1BIT 32
+
+
+
+/**********************************************************************/
+/* 1-D Texture Sampling Functions */
+/**********************************************************************/
+
+
+/*
+ * Return floor of x, being careful of negative values.
+ */
+static GLfloat myFloor(GLfloat x)
+{
+ if (x < 0.0F)
+ return (GLfloat) ((GLint) x - 1);
+ else
+ return (GLfloat) (GLint) x;
+}
+
+
+/*
+ * Return the fractional part of x.
+ */
+#define myFrac(x) ( (x) - myFloor(x) )
+
+
+
+
+/*
+ * Given 1-D texture image and an (i) texel column coordinate, return the
+ * texel color.
+ */
+static void get_1d_texel( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img, GLint i,
+ GLchan rgba[4] )
+{
+ const GLchan *texel;
+
+#ifdef DEBUG
+ GLint width = img->Width;
+ assert(i >= 0);
+ assert(i < width);
+#endif
+
+ switch (img->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[i];
+ palette_sample(tObj, index, rgba);
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[ i ];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[ i ];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + i * 2;
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + i * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + i * 4;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in get_1d_texel");
+ return;
+ }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s) using GL_NEAREST filter.
+ */
+static void sample_1d_nearest( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s, GLchan rgba[4] )
+{
+ const GLint width = img->Width2; /* without border, power of two */
+ const GLchan *texel;
+ GLint i;
+
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width, i);
+
+ /* skip over the border, if any */
+ i += img->Border;
+
+ /* Get the texel */
+ switch (img->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[i];
+ palette_sample(tObj, index, rgba );
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[i];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[i];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + i * 2;
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + i * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + i * 4;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in sample_1d_nearest");
+ }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s) using GL_LINEAR filter.
+ */
+static void sample_1d_linear( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s,
+ GLchan rgba[4] )
+{
+ const GLint width = img->Width2;
+ GLint i0, i1;
+ GLfloat u;
+ GLuint useBorderColor;
+
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width, i0, i1);
+
+ useBorderColor = 0;
+ if (img->Border) {
+ i0 += img->Border;
+ i1 += img->Border;
+ }
+ else {
+ if (i0 < 0 || i0 >= width) useBorderColor |= I0BIT;
+ if (i1 < 0 || i1 >= width) useBorderColor |= I1BIT;
+ }
+
+ {
+ const GLfloat a = myFrac(u);
+ /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+ const GLint w0 = (GLint) ((1.0F-a) * WEIGHT_SCALE + 0.5F);
+ const GLint w1 = (GLint) ( a * WEIGHT_SCALE + 0.5F);
+
+ GLchan t0[4], t1[4]; /* texels */
+
+ if (useBorderColor & I0BIT) {
+ COPY_CHAN4(t0, tObj->BorderColor);
+ }
+ else {
+ get_1d_texel( tObj, img, i0, t0 );
+ }
+ if (useBorderColor & I1BIT) {
+ COPY_CHAN4(t1, tObj->BorderColor);
+ }
+ else {
+ get_1d_texel( tObj, img, i1, t1 );
+ }
+
+ rgba[0] = (GLchan) ((w0 * t0[0] + w1 * t1[0]) >> WEIGHT_SHIFT);
+ rgba[1] = (GLchan) ((w0 * t0[1] + w1 * t1[1]) >> WEIGHT_SHIFT);
+ rgba[2] = (GLchan) ((w0 * t0[2] + w1 * t1[2]) >> WEIGHT_SHIFT);
+ rgba[3] = (GLchan) ((w0 * t0[3] + w1 * t1[3]) >> WEIGHT_SHIFT);
+ }
+}
+
+
+static void
+sample_1d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_1d_nearest( tObj, tObj->Image[level], s, rgba );
+}
+
+
+static void
+sample_1d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_1d_linear( tObj, tObj->Image[level], s, rgba );
+}
+
+
+
+static void
+sample_1d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_1d_nearest( tObj, tObj->Image[tObj->P], s, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4];
+ const GLfloat f = myFrac(lambda);
+ sample_1d_nearest( tObj, tObj->Image[level ], s, t0 );
+ sample_1d_nearest( tObj, tObj->Image[level+1], s, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+
+static void
+sample_1d_linear_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_1d_linear( tObj, tObj->Image[tObj->P], s, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4];
+ const GLfloat f = myFrac(lambda);
+ sample_1d_linear( tObj, tObj->Image[level ], s, t0 );
+ sample_1d_linear( tObj, tObj->Image[level+1], s, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+
+static void sample_nearest_1d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) t;
+ (void) u;
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_1d_nearest( tObj, image, s[i], rgba[i] );
+ }
+}
+
+
+
+static void sample_linear_1d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) t;
+ (void) u;
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_1d_linear( tObj, image, s[i], rgba[i] );
+ }
+}
+
+
+/*
+ * Given an (s) texture coordinate and lambda (level of detail) value,
+ * return a texture sample.
+ *
+ */
+static void sample_lambda_1d( 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;
+
+ (void) t;
+ (void) u;
+
+ for (i=0;i<n;i++) {
+ if (lambda[i] > tObj->MinMagThresh) {
+ /* minification */
+ switch (tObj->MinFilter) {
+ case GL_NEAREST:
+ sample_1d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_1d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_NEAREST:
+ sample_1d_nearest_mipmap_nearest( tObj, lambda[i], s[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_NEAREST:
+ sample_1d_linear_mipmap_nearest( tObj, s[i], lambda[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_LINEAR:
+ sample_1d_nearest_mipmap_linear( tObj, s[i], lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_LINEAR:
+ sample_1d_linear_mipmap_linear( tObj, s[i], lambda[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad min filter in sample_1d_texture");
+ return;
+ }
+ }
+ else {
+ /* magnification */
+ switch (tObj->MagFilter) {
+ case GL_NEAREST:
+ sample_1d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_1d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad mag filter in sample_1d_texture");
+ return;
+ }
+ }
+ }
+}
+
+
+
+
+/**********************************************************************/
+/* 2-D Texture Sampling Functions */
+/**********************************************************************/
+
+
+/*
+ * Given a texture image and an (i,j) integer texel coordinate, return the
+ * texel color.
+ */
+static void get_2d_texel( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img, GLint i, GLint j,
+ GLchan rgba[4] )
+{
+ const GLint width = img->Width; /* includes border */
+ const GLchan *texel;
+
+#ifdef DEBUG
+ const GLint height = img->Height; /* includes border */
+ assert(i >= 0);
+ assert(i < width);
+ assert(j >= 0);
+ assert(j < height);
+#endif
+
+ switch (img->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[ width *j + i ];
+ palette_sample(tObj, index, rgba );
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[ width * j + i ];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[ width * j + i ];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + (width * j + i) * 2;
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + (width * j + i) * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + (width * j + i) * 4;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in get_2d_texel");
+ }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
+ */
+static void sample_2d_nearest( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s, GLfloat t,
+ GLchan rgba[] )
+{
+ const GLint imgWidth = img->Width; /* includes border */
+ const GLint width = img->Width2; /* without border, power of two */
+ const GLint height = img->Height2; /* without border, power of two */
+ const GLchan *texel;
+ GLint i, j;
+
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width, i);
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
+
+ /* skip over the border, if any */
+ i += img->Border;
+ j += img->Border;
+
+ switch (img->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[ j * imgWidth + i ];
+ palette_sample(tObj, index, rgba);
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[ j * imgWidth + i ];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[ j * imgWidth + i ];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + ((j * imgWidth + i) << 1);
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + (j * imgWidth + i) * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + ((j * imgWidth + i) << 2);
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in sample_2d_nearest");
+ }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
+ * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
+ */
+static void sample_2d_linear( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s, GLfloat t,
+ GLchan rgba[] )
+{
+ const GLint width = img->Width2;
+ const GLint height = img->Height2;
+ GLint i0, j0, i1, j1;
+ GLuint useBorderColor;
+ GLfloat u, v;
+
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width, i0, i1);
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
+
+ useBorderColor = 0;
+ if (img->Border) {
+ i0 += img->Border;
+ i1 += img->Border;
+ j0 += img->Border;
+ j1 += img->Border;
+ }
+ else {
+ if (i0 < 0 || i0 >= width) useBorderColor |= I0BIT;
+ if (i1 < 0 || i1 >= width) useBorderColor |= I1BIT;
+ if (j0 < 0 || j0 >= height) useBorderColor |= J0BIT;
+ if (j1 < 0 || j1 >= height) useBorderColor |= J1BIT;
+ }
+
+ {
+ const GLfloat a = myFrac(u);
+ const GLfloat b = myFrac(v);
+ /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+ const GLint w00 = (GLint) ((1.0F-a)*(1.0F-b) * WEIGHT_SCALE + 0.5F);
+ const GLint w10 = (GLint) ( a *(1.0F-b) * WEIGHT_SCALE + 0.5F);
+ const GLint w01 = (GLint) ((1.0F-a)* b * WEIGHT_SCALE + 0.5F);
+ const GLint w11 = (GLint) ( a * b * WEIGHT_SCALE + 0.5F);
+ GLchan t00[4];
+ GLchan t10[4];
+ GLchan t01[4];
+ GLchan t11[4];
+
+ if (useBorderColor & (I0BIT | J0BIT)) {
+ COPY_CHAN4(t00, tObj->BorderColor);
+ }
+ else {
+ get_2d_texel( tObj, img, i0, j0, t00 );
+ }
+ if (useBorderColor & (I1BIT | J0BIT)) {
+ COPY_CHAN4(t10, tObj->BorderColor);
+ }
+ else {
+ get_2d_texel( tObj, img, i1, j0, t10 );
+ }
+ if (useBorderColor & (I0BIT | J1BIT)) {
+ COPY_CHAN4(t01, tObj->BorderColor);
+ }
+ else {
+ get_2d_texel( tObj, img, i0, j1, t01 );
+ }
+ if (useBorderColor & (I1BIT | J1BIT)) {
+ COPY_CHAN4(t11, tObj->BorderColor);
+ }
+ else {
+ get_2d_texel( tObj, img, i1, j1, t11 );
+ }
+
+ rgba[0] = (GLchan) ((w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0]) >> WEIGHT_SHIFT);
+ rgba[1] = (GLchan) ((w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1]) >> WEIGHT_SHIFT);
+ rgba[2] = (GLchan) ((w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2]) >> WEIGHT_SHIFT);
+ rgba[3] = (GLchan) ((w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3]) >> WEIGHT_SHIFT);
+ }
+
+}
+
+
+
+static void
+sample_2d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_2d_nearest( tObj, tObj->Image[level], s, t, rgba );
+}
+
+
+
+static void
+sample_2d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_2d_linear( tObj, tObj->Image[level], s, t, rgba );
+}
+
+
+
+static void
+sample_2d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_2d_nearest( tObj, tObj->Image[tObj->P], s, t, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4]; /* texels */
+ const GLfloat f = myFrac(lambda);
+ sample_2d_nearest( tObj, tObj->Image[level ], s, t, t0 );
+ sample_2d_nearest( tObj, tObj->Image[level+1], s, t, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+
+static void
+sample_2d_linear_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat lambda,
+ GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_2d_linear( tObj, tObj->Image[tObj->P], s, t, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4]; /* texels */
+ const GLfloat f = myFrac(lambda);
+ sample_2d_linear( tObj, tObj->Image[level ], s, t, t0 );
+ sample_2d_linear( tObj, tObj->Image[level+1], s, t, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+
+static void sample_nearest_2d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) u;
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_2d_nearest( tObj, image, s[i], t[i], rgba[i] );
+ }
+}
+
+
+
+static void sample_linear_2d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) u;
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_2d_linear( tObj, image, s[i], t[i], rgba[i] );
+ }
+}
+
+
+/*
+ * 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,
+ GLuint n,
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], const GLfloat lambda[],
+ GLchan rgba[][4] )
+{
+ GLuint i;
+ (void) u;
+ for (i=0;i<n;i++) {
+ if (lambda[i] > tObj->MinMagThresh) {
+ /* minification */
+ switch (tObj->MinFilter) {
+ case GL_NEAREST:
+ sample_2d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_2d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_NEAREST:
+ sample_2d_nearest_mipmap_nearest( tObj, s[i], t[i], lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_NEAREST:
+ sample_2d_linear_mipmap_nearest( tObj, s[i], t[i], lambda[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_LINEAR:
+ sample_2d_nearest_mipmap_linear( tObj, s[i], t[i], lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_LINEAR:
+ sample_2d_linear_mipmap_linear( tObj, s[i], t[i], lambda[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad min filter in sample_2d_texture");
+ return;
+ }
+ }
+ else {
+ /* magnification */
+ switch (tObj->MagFilter) {
+ case GL_NEAREST:
+ sample_2d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_2d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad mag filter in sample_2d_texture");
+ }
+ }
+ }
+}
+
+
+/*
+ * Optimized 2-D texture sampling:
+ * S and T wrap mode == GL_REPEAT
+ * GL_NEAREST min/mag filter
+ * No border
+ * Format = GL_RGB
+ */
+static void opt_sample_rgb_2d( const struct gl_texture_object *tObj,
+ GLuint n, const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], const GLfloat lambda[],
+ GLchan rgba[][4] )
+{
+ const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
+ const GLfloat width = (GLfloat) img->Width;
+ const GLfloat height = (GLfloat) img->Height;
+ const GLint colMask = img->Width - 1;
+ const GLint rowMask = img->Height - 1;
+ const GLint shift = img->WidthLog2;
+ GLuint k;
+ (void) u;
+ (void) lambda;
+ ASSERT(tObj->WrapS==GL_REPEAT);
+ ASSERT(tObj->WrapT==GL_REPEAT);
+ ASSERT(tObj->MinFilter==GL_NEAREST);
+ ASSERT(tObj->MagFilter==GL_NEAREST);
+ ASSERT(img->Border==0);
+ ASSERT(img->Format==GL_RGB);
+
+ /* NOTE: negative float->int doesn't floor, add 10000 as to work-around */
+ for (k=0;k<n;k++) {
+ GLint i = (GLint) ((s[k] + 10000.0) * width) & colMask;
+ GLint j = (GLint) ((t[k] + 10000.0) * height) & rowMask;
+ GLint pos = (j << shift) | i;
+ GLchan *texel = img->Data + pos + pos + pos; /* pos*3 */
+ rgba[k][RCOMP] = texel[0];
+ rgba[k][GCOMP] = texel[1];
+ rgba[k][BCOMP] = texel[2];
+ }
+}
+
+
+/*
+ * Optimized 2-D texture sampling:
+ * S and T wrap mode == GL_REPEAT
+ * GL_NEAREST min/mag filter
+ * No border
+ * Format = GL_RGBA
+ */
+static void opt_sample_rgba_2d( const struct gl_texture_object *tObj,
+ GLuint n, const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], const GLfloat lambda[],
+ GLchan rgba[][4] )
+{
+ const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
+ const GLfloat width = (GLfloat) img->Width;
+ const GLfloat height = (GLfloat) img->Height;
+ const GLint colMask = img->Width - 1;
+ const GLint rowMask = img->Height - 1;
+ const GLint shift = img->WidthLog2;
+ GLuint k;
+ (void) u;
+ (void) lambda;
+ ASSERT(tObj->WrapS==GL_REPEAT);
+ ASSERT(tObj->WrapT==GL_REPEAT);
+ ASSERT(tObj->MinFilter==GL_NEAREST);
+ ASSERT(tObj->MagFilter==GL_NEAREST);
+ ASSERT(img->Border==0);
+ ASSERT(img->Format==GL_RGBA);
+
+ /* NOTE: negative float->int doesn't floor, add 10000 as to work-around */
+ for (k=0;k<n;k++) {
+ GLint i = (GLint) ((s[k] + 10000.0) * width) & colMask;
+ GLint j = (GLint) ((t[k] + 10000.0) * height) & rowMask;
+ GLint pos = (j << shift) | i;
+ GLchan *texel = img->Data + (pos << 2); /* pos*4 */
+ rgba[k][RCOMP] = texel[0];
+ rgba[k][GCOMP] = texel[1];
+ rgba[k][BCOMP] = texel[2];
+ rgba[k][ACOMP] = texel[3];
+ }
+}
+
+
+
+/**********************************************************************/
+/* 3-D Texture Sampling Functions */
+/**********************************************************************/
+
+/*
+ * Given a texture image and an (i,j,k) integer texel coordinate, return the
+ * texel color.
+ */
+static void get_3d_texel( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLint i, GLint j, GLint k,
+ GLchan rgba[4] )
+{
+ const GLint width = img->Width; /* includes border */
+ const GLint height = img->Height; /* includes border */
+ const GLint rectarea = width * height;
+ const GLchan *texel;
+
+#ifdef DEBUG
+ const GLint depth = img->Depth; /* includes border */
+ assert(i >= 0);
+ assert(i < width);
+ assert(j >= 0);
+ assert(j < height);
+ assert(k >= 0);
+ assert(k < depth);
+#endif
+
+ switch (img->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[ rectarea * k + width * j + i ];
+ palette_sample(tObj, index, rgba );
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[ rectarea * k + width * j + i ];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[ rectarea * k + width * j + i ];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + ( rectarea * k + width * j + i) * 2;
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + (rectarea * k + width * j + i) * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + (rectarea * k + width * j + i) * 4;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in get_3d_texel");
+ }
+}
+
+
+/*
+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
+ */
+static void sample_3d_nearest( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLchan rgba[4] )
+{
+ const GLint imgWidth = img->Width; /* includes border, if any */
+ const GLint imgHeight = img->Height; /* includes border, if any */
+ const GLint width = img->Width2; /* without border, power of two */
+ const GLint height = img->Height2; /* without border, power of two */
+ const GLint depth = img->Depth2; /* without border, power of two */
+ const GLint rectarea = imgWidth * imgHeight;
+ const GLchan *texel;
+ GLint i, j, k;
+
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width, i);
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
+ COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapR, r, depth, k);
+
+ switch (tObj->Image[0]->Format) {
+ case GL_COLOR_INDEX:
+ {
+ GLint index = img->Data[ rectarea * k + j * imgWidth + i ];
+ palette_sample(tObj, index, rgba );
+ return;
+ }
+ case GL_ALPHA:
+ rgba[ACOMP] = img->Data[ rectarea * k + j * imgWidth + i ];
+ return;
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ rgba[RCOMP] = img->Data[ rectarea * k + j * imgWidth + i ];
+ return;
+ case GL_LUMINANCE_ALPHA:
+ texel = img->Data + ((rectarea * k + j * imgWidth + i) << 1);
+ rgba[RCOMP] = texel[0];
+ rgba[ACOMP] = texel[1];
+ return;
+ case GL_RGB:
+ texel = img->Data + ( rectarea * k + j * imgWidth + i) * 3;
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ return;
+ case GL_RGBA:
+ texel = img->Data + ((rectarea * k + j * imgWidth + i) << 2);
+ rgba[RCOMP] = texel[0];
+ rgba[GCOMP] = texel[1];
+ rgba[BCOMP] = texel[2];
+ rgba[ACOMP] = texel[3];
+ return;
+ default:
+ gl_problem(NULL, "Bad format in sample_3d_nearest");
+ }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
+ */
+static void sample_3d_linear( const struct gl_texture_object *tObj,
+ const struct gl_texture_image *img,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLchan rgba[4] )
+{
+ const GLint width = img->Width2;
+ const GLint height = img->Height2;
+ const GLint depth = img->Depth2;
+ GLint i0, j0, k0, i1, j1, k1;
+ GLuint useBorderColor;
+ GLfloat u, v, w;
+
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width, i0, i1);
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapR, r, w, depth, k0, k1);
+
+ useBorderColor = 0;
+ if (img->Border) {
+ i0 += img->Border;
+ i1 += img->Border;
+ j0 += img->Border;
+ j1 += img->Border;
+ k0 += img->Border;
+ k1 += img->Border;
+ }
+ else {
+ /* check if sampling texture border color */
+ if (i0 < 0 || i0 >= width) useBorderColor |= I0BIT;
+ if (i1 < 0 || i1 >= width) useBorderColor |= I1BIT;
+ if (j0 < 0 || j0 >= height) useBorderColor |= J0BIT;
+ if (j1 < 0 || j1 >= height) useBorderColor |= J1BIT;
+ if (k0 < 0 || k0 >= depth) useBorderColor |= K0BIT;
+ if (k1 < 0 || k1 >= depth) useBorderColor |= K1BIT;
+ }
+
+ {
+ const GLfloat a = myFrac(u);
+ const GLfloat b = myFrac(v);
+ const GLfloat c = myFrac(w);
+ /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+ GLint w000 = (GLint) ((1.0F-a)*(1.0F-b)*(1.0F-c) * WEIGHT_SCALE + 0.5F);
+ GLint w100 = (GLint) ( a *(1.0F-b)*(1.0F-c) * WEIGHT_SCALE + 0.5F);
+ GLint w010 = (GLint) ((1.0F-a)* b *(1.0F-c) * WEIGHT_SCALE + 0.5F);
+ GLint w110 = (GLint) ( a * b *(1.0F-c) * WEIGHT_SCALE + 0.5F);
+ GLint w001 = (GLint) ((1.0F-a)*(1.0F-b)* c * WEIGHT_SCALE + 0.5F);
+ GLint w101 = (GLint) ( a *(1.0F-b)* c * WEIGHT_SCALE + 0.5F);
+ GLint w011 = (GLint) ((1.0F-a)* b * c * WEIGHT_SCALE + 0.5F);
+ GLint w111 = (GLint) ( a * b * c * WEIGHT_SCALE + 0.5F);
+
+ GLchan t000[4], t010[4], t001[4], t011[4];
+ GLchan t100[4], t110[4], t101[4], t111[4];
+
+ if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
+ COPY_CHAN4(t000, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i0, j0, k0, t000 );
+ }
+ if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
+ COPY_CHAN4(t100, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i1, j0, k0, t100 );
+ }
+ if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
+ COPY_CHAN4(t010, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i0, j1, k0, t010 );
+ }
+ if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
+ COPY_CHAN4(t110, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i1, j1, k0, t110 );
+ }
+
+ if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
+ COPY_CHAN4(t001, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i0, j0, k1, t001 );
+ }
+ if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
+ COPY_CHAN4(t101, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i1, j0, k1, t101 );
+ }
+ if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
+ COPY_CHAN4(t011, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i0, j1, k1, t011 );
+ }
+ if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
+ COPY_CHAN4(t111, tObj->BorderColor);
+ }
+ else {
+ get_3d_texel( tObj, img, i1, j1, k1, t111 );
+ }
+
+ rgba[0] = (GLchan) (
+ (w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
+ w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0] )
+ >> WEIGHT_SHIFT);
+ rgba[1] = (GLchan) (
+ (w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
+ w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1] )
+ >> WEIGHT_SHIFT);
+ rgba[2] = (GLchan) (
+ (w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
+ w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2] )
+ >> WEIGHT_SHIFT);
+ rgba[3] = (GLchan) (
+ (w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
+ w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3] )
+ >> WEIGHT_SHIFT);
+ }
+}
+
+
+
+static void
+sample_3d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_3d_nearest( tObj, tObj->Image[level], s, t, r, rgba );
+}
+
+
+static void
+sample_3d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ GLint level;
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+ sample_3d_linear( tObj, tObj->Image[level], s, t, r, rgba );
+}
+
+
+static void
+sample_3d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_3d_nearest( tObj, tObj->Image[tObj->P], s, t, r, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4]; /* texels */
+ const GLfloat f = myFrac(lambda);
+ sample_3d_nearest( tObj, tObj->Image[level ], s, t, r, t0 );
+ sample_3d_nearest( tObj, tObj->Image[level+1], s, t, r, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+static void
+sample_3d_linear_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat r,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ if (level >= tObj->P) {
+ sample_3d_linear( tObj, tObj->Image[tObj->P], s, t, r, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4]; /* texels */
+ const GLfloat f = myFrac(lambda);
+ sample_3d_linear( tObj, tObj->Image[level ], s, t, r, t0 );
+ sample_3d_linear( tObj, tObj->Image[level+1], s, t, r, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+static void sample_nearest_3d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_3d_nearest( tObj, image, s[i], t[i], u[i], rgba[i] );
+ }
+}
+
+
+
+static void sample_linear_3d( 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;
+ struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+ (void) lambda;
+ for (i=0;i<n;i++) {
+ sample_3d_linear( tObj, image, s[i], t[i], u[i], rgba[i] );
+ }
+}
+
+
+/*
+ * 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,
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat u[], const GLfloat lambda[],
+ GLchan rgba[][4] )
+{
+ GLuint i;
+
+ for (i=0;i<n;i++) {
+
+ if (lambda[i] > tObj->MinMagThresh) {
+ /* minification */
+ switch (tObj->MinFilter) {
+ case GL_NEAREST:
+ sample_3d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_3d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_NEAREST:
+ sample_3d_nearest_mipmap_nearest( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_NEAREST:
+ sample_3d_linear_mipmap_nearest( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_LINEAR:
+ sample_3d_nearest_mipmap_linear( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_LINEAR:
+ sample_3d_linear_mipmap_linear( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad min filterin sample_3d_texture");
+ }
+ }
+ else {
+ /* magnification */
+ switch (tObj->MagFilter) {
+ case GL_NEAREST:
+ sample_3d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_3d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad mag filter in sample_3d_texture");
+ }
+ }
+ }
+}
+
+
+/**********************************************************************/
+/* Texture Cube Map Sampling Functions */
+/**********************************************************************/
+
+/*
+ * Choose one of six sides of a texture cube map given the texture
+ * coord (rx,ry,rz). Return pointer to corresponding array of texture
+ * images.
+ */
+static const struct gl_texture_image **
+choose_cube_face(const struct gl_texture_object *texObj,
+ GLfloat rx, GLfloat ry, GLfloat rz,
+ GLfloat *newS, GLfloat *newT)
+{
+/*
+ major axis
+ direction target sc tc ma
+ ---------- ------------------------------- --- --- ---
+ +rx TEXTURE_CUBE_MAP_POSITIVE_X_EXT -rz -ry rx
+ -rx TEXTURE_CUBE_MAP_NEGATIVE_X_EXT +rz -ry rx
+ +ry TEXTURE_CUBE_MAP_POSITIVE_Y_EXT +rx +rz ry
+ -ry TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT +rx -rz ry
+ +rz TEXTURE_CUBE_MAP_POSITIVE_Z_EXT +rx -ry rz
+ -rz TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT -rx -ry rz
+*/
+ const struct gl_texture_image **imgArray;
+ const GLfloat arx = ABSF(rx), ary = ABSF(ry), arz = ABSF(rz);
+ GLfloat sc, tc, ma;
+
+ if (arx > ary && arx > arz) {
+ if (rx >= 0.0F) {
+ imgArray = (const struct gl_texture_image **) texObj->Image;
+ sc = -rz;
+ tc = -ry;
+ ma = arx;
+ }
+ else {
+ imgArray = (const struct gl_texture_image **) texObj->NegX;
+ sc = rz;
+ tc = -ry;
+ ma = arx;
+ }
+ }
+ else if (ary > arx && ary > arz) {
+ if (ry >= 0.0F) {
+ imgArray = (const struct gl_texture_image **) texObj->PosY;
+ sc = rx;
+ tc = rz;
+ ma = ary;
+ }
+ else {
+ imgArray = (const struct gl_texture_image **) texObj->NegY;
+ sc = rx;
+ tc = -rz;
+ ma = ary;
+ }
+ }
+ else {
+ if (rz > 0.0F) {
+ imgArray = (const struct gl_texture_image **) texObj->PosZ;
+ sc = rx;
+ tc = -ry;
+ ma = arz;
+ }
+ else {
+ imgArray = (const struct gl_texture_image **) texObj->NegZ;
+ sc = -rx;
+ tc = -ry;
+ ma = arz;
+ }
+ }
+
+ *newS = ( sc / ma + 1.0F ) * 0.5F;
+ *newT = ( tc / ma + 1.0F ) * 0.5F;
+ return imgArray;
+}
+
+
+static void
+sample_nearest_cube(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;
+ (void) lambda;
+ for (i = 0; i < n; i++) {
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+ sample_2d_nearest( tObj, images[tObj->BaseLevel], newS, newT, rgba[i] );
+ }
+}
+
+
+static void
+sample_linear_cube(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;
+ (void) lambda;
+ for (i = 0; i < n; i++) {
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+ sample_2d_linear( tObj, images[tObj->BaseLevel], newS, newT, rgba[i] );
+ }
+}
+
+
+static void
+sample_cube_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat u,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ GLint level;
+
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+
+ images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+ sample_2d_nearest( tObj, images[level], newS, newT, rgba );
+}
+
+
+static void
+sample_cube_linear_mipmap_nearest( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat u,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ GLint level;
+
+ COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+
+ images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+ sample_2d_linear( tObj, images[level], newS, newT, rgba );
+}
+
+
+static void
+sample_cube_nearest_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat u,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+
+ if (level >= tObj->P) {
+ sample_2d_nearest( tObj, images[tObj->P], newS, newT, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4]; /* texels */
+ const GLfloat f = myFrac(lambda);
+ sample_2d_nearest( tObj, images[level ], newS, newT, t0 );
+ sample_2d_nearest( tObj, images[level+1], newS, newT, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+static void
+sample_cube_linear_mipmap_linear( const struct gl_texture_object *tObj,
+ GLfloat s, GLfloat t, GLfloat u,
+ GLfloat lambda, GLchan rgba[4] )
+{
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ GLint level;
+
+ COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+ images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+
+ if (level >= tObj->P) {
+ sample_2d_linear( tObj, images[tObj->P], newS, newT, rgba );
+ }
+ else {
+ GLchan t0[4], t1[4];
+ const GLfloat f = myFrac(lambda);
+ sample_2d_linear( tObj, images[level ], newS, newT, t0 );
+ sample_2d_linear( tObj, images[level+1], newS, newT, t1 );
+ rgba[RCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+ rgba[GCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+ rgba[BCOMP] = (GLchan) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+ rgba[ACOMP] = (GLchan) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+ }
+}
+
+
+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])
+{
+ GLuint i;
+
+ for (i = 0; i < n; i++) {
+ if (lambda[i] > tObj->MinMagThresh) {
+ /* minification */
+ switch (tObj->MinFilter) {
+ case GL_NEAREST:
+ {
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ images = choose_cube_face(tObj, s[i], t[i], u[i],
+ &newS, &newT);
+ sample_2d_nearest( tObj, images[tObj->BaseLevel],
+ newS, newT, rgba[i] );
+ }
+ break;
+ case GL_LINEAR:
+ {
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ images = choose_cube_face(tObj, s[i], t[i], u[i],
+ &newS, &newT);
+ sample_2d_linear( tObj, images[tObj->BaseLevel],
+ newS, newT, rgba[i] );
+ }
+ break;
+ case GL_NEAREST_MIPMAP_NEAREST:
+ sample_cube_nearest_mipmap_nearest( tObj, s[i], t[i], u[i],
+ lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_NEAREST:
+ sample_cube_linear_mipmap_nearest( tObj, s[i], t[i], u[i],
+ lambda[i], rgba[i] );
+ break;
+ case GL_NEAREST_MIPMAP_LINEAR:
+ sample_cube_nearest_mipmap_linear( tObj, s[i], t[i], u[i],
+ lambda[i], rgba[i] );
+ break;
+ case GL_LINEAR_MIPMAP_LINEAR:
+ sample_cube_linear_mipmap_linear( tObj, s[i], t[i], u[i],
+ lambda[i], rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad min filter in sample_lambda_cube");
+ }
+ }
+ else {
+ /* magnification */
+ const struct gl_texture_image **images;
+ GLfloat newS, newT;
+ images = choose_cube_face(tObj, s[i], t[i], u[i],
+ &newS, &newT);
+ switch (tObj->MagFilter) {
+ case GL_NEAREST:
+ sample_2d_nearest( tObj, images[tObj->BaseLevel],
+ newS, newT, rgba[i] );
+ break;
+ case GL_LINEAR:
+ sample_2d_linear( tObj, images[tObj->BaseLevel],
+ newS, newT, rgba[i] );
+ break;
+ default:
+ gl_problem(NULL, "Bad mag filter in sample_lambda_cube");
+ }
+ }
+ }
+}
+
+
+/**********************************************************************/
+/* Texture Sampling Setup */
+/**********************************************************************/
+
+
+/*
+ * Setup the texture sampling function for this texture object.
+ */
+void
+_swrast_set_texture_sampler( struct gl_texture_object *t )
+{
+ if (!t->Complete) {
+ t->SampleFunc = NULL;
+ }
+ else {
+ GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
+
+ if (needLambda) {
+ /* Compute min/mag filter threshold */
+ if (t->MagFilter==GL_LINEAR
+ && (t->MinFilter==GL_NEAREST_MIPMAP_NEAREST ||
+ t->MinFilter==GL_LINEAR_MIPMAP_NEAREST)) {
+ t->MinMagThresh = 0.5F;
+ }
+ else {
+ t->MinMagThresh = 0.0F;
+ }
+ }
+
+ switch (t->Dimensions) {
+ case 1:
+ if (needLambda) {
+ t->SampleFunc = sample_lambda_1d;
+ }
+ else if (t->MinFilter==GL_LINEAR) {
+ t->SampleFunc = sample_linear_1d;
+ }
+ else {
+ ASSERT(t->MinFilter==GL_NEAREST);
+ t->SampleFunc = sample_nearest_1d;
+ }
+ break;
+ case 2:
+ if (needLambda) {
+ t->SampleFunc = sample_lambda_2d;
+ }
+ else if (t->MinFilter==GL_LINEAR) {
+ t->SampleFunc = 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;
+ }
+ 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;
+ }
+ else
+ t->SampleFunc = sample_nearest_2d;
+ }
+ break;
+ case 3:
+ if (needLambda) {
+ t->SampleFunc = sample_lambda_3d;
+ }
+ else if (t->MinFilter==GL_LINEAR) {
+ t->SampleFunc = sample_linear_3d;
+ }
+ else {
+ ASSERT(t->MinFilter==GL_NEAREST);
+ t->SampleFunc = sample_nearest_3d;
+ }
+ break;
+ case 6: /* cube map */
+ if (needLambda) {
+ t->SampleFunc = sample_lambda_cube;
+ }
+ else if (t->MinFilter==GL_LINEAR) {
+ t->SampleFunc = sample_linear_cube;
+ }
+ else {
+ ASSERT(t->MinFilter==GL_NEAREST);
+ t->SampleFunc = sample_nearest_cube;
+ }
+ break;
+ default:
+ gl_problem(NULL, "invalid dimensions in _mesa_set_texture_sampler");
+ }
+ }
+}
+
+
+#define PROD(A,B) ( (GLuint)(A) * ((GLuint)(B)+1) )
+
+static INLINE void
+_mesa_texture_combine(const GLcontext *ctx,
+ const struct gl_texture_unit *textureUnit,
+ GLuint n,
+ GLchan (*primary_rgba)[4],
+ GLchan (*texel)[4],
+ GLchan (*rgba)[4])
+{
+ GLchan ccolor [3][3*MAX_WIDTH][4];
+ GLchan (*argRGB [3])[4];
+ GLchan (*argA [3])[4];
+ GLuint i, j;
+ const GLuint RGBshift = textureUnit->CombineScaleShiftRGB;
+ const GLuint Ashift = textureUnit->CombineScaleShiftA;
+
+ ASSERT(ctx->Extensions.EXT_texture_env_combine);
+
+ for (j = 0; j < 3; j++) {
+ switch (textureUnit->CombineSourceA[j]) {
+ case GL_TEXTURE:
+ argA[j] = texel;
+ break;
+ case GL_PRIMARY_COLOR_EXT:
+ argA[j] = primary_rgba;
+ break;
+ case GL_PREVIOUS_EXT:
+ argA[j] = rgba;
+ break;
+ case GL_CONSTANT_EXT:
+ {
+ GLchan (*c)[4] = ccolor[j];
+ GLchan alpha = FLOAT_TO_CHAN(textureUnit->EnvColor[3]);
+ for (i = 0; i < n; i++)
+ c[i][ACOMP] = alpha;
+ argA[j] = ccolor[j];
+ }
+ break;
+ default:
+ gl_problem(NULL, "invalid combine source");
+ }
+
+ switch (textureUnit->CombineSourceRGB[j]) {
+ case GL_TEXTURE:
+ argRGB[j] = texel;
+ break;
+ case GL_PRIMARY_COLOR_EXT:
+ argRGB[j] = primary_rgba;
+ break;
+ case GL_PREVIOUS_EXT:
+ argRGB[j] = rgba;
+ break;
+ case GL_CONSTANT_EXT:
+ {
+ GLchan (*c)[4] = ccolor[j];
+ const GLchan red = FLOAT_TO_CHAN(textureUnit->EnvColor[0]);
+ const GLchan green = FLOAT_TO_CHAN(textureUnit->EnvColor[1]);
+ const GLchan blue = FLOAT_TO_CHAN(textureUnit->EnvColor[2]);
+ for (i = 0; i < n; i++) {
+ c[i][RCOMP] = red;
+ c[i][GCOMP] = green;
+ c[i][BCOMP] = blue;
+ }
+ argRGB[j] = ccolor[j];
+ }
+ break;
+ default:
+ gl_problem(NULL, "invalid combine source");
+ }
+
+ if (textureUnit->CombineOperandRGB[j] != GL_SRC_COLOR) {
+ GLchan (*src)[4] = argRGB[j];
+ GLchan (*dst)[4] = ccolor[j];
+
+ argRGB[j] = ccolor[j];
+
+ if (textureUnit->CombineOperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
+ for (i = 0; i < n; i++) {
+ dst[i][RCOMP] = CHAN_MAX - src[i][RCOMP];
+ dst[i][GCOMP] = CHAN_MAX - src[i][GCOMP];
+ dst[i][BCOMP] = CHAN_MAX - src[i][BCOMP];
+ }
+ }
+ else if (textureUnit->CombineOperandRGB[j] == GL_SRC_ALPHA) {
+ src = argA[j];
+ for (i = 0; i < n; i++) {
+ dst[i][RCOMP] = src[i][ACOMP];
+ dst[i][GCOMP] = src[i][ACOMP];
+ dst[i][BCOMP] = src[i][ACOMP];
+ }
+ }
+ else { /* GL_ONE_MINUS_SRC_ALPHA */
+ src = argA[j];
+ for (i = 0; i < n; i++) {
+ dst[i][RCOMP] = CHAN_MAX - src[i][ACOMP];
+ dst[i][GCOMP] = CHAN_MAX - src[i][ACOMP];
+ dst[i][BCOMP] = CHAN_MAX - src[i][ACOMP];
+ }
+ }
+ }
+
+ if (textureUnit->CombineOperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
+ GLchan (*src)[4] = argA[j];
+ GLchan (*dst)[4] = ccolor[j];
+ argA[j] = ccolor[j];
+ for (i = 0; i < n; i++) {
+ dst[i][ACOMP] = CHAN_MAX - src[i][ACOMP];
+ }
+ }
+
+ if (textureUnit->CombineModeRGB == GL_REPLACE &&
+ textureUnit->CombineModeA == GL_REPLACE) {
+ break; /* done, we need only arg0 */
+ }
+
+ if (j == 1 &&
+ textureUnit->CombineModeRGB != GL_INTERPOLATE_EXT &&
+ textureUnit->CombineModeA != GL_INTERPOLATE_EXT) {
+ break; /* arg0 and arg1 are done. we don't need arg2. */
+ }
+ }
+
+ switch (textureUnit->CombineModeRGB) {
+ case GL_REPLACE:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+ if (RGBshift) {
+ for (i = 0; i < n; i++) {
+ GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
+ GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
+ GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ }
+ }
+ else {
+ for (i = 0; i < n; i++) {
+ rgba[i][RCOMP] = arg0[i][RCOMP];
+ rgba[i][GCOMP] = arg0[i][GCOMP];
+ rgba[i][BCOMP] = arg0[i][BCOMP];
+ }
+ }
+ }
+ break;
+ case GL_MODULATE:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+ const GLint shift = 8 - RGBshift;
+ for (i = 0; i < n; i++) {
+ GLuint r = PROD(arg0[i][0], arg1[i][RCOMP]) >> shift;
+ GLuint g = PROD(arg0[i][1], arg1[i][GCOMP]) >> shift;
+ GLuint b = PROD(arg0[i][2], arg1[i][BCOMP]) >> shift;
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_ADD:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+ for (i = 0; i < n; i++) {
+ GLint r = ((GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP]) << RGBshift;
+ GLint g = ((GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP]) << RGBshift;
+ GLint b = ((GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP]) << RGBshift;
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_ADD_SIGNED_EXT:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+ for (i = 0; i < n; i++) {
+ GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] - 128;
+ GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] - 128;
+ GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] - 128;
+ r = (r < 0) ? 0 : r << RGBshift;
+ g = (g < 0) ? 0 : g << RGBshift;
+ b = (b < 0) ? 0 : b << RGBshift;
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_INTERPOLATE_EXT:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+ const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
+ const GLint shift = 8 - RGBshift;
+ for (i = 0; i < n; i++) {
+ GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
+ + PROD(arg1[i][RCOMP], CHAN_MAX - arg2[i][RCOMP]))
+ >> shift;
+ GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
+ + PROD(arg1[i][GCOMP], CHAN_MAX - arg2[i][GCOMP]))
+ >> shift;
+ GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
+ + PROD(arg1[i][BCOMP], CHAN_MAX - arg2[i][BCOMP]))
+ >> shift;
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL, "invalid combine mode");
+ }
+
+ switch (textureUnit->CombineModeA) {
+ case GL_REPLACE:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+ if (Ashift) {
+ for (i = 0; i < n; i++) {
+ GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
+ rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+ }
+ }
+ else {
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = arg0[i][ACOMP];
+ }
+ }
+ }
+ break;
+ case GL_MODULATE:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+ const GLint shift = 8 - Ashift;
+ for (i = 0; i < n; i++) {
+ GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift);
+ rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_ADD:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+ for (i = 0; i < n; i++) {
+ GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
+ rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_ADD_SIGNED_EXT:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+ for (i = 0; i < n; i++) {
+ GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] - 128;
+ a = (a < 0) ? 0 : a << Ashift;
+ rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+ }
+ }
+ break;
+ case GL_INTERPOLATE_EXT:
+ {
+ const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+ const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+ const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
+ const GLint shift = 8 - Ashift;
+ for (i=0; i<n; i++) {
+ GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
+ + PROD(arg1[i][ACOMP], CHAN_MAX - arg2[i][ACOMP]))
+ >> shift;
+ rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL, "invalid combine mode");
+ }
+}
+#undef PROD
+
+
+
+/**********************************************************************/
+/* Texture Application */
+/**********************************************************************/
+
+
+/*
+ * Combine incoming fragment color with texel color to produce output color.
+ * Input: textureUnit - pointer to texture unit to apply
+ * format - base internal texture format
+ * n - number of fragments
+ * primary_rgba - primary colors (may be rgba for single texture)
+ * texels - array of texel colors
+ * InOut: rgba - incoming fragment colors modified by texel colors
+ * according to the texture environment mode.
+ */
+static void
+apply_texture( const GLcontext *ctx,
+ const struct gl_texture_unit *texUnit,
+ GLuint n,
+ GLchan primary_rgba[][4], GLchan texel[][4],
+ GLchan rgba[][4] )
+{
+ GLint baseLevel;
+ GLuint i;
+ GLint Rc, Gc, Bc, Ac;
+ GLenum format;
+
+ ASSERT(texUnit);
+ ASSERT(texUnit->Current);
+
+ baseLevel = texUnit->Current->BaseLevel;
+ ASSERT(texUnit->Current->Image[baseLevel]);
+
+ format = texUnit->Current->Image[baseLevel]->Format;
+
+ if (format==GL_COLOR_INDEX) {
+ format = GL_RGBA; /* XXXX a hack! */
+ }
+
+ switch (texUnit->EnvMode) {
+ case GL_REPLACE:
+ switch (format) {
+ case GL_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf */
+ /* Av = At */
+ rgba[i][ACOMP] = texel[i][ACOMP];
+ }
+ break;
+ case GL_LUMINANCE:
+ for (i=0;i<n;i++) {
+ /* Cv = Lt */
+ GLchan Lt = texel[i][RCOMP];
+ rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
+ /* Av = Af */
+ }
+ break;
+ case GL_LUMINANCE_ALPHA:
+ for (i=0;i<n;i++) {
+ GLchan Lt = texel[i][RCOMP];
+ /* Cv = Lt */
+ rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
+ /* Av = At */
+ rgba[i][ACOMP] = texel[i][ACOMP];
+ }
+ break;
+ case GL_INTENSITY:
+ for (i=0;i<n;i++) {
+ /* Cv = It */
+ GLchan It = texel[i][RCOMP];
+ rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
+ /* Av = It */
+ rgba[i][ACOMP] = It;
+ }
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ /* Cv = Ct */
+ rgba[i][RCOMP] = texel[i][RCOMP];
+ rgba[i][GCOMP] = texel[i][GCOMP];
+ rgba[i][BCOMP] = texel[i][BCOMP];
+ /* Av = Af */
+ }
+ break;
+ case GL_RGBA:
+ for (i=0;i<n;i++) {
+ /* Cv = Ct */
+ rgba[i][RCOMP] = texel[i][RCOMP];
+ rgba[i][GCOMP] = texel[i][GCOMP];
+ rgba[i][BCOMP] = texel[i][BCOMP];
+ /* Av = At */
+ rgba[i][ACOMP] = texel[i][ACOMP];
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad format (GL_REPLACE) in apply_texture");
+ return;
+ }
+ break;
+
+ case GL_MODULATE:
+ switch (format) {
+ case GL_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf */
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+ }
+ break;
+ case GL_LUMINANCE:
+ for (i=0;i<n;i++) {
+ /* Cv = LtCf */
+ GLchan Lt = texel[i][RCOMP];
+ rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
+ rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
+ rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+ /* Av = Af */
+ }
+ break;
+ case GL_LUMINANCE_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Cv = CfLt */
+ GLchan Lt = texel[i][RCOMP];
+ rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
+ rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
+ rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+ }
+ break;
+ case GL_INTENSITY:
+ for (i=0;i<n;i++) {
+ /* Cv = CfIt */
+ GLchan It = texel[i][RCOMP];
+ rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], It );
+ rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], It );
+ rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], It );
+ /* Av = AfIt */
+ rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], It );
+ }
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ /* Cv = CfCt */
+ rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
+ rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
+ rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+ /* Av = Af */
+ }
+ break;
+ case GL_RGBA:
+ for (i=0;i<n;i++) {
+ /* Cv = CfCt */
+ rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
+ rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
+ rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad format (GL_MODULATE) in apply_texture");
+ return;
+ }
+ break;
+
+ case GL_DECAL:
+ switch (format) {
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_LUMINANCE_ALPHA:
+ case GL_INTENSITY:
+ /* undefined */
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ /* Cv = Ct */
+ rgba[i][RCOMP] = texel[i][RCOMP];
+ rgba[i][GCOMP] = texel[i][GCOMP];
+ rgba[i][BCOMP] = texel[i][BCOMP];
+ /* Av = Af */
+ }
+ break;
+ case GL_RGBA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-At) + CtAt */
+ GLint t = texel[i][ACOMP], s = CHAN_MAX - t;
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(texel[i][RCOMP],t);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(texel[i][GCOMP],t);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(texel[i][BCOMP],t);
+ /* Av = Af */
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad format (GL_DECAL) in apply_texture");
+ return;
+ }
+ break;
+
+ case GL_BLEND:
+ Rc = (GLint) (texUnit->EnvColor[0] * CHAN_MAXF);
+ Gc = (GLint) (texUnit->EnvColor[1] * CHAN_MAXF);
+ Bc = (GLint) (texUnit->EnvColor[2] * CHAN_MAXF);
+ Ac = (GLint) (texUnit->EnvColor[3] * CHAN_MAXF);
+ switch (format) {
+ case GL_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf */
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+ }
+ break;
+ case GL_LUMINANCE:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-Lt) + CcLt */
+ GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+ /* Av = Af */
+ }
+ break;
+ case GL_LUMINANCE_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-Lt) + CcLt */
+ GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+ }
+ break;
+ case GL_INTENSITY:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-It) + CcLt */
+ GLchan It = texel[i][RCOMP], s = CHAN_MAX - It;
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, It);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, It);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, It);
+ /* Av = Af(1-It) + Ac*It */
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], s) + CHAN_PRODUCT(Ac, It);
+ }
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-Ct) + CcCt */
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+ /* Av = Af */
+ }
+ break;
+ case GL_RGBA:
+ for (i=0;i<n;i++) {
+ /* Cv = Cf(1-Ct) + CcCt */
+ rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
+ rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
+ rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+ /* Av = AfAt */
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad format (GL_BLEND) in apply_texture");
+ return;
+ }
+ break;
+
+ case GL_ADD: /* GL_EXT_texture_add_env */
+ switch (format) {
+ case GL_ALPHA:
+ for (i=0;i<n;i++) {
+ /* Rv = Rf */
+ /* Gv = Gf */
+ /* Bv = Bf */
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+ }
+ break;
+ case GL_LUMINANCE:
+ for (i=0;i<n;i++) {
+ GLuint Lt = texel[i][RCOMP];
+ GLuint r = rgba[i][RCOMP] + Lt;
+ GLuint g = rgba[i][GCOMP] + Lt;
+ GLuint b = rgba[i][BCOMP] + Lt;
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ /* Av = Af */
+ }
+ break;
+ case GL_LUMINANCE_ALPHA:
+ for (i=0;i<n;i++) {
+ GLuint Lt = texel[i][RCOMP];
+ GLuint r = rgba[i][RCOMP] + Lt;
+ GLuint g = rgba[i][GCOMP] + Lt;
+ GLuint b = rgba[i][BCOMP] + Lt;
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+ }
+ break;
+ case GL_INTENSITY:
+ for (i=0;i<n;i++) {
+ GLchan It = texel[i][RCOMP];
+ GLuint r = rgba[i][RCOMP] + It;
+ GLuint g = rgba[i][GCOMP] + It;
+ GLuint b = rgba[i][BCOMP] + It;
+ GLuint a = rgba[i][ACOMP] + It;
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ rgba[i][ACOMP] = MIN2(a, CHAN_MAX);
+ }
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
+ GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
+ GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ /* Av = Af */
+ }
+ break;
+ case GL_RGBA:
+ for (i=0;i<n;i++) {
+ GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
+ GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
+ GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
+ rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+ rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+ }
+ break;
+ default:
+ gl_problem(ctx, "Bad format (GL_ADD) in apply_texture");
+ return;
+ }
+ break;
+
+ case GL_COMBINE_EXT: /* GL_EXT_combine_ext; we modify texel array */
+ switch (format) {
+ case GL_ALPHA:
+ for (i=0;i<n;i++)
+ texel[i][RCOMP] = texel[i][GCOMP] = texel[i][BCOMP] = 0;
+ break;
+ case GL_LUMINANCE:
+ for (i=0;i<n;i++) {
+ /* Cv = Lt */
+ GLchan Lt = texel[i][RCOMP];
+ texel[i][GCOMP] = texel[i][BCOMP] = Lt;
+ /* Av = 1 */
+ texel[i][ACOMP] = CHAN_MAX;
+ }
+ break;
+ case GL_LUMINANCE_ALPHA:
+ for (i=0;i<n;i++) {
+ GLchan Lt = texel[i][RCOMP];
+ /* Cv = Lt */
+ texel[i][GCOMP] = texel[i][BCOMP] = Lt;
+ }
+ break;
+ case GL_INTENSITY:
+ for (i=0;i<n;i++) {
+ /* Cv = It */
+ GLchan It = texel[i][RCOMP];
+ texel[i][GCOMP] = texel[i][BCOMP] = It;
+ /* Av = It */
+ texel[i][ACOMP] = It;
+ }
+ break;
+ case GL_RGB:
+ for (i=0;i<n;i++) {
+ /* Av = 1 */
+ texel[i][ACOMP] = CHAN_MAX;
+ }
+ break;
+ case GL_RGBA: /* do nothing. */
+ break;
+ default:
+ gl_problem(ctx, "Bad format in apply_texture (GL_COMBINE_EXT)");
+ return;
+ }
+ _mesa_texture_combine(ctx, texUnit, n, primary_rgba, texel, rgba);
+ break;
+
+ default:
+ gl_problem(ctx, "Bad env mode in apply_texture");
+ return;
+ }
+}
+
+
+
+/*
+ * Apply a unit of texture mapping to the incoming fragments.
+ */
+void gl_texture_pixels( GLcontext *ctx, GLuint texUnit, GLuint n,
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat r[], GLfloat lambda[],
+ GLchan primary_rgba[][4], GLchan rgba[][4] )
+{
+ const GLuint mask = TEXTURE0_ANY << (texUnit * 4);
+
+ if (ctx->Texture.ReallyEnabled & mask) {
+ const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
+
+ if (textureUnit->Current && textureUnit->Current->SampleFunc) {
+ GLchan texel[PB_SIZE][4];
+
+ if (textureUnit->LodBias != 0.0F) {
+ /* apply LOD bias, but don't clamp yet */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ lambda[i] += textureUnit->LodBias;
+ }
+ }
+
+ 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;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLfloat l = lambda[i];
+ lambda[i] = CLAMP(l, min, max);
+ }
+ }
+
+ /* fetch texture images from device driver, if needed */
+ if (ctx->Driver.GetTexImage) {
+ if (!_mesa_get_teximages_from_driver(ctx, textureUnit->Current)) {
+ return;
+ }
+ }
+
+ /* Sample the texture. */
+ (*textureUnit->Current->SampleFunc)( textureUnit->Current, n,
+ s, t, r, lambda, texel );
+
+ apply_texture( ctx, textureUnit, n, primary_rgba, texel, rgba );
+ }
+ }
+}
--- /dev/null
+/* $Id: s_texture.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+
+
+
+#ifndef S_TEXTURE_H
+#define S_TEXTURE_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+extern void gl_texture_pixels( GLcontext *ctx, GLuint texSet, GLuint n,
+ const GLfloat s[], const GLfloat t[],
+ const GLfloat r[], GLfloat lambda[],
+ GLchan primary_rgba[][4], GLchan rgba[][4] );
+
+
+#endif
+
--- /dev/null
+/* $Id: s_triangle.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Triangle rasterizers
+ * When the device driver doesn't implement triangle rasterization Mesa
+ * will use these functions to draw triangles.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "feedback.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "teximage.h"
+#include "texstate.h"
+
+#include "s_aatriangle.h"
+#include "s_depth.h"
+#include "s_span.h"
+
+static GLboolean cull_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+ 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 c = ex*fy-ey*fx;
+
+ if (c * ctx->backface_sign > 0)
+ return 0;
+
+ return 1;
+}
+
+
+/*
+ * Render a flat-shaded color index triangle.
+ */
+static void flat_ci_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+#define INTERP_Z 1
+#define SETUP_CODE \
+ GLuint index = VB->IndexPtr->data[pv]; \
+ if (1) { \
+ /* set the color index */ \
+ (*ctx->Driver.Index)( ctx, index ); \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ const GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ if (n>0) { \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ ffz += fdzdx; \
+ fogspan[i] = fffog / 256; \
+ fffog += fdfogdx; \
+ } \
+ gl_write_monoindex_span( ctx, n, LEFT, Y, zspan, \
+ fogspan, index, GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Render a smooth-shaded color index triangle.
+ */
+static void smooth_ci_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+ (void) pv;
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ const GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLuint index[MAX_WIDTH]; \
+ if (n>0) { \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ ffz += fdzdx; \
+ index[i] = FixedToInt(ffi); \
+ ffi += fdidx; \
+ fogspan[i] = fffog / 256; \
+ fffog += fdfogdx; \
+ } \
+ gl_write_index_span( ctx, n, LEFT, Y, zspan, fogspan, \
+ index, GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Render a flat-shaded RGBA triangle.
+ */
+static void flat_rgba_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+
+#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]; \
+ (*ctx->Driver.Color)( ctx, r, g, b, a ); \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ const GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ if (n>0) { \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ ffz += fdzdx; \
+ fogspan[i] = fffog / 256; \
+ fffog += fdfogdx; \
+ } \
+ gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, \
+ fogspan, \
+ VB->ColorPtr->data[pv], \
+ GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+
+ ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */
+ ASSERT(ctx->Light.ShadeModel==GL_FLAT);
+}
+
+
+
+/*
+ * Render a smooth-shaded RGBA triangle.
+ */
+static void smooth_rgba_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ const GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ if (n>0) { \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ fogspan[i] = fffog / 256; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ } \
+ gl_write_rgba_span( ctx, n, LEFT, Y, \
+ (CONST GLdepth *) zspan, \
+ fogspan, \
+ rgba, GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+
+ ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */
+ ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);
+}
+
+
+/*
+ * Render an RGB, GL_DECAL, textured triangle.
+ * Interpolate S,T only w/out mipmapping or perspective correction.
+ *
+ * No fog.
+ */
+static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+#define SETUP_CODE \
+ struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \
+ GLint b = obj->BaseLevel; \
+ GLfloat twidth = (GLfloat) obj->Image[b]->Width; \
+ GLfloat theight = (GLfloat) obj->Image[b]->Height; \
+ GLint twidth_log2 = obj->Image[b]->WidthLog2; \
+ 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; \
+ texture = obj->Image[b]->Data; \
+ ASSERT(texture); \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ CONST GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLchan rgb[MAX_WIDTH][3]; \
+ if (n>0) { \
+ ffs -= FIXED_HALF; /* off-by-one error? */ \
+ fft -= FIXED_HALF; \
+ for (i=0;i<n;i++) { \
+ GLint s = FixedToInt(ffs) & smask; \
+ GLint t = FixedToInt(fft) & tmask; \
+ GLint pos = (t << twidth_log2) + s; \
+ pos = pos + pos + pos; /* multiply by 3 */ \
+ rgb[i][RCOMP] = texture[pos]; \
+ rgb[i][GCOMP] = texture[pos+1]; \
+ rgb[i][BCOMP] = texture[pos+2]; \
+ ffs += fdsdx; \
+ fft += fdtdx; \
+ } \
+ (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \
+ (CONST GLchan (*)[3]) rgb, NULL ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render an RGB, GL_DECAL, textured triangle.
+ * Interpolate S,T, GL_LESS depth test, w/out mipmapping or
+ * perspective correction.
+ *
+ * No fog.
+ */
+static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+#define SETUP_CODE \
+ struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \
+ GLint b = obj->BaseLevel; \
+ GLfloat twidth = (GLfloat) obj->Image[b]->Width; \
+ GLfloat theight = (GLfloat) obj->Image[b]->Height; \
+ GLint twidth_log2 = obj->Image[b]->WidthLog2; \
+ 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; \
+ texture = obj->Image[b]->Data; \
+ ASSERT(texture); \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ CONST GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLchan rgb[MAX_WIDTH][3]; \
+ GLubyte mask[MAX_WIDTH]; \
+ (void) fffog; \
+ if (n>0) { \
+ ffs -= FIXED_HALF; /* off-by-one error? */ \
+ fft -= FIXED_HALF; \
+ for (i=0;i<n;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ GLint s = FixedToInt(ffs) & smask; \
+ GLint t = FixedToInt(fft) & tmask; \
+ GLint pos = (t << twidth_log2) + s; \
+ pos = pos + pos + pos; /* multiply by 3 */ \
+ rgb[i][RCOMP] = texture[pos]; \
+ rgb[i][GCOMP] = texture[pos+1]; \
+ rgb[i][BCOMP] = texture[pos+2]; \
+ zRow[i] = z; \
+ mask[i] = 1; \
+ } \
+ else { \
+ mask[i] = 0; \
+ } \
+ ffz += fdzdx; \
+ ffs += fdsdx; \
+ fft += fdtdx; \
+ } \
+ (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \
+ (CONST GLchan (*)[3]) rgb, mask ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Render an RGB/RGBA textured triangle without perspective correction.
+ */
+static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+#define SETUP_CODE \
+ struct gl_texture_unit *unit = ctx->Texture.Unit+0; \
+ struct gl_texture_object *obj = unit->CurrentD[2]; \
+ GLint b = obj->BaseLevel; \
+ GLfloat twidth = (GLfloat) obj->Image[b]->Width; \
+ GLfloat theight = (GLfloat) obj->Image[b]->Height; \
+ GLint twidth_log2 = obj->Image[b]->WidthLog2; \
+ GLchan *texture = obj->Image[b]->Data; \
+ GLint smask = obj->Image[b]->Width - 1; \
+ GLint tmask = obj->Image[b]->Height - 1; \
+ GLint format = obj->Image[b]->Format; \
+ GLint filter = obj->MinFilter; \
+ GLint envmode = unit->EnvMode; \
+ GLint comp, tbytesline, tsize; \
+ GLfixed er, eg, eb, ea; \
+ GLint tr, tg, tb, ta; \
+ if (!texture) { \
+ if (!_mesa_get_teximages_from_driver(ctx, obj)) \
+ return; \
+ texture = obj->Image[b]->Data; \
+ ASSERT(texture); \
+ } \
+ if (envmode == GL_BLEND || envmode == GL_ADD) { \
+ /* potential off-by-one error here? (1.0f -> 2048 -> 0) */ \
+ er = FloatToFixed(unit->EnvColor[0]); \
+ eg = FloatToFixed(unit->EnvColor[1]); \
+ 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 affine_texture_triangle");\
+ return; \
+ } \
+ 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
+ * and complexity. Observe that an optimizing compiler kills
+ * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
+ */
+
+#define NEAREST_RGB \
+ tr = tex00[0]; \
+ tg = tex00[1]; \
+ tb = tex00[2]; \
+ ta = 0xff
+
+#define LINEAR_RGB \
+ tr = (ti * (si * tex00[0] + sf * tex01[0]) + \
+ tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \
+ tg = (ti * (si * tex00[1] + sf * tex01[1]) + \
+ tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \
+ tb = (ti * (si * tex00[2] + sf * tex01[2]) + \
+ tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \
+ ta = 0xff
+
+#define NEAREST_RGBA \
+ tr = tex00[0]; \
+ tg = tex00[1]; \
+ tb = tex00[2]; \
+ ta = tex00[3]
+
+#define LINEAR_RGBA \
+ tr = (ti * (si * tex00[0] + sf * tex01[0]) + \
+ tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \
+ tg = (ti * (si * tex00[1] + sf * tex01[1]) + \
+ tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \
+ tb = (ti * (si * tex00[2] + sf * tex01[2]) + \
+ tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \
+ ta = (ti * (si * tex00[3] + sf * tex01[3]) + \
+ tf * (si * tex10[3] + sf * tex11[3])) >> 2 * FIXED_SHIFT
+
+#define MODULATE \
+ dest[0] = ffr * (tr + 1) >> (FIXED_SHIFT + 8); \
+ dest[1] = ffg * (tg + 1) >> (FIXED_SHIFT + 8); \
+ dest[2] = ffb * (tb + 1) >> (FIXED_SHIFT + 8); \
+ dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)
+
+#define DECAL \
+ dest[0] = ((0xff - ta) * ffr + ((ta + 1) * tr << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
+ dest[1] = ((0xff - ta) * ffg + ((ta + 1) * tg << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
+ dest[2] = ((0xff - ta) * ffb + ((ta + 1) * tb << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
+ dest[3] = FixedToInt(ffa)
+
+#define BLEND \
+ dest[0] = ((0xff - tr) * ffr + (tr + 1) * er) >> (FIXED_SHIFT + 8); \
+ dest[1] = ((0xff - tg) * ffg + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \
+ dest[2] = ((0xff - tb) * ffb + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \
+ dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)
+
+#define REPLACE \
+ dest[0] = tr; \
+ dest[1] = tg; \
+ dest[2] = tb; \
+ dest[3] = ta
+
+#define ADD \
+ dest[0] = ((ffr << 8) + (tr + 1) * er) >> (FIXED_SHIFT + 8); \
+ dest[1] = ((ffg << 8) + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \
+ dest[2] = ((ffb << 8) + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \
+ dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)
+
+/* shortcuts */
+
+#define NEAREST_RGB_REPLACE NEAREST_RGB;REPLACE
+
+#define NEAREST_RGBA_REPLACE *(GLint *)dest = *(GLint *)tex00
+
+#define SPAN1(DO_TEX,COMP) \
+ for (i=0;i<n;i++) { \
+ GLint s = FixedToInt(ffs) & smask; \
+ GLint t = FixedToInt(fft) & tmask; \
+ GLint pos = (t << twidth_log2) + s; \
+ GLchan *tex00 = texture + COMP * pos; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ DO_TEX; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ffs += fdsdx; \
+ fft += fdtdx; \
+ dest += 4; \
+ }
+
+#define SPAN2(DO_TEX,COMP) \
+ for (i=0;i<n;i++) { \
+ GLint s = FixedToInt(ffs) & smask; \
+ GLint t = FixedToInt(fft) & tmask; \
+ GLint sf = ffs & FIXED_FRAC_MASK; \
+ GLint tf = fft & FIXED_FRAC_MASK; \
+ GLint si = FIXED_FRAC_MASK - sf; \
+ GLint ti = FIXED_FRAC_MASK - tf; \
+ GLint pos = (t << twidth_log2) + s; \
+ GLchan *tex00 = texture + COMP * pos; \
+ GLchan *tex10 = tex00 + tbytesline; \
+ GLchan *tex01 = tex00 + COMP; \
+ GLchan *tex11 = tex10 + COMP; \
+ if (t == tmask) { \
+ tex10 -= tsize; \
+ tex11 -= tsize; \
+ } \
+ if (s == smask) { \
+ tex01 -= tbytesline; \
+ tex11 -= tbytesline; \
+ } \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ DO_TEX; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ffs += fdsdx; \
+ fft += fdtdx; \
+ dest += 4; \
+ }
+
+/* here comes the heavy part.. (something for the compiler to chew on) */
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ CONST GLint n = RIGHT-LEFT; \
+ GLint i; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ if (n>0) { \
+ GLchan *dest = rgba[0]; \
+ ffs -= FIXED_HALF; /* off-by-one error? */ \
+ fft -= FIXED_HALF; \
+ switch (filter) { \
+ case GL_NEAREST: \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGB;MODULATE,3); \
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGB_REPLACE,3); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGB;BLEND,3); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGB;ADD,3); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGBA;MODULATE,4); \
+ break; \
+ case GL_DECAL: \
+ SPAN1(NEAREST_RGBA;DECAL,4); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGBA;BLEND,4); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGBA;ADD,4); \
+ break; \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGBA_REPLACE,4); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ break; \
+ case GL_LINEAR: \
+ ffs -= FIXED_HALF; \
+ fft -= FIXED_HALF; \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN2(LINEAR_RGB;MODULATE,3); \
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN2(LINEAR_RGB;REPLACE,3); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(LINEAR_RGB;BLEND,3); \
+ break; \
+ case GL_ADD: \
+ SPAN2(LINEAR_RGB;ADD,3); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN2(LINEAR_RGBA;MODULATE,4); \
+ break; \
+ case GL_DECAL: \
+ SPAN2(LINEAR_RGBA;DECAL,4); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(LINEAR_RGBA;BLEND,4); \
+ break; \
+ case GL_ADD: \
+ SPAN2(LINEAR_RGBA;ADD,4); \
+ break; \
+ case GL_REPLACE: \
+ SPAN2(LINEAR_RGBA;REPLACE,4); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ break; \
+ } \
+ gl_write_rgba_span(ctx, n, LEFT, Y, zspan, \
+ fogspan, \
+ rgba, GL_POLYGON); \
+ /* explicit kill of variables: */ \
+ ffr = ffg = ffb = ffa = 0; \
+ } \
+ }
+
+#include "s_tritemp.h"
+#undef SPAN1
+#undef SPAN2
+}
+
+
+
+/*
+ * Render an perspective corrected RGB/RGBA textured triangle.
+ * The Q (aka V in Mesa) coordinate must be zero such that the divide
+ * by interpolated Q/W comes out right.
+ *
+ * This function only renders textured triangles that use GL_NEAREST.
+ * Perspective correction works right.
+ *
+ * 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 )
+{
+/* The BIAS value is used to shift negative values into positive values.
+ * Without this, negative texture values don't GL_REPEAT correctly at just
+ * below zero, because (int)-0.5 = 0 = (int)0.5. We're not going to worry
+ * about texture coords less than -BIAS. This could be fixed by using
+ * FLOORF etc. instead, but this is slower...
+ */
+#define BIAS 4096.0F
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define SETUP_CODE \
+ struct gl_texture_unit *unit = ctx->Texture.Unit+0; \
+ struct gl_texture_object *obj = unit->CurrentD[2]; \
+ const GLint b = obj->BaseLevel; \
+ const GLfloat twidth = (GLfloat) obj->Image[b]->Width; \
+ const GLfloat theight = (GLfloat) obj->Image[b]->Height; \
+ const GLint twidth_log2 = obj->Image[b]->WidthLog2; \
+ GLchan *texture = obj->Image[b]->Data; \
+ const GLint smask = (obj->Image[b]->Width - 1); \
+ const GLint tmask = (obj->Image[b]->Height - 1); \
+ 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) { \
+ if (!_mesa_get_teximages_from_driver(ctx, obj)) \
+ return; \
+ texture = obj->Image[b]->Data; \
+ ASSERT(texture); \
+ } \
+ if (envmode == GL_BLEND || envmode == GL_ADD) { \
+ er = FloatToFixed(unit->EnvColor[0]); \
+ eg = FloatToFixed(unit->EnvColor[1]); \
+ 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++) { \
+ GLfloat invQ = 1.0f / vv; \
+ GLint s = (int)(SS * invQ + BIAS) & smask; \
+ GLint t = (int)(TT * invQ + BIAS) & tmask; \
+ GLint pos = COMP * ((t << twidth_log2) + s); \
+ GLchan *tex00 = texture + pos; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ DO_TEX; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ SS += dSdx; \
+ TT += dTdx; \
+ vv += dvdx; \
+ dest += 4; \
+ }
+
+#define X_Y_TEX_COORD(X, Y) ((((int)(X) & tmask) << twidth_log2) + ((int)(Y) & smask))
+#define Y_X_TEX_COORD(X, Y) ((((int)(Y) & tmask) << twidth_log2) + ((int)(X) & smask))
+
+#define SPAN1(DO_TEX, COMP, TEX_COORD) { \
+ GLfloat x_max = CEILF(x_tex); \
+ GLfloat y_max = y_tex + (x_max - x_tex) * dy_dx; \
+ GLint j, x_m = (int)x_max; \
+ GLint pos; \
+ if ((int)y_max != (int)y_tex) { \
+ GLfloat x_mid = x_tex + (CEILF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_tex, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_max; \
+ } \
+ nominator += vv * x_max; \
+ denominator -= dvdx * x_max; \
+ j = nominator / denominator; \
+ pos = COMP * TEX_COORD(x_tex, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ while (i<n) { \
+ y_tex = y_max; \
+ y_max += dy_dx; \
+ if ((int)y_max != (int)y_tex) { \
+ GLfloat x_mid = (CEILF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_max; \
+ } \
+ nominator += vv; \
+ denominator -= dvdx; \
+ j = nominator/denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ x_m ++; \
+ } \
+}
+
+#define SPAN2(DO_TEX, COMP, TEX_COORD) { \
+ GLfloat x_max = CEILF (x_tex); \
+ GLfloat y_max = y_tex + (x_max - x_tex) * dy_dx; \
+ GLint j, x_m = (int) x_max; \
+ GLint pos; \
+ if ((int)y_max != (int)y_tex) { \
+ GLfloat x_mid = x_tex + (FLOORF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_tex, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_max; \
+ } \
+ nominator += vv * x_max; \
+ denominator -= dvdx * x_max; \
+ j = nominator / denominator; \
+ pos = COMP * TEX_COORD(x_tex, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ while (i<n) { \
+ y_tex = y_max; \
+ y_max += dy_dx; \
+ if ((int)y_max != (int)y_tex) { \
+ GLfloat x_mid = (FLOORF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid);\
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_max; \
+ } \
+ nominator += vv; \
+ denominator -= dvdx; \
+ j = nominator/denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ x_m ++; \
+ } \
+}
+
+#define SPAN3(DO_TEX, COMP, TEX_COORD) { \
+ GLfloat x_min = FLOORF (x_tex); \
+ GLfloat y_min = y_tex + (x_min - x_tex) * dy_dx; \
+ GLint j, x_m = (int)x_min; \
+ GLint pos; \
+ if ((int)y_min != (int)y_tex) { \
+ GLfloat x_mid = x_tex + (CEILF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_min; \
+ } \
+ nominator += vv*x_min; \
+ denominator -= dvdx*x_min; \
+ j = nominator / denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ while (i<n) { \
+ x_m --; \
+ y_tex = y_min; \
+ y_min -= dy_dx; \
+ if ((int)y_min != (int)y_tex) { \
+ GLfloat x_mid = (CEILF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_min; \
+ } \
+ nominator -= vv; \
+ denominator += dvdx; \
+ j = nominator/denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ } \
+}
+
+#define SPAN4(DO_TEX, COMP, TEX_COORD) \
+{ \
+ GLfloat x_min = FLOORF(x_tex); \
+ GLint x_m = (int)x_min; \
+ GLfloat y_min = y_tex + (x_min - x_tex) * dy_dx; \
+ GLint j; \
+ GLint pos; \
+ if ((int)y_min != (int)y_tex) { \
+ GLfloat x_mid = x_tex + (FLOORF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_min; \
+ } \
+ nominator += vv * x_min; \
+ denominator -= dvdx * x_min; \
+ j = nominator / denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ while (i<n) { \
+ x_m --; \
+ y_tex = y_min; \
+ y_min -= dy_dx; \
+ if ((int)y_min != (int)y_tex) { \
+ GLfloat x_mid = (FLOORF(y_tex)-y_tex) * dx_dy; \
+ j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \
+ pos = COMP * TEX_COORD(x_m, (y_tex)); \
+ DRAW_LINE (DO_TEX); \
+ y_tex = y_min; \
+ } \
+ nominator -= vv; \
+ denominator += dvdx; \
+ j = nominator/denominator; \
+ pos = COMP * TEX_COORD(x_m, y_tex); \
+ DRAW_LINE (DO_TEX); \
+ } \
+}
+
+#define DRAW_LINE(DO_TEX) \
+ { \
+ GLchan *tex00 = texture + pos; \
+ if (j>n || j<-100000) \
+ j = n; \
+ while (i<j) { \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ DO_TEX; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ dest += 4; \
+ i++; \
+ } \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i = 0; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ (void)uu; /* please GCC */ \
+ if (n > 0) { \
+ GLchan *dest = rgba[0]; \
+ GLfloat SS = ss * sscale; \
+ GLfloat TT = tt * tscale; \
+ GLfloat dSdx = dsdx * sscale; \
+ GLfloat dTdx = dtdx * tscale; \
+ GLfloat x_tex; \
+ GLfloat y_tex; \
+ GLfloat dx_tex; \
+ GLfloat dy_tex; \
+ if (n<5) /* When line very short, setup-time > speed-gain. */ \
+ goto old_span; /* So: take old method */ \
+ x_tex = SS / vv, \
+ y_tex = TT / vv; \
+ dx_tex = (SS + n * dSdx) / (vv + n * dvdx) - x_tex, \
+ dy_tex = (TT + n * dTdx) / (vv + n * dvdx) - y_tex; \
+ /* Choose between walking over texture or over pixelline: */ \
+ /* If there are few texels, walk over texture otherwise */ \
+ /* walk over pixelarray. The quotient on the right side */ \
+ /* should give the timeratio needed to draw one texel in */ \
+ /* comparison to one pixel. Depends on CPU. */ \
+ if (dx_tex*dx_tex + dy_tex*dy_tex < (n*n)/16) { \
+ x_tex += BIAS; \
+ y_tex += BIAS; \
+ if (dx_tex*dx_tex > dy_tex*dy_tex) { \
+ /* if (FABSF(dx_tex) > FABSF(dy_tex)) */ \
+ GLfloat nominator = - SS - vv * BIAS; \
+ GLfloat denominator = dvdx * BIAS + dSdx; \
+ GLfloat dy_dx; \
+ GLfloat dx_dy; \
+ if (dy_tex != 0.0f) { \
+ dy_dx = dy_tex / dx_tex; \
+ dx_dy = 1.0f/dy_dx; \
+ } \
+ else \
+ dy_dx = 0.0f; \
+ if (dx_tex > 0.0f) { \
+ if (dy_tex > 0.0f) { \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN1(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ else { /* dy_tex <= 0.0f */ \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN2(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN2(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN2(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN2(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN2(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN2(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN2(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ } \
+ else { /* dx_tex < 0.0f */ \
+ if (dy_tex > 0.0f) { \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN3(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN3(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN3(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN3(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN3(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN3(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN3(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN3(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN3(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ else { /* dy_tex <= 0.0f */ \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN4(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN4(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN4(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN4(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN4(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN4(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN4(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN4(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN4(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ } \
+ } \
+ else { /* FABSF(dx_tex) > FABSF(dy_tex) */ \
+ GLfloat swap; \
+ GLfloat dy_dx; \
+ GLfloat dx_dy; \
+ GLfloat nominator, denominator; \
+ if (dx_tex == 0.0f /* && dy_tex == 0.0f*/) \
+ goto old_span; /* case so special, that use old */ \
+ /* swap some x-values and y-values */ \
+ SS = TT; \
+ dSdx = dTdx; \
+ swap = x_tex, x_tex = y_tex, y_tex = swap; \
+ swap = dx_tex, dx_tex = dy_tex, dy_tex = swap; \
+ nominator = - SS - vv * BIAS; \
+ denominator = dvdx * BIAS + dSdx; \
+ if (dy_tex != 0.0f) { \
+ dy_dx = dy_tex / dx_tex; \
+ dx_dy = 1.0f/dy_dx; \
+ } \
+ else \
+ dy_dx = 0.0f; \
+ if (dx_tex > 0.0f) { \
+ if (dy_tex > 0.0f) { \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN1(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN1(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN1(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN1(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN1(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ else { /* dy_tex <= 0.0f */ \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN2(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN2(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN2(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN2(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN2(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN2(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN2(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN2(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ } \
+ else { /* dx_tex < 0.0f */ \
+ if (dy_tex > 0.0f) { \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN3(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN3(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN3(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN3(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN3(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN3(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN3(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN3(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN3(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ else { /* dy_tex <= 0.0f */ \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN4(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN4(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN4(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN4(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ SPAN4(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\
+ break; \
+ case GL_DECAL: \
+ SPAN4(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_BLEND: \
+ SPAN4(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_ADD: \
+ SPAN4(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \
+ break; \
+ case GL_REPLACE: \
+ SPAN4(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ } \
+ } \
+ } \
+ else { \
+ old_span: \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ OLD_SPAN(NEAREST_RGB;MODULATE,3); \
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ OLD_SPAN(NEAREST_RGB_REPLACE,3); \
+ break; \
+ case GL_BLEND: \
+ OLD_SPAN(NEAREST_RGB;BLEND,3); \
+ break; \
+ case GL_ADD: \
+ OLD_SPAN(NEAREST_RGB;ADD,3); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch(envmode) { \
+ case GL_MODULATE: \
+ OLD_SPAN(NEAREST_RGBA;MODULATE,4); \
+ break; \
+ case GL_DECAL: \
+ OLD_SPAN(NEAREST_RGBA;DECAL,4); \
+ break; \
+ case GL_BLEND: \
+ OLD_SPAN(NEAREST_RGBA;BLEND,4); \
+ break; \
+ case GL_ADD: \
+ OLD_SPAN(NEAREST_RGBA;ADD,4); \
+ break; \
+ case GL_REPLACE: \
+ OLD_SPAN(NEAREST_RGBA_REPLACE,4); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ } \
+ } \
+ gl_write_rgba_span( ctx, n, LEFT, Y, zspan, \
+ fogspan, rgba, GL_POLYGON); \
+ ffr = ffg = ffb = ffa = 0; \
+ } \
+ } \
+
+#include "s_tritemp.h"
+#undef OLD_SPAN
+#undef SPAN1
+#undef SPAN2
+#undef SPAN3
+#undef SPAN4
+#undef X_Y_TEX_COORD
+#undef Y_X_TEX_COORD
+#undef DRAW_LINE
+#undef BIAS
+}
+
+
+
+/*
+ * Render an perspective corrected RGB/RGBA textured triangle.
+ * The Q (aka V in Mesa) coordinate must be zero such that the divide
+ * by interpolated Q/W comes out right.
+ *
+ * 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 )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define SETUP_CODE \
+ struct gl_texture_unit *unit = ctx->Texture.Unit+0; \
+ struct gl_texture_object *obj = unit->CurrentD[2]; \
+ const GLint b = obj->BaseLevel; \
+ const GLfloat twidth = (GLfloat) obj->Image[b]->Width; \
+ const GLfloat theight = (GLfloat) obj->Image[b]->Height; \
+ const GLint twidth_log2 = obj->Image[b]->WidthLog2; \
+ GLchan *texture = obj->Image[b]->Data; \
+ const GLint smask = (obj->Image[b]->Width - 1); \
+ const GLint tmask = (obj->Image[b]->Height - 1); \
+ 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) { \
+ if (!_mesa_get_teximages_from_driver(ctx, obj)) \
+ return; \
+ texture = obj->Image[b]->Data; \
+ ASSERT(texture); \
+ } \
+ if (envmode == GL_BLEND || envmode == GL_ADD) { \
+ er = FloatToFixed(unit->EnvColor[0]); \
+ eg = FloatToFixed(unit->EnvColor[1]); \
+ 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 lin_persp_texture_triangle"); \
+ return; \
+ } \
+ sscale = FIXED_SCALE * twidth; \
+ 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++) { \
+ GLfloat invQ = 1.0f / vv; \
+ GLfixed ffs = (int)(SS * invQ); \
+ GLfixed fft = (int)(TT * invQ); \
+ GLint s = FixedToInt(ffs) & smask; \
+ GLint t = FixedToInt(fft) & tmask; \
+ GLint sf = ffs & FIXED_FRAC_MASK; \
+ GLint tf = fft & FIXED_FRAC_MASK; \
+ GLint si = FIXED_FRAC_MASK - sf; \
+ GLint ti = FIXED_FRAC_MASK - tf; \
+ GLint pos = COMP * ((t << twidth_log2) + s); \
+ GLchan *tex00 = texture + pos; \
+ GLchan *tex10 = tex00 + tbytesline; \
+ GLchan *tex01 = tex00 + COMP; \
+ GLchan *tex11 = tex10 + COMP; \
+ if (t == tmask) { \
+ tex10 -= tsize; \
+ tex11 -= tsize; \
+ } \
+ if (s == smask) { \
+ tex01 -= tbytesline; \
+ tex11 -= tbytesline; \
+ } \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ DO_TEX; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ SS += dSdx; \
+ TT += dTdx; \
+ vv += dvdx; \
+ dest += 4; \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ (void) uu; /* please GCC */ \
+ if (n > 0) { \
+ GLfloat SS = ss * sscale; \
+ GLfloat TT = tt * tscale; \
+ GLfloat dSdx = dsdx * sscale; \
+ GLfloat dTdx = dtdx * tscale; \
+ GLchan *dest = rgba[0]; \
+ SS -= 0.5f * FIXED_SCALE * vv; \
+ TT -= 0.5f * FIXED_SCALE * vv; \
+ switch (format) { \
+ case GL_RGB: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN(LINEAR_RGB;MODULATE,3); \
+ break; \
+ case GL_DECAL: \
+ case GL_REPLACE: \
+ SPAN(LINEAR_RGB;REPLACE,3); \
+ break; \
+ case GL_BLEND: \
+ SPAN(LINEAR_RGB;BLEND,3); \
+ break; \
+ case GL_ADD: \
+ SPAN(LINEAR_RGB;ADD,3); \
+ break; \
+ default: \
+ abort(); \
+ } \
+ break; \
+ case GL_RGBA: \
+ switch (envmode) { \
+ case GL_MODULATE: \
+ SPAN(LINEAR_RGBA;MODULATE,4); \
+ break; \
+ case GL_DECAL: \
+ SPAN(LINEAR_RGBA;DECAL,4); \
+ break; \
+ case GL_BLEND: \
+ SPAN(LINEAR_RGBA;BLEND,4); \
+ break; \
+ case GL_REPLACE: \
+ SPAN(LINEAR_RGBA;REPLACE,4); \
+ break; \
+ case GL_ADD: \
+ SPAN(LINEAR_RGBA;ADD,4); \
+ break; \
+ default: /* unexpected env mode */ \
+ abort(); \
+ } \
+ } \
+ gl_write_rgba_span( ctx, n, LEFT, Y, zspan, \
+ fogspan, \
+ rgba, GL_POLYGON ); \
+ ffr = ffg = ffb = ffa = 0; \
+ } \
+ }
+
+
+#include "s_tritemp.h"
+#undef SPAN
+}
+
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle.
+ * Interpolate S,T,U with perspective correction, w/out mipmapping.
+ * 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 )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define SETUP_CODE \
+ 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]; \
+ }
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \
+ if (n>0) { \
+ if (flat_shade) { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = r; \
+ rgba[i][GCOMP] = g; \
+ rgba[i][BCOMP] = b; \
+ rgba[i][ACOMP] = a; \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ else { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ fogspan[i] = fffog / 256; \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \
+ s, t, u, NULL, \
+ rgba, \
+ NULL, GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle with separate specular
+ * color interpolation.
+ * Interpolate S,T,U with perspective correction, w/out mipmapping.
+ * 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,
+ GLdepth zspan[MAX_WIDTH],
+ GLfixed fogspan[MAX_WIDTH],
+ GLchan rgba[MAX_WIDTH][4],
+ GLchan spec[MAX_WIDTH][4] )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define SETUP_CODE \
+ 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]; \
+ }
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \
+ if (n>0) { \
+ if (flat_shade) { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = r; \
+ rgba[i][GCOMP] = g; \
+ rgba[i][BCOMP] = b; \
+ rgba[i][ACOMP] = a; \
+ spec[i][RCOMP] = sr; \
+ spec[i][GCOMP] = sg; \
+ spec[i][BCOMP] = sb; \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ else { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ spec[i][RCOMP] = FixedToInt(ffsr); \
+ spec[i][GCOMP] = FixedToInt(ffsg); \
+ spec[i][BCOMP] = FixedToInt(ffsb); \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ffsr += fdsrdx; \
+ ffsg += fdsgdx; \
+ ffsb += fdsbdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ gl_write_texture_span( ctx, n, LEFT, Y, zspan, \
+ fogspan, \
+ s, t, u, NULL, rgba, \
+ (CONST GLchan (*)[4]) spec, \
+ GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Compute the lambda value for a fragment. (texture level of detail)
+ */
+static INLINE GLfloat
+compute_lambda( GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
+ GLfloat invQ, GLfloat width, GLfloat height )
+{
+ GLfloat dudx = dsdx * invQ * width;
+ GLfloat dudy = dsdy * invQ * width;
+ GLfloat dvdx = dtdx * invQ * height;
+ GLfloat dvdy = dtdy * invQ * height;
+ GLfloat r1 = dudx * dudx + dudy * dudy;
+ GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+ GLfloat rho2 = r1 + r2; /* used to be: rho2 = MAX2(r1,r2); */
+ /* return log base 2 of rho */
+ return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2) */
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle.
+ * Interpolate S,T,U with perspective correction and compute lambda for
+ * each fragment. Lambda is used to determine whether to use the
+ * 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,
+ GLfloat s[MAX_WIDTH],
+ GLfloat t[MAX_WIDTH],
+ GLfloat u[MAX_WIDTH] )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+
+#define SETUP_CODE \
+ 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; \
+ const GLfloat theight = (GLfloat) texImage->Height; \
+ 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]; \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ GLfloat lambda[MAX_WIDTH]; \
+ if (n>0) { \
+ if (flat_shade) { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = r; \
+ rgba[i][GCOMP] = g; \
+ rgba[i][BCOMP] = b; \
+ rgba[i][ACOMP] = a; \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \
+ invQ, twidth, theight );\
+ ffz += fdzdx; \
+ fffog += fdfogdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ else { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \
+ invQ, twidth, theight );\
+ ffz += fdzdx; \
+ fffog += fdfogdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \
+ s, t, u, lambda, \
+ rgba, NULL, GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle with separate specular
+ * interpolation.
+ * Interpolate S,T,U with perspective correction and compute lambda for
+ * each fragment. Lambda is used to determine whether to use the
+ * 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,
+ GLfloat s[MAX_WIDTH],
+ GLfloat t[MAX_WIDTH],
+ GLfloat u[MAX_WIDTH] )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+
+#define SETUP_CODE \
+ 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; \
+ const GLfloat theight = (GLfloat) texImage->Height; \
+ 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]; \
+ }
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLchan spec[MAX_WIDTH][4]; \
+ GLchan rgba[MAX_WIDTH][4]; \
+ GLfloat lambda[MAX_WIDTH]; \
+ if (n>0) { \
+ if (flat_shade) { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = r; \
+ rgba[i][GCOMP] = g; \
+ rgba[i][BCOMP] = b; \
+ rgba[i][ACOMP] = a; \
+ spec[i][RCOMP] = sr; \
+ spec[i][GCOMP] = sg; \
+ spec[i][BCOMP] = sb; \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \
+ invQ, twidth, theight );\
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ else { \
+ for (i=0;i<n;i++) { \
+ GLdouble invQ = 1.0 / vv; \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ spec[i][RCOMP] = FixedToInt(ffsr); \
+ spec[i][GCOMP] = FixedToInt(ffsg); \
+ spec[i][BCOMP] = FixedToInt(ffsb); \
+ s[i] = ss*invQ; \
+ t[i] = tt*invQ; \
+ u[i] = uu*invQ; \
+ lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \
+ invQ, twidth, theight );\
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ ffsr += fdsrdx; \
+ ffsg += fdsgdx; \
+ ffsb += fdsbdx; \
+ ss += dsdx; \
+ tt += dtdx; \
+ uu += dudx; \
+ vv += dvdx; \
+ } \
+ } \
+ gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \
+ s, t, u, lambda, \
+ rgba, (CONST GLchan (*)[4]) spec, \
+ GL_POLYGON ); \
+ } \
+ }
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * This is the big one!
+ * 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]
+ )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+
+#define SETUP_CODE \
+ GLchan rgba[MAX_WIDTH][4]; \
+ const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \
+ 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]; \
+ } \
+ { \
+ 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; \
+ const GLint baseLevel = obj->BaseLevel; \
+ const struct gl_texture_image *texImage = obj->Image[baseLevel]; \
+ twidth[unit] = (GLfloat) texImage->Width; \
+ theight[unit] = (GLfloat) texImage->Height; \
+ } \
+ } \
+ }
+
+
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint n = RIGHT-LEFT; \
+ GLdepth zspan[MAX_WIDTH]; \
+ GLfixed fogspan[MAX_WIDTH]; \
+ GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH]; \
+ if (n > 0) { \
+ if (flat_shade) { \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ fffog += fdfogdx; \
+ ffz += fdzdx; \
+ rgba[i][RCOMP] = r; \
+ rgba[i][GCOMP] = g; \
+ rgba[i][BCOMP] = b; \
+ rgba[i][ACOMP] = a; \
+ { \
+ GLuint unit; \
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \
+ if (ctx->Texture.Unit[unit].ReallyEnabled) { \
+ GLdouble invQ = 1.0 / vv[unit]; \
+ s[unit][i] = ss[unit] * invQ; \
+ t[unit][i] = tt[unit] * invQ; \
+ u[unit][i] = uu[unit] * invQ; \
+ lambda[unit][i] = compute_lambda(dsdx[unit], dsdy[unit],\
+ dtdx[unit], dtdy[unit], invQ, \
+ twidth[unit], theight[unit] ); \
+ ss[unit] += dsdx[unit]; \
+ tt[unit] += dtdx[unit]; \
+ uu[unit] += dudx[unit]; \
+ vv[unit] += dvdx[unit]; \
+ } \
+ } \
+ } \
+ } \
+ } \
+ else { /* smooth shade */ \
+ for (i=0;i<n;i++) { \
+ zspan[i] = FixedToDepth(ffz); \
+ fogspan[i] = fffog / 256; \
+ ffz += fdzdx; \
+ fffog += fdfogdx; \
+ rgba[i][RCOMP] = FixedToInt(ffr); \
+ rgba[i][GCOMP] = FixedToInt(ffg); \
+ rgba[i][BCOMP] = FixedToInt(ffb); \
+ rgba[i][ACOMP] = FixedToInt(ffa); \
+ ffr += fdrdx; \
+ ffg += fdgdx; \
+ ffb += fdbdx; \
+ ffa += fdadx; \
+ { \
+ GLuint unit; \
+ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \
+ if (ctx->Texture.Unit[unit].ReallyEnabled) { \
+ GLdouble invQ = 1.0 / vv[unit]; \
+ s[unit][i] = ss[unit] * invQ; \
+ t[unit][i] = tt[unit] * invQ; \
+ u[unit][i] = uu[unit] * invQ; \
+ lambda[unit][i] = compute_lambda(dsdx[unit], dsdy[unit],\
+ dtdx[unit], dtdy[unit], invQ, \
+ twidth[unit], theight[unit] ); \
+ ss[unit] += dsdx[unit]; \
+ tt[unit] += dtdx[unit]; \
+ uu[unit] += dudx[unit]; \
+ vv[unit] += dvdx[unit]; \
+ } \
+ } \
+ } \
+ } \
+ } \
+ gl_write_multitexture_span( ctx, n, LEFT, Y, zspan, fogspan, \
+ (const GLfloat (*)[MAX_WIDTH]) s, \
+ (const GLfloat (*)[MAX_WIDTH]) t, \
+ (const GLfloat (*)[MAX_WIDTH]) u, \
+ (GLfloat (*)[MAX_WIDTH]) lambda, \
+ rgba, NULL, GL_POLYGON ); \
+ } \
+ }
+#include "s_tritemp.h"
+}
+
+
+/*
+ * These wrappers are needed to deal with the 32KB / stack frame limit
+ * on Mac / PowerPC systems.
+ */
+
+static void general_textured_spec_triangle(GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv)
+{
+ 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);
+}
+
+static void lambda_textured_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH];
+ lambda_textured_triangle1(ctx,v0,v1,v2,pv,s,t,u);
+}
+
+static void lambda_textured_spec_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ GLfloat s[MAX_WIDTH];
+ GLfloat t[MAX_WIDTH];
+ GLfloat u[MAX_WIDTH];
+ lambda_textured_spec_triangle1(ctx,v0,v1,v2,pv,s,t,u);
+}
+
+
+static void lambda_multitextured_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv)
+{
+
+ GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ DEFMARRAY(GLfloat,u,MAX_TEXTURE_UNITS,MAX_WIDTH);
+ CHECKARRAY(u,return);
+
+ lambda_multitextured_triangle1(ctx,v0,v1,v2,pv,s,t,u);
+
+ UNDEFARRAY(u);
+}
+
+
+
+static void occlusion_zless_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ (void)pv;
+ if (ctx->OcclusionResult) {
+ return;
+ }
+
+#define DO_OCCLUSION_TEST
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i; \
+ const GLint len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ (void) fffog; \
+ if (z < zRow[i]) { \
+ ctx->OcclusionResult = GL_TRUE; \
+ return; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * 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
+# define dputs(s) puts(s)
+#else
+# define dputs(s)
+#endif
+
+
+
+/*
+ * Determine which triangle rendering function to use given the current
+ * rendering context.
+ *
+ * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or
+ * remove tests to this code.
+ */
+void
+_swrast_set_triangle_function( GLcontext *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);
+ return;
+ }
+
+ if (ctx->Depth.OcclusionTest &&
+ ctx->Depth.Test &&
+ ctx->Depth.Mask == GL_FALSE &&
+ ctx->Depth.Func == GL_LESS &&
+ !ctx->Stencil.Enabled) {
+ if ((rgbmode &&
+ ctx->Color.ColorMask[0] == 0 &&
+ ctx->Color.ColorMask[1] == 0 &&
+ ctx->Color.ColorMask[2] == 0 &&
+ ctx->Color.ColorMask[3] == 0)
+ ||
+ (!rgbmode && ctx->Color.IndexMask == 0)) {
+ dputs("occlusion_test_triangle");
+ ctx->Driver.TriangleFunc = occlusion_zless_triangle;
+ return;
+ }
+ }
+
+ 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
+ && current2Dtex->WrapS==GL_REPEAT
+ && current2Dtex->WrapT==GL_REPEAT
+ && ((image = current2Dtex->Image[current2Dtex->BaseLevel]) != 0) /* correct! */
+ && image->Border==0
+ && ((format = image->Format)==GL_RGB || format==GL_RGBA)
+ && (filter = current2Dtex->MinFilter)==current2Dtex->MagFilter
+ && ctx->Light.Model.ColorControl==GL_SINGLE_COLOR
+ && ctx->Texture.Unit[0].EnvMode!=GL_COMBINE_EXT) {
+
+ if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {
+
+ if (filter==GL_NEAREST
+ && format==GL_RGB
+ && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE
+ || ctx->Texture.Unit[0].EnvMode==GL_DECAL)
+ && ((ctx->RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE)
+ || ctx->RasterMask==0)
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+
+ if (ctx->RasterMask==DEPTH_BIT) {
+ ctx->Driver.TriangleFunc = simple_z_textured_triangle;
+ dputs("simple_z_textured_triangle");
+ }
+ else {
+ ctx->Driver.TriangleFunc = simple_textured_triangle;
+ dputs("simple_textured_triangle");
+ }
+ }
+ else {
+ if (ctx->Texture.Unit[0].EnvMode==GL_ADD) {
+ ctx->Driver.TriangleFunc = general_textured_triangle;
+ dputs("general_textured_triangle");
+ }
+ else {
+ ctx->Driver.TriangleFunc = affine_textured_triangle;
+ dputs("affine_textured_triangle");
+ }
+ }
+ }
+ else {
+ if (filter==GL_NEAREST) {
+ ctx->Driver.TriangleFunc = near_persp_textured_triangle;
+ dputs("near_persp_textured_triangle");
+ }
+ else {
+ ctx->Driver.TriangleFunc = lin_persp_textured_triangle;
+ dputs("lin_persp_textured_triangle");
+ }
+ }
+ }
+ else {
+ /* 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;
+ if (obj && obj->MinFilter != obj->MagFilter)
+ needLambda = GL_TRUE;
+ else
+ needLambda = GL_FALSE;
+ if (ctx->Texture.MultiTextureEnabled) {
+ ctx->Driver.TriangleFunc = lambda_multitextured_triangle;
+ dputs("lambda_multitextured_triangle");
+ }
+ else if ((ctx->Light.Enabled &&
+ ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+ || ctx->Fog.ColorSumEnabled) {
+ /* separate specular color interpolation */
+ if (needLambda) {
+ ctx->Driver.TriangleFunc = lambda_textured_spec_triangle;
+ dputs("lambda_textured_spec_triangle");
+ }
+ else {
+ ctx->Driver.TriangleFunc = general_textured_spec_triangle;
+ dputs("general_textured_spec_triangle");
+ }
+ }
+ else {
+ if (needLambda) {
+ ctx->Driver.TriangleFunc = lambda_textured_triangle;
+ dputs("lambda_textured_triangle");
+ }
+ else {
+ ctx->Driver.TriangleFunc = general_textured_triangle;
+ dputs("general_textured_triangle");
+ }
+ }
+ }
+ }
+ else {
+ if (ctx->Light.ShadeModel==GL_SMOOTH) {
+ /* smooth shaded, no texturing, stippled or some raster ops */
+ if (rgbmode) {
+ dputs("smooth_rgba_triangle");
+ ctx->Driver.TriangleFunc = smooth_rgba_triangle;
+ }
+ else {
+ dputs("smooth_ci_triangle");
+ ctx->Driver.TriangleFunc = 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;
+ }
+ else {
+ dputs("flat_ci_triangle");
+ ctx->Driver.TriangleFunc = flat_ci_triangle;
+ }
+ }
+ }
+ }
+ else if (ctx->RenderMode==GL_FEEDBACK) {
+ ctx->Driver.TriangleFunc = gl_feedback_triangle;
+ }
+ else {
+ /* GL_SELECT mode */
+ ctx->Driver.TriangleFunc = gl_select_triangle;
+ }
+}
--- /dev/null
+/* $Id: s_triangle.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.1
+ *
+ * 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_TRIANGLES_H
+#define S_TRIANGLES_H
+
+
+#include "types.h"
+#include "swrast.h"
+
+
+void gl_set_triangle_function( GLcontext *ctx );
+GLboolean gl_cull_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv );
+
+
+#endif
+
--- /dev/null
+/* $Id: s_tritemp.h,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+/*
+ * Triangle Rasterizer Template
+ *
+ * This file is #include'd to generate custom triangle rasterizers.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be interplated across the triangle:
+ * INTERP_Z - if defined, interpolate Z values
+ * INTERP_RGB - if defined, interpolate RGB values
+ * INTERP_SPEC - if defined, interpolate specular RGB values
+ * INTERP_ALPHA - if defined, interpolate Alpha values
+ * INTERP_INDEX - if defined, interpolate color index values
+ * INTERP_INT_TEX - if defined, interpolate integer ST texcoords
+ * (fast, simple 2-D texture mapping)
+ * INTERP_TEX - if defined, interpolate set 0 float STRQ texcoords
+ * NOTE: OpenGL STRQ = Mesa STUV (R was taken for red)
+ * INTERP_MULTITEX - if defined, interpolate N units of STRQ texcoords
+ *
+ * When one can directly address pixels in the color buffer the following
+ * macros can be defined and used to compute pixel addresses during
+ * rasterization (see pRow):
+ * PIXEL_TYPE - the datatype of a pixel (GLubyte, GLushort, GLuint)
+ * BYTES_PER_ROW - number of bytes per row in the color buffer
+ * PIXEL_ADDRESS(X,Y) - returns the address of pixel at (X,Y) where
+ * Y==0 at bottom of screen and increases upward.
+ *
+ * Similarly, for direct depth buffer access, this type is used for depth
+ * buffer addressing:
+ * DEPTH_TYPE - either GLushort or GLuint
+ *
+ * Optionally, one may provide one-time setup code per triangle:
+ * SETUP_CODE - code which is to be executed once per triangle
+ *
+ * The following macro MUST be defined:
+ * INNER_LOOP(LEFT,RIGHT,Y) - code to write a span of pixels.
+ * Something like:
+ *
+ * for (x=LEFT; x<RIGHT;x++) {
+ * put_pixel(x,Y);
+ * // increment fixed point interpolants
+ * }
+ *
+ * This code was designed for the origin to be in the lower-left corner.
+ *
+ * Inspired by triangle rasterizer code written by Allen Akin. Thanks Allen!
+ */
+
+
+/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
+{
+ typedef struct {
+ GLint 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 */
+ GLfixed fsx; /* first sample point x coord */
+ GLfixed fsy;
+ GLfloat adjy; /* adjust from v[0]->fy to fsy, scaled */
+ GLint lines; /* number of lines to be sampled on this edge */
+ GLfixed fx0; /* fixed pt X of lower endpoint */
+ } EdgeT;
+
+#ifdef INTERP_Z
+ const GLint depthBits = ctx->Visual.DepthBits;
+ const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
+ 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;
+
+ /* 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];
+
+ if (y0<=y1) {
+ if (y1<=y2) {
+ vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */
+ }
+ else if (y2<=y0) {
+ vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */
+ }
+ else {
+ vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */
+ }
+ }
+ else {
+ if (y0<=y2) {
+ vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */
+ }
+ else if (y2<=y1) {
+ vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */
+ }
+ else {
+ vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */
+ }
+ }
+ }
+
+ /* vertex/edge relationship */
+ eMaj.v0 = vMin; eMaj.v1 = vMax; /*TODO: .v1's not needed */
+ eTop.v0 = vMid; eTop.v1 = vMax;
+ 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];
+
+ /* compute oneOverArea */
+ {
+ const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
+
+ /* Do backface culling */
+ if (area * bf < 0.0)
+ return;
+
+ if (area == 0.0F)
+ return;
+
+ /* check for very tiny triangle */
+ if (area * area < 0.0025F) /* square it to ensure positive value */
+ oneOverArea = 1.0F / 0.0025F; /* a close-enough value */
+ else
+ oneOverArea = 1.0F / area;
+ }
+
+#ifndef DO_OCCLUSION_TEST
+ ctx->OcclusionResult = GL_TRUE;
+#endif
+
+ /* 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);
+
+ eMaj.fsy = FixedCeil(vMin_fy);
+ eMaj.lines = FixedToInt(vMax_fy + FIXED_ONE - FIXED_EPSILON - eMaj.fsy);
+ if (eMaj.lines > 0) {
+ GLfloat dxdy = eMaj.dx / eMaj.dy;
+ eMaj.fdxdy = SignedFloatToFixed(dxdy);
+ eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy); /* SCALED! */
+ eMaj.fx0 = vMin_fx;
+ eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * dxdy);
+ }
+ else {
+ return; /*CULLED*/
+ }
+
+ eTop.fsy = FixedCeil(vMid_fy);
+ eTop.lines = FixedToInt(vMax_fy + FIXED_ONE - FIXED_EPSILON - eTop.fsy);
+ if (eTop.lines > 0) {
+ GLfloat dxdy = eTop.dx / eTop.dy;
+ eTop.fdxdy = SignedFloatToFixed(dxdy);
+ eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */
+ eTop.fx0 = vMid_fx;
+ eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * dxdy);
+ }
+
+ eBot.fsy = FixedCeil(vMin_fy);
+ eBot.lines = FixedToInt(vMid_fy + FIXED_ONE - FIXED_EPSILON - eBot.fsy);
+ if (eBot.lines > 0) {
+ GLfloat dxdy = eBot.dx / eBot.dy;
+ eBot.fdxdy = SignedFloatToFixed(dxdy);
+ eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy); /* SCALED! */
+ eBot.fx0 = vMin_fx;
+ eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * dxdy);
+ }
+ }
+
+ /*
+ * Conceptually, we view a triangle as two subtriangles
+ * separated by a perfectly horizontal line. The edge that is
+ * intersected by this line is one with maximal absolute dy; we
+ * call it a ``major'' edge. The other two edges are the
+ * ``top'' edge (for the upper subtriangle) and the ``bottom''
+ * edge (for the lower subtriangle). If either of these two
+ * edges is horizontal or very close to horizontal, the
+ * corresponding subtriangle might cover zero sample points;
+ * we take care to handle such cases, for performance as well
+ * as correctness.
+ *
+ * By stepping rasterization parameters along the major edge,
+ * we can avoid recomputing them at the discontinuity where
+ * the top and bottom edges meet. However, this forces us to
+ * be able to scan both left-to-right and right-to-left.
+ * Also, we must determine whether the major edge is at the
+ * left or right side of the triangle. We do this by
+ * computing the magnitude of the cross-product of the major
+ * and top edges. Since this magnitude depends on the sine of
+ * the angle between the two edges, its sign tells us whether
+ * we turn to the left or to the right when travelling along
+ * the major edge to the top edge, and from this we infer
+ * whether the major edge is on the left or the right.
+ *
+ * Serendipitously, this cross-product magnitude is also a
+ * value we need to compute the iteration parameter
+ * derivatives for the triangle, and it can be used to perform
+ * backface culling because its sign tells us whether the
+ * triangle is clockwise or counterclockwise. In this code we
+ * refer to it as ``area'' because it's also proportional to
+ * the pixel area of the triangle.
+ */
+
+ {
+ GLint ltor; /* true if scanning left-to-right */
+#ifdef INTERP_Z
+ GLfloat dzdx, dzdy; GLfixed fdzdx;
+ GLfloat dfogdx, dfogdy; GLfixed fdfogdx;
+#endif
+#ifdef INTERP_RGB
+ GLfloat drdx, drdy; GLfixed fdrdx;
+ GLfloat dgdx, dgdy; GLfixed fdgdx;
+ GLfloat dbdx, dbdy; GLfixed fdbdx;
+#endif
+#ifdef INTERP_SPEC
+ GLfloat dsrdx, dsrdy; GLfixed fdsrdx;
+ GLfloat dsgdx, dsgdy; GLfixed fdsgdx;
+ GLfloat dsbdx, dsbdy; GLfixed fdsbdx;
+#endif
+#ifdef INTERP_ALPHA
+ GLfloat dadx, dady; GLfixed fdadx;
+#endif
+#ifdef INTERP_INDEX
+ GLfloat didx, didy; GLfixed fdidx;
+#endif
+#ifdef INTERP_INT_TEX
+ GLfloat dsdx, dsdy; GLfixed fdsdx;
+ GLfloat dtdx, dtdy; GLfixed fdtdx;
+#endif
+#ifdef INTERP_TEX
+ GLfloat dsdx, dsdy;
+ GLfloat dtdx, dtdy;
+ GLfloat dudx, dudy;
+ GLfloat dvdx, dvdy;
+#endif
+#ifdef INTERP_MULTITEX
+ GLfloat dsdx[MAX_TEXTURE_UNITS], dsdy[MAX_TEXTURE_UNITS];
+ GLfloat dtdx[MAX_TEXTURE_UNITS], dtdy[MAX_TEXTURE_UNITS];
+ GLfloat dudx[MAX_TEXTURE_UNITS], dudy[MAX_TEXTURE_UNITS];
+ GLfloat dvdx[MAX_TEXTURE_UNITS], dvdy[MAX_TEXTURE_UNITS];
+#endif
+
+ /*
+ * Execute user-supplied setup code
+ */
+#ifdef SETUP_CODE
+ SETUP_CODE
+#endif
+
+ ltor = (oneOverArea < 0.0F);
+
+ /* compute d?/dx and d?/dy derivatives */
+#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];
+ dzdx = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
+ if (dzdx > maxDepth || dzdx < -maxDepth) {
+ /* probably a sliver triangle */
+ dzdx = 0.0;
+ dzdy = 0.0;
+ }
+ else {
+ dzdy = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
+ }
+ if (depthBits <= 16)
+ fdzdx = SignedFloatToFixed(dzdx);
+ else
+ fdzdx = (GLint) dzdx;
+ }
+ {
+ 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;
+ dfogdx = oneOverArea * (eMaj_dfog * eBot.dy - eMaj.dy * eBot_dfog);
+ fdfogdx = SignedFloatToFixed(dfogdx);
+ dfogdy = oneOverArea * (eMaj.dx * eBot_dfog - eMaj_dfog * eBot.dx);
+ }
+#endif
+#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];
+ 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];
+ 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];
+ dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
+ fdbdx = SignedFloatToFixed(dbdx);
+ dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
+ }
+#endif
+#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];
+ 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];
+ 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];
+ dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb);
+ fdsbdx = SignedFloatToFixed(dsbdx);
+ dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx);
+ }
+#endif
+#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];
+ dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
+ fdadx = SignedFloatToFixed(dadx);
+ dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
+ }
+#endif
+#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];
+ didx = oneOverArea * (eMaj_di * eBot.dy - eMaj.dy * eBot_di);
+ fdidx = SignedFloatToFixed(didx);
+ didy = oneOverArea * (eMaj.dx * eBot_di - eMaj_di * eBot.dx);
+ }
+#endif
+#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;
+ 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;
+ 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 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;
+ 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;
+ }
+
+ 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);
+ }
+ }
+#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];
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ 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;
+ 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);
+ }
+ }
+ }
+ }
+#endif
+
+ /*
+ * We always sample at pixel centers. However, we avoid
+ * explicit half-pixel offsets in this code by incorporating
+ * the proper offset in each of x and y during the
+ * transformation to window coordinates.
+ *
+ * We also apply the usual rasterization rules to prevent
+ * cracks and overlaps. A pixel is considered inside a
+ * subtriangle if it meets all of four conditions: it is on or
+ * to the right of the left edge, strictly to the left of the
+ * right edge, on or below the top edge, and strictly above
+ * the bottom edge. (Some edges may be degenerate.)
+ *
+ * The following discussion assumes left-to-right scanning
+ * (that is, the major edge is on the left); the right-to-left
+ * case is a straightforward variation.
+ *
+ * We start by finding the half-integral y coordinate that is
+ * at or below the top of the triangle. This gives us the
+ * first scan line that could possibly contain pixels that are
+ * inside the triangle.
+ *
+ * Next we creep down the major edge until we reach that y,
+ * and compute the corresponding x coordinate on the edge.
+ * Then we find the half-integral x that lies on or just
+ * inside the edge. This is the first pixel that might lie in
+ * the interior of the triangle. (We won't know for sure
+ * until we check the other edges.)
+ *
+ * As we rasterize the triangle, we'll step down the major
+ * edge. For each step in y, we'll move an integer number
+ * of steps in x. There are two possible x step sizes, which
+ * we'll call the ``inner'' step (guaranteed to land on the
+ * edge or inside it) and the ``outer'' step (guaranteed to
+ * land on the edge or outside it). The inner and outer steps
+ * differ by one. During rasterization we maintain an error
+ * term that indicates our distance from the true edge, and
+ * select either the inner step or the outer step, whichever
+ * gets us to the first pixel that falls inside the triangle.
+ *
+ * All parameters (z, red, etc.) as well as the buffer
+ * addresses for color and z have inner and outer step values,
+ * so that we can increment them appropriately. This method
+ * eliminates the need to adjust parameters by creeping a
+ * sub-pixel amount into the triangle at each scanline.
+ */
+
+ {
+ int subTriangle;
+ GLfixed fx, fxLeftEdge, fxRightEdge, fdxLeftEdge, fdxRightEdge;
+ GLfixed fdxOuter;
+ int idxOuter;
+ float dxOuter;
+ GLfixed fError, fdError;
+ float adjx, adjy;
+ GLfixed fy;
+ int iy;
+#ifdef PIXEL_ADDRESS
+ PIXEL_TYPE *pRow;
+ int dPRowOuter, dPRowInner; /* offset in bytes */
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ DEPTH_TYPE *zRow;
+ int dZRowOuter, dZRowInner; /* offset in bytes */
+# endif
+ GLfixed fz, fdzOuter, fdzInner;
+ GLfixed ffog, fdfogOuter, fdfogInner;
+#endif
+#ifdef INTERP_RGB
+ GLfixed fr, fdrOuter, fdrInner;
+ GLfixed fg, fdgOuter, fdgInner;
+ GLfixed fb, fdbOuter, fdbInner;
+#endif
+#ifdef INTERP_SPEC
+ GLfixed fsr, fdsrOuter, fdsrInner;
+ GLfixed fsg, fdsgOuter, fdsgInner;
+ GLfixed fsb, fdsbOuter, fdsbInner;
+#endif
+#ifdef INTERP_ALPHA
+ GLfixed fa, fdaOuter, fdaInner;
+#endif
+#ifdef INTERP_INDEX
+ GLfixed fi, fdiOuter, fdiInner;
+#endif
+#ifdef INTERP_INT_TEX
+ GLfixed fs, fdsOuter, fdsInner;
+ GLfixed ft, fdtOuter, fdtInner;
+#endif
+#ifdef INTERP_TEX
+ GLfloat sLeft, dsOuter, dsInner;
+ GLfloat tLeft, dtOuter, dtInner;
+ GLfloat uLeft, duOuter, duInner;
+ GLfloat vLeft, dvOuter, dvInner;
+#endif
+#ifdef INTERP_MULTITEX
+ GLfloat sLeft[MAX_TEXTURE_UNITS];
+ GLfloat tLeft[MAX_TEXTURE_UNITS];
+ GLfloat uLeft[MAX_TEXTURE_UNITS];
+ GLfloat vLeft[MAX_TEXTURE_UNITS];
+ GLfloat dsOuter[MAX_TEXTURE_UNITS], dsInner[MAX_TEXTURE_UNITS];
+ GLfloat dtOuter[MAX_TEXTURE_UNITS], dtInner[MAX_TEXTURE_UNITS];
+ GLfloat duOuter[MAX_TEXTURE_UNITS], duInner[MAX_TEXTURE_UNITS];
+ GLfloat dvOuter[MAX_TEXTURE_UNITS], dvInner[MAX_TEXTURE_UNITS];
+#endif
+
+ for (subTriangle=0; subTriangle<=1; subTriangle++) {
+ EdgeT *eLeft, *eRight;
+ int setupLeft, setupRight;
+ int lines;
+
+ if (subTriangle==0) {
+ /* bottom half */
+ if (ltor) {
+ eLeft = &eMaj;
+ eRight = &eBot;
+ lines = eRight->lines;
+ setupLeft = 1;
+ setupRight = 1;
+ }
+ else {
+ eLeft = &eBot;
+ eRight = &eMaj;
+ lines = eLeft->lines;
+ setupLeft = 1;
+ setupRight = 1;
+ }
+ }
+ else {
+ /* top half */
+ if (ltor) {
+ eLeft = &eMaj;
+ eRight = &eTop;
+ lines = eRight->lines;
+ setupLeft = 0;
+ setupRight = 1;
+ }
+ else {
+ eLeft = &eTop;
+ eRight = &eMaj;
+ lines = eLeft->lines;
+ setupLeft = 1;
+ setupRight = 0;
+ }
+ if (lines == 0)
+ return;
+ }
+
+ if (setupLeft && eLeft->lines > 0) {
+ GLint vLower;
+ GLfixed fsx = eLeft->fsx;
+ fx = FixedCeil(fsx);
+ fError = fx - fsx - FIXED_ONE;
+ fxLeftEdge = fsx - FIXED_EPSILON;
+ fdxLeftEdge = eLeft->fdxdy;
+ fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);
+ fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;
+ idxOuter = FixedToInt(fdxOuter);
+ dxOuter = (float) idxOuter;
+ (void) dxOuter;
+
+ fy = eLeft->fsy;
+ iy = FixedToInt(fy);
+
+ adjx = (float)(fx - eLeft->fx0); /* SCALED! */
+ adjy = eLeft->adjy; /* SCALED! */
+ (void) adjx; /* silence compiler warnings */
+ (void) adjy; /* silence compiler warnings */
+
+ vLower = eLeft->v0;
+ (void) vLower; /* silence compiler warnings */
+
+#ifdef PIXEL_ADDRESS
+ {
+ pRow = PIXEL_ADDRESS( FixedToInt(fxLeftEdge), iy );
+ dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
+ /* negative because Y=0 at bottom and increases upward */
+ }
+#endif
+ /*
+ * Now we need the set of parameter (z, color, etc.) values at
+ * the point (fx, fy). This gives us properly-sampled parameter
+ * values that we can step from pixel to pixel. Furthermore,
+ * although we might have intermediate results that overflow
+ * the normal parameter range when we step temporarily outside
+ * the triangle, we shouldn't overflow or underflow for any
+ * pixel that's actually inside the triangle.
+ */
+
+#ifdef INTERP_Z
+ {
+ GLfloat z0 = VB->Win.data[vLower][2] + ctx->PolygonZoffset;
+ if (depthBits <= 16) {
+ /* interpolate fixed-pt values */
+ GLfloat tmp = (z0 * FIXED_SCALE +
+ dzdx * adjx + dzdy * adjy) + FIXED_HALF;
+ if (tmp < MAX_GLUINT / 2)
+ fz = (GLfixed) tmp;
+ else
+ fz = MAX_GLUINT / 2;
+ fdzOuter = SignedFloatToFixed(dzdy + dxOuter * dzdx);
+ }
+ else {
+ /* interpolate depth values exactly */
+ fz = (GLint) (z0 + dzdx*FixedToFloat(adjx) + dzdy*FixedToFloat(adjy));
+ fdzOuter = (GLint) (dzdy + dxOuter * dzdx);
+ }
+# ifdef DEPTH_TYPE
+ zRow = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), iy);
+ dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
+# endif
+ }
+ ffog = FloatToFixed(VB->FogCoordPtr->data[vLower]) * 256 + dfogdx * adjx + dfogdy * adjy + FIXED_HALF;
+ fdfogOuter = SignedFloatToFixed(dfogdy + dxOuter * dfogdx);
+#endif
+#ifdef INTERP_RGB
+ fr = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][0])
+ + drdx * adjx + drdy * adjy) + FIXED_HALF;
+ fdrOuter = SignedFloatToFixed(drdy + dxOuter * drdx);
+
+ fg = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][1])
+ + dgdx * adjx + dgdy * adjy) + FIXED_HALF;
+ fdgOuter = SignedFloatToFixed(dgdy + dxOuter * dgdx);
+
+ fb = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][2])
+ + dbdx * adjx + dbdy * adjy) + FIXED_HALF;
+ fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx);
+#endif
+#ifdef INTERP_SPEC
+ fsr = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][0])
+ + dsrdx * adjx + dsrdy * adjy) + FIXED_HALF;
+ fdsrOuter = SignedFloatToFixed(dsrdy + dxOuter * dsrdx);
+
+ fsg = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][1])
+ + dsgdx * adjx + dsgdy * adjy) + FIXED_HALF;
+ fdsgOuter = SignedFloatToFixed(dsgdy + dxOuter * dsgdx);
+
+ fsb = (GLfixed)(IntToFixed(VB->SecondaryColorPtr->data[vLower][2])
+ + dsbdx * adjx + dsbdy * adjy) + FIXED_HALF;
+ fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx);
+#endif
+#ifdef INTERP_ALPHA
+ fa = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][3])
+ + dadx * adjx + dady * adjy) + FIXED_HALF;
+ fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx);
+#endif
+#ifdef INTERP_INDEX
+ fi = (GLfixed)(VB->IndexPtr->data[vLower] * 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;
+ 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);
+ }
+ }
+#endif
+#ifdef INTERP_TEX
+ {
+ GLfloat invW = VB->Win.data[vLower][3];
+ GLfloat s0, t0, u0, v0;
+ s0 = VB->TexCoordPtr[0]->data[vLower][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;
+ }
+ vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE);
+ dvOuter = dvdy + dxOuter * dvdx;
+ }
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ GLfloat invW = VB->Win.data[vLower][3];
+ GLfloat s0, t0, u0, v0;
+ s0 = VB->TexCoordPtr[u]->data[vLower][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;
+ }
+ vLeft[u] = v0 + (dvdx[u] * adjx + dvdy[u] * adjy) * (1.0F/FIXED_SCALE);
+ dvOuter[u] = dvdy[u] + dxOuter * dvdx[u];
+ }
+ }
+ }
+#endif
+
+ } /*if setupLeft*/
+
+
+ if (setupRight && eRight->lines>0) {
+ fxRightEdge = eRight->fsx - FIXED_EPSILON;
+ fdxRightEdge = eRight->fdxdy;
+ }
+
+ if (lines==0) {
+ continue;
+ }
+
+
+ /* Rasterize setup */
+#ifdef PIXEL_ADDRESS
+ dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
+# endif
+ fdzInner = fdzOuter + fdzdx;
+ fdfogInner = fdfogOuter + fdfogdx;
+#endif
+#ifdef INTERP_RGB
+ fdrInner = fdrOuter + fdrdx;
+ fdgInner = fdgOuter + fdgdx;
+ fdbInner = fdbOuter + fdbdx;
+#endif
+#ifdef INTERP_SPEC
+ fdsrInner = fdsrOuter + fdsrdx;
+ fdsgInner = fdsgOuter + fdsgdx;
+ fdsbInner = fdsbOuter + fdsbdx;
+#endif
+#ifdef INTERP_ALPHA
+ fdaInner = fdaOuter + fdadx;
+#endif
+#ifdef INTERP_INDEX
+ fdiInner = fdiOuter + fdidx;
+#endif
+#ifdef INTERP_INT_TEX
+ fdsInner = fdsOuter + fdsdx;
+ fdtInner = fdtOuter + fdtdx;
+#endif
+#ifdef INTERP_TEX
+ dsInner = dsOuter + dsdx;
+ dtInner = dtOuter + dtdx;
+ duInner = duOuter + dudx;
+ dvInner = dvOuter + dvdx;
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ dsInner[u] = dsOuter[u] + dsdx[u];
+ dtInner[u] = dtOuter[u] + dtdx[u];
+ duInner[u] = duOuter[u] + dudx[u];
+ dvInner[u] = dvOuter[u] + dvdx[u];
+ }
+ }
+ }
+#endif
+
+ while (lines>0) {
+ /* initialize the span interpolants to the leftmost value */
+ /* ff = fixed-pt fragment */
+ GLint left = FixedToInt(fxLeftEdge);
+ GLint right = FixedToInt(fxRightEdge);
+#ifdef INTERP_Z
+ GLfixed ffz = fz;
+ GLfixed fffog = ffog;
+#endif
+#ifdef INTERP_RGB
+ GLfixed ffr = fr, ffg = fg, ffb = fb;
+#endif
+#ifdef INTERP_SPEC
+ GLfixed ffsr = fsr, ffsg = fsg, ffsb = fsb;
+#endif
+#ifdef INTERP_ALPHA
+ GLfixed ffa = fa;
+#endif
+#ifdef INTERP_INDEX
+ GLfixed ffi = fi;
+#endif
+#ifdef INTERP_INT_TEX
+ GLfixed ffs = fs, fft = ft;
+#endif
+#ifdef INTERP_TEX
+ GLfloat ss = sLeft, tt = tLeft, uu = uLeft, vv = vLeft;
+#endif
+#ifdef INTERP_MULTITEX
+ GLfloat ss[MAX_TEXTURE_UNITS];
+ GLfloat tt[MAX_TEXTURE_UNITS];
+ GLfloat uu[MAX_TEXTURE_UNITS];
+ GLfloat vv[MAX_TEXTURE_UNITS];
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ ss[u] = sLeft[u];
+ tt[u] = tLeft[u];
+ uu[u] = uLeft[u];
+ vv[u] = vLeft[u];
+ }
+ }
+ }
+#endif
+
+#ifdef INTERP_RGB
+ {
+ /* need this to accomodate round-off errors */
+ GLfixed ffrend = ffr+(right-left-1)*fdrdx;
+ GLfixed ffgend = ffg+(right-left-1)*fdgdx;
+ GLfixed ffbend = ffb+(right-left-1)*fdbdx;
+ if (ffrend<0) ffr -= ffrend;
+ if (ffgend<0) ffg -= ffgend;
+ if (ffbend<0) ffb -= ffbend;
+ if (ffr<0) ffr = 0;
+ if (ffg<0) ffg = 0;
+ if (ffb<0) ffb = 0;
+ }
+#endif
+#ifdef INTERP_SPEC
+ {
+ /* need this to accomodate round-off errors */
+ GLfixed ffsrend = ffsr+(right-left-1)*fdsrdx;
+ GLfixed ffsgend = ffsg+(right-left-1)*fdsgdx;
+ GLfixed ffsbend = ffsb+(right-left-1)*fdsbdx;
+ if (ffsrend<0) ffsr -= ffsrend;
+ if (ffsgend<0) ffsg -= ffsgend;
+ if (ffsbend<0) ffsb -= ffsbend;
+ if (ffsr<0) ffsr = 0;
+ if (ffsg<0) ffsg = 0;
+ if (ffsb<0) ffsb = 0;
+ }
+#endif
+#ifdef INTERP_ALPHA
+ {
+ GLfixed ffaend = ffa+(right-left-1)*fdadx;
+ if (ffaend<0) ffa -= ffaend;
+ if (ffa<0) ffa = 0;
+ }
+#endif
+#ifdef INTERP_INDEX
+ if (ffi<0) ffi = 0;
+#endif
+
+ INNER_LOOP( left, right, iy );
+
+ /*
+ * Advance to the next scan line. Compute the
+ * new edge coordinates, and adjust the
+ * pixel-center x coordinate so that it stays
+ * on or inside the major edge.
+ */
+ iy++;
+ lines--;
+
+ fxLeftEdge += fdxLeftEdge;
+ fxRightEdge += fdxRightEdge;
+
+
+ fError += fdError;
+ if (fError >= 0) {
+ fError -= FIXED_ONE;
+#ifdef PIXEL_ADDRESS
+ pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowOuter);
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowOuter);
+# endif
+ fz += fdzOuter;
+ ffog += fdfogOuter;
+#endif
+#ifdef INTERP_RGB
+ fr += fdrOuter; fg += fdgOuter; fb += fdbOuter;
+#endif
+#ifdef INTERP_SPEC
+ fsr += fdsrOuter; fsg += fdsgOuter; fsb += fdsbOuter;
+#endif
+#ifdef INTERP_ALPHA
+ fa += fdaOuter;
+#endif
+#ifdef INTERP_INDEX
+ fi += fdiOuter;
+#endif
+#ifdef INTERP_INT_TEX
+ fs += fdsOuter; ft += fdtOuter;
+#endif
+#ifdef INTERP_TEX
+ sLeft += dsOuter;
+ tLeft += dtOuter;
+ uLeft += duOuter;
+ vLeft += dvOuter;
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ sLeft[u] += dsOuter[u];
+ tLeft[u] += dtOuter[u];
+ uLeft[u] += duOuter[u];
+ vLeft[u] += dvOuter[u];
+ }
+ }
+ }
+#endif
+ }
+ else {
+#ifdef PIXEL_ADDRESS
+ pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowInner);
+#endif
+#ifdef INTERP_Z
+# ifdef DEPTH_TYPE
+ zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowInner);
+# endif
+ fz += fdzInner;
+ ffog += fdfogInner;
+#endif
+#ifdef INTERP_RGB
+ fr += fdrInner; fg += fdgInner; fb += fdbInner;
+#endif
+#ifdef INTERP_SPEC
+ fsr += fdsrInner; fsg += fdsgInner; fsb += fdsbInner;
+#endif
+#ifdef INTERP_ALPHA
+ fa += fdaInner;
+#endif
+#ifdef INTERP_INDEX
+ fi += fdiInner;
+#endif
+#ifdef INTERP_INT_TEX
+ fs += fdsInner; ft += fdtInner;
+#endif
+#ifdef INTERP_TEX
+ sLeft += dsInner;
+ tLeft += dtInner;
+ uLeft += duInner;
+ vLeft += dvInner;
+#endif
+#ifdef INTERP_MULTITEX
+ {
+ GLuint u;
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u].ReallyEnabled) {
+ sLeft[u] += dsInner[u];
+ tLeft[u] += dtInner[u];
+ uLeft[u] += duInner[u];
+ vLeft[u] += dvInner[u];
+ }
+ }
+ }
+#endif
+ }
+ } /*while lines>0*/
+
+ } /* for subTriangle */
+
+ }
+ }
+}
+
+#undef SETUP_CODE
+#undef INNER_LOOP
+
+#undef PIXEL_TYPE
+#undef BYTES_PER_ROW
+#undef PIXEL_ADDRESS
+
+#undef INTERP_Z
+#undef INTERP_RGB
+#undef INTERP_SPEC
+#undef INTERP_ALPHA
+#undef INTERP_INDEX
+#undef INTERP_INT_TEX
+#undef INTERP_TEX
+#undef INTERP_MULTITEX
+
+#undef S_SCALE
+#undef T_SCALE
+
+#undef FixedToDepth
+
+#undef DO_OCCLUSION_TEST
--- /dev/null
+/* $Id: s_zoom.c,v 1.1 2000/10/31 18:00:05 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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 "macros.h"
+
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Write a span of pixels to the frame buffer while applying a pixel zoom.
+ * This is only used by glDrawPixels and glCopyPixels.
+ * Input: n - number of pixels in input row
+ * x, y - destination of the span
+ * z - depth values for the span
+ * red, green, blue, alpha - array of colors
+ * y0 - location of first row in the image we're drawing.
+ */
+void
+gl_write_zoomed_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ CONST GLchan rgba[][4], GLint y0 )
+{
+ GLint m;
+ GLint r0, r1, row, r;
+ GLint i, j, skipcol;
+ GLchan zrgba[MAX_WIDTH][4]; /* zoomed pixel colors */
+ GLdepth zdepth[MAX_WIDTH]; /* zoomed depth values */
+ GLfixed zfog[MAX_WIDTH]; /* zoomed fog values */
+ GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+ const GLuint *srcRGBA32 = (const GLuint *) rgba;
+ GLuint *dstRGBA32 = (GLuint *) zrgba;
+
+ /* compute width of output row */
+ m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+ if (m==0) {
+ return;
+ }
+ if (ctx->Pixel.ZoomX<0.0) {
+ /* adjust x coordinate for left/right mirroring */
+ x = x - m;
+ }
+
+ /* compute which rows to draw */
+ row = y-y0;
+ r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+ r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+ if (r0==r1) {
+ return;
+ }
+ else if (r1<r0) {
+ GLint rtmp = r1;
+ r1 = r0;
+ r0 = rtmp;
+ }
+
+ /* return early if r0...r1 is above or below window */
+ if (r0<0 && r1<0) {
+ /* below window */
+ return;
+ }
+ if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
+ /* above window */
+ return;
+ }
+
+ /* check if left edge is outside window */
+ skipcol = 0;
+ if (x<0) {
+ skipcol = -x;
+ m += x;
+ }
+ /* make sure span isn't too long or short */
+ if (m>maxwidth) {
+ m = maxwidth;
+ }
+ else if (m<=0) {
+ return;
+ }
+
+ assert( m <= MAX_WIDTH );
+
+ /* zoom the span horizontally */
+ if (ctx->Pixel.ZoomX==-1.0F) {
+ /* n==m */
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ dstRGBA32[j] = srcRGBA32[i];
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+ else {
+ GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ dstRGBA32[j] = srcRGBA32[i];
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+
+ /* write the span */
+ for (r=r0; r<r1; r++) {
+ gl_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+ (fog ? zfog : 0),
+ zrgba, GL_BITMAP );
+ }
+}
+
+
+
+void
+gl_write_zoomed_rgb_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ CONST GLchan rgb[][3], GLint y0 )
+{
+ GLint m;
+ GLint r0, r1, row, r;
+ GLint i, j, skipcol;
+ GLchan zrgba[MAX_WIDTH][4]; /* zoomed pixel colors */
+ GLdepth zdepth[MAX_WIDTH]; /* zoomed depth values */
+ GLfixed zfog[MAX_WIDTH]; /* zoomed fog values */
+ GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+ /* compute width of output row */
+ m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+ if (m==0) {
+ return;
+ }
+ if (ctx->Pixel.ZoomX<0.0) {
+ /* adjust x coordinate for left/right mirroring */
+ x = x - m;
+ }
+
+ /* compute which rows to draw */
+ row = y-y0;
+ r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+ r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+ if (r0==r1) {
+ return;
+ }
+ else if (r1<r0) {
+ GLint rtmp = r1;
+ r1 = r0;
+ r0 = rtmp;
+ }
+
+ /* return early if r0...r1 is above or below window */
+ if (r0<0 && r1<0) {
+ /* below window */
+ return;
+ }
+ if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
+ /* above window */
+ return;
+ }
+
+ /* check if left edge is outside window */
+ skipcol = 0;
+ if (x<0) {
+ skipcol = -x;
+ m += x;
+ }
+ /* make sure span isn't too long or short */
+ if (m>maxwidth) {
+ m = maxwidth;
+ }
+ else if (m<=0) {
+ return;
+ }
+
+ assert( m <= MAX_WIDTH );
+
+ /* zoom the span horizontally */
+ if (ctx->Pixel.ZoomX==-1.0F) {
+ /* n==m */
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zrgba[j][0] = rgb[i][0];
+ zrgba[j][1] = rgb[i][1];
+ zrgba[j][2] = rgb[i][2];
+ zrgba[j][3] = CHAN_MAX;
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+ else {
+ GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zrgba[j][0] = rgb[i][0];
+ zrgba[j][1] = rgb[i][1];
+ zrgba[j][2] = rgb[i][2];
+ zrgba[j][3] = CHAN_MAX;
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+
+ /* write the span */
+ for (r=r0; r<r1; r++) {
+ gl_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+ (fog ? zfog : 0), zrgba, GL_BITMAP );
+ }
+}
+
+
+
+/*
+ * As above, but write CI pixels.
+ */
+void
+gl_write_zoomed_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ const GLuint indexes[], GLint y0 )
+{
+ GLint m;
+ GLint r0, r1, row, r;
+ GLint i, j, skipcol;
+ GLuint zindexes[MAX_WIDTH]; /* zoomed color indexes */
+ GLdepth zdepth[MAX_WIDTH]; /* zoomed depth values */
+ GLfixed zfog[MAX_WIDTH]; /* zoomed fog values */
+ GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+ /* compute width of output row */
+ m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+ if (m==0) {
+ return;
+ }
+ if (ctx->Pixel.ZoomX<0.0) {
+ /* adjust x coordinate for left/right mirroring */
+ x = x - m;
+ }
+
+ /* compute which rows to draw */
+ row = y-y0;
+ r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+ r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+ if (r0==r1) {
+ return;
+ }
+ else if (r1<r0) {
+ GLint rtmp = r1;
+ r1 = r0;
+ r0 = rtmp;
+ }
+
+ /* return early if r0...r1 is above or below window */
+ if (r0<0 && r1<0) {
+ /* below window */
+ return;
+ }
+ if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
+ /* above window */
+ return;
+ }
+
+ /* check if left edge is outside window */
+ skipcol = 0;
+ if (x<0) {
+ skipcol = -x;
+ m += x;
+ }
+ /* make sure span isn't too long or short */
+ if (m>maxwidth) {
+ m = maxwidth;
+ }
+ else if (m<=0) {
+ return;
+ }
+
+ assert( m <= MAX_WIDTH );
+
+ /* zoom the span horizontally */
+ if (ctx->Pixel.ZoomX==-1.0F) {
+ /* n==m */
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zindexes[j] = indexes[i];
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+ else {
+ GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zindexes[j] = indexes[i];
+ zdepth[j] = z[i];
+ }
+ if (fog && ctx->Fog.Enabled) {
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zfog[j] = fog[i];
+ }
+ }
+ }
+
+ /* write the span */
+ for (r=r0; r<r1; r++) {
+ gl_write_index_span( ctx, m, x+skipcol, r, zdepth,
+ (fog ? zfog : 0), zindexes, GL_BITMAP );
+ }
+}
+
+
+
+/*
+ * As above, but write stencil values.
+ */
+void
+gl_write_zoomed_stencil_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLstencil stencil[], GLint y0 )
+{
+ GLint m;
+ GLint r0, r1, row, r;
+ GLint i, j, skipcol;
+ GLstencil zstencil[MAX_WIDTH]; /* zoomed stencil values */
+ GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+ /* compute width of output row */
+ m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+ if (m==0) {
+ return;
+ }
+ if (ctx->Pixel.ZoomX<0.0) {
+ /* adjust x coordinate for left/right mirroring */
+ x = x - m;
+ }
+
+ /* compute which rows to draw */
+ row = y-y0;
+ r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+ r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+ if (r0==r1) {
+ return;
+ }
+ else if (r1<r0) {
+ GLint rtmp = r1;
+ r1 = r0;
+ r0 = rtmp;
+ }
+
+ /* return early if r0...r1 is above or below window */
+ if (r0<0 && r1<0) {
+ /* below window */
+ return;
+ }
+ if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
+ /* above window */
+ return;
+ }
+
+ /* check if left edge is outside window */
+ skipcol = 0;
+ if (x<0) {
+ skipcol = -x;
+ m += x;
+ }
+ /* make sure span isn't too long or short */
+ if (m>maxwidth) {
+ m = maxwidth;
+ }
+ else if (m<=0) {
+ return;
+ }
+
+ assert( m <= MAX_WIDTH );
+
+ /* zoom the span horizontally */
+ if (ctx->Pixel.ZoomX==-1.0F) {
+ /* n==m */
+ for (j=0;j<m;j++) {
+ i = n - (j+skipcol) - 1;
+ zstencil[j] = stencil[i];
+ }
+ }
+ else {
+ GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+ for (j=0;j<m;j++) {
+ i = (GLint) ((j+skipcol) * xscale);
+ if (i<0) i = n + i - 1;
+ zstencil[j] = stencil[i];
+ }
+ }
+
+ /* write the span */
+ for (r=r0; r<r1; r++) {
+ _mesa_write_stencil_span( ctx, m, x+skipcol, r, zstencil );
+ }
+}
--- /dev/null
+/* $Id: s_zoom.h,v 1.1 2000/10/31 18:00:05 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.5
+ *
+ * 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.
+ */
+
+
+#ifndef S_ZOOM_H
+#define S_ZOOM_H
+
+
+#include "types.h"
+
+
+extern void
+gl_write_zoomed_rgba_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ CONST GLchan rgba[][4], GLint y0 );
+
+
+extern void
+gl_write_zoomed_rgb_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ CONST GLchan rgb[][3], GLint y0 );
+
+
+extern void
+gl_write_zoomed_index_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y, const GLdepth z[],
+ const GLfixed *fog,
+ const GLuint indexes[], GLint y0 );
+
+
+extern void
+gl_write_zoomed_stencil_span( GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ const GLstencil stencil[], GLint y0 );
+
+
+#endif
--- /dev/null
+#ifndef SWRAST_H
+#define SWRAST_H
+
+#include "types.h"
+
+/* These are the functions exported from swrast. (more to come)
+ */
+void
+_swrast_alloc_buffers( GLcontext *ctx );
+
+
+void
+_swrast_Bitmap( GLcontext *ctx,
+ GLint px, GLint py,
+ GLsizei width, GLsizei height,
+ const struct gl_pixelstore_attrib *unpack,
+ const GLubyte *bitmap );
+
+void
+_swrast_CopyPixels( GLcontext *ctx,
+ GLint srcx, GLint srcy,
+ GLint destx, GLint desty,
+ GLsizei width, GLsizei height,
+ GLenum type );
+
+void
+_swrast_DrawPixels( GLcontext *ctx,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ const struct gl_pixelstore_attrib *unpack,
+ const GLvoid *pixels );
+
+void
+_swrast_ReadPixels( GLcontext *ctx,
+ GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ const struct gl_pixelstore_attrib *unpack,
+ GLvoid *pixels );
+
+void
+_swrast_Clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height );
+
+void
+_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 );
+
+
+/* Replace:
+ */
+void
+_swrast_set_texture_sampler( struct gl_texture_object *t );
+
+
+
+#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)
+
+
+
+
+
+
+#endif
projects / mesa.git / commitdiff