/* $Id: vbrender.c,v 1.3 2000-05-23 20:41:03 jeroen 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. */ /* * Render points, lines, and polygons. The only entry point to this * file is the gl_render_vb() function. This function is called after * the vertex buffer has filled up or a state change has occurred. * * This file basically only makes calls to the clipping functions and * the point, line and triangle rasterizers via the function pointers. * context->Driver.PointsFunc() * context->Driver.LineFunc() * context->Driver.TriangleFunc() */ #ifdef PC_HEADER #include "all.h" #else #include "glheader.h" #include "clip.h" #include "types.h" #include "context.h" #include "light.h" #include "lines.h" #include "macros.h" #include "matrix.h" #include "pb.h" #include "points.h" #include "pipeline.h" #include "stages.h" #include "vb.h" #include "vbcull.h" #include "vbrender.h" #include "vbindirect.h" #include "xform.h" #endif /* * This file implements rendering of points, lines and polygons defined by * vertices in the vertex buffer. */ /* * Render a line segment from VB[v1] to VB[v2] when either one or both * endpoints must be clipped. */ void gl_render_clipped_line( GLcontext *ctx, GLuint v1, GLuint v2 ) { GLuint pv = v2; struct vertex_buffer *VB = ctx->VB; GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2]); /* GLubyte andmask = VB->ClipMask[v1] & VB->ClipMask[v2]; */ if ((ctx->line_clip_tab[VB->ClipPtr->size])( VB, &v1, &v2, mask )) ctx->Driver.LineFunc( ctx, v1, v2, pv ); } static INLINE void gl_render_clipped_line2( GLcontext *ctx, GLuint v1, GLuint v2 ) { GLuint pv = v2; struct vertex_buffer *VB = ctx->VB; GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2]); if (!mask || (ctx->line_clip_tab[VB->ClipPtr->size])( VB, &v1, &v2, mask )) ctx->Driver.LineFunc( ctx, v1, v2, pv ); } /* * Compute Z offsets for a polygon with plane defined by (A,B,C,D) * D is not needed. */ static void offset_polygon( GLcontext *ctx, GLfloat a, GLfloat b, GLfloat c ) { GLfloat ac, bc, m; GLfloat offset; if (c<0.001F && c>-0.001F) { /* to prevent underflow problems */ offset = 0.0F; } else { ac = a / c; bc = b / c; if (ac<0.0F) ac = -ac; if (bc<0.0F) bc = -bc; m = MAX2( ac, bc ); /* m = sqrt( ac*ac + bc*bc ); */ offset = m * ctx->Polygon.OffsetFactor + ctx->Polygon.OffsetUnits; } ctx->PointZoffset = ctx->Polygon.OffsetPoint ? offset : 0.0F; ctx->LineZoffset = ctx->Polygon.OffsetLine ? offset : 0.0F; ctx->PolygonZoffset = ctx->Polygon.OffsetFill ? offset : 0.0F; } #define FLUSH_PRIM(prim) \ do { \ if (ctx->PB->primitive != prim) { \ gl_reduced_prim_change( ctx, prim ); \ } \ } while(0) /* * When glPolygonMode() is used to specify that the front/back rendering * mode for polygons is not GL_FILL we end up calling this function. */ static void unfilled_polygon( GLcontext *ctx, GLuint n, GLuint vlist[], GLuint pv, GLuint facing ) { GLenum mode = facing ? ctx->Polygon.BackMode : ctx->Polygon.FrontMode; struct vertex_buffer *VB = ctx->VB; GLubyte *edge_ptr = (GLubyte *)VB->EdgeFlagPtr->data; FLUSH_PRIM(mode); if (mode==GL_POINT) { GLuint i, j; for (i=0;iDriver.PointsFunc)( ctx, j, j ); } } } else if (mode==GL_LINE) { GLuint i, j0, j1; ctx->StippleCounter = 0; /* draw the edges */ for (i=0;iDriver.LineFunc)( ctx, j0, j1, pv ); } } /* last edge is special */ j0 = vlist[i]; j1 = vlist[0]; if (edge_ptr[j0] & 0x2) { edge_ptr[j0] &= ~0x2; (*ctx->Driver.LineFunc)( ctx, j0, j1, pv ); } } else { /* Fill the polygon */ GLuint j0, i; j0 = vlist[0]; for (i=2;iDriver.TriangleFunc)( ctx, j0, vlist[i-1], vlist[i], pv ); } } } /* * Render a polygon in which at least one vertex has to be clipped. * Input: n - number of vertices * vlist - list of vertices in the polygon. * CCW order = front facing. */ void gl_render_clipped_triangle( GLcontext *ctx, GLuint n, GLuint vlist[], GLuint pv ) { struct vertex_buffer *VB = ctx->VB; GLubyte mask = 0; GLuint i; for (i = 0 ; i < n ; i++) mask |= VB->ClipMask[vlist[i]]; n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, n, vlist, mask ); for (i=2;iTriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); } static INLINE void gl_render_clipped_triangle2( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint pv ) { struct vertex_buffer *VB = ctx->VB; GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3]); GLuint vlist[VB_MAX_CLIPPED_VERTS]; GLuint i, n; if (!mask) { ctx->TriangleFunc( ctx, v1, v2, v3, pv ); return; } if (CLIP_ALL_BITS & VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3]) return; ASSIGN_3V(vlist, v1, v2, v3 ); n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, 3, vlist, mask ); for (i=2;iTriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); } static INLINE void gl_render_clipped_quad2( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv ) { struct vertex_buffer *VB = ctx->VB; GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3] | VB->ClipMask[v4]); GLuint vlist[VB_MAX_CLIPPED_VERTS]; GLuint i, n; if (!mask) { ctx->QuadFunc( ctx, v1, v2, v3, v4, pv ); return; } if (CLIP_ALL_BITS & VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3] & VB->ClipMask[v4]) return; ASSIGN_4V(vlist, v1, v2, v3, v4 ); n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, 4, vlist, mask ); for (i=2;iTriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); } /* Implements triangle_rendering when (IndirectTriangles & DD_SW_SETUP) * is non-zero. */ static void render_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; GLuint facing; GLuint tricaps; if (c * ctx->backface_sign > 0) return; facing = (c<0.0F) ^ (ctx->Polygon.FrontFace==GL_CW); tricaps = ctx->IndirectTriangles; if (tricaps & DD_TRI_OFFSET) { /* finish computing plane equation of polygon, compute offset */ GLfloat fz = win[v2][2] - win[v0][2]; GLfloat ez = win[v1][2] - win[v0][2]; GLfloat a = ey*fz-ez*fy; GLfloat b = ez*fx-ex*fz; offset_polygon( ctx, a, b, c ); } if (tricaps & DD_TRI_LIGHT_TWOSIDE) { VB->Specular = VB->Spec[facing]; VB->ColorPtr = VB->Color[facing]; VB->IndexPtr = VB->Index[facing]; } if (tricaps & DD_TRI_UNFILLED) { GLuint vlist[3]; vlist[0] = v0; vlist[1] = v1; vlist[2] = v2; unfilled_polygon( ctx, 3, vlist, pv, facing ); } else { (*ctx->Driver.TriangleFunc)( ctx, v0, v1, v2, pv ); } } static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { } /* Implements triangle_rendering when (IndirectTriangles & DD_SW_SETUP) * is non-zero. */ static void render_quad( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3, GLuint pv ) { struct vertex_buffer *VB = ctx->VB; GLfloat (*win)[4] = VB->Win.data; GLfloat ex = win[v2][0] - win[v0][0]; GLfloat ey = win[v2][1] - win[v0][1]; GLfloat fx = win[v3][0] - win[v1][0]; GLfloat fy = win[v3][1] - win[v1][1]; GLfloat c = ex*fy-ey*fx; GLuint facing; GLuint tricaps = ctx->IndirectTriangles; if (c * ctx->backface_sign > 0) return; facing = (c<0.0F) ^ (ctx->Polygon.FrontFace==GL_CW); if (tricaps & DD_TRI_OFFSET) { GLfloat ez = win[v2][2] - win[v0][2]; GLfloat fz = win[v3][2] - win[v1][2]; GLfloat a = ey*fz-ez*fy; GLfloat b = ez*fx-ex*fz; offset_polygon( ctx, a, b, c ); } if (tricaps & DD_TRI_LIGHT_TWOSIDE) { VB->Specular = VB->Spec[facing]; VB->ColorPtr = VB->Color[facing]; VB->IndexPtr = VB->Index[facing]; } /* Render the quad! */ if (tricaps & DD_TRI_UNFILLED) { GLuint vlist[4]; vlist[0] = v0; vlist[1] = v1; vlist[2] = v2; vlist[3] = v3; unfilled_polygon( ctx, 4, vlist, pv, facing ); } else { (*ctx->Driver.QuadFunc)( ctx, v0, v1, v2, v3, pv ); } } #if 0 static void null_quad( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3, GLuint pv ) { } #endif extern const char *gl_prim_name[]; /* * Either the vertex buffer is full (VB->Count==VB_MAX) or glEnd() has been * called. Render the primitives defined by the vertices and reset the * buffer. * * This function won't be called if the device driver implements a * RenderVB() function. */ #define NEED_EDGEFLAG_SETUP (ctx->TriangleCaps & DD_TRI_UNFILLED) #define EDGEFLAG_TRI( i2, i1, i, pv, parity) \ do { \ eflag[i2] = eflag[i1] = 1; eflag[i] = 2; \ } while (0) #define EDGEFLAG_QUAD( i3, i2, i1, i, pv) \ do { \ eflag[i3] = eflag[i2] = eflag[i1] = 1; eflag[i] = 2; \ } while (0) #define EDGEFLAG_POLY_TRI_PRE( i2, i1, i, pv) \ do { \ eflag[i1] |= (eflag[i1] >> 2) & 1; \ eflag[i] |= (eflag[i] >> 2) & 2; \ } while (0) #define EDGEFLAG_POLY_TRI_POST( i2, i1, i, pv) \ do { \ eflag[i2] = 0; \ eflag[i1] &= ~(4|1); \ eflag[i] &= ~(8|2); \ } while (0) /* Culled and possibly clipped primitives. */ #define RENDER_POINTS( start, count ) \ (void) cullmask; \ (*ctx->Driver.PointsFunc)( ctx, start, count-1 ); #define RENDER_LINE( i1, i ) \ do { \ const GLubyte flags = cullmask[i]; \ \ if (!(flags & PRIM_NOT_CULLED)) \ continue; \ \ if (flags & PRIM_ANY_CLIP) \ gl_render_clipped_line( ctx, i1, i ); \ else \ ctx->Driver.LineFunc( ctx, i1, i, i ); \ } while (0) #define RENDER_TRI( i2, i1, i, pv, parity) \ do { \ const GLubyte flags = cullmask[i]; \ \ if (!(flags & PRIM_NOT_CULLED)) \ continue; \ \ if (flags & PRIM_ANY_CLIP) { \ if (parity) { \ vlist[0] = i1; \ vlist[1] = i2; \ vlist[2] = i; \ } else { \ vlist[0] = i2; \ vlist[1] = i1; \ vlist[2] = i; \ } \ gl_render_clipped_triangle( ctx, 3, vlist, pv ); \ } else if (parity) \ ctx->TriangleFunc( ctx, i1, i2, i, pv ); \ else \ ctx->TriangleFunc( ctx, i2, i1, i, pv ); \ \ } while (0) #define RENDER_QUAD( i3, i2, i1, i, pv) \ do { \ const GLubyte flags = cullmask[i]; \ \ if (!(flags & PRIM_NOT_CULLED)) \ continue; \ \ if (flags&PRIM_ANY_CLIP) { \ vlist[0] = i3; \ vlist[1] = i2; \ vlist[2] = i1; \ vlist[3] = i; \ gl_render_clipped_triangle( ctx, 4, vlist, pv ); \ } else \ ctx->QuadFunc( ctx, i3, i2, i1, i, pv ); \ } while (0) #define LOCAL_VARS \ GLcontext *ctx = VB->ctx; \ const GLubyte *cullmask = VB->CullMask; \ GLuint vlist[VB_SIZE]; \ GLubyte *eflag = VB->EdgeFlagPtr->data; \ GLuint *stipplecounter = &VB->ctx->StippleCounter; \ (void) vlist; (void) eflag; (void) stipplecounter; #define TAG(x) x##_cull #define INIT(x) FLUSH_PRIM(x) #define RESET_STIPPLE *stipplecounter = 0 #include "render_tmp.h" /* Direct, no clipping or culling. */ #define RENDER_POINTS( start, count ) \ (*ctx->Driver.PointsFunc)( ctx, start, count-1 ) #define RENDER_LINE( i1, i ) \ (*ctx->Driver.LineFunc)( ctx, i1, i, i ) #define RENDER_TRI( i2, i1, i, pv, parity ) \ do { \ if (parity) \ ctx->TriangleFunc( ctx, i1, i2, i, pv ); \ else \ ctx->TriangleFunc( ctx, i2, i1, i, pv ); \ } while (0) #define RENDER_QUAD( i3, i2, i1, i, pv ) \ ctx->QuadFunc( ctx, i3, i2, i1, i, i ); #define TAG(x) x##_raw #define LOCAL_VARS \ GLcontext *ctx = VB->ctx; \ GLubyte *eflag = VB->EdgeFlagPtr->data; \ GLuint *stipplecounter = &VB->ctx->StippleCounter; \ (void) eflag; (void) stipplecounter; #define INIT(x) FLUSH_PRIM(x); #define RESET_STIPPLE *stipplecounter = 0 #include "render_tmp.h" /* Direct, with the possibility of clipping. */ #define RENDER_POINTS( start, count ) \ (*ctx->Driver.PointsFunc)( ctx, start, count-1 ) #define RENDER_LINE( i1, i ) \ gl_render_clipped_line2( ctx, i1, i ) #define RENDER_TRI( i2, i1, i, pv, parity) \ do { \ GLuint e2=i2, e1=i1; \ if (parity) { GLuint t=e2; e2=e1; e1=t; } \ gl_render_clipped_triangle2(ctx,e2,e1,i,pv); \ } while (0) #define RENDER_QUAD( i3, i2, i1, i, pv) \ do { \ gl_render_clipped_quad2(ctx,i3,i2,i1,i,pv); \ } while (0) #define LOCAL_VARS \ GLcontext *ctx = VB->ctx; \ GLubyte *eflag = VB->EdgeFlagPtr->data; \ GLuint *stipplecounter = &VB->ctx->StippleCounter; \ (void) eflag; (void) stipplecounter; #define INIT(x) FLUSH_PRIM(x); #define TAG(x) x##_clipped #define RESET_STIPPLE *stipplecounter = 0 #include "render_tmp.h" /* Bits: * 0x1 - draw this edge if it is first or second in a triangle. * 0x2 - draw this edge if it is last in a triangle. * 0x4 - placeholder for multipass rendering. * * Bits 0x1 and 0x2 are cleared after they are used. Bit 0x4 is used * to stop these values going to zero in multipass rendering. * * Clipping introduces vertices on outgoing edges with edgeflag 0x1. * Incoming edges retain the value of the clipped vertex, with the following * masks: * - If the incoming edge originates from the last vertex in the * clipped primitive (triangle or quad), the introduced vertex * retains both bits (0x3) of the original flag. * - All other introduced vertices retain only bit 1 (0x1). * * In a horrible hack I've had to push tristrips, fans & quadstrip handling * into render_tmp.h... * * Keith. */ static void setup_edgeflag( struct vertex_buffer *VB, GLenum prim, GLuint start, GLuint count, GLuint parity ) { GLubyte *flag = VB->EdgeFlagPtr->data + start; GLuint n = count - start; GLuint i; (void) parity; switch (prim) { case GL_TRIANGLES: for (i = 0 ; i < n-2 ; i+=3) { if (flag[i]) flag[i] = 0x1; if (flag[i+1]) flag[i+1] = 0x1; if (flag[i+2]) flag[i+2] = 0x3; } break; case GL_QUADS: for (i = 0 ; i < n-3 ; i+=4) { if (flag[i]) flag[i] = 0x1; if (flag[i+1]) flag[i+1] = 0x1; if (flag[i+2]) flag[i+2] = 0x1; if (flag[i+3]) flag[i+3] = 0x3; } break; case GL_POLYGON: if (flag[0]) flag[0] = 0x1; for (i = 1 ; i < n-1 ; i++) { if (flag[i]) flag[i] = 0x1<<2; } if (flag[i]) flag[i] = 0x3<<2; break; default: break; } } /* Could eventually generalize to handle changes of rasterization * state other than change-of-primitive. An example might be * some bind-texture calls. */ void gl_render_vb( struct vertex_buffer *VB ) { GLcontext *ctx = VB->ctx; GLuint i, next, prim; GLuint parity = VB->Parity; render_func *tab; GLuint count = VB->Count; GLint p = 0; if (VB->Indirect) { /* gl_render_vb_indirect( VB, VB ); */ return; } else if (VB->CullMode & CULL_MASK_ACTIVE) { tab = ctx->Driver.RenderVBCulledTab; } else if (VB->CullMode & CLIP_MASK_ACTIVE) { tab = ctx->Driver.RenderVBClippedTab; } else { tab = ctx->Driver.RenderVBRawTab; } if (!VB->CullDone) gl_fast_copy_vb( VB ); if (ctx->TriangleCaps & DD_TRI_UNFILLED) gl_import_client_data( VB, VERT_EDGE, VEC_WRITABLE|VEC_GOOD_STRIDE ); gl_import_client_data( VB, ctx->RenderFlags, (VB->ClipOrMask ? VEC_WRITABLE|VEC_GOOD_STRIDE : VEC_GOOD_STRIDE)); if (/* ctx->Current.Primitive == GL_POLYGON+1 && */ ctx->Driver.RenderStart) ctx->Driver.RenderStart( ctx ); do { for ( i= VB->CopyStart ; i < count ; parity = 0, i = next ) { prim = VB->Primitive[i]; next = VB->NextPrimitive[i]; if (ctx->TriangleCaps & DD_TRI_UNFILLED) setup_edgeflag(VB, prim, i, next, parity); tab[prim]( VB, i, next, parity ); if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) { VB->Specular = VB->Spec[0]; VB->ColorPtr = VB->Color[0]; VB->IndexPtr = VB->Index[0]; } } } while (ctx->Driver.MultipassFunc && ctx->Driver.MultipassFunc( VB, ++p )); if (ctx->PB->count > 0) gl_flush_pb(ctx); if (/* ctx->Current.Primitive == GL_POLYGON+1 && */ ctx->Driver.RenderFinish) ctx->Driver.RenderFinish( ctx ); } void gl_reduced_prim_change( GLcontext *ctx, GLenum prim ) { if (ctx->PB->count > 0) gl_flush_pb(ctx); ctx->PB->count = 0; ctx->PB->mono = GL_FALSE; if (ctx->PB->primitive != prim) { ctx->PB->primitive = prim; if (ctx->Driver.ReducedPrimitiveChange) ctx->Driver.ReducedPrimitiveChange( ctx, prim ); } } void gl_set_render_vb_function( GLcontext *ctx ) { if (ctx->Driver.RenderVBCulledTab == 0) ctx->Driver.RenderVBCulledTab = render_tab_cull; if (ctx->Driver.RenderVBClippedTab == 0) ctx->Driver.RenderVBClippedTab = render_tab_clipped; if (ctx->Driver.RenderVBRawTab == 0) ctx->Driver.RenderVBRawTab = render_tab_raw; ctx->TriangleFunc = ctx->Driver.TriangleFunc; ctx->QuadFunc = ctx->Driver.QuadFunc; ctx->ClippedTriangleFunc = ctx->TriangleFunc; if (ctx->IndirectTriangles & DD_SW_SETUP) { ctx->ClippedTriangleFunc = render_triangle; if (ctx->IndirectTriangles & (DD_SW_SETUP & ~DD_TRI_CULL)) { if (ctx->IndirectTriangles & DD_TRI_CULL_FRONT_BACK) { ctx->TriangleFunc = null_triangle; ctx->QuadFunc = render_quad; ctx->ClippedTriangleFunc = null_triangle; } else { ctx->TriangleFunc = render_triangle; ctx->QuadFunc = render_quad; } } } } void gl_init_vbrender( void ) { render_init_raw(); render_init_cull(); render_init_clipped(); }