2256 lines
86 KiB
C++
2256 lines
86 KiB
C++
/*==========================================================================;
|
|
*
|
|
* Copyright (C) 1998 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: stateset.cpp
|
|
* Content: State sets handling
|
|
*
|
|
***************************************************************************/
|
|
#include "pch.cpp"
|
|
#pragma hdrstop
|
|
|
|
#include "fe.h"
|
|
|
|
//=====================================================================
|
|
// CStateSets interface
|
|
//
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::CStateSets"
|
|
|
|
CStateSets::CStateSets(): m_SetHandles(10), m_DeviceHandles(10), m_GrowSize(10)
|
|
{
|
|
m_dwMaxSets = 0;
|
|
m_dwCurrentHandle = __INVALIDHANDLE;
|
|
m_pStateSets = NULL;
|
|
// Init handle factory
|
|
// m_SetHandles.Init(m_GrowSize, m_GrowSize);
|
|
m_SetHandles.CreateNewHandle( NULL ); // Reserve handle 0
|
|
// m_DeviceHandles.Init(m_GrowSize, m_GrowSize);
|
|
m_DeviceHandles.CreateNewHandle( NULL ); // Reserve handle 0
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::~CStateSets"
|
|
|
|
CStateSets::~CStateSets()
|
|
{
|
|
delete m_pBufferSet;
|
|
delete [] m_pStateSets;
|
|
m_SetHandles.ReleaseHandle(0);
|
|
m_DeviceHandles.ReleaseHandle(0);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::Init"
|
|
|
|
HRESULT CStateSets::Init(CD3DBase *pDev)
|
|
{
|
|
m_bPure = (pDev->BehaviorFlags() & D3DCREATE_PUREDEVICE) != 0;
|
|
m_bTLHal = (pDev->GetDDIType() == D3DDDITYPE_DX7TL) || (pDev->GetDDIType() == D3DDDITYPE_DX8TL);
|
|
m_bDX8Dev = (pDev->GetDDIType() >= D3DDDITYPE_DX8);
|
|
m_bHardwareVP = (pDev->BehaviorFlags() &
|
|
D3DCREATE_HARDWARE_VERTEXPROCESSING);
|
|
if(pDev->GetDDIType() > D3DDDITYPE_DX7TL)
|
|
{
|
|
DWORD value = 0;
|
|
GetD3DRegValue(REG_DWORD, "EmulateStateBlocks", &value, sizeof(DWORD));
|
|
if(value == 0)
|
|
{
|
|
m_bEmulate = FALSE;
|
|
}
|
|
else
|
|
{
|
|
m_bEmulate = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_bEmulate = TRUE;
|
|
}
|
|
if(m_bPure)
|
|
{
|
|
m_pBufferSet = new CPureStateSet;
|
|
}
|
|
else
|
|
{
|
|
m_pBufferSet = new CStateSet;
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::StartNewSet"
|
|
|
|
HRESULT CStateSets::StartNewSet()
|
|
{
|
|
m_dwCurrentHandle = m_SetHandles.CreateNewHandle( NULL );
|
|
if (m_dwCurrentHandle == __INVALIDHANDLE)
|
|
return E_OUTOFMEMORY;
|
|
if (m_dwCurrentHandle >= m_dwMaxSets)
|
|
{
|
|
// Time to grow the array
|
|
CStateSet *pNew;
|
|
if(m_bPure)
|
|
{
|
|
pNew = new CPureStateSet[m_dwMaxSets + m_GrowSize];
|
|
}
|
|
else
|
|
{
|
|
pNew = new CStateSet[m_dwMaxSets + m_GrowSize];
|
|
}
|
|
if (pNew == NULL)
|
|
{
|
|
m_SetHandles.ReleaseHandle(m_dwCurrentHandle);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
for (DWORD i=0; i < m_dwMaxSets; i++)
|
|
pNew[i] = m_pStateSets[i];
|
|
delete [] m_pStateSets;
|
|
m_pStateSets = pNew;
|
|
m_dwMaxSets += m_GrowSize;
|
|
}
|
|
m_pBufferSet->m_FEOnlyBuffer.Reset();
|
|
m_pBufferSet->m_DriverBuffer.Reset();
|
|
m_pCurrentStateSet = m_pBufferSet;
|
|
return D3D_OK;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::EndSet"
|
|
|
|
void CStateSets::EndSet()
|
|
{
|
|
m_pStateSets[m_dwCurrentHandle] = *m_pCurrentStateSet;
|
|
m_pCurrentStateSet = &m_pStateSets[m_dwCurrentHandle];
|
|
m_pCurrentStateSet->m_dwStateSetFlags |= __STATESET_INITIALIZED;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::DeleteStateSet"
|
|
|
|
void CStateSets::DeleteStateSet(CD3DBase *pDevI, DWORD dwHandle)
|
|
{
|
|
if (dwHandle >= m_dwMaxSets)
|
|
{
|
|
D3D_ERR("State block handle is greater than available number of blocks");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
CStateSet *pStateSet = &m_pStateSets[dwHandle];
|
|
if (!(pStateSet->m_dwStateSetFlags & __STATESET_INITIALIZED))
|
|
{
|
|
D3D_ERR("State block is not initialized");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
// Pass delete instruction to the driver only if there was some data recorded
|
|
if (pStateSet->m_dwDeviceHandle != __INVALIDHANDLE)
|
|
pDevI->m_pDDI->InsertStateSetOp(D3DHAL_STATESETDELETE,
|
|
pStateSet->m_dwDeviceHandle,
|
|
(D3DSTATEBLOCKTYPE)0);
|
|
|
|
Cleanup(dwHandle);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::Cleanup"
|
|
|
|
void CStateSets::Cleanup(DWORD dwHandle)
|
|
{
|
|
CStateSet &pStateSet = m_pStateSets[dwHandle];
|
|
m_SetHandles.ReleaseHandle(dwHandle);
|
|
if (pStateSet.m_dwDeviceHandle != __INVALIDHANDLE)
|
|
m_DeviceHandles.ReleaseHandle(pStateSet.m_dwDeviceHandle);
|
|
pStateSet.Release();
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::Capture"
|
|
|
|
void CStateSets::Capture(CD3DBase *pDevI, DWORD dwHandle)
|
|
{
|
|
if (dwHandle >= m_dwMaxSets)
|
|
{
|
|
D3D_ERR("Invalid state block handle");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
CStateSet *pStateSet = &m_pStateSets[dwHandle];
|
|
if (!(pStateSet->m_dwStateSetFlags & __STATESET_INITIALIZED))
|
|
{
|
|
D3D_ERR("State block not initialized");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
pStateSet->Capture(pDevI, TRUE);
|
|
if (pStateSet->m_dwDeviceHandle != __INVALIDHANDLE)
|
|
{
|
|
pStateSet->Capture(pDevI, FALSE);
|
|
pDevI->m_pDDI->InsertStateSetOp(D3DHAL_STATESETCAPTURE,
|
|
pStateSet->m_dwDeviceHandle,
|
|
(D3DSTATEBLOCKTYPE)0);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::CreatePredefined"
|
|
|
|
void CStateSets::CreatePredefined(CD3DBase *pDevI, D3DSTATEBLOCKTYPE sbt)
|
|
{
|
|
if (StartNewSet() != D3D_OK)
|
|
throw E_OUTOFMEMORY;
|
|
m_pCurrentStateSet->CreatePredefined(pDevI, sbt);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
// Allocates device handle if necessary
|
|
// And returns information of the device buffer
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::GetDeviceBufferInfo"
|
|
|
|
void CStateSets::GetDeviceBufferInfo(DWORD* dwStateSetHandle,
|
|
LPVOID *pBuffer,
|
|
DWORD* dwBufferSize)
|
|
{
|
|
if (m_pCurrentStateSet->m_DriverBuffer.m_dwCurrentSize != 0)
|
|
{
|
|
// Allocate a handle for the device
|
|
m_pCurrentStateSet->m_dwDeviceHandle = m_DeviceHandles.CreateNewHandle( NULL );
|
|
if (m_pCurrentStateSet->m_dwDeviceHandle == __INVALIDHANDLE)
|
|
{
|
|
D3D_ERR("Cannot allocate device handle for a state block");
|
|
throw E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
*dwStateSetHandle = m_pCurrentStateSet->m_dwDeviceHandle;
|
|
*pBuffer = (LPVOID)m_pCurrentStateSet->m_DriverBuffer.m_pBuffer;
|
|
*dwBufferSize = m_pCurrentStateSet->m_DriverBuffer.m_dwCurrentSize;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::GetDeviceBufferInfo"
|
|
|
|
void CStateSets::CreateNewDeviceHandle(DWORD* dwStateSetHandle)
|
|
{
|
|
// Allocate a handle for the device
|
|
m_pCurrentStateSet->m_dwDeviceHandle = m_DeviceHandles.CreateNewHandle( NULL );
|
|
if (m_pCurrentStateSet->m_dwDeviceHandle == __INVALIDHANDLE)
|
|
{
|
|
D3D_ERR("Cannot allocate device handle for a state block");
|
|
throw E_OUTOFMEMORY;
|
|
}
|
|
*dwStateSetHandle = m_pCurrentStateSet->m_dwDeviceHandle;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::TranslateDeviceBufferToDX7DDI"
|
|
|
|
void CStateSets::TranslateDeviceBufferToDX7DDI( DWORD* p, DWORD dwSize )
|
|
{
|
|
DWORD* pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_RENDERSTATE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DRENDERSTATETYPE dwState = (D3DRENDERSTATETYPE)*p++;
|
|
DWORD dwValue = *p++;
|
|
}
|
|
}
|
|
break;
|
|
case D3DDP2OP_SETLIGHT:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETLIGHT pData = (LPD3DHAL_DP2SETLIGHT)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETLIGHT));
|
|
switch (pData->dwDataType)
|
|
{
|
|
case D3DHAL_SETLIGHT_ENABLE:
|
|
case D3DHAL_SETLIGHT_DISABLE:
|
|
break;
|
|
case D3DHAL_SETLIGHT_DATA:
|
|
p = (LPDWORD)((LPBYTE)p + sizeof(D3DLIGHT8));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETMATERIAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETMATERIAL));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETTRANSFORM:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETTRANSFORM));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_TEXTURESTAGESTATE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2TEXTURESTAGESTATE pData = (LPD3DHAL_DP2TEXTURESTAGESTATE)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2TEXTURESTAGESTATE));
|
|
|
|
// Map DX8 filter enums to DX6/7 enums
|
|
switch (pData->TSState)
|
|
{
|
|
case D3DTSS_MAGFILTER: pData->dwValue = texf2texfg[min(D3DTEXF_GAUSSIANCUBIC,pData->dwValue)]; break;
|
|
case D3DTSS_MINFILTER: pData->dwValue = texf2texfn[min(D3DTEXF_GAUSSIANCUBIC,pData->dwValue)]; break;
|
|
case D3DTSS_MIPFILTER: pData->dwValue = texf2texfp[min(D3DTEXF_GAUSSIANCUBIC,pData->dwValue)]; break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_VIEWPORTINFO:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2VIEWPORTINFO));
|
|
// The next command has to be D3DDP2OP_ZRANGE
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2ZRANGE));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETCLIPPLANE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETCLIPPLANE));
|
|
}
|
|
break;
|
|
}
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertRenderState"
|
|
|
|
void CStateSets::InsertRenderState(D3DRENDERSTATETYPE state, DWORD dwValue,
|
|
BOOL bDriverCanHandle)
|
|
{
|
|
struct
|
|
{
|
|
D3DRENDERSTATETYPE state;
|
|
DWORD dwValue;
|
|
} data = {state, dwValue};
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_RENDERSTATE,
|
|
&data, sizeof(data),
|
|
!m_bEmulate && bDriverCanHandle);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertLight"
|
|
|
|
void CStateSets::InsertLight(DWORD dwLightIndex, CONST D3DLIGHT8* pData)
|
|
{
|
|
struct
|
|
{
|
|
D3DHAL_DP2SETLIGHT header;
|
|
D3DLIGHT8 light;
|
|
} data;
|
|
data.header.dwIndex = dwLightIndex;
|
|
data.header.dwDataType = D3DHAL_SETLIGHT_DATA;
|
|
data.light= *pData;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETLIGHT, &data, sizeof(data),
|
|
!m_bEmulate && m_bTLHal);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertLightEnable"
|
|
|
|
void CStateSets::InsertLightEnable(DWORD dwLightIndex, BOOL bEnable)
|
|
{
|
|
D3DHAL_DP2SETLIGHT data;
|
|
data.dwIndex = dwLightIndex;
|
|
if (bEnable)
|
|
data.dwDataType = D3DHAL_SETLIGHT_ENABLE;
|
|
else
|
|
data.dwDataType = D3DHAL_SETLIGHT_DISABLE;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETLIGHT, &data, sizeof(data),
|
|
!m_bEmulate && m_bTLHal);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertViewport"
|
|
|
|
void CStateSets::InsertViewport(CONST D3DVIEWPORT8* lpVwpData)
|
|
{
|
|
D3DHAL_DP2VIEWPORTINFO data2;
|
|
data2.dwX = lpVwpData->X;
|
|
data2.dwY = lpVwpData->Y;
|
|
data2.dwWidth = lpVwpData->Width;
|
|
data2.dwHeight = lpVwpData->Height;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_VIEWPORTINFO, &data2, sizeof(data2),
|
|
!m_bEmulate && m_bTLHal);
|
|
|
|
D3DHAL_DP2ZRANGE data1;
|
|
data1.dvMinZ = lpVwpData->MinZ;
|
|
data1.dvMaxZ = lpVwpData->MaxZ;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_ZRANGE, &data1, sizeof(data1),
|
|
!m_bEmulate && m_bTLHal);
|
|
|
|
m_pCurrentStateSet->ResetCurrentCommand();
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertMaterial"
|
|
|
|
void CStateSets::InsertMaterial(CONST D3DMATERIAL8* pData)
|
|
{
|
|
D3DMATERIAL8 mat = *pData;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETMATERIAL,
|
|
&mat,
|
|
sizeof(D3DMATERIAL8),
|
|
!m_bEmulate && m_bTLHal);
|
|
|
|
m_pCurrentStateSet->ResetCurrentCommand();
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertClipPlane"
|
|
|
|
void CStateSets::InsertClipPlane(DWORD dwPlaneIndex,
|
|
CONST D3DVALUE* pPlaneEquation)
|
|
{
|
|
D3DHAL_DP2SETCLIPPLANE data;
|
|
data.dwIndex = dwPlaneIndex;
|
|
data.plane[0] = pPlaneEquation[0];
|
|
data.plane[1] = pPlaneEquation[1];
|
|
data.plane[2] = pPlaneEquation[2];
|
|
data.plane[3] = pPlaneEquation[3];
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETCLIPPLANE,
|
|
&data, sizeof(data),
|
|
!m_bEmulate && m_bTLHal);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertTransform"
|
|
|
|
void CStateSets::InsertTransform(D3DTRANSFORMSTATETYPE state,
|
|
CONST D3DMATRIX* lpMat)
|
|
{
|
|
D3DHAL_DP2SETTRANSFORM data;
|
|
data.xfrmType = state;
|
|
data.matrix = *lpMat;
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETTRANSFORM,
|
|
&data, sizeof(data),
|
|
!m_bEmulate && m_bTLHal);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertTextureStageState"
|
|
|
|
void CStateSets::InsertTextureStageState(DWORD dwStage,
|
|
D3DTEXTURESTAGESTATETYPE type,
|
|
DWORD dwValue)
|
|
{
|
|
D3DHAL_DP2TEXTURESTAGESTATE data = {(WORD)dwStage, type, dwValue};
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_TEXTURESTAGESTATE,
|
|
&data, sizeof(data),
|
|
!m_bEmulate);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertTexture"
|
|
|
|
void CStateSets::InsertTexture(DWORD dwStage, IDirect3DBaseTexture8 *pTex)
|
|
{
|
|
D3DHAL_DP2FRONTENDDATA data = {(WORD)dwStage, pTex};
|
|
|
|
// Up the internal refcount of this texture.
|
|
CBaseTexture *lpTexI = CBaseTexture::SafeCast(pTex);
|
|
if (lpTexI)
|
|
lpTexI->IncrementUseCount();
|
|
|
|
// Only the front-end will parse this instruction
|
|
m_pCurrentStateSet->InsertCommand((D3DHAL_DP2OPERATION)D3DDP2OP_FRONTENDDATA, &data, sizeof(data), FALSE);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertCurrentTexturePalette"
|
|
|
|
void CStateSets::InsertCurrentTexturePalette(DWORD PaletteNumber)
|
|
{
|
|
D3DHAL_DP2FESETPAL data = {PaletteNumber};
|
|
// Only the front-end will parse this instruction
|
|
m_pCurrentStateSet->InsertCommand((D3DHAL_DP2OPERATION)D3DDP2OP_FESETPAL, &data, sizeof(data), FALSE);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertVertexShader"
|
|
|
|
void CStateSets::InsertVertexShader(DWORD dwShaderHandle, BOOL bHardware)
|
|
{
|
|
D3DHAL_DP2VERTEXSHADER data = {dwShaderHandle};
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETVERTEXSHADER,
|
|
&data, sizeof(data),
|
|
!m_bEmulate && m_bHardwareVP &&
|
|
m_bDX8Dev && bHardware);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertPixelShader"
|
|
|
|
void CStateSets::InsertPixelShader(DWORD dwShaderHandle)
|
|
{
|
|
D3DHAL_DP2PIXELSHADER data = {dwShaderHandle};
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETPIXELSHADER,
|
|
&data, sizeof(data),
|
|
!m_bEmulate && m_bDX8Dev);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertStreamSource"
|
|
|
|
void CStateSets::InsertStreamSource(DWORD dwStream, CVertexBuffer *pBuf, DWORD dwStride)
|
|
{
|
|
D3DHAL_DP2FESETVB data = {(WORD)dwStream, pBuf, dwStride};
|
|
// Only the front-end will parse this instruction
|
|
CVertexBuffer* pVB = static_cast<CVertexBuffer*>(pBuf);
|
|
if (pVB)
|
|
pVB->IncrementUseCount();
|
|
|
|
m_pCurrentStateSet->InsertCommand((D3DHAL_DP2OPERATION)D3DDP2OP_FESETVB, &data, sizeof(data), FALSE);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertIndices"
|
|
|
|
void CStateSets::InsertIndices(CIndexBuffer *pBuf, DWORD dwBaseVertex)
|
|
{
|
|
D3DHAL_DP2FESETIB data = {pBuf, dwBaseVertex};
|
|
// Only the front-end will parse this instruction
|
|
CIndexBuffer* pIB = static_cast<CIndexBuffer*>(pBuf);
|
|
if (pIB)
|
|
pIB->IncrementUseCount();
|
|
|
|
m_pCurrentStateSet->InsertCommand((D3DHAL_DP2OPERATION)D3DDP2OP_FESETIB, &data, sizeof(data), FALSE);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertVertexShaderConstant"
|
|
|
|
void CStateSets::InsertVertexShaderConstant(DWORD Register, CONST VOID* pConstantData, DWORD ConstantCount)
|
|
{
|
|
LPVOID pData = new BYTE[sizeof(D3DHAL_DP2SETVERTEXSHADERCONST) + ConstantCount * 16];
|
|
if(pData == 0)
|
|
{
|
|
throw E_OUTOFMEMORY;
|
|
}
|
|
((LPD3DHAL_DP2SETVERTEXSHADERCONST)pData)->dwRegister = Register;
|
|
((LPD3DHAL_DP2SETVERTEXSHADERCONST)pData)->dwCount = ConstantCount;
|
|
memcpy((LPD3DHAL_DP2SETVERTEXSHADERCONST)pData + 1, pConstantData, ConstantCount * 16);
|
|
try
|
|
{
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETVERTEXSHADERCONST,
|
|
pData,
|
|
sizeof(D3DHAL_DP2SETVERTEXSHADERCONST) + ConstantCount * 16,
|
|
!m_bEmulate && m_bDX8Dev && m_bTLHal);
|
|
}
|
|
catch(HRESULT hr)
|
|
{
|
|
delete[] pData;
|
|
throw hr;
|
|
}
|
|
delete[] pData;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::InsertPixelShaderConstant"
|
|
|
|
void CStateSets::InsertPixelShaderConstant(DWORD Register,
|
|
CONST VOID* pConstantData,
|
|
DWORD ConstantCount)
|
|
{
|
|
LPVOID pData = new BYTE[sizeof(D3DHAL_DP2SETPIXELSHADERCONST) + ConstantCount * 16];
|
|
if(pData == 0)
|
|
{
|
|
throw E_OUTOFMEMORY;
|
|
}
|
|
((LPD3DHAL_DP2SETPIXELSHADERCONST)pData)->dwRegister = Register;
|
|
((LPD3DHAL_DP2SETPIXELSHADERCONST)pData)->dwCount = ConstantCount;
|
|
memcpy((LPD3DHAL_DP2SETPIXELSHADERCONST)pData + 1, pConstantData, ConstantCount * 16);
|
|
try
|
|
{
|
|
m_pCurrentStateSet->InsertCommand(D3DDP2OP_SETPIXELSHADERCONST,
|
|
pData,
|
|
sizeof(D3DHAL_DP2SETPIXELSHADERCONST) + ConstantCount * 16,
|
|
!m_bEmulate && m_bDX8Dev);
|
|
}
|
|
catch(HRESULT hr)
|
|
{
|
|
delete[] pData;
|
|
throw hr;
|
|
}
|
|
delete[] pData;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSets::Execute"
|
|
|
|
void CStateSets::Execute(CD3DBase *pDevI, DWORD dwHandle)
|
|
{
|
|
#if DBG
|
|
if (dwHandle >= m_dwMaxSets)
|
|
{
|
|
D3D_ERR("Invalid state block handle");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
#endif
|
|
CStateSet *pStateSet = &m_pStateSets[dwHandle];
|
|
#if DBG
|
|
if (!(pStateSet->m_dwStateSetFlags & __STATESET_INITIALIZED))
|
|
{
|
|
D3D_ERR("State block not initialized");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
#endif
|
|
// Parse recorded data first
|
|
pStateSet->Execute(pDevI, TRUE);
|
|
// If the hardware buffer is not empty, we pass recorded data to it
|
|
if (pStateSet->m_dwDeviceHandle != __INVALIDHANDLE)
|
|
{
|
|
pStateSet->Execute(pDevI, FALSE);
|
|
if((pDevI->m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING) == 0 || (pStateSet->m_dwStateSetFlags & __STATESET_HASONLYVERTEXSTATE) == 0)
|
|
{
|
|
pDevI->m_pDDI->InsertStateSetOp(D3DHAL_STATESETEXECUTE, pStateSet->m_dwDeviceHandle, (D3DSTATEBLOCKTYPE)0);
|
|
}
|
|
else
|
|
{
|
|
pStateSet->m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
}
|
|
}
|
|
}
|
|
//=====================================================================
|
|
// CStateSet interface
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::Release"
|
|
|
|
HRESULT CStateSet::Release()
|
|
{
|
|
if (!(m_dwStateSetFlags & __STATESET_INITIALIZED))
|
|
return D3DERR_INVALIDCALL;
|
|
m_dwStateSetFlags &= ~__STATESET_INITIALIZED;
|
|
|
|
// Parse the FEOnly buffer and release all the VB/IB/Texture handles.
|
|
DWORD *p;
|
|
DWORD dwSize;
|
|
DWORD *pEnd;
|
|
|
|
p = (DWORD*)m_FEOnlyBuffer.m_pBuffer;
|
|
dwSize = m_FEOnlyBuffer.m_dwCurrentSize;
|
|
pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_RENDERSTATE:
|
|
p = (DWORD *)((D3DHAL_DP2RENDERSTATE *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_SETLIGHT:
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETLIGHT pData = (LPD3DHAL_DP2SETLIGHT)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETLIGHT));
|
|
switch (pData->dwDataType)
|
|
{
|
|
case D3DHAL_SETLIGHT_ENABLE:
|
|
case D3DHAL_SETLIGHT_DISABLE:
|
|
break;
|
|
case D3DHAL_SETLIGHT_DATA:
|
|
p = (DWORD *)((BYTE *)p + sizeof(D3DLIGHT8));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case D3DDP2OP_SETMATERIAL:
|
|
p = (DWORD *)((D3DHAL_DP2SETMATERIAL *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_SETTRANSFORM:
|
|
p = (DWORD *)((D3DHAL_DP2SETTRANSFORM *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_TEXTURESTAGESTATE:
|
|
p = (DWORD *)((D3DHAL_DP2TEXTURESTAGESTATE *)p +
|
|
pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
{
|
|
CBaseTexture* pTexOld = NULL;
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FRONTENDDATA pData = (LPD3DHAL_DP2FRONTENDDATA)p;
|
|
pTexOld = CBaseTexture::SafeCast(pData->pTexture);
|
|
if( pTexOld )
|
|
pTexOld->DecrementUseCount();
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FRONTENDDATA));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETVB:
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETVB pData = (LPD3DHAL_DP2FESETVB)p;
|
|
if( pData->pBuf )
|
|
pData->pBuf->DecrementUseCount();
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETVB));
|
|
}
|
|
break;
|
|
case D3DDP2OP_FESETIB:
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETIB pData = (LPD3DHAL_DP2FESETIB)p;
|
|
if( pData->pBuf )
|
|
pData->pBuf->DecrementUseCount();
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETIB));
|
|
}
|
|
break;
|
|
case D3DDP2OP_FESETPAL:
|
|
p = (DWORD *)((D3DHAL_DP2FESETPAL *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_VIEWPORTINFO:
|
|
// The next command has to be D3DDP2OP_ZRANGE
|
|
p = (DWORD *)((BYTE *)p +
|
|
( sizeof(D3DHAL_DP2VIEWPORTINFO) +
|
|
sizeof(D3DHAL_DP2COMMAND) +
|
|
sizeof(D3DHAL_DP2ZRANGE ) ) *
|
|
pCommand->wStateCount );
|
|
break;
|
|
case D3DDP2OP_SETCLIPPLANE:
|
|
p = (DWORD *)((D3DHAL_DP2SETCLIPPLANE *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_SETVERTEXSHADER:
|
|
p = (DWORD *)((D3DHAL_DP2VERTEXSHADER *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_SETPIXELSHADER:
|
|
p = (DWORD *)((D3DHAL_DP2PIXELSHADER *)p + pCommand->wStateCount);
|
|
break;
|
|
case D3DDP2OP_SETVERTEXSHADERCONST:
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETVERTEXSHADERCONST pData = (LPD3DHAL_DP2SETVERTEXSHADERCONST)p;
|
|
p = (DWORD*)((BYTE*)p +
|
|
sizeof(D3DHAL_DP2SETVERTEXSHADERCONST) +
|
|
pData->dwCount * 16);
|
|
|
|
}
|
|
break;
|
|
case D3DDP2OP_SETPIXELSHADERCONST:
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETPIXELSHADERCONST pData = (LPD3DHAL_DP2SETPIXELSHADERCONST)p;
|
|
p = (DWORD*)((BYTE*)p +
|
|
sizeof(D3DHAL_DP2SETPIXELSHADERCONST) +
|
|
pData->dwCount * 16);
|
|
}
|
|
break;
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
m_FEOnlyBuffer.Reset();
|
|
m_DriverBuffer.Reset();
|
|
return D3D_OK;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::InsertCommand"
|
|
|
|
void CStateSet::InsertCommand(D3DHAL_DP2OPERATION op, LPVOID pData,
|
|
DWORD dwDataSize,
|
|
BOOL bDriverCanHandle)
|
|
{
|
|
if (op == D3DDP2OP_TEXTURESTAGESTATE ||
|
|
(op == D3DDP2OP_RENDERSTATE &&
|
|
((LPD3DHAL_DP2RENDERSTATE)pData)->RenderState >= D3DRENDERSTATE_WRAP0 &&
|
|
((LPD3DHAL_DP2RENDERSTATE)pData)->RenderState <= D3DRENDERSTATE_WRAP7))
|
|
{
|
|
m_dwStateSetFlags |= __STATESET_NEEDCHECKREMAPPING;
|
|
}
|
|
if (bDriverCanHandle)
|
|
m_DriverBuffer.InsertCommand(op, pData, dwDataSize);
|
|
else
|
|
m_FEOnlyBuffer.InsertCommand(op, pData, dwDataSize);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::Execute"
|
|
|
|
void CStateSet::Execute(CD3DBase *pBaseDev, BOOL bFrontEndBuffer)
|
|
{
|
|
DWORD *p;
|
|
DWORD dwSize;
|
|
DWORD *pEnd;
|
|
// The device is not pure, so we can cast
|
|
DXGASSERT((pBaseDev->BehaviorFlags() & D3DCREATE_PUREDEVICE) == 0);
|
|
CD3DHal *pDevI = static_cast<CD3DHal*>(pBaseDev);
|
|
D3DFE_PROCESSVERTICES* pv = pDevI->m_pv;
|
|
try
|
|
{
|
|
// Texture stages could be re-mapped during texture transform processing.
|
|
// Before we set new values we have to restore original ones
|
|
if (pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES &&
|
|
m_dwStateSetFlags & __STATESET_NEEDCHECKREMAPPING)
|
|
{
|
|
RestoreTextureStages(pDevI);
|
|
pDevI->ForceFVFRecompute();
|
|
}
|
|
|
|
if (bFrontEndBuffer)
|
|
{
|
|
p = (DWORD*)m_FEOnlyBuffer.m_pBuffer;
|
|
dwSize = m_FEOnlyBuffer.m_dwCurrentSize;
|
|
}
|
|
else
|
|
{
|
|
p = (DWORD*)m_DriverBuffer.m_pBuffer;
|
|
dwSize = m_DriverBuffer.m_dwCurrentSize;
|
|
pDevI->m_dwRuntimeFlags |= D3DRT_EXECUTESTATEMODE;
|
|
m_dwStateSetFlags |= __STATESET_HASONLYVERTEXSTATE;
|
|
}
|
|
pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_RENDERSTATE:
|
|
{
|
|
if(pDevI->m_dwRuntimeFlags & D3DRT_EXECUTESTATEMODE)
|
|
{
|
|
m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DRENDERSTATETYPE dwState = (D3DRENDERSTATETYPE)*p++;
|
|
DWORD dwValue = *p++;
|
|
if ( (pDevI->rstates[dwState] != dwValue)
|
|
#if DBG
|
|
&& (dwState != D3DRS_DEBUGMONITORTOKEN) // don't filter these
|
|
#endif
|
|
)
|
|
{
|
|
if (!pDevI->rsVec.IsBitSet(dwState))
|
|
{ // Fast path. We do not need any processing done in UpdateInternalState other than updating rstates array
|
|
pDevI->rstates[dwState] = dwValue;
|
|
}
|
|
else
|
|
{
|
|
pDevI->UpdateInternalState(dwState, dwValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3D_WARN(4,"Ignoring redundant SetRenderState %d", dwState);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DRENDERSTATETYPE dwState = (D3DRENDERSTATETYPE)*p++;
|
|
DWORD dwValue = *p++;
|
|
if ( (pDevI->rstates[dwState] != dwValue)
|
|
#if DBG
|
|
&& (dwState != D3DRS_DEBUGMONITORTOKEN) // don't filter these
|
|
#endif
|
|
)
|
|
{
|
|
if (!pDevI->rsVec.IsBitSet(dwState))
|
|
{ // Fast path. We do not need any processing done in UpdateInternalState other than updating rstates array
|
|
pDevI->rstates[dwState] = dwValue;
|
|
|
|
pDevI->m_pDDI->SetRenderState(dwState, dwValue);
|
|
}
|
|
else
|
|
{
|
|
pDevI->UpdateInternalState(dwState, dwValue);
|
|
// Vertex processing only render states will be passed to the
|
|
// driver when we switch to the hardware vertex processing mode
|
|
if ((!(pDevI->rsVertexProcessingOnly.IsBitSet(dwState) &&
|
|
pDevI->m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)))
|
|
{
|
|
if (pDevI->CanHandleRenderState(dwState))
|
|
{
|
|
pDevI->m_pDDI->SetRenderState(dwState, dwValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3D_WARN(4,"Ignoring redundant SetRenderState %d", dwState);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETLIGHT:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETLIGHT pData = (LPD3DHAL_DP2SETLIGHT)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETLIGHT));
|
|
switch (pData->dwDataType)
|
|
{
|
|
case D3DHAL_SETLIGHT_ENABLE:
|
|
pDevI->LightEnableI( pData->dwIndex, TRUE );
|
|
break;
|
|
case D3DHAL_SETLIGHT_DISABLE:
|
|
pDevI->LightEnableI( pData->dwIndex, FALSE );
|
|
break;
|
|
case D3DHAL_SETLIGHT_DATA:
|
|
pDevI->SetLightI(pData->dwIndex, (D3DLIGHT8 *)p);
|
|
p = (LPDWORD)((LPBYTE)p + sizeof(D3DLIGHT8));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETMATERIAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETMATERIAL pData = (LPD3DHAL_DP2SETMATERIAL)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETMATERIAL));
|
|
pDevI->SetMaterialFast((D3DMATERIAL8*)pData);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETTRANSFORM:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DHAL_DP2SETTRANSFORM *pData = (D3DHAL_DP2SETTRANSFORM*)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETTRANSFORM));
|
|
pDevI->SetTransformI(pData->xfrmType, &pData->matrix);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_TEXTURESTAGESTATE:
|
|
{
|
|
if (pDevI->m_dwRuntimeFlags & D3DRT_EXECUTESTATEMODE)
|
|
{
|
|
m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2TEXTURESTAGESTATE pData = (LPD3DHAL_DP2TEXTURESTAGESTATE)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2TEXTURESTAGESTATE));
|
|
DWORD dwStage = pData->wStage;
|
|
DWORD dwState = pData->TSState;
|
|
DWORD dwValue = pData->dwValue;
|
|
if (pDevI->tsstates[dwStage][dwState] != dwValue)
|
|
{
|
|
// Fast path. We do not need any processing done in UpdateInternalTSS other than updating tsstates array
|
|
if (pDevI->NeedInternalTSSUpdate(dwState))
|
|
{
|
|
pDevI->UpdateInternalTextureStageState(dwStage, (D3DTEXTURESTAGESTATETYPE)dwState, &dwValue);
|
|
}
|
|
else
|
|
{
|
|
pDevI->tsstates[dwStage][dwState] = dwValue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3D_WARN(4,"Ignoring redundant SetTextureStageState Stage: %d, State: %d", dwStage, dwState);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2TEXTURESTAGESTATE pData = (LPD3DHAL_DP2TEXTURESTAGESTATE)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2TEXTURESTAGESTATE));
|
|
DWORD dwStage = pData->wStage;
|
|
DWORD dwState = pData->TSState;
|
|
DWORD dwValue = pData->dwValue;
|
|
if (pDevI->tsstates[dwStage][dwState] != dwValue)
|
|
{
|
|
// Fast path. We do not need any processing done in UpdateInternalTSS other than updating tsstates array
|
|
if (pDevI->NeedInternalTSSUpdate(dwState))
|
|
{
|
|
if(pDevI->UpdateInternalTextureStageState(dwStage, (D3DTEXTURESTAGESTATETYPE)dwState, &dwValue))
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
pDevI->tsstates[dwStage][dwState] = dwValue;
|
|
}
|
|
if (dwStage >= pDevI->m_dwMaxTextureBlendStages)
|
|
continue;
|
|
pDevI->m_pDDI->SetTSS(dwStage, (D3DTEXTURESTAGESTATETYPE)dwState, dwValue);
|
|
}
|
|
else
|
|
{
|
|
D3D_WARN(4,"Ignoring redundant SetTextureStageState Stage: %d, State: %d", dwStage, dwState);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FRONTENDDATA pData = (LPD3DHAL_DP2FRONTENDDATA)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FRONTENDDATA));
|
|
HRESULT ret = pDevI->SetTexture(pData->wStage, pData->pTexture);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETVB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETVB pData = (LPD3DHAL_DP2FESETVB)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETVB));
|
|
HRESULT ret = pDevI->SetStreamSource(pData->wStream, pData->pBuf, pData->dwStride);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETIB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETIB pData = (LPD3DHAL_DP2FESETIB)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETIB));
|
|
HRESULT ret = pDevI->SetIndices(pData->pBuf, pData->dwBase);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETPAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETPAL pData = (LPD3DHAL_DP2FESETPAL)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETPAL));
|
|
if( pData->dwPaletteNumber != __INVALIDPALETTE )
|
|
{
|
|
HRESULT ret = pDevI->SetCurrentTexturePalette(pData->dwPaletteNumber);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_VIEWPORTINFO:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DVIEWPORT8 viewport;
|
|
LPD3DHAL_DP2VIEWPORTINFO lpVwpData = (LPD3DHAL_DP2VIEWPORTINFO)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2VIEWPORTINFO));
|
|
viewport.X = lpVwpData->dwX;
|
|
viewport.Y = lpVwpData->dwY;
|
|
viewport.Width = lpVwpData->dwWidth;
|
|
viewport.Height = lpVwpData->dwHeight;
|
|
|
|
// The next command has to be D3DDP2OP_ZRANGE
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
LPD3DHAL_DP2ZRANGE pData = (LPD3DHAL_DP2ZRANGE)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2ZRANGE));
|
|
viewport.MinZ = pData->dvMinZ;
|
|
viewport.MaxZ = pData->dvMaxZ;
|
|
|
|
pDevI->SetViewportI(&viewport);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETCLIPPLANE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DHAL_DP2SETCLIPPLANE *pData = (D3DHAL_DP2SETCLIPPLANE*)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETCLIPPLANE));
|
|
pDevI->SetClipPlaneI(pData->dwIndex, pData->plane);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETVERTEXSHADER:
|
|
{
|
|
// Optimization, dont loop, use the last one.
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2VERTEXSHADER pData = (LPD3DHAL_DP2VERTEXSHADER)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2VERTEXSHADER));
|
|
if( pData->dwHandle != 0 )
|
|
{
|
|
pDevI->SetVertexShader(pData->dwHandle);
|
|
}
|
|
else
|
|
{
|
|
pDevI->m_dwCurrentShaderHandle = 0;
|
|
}
|
|
}
|
|
pDevI->m_pDDI->ResetVertexShader();
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETPIXELSHADER:
|
|
{
|
|
m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2PIXELSHADER pData = (LPD3DHAL_DP2PIXELSHADER)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2PIXELSHADER));
|
|
pDevI->SetPixelShaderFast(pData->dwHandle);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETVERTEXSHADERCONST:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETVERTEXSHADERCONST pData = (LPD3DHAL_DP2SETVERTEXSHADERCONST)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETVERTEXSHADERCONST) + pData->dwCount * 16);
|
|
pDevI->SetVertexShaderConstantI(pData->dwRegister, pData + 1, pData->dwCount);
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETPIXELSHADERCONST:
|
|
{
|
|
m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETPIXELSHADERCONST pData = (LPD3DHAL_DP2SETPIXELSHADERCONST)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETPIXELSHADERCONST) + pData->dwCount * 16);
|
|
pDevI->SetPixelShaderConstantFast(pData->dwRegister, pData + 1, pData->dwCount);
|
|
}
|
|
break;
|
|
}
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
pDevI->m_dwRuntimeFlags &= ~D3DRT_EXECUTESTATEMODE;
|
|
}
|
|
catch(HRESULT ret)
|
|
{
|
|
pDevI->m_dwRuntimeFlags &= ~D3DRT_EXECUTESTATEMODE;
|
|
m_dwStateSetFlags &= ~__STATESET_HASONLYVERTEXSTATE;
|
|
throw ret;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::Capture"
|
|
|
|
void CStateSet::Capture(CD3DBase *pBaseDev, BOOL bFrontEndBuffer)
|
|
{
|
|
DWORD *p;
|
|
DWORD dwSize;
|
|
DWORD *pEnd;
|
|
// The device is not pure, so we can cast
|
|
DXGASSERT((pBaseDev->BehaviorFlags() & D3DCREATE_PUREDEVICE) == 0);
|
|
CD3DHal *pDevI = static_cast<CD3DHal*>(pBaseDev);
|
|
D3DFE_PROCESSVERTICES* pv = pDevI->m_pv;
|
|
// Texture coordinate indices must be restored before capturing, because
|
|
// we do not call GetTextureStageState but access tsstates directly
|
|
if (pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
RestoreTextureStages(pDevI);
|
|
pDevI->ForceFVFRecompute();
|
|
}
|
|
if (bFrontEndBuffer)
|
|
{
|
|
p = (DWORD*)m_FEOnlyBuffer.m_pBuffer;
|
|
dwSize = m_FEOnlyBuffer.m_dwCurrentSize;
|
|
}
|
|
else
|
|
{
|
|
p = (DWORD*)m_DriverBuffer.m_pBuffer;
|
|
dwSize = m_DriverBuffer.m_dwCurrentSize;
|
|
}
|
|
pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_RENDERSTATE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
const D3DRENDERSTATETYPE state = (D3DRENDERSTATETYPE)*p++;
|
|
*p++ = pDevI->rstates[state];
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETLIGHT:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETLIGHT pData = (LPD3DHAL_DP2SETLIGHT)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETLIGHT));
|
|
LPDIRECT3DLIGHTI pLight =
|
|
static_cast<DIRECT3DLIGHTI *>
|
|
((*pDevI->m_pLightArray)[pData->dwIndex].m_pObj);
|
|
if(pData->dwIndex >= pDevI->m_pLightArray->GetSize())
|
|
{
|
|
D3D_ERR("Unable to capture light state (light not set?)");
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
switch (pData->dwDataType)
|
|
{
|
|
case D3DHAL_SETLIGHT_ENABLE:
|
|
if(!pLight->Enabled())
|
|
pData->dwDataType = D3DHAL_SETLIGHT_DISABLE;
|
|
break;
|
|
case D3DHAL_SETLIGHT_DISABLE:
|
|
if(pLight->Enabled())
|
|
pData->dwDataType = D3DHAL_SETLIGHT_ENABLE;
|
|
break;
|
|
case D3DHAL_SETLIGHT_DATA:
|
|
*((D3DLIGHT8*)p) = pLight->m_Light;
|
|
p = (LPDWORD)((LPBYTE)p + sizeof(D3DLIGHT8));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETMATERIAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETMATERIAL pData = (LPD3DHAL_DP2SETMATERIAL)p;
|
|
*pData = *((LPD3DHAL_DP2SETMATERIAL)&pv->lighting.material);
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETMATERIAL));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETTRANSFORM:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETTRANSFORM pData = (LPD3DHAL_DP2SETTRANSFORM)p;
|
|
DWORD state = pData->xfrmType;
|
|
if ((DWORD)state >= __WORLDMATRIXBASE &&
|
|
(DWORD)state < __WORLDMATRIXBASE + __MAXWORLDMATRICES)
|
|
{
|
|
UINT index = (DWORD)state - __WORLDMATRIXBASE;
|
|
pData->matrix = *((LPD3DMATRIX)&pv->world[index]);
|
|
}
|
|
else
|
|
switch(pData->xfrmType)
|
|
{
|
|
case D3DTRANSFORMSTATE_VIEW:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->view);
|
|
break;
|
|
case D3DTRANSFORMSTATE_PROJECTION:
|
|
pData->matrix = *((LPD3DMATRIX)&pDevI->transform.proj);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE0:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[0]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE1:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[1]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE2:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[2]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE3:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[3]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE4:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[4]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE5:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[5]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE6:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[6]);
|
|
break;
|
|
case D3DTRANSFORMSTATE_TEXTURE7:
|
|
pData->matrix = *((LPD3DMATRIX)&pv->mTexture[7]);
|
|
break;
|
|
}
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETTRANSFORM));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_TEXTURESTAGESTATE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2TEXTURESTAGESTATE pData = (LPD3DHAL_DP2TEXTURESTAGESTATE)p;
|
|
pData->dwValue = pDevI->tsstates[pData->wStage][pData->TSState];
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2TEXTURESTAGESTATE));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
{
|
|
CBaseTexture* pTexOld = NULL;
|
|
CBaseTexture* pTexNew = NULL;
|
|
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FRONTENDDATA pData = (LPD3DHAL_DP2FRONTENDDATA)p;
|
|
pTexOld = CBaseTexture::SafeCast(pData->pTexture);
|
|
if( pTexOld )
|
|
pTexOld->DecrementUseCount();
|
|
pTexNew = pDevI->m_lpD3DMappedTexI[pData->wStage];
|
|
if( pTexNew )
|
|
pTexNew->IncrementUseCount();
|
|
if (pDevI->m_lpD3DMappedTexI[pData->wStage] != 0)
|
|
{
|
|
switch(pDevI->m_lpD3DMappedTexI[pData->wStage]->GetBufferDesc()->Type)
|
|
{
|
|
case D3DRTYPE_TEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DTexture8*>(static_cast<CMipMap*>(pTexNew));
|
|
break;
|
|
case D3DRTYPE_CUBETEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DCubeTexture8*>(static_cast<CCubeMap*>(pTexNew));
|
|
break;
|
|
case D3DRTYPE_VOLUMETEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DVolumeTexture8*>(static_cast<CMipVolume*>(pTexNew));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pData->pTexture = 0;
|
|
}
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FRONTENDDATA));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETVB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETVB pData = (LPD3DHAL_DP2FESETVB)p;
|
|
if( pData->pBuf )
|
|
pData->pBuf->DecrementUseCount();
|
|
pData->pBuf = pDevI->m_pStream[pData->wStream].m_pVB;
|
|
if( pData->pBuf )
|
|
pData->pBuf->IncrementUseCount();
|
|
pData->dwStride = pDevI->m_pStream[pData->wStream].m_dwStride;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETVB));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETIB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETIB pData = (LPD3DHAL_DP2FESETIB)p;
|
|
if( pData->pBuf )
|
|
pData->pBuf->DecrementUseCount();
|
|
pData->pBuf = pDevI->m_pIndexStream->m_pVBI;
|
|
if( pData->pBuf )
|
|
pData->pBuf->IncrementUseCount();
|
|
pData->dwBase = pDevI->m_pIndexStream->m_dwBaseIndex;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETIB));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETPAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETPAL pData = (LPD3DHAL_DP2FESETPAL)p;
|
|
pData->dwPaletteNumber = pDevI->m_dwPalette;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETPAL));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_VIEWPORTINFO:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
D3DVIEWPORT8 viewport;
|
|
LPD3DHAL_DP2VIEWPORTINFO lpVwpData = (LPD3DHAL_DP2VIEWPORTINFO)p;
|
|
lpVwpData->dwX = pDevI->m_Viewport.X;
|
|
lpVwpData->dwY = pDevI->m_Viewport.Y;
|
|
lpVwpData->dwWidth = pDevI->m_Viewport.Width;
|
|
lpVwpData->dwHeight = pDevI->m_Viewport.Height;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2VIEWPORTINFO));
|
|
// The next command has to be D3DDP2OP_ZRANGE
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
LPD3DHAL_DP2ZRANGE pData = (LPD3DHAL_DP2ZRANGE)p;
|
|
pData->dvMinZ = pDevI->m_Viewport.MinZ;
|
|
pData->dvMaxZ = pDevI->m_Viewport.MaxZ;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2ZRANGE));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETCLIPPLANE:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETCLIPPLANE pData = (LPD3DHAL_DP2SETCLIPPLANE)p;
|
|
*((LPD3DVECTORH)pData->plane) = pDevI->transform.userClipPlane[pData->dwIndex];
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETCLIPPLANE));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETVERTEXSHADER:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2VERTEXSHADER pData = (LPD3DHAL_DP2VERTEXSHADER)p;
|
|
pData->dwHandle = pDevI->m_dwCurrentShaderHandle;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2VERTEXSHADER));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETPIXELSHADER:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2PIXELSHADER pData = (LPD3DHAL_DP2PIXELSHADER)p;
|
|
pData->dwHandle = pDevI->m_dwCurrentPixelShaderHandle;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2PIXELSHADER));
|
|
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETVERTEXSHADERCONST:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETVERTEXSHADERCONST pData = (LPD3DHAL_DP2SETVERTEXSHADERCONST)p;
|
|
pDevI->m_pv->pGeometryFuncs->GetShaderConstants(pData->dwRegister, pData->dwCount, pData + 1);
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETVERTEXSHADERCONST) + pData->dwCount * 16);
|
|
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_SETPIXELSHADERCONST:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2SETPIXELSHADERCONST pData = (LPD3DHAL_DP2SETPIXELSHADERCONST)p;
|
|
pDevI->GetPixelShaderConstantI(pData->dwRegister,
|
|
pData->dwCount,
|
|
pData + 1);
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2SETPIXELSHADERCONST) + pData->dwCount * 16);
|
|
}
|
|
break;
|
|
}
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSet::CreatePredefined"
|
|
|
|
void CStateSet::CreatePredefined(CD3DBase *pBaseDev, D3DSTATEBLOCKTYPE sbt)
|
|
{
|
|
static D3DRENDERSTATETYPE ALLrstates[] =
|
|
{
|
|
D3DRENDERSTATE_SPECULARENABLE,
|
|
D3DRENDERSTATE_ZENABLE,
|
|
D3DRENDERSTATE_FILLMODE,
|
|
D3DRENDERSTATE_SHADEMODE,
|
|
D3DRENDERSTATE_LINEPATTERN,
|
|
D3DRENDERSTATE_ZWRITEENABLE,
|
|
D3DRENDERSTATE_ALPHATESTENABLE,
|
|
D3DRENDERSTATE_LASTPIXEL,
|
|
D3DRENDERSTATE_SRCBLEND,
|
|
D3DRENDERSTATE_DESTBLEND,
|
|
D3DRENDERSTATE_CULLMODE,
|
|
D3DRENDERSTATE_ZFUNC,
|
|
D3DRENDERSTATE_ALPHAREF,
|
|
D3DRENDERSTATE_ALPHAFUNC,
|
|
D3DRENDERSTATE_DITHERENABLE,
|
|
D3DRENDERSTATE_FOGENABLE,
|
|
D3DRENDERSTATE_STIPPLEDALPHA,
|
|
D3DRENDERSTATE_FOGCOLOR,
|
|
D3DRENDERSTATE_FOGTABLEMODE,
|
|
D3DRENDERSTATE_FOGSTART,
|
|
D3DRENDERSTATE_FOGEND,
|
|
D3DRENDERSTATE_FOGDENSITY,
|
|
D3DRENDERSTATE_EDGEANTIALIAS,
|
|
D3DRENDERSTATE_ALPHABLENDENABLE,
|
|
D3DRENDERSTATE_ZBIAS,
|
|
D3DRENDERSTATE_RANGEFOGENABLE,
|
|
D3DRENDERSTATE_STENCILENABLE,
|
|
D3DRENDERSTATE_STENCILFAIL,
|
|
D3DRENDERSTATE_STENCILZFAIL,
|
|
D3DRENDERSTATE_STENCILPASS,
|
|
D3DRENDERSTATE_STENCILFUNC,
|
|
D3DRENDERSTATE_STENCILREF,
|
|
D3DRENDERSTATE_STENCILMASK,
|
|
D3DRENDERSTATE_STENCILWRITEMASK,
|
|
D3DRENDERSTATE_TEXTUREFACTOR,
|
|
D3DRENDERSTATE_WRAP0,
|
|
D3DRENDERSTATE_WRAP1,
|
|
D3DRENDERSTATE_WRAP2,
|
|
D3DRENDERSTATE_WRAP3,
|
|
D3DRENDERSTATE_WRAP4,
|
|
D3DRENDERSTATE_WRAP5,
|
|
D3DRENDERSTATE_WRAP6,
|
|
D3DRENDERSTATE_WRAP7,
|
|
D3DRENDERSTATE_AMBIENT,
|
|
D3DRENDERSTATE_COLORVERTEX,
|
|
D3DRENDERSTATE_FOGVERTEXMODE,
|
|
D3DRENDERSTATE_CLIPPING,
|
|
D3DRENDERSTATE_LIGHTING,
|
|
D3DRENDERSTATE_NORMALIZENORMALS,
|
|
D3DRENDERSTATE_LOCALVIEWER,
|
|
D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,
|
|
D3DRENDERSTATE_AMBIENTMATERIALSOURCE,
|
|
D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,
|
|
D3DRENDERSTATE_SPECULARMATERIALSOURCE,
|
|
D3DRENDERSTATE_VERTEXBLEND,
|
|
D3DRENDERSTATE_CLIPPLANEENABLE,
|
|
D3DRS_SOFTWAREVERTEXPROCESSING,
|
|
D3DRS_POINTSIZE,
|
|
D3DRS_POINTSIZE_MIN,
|
|
D3DRS_POINTSPRITEENABLE,
|
|
D3DRS_POINTSCALEENABLE,
|
|
D3DRS_POINTSCALE_A,
|
|
D3DRS_POINTSCALE_B,
|
|
D3DRS_POINTSCALE_C,
|
|
D3DRS_MULTISAMPLEANTIALIAS,
|
|
D3DRS_MULTISAMPLEMASK,
|
|
D3DRS_PATCHEDGESTYLE,
|
|
D3DRS_PATCHSEGMENTS,
|
|
D3DRS_POINTSIZE_MAX,
|
|
D3DRS_INDEXEDVERTEXBLENDENABLE,
|
|
D3DRS_COLORWRITEENABLE,
|
|
D3DRS_TWEENFACTOR,
|
|
D3DRS_BLENDOP,
|
|
D3DRS_POSITIONORDER,
|
|
D3DRS_NORMALORDER,
|
|
};
|
|
static D3DTEXTURESTAGESTATETYPE ALLtsstates[] =
|
|
{
|
|
D3DTSS_COLOROP,
|
|
D3DTSS_COLORARG1,
|
|
D3DTSS_COLORARG2,
|
|
D3DTSS_ALPHAOP,
|
|
D3DTSS_ALPHAARG1,
|
|
D3DTSS_ALPHAARG2,
|
|
D3DTSS_BUMPENVMAT00,
|
|
D3DTSS_BUMPENVMAT01,
|
|
D3DTSS_BUMPENVMAT10,
|
|
D3DTSS_BUMPENVMAT11,
|
|
D3DTSS_TEXCOORDINDEX,
|
|
D3DTSS_ADDRESSU,
|
|
D3DTSS_ADDRESSV,
|
|
D3DTSS_BORDERCOLOR,
|
|
D3DTSS_MAGFILTER,
|
|
D3DTSS_MINFILTER,
|
|
D3DTSS_MIPFILTER,
|
|
D3DTSS_MIPMAPLODBIAS,
|
|
D3DTSS_MAXMIPLEVEL,
|
|
D3DTSS_MAXANISOTROPY,
|
|
D3DTSS_BUMPENVLSCALE,
|
|
D3DTSS_BUMPENVLOFFSET,
|
|
D3DTSS_TEXTURETRANSFORMFLAGS,
|
|
D3DTSS_ADDRESSW,
|
|
D3DTSS_COLORARG0,
|
|
D3DTSS_ALPHAARG0,
|
|
D3DTSS_RESULTARG,
|
|
};
|
|
static D3DRENDERSTATETYPE PIXELrstates[] =
|
|
{
|
|
D3DRENDERSTATE_ZENABLE,
|
|
D3DRENDERSTATE_FILLMODE,
|
|
D3DRENDERSTATE_SHADEMODE,
|
|
D3DRENDERSTATE_LINEPATTERN,
|
|
D3DRENDERSTATE_ZWRITEENABLE,
|
|
D3DRENDERSTATE_ALPHATESTENABLE,
|
|
D3DRENDERSTATE_LASTPIXEL,
|
|
D3DRENDERSTATE_SRCBLEND,
|
|
D3DRENDERSTATE_DESTBLEND,
|
|
D3DRENDERSTATE_ZFUNC,
|
|
D3DRENDERSTATE_ALPHAREF,
|
|
D3DRENDERSTATE_ALPHAFUNC,
|
|
D3DRENDERSTATE_DITHERENABLE,
|
|
D3DRENDERSTATE_STIPPLEDALPHA,
|
|
D3DRENDERSTATE_FOGSTART,
|
|
D3DRENDERSTATE_FOGEND,
|
|
D3DRENDERSTATE_FOGDENSITY,
|
|
D3DRENDERSTATE_EDGEANTIALIAS,
|
|
D3DRENDERSTATE_ALPHABLENDENABLE,
|
|
D3DRENDERSTATE_ZBIAS,
|
|
D3DRENDERSTATE_STENCILENABLE,
|
|
D3DRENDERSTATE_STENCILFAIL,
|
|
D3DRENDERSTATE_STENCILZFAIL,
|
|
D3DRENDERSTATE_STENCILPASS,
|
|
D3DRENDERSTATE_STENCILFUNC,
|
|
D3DRENDERSTATE_STENCILREF,
|
|
D3DRENDERSTATE_STENCILMASK,
|
|
D3DRENDERSTATE_STENCILWRITEMASK,
|
|
D3DRENDERSTATE_TEXTUREFACTOR,
|
|
D3DRENDERSTATE_WRAP0,
|
|
D3DRENDERSTATE_WRAP1,
|
|
D3DRENDERSTATE_WRAP2,
|
|
D3DRENDERSTATE_WRAP3,
|
|
D3DRENDERSTATE_WRAP4,
|
|
D3DRENDERSTATE_WRAP5,
|
|
D3DRENDERSTATE_WRAP6,
|
|
D3DRENDERSTATE_WRAP7,
|
|
D3DRS_COLORWRITEENABLE,
|
|
D3DRS_BLENDOP,
|
|
};
|
|
static D3DTEXTURESTAGESTATETYPE PIXELtsstates[] =
|
|
{
|
|
D3DTSS_COLOROP,
|
|
D3DTSS_COLORARG1,
|
|
D3DTSS_COLORARG2,
|
|
D3DTSS_ALPHAOP,
|
|
D3DTSS_ALPHAARG1,
|
|
D3DTSS_ALPHAARG2,
|
|
D3DTSS_BUMPENVMAT00,
|
|
D3DTSS_BUMPENVMAT01,
|
|
D3DTSS_BUMPENVMAT10,
|
|
D3DTSS_BUMPENVMAT11,
|
|
D3DTSS_TEXCOORDINDEX,
|
|
D3DTSS_ADDRESSU,
|
|
D3DTSS_ADDRESSV,
|
|
D3DTSS_BORDERCOLOR,
|
|
D3DTSS_MAGFILTER,
|
|
D3DTSS_MINFILTER,
|
|
D3DTSS_MIPFILTER,
|
|
D3DTSS_MIPMAPLODBIAS,
|
|
D3DTSS_MAXMIPLEVEL,
|
|
D3DTSS_MAXANISOTROPY,
|
|
D3DTSS_BUMPENVLSCALE,
|
|
D3DTSS_BUMPENVLOFFSET,
|
|
D3DTSS_TEXTURETRANSFORMFLAGS,
|
|
D3DTSS_ADDRESSW,
|
|
D3DTSS_COLORARG0,
|
|
D3DTSS_ALPHAARG0,
|
|
D3DTSS_RESULTARG,
|
|
};
|
|
static D3DRENDERSTATETYPE VERTEXrstates[] =
|
|
{
|
|
D3DRENDERSTATE_SHADEMODE,
|
|
D3DRENDERSTATE_SPECULARENABLE,
|
|
D3DRENDERSTATE_CULLMODE,
|
|
D3DRENDERSTATE_FOGENABLE,
|
|
D3DRENDERSTATE_FOGCOLOR,
|
|
D3DRENDERSTATE_FOGTABLEMODE,
|
|
D3DRENDERSTATE_FOGSTART,
|
|
D3DRENDERSTATE_FOGEND,
|
|
D3DRENDERSTATE_FOGDENSITY,
|
|
D3DRENDERSTATE_RANGEFOGENABLE,
|
|
D3DRENDERSTATE_AMBIENT,
|
|
D3DRENDERSTATE_COLORVERTEX,
|
|
D3DRENDERSTATE_FOGVERTEXMODE,
|
|
D3DRENDERSTATE_CLIPPING,
|
|
D3DRENDERSTATE_LIGHTING,
|
|
D3DRENDERSTATE_NORMALIZENORMALS,
|
|
D3DRENDERSTATE_LOCALVIEWER,
|
|
D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,
|
|
D3DRENDERSTATE_AMBIENTMATERIALSOURCE,
|
|
D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,
|
|
D3DRENDERSTATE_SPECULARMATERIALSOURCE,
|
|
D3DRENDERSTATE_VERTEXBLEND,
|
|
D3DRENDERSTATE_CLIPPLANEENABLE,
|
|
D3DRS_SOFTWAREVERTEXPROCESSING,
|
|
D3DRS_POINTSIZE,
|
|
D3DRS_POINTSIZE_MIN,
|
|
D3DRS_POINTSPRITEENABLE,
|
|
D3DRS_POINTSCALEENABLE,
|
|
D3DRS_POINTSCALE_A,
|
|
D3DRS_POINTSCALE_B,
|
|
D3DRS_POINTSCALE_C,
|
|
D3DRS_MULTISAMPLEANTIALIAS,
|
|
D3DRS_MULTISAMPLEMASK,
|
|
D3DRS_PATCHEDGESTYLE,
|
|
D3DRS_PATCHSEGMENTS,
|
|
D3DRS_POINTSIZE_MAX,
|
|
D3DRS_INDEXEDVERTEXBLENDENABLE,
|
|
D3DRS_TWEENFACTOR,
|
|
D3DRS_POSITIONORDER,
|
|
D3DRS_NORMALORDER,
|
|
};
|
|
static D3DTEXTURESTAGESTATETYPE VERTEXtsstates[] =
|
|
{
|
|
D3DTSS_TEXCOORDINDEX,
|
|
D3DTSS_TEXTURETRANSFORMFLAGS
|
|
};
|
|
|
|
DWORD i;
|
|
BOOL bCapturePixelShaderState = TRUE;
|
|
|
|
// The device is not pure, so we can cast
|
|
DXGASSERT((pBaseDev->BehaviorFlags() & D3DCREATE_PUREDEVICE) == 0);
|
|
CD3DHal *pDevI = static_cast<CD3DHal*>(pBaseDev);
|
|
D3DFE_PROCESSVERTICES* pv = pDevI->m_pv;
|
|
// Texture coordinate indices must be restored before capturing, because
|
|
// we do not call GetTextureStageState but access tsstates directly
|
|
if (pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES)
|
|
{
|
|
RestoreTextureStages(pDevI);
|
|
pDevI->ForceFVFRecompute();
|
|
}
|
|
switch(sbt)
|
|
{
|
|
case (D3DSTATEBLOCKTYPE)0:
|
|
break;
|
|
case D3DSBT_ALL:
|
|
for(i = 0; i < sizeof(ALLrstates) / sizeof(D3DRENDERSTATETYPE); ++i)
|
|
pDevI->m_pStateSets->InsertRenderState(ALLrstates[i], pDevI->rstates[ALLrstates[i]], pDevI->CanHandleRenderState(ALLrstates[i]));
|
|
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
for(DWORD j = 0; j < sizeof(ALLtsstates) / sizeof(D3DTEXTURESTAGESTATETYPE); ++j)
|
|
pDevI->m_pStateSets->InsertTextureStageState(i, ALLtsstates[j], pDevI->tsstates[i][ALLtsstates[j]]);
|
|
|
|
// Capture textures
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
{
|
|
IDirect3DBaseTexture8 *pTex;
|
|
if (pDevI->m_lpD3DMappedTexI[i] != 0)
|
|
{
|
|
switch(pDevI->m_lpD3DMappedTexI[i]->GetBufferDesc()->Type)
|
|
{
|
|
case D3DRTYPE_TEXTURE:
|
|
pTex = static_cast<IDirect3DTexture8*>(static_cast<CMipMap*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
case D3DRTYPE_CUBETEXTURE:
|
|
pTex = static_cast<IDirect3DCubeTexture8*>(static_cast<CCubeMap*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
case D3DRTYPE_VOLUMETEXTURE:
|
|
pTex = static_cast<IDirect3DVolumeTexture8*>(static_cast<CMipVolume*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pTex = 0;
|
|
}
|
|
pDevI->m_pStateSets->InsertTexture(i, pTex);
|
|
}
|
|
|
|
// Capture current palette
|
|
pDevI->m_pStateSets->InsertCurrentTexturePalette(pDevI->m_dwPalette);
|
|
|
|
// Capture streams
|
|
for (i = 0; i < pDevI->m_dwNumStreams; i++)
|
|
{
|
|
pDevI->m_pStateSets->InsertStreamSource(i, pDevI->m_pStream[i].m_pVB, pDevI->m_pStream[i].m_dwStride);
|
|
}
|
|
pDevI->m_pStateSets->InsertIndices(pDevI->m_pIndexStream->m_pVBI, pDevI->m_pIndexStream->m_dwBaseIndex);
|
|
|
|
// Capture current viewport
|
|
pDevI->m_pStateSets->InsertViewport(&pDevI->m_Viewport);
|
|
|
|
// Capture current transforms
|
|
for (i = 0; i < __MAXWORLDMATRICES; i++)
|
|
{
|
|
pDevI->m_pStateSets->InsertTransform(D3DTS_WORLDMATRIX(i), (LPD3DMATRIX)&pv->world[i]);
|
|
}
|
|
pDevI->m_pStateSets->InsertTransform(D3DTRANSFORMSTATE_VIEW, (LPD3DMATRIX)&pv->view);
|
|
pDevI->m_pStateSets->InsertTransform(D3DTRANSFORMSTATE_PROJECTION, (LPD3DMATRIX)&pDevI->transform.proj);
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
{
|
|
pDevI->m_pStateSets->InsertTransform((D3DTRANSFORMSTATETYPE)(D3DTRANSFORMSTATE_TEXTURE0 + i), (LPD3DMATRIX)&pv->mTexture[i]);
|
|
}
|
|
|
|
// Capture current clip-planes
|
|
for (i = 0; i < pDevI->m_dwMaxUserClipPlanes; i++)
|
|
{
|
|
pDevI->m_pStateSets->InsertClipPlane(i, (LPD3DVALUE)&pDevI->transform.userClipPlane[i]);
|
|
}
|
|
|
|
// Capture current material
|
|
pDevI->m_pStateSets->InsertMaterial(&pv->lighting.material);
|
|
|
|
// Capture current lights
|
|
for (i = 0; i < pDevI->m_pLightArray->GetSize(); i++)
|
|
{
|
|
LPDIRECT3DLIGHTI pLight =
|
|
static_cast<DIRECT3DLIGHTI *>((*pDevI->m_pLightArray)[i].m_pObj);
|
|
if( pLight)
|
|
{
|
|
pDevI->m_pStateSets->InsertLight(i, &pLight->m_Light);
|
|
if(pLight->Enabled())
|
|
{
|
|
pDevI->m_pStateSets->InsertLightEnable(i, TRUE);
|
|
}
|
|
else
|
|
{
|
|
pDevI->m_pStateSets->InsertLightEnable(i, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Capture current shaders
|
|
if (D3DVSD_ISLEGACY(pDevI->m_dwCurrentShaderHandle))
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, TRUE);
|
|
}
|
|
else
|
|
{
|
|
CVShader* pShader = (CVShader*)pDevI->m_pVShaderArray->GetObject(pDevI->m_dwCurrentShaderHandle);
|
|
if (pShader->m_dwFlags & CVShader::SOFTWARE)
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, FALSE);
|
|
}
|
|
else
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, TRUE);
|
|
}
|
|
}
|
|
|
|
if( bCapturePixelShaderState )
|
|
pDevI->m_pStateSets->InsertPixelShader(pDevI->m_dwCurrentPixelShaderHandle);
|
|
|
|
// Capture shader constants. Use Microsoft's constants as a temp buffer
|
|
{
|
|
const UINT count = pDevI->m_MaxVertexShaderConst;
|
|
pDevI->GetVertexShaderConstant(0, pDevI->GeometryFuncsGuaranteed->m_VertexVM.GetRegisters()->m_c, count);
|
|
pDevI->m_pStateSets->InsertVertexShaderConstant(0, pDevI->GeometryFuncsGuaranteed->m_VertexVM.GetRegisters()->m_c, count);
|
|
}
|
|
|
|
// Capture pixel shader constants
|
|
if( bCapturePixelShaderState )
|
|
{
|
|
// Note this is hardcoded to 8. ff.ff supports 16 but here we capture only 8.
|
|
pDevI->m_pStateSets->InsertPixelShaderConstant(0, pDevI->m_PShaderConstReg, 8 );
|
|
}
|
|
|
|
break;
|
|
|
|
case D3DSBT_PIXELSTATE:
|
|
for(i = 0; i < sizeof(PIXELrstates) / sizeof(D3DRENDERSTATETYPE); ++i)
|
|
pDevI->m_pStateSets->InsertRenderState(PIXELrstates[i], pDevI->rstates[PIXELrstates[i]], pDevI->CanHandleRenderState(PIXELrstates[i]));
|
|
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
for(DWORD j = 0; j < sizeof(PIXELtsstates) / sizeof(D3DTEXTURESTAGESTATETYPE); ++j)
|
|
pDevI->m_pStateSets->InsertTextureStageState(i, PIXELtsstates[j], pDevI->tsstates[i][PIXELtsstates[j]]);
|
|
|
|
// Capture pixel shader constants
|
|
if( bCapturePixelShaderState )
|
|
pDevI->m_pStateSets->InsertPixelShaderConstant(0, pDevI->m_PShaderConstReg,
|
|
D3DPS_CONSTREG_MAX_DX8);
|
|
|
|
// Capture current pixel shader
|
|
if( bCapturePixelShaderState )
|
|
pDevI->m_pStateSets->InsertPixelShader(pDevI->m_dwCurrentPixelShaderHandle);
|
|
break;
|
|
|
|
case D3DSBT_VERTEXSTATE:
|
|
for(i = 0; i < sizeof(VERTEXrstates) / sizeof(D3DRENDERSTATETYPE); ++i)
|
|
pDevI->m_pStateSets->InsertRenderState(VERTEXrstates[i], pDevI->rstates[VERTEXrstates[i]], pDevI->CanHandleRenderState(VERTEXrstates[i]));
|
|
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
for(DWORD j = 0; j < sizeof(VERTEXtsstates) / sizeof(D3DTEXTURESTAGESTATETYPE); ++j)
|
|
pDevI->m_pStateSets->InsertTextureStageState(i, VERTEXtsstates[j], pDevI->tsstates[i][VERTEXtsstates[j]]);
|
|
|
|
// Capture current light enables
|
|
for (i = 0; i < pDevI->m_pLightArray->GetSize(); i++)
|
|
{
|
|
LPDIRECT3DLIGHTI pLight =
|
|
static_cast<DIRECT3DLIGHTI *>((*pDevI->m_pLightArray)[i].m_pObj);
|
|
if( pLight)
|
|
{
|
|
pDevI->m_pStateSets->InsertLight(i, &pLight->m_Light);
|
|
if(pLight->Enabled())
|
|
{
|
|
pDevI->m_pStateSets->InsertLightEnable(i, TRUE);
|
|
}
|
|
else
|
|
{
|
|
pDevI->m_pStateSets->InsertLightEnable(i, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Capture shader constants. Use Microsoft's constants as a temp buffer
|
|
{
|
|
const UINT count = pDevI->m_MaxVertexShaderConst;
|
|
pDevI->GetVertexShaderConstant(0, pDevI->GeometryFuncsGuaranteed->m_VertexVM.GetRegisters()->m_c, count);
|
|
pDevI->m_pStateSets->InsertVertexShaderConstant(0, pDevI->GeometryFuncsGuaranteed->m_VertexVM.GetRegisters()->m_c, count);
|
|
}
|
|
|
|
// Capture current vertex shader
|
|
if (D3DVSD_ISLEGACY(pDevI->m_dwCurrentShaderHandle))
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, TRUE);
|
|
}
|
|
else
|
|
{
|
|
CVShader* pShader = (CVShader*)pDevI->m_pVShaderArray->GetObject(pDevI->m_dwCurrentShaderHandle);
|
|
if (pShader->m_dwFlags & CVShader::SOFTWARE)
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, FALSE);
|
|
}
|
|
else
|
|
{
|
|
pDevI->m_pStateSets->InsertVertexShader(pDevI->m_dwCurrentShaderHandle, TRUE);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
pDevI->m_pStateSets->EndSet();
|
|
pDevI->m_pDDI->WriteStateSetToDevice(sbt);
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CPureStateSet::InsertCommand"
|
|
|
|
void CPureStateSet::InsertCommand(D3DHAL_DP2OPERATION op, LPVOID pData,
|
|
DWORD dwDataSize,
|
|
BOOL bDriverCanHandle)
|
|
{
|
|
switch(op)
|
|
{
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
case D3DDP2OP_FESETVB:
|
|
case D3DDP2OP_FESETIB:
|
|
m_FEOnlyBuffer.InsertCommand(op, pData, dwDataSize);
|
|
break;
|
|
default:
|
|
m_DriverBuffer.InsertCommand(op, pData, dwDataSize);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CPureStateSet::Execute"
|
|
|
|
void CPureStateSet::Execute(CD3DBase *pDevI, BOOL bFrontEndBuffer)
|
|
{
|
|
DWORD *p;
|
|
DWORD dwSize;
|
|
DWORD *pEnd;
|
|
if (bFrontEndBuffer)
|
|
{
|
|
p = (DWORD*)m_FEOnlyBuffer.m_pBuffer;
|
|
dwSize = m_FEOnlyBuffer.m_dwCurrentSize;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FRONTENDDATA pData = (LPD3DHAL_DP2FRONTENDDATA)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FRONTENDDATA));
|
|
HRESULT ret = pDevI->SetTexture(pData->wStage, pData->pTexture);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETVB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETVB pData = (LPD3DHAL_DP2FESETVB)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETVB));
|
|
HRESULT ret = pDevI->SetStreamSource(pData->wStream, pData->pBuf, pData->dwStride);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETIB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETIB pData = (LPD3DHAL_DP2FESETIB)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETIB));
|
|
HRESULT ret = pDevI->SetIndices(pData->pBuf, pData->dwBase);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETPAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETPAL pData = (LPD3DHAL_DP2FESETPAL)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETPAL));
|
|
if( pData->dwPaletteNumber != __INVALIDPALETTE )
|
|
{
|
|
HRESULT ret = pDevI->SetCurrentTexturePalette(pData->dwPaletteNumber);
|
|
if (ret != D3D_OK)
|
|
throw ret;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CPureStateSet::Capture"
|
|
|
|
void CPureStateSet::Capture(CD3DBase *pDevI, BOOL bFrontEndBuffer)
|
|
{
|
|
DWORD *p;
|
|
DWORD dwSize;
|
|
DWORD *pEnd;
|
|
if (bFrontEndBuffer)
|
|
{
|
|
p = (DWORD*)m_FEOnlyBuffer.m_pBuffer;
|
|
dwSize = m_FEOnlyBuffer.m_dwCurrentSize;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
pEnd = (DWORD*)((BYTE*)p + dwSize);
|
|
while (p < pEnd)
|
|
{
|
|
LPD3DHAL_DP2COMMAND pCommand = (LPD3DHAL_DP2COMMAND)p;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2COMMAND));
|
|
switch ((D3DHAL_DP2OPERATION)pCommand->bCommand)
|
|
{
|
|
case D3DDP2OP_FRONTENDDATA:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FRONTENDDATA pData = (LPD3DHAL_DP2FRONTENDDATA)p;
|
|
CBaseTexture* pTexOld = NULL;
|
|
CBaseTexture* pTexNew = NULL;
|
|
pTexOld = CBaseTexture::SafeCast(pData->pTexture);
|
|
if( pTexOld )
|
|
pTexOld->DecrementUseCount();
|
|
pTexNew = pDevI->m_lpD3DMappedTexI[pData->wStage];
|
|
if( pTexNew )
|
|
pTexNew->IncrementUseCount();
|
|
if (pDevI->m_lpD3DMappedTexI[pData->wStage] != 0)
|
|
{
|
|
switch(pDevI->m_lpD3DMappedTexI[pData->wStage]->GetBufferDesc()->Type)
|
|
{
|
|
case D3DRTYPE_TEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DTexture8*>(static_cast<CMipMap*>(pTexNew));
|
|
break;
|
|
case D3DRTYPE_CUBETEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DCubeTexture8*>(static_cast<CCubeMap*>(pTexNew));
|
|
break;
|
|
case D3DRTYPE_VOLUMETEXTURE:
|
|
pData->pTexture = static_cast<IDirect3DVolumeTexture8*>(static_cast<CMipVolume*>(pTexNew));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pData->pTexture = 0;
|
|
}
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FRONTENDDATA));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETVB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETVB pData = (LPD3DHAL_DP2FESETVB)p;
|
|
if( pData->pBuf )
|
|
{
|
|
pData->pBuf->DecrementUseCount();
|
|
}
|
|
pData->pBuf = pDevI->m_pStream[pData->wStream].m_pVB;
|
|
if( pData->pBuf )
|
|
{
|
|
pData->pBuf->IncrementUseCount();
|
|
}
|
|
pData->dwStride = pDevI->m_pStream[pData->wStream].m_dwStride;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETVB));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETIB:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETIB pData = (LPD3DHAL_DP2FESETIB)p;
|
|
pData->pBuf = pDevI->m_pIndexStream->m_pVBI;
|
|
if( pData->pBuf )
|
|
{
|
|
pData->pBuf->DecrementUseCount();
|
|
}
|
|
pData->dwBase = pDevI->m_pIndexStream->m_dwBaseIndex;
|
|
if( pData->pBuf )
|
|
{
|
|
pData->pBuf->IncrementUseCount();
|
|
}
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETIB));
|
|
}
|
|
break;
|
|
}
|
|
case D3DDP2OP_FESETPAL:
|
|
{
|
|
for(DWORD i = 0; i < (DWORD)pCommand->wStateCount; ++i)
|
|
{
|
|
LPD3DHAL_DP2FESETPAL pData = (LPD3DHAL_DP2FESETPAL)p;
|
|
pData->dwPaletteNumber = pDevI->m_dwPalette;
|
|
p = (DWORD*)((BYTE*)p + sizeof(D3DHAL_DP2FESETPAL));
|
|
}
|
|
break;
|
|
}
|
|
#ifdef DBG
|
|
default:
|
|
DXGASSERT(FALSE);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CPureStateSet::CreatePredefined"
|
|
|
|
void CPureStateSet::CreatePredefined(CD3DBase *pDevI, D3DSTATEBLOCKTYPE sbt)
|
|
{
|
|
DWORD i;
|
|
// The device is not pure, so we can cast
|
|
switch(sbt)
|
|
{
|
|
case (D3DSTATEBLOCKTYPE)0:
|
|
break;
|
|
case D3DSBT_ALL:
|
|
// Capture textures
|
|
for (i = 0; i < pDevI->m_dwMaxTextureBlendStages; i++)
|
|
{
|
|
IDirect3DBaseTexture8 *pTex;
|
|
if (pDevI->m_lpD3DMappedTexI[i] != 0)
|
|
{
|
|
switch(pDevI->m_lpD3DMappedTexI[i]->GetBufferDesc()->Type)
|
|
{
|
|
case D3DRTYPE_TEXTURE:
|
|
pTex = static_cast<IDirect3DTexture8*>(static_cast<CMipMap*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
case D3DRTYPE_CUBETEXTURE:
|
|
pTex = static_cast<IDirect3DCubeTexture8*>(static_cast<CCubeMap*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
case D3DRTYPE_VOLUMETEXTURE:
|
|
pTex = static_cast<IDirect3DVolumeTexture8*>(static_cast<CMipVolume*>(pDevI->m_lpD3DMappedTexI[i]));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pTex = 0;
|
|
}
|
|
pDevI->m_pStateSets->InsertTexture(i, pTex);
|
|
}
|
|
|
|
// Capture streams
|
|
for (i = 0; i < pDevI->m_dwNumStreams; i++)
|
|
{
|
|
pDevI->m_pStateSets->InsertStreamSource(i, pDevI->m_pStream[i].m_pVB, pDevI->m_pStream[i].m_dwStride);
|
|
}
|
|
pDevI->m_pStateSets->InsertIndices(pDevI->m_pIndexStream->m_pVBI, pDevI->m_pIndexStream->m_dwBaseIndex);
|
|
|
|
break;
|
|
|
|
case D3DSBT_PIXELSTATE:
|
|
break;
|
|
|
|
case D3DSBT_VERTEXSTATE:
|
|
break;
|
|
|
|
default:
|
|
throw D3DERR_INVALIDCALL;
|
|
}
|
|
pDevI->m_pStateSets->EndSet();
|
|
DWORD DeviceHandle;
|
|
pDevI->m_pStateSets->CreateNewDeviceHandle(&DeviceHandle);
|
|
pDevI->m_pDDI->InsertStateSetOp(D3DHAL_STATESETCREATE, DeviceHandle, sbt);
|
|
}
|
|
//=====================================================================
|
|
// CStateSetBuffer interface
|
|
//
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CStateSetBuffer::InsertCommand"
|
|
|
|
void CStateSetBuffer::InsertCommand(D3DHAL_DP2OPERATION op, LPVOID pData, DWORD dwDataSize)
|
|
{
|
|
const DWORD GROWSIZE = 1024;
|
|
if (m_pDP2CurrCommand != 0 && m_pDP2CurrCommand->bCommand == op)
|
|
{
|
|
if (dwDataSize + m_dwCurrentSize <= m_dwBufferSize)
|
|
{
|
|
++m_pDP2CurrCommand->wStateCount;
|
|
memcpy(m_pBuffer + m_dwCurrentSize, pData, dwDataSize);
|
|
m_dwCurrentSize += dwDataSize;
|
|
return;
|
|
}
|
|
}
|
|
// Check for space
|
|
if (sizeof(D3DHAL_DP2COMMAND) + dwDataSize + m_dwCurrentSize > m_dwBufferSize)
|
|
{
|
|
// We need to grow the buffer
|
|
DWORD dwNewBufferSize = max(m_dwBufferSize + GROWSIZE, sizeof(D3DHAL_DP2COMMAND) + dwDataSize + m_dwCurrentSize);
|
|
BYTE *pTmp = new BYTE[dwNewBufferSize];
|
|
if (pTmp == NULL)
|
|
{
|
|
D3D_ERR("Not enough memory to create state block buffer");
|
|
throw E_OUTOFMEMORY;
|
|
}
|
|
if (m_pBuffer)
|
|
{
|
|
memcpy(pTmp, m_pBuffer, m_dwCurrentSize);
|
|
delete [] m_pBuffer;
|
|
}
|
|
m_pBuffer = pTmp;
|
|
m_dwBufferSize = dwNewBufferSize;
|
|
}
|
|
// Add new instruction
|
|
m_pDP2CurrCommand = (LPD3DHAL_DP2COMMAND)(m_pBuffer + m_dwCurrentSize);
|
|
m_pDP2CurrCommand->bCommand = op;
|
|
m_pDP2CurrCommand->bReserved = 0;
|
|
m_pDP2CurrCommand->wStateCount = 1;
|
|
m_dwCurrentSize += sizeof(D3DHAL_DP2COMMAND);
|
|
memcpy(m_pBuffer + m_dwCurrentSize, pData, dwDataSize);
|
|
m_dwCurrentSize += dwDataSize;
|
|
return;
|
|
}
|