- Rename VertexShaderInfo to VertexDeclaration
- Move declaration related fields to CxbxVertexShader.Declaration
This commit is contained in:
Anthony Miles
parent
57a8dc6f3b
commit
eaa095e8a2
|
|
@ -1000,16 +1000,16 @@ void SetCxbxVertexShader(CxbxVertexShader* pCxbxVertexShader) {
|
|||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->SetVertexShader");
|
||||
|
||||
// Set either FVF or the vertex declaration
|
||||
if (pCxbxVertexShader->HostFVF)
|
||||
if (pCxbxVertexShader->Declaration.HostFVF)
|
||||
{
|
||||
// Set the FVF
|
||||
hRet = g_pD3DDevice->SetFVF(pCxbxVertexShader->HostFVF);
|
||||
hRet = g_pD3DDevice->SetFVF(pCxbxVertexShader->Declaration.HostFVF);
|
||||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->SetFVF");
|
||||
}
|
||||
else
|
||||
{
|
||||
// Set vertex declaration
|
||||
hRet = g_pD3DDevice->SetVertexDeclaration(pCxbxVertexShader->pHostVertexDeclaration);
|
||||
hRet = g_pD3DDevice->SetVertexDeclaration(pCxbxVertexShader->Declaration.pHostVertexDeclaration);
|
||||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->SetVertexDeclaration");
|
||||
}
|
||||
|
||||
|
|
@ -1020,7 +1020,7 @@ void SetCxbxVertexShader(CxbxVertexShader* pCxbxVertexShader) {
|
|||
// Any register not in the vertex declaration should be set to the default value
|
||||
float vertexDefaultFlags[16];
|
||||
for (int i = 0; i < 16; i++) {
|
||||
vertexDefaultFlags[i] = pCxbxVertexShader->VertexShaderInfo.vRegisterInDeclaration[i] ? 0.0f : 1.0f;
|
||||
vertexDefaultFlags[i] = pCxbxVertexShader->Declaration.vRegisterInDeclaration[i] ? 0.0f : 1.0f;
|
||||
}
|
||||
g_pD3DDevice->SetVertexShaderConstantF(CXBX_D3DVS_CONSTREG_VREGDEFAULTS_FLAG_BASE, vertexDefaultFlags, 4);
|
||||
}
|
||||
|
|
@ -4214,10 +4214,10 @@ HRESULT WINAPI XTL::EMUPATCH(D3DDevice_CreateVertexShader)
|
|||
pRecompiledDeclaration = EmuRecompileVshDeclaration((DWORD*)pDeclaration,
|
||||
/*bIsFixedFunction=*/pFunction == xbnullptr,
|
||||
&XboxDeclarationCount,
|
||||
&pCxbxVertexShader->VertexShaderInfo);
|
||||
&pCxbxVertexShader->Declaration);
|
||||
|
||||
// Create the vertex declaration
|
||||
hRet = g_pD3DDevice->CreateVertexDeclaration(pRecompiledDeclaration, &pCxbxVertexShader->pHostVertexDeclaration);
|
||||
hRet = g_pD3DDevice->CreateVertexDeclaration(pRecompiledDeclaration, &pCxbxVertexShader->Declaration.pHostVertexDeclaration);
|
||||
free(pRecompiledDeclaration);
|
||||
|
||||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->CreateVertexDeclaration");
|
||||
|
|
@ -4226,8 +4226,11 @@ HRESULT WINAPI XTL::EMUPATCH(D3DDevice_CreateVertexShader)
|
|||
// NOTE: This is a fatal error because it ALWAYS triggers a crash within DrawVertices if not set
|
||||
CxbxKrnlCleanup("Failed to create Vertex Declaration");
|
||||
}
|
||||
g_pD3DDevice->SetVertexDeclaration(pCxbxVertexShader->pHostVertexDeclaration);
|
||||
hRet = g_pD3DDevice->SetVertexDeclaration(pCxbxVertexShader->Declaration.pHostVertexDeclaration);
|
||||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->SetVertexDeclaration");
|
||||
if (FAILED(hRet)) {
|
||||
CxbxKrnlCleanup("Failed to set Vertex Declaration");
|
||||
}
|
||||
|
||||
uint64_t vertexShaderKey = 0;
|
||||
DWORD XboxFunctionSize = 0;
|
||||
|
|
@ -4236,31 +4239,23 @@ HRESULT WINAPI XTL::EMUPATCH(D3DDevice_CreateVertexShader)
|
|||
vertexShaderKey = g_VertexShaderSource.CreateShader(pFunction, &XboxFunctionSize);
|
||||
}
|
||||
|
||||
pCxbxVertexShader->pXboxDeclarationCopy = (DWORD*)malloc(XboxDeclarationCount * sizeof(DWORD));
|
||||
memcpy(pCxbxVertexShader->pXboxDeclarationCopy, pDeclaration, XboxDeclarationCount * sizeof(DWORD));
|
||||
pCxbxVertexShader->Declaration.pXboxDeclarationCopy = (DWORD*)malloc(XboxDeclarationCount * sizeof(DWORD));
|
||||
memcpy(pCxbxVertexShader->Declaration.pXboxDeclarationCopy, pDeclaration, XboxDeclarationCount * sizeof(DWORD));
|
||||
pCxbxVertexShader->XboxFunctionSize = 0;
|
||||
pCxbxVertexShader->pXboxFunctionCopy = nullptr;
|
||||
pCxbxVertexShader->XboxVertexShaderType = X_VST_NORMAL; // TODO : This can vary
|
||||
pCxbxVertexShader->XboxNrAddressSlots = (XboxFunctionSize - sizeof(X_VSH_SHADER_HEADER)) / X_VSH_INSTRUCTION_SIZE_BYTES;
|
||||
pCxbxVertexShader->HostFVF = 0;
|
||||
pCxbxVertexShader->Declaration.HostFVF = 0;
|
||||
pCxbxVertexShader->VertexShaderKey = vertexShaderKey;
|
||||
pCxbxVertexShader->XboxDeclarationCount = XboxDeclarationCount;
|
||||
pCxbxVertexShader->Declaration.XboxDeclarationCount = XboxDeclarationCount;
|
||||
// Save the status, to remove things later
|
||||
// pCxbxVertexShader->XboxStatus = hRet; // Not even used by VshHandleIsValidShader()
|
||||
|
||||
if(SUCCEEDED(hRet))
|
||||
if(pFunction != xbnullptr)
|
||||
{
|
||||
if(pFunction != xbnullptr)
|
||||
{
|
||||
pCxbxVertexShader->XboxFunctionSize = XboxFunctionSize;
|
||||
pCxbxVertexShader->pXboxFunctionCopy = (DWORD*)malloc(XboxFunctionSize);
|
||||
memcpy(pCxbxVertexShader->pXboxFunctionCopy, pFunction, XboxFunctionSize);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_TEST_CASE("Falling back to FVF shader");
|
||||
pCxbxVertexShader->HostFVF = D3DFVF_XYZ | D3DFVF_TEX0;
|
||||
pCxbxVertexShader->XboxFunctionSize = XboxFunctionSize;
|
||||
pCxbxVertexShader->pXboxFunctionCopy = (DWORD*)malloc(XboxFunctionSize);
|
||||
memcpy(pCxbxVertexShader->pXboxFunctionCopy, pFunction, XboxFunctionSize);
|
||||
}
|
||||
|
||||
// Register the host Vertex Shader
|
||||
|
|
@ -7944,17 +7939,17 @@ VOID WINAPI XTL::EMUPATCH(D3DDevice_DeleteVertexShader)
|
|||
CxbxVertexShader *pCxbxVertexShader = GetCxbxVertexShader(Handle);
|
||||
SetCxbxVertexShader(Handle, nullptr);
|
||||
|
||||
if (pCxbxVertexShader->pHostVertexDeclaration) {
|
||||
HRESULT hRet = pCxbxVertexShader->pHostVertexDeclaration->Release();
|
||||
if (pCxbxVertexShader->Declaration.pHostVertexDeclaration) {
|
||||
HRESULT hRet = pCxbxVertexShader->Declaration.pHostVertexDeclaration->Release();
|
||||
DEBUG_D3DRESULT(hRet, "g_pD3DDevice->DeleteVertexShader(pHostVertexDeclaration)");
|
||||
}
|
||||
|
||||
// Release the host vertex shader
|
||||
g_VertexShaderSource.ReleaseShader(pCxbxVertexShader->VertexShaderKey);
|
||||
|
||||
if (pCxbxVertexShader->pXboxDeclarationCopy)
|
||||
if (pCxbxVertexShader->Declaration.pXboxDeclarationCopy)
|
||||
{
|
||||
free(pCxbxVertexShader->pXboxDeclarationCopy);
|
||||
free(pCxbxVertexShader->Declaration.pXboxDeclarationCopy);
|
||||
}
|
||||
|
||||
if (pCxbxVertexShader->pXboxFunctionCopy)
|
||||
|
|
@ -8185,7 +8180,7 @@ VOID WINAPI XTL::EMUPATCH(D3DDevice_LoadVertexShaderProgram)
|
|||
}
|
||||
|
||||
// Simply retrieve the contents of the existing vertex shader program
|
||||
pXboxVertexDeclaration = pCxbxVertexShader->pXboxDeclarationCopy;
|
||||
pXboxVertexDeclaration = pCxbxVertexShader->Declaration.pXboxDeclarationCopy;
|
||||
} else {
|
||||
// This is an unusual scenario in which an FVF-based shader is being replaced with an actual shader
|
||||
// But without calling CreateVertexShader: This means we need to parse the current FVF and generate
|
||||
|
|
@ -8308,13 +8303,13 @@ HRESULT WINAPI XTL::EMUPATCH(D3DDevice_GetVertexShaderDeclaration)
|
|||
if (pSizeOfData) {
|
||||
CxbxVertexShader *pCxbxVertexShader = GetCxbxVertexShader(Handle);
|
||||
if (pCxbxVertexShader) {
|
||||
DWORD sizeOfData = pCxbxVertexShader->XboxDeclarationCount * sizeof(DWORD);
|
||||
DWORD sizeOfData = pCxbxVertexShader->Declaration.XboxDeclarationCount * sizeof(DWORD);
|
||||
if (*pSizeOfData < sizeOfData || !pData) {
|
||||
*pSizeOfData = sizeOfData;
|
||||
hRet = !pData ? D3D_OK : D3DERR_MOREDATA;
|
||||
}
|
||||
else {
|
||||
memcpy(pData, pCxbxVertexShader->pXboxDeclarationCopy, pCxbxVertexShader->XboxDeclarationCount * sizeof(DWORD));
|
||||
memcpy(pData, pCxbxVertexShader->Declaration.pXboxDeclarationCopy, pCxbxVertexShader->Declaration.XboxDeclarationCount * sizeof(DWORD));
|
||||
hRet = D3D_OK;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -180,9 +180,9 @@ DWORD CxbxGetStrideFromVertexShaderHandle(DWORD dwVertexShader)
|
|||
|
||||
CxbxVertexShader *pCxbxVertexShader = GetCxbxVertexShader(dwVertexShader);
|
||||
if (pCxbxVertexShader) {
|
||||
if (pCxbxVertexShader->VertexShaderInfo.NumberOfVertexStreams == 1) {
|
||||
if (pCxbxVertexShader->Declaration.NumberOfVertexStreams == 1) {
|
||||
// Note : This assumes that the only stream in use will be stream zero :
|
||||
Stride = pCxbxVertexShader->VertexShaderInfo.VertexStreams[0].HostVertexStride;
|
||||
Stride = pCxbxVertexShader->Declaration.VertexStreams[0].HostVertexStride;
|
||||
}
|
||||
else {
|
||||
LOG_TEST_CASE("Non-FVF Vertex Shaders with multiple streams not supported for PushBuffer emulation!");
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ CxbxPatchedStream::~CxbxPatchedStream()
|
|||
CxbxVertexBufferConverter::CxbxVertexBufferConverter()
|
||||
{
|
||||
m_uiNbrStreams = 0;
|
||||
m_pVertexShaderInfo = nullptr;
|
||||
m_pCxbxVertexDeclaration = nullptr;
|
||||
}
|
||||
|
||||
int CountActiveD3DStreams()
|
||||
|
|
@ -128,7 +128,7 @@ int CountActiveD3DStreams()
|
|||
return lastStreamIndex;
|
||||
}
|
||||
|
||||
CxbxVertexShaderInfo *GetCxbxVertexShaderInfo(DWORD XboxVertexShaderHandle); // forward
|
||||
CxbxVertexDeclaration *GetCxbxVertexDeclaration(DWORD XboxVertexShaderHandle); // forward
|
||||
|
||||
UINT CxbxVertexBufferConverter::GetNbrStreams(CxbxDrawContext *pDrawContext)
|
||||
{
|
||||
|
|
@ -138,13 +138,13 @@ UINT CxbxVertexBufferConverter::GetNbrStreams(CxbxDrawContext *pDrawContext)
|
|||
}
|
||||
|
||||
if(VshHandleIsVertexShader(g_Xbox_VertexShader_Handle)) {
|
||||
CxbxVertexShaderInfo *pVertexShaderInfo = GetCxbxVertexShaderInfo(g_Xbox_VertexShader_Handle);
|
||||
if (pVertexShaderInfo) {
|
||||
if (pVertexShaderInfo->NumberOfVertexStreams <= X_VSH_MAX_STREAMS) {
|
||||
return pVertexShaderInfo->NumberOfVertexStreams;
|
||||
CxbxVertexDeclaration *pDecl = GetCxbxVertexDeclaration(g_Xbox_VertexShader_Handle);
|
||||
if (pDecl) {
|
||||
if (pDecl->NumberOfVertexStreams <= X_VSH_MAX_STREAMS) {
|
||||
return pDecl->NumberOfVertexStreams;
|
||||
}
|
||||
|
||||
// If we reached here, pVertexShaderInfo was set,but with invalid data
|
||||
// If we reached here, pDecl was set,but with invalid data
|
||||
LOG_TEST_CASE("NumberOfVertexStreams > 16");
|
||||
}
|
||||
|
||||
|
|
@ -261,13 +261,13 @@ void CxbxVertexBufferConverter::ConvertStream
|
|||
}
|
||||
|
||||
CxbxVertexShaderStreamInfo *pVertexShaderStreamInfo = nullptr;
|
||||
if (m_pVertexShaderInfo != nullptr) {
|
||||
if (uiStream > m_pVertexShaderInfo->NumberOfVertexStreams + 1) {
|
||||
if (m_pCxbxVertexDeclaration != nullptr) {
|
||||
if (uiStream > m_pCxbxVertexDeclaration->NumberOfVertexStreams + 1) {
|
||||
LOG_TEST_CASE("uiStream > NumberOfVertexStreams");
|
||||
return;
|
||||
}
|
||||
|
||||
pVertexShaderStreamInfo = &(m_pVertexShaderInfo->VertexStreams[uiStream]);
|
||||
pVertexShaderStreamInfo = &(m_pCxbxVertexDeclaration->VertexStreams[uiStream]);
|
||||
}
|
||||
|
||||
bool bNeedVertexPatching = (pVertexShaderStreamInfo != nullptr && pVertexShaderStreamInfo->NeedPatch);
|
||||
|
|
@ -759,9 +759,9 @@ void CxbxVertexBufferConverter::Apply(CxbxDrawContext *pDrawContext)
|
|||
if ((pDrawContext->XboxPrimitiveType < XTL::X_D3DPT_POINTLIST) || (pDrawContext->XboxPrimitiveType > XTL::X_D3DPT_POLYGON))
|
||||
CxbxKrnlCleanup("Unknown primitive type: 0x%.02X\n", pDrawContext->XboxPrimitiveType);
|
||||
|
||||
m_pVertexShaderInfo = nullptr;
|
||||
m_pCxbxVertexDeclaration = nullptr;
|
||||
if (VshHandleIsVertexShader(g_Xbox_VertexShader_Handle)) {
|
||||
m_pVertexShaderInfo = &(GetCxbxVertexShader(g_Xbox_VertexShader_Handle)->VertexShaderInfo);
|
||||
m_pCxbxVertexDeclaration = &(GetCxbxVertexShader(g_Xbox_VertexShader_Handle)->Declaration);
|
||||
}
|
||||
|
||||
// If we are drawing from an offset, we know that the vertex count must have
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
|
||||
#include "Cxbx.h"
|
||||
|
||||
#include "core\hle\D3D8\XbVertexShader.h" // for CxbxVertexShaderInfo
|
||||
#include "core\hle\D3D8\XbVertexShader.h"
|
||||
|
||||
typedef struct _CxbxDrawContext
|
||||
{
|
||||
|
|
@ -90,7 +90,7 @@ class CxbxVertexBufferConverter
|
|||
std::list<CxbxPatchedStream> m_PatchedStreamUsageList; // Linked list of vertex streams, least recently used is last in the list
|
||||
CxbxPatchedStream& GetPatchedStream(uint64_t); // Fetches (or inserts) a patched stream associated with the given key
|
||||
|
||||
CxbxVertexShaderInfo *m_pVertexShaderInfo;
|
||||
CxbxVertexDeclaration *m_pCxbxVertexDeclaration;
|
||||
|
||||
// Returns the number of streams of a patch
|
||||
UINT GetNbrStreams(CxbxDrawContext *pPatchDesc);
|
||||
|
|
|
|||
|
|
@ -338,7 +338,7 @@ class XboxVertexDeclarationConverter
|
|||
{
|
||||
protected:
|
||||
// Internal variables
|
||||
CxbxVertexShaderInfo* pVertexShaderInfoToSet;
|
||||
CxbxVertexDeclaration* pVertexDeclarationToSet;
|
||||
CxbxVertexShaderStreamInfo* pCurrentVertexShaderStreamInfo = nullptr;
|
||||
bool IsFixedFunction;
|
||||
D3DVERTEXELEMENT* pRecompiled;
|
||||
|
|
@ -739,7 +739,7 @@ private:
|
|||
DWORD StreamNumber = VshGetVertexStream(*pXboxToken);
|
||||
|
||||
// new stream
|
||||
pCurrentVertexShaderStreamInfo = &(pVertexShaderInfoToSet->VertexStreams[StreamNumber]);
|
||||
pCurrentVertexShaderStreamInfo = &(pVertexDeclarationToSet->VertexStreams[StreamNumber]);
|
||||
pCurrentVertexShaderStreamInfo->NeedPatch = FALSE;
|
||||
pCurrentVertexShaderStreamInfo->DeclPosition = FALSE;
|
||||
pCurrentVertexShaderStreamInfo->CurrentStreamNumber = 0;
|
||||
|
|
@ -749,7 +749,7 @@ private:
|
|||
// Dxbx note : Use Dophin(s), FieldRender, MatrixPaletteSkinning and PersistDisplay as a testcase
|
||||
|
||||
pCurrentVertexShaderStreamInfo->CurrentStreamNumber = VshGetVertexStream(*pXboxToken);
|
||||
pVertexShaderInfoToSet->NumberOfVertexStreams++;
|
||||
pVertexDeclarationToSet->NumberOfVertexStreams++;
|
||||
// TODO : Keep a bitmask for all StreamNumber's seen?
|
||||
}
|
||||
}
|
||||
|
|
@ -1129,12 +1129,12 @@ private:
|
|||
}
|
||||
|
||||
public:
|
||||
D3DVERTEXELEMENT *Convert(DWORD* pXboxDeclaration, bool bIsFixedFunction, CxbxVertexShaderInfo* pCxbxVertexShaderInfo)
|
||||
D3DVERTEXELEMENT *Convert(DWORD* pXboxDeclaration, bool bIsFixedFunction, CxbxVertexDeclaration* pCxbxVertexDeclaration)
|
||||
{
|
||||
// Get a preprocessed copy of the original Xbox Vertex Declaration
|
||||
auto pXboxVertexDeclarationCopy = RemoveXboxDeclarationRedefinition(pXboxDeclaration);
|
||||
|
||||
pVertexShaderInfoToSet = pCxbxVertexShaderInfo;
|
||||
pVertexDeclarationToSet = pCxbxVertexDeclaration;
|
||||
|
||||
IsFixedFunction = bIsFixedFunction;
|
||||
|
||||
|
|
@ -1184,7 +1184,7 @@ public:
|
|||
|
||||
// Record which registers are in the vertex declaration
|
||||
for (size_t i = 0; i < RegVIsPresentInDeclaration.size(); i++) {
|
||||
pCxbxVertexShaderInfo->vRegisterInDeclaration[i] = RegVIsPresentInDeclaration[i];
|
||||
pCxbxVertexDeclaration->vRegisterInDeclaration[i] = RegVIsPresentInDeclaration[i];
|
||||
}
|
||||
|
||||
return Result;
|
||||
|
|
@ -1196,12 +1196,12 @@ D3DVERTEXELEMENT *EmuRecompileVshDeclaration
|
|||
DWORD *pXboxDeclaration,
|
||||
bool bIsFixedFunction,
|
||||
DWORD *pXboxDeclarationCount,
|
||||
CxbxVertexShaderInfo *pCxbxVertexShaderInfo
|
||||
CxbxVertexDeclaration *pCxbxVertexDeclaration
|
||||
)
|
||||
{
|
||||
XboxVertexDeclarationConverter Converter;
|
||||
|
||||
D3DVERTEXELEMENT* pHostVertexElements = Converter.Convert(pXboxDeclaration, bIsFixedFunction, pCxbxVertexShaderInfo);
|
||||
D3DVERTEXELEMENT* pHostVertexElements = Converter.Convert(pXboxDeclaration, bIsFixedFunction, pCxbxVertexDeclaration);
|
||||
|
||||
*pXboxDeclarationCount = Converter.XboxDeclarationCount;
|
||||
|
||||
|
|
@ -1210,7 +1210,7 @@ D3DVERTEXELEMENT *EmuRecompileVshDeclaration
|
|||
|
||||
extern void FreeVertexDynamicPatch(CxbxVertexShader *pVertexShader)
|
||||
{
|
||||
pVertexShader->VertexShaderInfo.NumberOfVertexStreams = 0;
|
||||
pVertexShader->Declaration.NumberOfVertexStreams = 0;
|
||||
}
|
||||
|
||||
// Checks for failed vertex shaders, and shaders that would need patching
|
||||
|
|
@ -1248,15 +1248,15 @@ extern boolean IsValidCurrentShader(void)
|
|||
return VshHandleIsValidShader(g_Xbox_VertexShader_Handle);
|
||||
}
|
||||
|
||||
CxbxVertexShaderInfo *GetCxbxVertexShaderInfo(DWORD XboxVertexShaderHandle)
|
||||
CxbxVertexDeclaration *GetCxbxVertexDeclaration(DWORD XboxVertexShaderHandle)
|
||||
{
|
||||
CxbxVertexShader *pCxbxVertexShader = GetCxbxVertexShader(XboxVertexShaderHandle);
|
||||
|
||||
for (uint32_t i = 0; i < pCxbxVertexShader->VertexShaderInfo.NumberOfVertexStreams; i++)
|
||||
for (uint32_t i = 0; i < pCxbxVertexShader->Declaration.NumberOfVertexStreams; i++)
|
||||
{
|
||||
if (pCxbxVertexShader->VertexShaderInfo.VertexStreams[i].NeedPatch)
|
||||
if (pCxbxVertexShader->Declaration.VertexStreams[i].NeedPatch)
|
||||
{
|
||||
return &pCxbxVertexShader->VertexShaderInfo;
|
||||
return &pCxbxVertexShader->Declaration;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
|
|
|
|||
|
|
@ -68,21 +68,23 @@ typedef struct _CxbxVertexShaderStreamInfo
|
|||
}
|
||||
CxbxVertexShaderStreamInfo;
|
||||
|
||||
typedef struct _CxbxVertexShaderInfo
|
||||
typedef struct _CxbxVertexDeclaration
|
||||
{
|
||||
UINT NumberOfVertexStreams; // The number of streams the vertex shader uses
|
||||
CxbxVertexShaderStreamInfo VertexStreams[X_VSH_MAX_STREAMS];
|
||||
bool vRegisterInDeclaration[16];
|
||||
IDirect3DVertexDeclaration* pHostVertexDeclaration;
|
||||
DWORD* pXboxDeclarationCopy;
|
||||
DWORD XboxDeclarationCount; // Xbox's number of DWORD-sized X_D3DVSD* tokens
|
||||
DWORD HostFVF; // Flexible Vertex Format (used when there's no host vertex shader)
|
||||
UINT NumberOfVertexStreams; // The number of streams the vertex shader uses
|
||||
bool vRegisterInDeclaration[X_VSH_MAX_ATTRIBUTES];
|
||||
}
|
||||
CxbxVertexShaderInfo;
|
||||
CxbxVertexDeclaration;
|
||||
|
||||
|
||||
typedef struct _CxbxVertexShader
|
||||
{
|
||||
// These are the parameters given by the XBE,
|
||||
// we save them to be able to return them when necessary.
|
||||
DWORD* pXboxDeclarationCopy;
|
||||
DWORD XboxDeclarationCount; // Xbox's number of DWORD-sized X_D3DVSD* tokens
|
||||
DWORD XboxFunctionSize;
|
||||
DWORD* pXboxFunctionCopy;
|
||||
UINT XboxNrAddressSlots;
|
||||
|
|
@ -90,12 +92,10 @@ typedef struct _CxbxVertexShader
|
|||
// DWORD XboxStatus; // Used by VshHandleIsValidShader()
|
||||
|
||||
// The resulting host variables
|
||||
DWORD HostFVF; // Flexible Vertex Format (used when there's no host vertex shader)
|
||||
uint64_t VertexShaderKey; // if nullptr, use SetFVF(HostFVF);
|
||||
IDirect3DVertexDeclaration* pHostVertexDeclaration;
|
||||
|
||||
// Needed for dynamic stream patching
|
||||
CxbxVertexShaderInfo VertexShaderInfo;
|
||||
CxbxVertexDeclaration Declaration;
|
||||
}
|
||||
CxbxVertexShader;
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ extern D3DVERTEXELEMENT *EmuRecompileVshDeclaration
|
|||
DWORD *pXboxDeclaration,
|
||||
bool bIsFixedFunction,
|
||||
DWORD *pXboxDeclarationCount,
|
||||
CxbxVertexShaderInfo *pCxbxVertexShaderInfo
|
||||
CxbxVertexDeclaration *pCxbxVertexDeclaration
|
||||
);
|
||||
|
||||
// Intermediate vertex shader structures
|
||||
|
|
|
|||
Loading…
Reference in New Issue