Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/private/windows/opengl/server/soft/so_prim.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

6679 lines
186 KiB
C
Raw Permalink Blame History

/******************************Module*Header*******************************\
* Module Name: so_prim.c
*
* Routines to draw primitives
*
* Created: 10-16-1995
* Author: Hock San Lee [hockl]
*
* Copyright (c) 1995 Microsoft Corporation
\**************************************************************************/
/*
** Copyright 1991, Silicon Graphics, Inc.
** All Rights Reserved.
**
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
** the contents of this file may not be disclosed to third parties, copied or
** duplicated in any form, in whole or in part, without the prior written
** permission of Silicon Graphics, Inc.
**
** RESTRICTED RIGHTS LEGEND:
** Use, duplication or disclosure by the Government is subject to restrictions
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
** rights reserved under the Copyright Laws of the United States.
**
** $Revision: 1.13 $
** $Date: 1993/08/31 16:23:41 $
*/
#include "precomp.h"
#pragma hdrstop
#ifdef _X86_
#include <gli386.h>
#endif
typedef void (FASTCALL *PFN_XFORM)
(__GLcoord *, const __GLfloat *, const __GLmatrix *);
typedef void (FASTCALL *PFN_POLYARRAYDRAW)(__GLcontext *, POLYARRAY *);
typedef void (FASTCALL *PFN_POLYARRAYRENDER)(__GLcontext *, POLYARRAY *);
// extern functions
void DoDomain1(__GLevaluatorMachine *em, __GLfloat u, __GLevaluator1 *e,
__GLfloat *v, __GLfloat *baseData);
void DoDomain2(__GLevaluatorMachine *em, __GLfloat u, __GLfloat v,
__GLevaluator2 *e, __GLfloat *r, __GLfloat *baseData);
void DoDomain2WithDerivs(__GLevaluatorMachine *em, __GLfloat u,
__GLfloat v, __GLevaluator2 *e, __GLfloat *r,
__GLfloat *du, __GLfloat *dv, __GLfloat *baseData);
void ComputeFirstPartials(__GLfloat *p, __GLfloat *pu, __GLfloat *pv);
void ComputeNormal2(__GLcontext *gc, __GLfloat *n, __GLfloat *pu,
__GLfloat *pv);
void FASTCALL vvec(__GLcoord *r, const __GLcoord *p1, const __GLcoord *p2);
// The PA* functions apply to one array entry only.
// The PolyArray* functions apply to the whole array.
void FASTCALL PARenderPoint(__GLcontext *gc, __GLvertex *v);
void FASTCALL PARenderTriangle(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2);
void PARenderQuadFast(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2, __GLvertex *v3);
void PARenderQuadSlow(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2, __GLvertex *v3);
void FASTCALL PAApplyMaterial(__GLcontext *gc, __GLmatChange *mat, GLint face);
void FASTCALL PASphereGen(POLYDATA *pd, __GLcoord *result);
void FASTCALL PADoEval1(__GLcontext *gc, POLYARRAY *pa, POLYDATA *pd);
GLuint FASTCALL PAClipCheckFrustum(__GLcontext *gc, POLYDATA *pd);
GLuint FASTCALL PAClipCheckFrustum2D(__GLcontext *gc, POLYDATA *pd);
GLuint FASTCALL PAClipCheckAll(__GLcontext *gc, POLYDATA *pd);
void FASTCALL PolyArrayRenderPoints(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderLines(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderLStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderTriangles(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderTStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderTFan(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderQuads(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderQStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayRenderPolygon(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawPoints(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawLines(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawLLoop(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawLStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawTriangles(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawTStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawTFan(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawQuads(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawQStrip(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayDrawPolygon(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayPropagateIndex(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayPropagateSameIndex(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayPropagateSameColor(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayPropagateColor(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayProcessEye(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayProcessEdgeFlag(POLYARRAY *pa);
void FASTCALL PolyArrayProcessEvaluator(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayComputeFog(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayApplyMaterials(__GLcontext *gc, POLYARRAY *pa);
GLuint FASTCALL PolyArrayCheckClippedPrimitive(__GLcontext *gc, POLYARRAY *pa, GLuint andCodes);
POLYARRAY * FASTCALL PolyArrayRemoveClippedPrimitives(POLYARRAY *pa0);
// Turn on clipcode optimization
#define POLYARRAY_AND_CLIPCODES 1
// Some assertions used in this code
// ASSERT_PRIMITIVE
#if !((GL_POINTS == 0x0000) \
&& (GL_LINES == 0x0001) \
&& (GL_LINE_LOOP == 0x0002) \
&& (GL_LINE_STRIP == 0x0003) \
&& (GL_TRIANGLES == 0x0004) \
&& (GL_TRIANGLE_STRIP == 0x0005) \
&& (GL_TRIANGLE_FAN == 0x0006) \
&& (GL_QUADS == 0x0007) \
&& (GL_QUAD_STRIP == 0x0008) \
&& (GL_POLYGON == 0x0009))
#error "bad primitive ordering\n"
#endif
// ASSERT_FACE
#if !((__GL_FRONTFACE == 0) && (__GL_BACKFACE == 1))
#error "bad face ordering\n"
#endif
// ASSERT_MATERIAL
#if !((POLYARRAY_MATERIAL_FRONT == POLYDATA_MATERIAL_FRONT) \
&& (POLYARRAY_MATERIAL_BACK == POLYDATA_MATERIAL_BACK))
#error "bad material mask\n"
#endif
// ASSERT_VERTEX
#if !((POLYARRAY_VERTEX2 == POLYDATA_VERTEX2) \
&& (POLYARRAY_VERTEX3 == POLYDATA_VERTEX3) \
&& (POLYARRAY_VERTEX4 == POLYDATA_VERTEX4))
#error "bad vertex flags\n"
#endif
//!!! Set it to 0!
#define ENABLE_PERF_CHECK 0
#if ENABLE_PERF_CHECK
// Performance check macro
#define PERF_CHECK(expr,str) \
{ \
static BOOL bPrinted = FALSE; \
if (!(expr) && !bPrinted) \
{ \
bPrinted = TRUE; \
WARNING("PERF_CHECK: " str);\
} \
}
#else
#define PERF_CHECK(expr,str)
#endif // ENABLE_PERF_CHECK
// Copy processed vertex.
#define PA_COPY_PROCESSED_VERTEX(pdDst,pdSrc) \
{ \
*(pdDst) = *(pdSrc); \
/* must update color pointer for polygon to work! */ \
(pdDst)->color = &(pdDst)->colors[__GL_FRONTFACE]; \
}
#define PA_COPY_VERTEX(pdDst,pdSrc) PA_COPY_PROCESSED_VERTEX(pdDst,pdSrc)
// POLYDATAs are 128 bytes wich is a power of two, so this macro may
// be removed...
#define PD_OFFSET(idx) \
((idx) << 7)
#define PD_ARRAY(ary, idx) \
((POLYDATA *)((GLubyte *)(ary)+PD_OFFSET(idx)))
#define PD_VERTEX(ary, idx) \
((__GLvertex *)((GLubyte *)(ary)+PD_OFFSET(idx)))
// Poly array draw routines.
// ASSERT_PRIMITIVE
PFN_POLYARRAYDRAW afnPolyArrayDraw[] =
{
(PFN_POLYARRAYDRAW) PolyArrayDrawPoints,
(PFN_POLYARRAYDRAW) PolyArrayDrawLines,
(PFN_POLYARRAYDRAW) PolyArrayDrawLLoop,
(PFN_POLYARRAYDRAW) PolyArrayDrawLStrip,
(PFN_POLYARRAYDRAW) PolyArrayDrawTriangles,
(PFN_POLYARRAYDRAW) PolyArrayDrawTStrip,
(PFN_POLYARRAYDRAW) PolyArrayDrawTFan,
(PFN_POLYARRAYDRAW) PolyArrayDrawQuads,
(PFN_POLYARRAYDRAW) PolyArrayDrawQStrip,
(PFN_POLYARRAYDRAW) PolyArrayDrawPolygon,
};
#ifdef _X86_
#define X86_MASK_EXCEPTIONS(dwOldMode) \
__asm fnstcw WORD PTR dwOldMode \
__asm mov eax, dwOldMode \
__asm or eax, 0x3f \
__asm mov WORD PTR dwOldMode+2, ax \
__asm fldcw WORD PTR dwOldMode+2
#define X86_RESTORE_MASK(dwOldMode) \
__asm fnclex \
__asm fldcw WORD PTR dwOldMode
#else // _X86_
#define X86_MASK_EXCEPTIONS(dwOldMode)
#define X86_RESTORE_MASK(dwOldMode)
#endif // _X86_
// READ THIS NOTE BEFORE YOU MAKE ANY CHANGES!
//
// NOTE: This function is also called by RasterPos to compute its associated
// color and texture coordinates!
// This code has to update current values and material even if there is
// no vertex.
//!!! special case provoking vertex?
void APIPRIVATE __glim_DrawPolyArray(void *_pa0)
{
__GLtransform *trMV;
__GLmatrix *m, *mEye;
GLuint enables;
GLuint paNeeds, paNeedsSaved;
GLuint orCodes, andCodes;
GLuint paflagsAll;
POLYDATA *pd;
POLYARRAY *pa0 = (POLYARRAY *) _pa0;
POLYARRAY *pa;
PFN_XFORM pfnXform, pfnXformEye;
GLuint (FASTCALL *clipCheck)(__GLcontext *gc, POLYDATA *pd);
__GLmatrix *mInv;
GLboolean doEye;
__GLcolor scaledUserColor;
GLuint paFlags;
DWORD dwOldMode;
__GL_SETUP();
ASSERTOPENGL(sizeof(POLYDATA) == 128,
"POLYDATA size mismatch with PD_OFFSET\n");
// Force FP exceptions to be masked on x86 because some of our
// rendering code can produce FP exceptions
X86_MASK_EXCEPTIONS(dwOldMode);
// There are 3 possible begin modes. If we are in the begin/end bracket,
// it is __GL_IN_BEGIN. If we are not in the begin/end bracket, it is either
// __GL_NOT_IN_BEGIN or __GL_NEED_VALIDATE.
// Validation should only be done inside the display lock!
ASSERTOPENGL(gc->beginMode != __GL_IN_BEGIN, "bad beginMode!");
if (gc->beginMode == __GL_NEED_VALIDATE)
(*gc->procs.validate)(gc);
gc->beginMode = __GL_IN_BEGIN;
// Initialize variables.
enables = gc->state.enables.general;
// We need to save a copy of paNeeds since we may modify the
// copy in the gc:
paNeeds = paNeedsSaved = gc->vertex.paNeeds;
paflagsAll = 0;
#if 0
// This is tricky to do in a DrawPolyArray chain.
// We would have to fix up the chain and restore color pointers correctly!
//
// If no vertex is given and there are no attribute changes, we are done.
// We need to close previously decomposed line loop or polygon even if
// there are no attribute changes.
if (pa->pd0 == pa->pdNextVertex)
{
if (!pa->pd0->flags)
{
if (pa->primType == GL_POLYGON || pa->primType == GL_LINE_LOOP)
{
if (!(pa->flags & (POLYARRAY_OTHER_COLOR|POLYARRAY_PARTIAL_BEGIN)))
goto drawpolyarray_exit;
}
else
{
if (!(pa->flags & POLYARRAY_OTHER_COLOR))
goto drawpolyarray_exit;
}
}
}
#endif
// ---------------------------------------------------------
// Update final current values and initialize current values at index 0
// if not given. Material changes are updated later.
paFlags = 0;
if (!gc->modes.colorIndexMode) {
__GL_SCALE_AND_CHECK_CLAMP_R(scaledUserColor.r, gc, paFlags, gc->state.current.userColor.r);
__GL_SCALE_AND_CHECK_CLAMP_G(scaledUserColor.g, gc, paFlags, gc->state.current.userColor.g);
__GL_SCALE_AND_CHECK_CLAMP_B(scaledUserColor.b, gc, paFlags, gc->state.current.userColor.b);
__GL_SCALE_AND_CHECK_CLAMP_A(scaledUserColor.a, gc, paFlags, gc->state.current.userColor.a);
} else {
__GL_CHECK_CLAMP_CI(scaledUserColor.r, gc, paFlags, gc->state.current.userColorIndex);
}
for (pa = pa0; pa; pa = pa->paNext)
{
POLYDATA *pd0;
pd0 = pa->pd0;
if (gc->modes.colorIndexMode)
{
// CI mode.
// Update final current RGBA color incase one is given.
if (pa->flags & POLYARRAY_OTHER_COLOR)
gc->state.current.userColor = pa->otherColor;
// Update final current CI color.
if (!(pd0->flags & POLYDATA_COLOR_VALID))
{
pd0->flags |= POLYDATA_COLOR_VALID;
pd0->colors[0].r = gc->state.current.userColorIndex;
pa->flags |= paFlags;
}
gc->state.current.userColorIndex = pa->pdCurColor->colors[0].r;
paFlags = (pa->flags & POLYARRAY_CLAMP_COLOR);
}
else
{
// RGBA mode.
// Update final current CI color in case one is given.
if (pa->flags & POLYARRAY_OTHER_COLOR)
gc->state.current.userColorIndex = pa->otherColor.r;
// Update final current RGBA color.
if (!(pd0->flags & POLYDATA_COLOR_VALID))
{
pd0->flags |= POLYDATA_COLOR_VALID;
pd0->colors[0] = scaledUserColor;
pa->flags |= paFlags;
}
scaledUserColor = pa->pdCurColor->colors[0];
paFlags = (pa->flags & POLYARRAY_CLAMP_COLOR);
}
// Update final current normal.
if (!(pd0->flags & POLYDATA_NORMAL_VALID))
{
pd0->flags |= POLYDATA_NORMAL_VALID;
// can also be pd0->normal = gc->state.current.normal!
pd0->normal.x = gc->state.current.normal.x;
pd0->normal.y = gc->state.current.normal.y;
pd0->normal.z = gc->state.current.normal.z;
}
gc->state.current.normal.x = pa->pdCurNormal->normal.x;
gc->state.current.normal.y = pa->pdCurNormal->normal.y;
gc->state.current.normal.z = pa->pdCurNormal->normal.z;
// Update final current texture coordinates.
if (!(pd0->flags & POLYDATA_TEXTURE_VALID))
{
pd0->flags |= POLYDATA_TEXTURE_VALID;
pd0->texture = gc->state.current.texture;
if (__GL_FLOAT_COMPARE_PONE(pd0->texture.w, !=))
pa->flags |= POLYARRAY_TEXTURE4;
else if (__GL_FLOAT_NEZ(pd0->texture.z))
pa->flags |= POLYARRAY_TEXTURE3;
else if (__GL_FLOAT_NEZ(pd0->texture.y))
pa->flags |= POLYARRAY_TEXTURE2;
else
pa->flags |= POLYARRAY_TEXTURE1;
}
gc->state.current.texture = pa->pdCurTexture->texture;
// Update the texture key for hardware accelaration:
pa->textureKey = gc->textureKey;
// Update final current edge flag.
if (!(pd0->flags & POLYDATA_EDGEFLAG_VALID))
{
if (gc->state.current.edgeTag)
pd0->flags |= POLYDATA_EDGEFLAG_VALID | POLYDATA_EDGEFLAG_BOUNDARY;
else
pd0->flags |= POLYDATA_EDGEFLAG_VALID;
}
gc->state.current.edgeTag = (GLboolean)
(pa->pdCurEdgeFlag->flags & POLYDATA_EDGEFLAG_BOUNDARY);
// Accumulate pa flags.
paflagsAll |= pa->flags;
}
// Store the normalized user color:
if (!gc->modes.colorIndexMode) {
gc->state.current.userColor.r = scaledUserColor.r * gc->oneOverRedVertexScale;
gc->state.current.userColor.g = scaledUserColor.g * gc->oneOverGreenVertexScale;
gc->state.current.userColor.b = scaledUserColor.b * gc->oneOverBlueVertexScale;
gc->state.current.userColor.a = scaledUserColor.a * gc->oneOverAlphaVertexScale;
}
// ---------------------------------------------------------
// Do evaluator.
if (paflagsAll & (POLYARRAY_EVALCOORD1 | POLYARRAY_EVALCOORD2 |
POLYARRAY_EVALPOINT1 | POLYARRAY_EVALPOINT2))
{
paflagsAll = 0; // recompute paflagsAll!
for (pa = pa0; pa; pa = pa->paNext)
{
if (pa->flags & (POLYARRAY_EVALCOORD1 | POLYARRAY_EVALCOORD2 |
POLYARRAY_EVALPOINT1 | POLYARRAY_EVALPOINT2))
// pdNextVertex may be changed by PolyArrayProcessEvaluator!
PolyArrayProcessEvaluator(gc, pa);
paflagsAll |= pa->flags;
}
}
//
// Get the modeling matrix:
//
trMV = gc->transform.modelView;
// ---------------------------------------------------------
// Initialize the normal matrix:
// Normals are not needed after color assignment and texture generation!
//
// IN: normal matrix
// OUT: normal natrix (processed)
if (paNeeds & PANEEDS_NORMAL)
{
if (trMV->updateInverse)
__glComputeInverseTranspose(gc, trMV);
gc->mInv = mInv = &trMV->inverseTranspose;
}
#if DBG
else
gc->mInv = mInv = (__GLmatrix *) -1;
#endif
// ---------------------------------------------------------
// Process texture coordinates. We need to do this while we still have
// valid object coordinate data. If we need normals to perform the texture
// generation, we also transform the normals.
//
// Texture coordinates are modified in place.
//
// IN: texture, obj, (eye), normal
// OUT: texture, (eye)
if (paNeeds & PANEEDS_TEXCOORD)
{
if ((gc->procs.paCalcTexture == PolyArrayCalcTexture) &&
(gc->transform.texture->matrix.matrixType == __GL_MT_IDENTITY)) {
for (pa = pa0; pa; pa = pa->paNext)
{
PERF_CHECK(!(pa->flags & (POLYARRAY_TEXTURE3 | POLYARRAY_TEXTURE4)),
"Uses r, q texture coordinates!\n");
// If all incoming vertices have valid texcoords, and texture
// matrix is identity, and texgen is disabled, we are done.
if ((pa->flags & POLYARRAY_SAME_POLYDATA_TYPE)
&& (pa->pdCurTexture != pa->pd0)
// Need to test 2nd vertex because pdCurTexture may have been
// advanced as a result of combining TexCoord command after End
&& ((pa->pd0 + 1)->flags & POLYDATA_TEXTURE_VALID))
;
else
PolyArrayCalcTexture(gc, pa);
}
} else {
for (pa = pa0; pa; pa = pa->paNext)
{
PERF_CHECK(!(pa->flags & (POLYARRAY_TEXTURE3 | POLYARRAY_TEXTURE4)),
"Uses r, q texture coordinates!\n");
if (paNeeds & PANEEDS_NORMAL) {
POLYDATA *pdLastNormal;
pdLastNormal = pa->pdCurNormal;
for (pd = pa->pd0; pd <= pdLastNormal; pd++)
{
if (pd->flags & POLYDATA_NORMAL_VALID)
{
(*mInv->xf3)(&pd->normal, &pd->normal.x, mInv);
if (enables & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
}
}
(*gc->procs.paCalcTexture)(gc, pa);
}
gc->vertex.paNeeds &= ~PANEEDS_NORMAL;
paNeeds = gc->vertex.paNeeds;
}
}
//
// Process the eye coordinate if:
// user clip planes are enabled
// we're processing RASTERPOS
// we have slow lighting which needs the eye coordinate
//
// We need to process the eye coordinate here because the
// object coordinate gets trashed by the initial obj->clip
// transform.
//
//
//
clipCheck = gc->procs.paClipCheck;
// Compute eye coord first
// We need eye coordinates to do user clip plane clipping
if ((clipCheck == PAClipCheckAll) ||
(pa0->flags & POLYARRAY_RASTERPOS) ||
(gc->procs.paCalcColor == PolyArrayCalcCIColor) ||
(gc->procs.paCalcColor == PolyArrayCalcRGBColor) ||
(enables & __GL_FOG_ENABLE && gc->renderMode == GL_RENDER))
{
mEye = &trMV->matrix;
if (paflagsAll & POLYARRAY_VERTEX4)
pfnXformEye = mEye->xf4;
else if (paflagsAll & POLYARRAY_VERTEX3)
pfnXformEye = mEye->xf3;
else
pfnXformEye = mEye->xf2;
doEye = TRUE;
} else
doEye = FALSE;
// If any incoming coords contains w coord, use xf4.
m = &trMV->mvp;
if (paflagsAll & POLYARRAY_VERTEX4)
pfnXform = m->xf4;
else if (paflagsAll & POLYARRAY_VERTEX3)
pfnXform = m->xf3;
else
pfnXform = m->xf2;
// ---------------------------------------------------------
// Do transform, color, and lighting calculations.
//
// This is the heart of the rendering pipeline, so we try
// to do as many operations as possible while touching the
// least amount of memory to reduce cache affects.
//
// ---------------------------------------------------------
for (pa = pa0; pa; pa = pa->paNext)
{
POLYDATA *pdLast;
pdLast = pa->pdNextVertex - 1;
// ---------------------------------------------------------
// Process the eye coordinate if we will need it in the
// pipeline and haven't yet processed it in texture generation.
// We have to do this before we trash the object coord in the
// next phase.
//
// IN: obj
// OUT: eye
if (doEye && !(pa->flags & POLYARRAY_EYE_PROCESSED)) {
pa->flags |= POLYARRAY_EYE_PROCESSED;
if (mEye->matrixType == __GL_MT_IDENTITY) {
for (pd = pa->pd0; pd <= pdLast; pd++)
pd->eye = pd->obj;
} else {
for (pd = pa->pd0; pd <= pdLast; pd++)
(*pfnXformEye)(&pd->eye, (__GLfloat *) &pd->obj, mEye);
}
}
// ---------------------------------------------------------
// Process the object coordinate. This generates the clip
// and window coordinates, along with the clip codes.
//
// IN: obj (destroyed)
// OUT: clip, window
orCodes = 0; // accumulate all clip codes
#ifdef POLYARRAY_AND_CLIPCODES
andCodes = (GLuint) -1;
#endif
if (clipCheck != PAClipCheckFrustum2D)
{
if (m->matrixType != __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
(*pfnXform)(&pd->clip, (__GLfloat *) &pd->obj, m);
pd->clipCode = (*clipCheck)(gc, pd);
orCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
andCodes &= pd->clipCode;
#endif
}
}
else
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
// pd->clip = pd->obj;
ASSERTOPENGL(&pd->clip == &pd->obj, "bad clip offset\n");
pd->clipCode = (*clipCheck)(gc, pd);
orCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
andCodes &= pd->clipCode;
#endif
}
}
}
else
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (m->matrixType == __GL_MT_IDENTITY)
{
// pd->clip = pd->obj;
ASSERTOPENGL(&pd->clip == &pd->obj, "bad clip offset\n");
}
else
(*pfnXform)(&pd->clip, (__GLfloat *) &pd->obj, m);
if (pd->flags & POLYDATA_VERTEX2)
pd->clipCode = PAClipCheckFrustum2D(gc, pd);
else
pd->clipCode = PAClipCheckFrustum(gc, pd);
orCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
andCodes &= pd->clipCode;
#endif
}
}
pa->orClipCodes = orCodes;
#ifdef POLYARRAY_AND_CLIPCODES
if (andCodes)
{
andCodes = PolyArrayCheckClippedPrimitive(gc, pa, andCodes);
// add POLYARRAY_REMOVE_PRIMITIVE flag
paflagsAll |= pa->flags;
}
pa->andClipCodes = andCodes;
#endif
// ---------------------------------------------------------
// Process colors and materials if we're not in selection and
// haven't been completely clipped out.
//
// IN: obj/eye, color (front), normal
// OUT: (normal), color (front and back)
if (!(pa->flags & POLYARRAY_REMOVE_PRIMITIVE) &&
!(paNeeds & PANEEDS_CLIP_ONLY))
{
if (!(enables & __GL_LIGHTING_ENABLE))
{
// Lighting is disabled.
// Clamp RGBA colors, mask color index values.
// Only front colors are computed, back colors are not needed.
if (paNeeds & PANEEDS_SKIP_LIGHTING)
{
// Note that when lighting calculation is skipped, we still need to
// fill in the colors field. Otherwise, the rasterization routines
// may get FP exceptions on invalid colors.
pa->flags |= POLYARRAY_SAME_COLOR_DATA;
(*gc->procs.paCalcColorSkip)(gc, pa, __GL_FRONTFACE);
}
else if (pa->flags & POLYARRAY_SAME_COLOR_DATA)
{
if (gc->modes.colorIndexMode)
PolyArrayPropagateSameIndex(gc, pa);
else
PolyArrayPropagateSameColor(gc, pa);
}
else if (gc->modes.colorIndexMode)
{
PolyArrayPropagateIndex(gc, pa);
}
else
{
PolyArrayPropagateColor(gc, pa);
}
} else {
// Lighting is enabled.
POLYDATA *pd1, *pd2, *pdN;
GLint face;
GLuint matMask;
GLboolean doFrontColor, doBackColor, doColor;
// Clear POLYARRAY_SAME_COLOR_DATA flag if lighting is enabled.
pa->flags &= ~POLYARRAY_SAME_COLOR_DATA;
pdN = pa->pdNextVertex;
// Needs only front color for points and lines.
// ASSERT_PRIMITIVE
if ((unsigned int) pa->primType <= GL_LINE_STRIP)
{
doFrontColor = GL_TRUE;
doBackColor = GL_FALSE;
}
else
{
doFrontColor = paNeeds & PANEEDS_FRONT_COLOR;
doBackColor = paNeeds & PANEEDS_BACK_COLOR;
}
// Process front and back colors in two passes.
// Do back colors first!
//!!! We can potentially optimize 2-sided lighting in the slow path by running
// through all vertices and look for color needs for each vertex!
// See RenderSmoothTriangle.
PERF_CHECK
(
!(doFrontColor && doBackColor),
"Two-sided lighting - need both colors!\n"
);
// ASSERT_FACE
// ASSERT_MATERIAL
for (face = 1,
matMask = POLYARRAY_MATERIAL_BACK,
doColor = doBackColor;
face >= 0;
face--,
matMask = POLYARRAY_MATERIAL_FRONT,
doColor = doFrontColor
)
{
POLYMATERIAL *pm;
if (!doColor)
continue;
// If color is not needed, fill in the colors field with default.
if (paNeeds & PANEEDS_SKIP_LIGHTING)
{
(*gc->procs.paCalcColorSkip)(gc, pa, face);
continue;
}
// Process color ranges that include no material changes (excluding color
// material) one at a time. Color material changes are handled in the
// color procs.
if (!(pa->flags & matMask))
{
// process the whole color array
(*gc->procs.paCalcColor)(gc, face, pa, pa->pd0, pdN - 1);
gc->vertex.paNeeds &= ~PANEEDS_NORMAL;
continue;
}
// There are material changes, we need to recompute material and light
// source machine values before processing the next color range.
// Each range below is given by [pd1, pd2-1].
//!!! it is possible to fix polyarraycalcrgbcolor to accept certain material!
pm = GLTEB_CLTPOLYMATERIAL();
// no need to do this material later
pa->flags &= ~matMask;
for (pd1 = pa->pd0; pd1 <= pdN; pd1 = pd2)
{
POLYDATA *pdColor, *pdNormal;
// Apply material changes to the current vertex.
// It also applies trailing material changes following
// the last vertex.
if (pd1->flags & matMask)
PAApplyMaterial(gc,
*(&pm->pdMaterial0[pd1 - pa->pdBuffer0].front + face),
face);
// If this is the trailing material change, we are done.
if (pd1 == pdN)
break;
// Find next vertex with material changes.
// We need to track current color and normal so that the
// next color range begins with valid color and normal.
// We cannot track current values on client side because
// we don't have initial current values when batching
// this function.
pdColor = pd1;
pdNormal = pd1;
for (pd2 = pd1 + 1; pd2 < pdN; pd2++)
{
// track current color
if (pd2->flags & POLYDATA_COLOR_VALID)
pdColor = pd2;
// track current normal
if (pd2->flags & POLYDATA_NORMAL_VALID)
pdNormal = pd2;
if (pd2->flags & matMask)
break;
}
// Update next vertex's current color and normal if not given.
// The paCalcColor proc assumes that the first vertex contains
// a valid current color and normal. We need to save the
// current values before they are modified by the color procs.
if (!(pd2->flags & POLYDATA_COLOR_VALID))
{
pd2->flags |= POLYDATA_COLOR_VALID;
pd2->colors[0] = pdColor->colors[0];
}
if (!(pd2->flags & POLYDATA_NORMAL_VALID))
{
pd2->flags |= POLYDATA_NORMAL_VALID;
pd2->normal.x = pdNormal->normal.x;
pd2->normal.y = pdNormal->normal.y;
pd2->normal.z = pdNormal->normal.z;
}
// Compute the colos range [pd1, pd2-1] that contains
// no material changes.
(*gc->procs.paCalcColor)(gc, face, pa, pd1, pd2-1);
} // for
gc->vertex.paNeeds &= ~PANEEDS_NORMAL;
} // for (faces)
gc->vertex.paNeeds = paNeeds;
} // lighting enabled
}
// Update material.
if (pa->flags & (POLYARRAY_MATERIAL_FRONT |
POLYARRAY_MATERIAL_BACK))
PolyArrayApplyMaterials(gc, pa);
} // end of transform, color, and lighting calculations.
// Restore the original paNeeds in the gc which may have been
// modified above:
gc->vertex.paNeeds = paNeedsSaved;
// ---------------------------------------------------------
// This is the end of the main pipeline loop. At this point,
// we need to take care of selection, removal of rejected
// primitives, cheap fog, and edge-flag processing.
// ---------------------------------------------------------
// In selection, we need only clip and window (and possibly eye values
// computed above.) At this point, we have already applied materials as well.
// but we still need to apply materials and colors.
if (paNeeds & PANEEDS_CLIP_ONLY)
goto drawpolyarray_render_primitives;
// If any of the andClipCodes is nonzero, we may be able to throw away
// some primitives.
#ifdef POLYARRAY_AND_CLIPCODES
if (paflagsAll & POLYARRAY_REMOVE_PRIMITIVE)
{
pa0 = PolyArrayRemoveClippedPrimitives(pa0);
// _pa0 = pa0;
if (!pa0)
goto drawpolyarray_apply_color;
}
#endif
// ---------------------------------------------------------
// Process cheap fog.
//
// IN: obj/eye, color
// OUT: eye, fog, color
// if this is changed, need to fix RasterPos's setup!
if (enables & __GL_FOG_ENABLE && gc->renderMode == GL_RENDER)
{
for (pa = pa0; pa; pa = pa->paNext)
{
// Note: the eye coordinate has already been computed.
if (gc->polygon.shader.modeFlags & __GL_SHADE_CHEAP_FOG)
{
// compute fog values
PolyArrayComputeFog(gc, pa);
// Apply fog if it is smooth shading and in render mode.
// In flat shading, cheap fogging is currently done at render procs
// we can probably do cheap fog in flat shading here but we will
// need to compute the provoking colors with z info correctly so
// we can interpolate in the clipping procs. It would require
// rewriting the clipping routines in so_clip.c too!
if (gc->polygon.shader.modeFlags & __GL_SHADE_SMOOTH_LIGHT)
(*gc->procs.paApplyCheapFog)(gc, pa);
}
else
{
PERF_CHECK(FALSE, "Uses slow fog\n");
}
}
}
// ---------------------------------------------------------
// Process edge flags.
//
// IN: edge
// OUT: edge (all vertices)
if (paNeeds & PANEEDS_EDGEFLAG)
{
for (pa = pa0; pa; pa = pa->paNext)
{
if (pa->primType == GL_TRIANGLES
|| pa->primType == GL_QUADS
|| pa->primType == GL_POLYGON)
{
// If all incoming vertices have valid edgeflags, we are done.
// When all polydata's are of the same type, there are 2 cases
// where edge flag processing can be skipped:
// 1. All edge flags were given.
// 2. No edge flag was given and the initial edge flag (i.e.
// current gc edge flag) is non boundary. In this case,
// all edge flags were set to non boundary in pd->flags
// initialization.
if ((pa->flags & POLYARRAY_SAME_POLYDATA_TYPE)
&& (((pa->pdCurEdgeFlag != pa->pd0) &&
// Need to test 2nd vertex because pdCurEdgeFlag may have been
// advanced as a result of combining EdgeFlag command after End
((pa->pd0 + 1)->flags & POLYDATA_EDGEFLAG_VALID))
|| !(pa->pd0->flags & POLYDATA_EDGEFLAG_BOUNDARY)))
;
else
PolyArrayProcessEdgeFlag(pa);
}
}
}
// ---------------------------------------------------------
// Process the primitives.
drawpolyarray_render_primitives:
// Skip the rest if this is a RasterPos
if (pa0->flags & POLYARRAY_RASTERPOS)
goto drawpolyarray_exit;
for (pa = pa0; pa; pa = pa->paNext)
{
ASSERTOPENGL(pa->primType >= GL_POINTS && pa->primType <= GL_POLYGON,
"DrawPolyArray: bad primitive type\n");
(*afnPolyArrayDraw[pa->primType])(gc, pa);
}
// ---------------------------------------------------------
// Update final light source machine.
// The user color was initialized above.
drawpolyarray_apply_color:
(*gc->procs.applyColor)(gc);
// ---------------------------------------------------------
// Flush the primitive chain.
#if 1
if (pa0)
glsrvFlushDrawPolyArray(pa0);
#endif
drawpolyarray_exit:
// Out of begin mode.
X86_RESTORE_MASK(dwOldMode);
ASSERTOPENGL(gc->beginMode == __GL_IN_BEGIN, "bad beginMode!");
gc->beginMode = __GL_NOT_IN_BEGIN;
return;
}
#ifdef POLYARRAY_AND_CLIPCODES
// Determine if a clipped primitive can be removed early.
// If the logical AND of vertex clip codes of a primitive is non-zero,
// the primitive is completely clipped and can be removed early.
// However, if a primitive is partially built, we may not be able to
// remove it yet to maintain connectivity between the partial primitives.
// By eliminating a primitive early, we save on lighting and other calculations.
//
// Set POLYARRAY_REMOVE_PRIMITIVE flag if the primitve can be removed early.
// Return new andCodes.
GLuint FASTCALL PolyArrayCheckClippedPrimitive(__GLcontext *gc, POLYARRAY *pa, GLuint andCodes)
{
ASSERTOPENGL(andCodes, "bad andCodes\n");
// Don't eliminate RasterPos
if (pa->flags & POLYARRAY_RASTERPOS)
return andCodes;
// If this is a partial begin, include previous clipcode.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
switch (pa->primType)
{
case GL_LINE_LOOP:
// previous vertex
andCodes &= gc->vertex.pdSaved[0].clipCode;
// loop vertex
if (!(pa->flags & POLYARRAY_PARTIAL_END))
andCodes &= gc->vertex.pdSaved[1].clipCode;
break;
case GL_POLYGON:
andCodes &= gc->vertex.pdSaved[2].clipCode;
// fall through
case GL_TRIANGLE_FAN:
case GL_TRIANGLE_STRIP:
case GL_QUAD_STRIP:
andCodes &= gc->vertex.pdSaved[1].clipCode;
// fall through
case GL_LINE_STRIP:
andCodes &= gc->vertex.pdSaved[0].clipCode;
break;
case GL_POINTS:
case GL_LINES:
case GL_TRIANGLES:
case GL_QUADS:
default:
break;
}
}
if (andCodes
&&
(
!(pa->flags & POLYARRAY_PARTIAL_END) ||
pa->primType == GL_POINTS ||
pa->primType == GL_LINES ||
pa->primType == GL_TRIANGLES ||
pa->primType == GL_QUADS
)
)
pa->flags |= POLYARRAY_REMOVE_PRIMITIVE;
// return new andCodes.
return andCodes;
}
// Remove completely clipped primitives from the polyarray chain.
POLYARRAY * FASTCALL PolyArrayRemoveClippedPrimitives(POLYARRAY *pa0)
{
POLYARRAY *pa, *paNext, *pa2First, *pa2Last;
// Eliminate the trivially clipped primitives and build a new pa chain.
pa2First = pa2Last = NULL;
for (pa = pa0; pa; pa = paNext)
{
// get next pa first
paNext = pa->paNext;
if (pa->flags & POLYARRAY_REMOVE_PRIMITIVE)
{
PolyArrayRestoreColorPointer(pa);
}
else
{
// add to the new pa chain
if (!pa2First)
pa2First = pa;
else
pa2Last->paNext = pa;
pa2Last = pa;
pa2Last->paNext = NULL;
}
}
// Return the new pa chain.
return pa2First;
}
#endif // POLYARRAY_AND_CLIPCODES
/******************************Public*Routine******************************\
* glsrvFlushDrawPolyArray
*
* The dispatch code in glsrvAttention links together the POLYARRAY data
* structures of consecutive glim_DrawPolyArray calls. The front end
* preprocessing of the vertices in each POLYARRAY is executed immediately
* in glim_DrawPolyArray (i.e., PolyArrayDrawXXX), but the actually back end
* rendering (PolyArrayRenderXXX) is delayed until the chain is broken (either
* by a non-DrawPolyArray call, the end of the batch, or a batch timeout).
*
* glsrvFlushDrawPolyArray is the function that is called to flush the
* chained POLYARRAYs by invoking the back end rendering code. The back end
* may be the generic software-only implementation or the MCD driver.
*
* History:
* 12-Feb-1996 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
// Poly array render routines.
// ASSERT_PRIMITIVE
PFN_POLYARRAYRENDER afnPolyArrayRender[] =
{
(PFN_POLYARRAYRENDER) PolyArrayRenderPoints,
(PFN_POLYARRAYRENDER) PolyArrayRenderLines,
(PFN_POLYARRAYRENDER) NULL, // line loop not required
(PFN_POLYARRAYRENDER) PolyArrayRenderLStrip,
(PFN_POLYARRAYRENDER) PolyArrayRenderTriangles,
(PFN_POLYARRAYRENDER) PolyArrayRenderTStrip,
(PFN_POLYARRAYRENDER) PolyArrayRenderTFan,
(PFN_POLYARRAYRENDER) PolyArrayRenderQuads,
(PFN_POLYARRAYRENDER) PolyArrayRenderQStrip,
(PFN_POLYARRAYRENDER) PolyArrayRenderPolygon,
};
void APIPRIVATE glsrvFlushDrawPolyArray(void *_paBegin)
{
POLYARRAY *paBegin = (POLYARRAY *)_paBegin;
POLYARRAY *pa, *paNext;
__GLGENcontext *gengc;
__GL_SETUP();
//#define FRONT_END_ONLY 1
#if FRONT_END_ONLY
if (paBegin)
{
for (pa = paNext = paBegin; pa = paNext; )
{
ASSERTOPENGL(pa->primType >= GL_POINTS &&
pa->primType <= GL_POLYGON,
"DrawPolyArray: bad primitive type\n");
// Get next pointer first!
paNext = pa->paNext;
// Restore color pointer in the vertex buffer!
PolyArrayRestoreColorPointer(pa);
}
}
return;
#endif
gengc = (__GLGENcontext *) gc;
#ifdef _MCD_
#if DBG
if (gengc->pMcdState && !(glDebugFlags & GLDEBUG_DISABLEPRIM) &&
(gc->renderMode == GL_RENDER))
#else
if ((gengc->pMcdState) && (gc->renderMode == GL_RENDER))
#endif
{
POLYARRAY *paEnd;
// Let the MCD driver have first crack. If the MCD processes
// the entire batch, then it will return NULL. Otherwise, it
// will return a pointer to a chain of unprocessed POLYARRAYs.
paEnd = GenMcdDrawPrim(gengc, paBegin);
// Restore color pointer in the vertex buffer (for the POLYARRAYs
// that have been processed by MCD; leave the unprocessed ones alone).
//
// If the driver is using DMA, it must do the reset. If not DMA,
// we will do it for the driver.
if (!(McdDriverInfo.drvMemFlags & MCDRV_MEM_DMA))
{
for (pa = paBegin; pa != paEnd; pa = paNext)
{
paNext = pa->paNext;
PolyArrayRestoreColorPointer(pa);
}
}
else
{
// With DMA, the driver must either process the entire batch
// or reject the entire batch.
//
// Therefore, if GenMcdDrawPrim returns success (paEnd == NULL),
// the POLYARRAY is being sent via DMA to the driver and we
// need to switch to the other buffer. Otherwise, we need to
// drop down into the software implementation below.
if (!paEnd)
{
GenMcdSwapBatch(gengc);
}
}
// If able, let generic handle unprocessed POLYARRAYs (if any).
if (gengc->flags & GENGC_GENERIC_COMPATIBLE_FORMAT)
{
paBegin = paEnd;
}
else
{
// Generic cannot be used, so we must abandon the rest of the batch.
// Must reset the color pointers in the remainder of the batch.
for (pa = paEnd; pa; pa = paNext)
{
paNext = pa->paNext;
PolyArrayRestoreColorPointer(pa);
}
paBegin = (POLYARRAY *) NULL;
__glSetError(GL_OUT_OF_MEMORY);
}
}
if (paBegin)
#endif
{
for (pa = paNext = paBegin; pa = paNext; )
{
ASSERTOPENGL(pa->primType >= GL_POINTS &&
pa->primType <= GL_POLYGON,
"DrawPolyArray: bad primitive type\n");
if (pa->flags & POLYARRAY_RENDER_PRIMITIVE)
(*afnPolyArrayRender[pa->primType])(gc, pa);
// Get next pointer first!
paNext = pa->paNext;
// Restore color pointer in the vertex buffer!
PolyArrayRestoreColorPointer(pa);
}
}
}
/****************************************************************************/
// Restore color pointer in the vertex buffer!
// However, don't restore the color pointer if it is a RasterPos call.
GLvoid FASTCALL PolyArrayRestoreColorPointer(POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
ASSERTOPENGL(!(pa->flags & POLYARRAY_RASTERPOS), "RasterPos unexpected\n");
// See also glsbResetBuffers.
// Reset color pointer in output index array
if (pa->aIndices)
{
ASSERTOPENGL((POLYDATA *) pa->aIndices >= pa->pdBuffer0 &&
(POLYDATA *) pa->aIndices <= pa->pdBufferMax,
"bad index map pointer\n");
pdLast = (POLYDATA *) (pa->aIndices + pa->nIndices);
for (pd = (POLYDATA *) pa->aIndices; pd < pdLast; pd++)
pd->color = &pd->colors[__GL_FRONTFACE];
ASSERTOPENGL(pd >= pa->pdBuffer0 &&
pd <= pa->pdBufferMax + 1,
"bad polyarray pointer\n");
}
// Reset color pointer in the POLYARRAY structure last!
ASSERTOPENGL((POLYDATA *) pa >= pa->pdBuffer0 &&
(POLYDATA *) pa <= pa->pdBufferMax,
"bad polyarray pointer\n");
((POLYDATA *) pa)->color = &((POLYDATA *) pa)->colors[__GL_FRONTFACE];
}
/****************************************************************************/
// Compute generic fog value for the poly array.
//
// IN: eye
// OUT: fog
void FASTCALL PolyArrayComputeFog(__GLcontext *gc, POLYARRAY *pa)
{
__GLfloat density, density2neg, end, oneOverEMinusS;
POLYDATA *pd, *pdLast;
ASSERTOPENGL(pa->flags & POLYARRAY_EYE_PROCESSED, "need eye\n");
pdLast = pa->pdNextVertex-1;
switch (gc->state.fog.mode)
{
case GL_EXP:
PERF_CHECK(FALSE, "Uses GL_EXP fog\n");
density = gc->state.fog.density;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat eyeZ;
pd->flags |= POLYDATA_FOG_VALID; // used by clipping code!
eyeZ = pd->eye.z;
if (__GL_FLOAT_LTZ(eyeZ))
pd->fog = __GL_POWF(__glE, density * eyeZ);
else
pd->fog = __GL_POWF(__glE, -density * eyeZ);
// clamp the fog value to [0.0,1.0]
if (pd->fog > __glOne)
pd->fog = __glOne;
}
break;
case GL_EXP2:
PERF_CHECK(FALSE, "Uses GL_EXP2 fog\n");
density2neg = gc->state.fog.density2neg;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat eyeZ;
pd->flags |= POLYDATA_FOG_VALID;
eyeZ = pd->eye.z;
pd->fog = __GL_POWF(__glE, density2neg * eyeZ * eyeZ);
// clamp the fog value to [0.0,1.0]
if (pd->fog > __glOne)
pd->fog = __glOne;
}
break;
case GL_LINEAR:
end = gc->state.fog.end;
oneOverEMinusS = gc->state.fog.oneOverEMinusS;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat eyeZ;
pd->flags |= POLYDATA_FOG_VALID;
eyeZ = pd->eye.z;
if (__GL_FLOAT_LTZ(eyeZ))
pd->fog = (end + eyeZ) * oneOverEMinusS;
else
pd->fog = (end - eyeZ) * oneOverEMinusS;
// clamp the fog value here
if (__GL_FLOAT_LTZ(pd->fog))
pd->fog = __glZero;
else if (__GL_FLOAT_COMPARE_PONE(pd->fog, >))
pd->fog = __glOne;
}
break;
}
}
// Apply cheap fog to RGB colors.
//
// IN: fog, color (front/back)
// OUT: color (front/back)
void FASTCALL PolyArrayCheapFogRGBColor(__GLcontext *gc, POLYARRAY *pa)
{
__GLfloat fogColorR, fogColorG, fogColorB;
POLYDATA *pd, *pdLast;
GLboolean bGrayFog;
GLboolean doFrontColor, doBackColor;
if (!(gc->state.enables.general & __GL_LIGHTING_ENABLE))
{
ASSERTOPENGL(!(gc->vertex.paNeeds & PANEEDS_BACK_COLOR),
"no back color needed when lighting is disabled\n");
}
// ASSERT_PRIMITIVE
if ((unsigned int) pa->primType <= GL_LINE_STRIP)
{
doFrontColor = GL_TRUE;
doBackColor = GL_FALSE;
}
else
{
doFrontColor = gc->vertex.paNeeds & PANEEDS_FRONT_COLOR;
doBackColor = gc->vertex.paNeeds & PANEEDS_BACK_COLOR;
}
pdLast = pa->pdNextVertex-1;
fogColorR = gc->state.fog.color.r;
fogColorG = gc->state.fog.color.g;
fogColorB = gc->state.fog.color.b;
bGrayFog = (gc->state.fog.flags & __GL_FOG_GRAY_RGB) ? GL_TRUE : GL_FALSE;
PERF_CHECK(bGrayFog, "Uses non gray fog color\n");
if (bGrayFog)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat fog, oneMinusFog, delta;
/* Get the vertex fog value */
fog = pd->fog;
oneMinusFog = __glOne - fog;
delta = oneMinusFog * fogColorR;
/* Now whack the color */
if (doFrontColor)
{
pd->colors[0].r = fog * pd->colors[0].r + delta;
pd->colors[0].g = fog * pd->colors[0].g + delta;
pd->colors[0].b = fog * pd->colors[0].b + delta;
}
if (doBackColor)
{
pd->colors[1].r = fog * pd->colors[1].r + delta;
pd->colors[1].g = fog * pd->colors[1].g + delta;
pd->colors[1].b = fog * pd->colors[1].b + delta;
}
}
}
else
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat fog, oneMinusFog;
/* Get the vertex fog value */
fog = pd->fog;
oneMinusFog = __glOne - fog;
/* Now whack the color */
if (doFrontColor)
{
pd->colors[0].r = fog * pd->colors[0].r + oneMinusFog * fogColorR;
pd->colors[0].g = fog * pd->colors[0].g + oneMinusFog * fogColorG;
pd->colors[0].b = fog * pd->colors[0].b + oneMinusFog * fogColorB;
}
if (doBackColor)
{
pd->colors[1].r = fog * pd->colors[1].r + oneMinusFog * fogColorR;
pd->colors[1].g = fog * pd->colors[1].g + oneMinusFog * fogColorG;
pd->colors[1].b = fog * pd->colors[1].b + oneMinusFog * fogColorB;
}
}
}
}
// Apply cheap fog to color index values.
//
// IN: fog, color.r (front/back)
// OUT: color.r (front/back)
void FASTCALL PolyArrayCheapFogCIColor(__GLcontext *gc, POLYARRAY *pa)
{
__GLfloat maxR, fogIndex;
POLYDATA *pd, *pdLast;
GLboolean doFrontColor, doBackColor;
if (!(gc->state.enables.general & __GL_LIGHTING_ENABLE))
{
ASSERTOPENGL(!(gc->vertex.paNeeds & PANEEDS_BACK_COLOR),
"no back color needed when lighting is disabled\n");
}
// ASSERT_PRIMITIVE
if ((unsigned int) pa->primType <= GL_LINE_STRIP)
{
doFrontColor = GL_TRUE;
doBackColor = GL_FALSE;
}
else
{
doFrontColor = gc->vertex.paNeeds & PANEEDS_FRONT_COLOR;
doBackColor = gc->vertex.paNeeds & PANEEDS_BACK_COLOR;
}
fogIndex = gc->state.fog.index;
maxR = (1 << gc->modes.indexBits) - 1;
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
__GLfloat fogDelta;
fogDelta = (__glOne - pd->fog) * fogIndex;
/* Now whack the color */
if (doFrontColor)
{
pd->colors[0].r = pd->colors[0].r + fogDelta;
if (pd->colors[0].r > maxR)
pd->colors[0].r = maxR;
}
if (doBackColor)
{
pd->colors[1].r = pd->colors[1].r + fogDelta;
if (pd->colors[1].r > maxR)
pd->colors[1].r = maxR;
}
}
}
/****************************************************************************/
void FASTCALL PADoEval1(__GLcontext *gc, POLYARRAY *pa, POLYDATA *pd)
{
__GLevaluator1 *eval = gc->eval.eval1;
__GLfloat **evalData = gc->eval.eval1Data;
__GLevaluatorMachine em = gc->eval;
__GLfloat u;
// Find u.
if (pd->flags & POLYDATA_EVALCOORD1)
{
u = pd->obj.x;
}
else
{
__GLevaluatorGrid *gu;
__GLfloat du;
GLint i;
ASSERTOPENGL(pd->flags & POLYDATA_EVALPOINT1, "bad pd flags\n");
i = *(GLint *) &pd->obj;
gu = &gc->state.evaluator.u1;
du = (gu->finish - gu->start)/(__GLfloat)gu->n;/*XXX cache? */
u = (i == gu->n) ? gu->finish : (gu->start + i * du);
}
// Evaluated color, index, normal and texture coords are ignored in selection
if (gc->renderMode != GL_SELECT)
{
if (gc->modes.colorIndexMode)
{
if (!(gc->state.enables.general & __GL_LIGHTING_ENABLE))
{
if (gc->state.enables.eval1 & __GL_MAP1_INDEX_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_I], &pd->colors[0].r,
evalData[__GL_I]);
__GL_CHECK_CLAMP_CI(pd->colors[0].r, gc, pa->flags, pd->colors[0].r);
pd->flags |= POLYDATA_COLOR_VALID;
}
}
}
else
{
if (gc->state.enables.eval1 & __GL_MAP1_COLOR_4_ENABLE)
{
// NOTE: In OpenGL 1.0, color material does not apply to evaluated colors.
// In OpenGL 1.1, this behavior was changed. This (1.1) code assumes that
// ColorMaterial applies to evaluated colors to simplify the graphics pipeline.
// Otherwise, the evaluated colors have no effect when lighting is enabled.
DoDomain1(&em, u, &eval[__GL_C4], &pd->colors[0].r,
evalData[__GL_C4]);
__GL_SCALE_AND_CHECK_CLAMP_R(pd->colors[0].r, gc, pa->flags, pd->colors[0].r);
__GL_SCALE_AND_CHECK_CLAMP_G(pd->colors[0].g, gc, pa->flags, pd->colors[0].g);
__GL_SCALE_AND_CHECK_CLAMP_B(pd->colors[0].b, gc, pa->flags, pd->colors[0].b);
__GL_SCALE_AND_CHECK_CLAMP_A(pd->colors[0].a, gc, pa->flags, pd->colors[0].a);
pd->flags |= POLYDATA_COLOR_VALID;
}
if (gc->state.enables.eval1 & __GL_MAP1_TEXTURE_COORD_4_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_T4], &pd->texture.x,
evalData[__GL_T4]);
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE4;
}
else if (gc->state.enables.eval1 & __GL_MAP1_TEXTURE_COORD_3_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_T3], &pd->texture.x,
evalData[__GL_T3]);
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE3;
}
else if (gc->state.enables.eval1 & __GL_MAP1_TEXTURE_COORD_2_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_T2], &pd->texture.x,
evalData[__GL_T2]);
pd->texture.z = __glZero;
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE2;
}
else if (gc->state.enables.eval1 & __GL_MAP1_TEXTURE_COORD_1_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_T1], &pd->texture.x,
evalData[__GL_T1]);
pd->texture.y = __glZero;
pd->texture.z = __glZero;
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE1;
}
}
if (gc->state.enables.eval1 & __GL_MAP1_NORMAL_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_N3], &pd->normal.x,
evalData[__GL_N3]);
pd->flags |= POLYDATA_NORMAL_VALID;
}
}
if (gc->state.enables.eval1 & __GL_MAP1_VERTEX_4_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_V4], &pd->obj.x,
evalData[__GL_V4]);
pd->flags |= POLYDATA_VERTEX4;
pa->flags |= POLYARRAY_VERTEX4;
}
else if (gc->state.enables.eval1 & __GL_MAP1_VERTEX_3_ENABLE)
{
DoDomain1(&em, u, &eval[__GL_V3], &pd->obj.x,
evalData[__GL_V3]);
pd->obj.w = __glOne;
pd->flags |= POLYDATA_VERTEX3;
pa->flags |= POLYARRAY_VERTEX3;
}
}
// Compute the color, texture, normal, vertex based upon u and v.
//
// NOTE: This function is called by the client side EvalMesh2 functions.
// If you modify it, make sure that you modify the callers too!
void FASTCALL PADoEval2(__GLcontext *gc, POLYARRAY *pa, POLYDATA *pd, BOOL bScaleColor)
{
__GLevaluator2 *eval = gc->eval.eval2;
__GLfloat **evalData = gc->eval.eval2Data;
__GLevaluatorMachine em = gc->eval;
__GLfloat u, v;
// Find u and v.
if (pd->flags & POLYDATA_EVALCOORD2)
{
u = pd->obj.x;
v = pd->obj.y;
}
else
{
__GLevaluatorGrid *gu;
__GLevaluatorGrid *gv;
__GLfloat du;
__GLfloat dv;
GLint i, j, *pi;
ASSERTOPENGL(pd->flags & POLYDATA_EVALPOINT2, "bad pd flags\n");
pi = (GLint *) &pd->obj;
i = pi[0];
j = pi[1];
gu = &gc->state.evaluator.u2;
gv = &gc->state.evaluator.v2;
du = (gu->finish - gu->start)/(__GLfloat)gu->n;/*XXX cache? */
dv = (gv->finish - gv->start)/(__GLfloat)gv->n;/*XXX cache? */
u = (i == gu->n) ? gu->finish : (gu->start + i * du);
v = (j == gv->n) ? gv->finish : (gv->start + j * dv);
}
// Evaluated colors, normals and texture coords are ignored in selection.
if (gc->renderMode == GL_SELECT)
{
if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_4_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_V4], &pd->obj.x,
evalData[__GL_V4]);
pd->flags |= POLYDATA_VERTEX4;
pa->flags |= POLYARRAY_VERTEX4;
}
else if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_3_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_V3], &pd->obj.x,
evalData[__GL_V3]);
pd->obj.w = __glOne;
pd->flags |= POLYDATA_VERTEX3;
pa->flags |= POLYARRAY_VERTEX3;
}
return;
}
if (gc->state.enables.general & __GL_AUTO_NORMAL_ENABLE)
{
if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_4_ENABLE)
{
__GLfloat du[4];
__GLfloat dv[4];
DoDomain2WithDerivs(&em, u, v, &eval[__GL_V4], &pd->obj.x, du, dv,
evalData[__GL_V4]);
ComputeFirstPartials(&pd->obj.x, du, dv);
ComputeNormal2(gc, &pd->normal.x, du, dv);
pd->flags |= POLYDATA_NORMAL_VALID;
pd->flags |= POLYDATA_VERTEX4;
pa->flags |= POLYARRAY_VERTEX4;
}
else if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_3_ENABLE)
{
__GLfloat du[3];
__GLfloat dv[3];
DoDomain2WithDerivs(&em, u, v, &eval[__GL_V3], &pd->obj.x, du, dv,
evalData[__GL_V3]);
ComputeNormal2(gc, &pd->normal.x, du, dv);
pd->obj.w = __glOne;
pd->flags |= POLYDATA_NORMAL_VALID;
pd->flags |= POLYDATA_VERTEX3;
pa->flags |= POLYARRAY_VERTEX3;
}
}
else
{
if (gc->state.enables.eval2 & __GL_MAP2_NORMAL_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_N3], &pd->normal.x,
evalData[__GL_N3]);
pd->flags |= POLYDATA_NORMAL_VALID;
}
if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_4_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_V4], &pd->obj.x,
evalData[__GL_V4]);
pd->flags |= POLYDATA_VERTEX4;
pa->flags |= POLYARRAY_VERTEX4;
}
else if (gc->state.enables.eval2 & __GL_MAP2_VERTEX_3_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_V3], &pd->obj.x,
evalData[__GL_V3]);
pd->obj.w = __glOne;
pd->flags |= POLYDATA_VERTEX3;
pa->flags |= POLYARRAY_VERTEX3;
}
}
if (gc->modes.colorIndexMode)
{
if (!(gc->state.enables.general & __GL_LIGHTING_ENABLE))
{
if (gc->state.enables.eval2 & __GL_MAP2_INDEX_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_I], &pd->colors[0].r,
evalData[__GL_I]);
__GL_CHECK_CLAMP_CI(pd->colors[0].r, gc, pa->flags, pd->colors[0].r);
pd->flags |= POLYDATA_COLOR_VALID;
}
}
}
else
{
if (gc->state.enables.eval2 & __GL_MAP2_COLOR_4_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_C4], &pd->colors[0].r,
evalData[__GL_C4]);
if (bScaleColor)
{
__GL_SCALE_AND_CHECK_CLAMP_R(pd->colors[0].r, gc, pa->flags, pd->colors[0].r);
__GL_SCALE_AND_CHECK_CLAMP_G(pd->colors[0].g, gc, pa->flags, pd->colors[0].g);
__GL_SCALE_AND_CHECK_CLAMP_B(pd->colors[0].b, gc, pa->flags, pd->colors[0].b);
__GL_SCALE_AND_CHECK_CLAMP_A(pd->colors[0].a, gc, pa->flags, pd->colors[0].a);
}
pd->flags |= POLYDATA_COLOR_VALID;
}
if (gc->state.enables.eval2 & __GL_MAP2_TEXTURE_COORD_4_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_T4], &pd->texture.x,
evalData[__GL_T4]);
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE4;
}
else if (gc->state.enables.eval2 & __GL_MAP2_TEXTURE_COORD_3_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_T3], &pd->texture.x,
evalData[__GL_T3]);
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE3;
}
else if (gc->state.enables.eval2 & __GL_MAP2_TEXTURE_COORD_2_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_T2], &pd->texture.x,
evalData[__GL_T2]);
pd->texture.z = __glZero;
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE2;
}
else if (gc->state.enables.eval2 & __GL_MAP2_TEXTURE_COORD_1_ENABLE)
{
DoDomain2(&em, u, v, &eval[__GL_T1], &pd->texture.x,
evalData[__GL_T1]);
pd->texture.y = __glZero;
pd->texture.z = __glZero;
pd->texture.w = __glOne;
pd->flags |= POLYDATA_TEXTURE_VALID;
pa->flags |= POLYARRAY_TEXTURE1;
}
}
}
// Fill in the evaluated values.
// DrawPolyArray should keep track of final current values because this
// function will overwrite them with evaluated values.
// The evaluated values do not modify current values.
//
// Note: The first vertex must have valid color, normal and texture!
void FASTCALL PolyArrayProcessEvaluator(__GLcontext *gc, POLYARRAY *pa)
{
POLYDATA *pd, *pdLast, *pdCur;
__GLcolor savedColor;
__GLcoord savedNormal, savedTexture;
GLboolean updateColor, updateNormal, updateTexture;
GLboolean doEval1, doEval2, doRemoveEval1, doRemoveEval2;
GLuint enablesEval1, enablesEval2;
GLuint pdFlagsEval;
GLboolean bSamePolyDataType;
ASSERTOPENGL(pa->flags & (POLYARRAY_EVALCOORD1 | POLYARRAY_EVALCOORD2 |
POLYARRAY_EVALPOINT1 | POLYARRAY_EVALPOINT2),
"no evaluator!\n");
ASSERTOPENGL(!(pa->flags & POLYARRAY_SAME_COLOR_DATA),
"POLYARRAY_SAME_COLOR_DATA unexpected in evaluators!\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_COLOR_VALID,
"need initial color value\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_NORMAL_VALID,
"need initial normal\n");
// Find out which attributes are modified by the evaluators.
pdLast = pa->pdNextVertex-1;
enablesEval1 = gc->state.enables.eval1;
enablesEval2 = gc->state.enables.eval2;
doEval1 = (pa->flags & (POLYARRAY_EVALCOORD1 | POLYARRAY_EVALPOINT1))
? GL_TRUE : GL_FALSE;
doEval2 = (pa->flags & (POLYARRAY_EVALCOORD2 | POLYARRAY_EVALPOINT2))
? GL_TRUE : GL_FALSE;
pdFlagsEval = pa->flags & (POLYARRAY_EVALCOORD1 | POLYARRAY_EVALCOORD2 |
POLYARRAY_EVALPOINT1 | POLYARRAY_EVALPOINT2);
bSamePolyDataType = GL_TRUE; // assume the polydata's are of same type
updateColor = GL_FALSE;
updateNormal = GL_FALSE;
updateTexture = GL_FALSE;
// Evaluated color, index, normal and texture coords are ignored in selection
if (gc->renderMode != GL_SELECT)
{
if (gc->modes.colorIndexMode)
{
if (!(gc->state.enables.general & __GL_LIGHTING_ENABLE))
{
if ((enablesEval1 & __GL_MAP1_INDEX_ENABLE) && doEval1
|| (enablesEval2 & __GL_MAP2_INDEX_ENABLE) && doEval2)
{
updateColor = GL_TRUE;
pa->pdCurColor = pdLast; // update to last vertex!
}
}
}
else
{
if ((enablesEval1 & __GL_MAP1_COLOR_4_ENABLE) && doEval1
|| (enablesEval2 & __GL_MAP2_COLOR_4_ENABLE) && doEval2)
{
updateColor = GL_TRUE;
pa->pdCurColor = pdLast; // update to last vertex!
}
if ((enablesEval1 & (__GL_MAP1_TEXTURE_COORD_1_ENABLE
| __GL_MAP1_TEXTURE_COORD_2_ENABLE
| __GL_MAP1_TEXTURE_COORD_3_ENABLE
| __GL_MAP1_TEXTURE_COORD_4_ENABLE)) && doEval1
|| (enablesEval2 & (__GL_MAP2_TEXTURE_COORD_1_ENABLE
| __GL_MAP2_TEXTURE_COORD_2_ENABLE
| __GL_MAP2_TEXTURE_COORD_3_ENABLE
| __GL_MAP2_TEXTURE_COORD_4_ENABLE)) && doEval2)
{
updateTexture = GL_TRUE;
pa->pdCurTexture = pdLast; // update to last vertex!
}
}
if ((enablesEval1 & __GL_MAP1_NORMAL_ENABLE) && doEval1
|| (gc->state.enables.general & __GL_AUTO_NORMAL_ENABLE
|| enablesEval2 & __GL_MAP2_NORMAL_ENABLE) && doEval2)
{
updateNormal = GL_TRUE;
pa->pdCurNormal = pdLast; // update to last vertex!
}
}
// If vertex map is not enabled, we need to propagate current values
// for all vertices and pack the poly array!
// The poly array code does not handle null entries.
//
// NOTE: To do this correctly, we need to propagate edge flags and materials
// too. Since this is likely an application bug, we will punt on updating
// these attributes.
doRemoveEval1 = GL_FALSE;
doRemoveEval2 = GL_FALSE;
if (doEval1 && !(enablesEval1 & (__GL_MAP1_VERTEX_3_ENABLE |
__GL_MAP1_VERTEX_4_ENABLE)))
doRemoveEval1 = GL_TRUE;
if (doEval2 && !(enablesEval2 & (__GL_MAP2_VERTEX_3_ENABLE |
__GL_MAP2_VERTEX_4_ENABLE)))
doRemoveEval2 = GL_TRUE;
if (doRemoveEval1 || doRemoveEval2)
{
updateColor = GL_TRUE;
updateTexture = GL_TRUE;
updateNormal = GL_TRUE;
}
for (pd = pa->pd0; pd <= pdLast; pd++)
{
// Check if all polydata's contain same eval type with no other attributes.
if (pd->flags != pdFlagsEval)
bSamePolyDataType = GL_FALSE;
// Need to propagate the current values for non evaluated vertices.
// Save the current values before they are modified by evaluators.
// works for color index too!
if (updateColor && pd->flags & POLYDATA_COLOR_VALID)
savedColor = pd->colors[0];
if (updateNormal && pd->flags & POLYDATA_NORMAL_VALID)
{
savedNormal.x = pd->normal.x;
savedNormal.y = pd->normal.y;
savedNormal.z = pd->normal.z;
}
if (updateTexture && pd->flags & POLYDATA_TEXTURE_VALID)
savedTexture = pd->texture;
if (pd->flags & (POLYDATA_EVALCOORD1 | POLYDATA_EVALPOINT1))
PADoEval1(gc, pa, pd);
else if (pd->flags & (POLYDATA_EVALCOORD2 | POLYDATA_EVALPOINT2))
PADoEval2(gc, pa, pd, TRUE);
else
{
// This vertex does not use evaluated values. Update its current values.
if (updateColor && !(pd->flags & POLYDATA_COLOR_VALID))
{
pd->flags |= POLYDATA_COLOR_VALID;
pd->colors[0] = savedColor;
}
if (updateNormal && !(pd->flags & POLYDATA_NORMAL_VALID))
{
pd->flags |= POLYDATA_NORMAL_VALID;
pd->normal.x = savedNormal.x;
pd->normal.y = savedNormal.y;
pd->normal.z = savedNormal.z;
}
if (updateTexture && !(pd->flags & POLYDATA_TEXTURE_VALID))
{
pd->flags |= POLYDATA_TEXTURE_VALID;
pd->texture = savedTexture;
}
}
}
// If the polyarray contain the same data (i.e. evaluators) type with
// no attribute changes, set the flag POLYARRAY_SAME_POLYDATA_TYPE.
#if 0
// This is now handled correctly in DPA.
// Make sure there is no trailing attribute changes.
if (pd->flags != 0)
bSamePolyDataType = GL_FALSE;
#endif
if (bSamePolyDataType)
pa->flags |= POLYARRAY_SAME_POLYDATA_TYPE;
// If vertex map is not enabled, we need to pack the poly array!
if (doRemoveEval1 || doRemoveEval2)
{
PERF_CHECK(FALSE,
"PolyArrayProcessEvaluator: vertex map not enabled!\n");
DBGPRINT("PolyArrayProcessEvaluator: vertex map not enabled!\n");
if (doRemoveEval1)
pa->flags &= ~(POLYARRAY_EVALCOORD1 | POLYARRAY_EVALPOINT1);
if (doRemoveEval2)
pa->flags &= ~(POLYARRAY_EVALCOORD2 | POLYARRAY_EVALPOINT2);
for (pd = pdCur = pa->pd0; pd <= pdLast; pd++)
{
if ((pd->flags & (POLYDATA_EVALCOORD1 | POLYDATA_EVALPOINT1))
&& doRemoveEval1)
{
// Need to propagate materials and edge flag!
// Ignore first edge flag because it may have been set by
// DrawPolyArray initialization code.
ASSERTOPENGL
(
(!(pd->flags & (POLYDATA_MATERIAL_FRONT |
POLYDATA_MATERIAL_BACK)))
&& (!(pd->flags & POLYDATA_EDGEFLAG_VALID) || pd == pa->pd0),
"PolyArrayProcessEvaluator: bad evaluator!\n"
);
continue;
}
if ((pd->flags & (POLYDATA_EVALCOORD2 | POLYDATA_EVALPOINT2))
&& doRemoveEval2)
{
// Need to propagate materials and edge flag!
// Ignore first edge flag because it may have been set by
// DrawPolyArray initialization code.
ASSERTOPENGL
(
(!(pd->flags & (POLYDATA_MATERIAL_FRONT |
POLYDATA_MATERIAL_BACK)))
&& (!(pd->flags & POLYDATA_EDGEFLAG_VALID) || pd == pa->pd0),
"PolyArrayProcessEvaluator: bad evaluator!\n"
);
continue;
}
PA_COPY_VERTEX(pdCur,pd);
pdCur++;
}
// update poly array
pa->pdNextVertex = pdCur;
if (pdCur != pa->pd0)
{
pa->pdCurColor =
pa->pdCurNormal =
pa->pdCurTexture = pdCur - 1;
}
else
{
pa->pdCurColor =
pa->pdCurNormal =
pa->pdCurTexture = pdCur;
}
pa->nIndices = pdCur - pa->pd0;
}
}
/****************************************************************************/
// Compute eye coordinates
//
// IN: obj
// OUT: eye
void FASTCALL PolyArrayProcessEye(__GLcontext *gc, POLYARRAY *pa)
{
__GLtransform *trMV;
__GLmatrix *m;
POLYDATA *pd, *pdLast;
if (pa->flags & POLYARRAY_EYE_PROCESSED)
return;
pa->flags |= POLYARRAY_EYE_PROCESSED;
trMV = gc->transform.modelView;
m = &trMV->matrix;
pdLast = pa->pdNextVertex-1;
// The primitive may contain a mix of vertex types (2,3,4)!
if (m->matrixType == __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
pd->eye = pd->obj;
}
else
{
PFN_XFORM pfnXform;
// If any incoming coords contains w coord, use xf4.
if (pa->flags & POLYARRAY_VERTEX4)
pfnXform = m->xf4;
else if (pa->flags & POLYARRAY_VERTEX3)
pfnXform = m->xf3;
else
pfnXform = m->xf2;
for (pd = pa->pd0; pd <= pdLast; pd++)
(*pfnXform)(&pd->eye, (__GLfloat *) &pd->obj, m);
}
}
/****************************************************************************/
// Process edge flags.
//
// IN: edge
// OUT: edge (all vertices)
void FASTCALL PolyArrayProcessEdgeFlag(POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
GLuint prevEdgeFlag;
PERF_CHECK(FALSE, "Uses edge flags!\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_EDGEFLAG_VALID,
"need initial edgeflag value\n");
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_EDGEFLAG_VALID)
prevEdgeFlag = pd->flags & (POLYDATA_EDGEFLAG_VALID | POLYDATA_EDGEFLAG_BOUNDARY);
else
pd->flags |= prevEdgeFlag;
}
}
/****************************************************************************/
// transform texture coordinates
// there is no generated texture coords.
// texture coordinates are modified in place
//
// IN: texture
// OUT: texture (all vertices are updated)
void FASTCALL PolyArrayCalcTexture(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
POLYDATA *pd, *pdLast;
PFN_XFORM xf;
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
m = &gc->transform.texture->matrix;
pdLast = pa->pdNextVertex-1;
if (m->matrixType == __GL_MT_IDENTITY)
{
// Identity texture xform. Incoming texcoord already has all s,t,q,r values.
for (pd = pa->pd0; pd <= pdLast; pd++)
if (!(pd->flags & POLYDATA_TEXTURE_VALID))
pd->texture = (pd-1)->texture;
}
else
{
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else if (pa->flags & POLYARRAY_TEXTURE2)
xf = m->xf2;
else
xf = m->xf1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
// Apply texture matrix
if (pd->flags & POLYDATA_TEXTURE_VALID)
(*xf)(&pd->texture, (__GLfloat *) &pd->texture, m);
else
pd->texture = (pd-1)->texture;
}
}
}
// Generate texture coordinates from object coordinates
// object linear texture generation
// s and t are enabled but r and q are disabled
// both s and t use the object linear mode
// both s and t have the SAME plane equation
// texture coordinates are modified in place
//
// IN: texture, obj
// OUT: texture (all vertices are updated)
void FASTCALL PolyArrayCalcObjectLizNearSameST(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
__GLcoord *cs, gen;
POLYDATA *pd, *pdLast;
PFN_XFORM xf;
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
cs = &gc->state.texture.s.objectPlaneEquation;
pdLast = pa->pdNextVertex-1;
m = &gc->transform.texture->matrix;
if (m->matrixType == __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_TEXTURE_VALID))
{
pd->texture.z = (pd-1)->texture.z;
pd->texture.w = (pd-1)->texture.w;
}
// both s and t have the SAME plane equation
pd->texture.x = cs->x * pd->obj.x + cs->y * pd->obj.y +
cs->z * pd->obj.z + cs->w * pd->obj.w;
pd->texture.y = pd->texture.x;
}
}
else
{
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else
xf = m->xf2; // at least 2 generated values
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_TEXTURE_VALID)
{
gen.z = pd->texture.z;
gen.w = pd->texture.w;
}
// both s and t have the SAME plane equation
gen.x = cs->x * pd->obj.x + cs->y * pd->obj.y +
cs->z * pd->obj.z + cs->w * pd->obj.w;
gen.y = gen.x;
// Finally, apply texture matrix
(*xf)(&pd->texture, (__GLfloat *) &gen, m);
}
}
}
// Generate texture coordinates from object coordinates
// object linear texture generation
// s and t are enabled but r and q are disabled
// both s and t use the object linear mode
// both s and t have DIFFERENT plane equations
// texture coordinates are modified in place
//
// IN: texture, obj
// OUT: texture (all vertices are updated)
void FASTCALL PolyArrayCalcObjectLizNear(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
__GLcoord *cs, *ct, gen;
POLYDATA *pd, *pdLast;
PFN_XFORM xf;
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
cs = &gc->state.texture.s.objectPlaneEquation;
ct = &gc->state.texture.t.objectPlaneEquation;
pdLast = pa->pdNextVertex-1;
m = &gc->transform.texture->matrix;
if (m->matrixType == __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_TEXTURE_VALID))
{
pd->texture.z = (pd-1)->texture.z;
pd->texture.w = (pd-1)->texture.w;
}
pd->texture.x = cs->x * pd->obj.x + cs->y * pd->obj.y +
cs->z * pd->obj.z + cs->w * pd->obj.w;
pd->texture.y = ct->x * pd->obj.x + ct->y * pd->obj.y +
ct->z * pd->obj.z + ct->w * pd->obj.w;
}
}
else
{
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else
xf = m->xf2; // at least 2 generated values
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_TEXTURE_VALID)
{
gen.z = pd->texture.z;
gen.w = pd->texture.w;
}
gen.x = cs->x * pd->obj.x + cs->y * pd->obj.y +
cs->z * pd->obj.z + cs->w * pd->obj.w;
gen.y = ct->x * pd->obj.x + ct->y * pd->obj.y +
ct->z * pd->obj.z + ct->w * pd->obj.w;
// Finally, apply texture matrix
(*xf)(&pd->texture, (__GLfloat *) &gen, m);
}
}
}
// Generate texture coordinates from eye coordinates
// eye linear texture generation
// s and t are enabled but r and q are disabled
// both s and t use the eye linear mode
// both s and t have SAME plane equations
// texture coordinates are modified in place
// we may be able to get away without computing eye coord!
//
// IN: texture; obj or eye
// OUT: texture and eye (all vertices are updated)
void FASTCALL PolyArrayCalcEyeLizNearSameST(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
__GLcoord *cs, gen;
POLYDATA *pd, *pdLast;
PFN_XFORM xf;
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
// Compute eye coord first
if (!(pa->flags & POLYARRAY_EYE_PROCESSED))
PolyArrayProcessEye(gc, pa);
cs = &gc->state.texture.s.eyePlaneEquation;
pdLast = pa->pdNextVertex-1;
m = &gc->transform.texture->matrix;
if (m->matrixType == __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_TEXTURE_VALID))
{
pd->texture.z = (pd-1)->texture.z;
pd->texture.w = (pd-1)->texture.w;
}
// both s and t have the SAME plane equation
pd->texture.x = cs->x * pd->eye.x + cs->y * pd->eye.y +
cs->z * pd->eye.z + cs->w * pd->eye.w;
pd->texture.y = pd->texture.x;
}
}
else
{
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else
xf = m->xf2; // at least 2 generated values
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_TEXTURE_VALID)
{
gen.z = pd->texture.z;
gen.w = pd->texture.w;
}
// both s and t have the SAME plane equation
gen.x = cs->x * pd->eye.x + cs->y * pd->eye.y +
cs->z * pd->eye.z + cs->w * pd->eye.w;
gen.y = gen.x;
// Finally, apply texture matrix
(*xf)(&pd->texture, (__GLfloat *) &gen, m);
}
}
}
// Generate texture coordinates from eye coordinates
// eye linear texture generation
// s and t are enabled but r and q are disabled
// both s and t use the eye linear mode
// both s and t have SAME plane equations
// texture coordinates are modified in place
// we may be able to get away without computing eye coord!
//
// IN: texture; obj or eye
// OUT: texture and eye (all vertices are updated)
void FASTCALL PolyArrayCalcEyeLizNear(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
__GLcoord *cs, *ct, gen;
POLYDATA *pd, *pdLast;
PFN_XFORM xf;
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
// Compute eye coord first
if (!(pa->flags & POLYARRAY_EYE_PROCESSED))
PolyArrayProcessEye(gc, pa);
cs = &gc->state.texture.s.eyePlaneEquation;
ct = &gc->state.texture.t.eyePlaneEquation;
pdLast = pa->pdNextVertex-1;
m = &gc->transform.texture->matrix;
if (m->matrixType == __GL_MT_IDENTITY)
{
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_TEXTURE_VALID))
{
pd->texture.z = (pd-1)->texture.z;
pd->texture.w = (pd-1)->texture.w;
}
pd->texture.x = cs->x * pd->eye.x + cs->y * pd->eye.y +
cs->z * pd->eye.z + cs->w * pd->eye.w;
pd->texture.y = ct->x * pd->eye.x + ct->y * pd->eye.y +
ct->z * pd->eye.z + ct->w * pd->eye.w;
}
}
else
{
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else
xf = m->xf2; // at least 2 generated values
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_TEXTURE_VALID)
{
gen.z = pd->texture.z;
gen.w = pd->texture.w;
}
gen.x = cs->x * pd->eye.x + cs->y * pd->eye.y +
cs->z * pd->eye.z + cs->w * pd->eye.w;
gen.y = ct->x * pd->eye.x + ct->y * pd->eye.y +
ct->z * pd->eye.z + ct->w * pd->eye.w;
// Finally, apply texture matrix
(*xf)(&pd->texture, (__GLfloat *) &gen, m);
}
}
}
// Compute the s & t coordinates for a sphere map. The s & t values
// are stored in "result" even if both coordinates are not being
// generated. The caller picks the right values out.
//
// IN: eye, normal
void FASTCALL PASphereGen(POLYDATA *pd, __GLcoord *result)
{
__GLcoord u, r;
__GLfloat m, ndotu;
// Get unit vector from origin to the vertex in eye coordinates into u
__glNormalize(&u.x, &pd->eye.x);
// Dot the normal with the unit position u
ndotu = pd->normal.x * u.x + pd->normal.y * u.y + pd->normal.z * u.z;
// Compute r
r.x = u.x - 2 * pd->normal.x * ndotu;
r.y = u.y - 2 * pd->normal.y * ndotu;
r.z = u.z - 2 * pd->normal.z * ndotu;
// Compute m
m = 2 * __GL_SQRTF(r.x*r.x + r.y*r.y + (r.z + 1) * (r.z + 1));
if (m)
{
result->x = r.x / m + __glHalf;
result->y = r.y / m + __glHalf;
}
else
{
result->x = __glHalf;
result->y = __glHalf;
}
}
// Generate texture coordinates for sphere map
// sphere map texture generation
// s and t are enabled but r and q are disabled
// both s and t use the sphere map mode
// texture coordinates are modified in place
// we may be able to get away without computing eye coord!
//
// IN: texture; obj or eye; normal
// OUT: texture and eye (all vertices are updated)
void FASTCALL PolyArrayCalcSphereMap(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
__GLcoord gen;
POLYDATA *pd, *pdLast, *pdNormal;
PFN_XFORM xf;
GLboolean bIdentity;
// this is really okay
PERF_CHECK(FALSE, "Uses sphere map texture generation!\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->pd0->flags & POLYDATA_NORMAL_VALID,
"need initial normal\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
// Compute eye coord first
if (!(pa->flags & POLYARRAY_EYE_PROCESSED))
PolyArrayProcessEye(gc, pa);
m = &gc->transform.texture->matrix;
bIdentity = (m->matrixType == __GL_MT_IDENTITY);
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3)
xf = m->xf3;
else
xf = m->xf2; // at least 2 generated values
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_TEXTURE_VALID)
{
gen.z = pd->texture.z;
gen.w = pd->texture.w;
}
if (pd->flags & POLYDATA_NORMAL_VALID)
{
// track current normal
pdNormal = pd;
}
else
{
// pd->flags |= POLYDATA_NORMAL_VALID;
pd->normal.x = pdNormal->normal.x;
pd->normal.y = pdNormal->normal.y;
pd->normal.z = pdNormal->normal.z;
}
PASphereGen(pd, &gen); // compute s, t values
// Finally, apply texture matrix
if (!bIdentity)
(*xf)(&pd->texture, (__GLfloat *) &gen, m);
else
pd->texture = gen;
}
}
// Transform or compute the texture coordinates for the polyarray
// It handles all texture generation modes. Texture coordinates are
// generated (if necessary) and transformed.
// Note that texture coordinates are modified in place.
//
// IN: texture (always)
// obj in GL_OBJECT_LINEAR mode
// obj or eye in GL_EYE_LINEAR mode
// obj or eye; normal in GL_SPHERE_MAP mode
// OUT: texture (all vertices are updated)
// eye in GL_EYE_LINEAR and GL_SPHERE_MAP modes (all vertices
// are updated)
void FASTCALL PolyArrayCalcMixedTexture(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatrix *m;
GLuint enables;
POLYDATA *pd, *pdLast, *pdNormal;
PFN_XFORM xf;
BOOL needNormal, didSphereGen;
__GLcoord savedTexture, sphereCoord, *c;
GLboolean bIdentity;
enables = gc->state.enables.general;
PERF_CHECK
(
!(enables & (__GL_TEXTURE_GEN_R_ENABLE | __GL_TEXTURE_GEN_Q_ENABLE)),
"Uses r, q texture generation!\n"
);
if ((enables & __GL_TEXTURE_GEN_S_ENABLE)
&& (enables & __GL_TEXTURE_GEN_T_ENABLE)
&& (gc->state.texture.s.mode != gc->state.texture.t.mode))
{
PERF_CHECK(FALSE, "Uses different s and t tex gen modes!\n");
}
ASSERTOPENGL(pa->pd0->flags & POLYDATA_TEXTURE_VALID,
"need initial texcoord value\n");
ASSERTOPENGL(pa->flags & (POLYARRAY_TEXTURE1|POLYARRAY_TEXTURE2|
POLYARRAY_TEXTURE3|POLYARRAY_TEXTURE4),
"bad paflags\n");
if ((enables & __GL_TEXTURE_GEN_S_ENABLE) && (gc->state.texture.s.mode == GL_SPHERE_MAP)
|| (enables & __GL_TEXTURE_GEN_T_ENABLE) && (gc->state.texture.t.mode == GL_SPHERE_MAP))
{
ASSERTOPENGL(pa->pd0->flags & POLYDATA_NORMAL_VALID,
"need initial normal\n");
needNormal = TRUE;
}
else
{
needNormal = FALSE;
}
// Compute eye coord first
if (!(pa->flags & POLYARRAY_EYE_PROCESSED))
{
if ((enables & __GL_TEXTURE_GEN_S_ENABLE)
&& (gc->state.texture.s.mode != GL_OBJECT_LINEAR)
|| (enables & __GL_TEXTURE_GEN_T_ENABLE)
&& (gc->state.texture.t.mode != GL_OBJECT_LINEAR)
|| (enables & __GL_TEXTURE_GEN_R_ENABLE)
&& (gc->state.texture.r.mode != GL_OBJECT_LINEAR)
|| (enables & __GL_TEXTURE_GEN_Q_ENABLE)
&& (gc->state.texture.q.mode != GL_OBJECT_LINEAR))
PolyArrayProcessEye(gc, pa);
}
m = &gc->transform.texture->matrix;
bIdentity = (m->matrixType == __GL_MT_IDENTITY);
// If any incoming texture coords contains q coord, use xf4.
if (pa->flags & POLYARRAY_TEXTURE4 || enables & __GL_TEXTURE_GEN_Q_ENABLE)
xf = m->xf4;
else if (pa->flags & POLYARRAY_TEXTURE3 || enables & __GL_TEXTURE_GEN_R_ENABLE)
xf = m->xf3;
else if (pa->flags & POLYARRAY_TEXTURE2 || enables & __GL_TEXTURE_GEN_T_ENABLE)
xf = m->xf2;
else
xf = m->xf1;
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
// texture coordinates are modified in place.
// save the valid values to use for the invalid entries.
if (pd->flags & POLYDATA_TEXTURE_VALID)
savedTexture = pd->texture;
else
pd->texture = savedTexture;
if (needNormal)
{
if (pd->flags & POLYDATA_NORMAL_VALID)
{
// track current normal
pdNormal = pd;
}
else
{
// pd->flags |= POLYDATA_NORMAL_VALID;
pd->normal.x = pdNormal->normal.x;
pd->normal.y = pdNormal->normal.y;
pd->normal.z = pdNormal->normal.z;
}
}
didSphereGen = GL_FALSE;
/* Generate s coordinate */
if (enables & __GL_TEXTURE_GEN_S_ENABLE)
{
if (gc->state.texture.s.mode == GL_EYE_LINEAR)
{
c = &gc->state.texture.s.eyePlaneEquation;
pd->texture.x = c->x * pd->eye.x + c->y * pd->eye.y
+ c->z * pd->eye.z + c->w * pd->eye.w;
}
else if (gc->state.texture.s.mode == GL_OBJECT_LINEAR)
{
// the primitive may contain a mix of vertex types (2,3,4)!
c = &gc->state.texture.s.objectPlaneEquation;
pd->texture.x = c->x * pd->obj.x + c->y * pd->obj.y +
c->z * pd->obj.z + c->w * pd->obj.w;
}
else
{
ASSERTOPENGL(gc->state.texture.s.mode == GL_SPHERE_MAP,
"invalide texture s mode");
PASphereGen(pd, &sphereCoord); // compute s, t values
pd->texture.x = sphereCoord.x;
didSphereGen = GL_TRUE;
}
}
/* Generate t coordinate */
if (enables & __GL_TEXTURE_GEN_T_ENABLE)
{
if (gc->state.texture.t.mode == GL_EYE_LINEAR)
{
c = &gc->state.texture.t.eyePlaneEquation;
pd->texture.y = c->x * pd->eye.x + c->y * pd->eye.y
+ c->z * pd->eye.z + c->w * pd->eye.w;
}
else if (gc->state.texture.t.mode == GL_OBJECT_LINEAR)
{
// the primitive may contain a mix of vertex types (2,3,4)!
c = &gc->state.texture.t.objectPlaneEquation;
pd->texture.y = c->x * pd->obj.x + c->y * pd->obj.y +
c->z * pd->obj.z + c->w * pd->obj.w;
}
else
{
ASSERTOPENGL(gc->state.texture.t.mode == GL_SPHERE_MAP,
"invalide texture t mode");
if (!didSphereGen)
PASphereGen(pd, &sphereCoord); // compute s, t values
pd->texture.y = sphereCoord.y;
}
}
/* Generate r coordinate */
if (enables & __GL_TEXTURE_GEN_R_ENABLE)
{
if (gc->state.texture.r.mode == GL_EYE_LINEAR)
{
c = &gc->state.texture.r.eyePlaneEquation;
pd->texture.z = c->x * pd->eye.x + c->y * pd->eye.y
+ c->z * pd->eye.z + c->w * pd->eye.w;
}
else
{
ASSERTOPENGL(gc->state.texture.r.mode == GL_OBJECT_LINEAR,
"invalide texture r mode");
// the primitive may contain a mix of vertex types (2,3,4)!
c = &gc->state.texture.r.objectPlaneEquation;
pd->texture.z = c->x * pd->obj.x + c->y * pd->obj.y +
c->z * pd->obj.z + c->w * pd->obj.w;
}
}
/* Generate q coordinate */
if (enables & __GL_TEXTURE_GEN_Q_ENABLE)
{
if (gc->state.texture.q.mode == GL_EYE_LINEAR)
{
c = &gc->state.texture.q.eyePlaneEquation;
pd->texture.w = c->x * pd->eye.x + c->y * pd->eye.y
+ c->z * pd->eye.z + c->w * pd->eye.w;
}
else
{
ASSERTOPENGL(gc->state.texture.q.mode == GL_OBJECT_LINEAR,
"invalide texture q mode");
// the primitive may contain a mix of vertex types (2,3,4)!
c = &gc->state.texture.q.objectPlaneEquation;
pd->texture.w = c->x * pd->obj.x + c->y * pd->obj.y +
c->z * pd->obj.z + c->w * pd->obj.w;
}
}
/* Finally, apply texture matrix */
if (!bIdentity)
(*xf)(&pd->texture, (__GLfloat *) &pd->texture, m);
}
}
/****************************************************************************/
// Apply the accumulated material changes to a vertex
void FASTCALL PAApplyMaterial(__GLcontext *gc, __GLmatChange *mat, GLint face)
{
__GLmaterialState *ms;
GLuint changeBits;
PERF_CHECK(FALSE, "Primitives contain glMaterial calls!\n");
// Don't modify color materials if they are in effect!
if (face == __GL_FRONTFACE)
{
ms = &gc->state.light.front;
changeBits = mat->dirtyBits & ~gc->light.front.colorMaterialChange;
}
else
{
ms = &gc->state.light.back;
changeBits = mat->dirtyBits & ~gc->light.back.colorMaterialChange;
}
if (changeBits & __GL_MATERIAL_AMBIENT)
ms->ambient = mat->ambient;
if (changeBits & __GL_MATERIAL_DIFFUSE)
ms->diffuse = mat->diffuse;
if (changeBits & __GL_MATERIAL_SPECULAR)
ms->specular = mat->specular;
if (changeBits & __GL_MATERIAL_EMISSIVE)
{
ms->emissive.r = mat->emissive.r * gc->redVertexScale;
ms->emissive.g = mat->emissive.g * gc->greenVertexScale;
ms->emissive.b = mat->emissive.b * gc->blueVertexScale;
ms->emissive.a = mat->emissive.a * gc->alphaVertexScale;
}
if (changeBits & __GL_MATERIAL_SHININESS)
ms->specularExponent = mat->shininess;
if (changeBits & __GL_MATERIAL_COLORINDEXES)
{
ms->cmapa = mat->cmapa;
ms->cmapd = mat->cmapd;
ms->cmaps = mat->cmaps;
}
// Re-calculate the precomputed values. This works for RGBA and CI modes.
if (face == __GL_FRONTFACE)
__glValidateMaterial(gc, (GLint) changeBits, 0);
else
__glValidateMaterial(gc, 0, (GLint) changeBits);
}
void FASTCALL PolyArrayApplyMaterials(__GLcontext *gc, POLYARRAY *pa)
{
__GLmatChange matChange, *pdMat;
GLuint matMask;
POLYDATA *pd, *pdN;
GLint face;
POLYMATERIAL *pm;
pm = GLTEB_CLTPOLYMATERIAL();
// Need to apply material changes defined after the last vertex!
pdN = pa->pdNextVertex;
// ASSERT_FACE
for (face = __GL_BACKFACE, matMask = POLYARRAY_MATERIAL_BACK;
face >= 0;
face--, matMask = POLYARRAY_MATERIAL_FRONT
)
{
if (!(pa->flags & matMask))
continue;
// Accumulate all changes into one material change record
// We need to process (n + 1) vertices for material changes!
matChange.dirtyBits = 0;
for (pd = pa->pd0; pd <= pdN; pd++)
{
// ASSERT_MATERIAL
if (pd->flags & matMask)
{
GLuint dirtyBits;
pdMat = *(&pm->pdMaterial0[pd - pa->pdBuffer0].front + face);
dirtyBits = pdMat->dirtyBits;
matChange.dirtyBits |= dirtyBits;
if (dirtyBits & __GL_MATERIAL_AMBIENT)
matChange.ambient = pdMat->ambient;
if (dirtyBits & __GL_MATERIAL_DIFFUSE)
matChange.diffuse = pdMat->diffuse;
if (dirtyBits & __GL_MATERIAL_SPECULAR)
matChange.specular = pdMat->specular;
if (dirtyBits & __GL_MATERIAL_EMISSIVE)
matChange.emissive = pdMat->emissive;
if (dirtyBits & __GL_MATERIAL_SHININESS)
matChange.shininess = pdMat->shininess;
if (dirtyBits & __GL_MATERIAL_COLORINDEXES)
{
matChange.cmapa = pdMat->cmapa;
matChange.cmapd = pdMat->cmapd;
matChange.cmaps = pdMat->cmaps;
}
}
}
// apply material changes for this face
PAApplyMaterial(gc, &matChange, face);
}
}
/****************************************************************************/
#ifndef __GL_ASM_POLYARRAYFILLINDEX0
// Fill the index values with 0
//
// IN: none
// OUT: colors[face].r (all vertices are updated)
void FASTCALL PolyArrayFillIndex0(__GLcontext *gc, POLYARRAY *pa, GLint face)
{
POLYDATA *pd, *pdLast;
ASSERTOPENGL((GLuint) face <= 1, "bad face value\n");
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
pd->colors[face].r = __glZero;
}
}
#endif // __GL_ASM_POLYARRAYFILLINDEX0
#ifndef __GL_ASM_POLYARRAYFILLCOLOR0
// Fill the color values with 0,0,0,0
//
// IN: none
// OUT: colors[face] (all vertices are updated)
void FASTCALL PolyArrayFillColor0(__GLcontext *gc, POLYARRAY *pa, GLint face)
{
POLYDATA *pd, *pdLast;
ASSERTOPENGL((GLuint) face <= 1, "bad face value\n");
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
pd->colors[face].r = __glZero;
pd->colors[face].g = __glZero;
pd->colors[face].b = __glZero;
pd->colors[face].a = __glZero;
}
}
#endif // __GL_ASM_POLYARRAYFILLCOLOR0
#ifndef __GL_ASM_POLYARRAYPROPAGATESAMECOLOR
// All vertices have the same color values.
// Clamp and scale the current color using the color buffer scales.
// From here on out the colors in the vertex are in their final form.
//
// Note: The first vertex must have a valid color!
// Back color is not needed when lighting is disabled.
//
// IN: color (front)
// OUT: color (front) (all vertices are updated)
void FASTCALL PolyArrayPropagateSameColor(__GLcontext *gc, POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
__GLfloat r, g, b, a;
pdLast = pa->pdNextVertex-1;
pd = pa->pd0;
if (pd > pdLast)
return;
ASSERTOPENGL(pd->flags & POLYDATA_COLOR_VALID, "no initial color\n");
if (pa->flags & POLYARRAY_CLAMP_COLOR) {
__GL_CLAMP_R(pd->colors[0].r, gc, pd->colors[0].r);
__GL_CLAMP_G(pd->colors[0].g, gc, pd->colors[0].g);
__GL_CLAMP_B(pd->colors[0].b, gc, pd->colors[0].b);
__GL_CLAMP_A(pd->colors[0].a, gc, pd->colors[0].a);
}
#ifdef _X86_
__asm
{
// Register usage.
// EAX: r, EBX: g, ECX: b, EDX: a
// ESI: &pdLast->colors[0]
// EDI: &pd->colors[0]
mov edi, pd
mov esi, pdLast
add edi, PD_colors0
add esi, PD_colors0
mov eax, [edi]
mov ebx, [edi+4]
mov ecx, [edi+8]
mov edx, [edi+12]
add edi, sizeof_POLYDATA
cmp edi, esi
ja Done
DoLoop:
mov [edi], eax
mov [edi+4], ebx
mov [edi+8], ecx
mov [edi+12], edx
add edi, sizeof_POLYDATA
cmp edi, esi
jbe DoLoop
Done:
}
#else
r = pd->colors[0].r;
g = pd->colors[0].g;
b = pd->colors[0].b;
a = pd->colors[0].a;
for (pd = pd + 1 ; pd <= pdLast; pd++)
{
pd->colors[0].r = r;
pd->colors[0].g = g;
pd->colors[0].b = b;
pd->colors[0].a = a;
}
#endif
}
#endif // __GL_ASM_POLYARRAYPROPAGATESAMECOLOR
#ifndef __GL_ASM_POLYARRAYPROPAGATESAMEINDEX
// All vertices have the same index values.
// Mask the index values befor color clipping
// SGIBUG: The sample implementation fails to do this!
//
// Note: The first vertex must have a valid color index!
// Back color is not needed when lighting is disabled.
//
// IN: color.r (front)
// OUT: color.r (front) (all vertices are updated)
void FASTCALL PolyArrayPropagateSameIndex(__GLcontext *gc, POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
__GLfloat index;
pdLast = pa->pdNextVertex-1;
pd = pa->pd0;
if (pd > pdLast)
return;
ASSERTOPENGL(pd->flags & POLYDATA_COLOR_VALID, "no initial color index\n");
if (pa->flags & POLYARRAY_CLAMP_COLOR) {
__GL_CLAMP_CI(pd->colors[0].r, gc, pd->colors[0].r);
}
index = pd->colors[0].r;
for (pd = pd + 1; pd <= pdLast; pd++)
{
pd->colors[0].r = index;
}
}
#endif // __GL_ASM_POLYARRAYPROPAGATESAMEINDEX
#ifndef __GL_ASM_POLYARRAYPROPAGATEINDEX
// Propagate the valid CI colors through the vertex buffer.
//
// IN: color.r (front)
// OUT: color.r (front) (all vertices are updated)
void FASTCALL PolyArrayPropagateIndex(__GLcontext *gc, POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
if (pa->flags & POLYARRAY_CLAMP_COLOR) {
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_COLOR_VALID))
{
// If color has not changed for this vertex,
// use the previously computed color.
ASSERTOPENGL(pd != pa->pd0, "no initial color index\n");
pd->colors[0].r = (pd-1)->colors[0].r;
continue;
}
__GL_CLAMP_CI(pd->colors[0].r, gc, pd->colors[0].r);
}
} else {
// If all incoming vertices have valid colors, we are done.
if ((pa->flags & POLYARRAY_SAME_POLYDATA_TYPE)
&& (pa->pdCurColor != pa->pd0)
// Need to test 2nd vertex because pdCurColor may have been
// advanced as a result of combining Color command after End
&& ((pa->pd0 + 1)->flags & POLYDATA_COLOR_VALID))
;
else
{
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_COLOR_VALID))
{
// If color has not changed for this vertex,
// use the previously computed color.
ASSERTOPENGL(pd != pa->pd0, "no initial color index\n");
pd->colors[0].r = (pd-1)->colors[0].r;
}
}
}
}
}
#endif // __GL_ASM_POLYARRAYPROPAGATEINDEX
#ifndef __GL_ASM_POLYARRAYPROPAGATECOLOR
// Propagate the valid RGBA colors through the vertex buffer.
//
// IN: color (front)
// OUT: color (front) (all vertices are updated)
void FASTCALL PolyArrayPropagateColor(__GLcontext *gc, POLYARRAY *pa)
{
POLYDATA *pd, *pdLast;
if (pa->flags & POLYARRAY_CLAMP_COLOR) {
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_COLOR_VALID))
{
// If color has not changed for this vertex,
// use the previously computed color.
ASSERTOPENGL(pd != pa->pd0, "no initial color\n");
pd->colors[0] = (pd-1)->colors[0];
continue;
}
__GL_CLAMP_R(pd->colors[0].r, gc, pd->colors[0].r);
__GL_CLAMP_G(pd->colors[0].g, gc, pd->colors[0].g);
__GL_CLAMP_B(pd->colors[0].b, gc, pd->colors[0].b);
__GL_CLAMP_A(pd->colors[0].a, gc, pd->colors[0].a);
}
} else {
// If all incoming vertices have valid colors, we are done.
if ((pa->flags & POLYARRAY_SAME_POLYDATA_TYPE)
&& (pa->pdCurColor != pa->pd0)
// Need to test 2nd vertex because pdCurColor may have been
// advanced as a result of combining Color command after End
&& ((pa->pd0 + 1)->flags & POLYDATA_COLOR_VALID))
;
else
{
pdLast = pa->pdNextVertex-1;
for (pd = pa->pd0; pd <= pdLast; pd++)
{
if (!(pd->flags & POLYDATA_COLOR_VALID))
{
// If color has not changed for this vertex,
// use the previously computed color.
ASSERTOPENGL(pd != pa->pd0, "no initial color\n");
pd->colors[0] = (pd-1)->colors[0];
}
}
}
}
}
#endif // __GL_ASM_POLYARRAYPROPAGATECOLOR
/****************************************************************************/
#if 0
//!!! remove this
// do we need clip?
// need __GL_HAS_FOG bit for line and polygon clipping!
// The boundaryEdge field is initialized in the calling routine.
#define PA_STORE_PROCESSED_POLYGON_VERTEX(v,pd,bits) \
{ \
(v)->clip = (pd)->clip; \
(v)->window = (pd)->window; \
(v)->eye.z = (pd)->eye.z; /* needed by slow fog */ \
(v)->fog = (pd)->fog; /* needed by cheap fog in flat shading */ \
(v)->texture.x = (pd)->texture.x; \
(v)->texture.y = (pd)->texture.y; \
(v)->texture.z = (pd)->texture.z; /* z is needed by feedback! */\
(v)->texture.w = (pd)->texture.w; \
(v)->color = &(pd)->color; \
(v)->clipCode = (pd)->clipCode; \
(v)->has = bits; \
}
// need eye if there is eyeClipPlanes
// need texture if there is texture
// need __GL_HAS_FOG bit for line and polygon clipping!
#define PA_STORE_PROCESSED_LINE_VERTEX(v,pd,bits) \
{ \
(v)->clip = (pd)->clip; \
(v)->window = (pd)->window; \
(v)->eye.z = (pd)->eye.z; /* needed by slow fog */ \
(v)->fog = (pd)->fog; /* needed by cheap fog in flat shading */ \
(v)->texture.x = (pd)->texture.x; \
(v)->texture.y = (pd)->texture.y; \
(v)->texture.z = (pd)->texture.z; /* z is needed by feedback! */\
(v)->texture.w = (pd)->texture.w; \
(v)->colors[__GL_FRONTFACE] = (pd)->color; \
(v)->clipCode = (pd)->clipCode; \
(v)->has = bits; \
}
// need eye if antialised is on
// need texture if there is texture
#define PA_STORE_PROCESSED_POINT_VERTEX(v,pd,bits) \
{ \
(v)->window = (pd)->window; \
(v)->eye.z = (pd)->eye.z; /* needed by slow fog */ \
(v)->fog = (pd)->fog; /* needed by cheap fog in flat shading */ \
(v)->clip.w = (pd)->clip.w; /* needed by feedback! */ \
(v)->texture.x = (pd)->texture.x; \
(v)->texture.y = (pd)->texture.y; \
(v)->texture.z = (pd)->texture.z; /* z is needed by feedback! */\
(v)->texture.w = (pd)->texture.w; \
(v)->color = &(pd)->color; \
(v)->has = bits; \
}
#endif // 0
// ---------------------------------------------------------
// The primitive is clipped.
void FASTCALL PARenderPoint(__GLcontext *gc, __GLvertex *v)
{
if (v->clipCode == 0)
(*gc->procs.renderPoint)(gc, v);
}
// ---------------------------------------------------------
// The primitive is clipped.
void FASTCALL PARenderLine(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, GLuint flags)
{
if (v0->clipCode | v1->clipCode)
{
/*
* The line must be clipped more carefully. Cannot
* trivially accept the lines.
*
* If anding the codes is non-zero then every vertex
* in the line is outside of the same set of clipping
* planes (at least one). Trivially reject the line.
*/
if ((v0->clipCode & v1->clipCode) == 0)
__glClipLine(gc, v0, v1, flags);
}
else
{
// Line is trivially accepted so render it
(*gc->procs.renderLine)(gc, v0, v1, flags);
}
}
// ---------------------------------------------------------
// The primitive is clipped.
void FASTCALL PARenderTriangle(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2)
{
GLuint orCodes;
/* Clip check */
orCodes = v0->clipCode | v1->clipCode | v2->clipCode;
if (orCodes)
{
/* Some kind of clipping is needed.
*
* If anding the codes is non-zero then every vertex
* in the triangle is outside of the same set of
* clipping planes (at least one). Trivially reject
* the triangle.
*/
if (!(v0->clipCode & v1->clipCode & v2->clipCode))
(*gc->procs.clipTriangle)(gc, v0, v1, v2, orCodes);
}
else
{
(*gc->procs.renderTriangle)(gc, v0, v1, v2);
}
}
// ---------------------------------------------------------
// The primitive is not clipped.
void PARenderQuadFast(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2, __GLvertex *v3)
{
// Vertex ordering is important. Line stippling uses it.
// SGIBUG: The sample implementation does it wrong.
GLuint savedTag;
/* Render the quad as two triangles */
savedTag = v2->has & __GL_HAS_EDGEFLAG_BOUNDARY;
v2->has &= ~__GL_HAS_EDGEFLAG_BOUNDARY;
(*gc->procs.renderTriangle)(gc, v0, v1, v2);
v2->has |= savedTag;
savedTag = v0->has & __GL_HAS_EDGEFLAG_BOUNDARY;
v0->has &= ~__GL_HAS_EDGEFLAG_BOUNDARY;
(*gc->procs.renderTriangle)(gc, v2, v3, v0);
v0->has |= savedTag;
}
// ---------------------------------------------------------
// The primitive is clipped.
void PARenderQuadSlow(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2, __GLvertex *v3)
{
GLuint orCodes;
orCodes = v0->clipCode | v1->clipCode | v2->clipCode | v3->clipCode;
if (orCodes)
{
/* Some kind of clipping is needed.
*
* If anding the codes is non-zero then every vertex
* in the quad is outside of the same set of
* clipping planes (at least one). Trivially reject
* the quad.
*/
if (!(v0->clipCode & v1->clipCode & v2->clipCode & v3->clipCode))
{
/* Clip the quad as a polygon */
__GLvertex *iv[4];
iv[0] = v0;
iv[1] = v1;
iv[2] = v2;
iv[3] = v3;
__glDoPolygonClip(gc, &iv[0], 4, orCodes);
}
}
else
{
PARenderQuadFast(gc, v0, v1, v2, v3);
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawPoints(__GLcontext *gc, POLYARRAY *pa)
{
// Index mapping is always identity in Points.
ASSERTOPENGL(!pa->aIndices, "Index mapping must be identity\n");
// Assert that pa->nIndices is correct
ASSERTOPENGL(pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Call PolyArrayRenderPoints later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderPoints(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, nIndices;
POLYDATA *pd0;
void (FASTCALL *rp)(__GLcontext *gc, __GLvertex *v);
// Index mapping is always identity in Points.
ASSERTOPENGL(!pa->aIndices, "Index mapping must be identity\n");
nIndices = pa->nIndices;
pd0 = pa->pd0;
rp = pa->orClipCodes ? PARenderPoint : gc->procs.renderPoint;
// Identity mapping
for (i = 0; i < nIndices; i++)
/* Render the point */
(*rp)(gc, (__GLvertex *) &pd0[i]);
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawLines(__GLcontext *gc, POLYARRAY *pa)
{
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Call PolyArrayRenderLines later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderLines(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast2;
GLubyte *aIndices;
POLYDATA *pd0;
PFN_RENDER_LINE rl;
iLast2 = pa->nIndices - 2;
pd0 = pa->pd0;
rl = pa->orClipCodes ? PARenderLine : gc->procs.renderLine;
(*gc->procs.lineBegin)(gc);
if (!(aIndices = pa->aIndices))
{
// Identity mapping
for (i = 0; i <= iLast2; i += 2)
{
/* setup for rendering this line */
gc->line.notResetStipple = GL_FALSE;
(*rl)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1], __GL_LVERT_FIRST);
}
}
else
{
for (i = 0; i <= iLast2; i += 2)
{
/* setup for rendering this line */
gc->line.notResetStipple = GL_FALSE;
(*rl)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]], __GL_LVERT_FIRST);
}
}
(*gc->procs.lineEnd)(gc);
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawLLoop(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
POLYDATA *pd, *pd0;
// Index mapping is always identity in Line Loop.
ASSERTOPENGL(!pa->aIndices, "Index mapping must be identity\n");
// A line loop is the same as a line strip except that a final segment is
// added from the final specified vertex to the first vertex. We will
// convert the line loop into a strip here.
nIndices = pa->nIndices;
// If we are continuing with a previously decomposed line loop, we need to
// connect the last vertex of the previous primitive and the first vertex
// of the current primitive with a line segment.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_RESET_STIPPLE),
"bad stipple reset flag!\n");
// Insert previous end vertex at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
}
else
{
// New line loop.
ASSERTOPENGL(pa->flags & POLYARRAY_RESET_STIPPLE,
"bad stipple reset flag!\n");
// At least two vertices must be given for anything to occur.
// An extra vertex was added to close the loop.
if (nIndices < 3)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
pa->nIndices--;
goto DrawLLoop_end;
}
}
pd0 = pa->pd0;
// If the primitive is only partially complete, save the last vertex for
// next batch.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
pd = &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd);
// Save the the original first vertex for closing the loop later.
if (!(pa->flags & POLYARRAY_PARTIAL_BEGIN))
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[1], pd0);
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
goto DrawLLoop_end;
#endif
}
else
{
POLYDATA *pdOrigin;
// Insert the original first vertex to close the loop and update clip code.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
pdOrigin = &gc->vertex.pdSaved[1];
else
pdOrigin = pd0;
pd = pa->pdNextVertex++;
ASSERTOPENGL(pd <= pa->pdBufferMax, "vertex overflows\n");
PA_COPY_PROCESSED_VERTEX(pd, pdOrigin);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
}
// Assert that pa->nIndices is correct
ASSERTOPENGL(pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the line strip.
// Call PolyArrayRenderLStrip later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
DrawLLoop_end:
// Change primitive type to line strip!
pa->primType = GL_LINE_STRIP;
}
void FASTCALL PolyArrayRenderLStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast;
GLubyte *aIndices;
POLYDATA *pd0;
PFN_RENDER_LINE rl;
// Render the line strip.
iLast = pa->nIndices - 1;
pd0 = pa->pd0;
rl = pa->orClipCodes ? PARenderLine : gc->procs.renderLine;
if (iLast <= 0)
return;
// Reset the line stipple if this is a new strip.
if (pa->flags & POLYARRAY_RESET_STIPPLE)
gc->line.notResetStipple = GL_FALSE;
(*gc->procs.lineBegin)(gc);
if (!(aIndices = pa->aIndices))
{
// Identity mapping
// Add first line segment (NOTE: 0, 1)
(*rl)(gc, (__GLvertex *) &pd0[0],
(__GLvertex *) &pd0[1], __GL_LVERT_FIRST);
// Add subsequent line segments (NOTE: i, i+1)
for (i = 1; i < iLast; i++)
(*rl)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1], 0);
}
else
{
// Add first line segment (NOTE: 0, 1)
(*rl)(gc, (__GLvertex *) &pd0[aIndices[0]],
(__GLvertex *) &pd0[aIndices[1]], __GL_LVERT_FIRST);
// Add subsequent line segments (NOTE: i, i+1)
for (i = 1; i < iLast; i++)
(*rl)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]], 0);
}
(*gc->procs.lineEnd)(gc);
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawLStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
GLubyte *aIndices;
POLYDATA *pd, *pd0;
nIndices = pa->nIndices;
aIndices = pa->aIndices;
// If we are continuing with a previously decomposed line strip, we need to
// connect the last vertex of the previous primitive and the first vertex
// of the current primitive with a line segment.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_RESET_STIPPLE),
"bad stipple reset flag!\n");
// Insert previous end vertex at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[0] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[0] == 0, "bad index mapping\n");
}
else
{
// New line strip.
ASSERTOPENGL(pa->flags & POLYARRAY_RESET_STIPPLE,
"bad stipple reset flag!\n");
}
// At least two vertices must be given for anything to occur.
if (nIndices < 2)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
return;
}
// If the primitive is only partially complete, save the last vertex for
// next batch.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
pd0 = pa->pd0;
pd = aIndices ? &pd0[aIndices[nIndices-1]] : &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd);
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
return;
#endif
}
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the line strip.
// Call PolyArrayRenderLStrip later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawTriangles(__GLcontext *gc, POLYARRAY *pa)
{
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Call PolyArrayRenderTriangles later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderTriangles(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast3;
GLubyte *aIndices, *aIndicesEnd;
POLYDATA *pd0;
__GLvertex *provoking;
PFN_RENDER_TRIANGLE rt;
// Vertex ordering is important. Line stippling uses it.
// SGIBUG: The sample implementation does it wrong.
iLast3 = pa->nIndices - 3;
pd0 = pa->pd0;
rt = pa->orClipCodes ? PARenderTriangle : gc->procs.renderTriangle;
if (!(aIndices = pa->aIndices))
{
// Identity mapping
for (i = 0; i <= iLast3; i += 3)
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+2];
/* Render the triangle (NOTE: i, i+1, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1],
(__GLvertex *) &pd0[i+2]);
}
}
else
{
#if 0
for (i = 0; i <= iLast3; i += 3)
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+2]];
/* Render the triangle (NOTE: i, i+1, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]],
(__GLvertex *) &pd0[aIndices[i+2]]);
}
#else
aIndicesEnd = aIndices+iLast3;
while (aIndices <= aIndicesEnd)
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
provoking = PD_VERTEX(pd0, aIndices[2]);
gc->vertex.provoking = provoking;
/* Render the triangle (NOTE: i, i+1, i+2) */
(*rt)(gc, PD_VERTEX(pd0, aIndices[0]),
PD_VERTEX(pd0, aIndices[1]),
provoking);
aIndices += 3;
}
#endif
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawTStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
GLubyte *aIndices;
POLYDATA *pd, *pd0;
nIndices = pa->nIndices;
aIndices = pa->aIndices;
// If we are continuing with a previously decomposed triangle strip, we need to
// start from the last two vertices of the previous primitive.
//
// Note that the flush vertex ensures that the continuing triangle strip is in
// the default orientation so that it can fall through the normal code.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
// Insert previous end vertices at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[1]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[1] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[1] == 1, "bad index mapping\n");
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[0] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[0] == 0, "bad index mapping\n");
}
// Need at least 3 vertices.
if (nIndices < 3)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
return;
}
// If the primitive is only partially complete, save the last two vertices for
// next batch.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
pd0 = pa->pd0;
pd = aIndices ? &pd0[aIndices[nIndices-2]] : &pd0[nIndices-2];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd);
pd = aIndices ? &pd0[aIndices[nIndices-1]] : &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[1], pd);
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
return;
#endif
}
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the triangle strip.
// Call PolyArrayRenderTStrip later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderTStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast3;
GLubyte *aIndices;
POLYDATA *pd0;
PFN_RENDER_TRIANGLE rt;
iLast3 = pa->nIndices - 3;
pd0 = pa->pd0;
rt = pa->orClipCodes ? PARenderTriangle : gc->procs.renderTriangle;
if (iLast3 < 0)
return;
// Vertex ordering is important. Line stippling uses it.
if (!(aIndices = pa->aIndices))
{
// Identity mapping
// Initialize first 2 vertices so we can start rendering the strip
// below. The edge flags are not modified by our lower level routines.
pd0[0].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[1].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
for (i = 0; i <= iLast3; )
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+2];
pd0[i+2].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: i, i+1, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1],
(__GLvertex *) &pd0[i+2]);
i++;
if (i > iLast3)
break;
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+2];
pd0[i+2].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: i+1, i, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[i+1],
(__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+2]);
i++;
}
}
else
{
// Initialize first 2 vertices so we can start rendering the strip
// below. The edge flags are not modified by our lower level routines.
pd0[aIndices[0]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[aIndices[1]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
for (i = 0; i <= iLast3; )
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+2]];
pd0[aIndices[i+2]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: i, i+1, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]],
(__GLvertex *) &pd0[aIndices[i+2]]);
i++;
if (i > iLast3)
break;
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+2]];
pd0[aIndices[i+2]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: i+1, i, i+2) */
(*rt)(gc, (__GLvertex *) &pd0[aIndices[i+1]],
(__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+2]]);
i++;
}
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawTFan(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
GLubyte *aIndices;
POLYDATA *pd, *pd0;
nIndices = pa->nIndices;
aIndices = pa->aIndices;
// If we are continuing with a previously decomposed triangle fan, we need to
// connect the last vertex of the previous primitive and the first vertex
// of the current primitive with a triangle.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
// Insert previous end vertex at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[1]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[1] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[1] == 1, "bad index mapping\n");
// Insert the origin first vertex at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[0] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[0] == 0, "bad index mapping\n");
}
// Need at least 3 vertices.
if (nIndices < 3)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
return;
}
// If the primitive is only partially complete, save the last vertex for
// next batch. Also save the original first vertex of the triangle fan.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
pd0 = pa->pd0;
pd = aIndices ? &pd0[aIndices[nIndices-1]] : &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[1], pd);
if (!(pa->flags & POLYARRAY_PARTIAL_BEGIN))
{
pd = aIndices ? &pd0[aIndices[0]] : &pd0[0];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd);
}
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
return;
#endif
}
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the triangle fan.
// Call PolyArrayRenderTFan later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderTFan(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast2;
GLubyte *aIndices;
POLYDATA *pd0;
PFN_RENDER_TRIANGLE rt;
iLast2 = pa->nIndices - 2;
pd0 = pa->pd0;
rt = pa->orClipCodes ? PARenderTriangle : gc->procs.renderTriangle;
if (iLast2 <= 0)
return;
// Vertex ordering is important. Line stippling uses it.
// SGIBUG: The sample implementation does it wrong.
if (!(aIndices = pa->aIndices))
{
// Identity mapping
// Initialize first 2 vertices so we can start rendering the tfan
// below. The edge flags are not modified by our lower level routines.
pd0[0].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[1].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
for (i = 1; i <= iLast2; i++)
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+1];
pd0[i+1].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: 0, i, i+1) */
(*rt)(gc, (__GLvertex *) &pd0[0 ],
(__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1]);
}
}
else
{
POLYDATA *pdOrigin;
// Initialize first 2 vertices so we can start rendering the tfan
// below. The edge flags are not modified by our lower level routines.
pd0[aIndices[0]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[aIndices[1]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pdOrigin = &pd0[aIndices[0]];
for (i = 1; i <= iLast2; i++)
{
/* setup for rendering this triangle */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+1]];
pd0[aIndices[i+1]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the triangle (NOTE: 0, i, i+1) */
(*rt)(gc, (__GLvertex *) pdOrigin,
(__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]]);
}
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawQuads(__GLcontext *gc, POLYARRAY *pa)
{
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Call PolyArrayRenderQuad later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderQuads(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast4;
GLubyte *aIndices;
POLYDATA *pd0;
void (*rq)(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2,
__GLvertex *v3);
// Vertex ordering is important. Line stippling uses it.
iLast4 = pa->nIndices - 4;
pd0 = pa->pd0;
rq = pa->orClipCodes ? PARenderQuadSlow : PARenderQuadFast;
if (!(aIndices = pa->aIndices))
{
// Identity mapping
for (i = 0; i <= iLast4; i += 4)
{
/* setup for rendering this quad */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+3];
/* Render the quad (NOTE: i, i+1, i+2, i+3) */
(*rq)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1],
(__GLvertex *) &pd0[i+2],
(__GLvertex *) &pd0[i+3]);
}
}
else
{
for (i = 0; i <= iLast4; i += 4)
{
/* setup for rendering this quad */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+3]];
/* Render the quad (NOTE: i, i+1, i+2, i+3) */
(*rq)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]],
(__GLvertex *) &pd0[aIndices[i+2]],
(__GLvertex *) &pd0[aIndices[i+3]]);
}
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawQStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
GLubyte *aIndices;
POLYDATA *pd, *pd0;
nIndices = pa->nIndices;
aIndices = pa->aIndices;
// If we are continuing with a previously decomposed quad strip, we need to
// start from the last two vertices of the previous primitive.
//
// Note that the flush vertex ensures that the continuing quad strip starts
// at an odd vertex so that it can fall through the normal code.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
// Insert previous end vertices at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[1]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[1] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[1] == 1, "bad index mapping\n");
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Assert that aIndices[0] was initialized in Begin
ASSERTOPENGL(!pa->aIndices || pa->aIndices[0] == 0, "bad index mapping\n");
}
// Need at least 4 vertices.
if (nIndices < 4)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
return;
}
// If the primitive is only partially complete, save the last two vertices for
// next batch.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
pd0 = pa->pd0;
pd = aIndices ? &pd0[aIndices[nIndices-2]] : &pd0[nIndices-2];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd);
pd = aIndices ? &pd0[aIndices[nIndices-1]] : &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[1], pd);
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
return;
#endif
}
// Assert that pa->nIndices is correct if aIndices is identity
ASSERTOPENGL(pa->aIndices || pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the quad strip.
// Call PolyArrayRenderQStrip later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderQStrip(__GLcontext *gc, POLYARRAY *pa)
{
GLint i, iLast4;
GLubyte *aIndices;
POLYDATA *pd0;
void (*rq)(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1, __GLvertex *v2,
__GLvertex *v3);
iLast4 = pa->nIndices - 4;
pd0 = pa->pd0;
rq = pa->orClipCodes ? PARenderQuadSlow : PARenderQuadFast;
if (iLast4 < 0)
return;
// Vertex ordering is important. Line stippling uses it.
if (!(aIndices = pa->aIndices))
{
// Identity mapping
// Initialize first 2 vertices so we can start rendering the quad
// below. The edge flags are not modified by our lower level routines.
pd0[0].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[1].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
for (i = 0; i <= iLast4; i += 2)
{
/* setup for rendering this quad */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[i+3];
pd0[i+2].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[i+3].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the quad (NOTE: i, i+1, i+3, i+2) */
(*rq)(gc, (__GLvertex *) &pd0[i ],
(__GLvertex *) &pd0[i+1],
(__GLvertex *) &pd0[i+3],
(__GLvertex *) &pd0[i+2]);
}
}
else
{
// Initialize first 2 vertices so we can start rendering the quad
// below. The edge flags are not modified by our lower level routines.
pd0[aIndices[0]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[aIndices[1]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
for (i = 0; i <= iLast4; i += 2)
{
/* setup for rendering this quad */
gc->line.notResetStipple = GL_FALSE;
gc->vertex.provoking = (__GLvertex *) &pd0[aIndices[i+3]];
pd0[aIndices[i+2]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
pd0[aIndices[i+3]].flags |= POLYDATA_EDGEFLAG_BOUNDARY;
/* Render the quad (NOTE: i, i+1, i+3, i+2) */
(*rq)(gc, (__GLvertex *) &pd0[aIndices[i ]],
(__GLvertex *) &pd0[aIndices[i+1]],
(__GLvertex *) &pd0[aIndices[i+3]],
(__GLvertex *) &pd0[aIndices[i+2]]);
}
}
}
// ---------------------------------------------------------
void FASTCALL PolyArrayDrawPolygon(__GLcontext *gc, POLYARRAY *pa)
{
GLint nIndices;
POLYDATA *pd, *pd0;
// Index mapping is always identity in Polygon.
ASSERTOPENGL(!pa->aIndices, "Index mapping must be identity\n");
nIndices = pa->nIndices;
// If we are continuing with a previously decomposed polygon, we need to
// insert the original first vertex and the last two vertices of the
// previous polygon at the beginning of the current batch (see note below).
// The decomposer expects the polygon vertices to be in sequential memory order.
if (pa->flags & POLYARRAY_PARTIAL_BEGIN)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_RESET_STIPPLE),
"bad stipple reset flag!\n");
// Insert previous end vertices at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[2]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[1]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
// Insert the origin first vertex at the beginning and update clip code
pd = --pa->pd0;
ASSERTOPENGL(pd > (POLYDATA *) pa, "vertex underflows\n");
PA_COPY_PROCESSED_VERTEX(pd, &gc->vertex.pdSaved[0]);
pa->orClipCodes |= pd->clipCode;
#ifdef POLYARRAY_AND_CLIPCODES
pa->andClipCodes &= pd->clipCode;
#endif
}
else
{
// New polygon.
ASSERTOPENGL(pa->flags & POLYARRAY_RESET_STIPPLE,
"bad stipple reset flag!\n");
}
// Need at least 3 vertices.
if (nIndices < 3)
{
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_END),
"Partial end with insufficient vertices\n");
ASSERTOPENGL(!(pa->flags & POLYARRAY_PARTIAL_BEGIN),
"Partial begin with insufficient vertices\n");
return;
}
// If the primitive is only partially complete, save the last 2 vertices for
// next batch. Also save the original first vertex of the polygon.
if (pa->flags & POLYARRAY_PARTIAL_END)
{
// Since there may be no vertex following this partial primitive, we
// cannot determine the edge flag of the last vertex in this batch. So
// we save the last vertex for next batch instead.
pd0 = pa->pd0;
pd = &pd0[nIndices-1];
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[2], pd);
// Remove the last vertex from this partial primitive
nIndices = --pa->nIndices;
pa->pdNextVertex--;
// Mark the closing edge of this decomposed polygon as non-boundary
// because we are synthetically generating it.
pd--;
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[1], pd);
pd->flags &= ~POLYDATA_EDGEFLAG_BOUNDARY;
if (!(pa->flags & POLYARRAY_PARTIAL_BEGIN))
{
PA_COPY_PROCESSED_VERTEX(&gc->vertex.pdSaved[0], pd0);
// Mark the first polygon vertex's edge tag as non-boundary
// because when it gets rendered again it will no longer be
// a boundary edge.
gc->vertex.pdSaved[0].flags &= ~POLYDATA_EDGEFLAG_BOUNDARY;
}
// Need not render this partial primitive if it is completely clipped.
#ifdef POLYARRAY_AND_CLIPCODES
if (pa->andClipCodes != 0)
return;
#endif
}
// The polygon clipper can only handle this many vertices.
ASSERTOPENGL(nIndices <= __GL_MAX_POLYGON_CLIP_SIZE,
"too many points for the polygon clipper!\n");
// Assert that pa->nIndices is correct
ASSERTOPENGL(pa->nIndices == pa->pdNextVertex - pa->pd0,
"bad nIndices\n");
// Render the polygon.
// Call PolyArrayRenderPolygon later
pa->flags |= POLYARRAY_RENDER_PRIMITIVE;
}
void FASTCALL PolyArrayRenderPolygon(__GLcontext *gc, POLYARRAY *pa)
{
// Index mapping is always identity in Polygon.
ASSERTOPENGL(!pa->aIndices, "Index mapping must be identity\n");
// Reset the line stipple if this is a new polygon.
if (pa->flags & POLYARRAY_RESET_STIPPLE)
gc->line.notResetStipple = GL_FALSE;
// Note that the provoking vertex is set to pd0 in clipPolygon
(*gc->procs.clipPolygon)(gc, (__GLvertex *) pa->pd0, pa->nIndices);
}
/****************************************************************************/
// Note: The first vertex must have a valid normal!
//
// IN: obj/eye, normal
// OUT: eye, color.r (front or back depending on face) (all vertices are
// updated)
void FASTCALL PolyArrayCalcCIColor(__GLcontext *gc, GLint face, POLYARRAY *pa, POLYDATA *pdFirst, POLYDATA *pdLast)
{
__GLfloat nxi, nyi, nzi;
__GLfloat zero;
__GLlightSourceMachine *lsm;
__GLmaterialState *ms;
__GLmaterialMachine *msm;
__GLfloat msm_threshold, msm_scale, *msm_specTable;
__GLfloat ms_cmapa, ms_cmapd, ms_cmaps;
__GLfloat si, di;
POLYDATA *pd;
GLfloat redMaxF;
GLint redMaxI;
GLboolean eyeWIsZero, localViewer;
static __GLcoord Pe = { 0, 0, 0, 1 };
PERF_CHECK(FALSE, "Uses slow lights\n");
zero = __glZero;
if (face == __GL_FRONTFACE)
{
ms = &gc->state.light.front;
msm = &gc->light.front;
}
else
{
ms = &gc->state.light.back;
msm = &gc->light.back;
}
msm_scale = msm->scale;
msm_threshold = msm->threshold;
msm_specTable = msm->specTable;
ms_cmapa = ms->cmapa;
ms_cmapd = ms->cmapd;
ms_cmaps = ms->cmaps;
localViewer = gc->state.light.model.localViewer;
redMaxF = (GLfloat) gc->frontBuffer.redMax;
redMaxI = (GLint) gc->frontBuffer.redMax;
// Eye coord should have been processed
ASSERTOPENGL(pa->flags & POLYARRAY_EYE_PROCESSED, "need eye\n");
// NOTE: the following values may be re-used in the next iteration:
// nxi, nyi, nzi
for (pd = pdFirst; pd <= pdLast; pd++)
{
__GLfloat ci;
if (pd->flags & POLYDATA_NORMAL_VALID)
{
if (gc->vertex.paNeeds & PANEEDS_NORMAL) {
(*gc->mInv->xf3)(&pd->normal, &pd->normal.x, gc->mInv);
if (gc->state.enables.general & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
if (face == __GL_FRONTFACE)
{
nxi = pd->normal.x;
nyi = pd->normal.y;
nzi = pd->normal.z;
}
else
{
nxi = -pd->normal.x;
nyi = -pd->normal.y;
nzi = -pd->normal.z;
}
}
else
{
// use previous normal (nxi, nyi, nzi)!
ASSERTOPENGL(pd != pdFirst, "no initial normal\n");
}
si = zero;
di = zero;
eyeWIsZero = __GL_FLOAT_EQZ(pd->eye.w);
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
if (lsm->slowPath || eyeWIsZero)
{
__GLfloat n1, n2, att, attSpot;
__GLcoord vPliHat, vPli, hHat, vPeHat;
__GLfloat hv[3];
/* Compute vPli, hi (normalized) */
vvec(&vPli, &pd->eye, &lsm->position);
__glNormalize(&vPliHat.x, &vPli.x);
if (localViewer)
{
vvec(&vPeHat, &pd->eye, &Pe);
__glNormalize(&vPeHat.x, &vPeHat.x);
hv[0] = vPliHat.x + vPeHat.x;
hv[1] = vPliHat.y + vPeHat.y;
hv[2] = vPliHat.z + vPeHat.z;
}
else
{
hv[0] = vPliHat.x;
hv[1] = vPliHat.y;
hv[2] = vPliHat.z + __glOne;
}
__glNormalize(&hHat.x, hv);
/* Compute attenuation */
if (__GL_FLOAT_NEZ(lsm->position.w))
{
__GLfloat k0, k1, k2, dist;
k0 = lsm->constantAttenuation;
k1 = lsm->lizNearAttenuation;
k2 = lsm->quadraticAttenuation;
if (__GL_FLOAT_EQZ(k1) && __GL_FLOAT_EQZ(k2))
{
/* Use pre-computed 1/k0 */
att = lsm->attenuation;
}
else
{
dist = __GL_SQRTF(vPli.x*vPli.x + vPli.y*vPli.y
+ vPli.z*vPli.z);
att = __glOne / (k0 + k1 * dist + k2 * dist * dist);
}
}
else
{
att = __glOne;
}
/* Compute spot effect if light is a spot light */
attSpot = att;
if (lsm->isSpot)
{
__GLfloat dot, px, py, pz;
px = -vPliHat.x;
py = -vPliHat.y;
pz = -vPliHat.z;
dot = px * lsm->direction.x + py * lsm->direction.y
+ pz * lsm->direction.z;
if ((dot >= lsm->threshold) && (dot >= lsm->cosCutOffAngle))
{
GLint ix = (GLint)((dot - lsm->threshold) * lsm->scale
+ __glHalf);
if (ix < __GL_SPOT_LOOKUP_TABLE_SIZE)
attSpot = att * lsm->spotTable[ix];
}
else
{
attSpot = zero;
}
}
/* Add in remaining effect of light, if any */
if (attSpot)
{
n1 = nxi * vPliHat.x + nyi * vPliHat.y + nzi * vPliHat.z;
if (__GL_FLOAT_GTZ(n1)) {
n2 = nxi * hHat.x + nyi * hHat.y + nzi * hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
si += attSpot * n2 * lsm->sli;
}
di += attSpot * n1 * lsm->dli;
}
}
}
else
{
__GLfloat n1, n2;
/* Compute specular contribution */
n1 = nxi * lsm->unitVPpli.x + nyi * lsm->unitVPpli.y +
nzi * lsm->unitVPpli.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = nxi * lsm->hHat.x + nyi * lsm->hHat.y + nzi * lsm->hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
si += n2 * lsm->sli;
}
di += n1 * lsm->dli;
}
}
}
/* Compute final color */
if (si > __glOne)
si = __glOne;
ci = ms_cmapa + (__glOne - si) * di * (ms_cmapd - ms_cmapa)
+ si * (ms_cmaps - ms_cmapa);
if (ci > ms_cmaps)
ci = ms_cmaps;
// need to mask color index before color clipping
if (ci > redMaxF) {
GLfloat fraction;
GLint integer;
integer = (GLint) ci;
fraction = ci - (GLfloat) integer;
integer = integer & redMaxI;
ci = (GLfloat) integer + fraction;
} else if (ci < 0) {
GLfloat fraction;
GLint integer;
integer = (GLint) __GL_FLOORF(ci);
fraction = ci - (GLfloat) integer;
integer = integer & redMaxI;
ci = (GLfloat) integer + fraction;
}
pd->colors[face].r = ci;
}
}
// No slow lights version
// Note: The first vertex must have a valid normal!
//
// IN: normal
// OUT: color.r (front or back depending on face) (all vertices are updated)
void FASTCALL PolyArrayFastCalcCIColor(__GLcontext *gc, GLint face, POLYARRAY *pa, POLYDATA *pdFirst, POLYDATA *pdLast)
{
__GLfloat nxi, nyi, nzi;
__GLfloat zero;
__GLlightSourceMachine *lsm;
__GLmaterialState *ms;
__GLmaterialMachine *msm;
__GLfloat msm_threshold, msm_scale, *msm_specTable;
__GLfloat ms_cmapa, ms_cmapd, ms_cmaps;
__GLfloat si, di;
POLYDATA *pd;
GLfloat redMaxF;
GLint redMaxI;
#if LATER
// if eye.w is zero, it should really take the slow path!
// Since the RGB version ignores it, we will also ignore it here.
// Even the original generic implementation may not have computed eye values.
#endif
zero = __glZero;
if (face == __GL_FRONTFACE)
{
ms = &gc->state.light.front;
msm = &gc->light.front;
}
else
{
ms = &gc->state.light.back;
msm = &gc->light.back;
}
msm_scale = msm->scale;
msm_threshold = msm->threshold;
msm_specTable = msm->specTable;
ms_cmapa = ms->cmapa;
ms_cmapd = ms->cmapd;
ms_cmaps = ms->cmaps;
redMaxF = (GLfloat) gc->frontBuffer.redMax;
redMaxI = (GLint) gc->frontBuffer.redMax;
// NOTE: the following values may be re-used in the next iteration:
// nxi, nyi, nzi
for (pd = pdFirst; pd <= pdLast; pd++)
{
__GLfloat ci;
// If normal has not changed for this vertex, use the previously computed
// color index.
if (!(pd->flags & POLYDATA_NORMAL_VALID))
{
ASSERTOPENGL(pd != pdFirst, "no initial normal\n");
pd->colors[face].r = (pd-1)->colors[face].r;
continue;
}
if (gc->vertex.paNeeds & PANEEDS_NORMAL) {
(*gc->mInv->xf3)(&pd->normal, &pd->normal.x, gc->mInv);
if (gc->state.enables.general & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
if (face == __GL_FRONTFACE)
{
nxi = pd->normal.x;
nyi = pd->normal.y;
nzi = pd->normal.z;
}
else
{
nxi = -pd->normal.x;
nyi = -pd->normal.y;
nzi = -pd->normal.z;
}
si = zero;
di = zero;
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
__GLfloat n1, n2;
/* Compute specular contribution */
n1 = nxi * lsm->unitVPpli.x + nyi * lsm->unitVPpli.y +
nzi * lsm->unitVPpli.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = nxi * lsm->hHat.x + nyi * lsm->hHat.y + nzi * lsm->hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
si += n2 * lsm->sli;
}
di += n1 * lsm->dli;
}
}
/* Compute final color */
if (si > __glOne)
si = __glOne;
ci = ms_cmapa + (__glOne - si) * di * (ms_cmapd - ms_cmapa)
+ si * (ms_cmaps - ms_cmapa);
if (ci > ms_cmaps)
ci = ms_cmaps;
// need to mask color index before color clipping
// SGIBUG: The sample implementation fails to do this!
if (ci > redMaxF) {
GLfloat fraction;
GLint integer;
integer = (GLint) ci;
fraction = ci - (GLfloat) integer;
integer = integer & redMaxI;
ci = (GLfloat) integer + fraction;
} else if (ci < 0) {
GLfloat fraction;
GLint integer;
integer = (GLint) __GL_FLOORF(ci);
fraction = ci - (GLfloat) integer;
integer = integer & redMaxI;
ci = (GLfloat) integer + fraction;
}
pd->colors[face].r = ci;
}
}
// If both front and back colors are needed, the back colors must be computed
// first! Otherwise, the front colors can be overwritten prematurely.
// Note: The first vertex must have valid normal and color!
//
// IN: obj/eye, color (front), normal
// OUT: eye, color (front or back depending on face) (all vertices are updated)
void FASTCALL PolyArrayCalcRGBColor(__GLcontext *gc, GLint face, POLYARRAY *pa, POLYDATA *pdFirst, POLYDATA *pdLast)
{
__GLfloat nxi, nyi, nzi;
__GLfloat zero;
__GLlightSourcePerMaterialMachine *lspmm;
__GLlightSourceMachine *lsm;
__GLlightSourceState *lss;
__GLfloat ri, gi, bi;
__GLfloat alpha;
__GLfloat rsi, gsi, bsi;
__GLcolor sceneColorI;
__GLmaterialMachine *msm;
__GLcolor lm_ambient;
__GLfloat msm_alpha, msm_threshold, msm_scale, *msm_specTable;
__GLcolor msm_paSceneColor;
GLuint msm_colorMaterialChange;
POLYDATA *pd;
GLboolean eyeWIsZero, localViewer;
static __GLcoord Pe = { 0, 0, 0, 1 };
PERF_CHECK(FALSE, "Uses slow lights\n");
zero = __glZero;
// Eye coord should have been processed
ASSERTOPENGL(pa->flags & POLYARRAY_EYE_PROCESSED, "need eye\n");
if (face == __GL_FRONTFACE)
msm = &gc->light.front;
else
msm = &gc->light.back;
lm_ambient.r = gc->state.light.model.ambient.r;
lm_ambient.g = gc->state.light.model.ambient.g;
lm_ambient.b = gc->state.light.model.ambient.b;
msm_scale = msm->scale;
msm_threshold = msm->threshold;
msm_specTable = msm->specTable;
msm_alpha = msm->alpha;
msm_colorMaterialChange = msm->colorMaterialChange;
msm_paSceneColor = msm->paSceneColor;
localViewer = gc->state.light.model.localViewer;
// Get invarient scene color if there is no ambient or emissive color material.
sceneColorI.r = msm_paSceneColor.r;
sceneColorI.g = msm_paSceneColor.g;
sceneColorI.b = msm_paSceneColor.b;
// NOTE: the following values may be re-used in the next iteration:
// ri, gi, bi, alpha, nxi, nyi, nzi, sceneColorI
for (pd = pdFirst; pd <= pdLast; pd++)
{
if (pd->flags & POLYDATA_COLOR_VALID)
{
// Save latest colors normalized to 0..1
ri = pd->colors[0].r * gc->oneOverRedVertexScale;
gi = pd->colors[0].g * gc->oneOverGreenVertexScale;
bi = pd->colors[0].b * gc->oneOverBlueVertexScale;
alpha = pd->colors[0].a;
// Compute scene color.
// If color has not changed, the previous sceneColorI values are used!
if (msm_colorMaterialChange & (__GL_MATERIAL_AMBIENT | __GL_MATERIAL_EMISSIVE))
{
if (msm_colorMaterialChange & __GL_MATERIAL_AMBIENT)
{
sceneColorI.r = msm_paSceneColor.r + ri * lm_ambient.r;
sceneColorI.g = msm_paSceneColor.g + gi * lm_ambient.g;
sceneColorI.b = msm_paSceneColor.b + bi * lm_ambient.b;
}
else
{
sceneColorI.r = msm_paSceneColor.r + pd->colors[0].r;
sceneColorI.g = msm_paSceneColor.g + pd->colors[0].g;
sceneColorI.b = msm_paSceneColor.b + pd->colors[0].b;
}
}
}
else
{
// use previous ri, gi, bi, alpha, and sceneColorI!
ASSERTOPENGL(pd != pdFirst, "no initial color\n");
}
// Compute the diffuse and specular components for this vertex.
if (pd->flags & POLYDATA_NORMAL_VALID)
{
if (gc->vertex.paNeeds & PANEEDS_NORMAL) {
(*gc->mInv->xf3)(&pd->normal, &pd->normal.x, gc->mInv);
if (gc->state.enables.general & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
if (face == __GL_FRONTFACE)
{
nxi = pd->normal.x;
nyi = pd->normal.y;
nzi = pd->normal.z;
}
else
{
nxi = -pd->normal.x;
nyi = -pd->normal.y;
nzi = -pd->normal.z;
}
}
else
{
// use previous normal (nxi, nyi, nzi)!
ASSERTOPENGL(pd != pdFirst, "no initial normal\n");
}
rsi = sceneColorI.r;
gsi = sceneColorI.g;
bsi = sceneColorI.b;
eyeWIsZero = __GL_FLOAT_EQZ(pd->eye.w);
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
__GLfloat n1, n2;
lss = lsm->state;
lspmm = &lsm->front + face;
if (lsm->slowPath || eyeWIsZero)
{
__GLcoord hHat, vPli, vPliHat, vPeHat;
__GLfloat att, attSpot;
__GLfloat hv[3];
/* Compute unit h[i] */
vvec(&vPli, &pd->eye, &lsm->position);
__glNormalize(&vPliHat.x, &vPli.x);
if (localViewer)
{
vvec(&vPeHat, &pd->eye, &Pe);
__glNormalize(&vPeHat.x, &vPeHat.x);
hv[0] = vPliHat.x + vPeHat.x;
hv[1] = vPliHat.y + vPeHat.y;
hv[2] = vPliHat.z + vPeHat.z;
}
else
{
hv[0] = vPliHat.x;
hv[1] = vPliHat.y;
hv[2] = vPliHat.z + __glOne;
}
__glNormalize(&hHat.x, hv);
/* Compute attenuation */
if (__GL_FLOAT_NEZ(lsm->position.w))
{
__GLfloat k0, k1, k2, dist;
k0 = lsm->constantAttenuation;
k1 = lsm->lizNearAttenuation;
k2 = lsm->quadraticAttenuation;
if (__GL_FLOAT_EQZ(k1) && __GL_FLOAT_EQZ(k2))
{
/* Use pre-computed 1/k0 */
att = lsm->attenuation;
}
else
{
dist = __GL_SQRTF(vPli.x*vPli.x + vPli.y*vPli.y
+ vPli.z*vPli.z);
att = __glOne / (k0 + k1 * dist + k2 * dist * dist);
}
}
else
{
att = __glOne;
}
/* Compute spot effect if light is a spot light */
attSpot = att;
if (lsm->isSpot)
{
__GLfloat dot, px, py, pz;
px = -vPliHat.x;
py = -vPliHat.y;
pz = -vPliHat.z;
dot = px * lsm->direction.x + py * lsm->direction.y
+ pz * lsm->direction.z;
if ((dot >= lsm->threshold) && (dot >= lsm->cosCutOffAngle))
{
GLint ix = (GLint)((dot - lsm->threshold) * lsm->scale
+ __glHalf);
if (ix < __GL_SPOT_LOOKUP_TABLE_SIZE)
attSpot = att * lsm->spotTable[ix];
}
else
{
attSpot = zero;
}
}
/* Add in remaining effect of light, if any */
if (attSpot)
{
__GLfloat n1, n2;
__GLcolor sum;
if (msm_colorMaterialChange & __GL_MATERIAL_AMBIENT)
{
sum.r = ri * lss->ambient.r;
sum.g = gi * lss->ambient.g;
sum.b = bi * lss->ambient.b;
}
else
{
sum.r = lspmm->ambient.r;
sum.g = lspmm->ambient.g;
sum.b = lspmm->ambient.b;
}
n1 = nxi * vPliHat.x + nyi * vPliHat.y + nzi * vPliHat.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = nxi * hHat.x + nyi * hHat.y + nzi * hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
if (msm_colorMaterialChange & __GL_MATERIAL_SPECULAR)
{
/* Recompute per-light per-material cached specular */
sum.r += n2 * ri * lss->specular.r;
sum.g += n2 * gi * lss->specular.g;
sum.b += n2 * bi * lss->specular.b;
}
else
{
sum.r += n2 * lspmm->specular.r;
sum.g += n2 * lspmm->specular.g;
sum.b += n2 * lspmm->specular.b;
}
}
if (msm_colorMaterialChange & __GL_MATERIAL_DIFFUSE)
{
/* Recompute per-light per-material cached diffuse */
sum.r += n1 * ri * lss->diffuse.r;
sum.g += n1 * gi * lss->diffuse.g;
sum.b += n1 * bi * lss->diffuse.b;
}
else
{
sum.r += n1 * lspmm->diffuse.r;
sum.g += n1 * lspmm->diffuse.g;
sum.b += n1 * lspmm->diffuse.b;
}
}
rsi += attSpot * sum.r;
gsi += attSpot * sum.g;
bsi += attSpot * sum.b;
}
}
else
{
__GLfloat n1, n2;
if (msm_colorMaterialChange & __GL_MATERIAL_AMBIENT)
{
rsi += ri * lss->ambient.r;
gsi += gi * lss->ambient.g;
bsi += bi * lss->ambient.b;
}
else
{
rsi += lspmm->ambient.r;
gsi += lspmm->ambient.g;
bsi += lspmm->ambient.b;
}
/* Add in specular and diffuse effect of light, if any */
n1 = nxi * lsm->unitVPpli.x + nyi * lsm->unitVPpli.y +
nzi * lsm->unitVPpli.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = nxi * lsm->hHat.x + nyi * lsm->hHat.y + nzi * lsm->hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2)) {
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
if (msm_colorMaterialChange & __GL_MATERIAL_SPECULAR)
{
/* Recompute per-light per-material cached specular */
rsi += n2 * ri * lss->specular.r;
gsi += n2 * gi * lss->specular.g;
bsi += n2 * bi * lss->specular.b;
}
else
{
rsi += n2 * lspmm->specular.r;
gsi += n2 * lspmm->specular.g;
bsi += n2 * lspmm->specular.b;
}
}
if (msm_colorMaterialChange & __GL_MATERIAL_DIFFUSE)
{
/* Recompute per-light per-material cached diffuse */
rsi += n1 * ri * lss->diffuse.r;
gsi += n1 * gi * lss->diffuse.g;
bsi += n1 * bi * lss->diffuse.b;
}
else
{
rsi += n1 * lspmm->diffuse.r;
gsi += n1 * lspmm->diffuse.g;
bsi += n1 * lspmm->diffuse.b;
}
}
}
}
{
__GLcolor *pd_color_dst;
pd_color_dst = &pd->colors[face];
__GL_CLAMP_R(pd_color_dst->r, gc, rsi);
__GL_CLAMP_G(pd_color_dst->g, gc, gsi);
__GL_CLAMP_B(pd_color_dst->b, gc, bsi);
if (msm_colorMaterialChange & __GL_MATERIAL_DIFFUSE)
{
if (pa->flags & POLYARRAY_CLAMP_COLOR)
{
__GL_CLAMP_A(pd_color_dst->a, gc, alpha);
}
else
pd_color_dst->a = alpha;
}
else
{
pd_color_dst->a = msm_alpha;
}
}
}
}
// If both front and back colors are needed, the back color must be computed
// first! Otherwise, the front color can be overwritten prematurely.
// Note: The first vertex must have valid normal and color!
//
// IN: color (front), normal
// OUT: color (front or back depending on face) (all vertices are updated)
#ifndef __GL_ASM_POLYARRAYFASTCALCRGBCOLOR
void FASTCALL PolyArrayFastCalcRGBColor(__GLcontext *gc, GLint face, POLYARRAY *pa, POLYDATA *pdFirst, POLYDATA *pdLast)
{
__GLfloat nxi, nyi, nzi;
__GLfloat zero;
__GLlightSourcePerMaterialMachine *lspmm;
__GLlightSourceMachine *lsm;
__GLlightSourceState *lss;
__GLfloat ri, gi, bi;
__GLfloat alpha;
__GLcolor emissiveAmbientI;
__GLcolor diffuseSpecularI;
__GLcolor baseEmissiveAmbient;
__GLmaterialMachine *msm;
__GLcolor lm_ambient;
__GLfloat msm_alpha, msm_threshold, msm_scale, *msm_specTable;
GLuint msm_colorMaterialChange;
POLYDATA *pd;
#if LATER
// if eye.w is zero, it should really take the slow path!
// Since the sample implementation ignores it, we will also ignore it here.
#endif
PERF_CHECK(FALSE, "Primitives contain glColorMaterial calls\n");
zero = __glZero;
if (face == __GL_FRONTFACE)
msm = &gc->light.front;
else
msm = &gc->light.back;
// If there is no color material change for this face, we can call the
// zippy function!
msm_colorMaterialChange = msm->colorMaterialChange;
if (!msm_colorMaterialChange)
{
PolyArrayZippyCalcRGBColor(gc, face, pa, pdFirst, pdLast);
return;
}
lm_ambient.r = gc->state.light.model.ambient.r;
lm_ambient.g = gc->state.light.model.ambient.g;
lm_ambient.b = gc->state.light.model.ambient.b;
msm_scale = msm->scale;
msm_threshold = msm->threshold;
msm_specTable = msm->specTable;
msm_alpha = msm->alpha;
// Compute invarient emissive and ambient components for this vertex.
baseEmissiveAmbient.r = msm->paSceneColor.r;
baseEmissiveAmbient.g = msm->paSceneColor.g;
baseEmissiveAmbient.b = msm->paSceneColor.b;
// add invarient per-light per-material cached ambient
if (!(msm_colorMaterialChange & __GL_MATERIAL_AMBIENT))
{
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
lspmm = &lsm->front + face;
baseEmissiveAmbient.r += lspmm->ambient.r;
baseEmissiveAmbient.g += lspmm->ambient.g;
baseEmissiveAmbient.b += lspmm->ambient.b;
}
}
// If there is no emissive or ambient color material change, this
// will be the emissive and ambient components.
emissiveAmbientI.r = baseEmissiveAmbient.r;
emissiveAmbientI.g = baseEmissiveAmbient.g;
emissiveAmbientI.b = baseEmissiveAmbient.b;
// NOTE: the following values may be re-used in the next iteration:
// ri, gi, bi, alpha, nxi, nyi, nzi, emissiveAmbientI, diffuseSpecularI
for (pd = pdFirst; pd <= pdLast; pd++)
{
// If color and normal have not changed for this vertex, use the previously
// computed color.
if (!(pd->flags & (POLYDATA_NORMAL_VALID | POLYDATA_COLOR_VALID)))
{
ASSERTOPENGL(pd != pdFirst, "no initial normal and color\n");
pd->colors[face] = (pd-1)->colors[face];
continue;
}
if (pd->flags & POLYDATA_COLOR_VALID)
{
// Save latest colors normalized to 0..1
ri = pd->colors[0].r * gc->oneOverRedVertexScale;
gi = pd->colors[0].g * gc->oneOverGreenVertexScale;
bi = pd->colors[0].b * gc->oneOverBlueVertexScale;
alpha = pd->colors[0].a;
// Compute the emissive and ambient components for this vertex if necessary.
// If color has not changed, the previous emissveAmbientI values are used!
if (msm_colorMaterialChange
& (__GL_MATERIAL_AMBIENT | __GL_MATERIAL_EMISSIVE))
{
if (msm_colorMaterialChange & __GL_MATERIAL_AMBIENT)
{
emissiveAmbientI.r = baseEmissiveAmbient.r
+ ri * lm_ambient.r;
emissiveAmbientI.g = baseEmissiveAmbient.g
+ gi * lm_ambient.g;
emissiveAmbientI.b = baseEmissiveAmbient.b
+ bi * lm_ambient.b;
// Add per-light per-material ambient
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
lss = lsm->state;
emissiveAmbientI.r += ri * lss->ambient.r;
emissiveAmbientI.g += gi * lss->ambient.g;
emissiveAmbientI.b += bi * lss->ambient.b;
}
}
else
{
emissiveAmbientI.r = baseEmissiveAmbient.r + pd->colors[0].r;
emissiveAmbientI.g = baseEmissiveAmbient.g + pd->colors[0].g;
emissiveAmbientI.b = baseEmissiveAmbient.b + pd->colors[0].b;
}
}
}
else
{
// use previous ri, gi, bi, alpha, and emissiveAmbientI!
ASSERTOPENGL(pd != pdFirst, "no initial color\n");
}
// Compute the diffuse and specular components for this vertex.
if (pd->flags & POLYDATA_NORMAL_VALID)
{
if (gc->vertex.paNeeds & PANEEDS_NORMAL) {
(*gc->mInv->xf3)(&pd->normal, &pd->normal.x, gc->mInv);
if (gc->state.enables.general & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
if (face == __GL_FRONTFACE)
{
nxi = pd->normal.x;
nyi = pd->normal.y;
nzi = pd->normal.z;
}
else
{
nxi = -pd->normal.x;
nyi = -pd->normal.y;
nzi = -pd->normal.z;
}
}
else
{
ASSERTOPENGL(pd != pdFirst, "no initial normal\n");
// If normal and diffuse and specular components have not changed,
// use the previously computed diffuse and specular values.
// otherwise, use previous normal (nxi, nyi, nzi) and
// diffuseSpecularI!
if (!(msm_colorMaterialChange & (__GL_MATERIAL_SPECULAR | __GL_MATERIAL_DIFFUSE)))
goto store_color;
}
diffuseSpecularI.r = zero;
diffuseSpecularI.g = zero;
diffuseSpecularI.b = zero;
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
__GLfloat n1, n2;
lss = lsm->state;
lspmm = &lsm->front + face;
/* Add in specular and diffuse effect of light, if any */
n1 = nxi * lsm->unitVPpli.x + nyi * lsm->unitVPpli.y +
nzi * lsm->unitVPpli.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = nxi * lsm->hHat.x + nyi * lsm->hHat.y + nzi * lsm->hHat.z;
n2 -= msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
if (msm_colorMaterialChange & __GL_MATERIAL_SPECULAR)
{
/* Recompute per-light per-material cached specular */
diffuseSpecularI.r += n2 * ri * lss->specular.r;
diffuseSpecularI.g += n2 * gi * lss->specular.g;
diffuseSpecularI.b += n2 * bi * lss->specular.b;
}
else
{
diffuseSpecularI.r += n2 * lspmm->specular.r;
diffuseSpecularI.g += n2 * lspmm->specular.g;
diffuseSpecularI.b += n2 * lspmm->specular.b;
}
}
if (msm_colorMaterialChange & __GL_MATERIAL_DIFFUSE)
{
/* Recompute per-light per-material cached diffuse */
diffuseSpecularI.r += n1 * ri * lss->diffuse.r;
diffuseSpecularI.g += n1 * gi * lss->diffuse.g;
diffuseSpecularI.b += n1 * bi * lss->diffuse.b;
}
else
{
diffuseSpecularI.r += n1 * lspmm->diffuse.r;
diffuseSpecularI.g += n1 * lspmm->diffuse.g;
diffuseSpecularI.b += n1 * lspmm->diffuse.b;
}
}
}
store_color:
{
__GLcolor *pd_color_dst;
pd_color_dst = &pd->colors[face];
__GL_CLAMP_R(pd_color_dst->r, gc, emissiveAmbientI.r + diffuseSpecularI.r);
__GL_CLAMP_G(pd_color_dst->g, gc, emissiveAmbientI.g + diffuseSpecularI.g);
__GL_CLAMP_B(pd_color_dst->b, gc, emissiveAmbientI.b + diffuseSpecularI.b);
if (msm_colorMaterialChange & __GL_MATERIAL_DIFFUSE)
{
if (pa->flags & POLYARRAY_CLAMP_COLOR)
{
__GL_CLAMP_A(pd_color_dst->a, gc, alpha);
}
else
pd_color_dst->a = alpha;
}
else
{
pd_color_dst->a = msm_alpha;
}
}
}
}
#endif // __GL_ASM_POLYARRAYFASTCALCRGBCOLOR
// This function is called when color material is disabled and there are no
// slow lights.
//
// Note: The first vertex must have a valid normal!
//
// IN: normal
// OUT: color (front or back depending on face) (all vertices are updated)
#ifndef __GL_ASM_POLYARRAYZIPPYCALCRGBCOLOR
void FASTCALL PolyArrayZippyCalcRGBColor(__GLcontext *gc, GLint face, POLYARRAY *pa, POLYDATA *pdFirst, POLYDATA *pdLast)
{
__GLfloat nxi, nyi, nzi;
__GLlightSourcePerMaterialMachine *lspmm;
__GLlightSourceMachine *lsm;
__GLlightSourceState *lss;
__GLcolor baseEmissiveAmbient;
__GLmaterialMachine *msm;
__GLfloat msm_alpha, msm_threshold, msm_scale, *msm_specTable;
POLYDATA *pd;
#if LATER
// if eye.w is zero, it should really take the slow path!
// Since the sample implementation ignores it, we will also ignore it here.
#endif
if (face == __GL_FRONTFACE)
msm = &gc->light.front;
else
msm = &gc->light.back;
msm_scale = msm->scale;
msm_threshold = msm->threshold;
msm_specTable = msm->specTable;
msm_alpha = msm->alpha;
// Compute invarient emissive and ambient components for this vertex.
baseEmissiveAmbient.r = msm->paSceneColor.r;
baseEmissiveAmbient.g = msm->paSceneColor.g;
baseEmissiveAmbient.b = msm->paSceneColor.b;
// add invarient per-light per-material cached ambient
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
lspmm = &lsm->front + face;
baseEmissiveAmbient.r += lspmm->ambient.r;
baseEmissiveAmbient.g += lspmm->ambient.g;
baseEmissiveAmbient.b += lspmm->ambient.b;
}
// NOTE: the following values may be re-used in the next iteration:
// nxi, nyi, nzi
for (pd = pdFirst; pd <= pdLast; pd++)
{
__GLfloat rsi, gsi, bsi;
// If normal has not changed for this vertex, use the previously computed color.
if (!(pd->flags & POLYDATA_NORMAL_VALID))
{
ASSERTOPENGL(pd != pdFirst, "no initial normal\n");
pd->colors[face] = (pd-1)->colors[face];
continue;
}
if (gc->vertex.paNeeds & PANEEDS_NORMAL) {
(*gc->mInv->xf3)(&pd->normal, &pd->normal.x, gc->mInv);
if (gc->state.enables.general & __GL_NORMALIZE_ENABLE)
__glNormalize(&pd->normal.x, &pd->normal.x);
}
if (face == __GL_FRONTFACE)
{
nxi = pd->normal.x;
nyi = pd->normal.y;
nzi = pd->normal.z;
}
else
{
nxi = -pd->normal.x;
nyi = -pd->normal.y;
nzi = -pd->normal.z;
}
rsi = baseEmissiveAmbient.r;
gsi = baseEmissiveAmbient.g;
bsi = baseEmissiveAmbient.b;
// Compute the diffuse and specular components for this vertex.
for (lsm = gc->light.sources; lsm; lsm = lsm->next)
{
__GLfloat n1, n2;
lss = lsm->state;
lspmm = &lsm->front + face;
/* Add in specular and diffuse effect of light, if any */
n1 = nxi * lsm->unitVPpli.x + nyi * lsm->unitVPpli.y +
nzi * lsm->unitVPpli.z;
if (__GL_FLOAT_GTZ(n1))
{
n2 = (nxi * lsm->hHat.x + nyi * lsm->hHat.y + nzi * lsm->hHat.z)
- msm_threshold;
if (__GL_FLOAT_GEZ(n2))
{
#ifdef NT
__GLfloat fx = n2 * msm_scale + __glHalf;
if( fx < (__GLfloat)__GL_SPEC_LOOKUP_TABLE_SIZE )
n2 = msm_specTable[(GLint)fx];
else
n2 = __glOne;
#else
GLint ix = (GLint)(n2 * msm_scale + __glHalf);
if (ix < __GL_SPEC_LOOKUP_TABLE_SIZE)
n2 = msm_specTable[ix];
else
n2 = __glOne;
#endif
rsi += n2 * lspmm->specular.r;
gsi += n2 * lspmm->specular.g;
bsi += n2 * lspmm->specular.b;
}
rsi += n1 * lspmm->diffuse.r;
gsi += n1 * lspmm->diffuse.g;
bsi += n1 * lspmm->diffuse.b;
}
}
{
__GLcolor *pd_color_dst;
pd_color_dst = &pd->colors[face];
__GL_CLAMP_R(pd_color_dst->r, gc, rsi);
__GL_CLAMP_G(pd_color_dst->g, gc, gsi);
__GL_CLAMP_B(pd_color_dst->b, gc, bsi);
pd_color_dst->a = msm_alpha;
}
}
}
#endif // __GL_ASM_POLYARRAYZIPPYCALCRGBCOLOR
/****************************************************************************/
// Clip check the clip coordinates against the frustum planes.
// Compute the window coordinates if not clipped!
//
// IN: clip
// OUT: window (if not clipped)
// Clip codes indexed by:
// 2 1 0
// wsign xsign w-xsign
// For both the x > w and x < -w cases
static GLubyte __glXClipCodes[8] =
{
0,
__GL_CLIP_RIGHT,
0,
__GL_CLIP_LEFT,
__GL_CLIP_LEFT | __GL_CLIP_RIGHT,
__GL_CLIP_RIGHT,
__GL_CLIP_LEFT | __GL_CLIP_RIGHT,
__GL_CLIP_LEFT,
};
static GLubyte __glYClipCodes[8] =
{
0,
__GL_CLIP_TOP,
0,
__GL_CLIP_BOTTOM,
__GL_CLIP_BOTTOM | __GL_CLIP_TOP,
__GL_CLIP_TOP,
__GL_CLIP_BOTTOM | __GL_CLIP_TOP,
__GL_CLIP_BOTTOM,
};
static GLubyte __glZClipCodes[8] =
{
0,
__GL_CLIP_FAR,
0,
__GL_CLIP_NEAR,
__GL_CLIP_NEAR | __GL_CLIP_FAR,
__GL_CLIP_FAR,
__GL_CLIP_NEAR | __GL_CLIP_FAR,
__GL_CLIP_NEAR,
};
#ifndef __GL_ASM_PACLIPCHECKFRUSTUM
GLuint FASTCALL PAClipCheckFrustum(__GLcontext *gc, POLYDATA *pd)
{
__GLfloat x, y, z, w, invW, negW;
GLuint code;
w = pd->clip.w;
if (__GL_FLOAT_COMPARE_PONE(w, ==))
{
pd->window.w = __glOne;
/* Set clip codes */
#ifdef _X86_
// Always computes both add/sub even though
// it's not technically necessary. The overhead of
// doing a test and branch for each value plus the
// loss of overlap doesn't seem worth it
// This also isn't the common case
__asm
{
mov edx, pd
xor edi, edi
xor ecx, ecx
// Accumulate w sign and abs(w)
mov eax, __FLOAT_ONE
// Accumulate x sign and abs(x)
// Compute abs(w)-abs(x) and accumulate sign
mov ebx, [edx+PD_clip]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
mov cl, __glXClipCodes[edi]
shr edi, 2
// Accumulate y sign and abs(y)
// Compute abs(w)-abs(y) and accumulate sign
mov ebx, [edx+PD_clip+4]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
or cl, __glYClipCodes[edi]
shr edi, 2
// Accumulate z sign and abs(z)
// Compute abs(w)-abs(z) and accumulate sign
mov ebx, [edx+PD_clip+8]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi
or cl, __glZClipCodes[edi]
mov code, ecx
or ecx, ecx
jnz Clipped
mov eax, gc
fld DWORD PTR [edx+PD_clip]
fmul DWORD PTR [eax+GC_VIEWPORT_xScale]
fld DWORD PTR [edx+PD_clip+4]
fmul DWORD PTR [eax+GC_VIEWPORT_yScale]
fld DWORD PTR [edx+PD_clip+8]
fmul DWORD PTR [eax+GC_VIEWPORT_zScale]
fld DWORD PTR [eax+GC_VIEWPORT_xCenter]
fld DWORD PTR [eax+GC_VIEWPORT_yCenter]
fld DWORD PTR [eax+GC_VIEWPORT_zCenter]
faddp st(3), st(0)
faddp st(3), st(0)
faddp st(3), st(0)
fxch st(2)
fstp DWORD PTR [edx+PD_window]
fstp DWORD PTR [edx+PD_window+4]
fstp DWORD PTR [edx+PD_window+8]
Clipped:
}
#else
x = pd->clip.x;
y = pd->clip.y;
z = pd->clip.z;
code = 0;
negW = __glMinusOne;
if (x < negW) code |= __GL_CLIP_LEFT;
else if (x > w) code |= __GL_CLIP_RIGHT;
if (y < negW) code |= __GL_CLIP_BOTTOM;
else if (y > w) code |= __GL_CLIP_TOP;
if (z < negW) code |= __GL_CLIP_NEAR;
else if (z > w) code |= __GL_CLIP_FAR;
/* Compute window coordinates if not clipped */
if (!code)
{
__GLfloat wx, wy, wz;
wx = x * gc->state.viewport.xScale + gc->state.viewport.xCenter;
wy = y * gc->state.viewport.yScale + gc->state.viewport.yCenter;
wz = z * gc->state.viewport.zScale + gc->state.viewport.zCenter;
pd->window.x = wx;
pd->window.y = wy;
pd->window.z = wz;
}
#endif
}
else
{
// Enable single precision divides
CHOP_ROUND_ON();
/* Set clip codes */
#ifdef _X86_
__asm
{
// Start 1/w divide
mov eax, w
or eax, eax
jz WEqZero
fld __glOne
fdiv w
jmp WDivStarted
WEqZero:
fld __glZero
WDivStarted:
mov edx, pd
xor edi, edi
xor ecx, ecx
// Accumulate w sign and abs(w)
// Accumulate x sign and abs(x)
// Compute abs(w)-abs(x) and accumulate sign
shl eax, 1
mov ebx, [edx+PD_clip]
rcl edi, 1
shr eax, 1
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
mov cl, __glXClipCodes[edi]
shr edi, 2
// Accumulate y sign and abs(y)
// Compute abs(w)-abs(y) and accumulate sign
mov ebx, [edx+PD_clip+4]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
or cl, __glYClipCodes[edi]
shr edi, 2
// Accumulate z sign and abs(z)
// Compute abs(w)-abs(z) and accumulate sign
mov ebx, [edx+PD_clip+8]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi
or cl, __glZClipCodes[edi]
mov code, ecx
or ecx, ecx
// Save invW
fstp invW
jnz ClippedW
mov eax, gc
fld DWORD PTR [edx+PD_clip]
fmul DWORD PTR [eax+GC_VIEWPORT_xScale]
fld DWORD PTR [edx+PD_clip+4]
fmul DWORD PTR [eax+GC_VIEWPORT_yScale]
fld DWORD PTR [edx+PD_clip+8]
fmul DWORD PTR [eax+GC_VIEWPORT_zScale]
fld invW ; iW z y x
fmul st(3), st(0)
fld DWORD PTR [eax+GC_VIEWPORT_xCenter] ; xc iW z y xiW
fxch st(1) ; iW xc z y xiW
fmul st(3), st(0)
fld DWORD PTR [eax+GC_VIEWPORT_yCenter] ; yc iW xc z yiW xiW
fxch st(1) ; iW yc xc z yiW xiW
fmulp st(3), st(0) ; yc xc ziW yiW xiW
fld DWORD PTR [eax+GC_VIEWPORT_zCenter] ; zc yc xc ziW yiW xiW
faddp st(3), st(0)
faddp st(3), st(0)
faddp st(3), st(0)
fxch st(2)
fstp DWORD PTR [edx+PD_window]
fstp DWORD PTR [edx+PD_window+4]
fstp DWORD PTR [edx+PD_window+8]
ClippedW:
}
pd->window.w = invW;
#else
/* XXX (mf) prevent divide-by-zero */
if (__GL_FLOAT_NEZ(w))
{
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, w, invW);
}
else
{
invW = __glZero;
}
x = pd->clip.x;
y = pd->clip.y;
z = pd->clip.z;
code = 0;
negW = -w;
__GL_FLOAT_SIMPLE_END_DIVIDE(invW);
pd->window.w = invW;
/*
** NOTE: it is possible for x to be less than negW and greater than w
** (if w is negative). Otherwise there would be "else" clauses here.
*/
if (x < negW) code |= __GL_CLIP_LEFT;
if (x > w) code |= __GL_CLIP_RIGHT;
if (y < negW) code |= __GL_CLIP_BOTTOM;
if (y > w) code |= __GL_CLIP_TOP;
if (z < negW) code |= __GL_CLIP_NEAR;
if (z > w) code |= __GL_CLIP_FAR;
/* Compute window coordinates if not clipped */
if (!code)
{
__GLfloat wx, wy, wz;
wx = x * gc->state.viewport.xScale * invW +
gc->state.viewport.xCenter;
wy = y * gc->state.viewport.yScale * invW +
gc->state.viewport.yCenter;
wz = z * gc->state.viewport.zScale * invW +
gc->state.viewport.zCenter;
pd->window.x = wx;
pd->window.y = wy;
pd->window.z = wz;
}
#endif
CHOP_ROUND_OFF();
}
return code;
}
#endif // __GL_ASM_PACLIPCHECKFRUSTUM
// Clip check the clip coordinates against the frustum planes.
// Compute the window coordinates if not clipped!
//
// IN: clip
// OUT: window (if not clipped)
#ifndef __GL_ASM_PACLIPCHECKFRUSTUM2D
GLuint FASTCALL PAClipCheckFrustum2D(__GLcontext *gc, POLYDATA *pd)
{
__GLfloat x, y, z, w, negW, invW;
GLuint code;
/* W is 1.0 */
pd->window.w = __glOne;
#ifdef _X86_
__asm
{
mov edx, pd
xor edi, edi
xor ecx, ecx
// Accumulate w sign and abs(w)
mov eax, __FLOAT_ONE
// Accumulate x sign and abs(x)
// Compute abs(w)-abs(x) and accumulate sign
mov ebx, [edx+PD_clip]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
mov cl, __glXClipCodes[edi]
shr edi, 2
// Accumulate y sign and abs(y)
// Compute abs(w)-abs(y) and accumulate sign
mov ebx, [edx+PD_clip+4]
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
or cl, __glYClipCodes[edi]
mov code, ecx
or ecx, ecx
jnz Clipped
mov eax, gc
fld DWORD PTR [edx+PD_clip]
fmul DWORD PTR [eax+GC_VIEWPORT_xScale]
fld DWORD PTR [edx+PD_clip+4]
fmul DWORD PTR [eax+GC_VIEWPORT_yScale]
fld DWORD PTR [edx+PD_clip+8]
fmul DWORD PTR [eax+GC_VIEWPORT_zScale]
fld DWORD PTR [eax+GC_VIEWPORT_xCenter]
fld DWORD PTR [eax+GC_VIEWPORT_yCenter]
fld DWORD PTR [eax+GC_VIEWPORT_zCenter]
faddp st(3), st(0)
faddp st(3), st(0)
faddp st(3), st(0)
fxch st(2)
fstp DWORD PTR [edx+PD_window]
fstp DWORD PTR [edx+PD_window+4]
fstp DWORD PTR [edx+PD_window+8]
Clipped:
}
#else
x = pd->clip.x;
y = pd->clip.y;
z = pd->clip.z;
w = pd->clip.w;
negW = __glMinusOne;
/* Set clip codes */
code = 0;
if (x < negW) code |= __GL_CLIP_LEFT;
else if (x > w) code |= __GL_CLIP_RIGHT;
if (y < negW) code |= __GL_CLIP_BOTTOM;
else if (y > w) code |= __GL_CLIP_TOP;
/* Compute window coordinates if not clipped */
if (!code)
{
__GLfloat wx, wy, wz;
wx = x * gc->state.viewport.xScale + gc->state.viewport.xCenter;
wy = y * gc->state.viewport.yScale + gc->state.viewport.yCenter;
wz = z * gc->state.viewport.zScale + gc->state.viewport.zCenter;
pd->window.x = wx;
pd->window.y = wy;
pd->window.z = wz;
}
#endif
return code;
}
#endif // __GL_ASM_PACLIPCHECKFRUSTUM2D
// Clip check against the frustum and user clipping planes.
// Compute the window coordinates if not clipped!
//
// IN: clip, eye
// OUT: window (if not clipped)
GLuint FASTCALL PAClipCheckAll(__GLcontext *gc, POLYDATA *pd)
{
__GLfloat x, y, z, w, negW, invW;
GLuint code, bit, clipPlanesMask;
__GLcoord *plane;
// Enable single precision divides
CHOP_ROUND_ON();
PERF_CHECK(FALSE, "Performs user plane clipping!\n");
/*
** Do frustum checks.
**
** NOTE: it is possible for x to be less than negW and greater than w
** (if w is negative). Otherwise there would be "else" clauses here.
*/
x = pd->clip.x;
y = pd->clip.y;
z = pd->clip.z;
w = pd->clip.w;
/* Set clip codes */
#ifdef _X86_
__asm
{
// Start 1/w divide
mov eax, w
or eax, eax
jz WEqZero
fld __glOne
fdiv w
jmp WDivStarted
WEqZero:
fld __glZero
WDivStarted:
xor edi, edi
xor ecx, ecx
// Accumulate w sign and abs(w)
// Accumulate x sign and abs(x)
// Compute abs(w)-abs(x) and accumulate sign
shl eax, 1
mov ebx, x
rcl edi, 1
shr eax, 1
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
mov cl, __glXClipCodes[edi]
shr edi, 2
// Accumulate y sign and abs(y)
// Compute abs(w)-abs(y) and accumulate sign
mov ebx, y
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi and reset edi
or cl, __glYClipCodes[edi]
shr edi, 2
// Accumulate z sign and abs(z)
// Compute abs(w)-abs(z) and accumulate sign
mov ebx, z
shl ebx, 1
mov esi, eax
rcl edi, 1
shr ebx, 1
sub esi, ebx
shl esi, 1
rcl edi, 1
// Get clip codes for index in edi
or cl, __glZClipCodes[edi]
// Store invW
fstp invW
mov code, ecx
}
pd->window.w = invW;
#else
/* XXX (mf) prevent divide-by-zero */
if (__GL_FLOAT_NEZ(w))
{
__GL_FLOAT_SIMPLE_BEGIN_DIVIDE(__glOne, w, invW);
__GL_FLOAT_SIMPLE_END_DIVIDE(invW);
}
else
{
invW = __glZero;
}
pd->window.w = invW;
negW = -w;
code = 0;
if (x < negW) code |= __GL_CLIP_LEFT;
if (x > w) code |= __GL_CLIP_RIGHT;
if (y < negW) code |= __GL_CLIP_BOTTOM;
if (y > w) code |= __GL_CLIP_TOP;
if (z < negW) code |= __GL_CLIP_NEAR;
if (z > w) code |= __GL_CLIP_FAR;
#endif
/*
** Now do user clip plane checks
*/
x = pd->eye.x;
y = pd->eye.y;
z = pd->eye.z;
w = pd->eye.w;
clipPlanesMask = gc->state.enables.clipPlanes;
plane = &gc->state.transform.eyeClipPlanes[0];
bit = __GL_CLIP_USER0;
while (clipPlanesMask)
{
if (clipPlanesMask & 1)
{
/*
** Dot the vertex clip coordinate against the clip plane and see
** if the sign is negative. If so, then the point is out.
*/
if (x * plane->x + y * plane->y + z * plane->z + w * plane->w <
__glZero)
{
code |= bit;
}
}
clipPlanesMask >>= 1;
bit <<= 1;
plane++;
}
/* Compute window coordinates if not clipped */
if (!code)
{
__GLfloat wx, wy, wz;
x = pd->clip.x;
y = pd->clip.y;
z = pd->clip.z;
#ifdef _X86_
__asm
{
mov edx, pd
mov eax, gc
fld DWORD PTR [edx+PD_clip]
fmul DWORD PTR [eax+GC_VIEWPORT_xScale]
fld DWORD PTR [edx+PD_clip+4]
fmul DWORD PTR [eax+GC_VIEWPORT_yScale]
fld DWORD PTR [edx+PD_clip+8]
fmul DWORD PTR [eax+GC_VIEWPORT_zScale]
fld invW ; iW z y x
fmul st(3), st(0)
fld DWORD PTR [eax+GC_VIEWPORT_xCenter] ; xc iW z y xiW
fxch st(1) ; iW xc z y xiW
fmul st(3), st(0)
fld DWORD PTR [eax+GC_VIEWPORT_yCenter] ; yc iW xc z yiW xiW
fxch st(1) ; iW yc xc z yiW xiW
fmulp st(3), st(0) ; yc xc ziW yiW xiW
fld DWORD PTR [eax+GC_VIEWPORT_zCenter] ; zc yc xc ziW yiW xiW
faddp st(3), st(0)
faddp st(3), st(0)
faddp st(3), st(0)
fxch st(2)
fstp DWORD PTR [edx+PD_window]
fstp DWORD PTR [edx+PD_window+4]
fstp DWORD PTR [edx+PD_window+8]
}
#else
wx = x * gc->state.viewport.xScale * invW + gc->state.viewport.xCenter;
wy = y * gc->state.viewport.yScale * invW + gc->state.viewport.yCenter;
wz = z * gc->state.viewport.zScale * invW + gc->state.viewport.zCenter;
pd->window.x = wx;
pd->window.y = wy;
pd->window.z = wz;
#endif
}
CHOP_ROUND_OFF();
return code;
}
/****************************************************************************/
void APIPRIVATE __glim_EdgeFlag(GLboolean tag)
{
__GL_SETUP();
gc->state.current.edgeTag = tag;
}
void APIPRIVATE __glim_TexCoord4fv(const GLfloat x[4])
{
__GL_SETUP();
gc->state.current.texture.x = x[0];
gc->state.current.texture.y = x[1];
gc->state.current.texture.z = x[2];
gc->state.current.texture.w = x[3];
}
void APIPRIVATE __glim_Normal3fv(const GLfloat v[3])
{
__GL_SETUP();
GLfloat x, y, z;
x = v[0];
y = v[1];
z = v[2];
gc->state.current.normal.x = x;
gc->state.current.normal.y = y;
gc->state.current.normal.z = z;
}
void APIPRIVATE __glim_Color4fv(const GLfloat v[4])
{
__GL_SETUP();
gc->state.current.userColor.r = v[0];
gc->state.current.userColor.g = v[1];
gc->state.current.userColor.b = v[2];
gc->state.current.userColor.a = v[3];
(*gc->procs.applyColor)(gc);
}
void APIPRIVATE __glim_Indexf(GLfloat c)
{
__GL_SETUP();
gc->state.current.userColorIndex = c;
}
#if DBG
#define DEBUG_RASTERPOS 1
#endif
// This is not very efficient but it should work fine.
void APIPRIVATE __glim_RasterPos4fv(const GLfloat v[4])
{
POLYDATA pd3[3]; // one pa, one pd, followed by one spare.
POLYARRAY *pa = (POLYARRAY *) &pd3[0];
POLYDATA *pd = &pd3[1];
__GLvertex *rp;
GLuint oldPaNeeds, oldEnables;
#ifdef DEBUG_RASTERPOS
void (FASTCALL *oldRenderPoint)(__GLcontext *gc, __GLvertex *v);
#endif
GLuint pdflags;
__GL_SETUP_NOT_IN_BEGIN_VALIDATE();
// ASSERT_VERTEX
if (v[3] == (GLfloat) 1.0)
{
if (v[2] == (GLfloat) 0.0)
pdflags = POLYDATA_VERTEX2;
else
pdflags = POLYDATA_VERTEX3;
}
else
{
pdflags = POLYDATA_VERTEX4;
}
rp = &gc->state.current.rasterPos;
// Initialize POLYARRAY structure with one vertex
pa->flags = pdflags | POLYARRAY_RASTERPOS;
pa->pdNextVertex = pd+1;
pa->pdCurColor =
pa->pdCurNormal =
pa->pdCurTexture =
pa->pdCurEdgeFlag =
pa->pd0 = pd;
pa->primType = GL_POINTS;
pa->nIndices = 1;
pa->aIndices = NULL; // identity mapping
pa->paNext = NULL;
pd->flags = pdflags;
pd->obj = *(__GLcoord *) &v[0];
pd->color = &pd->colors[__GL_FRONTFACE];
pd->clipCode = 1; // set for debugging
(pd+1)->flags = 0;
// Set up states.
// need transformed texcoord in all cases
oldPaNeeds = gc->vertex.paNeeds;
gc->vertex.paNeeds |= PANEEDS_TEXCOORD;
// no front-end optimization
gc->vertex.paNeeds &= ~(PANEEDS_CLIP_ONLY | PANEEDS_SKIP_LIGHTING | PANEEDS_NORMAL);
// set normal need
if (gc->vertex.paNeeds & PANEEDS_RASTERPOS_NORMAL)
gc->vertex.paNeeds |= PANEEDS_NORMAL;
// don't apply cheap fog!
oldEnables = gc->state.enables.general;
gc->state.enables.general &= ~__GL_FOG_ENABLE;
#ifdef DEBUG_RASTERPOS
// Debug only!
// allow DrawPolyArray to perform selection but not feedback and rendering
oldRenderPoint = gc->procs.renderPoint;
if (gc->renderMode != GL_SELECT)
gc->procs.renderPoint = NULL; // was __glRenderPointNop but set to 0
// for debugging
#endif
// Call DrawPolyArray to 'draw' the point.
// Begin validation has already been done.
__glim_DrawPolyArray(pa);
// 'Render' the point in selection but not in feedback and render modes.
if (gc->renderMode == GL_SELECT)
{
PARenderPoint(gc, (__GLvertex *)pa->pd0);
}
// Eye coord should have been processed
ASSERTOPENGL(pa->flags & POLYARRAY_EYE_PROCESSED, "need eye\n");
// Restore states.
gc->vertex.paNeeds = oldPaNeeds;
gc->state.enables.general = oldEnables;
#ifdef DEBUG_RASTERPOS
gc->procs.renderPoint = oldRenderPoint;
#endif
// If the point is clipped, the raster position is invalid.
if (pd->clipCode)
{
gc->state.current.validRasterPos = GL_FALSE;
return;
}
gc->state.current.validRasterPos = GL_TRUE;
// Update raster pos data structure!
// Only the following fields are needed.
rp->window.x = pd->window.x;
rp->window.y = pd->window.y;
rp->window.z = pd->window.z;
rp->clip.w = pd->clip.w;
rp->eyeZ = pd->eye.z;
rp->colors[__GL_FRONTFACE] = pd->colors[__GL_FRONTFACE];
rp->texture = pd->texture;
assert(rp->color = &rp->colors[__GL_FRONTFACE]);
}
/************************************************************************/
void FASTCALL __glNop(void) {}
void FASTCALL __glNopGC(__GLcontext* gc) {}
GLboolean FASTCALL __glNopGCBOOL(__GLcontext* gc) { return FALSE; }
void FASTCALL __glNopGCFRAG(__GLcontext* gc, __GLfragment *frag, __GLtexel *texel) {}
void FASTCALL __glNopGCCOLOR(__GLcontext* gc, __GLcolor *color, __GLtexel *texel) {}
void FASTCALL __glNopLight(__GLcontext*gc, GLint i, __GLvertex*v) {}
#ifdef NT_DEADCODE_POLYARRAY
void FASTCALL __glNopVertexInt(__GLcontext *gc, __GLvertex *vx, GLuint needs) {}
void FASTCALL __glNopVertex(__GLcontext *gc, __GLvertex *vx) {}
void FASTCALL __glNopGCListOp(__GLcontext *gc, __GLdlistOp *op) {}
#endif
void FASTCALL __glNopExtract(__GLmipMapLevel *level, __GLtexture *tex,
GLint row, GLint col, __GLtexel *result) {}
#ifdef NT_DEADCODE_POLYARRAY
/*
** End a primitive that needs no special end processing
*/
void FASTCALL __glEndPrim(__GLcontext *gc)
{
gc->procs.vertex = __glNopVertex;
gc->procs.endPrim = __glEndPrim;
}
#endif
void FASTCALL ComputeColorMaterialChange(__GLcontext *gc)
{
gc->light.front.colorMaterialChange = 0;
gc->light.back.colorMaterialChange = 0;
if (gc->modes.rgbMode
&& gc->state.enables.general & __GL_COLOR_MATERIAL_ENABLE)
{
GLuint colorMaterialChange;
switch (gc->state.light.colorMaterialParam)
{
case GL_EMISSION:
colorMaterialChange = __GL_MATERIAL_EMISSIVE;
break;
case GL_SPECULAR:
colorMaterialChange = __GL_MATERIAL_SPECULAR;
break;
case GL_AMBIENT:
colorMaterialChange = __GL_MATERIAL_AMBIENT;
break;
case GL_DIFFUSE:
colorMaterialChange = __GL_MATERIAL_DIFFUSE;
break;
case GL_AMBIENT_AND_DIFFUSE:
colorMaterialChange = __GL_MATERIAL_AMBIENT | __GL_MATERIAL_DIFFUSE;
break;
}
if (gc->state.light.colorMaterialFace == GL_FRONT_AND_BACK
|| gc->state.light.colorMaterialFace == GL_FRONT)
gc->light.front.colorMaterialChange = colorMaterialChange;
if (gc->state.light.colorMaterialFace == GL_FRONT_AND_BACK
|| gc->state.light.colorMaterialFace == GL_BACK)
gc->light.back.colorMaterialChange = colorMaterialChange;
}
}
void FASTCALL __glGenericPickVertexProcs(__GLcontext *gc)
{
GLuint enables = gc->state.enables.general;
GLenum mvpMatrixType;
__GLmatrix *m;
m = &(gc->transform.modelView->mvp);
mvpMatrixType = m->matrixType;
/* Pick paClipCheck proc */
//!!! are there better clip procs?
if (gc->state.enables.clipPlanes)
{
gc->procs.paClipCheck = PAClipCheckAll;
}
else
{
if (mvpMatrixType >= __GL_MT_IS2D &&
m->matrix[3][2] >= -1.0f && m->matrix[3][2] <= 1.0f)
gc->procs.paClipCheck = PAClipCheckFrustum2D;
else
gc->procs.paClipCheck = PAClipCheckFrustum;
}
}
// Allocate the POLYDATA vertex buffer.
// Align the buffer on a cache line boundary
GLboolean FASTCALL PolyArrayAllocBuffer(__GLcontext *gc, GLuint nVertices)
{
GLuint cjSize;
// Make sure that the vertex buffer holds a minimum number of vertices.
if (nVertices < MINIMUM_POLYDATA_BUFFER_SIZE)
{
ASSERTOPENGL(FALSE, "vertex buffer too small\n");
return GL_FALSE;
}
// Allocate the vertex buffer.
cjSize = (nVertices * sizeof(POLYDATA));
if (!(gc->vertex.pdBuf = (POLYDATA *) __wglMallocAlign32(gc, cjSize)))
return GL_FALSE;
gc->vertex.pdBufSizeBytes = cjSize;
// Only (n-1) vertices are available for use. The last one is reserved
// by polyarray code.
gc->vertex.pdBufSize = nVertices - 1;
// Initialize the vertex buffer.
PolyArrayResetBuffer(gc);
return GL_TRUE;
}
// Reset the color pointers in vertex buffer.
GLvoid FASTCALL PolyArrayResetBuffer(__GLcontext *gc)
{
GLuint i;
for (i = 0; i <= gc->vertex.pdBufSize; i++)
gc->vertex.pdBuf[i].color = &gc->vertex.pdBuf[i].colors[__GL_FRONTFACE];
}
// Free the POLYDATA vertex buffer.
GLvoid FASTCALL PolyArrayFreeBuffer(__GLcontext *gc)
{
#ifdef _MCD_
// If MCD, the POLYDATA vertex buffer is freed when the MCD context is
// destroyed (see GenMcdDestroy).
if (((__GLGENcontext *) gc)->_pMcdState)
return;
#endif
if (gc->vertex.pdBuf)
__wglFreeAlign32(gc, gc->vertex.pdBuf);
gc->vertex.pdBufSizeBytes = 0;
gc->vertex.pdBufSize = 0;
}
Reference in New Issue View Git Blame Copy Permalink