/*==========================================================================; * * 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(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(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(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(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 ((*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(static_cast(pTexNew)); break; case D3DRTYPE_CUBETEXTURE: pData->pTexture = static_cast(static_cast(pTexNew)); break; case D3DRTYPE_VOLUMETEXTURE: pData->pTexture = static_cast(static_cast(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(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(static_cast(pDevI->m_lpD3DMappedTexI[i])); break; case D3DRTYPE_CUBETEXTURE: pTex = static_cast(static_cast(pDevI->m_lpD3DMappedTexI[i])); break; case D3DRTYPE_VOLUMETEXTURE: pTex = static_cast(static_cast(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((*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((*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(static_cast(pTexNew)); break; case D3DRTYPE_CUBETEXTURE: pData->pTexture = static_cast(static_cast(pTexNew)); break; case D3DRTYPE_VOLUMETEXTURE: pData->pTexture = static_cast(static_cast(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(static_cast(pDevI->m_lpD3DMappedTexI[i])); break; case D3DRTYPE_CUBETEXTURE: pTex = static_cast(static_cast(pDevI->m_lpD3DMappedTexI[i])); break; case D3DRTYPE_VOLUMETEXTURE: pTex = static_cast(static_cast(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; }