|
|
/*==========================================================================;
* * 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;}
|
