/*============================================================================
*
* Copyright (C) 2001 Microsoft Corporation. All Rights Reserved.
*
* File: npatch.cpp
* Content: Consersion of NPatches to Rect-Patches
*
****************************************************************************/
#include "pch.cpp"
#pragma hdrstop
//-----------------------------------------------------------------------------
UINT CVertexPointer::Stride[__NUMELEMENTS];
UINT CVertexPointer::NumUsedElements;
UINT CVertexPointer::DataType[__NUMELEMENTS];
//-----------------------------------------------------------------------------
static const float Tension = 1.0f/3.0f;
static const float OneOver3 = 1.0f/3.0f;
//-----------------------------------------------------------------------------
struct UVW
{
float u, v, w, uu, vv, ww, uv, uw, vw;
};
static UVW g_uvw[10];
//-----------------------------------------------------------------------------
CNPatch2TriPatch::CNPatch2TriPatch()
{
memset(this, 0, sizeof(this));
// Write only streams with RTPatches usage
for (int i=0; i < __NUMELEMENTS; i++)
m_pOutStream[i] = new CTLStream(TRUE, D3DUSAGE_RTPATCHES);
int k = 0;
for(int vv = 3; vv >= 0; --vv)
for(int uu = 0; uu < 4 - vv; ++uu)
{
int ww = 3 - uu - vv;
float u = uu * OneOver3;
float v = vv * OneOver3;
float w = ww * OneOver3;
g_uvw[k].u = u;
g_uvw[k].v = v;
g_uvw[k].w = w;
g_uvw[k].uu = u*u;
g_uvw[k].vv = v*v;
g_uvw[k].ww = w*w;
g_uvw[k].uv = u*v;
g_uvw[k].uw = u*w;
g_uvw[k].vw = v*w;
k++;
}
}
//-----------------------------------------------------------------------------
void ComputeNormalControlPoint(D3DVECTOR* cp,
float* pVi, float* pVj,
float* pNi, float* pNj)
{
D3DVECTOR Pji;
D3DVECTOR Nij;
VecSub(*(D3DVECTOR*)pVj, *(D3DVECTOR*)pVi, Pji);
VecAdd(*(D3DVECTOR*)pNj, *(D3DVECTOR*)pNi, Nij);
FLOAT v = 2.0f * VecDot(Pji, Nij) / VecDot(Pji, Pji);
Pji.x *= v;
Pji.y *= v;
Pji.z *= v;
VecSub(Nij, Pji, *cp);
// Now go from polynomial coefficients to Bezier control points
cp->x *= 0.5f;
cp->y *= 0.5f;
cp->z *= 0.5f;
}
//-----------------------------------------------------------------------------
CNPatch2TriPatch::~CNPatch2TriPatch()
{
for (int i=0; i < __NUMELEMENTS; i++)
delete m_pOutStream[i];
}
//-----------------------------------------------------------------------------
// Convert NPatch to Rect-Patch:
//
void CNPatch2TriPatch::MakeRectPatch(const CVertexPointer& pV0,
const CVertexPointer& pV2,
const CVertexPointer& pV1)
{
float t, Edge[3], B[10][3];
float n0[3];
float n1[3];
float n2[3];
float *p0 = (float*)pV0.pData[m_PositionIndex];
float *p1 = (float*)pV1.pData[m_PositionIndex];
float *p2 = (float*)pV2.pData[m_PositionIndex];
n0[0] = ((float*)pV0.pData[m_NormalIndex])[0];
n0[1] = ((float*)pV0.pData[m_NormalIndex])[1];
n0[2] = ((float*)pV0.pData[m_NormalIndex])[2];
n1[0] = ((float*)pV1.pData[m_NormalIndex])[0];
n1[1] = ((float*)pV1.pData[m_NormalIndex])[1];
n1[2] = ((float*)pV1.pData[m_NormalIndex])[2];
n2[0] = ((float*)pV2.pData[m_NormalIndex])[0];
n2[1] = ((float*)pV2.pData[m_NormalIndex])[1];
n2[2] = ((float*)pV2.pData[m_NormalIndex])[2];
// Coefficients to interpolate quadratic normals
D3DVECTOR N002;
D3DVECTOR N020;
D3DVECTOR N200;
D3DVECTOR N110;
D3DVECTOR N101;
D3DVECTOR N011;
// Convert NPatch to Tri-Patch first
if (m_PositionOrder == D3DORDER_CUBIC)
{
B[0][0] = p0[0];
B[0][1] = p0[1];
B[0][2] = p0[2];
B[6][0] = p1[0];
B[6][1] = p1[1];
B[6][2] = p1[2];
B[9][0] = p2[0];
B[9][1] = p2[1];
B[9][2] = p2[2];
Edge[0] = p1[0] - p0[0];
Edge[1] = p1[1] - p0[1];
Edge[2] = p1[2] - p0[2];
t = Edge[0] * n0[0] + Edge[1] * n0[1] + Edge[2] * n0[2];
B[1][0] = p0[0] + (Edge[0] - n0[0] * t) * Tension;
B[1][1] = p0[1] + (Edge[1] - n0[1] * t) * Tension;
B[1][2] = p0[2] + (Edge[2] - n0[2] * t) * Tension;
Edge[0] = p0[0] - p1[0];
Edge[1] = p0[1] - p1[1];
Edge[2] = p0[2] - p1[2];
t = Edge[0] * n1[0] + Edge[1] * n1[1] + Edge[2] * n1[2];
B[3][0] = p1[0] + (Edge[0] - n1[0] * t) * Tension;
B[3][1] = p1[1] + (Edge[1] - n1[1] * t) * Tension;
B[3][2] = p1[2] + (Edge[2] - n1[2] * t) * Tension;
Edge[0] = p2[0] - p1[0];
Edge[1] = p2[1] - p1[1];
Edge[2] = p2[2] - p1[2];
t = Edge[0] * n1[0] + Edge[1] * n1[1] + Edge[2] * n1[2];
B[7][0] = p1[0] + (Edge[0] - n1[0] * t) * Tension;
B[7][1] = p1[1] + (Edge[1] - n1[1] * t) * Tension;
B[7][2] = p1[2] + (Edge[2] - n1[2] * t) * Tension;
Edge[0] = p1[0] - p2[0];
Edge[1] = p1[1] - p2[1];
Edge[2] = p1[2] - p2[2];
t = Edge[0] * n2[0] + Edge[1] * n2[1] + Edge[2] * n2[2];
B[8][0] = p2[0] + (Edge[0] - n2[0] * t) * Tension;
B[8][1] = p2[1] + (Edge[1] - n2[1] * t) * Tension;
B[8][2] = p2[2] + (Edge[2] - n2[2] * t) * Tension;
Edge[0] = p2[0] - p0[0];
Edge[1] = p2[1] - p0[1];
Edge[2] = p2[2] - p0[2];
t = Edge[0] * n0[0] + Edge[1] * n0[1] + Edge[2] * n0[2];
B[2][0] = p0[0] + (Edge[0] - n0[0] * t) * Tension;
B[2][1] = p0[1] + (Edge[1] - n0[1] * t) * Tension;
B[2][2] = p0[2] + (Edge[2] - n0[2] * t) * Tension;
Edge[0] = p0[0] - p2[0];
Edge[1] = p0[1] - p2[1];
Edge[2] = p0[2] - p2[2];
t = Edge[0] * n2[0] + Edge[1] * n2[1] + Edge[2] * n2[2];
B[5][0] = p2[0] + (Edge[0] - n2[0] * t) * Tension;
B[5][1] = p2[1] + (Edge[1] - n2[1] * t) * Tension;
B[5][2] = p2[2] + (Edge[2] - n2[2] * t) * Tension;
B[4][0] = (B[1][0] + B[2][0] + B[3][0] + B[5][0] + B[7][0] + B[8][0]) / 4.0f - (B[0][0] + B[6][0] + B[9][0]) / 6.0f;
B[4][1] = (B[1][1] + B[2][1] + B[3][1] + B[5][1] + B[7][1] + B[8][1]) / 4.0f - (B[0][1] + B[6][1] + B[9][1]) / 6.0f;
B[4][2] = (B[1][2] + B[2][2] + B[3][2] + B[5][2] + B[7][2] + B[8][2]) / 4.0f - (B[0][2] + B[6][2] + B[9][2]) / 6.0f;
}
if (m_NormalOrder == D3DORDER_QUADRATIC)
{
// Compute central control point
if (m_bNormalizeNormals)
{
VecNormalizeFast(*n0);
VecNormalizeFast(*n1);
VecNormalizeFast(*n2);
}
N002 = *(D3DVECTOR*)n1;
N020 = *(D3DVECTOR*)n0;
N200 = *(D3DVECTOR*)n2;
// Compute edge control points
ComputeNormalControlPoint(&N110, p0, p2, n0, n2);
ComputeNormalControlPoint(&N101, p2, p1, n2, n1);
ComputeNormalControlPoint(&N011, p1, p0, n1, n0);
}
float CP[__NUMELEMENTS*4][10]; // Computed tri-patch control pointes
int iCP; // Float value index in the control point array
for(int k = 0; k < 10; k++)
{
iCP = 0;
const float U = g_uvw[k].u;
const float V = g_uvw[k].v;
const float W = g_uvw[k].w;
for (UINT iElement=0; iElement < CVertexPointer::NumUsedElements; iElement++)
{
if (iElement == m_PositionIndex)
{
if (m_PositionOrder == D3DORDER_CUBIC)
{
CP[iCP++][k] = B[k][0];
CP[iCP++][k] = B[k][1];
CP[iCP++][k] = B[k][2];
}
else
{
CP[iCP++][k] = p2[0] * U + p0[0] * V + p1[0] * W;
CP[iCP++][k] = p2[1] * U + p0[1] * V + p1[1] * W;
CP[iCP++][k] = p2[2] * U + p0[2] * V + p1[2] * W;
}
}
else
if (iElement == m_NormalIndex)
{
if (m_NormalOrder == D3DORDER_QUADRATIC)
{
D3DVECTOR Q;
// Do degree elevation from quadratic to cubic
switch (k)
{
case 0:
Q.x = N020.x;
Q.y = N020.y;
Q.z = N020.z;
break;
case 1:
Q.x = (2.0f*N011.x + N020.x) * OneOver3;
Q.y = (2.0f*N011.y + N020.y) * OneOver3;
Q.z = (2.0f*N011.z + N020.z) * OneOver3;
break;
case 2:
Q.x = (2.0f*N110.x + N020.x) * OneOver3;
Q.y = (2.0f*N110.y + N020.y) * OneOver3;
Q.z = (2.0f*N110.z + N020.z) * OneOver3;
break;
case 3:
Q.x = (2.0f*N011.x + N002.x) * OneOver3;
Q.y = (2.0f*N011.y + N002.y) * OneOver3;
Q.z = (2.0f*N011.z + N002.z) * OneOver3;
break;
case 4:
Q.x = (N011.x + N101.x + N110.x) * OneOver3;
Q.y = (N011.y + N101.y + N110.y) * OneOver3;
Q.z = (N011.z + N101.z + N110.z) * OneOver3;
break;
case 5:
Q.x = (2.0f*N110.x + N200.x) * OneOver3;
Q.y = (2.0f*N110.y + N200.y) * OneOver3;
Q.z = (2.0f*N110.z + N200.z) * OneOver3;
break;
case 6:
Q.x = N002.x;
Q.y = N002.y;
Q.z = N002.z;
break;
case 7:
Q.x = (2.0f*N101.x + N002.x) * OneOver3;
Q.y = (2.0f*N101.y + N002.y) * OneOver3;
Q.z = (2.0f*N101.z + N002.z) * OneOver3;
break;
case 8:
Q.x = (2.0f*N101.x + N200.x) * OneOver3;
Q.y = (2.0f*N101.y + N200.y) * OneOver3;
Q.z = (2.0f*N101.z + N200.z) * OneOver3;
break;
case 9:
Q.x = N200.x;
Q.y = N200.y;
Q.z = N200.z;
break;
}
CP[iCP++][k] = Q.x;
CP[iCP++][k] = Q.y;
CP[iCP++][k] = Q.z;
}
else
{
CP[iCP++][k] = n2[0] * U + n0[0] * V + n1[0] * W;
CP[iCP++][k] = n2[1] * U + n0[1] * V + n1[1] * W;
CP[iCP++][k] = n2[2] * U + n0[2] * V + n1[2] * W;
}
}
else
{
switch(CVertexPointer::DataType[iElement])
{
case D3DVSDT_FLOAT1:
CP[iCP++][k] = ((float*)pV2.pData[iElement])[0] * U +
((float*)pV0.pData[iElement])[0] * V +
((float*)pV1.pData[iElement])[0] * W;
break;
case D3DVSDT_FLOAT2:
CP[iCP++][k] = ((float*)pV2.pData[iElement])[0] * U +
((float*)pV0.pData[iElement])[0] * V +
((float*)pV1.pData[iElement])[0] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[1] * U +
((float*)pV0.pData[iElement])[1] * V +
((float*)pV1.pData[iElement])[1] * W;
break;
case D3DVSDT_FLOAT3:
CP[iCP++][k] = ((float*)pV2.pData[iElement])[0] * U +
((float*)pV0.pData[iElement])[0] * V +
((float*)pV1.pData[iElement])[0] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[1] * U +
((float*)pV0.pData[iElement])[1] * V +
((float*)pV1.pData[iElement])[1] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[2] * U +
((float*)pV0.pData[iElement])[2] * V +
((float*)pV1.pData[iElement])[2] * W;
break;
case D3DVSDT_FLOAT4:
CP[iCP++][k] = ((float*)pV2.pData[iElement])[0] * U +
((float*)pV0.pData[iElement])[0] * V +
((float*)pV1.pData[iElement])[0] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[1] * U +
((float*)pV0.pData[iElement])[1] * V +
((float*)pV1.pData[iElement])[1] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[2] * U +
((float*)pV0.pData[iElement])[2] * V +
((float*)pV1.pData[iElement])[2] * W;
CP[iCP++][k] = ((float*)pV2.pData[iElement])[3] * U +
((float*)pV0.pData[iElement])[3] * V +
((float*)pV1.pData[iElement])[3] * W;
break;
case D3DVSDT_D3DCOLOR:
case D3DVSDT_UBYTE4:
DWORD c;
c = *(DWORD*)pV0.pData[iElement];
float r[3], g[3], b[3], a[3];
r[0] = float(c & 0xFF);
g[0] = float((c >> 8) & 0xFF);
b[0] = float((c >> 16) & 0xFF);
a[0] = float((c >> 24) & 0xFF);
c = *(DWORD*)pV1.pData[iElement];
r[1] = float(c & 0xFF);
g[1] = float((c >> 8) & 0xFF);
b[1] = float((c >> 16) & 0xFF);
a[1] = float((c >> 24) & 0xFF);
c = *(DWORD*)pV2.pData[iElement];
r[2] = float(c & 0xFF);
g[2] = float((c >> 8) & 0xFF);
b[2] = float((c >> 16) & 0xFF);
a[2] = float((c >> 24) & 0xFF);
CP[iCP++][k] = r[2] * U + r[0] * V + r[1] * W;
CP[iCP++][k] = g[2] * U + g[0] * V + g[1] * W;
CP[iCP++][k] = b[2] * U + b[0] * V + b[1] * W;
CP[iCP++][k] = a[2] * U + a[0] * V + a[1] * W;
break;
case D3DVSDT_SHORT2:
CP[iCP++][k]= (float)(
((short*)pV2.pData[iElement])[0] * U +
((short*)pV0.pData[iElement])[0] * V +
((short*)pV1.pData[iElement])[0] * W);
CP[iCP++][k] = (float)(
((short*)pV2.pData[iElement])[1] * U +
((short*)pV0.pData[iElement])[1] * V +
((short*)pV1.pData[iElement])[1] * W);
break;
case D3DVSDT_SHORT4:
CP[iCP++][k] = (float)(
((short*)pV2.pData[iElement])[0] * U +
((short*)pV0.pData[iElement])[0] * V +
((short*)pV1.pData[iElement])[0] * W);
CP[iCP++][k] = (float)(
((short*)pV2.pData[iElement])[1] * U +
((short*)pV0.pData[iElement])[1] * V +
((short*)pV1.pData[iElement])[1] * W);
CP[iCP++][k] = (float)(
((short*)pV2.pData[iElement])[2] * U +
((short*)pV0.pData[iElement])[2] * V +
((short*)pV1.pData[iElement])[2] * W);
CP[iCP++][k] = (float)(
((short*)pV2.pData[iElement])[3] * U +
((short*)pV0.pData[iElement])[3] * V +
((short*)pV1.pData[iElement])[3] * W);
break;
default: DXGASSERT(FALSE);
}
}
}
}
// Now convert Tri-Patch to Rect-Patch by transforming 10 tri-patch control
// points to 16 rect-patch control points
float CPR[16][__NUMELEMENTS*4]; // Computed rect-patch control pointes
{
for (int i=0; i < iCP; i++)
{
// First row - copy first point 4 times
CPR[0][i] = CPR[1][i] =
CPR[2][i] = CPR[3][i] = CP[i][0];
// 2nd row
float v1 = CP[i][1];
float v2 = CP[i][2];
CPR[ 4][i] = v1;
CPR[ 5][i] = (v1 * 2.0f + v2 ) * OneOver3;
CPR[ 6][i] = (v1 + v2 * 2.0f) * OneOver3;
CPR[ 7][i] = v2;
// 3rd row
CPR[ 8][i] = CP[i][3];
CPR[ 9][i] = (CP[i][3] + CP[i][4] * 2.0f) * OneOver3;
CPR[10][i] = (CP[i][4] * 2.0f + CP[i][5] ) * OneOver3;
CPR[11][i] = CP[i][5];
// 4th row - copy all elements
CPR[12][i] = CP[i][6];
CPR[13][i] = CP[i][7];
CPR[14][i] = CP[i][8];
CPR[15][i] = CP[i][9];
}
}
// Output the result
{
for (int i=0; i < 16; i++)
{
UINT k = 0;
for (UINT iElement=0; iElement < CVertexPointer::NumUsedElements; iElement++)
{
float* pout = (float*)m_OutVertex.pData[iElement];
switch(CVertexPointer::DataType[iElement])
{
case D3DVSDT_FLOAT1:
pout[0] = CPR[i][k++];
break;
case D3DVSDT_FLOAT2:
pout[0] = CPR[i][k++];
pout[1] = CPR[i][k++];
break;
case D3DVSDT_FLOAT3:
pout[0] = CPR[i][k++];
pout[1] = CPR[i][k++];
pout[2] = CPR[i][k++];
break;
case D3DVSDT_FLOAT4:
pout[0] = CPR[i][k++];
pout[1] = CPR[i][k++];
pout[2] = CPR[i][k++];
pout[3] = CPR[i][k++];
break;
case D3DVSDT_D3DCOLOR:
case D3DVSDT_UBYTE4:
{
DWORD c;
float r = CPR[i][k++];
float g = CPR[i][k++];
float b = CPR[i][k++];
float a = CPR[i][k++];
c = DWORD(r);
c |= DWORD(g) << 8;
c |= DWORD(b) << 16;
c |= DWORD(a) << 24;
*(DWORD*)pout = c;
}
break;
case D3DVSDT_SHORT2:
((short*)pout)[0] = (short)(CPR[i][k++]);
((short*)pout)[1] = (short)(CPR[i][k++]);
break;
case D3DVSDT_SHORT4:
((short*)pout)[0] = (short)(CPR[i][k++]);
((short*)pout)[1] = (short)(CPR[i][k++]);
((short*)pout)[2] = (short)(CPR[i][k++]);
((short*)pout)[3] = (short)(CPR[i][k++]);
break;
default: DXGASSERT(FALSE);
}
}
m_OutVertex++;
}
}
}
//-----------------------------------------------------------------------------
void DrawPatches(CD3DHal* pDevice, UINT PrimitiveCount)
{
// Unlock output vertex buffers
if (D3DVSD_ISLEGACY(pDevice->m_dwCurrentShaderHandle))
{
pDevice->m_pConvObj->m_pOutStream[0]->m_pVB->Unlock();
}
else
{
CVDeclaration* pDecl = &pDevice->m_pCurrentShader->m_Declaration;
CVStreamDecl* pStreamDecl = pDevice->m_pCurrentShader->m_Declaration.m_pActiveStreams;
while (pStreamDecl)
{
pDevice->m_pConvObj->m_pOutStream[pStreamDecl->m_dwStreamIndex]->m_pVB->Unlock();
pStreamDecl = (CVStreamDecl*)pStreamDecl->m_pNext;
}
}
// Draw rect patches
float numSegs[4];
numSegs[0] =
numSegs[1] =
numSegs[2] =
numSegs[3] = *(float*)&pDevice->rstates[D3DRS_PATCHSEGMENTS];
D3DRECTPATCH_INFO info;
info.StartVertexOffsetWidth = pDevice->m_pConvObj->m_FirstVertex;
info.StartVertexOffsetHeight = 0;
info.Width = 4;
info.Height = 4;
info.Stride = 4; // verticies to next row of verticies
info.Basis = D3DBASIS_BEZIER;
info.Order = D3DORDER_CUBIC;
for (UINT i = PrimitiveCount; i > 0; i--)
{
pDevice->DrawRectPatch(0, numSegs, &info);
info.StartVertexOffsetWidth += 16;
}
// Restore input vertex streams
if (D3DVSD_ISLEGACY(pDevice->m_dwCurrentShaderHandle))
{
// Always need to call SetStreamSource to decrease reference count of
// the internal VB buffer
pDevice->SetStreamSource(0, pDevice->m_pConvObj->m_InpStream[0].m_pVB,
CVertexPointer::Stride[0]);
if (pDevice->m_pConvObj->m_InpStream[0].m_pVB)
{
// Remove additional ref count, because the stream is set
// second time
pDevice->m_pConvObj->m_InpStream[0].m_pVB->Release();
pDevice->m_pConvObj->m_InpStream[0].m_pVB = NULL;
}
}
else
{
CVDeclaration* pDecl = &pDevice->m_pCurrentShader->m_Declaration;
CVStreamDecl* pStreamDecl = pDevice->m_pCurrentShader->m_Declaration.m_pActiveStreams;
while (pStreamDecl)
{
UINT si = pStreamDecl->m_dwStreamIndex;
UINT Stride = pStreamDecl->m_dwStride;
CVStream* pStream = &pDevice->m_pConvObj->m_InpStream[si];
// Always need to call SetStreamSource to decrease reference count
// of the internal VB buffer
pDevice->SetStreamSource(si, pStream->m_pVB, Stride);
if (pStream->m_pVB)
{
// Remove additional ref count, because the stream is set second
// time
pStream->m_pVB->Release();
pStream->m_pVB = NULL;
}
pStreamDecl = (CVStreamDecl*)pStreamDecl->m_pNext;
}
}
}
//-----------------------------------------------------------------------------
void CD3DHal_DrawNPatch(CD3DBase* pBaseDevice, D3DPRIMITIVETYPE PrimitiveType,
UINT StartVertex, UINT PrimitiveCount)
{
CD3DHal* pDevice = static_cast<CD3DHal*>(pBaseDevice);
// Draw as usual for non-triangle primitive types
if (PrimitiveType < D3DPT_TRIANGLELIST)
{
(*pDevice->m_pfnDrawPrimFromNPatch)(pBaseDevice, PrimitiveType,
StartVertex, PrimitiveCount);
// m_pfnDrawPrim could be switched to fast path, so we need to restore it
pDevice->m_pfnDrawPrim = CD3DHal_DrawNPatch;
return;
}
#if DBG
UINT nVer = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
pDevice->ValidateDraw2(PrimitiveType, StartVertex, PrimitiveCount, nVer,
FALSE);
#endif
pDevice->PrepareNPatchConversion(PrimitiveCount, StartVertex);
// Go through triangles and generate tri-patches
CNPatch2TriPatch* pConvObj = pDevice->m_pConvObj;
switch( PrimitiveType )
{
case D3DPT_TRIANGLELIST:
{
for (UINT i = PrimitiveCount; i > 0; i--)
{
CVertexPointer pV0 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
CVertexPointer pV1 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
CVertexPointer pV2 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLESTRIP:
{
// Get initial vertex values.
CVertexPointer pV0;
CVertexPointer pV1 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
CVertexPointer pV2 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
for (UINT i =PrimitiveCount; i > 1; i -= 2)
{
pV0 = pV1;
pV1 = pV2;
pV2 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
pConvObj->MakeRectPatch(pV0, pV1, pV2);
pV0 = pV1;
pV1 = pV2;
pV2 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
pConvObj->MakeRectPatch(pV0, pV2, pV1);
}
if (i > 0)
{
pV0 = pV1;
pV1 = pV2;
pV2 = pConvObj->m_InpVertex;
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLEFAN:
{
CVertexPointer pV0;
CVertexPointer pV1;
CVertexPointer pV2;
pV2 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
// Preload initial pV0.
pV1 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
for (UINT i = PrimitiveCount; i > 0; i--)
{
pV0 = pV1;
pV1 = pConvObj->m_InpVertex;
pConvObj->m_InpVertex++;
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
default:
DXGASSERT(FALSE);
}
pDevice->m_pDDI->SetWithinPrimitive(TRUE);
DrawPatches(pDevice, PrimitiveCount);
pDevice->m_pDDI->SetWithinPrimitive(FALSE);
}
//-----------------------------------------------------------------------------
void CD3DHal_DrawIndexedNPatch(CD3DBase* pBaseDevice,
D3DPRIMITIVETYPE PrimitiveType,
UINT BaseIndex,
UINT MinIndex, UINT NumVertices,
UINT StartIndex,
UINT PrimitiveCount)
{
CD3DHal* pDevice = static_cast<CD3DHal*>(pBaseDevice);
// Draw as usual for non-triangle primitive types
if (PrimitiveType < D3DPT_TRIANGLELIST)
{
(*pDevice->m_pfnDrawIndexedPrimFromNPatch)(pBaseDevice, PrimitiveType,
BaseIndex, MinIndex, NumVertices,
StartIndex, PrimitiveCount);
// m_pfnDrawIndexedPrim could be switched to fast path, so we
// need to restore it
pDevice->m_pfnDrawIndexedPrim = CD3DHal_DrawIndexedNPatch;
return;
}
#if DBG
pDevice->ValidateDraw2(PrimitiveType, MinIndex + BaseIndex, PrimitiveCount, NumVertices,
TRUE, StartIndex);
#endif
pDevice->PrepareNPatchConversion(PrimitiveCount, BaseIndex);
// Go through triangles and generate tri-patches
CNPatch2TriPatch* pConvObj = pDevice->m_pConvObj;
if (pDevice->m_pIndexStream->m_dwStride == 2)
{
WORD* pIndices = (WORD*)pDevice->m_pIndexStream->Data() + StartIndex;
switch( PrimitiveType )
{
case D3DPT_TRIANGLELIST:
{
for (UINT i = PrimitiveCount; i > 0; i--)
{
CVertexPointer pV0;
CVertexPointer pV1;
CVertexPointer pV2;
pV0.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLESTRIP:
{
CVertexPointer pV0;
CVertexPointer pV1;
CVertexPointer pV2;
// Get initial vertex values.
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
for (UINT i = PrimitiveCount; i > 1; i -= 2)
{
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV2, pV1);
}
if (i > 0)
{
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLEFAN:
{
CVertexPointer pV1;
CVertexPointer pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
// Preload initial pV0.
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
for (UINT i = PrimitiveCount; i > 0; i--)
{
CVertexPointer pV0 = pV1;
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV2, pV1);
}
}
break;
default:
DXGASSERT(FALSE);
}
}
else
{
DWORD* pIndices = (DWORD*)pDevice->m_pIndexStream->Data() + StartIndex;
switch( PrimitiveType )
{
case D3DPT_TRIANGLELIST:
{
for (UINT i = PrimitiveCount; i > 0; i--)
{
CVertexPointer pV0;
CVertexPointer pV1;
CVertexPointer pV2;
pV0.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLESTRIP:
{
CVertexPointer pV0;
CVertexPointer pV1;
CVertexPointer pV2;
// Get initial vertex values.
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
for (UINT i = PrimitiveCount; i > 1; i -= 2)
{
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV2, pV1);
}
if (i > 0)
{
pV0 = pV1;
pV1 = pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV1, pV2);
}
}
break;
case D3DPT_TRIANGLEFAN:
{
CVertexPointer pV1;
CVertexPointer pV2;
pV2.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
// Preload initial pV0.
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
for (UINT i = PrimitiveCount; i > 0; i--)
{
CVertexPointer pV0 = pV1;
pV1.SetVertex(pConvObj->m_InpVertex, (*pIndices++));
pConvObj->MakeRectPatch(pV0, pV2, pV1);
}
}
break;
default:
DXGASSERT(FALSE);
}
}
DrawPatches(pDevice, PrimitiveCount);
}
//-----------------------------------------------------------------------------
// Conversion output will have the same number of streams as input and the
// same vertex shader
//
void CD3DHal::PrepareNPatchConversion(UINT PrimitiveCount, UINT StartVertex)
{
if (m_pConvObj == NULL)
{
m_pConvObj = new CNPatch2TriPatch;
if (m_pConvObj == NULL)
{
D3D_THROW(E_OUTOFMEMORY, "Not enough memory");
}
// Pre-allocate output streams
for (int i=0; i < __NUMELEMENTS; i++)
{
m_pConvObj->m_pOutStream[i]->Grow(512*32, m_pDDI);
}
}
m_pConvObj->m_PositionOrder = (D3DORDERTYPE)rstates[D3DRS_POSITIONORDER];
m_pConvObj->m_NormalOrder = (D3DORDERTYPE)rstates[D3DRS_NORMALORDER];
m_pConvObj->m_bNormalizeNormals = rstates[D3DRS_NORMALIZENORMALS];
// Compute number of vertices in the output. Each output patch has 16
// control points
UINT nOutVertices = PrimitiveCount * 16;
if (D3DVSD_ISLEGACY(m_dwCurrentShaderHandle))
{
CVStream* pStream = &m_pStream[0];
UINT Stride = pStream->m_dwStride;
// Get memory pointer for the input stream 0
m_pConvObj->m_pInpStreamMem[0] = pStream->Data() + StartVertex * Stride;
if (Stride != m_pConvObj->m_pOutStream[0]->m_dwStride &&
m_pConvObj->m_pOutStream[0]->GetPrimitiveBase() != 0)
{
m_pDDI->FlushStates();
m_pConvObj->m_pOutStream[0]->Reset();
m_pConvObj->m_FirstVertex = 0;
}
// Allocate space in the corresponding output stream and get its
// memory pointer
m_pConvObj->m_pOutStreamMem[0] = m_pConvObj->m_pOutStream[0]->Lock(nOutVertices * Stride, m_pDDI);
m_pConvObj->m_pOutStream[0]->SetVertexSize(Stride);
m_pConvObj->m_FirstVertex = m_pConvObj->m_pOutStream[0]->GetPrimitiveBase();
m_pConvObj->m_FirstVertex /= Stride;
m_pConvObj->m_pOutStream[0]->SkipVertices(nOutVertices);
// Save the old vertex buffer
UINT tmp;
GetStreamSource(0, (IDirect3DVertexBuffer8**)&m_pConvObj->m_InpStream[0].m_pVB, &tmp);
// Set new vertex buffer as input stream
SetStreamSource(0, m_pConvObj->m_pOutStream[0]->m_pVB, Stride);
// Initialize vertex elements pointers based on the FVF handle
UINT VertexOffset = 0;
CVertexPointer::NumUsedElements = 0;
BYTE* pinp = m_pConvObj->m_pInpStreamMem[0];
BYTE* pout = m_pConvObj->m_pOutStreamMem[0];
// Position
m_pConvObj->m_PositionIndex = CVertexPointer::NumUsedElements;
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout;
VertexOffset += 3*sizeof(float);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT3;
CVertexPointer::NumUsedElements++;
// Data after position
switch (m_dwCurrentShaderHandle & D3DFVF_POSITION_MASK)
{
case D3DFVF_XYZB1:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT1;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_XYZB2:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 2;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT2;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_XYZB3:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 3;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT3;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_XYZB4:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 4;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT4;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_XYZB5:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 4;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT4;
CVertexPointer::NumUsedElements++;
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 1;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT1;
CVertexPointer::NumUsedElements++;
break;
}
//Normal
m_pConvObj->m_NormalIndex = CVertexPointer::NumUsedElements;
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += 3*sizeof(float);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT3;
CVertexPointer::NumUsedElements++;
if (m_dwCurrentShaderHandle & D3DFVF_PSIZE)
{
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT1;
CVertexPointer::NumUsedElements++;
}
if (m_dwCurrentShaderHandle & D3DFVF_DIFFUSE)
{
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(DWORD);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_D3DCOLOR;
CVertexPointer::NumUsedElements++;
}
if (m_dwCurrentShaderHandle & D3DFVF_SPECULAR)
{
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(DWORD);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_D3DCOLOR;
CVertexPointer::NumUsedElements++;
}
UINT iTexCount = FVF_TEXCOORD_NUMBER(m_dwCurrentShaderHandle);
for (UINT i = 0; i < iTexCount; i++)
{
switch (D3DFVF_GETTEXCOORDSIZE(m_dwCurrentShaderHandle, i))
{
case D3DFVF_TEXTUREFORMAT2:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 2;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT2;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_TEXTUREFORMAT1:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float);
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT1;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_TEXTUREFORMAT3:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 3;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT3;
CVertexPointer::NumUsedElements++;
break;
case D3DFVF_TEXTUREFORMAT4:
m_pConvObj->m_InpVertex.Stride[CVertexPointer::NumUsedElements] = Stride;
m_pConvObj->m_InpVertex.pData[CVertexPointer::NumUsedElements] = pinp + VertexOffset;
m_pConvObj->m_OutVertex.pData[CVertexPointer::NumUsedElements] = pout + VertexOffset;
VertexOffset += sizeof(float) * 4;
CVertexPointer::DataType[CVertexPointer::NumUsedElements] = D3DVSDT_FLOAT4;
CVertexPointer::NumUsedElements++;
break;
}
}
}
else
{
// Check if we can batch to the same output vertex streams.
// All output streams must have the same stride as declaration, the
// same primitive base and enough space to store output vertices
CVStreamDecl* pStreamDecl = m_pCurrentShader->m_Declaration.m_pActiveStreams;
BOOL bFirstStream = TRUE;
UINT FirstVertexIndex = 0;
while (pStreamDecl)
{
UINT si = pStreamDecl->m_dwStreamIndex;
UINT Stride = pStreamDecl->m_dwStride;
UINT PrimitiveBase = m_pConvObj->m_pOutStream[si]->GetPrimitiveBase();
PrimitiveBase /= Stride;
if (bFirstStream)
{
FirstVertexIndex = PrimitiveBase;
m_pConvObj->m_FirstVertex = FirstVertexIndex;
}
if ((m_pConvObj->m_pOutStream[si]->m_dwStride != Stride &&
PrimitiveBase != 0) || FirstVertexIndex != PrimitiveBase ||
!m_pConvObj->m_pOutStream[si]->CheckFreeSpace(nOutVertices * Stride))
{
m_pDDI->FlushStates();
for (int i=0; i < __NUMELEMENTS; i++)
{
m_pConvObj->m_pOutStream[i]->Reset();
}
m_pConvObj->m_FirstVertex = 0;
}
bFirstStream = FALSE;
pStreamDecl = (CVStreamDecl*)pStreamDecl->m_pNext;
}
// Build an array of all vertex elements used in the shader by going
// through all streams and elements inside each stream.
CVDeclaration* pDecl = &m_pCurrentShader->m_Declaration;
pStreamDecl = m_pCurrentShader->m_Declaration.m_pActiveStreams;
UINT ve = 0; // Vertex element index
bFirstStream = TRUE;
while (pStreamDecl)
{
UINT si = pStreamDecl->m_dwStreamIndex;
UINT Stride = pStreamDecl->m_dwStride;
CVStream * pStream = &m_pStream[si];
m_pConvObj->m_pInpStreamMem[si] = pStream->Data() + StartVertex * Stride;
// Allocate space in the corresponding output stream and get
// memory pointer
m_pConvObj->m_pOutStreamMem[si] = m_pConvObj->m_pOutStream[si]->Lock(nOutVertices * Stride, m_pDDI);
m_pConvObj->m_pOutStream[si]->SetVertexSize(Stride);
m_pConvObj->m_pOutStream[si]->SkipVertices(nOutVertices);
// Save the old vertex buffer
UINT tmp;
GetStreamSource(si, (IDirect3DVertexBuffer8**)&m_pConvObj->m_InpStream[si].m_pVB, &tmp);
// Set new vertex buffer as input
SetStreamSource(si, m_pConvObj->m_pOutStream[si]->m_pVB, Stride);
for (DWORD i=0; i < pStreamDecl->m_dwNumElements; i++)
{
if (i >= __NUMELEMENTS)
{
D3D_THROW_FAIL("Declaration is using too many elements");
}
// This is the array we build
CVElement* pVerElem = &pStreamDecl->m_Elements[i];
CVertexPointer::Stride[ve] = Stride;
CVertexPointer::DataType[ve] = pVerElem->m_dwDataType;
m_pConvObj->m_InpVertex.pData[ve] = m_pConvObj->m_pInpStreamMem[si] + pVerElem->m_dwOffset;
m_pConvObj->m_OutVertex.pData[ve] = m_pConvObj->m_pOutStreamMem[si] + pVerElem->m_dwOffset;
if (pVerElem->m_dwRegister == D3DVSDE_POSITION)
m_pConvObj->m_PositionIndex = ve;
else
if (pVerElem->m_dwRegister == D3DVSDE_NORMAL)
m_pConvObj->m_NormalIndex = ve;
ve++;
}
pStreamDecl = (CVStreamDecl*)pStreamDecl->m_pNext;
}
pDecl->m_dwNumElements = ve;
CVertexPointer::NumUsedElements = ve;
}
}