/*
** Copyright 1991, 1992, 1993, 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.
*/
#include "precomp.h"
#pragma hdrstop
#include <fixed.h>
#if _X86_
#define SHADER __GLcontext.polygon.shader
#define GET_HALF_AREA(gc, a, b, c)\
\
__asm{ mov eax, a };\
__asm{ mov ecx, c };\
__asm{ mov ebx, b };\
__asm{ mov edx, gc };\
__asm{ fld DWORD PTR [OFFSET(__GLvertex.window.x)][eax] };\
__asm{ fsub DWORD PTR [OFFSET(__GLvertex.window.x)][ecx] /* dxAC */ };\
__asm{ fld DWORD PTR [OFFSET(__GLvertex.window.y)][ebx] };\
__asm{ fsub DWORD PTR [OFFSET(__GLvertex.window.y)][ecx] /* dyBC dxAC */ };\
__asm{ fld DWORD PTR [OFFSET(__GLvertex.window.x)][ebx] };\
__asm{ fsub DWORD PTR [OFFSET(__GLvertex.window.x)][ecx] /* dxBC dyBC dxAC */ };\
__asm{ fld DWORD PTR [OFFSET(__GLvertex.window.y)][eax] };\
__asm{ fsub DWORD PTR [OFFSET(__GLvertex.window.y)][ecx] /* dyAC dxBC dyBC dxAC */ };\
__asm{ fxch ST(2) /* dyBC dxBC dyAC dxAC */ };\
__asm{ fst DWORD PTR [OFFSET(SHADER.dyBC)][edx] };\
__asm{ fmul ST, ST(3) /* dxACdyBC dxBC dyAC dxAC */ };\
__asm{ fxch ST(2) /* dyAC dxBC dxACdyBC dxAC */ };\
__asm{ fst DWORD PTR [OFFSET(SHADER.dyAC)][edx] };\
__asm{ fmul ST, ST(1) /* dxBCdyAC dxBC dxACdyBC dxAC */};\
__asm{ fxch ST(1) /* dxBC dxBCdyAC dxACdyBC dxAC */};\
__asm{ fstp DWORD PTR [OFFSET(SHADER.dxBC)][edx] /* dxBCdyAC dxACdyBC dxAC */ };\
__asm{ fsubp ST(1), ST /* +1*/ /* area dxAC */ };\
__asm{ fxch ST(1) /* dxAC area */ };\
__asm{ fstp DWORD PTR [OFFSET(SHADER.dxAC)][edx] /* area */ };\
__asm{ fstp DWORD PTR [OFFSET(SHADER.area)][edx] /* +1*/ /* (empty) */ };
#define STORE_AREA_PARAMS
#else
#define GET_HALF_AREA(gc, a, b, c)\
/* Compute signed half-area of the triangle */ \
dxAC = a->window.x - c->window.x; \
dxBC = b->window.x - c->window.x; \
dyAC = a->window.y - c->window.y; \
dyBC = b->window.y - c->window.y; \
gc->polygon.shader.area = dxAC * dyBC - dxBC * dyAC;
#define STORE_AREA_PARAMS\
gc->polygon.shader.dxAC = dxAC; \
gc->polygon.shader.dxBC = dxBC; \
gc->polygon.shader.dyAC = dyAC; \
gc->polygon.shader.dyBC = dyBC;
#endif
#define SORT_AND_CULL_FACE(a, b, c, face, ccw)\
\
/* \
** Sort vertices in y. Keep track if a reversal of the winding \
** occurs in direction (0 means no reversal, 1 means reversal). \
** Save old vertex pointers in case we end up not doing a fill. \
*/ \
reversed = 0; \
if (__GL_VERTEX_COMPARE(a->window.y, <, b->window.y)) { \
if (__GL_VERTEX_COMPARE(b->window.y, <, c->window.y)) { \
/* Already sorted */ \
} else { \
if (__GL_VERTEX_COMPARE(a->window.y, <, c->window.y)) { \
temp=b; b=c; c=temp; \
reversed = 1; \
} else { \
temp=a; a=c; c=b; b=temp; \
} \
} \
} else { \
if (__GL_VERTEX_COMPARE(b->window.y, <, c->window.y)) { \
if (__GL_VERTEX_COMPARE(a->window.y, <, c->window.y)) { \
temp=a; a=b; b=temp; \
reversed = 1; \
} else { \
temp=a; a=b; b=c; c=temp; \
} \
} else { \
temp=a; a=c; c=temp; \
reversed = 1; \
} \
} \
\
GET_HALF_AREA(gc, a, b, c); \
ccw = !__GL_FLOAT_LTZ(gc->polygon.shader.area); \
\
/* \
** Figure out if face is culled or not. The face check needs to be \
** based on the vertex winding before sorting. This code uses the \
** reversed flag to invert the sense of ccw - an xor accomplishes \
** this conversion without an if test. \
** \
** ccw reversed xor \
** --- -------- --- \
** 0 0 0 (remain !ccw) \
** 1 0 1 (remain ccw) \
** 0 1 1 (become ccw) \
** 1 1 0 (become cw) \
*/ \
face = gc->polygon.face[ccw ^ reversed]; \
if (face == gc->polygon.cullFace) { \
/* Culled */ \
return; \
} \
\
STORE_AREA_PARAMS;
// #define NO_RENDERING
void __glTriangleOffsetZ( __GLcontext *gc, __GLvertex *a, __GLvertex *b,
__GLvertex *c)
{
__GLfloat dzAC, dzBC;
__GLfloat oneOverArea, t1, t2, t3, t4;
__GLfloat zOffset;
// Calc dzdxf, dzdyf values as in __glFillTriangle
/* Pre-compute one over polygon area */
if( gc->polygon.shader.area == 0.0f )
oneOverArea = (__GLfloat)(__glOne / __GL_PGON_OFFSET_NEAR_ZERO);
else
oneOverArea = __glOne / gc->polygon.shader.area;
/*
** Compute delta values for unit changes in x or y for each
** parameter.
*/
t1 = gc->polygon.shader.dyAC * oneOverArea;
t2 = gc->polygon.shader.dyBC * oneOverArea;
t3 = gc->polygon.shader.dxAC * oneOverArea;
t4 = gc->polygon.shader.dxBC * oneOverArea;
dzAC = a->window.z - c->window.z;
dzBC = b->window.z - c->window.z;
gc->polygon.shader.dzdxf = dzAC * t2 - dzBC * t1;
gc->polygon.shader.dzdyf = dzBC * t3 - dzAC * t4;
zOffset = __glPolygonOffsetZ(gc);
a->window.z += zOffset;
b->window.z += zOffset;
c->window.z += zOffset;
}
// Polygon offset z-munge: we modify the window.z of the vertices with the
// offset z, then restore the z after rendering, due to the possibility of the
// vertices being sent down multiple times by a higher-order primitive.
#define SAVE_WINDOW_Z \
awinz = a->window.z; bwinz = b->window.z; cwinz = c->window.z;
#define RESTORE_WINDOW_Z \
a->window.z = awinz; \
b->window.z = bwinz; \
c->window.z = cwinz;
#ifdef GL_EXT_flat_paletted_lighting
void __glPickLightingPalette(__GLcontext *gc)
{
__GLtexture *tex;
GLint loffset;
tex = gc->texture.currentTexture;
loffset = (GLint)(gc->vertex.provoking->color->r *
gc->oneOverRedVertexScale *
tex->paletteDivision) << tex->paletteDivShift;
tex->paletteData = tex->paletteTotalData+loffset;
__glGenSetPaletteOffset(gc, tex, loffset);
}
#endif GL_EXT_flat_paletted_lighting
/*
** Generic triangle handling code. This code is used when render mode
** is GL_RENDER and the polygon modes are not both fill.
*/
void FASTCALL __glRenderTriangle(__GLcontext *gc, __GLvertex *a,
__GLvertex *b, __GLvertex *c)
{
GLuint needs, modeFlags, faceNeeds;
GLint ccw, colorFace, reversed, face;
__GLfloat dxAC, dxBC, dyAC, dyBC;
__GLvertex *oa, *ob, *oc;
__GLvertex *temp;
__GLfloat awinz, bwinz, cwinz;
#ifdef NO_RENDERING
return;
#endif
oa = a; ob = b; oc = c;
SORT_AND_CULL_FACE(a, b, c, face, ccw);
/*
** Pick face to use for coloring
*/
modeFlags = gc->polygon.shader.modeFlags;
#ifdef NT
if (modeFlags & __GL_SHADE_SMOOTH_LIGHT)
{ /* Smooth shading */
if (modeFlags & __GL_SHADE_TWOSIDED && face == __GL_BACKFACE)
{
a->color++;
b->color++;
c->color++;
}
}
#ifdef GL_WIN_phong_shading
else if (modeFlags & __GL_SHADE_PHONG)
{ /* Phong shading */
if (modeFlags & __GL_SHADE_TWOSIDED && face == __GL_BACKFACE)
gc->polygon.shader.phong.face = __GL_BACKFACE;
else
gc->polygon.shader.phong.face = __GL_FRONTFACE;
}
#endif //GL_WIN_phong_shading
else
{ /* Flat shading */
__GLvertex *pv = gc->vertex.provoking;
if (modeFlags & __GL_SHADE_TWOSIDED && face == __GL_BACKFACE)
pv->color++;
a->color = pv->color;
b->color = pv->color;
c->color = pv->color;
}
#else
if (modeFlags & __GL_SHADE_TWOSIDED) {
colorFace = face;
faceNeeds = gc->vertex.faceNeeds[face];
} else {
colorFace = __GL_FRONTFACE;
faceNeeds = gc->vertex.faceNeeds[__GL_FRONTFACE];
}
/*
** Choose colors for the vertices.
*/
needs = gc->vertex.needs;
pv = gc->vertex.provoking;
if (modeFlags & __GL_SHADE_SMOOTH_LIGHT) {
/* Smooth shading */
a->color = &a->colors[colorFace];
b->color = &b->colors[colorFace];
c->color = &c->colors[colorFace];
needs |= faceNeeds;
} else {
GLuint pvneeds;
/*
** Validate the lighting (and color) information in the provoking
** vertex only. Fill routines always use gc->vertex.provoking->color
** to find the color.
*/
pv->color = &pv->colors[colorFace];
a->color = pv->color;
b->color = pv->color;
c->color = pv->color;
pvneeds = faceNeeds & (__GL_HAS_LIGHTING |
__GL_HAS_FRONT_COLOR | __GL_HAS_BACK_COLOR);
if (~pv->has & pvneeds) {
(*pv->validate)(gc, pv, pvneeds);
}
}
/* Validate vertices */
if (~a->has & needs) (*a->validate)(gc, a, needs);
if (~b->has & needs) (*b->validate)(gc, b, needs);
if (~c->has & needs) (*c->validate)(gc, c, needs);
#endif
/* Render triangle using the faces polygon mode */
switch (gc->polygon.mode[face]) {
case __GL_POLYGON_MODE_FILL:
if (__GL_FLOAT_NEZ(gc->polygon.shader.area)) {
#ifdef GL_EXT_flat_paletted_lighting
if ((gc->state.enables.general & __GL_PALETTED_LIGHTING_ENABLE) &&
(modeFlags & __GL_SHADE_SMOOTH_LIGHT) == 0 &&
gc->texture.currentTexture != NULL)
{
__glPickLightingPalette(gc);
}
#endif
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
}
break;
case __GL_POLYGON_MODE_POINT:
if( gc->state.enables.general & __GL_POLYGON_OFFSET_POINT_ENABLE ) {
SAVE_WINDOW_Z;
__glTriangleOffsetZ( gc, a, b, c );
}
#ifdef NT
if (oa->has & __GL_HAS_EDGEFLAG_BOUNDARY)
(*gc->procs.renderPoint)(gc, oa);
if (ob->has & __GL_HAS_EDGEFLAG_BOUNDARY)
(*gc->procs.renderPoint)(gc, ob);
if (oc->has & __GL_HAS_EDGEFLAG_BOUNDARY)
(*gc->procs.renderPoint)(gc, oc);
if( gc->state.enables.general & __GL_POLYGON_OFFSET_POINT_ENABLE ) {
RESTORE_WINDOW_Z;
}
break;
#else
if (oa->boundaryEdge) (*gc->procs.renderPoint)(gc, oa);
if (ob->boundaryEdge) (*gc->procs.renderPoint)(gc, ob);
if (oc->boundaryEdge) (*gc->procs.renderPoint)(gc, oc);
break;
#endif
case __GL_POLYGON_MODE_LINE:
if( gc->state.enables.general & __GL_POLYGON_OFFSET_LINE_ENABLE ) {
SAVE_WINDOW_Z;
__glTriangleOffsetZ( gc, a, b, c );
}
#ifdef NT
(*gc->procs.lineBegin)(gc);
if ((oa->has & __GL_HAS_EDGEFLAG_BOUNDARY) &&
(ob->has & __GL_HAS_EDGEFLAG_BOUNDARY) &&
(oc->has & __GL_HAS_EDGEFLAG_BOUNDARY))
{
// Is this an important case to optimize?
(*gc->procs.renderLine)(gc, oa, ob, __GL_LVERT_FIRST);
(*gc->procs.renderLine)(gc, ob, oc, 0);
(*gc->procs.renderLine)(gc, oc, oa, 0);
}
else
{
if (oa->has & __GL_HAS_EDGEFLAG_BOUNDARY)
{
(*gc->procs.renderLine)(gc, oa, ob, __GL_LVERT_FIRST);
}
if (ob->has & __GL_HAS_EDGEFLAG_BOUNDARY)
{
(*gc->procs.renderLine)(gc, ob, oc, __GL_LVERT_FIRST);
}
if (oc->has & __GL_HAS_EDGEFLAG_BOUNDARY)
{
(*gc->procs.renderLine)(gc, oc, oa, __GL_LVERT_FIRST);
}
}
(*gc->procs.lineEnd)(gc);
if( gc->state.enables.general & __GL_POLYGON_OFFSET_LINE_ENABLE ) {
RESTORE_WINDOW_Z;
}
break;
#else
if (oa->boundaryEdge) {
(*gc->procs.renderLine)(gc, oa, ob);
}
if (ob->boundaryEdge) {
(*gc->procs.renderLine)(gc, ob, oc);
}
if (oc->boundaryEdge) {
(*gc->procs.renderLine)(gc, oc, oa);
}
break;
#endif
}
/* Restore color pointers */
a->color = &a->colors[__GL_FRONTFACE];
b->color = &b->colors[__GL_FRONTFACE];
c->color = &c->colors[__GL_FRONTFACE];
#ifdef NT
if (!(modeFlags & __GL_SHADE_SMOOTH_LIGHT)
#ifdef GL_WIN_phong_shading
&& !(modeFlags & __GL_SHADE_PHONG)
#endif //GL_WIN_phong_shading
)
{
__GLvertex *pv = gc->vertex.provoking;
pv->color = &pv->colors[__GL_FRONTFACE];
}
#else
pv->color = &pv->colors[__GL_FRONTFACE];
#endif
}
/************************************************************************/
/*
** Generic triangle handling code. This code is used when render mode
** is GL_RENDER and both polygon modes are FILL and the triangle is
** being flat shaded.
*/
void FASTCALL __glRenderFlatTriangle(__GLcontext *gc, __GLvertex *a, __GLvertex *b,
__GLvertex *c)
{
GLuint needs, pvneeds, modeFlags, faceNeeds;
GLint ccw, colorFace, reversed, face;
__GLfloat dxAC, dxBC, dyAC, dyBC;
__GLvertex *temp;
#ifdef NO_RENDERING
return;
#endif
SORT_AND_CULL_FACE(a, b, c, face, ccw);
if (__GL_FLOAT_EQZ(gc->polygon.shader.area))
return;
/*
** Pick face to use for coloring
*/
modeFlags = gc->polygon.shader.modeFlags;
#ifdef GL_EXT_flat_paletted_lighting
ASSERTOPENGL((modeFlags & __GL_SHADE_SMOOTH_LIGHT) == 0,
"Flat triangle with smooth shading\n");
if ((gc->state.enables.general & __GL_PALETTED_LIGHTING_ENABLE) &&
gc->texture.currentTexture != NULL)
{
__glPickLightingPalette(gc);
}
#endif
#ifdef NT
//!!! don't we need to update a,b,c color pointers if cheap fog is enabled?
if (modeFlags & __GL_SHADE_TWOSIDED && face == __GL_BACKFACE)
{
__GLvertex *pv = gc->vertex.provoking;
/* Fill triangle */
pv->color++;
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
pv->color--;
}
else
{
/* Fill triangle */
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
}
#else
if (modeFlags & __GL_SHADE_TWOSIDED) {
colorFace = face;
faceNeeds = gc->vertex.faceNeeds[face];
} else {
colorFace = __GL_FRONTFACE;
faceNeeds = gc->vertex.faceNeeds[__GL_FRONTFACE];
}
/*
** Choose colors for the vertices.
*/
needs = gc->vertex.needs;
pv = gc->vertex.provoking;
/*
** Validate the lighting (and color) information in the provoking
** vertex only. Fill routines always use gc->vertex.provoking->color
** to find the color.
*/
pv->color = &pv->colors[colorFace];
pvneeds = faceNeeds & (__GL_HAS_LIGHTING |
__GL_HAS_FRONT_COLOR | __GL_HAS_BACK_COLOR);
if (~pv->has & pvneeds) {
(*pv->validate)(gc, pv, pvneeds);
}
/* Validate vertices */
if (~a->has & needs) (*a->validate)(gc, a, needs);
if (~b->has & needs) (*b->validate)(gc, b, needs);
if (~c->has & needs) (*c->validate)(gc, c, needs);
/* Fill triangle */
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
/* Restore color pointers */
pv->color = &pv->colors[__GL_FRONTFACE];
#endif
}
/************************************************************************/
/*
** Generic triangle handling code. This code is used when render mode
** is GL_RENDER and both polygon modes are FILL and the triangle is
** being smooth shaded.
*/
void FASTCALL __glRenderSmoothTriangle(__GLcontext *gc, __GLvertex *a, __GLvertex *b,
__GLvertex *c)
{
GLuint needs, modeFlags;
GLint ccw, colorFace, reversed, face;
__GLfloat dxAC, dxBC, dyAC, dyBC;
__GLvertex *temp;
#ifdef NO_RENDERING
return;
#endif
SORT_AND_CULL_FACE(a, b, c, face, ccw);
if (__GL_FLOAT_EQZ(gc->polygon.shader.area))
return;
/*
** Pick face to use for coloring
*/
modeFlags = gc->polygon.shader.modeFlags;
#ifdef GL_EXT_flat_paletted_lighting
// No lighting because smooth shading is always on in this routine
#endif
#ifdef NT
if (modeFlags & __GL_SHADE_TWOSIDED && face == __GL_BACKFACE)
{
/* Fill triangle */
a->color++;
b->color++;
c->color++;
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
a->color--;
b->color--;
c->color--;
}
else
{
/* Fill triangle */
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
}
#else
needs = gc->vertex.needs;
if (modeFlags & __GL_SHADE_TWOSIDED) {
colorFace = face;
needs |= gc->vertex.faceNeeds[face];
} else {
colorFace = __GL_FRONTFACE;
needs |= gc->vertex.faceNeeds[__GL_FRONTFACE];
}
/*
** Choose colors for the vertices.
*/
a->color = &a->colors[colorFace];
b->color = &b->colors[colorFace];
c->color = &c->colors[colorFace];
/* Validate vertices */
if (~a->has & needs) (*a->validate)(gc, a, needs);
if (~b->has & needs) (*b->validate)(gc, b, needs);
if (~c->has & needs) (*c->validate)(gc, c, needs);
/* Fill triangle */
(*gc->procs.fillTriangle)(gc, a, b, c, (GLboolean) ccw);
/* Restore color pointers */
a->color = &a->colors[__GL_FRONTFACE];
b->color = &b->colors[__GL_FRONTFACE];
c->color = &c->colors[__GL_FRONTFACE];
#endif
}
void FASTCALL __glDontRenderTriangle(__GLcontext *gc, __GLvertex *a, __GLvertex *b,
__GLvertex *c)
{
}