1797 lines
53 KiB
C++
1797 lines
53 KiB
C++
#include "pch.cpp"
|
|
#pragma hdrstop
|
|
|
|
#define GET_NEW_CLIP_VERTEX \
|
|
&clip_vertices[clip_vertices_used++];
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
inline void
|
|
InterpolateColor(RDClipVertex *out,
|
|
RDClipVertex *p1,
|
|
RDClipVertex *p2,
|
|
D3DVALUE num_denom )
|
|
{
|
|
FLOAT r1, g1, b1, a1;
|
|
FLOAT r2, g2, b2, a2;
|
|
|
|
r1 = p1->m_diffuse.r;
|
|
g1 = p1->m_diffuse.g;
|
|
b1 = p1->m_diffuse.b;
|
|
a1 = p1->m_diffuse.a;
|
|
r2 = p2->m_diffuse.r;
|
|
g2 = p2->m_diffuse.g;
|
|
b2 = p2->m_diffuse.b;
|
|
a2 = p2->m_diffuse.a;
|
|
out->m_diffuse.r = (r1 + (r2 - r1) * num_denom);
|
|
out->m_diffuse.g = (g1 + (g2 - g1) * num_denom);
|
|
out->m_diffuse.b = (b1 + (b2 - b1) * num_denom);
|
|
out->m_diffuse.a = (a1 + (a2 - a1) * num_denom);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
inline void
|
|
InterpolateSpecular(RDClipVertex *out,
|
|
RDClipVertex *p1,
|
|
RDClipVertex *p2,
|
|
D3DVALUE num_denom )
|
|
{
|
|
FLOAT r1, g1, b1, a1;
|
|
FLOAT r2, g2, b2, a2;
|
|
|
|
r1 = p1->m_specular.r;
|
|
g1 = p1->m_specular.g;
|
|
b1 = p1->m_specular.b;
|
|
a1 = p1->m_specular.a;
|
|
r2 = p2->m_specular.r;
|
|
g2 = p2->m_specular.g;
|
|
b2 = p2->m_specular.b;
|
|
a2 = p2->m_specular.a;
|
|
out->m_specular.r = (r1 + (r2 - r1) * num_denom);
|
|
out->m_specular.g = (g1 + (g2 - g1) * num_denom);
|
|
out->m_specular.b = (b1 + (b2 - b1) * num_denom);
|
|
out->m_specular.a = (a1 + (a2 - a1) * num_denom);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
// Inline texture coordinate difference.
|
|
__inline FLOAT
|
|
TextureDiff(FLOAT fTb, FLOAT fTa, INT iMode)
|
|
{
|
|
FLOAT fDiff1 = fTb - fTa;
|
|
|
|
if( iMode == 0 )
|
|
{
|
|
// Wrap not set, return plain difference.
|
|
return fDiff1;
|
|
}
|
|
else
|
|
{
|
|
FLOAT fDiff2;
|
|
|
|
// Wrap set, compute shortest distance of plain difference
|
|
// and wrap difference.
|
|
|
|
fDiff2 = fDiff1;
|
|
if( FLOAT_LTZ(fDiff1) )
|
|
{
|
|
fDiff2 += g_fOne;
|
|
}
|
|
else if( FLOAT_GTZ(fDiff1) )
|
|
{
|
|
fDiff2 -= g_fOne;
|
|
}
|
|
if( ABSF(fDiff1) < ABSF(fDiff2) )
|
|
{
|
|
return fDiff1;
|
|
}
|
|
else
|
|
{
|
|
return fDiff2;
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
inline D3DVALUE
|
|
InterpolateTexture(D3DVALUE t1,
|
|
D3DVALUE t2,
|
|
D3DVALUE num_denom,
|
|
DWORD bWrap)
|
|
{
|
|
if( !bWrap )
|
|
{
|
|
return ((t2 - t1) * num_denom + t1);
|
|
}
|
|
else
|
|
{
|
|
D3DVALUE t = (TextureDiff(t2, t1, 1) * num_denom + t1);
|
|
if( t > 1.0f ) t -= 1.0f;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// RefClipper implementation
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
const DWORD RefClipper::RCLIP_DIRTY_ZRANGE = (1 << 0);
|
|
const DWORD RefClipper::RCLIP_DIRTY_VIEWRECT = (1 << 1);
|
|
const DWORD RefClipper::RCLIP_DO_FLATSHADING = (1 << 2);
|
|
const DWORD RefClipper::RCLIP_DO_WIREFRAME = (1 << 3);
|
|
const DWORD RefClipper::RCLIP_DO_ADJUSTWRAP = (1 << 4);
|
|
const DWORD RefClipper::RCLIP_Z_ENABLE = (1 << 5);
|
|
|
|
RefClipper::RefClipper()
|
|
{
|
|
m_dwFlags = 0;
|
|
memset( &m_Viewport, 0, sizeof( m_Viewport) );
|
|
|
|
dvX = dvY = dvWidth = dvHeight = 0.0f;
|
|
scaleX = scaleY = scaleZ = 0.0f;
|
|
offsetX = offsetY = offsetZ = 0.0f;
|
|
scaleXi = scaleYi = scaleZi = 0.0f;
|
|
minX = minY = maxX = maxY = 0.0f;
|
|
minXgb = minYgb = maxXgb = maxYgb = 0.0f;
|
|
gb11 = gb22 = gb41 = gb42 = 0.0f;
|
|
Kgbx1 = Kgby1 = Kgbx2 = Kgby2 = 0.0f;
|
|
|
|
memset( clip_vbuf1, 0, sizeof(RDClipVertex*)*RD_MAX_CLIP_VERTICES );
|
|
memset( clip_vbuf2, 0, sizeof(RDClipVertex*)*RD_MAX_CLIP_VERTICES );
|
|
current_vbuf = 0;
|
|
memset( clip_vertices, 0, sizeof(RDClipVertex)*RD_MAX_CLIP_VERTICES );
|
|
m_dwInterpolate = 0;
|
|
clip_vertices_used = 0;
|
|
|
|
m_clipUnion = 0;
|
|
m_clipIntersection = 0;
|
|
|
|
// By default enable Guardband and set the extents equal
|
|
// to the default RefRast parameters
|
|
m_bUseGB = TRUE;
|
|
minXgb = (RD_GB_LEFT);
|
|
maxXgb = RD_GB_RIGHT;
|
|
minYgb = (RD_GB_TOP);
|
|
maxYgb = RD_GB_BOTTOM;
|
|
|
|
memset( m_userClipPlanes, 0, sizeof(RDVECTOR4)*RD_MAX_USER_CLIPPLANES );
|
|
|
|
#if DBG
|
|
DWORD v = 0;
|
|
// Guardband parameters
|
|
if( GetD3DRegValue(REG_DWORD, "DisableGB", &v, 4) && v != 0 )
|
|
{
|
|
m_bUseGB = FALSE;
|
|
}
|
|
// Try to get test values for the guard band
|
|
char value[80];
|
|
if( GetD3DRegValue(REG_SZ, "GuardBandLeft", &value, 80) &&
|
|
value[0] != 0 )
|
|
sscanf(value, "%f", &minXgb);
|
|
if( GetD3DRegValue(REG_SZ, "GuardBandRight", &value, 80) &&
|
|
value[0] != 0 )
|
|
sscanf(value, "%f", &maxXgb);
|
|
if( GetD3DRegValue(REG_SZ, "GuardBandTop", &value, 80) &&
|
|
value[0] != 0 )
|
|
sscanf(value, "%f", &minYgb);
|
|
if( GetD3DRegValue(REG_SZ, "GuardBandBottom", &value, 80) &&
|
|
value[0] != 0 )
|
|
sscanf(value, "%f", &maxYgb);
|
|
#endif // DBG
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// RefClipper::UpdateViewData
|
|
// Updates View data used by ProcessVertices[VVM]
|
|
//---------------------------------------------------------------------
|
|
HRESULT
|
|
RefClipper::UpdateViewData()
|
|
{
|
|
HRESULT hr = D3D_OK;
|
|
|
|
// Update viewport information
|
|
if( m_dwFlags & RCLIP_DIRTY_ZRANGE )
|
|
{
|
|
scaleZ = m_Viewport.dvMaxZ - m_Viewport.dvMinZ;
|
|
offsetZ = m_Viewport.dvMinZ;
|
|
// ATTENTION: This could be a Divide by Zero here if
|
|
// the dvMaxZ == dvMinZ. Fix it later.
|
|
scaleZi = D3DVAL(1) / scaleZ;
|
|
}
|
|
|
|
if( m_dwFlags & RCLIP_DIRTY_VIEWRECT )
|
|
{
|
|
// Bail if we are going to cause any divide by zero exceptions.
|
|
// The likely reason is that we have a bogus viewport set by
|
|
// TLVertex execute buffer app.
|
|
if(m_Viewport.dwWidth == 0 || m_Viewport.dwHeight == 0 )
|
|
return DDERR_GENERIC;
|
|
|
|
dvX = D3DVAL(m_Viewport.dwX);
|
|
dvY = D3DVAL(m_Viewport.dwY);
|
|
dvWidth = D3DVAL(m_Viewport.dwWidth);
|
|
dvHeight = D3DVAL(m_Viewport.dwHeight);
|
|
|
|
// Coefficients to compute screen coordinates from normalized window
|
|
// coordinates
|
|
scaleX = dvWidth;
|
|
scaleY = - dvHeight;
|
|
offsetX = dvX;
|
|
offsetY = dvY + dvHeight;
|
|
|
|
#if 0
|
|
// Small offset is added to prevent generation of negative screen
|
|
// coordinates (this could happen because of precision errors).
|
|
// Not needed (or wanted) for devices which do guardband.
|
|
offsetX += SMALL_NUMBER;
|
|
offsetY += SMALL_NUMBER;
|
|
#endif
|
|
|
|
scaleXi = D3DVAL(1) / scaleX;
|
|
scaleYi = D3DVAL(1) / scaleY;
|
|
|
|
minX = dvX;
|
|
maxX = dvX + dvWidth;
|
|
minY = dvY;
|
|
maxY = dvY + dvHeight;
|
|
|
|
if( m_bUseGB )
|
|
{
|
|
// Because we clip by guard band window we have to use its extents
|
|
D3DVALUE w = 2.0f / dvWidth;
|
|
D3DVALUE h = 2.0f / dvHeight;
|
|
D3DVALUE ax1 = -(minXgb - dvX) * w + 1.0f;
|
|
D3DVALUE ax2 = (maxXgb - dvX) * w - 1.0f;
|
|
D3DVALUE ay1 = (maxYgb - dvY) * h - 1.0f;
|
|
D3DVALUE ay2 = -(minYgb - dvY) * h + 1.0f;
|
|
gb11 = 2.0f / (ax1 + ax2);
|
|
gb41 = gb11 * (ax1 - 1.0f) * 0.5f;
|
|
gb22 = 2.0f / (ay1 + ay2);
|
|
gb42 = gb22 * (ay1 - 1.0f) * 0.5f;
|
|
|
|
Kgbx1 = 0.5f * (1.0f - ax1);
|
|
Kgbx2 = 0.5f * (1.0f + ax2);
|
|
Kgby1 = 0.5f * (1.0f - ay1);
|
|
Kgby2 = 0.5f * (1.0f + ay2);
|
|
}
|
|
else
|
|
{
|
|
minXgb = minX;
|
|
maxXgb = maxX;
|
|
minYgb = minY;
|
|
maxYgb = maxY;
|
|
}
|
|
}
|
|
|
|
// Clear the dirty transform flags
|
|
m_dwFlags &= ~(RCLIP_DIRTY_VIEWRECT | RCLIP_DIRTY_ZRANGE);
|
|
return hr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Make clip vertex from RDVertex
|
|
//
|
|
// cv - clipVertex
|
|
// v - a TL vertex
|
|
// qwFVF - FVF of the input TL vertex
|
|
//---------------------------------------------------------------------
|
|
void
|
|
RefClipper::MakeClipVertexFromVertex( RDClipVertex& cv, RDVertex& v,
|
|
DWORD dwClipMask )
|
|
{
|
|
DWORD dwClipFlag = (DWORD) v.m_clip;
|
|
|
|
memcpy( &cv, &v, sizeof( RDVertex ) );
|
|
|
|
// If the clip flag for this vertex is set, that means that the
|
|
// transformation loop has not computed the screen coordinates for
|
|
// this vertex, it has simply stored the clip coordinates for this
|
|
// vertex
|
|
#if 0
|
|
if( v.m_clip & dwClipMask )
|
|
{
|
|
// This is a clipped vertex, simply no screen coordinates
|
|
cv.m_pos.x = D3DVALUE(0);
|
|
cv.m_pos.y = D3DVALUE(0);
|
|
cv.m_pos.z = D3DVALUE(0);
|
|
cv.m_rhw = D3DVALUE(0);
|
|
|
|
// Since this vertex has been clipped, the transformation loop
|
|
// has put in the clip coordinates instead
|
|
cv.hx = v.m_pos.x;
|
|
cv.hy = v.m_pos.y;
|
|
cv.hz = v.m_pos.z;
|
|
cv.hw = v.m_rhw;
|
|
}
|
|
else
|
|
{
|
|
// This vertex is not clipped, so its screen coordinates have been
|
|
// computed
|
|
|
|
// Transform the screen coordinate back to the clipping space
|
|
cv.hw = 1.0f / cv.m_rhw;
|
|
cv.hx = (cv.m_pos.x - offsetX) * cv.hw * scaleXi;
|
|
cv.hy = (cv.m_pos.y - offsetY) * cv.hw * scaleYi;
|
|
cv.hz = (cv.m_pos.z - offsetZ) * cv.hw * scaleZi;
|
|
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// RefVP::ComputeClipCodes
|
|
//---------------------------------------------------------------------
|
|
RDCLIPCODE
|
|
RefClipper::ComputeClipCodes(RDCLIPCODE* pclipIntersection,
|
|
RDCLIPCODE* pclipUnion,
|
|
FLOAT x_clip, FLOAT y_clip,
|
|
FLOAT z_clip, FLOAT w_clip)
|
|
{
|
|
D3DVALUE xx = w_clip - x_clip;
|
|
D3DVALUE yy = w_clip - y_clip;
|
|
D3DVALUE zz = w_clip - z_clip;
|
|
|
|
// if( x < 0 ) clip |= RDCLIP_LEFTBIT;
|
|
// if( x >= we ) clip |= RDCLIP_RIGHTBIT;
|
|
// if( y < 0 ) clip |= RDCLIP_BOTTOMBIT;
|
|
// if( y >= we ) clip |= RDCLIP_TOPBIT;
|
|
// if( z < 0 ) clip |= RDCLIP_FRONTBIT;
|
|
// if( z >= we ) clip |= RDCLIP_BACKBIT;
|
|
RDCLIPCODE clip =
|
|
((AS_INT32(x_clip) & 0x80000000) >> (32-RDCLIP_LEFTBIT)) |
|
|
((AS_INT32(y_clip) & 0x80000000) >> (32-RDCLIP_BOTTOMBIT))|
|
|
((AS_INT32(z_clip) & 0x80000000) >> (32-RDCLIP_FRONTBIT)) |
|
|
((AS_INT32(xx) & 0x80000000) >> (32-RDCLIP_RIGHTBIT)) |
|
|
((AS_INT32(yy) & 0x80000000) >> (32-RDCLIP_TOPBIT)) |
|
|
((AS_INT32(zz) & 0x80000000) >> (32-RDCLIP_BACKBIT));
|
|
|
|
RDCLIPCODE clipBit = RDCLIP_USERCLIPPLANE0;
|
|
for( DWORD j=0; j<RD_MAX_USER_CLIPPLANES; j++)
|
|
{
|
|
if( m_xfmUserClipPlanes[j].bActive )
|
|
{
|
|
RDVECTOR4& plane = m_xfmUserClipPlanes[j].plane;
|
|
FLOAT fComp = 0.0f;
|
|
if( (x_clip*plane.x +
|
|
y_clip*plane.y +
|
|
z_clip*plane.z +
|
|
w_clip*plane.w) < fComp )
|
|
{
|
|
clip |= clipBit;
|
|
}
|
|
}
|
|
clipBit <<= 1;
|
|
}
|
|
|
|
if( clip == 0 )
|
|
{
|
|
*pclipIntersection = 0;
|
|
return clip;
|
|
}
|
|
else
|
|
{
|
|
if( m_bUseGB )
|
|
{
|
|
// We do guardband check in the projection space, so
|
|
// we transform X and Y of the vertex there
|
|
D3DVALUE xnew = x_clip * gb11 +
|
|
w_clip * gb41;
|
|
D3DVALUE ynew = y_clip * gb22 +
|
|
w_clip * gb42;
|
|
D3DVALUE xx = w_clip - xnew;
|
|
D3DVALUE yy = w_clip - ynew;
|
|
clip |= ((AS_INT32(xnew) & 0x80000000) >> (32-RDCLIPGB_LEFTBIT)) |
|
|
((AS_INT32(ynew) & 0x80000000) >> (32-RDCLIPGB_BOTTOMBIT)) |
|
|
((AS_INT32(xx) & 0x80000000) >> (32-RDCLIPGB_RIGHTBIT)) |
|
|
((AS_INT32(yy) & 0x80000000) >> (32-RDCLIPGB_TOPBIT));
|
|
}
|
|
*pclipIntersection &= clip;
|
|
*pclipUnion |= clip;
|
|
return clip;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// RefVP::ComputeClipCodesTL
|
|
//---------------------------------------------------------------------
|
|
void
|
|
RefClipper::ComputeClipCodesTL( RDVertex* pVtx )
|
|
{
|
|
FLOAT x, y, z;
|
|
DWORD clip = 0;
|
|
|
|
_ASSERT( FVF_TRANSFORMED( pVtx->m_qwFVF ),
|
|
"Can compute clipcodes only for Transformed vertices." );
|
|
DWORD clipZF = (m_dwFlags & RCLIP_Z_ENABLE) ? RDCLIP_FRONT : 0;
|
|
DWORD clipZB = (m_dwFlags & RCLIP_Z_ENABLE) ? RDCLIP_BACK : 0;
|
|
|
|
// Invert to compenstate for the sign during the
|
|
// divide by w.
|
|
if( pVtx->m_rhw < 0 )
|
|
{
|
|
x = -pVtx->m_pos.x;
|
|
y = -pVtx->m_pos.y;
|
|
z = -pVtx->m_pos.z;
|
|
}
|
|
else
|
|
{
|
|
x = pVtx->m_pos.x;
|
|
y = pVtx->m_pos.y;
|
|
z = pVtx->m_pos.z;
|
|
}
|
|
|
|
if( x < minX )
|
|
clip |= RDCLIP_LEFT;
|
|
else if( x >= maxX )
|
|
clip |= RDCLIP_RIGHT;
|
|
|
|
if (y < minY)
|
|
clip |= RDCLIP_TOP;
|
|
else if (y >= maxY)
|
|
clip |= RDCLIP_BOTTOM;
|
|
|
|
if (z < 0.0f)
|
|
clip |= clipZF;
|
|
else if (z >= 1.0f)
|
|
clip |= clipZB;
|
|
|
|
if( m_bUseGB )
|
|
{
|
|
if( x < minXgb )
|
|
clip |= RDCLIPGB_LEFT;
|
|
else if( x >= maxXgb )
|
|
clip |= RDCLIPGB_RIGHT;
|
|
|
|
if( y < minYgb )
|
|
clip |= RDCLIPGB_TOP;
|
|
else if( y >= maxYgb )
|
|
clip |= RDCLIPGB_BOTTOM;
|
|
}
|
|
|
|
pVtx->m_clip = clip;
|
|
|
|
// Back transform to obtain the clip-coordinates
|
|
pVtx->m_clip_w = 1.0f / pVtx->m_rhw; // This is w_clip
|
|
pVtx->m_clip_x = (pVtx->m_pos.x - offsetX) * pVtx->m_clip_w * scaleXi;
|
|
pVtx->m_clip_y = (pVtx->m_pos.y - offsetY) * pVtx->m_clip_w * scaleYi;
|
|
pVtx->m_clip_z = (pVtx->m_pos.z - offsetZ) * pVtx->m_clip_w * scaleZi;
|
|
|
|
return;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Clipping a triangle by a plane
|
|
//
|
|
// Returns number of vertices in the clipped triangle
|
|
//---------------------------------------------------------------------
|
|
int
|
|
RefClipper::ClipByPlane( RDClipVertex **inv, RDClipVertex **outv,
|
|
RDVECTOR4 *plane, DWORD dwClipFlag, int count )
|
|
{
|
|
int i;
|
|
int out_count = 0;
|
|
RDClipVertex *curr, *prev;
|
|
D3DVALUE curr_inside;
|
|
D3DVALUE prev_inside;
|
|
|
|
prev = inv[count-1];
|
|
curr = *inv++;
|
|
prev_inside = prev->m_clip_x*plane->x + prev->m_clip_y*plane->y +
|
|
prev->m_clip_z*plane->z + prev->m_clip_w*plane->w;
|
|
for (i = count; i; i--)
|
|
{
|
|
curr_inside = curr->m_clip_x*plane->x + curr->m_clip_y*plane->y +
|
|
curr->m_clip_z*plane->z + curr->m_clip_w*plane->w;
|
|
// We interpolate always from the inside vertex to the outside vertex
|
|
// to reduce precision problems
|
|
if( FLOAT_LTZ(prev_inside) )
|
|
{ // first point is outside
|
|
if( FLOAT_GEZ(curr_inside) )
|
|
{ // second point is inside
|
|
// Find intersection and insert in into the output buffer
|
|
outv[out_count] = GET_NEW_CLIP_VERTEX;
|
|
outv[out_count]->m_qwFVF = prev->m_qwFVF;
|
|
Interpolate( outv[out_count],
|
|
curr, prev,
|
|
(prev->m_clip & CLIPPED_ENABLE) | dwClipFlag,
|
|
curr_inside, curr_inside - prev_inside);
|
|
out_count++;
|
|
}
|
|
} else
|
|
{ // first point is inside - put it to the output buffer first
|
|
outv[out_count++] = prev;
|
|
if( FLOAT_LTZ(curr_inside) )
|
|
{ // second point is outside
|
|
// Find intersection and put it to the output buffer
|
|
outv[out_count] = GET_NEW_CLIP_VERTEX;
|
|
outv[out_count]->m_qwFVF = prev->m_qwFVF;
|
|
Interpolate( outv[out_count],
|
|
prev, curr,
|
|
dwClipFlag,
|
|
prev_inside, prev_inside - curr_inside);
|
|
out_count++;
|
|
}
|
|
}
|
|
prev = curr;
|
|
curr = *inv++;
|
|
prev_inside = curr_inside;
|
|
}
|
|
return out_count;
|
|
}
|
|
//-------------------------------------------------------------------------
|
|
// Clips a line by a plane
|
|
//
|
|
// Returns 1 if the line is outside the frustum, 0 otherwise
|
|
//
|
|
int
|
|
RefClipper::ClipLineByPlane( RDCLIPTRIANGLE *line, RDVECTOR4 *plane,
|
|
DWORD dwClipBit )
|
|
{
|
|
D3DVALUE in1, in2;
|
|
RDClipVertex outv;
|
|
in1 = line->v[0]->m_clip_x * plane->x +
|
|
line->v[0]->m_clip_y * plane->y +
|
|
line->v[0]->m_clip_z * plane->z +
|
|
line->v[0]->m_clip_w * plane->w;
|
|
in2 = line->v[1]->m_clip_x * plane->x +
|
|
line->v[1]->m_clip_y * plane->y +
|
|
line->v[1]->m_clip_z * plane->z +
|
|
line->v[1]->m_clip_w * plane->w;
|
|
if( in1 < 0 )
|
|
{
|
|
if( in2 < 0 )
|
|
return 1;
|
|
Interpolate( &outv, line->v[0], line->v[1],
|
|
dwClipBit, in1, in1 - in2);
|
|
*line->v[0] = outv;
|
|
}
|
|
else
|
|
{
|
|
if( in2 < 0 )
|
|
{
|
|
Interpolate( &outv, line->v[0], line->v[1],
|
|
dwClipBit, in1, in1 - in2);
|
|
*line->v[1] = outv;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
/*------------------------------------------------------------------------
|
|
* Calculate the screen coords for any new vertices
|
|
* introduced into the polygon.
|
|
*/
|
|
void
|
|
RefClipper::ComputeScreenCoordinates( RDClipVertex **inv, int count )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
RDClipVertex *p;
|
|
p = inv[i];
|
|
|
|
//
|
|
// Catch any vertices that need screen co-ordinates generated.
|
|
// There are two possibilities
|
|
// 1) Vertices generated during interpolation
|
|
// 2) Vertices marked for clipping by the transform but
|
|
// not clipped here due to the finite precision
|
|
// of the floating point unit.
|
|
//
|
|
|
|
if( p->m_clip & ~CLIPPED_ENABLE )
|
|
{
|
|
D3DVALUE inv_w;
|
|
|
|
inv_w = D3DVAL(1.0)/p->m_clip_w;
|
|
switch ((int)p->m_clip & (CLIPPED_LEFT|CLIPPED_RIGHT))
|
|
{
|
|
case CLIPPED_LEFT: p->m_pos.x = minXgb; break;
|
|
case CLIPPED_RIGHT: p->m_pos.x = maxXgb; break;
|
|
default:
|
|
p->m_pos.x = p->m_clip_x * scaleX * inv_w + offsetX;
|
|
if( p->m_pos.x < minXgb )
|
|
p->m_pos.x = minXgb;
|
|
if( p->m_pos.x > maxXgb )
|
|
p->m_pos.x = maxXgb;
|
|
}
|
|
switch ((int)p->m_clip & (CLIPPED_TOP|CLIPPED_BOTTOM))
|
|
{
|
|
case CLIPPED_BOTTOM: p->m_pos.y = maxYgb; break;
|
|
case CLIPPED_TOP: p->m_pos.y = minYgb; break;
|
|
default:
|
|
p->m_pos.y = p->m_clip_y * scaleY * inv_w + offsetY;
|
|
if( p->m_pos.y < minYgb )
|
|
p->m_pos.y = minYgb;
|
|
if( p->m_pos.y > maxYgb )
|
|
p->m_pos.y = maxYgb;
|
|
}
|
|
p->m_pos.z = p->m_clip_z * scaleZ * inv_w + offsetZ;
|
|
p->m_rhw = inv_w;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
void
|
|
RefClipper::Interpolate( RDClipVertex *out, RDClipVertex *p1, RDClipVertex *p2,
|
|
int code, D3DVALUE num, D3DVALUE denom )
|
|
{
|
|
DWORD dwInterpolate = m_dwInterpolate;
|
|
D3DVALUE num_denom = num / denom;
|
|
|
|
out->m_clip = (((int)p1->m_clip & (int)p2->m_clip) & ~CLIPPED_ENABLE) | code;
|
|
out->m_clip_x = p1->m_clip_x + (p2->m_clip_x - p1->m_clip_x) * num_denom;
|
|
out->m_clip_y = p1->m_clip_y + (p2->m_clip_y - p1->m_clip_y) * num_denom;
|
|
out->m_clip_z = p1->m_clip_z + (p2->m_clip_z - p1->m_clip_z) * num_denom;
|
|
out->m_clip_w = p1->m_clip_w + (p2->m_clip_w - p1->m_clip_w) * num_denom;
|
|
out->m_diffuse = clip_color;
|
|
out->m_specular = clip_specular;
|
|
|
|
/*
|
|
* Interpolate any other color model or quality dependent values.
|
|
*/
|
|
if( dwInterpolate & RDCLIP_INTERPOLATE_COLOR )
|
|
{
|
|
InterpolateColor(out, p1, p2, num_denom);
|
|
}
|
|
|
|
if( dwInterpolate & RDCLIP_INTERPOLATE_SPECULAR )
|
|
{
|
|
InterpolateSpecular(out, p1, p2, num_denom);
|
|
}
|
|
|
|
if( dwInterpolate & RDCLIP_INTERPOLATE_TEXTURE )
|
|
{
|
|
UINT64 qwFVF = p1->m_qwFVF;
|
|
|
|
// Assume that D3DRENDERSTATE_WRAPi are sequential
|
|
DWORD numTex = FVF_TEXCOORD_NUMBER(qwFVF);
|
|
for (DWORD i = 0; i < numTex; i++)
|
|
{
|
|
FLOAT* pTexture1 = (FLOAT *)&p1->m_tex[i];
|
|
FLOAT* pTexture2 = (FLOAT *)&p2->m_tex[i];
|
|
FLOAT* pTexture = (FLOAT *)&out->m_tex[i];
|
|
DWORD wrapState;
|
|
|
|
if( m_dwFlags & RCLIP_DO_ADJUSTWRAP )
|
|
{
|
|
DWORD TCI = m_pDev->GetTSS(i)[D3DTSS_TEXCOORDINDEX] & 0xffff;
|
|
wrapState = m_pDev->GetRS()[D3DRENDERSTATE_WRAP0 + TCI];
|
|
}
|
|
else
|
|
{
|
|
wrapState = m_pDev->GetRS()[D3DRENDERSTATE_WRAP0 + i];
|
|
}
|
|
|
|
DWORD n = GetTexCoordDim(qwFVF, i);
|
|
// DWORD n = (DWORD)(m_dwTexCoordSizeArray[i] >> 2);
|
|
DWORD dwWrapBit = 1;
|
|
for (DWORD j=0; j < n; j++)
|
|
{
|
|
pTexture[j] = InterpolateTexture(pTexture1[j], pTexture2[j],
|
|
num_denom,
|
|
wrapState & dwWrapBit);
|
|
dwWrapBit <<= 1;
|
|
}
|
|
}
|
|
}
|
|
if( dwInterpolate & RDCLIP_INTERPOLATE_S )
|
|
{
|
|
out->m_pointsize = p1->m_pointsize +
|
|
(p2->m_pointsize - p1->m_pointsize) * num_denom;
|
|
}
|
|
if( dwInterpolate & RDCLIP_INTERPOLATE_FOG )
|
|
{
|
|
out->m_fog = p1->m_fog + (p2->m_fog - p1->m_fog) * num_denom;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Functions for clipping by frustum window
|
|
//
|
|
#define __CLIP_NAME ClipLeft
|
|
#define __CLIP_LINE_NAME ClipLineLeft
|
|
#define __CLIP_FLAG CLIPPED_LEFT
|
|
#define __CLIP_COORD m_clip_x
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipRight
|
|
#define __CLIP_LINE_NAME ClipLineRight
|
|
#define __CLIP_W
|
|
#define __CLIP_FLAG CLIPPED_RIGHT
|
|
#define __CLIP_COORD m_clip_x
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipBottom
|
|
#define __CLIP_LINE_NAME ClipLineBottom
|
|
#define __CLIP_FLAG CLIPPED_BOTTOM
|
|
#define __CLIP_COORD m_clip_y
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipTop
|
|
#define __CLIP_LINE_NAME ClipLineTop
|
|
#define __CLIP_W
|
|
#define __CLIP_FLAG CLIPPED_TOP
|
|
#define __CLIP_COORD m_clip_y
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipBack
|
|
#define __CLIP_LINE_NAME ClipLineBack
|
|
#define __CLIP_W
|
|
#define __CLIP_FLAG CLIPPED_BACK
|
|
#define __CLIP_COORD m_clip_z
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipFront
|
|
#define __CLIP_LINE_NAME ClipLineFront
|
|
#define __CLIP_FLAG CLIPPED_FRONT
|
|
#define __CLIP_COORD m_clip_z
|
|
#include "clip.h"
|
|
//------------------------------------------------------------------------------
|
|
// Functions for guard band clipping
|
|
//
|
|
#define __CLIP_GUARDBAND
|
|
#define __CLIP_NAME ClipLeftGB
|
|
#define __CLIP_LINE_NAME ClipLineLeftGB
|
|
#define __CLIP_FLAG CLIPPED_LEFT
|
|
#define __CLIP_COORD m_clip_x
|
|
#define __CLIP_SIGN -
|
|
#define __CLIP_GBCOEF Kgbx1
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipRightGB
|
|
#define __CLIP_LINE_NAME ClipLineRightGB
|
|
#define __CLIP_FLAG CLIPPED_RIGHT
|
|
#define __CLIP_COORD m_clip_x
|
|
#define __CLIP_GBCOEF Kgbx2
|
|
#define __CLIP_SIGN +
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipBottomGB
|
|
#define __CLIP_LINE_NAME ClipLineBottomGB
|
|
#define __CLIP_FLAG CLIPPED_BOTTOM
|
|
#define __CLIP_COORD m_clip_y
|
|
#define __CLIP_SIGN -
|
|
#define __CLIP_GBCOEF Kgby1
|
|
#include "clip.h"
|
|
|
|
#define __CLIP_NAME ClipTopGB
|
|
#define __CLIP_LINE_NAME ClipLineTopGB
|
|
#define __CLIP_FLAG CLIPPED_TOP
|
|
#define __CLIP_COORD m_clip_y
|
|
#define __CLIP_GBCOEF Kgby2
|
|
#define __CLIP_SIGN +
|
|
#include "clip.h"
|
|
|
|
#undef __CLIP_GUARDBAND
|
|
|
|
//---------------------------------------------------------------------
|
|
inline DWORD
|
|
ComputeClipCodeUserPlanes( RDUSERCLIPPLANE *UserPlanes, RDClipVertex *p)
|
|
{
|
|
DWORD clip = 0;
|
|
DWORD dwClipBit = RDCLIP_USERCLIPPLANE0;
|
|
for( DWORD j=0; j<RD_MAX_USER_CLIPPLANES; j++)
|
|
{
|
|
if( UserPlanes[j].bActive )
|
|
{
|
|
RDVECTOR4& plane = UserPlanes[j].plane;
|
|
if( (p->m_clip_x*plane.x +
|
|
p->m_clip_y*plane.y +
|
|
p->m_clip_z*plane.z +
|
|
p->m_clip_w*plane.w) < 0 )
|
|
{
|
|
clip |= dwClipBit;
|
|
}
|
|
}
|
|
dwClipBit <<= 1;
|
|
}
|
|
return clip;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
inline DWORD
|
|
RefClipper::ComputeClipCodeGB( RDClipVertex *p )
|
|
{
|
|
DWORD clip = 0;
|
|
if( p->m_clip_x < p->m_clip_w * Kgbx1 )
|
|
clip |= RDCLIPGB_LEFT;
|
|
if( p->m_clip_x > p->m_clip_w * Kgbx2 )
|
|
clip |= RDCLIPGB_RIGHT;
|
|
if( p->m_clip_y < p->m_clip_w * Kgby1 )
|
|
clip |= RDCLIPGB_BOTTOM;
|
|
if( p->m_clip_y > p->m_clip_w * Kgby2 )
|
|
clip |= RDCLIPGB_TOP;
|
|
if( p->m_clip_z > p->m_clip_w )
|
|
clip |= RDCLIP_BACK;
|
|
clip |= ComputeClipCodeUserPlanes( m_xfmUserClipPlanes, p );
|
|
p->m_clip = (p->m_clip & (CLIPPED_ENABLE | CLIPPED_FRONT)) | clip;
|
|
return clip;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
inline DWORD
|
|
RefClipper::ComputeClipCode( RDClipVertex *p )
|
|
{
|
|
DWORD clip = 0;
|
|
if( FLOAT_LTZ(p->m_clip_x) )
|
|
clip |= RDCLIP_LEFT;
|
|
if( p->m_clip_x > p->m_clip_w )
|
|
clip |= RDCLIP_RIGHT;
|
|
if( FLOAT_LTZ(p->m_clip_y) )
|
|
clip |= RDCLIP_BOTTOM;
|
|
if( p->m_clip_y > p->m_clip_w )
|
|
clip |= RDCLIP_TOP;
|
|
if( p->m_clip_z > p->m_clip_w )
|
|
clip |= RDCLIP_BACK;
|
|
clip |= ComputeClipCodeUserPlanes( m_xfmUserClipPlanes, p );
|
|
p->m_clip = (p->m_clip & (CLIPPED_ENABLE | CLIPPED_FRONT)) | clip;
|
|
return clip;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// RefDev::UpdateClipper
|
|
// Updates clipping data used by ProcessVertices
|
|
// BOOL bProgrammablePipeLine: If this is true, it means that the
|
|
// programmable vertex machine is invoking
|
|
// this method.
|
|
//---------------------------------------------------------------------
|
|
HRESULT
|
|
RefDev::UpdateClipper()
|
|
{
|
|
HRESULT hr = D3D_OK;
|
|
|
|
HR_RET( m_Clipper.UpdateViewData() );
|
|
DWORD dwClipPlanesEnable =
|
|
GetRS()[D3DRENDERSTATE_CLIPPLANEENABLE];
|
|
|
|
if( !GetRS()[D3DRENDERSTATE_CLIPPING] )
|
|
return S_OK;
|
|
|
|
m_Clipper.m_dwFlags &= ~RefClipper::RCLIP_DO_ADJUSTWRAP;
|
|
if( (m_RefVP.m_dwTLState & (RDPV_DOTEXXFORM | RDPV_DOTEXGEN)) &&
|
|
m_pCurrentVShader->IsFixedFunction() )
|
|
m_Clipper.m_dwFlags |= RefClipper::RCLIP_DO_ADJUSTWRAP;
|
|
|
|
// Figure out which pieces need to be interpolated in new vertices.
|
|
m_Clipper.m_dwInterpolate = 0;
|
|
if( GetRS()[D3DRENDERSTATE_SHADEMODE] == D3DSHADE_GOURAUD )
|
|
{
|
|
m_Clipper.m_dwInterpolate |= RDCLIP_INTERPOLATE_COLOR;
|
|
|
|
if( m_qwFVFOut & D3DFVF_SPECULAR )
|
|
{
|
|
m_Clipper.m_dwInterpolate |= RDCLIP_INTERPOLATE_SPECULAR;
|
|
}
|
|
}
|
|
|
|
// if( GetRS()[D3DRENDERSTATE_FOGENABLE] )
|
|
if( m_qwFVFOut & D3DFVFP_FOG )
|
|
{
|
|
m_Clipper.m_dwInterpolate |= RDCLIP_INTERPOLATE_FOG;
|
|
}
|
|
|
|
if( FVF_TEXCOORD_NUMBER(m_qwFVFOut) != 0 )
|
|
{
|
|
m_Clipper.m_dwInterpolate |= RDCLIP_INTERPOLATE_TEXTURE;
|
|
}
|
|
|
|
if( m_qwFVFOut & D3DFVF_PSIZE ) // m_primType == D3DPT_POINTLIST
|
|
{
|
|
m_Clipper.m_dwInterpolate |= RDCLIP_INTERPOLATE_S;
|
|
}
|
|
|
|
// Clear clip union and intersection flags
|
|
m_Clipper.m_clipIntersection = 0;
|
|
m_Clipper.m_clipUnion = 0;
|
|
|
|
// The matrix to transform user clip planes depends on whether it is a
|
|
// fixed function pipeline or a programmable pipeline.
|
|
// Programmable pipeline: the clip-planes are transformed by the
|
|
// Inverse(Mshift) to adjust for clipping in the clipper. The user is
|
|
// assumed to have pre-transformed the clip-planes to the clipping
|
|
// space.
|
|
// Fixed function pipeline: the clip-planes are transformed to the clipping
|
|
// space by the Inverse(Mview * Mproj * Mshift).
|
|
RDMATRIX* pUserClipPlaneMatrix = NULL;
|
|
RDMATRIX matProgPipe =
|
|
{
|
|
2, 0, 0, 0,
|
|
0, 2, 0, 0,
|
|
0, 0, 1, 0,
|
|
-1,-1, 0, 1
|
|
};
|
|
|
|
if( m_pCurrentVShader->IsFixedFunction() )
|
|
{
|
|
pUserClipPlaneMatrix = &(m_RefVP.m_TransformData.m_VPSInv);
|
|
}
|
|
else
|
|
{
|
|
pUserClipPlaneMatrix = &matProgPipe;
|
|
}
|
|
|
|
// Update the user defined clip plane data
|
|
for( DWORD i=0; i<RD_MAX_USER_CLIPPLANES; i++ )
|
|
{
|
|
// Figure out if it is active
|
|
m_Clipper.m_xfmUserClipPlanes[i].bActive =
|
|
(BOOL)(dwClipPlanesEnable & 0x1);
|
|
dwClipPlanesEnable >>= 1;
|
|
|
|
// If it is active, transform it into eye-space using the
|
|
// view transform. The clip planes are defined in the
|
|
// world space.
|
|
if( m_Clipper.m_xfmUserClipPlanes[i].bActive )
|
|
{
|
|
XformPlaneBy4x4Transposed( &(m_Clipper.m_userClipPlanes[i]),
|
|
pUserClipPlaneMatrix,
|
|
&(m_Clipper.m_xfmUserClipPlanes[i].plane) );
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// DrawOnePrimitive
|
|
//
|
|
// Draw one clipped primitive.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
RefClipper::DrawOnePrimitive( GArrayT<RDVertex>& VtxArray,
|
|
DWORD dwStartVertex,
|
|
D3DPRIMITIVETYPE PrimType,
|
|
UINT cVertices )
|
|
{
|
|
INT i;
|
|
RDVertex* pV0;
|
|
RDVertex* pV1;
|
|
RDVertex* pV2;
|
|
HRESULT hr;
|
|
DWORD dwCurrVtx = dwStartVertex;
|
|
|
|
switch( PrimType )
|
|
{
|
|
case D3DPT_POINTLIST:
|
|
for (i = 0; i < (INT)cVertices; i++)
|
|
{
|
|
DrawPoint(&VtxArray[i]);
|
|
}
|
|
break;
|
|
|
|
case D3DPT_LINELIST:
|
|
for (i = (INT)cVertices / 2; i > 0; i--)
|
|
{
|
|
pV0 = &VtxArray[dwCurrVtx++];
|
|
pV1 = &VtxArray[dwCurrVtx++];
|
|
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
break;
|
|
case D3DPT_LINESTRIP:
|
|
{
|
|
pV1 = &VtxArray[dwCurrVtx];
|
|
|
|
// Disable last-pixel setting for shared verties and store prestate.
|
|
m_pDev->StoreLastPixelState(TRUE);
|
|
|
|
// Initial pV0.
|
|
for (i = (INT)cVertices - 1; i > 1; i--)
|
|
{
|
|
pV0 = pV1;
|
|
dwCurrVtx++;
|
|
pV1 = &VtxArray[dwCurrVtx];
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
|
|
// Restore last-pixel setting.
|
|
m_pDev->StoreLastPixelState(FALSE);
|
|
|
|
// Draw last line with last-pixel setting from state.
|
|
if( i == 1 )
|
|
{
|
|
dwCurrVtx++;
|
|
pV0 = &VtxArray[dwCurrVtx];
|
|
DrawLine(pV1, pV0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case D3DPT_TRIANGLELIST:
|
|
for (i = (INT)cVertices; i > 0; i -= 3)
|
|
{
|
|
pV0 = &VtxArray[dwCurrVtx++];
|
|
pV1 = &VtxArray[dwCurrVtx++];
|
|
pV2 = &VtxArray[dwCurrVtx++];
|
|
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLESTRIP:
|
|
{
|
|
// Get initial vertex values.
|
|
pV1 = &VtxArray[dwCurrVtx++];
|
|
pV2 = &VtxArray[dwCurrVtx++];
|
|
|
|
for (i = (INT)cVertices - 2; i > 1; i -= 2)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[dwCurrVtx++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[dwCurrVtx++];
|
|
DrawTriangle(pV0, pV2, pV1);
|
|
}
|
|
|
|
if( i > 0 )
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[dwCurrVtx];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLEFAN:
|
|
{
|
|
RDCLIPCODE c0, c1, c2;
|
|
|
|
pV2 = &VtxArray[dwCurrVtx++];
|
|
// Preload initial pV0.
|
|
pV1 = &VtxArray[dwCurrVtx++];
|
|
for (i = (INT)cVertices - 2; i > 0; i--)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = &VtxArray[dwCurrVtx++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DPFERR("Refrast Error: Unknown or unsupported primitive type "
|
|
"requested of DrawOnePrimitive");
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// DrawOneIndexedPrimitive
|
|
//
|
|
// Draw one list of clipped indexed primitives.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
RefClipper::DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
|
|
int StartVertexIndex,
|
|
LPWORD pIndices,
|
|
DWORD StartIndex,
|
|
UINT cIndices,
|
|
D3DPRIMITIVETYPE PrimType )
|
|
{
|
|
INT i;
|
|
RDVertex* pV0;
|
|
RDVertex* pV1;
|
|
RDVertex* pV2;
|
|
LPWORD puIndices = pIndices + StartIndex;
|
|
DWORD dwCurrIndex;
|
|
|
|
HRESULT hr;
|
|
|
|
switch( PrimType )
|
|
{
|
|
case D3DPT_POINTLIST:
|
|
for (i = (INT)cIndices; i > 0; i--)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawPoint( pV0 );
|
|
}
|
|
break;
|
|
|
|
case D3DPT_LINELIST:
|
|
for (i = (INT)cIndices / 2; i > 0; i--)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
break;
|
|
case D3DPT_LINESTRIP:
|
|
{
|
|
// Disable last-pixel setting for shared verties and store prestate.
|
|
m_pDev->StoreLastPixelState(TRUE);
|
|
// Initial pV1.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
for (i = (INT)cIndices - 1; i > 1; i--)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
// Restore last-pixel setting.
|
|
m_pDev->StoreLastPixelState(FALSE);
|
|
|
|
// Draw last line with last-pixel setting from state.
|
|
if( i == 1 )
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices];
|
|
DrawLine(pV1, pV0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case D3DPT_TRIANGLELIST:
|
|
for (i = (INT)cIndices; i > 0; i -= 3)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLESTRIP:
|
|
{
|
|
// Get initial vertex values.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
|
|
for (i = (INT)cIndices - 2; i > 1; i -= 2)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV2, pV1);
|
|
}
|
|
|
|
if( i > 0 )
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLEFAN:
|
|
{
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
// Preload initial pV0.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
for (i = (INT)cIndices - 2; i > 0; i--)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DPFERR("Refrast Error: Unknown or unsupported primitive type "
|
|
"requested of DrawOneIndexedPrimitive");
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
HRESULT
|
|
RefClipper::DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
|
|
int StartVertexIndex,
|
|
LPDWORD pIndices,
|
|
DWORD StartIndex,
|
|
UINT cIndices,
|
|
D3DPRIMITIVETYPE PrimType )
|
|
{
|
|
INT i;
|
|
RDVertex* pV0;
|
|
RDVertex* pV1;
|
|
RDVertex* pV2;
|
|
LPDWORD puIndices = pIndices + StartIndex;
|
|
|
|
HRESULT hr;
|
|
|
|
switch( PrimType )
|
|
{
|
|
case D3DPT_POINTLIST:
|
|
for (i = (INT)cIndices; i > 0; i--)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawPoint(pV0);
|
|
}
|
|
break;
|
|
|
|
case D3DPT_LINELIST:
|
|
for (i = (INT)cIndices / 2; i > 0; i--)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
break;
|
|
case D3DPT_LINESTRIP:
|
|
{
|
|
// Disable last-pixel setting for shared verties and store prestate.
|
|
m_pDev->StoreLastPixelState(TRUE);
|
|
// Initial pV1.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
for (i = (INT)cIndices - 1; i > 1; i--)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawLine(pV0, pV1);
|
|
}
|
|
// Restore last-pixel setting.
|
|
m_pDev->StoreLastPixelState(FALSE);
|
|
|
|
// Draw last line with last-pixel setting from state.
|
|
if( i == 1 )
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices];
|
|
DrawLine(pV1, pV0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case D3DPT_TRIANGLELIST:
|
|
for (i = (INT)cIndices; i > 0; i -= 3)
|
|
{
|
|
pV0 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLESTRIP:
|
|
{
|
|
// Get initial vertex values.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
|
|
for (i = (INT)cIndices - 2; i > 1; i -= 2)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV2, pV1);
|
|
}
|
|
|
|
if( i > 0 )
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = pV2;
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
case D3DPT_TRIANGLEFAN:
|
|
{
|
|
pV2 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
// Preload initial pV0.
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
for (i = (INT)cIndices - 2; i > 0; i--)
|
|
{
|
|
pV0 = pV1;
|
|
pV1 = &VtxArray[StartVertexIndex + *puIndices++];
|
|
DrawTriangle(pV0, pV1, pV2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DPFERR("Refrast Error: Unknown or unsupported primitive type "
|
|
"requested of DrawOneIndexedPrimitive");
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
RefClipper::DrawTriangle( RDVertex* pV0, RDVertex* pV1, RDVertex* pV2,
|
|
WORD wFlags )
|
|
{
|
|
// If the clip-codes dont exist then compute them. This happens only
|
|
// for Transformed vertices that are directly passed in to be rasterized.
|
|
if( (pV0->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV0 );
|
|
if( (pV1->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV1 );
|
|
if( (pV2->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV2 );
|
|
|
|
RDCLIPCODE c0 = pV0->m_clip;
|
|
RDCLIPCODE c1 = pV1->m_clip;
|
|
RDCLIPCODE c2 = pV2->m_clip;
|
|
|
|
DWORD dwInter = (c0 & c1 & c2);
|
|
DWORD dwUnion = (c0 | c1 | c2);
|
|
DWORD dwMask = (UseGuardBand()) ? RDCLIPGB_ALL : RDCLIP_ALL;
|
|
|
|
// All vertices outside the frustum or guardband,
|
|
// return without drawing
|
|
if( dwInter )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If all the vertices are in, draw and return
|
|
if( (dwUnion & dwMask) == 0 )
|
|
{
|
|
m_pDev->DrawTriangle( pV0, pV1, pV2, wFlags );
|
|
return;
|
|
}
|
|
|
|
// Do Clipping
|
|
RDCLIPTRIANGLE newtri;
|
|
RDClipVertex cv[3];
|
|
|
|
MakeClipVertexFromVertex( cv[0], *pV0, dwMask);
|
|
MakeClipVertexFromVertex( cv[1], *pV1, dwMask);
|
|
MakeClipVertexFromVertex( cv[2], *pV2, dwMask);
|
|
|
|
newtri.v[0] = &cv[0]; cv[0].next = &cv[1];
|
|
newtri.v[1] = &cv[1]; cv[1].next = &cv[2];
|
|
newtri.v[2] = &cv[2]; cv[2].next = NULL;
|
|
|
|
int count;
|
|
RDClipVertex **ver;
|
|
cv[0].m_clip |= CLIPPED_ENABLE;
|
|
cv[1].m_clip |= CLIPPED_ENABLE;
|
|
cv[2].m_clip |= CLIPPED_ENABLE;
|
|
|
|
if( count = ClipSingleTriangle( &newtri, &ver ) )
|
|
{
|
|
int i;
|
|
|
|
// Temporary Byte Array
|
|
if( FAILED( ClipBuf.Grow(count) ) ) return;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
MakeVertexFromClipVertex( ClipBuf[i], *(ver[i]) );
|
|
ClipBuf[i].SetFVF( pV0->m_qwFVF );
|
|
}
|
|
|
|
// If it is in wireframe mode, convert the clipper output to
|
|
// a line list.
|
|
if( m_dwFlags & RCLIP_DO_WIREFRAME )
|
|
{
|
|
DWORD dwEdgeFlags = 0;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
if( ver[i]->m_clip & CLIPPED_ENABLE ) dwEdgeFlags |= (1 << i);
|
|
}
|
|
|
|
m_pDev->DrawOneEdgeFlagTriangleFan( ClipBuf, count, dwEdgeFlags );
|
|
}
|
|
else
|
|
{
|
|
m_pDev->DrawOnePrimitive( ClipBuf, 0, D3DPT_TRIANGLEFAN, count );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
RefClipper::DrawLine( RDVertex* pV0, RDVertex* pV1 )
|
|
{
|
|
// If the clip-codes dont exist then compute them. This happens only
|
|
// for Transformed vertices that are directly passed in to be rasterized.
|
|
if( (pV0->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV0 );
|
|
if( (pV1->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV1 );
|
|
|
|
RDCLIPCODE c0 = pV0->m_clip;
|
|
RDCLIPCODE c1 = pV1->m_clip;
|
|
|
|
DWORD dwInter = (c0 & c1);
|
|
DWORD dwUnion = (c0 | c1);
|
|
DWORD dwMask = (UseGuardBand()) ? RDCLIPGB_ALL : RDCLIP_ALL;
|
|
|
|
// All vertices outside the frustum or guardband,
|
|
// return without drawing
|
|
if( dwInter )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If all the vertices are in, draw and return
|
|
if( (dwUnion & dwMask) == 0 )
|
|
{
|
|
m_pDev->DrawLine( pV0, pV1 );
|
|
return;
|
|
}
|
|
|
|
RDCLIPTRIANGLE newline;
|
|
RDClipVertex cv[2];
|
|
|
|
MakeClipVertexFromVertex( cv[0], *pV0, dwMask );
|
|
MakeClipVertexFromVertex( cv[1], *pV1, dwMask );
|
|
|
|
newline.v[0] = &cv[0];
|
|
newline.v[1] = &cv[1];
|
|
|
|
if( ClipSingleLine( &newline ) )
|
|
{
|
|
// Temporary Byte Array
|
|
if( FAILED(ClipBuf.Grow( 2 )) ) return;
|
|
MakeVertexFromClipVertex( ClipBuf[0], *(newline.v[0]) );
|
|
MakeVertexFromClipVertex( ClipBuf[1], *(newline.v[1]) );
|
|
ClipBuf[0].SetFVF( pV0->m_qwFVF );
|
|
ClipBuf[1].SetFVF( pV0->m_qwFVF );
|
|
|
|
m_pDev->DrawLine( &ClipBuf[0], &ClipBuf[1] );
|
|
}
|
|
}
|
|
|
|
void
|
|
RefClipper::DrawPoint( RDVertex* pV0 )
|
|
{
|
|
// If the clip-codes dont exist then compute them. This happens only
|
|
// for Transformed vertices that are directly passed in to be rasterized.
|
|
if( (pV0->m_qwFVF & D3DFVFP_CLIP) == 0 ) ComputeClipCodesTL( pV0 );
|
|
|
|
RDCLIPCODE c0 = pV0->m_clip;
|
|
DWORD dwMask = (UseGuardBand()) ? RDCLIPGB_ALL : RDCLIP_ALL;
|
|
|
|
// if definitely out
|
|
#if 0
|
|
if( c0 & (RDCLIP_FRONT | RDCLIP_BACK |
|
|
(1<<RDCLIPGB_LEFTBIT) | (1<<RDCLIPGB_RIGHTBIT) |
|
|
(1<<RDCLIPGB_TOPBIT) | (1<<RDCLIPGB_BOTTOMBIT)) )
|
|
return;
|
|
#else
|
|
if( c0 & dwMask ) return;
|
|
#endif
|
|
// is completely in, just draw it
|
|
m_pDev->DrawPoint( pV0 );
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Returns 0, if triangle is clipped. Number of vertices otherwise.
|
|
//
|
|
// Original vertices should not be modified inside the function
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int
|
|
RefClipper::ClipSingleTriangle( RDCLIPTRIANGLE *tri,
|
|
RDClipVertex ***clipVertexPointer )
|
|
{
|
|
int accept;
|
|
int i, j;
|
|
int count;
|
|
RDClipVertex **inv;
|
|
RDClipVertex **outv;
|
|
RDClipVertex *p;
|
|
ULONG_PTR swapv;
|
|
RDCOLOR4 diffuse1; // Original colors
|
|
RDCOLOR4 specular1;
|
|
RDCOLOR4 diffuse2;
|
|
RDCOLOR4 specular2;
|
|
DWORD dwClipBit;
|
|
DWORD dwClippedBit;
|
|
|
|
if( m_dwFlags & RCLIP_DO_FLATSHADING )
|
|
{
|
|
// It is easier to set all vertices to the same color here
|
|
RDCOLOR4 diffuse = tri->v[0]->m_diffuse;
|
|
RDCOLOR4 specular = tri->v[0]->m_specular;
|
|
|
|
//Save original colors
|
|
diffuse1 = tri->v[1]->m_diffuse;
|
|
specular1 = tri->v[1]->m_specular;
|
|
diffuse2 = tri->v[2]->m_diffuse;
|
|
specular2 = tri->v[2]->m_specular;
|
|
|
|
tri->v[1]->m_diffuse = diffuse;
|
|
tri->v[1]->m_specular = specular;
|
|
tri->v[2]->m_diffuse = diffuse;
|
|
tri->v[2]->m_specular = specular;
|
|
}
|
|
accept = (tri->v[0]->m_clip | tri->v[1]->m_clip | tri->v[2]->m_clip);
|
|
|
|
inv = tri->v;
|
|
count = 3;
|
|
outv = clip_vbuf1;
|
|
clip_color = tri->v[0]->m_diffuse;
|
|
clip_specular = tri->v[0]->m_specular;
|
|
|
|
/*
|
|
* XXX assumes sizeof(void*) == sizeof(unsigned long)
|
|
*/
|
|
{
|
|
ULONG_PTR tmp1;
|
|
ULONG_PTR tmp2;
|
|
|
|
tmp1 = (ULONG_PTR)clip_vbuf1;
|
|
tmp2 = (ULONG_PTR)clip_vbuf2;
|
|
|
|
swapv = tmp1 + tmp2;
|
|
}
|
|
clip_vertices_used = 0;
|
|
|
|
#define SWAP(inv, outv) \
|
|
inv = outv; \
|
|
outv = (RDClipVertex**) (swapv - (ULONG_PTR) outv)
|
|
|
|
if( accept & RDCLIP_FRONT )
|
|
{
|
|
count = ClipFront( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( UseGuardBand() )
|
|
{
|
|
// If there was clipping by the front plane it is better to
|
|
// compute clip code for new vertices and re-compute accept.
|
|
// Otherwise we will try to clip by sides when it is not necessary
|
|
if( accept & RDCLIP_FRONT )
|
|
{
|
|
accept = 0;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
RDClipVertex *p;
|
|
p = inv[i];
|
|
if( p->m_clip & CLIPPED_FRONT )
|
|
accept |= ComputeClipCodeGB( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
}
|
|
}
|
|
if( accept & RDCLIP_BACK )
|
|
{
|
|
count = ClipBack( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIPGB_LEFT )
|
|
{
|
|
count = ClipLeftGB( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIPGB_RIGHT )
|
|
{
|
|
count = ClipRightGB( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIPGB_BOTTOM )
|
|
{
|
|
count = ClipBottomGB( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIPGB_TOP )
|
|
{
|
|
count = ClipTopGB( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If there was clipping by the front plane it is better to
|
|
// compute clip code for new vertices and re-compute accept.
|
|
// Otherwise we will try to clip by sides when it is not necessary
|
|
if( accept & RDCLIP_FRONT )
|
|
{
|
|
accept = 0;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
RDClipVertex *p;
|
|
p = inv[i];
|
|
if( p->m_clip & (CLIPPED_FRONT) )
|
|
accept |= ComputeClipCode( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
}
|
|
}
|
|
if( accept & RDCLIP_BACK )
|
|
{
|
|
count = ClipBack( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIP_LEFT )
|
|
{
|
|
count = ClipLeft( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIP_RIGHT )
|
|
{
|
|
count = ClipRight( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIP_BOTTOM )
|
|
{
|
|
count = ClipBottom( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
if( accept & RDCLIP_TOP )
|
|
{
|
|
count = ClipTop( inv, outv, count );
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
}
|
|
|
|
dwClipBit = RDCLIP_USERCLIPPLANE0;
|
|
dwClippedBit = CLIPPED_USERCLIPPLANE0;
|
|
// User Clip Planes
|
|
for( j=0; j<RD_MAX_USER_CLIPPLANES; j++)
|
|
{
|
|
if( accept & dwClipBit )
|
|
{
|
|
count = ClipByPlane( inv, outv, &(m_xfmUserClipPlanes[j].plane),
|
|
dwClippedBit, count);
|
|
if( count < 3 )
|
|
goto out_of_here;
|
|
SWAP(inv, outv);
|
|
}
|
|
dwClipBit <<= 1;
|
|
dwClippedBit <<= 1;
|
|
}
|
|
|
|
#undef SWAP
|
|
|
|
ComputeScreenCoordinates( inv, count );
|
|
|
|
*clipVertexPointer = inv;
|
|
current_vbuf = inv;
|
|
return count;
|
|
|
|
out_of_here:
|
|
|
|
*clipVertexPointer = NULL;
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
//
|
|
int
|
|
RefClipper::ClipSingleLine( RDCLIPTRIANGLE *line )
|
|
{
|
|
int accept;
|
|
int j;
|
|
D3DVALUE in1, in2;
|
|
DWORD dwClipBit;
|
|
DWORD dwClippedBit;
|
|
|
|
accept = (line->v[0]->m_clip | line->v[1]->m_clip);
|
|
|
|
clip_color = line->v[0]->m_diffuse;
|
|
clip_specular = line->v[0]->m_specular;
|
|
|
|
if( accept & D3DCS_FRONT )
|
|
if( ClipLineFront(line) )
|
|
goto out_of_here;
|
|
if( UseGuardBand() )
|
|
{
|
|
// If there was clipping by the front plane it is better to
|
|
// compute clip code for new vertices and re-compute accept.
|
|
// Otherwise we will try to clip by sides when it is not necessary
|
|
if( accept & D3DCS_FRONT )
|
|
{
|
|
RDClipVertex * p;
|
|
accept = 0;
|
|
p = line->v[0];
|
|
if( p->m_clip & CLIPPED_FRONT )
|
|
accept |= ComputeClipCodeGB( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
p = line->v[1];
|
|
if( p->m_clip & CLIPPED_FRONT )
|
|
accept |= ComputeClipCodeGB( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
}
|
|
if( accept & D3DCS_BACK )
|
|
if( ClipLineBack( line ) )
|
|
goto out_of_here;
|
|
if( accept & RDCLIPGB_LEFT )
|
|
if( ClipLineLeftGB( line ) )
|
|
goto out_of_here;
|
|
if( accept & RDCLIPGB_RIGHT )
|
|
if( ClipLineRightGB( line ) )
|
|
goto out_of_here;
|
|
if( accept & RDCLIPGB_TOP )
|
|
if( ClipLineTopGB( line ) )
|
|
goto out_of_here;
|
|
if( accept & RDCLIPGB_BOTTOM )
|
|
if( ClipLineBottomGB( line ) )
|
|
goto out_of_here;
|
|
}
|
|
else
|
|
{
|
|
// If there was clipping by the front plane it is better to
|
|
// compute clip code for new vertices and re-compute accept.
|
|
// Otherwise we will try to clip by sides when it is not necessary
|
|
if( accept & D3DCS_FRONT )
|
|
{
|
|
RDClipVertex * p;
|
|
accept = 0;
|
|
p = line->v[0];
|
|
if( p->m_clip & CLIPPED_FRONT )
|
|
accept |= ComputeClipCode( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
p = line->v[1];
|
|
if( p->m_clip & CLIPPED_FRONT )
|
|
accept |= ComputeClipCode( p );
|
|
else
|
|
accept |= p->m_clip;
|
|
}
|
|
if( accept & D3DCS_BACK )
|
|
if( ClipLineBack( line ) )
|
|
goto out_of_here;
|
|
if( accept & D3DCS_LEFT )
|
|
if( ClipLineLeft( line ) )
|
|
goto out_of_here;
|
|
if( accept & D3DCS_RIGHT )
|
|
if( ClipLineRight( line ) )
|
|
goto out_of_here;
|
|
if( accept & D3DCS_TOP )
|
|
if( ClipLineTop( line ) )
|
|
goto out_of_here;
|
|
if( accept & D3DCS_BOTTOM )
|
|
if( ClipLineBottom( line ) )
|
|
goto out_of_here;
|
|
}
|
|
|
|
// User Clip Planes
|
|
dwClipBit = RDCLIP_USERCLIPPLANE0;
|
|
dwClippedBit = CLIPPED_USERCLIPPLANE0;
|
|
for( j=0; j<RD_MAX_USER_CLIPPLANES; j++)
|
|
{
|
|
if( accept & dwClipBit )
|
|
{
|
|
if( ClipLineByPlane( line, &m_xfmUserClipPlanes[j].plane,
|
|
dwClippedBit ))
|
|
goto out_of_here;
|
|
}
|
|
dwClipBit <<= 1;
|
|
dwClippedBit <<= 1;
|
|
}
|
|
|
|
ComputeScreenCoordinates( line->v, 2 );
|
|
|
|
return 1;
|
|
out_of_here:
|
|
return 0;
|
|
}
|
|
|