613 lines
21 KiB
C++
613 lines
21 KiB
C++
|
/*==========================================================================;
|
||
|
|
*
|
||
|
|
* Copyright (C) 1997 Microsoft Corporation. All Rights Reserved.
|
||
|
|
*
|
||
|
|
* File: dpclip.c
|
||
|
|
* Content: DrawPrimitive clipper
|
||
|
|
*
|
||
|
|
***************************************************************************/
|
||
|
|
|
||
|
|
#include "pch.cpp"
|
||
|
|
#pragma hdrstop
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------
|
||
|
|
HRESULT D3DFE_PVFUNCSI::Clip(D3DFE_PROCESSVERTICES *pv, ClipVertex *cv1,
|
||
|
|
ClipVertex *cv2,
|
||
|
|
ClipVertex *cv3)
|
||
|
|
{
|
||
|
|
ClipTriangle newtri;
|
||
|
|
LPVOID saveVer = pv->lpvOut; // For indexed primitive
|
||
|
|
DWORD numVer = pv->dwNumVertices; // For indexed primitive
|
||
|
|
newtri.v[0] = cv1;
|
||
|
|
newtri.v[1] = cv2;
|
||
|
|
newtri.v[2] = cv3;
|
||
|
|
|
||
|
|
int count;
|
||
|
|
ClipVertex** ver;
|
||
|
|
|
||
|
|
cv1->clip |= CLIPPED_ENABLE;
|
||
|
|
cv2->clip |= CLIPPED_ENABLE;
|
||
|
|
cv3->clip |= CLIPPED_ENABLE;
|
||
|
|
// For the flat shading mode we have to use first vertex color as
|
||
|
|
// color for all vertices
|
||
|
|
D3DCOLOR diffuse1; // Original colors
|
||
|
|
D3DCOLOR specular1;
|
||
|
|
D3DCOLOR diffuse2;
|
||
|
|
D3DCOLOR specular2;
|
||
|
|
if (pv->lpdwRStates[D3DRS_SHADEMODE] == D3DSHADE_FLAT)
|
||
|
|
{
|
||
|
|
// It is easier to set all vertices to the same color here
|
||
|
|
D3DCOLOR diffuse = cv1->color;
|
||
|
|
// Exclude fog factor
|
||
|
|
D3DCOLOR specular = cv1->specular & 0x00FFFFFF;
|
||
|
|
|
||
|
|
//Save original colors
|
||
|
|
diffuse1 = cv2->color;
|
||
|
|
specular1 = cv2->specular;
|
||
|
|
diffuse2 = cv3->color;
|
||
|
|
specular2 = cv3->specular;
|
||
|
|
|
||
|
|
// Copy the same color to all vertices but preserve fog factor, because
|
||
|
|
// fog factor should be interpolated
|
||
|
|
cv2->color = diffuse;
|
||
|
|
cv3->color = diffuse;
|
||
|
|
cv2->specular = (cv2->specular & 0xFF000000) | specular;
|
||
|
|
cv3->specular = (cv3->specular & 0xFF000000) | specular;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (count = pv->pGeometryFuncs->ClipSingleTriangle(pv, &newtri, &ver))
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
HRESULT ret;
|
||
|
|
BYTE *pTLV = pv->ClipperState.clipBuf;
|
||
|
|
BYTE *p = pTLV;
|
||
|
|
|
||
|
|
for (i = 0; i < count; i++)
|
||
|
|
{
|
||
|
|
MAKE_TL_VERTEX_FVF(pv, p, ver[i]);
|
||
|
|
p += pv->dwOutputSize;
|
||
|
|
}
|
||
|
|
ret = DRAW_CLIPPED_PRIM(pv, D3DPT_TRIANGLEFAN, pTLV, count, count-2);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// CLIPPED_ENABLE bit could be set in the ClipSingleTriangle.
|
||
|
|
// If this bit is not cleared, clipping will be wrong. Because, clip
|
||
|
|
// vertices are re-used by next triangles.
|
||
|
|
// This bit should be cleared *after* drawing command. Otherwise, edge flags
|
||
|
|
// will be incorrect
|
||
|
|
cv1->clip &= ~CLIPPED_ENABLE;
|
||
|
|
cv2->clip &= ~CLIPPED_ENABLE;
|
||
|
|
cv3->clip &= ~CLIPPED_ENABLE;
|
||
|
|
|
||
|
|
if (pv->lpdwRStates[D3DRENDERSTATE_SHADEMODE] == D3DSHADE_FLAT)
|
||
|
|
{
|
||
|
|
// Restore original colors
|
||
|
|
cv2->color = diffuse1;
|
||
|
|
cv2->specular = specular1;
|
||
|
|
cv3->color = diffuse2;
|
||
|
|
cv3->specular = specular2;
|
||
|
|
}
|
||
|
|
pv->lpvOut = saveVer;
|
||
|
|
pv->dwNumVertices = numVer;
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
//----------------------------------------------------------------------
|
||
|
|
HRESULT D3DFE_PVFUNCSI::ClipLine(D3DFE_PROCESSVERTICES *pv, ClipVertex *v1, ClipVertex *v2)
|
||
|
|
{
|
||
|
|
ClipTriangle newline;
|
||
|
|
LPVOID saveVer = pv->lpvOut; // For indexed primitive
|
||
|
|
DWORD numVer = pv->dwNumVertices; // For indexed primitive
|
||
|
|
ClipVertex cv1 = *v1;
|
||
|
|
ClipVertex cv2 = *v2;
|
||
|
|
newline.v[0] = &cv1;
|
||
|
|
newline.v[1] = &cv2;
|
||
|
|
|
||
|
|
int count;
|
||
|
|
ClipVertex** ver;
|
||
|
|
|
||
|
|
if (pv->lpdwRStates[D3DRENDERSTATE_SHADEMODE] == D3DSHADE_FLAT)
|
||
|
|
{
|
||
|
|
// Copy the same color to all vertices but preserve fog factor, because
|
||
|
|
// fog factor should be interpolated
|
||
|
|
cv2.color = cv1.color;
|
||
|
|
cv2.specular = (cv2.specular & 0xFF000000)|(cv1.specular & 0x00FFFFFF);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ClipSingleLine(pv, &newline))
|
||
|
|
{
|
||
|
|
BYTE *pTLV = pv->ClipperState.clipBuf;
|
||
|
|
BYTE *p = pTLV;
|
||
|
|
MAKE_TL_VERTEX_FVF(pv, p, newline.v[0]);
|
||
|
|
p += pv->dwOutputSize;
|
||
|
|
MAKE_TL_VERTEX_FVF(pv, p, newline.v[1]);
|
||
|
|
HRESULT ret = DRAW_CLIPPED_PRIM(pv, D3DPT_LINELIST, pTLV, 2, 1);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
pv->lpvOut = saveVer;
|
||
|
|
pv->dwNumVertices = numVer;
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
HRESULT D3DFE_PVFUNCSI::ProcessClippedTriangleFan(D3DFE_PROCESSVERTICES *pv)
|
||
|
|
{
|
||
|
|
BYTE *p1;
|
||
|
|
DWORD f1;
|
||
|
|
D3DFE_CLIPCODE *clipCode;
|
||
|
|
DWORD i;
|
||
|
|
HRESULT ret;
|
||
|
|
BYTE *vertex;
|
||
|
|
BYTE *startVertex;
|
||
|
|
int vertexCount;
|
||
|
|
DWORD vertexSize;
|
||
|
|
ClipVertex cv[3];
|
||
|
|
BOOL vertexTransformed;
|
||
|
|
|
||
|
|
vertexTransformed = pv->dwFlags & D3DPV_TLVCLIP;;
|
||
|
|
clipCode = pv->lpClipFlags;
|
||
|
|
vertex = (BYTE*)pv->lpvOut;
|
||
|
|
startVertex = (BYTE*)pv->lpvOut;
|
||
|
|
vertexSize = pv->dwOutputSize;
|
||
|
|
vertexCount = 0;
|
||
|
|
|
||
|
|
f1 = clipCode[0];
|
||
|
|
p1 = vertex;
|
||
|
|
clipCode++;
|
||
|
|
vertex += vertexSize;
|
||
|
|
// In the clipper color from the first vertex is propagated to all
|
||
|
|
// vertices for FLAT shade mode. In triangle fans the second vertex defines
|
||
|
|
// the color in FLAT shade mode. So we will make the vertex order: 1, 2, 0
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[2], p1, f1, vertexTransformed);
|
||
|
|
for (i = pv->dwNumVertices-2; i; i--)
|
||
|
|
{
|
||
|
|
DWORD f2, f3; // vertex clip flags
|
||
|
|
f2 = clipCode[0];
|
||
|
|
f3 = clipCode[1];
|
||
|
|
|
||
|
|
BOOL needClip = FALSE;
|
||
|
|
BOOL offFrustum = FALSE;
|
||
|
|
if (f1 & f2 & f3)
|
||
|
|
offFrustum = TRUE;
|
||
|
|
else
|
||
|
|
if ((f1 | f2 | f3) & pv->dwClipMaskOffScreen)
|
||
|
|
needClip = TRUE;
|
||
|
|
|
||
|
|
if (offFrustum || needClip)
|
||
|
|
{ // if this tri does need clipping
|
||
|
|
if (vertexCount)
|
||
|
|
{ // first draw the ones that didn't need clipping
|
||
|
|
BYTE tmp[__MAX_VERTEX_SIZE];
|
||
|
|
BYTE *pStart = startVertex;
|
||
|
|
if (startVertex != p1)
|
||
|
|
{
|
||
|
|
pStart -= vertexSize;
|
||
|
|
memcpy (tmp, pStart, vertexSize);
|
||
|
|
memcpy (pStart, p1, vertexSize);
|
||
|
|
// Mark this call as gen by clipper, but set non clipped bit
|
||
|
|
pv->dwFlags |= D3DPV_NONCLIPPED;
|
||
|
|
ret = DRAW_CLIPPED_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2,
|
||
|
|
vertexCount);
|
||
|
|
pv->dwFlags &= ~D3DPV_NONCLIPPED;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2, vertexCount);
|
||
|
|
}
|
||
|
|
if (startVertex != p1)
|
||
|
|
memcpy (pStart, tmp, vertexSize);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// reset count and start ptr
|
||
|
|
vertexCount = 0;
|
||
|
|
startVertex = vertex + vertexSize;
|
||
|
|
|
||
|
|
// now deal with the single clipped triangle
|
||
|
|
// first check if it should just be tossed or if it should be clipped
|
||
|
|
|
||
|
|
if (!offFrustum)
|
||
|
|
{
|
||
|
|
BYTE *p2 = vertex;
|
||
|
|
BYTE *p3 = vertex + vertexSize;
|
||
|
|
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[0], p2, f2, vertexTransformed);
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[1], p3, f3, vertexTransformed);
|
||
|
|
|
||
|
|
ret = Clip(pv, &cv[0], &cv[1], &cv[2]);
|
||
|
|
if (ret) return ret;
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
vertexCount++;
|
||
|
|
clipCode++;
|
||
|
|
vertex += vertexSize;
|
||
|
|
}
|
||
|
|
// draw final batch, if any
|
||
|
|
if (vertexCount)
|
||
|
|
{
|
||
|
|
BYTE tmp[__MAX_VERTEX_SIZE];
|
||
|
|
BYTE *pStart = startVertex;
|
||
|
|
if (startVertex == p1)
|
||
|
|
{
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2, vertexCount);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pStart -= vertexSize;
|
||
|
|
memcpy(tmp, pStart, vertexSize);
|
||
|
|
memcpy(pStart, p1, vertexSize);
|
||
|
|
// Mark this call as gen by clipper
|
||
|
|
pv->dwFlags |= D3DPV_NONCLIPPED;
|
||
|
|
ret = DRAW_CLIPPED_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2, vertexCount);
|
||
|
|
pv->dwFlags &= ~D3DPV_NONCLIPPED;
|
||
|
|
}
|
||
|
|
if (startVertex != p1)
|
||
|
|
memcpy(pStart, tmp, vertexSize);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
HRESULT
|
||
|
|
D3DFE_PVFUNCSI::ProcessClippedIndexedTriangleFan(D3DFE_PROCESSVERTICES *pv)
|
||
|
|
{
|
||
|
|
DWORD f1; // Clip code for the first vertex
|
||
|
|
D3DFE_CLIPCODE *clipCode;
|
||
|
|
DWORD i;
|
||
|
|
HRESULT ret;
|
||
|
|
// Vertex array
|
||
|
|
BYTE *vertex;
|
||
|
|
// Start indexed of the current in-screen triangle batch
|
||
|
|
LPBYTE startIndex;
|
||
|
|
// Pointer to second index of the current triangle
|
||
|
|
LPBYTE index = (LPBYTE)pv->lpwIndices;
|
||
|
|
int vertexCount;
|
||
|
|
DWORD vertexSize;
|
||
|
|
ClipVertex cv[3];
|
||
|
|
DWORD dwIndexSize = pv->dwIndexSize;
|
||
|
|
DWORD dwFirstIndex; // First index of the primitive
|
||
|
|
BOOL vertexTransformed;
|
||
|
|
// If there was a off-screen or clipped triangle we copy the first primitive
|
||
|
|
// index to the start of the next in-screen triangle batch
|
||
|
|
BOOL bWasClipping = FALSE;
|
||
|
|
|
||
|
|
|
||
|
|
vertexTransformed = pv->dwFlags & D3DPV_TLVCLIP;
|
||
|
|
clipCode = pv->lpClipFlags;
|
||
|
|
vertex = (BYTE*)pv->lpvOut;
|
||
|
|
startIndex = (LPBYTE)pv->lpwIndices;
|
||
|
|
vertexSize = pv->dwOutputSize;
|
||
|
|
vertexCount = 0;
|
||
|
|
// Update the address of the vertex array to handle the index base
|
||
|
|
if (pv->dwIndexOffset != 0)
|
||
|
|
{
|
||
|
|
vertex -= pv->dwIndexOffset * vertexSize;
|
||
|
|
clipCode -= pv->dwIndexOffset;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
dwFirstIndex = *(WORD*)index;
|
||
|
|
else
|
||
|
|
dwFirstIndex = *(DWORD*)index;
|
||
|
|
f1 = clipCode[dwFirstIndex];
|
||
|
|
LPBYTE ver; // First vertex
|
||
|
|
ver = vertex + dwFirstIndex * vertexSize;
|
||
|
|
index += dwIndexSize;
|
||
|
|
// In the clipper color from the first vertex is propagated to all
|
||
|
|
// vertices for FLAT shade mode. In triangle fans the second vertex defines
|
||
|
|
// the color in FLAT shade mode. So we will make the vertex order: 1, 2, 0
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[2], ver, f1, vertexTransformed);
|
||
|
|
for (i = pv->dwNumPrimitives; i; i--)
|
||
|
|
{
|
||
|
|
DWORD f2, f3; // vertex clip flags
|
||
|
|
DWORD v1, v2;
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
{
|
||
|
|
v1 = *(WORD*)index;
|
||
|
|
v2 = *(WORD*)(index + 2);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
v1 = *(DWORD*)index;
|
||
|
|
v2 = *(DWORD*)(index + 4);
|
||
|
|
}
|
||
|
|
f2 = clipCode[v1];
|
||
|
|
f3 = clipCode[v2];
|
||
|
|
BOOL needClip = FALSE;
|
||
|
|
BOOL offFrustum = FALSE;
|
||
|
|
if (f1 & f2 & f3)
|
||
|
|
offFrustum = TRUE;
|
||
|
|
else
|
||
|
|
if ((f1 | f2 | f3) & pv->dwClipMaskOffScreen)
|
||
|
|
needClip = TRUE;
|
||
|
|
|
||
|
|
if (offFrustum || needClip)
|
||
|
|
{ // if this tri does need clipping
|
||
|
|
if (vertexCount)
|
||
|
|
{ // first draw the ones that didn't need clipping
|
||
|
|
WORD* pStart = (WORD*)startIndex;
|
||
|
|
DWORD tmp;
|
||
|
|
if (bWasClipping)
|
||
|
|
{
|
||
|
|
// Save old value of the index before the current start
|
||
|
|
// index and copy the first primitive index there. This
|
||
|
|
// will the start of the current unclipped batch
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
{
|
||
|
|
pStart--;
|
||
|
|
tmp = *pStart;
|
||
|
|
*pStart = (WORD)dwFirstIndex;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pStart -= 2;
|
||
|
|
tmp = *(DWORD*)pStart;
|
||
|
|
*(DWORD*)pStart = dwFirstIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ret = DRAW_INDEX_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2,
|
||
|
|
vertexCount);
|
||
|
|
if (bWasClipping)
|
||
|
|
{ // Restore old value
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
*pStart = (WORD)tmp;
|
||
|
|
else
|
||
|
|
*(DWORD*)pStart = tmp;
|
||
|
|
}
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
|
||
|
|
}
|
||
|
|
bWasClipping = TRUE;
|
||
|
|
// reset count and start ptr
|
||
|
|
vertexCount = 0;
|
||
|
|
startIndex = index + dwIndexSize;
|
||
|
|
|
||
|
|
// now deal with the single clipped triangle
|
||
|
|
// first check if it should just be tossed or if it should be clipped
|
||
|
|
|
||
|
|
if (!offFrustum)
|
||
|
|
{
|
||
|
|
BYTE *p2 = vertex + v1*vertexSize;
|
||
|
|
BYTE *p3 = vertex + v2*vertexSize;
|
||
|
|
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[0], p2, f2, vertexTransformed);
|
||
|
|
MAKE_CLIP_VERTEX_FVF(pv, cv[1], p3, f3, vertexTransformed);
|
||
|
|
|
||
|
|
ret = Clip(pv, &cv[0], &cv[1], &cv[2]);
|
||
|
|
if (ret) return ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
vertexCount++;
|
||
|
|
index += dwIndexSize;
|
||
|
|
}
|
||
|
|
// draw final batch, if any
|
||
|
|
if (vertexCount)
|
||
|
|
{
|
||
|
|
WORD* pStart = (WORD*)startIndex;
|
||
|
|
DWORD tmp;
|
||
|
|
if (bWasClipping)
|
||
|
|
{
|
||
|
|
// Save old value of the index before the current start
|
||
|
|
// index and copy the first primitive index there. This
|
||
|
|
// will the start of the current unclipped batch
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
{
|
||
|
|
pStart--;
|
||
|
|
tmp = *pStart;
|
||
|
|
*pStart = (WORD)dwFirstIndex;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pStart -= 2;
|
||
|
|
tmp = *(DWORD*)pStart;
|
||
|
|
*(DWORD*)pStart = dwFirstIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ret = DRAW_INDEX_PRIM(pv, D3DPT_TRIANGLEFAN, pStart, vertexCount+2,
|
||
|
|
vertexCount);
|
||
|
|
if (bWasClipping)
|
||
|
|
{ // Restore old value
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
*pStart = (WORD)tmp;
|
||
|
|
else
|
||
|
|
*(DWORD*)pStart = tmp;
|
||
|
|
}
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
|
||
|
|
}
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define __PROCESS_LINE_NAME ProcessClippedLine
|
||
|
|
#define __PROCESS_TRI_LIST_NAME ProcessClippedTriangleList
|
||
|
|
#define __PROCESS_TRI_STRIP_NAME ProcessClippedTriangleStrip
|
||
|
|
#include "clipprim.h"
|
||
|
|
|
||
|
|
#define __INDEX_PRIM
|
||
|
|
#define __PROCESS_TRI_LIST_NAME ProcessClippedIndexedTriangleList
|
||
|
|
#define __PROCESS_TRI_STRIP_NAME ProcessClippedIndexedTriangleStrip
|
||
|
|
#define __PROCESS_LINE_NAME ProcessClippedIndexedLine
|
||
|
|
#include "clipprim.h"
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------
|
||
|
|
HRESULT D3DFE_PVFUNCSI::ProcessClippedPoints(D3DFE_PROCESSVERTICES *pv)
|
||
|
|
{
|
||
|
|
DWORD i;
|
||
|
|
WORD count;
|
||
|
|
BYTE *lpStartVertex;
|
||
|
|
BYTE *lpCurVertex;
|
||
|
|
HRESULT ret;
|
||
|
|
D3DFE_CLIPCODE *clipCode;
|
||
|
|
const DWORD nVertices = pv->dwNumVertices;
|
||
|
|
|
||
|
|
clipCode = pv->lpClipFlags;
|
||
|
|
count = 0;
|
||
|
|
lpStartVertex = lpCurVertex = (BYTE*)pv->lpvOut;
|
||
|
|
for (i=0; i < nVertices; i++)
|
||
|
|
{
|
||
|
|
if (clipCode[i])
|
||
|
|
{ // if this point is clipped
|
||
|
|
if (count)
|
||
|
|
{ // first draw the ones that didn't need clipping
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_POINTLIST, lpStartVertex, count, count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// reset count and start ptr
|
||
|
|
count = 0;
|
||
|
|
lpCurVertex += pv->dwOutputSize;
|
||
|
|
lpStartVertex = lpCurVertex;
|
||
|
|
pv->pDDI->SkipVertices(1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
count++;
|
||
|
|
lpCurVertex += pv->dwOutputSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// draw final batch, if any
|
||
|
|
if (count)
|
||
|
|
{
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_POINTLIST, lpStartVertex, count, count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
//---------------------------------------------------------------------
|
||
|
|
// We do not throw away point sprites which centers are off screeen.
|
||
|
|
// We detect this case and compute screen coordinates for those sprites
|
||
|
|
//
|
||
|
|
HRESULT ProcessClippedPointSprites(D3DFE_PROCESSVERTICES *pv)
|
||
|
|
{
|
||
|
|
DWORD i;
|
||
|
|
WORD count;
|
||
|
|
BYTE *lpStartVertex;
|
||
|
|
BYTE *lpCurVertex;
|
||
|
|
HRESULT ret;
|
||
|
|
D3DFE_CLIPCODE *clipCode;
|
||
|
|
const DWORD nVertices = pv->dwNumVertices;
|
||
|
|
|
||
|
|
clipCode = pv->lpClipFlags;
|
||
|
|
count = 0;
|
||
|
|
lpStartVertex = lpCurVertex = (BYTE*)pv->lpvOut;
|
||
|
|
for (i=0; i < nVertices; i++)
|
||
|
|
{
|
||
|
|
// If a point is outside screen or guard band, the sprite could still
|
||
|
|
// be visible (when the guard band is small enough
|
||
|
|
if (clipCode[i] & ~(D3DCS_LEFT | D3DCS_RIGHT |
|
||
|
|
D3DCS_TOP | D3DCS_BOTTOM |
|
||
|
|
__D3DCLIPGB_ALL))
|
||
|
|
{
|
||
|
|
// This point is off viewing frustum
|
||
|
|
if (count)
|
||
|
|
{ // first draw the ones that didn't need clipping
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_POINTLIST, lpStartVertex, count, count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// reset count and start ptr
|
||
|
|
count = 0;
|
||
|
|
lpCurVertex += pv->dwOutputSize;
|
||
|
|
lpStartVertex = lpCurVertex;
|
||
|
|
if (!(pv->dwDeviceFlags & D3DDEV_DOPOINTSPRITEEMULATION))
|
||
|
|
pv->pDDI->SkipVertices(1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (clipCode[i])
|
||
|
|
{
|
||
|
|
// When we are here, the point sprite center is off-screen, but
|
||
|
|
// could be visible
|
||
|
|
|
||
|
|
// Non zero when the point is outside guard band
|
||
|
|
DWORD gbBits = clipCode[i] & __D3DCLIPGB_ALL;
|
||
|
|
|
||
|
|
// Screen coordinates were not computed for the point if there is
|
||
|
|
// no guard band or the point is outside the guard band
|
||
|
|
if (!(pv->dwDeviceFlags & D3DDEV_GUARDBAND) ||
|
||
|
|
(pv->dwDeviceFlags & D3DDEV_GUARDBAND) && gbBits)
|
||
|
|
{
|
||
|
|
D3DVECTORH* p = (D3DVECTORH*)lpCurVertex;
|
||
|
|
float w = 1.0f/p->w;
|
||
|
|
p->x = p->x * w * pv->vcache.scaleX + pv->vcache.offsetX;
|
||
|
|
p->y = p->y * w * pv->vcache.scaleY + pv->vcache.offsetY;
|
||
|
|
p->z = p->z * w * pv->vcache.scaleZ + pv->vcache.offsetZ;
|
||
|
|
p->w = w;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
count++;
|
||
|
|
lpCurVertex += pv->dwOutputSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// draw final batch, if any
|
||
|
|
if (count)
|
||
|
|
{
|
||
|
|
ret = DRAW_PRIM(pv, D3DPT_POINTLIST, lpStartVertex, count, count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
return D3D_OK;
|
||
|
|
}
|
||
|
|
//---------------------------------------------------------------------
|
||
|
|
HRESULT D3DFE_PVFUNCSI::ProcessClippedIndexedPoints(D3DFE_PROCESSVERTICES *pv)
|
||
|
|
{
|
||
|
|
DWORD i;
|
||
|
|
WORD count;
|
||
|
|
BYTE *lpStartIndex;
|
||
|
|
BYTE *lpCurIndex;
|
||
|
|
HRESULT ret;
|
||
|
|
D3DFE_CLIPCODE *clipCode;
|
||
|
|
const DWORD nIndices = pv->dwNumIndices;
|
||
|
|
DWORD dwIndexSize = pv->dwIndexSize;
|
||
|
|
LPBYTE pIndices = (LPBYTE)pv->lpwIndices;
|
||
|
|
|
||
|
|
clipCode = pv->lpClipFlags;
|
||
|
|
count = 0;
|
||
|
|
lpStartIndex = lpCurIndex = (BYTE*)pv->lpwIndices;
|
||
|
|
// Update the address of the vertex array to handle the index base
|
||
|
|
clipCode -= pv->dwIndexOffset;
|
||
|
|
|
||
|
|
for (i=0; i < nIndices; i++)
|
||
|
|
{
|
||
|
|
DWORD index;
|
||
|
|
if (dwIndexSize == 2)
|
||
|
|
index = *(WORD*)pIndices;
|
||
|
|
else
|
||
|
|
index = *(DWORD*)pIndices;
|
||
|
|
pIndices += dwIndexSize;
|
||
|
|
if (clipCode[index])
|
||
|
|
{ // if this point is clipped
|
||
|
|
if (count)
|
||
|
|
{ // first draw the ones that didn't need clipping
|
||
|
|
ret = DRAW_INDEX_PRIM(pv, D3DPT_POINTLIST, (WORD*)lpStartIndex,
|
||
|
|
count, count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// reset count and start ptr
|
||
|
|
count = 0;
|
||
|
|
lpCurIndex += pv->dwIndexSize;
|
||
|
|
lpStartIndex = lpCurIndex;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
count++;
|
||
|
|
lpCurIndex += pv->dwIndexSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// draw final batch, if any
|
||
|
|
if (count)
|
||
|
|
{
|
||
|
|
ret = DRAW_INDEX_PRIM(pv, D3DPT_POINTLIST, (WORD*)lpStartIndex, count,
|
||
|
|
count);
|
||
|
|
if (ret)
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
return D3D_OK;
|
||
|
|
}
|