From f18598cbd2802e61c2cbb1d610630da9b5951169 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Fri, 30 Jan 2004 23:26:19 +0000 Subject: Via Unichrome/cle266 driver (Erdi Chen) --- src/mesa/drivers/dri/unichrome/via_dd_tritmp.h | 759 +++++++++++++++++++++++++ 1 file changed, 759 insertions(+) create mode 100644 src/mesa/drivers/dri/unichrome/via_dd_tritmp.h (limited to 'src/mesa/drivers/dri/unichrome/via_dd_tritmp.h') diff --git a/src/mesa/drivers/dri/unichrome/via_dd_tritmp.h b/src/mesa/drivers/dri/unichrome/via_dd_tritmp.h new file mode 100644 index 0000000000..e9af518212 --- /dev/null +++ b/src/mesa/drivers/dri/unichrome/via_dd_tritmp.h @@ -0,0 +1,759 @@ +/* + * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved. + * Copyright 2001-2003 S3 Graphics, Inc. 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, sub license, + * 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 (including the + * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL + * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS 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. + */ + +#if HAVE_RGBA +#define VERT_SET_IND(v, c) (void)c +#define VERT_COPY_IND(v0, v1) +#define VERT_SAVE_IND(idx) +#define VERT_RESTORE_IND(idx) +#if HAVE_BACK_COLORS +#define VERT_SET_RGBA(v, c) +#endif +#else +#define VERT_SET_RGBA(v, c) (void)c +#define VERT_COPY_RGBA(v0, v1) +#define VERT_SAVE_RGBA(idx) +#define VERT_RESTORE_RGBA(idx) +#if HAVE_BACK_COLORS +#define VERT_SET_IND(v, c) +#endif +#endif + +#if !HAVE_SPEC +#define VERT_SET_SPEC(v, c) (void)c +#define VERT_COPY_SPEC(v0, v1) +#define VERT_SAVE_SPEC(idx) +#define VERT_RESTORE_SPEC(idx) +#if HAVE_BACK_COLORS +#define VERT_COPY_SPEC1(v) +#endif +#else +#if HAVE_BACK_COLORS +#define VERT_SET_SPEC(v, c) +#endif +#endif + +#if !HAVE_BACK_COLORS +#define VERT_COPY_SPEC1(v) +#define VERT_COPY_IND1(v) +#define VERT_COPY_RGBA1(v) +#endif + +#ifndef INSANE_VERTICES +#define VERT_SET_Z(v, val) VERT_Z(v) = val +#define VERT_Z_ADD(v, val) VERT_Z(v) += val +#endif + +#if DO_TRI +static void TAG(triangle)(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + VERTEX *v[3]; + GLfloat offset; + GLfloat z[3]; + GLenum mode = GL_FILL; + GLuint facing; + LOCAL_VARS(3); + +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif +#ifdef PERFORMANCE_MEASURE + if (VIA_PERFORMANCE) P_M; +#endif + + v[0] = (VERTEX *)GET_VERTEX(e0); + v[1] = (VERTEX *)GET_VERTEX(e1); + v[2] = (VERTEX *)GET_VERTEX(e2); + + if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED) { + GLfloat ex = VERT_X(v[0]) - VERT_X(v[2]); + GLfloat ey = VERT_Y(v[0]) - VERT_Y(v[2]); + GLfloat fx = VERT_X(v[1]) - VERT_X(v[2]); + GLfloat fy = VERT_Y(v[1]) - VERT_Y(v[2]); + GLfloat cc = ex * fy - ey * fx; + + if (DO_TWOSIDE || DO_UNFILLED) { + facing = AREA_IS_CCW(cc) ^ ctx->Polygon._FrontBit; + + if (DO_UNFILLED) { + if (facing) { + mode = ctx->Polygon.BackMode; + if (ctx->Polygon.CullFlag && + ctx->Polygon.CullFaceMode != GL_FRONT) { + return; + } + } + else { + mode = ctx->Polygon.FrontMode; + if (ctx->Polygon.CullFlag && + ctx->Polygon.CullFaceMode != GL_BACK) { + return; + } + } + } + + if (DO_TWOSIDE && facing == 1) { + if (HAVE_RGBA) { + if (HAVE_BACK_COLORS) { + if (!DO_FLAT) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_COPY_RGBA1(v[0]); + VERT_COPY_RGBA1(v[1]); + } + VERT_SAVE_RGBA(2); + VERT_COPY_RGBA1(v[2]); + if (HAVE_SPEC) { + if (!DO_FLAT) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_COPY_SPEC1(v[0]); + VERT_COPY_SPEC1(v[1]); + } + VERT_SAVE_SPEC(2); + VERT_COPY_SPEC1(v[2]); + } + } + else { + GLfloat (*vbcolor)[4] = VB->ColorPtr[1]->data; + ASSERT(VB->ColorPtr[1]->stride == 4*sizeof(GLfloat)); + (void)vbcolor; + + if (!DO_FLAT) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_SET_RGBA(v[0], vbcolor[e0]); + VERT_SET_RGBA(v[1], vbcolor[e1]); + } + VERT_SAVE_RGBA(2); + VERT_SET_RGBA(v[2], vbcolor[e2]); + + if (HAVE_SPEC && VB->SecondaryColorPtr[1]) { + GLfloat (*vbspec)[4] = VB->SecondaryColorPtr[1]->data; + + if (!DO_FLAT) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_SET_SPEC(v[0], vbspec[e0]); + VERT_SET_SPEC(v[1], vbspec[e1]); + } + VERT_SAVE_SPEC(2); + VERT_SET_SPEC(v[2], vbspec[e2]); + } + } + } + else { + GLfloat *vbindex = (GLfloat*) VB->IndexPtr[1]->data; + if (!DO_FLAT) { + //VERT_SAVE_IND( 0 ); + //VERT_SAVE_IND( 1 ); + VERT_SET_IND(v[0], vbindex[e0]); + VERT_SET_IND(v[1], vbindex[e1]); + } + //VERT_SAVE_IND( 2 ); + VERT_SET_IND(v[2], vbindex[e2]); + } + } + } + + if (DO_OFFSET) { + offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE; + z[0] = VERT_Z(v[0]); + z[1] = VERT_Z(v[1]); + z[2] = VERT_Z(v[2]); + if (cc * cc > 1e-16) { + GLfloat ic = 1.0 / cc; + GLfloat ez = z[0] - z[2]; + GLfloat fz = z[1] - z[2]; + GLfloat a = ey * fz - ez * fy; + GLfloat b = ez * fx - ex * fz; + GLfloat ac = a * ic; + GLfloat bc = b * ic; + if (ac < 0.0f) ac = -ac; + if (bc < 0.0f) bc = -bc; + offset += MAX2(ac, bc) * ctx->Polygon.OffsetFactor; + } + offset *= ctx->MRD; + } + } + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_COPY_RGBA(v[0], v[2]); + VERT_COPY_RGBA(v[1], v[2]); + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_COPY_SPEC(v[0], v[2]); + VERT_COPY_SPEC(v[1], v[2]); + } + } + else { + VERT_SAVE_IND(0); + VERT_SAVE_IND(1); + VERT_COPY_IND(v[0], v[2]); + VERT_COPY_IND(v[1], v[2]); + } + } + + if (mode == GL_POINT) { + if (DO_OFFSET && ctx->Polygon.OffsetPoint) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + } + UNFILLED_TRI(ctx, GL_POINT, e0, e1, e2); + } + else if (mode == GL_LINE) { + if (DO_OFFSET && ctx->Polygon.OffsetLine) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + } + UNFILLED_TRI(ctx, GL_LINE, e0, e1, e2); + } + else { + if (DO_OFFSET && ctx->Polygon.OffsetFill) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + } + if (DO_UNFILLED) + RASTERIZE(GL_TRIANGLES); + TRI(v[0], v[1], v[2]); + } + + if (DO_OFFSET) { + VERT_SET_Z(v[0], z[0]); + VERT_SET_Z(v[1], z[1]); + VERT_SET_Z(v[2], z[2]); + } + + if (DO_TWOSIDE && facing == 1) { + if (HAVE_RGBA) { + if (!DO_FLAT) { + VERT_RESTORE_RGBA(0); + VERT_RESTORE_RGBA(1); + } + VERT_RESTORE_RGBA(2); + if (HAVE_SPEC) { + if (!DO_FLAT) { + VERT_RESTORE_SPEC(0); + VERT_RESTORE_SPEC(1); + } + VERT_RESTORE_SPEC(2); + } + } + else { +#if 0 // XXX TODO _SOLO + GLuint *vbindex = VB->IndexPtr[0]->data; + if (!DO_FLAT) { + VERT_SET_IND(v[0], vbindex[e0]); + VERT_SET_IND(v[1], vbindex[e1]); + } + VERT_SET_IND(v[2], vbindex[e2]); +#else + if (!DO_FLAT) { + VERT_RESTORE_IND( 0 ); + VERT_RESTORE_IND( 1 ); + } + VERT_RESTORE_IND( 2 ); +#endif + } + } + + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_RESTORE_RGBA(0); + VERT_RESTORE_RGBA(1); + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_RESTORE_SPEC(0); + VERT_RESTORE_SPEC(1); + } + } + else { + VERT_RESTORE_IND(0); + VERT_RESTORE_IND(1); + } + } + SET_PRIMITIVE_RENDERED +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif +} +#endif + +#if DO_QUAD +#if DO_FULL_QUAD +static void TAG(quad)(GLcontext *ctx, + GLuint e0, GLuint e1, GLuint e2, GLuint e3) +{ + struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb; + VERTEX *v[4]; + GLfloat offset; + GLfloat z[4]; + GLenum mode = GL_FILL; + GLuint facing; + LOCAL_VARS(4); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif +#ifdef PERFORMANCE_MEASURE + if (VIA_PERFORMANCE) P_M; +#endif + v[0] = (VERTEX *)GET_VERTEX(e0); + v[1] = (VERTEX *)GET_VERTEX(e1); + v[2] = (VERTEX *)GET_VERTEX(e2); + v[3] = (VERTEX *)GET_VERTEX(e3); + + if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED) { + GLfloat ex = VERT_X(v[2]) - VERT_X(v[0]); + GLfloat ey = VERT_Y(v[2]) - VERT_Y(v[0]); + GLfloat fx = VERT_X(v[3]) - VERT_X(v[1]); + GLfloat fy = VERT_Y(v[3]) - VERT_Y(v[1]); + GLfloat cc = ex * fy - ey * fx; + + if (DO_TWOSIDE || DO_UNFILLED) { + facing = AREA_IS_CCW(cc) ^ ctx->Polygon._FrontBit; + + if (DO_UNFILLED) { + if (facing) { + mode = ctx->Polygon.BackMode; + if (ctx->Polygon.CullFlag && + ctx->Polygon.CullFaceMode != GL_FRONT) { + return; + } + } + else { + mode = ctx->Polygon.FrontMode; + if (ctx->Polygon.CullFlag && + ctx->Polygon.CullFaceMode != GL_BACK) { + return; + } + } + } + + if (DO_TWOSIDE && facing == 1) { + if (HAVE_RGBA) { + GLfloat (*vbcolor)[4] = VB->ColorPtr[1]->data; + (void)vbcolor; + + if (HAVE_BACK_COLORS) { + if (!DO_FLAT) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_SAVE_RGBA(2); + VERT_COPY_RGBA1(v[0]); + VERT_COPY_RGBA1(v[1]); + VERT_COPY_RGBA1(v[2]); + } + VERT_SAVE_RGBA(3); + VERT_COPY_RGBA1(v[3]); + if (HAVE_SPEC) { + if (!DO_FLAT) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_SAVE_SPEC(2); + VERT_COPY_SPEC1(v[0]); + VERT_COPY_SPEC1(v[1]); + VERT_COPY_SPEC1(v[2]); + } + VERT_SAVE_SPEC(3); + VERT_COPY_SPEC1(v[3]); + } + } + else { + if (!DO_FLAT) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_SAVE_RGBA(2); + VERT_SET_RGBA(v[0], vbcolor[e0]); + VERT_SET_RGBA(v[1], vbcolor[e1]); + VERT_SET_RGBA(v[2], vbcolor[e2]); + } + VERT_SAVE_RGBA(3); + VERT_SET_RGBA(v[3], vbcolor[e3]); + + if (HAVE_SPEC && VB->SecondaryColorPtr[1]) { + GLfloat (*vbspec)[4] = VB->SecondaryColorPtr[1]->data; + ASSERT(VB->SecondaryColorPtr[1]->stride==4*sizeof(GLfloat)); + + if (!DO_FLAT) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_SAVE_SPEC(2); + VERT_SET_SPEC(v[0], vbspec[e0]); + VERT_SET_SPEC(v[1], vbspec[e1]); + VERT_SET_SPEC(v[2], vbspec[e2]); + } + VERT_SAVE_SPEC(3); + VERT_SET_SPEC(v[3], vbspec[e3]); + } + } + } + else { + GLfloat *vbindex = (GLfloat*) VB->IndexPtr[1]->data; + if (!DO_FLAT) { + //VERT_SAVE_IND( 0 ); + //VERT_SAVE_IND( 1 ); + //VERT_SAVE_IND( 2 ); + VERT_SET_IND(v[0], vbindex[e0]); + VERT_SET_IND(v[1], vbindex[e1]); + VERT_SET_IND(v[2], vbindex[e2]); + } + //VERT_SAVE_IND( 3 ); + VERT_SET_IND(v[3], vbindex[e3]); + } + } + } + + + if (DO_OFFSET) { + offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE; + z[0] = VERT_Z(v[0]); + z[1] = VERT_Z(v[1]); + z[2] = VERT_Z(v[2]); + z[3] = VERT_Z(v[3]); + if (cc * cc > 1e-16) { + GLfloat ez = z[2] - z[0]; + GLfloat fz = z[3] - z[1]; + GLfloat a = ey * fz - ez * fy; + GLfloat b = ez * fx - ex * fz; + GLfloat ic = 1.0 / cc; + GLfloat ac = a * ic; + GLfloat bc = b * ic; + if ( ac < 0.0f ) ac = -ac; + if ( bc < 0.0f ) bc = -bc; + offset += MAX2(ac, bc) * ctx->Polygon.OffsetFactor; + } + offset *= ctx->MRD; + } + } + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_SAVE_RGBA(0); + VERT_SAVE_RGBA(1); + VERT_SAVE_RGBA(2); + VERT_COPY_RGBA(v[0], v[3]); + VERT_COPY_RGBA(v[1], v[3]); + VERT_COPY_RGBA(v[2], v[3]); + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_SAVE_SPEC(0); + VERT_SAVE_SPEC(1); + VERT_SAVE_SPEC(2); + VERT_COPY_SPEC(v[0], v[3]); + VERT_COPY_SPEC(v[1], v[3]); + VERT_COPY_SPEC(v[2], v[3]); + } + } + else { + VERT_SAVE_IND(0); + VERT_SAVE_IND(1); + VERT_SAVE_IND(2); + VERT_COPY_IND(v[0], v[3]); + VERT_COPY_IND(v[1], v[3]); + VERT_COPY_IND(v[2], v[3]); + } + } + + if (mode == GL_POINT) { + if (( DO_OFFSET) && ctx->Polygon.OffsetPoint) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + VERT_Z_ADD(v[3], offset); + } + UNFILLED_QUAD(ctx, GL_POINT, e0, e1, e2, e3); + } + else if (mode == GL_LINE) { + if (DO_OFFSET && ctx->Polygon.OffsetLine) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + VERT_Z_ADD(v[3], offset); + } + UNFILLED_QUAD(ctx, GL_LINE, e0, e1, e2, e3); + } + else { + if (DO_OFFSET && ctx->Polygon.OffsetFill) { + VERT_Z_ADD(v[0], offset); + VERT_Z_ADD(v[1], offset); + VERT_Z_ADD(v[2], offset); + VERT_Z_ADD(v[3], offset); + } + RASTERIZE(GL_TRIANGLES); + QUAD((v[0]), (v[1]), (v[2]), (v[3])); + } + + if (DO_OFFSET) { + VERT_SET_Z(v[0], z[0]); + VERT_SET_Z(v[1], z[1]); + VERT_SET_Z(v[2], z[2]); + VERT_SET_Z(v[3], z[3]); + } + + if (DO_TWOSIDE && facing == 1) { + if (HAVE_RGBA) { + if (!DO_FLAT) { + VERT_RESTORE_RGBA(0); + VERT_RESTORE_RGBA(1); + VERT_RESTORE_RGBA(2); + } + VERT_RESTORE_RGBA(3); + if (HAVE_SPEC) { + if (!DO_FLAT) { + VERT_RESTORE_SPEC(0); + VERT_RESTORE_SPEC(1); + VERT_RESTORE_SPEC(2); + } + VERT_RESTORE_SPEC(3); + } + } + else { +#if 0 // XXX TODO _SOLO + GLuint *vbindex = VB->IndexPtr[0]->data; + if (!DO_FLAT) { + VERT_SET_IND(v[0], vbindex[e0]); + VERT_SET_IND(v[1], vbindex[e1]); + VERT_SET_IND(v[2], vbindex[e2]); + } + VERT_SET_IND(v[3], vbindex[e3]); +#else + if (!DO_FLAT) { + VERT_RESTORE_IND( 0 ); + VERT_RESTORE_IND( 1 ); + VERT_RESTORE_IND( 2 ); + } + VERT_RESTORE_IND( 3 ); +#endif + } + } + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_RESTORE_RGBA(0); + VERT_RESTORE_RGBA(1); + VERT_RESTORE_RGBA(2); + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_RESTORE_SPEC(0); + VERT_RESTORE_SPEC(1); + VERT_RESTORE_SPEC(2); + } + } + else { + VERT_RESTORE_IND(0); + VERT_RESTORE_IND(1); + VERT_RESTORE_IND(2); + } + } +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif +} +#else +static void TAG(quad)(GLcontext *ctx, GLuint e0, + GLuint e1, GLuint e2, GLuint e3) +{ +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif +#ifdef PERFORMANCE_MEASURE + if (VIA_PERFORMANCE) P_M; +#endif + if (DO_UNFILLED) { + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLubyte ef1 = VB->EdgeFlag[e1]; + GLubyte ef3 = VB->EdgeFlag[e3]; + VB->EdgeFlag[e1] = 0; + TAG(triangle)(ctx, e0, e1, e3); + VB->EdgeFlag[e1] = ef1; + VB->EdgeFlag[e3] = 0; + TAG(triangle)(ctx, e1, e2, e3); + VB->EdgeFlag[e3] = ef3; + } + else { + TAG(triangle)(ctx, e0, e1, e3); + TAG(triangle)(ctx, e1, e2, e3); + } +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif +} +#endif +#endif + +#if DO_LINE +static void TAG(line)(GLcontext *ctx, GLuint e0, GLuint e1) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + VERTEX *v[2]; + LOCAL_VARS(2); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif +#ifdef PERFORMANCE_MEASURE + if (VIA_PERFORMANCE) P_M; +#endif + v[0] = (VERTEX *)GET_VERTEX(e0); + v[1] = (VERTEX *)GET_VERTEX(e1); + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_SAVE_RGBA( 0 ); + VERT_COPY_RGBA( v[0], v[1] ); + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_SAVE_SPEC(0); + VERT_COPY_SPEC(v[0], v[1]); + } + } + else { + VERT_SAVE_IND(0); + VERT_COPY_IND(v[0], v[1]); + } + } + + LINE(v[0], v[1]); + + if (DO_FLAT) { + if (HAVE_RGBA) { + VERT_RESTORE_RGBA(0); + + if (HAVE_SPEC && VB->SecondaryColorPtr[0]) { + VERT_RESTORE_SPEC(0); + } + } + else { + VERT_RESTORE_IND(0); + } + } + SET_PRIMITIVE_RENDERED +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif +} +#endif + +#if DO_POINTS +static void TAG(points)(GLcontext *ctx, GLuint first, GLuint last) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + int i; + LOCAL_VARS(1); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif +#ifdef PERFORMANCE_MEASURE + if (VIA_PERFORMANCE) P_M; +#endif + if (VB->Elts == 0) { + for (i = first; i < last; i++) { + if (VB->ClipMask[i] == 0) { + VERTEX *v = (VERTEX *)GET_VERTEX(i); + POINT(v); + SET_PRIMITIVE_RENDERED + } + } + } + else { + for (i = first; i < last; i++) { + GLuint e = VB->Elts[i]; + if (VB->ClipMask[e] == 0) { + VERTEX *v = (VERTEX *)GET_VERTEX(e); + POINT(v); + SET_PRIMITIVE_RENDERED + } + } + } +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif +} +#endif + +static void TAG(init)(void) +{ +#if DO_QUAD + TAB[IND].quad = TAG(quad); +#endif +#if DO_TRI + TAB[IND].triangle = TAG(triangle); +#endif +#if DO_LINE + TAB[IND].line = TAG(line); +#endif +#if DO_POINTS + TAB[IND].points = TAG(points); +#endif +} + +#undef IND +#undef TAG + +#if HAVE_RGBA +#undef VERT_SET_IND +#undef VERT_COPY_IND +#undef VERT_SAVE_IND +#undef VERT_RESTORE_IND +#if HAVE_BACK_COLORS +#undef VERT_SET_RGBA +#endif +#else +#undef VERT_SET_RGBA +#undef VERT_COPY_RGBA +#undef VERT_SAVE_RGBA +#undef VERT_RESTORE_RGBA +#if HAVE_BACK_COLORS +#undef VERT_SET_IND +#endif +#endif + +#if !HAVE_SPEC +#undef VERT_SET_SPEC +#undef VERT_COPY_SPEC +#undef VERT_SAVE_SPEC +#undef VERT_RESTORE_SPEC +#if HAVE_BACK_COLORS +#undef VERT_COPY_SPEC1 +#endif +#else +#if HAVE_BACK_COLORS +#undef VERT_SET_SPEC +#endif +#endif + +#if !HAVE_BACK_COLORS +#undef VERT_COPY_SPEC1 +#undef VERT_COPY_IND1 +#undef VERT_COPY_RGBA1 +#endif + +#ifndef INSANE_VERTICES +#undef VERT_SET_Z +#undef VERT_Z_ADD +#endif -- cgit v1.2.3