You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2606 lines
102 KiB
2606 lines
102 KiB
/*============================================================================
|
|
*
|
|
* Copyright (C) 1999 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: vshader.cpp
|
|
* Content: SetStreamSource and VertexShader
|
|
* software implementation.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "pch.cpp"
|
|
#pragma hdrstop
|
|
|
|
#include "ibuffer.hpp"
|
|
#include "fe.h"
|
|
#include "ddibase.h"
|
|
#include "pvvid.h"
|
|
|
|
void __Transpose(D3DMATRIXI* m, D3DMATRIX* res)
|
|
{
|
|
res->_11 = m->_11;
|
|
res->_12 = m->_21;
|
|
res->_13 = m->_31;
|
|
res->_14 = m->_41;
|
|
res->_21 = m->_12;
|
|
res->_22 = m->_22;
|
|
res->_23 = m->_32;
|
|
res->_24 = m->_42;
|
|
res->_31 = m->_13;
|
|
res->_32 = m->_23;
|
|
res->_33 = m->_33;
|
|
res->_34 = m->_43;
|
|
res->_41 = m->_14;
|
|
res->_42 = m->_24;
|
|
res->_43 = m->_34;
|
|
res->_44 = m->_44;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Forward definitions
|
|
//
|
|
void CD3DHal_DrawPrimitive(CD3DBase* pBaseDevice, D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT StartVertex, UINT PrimitiveCount);
|
|
void CD3DHal_DrawIndexedPrimitive(CD3DBase* pBaseDevice,
|
|
D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT BaseIndex,
|
|
UINT MinIndex, UINT NumVertices,
|
|
UINT StartIndex,
|
|
UINT PrimitiveCount);
|
|
void CD3DHal_DrawNPatch(CD3DBase* pBaseDevice, D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT StartVertex, UINT PrimitiveCount);
|
|
void CD3DHal_DrawIndexedNPatch(CD3DBase* pBaseDevice,
|
|
D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT BaseIndex,
|
|
UINT MinIndex, UINT NumVertices,
|
|
UINT StartIndex,
|
|
UINT PrimitiveCount);
|
|
//-----------------------------------------------------------------------------
|
|
void __declspec(nothrow) CD3DHal::PickDrawPrimFn()
|
|
{
|
|
if (!(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING))
|
|
{
|
|
m_pfnDrawPrim = m_pDDI->GetDrawPrimFunction();
|
|
m_pfnDrawIndexedPrim = m_pDDI->GetDrawIndexedPrimFunction();
|
|
if (m_dwRuntimeFlags & D3DRT_DONPATCHCONVERSION)
|
|
{
|
|
m_pfnDrawPrimFromNPatch = m_pfnDrawPrim;
|
|
m_pfnDrawIndexedPrimFromNPatch = m_pfnDrawIndexedPrim;
|
|
m_pfnDrawPrim = CD3DHal_DrawNPatch;
|
|
m_pfnDrawIndexedPrim = CD3DHal_DrawIndexedNPatch;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwDeviceFlags = m_pv->dwDeviceFlags;
|
|
BOOL bCallDriver;
|
|
if (Enum()->GetAppSdkVersion() == D3D_SDK_VERSION_DX8)
|
|
{
|
|
bCallDriver = dwDeviceFlags & D3DDEV_TRANSFORMEDFVF &&
|
|
(dwDeviceFlags & D3DDEV_DONOTCLIP ||
|
|
!(dwDeviceFlags & D3DDEV_VBPROCVER));
|
|
}
|
|
else
|
|
{
|
|
bCallDriver = dwDeviceFlags & D3DDEV_TRANSFORMEDFVF &&
|
|
dwDeviceFlags & D3DDEV_DONOTCLIP;
|
|
}
|
|
if (bCallDriver)
|
|
{
|
|
m_pfnDrawPrim = m_pDDI->GetDrawPrimFunction();
|
|
m_pfnDrawIndexedPrim = m_pDDI->GetDrawIndexedPrimFunction();
|
|
}
|
|
else
|
|
{
|
|
m_pfnDrawPrim = CD3DHal_DrawPrimitive;
|
|
m_pfnDrawIndexedPrim = CD3DHal_DrawIndexedPrimitive;
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Checks if we can call driver directly to draw the current primitive
|
|
//
|
|
inline BOOL CanCallDriver(CD3DHal* pDev, D3DPRIMITIVETYPE PrimType)
|
|
{
|
|
DWORD dwDeviceFlags = pDev->m_pv->dwDeviceFlags;
|
|
if (PrimType != D3DPT_POINTLIST)
|
|
return dwDeviceFlags & D3DDEV_TRANSFORMEDFVF &&
|
|
(dwDeviceFlags & D3DDEV_DONOTCLIP ||
|
|
pDev->Enum()->GetAppSdkVersion() == D3D_SDK_VERSION_DX8);
|
|
else
|
|
// This function could be called from DrawPointsI, which could be
|
|
// called from other Draw() function than DrawPrimitiveUP, so we need
|
|
// to check for D3DDEV_VBPROCVER. We cannot pass vertices, which are
|
|
// result of ProcessVertices(), to the driver directly
|
|
return dwDeviceFlags & D3DDEV_TRANSFORMEDFVF &&
|
|
!(pDev->m_dwRuntimeFlags & D3DRT_DOPOINTSPRITEEMULATION) &&
|
|
(dwDeviceFlags & D3DDEV_DONOTCLIP ||
|
|
(pDev->Enum()->GetAppSdkVersion() == D3D_SDK_VERSION_DX8 &&
|
|
!(dwDeviceFlags & D3DDEV_VBPROCVER)));
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// API calls
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::SetStreamSourceI"
|
|
|
|
void
|
|
CD3DHal::SetStreamSourceI(CVStream* pStream)
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
|
|
{
|
|
CVertexBuffer * pVB = pStream->m_pVB;
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_VBPROCVER;
|
|
DWORD dwFVF = pVB->GetFVF();
|
|
if (pVB->GetClipCodes() != NULL)
|
|
{
|
|
// This vertex buffer is the output of ProcessVertices
|
|
DXGASSERT(FVF_TRANSFORMED(dwFVF));
|
|
m_pv->dwDeviceFlags |= D3DDEV_VBPROCVER;
|
|
}
|
|
if (D3DVSD_ISLEGACY(m_dwCurrentShaderHandle))
|
|
{
|
|
SetupStrides(m_pv, m_pStream[0].m_dwStride);
|
|
}
|
|
}
|
|
PickDrawPrimFn();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::SetIndicesI"
|
|
|
|
void
|
|
CD3DHal::SetIndicesI(CVIndexStream* pStream)
|
|
{
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::CreateVertexShaderI"
|
|
|
|
void
|
|
CD3DHal::CreateVertexShaderI(CONST DWORD* pdwDeclaration, DWORD dwDeclSize,
|
|
CONST DWORD* pdwFunction, DWORD dwCodeSize,
|
|
DWORD dwHandle)
|
|
{
|
|
BOOL bIsCheckedBuild =
|
|
#if DBG
|
|
TRUE;
|
|
#else
|
|
FALSE;
|
|
#endif
|
|
CVShader* pShader = (CVShader*)m_pVShaderArray->GetObject(dwHandle);
|
|
if (pShader->m_dwFlags & CVShader::SOFTWARE)
|
|
{
|
|
|
|
// Build the array of all vertex elements used in the shader by going
|
|
// through all streams and elements inside each stream.
|
|
|
|
CVDeclaration* pDecl = &pShader->m_Declaration;
|
|
CVStreamDecl* pStream = pShader->m_Declaration.m_pActiveStreams;
|
|
// This is the array we build
|
|
CVElement* pVerElem = pShader->m_Declaration.m_VertexElements;
|
|
pDecl->m_dwNumElements = 0;
|
|
while (pStream)
|
|
{
|
|
for (DWORD i=0; i < pStream->m_dwNumElements; i++)
|
|
{
|
|
if (pDecl->m_dwNumElements >= __NUMELEMENTS)
|
|
{
|
|
D3D_THROW_FAIL("Declaration is using too many elements");
|
|
}
|
|
*pVerElem = pStream->m_Elements[i];
|
|
pVerElem->m_dwStreamIndex = pStream->m_dwStreamIndex;
|
|
pVerElem++;
|
|
pDecl->m_dwNumElements++;
|
|
}
|
|
pStream = (CVStreamDecl*)pStream->m_pNext;
|
|
}
|
|
|
|
if (pdwFunction != NULL)
|
|
{
|
|
// compute adjusted function pointer depending on FREE/CHECKED and PSGP
|
|
LPDWORD pdwFunctionAdj = pShader->m_pStrippedFuncCode;
|
|
if ( bIsCheckedBuild &&
|
|
((LPVOID)m_pv->pGeometryFuncs == (LPVOID)GeometryFuncsGuaranteed) ) // !PSGP
|
|
{
|
|
pdwFunctionAdj = pShader->m_pOrgFuncCode;
|
|
}
|
|
// Microsoft shader is always created.
|
|
// It is used for validation and to compute the output FVF in case
|
|
// when PSGP is present
|
|
HRESULT hr;
|
|
hr = GeometryFuncsGuaranteed->CreateShader(
|
|
pDecl->m_VertexElements,
|
|
pDecl->m_dwNumElements,
|
|
pdwFunctionAdj, 0,
|
|
(CPSGPShader**)&pShader->m_pCode);
|
|
if(FAILED(hr))
|
|
{
|
|
D3D_THROW_FAIL("Failed to create vertex shader code");
|
|
}
|
|
// When device driver can not handle separate fog value in the FVF,
|
|
// we should use specular alpha as the fog factor
|
|
if (pShader->m_pCode->m_dwOutFVF & D3DFVF_FOG &&
|
|
!(GetD3DCaps()->PrimitiveMiscCaps & D3DPMISCCAPS_FOGINFVF))
|
|
{
|
|
pShader->m_pCode->m_dwOutFVF &= ~D3DFVF_FOG;
|
|
// Assume that texture coordinates follow fog value
|
|
// No need to adjust offsets when specular is already present
|
|
if (pShader->m_pCode->m_dwOutFVF & D3DFVF_SPECULAR)
|
|
{
|
|
pShader->m_pCode->m_dwOutVerSize -= 4;
|
|
pShader->m_pCode->m_dwTextureOffset -= 4;
|
|
}
|
|
pShader->m_pCode->m_dwOutFVF |= D3DFVF_SPECULAR;
|
|
}
|
|
// Clear texture format bits if device can handle only 2 floats per
|
|
// texture coordinate
|
|
if (m_dwRuntimeFlags & D3DRT_ONLY2FLOATSPERTEXTURE &&
|
|
pShader->m_pCode->m_dwOutFVF & 0xFFFF0000)
|
|
{
|
|
CVShaderCode * pCode = pShader->m_pCode;
|
|
pCode->m_dwOutFVF &= 0x0000FFFF;
|
|
pCode->m_dwOutVerSize = ComputeVertexSizeFVF(pCode->m_dwOutFVF);
|
|
for (DWORD i=0; i < pCode->m_nOutTexCoord; i++)
|
|
{
|
|
pCode->m_dwOutTexCoordSize[i] = 2 * 4;
|
|
}
|
|
}
|
|
if ((LPVOID)m_pv->pGeometryFuncs != (LPVOID)GeometryFuncsGuaranteed)
|
|
{
|
|
DWORD dwOutputFVF = pShader->m_pCode->m_dwOutFVF;
|
|
CVShaderCode* pCodeMs = pShader->m_pCode;
|
|
// Now we can create PSGP shader
|
|
hr = m_pv->pGeometryFuncs->CreateShader(pDecl->m_VertexElements,
|
|
pDecl->m_dwNumElements,
|
|
pdwFunctionAdj, dwOutputFVF,
|
|
(CPSGPShader**)&pShader->m_pCode);
|
|
if(FAILED(hr))
|
|
{
|
|
delete pCodeMs;
|
|
D3D_THROW_FAIL("Failed to create vertex shader code");
|
|
}
|
|
// Copy pre-computed data from Microsoft's shader to the PSGP
|
|
CPSGPShader * pCode = pShader->m_pCode;
|
|
CPSGPShader * pMsShader = pCodeMs;
|
|
pCode->m_dwOutRegs = pMsShader->m_dwOutRegs;
|
|
pCode->m_dwOutFVF = pMsShader->m_dwOutFVF;
|
|
pCode->m_dwPointSizeOffset = pMsShader->m_dwPointSizeOffset;
|
|
pCode->m_dwDiffuseOffset = pMsShader->m_dwDiffuseOffset;
|
|
pCode->m_dwSpecularOffset = pMsShader->m_dwSpecularOffset;
|
|
pCode->m_dwFogOffset = pMsShader->m_dwFogOffset;
|
|
pCode->m_dwTextureOffset = pMsShader->m_dwTextureOffset;
|
|
pCode->m_nOutTexCoord = pMsShader->m_nOutTexCoord;
|
|
pCode->m_dwOutVerSize = pMsShader->m_dwOutVerSize;
|
|
for (DWORD i=0; i < pCode->m_nOutTexCoord; i++)
|
|
{
|
|
pCode->m_dwOutTexCoordSize[i] = pMsShader->m_dwOutTexCoordSize[i];
|
|
}
|
|
// Microsoft shader is not needed any more
|
|
delete pCodeMs;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( bIsCheckedBuild && (GetDeviceType() != D3DDEVTYPE_HAL ) )
|
|
{
|
|
// pass non-stripped version
|
|
m_pDDI->CreateVertexShader(
|
|
pdwDeclaration, dwDeclSize,
|
|
pShader->m_pOrgFuncCode,
|
|
pShader->m_OrgFuncCodeSize, dwHandle,
|
|
pShader->m_Declaration.m_bLegacyFVF);
|
|
}
|
|
else
|
|
{
|
|
// pass stripped version
|
|
m_pDDI->CreateVertexShader(
|
|
pdwDeclaration, dwDeclSize,
|
|
pShader->m_pStrippedFuncCode,
|
|
pShader->m_StrippedFuncCodeSize, dwHandle,
|
|
pShader->m_Declaration.m_bLegacyFVF);
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::SetVertexShaderI"
|
|
|
|
void CD3DHal::SetVertexShaderI(DWORD dwHandle)
|
|
{
|
|
#if DBG
|
|
// We need to validate shader handle here, because the shader could be
|
|
// deleted by user after creating a state block with the shader handle.
|
|
CheckVertexShaderHandle(dwHandle);
|
|
#endif
|
|
|
|
CVConstantData* pConst = NULL;
|
|
if (!D3DVSD_ISLEGACY(dwHandle))
|
|
{
|
|
CVShader* pShader = (CVShader*)m_pVShaderArray->GetObject(dwHandle);
|
|
pConst = pShader->m_Declaration.m_pConstants;
|
|
}
|
|
// Ignore redundant handle when we do not need to update constantes
|
|
if(pConst == NULL)
|
|
{
|
|
if(dwHandle == m_dwCurrentShaderHandle)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Load constants
|
|
while (pConst)
|
|
{
|
|
HRESULT hr;
|
|
hr = m_pv->pGeometryFuncs->LoadShaderConstants(pConst->m_dwAddress,
|
|
pConst->m_dwCount,
|
|
pConst->m_pData);
|
|
if (FAILED(hr))
|
|
{
|
|
D3D_THROW_FAIL("Failed to load vertex shader constants");
|
|
}
|
|
pConst = (CVConstantData*)pConst->m_pNext;
|
|
m_dwRuntimeFlags |= D3DRT_NEED_VSCONST_UPDATE;
|
|
}
|
|
}
|
|
|
|
ForceFVFRecompute();
|
|
// When we switch from FVF shaders to programmable we need to re-compute
|
|
// clipping planes, because they are transformed by different matrix
|
|
if (this->rstates[D3DRENDERSTATE_CLIPPLANEENABLE])
|
|
{
|
|
this->dwFEFlags |= D3DFE_CLIPPLANES_DIRTY;
|
|
}
|
|
|
|
m_dwCurrentShaderHandle = dwHandle;
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
|
|
{
|
|
m_dwRuntimeFlags &= ~D3DRT_POINTSIZEINVERTEX;
|
|
m_dwRuntimeFlags |= D3DRT_SHADERDIRTY;
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_TRANSFORMEDFVF;
|
|
|
|
if (D3DVSD_ISLEGACY(dwHandle))
|
|
{
|
|
if (dwHandle & D3DFVF_PSIZE)
|
|
m_dwRuntimeFlags |= D3DRT_POINTSIZEINVERTEX;
|
|
|
|
m_pCurrentShader = NULL;
|
|
m_pv->dwDeviceFlags &= ~(D3DDEV_STRIDE | D3DDEV_VERTEXSHADERS);
|
|
|
|
if (FVF_TRANSFORMED(dwHandle))
|
|
{
|
|
if (!(m_dwRuntimeFlags & D3DRT_EXECUTESTATEMODE))
|
|
{
|
|
m_pDDI->SetVertexShader(dwHandle);
|
|
}
|
|
m_pv->dwDeviceFlags |= D3DDEV_TRANSFORMEDFVF;
|
|
}
|
|
|
|
m_pfnPrepareToDraw = PrepareToDrawLegacy;
|
|
m_pv->dwVIDIn = dwHandle;
|
|
SetupStrides(m_pv, m_pStream[0].m_dwStride);
|
|
}
|
|
else
|
|
{
|
|
CVShader* pShader = (CVShader*)m_pVShaderArray->GetObject(dwHandle);
|
|
m_pCurrentShader = pShader;
|
|
if(!(pShader->m_dwFlags & CVShader::FIXEDFUNCTION))
|
|
{
|
|
// Programmable vertex shaders are used
|
|
m_pv->dwDeviceFlags |= D3DDEV_VERTEXSHADERS;
|
|
m_pfnPrepareToDraw = PrepareToDrawVVM;
|
|
if (m_pCurrentShader->m_pCode->m_dwOutFVF & D3DFVF_PSIZE)
|
|
m_dwRuntimeFlags |= D3DRT_POINTSIZEINVERTEX;
|
|
|
|
// Pre-compute as much info as possible and keep it
|
|
// in the vertex descriptors. This information is constant
|
|
// unless shader is changed
|
|
CVDeclaration* pDecl = &m_pCurrentShader->m_Declaration;
|
|
CVertexDesc* pVD = m_pv->VertexDesc;
|
|
CVElement *pElem = pDecl->m_VertexElements;
|
|
m_pv->dwNumUsedVertexDescs = pDecl->m_dwNumElements;
|
|
for (DWORD i = pDecl->m_dwNumElements; i; i--)
|
|
{
|
|
pVD->pfnCopy = pElem->m_pfnCopy;
|
|
pVD->dwRegister = pElem->m_dwRegister;
|
|
pVD->dwVertexOffset = pElem->m_dwOffset;
|
|
pVD->pStream = &m_pStream[pElem->m_dwStreamIndex];
|
|
pVD++;
|
|
pElem++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fixed-function pipeline is used with declarations
|
|
// We draw primitives using strided code path
|
|
m_pv->dwDeviceFlags |= D3DDEV_STRIDE;
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_VERTEXSHADERS;
|
|
|
|
m_pfnPrepareToDraw = PrepareToDraw;
|
|
|
|
if (pShader->m_dwInputFVF & D3DFVF_PSIZE)
|
|
m_dwRuntimeFlags |= D3DRT_POINTSIZEINVERTEX;
|
|
|
|
// Go through the elements in the current declaration and
|
|
// initialize vertex descriptors. They are used to quickly
|
|
// initialize strided data pointers.
|
|
CVDeclaration* pDecl = &m_pCurrentShader->m_Declaration;
|
|
CVertexDesc* pVD = m_pv->VertexDesc;
|
|
CVElement *pElem = pDecl->m_VertexElements;
|
|
m_pv->dwNumUsedVertexDescs = pDecl->m_dwNumElements;
|
|
for (DWORD i = pDecl->m_dwNumElements; i; i--)
|
|
{
|
|
pVD->pElement = &m_pv->elements[pElem->m_dwRegister];
|
|
pVD->pStream = &m_pStream[pElem->m_dwStreamIndex];
|
|
pVD->dwVertexOffset = pElem->m_dwOffset;
|
|
pVD++;
|
|
pElem++;
|
|
}
|
|
m_pv->dwVIDIn = pDecl->m_dwInputFVF;
|
|
if (pDecl->m_dwInputFVF & D3DFVF_PSIZE)
|
|
m_dwRuntimeFlags |= D3DRT_POINTSIZEINVERTEX;
|
|
}
|
|
HRESULT hr = m_pv->pGeometryFuncs->SetActiveShader(pShader->m_pCode);
|
|
if (FAILED(hr))
|
|
{
|
|
D3D_THROW_FAIL("Failed to set active vertex shader");
|
|
}
|
|
}
|
|
m_pDDI->PickProcessPrimitive();
|
|
}
|
|
else
|
|
{
|
|
#if DBG
|
|
// For the validation we need to set the m_pCurrentShader even for
|
|
// hardware mode
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_VERTEXSHADERS;
|
|
if (D3DVSD_ISLEGACY(dwHandle))
|
|
{
|
|
m_pCurrentShader = NULL;
|
|
}
|
|
else
|
|
{
|
|
m_pCurrentShader = (CVShader*)m_pVShaderArray->GetObject(dwHandle);
|
|
if(!(m_pCurrentShader->m_dwFlags & CVShader::FIXEDFUNCTION))
|
|
{
|
|
// Programmable pipeline is used
|
|
m_pv->dwDeviceFlags |= D3DDEV_VERTEXSHADERS;
|
|
}
|
|
}
|
|
#endif
|
|
if (!(m_dwRuntimeFlags & D3DRT_EXECUTESTATEMODE))
|
|
{
|
|
m_pDDI->SetVertexShaderHW(dwHandle);
|
|
}
|
|
}
|
|
PickDrawPrimFn();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::DeleteVertexShaderI"
|
|
|
|
void CD3DHal::DeleteVertexShaderI(DWORD dwHandle)
|
|
{
|
|
#if DBG
|
|
for(unsigned Handle = 0; Handle < m_pRTPatchValidationInfo->GetSize(); ++Handle)
|
|
{
|
|
if ((*m_pRTPatchValidationInfo)[Handle].m_pObj != 0)
|
|
{
|
|
if (static_cast<CRTPatchValidationInfo*>((*m_pRTPatchValidationInfo)[Handle].m_pObj)->m_ShaderHandle == dwHandle)
|
|
{
|
|
static_cast<CRTPatchValidationInfo*>((*m_pRTPatchValidationInfo)[Handle].m_pObj)->m_ShaderHandle = 0;
|
|
D3D_INFO(0, "Found this vertex shader in a cached patch. Will invalidate the cached patch.");
|
|
}
|
|
}
|
|
}
|
|
#endif // DBG
|
|
if (dwHandle == m_dwCurrentShaderHandle)
|
|
{
|
|
m_pCurrentShader = NULL;
|
|
m_dwCurrentShaderHandle = 0;
|
|
}
|
|
if (!D3DVSD_ISLEGACY(dwHandle))
|
|
{
|
|
CVShader* pShader = (CVShader*)m_pVShaderArray->GetObject(dwHandle);
|
|
#if DBG
|
|
if (pShader == NULL)
|
|
{
|
|
D3D_THROW(D3DERR_INVALIDCALL, "Invalid vertex shader handle");
|
|
}
|
|
#endif
|
|
if (!(pShader->m_dwFlags & CVShader::SOFTWARE))
|
|
{
|
|
m_pDDI->DeleteVertexShader(dwHandle);
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::SetVertexShaderConstantI"
|
|
|
|
void
|
|
CD3DHal::SetVertexShaderConstantI(DWORD Register, CONST VOID* pData, DWORD count)
|
|
{
|
|
HRESULT hr;
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING ||
|
|
((count + Register) <= D3DVS_CONSTREG_MAX_V1_1))
|
|
{
|
|
// For software vertex processing we store constant registers in PSGP if
|
|
// possible
|
|
hr = m_pv->pGeometryFuncs->LoadShaderConstants(Register, count,
|
|
const_cast<VOID*>(pData));
|
|
}
|
|
else
|
|
{
|
|
if (Register >= D3DVS_CONSTREG_MAX_V1_1)
|
|
{
|
|
// When all modified registers are above software limit, we use Microsoft
|
|
// internal array
|
|
hr = GeometryFuncsGuaranteed->LoadShaderConstants(Register, count,
|
|
const_cast<VOID*>(pData));
|
|
}
|
|
else
|
|
{
|
|
// Part of constant data is stores in the PSGP array and part in the
|
|
// Microsoft's array
|
|
UINT FirstCount = D3DVS_CONSTREG_MAX_V1_1 - Register;
|
|
hr = m_pv->pGeometryFuncs->LoadShaderConstants(Register, FirstCount,
|
|
const_cast<VOID*>(pData));
|
|
if (FAILED(hr))
|
|
{
|
|
D3D_THROW(hr, "Failed to set vertex shader constants");
|
|
}
|
|
hr = GeometryFuncsGuaranteed->LoadShaderConstants(D3DVS_CONSTREG_MAX_V1_1,
|
|
Register + count - D3DVS_CONSTREG_MAX_V1_1,
|
|
&((DWORD*)pData)[FirstCount*4]);
|
|
}
|
|
}
|
|
if (FAILED(hr))
|
|
{
|
|
D3D_THROW(hr, "Failed to set vertex shader constants");
|
|
}
|
|
|
|
if (!(m_dwRuntimeFlags & D3DRT_EXECUTESTATEMODE))
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
|
|
m_dwRuntimeFlags |= D3DRT_NEED_VSCONST_UPDATE;
|
|
else
|
|
m_pDDI->SetVertexShaderConstant(Register,
|
|
pData,
|
|
count);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::ValidateDraw2"
|
|
|
|
void CD3DHal::ValidateDraw2(D3DPRIMITIVETYPE primType,
|
|
UINT StartVertex,
|
|
UINT PrimitiveCount,
|
|
UINT NumVertices,
|
|
BOOL bIndexPrimitive,
|
|
UINT StartIndex)
|
|
{
|
|
#if DBG
|
|
if (this->rstates[D3DRS_FILLMODE] == D3DFILL_POINT &&
|
|
m_dwRuntimeFlags & D3DRT_POINTSIZEPRESENT &&
|
|
primType != D3DPT_POINTLIST)
|
|
{
|
|
D3D_INFO(0, "Result of drawing primitives with D3DFILL_POINT fill mode "
|
|
"and point size not equal 1.0f could be different on "
|
|
"different devices");
|
|
}
|
|
if ((m_dwHintFlags & D3DDEVBOOL_HINTFLAGS_INSCENE) == 0 &&
|
|
!(m_pv->dwFlags & D3DPV_VBCALL))
|
|
{
|
|
D3D_THROW_FAIL("Need to call BeginScene before rendering.");
|
|
}
|
|
if (m_dwCurrentShaderHandle == 0)
|
|
{
|
|
D3D_THROW_FAIL("Invalid vertex shader handle (0x0)");
|
|
}
|
|
if (bIndexPrimitive && primType == D3DPT_POINTLIST)
|
|
{
|
|
D3D_THROW_FAIL("Indexed point lists are not supported");
|
|
}
|
|
if (*(FLOAT*)&rstates[D3DRS_PATCHSEGMENTS] > 1.f)
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
|
|
{
|
|
D3D_THROW_FAIL("N-Patches are not supported with software vertex processing");
|
|
}
|
|
else
|
|
if ((GetD3DCaps()->DevCaps & (D3DDEVCAPS_NPATCHES | D3DDEVCAPS_RTPATCHES)) == 0)
|
|
{
|
|
D3D_THROW_FAIL("N-Patches are not supported");
|
|
}
|
|
}
|
|
BOOL bUserMemPrimitive = this->m_dwRuntimeFlags & D3DRT_USERMEMPRIMITIVE;
|
|
if (D3DVSD_ISLEGACY(m_dwCurrentShaderHandle))
|
|
{
|
|
// DX7 FVF handles can work only from stream zero
|
|
if (!bUserMemPrimitive)
|
|
{
|
|
if (m_pStream[0].m_pVB == NULL)
|
|
{
|
|
D3D_THROW_FAIL("Stream 0 should be initialized for FVF shaders");
|
|
}
|
|
DWORD dwFVF = m_pStream[0].m_pVB->GetFVF();
|
|
if (dwFVF != 0 && dwFVF != m_dwCurrentShaderHandle)
|
|
{
|
|
D3D_THROW_FAIL("Current vertex shader doesn't match VB's FVF");
|
|
}
|
|
if (FVF_TRANSFORMED(m_dwCurrentShaderHandle))
|
|
{
|
|
if (!(m_pv->dwDeviceFlags & D3DDEV_DONOTCLIP) &&
|
|
m_pStream[0].m_pVB->GetBufferDesc()->Usage & D3DUSAGE_DONOTCLIP)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffer with D3DUSAGE_DONOTCLIP is used with clipping");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3DVERTEXBUFFER_DESC Desc;
|
|
static_cast<IDirect3DVertexBuffer8*>(m_pStream[0].m_pVB)->GetDesc(&Desc);
|
|
if ((BehaviorFlags() & D3DCREATE_MIXED_VERTEXPROCESSING) != 0 &&
|
|
(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING) != 0 &&
|
|
(Desc.Usage & D3DUSAGE_SOFTWAREPROCESSING) == 0 &&
|
|
Desc.Pool != D3DPOOL_SYSTEMMEM)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffer should have software usage or should be managed or should be in system memory");
|
|
}
|
|
}
|
|
if (m_pStream[0].m_pVB->IsLocked())
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffer must be unlocked during DrawPrimitive call");
|
|
}
|
|
if (*((FLOAT*)&rstates[D3DRS_PATCHSEGMENTS]) > 1.f && (m_pStream[0].m_pVB->GetBufferDesc()->Usage & D3DUSAGE_NPATCHES) == 0)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffers used for rendering N-Patches should have D3DUSAGE_NPATCHES set");
|
|
}
|
|
}
|
|
// DX7 drivers cannot handle case when vertex size, computed from FVF,
|
|
// is different from the stream stride
|
|
if (m_pStream[0].m_dwStride != ComputeVertexSizeFVF(m_dwCurrentShaderHandle))
|
|
{
|
|
D3D_THROW_FAIL("Stream 0 stride should match the stride, implied by the current vertex shader");
|
|
}
|
|
if (m_pStream[0].m_dwNumVertices < (StartVertex + NumVertices))
|
|
{
|
|
D3D_THROW_FAIL("Streams do not have required number of vertices");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_pv->dwDeviceFlags & D3DDEV_VERTEXSHADERS)
|
|
{
|
|
CVShaderCode * pCode = m_pCurrentShader->m_pCode;
|
|
for (DWORD i=0; i < D3DHAL_TSS_MAXSTAGES; i++)
|
|
{
|
|
if (this->tsstates[i][D3DTSS_TEXCOORDINDEX] != i)
|
|
{
|
|
D3D_ERR("Stage %d - Texture coordinate index in the stage "
|
|
"must be equal to the stage index when programmable"
|
|
" vertex pipeline is used", i);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
DWORD TexTransformFlags = tsstates[i][D3DTSS_TEXTURETRANSFORMFLAGS];
|
|
if (pCode)
|
|
{
|
|
if (TexTransformFlags & D3DTTFF_PROJECTED &&
|
|
!(m_dwRuntimeFlags & D3DRT_ONLY2FLOATSPERTEXTURE) &&
|
|
pCode->m_dwOutTexCoordSize[i] != 16)
|
|
{
|
|
D3D_ERR("Stage %d - Vertex shader must write XYZW to the "
|
|
"output texture register when texture projection is enabled", i);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
}
|
|
if ((TexTransformFlags & ~D3DTTFF_PROJECTED) != D3DTTFF_DISABLE)
|
|
{
|
|
D3D_ERR("Stage %d - Count in D3DTSS_TEXTURETRANSFORMFLAGS "
|
|
"must be 0 when programmable pipeline is used", i);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_pCurrentShader->m_Declaration.m_bStreamTessPresent)
|
|
{
|
|
D3D_THROW_FAIL("Declaration with tesselator stream cannot be used with DrawPrimitive API");
|
|
}
|
|
if (((GetDDIType() < D3DDDITYPE_DX8)&&
|
|
(m_pCurrentShader->m_Declaration.m_bLegacyFVF == FALSE))
|
|
&&
|
|
!(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
|
|
)
|
|
{
|
|
D3D_THROW_FAIL("Device does not support declarations");
|
|
}
|
|
// Check if
|
|
// 1. streams, referenced by the current shader, are valid
|
|
// 2. stride in the current shader and in the stream matches
|
|
// 3. Compute max number of vertices the streams can contain
|
|
CVStreamDecl* pStream;
|
|
pStream = m_pCurrentShader->m_Declaration.m_pActiveStreams;
|
|
while(pStream)
|
|
{
|
|
UINT index = pStream->m_dwStreamIndex;
|
|
CVStream* pDeviceStream = &m_pStream[index];
|
|
if (bUserMemPrimitive)
|
|
{
|
|
DXGASSERT(pDeviceStream->m_pData != NULL);
|
|
if (index != 0)
|
|
{
|
|
D3D_THROW_FAIL("DrawPrimitiveUP can use declaration only with stream 0");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pDeviceStream->m_pVB == NULL)
|
|
{
|
|
D3D_ERR("Stream %d is not set, but used by current declaration", index);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
if (pDeviceStream->m_pVB->IsLocked())
|
|
{
|
|
D3D_ERR("Vertex buffer in stream %d must be unlocked during drawing", index);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
D3DVERTEXBUFFER_DESC Desc;
|
|
static_cast<IDirect3DVertexBuffer8*>(pDeviceStream->m_pVB)->GetDesc(&Desc);
|
|
if ((BehaviorFlags() & D3DCREATE_MIXED_VERTEXPROCESSING) != 0 &&
|
|
(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING) != 0 &&
|
|
(Desc.Usage & D3DUSAGE_SOFTWAREPROCESSING) == 0 &&
|
|
Desc.Pool != D3DPOOL_SYSTEMMEM)
|
|
{
|
|
D3D_INFO(0, "In stream %d vertex buffer should have software usage or should be managed or should be in system memory", pStream->m_dwStreamIndex);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
if (*((FLOAT*)&rstates[D3DRS_PATCHSEGMENTS]) > 1.f && (pDeviceStream->m_pVB->GetBufferDesc()->Usage & D3DUSAGE_NPATCHES) == 0)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffers used for rendering N-Patches should have D3DUSAGE_NPATCHES set");
|
|
}
|
|
// Validate matching of FVF in the vertex buffer and stream
|
|
// declaration
|
|
if (m_pv->dwDeviceFlags & D3DDEV_VERTEXSHADERS)
|
|
{
|
|
if (pDeviceStream->m_pVB->GetFVF() != 0)
|
|
{
|
|
D3D_INFO(1, "In stream %d vertex buffer with FVF is "
|
|
"used with programmable vertex shader",
|
|
pStream->m_dwStreamIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fixed function pipeline case
|
|
DWORD vbFVF = pDeviceStream->m_pVB->GetFVF();
|
|
DWORD streamFVF = pStream->m_dwFVF;
|
|
// VB FVF should be a superset of the stream FVF
|
|
if (vbFVF && ((vbFVF & streamFVF) != streamFVF))
|
|
{
|
|
D3D_INFO(0, "In stream %d vertex buffer FVF and declaration FVF do not match",
|
|
pStream->m_dwStreamIndex);
|
|
}
|
|
}
|
|
}
|
|
// Stride 0 is allowed
|
|
if (pDeviceStream->m_dwStride)
|
|
{
|
|
if (pDeviceStream->m_dwStride < pStream->m_dwStride)
|
|
{
|
|
D3D_ERR("Vertex strides in stream %d is less than in the declaration", index);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
if (pDeviceStream->m_dwNumVertices < (StartVertex + NumVertices))
|
|
{
|
|
D3D_ERR("Stream %d does not have required number of vertices",
|
|
pStream->m_dwStreamIndex);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
}
|
|
pStream = (CVStreamDecl*)pStream->m_pNext;
|
|
}
|
|
}
|
|
if (bIndexPrimitive)
|
|
{
|
|
if (!bUserMemPrimitive)
|
|
{
|
|
if (m_pIndexStream->m_pVBI == NULL)
|
|
{
|
|
D3D_THROW_FAIL("Index stream is not set");
|
|
}
|
|
if (m_pIndexStream->m_pVBI->IsLocked())
|
|
{
|
|
D3D_THROW_FAIL("Index buffer must be unlocked during drawing");
|
|
}
|
|
UINT NumIndices = GETVERTEXCOUNT(primType, PrimitiveCount);
|
|
if (m_pIndexStream->m_dwNumVertices < (StartIndex + NumIndices))
|
|
{
|
|
D3D_THROW_FAIL("Index stream does not have required number of indices");
|
|
}
|
|
if (FVF_TRANSFORMED(m_dwCurrentShaderHandle) &&
|
|
D3DVSD_ISLEGACY(m_dwCurrentShaderHandle))
|
|
{
|
|
if (!(m_pv->dwDeviceFlags & D3DDEV_DONOTCLIP) &&
|
|
(m_pIndexStream->m_pVBI->GetBufferDesc()->Usage & D3DUSAGE_DONOTCLIP))
|
|
{
|
|
D3D_THROW_FAIL("Index buffer with D3DUSAGE_DONOTCLIP is used with clipping");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3DINDEXBUFFER_DESC Desc;
|
|
static_cast<IDirect3DIndexBuffer8*>(m_pIndexStream->m_pVBI)->GetDesc(&Desc);
|
|
if ((BehaviorFlags() & D3DCREATE_MIXED_VERTEXPROCESSING) != 0 &&
|
|
(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING) != 0 &&
|
|
(Desc.Usage & D3DUSAGE_SOFTWAREPROCESSING) == 0 &&
|
|
Desc.Pool != D3DPOOL_SYSTEMMEM)
|
|
{
|
|
D3D_THROW_FAIL("Index buffer should have software usage or should be managed or should be in system memory");
|
|
}
|
|
}
|
|
if (*((FLOAT*)&rstates[D3DRS_PATCHSEGMENTS]) > 1.f && (m_pIndexStream->m_pVBI->GetBufferDesc()->Usage & D3DUSAGE_NPATCHES) == 0)
|
|
{
|
|
D3D_THROW_FAIL("Index buffers used for rendering N-Patches should have D3DUSAGE_NPATCHES set");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DXGASSERT(m_pIndexStream->m_pData != NULL);
|
|
}
|
|
}
|
|
#endif //DBG
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::DrawPoints"
|
|
|
|
void CD3DHal::DrawPoints(UINT StartVertex)
|
|
{
|
|
BOOL bRecomputeOutputFVF = FALSE;
|
|
// If point scale is enabled and device supports point sprites
|
|
// we may need to add the point size to the output FVF
|
|
if (rstates[D3DRS_POINTSCALEENABLE] &&
|
|
!(m_dwRuntimeFlags & D3DRT_POINTSIZEINVERTEX) &&
|
|
!(m_pv->dwDeviceFlags & D3DDEV_TRANSFORMEDFVF))
|
|
{
|
|
ForceFVFRecompute();
|
|
bRecomputeOutputFVF = TRUE;
|
|
}
|
|
if (m_dwRuntimeFlags & D3DRT_DOPOINTSPRITEEMULATION)
|
|
{
|
|
// We do point sprite expansion when point size is not 1.0 in the
|
|
// render state or it is present in vertices or we need to do point
|
|
// scaling for untransformed vertices
|
|
if ((m_dwRuntimeFlags & D3DRT_POINTSIZEPRESENT ||
|
|
(rstates[D3DRS_POINTSCALEENABLE] &&
|
|
!(m_pv->dwDeviceFlags & D3DDEV_TRANSFORMEDFVF))) &&
|
|
// We do not do emulation for devices which supports point sprites,
|
|
// but only when there is no point size in the FVF
|
|
!(bRecomputeOutputFVF == FALSE &&
|
|
(m_dwRuntimeFlags & D3DRT_POINTSIZEINVERTEX) == 0 &&
|
|
m_dwRuntimeFlags & D3DRT_SUPPORTSPOINTSPRITES))
|
|
{
|
|
m_pv->dwDeviceFlags |= D3DDEV_DOPOINTSPRITEEMULATION;
|
|
m_pDDI->PickProcessPrimitive();
|
|
}
|
|
else
|
|
{
|
|
if (m_pv->dwDeviceFlags & D3DDEV_TRANSFORMEDFVF &&
|
|
(m_pv->dwDeviceFlags & D3DDEV_DONOTCLIP ||
|
|
!(m_pv->dwDeviceFlags & D3DDEV_VBPROCVER)))
|
|
{
|
|
// Now we can call DDI directly, because no emulation is
|
|
// necessary
|
|
if (m_pStream[0].m_pVB)
|
|
{
|
|
(*m_pDDI->GetDrawPrimFunction())(this, m_pv->primType,
|
|
StartVertex,
|
|
m_pv->dwNumPrimitives);
|
|
}
|
|
else
|
|
{
|
|
m_pDDI->SetVertexShader(m_dwCurrentShaderHandle);
|
|
m_pDDI->SetStreamSource(0, &m_pStream[0]);
|
|
m_pDDI->DrawPrimitiveUP(m_pv->primType, m_pv->dwNumPrimitives);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
(this->*m_pfnPrepareToDraw)(StartVertex);
|
|
(m_pDDI->*m_pDDI->m_pfnProcessPrimitive)(m_pv, StartVertex);
|
|
|
|
if (bRecomputeOutputFVF)
|
|
{
|
|
ForceFVFRecompute();
|
|
}
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_DOPOINTSPRITEEMULATION;
|
|
m_pDDI->PickProcessPrimitive();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Draw all primitive types except points
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "DrawPrimitiveHal"
|
|
|
|
void CD3DHal_DrawPrimitive(CD3DBase* pBaseDevice, D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT StartVertex, UINT PrimitiveCount)
|
|
{
|
|
CD3DHal* pDevice = static_cast<CD3DHal*>(pBaseDevice);
|
|
CD3DDDIDX6* pDDI = pBaseDevice->m_pDDI;
|
|
|
|
#if DBG
|
|
UINT nVer = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
|
|
pDevice->ValidateDraw2(PrimitiveType, StartVertex, PrimitiveCount, nVer,
|
|
FALSE);
|
|
#endif
|
|
D3DFE_PROCESSVERTICES* pv = pDevice->m_pv;
|
|
pv->primType = PrimitiveType;
|
|
pv->dwNumPrimitives = PrimitiveCount;
|
|
pv->dwNumVertices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
|
|
pv->dwFlags &= D3DPV_PERSIST;
|
|
(pDevice->*pDevice->m_pfnPrepareToDraw)(StartVertex);
|
|
(pDDI->*pDDI->m_pfnProcessPrimitive)(pv, StartVertex);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Draw only points
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::DrawPointsI"
|
|
|
|
void CD3DHal::DrawPointsI(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex,
|
|
UINT PrimitiveCount)
|
|
{
|
|
#if DBG
|
|
UINT nVer = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
|
|
ValidateDraw2(PrimitiveType, StartVertex, PrimitiveCount, nVer, FALSE);
|
|
#endif
|
|
if (!(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING) ||
|
|
CanCallDriver(this, PrimitiveType))
|
|
{
|
|
(*m_pfnDrawPrim)(this, PrimitiveType, StartVertex, PrimitiveCount);
|
|
}
|
|
else
|
|
{
|
|
m_pv->primType = PrimitiveType;
|
|
m_pv->dwNumPrimitives = PrimitiveCount;
|
|
m_pv->dwNumVertices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
|
|
m_pv->dwFlags &= D3DPV_PERSIST;
|
|
DrawPoints(StartVertex);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal_DrawIndexedPrimitive"
|
|
|
|
void CD3DHal_DrawIndexedPrimitive(CD3DBase* pBaseDevice,
|
|
D3DPRIMITIVETYPE PrimitiveType,
|
|
UINT BaseIndex,
|
|
UINT MinIndex, UINT NumVertices,
|
|
UINT StartIndex,
|
|
UINT PrimitiveCount)
|
|
{
|
|
CD3DHal* pDevice = static_cast<CD3DHal*>(pBaseDevice);
|
|
CVIndexStream* pIndexStream = pBaseDevice->m_pIndexStream;
|
|
CD3DDDIDX6* pDDI = pBaseDevice->m_pDDI;
|
|
|
|
#if DBG
|
|
pDevice->ValidateDraw2(PrimitiveType, MinIndex + pIndexStream->m_dwBaseIndex,
|
|
PrimitiveCount, NumVertices, TRUE, StartIndex);
|
|
#endif
|
|
D3DFE_PROCESSVERTICES* pv = pDevice->m_pv;
|
|
pIndexStream->m_pData = NULL;
|
|
pv->primType = PrimitiveType;
|
|
pv->dwNumPrimitives = PrimitiveCount;
|
|
pv->dwFlags &= D3DPV_PERSIST;
|
|
|
|
pv->dwNumVertices = NumVertices;
|
|
pv->dwNumIndices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
|
|
pv->dwIndexSize = pIndexStream->m_dwStride;
|
|
UINT StartVertex = MinIndex + pIndexStream->m_dwBaseIndex;
|
|
pDDI->SetIndexedPrimParams(StartIndex, MinIndex, NumVertices,
|
|
pIndexStream->m_dwBaseIndex);
|
|
(pDevice->*pDevice->m_pfnPrepareToDraw)(StartVertex);
|
|
(pDDI->*pDDI->m_pfnProcessIndexedPrimitive)(pv, StartVertex);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::DrawPrimitiveUPI"
|
|
|
|
void CD3DHal::DrawPrimitiveUPI(D3DPRIMITIVETYPE PrimType, UINT PrimCount)
|
|
|
|
{
|
|
#if DBG
|
|
UINT nVer = GETVERTEXCOUNT(PrimType, PrimCount);
|
|
ValidateDraw2(PrimType, 0, PrimCount, nVer, FALSE);
|
|
#endif
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_VBPROCVER;
|
|
if (!(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING))
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_DONPATCHCONVERSION &&
|
|
PrimType >= D3DPT_TRIANGLELIST)
|
|
{
|
|
CD3DHal_DrawNPatch(this, PrimType, 0, PrimCount);
|
|
}
|
|
else
|
|
{
|
|
m_pDDI->DrawPrimitiveUP(PrimType, PrimCount);
|
|
}
|
|
}
|
|
else
|
|
if (CanCallDriver(this, PrimType))
|
|
{
|
|
m_pDDI->SetVertexShader(m_dwCurrentShaderHandle);
|
|
m_pDDI->SetStreamSource(0, &m_pStream[0]);
|
|
m_pDDI->DrawPrimitiveUP(PrimType, PrimCount);
|
|
}
|
|
else
|
|
{
|
|
SetupStrides(m_pv, m_pStream[0].m_dwStride);
|
|
m_pv->primType = PrimType;
|
|
m_pv->dwNumPrimitives = PrimCount;
|
|
m_pv->dwNumVertices = GETVERTEXCOUNT(PrimType, PrimCount);
|
|
m_pv->dwFlags &= D3DPV_PERSIST;
|
|
if (PrimType != D3DPT_POINTLIST)
|
|
{
|
|
(this->*m_pfnPrepareToDraw)(0);
|
|
(m_pDDI->*m_pDDI->m_pfnProcessPrimitive)(m_pv, 0);
|
|
}
|
|
else
|
|
DrawPoints(0);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::DrawIndexedPrimitiveUPI"
|
|
|
|
void
|
|
CD3DHal::DrawIndexedPrimitiveUPI(D3DPRIMITIVETYPE PrimType,
|
|
UINT MinVertexIndex,
|
|
UINT NumVertices,
|
|
UINT PrimCount)
|
|
{
|
|
#if DBG
|
|
ValidateDraw2(PrimType, 0, PrimCount, NumVertices, TRUE);
|
|
#endif
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_VBPROCVER;
|
|
if (!(m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING))
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_DONPATCHCONVERSION &&
|
|
PrimType >= D3DPT_TRIANGLELIST)
|
|
{
|
|
CD3DHal_DrawIndexedNPatch(this, PrimType, 0, MinVertexIndex,
|
|
NumVertices, 0, PrimCount);
|
|
}
|
|
else
|
|
{
|
|
m_pDDI->DrawIndexedPrimitiveUP(PrimType, MinVertexIndex, NumVertices,
|
|
PrimCount);
|
|
}
|
|
}
|
|
else
|
|
if (CanCallDriver(this, PrimType))
|
|
{
|
|
m_pDDI->SetVertexShader(m_dwCurrentShaderHandle);
|
|
m_pDDI->SetStreamSource(0, &m_pStream[0]);
|
|
m_pDDI->SetIndices(m_pIndexStream);
|
|
m_pDDI->DrawIndexedPrimitiveUP(PrimType, MinVertexIndex, NumVertices,
|
|
PrimCount);
|
|
}
|
|
else
|
|
{
|
|
SetupStrides(m_pv, m_pStream[0].m_dwStride);
|
|
m_pv->primType = PrimType;
|
|
m_pv->dwNumPrimitives = PrimCount;
|
|
m_pv->dwFlags &= D3DPV_PERSIST;
|
|
|
|
m_pv->dwNumVertices = NumVertices;
|
|
m_pv->dwNumIndices = GETVERTEXCOUNT(PrimType, PrimCount);
|
|
m_pv->lpwIndices = (WORD*)m_pIndexStream->m_pData;
|
|
m_pv->dwIndexSize = m_pIndexStream->m_dwStride;
|
|
m_pDDI->SetIndexedPrimParams(0, MinVertexIndex,
|
|
MinVertexIndex + NumVertices, 0);
|
|
(this->*m_pfnPrepareToDraw)(MinVertexIndex);
|
|
(m_pDDI->*m_pDDI->m_pfnProcessIndexedPrimitive)(m_pv, MinVertexIndex);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "SetupFVFDataVVM"
|
|
|
|
void SetupFVFDataVVM(CD3DHal* pDev)
|
|
{
|
|
D3DFE_PROCESSVERTICES* pv = pDev->m_pv;
|
|
// We have to restore texture stage indices if previous primitive
|
|
// re-mapped them
|
|
if (pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
RestoreTextureStages(pDev);
|
|
}
|
|
|
|
// Input FVF has no meaning for vertex shaders, but it is used for validaion
|
|
pv->dwVIDIn = 0;
|
|
|
|
// Compute output FVF
|
|
|
|
CVShaderCode * pCode = pDev->m_pCurrentShader->m_pCode;
|
|
|
|
pv->dwVIDOut = pCode->m_dwOutFVF;
|
|
pv->dwOutputSize = pCode->m_dwOutVerSize;
|
|
pv->nOutTexCoord = pCode->m_nOutTexCoord;
|
|
// We use offsets, computed by the vertex shader
|
|
pv->pointSizeOffsetOut = pCode->m_dwPointSizeOffset;
|
|
pv->diffuseOffsetOut = pCode->m_dwDiffuseOffset;
|
|
pv->specularOffsetOut = pCode->m_dwSpecularOffset;
|
|
pv->fogOffsetOut = pCode->m_dwFogOffset;
|
|
pv->texOffsetOut = pCode->m_dwTextureOffset;
|
|
pv->dwTextureCoordSizeTotal = 0;
|
|
for (DWORD i=0; i < pv->nOutTexCoord; i++)
|
|
{
|
|
DWORD dwSize = pCode->m_dwOutTexCoordSize[i];
|
|
pv->dwTextureCoordSize[i] = dwSize;
|
|
pv->dwTextureCoordSizeTotal += dwSize;
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------
|
|
void CD3DHal::SetupFVFData()
|
|
{
|
|
CD3DHal::SetupFVFDataCommon();
|
|
if (!(m_pv->dwVIDIn & D3DFVF_NORMAL))
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_NORMALINCAMERASPACE;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
// Computes the following data
|
|
// - dwTextureCoordOffset[] offset of every input texture coordinates
|
|
|
|
static __inline void ComputeInpTexCoordOffsets(DWORD dwNumTexCoord,
|
|
DWORD dwFVF,
|
|
DWORD *pdwTextureCoordOffset)
|
|
{
|
|
// Compute texture coordinate size
|
|
DWORD dwTextureFormats = dwFVF >> 16;
|
|
if (dwTextureFormats == 0)
|
|
{
|
|
for (DWORD i=0; i < dwNumTexCoord; i++)
|
|
{
|
|
pdwTextureCoordOffset[i] = i << 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwOffset = 0;
|
|
for (DWORD i=0; i < dwNumTexCoord; i++)
|
|
{
|
|
pdwTextureCoordOffset[i] = dwOffset;
|
|
dwOffset += g_TextureSize[dwTextureFormats & 3];
|
|
dwTextureFormats >>= 2;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
// Returns 2 bits of FVF texture format for the texture index
|
|
//
|
|
static inline DWORD FVFGetTextureFormat(DWORD dwFVF, DWORD dwTextureIndex)
|
|
{
|
|
return (dwFVF >> (dwTextureIndex*2 + 16)) & 3;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
// Returns texture format bits shifted to the right place
|
|
//
|
|
static inline DWORD FVFMakeTextureFormat(DWORD dwNumberOfCoordinates, DWORD dwTextureIndex)
|
|
{
|
|
return g_dwTextureFormat[dwNumberOfCoordinates] << ((dwTextureIndex << 1) + 16);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
inline DWORD GetOutTexCoordSize(DWORD *pdwStage, DWORD dwInpTexCoordSize)
|
|
{
|
|
// Low byte has texture coordinate count
|
|
const DWORD dwTextureTransformFlags = pdwStage[D3DTSS_TEXTURETRANSFORMFLAGS] & 0xFF;
|
|
if (dwTextureTransformFlags == 0)
|
|
return dwInpTexCoordSize;
|
|
else
|
|
return (dwTextureTransformFlags << 2);
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// pDevI->nOutTexCoord should be initialized to the number of input texture coord sets
|
|
//
|
|
void EvalTextureTransforms(LPD3DHAL pDevI, DWORD dwTexTransform,
|
|
DWORD *pdwOutTextureSize, DWORD *pdwOutTextureFormat)
|
|
{
|
|
D3DFE_PROCESSVERTICES* pv = pDevI->m_pv;
|
|
DWORD dwOutTextureSize = 0; // Used to compute output vertex size
|
|
DWORD dwOutTextureFormat = 0; // Used to compute output texture FVF
|
|
// The bits are used to find out how the texture coordinates are used.
|
|
const DWORD __USED_BY_TRANSFORM = 1;
|
|
const DWORD __USED = 2;
|
|
const DWORD __USED_TEXTURE_PROJECTION = 4;
|
|
// The low 16 bits are for _USED bits. The high 16 bits will hold
|
|
// re-mapped texture index for a stage
|
|
DWORD dwTexCoordUsage[D3DDP_MAXTEXCOORD];
|
|
memset(dwTexCoordUsage, 0, sizeof(dwTexCoordUsage));
|
|
|
|
// Re-mapping buffer will contain only stages that use texture
|
|
// This variable is used to count them
|
|
pDevI->dwNumTextureStagesToRemap = 0;
|
|
DWORD dwNewIndex = 0; // Used to generate output index
|
|
// We need offsets for every input texture coordinate, because
|
|
// we could access them in random order.
|
|
// Offsets are not needed for strided input
|
|
DWORD dwTextureCoordOffset[D3DDP_MAXTEXCOORD];
|
|
if (!(pv->dwDeviceFlags & D3DDEV_STRIDE))
|
|
{
|
|
ComputeInpTexCoordOffsets(pv->nTexCoord, pv->dwVIDIn, dwTextureCoordOffset);
|
|
}
|
|
DWORD dwOutTextureCoordSize[D3DDP_MAXTEXCOORD];
|
|
// TRUE, if we do not do texture projection and transform for a stage,
|
|
// because the stage does not have corresponding texture coordinates in the
|
|
// input
|
|
BOOL bIgnoreTexCoord = FALSE;
|
|
// Go through all texture stages and find those wich use texture coordinates
|
|
for (DWORD i=0; i < D3DDP_MAXTEXCOORD; i++)
|
|
{
|
|
if (pDevI->tsstates[i][D3DTSS_COLOROP] == D3DTOP_DISABLE)
|
|
break;
|
|
|
|
DWORD dwIndex = pDevI->tsstates[i][D3DTSS_TEXCOORDINDEX];
|
|
DWORD dwInpTextureFormat;
|
|
DWORD dwInpTexSize;
|
|
LPD3DFE_TEXTURESTAGE pStage = &pDevI->textureStageToRemap[pDevI->dwNumTextureStagesToRemap];
|
|
DWORD dwTexGenMode = dwIndex & ~0xFFFF;
|
|
pStage->dwInpOffset = 0;
|
|
dwIndex = dwIndex & 0xFFFF; // Remove texture generation mode
|
|
if (dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL ||
|
|
dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION ||
|
|
dwTexGenMode == D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR)
|
|
{
|
|
dwInpTextureFormat = D3DFVF_TEXCOORDSIZE3(dwIndex);
|
|
dwInpTexSize = 3*sizeof(D3DVALUE);
|
|
pv->dwDeviceFlags |= D3DDEV_REMAPTEXTUREINDICES;
|
|
if (dwTexGenMode == D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR)
|
|
pv->dwDeviceFlags |= D3DDEV_NORMALINCAMERASPACE | D3DDEV_POSITIONINCAMERASPACE;
|
|
else
|
|
if (dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL)
|
|
pv->dwDeviceFlags |= D3DDEV_NORMALINCAMERASPACE;
|
|
else
|
|
if (dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION)
|
|
pv->dwDeviceFlags |= D3DDEV_POSITIONINCAMERASPACE;
|
|
}
|
|
else
|
|
{
|
|
if (dwIndex >= pv->nTexCoord)
|
|
{
|
|
// This could happen when input vertex does not have texture
|
|
// coordinates, but it is OK, because texture pointer in the
|
|
// stage could be NULL, or the stage does not use texture, or
|
|
// pixel shader is used.
|
|
// It is too complex and error prone to check all cases when
|
|
// this is an user error, so we just make this case to work.
|
|
dwIndex = 0;
|
|
dwInpTexSize = sizeof(float)*2;
|
|
dwInpTextureFormat = 0;
|
|
// Ignore special texture coordinate processing for this stage
|
|
bIgnoreTexCoord = TRUE;
|
|
// Disable texture transform for the stage
|
|
dwTexTransform &= ~1;
|
|
pStage->dwInpOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
dwInpTexSize = pv->dwTextureCoordSize[dwIndex];
|
|
dwInpTextureFormat = FVFGetTextureFormat(pv->dwVIDIn, dwIndex);
|
|
pStage->dwInpOffset = dwTextureCoordOffset[dwIndex];
|
|
}
|
|
}
|
|
pStage->dwInpCoordIndex = dwIndex;
|
|
pStage->dwTexGenMode = dwTexGenMode;
|
|
pStage->dwOrgStage = i;
|
|
pStage->bDoTextureProjection = FALSE;
|
|
DWORD dwOutTexCoordSize; // Size of the texture coord set in bytes for this stage
|
|
if (dwTexTransform & 1)
|
|
{
|
|
pv->dwDeviceFlags |= D3DDEV_TEXTURETRANSFORM;
|
|
pStage->pmTextureTransform = &pv->mTexture[i];
|
|
dwOutTexCoordSize = GetOutTexCoordSize((DWORD*)&pDevI->tsstates[i], dwInpTexSize);
|
|
// If we have to add or remove some coordinates we go through
|
|
// the re-mapping path
|
|
if (dwOutTexCoordSize != dwInpTexSize)
|
|
pv->dwDeviceFlags |= D3DDEV_REMAPTEXTUREINDICES;
|
|
pStage->dwTexTransformFuncIndex = MakeTexTransformFuncIndex
|
|
(dwInpTexSize >> 2, dwOutTexCoordSize >> 2);
|
|
}
|
|
else
|
|
{
|
|
pStage->pmTextureTransform = NULL;
|
|
dwOutTexCoordSize = dwInpTexSize;
|
|
pStage->dwTexTransformFuncIndex = 0;
|
|
}
|
|
if (NeedTextureProjection(pv, i) && !bIgnoreTexCoord)
|
|
{
|
|
// Remove one float from the output
|
|
dwOutTexCoordSize -= 4;
|
|
// Set re-mapping so we do not complicate simple case
|
|
pv->dwDeviceFlags |= D3DDEV_REMAPTEXTUREINDICES;
|
|
// Texture projection is required for the stage
|
|
pStage->bDoTextureProjection = TRUE;
|
|
}
|
|
if ((dwTexCoordUsage[dwIndex] & 0xFFFF) == 0)
|
|
{
|
|
// Texture coordinate set is used first time
|
|
if (dwTexTransform & 1)
|
|
dwTexCoordUsage[dwIndex] |= __USED_BY_TRANSFORM;
|
|
dwTexCoordUsage[dwIndex] |= __USED;
|
|
if (pStage->bDoTextureProjection)
|
|
dwTexCoordUsage[dwIndex] |= __USED_TEXTURE_PROJECTION;
|
|
}
|
|
else
|
|
{
|
|
// Texture coordinate set is used second or more time
|
|
if (dwTexTransform & 1)
|
|
{
|
|
// This set is used by two texture transforms or a
|
|
// texture transform and without it, so we have to
|
|
// generate an additional output texture coordinate
|
|
dwTexCoordUsage[dwIndex] |= __USED_BY_TRANSFORM;
|
|
pv->dwDeviceFlags |= D3DDEV_REMAPTEXTUREINDICES;
|
|
}
|
|
else
|
|
{
|
|
if (dwTexCoordUsage[dwIndex] & __USED_BY_TRANSFORM)
|
|
{
|
|
// This set is used by two texture transforms or a
|
|
// texture transform and without it, so we have to
|
|
// generate an additional output texture coordinate
|
|
pv->dwDeviceFlags |= D3DDEV_REMAPTEXTUREINDICES;
|
|
}
|
|
else
|
|
// We can re-use the same input texture coordinate if there is no
|
|
// texture generation and texture projection flag is the same for both
|
|
// stages
|
|
if (dwTexGenMode == 0 &&
|
|
(pStage->bDoTextureProjection == ((dwTexCoordUsage[dwIndex] & __USED_TEXTURE_PROJECTION) != 0)))
|
|
{
|
|
DWORD dwOutIndex = dwTexCoordUsage[dwIndex] >> 16;
|
|
pStage->dwOutCoordIndex = dwOutIndex;
|
|
// Mark the stage as not to be used in the vertex processing loop
|
|
pStage->dwInpOffset = 0xFFFFFFFF;
|
|
goto l_NoNewOutTexCoord;
|
|
}
|
|
}
|
|
}
|
|
// If we are here, we have to generate new output texture coordinate set
|
|
pStage->dwOutCoordIndex = dwNewIndex;
|
|
dwTexCoordUsage[dwIndex] |= dwNewIndex << 16;
|
|
dwOutTextureSize += dwOutTexCoordSize;
|
|
dwOutTextureCoordSize[dwNewIndex] = dwOutTexCoordSize;
|
|
dwOutTextureFormat |= FVFMakeTextureFormat(dwOutTexCoordSize >> 2, dwNewIndex);
|
|
dwNewIndex++;
|
|
l_NoNewOutTexCoord:
|
|
pDevI->dwNumTextureStagesToRemap++;
|
|
dwTexTransform >>= 1;
|
|
}
|
|
if (pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
// Now, when we have to do re-mapping, we have to set new output texture
|
|
// coordinate set sizes and we need to remove stages, which do not produce
|
|
// output texture coordinates.
|
|
DWORD dwNumTextureStages = 0;
|
|
for (DWORD i=0; i < pDevI->dwNumTextureStagesToRemap; i++)
|
|
{
|
|
if (pDevI->textureStageToRemap[i].dwInpOffset != 0xFFFFFFFF)
|
|
{
|
|
pv->textureStage[dwNumTextureStages] = pDevI->textureStageToRemap[i];
|
|
pv->dwTextureCoordSize[dwNumTextureStages] = dwOutTextureCoordSize[dwNumTextureStages];
|
|
dwNumTextureStages++;
|
|
}
|
|
pv->dwNumTextureStages = dwNumTextureStages;
|
|
}
|
|
pv->nOutTexCoord = dwNewIndex;
|
|
}
|
|
*pdwOutTextureSize = dwOutTextureSize;
|
|
*pdwOutTextureFormat = dwOutTextureFormat;
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Sets texture transform pointer for every input texture coordinate set
|
|
//
|
|
void SetupTextureTransforms(LPD3DHAL pDevI)
|
|
{
|
|
D3DFE_PROCESSVERTICES* pv = pDevI->m_pv;
|
|
// Set texture transforms to NULL in case when some texture coordinates
|
|
// are not used by texture stages
|
|
memset(pv->pmTexture, 0, sizeof(pv->pmTexture));
|
|
|
|
for (DWORD i=0; i < pDevI->dwNumTextureStagesToRemap; i++)
|
|
{
|
|
LPD3DFE_TEXTURESTAGE pStage = &pDevI->textureStageToRemap[i];
|
|
pv->pmTexture[pStage->dwInpCoordIndex] = pStage->pmTextureTransform;
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Computes the following device data
|
|
// - dwVIDOut, based on input FVF id and device settings
|
|
// - nTexCoord
|
|
// - dwTextureCoordSizeTotal
|
|
// - dwTextureCoordSize[] array, based on the input FVF id
|
|
// - dwOutputSize, based on the output FVF id
|
|
//
|
|
// The function is called from ProcessVertices and DrawPrimitives code paths
|
|
//
|
|
// The following variables should be set in the pDevI:
|
|
// - dwVIDIn
|
|
//
|
|
// Number of texture coordinates is set based on dwVIDIn. ValidateFVF should
|
|
// make sure that it is not greater than supported by the driver
|
|
// Last settings for dwVIDOut and dwVIDIn are saved to speed up processing
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::SetupFVFDataCommon"
|
|
|
|
void CD3DHal::SetupFVFDataCommon()
|
|
{
|
|
HRESULT ret;
|
|
this->dwFEFlags &= ~D3DFE_FVF_DIRTY;
|
|
// We have to restore texture stage indices if previous primitive
|
|
// re-mapped them
|
|
if (m_pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
RestoreTextureStages(this);
|
|
}
|
|
|
|
// Compute number of the input texture coordinates
|
|
m_pv->nTexCoord = FVF_TEXCOORD_NUMBER(m_pv->dwVIDIn);
|
|
|
|
// Compute size of input texture coordinates
|
|
|
|
m_pv->dwTextureCoordSizeTotal = ComputeTextureCoordSize(m_pv->dwVIDIn,
|
|
m_pv->dwInpTextureCoordSize);
|
|
|
|
// This size is the same for input and output FVFs in case when we do not have to
|
|
// expand number of texture coordinates
|
|
for (DWORD i=0; i < m_pv->nTexCoord; i++)
|
|
m_pv->dwTextureCoordSize[i] = m_pv->dwInpTextureCoordSize[i];
|
|
|
|
m_pv->nOutTexCoord = m_pv->nTexCoord;
|
|
|
|
// Setup input vertex offsets
|
|
UpdateGeometryLoopData(m_pv);
|
|
|
|
if (FVF_TRANSFORMED(m_pv->dwVIDIn))
|
|
{
|
|
// Set up vertex pointers
|
|
m_pv->dwVIDOut = m_pv->dwVIDIn;
|
|
ComputeOutputVertexOffsets(m_pv);
|
|
m_pv->dwOutputSize = ComputeVertexSizeFVF(m_pv->dwVIDOut);
|
|
return;
|
|
}
|
|
|
|
// Compute output FVF
|
|
|
|
m_pv->dwVIDOut = D3DFVF_XYZRHW;
|
|
if (m_pv->dwDeviceFlags & D3DDEV_DONOTSTRIPELEMENTS &&
|
|
!(m_pv->dwFlags & D3DPV_VBCALL))
|
|
{
|
|
m_pv->dwVIDOut |= D3DFVF_DIFFUSE | D3DFVF_SPECULAR;
|
|
}
|
|
else
|
|
{
|
|
// If normal present we have to compute specular and duffuse
|
|
// Otherwise set these bits the same as input.
|
|
// Not that normal should not be present for XYZRHW position type
|
|
if (m_pv->dwDeviceFlags & D3DDEV_LIGHTING)
|
|
m_pv->dwVIDOut |= D3DFVF_DIFFUSE | D3DFVF_SPECULAR;
|
|
else
|
|
m_pv->dwVIDOut |= m_pv->dwVIDIn &
|
|
(D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
|
|
// Always set specular flag if vertex fog is enabled
|
|
if (this->rstates[D3DRENDERSTATE_FOGENABLE] &&
|
|
m_pv->lighting.fog_mode != D3DFOG_NONE)
|
|
{
|
|
m_pv->dwVIDOut |= D3DFVF_SPECULAR;
|
|
}
|
|
else
|
|
// Clear specular flag if specular disabled and we do not have
|
|
// specular in the input
|
|
if (!this->rstates[D3DRENDERSTATE_SPECULARENABLE] &&
|
|
!(m_pv->dwVIDIn & D3DFVF_SPECULAR))
|
|
{
|
|
m_pv->dwVIDOut &= ~D3DFVF_SPECULAR;
|
|
}
|
|
}
|
|
if (m_pv->dwVIDIn & D3DFVF_PSIZE ||
|
|
m_pv->primType == D3DPT_POINTLIST &&
|
|
this->rstates[D3DRS_POINTSCALEENABLE])
|
|
{
|
|
m_pv->dwVIDOut |= D3DFVF_PSIZE;
|
|
}
|
|
|
|
// Compute number of the output texture coordinates
|
|
|
|
// Transform enable bits
|
|
m_pv->dwDeviceFlags &= ~D3DDEV_TEXTURETRANSFORM;
|
|
|
|
DWORD dwTexTransform = m_pv->dwFlags2 & __FLAGS2_TEXTRANSFORM;
|
|
|
|
// When texture transform is enabled or we need to do projected texture
|
|
// emulation or texture coordinates are taken from the vertex data (texgen),
|
|
// output texture coordinates could be generated.
|
|
// So we go and evaluate texture stages
|
|
if ((m_pv->dwFlags2 & (__FLAGS2_TEXTRANSFORM | __FLAGS2_TEXPROJ)
|
|
&& (m_pv->nTexCoord > 0)) ||
|
|
m_pv->dwFlags2 & __FLAGS2_TEXGEN)
|
|
{
|
|
DWORD dwOutTextureSize; // Used to compute output vertex size
|
|
DWORD dwOutTextureFormat; // Used to compute output texture FVF
|
|
// There are texture transforms.
|
|
// Now we find out if some of the texture coordinates are used two
|
|
// or more times and used by a texture transform. In this case we
|
|
// have expand number of output texture coordinates.
|
|
EvalTextureTransforms(this, dwTexTransform,
|
|
&dwOutTextureSize,
|
|
&dwOutTextureFormat);
|
|
if (m_pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
// For ProcessVertices calls user should set texture stages and
|
|
// wrap modes himself
|
|
if (!(m_pv->dwFlags & D3DPV_VBCALL))
|
|
{
|
|
// dwVIDIn is used to force re-compute FVF in the
|
|
// SetTextureStageState. so we save and restore it.
|
|
DWORD dwVIDInSaved = m_pv->dwVIDIn;
|
|
// Re-map indices in the texture stages and wrap modes
|
|
DWORD dwOrgWrapModes[D3DDP_MAXTEXCOORD];
|
|
memcpy(dwOrgWrapModes, &this->rstates[D3DRENDERSTATE_WRAP0],
|
|
sizeof(dwOrgWrapModes));
|
|
for (DWORD i=0; i < this->dwNumTextureStagesToRemap; i++)
|
|
{
|
|
LPD3DFE_TEXTURESTAGE pStage = &this->textureStageToRemap[i];
|
|
DWORD dwOutIndex = pStage->dwOutCoordIndex;
|
|
DWORD dwInpIndex = pStage->dwInpCoordIndex;
|
|
if (dwOutIndex != dwInpIndex || pStage->dwTexGenMode)
|
|
{
|
|
DWORD dwState = D3DRENDERSTATE_WRAP0 + dwOutIndex;
|
|
pStage->dwOrgWrapMode = dwOrgWrapModes[dwOutIndex];
|
|
DWORD dwValue = dwOrgWrapModes[dwInpIndex];
|
|
// We do not call UpdateInternaState because it
|
|
// will call ForceRecomputeFVF and we do not want this.
|
|
this->rstates[dwState] = dwValue;
|
|
|
|
m_pDDI->SetRenderState((D3DRENDERSTATETYPE)dwState, dwValue);
|
|
|
|
// We do not call UpdateInternalTextureStageState because it
|
|
// will call ForceRecomputeFVF and we do not want this.
|
|
m_pDDI->SetTSS(pStage->dwOrgStage, D3DTSS_TEXCOORDINDEX, dwOutIndex);
|
|
// We do not call UpdateInternalTextureStageState because it
|
|
// will call ForceRecomputeFVF and we do not want this.
|
|
// We set some invalid value to the internal array, because otherwise
|
|
// a new SetTextureStageState could be filtered as redundant
|
|
tsstates[pStage->dwOrgStage][D3DTSS_TEXCOORDINDEX] = 0xFFFFFFFF;
|
|
}
|
|
}
|
|
m_pv->dwVIDIn = dwVIDInSaved;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
m_pv->dwVIDOut |= dwOutTextureFormat;
|
|
m_pv->dwTextureCoordSizeTotal = dwOutTextureSize;
|
|
}
|
|
else
|
|
{ // We do not do re-mapping but we have to make correspondence between
|
|
// texture sets and texture transforms
|
|
SetupTextureTransforms(this);
|
|
|
|
// Copy input texture formats
|
|
m_pv->dwVIDOut |= m_pv->dwVIDIn & 0xFFFF0000;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Copy input texture formats
|
|
m_pv->dwVIDOut |= m_pv->dwVIDIn & 0xFFFF0000;
|
|
// When we have texture coordinate set with number of floats different
|
|
// from 2 and device does not support them, we "fix" the texture format
|
|
if (m_pv->dwVIDOut & 0xFFFF0000)
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_ONLY2FLOATSPERTEXTURE)
|
|
{
|
|
m_pv->dwVIDOut &= ~0xFFFF0000;
|
|
for (DWORD i=0; i < m_pv->nOutTexCoord; i++)
|
|
m_pv->dwTextureCoordSize[i] = 8;
|
|
m_pv->dwTextureCoordSizeTotal = m_pv->nTexCoord * 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_pv->dwDeviceFlags & D3DDEV_DONOTSTRIPELEMENTS)
|
|
{
|
|
if (m_pv->nOutTexCoord == 0 && !(m_pv->dwFlags & D3DPV_VBCALL))
|
|
{
|
|
m_pv->dwTextureCoordSize[0] = 0;
|
|
m_pv->dwVIDOut |= (1 << D3DFVF_TEXCOUNT_SHIFT);
|
|
}
|
|
}
|
|
// Set up number of output texture coordinates
|
|
m_pv->dwVIDOut |= (m_pv->nOutTexCoord << D3DFVF_TEXCOUNT_SHIFT);
|
|
if ((m_pv->dwVIDOut & 0xFFFF0000) &&
|
|
(GetDDIType() < D3DDDITYPE_DX7))
|
|
{
|
|
D3D_THROW_FAIL("Texture format bits in the output FVF for this device should be 0");
|
|
}
|
|
|
|
if (!(m_pv->dwFlags & D3DPV_VBCALL))
|
|
{
|
|
m_pv->dwOutputSize = ComputeVertexSizeFVF(m_pv->dwVIDOut);
|
|
ComputeOutputVertexOffsets(m_pv);
|
|
}
|
|
|
|
|
|
// In case if COLORVERTEX is TRUE, the vertexAlpha could be overriden
|
|
// by vertex alpha
|
|
m_pv->lighting.alpha = (DWORD)m_pv->lighting.materialAlpha;
|
|
m_pv->lighting.alphaSpecular = (DWORD)m_pv->lighting.materialAlphaS;
|
|
|
|
this->dwFEFlags |= D3DFE_VERTEXBLEND_DIRTY | D3DFE_FRONTEND_DIRTY;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Sets input vertex pointers and output offsets for legacy vertex shaders for
|
|
// the programmable vertex shaders
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::PrepareToDrawVVM"
|
|
|
|
void CD3DHal::PrepareToDrawVVM(UINT StartVertex)
|
|
{
|
|
if (m_dwRuntimeFlags & D3DRT_SHADERDIRTY)
|
|
{
|
|
SetupFVFDataVVM(this);
|
|
m_dwRuntimeFlags &= ~D3DRT_SHADERDIRTY;
|
|
m_pDDI->SetVertexShader(m_pv->dwVIDOut);
|
|
}
|
|
// Initialize vertex pointers used in the vertex loop
|
|
CVertexDesc* pVD = m_pv->VertexDesc;
|
|
for (DWORD i = m_pv->dwNumUsedVertexDescs; i; i--)
|
|
{
|
|
CVStream* pStream = pVD->pStream;
|
|
DWORD dwStride = pStream->m_dwStride;
|
|
pVD->pMemory = pStream->Data() + pVD->dwVertexOffset +
|
|
StartVertex * dwStride;
|
|
pVD->dwStride = dwStride;
|
|
pVD++;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Sets input vertex pointers and output offsets for legacy vertex shaders
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::PrepareToDrawLegacy"
|
|
|
|
void CD3DHal::PrepareToDrawLegacy(UINT StartVertex)
|
|
{
|
|
// For legacy FVFs we draw using Stream[0]
|
|
m_pv->position.lpvData = m_pStream[0].Data() +
|
|
m_pStream[0].m_dwStride * StartVertex;
|
|
if (m_dwRuntimeFlags & D3DRT_SHADERDIRTY)
|
|
{
|
|
SetupFVFData();
|
|
m_pDDI->SetVertexShader(m_pv->dwVIDOut);
|
|
m_dwRuntimeFlags &= ~D3DRT_SHADERDIRTY;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Sets input vertex pointers and output offsets for the fixed-function pipeline
|
|
// and non-legacy vertex declarations
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::PrepareToDraw"
|
|
|
|
void CD3DHal::PrepareToDraw(UINT StartVertex)
|
|
{
|
|
// Initialize strided data pointers used in the vertex loop
|
|
#if DBG
|
|
{
|
|
// Set all NULL pointers to check if they are initialized by the
|
|
// declaration
|
|
for (DWORD i=0; i < __NUMELEMENTS; i++)
|
|
{
|
|
m_pv->elements[i].lpvData = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
CVertexDesc* pVD = m_pv->VertexDesc;
|
|
for (DWORD i = m_pv->dwNumUsedVertexDescs; i; i--)
|
|
{
|
|
CVStream* pStream = pVD->pStream;
|
|
DWORD dwStride = pStream->m_dwStride;
|
|
pVD->pElement->lpvData = pStream->Data() +
|
|
pVD->dwVertexOffset +
|
|
StartVertex * dwStride;
|
|
pVD->pElement->dwStride = dwStride;
|
|
pVD++;
|
|
}
|
|
if (m_dwRuntimeFlags & D3DRT_SHADERDIRTY)
|
|
{
|
|
SetupFVFData();
|
|
m_pDDI->SetVertexShader(m_pv->dwVIDOut);
|
|
m_dwRuntimeFlags &= ~D3DRT_SHADERDIRTY;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Object implementations
|
|
//
|
|
//---------------------------------------------------------------------
|
|
const DWORD CVShader::FIXEDFUNCTION = 1;
|
|
const DWORD CVShader::SOFTWARE = 2;
|
|
|
|
void CheckForNull(LPVOID p, DWORD line, char* file)
|
|
{
|
|
if (p == NULL)
|
|
D3D_THROW_LINE(E_OUTOFMEMORY, "Not enough memory", line, file);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void Copy_FLOAT1(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
pVertexRegister->x = *(float*)pInputStream;
|
|
pVertexRegister->y = 0;
|
|
pVertexRegister->z = 0;
|
|
pVertexRegister->w = 1;
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_FLOAT2(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
pVertexRegister->x = ((float*)pInputStream)[0];
|
|
pVertexRegister->y = ((float*)pInputStream)[1];
|
|
pVertexRegister->z = 0;
|
|
pVertexRegister->w = 1;
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_FLOAT3(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
pVertexRegister->x = ((float*)pInputStream)[0];
|
|
pVertexRegister->y = ((float*)pInputStream)[1];
|
|
pVertexRegister->z = ((float*)pInputStream)[2];
|
|
pVertexRegister->w = 1;
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_FLOAT4(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
pVertexRegister->x = ((float*)pInputStream)[0];
|
|
pVertexRegister->y = ((float*)pInputStream)[1];
|
|
pVertexRegister->z = ((float*)pInputStream)[2];
|
|
pVertexRegister->w = ((float*)pInputStream)[3];
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_D3DCOLOR(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
const float scale = 1.0f/255.f;
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
const DWORD v = ((DWORD*)pInputStream)[0];
|
|
pVertexRegister->x = scale * RGBA_GETRED(v);
|
|
pVertexRegister->y = scale * RGBA_GETGREEN(v);
|
|
pVertexRegister->z = scale * RGBA_GETBLUE(v);
|
|
pVertexRegister->w = scale * RGBA_GETALPHA(v);
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_UBYTE4(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
const BYTE* v = (BYTE*)pInputStream;
|
|
pVertexRegister->x = v[0];
|
|
pVertexRegister->y = v[1];
|
|
pVertexRegister->z = v[2];
|
|
pVertexRegister->w = v[3];
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_SHORT2(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
const short* v = (short*)pInputStream;
|
|
pVertexRegister->x = v[0];
|
|
pVertexRegister->y = v[1];
|
|
pVertexRegister->z = 0;
|
|
pVertexRegister->w = 1;
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
|
|
void Copy_SHORT4(LPVOID pInputStream, UINT stride, UINT count,
|
|
VVM_WORD * pVertexRegister)
|
|
{
|
|
for (UINT i=0; i < count; i++)
|
|
{
|
|
const short* v = (short*)pInputStream;
|
|
pVertexRegister->x = v[0];
|
|
pVertexRegister->y = v[1];
|
|
pVertexRegister->z = v[2];
|
|
pVertexRegister->w = v[3];
|
|
pInputStream = (BYTE*)pInputStream + stride;
|
|
pVertexRegister++;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Based on register and data type the function computes FVF dword and presence
|
|
// bits:
|
|
// - Bits in the dwFVF2 are used to detect that some field is not entered twice
|
|
// - pnFloats is used to compute number of floats with position
|
|
//
|
|
|
|
// Bits for dwFVF2. Order is the same as in the FVF!!!
|
|
//
|
|
static const DWORD __POSITION_PRESENT = 1 << 0;
|
|
static const DWORD __BLENDWEIGHT_PRESENT = 1 << 1;
|
|
static const DWORD __BLENDINDICES_PRESENT = 1 << 2;
|
|
static const DWORD __NORMAL_PRESENT = 1 << 3;
|
|
static const DWORD __PSIZE_PRESENT = 1 << 4;
|
|
static const DWORD __DIFFUSE_PRESENT = 1 << 5;
|
|
static const DWORD __SPECULAR_PRESENT = 1 << 6;
|
|
// __TEXTURE0_PRESENT must start from 8th bit
|
|
static const DWORD __TEXTURE0_PRESENT = 1 << 8;
|
|
static const DWORD __TEXTURE1_PRESENT = 1 << 9;
|
|
static const DWORD __TEXTURE2_PRESENT = 1 << 10;
|
|
static const DWORD __TEXTURE3_PRESENT = 1 << 11;
|
|
static const DWORD __TEXTURE4_PRESENT = 1 << 12;
|
|
static const DWORD __TEXTURE5_PRESENT = 1 << 13;
|
|
static const DWORD __TEXTURE6_PRESENT = 1 << 14;
|
|
static const DWORD __TEXTURE7_PRESENT = 1 << 15;
|
|
static const DWORD __POSITION2_PRESENT = 1 << 16;
|
|
static const DWORD __NORMAL2_PRESENT = 1 << 17;
|
|
|
|
// Check if any bit left from the CurrentBit is set in PresenceBits
|
|
// PresenceBits are updated by CurrentBit.
|
|
//
|
|
inline void CheckOrder(
|
|
DWORD* pPresenceBits, // Presence bits for the declaration
|
|
DWORD CurrentBit,
|
|
BOOL* pFlag, // Out of order flag for the declaration
|
|
char* s) // Name of the field
|
|
{
|
|
if (*pPresenceBits & CurrentBit)
|
|
{
|
|
char msg[80];
|
|
sprintf(msg, "%s specified twice in the declaration", s);
|
|
D3D_THROW_FAIL(msg);
|
|
}
|
|
if (*pPresenceBits & ~(CurrentBit | (CurrentBit-1)))
|
|
{
|
|
*pFlag = FALSE;
|
|
}
|
|
*pPresenceBits |= CurrentBit;
|
|
}
|
|
|
|
void UpdateFVF(DWORD dwRegister, DWORD dwDataType,
|
|
DWORD* pdwFVF, // FVF for the current declaration
|
|
DWORD* pdwFVF2, // Presence bits for the current stream
|
|
DWORD* pnFloats,
|
|
BOOL* pbLegacyFVF)
|
|
{
|
|
switch (dwRegister)
|
|
{
|
|
case D3DVSDE_POSITION:
|
|
if (dwDataType != D3DVSDT_FLOAT3)
|
|
D3D_THROW_FAIL("Position register must be FLOAT3 for fixed-function pipeline");
|
|
|
|
CheckOrder(pdwFVF2, __POSITION_PRESENT, pbLegacyFVF, "Position");
|
|
*pdwFVF |= D3DFVF_XYZ;
|
|
break;
|
|
case D3DVSDE_POSITION2:
|
|
if (dwDataType != D3DVSDT_FLOAT3)
|
|
D3D_THROW_FAIL("Position2 register must be FLOAT3 for fixed-function pipeline");
|
|
CheckOrder(pdwFVF2, __POSITION2_PRESENT, pbLegacyFVF, "Position2");
|
|
break;
|
|
case D3DVSDE_BLENDWEIGHT:
|
|
{
|
|
CheckOrder(pdwFVF2, __BLENDWEIGHT_PRESENT, pbLegacyFVF, "Blend weight");
|
|
switch (dwDataType)
|
|
{
|
|
case D3DVSDT_FLOAT1:
|
|
(*pnFloats)++;
|
|
break;
|
|
case D3DVSDT_FLOAT2:
|
|
(*pnFloats) += 2;
|
|
break;
|
|
case D3DVSDT_FLOAT3:
|
|
(*pnFloats) += 3;
|
|
break;
|
|
case D3DVSDT_FLOAT4:
|
|
(*pnFloats) += 4;
|
|
break;
|
|
default:
|
|
D3D_THROW_FAIL("Invalid data type set for vertex blends");
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case D3DVSDE_NORMAL:
|
|
CheckOrder(pdwFVF2, __NORMAL_PRESENT, pbLegacyFVF, "Normal");
|
|
if (dwDataType != D3DVSDT_FLOAT3)
|
|
D3D_THROW_FAIL("Normal register must be FLOAT3 for fixed-function pipeline");
|
|
*pdwFVF |= D3DFVF_NORMAL;
|
|
break;
|
|
case D3DVSDE_NORMAL2:
|
|
CheckOrder(pdwFVF2, __NORMAL2_PRESENT, pbLegacyFVF, "Normal2");
|
|
if (dwDataType != D3DVSDT_FLOAT3)
|
|
D3D_THROW_FAIL("Normal2 register must be FLOAT3 for fixed-function pipeline");
|
|
break;
|
|
case D3DVSDE_PSIZE:
|
|
CheckOrder(pdwFVF2, __PSIZE_PRESENT, pbLegacyFVF, "Point size");
|
|
if (dwDataType != D3DVSDT_FLOAT1)
|
|
D3D_THROW_FAIL("Point size register must be FLOAT1 for fixed-function pipeline");
|
|
*pdwFVF |= D3DFVF_PSIZE;
|
|
break;
|
|
case D3DVSDE_DIFFUSE:
|
|
CheckOrder(pdwFVF2, __DIFFUSE_PRESENT, pbLegacyFVF, "Diffuse");
|
|
if (dwDataType != D3DVSDT_D3DCOLOR)
|
|
D3D_THROW_FAIL("Diffuse register must be D3DCOLOR for fixed-function pipeline");
|
|
*pdwFVF |= D3DFVF_DIFFUSE;
|
|
break;
|
|
case D3DVSDE_SPECULAR:
|
|
CheckOrder(pdwFVF2, __SPECULAR_PRESENT, pbLegacyFVF, "Specular");
|
|
if (dwDataType != D3DVSDT_D3DCOLOR)
|
|
D3D_THROW_FAIL("Specular register must be D3DCOLOR for fixed-function pipeline");
|
|
*pdwFVF |= D3DFVF_SPECULAR;
|
|
break;
|
|
case D3DVSDE_BLENDINDICES:
|
|
CheckOrder(pdwFVF2, __BLENDINDICES_PRESENT, pbLegacyFVF, "Blend indices");
|
|
if (dwDataType != D3DVSDT_UBYTE4)
|
|
D3D_THROW_FAIL("Blend indices register must be D3DVSDT_UBYTE4 for fixed-function pipeline");
|
|
// Update number of floats after position
|
|
(*pnFloats)++;
|
|
break;
|
|
case D3DVSDE_TEXCOORD0:
|
|
case D3DVSDE_TEXCOORD1:
|
|
case D3DVSDE_TEXCOORD2:
|
|
case D3DVSDE_TEXCOORD3:
|
|
case D3DVSDE_TEXCOORD4:
|
|
case D3DVSDE_TEXCOORD5:
|
|
case D3DVSDE_TEXCOORD6:
|
|
case D3DVSDE_TEXCOORD7:
|
|
{
|
|
DWORD dwTextureIndex = dwRegister - D3DVSDE_TEXCOORD0;
|
|
DWORD dwBit = __TEXTURE0_PRESENT << dwTextureIndex;
|
|
CheckOrder(pdwFVF2, dwBit, pbLegacyFVF, "Texture");
|
|
switch (dwDataType)
|
|
{
|
|
case D3DVSDT_FLOAT1:
|
|
*pdwFVF |= D3DFVF_TEXCOORDSIZE1(dwTextureIndex);
|
|
break;
|
|
case D3DVSDT_FLOAT2:
|
|
*pdwFVF |= D3DFVF_TEXCOORDSIZE2(dwTextureIndex);
|
|
break;
|
|
case D3DVSDT_FLOAT3:
|
|
*pdwFVF |= D3DFVF_TEXCOORDSIZE3(dwTextureIndex);
|
|
break;
|
|
case D3DVSDT_FLOAT4:
|
|
*pdwFVF |= D3DFVF_TEXCOORDSIZE4(dwTextureIndex);
|
|
break;
|
|
default:
|
|
D3D_THROW_FAIL("Invalid data type set for texture register");
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
D3D_THROW_FAIL("Invalid register set for fixed-function pipeline");
|
|
break;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CVStreamDecl::Parse(CD3DBase* pDevice,
|
|
DWORD CONST ** ppToken, BOOL bFixedFunction,
|
|
DWORD* pdwFVF, DWORD* pdwFVF2, DWORD* pnFloats,
|
|
BOOL* pbLegacyFVF, UINT usage, BOOL bTessStream)
|
|
{
|
|
CONST DWORD* pToken = *ppToken;
|
|
// Used to compute stream stride and offset in bytes for each stream element
|
|
DWORD dwCurrentOffset = 0;
|
|
// FVF and FVF2 for this stream only. Used to check if data in the stream
|
|
// form a FVF subset
|
|
DWORD dwFVF2 = 0;
|
|
DWORD dwFVF = 0;
|
|
DWORD nFloats = 0;
|
|
// Set to TRUE, if data in the stream is an FVF subset
|
|
BOOL bFVFSubset = TRUE;
|
|
|
|
while (TRUE)
|
|
{
|
|
DWORD dwToken = *pToken++;
|
|
const DWORD dwTokenType = D3DVSD_GETTOKENTYPE(dwToken);
|
|
switch (dwTokenType)
|
|
{
|
|
case D3DVSD_TOKEN_NOP: break;
|
|
case D3DVSD_TOKEN_TESSELLATOR:
|
|
{
|
|
*pbLegacyFVF = FALSE;
|
|
bFVFSubset = FALSE;
|
|
const DWORD dwDataType = D3DVSD_GETDATATYPE(dwToken);
|
|
switch (dwDataType)
|
|
{
|
|
case D3DVSDT_FLOAT2:
|
|
case D3DVSDT_FLOAT3:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case D3DVSD_TOKEN_STREAMDATA:
|
|
{
|
|
switch (D3DVSD_GETDATALOADTYPE(dwToken))
|
|
{
|
|
case D3DVSD_LOADREGISTER:
|
|
{
|
|
#if DBG
|
|
if (m_dwNumElements >= __NUMELEMENTS)
|
|
{
|
|
D3D_ERR("D3DVSD_TOKEN_STREAMDATA:");
|
|
D3D_ERR(" Number of vertex elements in a stream is greater than max supported");
|
|
D3D_ERR(" Max supported number of elements is %d", __NUMELEMENTS);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
#endif
|
|
CVElement* pElement = &m_Elements[m_dwNumElements++];
|
|
const DWORD dwDataType = D3DVSD_GETDATATYPE(dwToken);
|
|
const DWORD dwRegister = D3DVSD_GETVERTEXREG(dwToken);
|
|
pElement->m_dwOffset = dwCurrentOffset;
|
|
pElement->m_dwRegister = dwRegister;
|
|
pElement->m_dwDataType = dwDataType;
|
|
switch (dwDataType)
|
|
{
|
|
case D3DVSDT_FLOAT1:
|
|
dwCurrentOffset += sizeof(float);
|
|
pElement->m_pfnCopy = (LPVOID)Copy_FLOAT1;
|
|
break;
|
|
case D3DVSDT_FLOAT2:
|
|
dwCurrentOffset += sizeof(float) * 2;
|
|
pElement->m_pfnCopy = (LPVOID)Copy_FLOAT2;
|
|
break;
|
|
case D3DVSDT_FLOAT3:
|
|
dwCurrentOffset += sizeof(float) * 3;
|
|
pElement->m_pfnCopy = (LPVOID)Copy_FLOAT3;
|
|
break;
|
|
case D3DVSDT_FLOAT4:
|
|
dwCurrentOffset += sizeof(float) * 4;
|
|
pElement->m_pfnCopy = (LPVOID)Copy_FLOAT4;
|
|
break;
|
|
case D3DVSDT_D3DCOLOR:
|
|
dwCurrentOffset += sizeof(DWORD);
|
|
pElement->m_pfnCopy = (LPVOID)Copy_D3DCOLOR;
|
|
break;
|
|
case D3DVSDT_UBYTE4:
|
|
#if DBG
|
|
// Do not fail when software processing will be used
|
|
if (pDevice->GetD3DCaps()->VertexProcessingCaps & D3DVTXPCAPS_NO_VSDT_UBYTE4 &&
|
|
!((usage & D3DUSAGE_SOFTWAREPROCESSING &&
|
|
pDevice->BehaviorFlags() & D3DCREATE_MIXED_VERTEXPROCESSING) ||
|
|
(pDevice->BehaviorFlags() & D3DCREATE_SOFTWARE_VERTEXPROCESSING)))
|
|
{
|
|
D3D_THROW_FAIL("Device does not support UBYTE4 data type");
|
|
}
|
|
#endif // DBG
|
|
dwCurrentOffset += sizeof(DWORD);
|
|
pElement->m_pfnCopy = (LPVOID)Copy_UBYTE4;
|
|
break;
|
|
case D3DVSDT_SHORT2:
|
|
dwCurrentOffset += sizeof(short) * 2;
|
|
pElement->m_pfnCopy = (LPVOID)Copy_SHORT2;
|
|
break;
|
|
case D3DVSDT_SHORT4:
|
|
dwCurrentOffset += sizeof(short) * 4;
|
|
pElement->m_pfnCopy = (LPVOID)Copy_SHORT4;
|
|
break;
|
|
default:
|
|
D3D_ERR("D3DVSD_TOKEN_STREAMDATA: Invalid element data type: %10x", dwToken);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
// Compute input FVF for fixed-function pipeline
|
|
if (bFixedFunction)
|
|
{
|
|
// Update FVF for the declaration
|
|
UpdateFVF(dwRegister, dwDataType, pdwFVF, pdwFVF2,
|
|
pnFloats, pbLegacyFVF);
|
|
// Update FVF for the stream
|
|
UpdateFVF(dwRegister, dwDataType, &dwFVF, &dwFVF2,
|
|
&nFloats, &bFVFSubset);
|
|
}
|
|
else
|
|
if (dwRegister >= D3DVS_INPUTREG_MAX_V1_1)
|
|
D3D_THROW_FAIL("D3DVSD_TOKEN_STREAMDATA: Invalid register number");
|
|
break;
|
|
}
|
|
case D3DVSD_SKIP:
|
|
{
|
|
if (bFixedFunction)
|
|
{
|
|
D3D_THROW_FAIL("D3DVSD_SKIP is not allowed for fixed-function pipeline");
|
|
}
|
|
const DWORD dwCount = D3DVSD_GETSKIPCOUNT(dwToken);
|
|
dwCurrentOffset += dwCount * sizeof(DWORD);
|
|
break;
|
|
}
|
|
default:
|
|
D3D_ERR("Invalid data load type: %10x", dwToken);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
*ppToken = pToken - 1;
|
|
m_dwStride = dwCurrentOffset;
|
|
goto l_exit;
|
|
}
|
|
} // switch
|
|
} // while
|
|
l_exit:
|
|
if (bFixedFunction && !bTessStream)
|
|
{
|
|
#if DBG
|
|
m_dwFVF = dwFVF;
|
|
#endif
|
|
if (!bFVFSubset)
|
|
{
|
|
D3D_THROW_FAIL("For fixed-function pipeline each stream has to be an FVF subset");
|
|
}
|
|
if (dwFVF2 & (__POSITION2_PRESENT | __NORMAL2_PRESENT |
|
|
__PSIZE_PRESENT | __BLENDINDICES_PRESENT))
|
|
{
|
|
*pbLegacyFVF = FALSE;
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
CVDeclaration::CVDeclaration(DWORD dwNumStreams)
|
|
{
|
|
m_pConstants = NULL;
|
|
m_pConstantsTail = NULL;
|
|
m_pActiveStreams = NULL;
|
|
m_pActiveStreamsTail = NULL;
|
|
m_dwInputFVF = 0;
|
|
m_bLegacyFVF = TRUE;
|
|
m_dwNumStreams = dwNumStreams;
|
|
m_bStreamTessPresent = FALSE;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
CVDeclaration::~CVDeclaration()
|
|
{
|
|
delete m_pActiveStreams;
|
|
delete m_pConstants;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CVDeclaration::Parse(CD3DBase* pDevice, CONST DWORD* pTok, BOOL bFixedFunction,
|
|
DWORD* pDeclSize, UINT usage)
|
|
{
|
|
DWORD dwFVF = 0; // FVF for fixed-function pipeline
|
|
DWORD dwFVF2 = 0; // Texture presence bits (8 bits)
|
|
DWORD nFloats = 0; // Number of floats after position
|
|
|
|
DWORD dwStreamPresent = 0; // Bit is set if a stream is used
|
|
m_bLegacyFVF = TRUE;
|
|
|
|
CONST DWORD* pToken = pTok;
|
|
while (TRUE)
|
|
{
|
|
DWORD dwToken = *pToken++;
|
|
const DWORD dwTokenType = D3DVSD_GETTOKENTYPE(dwToken);
|
|
switch (dwTokenType)
|
|
{
|
|
case D3DVSD_TOKEN_NOP: break;
|
|
case D3DVSD_TOKEN_STREAM:
|
|
{
|
|
CVStreamDecl StreamTess;
|
|
|
|
if( D3DVSD_ISSTREAMTESS(dwToken) )
|
|
{
|
|
m_bLegacyFVF = FALSE;
|
|
if( m_bStreamTessPresent )
|
|
{
|
|
D3D_THROW(D3DERR_INVALIDCALL, "Tesselator Stream has already been defined in the declaration");
|
|
}
|
|
|
|
m_bStreamTessPresent = TRUE;
|
|
//
|
|
// For now simply skip over the Tess tokens in the
|
|
// Runtime.
|
|
StreamTess.Parse(pDevice, &pToken, bFixedFunction, &dwFVF, &dwFVF2,
|
|
&nFloats, &m_bLegacyFVF, usage, TRUE);
|
|
}
|
|
else
|
|
{
|
|
DWORD dwStream = D3DVSD_GETSTREAMNUMBER(dwToken);
|
|
if (dwStream >= m_dwNumStreams)
|
|
{
|
|
D3D_THROW_FAIL("Stream number is too big");
|
|
}
|
|
|
|
if (dwStreamPresent & (1 << dwStream))
|
|
{
|
|
D3D_THROW(D3DERR_INVALIDCALL, "Stream is already defined"
|
|
"in the declaration");
|
|
}
|
|
|
|
dwStreamPresent |= 1 << dwStream;
|
|
|
|
// There are more than one stream present, so cant be
|
|
// handled by legacy FVF.
|
|
if( dwStreamPresent & (dwStreamPresent - 1) )
|
|
m_bLegacyFVF = FALSE;
|
|
|
|
|
|
CVStreamDecl* pStream = new CVStreamDecl;
|
|
if (pStream == NULL)
|
|
{
|
|
D3D_THROW(E_OUTOFMEMORY, "Not enough memory");
|
|
}
|
|
try
|
|
{
|
|
pStream->Parse(pDevice, &pToken, bFixedFunction, &dwFVF, &dwFVF2,
|
|
&nFloats, &m_bLegacyFVF, usage);
|
|
pStream->m_dwStreamIndex = dwStream;
|
|
if (m_pActiveStreams == NULL)
|
|
{
|
|
m_pActiveStreams = pStream;
|
|
m_pActiveStreamsTail = pStream;
|
|
}
|
|
else
|
|
{
|
|
m_pActiveStreamsTail->Append(pStream);
|
|
m_pActiveStreamsTail = pStream;
|
|
}
|
|
}
|
|
catch (HRESULT e)
|
|
{
|
|
delete pStream;
|
|
throw e;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DVSD_TOKEN_STREAMDATA:
|
|
{
|
|
D3D_THROW_FAIL("D3DVSD_TOKEN_STREAMDATA could only be used after D3DVSD_TOKEN_STREAM");
|
|
}
|
|
case D3DVSD_TOKEN_CONSTMEM:
|
|
{
|
|
CVConstantData * cd = new CVConstantData;
|
|
CheckForNull(cd, __LINE__, __FILE__);
|
|
|
|
cd->m_dwCount = D3DVSD_GETCONSTCOUNT(dwToken);
|
|
cd->m_dwAddress = D3DVSD_GETCONSTADDRESS(dwToken);
|
|
|
|
UINT ValidationCount;
|
|
if (usage & D3DUSAGE_SOFTWAREPROCESSING)
|
|
ValidationCount = D3DVS_CONSTREG_MAX_V1_1;
|
|
else
|
|
ValidationCount = pDevice->GetD3DCaps()->MaxVertexShaderConst;
|
|
|
|
if ((cd->m_dwCount + cd->m_dwAddress) > ValidationCount)
|
|
D3D_THROW_FAIL("D3DVSD_TOKEN_CONSTMEM writes outside constant memory");
|
|
|
|
const DWORD dwSize = cd->m_dwCount << 2; // number of DWORDs
|
|
cd->m_pData = new DWORD[dwSize];
|
|
CheckForNull(cd->m_pData, __LINE__, __FILE__);
|
|
|
|
memcpy(cd->m_pData, pToken, dwSize << 2);
|
|
if (m_pConstants == NULL)
|
|
{
|
|
m_pConstants = cd;
|
|
m_pConstantsTail = cd;
|
|
}
|
|
else
|
|
{
|
|
m_pConstantsTail->Append(cd);
|
|
m_pConstantsTail = cd;
|
|
}
|
|
pToken += dwSize;
|
|
break;
|
|
}
|
|
case D3DVSD_TOKEN_EXT:
|
|
{
|
|
// Skip extension info
|
|
DWORD dwCount = D3DVSD_GETEXTCOUNT(dwToken);
|
|
pToken += dwCount;
|
|
break;
|
|
}
|
|
case D3DVSD_TOKEN_END:
|
|
{
|
|
goto l_End;
|
|
}
|
|
default:
|
|
{
|
|
D3D_ERR("Invalid declaration token: %10x", dwToken);
|
|
D3D_THROW_FAIL("");
|
|
}
|
|
}
|
|
}
|
|
l_End:
|
|
// Validate input for the fixed-function pipeline
|
|
if (bFixedFunction && !m_bStreamTessPresent)
|
|
{
|
|
m_dwInputFVF = dwFVF & 0xFFFF0FFF; // Remove float count
|
|
switch (nFloats)
|
|
{
|
|
case 0: m_dwInputFVF |= D3DFVF_XYZ; break;
|
|
case 1: m_dwInputFVF |= D3DFVF_XYZB1; break;
|
|
case 2: m_dwInputFVF |= D3DFVF_XYZB2; break;
|
|
case 3: m_dwInputFVF |= D3DFVF_XYZB3; break;
|
|
case 4: m_dwInputFVF |= D3DFVF_XYZB4; break;
|
|
case 5: m_dwInputFVF |= D3DFVF_XYZB5; break;
|
|
default:
|
|
D3D_THROW_FAIL("Too many floats after position");
|
|
}
|
|
// Compute number of texture coordinates
|
|
DWORD nTexCoord = 0;
|
|
DWORD dwTexturePresenceBits = (dwFVF2 >> 8) & 0xFF;
|
|
while (dwTexturePresenceBits & 1)
|
|
{
|
|
dwTexturePresenceBits >>= 1;
|
|
nTexCoord++;
|
|
}
|
|
// There should be no gaps in texture coordinates
|
|
if (dwTexturePresenceBits)
|
|
D3D_THROW_FAIL("Texture coordinates should have no gaps");
|
|
|
|
m_dwInputFVF |= nTexCoord << D3DFVF_TEXCOUNT_SHIFT;
|
|
|
|
// Position must be set
|
|
if ((dwFVF & D3DFVF_POSITION_MASK) != D3DFVF_XYZ)
|
|
D3D_THROW_FAIL("Position register must be set");
|
|
}
|
|
if (pDeclSize != NULL)
|
|
{
|
|
*pDeclSize = (DWORD) (pToken - pTok) << 2;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
CVStream::~CVStream()
|
|
{
|
|
if (m_pVB)
|
|
m_pVB->DecrementUseCount();
|
|
}
|
|
//---------------------------------------------------------------------
|
|
CVIndexStream::~CVIndexStream()
|
|
{
|
|
if (m_pVBI)
|
|
m_pVBI->DecrementUseCount();
|
|
}
|
|
//---------------------------------------------------------------------
|
|
DWORD g_PrimToVerCount[7][2] =
|
|
{
|
|
{0, 0}, // Illegal
|
|
{1, 0}, // D3DPT_POINTLIST = 1,
|
|
{2, 0}, // D3DPT_LINELIST = 2,
|
|
{1, 1}, // D3DPT_LINESTRIP = 3,
|
|
{3, 0}, // D3DPT_TRIANGLELIST = 4,
|
|
{1, 2}, // D3DPT_TRIANGLESTRIP = 5,
|
|
{1, 2}, // D3DPT_TRIANGLEFAN = 6,
|
|
};
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT D3DFE_PVFUNCSI::CreateShader(CVElement* pElements, DWORD dwNumElements,
|
|
DWORD* pdwShaderCode, DWORD dwOutputFVF,
|
|
CPSGPShader** ppPSGPShader)
|
|
{
|
|
*ppPSGPShader = NULL;
|
|
try
|
|
{
|
|
*ppPSGPShader = m_VertexVM.CreateShader(pElements, dwNumElements,
|
|
pdwShaderCode);
|
|
if (*ppPSGPShader == NULL)
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
D3D_CATCH;
|
|
return D3D_OK;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT D3DFE_PVFUNCSI::SetActiveShader(CPSGPShader* pPSGPShader)
|
|
{
|
|
return m_VertexVM.SetActiveShader((CVShaderCode*)pPSGPShader);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Load vertex shader constants
|
|
HRESULT
|
|
D3DFE_PVFUNCSI::LoadShaderConstants(DWORD start, DWORD count, LPVOID buffer)
|
|
{
|
|
return m_VertexVM.SetData(D3DSPR_CONST, start, count, buffer);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Get vertex shader constants
|
|
HRESULT
|
|
D3DFE_PVFUNCSI::GetShaderConstants(DWORD start, DWORD count, LPVOID buffer)
|
|
{
|
|
return m_VertexVM.GetData(D3DSPR_CONST, start, count, buffer);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::GetVertexShaderConstant"
|
|
|
|
HRESULT D3DAPI
|
|
CD3DHal::GetVertexShaderConstant(DWORD Register, LPVOID pData, DWORD count)
|
|
{
|
|
API_ENTER(this);
|
|
#if DBG
|
|
// Validate Parameters
|
|
if (!VALID_WRITEPTR(pData, 4 * sizeof(DWORD) * count))
|
|
{
|
|
D3D_ERR("Invalid constant data pointer. GetVertexShaderConstant failed.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
if ((GetD3DCaps()->VertexShaderVersion == D3DVS_VERSION(0,0)) &&
|
|
(BehaviorFlags() & (D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE)))
|
|
{
|
|
D3D_ERR("No programmable vertex shaders are supported by this device. GetVertexShaderConstant failed.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
UINT ValidationCount;
|
|
if (BehaviorFlags() & D3DCREATE_MIXED_VERTEXPROCESSING)
|
|
ValidationCount = max(m_MaxVertexShaderConst, D3DVS_CONSTREG_MAX_V1_1);
|
|
else
|
|
if (BehaviorFlags() & D3DCREATE_SOFTWARE_VERTEXPROCESSING)
|
|
ValidationCount = D3DVS_CONSTREG_MAX_V1_1;
|
|
else
|
|
ValidationCount = m_MaxVertexShaderConst;
|
|
if((Register + count) > ValidationCount)
|
|
{
|
|
D3D_ERR("Not that many constant registers in the vertex machine. GetVertexShaderConstant failed.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
#endif
|
|
HRESULT hr;
|
|
if (m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING ||
|
|
((count + Register) <= D3DVS_CONSTREG_MAX_V1_1))
|
|
{
|
|
// For software vertex processing we store constant registers in PSGP if
|
|
// possible
|
|
return m_pv->pGeometryFuncs->GetShaderConstants(Register, count,
|
|
const_cast<VOID*>(pData));
|
|
}
|
|
else
|
|
{
|
|
if (Register >= D3DVS_CONSTREG_MAX_V1_1)
|
|
{
|
|
// When all modified registers are above software limit, we use Microsoft
|
|
// internal array
|
|
hr = GeometryFuncsGuaranteed->GetShaderConstants(Register, count,
|
|
const_cast<VOID*>(pData));
|
|
}
|
|
else
|
|
{
|
|
// Part of constant data is taken from PSGP array and part from
|
|
// Microsoft's array
|
|
UINT FirstCount = D3DVS_CONSTREG_MAX_V1_1 - Register;
|
|
hr = m_pv->pGeometryFuncs->GetShaderConstants(Register, FirstCount,
|
|
const_cast<VOID*>(pData));
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
return GeometryFuncsGuaranteed->GetShaderConstants(D3DVS_CONSTREG_MAX_V1_1,
|
|
Register + count - D3DVS_CONSTREG_MAX_V1_1,
|
|
&((DWORD*)pData)[FirstCount*4]);
|
|
}
|
|
return hr;
|
|
}
|
|
return m_pv->pGeometryFuncs->GetShaderConstants(Register, count, pData);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::GetVertexShader"
|
|
|
|
HRESULT D3DAPI
|
|
CD3DHal::GetVertexShader(LPDWORD pdwHandle)
|
|
{
|
|
API_ENTER(this); // Takes D3D Lock if necessary
|
|
|
|
HRESULT ret = D3D_OK;
|
|
#if DBG
|
|
// Validate Parameters
|
|
if (!VALID_WRITEPTR(pdwHandle, sizeof(DWORD)))
|
|
{
|
|
D3D_ERR("Invalid handle pointer. GetVertexShader failed.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
#endif
|
|
*pdwHandle = m_dwCurrentShaderHandle;
|
|
return ret;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::GetPixelShader"
|
|
|
|
HRESULT D3DAPI
|
|
CD3DHal::GetPixelShader(LPDWORD pdwHandle)
|
|
{
|
|
API_ENTER(this); // Takes D3D Lock if necessary
|
|
|
|
HRESULT ret = D3D_OK;
|
|
|
|
#if DBG
|
|
// Validate Parameters
|
|
if (!VALID_WRITEPTR(pdwHandle, sizeof(DWORD)))
|
|
{
|
|
D3D_ERR("Invalid handle pointer. GetPixelShader failed.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
#endif
|
|
*pdwHandle = m_dwCurrentPixelShaderHandle;
|
|
return ret;
|
|
}
|
|
#if DBG
|
|
//-----------------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CD3DHal::ValidateRTPatch"
|
|
|
|
void CD3DHal::ValidateRTPatch()
|
|
{
|
|
if (D3DVSD_ISLEGACY(m_dwCurrentShaderHandle))
|
|
{
|
|
if (m_pStream[0].m_pVB == 0)
|
|
{
|
|
D3D_THROW_FAIL("Draw[RT]Patch should have streams set");
|
|
}
|
|
if ((m_pStream[0].m_pVB->GetBufferDesc()->Usage & D3DUSAGE_RTPATCHES) == 0)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffers used for rendering RT-Patches should have D3DUSAGE_RTPATCHES set");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CVStreamDecl* pStream;
|
|
pStream = m_pCurrentShader->m_Declaration.m_pActiveStreams;
|
|
while(pStream)
|
|
{
|
|
UINT index = pStream->m_dwStreamIndex;
|
|
CVStream* pDeviceStream = &m_pStream[index];
|
|
if (pDeviceStream->m_pVB == 0)
|
|
{
|
|
D3D_THROW_FAIL("Draw[RT]Patch should have streams set");
|
|
}
|
|
if ((pDeviceStream->m_pVB->GetBufferDesc()->Usage & D3DUSAGE_RTPATCHES) == 0)
|
|
{
|
|
D3D_THROW_FAIL("Vertex buffers used for rendering RT-Patches should have D3DUSAGE_RTPATCHES set");
|
|
}
|
|
pStream = (CVStreamDecl*)pStream->m_pNext;
|
|
}
|
|
}
|
|
}
|
|
#endif // DBG
|