ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/Cxbx-Reloaded/master'

This commit is contained in:
PatrickvL 2017-05-01 08:50:13 +02:00
parent 205a19b9a0 394aee6b9c
commit 3f7f94f2a5
29 changed files with 1127 additions and 996 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
resource/Cxbx.aps
View File

Binary file not shown.

5
resource/Cxbx.rc
View File

@ -131,6 +131,11 @@ BEGIN
MENUITEM "Config &Audio...", ID_SETTINGS_CONFIGURESOUND, GRAYED MENUITEM "Config &Audio...", ID_SETTINGS_CONFIGURESOUND, GRAYED
MENUITEM "Config &Video...", ID_SETTINGS_CONFIG_VIDEO MENUITEM "Config &Video...", ID_SETTINGS_CONFIG_VIDEO
MENUITEM SEPARATOR MENUITEM SEPARATOR
POPUP "&HLE Cache"
BEGIN
MENUITEM "&Clear HLE Cache", ID_CACHE_CLEARHLECACHE
END
MENUITEM SEPARATOR
POPUP "&LLE (Experimental)" POPUP "&LLE (Experimental)"
BEGIN BEGIN
MENUITEM "LLE &JIT", ID_EMULATION_LLE_JIT MENUITEM "LLE &JIT", ID_EMULATION_LLE_JIT

4
src/Cxbx/ResCxbx.h
View File

@ -90,6 +90,8 @@
#define ID_EDIT_DUMPXBEINFOTO_FILE 40071 #define ID_EDIT_DUMPXBEINFOTO_FILE 40071
#define ID_EDIT_DUMPXBEINFOTO_DEBUGCONSOLE 40072 #define ID_EDIT_DUMPXBEINFOTO_DEBUGCONSOLE 40072
#define ID_EMULATION_STOP 40082 #define ID_EMULATION_STOP 40082
#define ID_SETTINGS_CACHE 40083
#define ID_CACHE_CLEARHLECACHE 40084
#define IDC_STATIC -1 #define IDC_STATIC -1
// Next default values for new objects // Next default values for new objects
@ -97,7 +99,7 @@
#ifdef APSTUDIO_INVOKED #ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS #ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 130 #define _APS_NEXT_RESOURCE_VALUE 130
#define _APS_NEXT_COMMAND_VALUE 40083 #define _APS_NEXT_COMMAND_VALUE 40085
#define _APS_NEXT_CONTROL_VALUE 1058 #define _APS_NEXT_CONTROL_VALUE 1058
#define _APS_NEXT_SYMED_VALUE 104 #define _APS_NEXT_SYMED_VALUE 104
#endif #endif

3
src/Cxbx/WinMain.cpp
View File

@ -59,6 +59,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
return 1; return 1;
} }
/* Initialize Cxbx File Paths */
CxbxInitFilePaths();
/*! initialize shared memory */ /*! initialize shared memory */
EmuShared::Init(); EmuShared::Init();

29
src/Cxbx/WndMain.cpp
View File

@ -867,6 +867,35 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
ShowVideoConfig(hwnd); ShowVideoConfig(hwnd);
break; break;
case ID_CACHE_CLEARHLECACHE:
{
std::string cacheDir = std::string(XTL::szFolder_CxbxReloadedData) + "\\HLECache\\";
std::string fullpath = cacheDir + "*.ini";
WIN32_FIND_DATA data;
HANDLE hFind = FindFirstFile(fullpath.c_str(), &data);
if (hFind != INVALID_HANDLE_VALUE) {
BOOL bContinue = TRUE;
do {
if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
fullpath = cacheDir + data.cFileName;
if (!DeleteFile(fullpath.c_str())) {
break;
}
}
bContinue = FindNextFile(hFind, &data);
} while (bContinue);
FindClose(hFind);
}
MessageBox(m_hwnd, "The HLE Cache has been cleared.", "Cxbx-Reloaded", MB_OK);
}
break;
case ID_EMULATION_DEBUGOUTPUTKERNEL_CONSOLE: case ID_EMULATION_DEBUGOUTPUTKERNEL_CONSOLE:
{ {
if(m_KrnlDebug == DM_NONE || m_KrnlDebug == DM_FILE) if(m_KrnlDebug == DM_NONE || m_KrnlDebug == DM_FILE)

6
src/CxbxKrnl/CxbxKrnl.cpp
View File

@ -396,8 +396,6 @@ void CxbxKrnlMain(int argc, char* argv[])
RestoreExeImageHeader(); RestoreExeImageHeader();
} }
CxbxInitFilePaths();
CxbxRestoreContiguousMemory(szFilePath_memory_bin); CxbxRestoreContiguousMemory(szFilePath_memory_bin);
CxbxRestorePersistentMemoryRegions(); CxbxRestorePersistentMemoryRegions();
@ -756,6 +754,9 @@ void CxbxKrnlInit
// initialize grapchics // initialize grapchics
DbgPrintf("EmuMain: Initializing render window.\n"); DbgPrintf("EmuMain: Initializing render window.\n");
XTL::CxbxInitWindow(pXbeHeader, dwXbeHeaderSize); XTL::CxbxInitWindow(pXbeHeader, dwXbeHeaderSize);
EmuHLEIntercept(pXbeHeader);
if (bLLE_GPU) if (bLLE_GPU)
{ {
DbgPrintf("EmuMain: Initializing OpenGL.\n"); DbgPrintf("EmuMain: Initializing OpenGL.\n");
@ -767,7 +768,6 @@ void CxbxKrnlInit
XTL::EmuD3DInit(); XTL::EmuD3DInit();
} }
EmuHLEIntercept(pXbeHeader);
// Apply Media Patches to bypass Anti-Piracy checks // Apply Media Patches to bypass Anti-Piracy checks
// Required until we perfect emulation of X2 DVD Authentication // Required until we perfect emulation of X2 DVD Authentication
// See: https://multimedia.cx/eggs/xbox-sphinx-protocol/ // See: https://multimedia.cx/eggs/xbox-sphinx-protocol/

783
src/CxbxKrnl/EmuD3D8.cpp
View File

File diff suppressed because it is too large Load Diff

59
src/CxbxKrnl/EmuD3D8.h
View File

@ -67,7 +67,7 @@ extern VOID EmuD3DCleanup();
extern X_D3DTILE EmuD3DTileCache[0x08]; extern X_D3DTILE EmuD3DTileCache[0x08];
// EmuD3DActiveTexture // EmuD3DActiveTexture
extern X_D3DResource *EmuD3DActiveTexture[4]; extern X_D3DPixelContainer *EmuD3DActiveTexture[TEXTURE_STAGES];
// ****************************************************************** // ******************************************************************
// * patch: Direct3D_CreateDevice // * patch: Direct3D_CreateDevice
@ -1208,7 +1208,7 @@ HRESULT WINAPI EMUPATCH(D3DDevice_GetTransform)
// ****************************************************************** // ******************************************************************
VOID WINAPI EMUPATCH(D3DVertexBuffer_Lock) VOID WINAPI EMUPATCH(D3DVertexBuffer_Lock)
( (
X_D3DVertexBuffer *ppVertexBuffer, X_D3DVertexBuffer *pVertexBuffer,
UINT OffsetToLock, UINT OffsetToLock,
UINT SizeToLock, UINT SizeToLock,
BYTE **ppbData, BYTE **ppbData,
@ -1220,7 +1220,7 @@ VOID WINAPI EMUPATCH(D3DVertexBuffer_Lock)
// ****************************************************************** // ******************************************************************
BYTE* WINAPI EMUPATCH(D3DVertexBuffer_Lock2) BYTE* WINAPI EMUPATCH(D3DVertexBuffer_Lock2)
( (
X_D3DVertexBuffer *ppVertexBuffer, X_D3DVertexBuffer *pVertexBuffer,
DWORD Flags DWORD Flags
); );
@ -1629,14 +1629,16 @@ VOID WINAPI EMUPATCH(D3DResource_BlockUntilNotBusy)
X_D3DResource *pThis X_D3DResource *pThis
); );
#if 0 // patch DISABLED
// ****************************************************************** // ******************************************************************
// * patch: D3DVertexBuffer_GetDesc // * patch: D3DVertexBuffer_GetDesc
// ****************************************************************** // ******************************************************************
VOID WINAPI EMUPATCH(D3DVertexBuffer_GetDesc) VOID WINAPI EMUPATCH(D3DVertexBuffer_GetDesc)
( (
X_D3DVertexBuffer *pThis, X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc X_D3DVERTEXBUFFER_DESC *pDesc
); );
#endif
// ****************************************************************** // ******************************************************************
// * patch: D3DDevice_SetScissors // * patch: D3DDevice_SetScissors
@ -1657,46 +1659,6 @@ HRESULT WINAPI EMUPATCH(D3DDevice_SetScreenSpaceOffset)
FLOAT y FLOAT y
); );
// ******************************************************************
// * patch: D3DDevice_InsertFence
// ******************************************************************
DWORD WINAPI EMUPATCH(D3DDevice_InsertFence)();
// ******************************************************************
// * patch: D3DDevice_BlockOnFence
// ******************************************************************
VOID WINAPI EMUPATCH(D3DDevice_BlockOnFence)
(
DWORD Fence
);
// ******************************************************************
// * patch: D3DResource_BlockUntilNotBusy
// ******************************************************************
VOID WINAPI EMUPATCH(D3DResource_BlockUntilNotBusy)
(
X_D3DResource *pThis
);
// ******************************************************************
// * patch: D3DVertexBuffer_GetDesc
// ******************************************************************
VOID WINAPI EMUPATCH(D3DVertexBuffer_GetDesc)
(
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
);
// ******************************************************************
// * patch: D3DDevice_SetScissors
// ******************************************************************
HRESULT WINAPI EMUPATCH(D3DDevice_SetScissors)
(
DWORD Count,
BOOL Exclusive,
CONST D3DRECT *pRects
);
// ****************************************************************** // ******************************************************************
// * patch: D3DDevice_SetPixelShaderProgram // * patch: D3DDevice_SetPixelShaderProgram
// ****************************************************************** // ******************************************************************
@ -1705,15 +1667,6 @@ HRESULT WINAPI EMUPATCH(D3DDevice_SetPixelShaderProgram)
X_D3DPIXELSHADERDEF *pPSDef X_D3DPIXELSHADERDEF *pPSDef
); );
// ******************************************************************
// * patch: D3DDevice_SetScreenSpaceOffset
// ******************************************************************
HRESULT WINAPI EMUPATCH(D3DDevice_SetScreenSpaceOffset)
(
FLOAT x,
FLOAT y
);
// ****************************************************************** // ******************************************************************
// * patch: D3DDevice_CreateStateBlock // * patch: D3DDevice_CreateStateBlock
// ****************************************************************** // ******************************************************************

2
src/CxbxKrnl/EmuD3D8/PushBuffer.cpp
View File

@ -74,7 +74,7 @@ void XTL::EmuExecutePushBuffer
static void EmuUnswizzleActiveTexture() static void EmuUnswizzleActiveTexture()
{ {
// for current usages, we're always on stage 0 // for current usages, we're always on stage 0
XTL::X_D3DPixelContainer *pPixelContainer = (XTL::X_D3DPixelContainer*)XTL::EmuD3DActiveTexture[0]; XTL::X_D3DPixelContainer *pPixelContainer = XTL::EmuD3DActiveTexture[0];
if(pPixelContainer == NULL || !(pPixelContainer->Common & X_D3DCOMMON_ISLOCKED)) if(pPixelContainer == NULL || !(pPixelContainer->Common & X_D3DCOMMON_ISLOCKED))
return; return;

152
src/CxbxKrnl/EmuD3D8/VertexBuffer.cpp
View File

@ -52,10 +52,10 @@
#define MAX_STREAM_NOT_USED_TIME (2 * CLOCKS_PER_SEC) // TODO: Trim the not used time #define MAX_STREAM_NOT_USED_TIME (2 * CLOCKS_PER_SEC) // TODO: Trim the not used time
// inline vertex buffer emulation // inline vertex buffer emulation
XTL::DWORD *XTL::g_pIVBVertexBuffer = 0; XTL::DWORD *XTL::g_pIVBVertexBuffer = nullptr;
XTL::X_D3DPRIMITIVETYPE XTL::g_IVBPrimitiveType = XTL::X_D3DPT_INVALID; XTL::X_D3DPRIMITIVETYPE XTL::g_IVBPrimitiveType = XTL::X_D3DPT_INVALID;
UINT XTL::g_IVBTblOffs = 0; UINT XTL::g_IVBTblOffs = 0;
struct XTL::_D3DIVB *XTL::g_IVBTable = 0; struct XTL::_D3DIVB *XTL::g_IVBTable = nullptr;
extern DWORD XTL::g_IVBFVF = 0; extern DWORD XTL::g_IVBFVF = 0;
extern XTL::X_D3DVertexBuffer *g_pVertexBuffer = NULL; extern XTL::X_D3DVertexBuffer *g_pVertexBuffer = NULL;
@ -100,7 +100,7 @@ void XTL::VertexPatcher::CacheStream(VertexPatchDesc *pPatchDesc,
UINT uiStream) UINT uiStream)
{ {
UINT uiStride; UINT uiStride;
IDirect3DVertexBuffer8 *pOrigVertexBuffer; IDirect3DVertexBuffer8 *pOrigVertexBuffer = nullptr;
XTL::D3DVERTEXBUFFER_DESC Desc; XTL::D3DVERTEXBUFFER_DESC Desc;
void *pCalculateData = NULL; void *pCalculateData = NULL;
uint32 uiKey; uint32 uiKey;
@ -177,7 +177,7 @@ void XTL::VertexPatcher::CacheStream(VertexPatchDesc *pPatchDesc,
} }
uint32_t uiHash = XXHash32::hash((void *)pCalculateData, uiLength, HASH_SEED); uint32_t uiHash = XXHash32::hash((void *)pCalculateData, uiLength, HASH_SEED);
if(!pPatchDesc->pVertexStreamZeroData) if(pOrigVertexBuffer)
{ {
pOrigVertexBuffer->Unlock(); pOrigVertexBuffer->Unlock();
} }
@ -222,7 +222,7 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
bool *pbFatalError) bool *pbFatalError)
{ {
UINT uiStride; UINT uiStride;
IDirect3DVertexBuffer8 *pOrigVertexBuffer; IDirect3DVertexBuffer8 *pOrigVertexBuffer = nullptr;
XTL::D3DVERTEXBUFFER_DESC Desc; XTL::D3DVERTEXBUFFER_DESC Desc;
void *pCalculateData = NULL; void *pCalculateData = NULL;
UINT uiLength; UINT uiLength;
@ -232,7 +232,10 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
if(!pPatchDesc->pVertexStreamZeroData) if(!pPatchDesc->pVertexStreamZeroData)
{ {
g_pD3DDevice8->GetStreamSource(uiStream, &pOrigVertexBuffer, &uiStride); g_pD3DDevice8->GetStreamSource(
uiStream,
&pOrigVertexBuffer,
&uiStride);
if(!pOrigVertexBuffer) if(!pOrigVertexBuffer)
{ {
/*if(!g_pVertexBuffer || !g_pVertexBuffer->EmuVertexBuffer8) /*if(!g_pVertexBuffer || !g_pVertexBuffer->EmuVertexBuffer8)
@ -261,6 +264,7 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
{ {
CxbxKrnlCleanup("Trying to find a cached Draw..UP with more than stream zero!"); CxbxKrnlCleanup("Trying to find a cached Draw..UP with more than stream zero!");
} }
uiStride = pPatchDesc->uiVertexStreamZeroStride; uiStride = pPatchDesc->uiVertexStreamZeroStride;
pCalculateData = (uint08 *)pPatchDesc->pVertexStreamZeroData; pCalculateData = (uint08 *)pPatchDesc->pVertexStreamZeroData;
// TODO: This is sometimes the number of indices, which isn't too good // TODO: This is sometimes the number of indices, which isn't too good
@ -279,13 +283,14 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
bool bMismatch = false; bool bMismatch = false;
if(pCachedStream->uiCount == (pCachedStream->uiCheckFrequency - 1)) if(pCachedStream->uiCount == (pCachedStream->uiCheckFrequency - 1))
{ {
if(!pPatchDesc->pVertexStreamZeroData) if(pOrigVertexBuffer)
{ {
if(FAILED(pOrigVertexBuffer->Lock(0, 0, (uint08**)&pCalculateData, 0))) if(FAILED(pOrigVertexBuffer->Lock(0, 0, (uint08**)&pCalculateData, 0)))
{ {
CxbxKrnlCleanup("Couldn't lock the original buffer"); CxbxKrnlCleanup("Couldn't lock the original buffer");
} }
} }
// Use the cached stream length (which is a must for the UP stream) // Use the cached stream length (which is a must for the UP stream)
uint32_t uiHash = XXHash32::hash((void *)pCalculateData, pCachedStream->uiLength, HASH_SEED); uint32_t uiHash = XXHash32::hash((void *)pCalculateData, pCachedStream->uiLength, HASH_SEED);
if(uiHash == pCachedStream->uiHash) if(uiHash == pCachedStream->uiHash)
@ -311,7 +316,8 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
pCachedStream = NULL; pCachedStream = NULL;
bMismatch = true; bMismatch = true;
} }
if(!pPatchDesc->pVertexStreamZeroData)
if(pOrigVertexBuffer)
{ {
pOrigVertexBuffer->Unlock(); pOrigVertexBuffer->Unlock();
} }
@ -320,6 +326,7 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
{ {
pCachedStream->uiCount++; pCachedStream->uiCount++;
} }
if(!bMismatch) if(!bMismatch)
{ {
if(!pCachedStream->bIsUP) if(!pCachedStream->bIsUP)
@ -337,18 +344,21 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
pPatchDesc->pVertexStreamZeroData = pCachedStream->pStreamUP; pPatchDesc->pVertexStreamZeroData = pCachedStream->pStreamUP;
pPatchDesc->uiVertexStreamZeroStride = pCachedStream->Stream.uiNewStride; pPatchDesc->uiVertexStreamZeroStride = pCachedStream->Stream.uiNewStride;
} }
if(pCachedStream->dwPrimitiveCount) if(pCachedStream->dwPrimitiveCount)
{ {
// The primitives were patched, draw with the correct number of primimtives from the cache // The primitives were patched, draw with the correct number of primimtives from the cache
pPatchDesc->dwPrimitiveCount = pCachedStream->dwPrimitiveCount; pPatchDesc->dwPrimitiveCount = pCachedStream->dwPrimitiveCount;
} }
bApplied = true; bApplied = true;
m_bPatched = true; m_bPatched = true;
} }
} }
g_PatchedStreamsCache.Unlock(); g_PatchedStreamsCache.Unlock();
if(!pPatchDesc->pVertexStreamZeroData) if(pOrigVertexBuffer)
{ {
pOrigVertexBuffer->Release(); pOrigVertexBuffer->Release();
} }
@ -358,9 +368,9 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
UINT XTL::VertexPatcher::GetNbrStreams(VertexPatchDesc *pPatchDesc) UINT XTL::VertexPatcher::GetNbrStreams(VertexPatchDesc *pPatchDesc)
{ {
if(VshHandleIsVertexShader(g_CurrentVertexShader)) if(VshHandleIsVertexShader(pPatchDesc->hVertexShader))
{ {
VERTEX_DYNAMIC_PATCH *pDynamicPatch = VshGetVertexDynamicPatch(g_CurrentVertexShader); VERTEX_DYNAMIC_PATCH *pDynamicPatch = VshGetVertexDynamicPatch(pPatchDesc->hVertexShader);
if(pDynamicPatch) if(pDynamicPatch)
{ {
return pDynamicPatch->NbrStreams; return pDynamicPatch->NbrStreams;
@ -370,7 +380,7 @@ UINT XTL::VertexPatcher::GetNbrStreams(VertexPatchDesc *pPatchDesc)
return 1; // Could be more, but it doesn't matter as we're not going to patch the types return 1; // Could be more, but it doesn't matter as we're not going to patch the types
} }
} }
else if(g_CurrentVertexShader) else if(pPatchDesc->hVertexShader)
{ {
return 1; return 1;
} }
@ -405,6 +415,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
IDirect3DVertexBuffer8 *pNewVertexBuffer; IDirect3DVertexBuffer8 *pNewVertexBuffer;
uint08 *pOrigData; uint08 *pOrigData;
uint08 *pNewData; uint08 *pNewData;
UINT uiVertexCount;
UINT uiStride; UINT uiStride;
XTL::D3DVERTEXBUFFER_DESC Desc; XTL::D3DVERTEXBUFFER_DESC Desc;
PATCHEDSTREAM *pStream = &m_pStreams[uiStream]; PATCHEDSTREAM *pStream = &m_pStreams[uiStream];
@ -413,14 +424,21 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
if(!pPatchDesc->pVertexStreamZeroData) if(!pPatchDesc->pVertexStreamZeroData)
{ {
g_pD3DDevice8->GetStreamSource(uiStream, &pOrigVertexBuffer, &uiStride); g_pD3DDevice8->GetStreamSource(
uiStream,
&pOrigVertexBuffer,
&uiStride);
if(FAILED(pOrigVertexBuffer->GetDesc(&Desc))) if(FAILED(pOrigVertexBuffer->GetDesc(&Desc)))
{ {
CxbxKrnlCleanup("Could not retrieve original buffer size"); CxbxKrnlCleanup("Could not retrieve original buffer size");
} }
// Set a new (exact) vertex count // Set a new (exact) vertex count
pPatchDesc->dwVertexCount = Desc.Size / uiStride; uiVertexCount = Desc.Size / uiStride;
dwNewSize = pPatchDesc->dwVertexCount * pStreamPatch->ConvertedStride; // Dxbx addition : Don't update pPatchDesc.dwVertexCount because an indexed draw
// can (and will) use less vertices than the supplied nr of indexes. Thix fixes
// the missing parts in the CompressedVertices sample (in Vertex shader mode).
pStreamPatch->ConvertedStride = max(pStreamPatch->ConvertedStride, uiStride); // ??
dwNewSize = uiVertexCount * pStreamPatch->ConvertedStride;
if(FAILED(pOrigVertexBuffer->Lock(0, 0, &pOrigData, 0))) if(FAILED(pOrigVertexBuffer->Lock(0, 0, &pOrigData, 0)))
{ {
@ -445,9 +463,11 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
CxbxKrnlCleanup("Trying to patch a Draw..UP with more than stream zero!"); CxbxKrnlCleanup("Trying to patch a Draw..UP with more than stream zero!");
} }
uiStride = pPatchDesc->uiVertexStreamZeroStride; uiStride = pPatchDesc->uiVertexStreamZeroStride;
pStreamPatch->ConvertedStride = max(pStreamPatch->ConvertedStride, uiStride); // ??
pOrigData = (uint08 *)pPatchDesc->pVertexStreamZeroData; pOrigData = (uint08 *)pPatchDesc->pVertexStreamZeroData;
// TODO: This is sometimes the number of indices, which isn't too good // TODO: This is sometimes the number of indices, which isn't too good
dwNewSize = pPatchDesc->dwVertexCount * pStreamPatch->ConvertedStride; uiVertexCount = pPatchDesc->dwVertexCount;
dwNewSize = uiVertexCount * pStreamPatch->ConvertedStride;
pNewVertexBuffer = NULL; pNewVertexBuffer = NULL;
pNewData = (uint08*)g_MemoryManager.Allocate(dwNewSize); pNewData = (uint08*)g_MemoryManager.Allocate(dwNewSize);
if(!pNewData) if(!pNewData)
@ -456,7 +476,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
} }
} }
for (uint32 uiVertex = 0; uiVertex < pPatchDesc->dwVertexCount; uiVertex++) for (uint32 uiVertex = 0; uiVertex < uiVertexCount; uiVertex++)
{ {
uint08 *pOrigVertex = &pOrigData[uiVertex * uiStride]; uint08 *pOrigVertex = &pOrigData[uiVertex * uiStride];
uint08 *pNewDataPos = &pNewData[uiVertex * pStreamPatch->ConvertedStride]; uint08 *pNewDataPos = &pNewData[uiVertex * pStreamPatch->ConvertedStride];
@ -509,6 +529,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
break; break;
} }
case X_D3DVSDT_PBYTE4: { // 0x44: // Make it FLOAT4 case X_D3DVSDT_PBYTE4: { // 0x44: // Make it FLOAT4
// Hit by Jet Set Radio Future
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((BYTE*)pOrigVertex)[0]) / 255.0f; ((FLOAT *)pNewDataPos)[0] = ((FLOAT)((BYTE*)pOrigVertex)[0]) / 255.0f;
((FLOAT *)pNewDataPos)[1] = ((FLOAT)((BYTE*)pOrigVertex)[1]) / 255.0f; ((FLOAT *)pNewDataPos)[1] = ((FLOAT)((BYTE*)pOrigVertex)[1]) / 255.0f;
((FLOAT *)pNewDataPos)[2] = ((FLOAT)((BYTE*)pOrigVertex)[2]) / 255.0f; ((FLOAT *)pNewDataPos)[2] = ((FLOAT)((BYTE*)pOrigVertex)[2]) / 255.0f;
@ -519,9 +540,11 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
case X_D3DVSDT_NORMSHORT1: { // 0x11: // Make it FLOAT1 case X_D3DVSDT_NORMSHORT1: { // 0x11: // Make it FLOAT1
// UNTESTED - Need test-case! // UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f; ((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
//((FLOAT *)pNewDataPos)[1] = 0.0f; // Would be needed for FLOAT2
pOrigVertex += 1 * sizeof(SHORT); pOrigVertex += 1 * sizeof(SHORT);
break; break;
} }
#if !DXBX_USE_D3D9 // No need for patching in D3D9
case X_D3DVSDT_NORMSHORT2: { // 0x21: // Make it FLOAT2 case X_D3DVSDT_NORMSHORT2: { // 0x21: // Make it FLOAT2
// UNTESTED - Need test-case! // UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f; ((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -529,6 +552,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 2 * sizeof(SHORT); pOrigVertex += 2 * sizeof(SHORT);
break; break;
} }
#endif
case X_D3DVSDT_NORMSHORT3: { // 0x31: // Make it FLOAT3 case X_D3DVSDT_NORMSHORT3: { // 0x31: // Make it FLOAT3
// UNTESTED - Need test-case! // UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f; ((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -537,6 +561,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 3 * sizeof(SHORT); pOrigVertex += 3 * sizeof(SHORT);
break; break;
} }
#if !DXBX_USE_D3D9 // No need for patching in D3D9
case X_D3DVSDT_NORMSHORT4: { // 0x41: // Make it FLOAT4 case X_D3DVSDT_NORMSHORT4: { // 0x41: // Make it FLOAT4
// UNTESTED - Need test-case! // UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f; ((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -546,6 +571,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 4 * sizeof(SHORT); pOrigVertex += 4 * sizeof(SHORT);
break; break;
} }
#endif
case X_D3DVSDT_FLOAT2H: { // 0x72: // Make it FLOAT4 and set the third float to 0.0 case X_D3DVSDT_FLOAT2H: { // 0x72: // Make it FLOAT4 and set the third float to 0.0
((FLOAT *)pNewDataPos)[0] = ((FLOAT*)pOrigVertex)[0]; ((FLOAT *)pNewDataPos)[0] = ((FLOAT*)pOrigVertex)[0];
((FLOAT *)pNewDataPos)[1] = ((FLOAT*)pOrigVertex)[1]; ((FLOAT *)pNewDataPos)[1] = ((FLOAT*)pOrigVertex)[1];
@ -619,7 +645,7 @@ bool XTL::VertexPatcher::NormalizeTexCoords(VertexPatchDesc *pPatchDesc, UINT ui
for(uint08 i = 0; i < 4; i++) for(uint08 i = 0; i < 4; i++)
{ {
X_D3DPixelContainer *pPixelContainer = (X_D3DPixelContainer*)EmuD3DActiveTexture[i]; X_D3DPixelContainer *pPixelContainer = EmuD3DActiveTexture[i];
if (pPixelContainer) if (pPixelContainer)
{ {
XTL::X_D3DFORMAT XBFormat = (XTL::X_D3DFORMAT)((pPixelContainer->Format & X_D3DFORMAT_FORMAT_MASK) >> X_D3DFORMAT_FORMAT_SHIFT); XTL::X_D3DFORMAT XBFormat = (XTL::X_D3DFORMAT)((pPixelContainer->Format & X_D3DFORMAT_FORMAT_MASK) >> X_D3DFORMAT_FORMAT_SHIFT);
@ -830,10 +856,10 @@ bool XTL::VertexPatcher::PatchPrimitive(VertexPatchDesc *pPatchDesc,
DWORD dwNewSizeWR = 0; DWORD dwNewSizeWR = 0;
// vertex data arrays // vertex data arrays
BYTE *pOrigVertexData = 0; BYTE *pOrigVertexData = nullptr;
BYTE *pPatchedVertexData = 0; BYTE *pPatchedVertexData = nullptr;
if(pPatchDesc->pVertexStreamZeroData == 0) if(pPatchDesc->pVertexStreamZeroData == nullptr)
{ {
g_pD3DDevice8->GetStreamSource(0, &pStream->pOriginalStream, &pStream->uiOrigStride); g_pD3DDevice8->GetStreamSource(0, &pStream->pOriginalStream, &pStream->uiOrigStride);
pStream->uiNewStride = pStream->uiOrigStride; // The stride is still the same pStream->uiNewStride = pStream->uiOrigStride; // The stride is still the same
@ -862,7 +888,7 @@ bool XTL::VertexPatcher::PatchPrimitive(VertexPatchDesc *pPatchDesc,
dwNewSize = pPatchDesc->dwPrimitiveCount * pStream->uiOrigStride + pStream->uiOrigStride; dwNewSize = pPatchDesc->dwPrimitiveCount * pStream->uiOrigStride + pStream->uiOrigStride;
} }
if(pPatchDesc->pVertexStreamZeroData == 0) if(pPatchDesc->pVertexStreamZeroData == nullptr)
{ {
// Retrieve the original buffer size // Retrieve the original buffer size
{ {
@ -965,7 +991,7 @@ bool XTL::VertexPatcher::PatchPrimitive(VertexPatchDesc *pPatchDesc,
memcpy(&pPatchedVertexData[pPatchDesc->dwOffset + dwOriginalSize], &pOrigVertexData[pPatchDesc->dwOffset], pStream->uiOrigStride); memcpy(&pPatchedVertexData[pPatchDesc->dwOffset + dwOriginalSize], &pOrigVertexData[pPatchDesc->dwOffset], pStream->uiOrigStride);
} }
if(pPatchDesc->pVertexStreamZeroData == 0) if(pPatchDesc->pVertexStreamZeroData == nullptr)
{ {
pStream->pOriginalStream->Unlock(); pStream->pOriginalStream->Unlock();
pStream->pPatchedStream->Unlock(); pStream->pPatchedStream->Unlock();
@ -1039,6 +1065,9 @@ bool XTL::VertexPatcher::Restore()
if(this->m_bAllocatedStreamZeroData) if(this->m_bAllocatedStreamZeroData)
{ {
free(m_pNewVertexStreamZeroData); free(m_pNewVertexStreamZeroData);
// Cleanup, just to be sure :
m_pNewVertexStreamZeroData = nullptr;
this->m_bAllocatedStreamZeroData = false;
} }
} }
else else
@ -1055,7 +1084,7 @@ VOID XTL::EmuFlushIVB()
{ {
XTL::EmuUpdateDeferredStates(); XTL::EmuUpdateDeferredStates();
DWORD *pdwVB = (DWORD*)g_IVBTable; DWORD *pdwVB = (DWORD*)g_pIVBVertexBuffer;
UINT uiStride = 0; UINT uiStride = 0;
@ -1080,23 +1109,18 @@ VOID XTL::EmuFlushIVB()
DbgPrintf("g_IVBTblOffs := %d\n", g_IVBTblOffs); DbgPrintf("g_IVBTblOffs := %d\n", g_IVBTblOffs);
DWORD dwPos = dwCurFVF & D3DFVF_POSITION_MASK;
DWORD dwTexN = (dwCurFVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
for(uint v=0;v<g_IVBTblOffs;v++) for(uint v=0;v<g_IVBTblOffs;v++)
{ {
DWORD dwPos = dwCurFVF & D3DFVF_POSITION_MASK;
if(dwPos == D3DFVF_XYZ) if(dwPos == D3DFVF_XYZ)
{ {
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.x; *(FLOAT*)pdwVB++ = g_IVBTable[v].Position.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].Position.y;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z; *(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z;
if(v == 0)
{
uiStride += (sizeof(FLOAT)*3);
}
DbgPrintf("IVB Position := {%f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z); DbgPrintf("IVB Position := {%f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z);
} }
else if(dwPos == D3DFVF_XYZRHW) else if(dwPos == D3DFVF_XYZRHW)
{ {
@ -1105,11 +1129,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z; *(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Rhw; *(FLOAT*)pdwVB++ = g_IVBTable[v].Rhw;
if(v == 0)
{
uiStride += (sizeof(FLOAT)*4);
}
DbgPrintf("IVB Position := {%f, %f, %f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z, g_IVBTable[v].Position.z, g_IVBTable[v].Rhw); DbgPrintf("IVB Position := {%f, %f, %f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z, g_IVBTable[v].Position.z, g_IVBTable[v].Rhw);
} }
else if(dwPos == D3DFVF_XYZB1) else if(dwPos == D3DFVF_XYZB1)
@ -1119,14 +1138,8 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z; *(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Blend1; *(FLOAT*)pdwVB++ = g_IVBTable[v].Blend1;
if(v == 0)
{
uiStride += (sizeof(FLOAT)*4);
}
DbgPrintf("IVB Position := {%f, %f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z, g_IVBTable[v].Blend1); DbgPrintf("IVB Position := {%f, %f, %f, %f}\n", g_IVBTable[v].Position.x, g_IVBTable[v].Position.y, g_IVBTable[v].Position.z, g_IVBTable[v].Blend1);
} }
else else
{ {
CxbxKrnlCleanup("Unsupported Position Mask (FVF := 0x%.08X dwPos := 0x%.08X)", dwCurFVF, dwPos); CxbxKrnlCleanup("Unsupported Position Mask (FVF := 0x%.08X dwPos := 0x%.08X)", dwCurFVF, dwPos);
@ -1139,24 +1152,13 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].Normal.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].Normal.y;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Normal.z; *(FLOAT*)pdwVB++ = g_IVBTable[v].Normal.z;
if(v == 0)
{
uiStride += (sizeof(FLOAT)*3);
}
DbgPrintf("IVB Normal := {%f, %f, %f}\n", g_IVBTable[v].Normal.x, g_IVBTable[v].Normal.y, g_IVBTable[v].Normal.z); DbgPrintf("IVB Normal := {%f, %f, %f}\n", g_IVBTable[v].Normal.x, g_IVBTable[v].Normal.y, g_IVBTable[v].Normal.z);
} }
if(dwCurFVF & D3DFVF_DIFFUSE) if(dwCurFVF & D3DFVF_DIFFUSE)
{ {
*(DWORD*)pdwVB++ = g_IVBTable[v].dwDiffuse; *(DWORD*)pdwVB++ = g_IVBTable[v].dwDiffuse;
if(v == 0)
{
uiStride += sizeof(DWORD);
}
DbgPrintf("IVB Diffuse := 0x%.08X\n", g_IVBTable[v].dwDiffuse); DbgPrintf("IVB Diffuse := 0x%.08X\n", g_IVBTable[v].dwDiffuse);
} }
@ -1164,26 +1166,14 @@ VOID XTL::EmuFlushIVB()
{ {
*(DWORD*)pdwVB++ = g_IVBTable[v].dwSpecular; *(DWORD*)pdwVB++ = g_IVBTable[v].dwSpecular;
if(v == 0)
{
uiStride += sizeof(DWORD);
}
DbgPrintf("IVB Specular := 0x%.08X\n", g_IVBTable[v].dwSpecular); DbgPrintf("IVB Specular := 0x%.08X\n", g_IVBTable[v].dwSpecular);
} }
DWORD dwTexN = (dwCurFVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
if(dwTexN >= 1) if(dwTexN >= 1)
{ {
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord1.x; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord1.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord1.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord1.y;
if(v == 0)
{
uiStride += sizeof(FLOAT)*2;
}
DbgPrintf("IVB TexCoord1 := {%f, %f}\n", g_IVBTable[v].TexCoord1.x, g_IVBTable[v].TexCoord1.y); DbgPrintf("IVB TexCoord1 := {%f, %f}\n", g_IVBTable[v].TexCoord1.x, g_IVBTable[v].TexCoord1.y);
} }
@ -1192,11 +1182,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord2.x; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord2.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord2.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord2.y;
if(v == 0)
{
uiStride += sizeof(FLOAT)*2;
}
DbgPrintf("IVB TexCoord2 := {%f, %f}\n", g_IVBTable[v].TexCoord2.x, g_IVBTable[v].TexCoord2.y); DbgPrintf("IVB TexCoord2 := {%f, %f}\n", g_IVBTable[v].TexCoord2.x, g_IVBTable[v].TexCoord2.y);
} }
@ -1205,11 +1190,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord3.x; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord3.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord3.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord3.y;
if(v == 0)
{
uiStride += sizeof(FLOAT)*2;
}
DbgPrintf("IVB TexCoord3 := {%f, %f}\n", g_IVBTable[v].TexCoord3.x, g_IVBTable[v].TexCoord3.y); DbgPrintf("IVB TexCoord3 := {%f, %f}\n", g_IVBTable[v].TexCoord3.x, g_IVBTable[v].TexCoord3.y);
} }
@ -1218,12 +1198,20 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.x; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.y; *(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.y;
if(v == 0) DbgPrintf("IVB TexCoord4 := {%f, %f}\n", g_IVBTable[v].TexCoord4.x, g_IVBTable[v].TexCoord4.y);
{
uiStride += sizeof(FLOAT)*2;
} }
DbgPrintf("IVB TexCoord4 := {%f, %f}\n", g_IVBTable[v].TexCoord4.x, g_IVBTable[v].TexCoord4.y); uint VertexBufferUsage = (BYTE *)pdwVB - (BYTE *)g_pIVBVertexBuffer;
if (v == 0)
{
// Stride is equal to the delta of the first vertex
uiStride = VertexBufferUsage;
}
if (VertexBufferUsage >= IVB_BUFFER_SIZE)
{
CxbxKrnlCleanup("Overflow g_pIVBVertexBuffer : %d", v);
} }
} }
@ -1232,7 +1220,7 @@ VOID XTL::EmuFlushIVB()
VPDesc.PrimitiveType = g_IVBPrimitiveType; VPDesc.PrimitiveType = g_IVBPrimitiveType;
VPDesc.dwVertexCount = g_IVBTblOffs; VPDesc.dwVertexCount = g_IVBTblOffs;
VPDesc.dwOffset = 0; VPDesc.dwOffset = 0;
VPDesc.pVertexStreamZeroData = g_IVBTable; VPDesc.pVertexStreamZeroData = g_pIVBVertexBuffer;
VPDesc.uiVertexStreamZeroStride = uiStride; VPDesc.uiVertexStreamZeroStride = uiStride;
VPDesc.hVertexShader = g_CurrentVertexShader; VPDesc.hVertexShader = g_CurrentVertexShader;
@ -1283,7 +1271,7 @@ VOID XTL::EmuUpdateActiveTexture() // Never called!
X_D3DFORMAT X_Format = (X_D3DFORMAT)((pPixelContainer->Format & X_D3DFORMAT_FORMAT_MASK) >> X_D3DFORMAT_FORMAT_SHIFT); X_D3DFORMAT X_Format = (X_D3DFORMAT)((pPixelContainer->Format & X_D3DFORMAT_FORMAT_MASK) >> X_D3DFORMAT_FORMAT_SHIFT);
if(X_Format != 0xCD && (pTexture->EmuResource8->GetType() == D3DRTYPE_TEXTURE)) if(X_Format != 0xCD && ((pTexture->Common & X_D3DCOMMON_TYPE_MASK) == X_D3DCOMMON_TYPE_TEXTURE))
{ {
DWORD dwWidth, dwHeight, dwBPP, dwDepth = 1, dwPitch = 0, dwMipMapLevels = 1; DWORD dwWidth, dwHeight, dwBPP, dwDepth = 1, dwPitch = 0, dwMipMapLevels = 1;
BOOL bSwizzled = FALSE, bCompressed = FALSE, dwCompressedSize = 0; BOOL bSwizzled = FALSE, bCompressed = FALSE, dwCompressedSize = 0;

5
src/CxbxKrnl/EmuD3D8/VertexBuffer.h
View File

@ -130,6 +130,11 @@ extern DWORD *g_pIVBVertexBuffer;
extern X_D3DPRIMITIVETYPE g_IVBPrimitiveType; extern X_D3DPRIMITIVETYPE g_IVBPrimitiveType;
extern DWORD g_IVBFVF; extern DWORD g_IVBFVF;
#define IVB_TABLE_SIZE 1024
#define IVB_BUFFER_SIZE sizeof(_D3DIVB)*1024
// TODO : Enlarge IVB_TABLE_SIZE and IVB_BUFFER_SIZE
// TODO : Calculate IVB_BUFFER_SIZE using sizeof(DWORD)
extern struct _D3DIVB extern struct _D3DIVB
{ {
XTL::D3DXVECTOR3 Position; // Position XTL::D3DXVECTOR3 Position; // Position

507
src/CxbxKrnl/EmuD3D8/VertexShader.cpp
View File

@ -43,6 +43,7 @@
#include "CxbxKrnl/EmuAlloc.h" #include "CxbxKrnl/EmuAlloc.h"
#include "CxbxKrnl/EmuXTL.h" #include "CxbxKrnl/EmuXTL.h"
#include "CxbxKrnl/MemoryManager.h" #include "CxbxKrnl/MemoryManager.h"
#include "CxbxKrnl/EmuD3D8Types.h" // For X_D3DVSDE_*
// **************************************************************************** // ****************************************************************************
// * Vertex shader function recompiler // * Vertex shader function recompiler
@ -56,6 +57,27 @@
#define VSH_XBOX_MAX_INSTRUCTION_COUNT 136 // The maximum Xbox shader instruction count #define VSH_XBOX_MAX_INSTRUCTION_COUNT 136 // The maximum Xbox shader instruction count
#define VSH_MAX_INTERMEDIATE_COUNT 1024 // The maximum number of intermediate format slots #define VSH_MAX_INTERMEDIATE_COUNT 1024 // The maximum number of intermediate format slots
typedef enum _VSH_SWIZZLE
{
SWIZZLE_X = 0,
SWIZZLE_Y,
SWIZZLE_Z,
SWIZZLE_W
}
VSH_SWIZZLE;
typedef struct DxbxSwizzles { VSH_SWIZZLE s[4]; } DxbxSwizzles;
typedef DWORD DxbxMask,
*PDxbxMask;
#define MASK_X 0x001
#define MASK_Y 0x002
#define MASK_Z 0x004
#define MASK_W 0x008
#define MASK_XYZ MASK_X | MASK_Y | MASK_Z
#define MASK_XYZW MASK_X | MASK_Y | MASK_Z | MASK_W
// Local types // Local types
typedef enum _VSH_FIELD_NAME typedef enum _VSH_FIELD_NAME
{ {
@ -114,34 +136,25 @@ VSH_FIELD_NAME;
typedef enum _VSH_OREG_NAME typedef enum _VSH_OREG_NAME
{ {
OREG_OPOS, OREG_OPOS, // 0
OREG_UNUSED1, OREG_UNUSED1, // 1
OREG_UNUSED2, OREG_UNUSED2, // 2
OREG_OD0, OREG_OD0, // 3
OREG_OD1, OREG_OD1, // 4
OREG_OFOG, OREG_OFOG, // 5
OREG_OPTS, OREG_OPTS, // 6
OREG_OB0, OREG_OB0, // 7
OREG_OB1, OREG_OB1, // 8
OREG_OT0, OREG_OT0, // 9
OREG_OT1, OREG_OT1, // 10
OREG_OT2, OREG_OT2, // 11
OREG_OT3, OREG_OT3, // 12
OREG_UNUSED3, OREG_UNUSED3, // 13
OREG_UNUSED4, OREG_UNUSED4, // 14
OREG_A0X OREG_A0X // 15 - all values of the 4 bits are used
} }
VSH_OREG_NAME; VSH_OREG_NAME;
typedef enum _VSH_PARAMETER_TYPE
{
PARAM_UNKNOWN = 0,
PARAM_R,
PARAM_V,
PARAM_C
}
VSH_PARAMETER_TYPE;
typedef enum _VSH_OUTPUT_TYPE typedef enum _VSH_OUTPUT_TYPE
{ {
OUTPUT_C = 0, OUTPUT_C = 0,
@ -149,6 +162,18 @@ typedef enum _VSH_OUTPUT_TYPE
} }
VSH_OUTPUT_TYPE; VSH_OUTPUT_TYPE;
typedef enum _VSH_ARGUMENT_TYPE
{
PARAM_UNKNOWN = 0,
PARAM_R, // Temporary registers
PARAM_V, // Vertex registers
PARAM_C, // Constant registers, set by SetVertexShaderConstant
PARAM_O
}
VSH_ARGUMENT_TYPE;
typedef VSH_ARGUMENT_TYPE VSH_PARAMETER_TYPE; // Alias, to indicate difference between a parameter and a generic argument
typedef enum _VSH_OUTPUT_MUX typedef enum _VSH_OUTPUT_MUX
{ {
OMUX_MAC = 0, OMUX_MAC = 0,
@ -156,6 +181,16 @@ typedef enum _VSH_OUTPUT_MUX
} }
VSH_OUTPUT_MUX; VSH_OUTPUT_MUX;
typedef enum _VSH_IMD_OUTPUT_TYPE
{
IMD_OUTPUT_C,
IMD_OUTPUT_R,
IMD_OUTPUT_O,
IMD_OUTPUT_A0X
}
VSH_IMD_OUTPUT_TYPE;
// Dxbx note : ILU stands for 'Inverse Logic Unit' opcodes
typedef enum _VSH_ILU typedef enum _VSH_ILU
{ {
ILU_NOP = 0, ILU_NOP = 0,
@ -165,13 +200,14 @@ typedef enum _VSH_ILU
ILU_RSQ, ILU_RSQ,
ILU_EXP, ILU_EXP,
ILU_LOG, ILU_LOG,
ILU_LIT ILU_LIT // = 7 - all values of the 3 bits are used
} }
VSH_ILU; VSH_ILU;
// Dxbx note : MAC stands for 'Multiply And Accumulate' opcodes
typedef enum _VSH_MAC typedef enum _VSH_MAC
{ {
MAC_NOP, MAC_NOP = 0,
MAC_MOV, MAC_MOV,
MAC_MUL, MAC_MUL,
MAC_ADD, MAC_ADD,
@ -185,28 +221,23 @@ typedef enum _VSH_MAC
MAC_SLT, MAC_SLT,
MAC_SGE, MAC_SGE,
MAC_ARL MAC_ARL
// ??? 14
// ??? 15 - 2 values of the 4 bits are undefined
} }
VSH_MAC; VSH_MAC;
typedef struct _VSH_OPCODE_PARAMS typedef struct _VSH_OPCODE_PARAMS
{ {
VSH_ILU ILU; // Dxbx Note : Since we split up g_OpCodeParams into g_OpCodeParams_ILU and g_OpCodeParams_MAC
VSH_MAC MAC; // the following two members aren't needed anymore :
// VSH_ILU ILU;
// VSH_MAC MAC;
boolean A; boolean A;
boolean B; boolean B;
boolean C; boolean C;
} }
VSH_OPCODE_PARAMS; VSH_OPCODE_PARAMS;
typedef enum _VSH_SWIZZLE
{
SWIZZLE_X = 0,
SWIZZLE_Y,
SWIZZLE_Z,
SWIZZLE_W
}
VSH_SWIZZLE;
typedef struct _VSH_PARAMETER typedef struct _VSH_PARAMETER
{ {
VSH_PARAMETER_TYPE ParameterType; // Parameter type, R, V or C VSH_PARAMETER_TYPE ParameterType; // Parameter type, R, V or C
@ -245,15 +276,6 @@ typedef struct _VSH_SHADER_INSTRUCTION
} }
VSH_SHADER_INSTRUCTION; VSH_SHADER_INSTRUCTION;
typedef enum _VSH_IMD_OUTPUT_TYPE
{
IMD_OUTPUT_C,
IMD_OUTPUT_R,
IMD_OUTPUT_O,
IMD_OUTPUT_A0X
}
VSH_IMD_OUTPUT_TYPE;
typedef enum _VSH_IMD_INSTRUCTION_TYPE typedef enum _VSH_IMD_INSTRUCTION_TYPE
{ {
IMD_MAC, IMD_MAC,
@ -273,7 +295,11 @@ typedef struct _VSH_IMD_PARAMETER
{ {
boolean Active; boolean Active;
VSH_PARAMETER Parameter; VSH_PARAMETER Parameter;
boolean IsA0X; // There is only a single address register in Microsoft DirectX 8.0.
// The address register, designated as a0.x, may be used as signed
// integer offset in relative addressing into the constant register file.
// c[a0.x + n]
boolean IndexesWithA0_X;
} }
VSH_IMD_PARAMETER; VSH_IMD_PARAMETER;
@ -315,7 +341,7 @@ static const VSH_FIELDMAPPING g_FieldMapping[] =
{ FLD_MAC, 1, 21, 4 }, { FLD_MAC, 1, 21, 4 },
{ FLD_CONST, 1, 13, 8 }, { FLD_CONST, 1, 13, 8 },
{ FLD_V, 1, 9, 4 }, { FLD_V, 1, 9, 4 },
// INPUT A // Input A
{ FLD_A_NEG, 1, 8, 1 }, { FLD_A_NEG, 1, 8, 1 },
{ FLD_A_SWZ_X, 1, 6, 2 }, { FLD_A_SWZ_X, 1, 6, 2 },
{ FLD_A_SWZ_Y, 1, 4, 2 }, { FLD_A_SWZ_Y, 1, 4, 2 },
@ -323,7 +349,7 @@ static const VSH_FIELDMAPPING g_FieldMapping[] =
{ FLD_A_SWZ_W, 1, 0, 2 }, { FLD_A_SWZ_W, 1, 0, 2 },
{ FLD_A_R, 2, 28, 4 }, { FLD_A_R, 2, 28, 4 },
{ FLD_A_MUX, 2, 26, 2 }, { FLD_A_MUX, 2, 26, 2 },
// INPUT B // Input B
{ FLD_B_NEG, 2, 25, 1 }, { FLD_B_NEG, 2, 25, 1 },
{ FLD_B_SWZ_X, 2, 23, 2 }, { FLD_B_SWZ_X, 2, 23, 2 },
{ FLD_B_SWZ_Y, 2, 21, 2 }, { FLD_B_SWZ_Y, 2, 21, 2 },
@ -331,7 +357,7 @@ static const VSH_FIELDMAPPING g_FieldMapping[] =
{ FLD_B_SWZ_W, 2, 17, 2 }, { FLD_B_SWZ_W, 2, 17, 2 },
{ FLD_B_R, 2, 13, 4 }, { FLD_B_R, 2, 13, 4 },
{ FLD_B_MUX, 2, 11, 2 }, { FLD_B_MUX, 2, 11, 2 },
// INPUT C // Input C
{ FLD_C_NEG, 2, 10, 1 }, { FLD_C_NEG, 2, 10, 1 },
{ FLD_C_SWZ_X, 2, 8, 2 }, { FLD_C_SWZ_X, 2, 8, 2 },
{ FLD_C_SWZ_Y, 2, 6, 2 }, { FLD_C_SWZ_Y, 2, 6, 2 },
@ -357,34 +383,42 @@ static const VSH_FIELDMAPPING g_FieldMapping[] =
{ FLD_OUT_ORB, 3, 11, 1 }, { FLD_OUT_ORB, 3, 11, 1 },
{ FLD_OUT_ADDRESS, 3, 3, 8 }, { FLD_OUT_ADDRESS, 3, 3, 8 },
{ FLD_OUT_MUX, 3, 2, 1 }, { FLD_OUT_MUX, 3, 2, 1 },
// Other // Relative addressing
{ FLD_A0X, 3, 1, 1 }, { FLD_A0X, 3, 1, 1 },
// Final instruction
{ FLD_FINAL, 3, 0, 1 } { FLD_FINAL, 3, 0, 1 }
}; };
static const VSH_OPCODE_PARAMS g_OpCodeParams[] = static const VSH_OPCODE_PARAMS g_OpCodeParams_ILU[] =
{ {
// ILU OP MAC OP ParamA ParamB ParamC // ILU OP MAC OP ParamA ParamB ParamC
{ ILU_MOV, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_NOP, MAC_NOP, */ FALSE, FALSE, FALSE }, // Dxbx note : Unused
{ ILU_RCP, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_MOV, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_RCC, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_RCP, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_RSQ, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_RCC, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_EXP, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_RSQ, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_LOG, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_EXP, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_LIT, MAC_NOP, FALSE, FALSE, TRUE }, { /*ILU_LOG, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_NOP, MAC_MOV, TRUE, FALSE, FALSE }, { /*ILU_LIT, MAC_NOP, */ FALSE, FALSE, TRUE },
{ ILU_NOP, MAC_MUL, TRUE, TRUE, FALSE }, };
{ ILU_NOP, MAC_ADD, TRUE, FALSE, TRUE },
{ ILU_NOP, MAC_MAD, TRUE, TRUE, TRUE }, static const VSH_OPCODE_PARAMS g_OpCodeParams_MAC[] =
{ ILU_NOP, MAC_DP3, TRUE, TRUE, FALSE }, {
{ ILU_NOP, MAC_DPH, TRUE, TRUE, FALSE }, // ILU OP MAC OP ParamA ParamB ParamC
{ ILU_NOP, MAC_DP4, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_NOP, */ FALSE, FALSE, FALSE }, // Dxbx note : Unused
{ ILU_NOP, MAC_DST, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_MOV, */ TRUE, FALSE, FALSE },
{ ILU_NOP, MAC_MIN, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_MUL, */ TRUE, TRUE, FALSE },
{ ILU_NOP, MAC_MAX, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_ADD, */ TRUE, FALSE, TRUE },
{ ILU_NOP, MAC_SLT, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_MAD, */ TRUE, TRUE, TRUE },
{ ILU_NOP, MAC_SGE, TRUE, TRUE, FALSE }, { /*ILU_NOP, MAC_DP3, */ TRUE, TRUE, FALSE },
{ ILU_NOP, MAC_ARL, TRUE, FALSE, FALSE } { /*ILU_NOP, MAC_DPH, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_DP4, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_DST, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_MIN, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_MAX, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_SLT, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_SGE, */ TRUE, TRUE, FALSE },
{ /*ILU_NOP, MAC_ARL, */ TRUE, FALSE, FALSE }
}; };
static const char* MAC_OpCode[] = static const char* MAC_OpCode[] =
@ -402,7 +436,7 @@ static const char* MAC_OpCode[] =
"max", "max",
"slt", "slt",
"sge", "sge",
"mov", // really "arl" "mov", // really "arl" Dxbx note : Alias for 'mov a0.x'
"???", "???",
"???" "???"
}; };
@ -439,6 +473,26 @@ static const char* OReg_Name[] =
"a0.x" "a0.x"
}; };
// Dxbx note : This tooling function is never used, but clearly illustrates the relation
// between vertex shader's being passed around, and the actual handle value used on PC.
DWORD VshHandleGetRealHandle(DWORD aHandle)
{
using namespace XTL;
if (VshHandleIsVertexShader(aHandle))
{
X_D3DVertexShader *pD3DVertexShader = VshHandleGetVertexShader(aHandle);
// assert(pD3DVertexShader);
VERTEX_SHADER *pVertexShader = (VERTEX_SHADER*)(pD3DVertexShader->Handle);
// assert(pVertexShader);
return pVertexShader->Handle;
}
else
return aHandle;
}
static inline int IsInUse(const boolean *pMask) static inline int IsInUse(const boolean *pMask)
{ {
return (pMask[0] || pMask[1] || pMask[2] || pMask[3]); return (pMask[0] || pMask[1] || pMask[2] || pMask[3]);
@ -502,16 +556,12 @@ uint08 VshGetField(uint32 *pShaderToken,
static VSH_OPCODE_PARAMS* VshGetOpCodeParams(VSH_ILU ILU, static VSH_OPCODE_PARAMS* VshGetOpCodeParams(VSH_ILU ILU,
VSH_MAC MAC) VSH_MAC MAC)
{ {
int i; if (ILU >= ILU_MOV && ILU <= ILU_LIT)
return (VSH_OPCODE_PARAMS*)&g_OpCodeParams_ILU[ILU];
for (i = 0; i < (sizeof(g_OpCodeParams) / sizeof(VSH_OPCODE_PARAMS)); i++) else
{ if (MAC >= MAC_MOV && MAC <= MAC_ARL)
if(ILU != ILU_NOP && ILU == g_OpCodeParams[i].ILU || return (VSH_OPCODE_PARAMS*)&g_OpCodeParams_MAC[MAC];
MAC != MAC_NOP && MAC == g_OpCodeParams[i].MAC) else
{
return (VSH_OPCODE_PARAMS*)&g_OpCodeParams[i];
}
}
return NULL; return NULL;
} }
@ -521,6 +571,7 @@ static void VshParseInstruction(uint32 *pShaderToken,
// First get the instruction(s). // First get the instruction(s).
pInstruction->ILU = (VSH_ILU)VshGetField(pShaderToken, FLD_ILU); pInstruction->ILU = (VSH_ILU)VshGetField(pShaderToken, FLD_ILU);
pInstruction->MAC = (VSH_MAC)VshGetField(pShaderToken, FLD_MAC); pInstruction->MAC = (VSH_MAC)VshGetField(pShaderToken, FLD_MAC);
// Get parameter A // Get parameter A
pInstruction->A.ParameterType = (VSH_PARAMETER_TYPE)VshGetField(pShaderToken, FLD_A_MUX); pInstruction->A.ParameterType = (VSH_PARAMETER_TYPE)VshGetField(pShaderToken, FLD_A_MUX);
switch(pInstruction->A.ParameterType) switch(pInstruction->A.ParameterType)
@ -622,18 +673,20 @@ static void VshParseInstruction(uint32 *pShaderToken,
} }
// Print functions // Print functions
static char VshGetRegisterName(VSH_PARAMETER_TYPE ParameterType) static char *VshGetRegisterName(VSH_PARAMETER_TYPE ParameterType)
{ {
switch(ParameterType) switch(ParameterType)
{ {
case PARAM_R: case PARAM_R:
return 'r'; return "r";
case PARAM_V: case PARAM_V:
return 'v'; return "v";
case PARAM_C: case PARAM_C:
return 'c'; return "c";
case PARAM_O:
return "oPos";
default: default:
return '?'; return "?";
} }
} }
@ -643,7 +696,7 @@ static void VshWriteOutputMask(boolean *OutputMask,
{ {
if(OutputMask[0] && OutputMask[1] && OutputMask[2] && OutputMask[3]) if(OutputMask[0] && OutputMask[1] && OutputMask[2] && OutputMask[3])
{ {
// All compoenents are there, no need to print the mask // All components are there, no need to print the mask
return; return;
} }
*pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, ".%s%s%s%s", *pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, ".%s%s%s%s",
@ -657,10 +710,10 @@ static void VshWriteParameter(VSH_IMD_PARAMETER *pParameter,
char *pDisassembly, char *pDisassembly,
uint32 *pDisassemblyPos) uint32 *pDisassemblyPos)
{ {
*pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, ", %s%c", *pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, ", %s%s",
pParameter->Parameter.Neg ? "-" : "", pParameter->Parameter.Neg ? "-" : "",
VshGetRegisterName(pParameter->Parameter.ParameterType)); VshGetRegisterName(pParameter->Parameter.ParameterType));
if(pParameter->Parameter.ParameterType == PARAM_C && pParameter->IsA0X) if(pParameter->Parameter.ParameterType == PARAM_C && pParameter->IndexesWithA0_X)
{ {
// Only display the offset if it's not 0. // Only display the offset if it's not 0.
if(pParameter->Parameter.Address) if(pParameter->Parameter.Address)
@ -677,10 +730,10 @@ static void VshWriteParameter(VSH_IMD_PARAMETER *pParameter,
*pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, "%d", pParameter->Parameter.Address); *pDisassemblyPos += sprintf(pDisassembly + *pDisassemblyPos, "%d", pParameter->Parameter.Address);
} }
// Only bother printing the swizzle if it is not .xyzw // Only bother printing the swizzle if it is not .xyzw
if(!(pParameter->Parameter.Swizzle[0] == 0 && if(!(pParameter->Parameter.Swizzle[0] == SWIZZLE_X &&
pParameter->Parameter.Swizzle[1] == 1 && pParameter->Parameter.Swizzle[1] == SWIZZLE_Y &&
pParameter->Parameter.Swizzle[2] == 2 && pParameter->Parameter.Swizzle[2] == SWIZZLE_Z &&
pParameter->Parameter.Swizzle[3] == 3)) pParameter->Parameter.Swizzle[3] == SWIZZLE_W))
{ {
int i; int i;
@ -750,18 +803,28 @@ static void VshWriteShader(VSH_XBOX_SHADER *pShader,
{ {
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "; -- Passing the truncation limit --\n"); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "; -- Passing the truncation limit --\n");
} }
// Writing combining sign if neccessary // Writing combining sign if neccessary
if(pIntermediate->IsCombined) if(pIntermediate->IsCombined)
{ {
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "+"); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "+");
} }
// Print the op code // Print the op code
if(pIntermediate->InstructionType == IMD_MAC) if(pIntermediate->InstructionType == IMD_MAC)
{ {
// Dxbx addition : Safeguard against incorrect MAC opcodes :
if (pIntermediate->MAC > MAC_ARL)
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "??? ");
else
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s ", MAC_OpCode[pIntermediate->MAC]); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s ", MAC_OpCode[pIntermediate->MAC]);
} }
else else // IMD_ILU
{ {
// Dxbx addition : Safeguard against incorrect ILU opcodes :
if (pIntermediate->ILU > ILU_LIT)
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "??? ");
else
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s ", ILU_OpCode[pIntermediate->ILU]); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s ", ILU_OpCode[pIntermediate->ILU]);
} }
@ -781,6 +844,10 @@ static void VshWriteShader(VSH_XBOX_SHADER *pShader,
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "r%d", pIntermediate->Output.Address); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "r%d", pIntermediate->Output.Address);
break; break;
case IMD_OUTPUT_O: case IMD_OUTPUT_O:
// Dxbx addition : Safeguard against incorrect VSH_OREG_NAME values :
if ((int)pIntermediate->Output.Address > OREG_A0X)
; // don't add anything
else
DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s", OReg_Name[pIntermediate->Output.Address]); DisassemblyPos += sprintf(pDisassembly + DisassemblyPos, "%s", OReg_Name[pIntermediate->Output.Address]);
break; break;
default: default:
@ -809,7 +876,7 @@ static void VshAddParameter(VSH_PARAMETER *pParameter,
{ {
pIntermediateParameter->Parameter = *pParameter; pIntermediateParameter->Parameter = *pParameter;
pIntermediateParameter->Active = TRUE; pIntermediateParameter->Active = TRUE;
pIntermediateParameter->IsA0X = a0x; pIntermediateParameter->IndexesWithA0_X = a0x;
} }
static void VshAddParameters(VSH_SHADER_INSTRUCTION *pInstruction, static void VshAddParameters(VSH_SHADER_INSTRUCTION *pInstruction,
@ -966,6 +1033,63 @@ static boolean VshAddInstructionMAC_ARL(VSH_SHADER_INSTRUCTION *pInstruction,
return TRUE; return TRUE;
} }
/*
// Dxbx addition : Scalar instructions reading from W should read from X instead
boolean DxbxFixupScalarParameter(VSH_SHADER_INSTRUCTION *pInstruction,
VSH_XBOX_SHADER *pShader,
VSH_PARAMETER *pParameter)
{
boolean Result;
int i;
boolean WIsWritten;
// The DirectX vertex shader language specifies that the exp, log, rcc, rcp, and rsq instructions
// all operate on the "w" component of the input. But the microcode versions of these instructions
// actually operate on the "x" component of the input.
Result = false;
// Test if this is a scalar instruction :
if (pInstruction->ILU in [ILU_RCP, ILU_RCC, ILU_RSQ, ILU_EXP, ILU_LOG])
{
// Test if this parameter reads all components, including W (TODO : Or should we fixup any W reading swizzle?) :
if ((pParameter->Swizzle[0] = SWIZZLE_X)
&& (pParameter->Swizzle[1] = SWIZZLE_Y)
&& (pParameter->Swizzle[2] = SWIZZLE_Z)
&& (pParameter->Swizzle[3] = SWIZZLE_W))
{
// Also test that the .W component is never written to before:
WIsWritten = false;
for (i = 0; i < pShader->IntermediateCount; i++)
{
// Stop when we reached this instruction :
if (&(pShader->Intermediate[i]) == pInstruction)
break;
// Check if this instruction writes to the .W component of the same input parameter :
if (((pShader->Intermediate[i].Output.Type == IMD_OUTPUT_C) && (pParameter->ParameterType == PARAM_C))
|| ((pShader->Intermediate[i].Output.Type == IMD_OUTPUT_R) && (pParameter->ParameterType == PARAM_R)))
{
WIsWritten = (pShader->Intermediate[i].Output.Address == pParameter->Address)
&& ((pShader->Intermediate[i].Output.Mask && MASK_W) > 0);
if (WIsWritten)
break;
}
}
if (!WIsWritten)
{
// Change the read from W into a read from X (this fixes the XDK VolumeLight sample) :
VshSetSwizzle(pParameter, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X);
DbgVshPrintf("Dxbx fixup on scalar instruction applied; Changed read of uninitialized W into a read of X!\n");
Result = true;
}
}
}
return Result;
}
*/
static boolean VshAddInstructionILU_R(VSH_SHADER_INSTRUCTION *pInstruction, static boolean VshAddInstructionILU_R(VSH_SHADER_INSTRUCTION *pInstruction,
VSH_XBOX_SHADER *pShader, VSH_XBOX_SHADER *pShader,
boolean IsCombined) boolean IsCombined)
@ -976,6 +1100,10 @@ static boolean VshAddInstructionILU_R(VSH_SHADER_INSTRUCTION *pInstruction,
return FALSE; return FALSE;
} }
/* TODO
// Dxbx note : Scalar instructions read from C, but use X instead of W, fix that :
DxbxFixupScalarParameter(pInstruction, pShader, &pInstruction.C);
*/
pIntermediate = VshNewIntermediate(pShader); pIntermediate = VshNewIntermediate(pShader);
pIntermediate->IsCombined = IsCombined; pIntermediate->IsCombined = IsCombined;
@ -1122,7 +1250,7 @@ static void VshRemoveScreenSpaceInstructions(VSH_XBOX_SHADER *pShader)
if(pIntermediate->Parameters[k].Active) if(pIntermediate->Parameters[k].Active)
{ {
if(pIntermediate->Parameters[k].Parameter.ParameterType == PARAM_C && if(pIntermediate->Parameters[k].Parameter.ParameterType == PARAM_C &&
!pIntermediate->Parameters[k].IsA0X) !pIntermediate->Parameters[k].IndexesWithA0_X)
{ {
if(pIntermediate->Parameters[k].Parameter.Address == -37) if(pIntermediate->Parameters[k].Parameter.Address == -37)
{ {
@ -1202,13 +1330,13 @@ static void VshRemoveScreenSpaceInstructions(VSH_XBOX_SHADER *pShader)
MulIntermediate.Output.Mask[2] = pIntermediate->Output.Mask[2]; MulIntermediate.Output.Mask[2] = pIntermediate->Output.Mask[2];
MulIntermediate.Output.Mask[3] = pIntermediate->Output.Mask[3]; MulIntermediate.Output.Mask[3] = pIntermediate->Output.Mask[3];
MulIntermediate.Parameters[0].Active = TRUE; MulIntermediate.Parameters[0].Active = TRUE;
MulIntermediate.Parameters[0].IsA0X = FALSE; MulIntermediate.Parameters[0].IndexesWithA0_X = FALSE;
MulIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R; MulIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R;
MulIntermediate.Parameters[0].Parameter.Address = 11; MulIntermediate.Parameters[0].Parameter.Address = 11;
MulIntermediate.Parameters[0].Parameter.Neg = FALSE; MulIntermediate.Parameters[0].Parameter.Neg = FALSE;
VshSetSwizzle(&MulIntermediate.Parameters[0], SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W); VshSetSwizzle(&MulIntermediate.Parameters[0], SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
MulIntermediate.Parameters[1].Active = TRUE; MulIntermediate.Parameters[1].Active = TRUE;
MulIntermediate.Parameters[1].IsA0X = FALSE; MulIntermediate.Parameters[1].IndexesWithA0_X = FALSE;
MulIntermediate.Parameters[1].Parameter.ParameterType = PARAM_C; MulIntermediate.Parameters[1].Parameter.ParameterType = PARAM_C;
MulIntermediate.Parameters[1].Parameter.Address = ConvertCRegister(58); MulIntermediate.Parameters[1].Parameter.Address = ConvertCRegister(58);
MulIntermediate.Parameters[1].Parameter.Neg = FALSE; MulIntermediate.Parameters[1].Parameter.Neg = FALSE;
@ -1330,7 +1458,7 @@ static boolean VshConvertShader(VSH_XBOX_SHADER *pShader,
VshSetOutputMask(&pIntermediate->Output, TRUE, TRUE, TRUE, TRUE); VshSetOutputMask(&pIntermediate->Output, TRUE, TRUE, TRUE, TRUE);
TmpIntermediate.MAC = MAC_ADD; TmpIntermediate.MAC = MAC_ADD;
TmpIntermediate.Parameters[0].IsA0X = FALSE; TmpIntermediate.Parameters[0].IndexesWithA0_X = FALSE;
TmpIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R; TmpIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R;
TmpIntermediate.Parameters[0].Parameter.Address = outRegister; TmpIntermediate.Parameters[0].Parameter.Address = outRegister;
TmpIntermediate.Parameters[0].Parameter.Neg = FALSE; TmpIntermediate.Parameters[0].Parameter.Neg = FALSE;
@ -1344,7 +1472,7 @@ static boolean VshConvertShader(VSH_XBOX_SHADER *pShader,
VSH_INTERMEDIATE_FORMAT TmpIntermediate = *pIntermediate; VSH_INTERMEDIATE_FORMAT TmpIntermediate = *pIntermediate;
pIntermediate->MAC = MAC_DP3; pIntermediate->MAC = MAC_DP3;
TmpIntermediate.MAC = MAC_ADD; TmpIntermediate.MAC = MAC_ADD;
TmpIntermediate.Parameters[0].IsA0X = FALSE; TmpIntermediate.Parameters[0].IndexesWithA0_X = FALSE;
TmpIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R; TmpIntermediate.Parameters[0].Parameter.ParameterType = PARAM_R;
TmpIntermediate.Parameters[0].Parameter.Address = TmpIntermediate.Output.Address; TmpIntermediate.Parameters[0].Parameter.Address = TmpIntermediate.Output.Address;
TmpIntermediate.Parameters[0].Parameter.Neg = FALSE; TmpIntermediate.Parameters[0].Parameter.Neg = FALSE;
@ -1417,7 +1545,7 @@ static boolean VshConvertShader(VSH_XBOX_SHADER *pShader,
} }
else if(pIntermediate->Parameters[k].Parameter.ParameterType == PARAM_C && else if(pIntermediate->Parameters[k].Parameter.ParameterType == PARAM_C &&
pIntermediate->Parameters[k].Parameter.Address == 58 && pIntermediate->Parameters[k].Parameter.Address == 58 &&
!pIntermediate->Parameters[k].IsA0X) !pIntermediate->Parameters[k].IndexesWithA0_X)
{ {
// Found c-38, replace it with r12.w // Found c-38, replace it with r12.w
pIntermediate->Parameters[k].Parameter.ParameterType = PARAM_R; pIntermediate->Parameters[k].Parameter.ParameterType = PARAM_R;
@ -1465,6 +1593,7 @@ VSH_STREAM_PATCH_DATA;
typedef struct _VSH_PATCH_DATA typedef struct _VSH_PATCH_DATA
{ {
boolean NeedPatching; boolean NeedPatching;
WORD CurrentStreamNumber;
DWORD ConvertedStride; DWORD ConvertedStride;
VSH_TYPE_PATCH_DATA TypePatchData; VSH_TYPE_PATCH_DATA TypePatchData;
VSH_STREAM_PATCH_DATA StreamPatchData; VSH_STREAM_PATCH_DATA StreamPatchData;
@ -1485,68 +1614,85 @@ static DWORD VshGetDeclarationSize(DWORD *pDeclaration)
return (Pos + 1) * sizeof(DWORD); return (Pos + 1) * sizeof(DWORD);
} }
DWORD Xb2PCRegisterType(DWORD VertexRegister) typedef DWORD D3DDECLUSAGE;
#define D3DDECLUSAGE_UNSUPPORTED ((D3DDECLUSAGE)-1)
D3DDECLUSAGE Xb2PCRegisterType
(
DWORD VertexRegister,
boolean IsFixedFunction
)
{ {
DWORD PCRegisterType; using namespace XTL;
D3DDECLUSAGE PCRegisterType;
// For fixed function vertex shaders, print D3DVSDE_*, for custom shaders print numbered registers.
if (IsFixedFunction) {
switch (VertexRegister) switch (VertexRegister)
{ {
case -1: case X_D3DVSDE_VERTEX: // -1
DbgVshPrintf("D3DVSDE_VERTEX /* xbox ext. */"); DbgVshPrintf("D3DVSDE_VERTEX /* xbox ext. */");
PCRegisterType = -1; PCRegisterType = D3DDECLUSAGE_UNSUPPORTED;
break; break;
case 0: case X_D3DVSDE_POSITION: // 0
DbgVshPrintf("D3DVSDE_POSITION"); DbgVshPrintf("D3DVSDE_POSITION");
PCRegisterType = D3DVSDE_POSITION; PCRegisterType = D3DVSDE_POSITION;
break; break;
case 1: case X_D3DVSDE_BLENDWEIGHT: // 1
DbgVshPrintf("D3DVSDE_BLENDWEIGHT"); DbgVshPrintf("D3DVSDE_BLENDWEIGHT");
PCRegisterType = D3DVSDE_BLENDWEIGHT; PCRegisterType = D3DVSDE_BLENDWEIGHT;
break; break;
case 2: case X_D3DVSDE_NORMAL: // 2
DbgVshPrintf("D3DVSDE_NORMAL"); DbgVshPrintf("D3DVSDE_NORMAL");
PCRegisterType = D3DVSDE_NORMAL; PCRegisterType = D3DVSDE_NORMAL;
break; break;
case 3: case X_D3DVSDE_DIFFUSE: // 3
DbgVshPrintf("D3DVSDE_DIFFUSE"); DbgVshPrintf("D3DVSDE_DIFFUSE");
PCRegisterType = D3DVSDE_DIFFUSE; PCRegisterType = D3DVSDE_DIFFUSE;
break; break;
case 4: case X_D3DVSDE_SPECULAR: // 4
DbgVshPrintf("D3DVSDE_SPECULAR"); DbgVshPrintf("D3DVSDE_SPECULAR");
PCRegisterType = D3DVSDE_SPECULAR; PCRegisterType = D3DVSDE_SPECULAR;
break; break;
case 5: case X_D3DVSDE_FOG: // 5
DbgVshPrintf("D3DVSDE_FOG /* xbox ext. */"); DbgVshPrintf("D3DVSDE_FOG /* xbox ext. */");
PCRegisterType = -1; PCRegisterType = D3DDECLUSAGE_UNSUPPORTED;
break; break;
case 7: case X_D3DVSDE_BACKDIFFUSE: // 7
DbgVshPrintf("D3DVSDE_BACKDIFFUSE /* xbox ext. */"); DbgVshPrintf("D3DVSDE_BACKDIFFUSE /* xbox ext. */");
PCRegisterType = -1; PCRegisterType = D3DDECLUSAGE_UNSUPPORTED;
break; break;
case 8: case X_D3DVSDE_BACKSPECULAR: // 8
DbgVshPrintf("D3DVSDE_BACKSPECULAR /* xbox ext. */"); DbgVshPrintf("D3DVSDE_BACKSPECULAR /* xbox ext. */");
PCRegisterType = -1; PCRegisterType = D3DDECLUSAGE_UNSUPPORTED;
break; break;
case 9: case X_D3DVSDE_TEXCOORD0: // 9
DbgVshPrintf("D3DVSDE_TEXCOORD0"); DbgVshPrintf("D3DVSDE_TEXCOORD0");
PCRegisterType = D3DVSDE_TEXCOORD0; PCRegisterType = D3DVSDE_TEXCOORD0;
break; break;
case 10: case X_D3DVSDE_TEXCOORD1: // 10
DbgVshPrintf("D3DVSDE_TEXCOORD1"); DbgVshPrintf("D3DVSDE_TEXCOORD1");
PCRegisterType = D3DVSDE_TEXCOORD1; PCRegisterType = D3DVSDE_TEXCOORD1;
break; break;
case 11: case X_D3DVSDE_TEXCOORD2: // 11
DbgVshPrintf("D3DVSDE_TEXCOORD2"); DbgVshPrintf("D3DVSDE_TEXCOORD2");
PCRegisterType = D3DVSDE_TEXCOORD2; PCRegisterType = D3DVSDE_TEXCOORD2;
break; break;
case 12: case X_D3DVSDE_TEXCOORD3: // 12
DbgVshPrintf("D3DVSDE_TEXCOORD3"); DbgVshPrintf("D3DVSDE_TEXCOORD3");
PCRegisterType = D3DVSDE_TEXCOORD3; PCRegisterType = D3DVSDE_TEXCOORD3;
break; break;
default: default:
DbgVshPrintf("%d /* unknown register */", VertexRegister); DbgVshPrintf("%d /* unknown register */", VertexRegister);
PCRegisterType = -1; PCRegisterType = D3DDECLUSAGE_UNSUPPORTED;
break; break;
} }
} else {
PCRegisterType = (D3DDECLUSAGE)VertexRegister;
DbgVshPrintf("%d", VertexRegister);
}
return PCRegisterType; return PCRegisterType;
} }
@ -1612,16 +1758,7 @@ static void VshConverToken_TESSELATOR(DWORD *pToken,
XTL::DWORD NewVertexRegister = VertexRegister; XTL::DWORD NewVertexRegister = VertexRegister;
DbgVshPrintf("\tD3DVSD_TESSUV("); DbgVshPrintf("\tD3DVSD_TESSUV(");
NewVertexRegister = Xb2PCRegisterType(VertexRegister, IsFixedFunction);
if(IsFixedFunction)
{
NewVertexRegister = Xb2PCRegisterType(VertexRegister);
}
else
{
DbgVshPrintf("%d", NewVertexRegister);
}
DbgVshPrintf("),\n"); DbgVshPrintf("),\n");
*pToken = D3DVSD_TESSUV(NewVertexRegister); *pToken = D3DVSD_TESSUV(NewVertexRegister);
@ -1636,27 +1773,9 @@ static void VshConverToken_TESSELATOR(DWORD *pToken,
XTL::DWORD NewVertexRegisterOut = VertexRegisterOut; XTL::DWORD NewVertexRegisterOut = VertexRegisterOut;
DbgVshPrintf("\tD3DVSD_TESSNORMAL("); DbgVshPrintf("\tD3DVSD_TESSNORMAL(");
NewVertexRegisterIn = Xb2PCRegisterType(VertexRegisterIn, IsFixedFunction);
if(IsFixedFunction)
{
NewVertexRegisterIn = Xb2PCRegisterType(VertexRegisterIn);
}
else
{
DbgVshPrintf("%d", NewVertexRegisterIn);
}
DbgVshPrintf(", "); DbgVshPrintf(", ");
NewVertexRegisterOut = Xb2PCRegisterType(VertexRegisterOut, IsFixedFunction);
if(IsFixedFunction)
{
NewVertexRegisterOut = Xb2PCRegisterType(VertexRegisterOut);
}
else
{
DbgVshPrintf("%d", NewVertexRegisterOut);
}
DbgVshPrintf("),\n"); DbgVshPrintf("),\n");
*pToken = D3DVSD_TESSNORMAL(NewVertexRegisterIn, NewVertexRegisterOut); *pToken = D3DVSD_TESSNORMAL(NewVertexRegisterIn, NewVertexRegisterOut);
} }
@ -1664,7 +1783,7 @@ static void VshConverToken_TESSELATOR(DWORD *pToken,
static boolean VshAddStreamPatch(VSH_PATCH_DATA *pPatchData) static boolean VshAddStreamPatch(VSH_PATCH_DATA *pPatchData)
{ {
int CurrentStream = pPatchData->StreamPatchData.NbrStreams - 1; int CurrentStream = pPatchData->StreamPatchData.NbrStreams - 1; // TODO : Should we use pPatchData->CurrentStreamNumber?
if(CurrentStream >= 0) if(CurrentStream >= 0)
{ {
@ -1703,13 +1822,18 @@ static void VshConvertToken_STREAM(DWORD *pToken,
// new stream // new stream
// copy current data to structure // copy current data to structure
// Dxbx note : Use Dophin(s), FieldRender, MatrixPaletteSkinning and PersistDisplay as a testcase
if(VshAddStreamPatch(pPatchData)) if(VshAddStreamPatch(pPatchData))
{ {
// Reset fields for next patch :
pPatchData->ConvertedStride = 0; pPatchData->ConvertedStride = 0;
pPatchData->TypePatchData.NbrTypes = 0; pPatchData->TypePatchData.NbrTypes = 0;
pPatchData->NeedPatching = FALSE; pPatchData->NeedPatching = FALSE;
pPatchData->StreamPatchData.NbrStreams = 0; // Dxbx addition
} }
pPatchData->CurrentStreamNumber = (WORD)StreamNumber;
pPatchData->StreamPatchData.NbrStreams++; pPatchData->StreamPatchData.NbrStreams++;
} }
} }
@ -1741,21 +1865,11 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
{ {
using namespace XTL; using namespace XTL;
DbgVshPrintf("\tD3DVSD_REG(");
XTL::DWORD VertexRegister = VshGetVertexRegister(*pToken); XTL::DWORD VertexRegister = VshGetVertexRegister(*pToken);
XTL::DWORD NewVertexRegister; XTL::DWORD NewVertexRegister;
if(IsFixedFunction) DbgVshPrintf("\tD3DVSD_REG(");
{ NewVertexRegister = Xb2PCRegisterType(VertexRegister, IsFixedFunction);
NewVertexRegister = Xb2PCRegisterType(VertexRegister);
}
else
{
NewVertexRegister = VertexRegister;
DbgVshPrintf("%d", NewVertexRegister);
}
DbgVshPrintf(", "); DbgVshPrintf(", ");
XTL::DWORD DataType = (*pToken & X_D3DVSD_DATATYPEMASK) >> X_D3DVSD_DATATYPESHIFT; XTL::DWORD DataType = (*pToken & X_D3DVSD_DATATYPEMASK) >> X_D3DVSD_DATATYPESHIFT;
@ -1801,7 +1915,7 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
break; break;
case X_D3DVSDT_NORMSHORT1: // 0x11: case X_D3DVSDT_NORMSHORT1: // 0x11:
DbgVshPrintf("D3DVSDT_NORMSHORT1 /* xbox ext. */"); DbgVshPrintf("D3DVSDT_NORMSHORT1 /* xbox ext. */");
NewDataType = D3DVSDT_FLOAT1; NewDataType = D3DVSDT_FLOAT1; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT2 in Direct3D9 ?
NewSize = sizeof(FLOAT); NewSize = sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
@ -1813,7 +1927,7 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
break; break;
case X_D3DVSDT_NORMSHORT3: // 0x31: case X_D3DVSDT_NORMSHORT3: // 0x31:
DbgVshPrintf("D3DVSDT_NORMSHORT3 /* xbox ext. nsp */"); DbgVshPrintf("D3DVSDT_NORMSHORT3 /* xbox ext. nsp */");
NewDataType = D3DVSDT_FLOAT3; NewDataType = D3DVSDT_FLOAT3; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT4 in Direct3D9 ?
NewSize = 3*sizeof(FLOAT); NewSize = 3*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
@ -1843,42 +1957,48 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
break; break;
case X_D3DVSDT_PBYTE1: // 0x14: case X_D3DVSDT_PBYTE1: // 0x14:
DbgVshPrintf("D3DVSDT_PBYTE1 /* xbox ext. nsp */"); DbgVshPrintf("D3DVSDT_PBYTE1 /* xbox ext. nsp */");
NewDataType = D3DVSDT_FLOAT1; NewDataType = D3DVSDT_FLOAT1; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT2 in Direct3D9 ?
NewSize = 1*sizeof(FLOAT); NewSize = 1*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
case X_D3DVSDT_PBYTE2: // 0x24: case X_D3DVSDT_PBYTE2: // 0x24:
DbgVshPrintf("D3DVSDT_PBYTE2 /* xbox ext. nsp */"); DbgVshPrintf("D3DVSDT_PBYTE2 /* xbox ext. nsp */");
NewDataType = D3DVSDT_FLOAT2; NewDataType = D3DVSDT_FLOAT2; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT2 in Direct3D9 ?
NewSize = 2*sizeof(FLOAT); NewSize = 2*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
case X_D3DVSDT_PBYTE3: // 0x34: case X_D3DVSDT_PBYTE3: // 0x34:
DbgVshPrintf("D3DVSDT_PBYTE3 /* xbox ext. nsp */"); DbgVshPrintf("D3DVSDT_PBYTE3 /* xbox ext. nsp */");
NewDataType = D3DVSDT_FLOAT3; NewDataType = D3DVSDT_FLOAT3; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT4 in Direct3D9 ?
NewSize = 3*sizeof(FLOAT); NewSize = 3*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
case X_D3DVSDT_PBYTE4: // 0x44: // Hit by Panzer case X_D3DVSDT_PBYTE4: // 0x44: // Hit by Panzer
DbgVshPrintf("D3DVSDT_PBYTE4 /* xbox ext. */"); DbgVshPrintf("D3DVSDT_PBYTE4 /* xbox ext. */");
NewDataType = D3DVSDT_FLOAT4; NewDataType = D3DVSDT_FLOAT4; // TODO -oDxbx : Is it better to use D3DVSDT_NORMSHORT4 or D3DDECLTYPE_UBYTE4N (if in caps) in Direct3D9 ?
NewSize = 4*sizeof(FLOAT); NewSize = 4*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
case X_D3DVSDT_FLOAT2H: // 0x72: case X_D3DVSDT_FLOAT2H: // 0x72:
DbgVshPrintf("D3DVSDT_FLOAT2H /* xbox ext. */"); DbgVshPrintf("D3DVSDT_FLOAT2H /* xbox ext. */");
NewDataType = D3DVSDT_FLOAT3; NewDataType = D3DVSDT_FLOAT4;
NewSize = 3*sizeof(FLOAT); NewSize = 4*sizeof(FLOAT);
pPatchData->NeedPatching = TRUE; pPatchData->NeedPatching = TRUE;
break; break;
case X_D3DVSDT_NONE: // 0x02: case X_D3DVSDT_NONE: // 0x02:
DbgVshPrintf("D3DVSDT_NONE /* xbox ext. nsp */"); DbgVshPrintf("D3DVSDT_NONE /* xbox ext. nsp */");
#if DXBX_USE_D3D9
NewDataType = D3DVSDT_NONE;
#endif
// TODO -oDxbx: Use D3DVSD_NOP ?
NewDataType = 0xFF; NewDataType = 0xFF;
break; break;
default: default:
DbgVshPrintf("Unknown data type for D3DVSD_REG: 0x%02X\n", DataType); DbgVshPrintf("Unknown data type for D3DVSD_REG: 0x%02X\n", DataType);
break; break;
} }
// save patching information
pPatchData->TypePatchData.Types[pPatchData->TypePatchData.NbrTypes] = DataType; pPatchData->TypePatchData.Types[pPatchData->TypePatchData.NbrTypes] = DataType;
pPatchData->TypePatchData.NewSizes[pPatchData->TypePatchData.NbrTypes] = NewSize; pPatchData->TypePatchData.NewSizes[pPatchData->TypePatchData.NbrTypes] = NewSize;
pPatchData->TypePatchData.NbrTypes++; pPatchData->TypePatchData.NbrTypes++;
@ -1895,24 +2015,26 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
} }
} }
#define D3DVSD_MASK_TESSUV 0x10000000
#define D3DVSD_MASK_SKIP 0x10000000 // Skips (normally) dwords
#define D3DVSD_MASK_SKIPBYTES 0x08000000 // Skips bytes (no, really?!)
static void VshConvertToken_STREAMDATA(DWORD *pToken, static void VshConvertToken_STREAMDATA(DWORD *pToken,
boolean IsFixedFunction, boolean IsFixedFunction,
VSH_PATCH_DATA *pPatchData) VSH_PATCH_DATA *pPatchData)
{ {
using namespace XTL; using namespace XTL;
if (*pToken & D3DVSD_MASK_SKIP)
// D3DVSD_SKIP
if(*pToken & 0x10000000)
{ {
// For D3D9, use D3DDECLTYPE_UNUSED ?
if (*pToken & D3DVSD_MASK_SKIPBYTES) {
VshConvertToken_STREAMDATA_SKIPBYTES(pToken);
} else {
VshConvertToken_STREAMDATA_SKIP(pToken); VshConvertToken_STREAMDATA_SKIP(pToken);
} }
// D3DVSD_SKIPBYTES
else if(*pToken & 0x18000000)
{
VshConvertToken_STREAMDATA_SKIPBYTES(pToken);
} }
// D3DVSD_REG else // D3DVSD_REG
else
{ {
VshConvertToken_STREAMDATA_REG(pToken, IsFixedFunction, pPatchData); VshConvertToken_STREAMDATA_REG(pToken, IsFixedFunction, pPatchData);
} }
@ -1993,9 +2115,10 @@ DWORD XTL::EmuRecompileVshDeclaration
DWORD Step = VshRecompileToken(pRecompiled, IsFixedFunction, &PatchData); DWORD Step = VshRecompileToken(pRecompiled, IsFixedFunction, &PatchData);
pRecompiled += Step; pRecompiled += Step;
} }
DbgVshPrintf("\tD3DVSD_END()\n};\n");
// copy last current data to structure
VshAddStreamPatch(&PatchData); VshAddStreamPatch(&PatchData);
DbgVshPrintf("\tD3DVSD_END()\n};\n");
DbgVshPrintf("NbrStreams: %d\n", PatchData.StreamPatchData.NbrStreams); DbgVshPrintf("NbrStreams: %d\n", PatchData.StreamPatchData.NbrStreams);
@ -2144,17 +2267,19 @@ extern void XTL::FreeVertexDynamicPatch(VERTEX_SHADER *pVertexShader)
extern boolean XTL::IsValidCurrentShader(void) extern boolean XTL::IsValidCurrentShader(void)
{ {
DWORD Handle; // Dxbx addition : There's no need to call
// XTL_EmuIDirect3DDevice_GetVertexShader, just check g_CurrentVertexShader :
return VshHandleIsValidShader(g_CurrentVertexShader);
EMUPATCH(D3DDevice_GetVertexShader)(&Handle); }
// Checks for failed vertex shaders, and shaders that would need patching
boolean XTL::VshHandleIsValidShader(DWORD Handle)
{
//printf( "VS = 0x%.08X\n", Handle ); //printf( "VS = 0x%.08X\n", Handle );
if (VshHandleIsVertexShader(Handle)) if (VshHandleIsVertexShader(Handle))
{ {
X_D3DVertexShader *pD3DVertexShader = (X_D3DVertexShader *)(Handle & 0x7FFFFFFF); X_D3DVertexShader *pD3DVertexShader = VshHandleGetVertexShader(Handle);
VERTEX_SHADER *pVertexShader = (VERTEX_SHADER *)pD3DVertexShader->Handle; VERTEX_SHADER *pVertexShader = (VERTEX_SHADER *)pD3DVertexShader->Handle;
if (pVertexShader->Status != 0) if (pVertexShader->Status != 0)
{ {

8
src/CxbxKrnl/EmuD3D8/VertexShader.h
View File

@ -73,9 +73,13 @@ extern void FreeVertexDynamicPatch(VERTEX_SHADER *pVertexShader);
// Checks for failed vertex shaders, and shaders that would need patching // Checks for failed vertex shaders, and shaders that would need patching
extern boolean IsValidCurrentShader(void); extern boolean IsValidCurrentShader(void);
extern boolean VshHandleIsValidShader(DWORD Handle);
inline boolean VshHandleIsVertexShader(DWORD Handle) { return (Handle & 0x80000000) ? TRUE : FALSE; } // Dxbx note : On Xbox, a FVF is recognizable when the handle <= 0x0000FFFF
inline X_D3DVertexShader *VshHandleGetVertexShader(DWORD Handle) { return (X_D3DVertexShader *)(Handle & 0x7FFFFFFF); } // (as all values above are allocated VertexShader addresses).
inline boolean VshHandleIsFVF(DWORD Handle) { return (Handle > NULL) && (Handle <= 0x0000FFFF); }
inline boolean VshHandleIsVertexShader(DWORD Handle) { return (Handle > 0x0000FFFF) ? TRUE : FALSE; }
inline X_D3DVertexShader *VshHandleGetVertexShader(DWORD Handle) { return VshHandleIsVertexShader(Handle) ? (X_D3DVertexShader *)Handle : nullptr; }
VERTEX_DYNAMIC_PATCH *VshGetVertexDynamicPatch(DWORD Handle); VERTEX_DYNAMIC_PATCH *VshGetVertexDynamicPatch(DWORD Handle);
#ifdef _DEBUG_TRACK_VS #ifdef _DEBUG_TRACK_VS

19
src/CxbxKrnl/EmuD3D8Types.h
View File

@ -241,6 +241,8 @@ X_D3DRESOURCETYPE;
#define X_D3DTEXTURE_PITCH_ALIGNMENT X_D3D_RENDER_MEMORY_ALIGNMENT #define X_D3DTEXTURE_PITCH_ALIGNMENT X_D3D_RENDER_MEMORY_ALIGNMENT
#define X_D3DTEXTURE_PITCH_MIN X_D3DTEXTURE_PITCH_ALIGNMENT #define X_D3DTEXTURE_PITCH_MIN X_D3DTEXTURE_PITCH_ALIGNMENT
#define TEXTURE_STAGES 4 // X_D3DTS_STAGECOUNT
typedef enum _X_D3DSET_DEPTH_CLIP_PLANES_FLAGS typedef enum _X_D3DSET_DEPTH_CLIP_PLANES_FLAGS
{ {
X_D3DSDCP_SET_VERTEXPROGRAM_PLANES = 1, X_D3DSDCP_SET_VERTEXPROGRAM_PLANES = 1,
@ -260,6 +262,21 @@ typedef struct _X_D3DDISPLAYMODE
} }
X_D3DDISPLAYMODE; X_D3DDISPLAYMODE;
typedef struct _X_D3DVERTEXBUFFER_DESC
{
X_D3DFORMAT Format;
X_D3DRESOURCETYPE Type;
}
X_D3DVERTEXBUFFER_DESC;
typedef struct _X_D3DINDEXBUFFER_DESC
{
X_D3DFORMAT Format;
X_D3DRESOURCETYPE Type;
}
X_D3DINDEXBUFFER_DESC;
typedef struct _X_D3DSURFACE_DESC typedef struct _X_D3DSURFACE_DESC
{ {
X_D3DFORMAT Format; X_D3DFORMAT Format;
@ -358,7 +375,7 @@ typedef struct _PixelShader_
DWORD dwStatus; DWORD dwStatus;
X_D3DPIXELSHADERDEF PSDef; X_D3DPIXELSHADERDEF PSDef;
DWORD dwStageMap[4]; DWORD dwStageMap[TEXTURE_STAGES];
} PIXEL_SHADER; } PIXEL_SHADER;

50
src/CxbxKrnl/EmuKrnlAv.cpp
View File

@ -74,6 +74,12 @@ ULONG AvQueryAvCapabilities()
return AV_PACK_HDTV | AV_STANDARD_NTSC_M | AV_FLAGS_60Hz; return AV_PACK_HDTV | AV_STANDARD_NTSC_M | AV_FLAGS_60Hz;
} }
// Xbox code will set this address via AvSetSavedDataAddress
// TODO: This value should be persisted between reboots
// Xbox code sets this to the contiguous memory region
// so data is already persisted.
PVOID g_AvSavedDataAddress = NULL;
// ****************************************************************** // ******************************************************************
// * 0x0001 - AvGetSavedDataAddress() // * 0x0001 - AvGetSavedDataAddress()
// ****************************************************************** // ******************************************************************
@ -81,47 +87,7 @@ XBSYSAPI EXPORTNUM(1) xboxkrnl::PVOID NTAPI xboxkrnl::AvGetSavedDataAddress(void
{ {
LOG_FUNC(); LOG_FUNC();
__asm int 3; RETURN(g_AvSavedDataAddress);
// Allocate a buffer the size of the screen buffer and return that.
// TODO: Fill this buffer with the contents of the front buffer.
// TODO: This isn't always the size we need...
if (g_pPersistedData)
{
g_MemoryManager.Free(g_pPersistedData);
g_pPersistedData = NULL;
}
g_pPersistedData = g_MemoryManager.Allocate(640 * 480 * 4);
#if 0
// Get a copy of the front buffer
IDirect3DSurface8* pFrontBuffer = NULL;
if (SUCCEEDED(g_pD3DDevice8->GetFrontBuffer(pFrontBuffer)))
{
D3DLOCKED_RECT LockedRect;
pFrontBuffer->LockRect(0, NULL, &LockedRect);
CopyMemory(g_pPersistedData, LockRect.pBits, 640 * 480 * 4);
pFrontBuffer->UnlockRect();
}
#endif
// TODO: We might want to return something sometime...
/*if( !g_pPersistedData )
{
FILE* fp = fopen( "PersistedSurface.bin", "rb" );
fseek( fp, 0, SEEK_END );
long size = ftell( fp );
g_pPersistedData = g_MemoryManager.Allocate( size );
fread( g_pPersistedData, size, 1, fp );
fclose(fp);
}*/
RETURN (NULL); //g_pPersistedData;
} }
// ****************************************************************** // ******************************************************************
@ -244,5 +210,5 @@ XBSYSAPI EXPORTNUM(4) xboxkrnl::VOID NTAPI xboxkrnl::AvSetSavedDataAddress
LOG_FUNC_ARG(Address) LOG_FUNC_ARG(Address)
LOG_FUNC_END; LOG_FUNC_END;
LOG_UNIMPLEMENTED(); g_AvSavedDataAddress = Address;
} }

2
src/CxbxKrnl/HLEDataBase/D3D8.1.0.3925.inl
View File

@ -3824,7 +3824,7 @@ OOVPATable D3D8_3925[] = {
REGISTER_OOVPA(D3DDevice_SwitchTexture, 3925, PATCH), REGISTER_OOVPA(D3DDevice_SwitchTexture, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_GetModelView, 3925, PATCH), REGISTER_OOVPA(D3DDevice_GetModelView, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_CopyRects, 3925, PATCH), REGISTER_OOVPA(D3DDevice_CopyRects, 3925, PATCH),
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 3925, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 3925, DISABLED),
REGISTER_OOVPA(D3DDevice_GetShaderConstantMode, 3925, PATCH), REGISTER_OOVPA(D3DDevice_GetShaderConstantMode, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_GetVertexShader, 3925, PATCH), REGISTER_OOVPA(D3DDevice_GetVertexShader, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_GetVertexShaderConstant, 3925, PATCH), REGISTER_OOVPA(D3DDevice_GetVertexShaderConstant, 3925, PATCH),

8
src/CxbxKrnl/HLEDataBase/D3D8.1.0.4627.inl
View File

@ -1355,10 +1355,10 @@ OOVPA_NO_XREF(D3DDevice_DrawVerticesUP, 4627, 10)
{ 0x31, 0x04 }, // (Offset,Value)-Pair #6 { 0x31, 0x04 }, // (Offset,Value)-Pair #6
{ 0x32, 0x08 }, // (Offset,Value)-Pair #7 { 0x32, 0x08 }, // (Offset,Value)-Pair #7
// D3DDevice_DrawVerticesUP+0xC2 : cmp esi, 0x80 // D3DDevice_DrawVerticesUP+0x8A : mov [ebp+arg_C], eax
{ 0xC2, 0x81 }, // (Offset,Value)-Pair #8 { 0x8A, 0x89 }, // (Offset,Value)-Pair #8
{ 0xC3, 0xFE }, // (Offset,Value)-Pair #9 { 0x8B, 0x45 }, // (Offset,Value)-Pair #9
{ 0xC4, 0x80 }, // (Offset,Value)-Pair #10 { 0x8C, 0x14 }, // (Offset,Value)-Pair #10
OOVPA_END; OOVPA_END;
// ****************************************************************** // ******************************************************************

19
src/CxbxKrnl/HLEDataBase/D3D8.1.0.5028.inl
View File

@ -762,6 +762,21 @@ OOVPA_NO_XREF(D3DDevice_GetOverlayUpdateStatus, 5028, 12)
{ 0x1C, 0xC3 }, // (Offset,Value)-Pair #12 { 0x1C, 0xC3 }, // (Offset,Value)-Pair #12
OOVPA_END; OOVPA_END;
// ******************************************************************
// * D3D::CDevice::KickOff
// ******************************************************************
OOVPA_NO_XREF(D3DDevice_KickOff, 5028, 8)
{ 0x07, 0x08 },
{ 0x17, 0xC4 },
{ 0x18, 0x20 },
{ 0x19, 0x75 },
{ 0x1A, 0x63 },
{ 0x1B, 0xA1 },
{ 0x6D, 0x85 },
{ 0x7E, 0xBA },
OOVPA_END;
// ****************************************************************** // ******************************************************************
// * D3D8_5028 // * D3D8_5028
// ****************************************************************** // ******************************************************************
@ -905,7 +920,7 @@ OOVPATable D3D8_5028[] = {
REGISTER_OOVPA(D3D_SetFence, 5028, XREF), REGISTER_OOVPA(D3D_SetFence, 5028, XREF),
REGISTER_OOVPA(D3DDevice_InsertFence, 3925, PATCH), REGISTER_OOVPA(D3DDevice_InsertFence, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_IsFencePending, 5028, PATCH), REGISTER_OOVPA(D3DDevice_IsFencePending, 5028, PATCH),
REGISTER_OOVPA(D3DDevice_KickOff, 4627, PATCH), REGISTER_OOVPA(D3DDevice_KickOff, 5028, PATCH),
REGISTER_OOVPA(D3DDevice_SetPixelShaderConstant, 4928, PATCH), REGISTER_OOVPA(D3DDevice_SetPixelShaderConstant, 4928, PATCH),
REGISTER_OOVPA(D3DDevice_SetRenderState_TwoSidedLighting, 4134, PATCH), // Beware of the typo... REGISTER_OOVPA(D3DDevice_SetRenderState_TwoSidedLighting, 4134, PATCH), // Beware of the typo...
REGISTER_OOVPA(D3DDevice_GetTexture2, 4627, PATCH), REGISTER_OOVPA(D3DDevice_GetTexture2, 4627, PATCH),
@ -960,7 +975,7 @@ OOVPATable D3D8_5028[] = {
REGISTER_OOVPA(D3DDevice_SetVertexData2s, 4361, PATCH), REGISTER_OOVPA(D3DDevice_SetVertexData2s, 4361, PATCH),
REGISTER_OOVPA(D3DDevice_SetVertexData4s, 4361, PATCH), REGISTER_OOVPA(D3DDevice_SetVertexData4s, 4361, PATCH),
REGISTER_OOVPA(D3DDevice_PrimeVertexCache, 4627, PATCH), REGISTER_OOVPA(D3DDevice_PrimeVertexCache, 4627, PATCH),
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5028, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5028, DISABLED),
}; };
// ****************************************************************** // ******************************************************************

2
src/CxbxKrnl/HLEDataBase/D3D8.1.0.5233.inl
View File

@ -704,7 +704,7 @@ OOVPATable D3D8_5233[] = {
REGISTER_OOVPA(D3DDevice_LightEnable, 5233, PATCH), REGISTER_OOVPA(D3DDevice_LightEnable, 5233, PATCH),
REGISTER_OOVPA(D3DDevice_DrawIndexedVertices, 5028, PATCH), REGISTER_OOVPA(D3DDevice_DrawIndexedVertices, 5028, PATCH),
REGISTER_OOVPA(D3DDevice_SetMaterial, 4627, PATCH), REGISTER_OOVPA(D3DDevice_SetMaterial, 4627, PATCH),
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, DISABLED),
REGISTER_OOVPA(D3DVertexBuffer_Lock2, 4627, PATCH), REGISTER_OOVPA(D3DVertexBuffer_Lock2, 4627, PATCH),
REGISTER_OOVPA(D3DResource_Register, 3925, PATCH), REGISTER_OOVPA(D3DResource_Register, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_GetBackBuffer2, 5233, PATCH), REGISTER_OOVPA(D3DDevice_GetBackBuffer2, 5233, PATCH),

2
src/CxbxKrnl/HLEDataBase/D3D8.1.0.5344.inl
View File

@ -886,7 +886,7 @@ OOVPATable D3D8_5344[] = {
REGISTER_OOVPA(D3DDevice_LightEnable, 5344, PATCH), // Was 5233 REGISTER_OOVPA(D3DDevice_LightEnable, 5344, PATCH), // Was 5233
REGISTER_OOVPA(D3DDevice_DrawIndexedVertices, 5028, PATCH), REGISTER_OOVPA(D3DDevice_DrawIndexedVertices, 5028, PATCH),
REGISTER_OOVPA(D3DDevice_SetMaterial, 5344, PATCH), // Was 4627 REGISTER_OOVPA(D3DDevice_SetMaterial, 5344, PATCH), // Was 4627
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, DISABLED),
REGISTER_OOVPA(D3DVertexBuffer_Lock2, 4627, PATCH), REGISTER_OOVPA(D3DVertexBuffer_Lock2, 4627, PATCH),
REGISTER_OOVPA(D3DResource_Register, 3925, PATCH), REGISTER_OOVPA(D3DResource_Register, 3925, PATCH),
REGISTER_OOVPA(D3DDevice_GetBackBuffer2, 5344, PATCH), // 5233 REGISTER_OOVPA(D3DDevice_GetBackBuffer2, 5344, PATCH), // 5233

2
src/CxbxKrnl/HLEDataBase/D3D8.1.0.5558.inl
View File

@ -1432,7 +1432,7 @@ OOVPATable D3D8_5558[] = {
REGISTER_OOVPA(D3DDevice_BlockOnFence, 5233, PATCH), REGISTER_OOVPA(D3DDevice_BlockOnFence, 5233, PATCH),
REGISTER_OOVPA(D3D_BlockOnResource, 5558, XREF), REGISTER_OOVPA(D3D_BlockOnResource, 5558, XREF),
REGISTER_OOVPA(D3DResource_BlockUntilNotBusy, 5558, PATCH), REGISTER_OOVPA(D3DResource_BlockUntilNotBusy, 5558, PATCH),
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, DISABLED),
REGISTER_OOVPA(D3DDevice_CopyRects, 5233, PATCH), REGISTER_OOVPA(D3DDevice_CopyRects, 5233, PATCH),
REGISTER_OOVPA(D3DDevice_SetScissors, 5558, PATCH), REGISTER_OOVPA(D3DDevice_SetScissors, 5558, PATCH),
REGISTER_OOVPA(D3DDevice_SetScissors, 5344, PATCH), REGISTER_OOVPA(D3DDevice_SetScissors, 5344, PATCH),

2
src/CxbxKrnl/HLEDataBase/D3D8.1.0.5788.inl
View File

@ -1015,7 +1015,7 @@ OOVPATable D3D8_5788[] = {
REGISTER_OOVPA(D3DResource_IsBusy, 4361, PATCH), REGISTER_OOVPA(D3DResource_IsBusy, 4361, PATCH),
REGISTER_OOVPA(D3D_BlockOnResource, 5558, XREF), REGISTER_OOVPA(D3D_BlockOnResource, 5558, XREF),
REGISTER_OOVPA(D3DResource_BlockUntilNotBusy, 5558, PATCH), REGISTER_OOVPA(D3DResource_BlockUntilNotBusy, 5558, PATCH),
REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, PATCH), REGISTER_OOVPA(D3DVertexBuffer_GetDesc, 5233, DISABLED),
REGISTER_OOVPA(D3DSurface_GetDesc, 4134, PATCH), REGISTER_OOVPA(D3DSurface_GetDesc, 4134, PATCH),
REGISTER_OOVPA(D3DDevice_CopyRects, 5233, PATCH), REGISTER_OOVPA(D3DDevice_CopyRects, 5233, PATCH),
REGISTER_OOVPA(D3DPalette_Lock2, 4627, PATCH), REGISTER_OOVPA(D3DPalette_Lock2, 4627, PATCH),

19
src/CxbxKrnl/HLEDataBase/DSound.1.0.4627.inl
View File

@ -505,6 +505,24 @@ OOVPA_END;
// ****************************************************************** // ******************************************************************
#define DirectSound_CDirectSoundVoice_SetFormat_4627 DirectSound_CDirectSoundVoice_SetFormat_4361 #define DirectSound_CDirectSoundVoice_SetFormat_4627 DirectSound_CDirectSoundVoice_SetFormat_4361
// ******************************************************************
// * DirectSound::CDirectSoundVoice::SetFormat
// ******************************************************************
OOVPA_XREF(DirectSound_CDirectSoundVoice_SetFormat, 4721, 8,
XREF_DirectSound_CDirectSoundVoice_SetFormat,
XRefZero)
{ 0x06, 0x4E },
{ 0x0E, 0xE8 },
{ 0x18, 0x4E },
{ 0x25, 0xFF },
{ 0x2E, 0x0C },
{ 0x34, 0x85 },
{ 0x38, 0x8B },
{ 0x43, 0x00 },
OOVPA_END;
// ****************************************************************** // ******************************************************************
// * DirectSound::CDirectSoundBuffer::SetFormat // * DirectSound::CDirectSoundBuffer::SetFormat
// ****************************************************************** // ******************************************************************
@ -1563,6 +1581,7 @@ OOVPATable DSound_4627[] = {
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), // +s REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), // +s
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4627, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4721, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetFormat, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetFormat, 4627, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetFormat, 4627, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetFormat, 4627, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetFormat, 4361, PATCH), REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetFormat, 4361, PATCH),

29
src/CxbxKrnl/HLEDataBase/DSound.1.0.5028.inl
View File

@ -33,25 +33,22 @@
// ****************************************************************** // ******************************************************************
// ****************************************************************** // ******************************************************************
// * DirectSound::CDirectSoundVoice::SetFormat // * XFileCreateMediaObjectEx
// ****************************************************************** // ******************************************************************
OOVPA_XREF(DirectSound_CDirectSoundVoice_SetFormat, 5028, 8, OOVPA_NO_XREF(XFileCreateMediaObjectEx, 5028, 8)
XREF_DirectSound_CDirectSoundVoice_SetFormat, { 0x03, 0x56 },
XRefZero) { 0x22, 0x1B },
{ 0x89, 0x1B },
{ 0x06, 0x4E }, { 0xA9, 0x85 },
{ 0x0E, 0xE8 }, { 0xAA, 0xF6 },
{ 0x18, 0x4E }, { 0xAB, 0x7C },
{ 0x25, 0xFF }, { 0xAC, 0x0C },
{ 0x2E, 0x0C }, { 0xAD, 0x57 },
{ 0x34, 0x85 },
{ 0x38, 0x8B },
{ 0x43, 0x00 },
OOVPA_END; OOVPA_END;
// ****************************************************************** // ******************************************************************
// * Direct, 5028 // * DSound_5028
// ****************************************************************** // ******************************************************************
OOVPATable DSound_5028[] = { OOVPATable DSound_5028[] = {
@ -183,7 +180,7 @@ OOVPATable DSound_5028[] = {
REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetI3DL2Source, 4134, PATCH), REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetI3DL2Source, 4134, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), // +s REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), // +s
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 5028, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4721, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetFormat, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetFormat, 4627, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetFormat, 4627, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetFormat, 4627, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSound_EnableHeadphones, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSound_EnableHeadphones, 4627, XREF),
@ -241,7 +238,7 @@ OOVPATable DSound_5028[] = {
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetRolloffCurve, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetRolloffCurve, 4627, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetRolloffCurve, 4627, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetRolloffCurve, 4627, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetRolloffCurve, 4627, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetRolloffCurve, 4627, PATCH),
REGISTER_OOVPA(XFileCreateMediaObjectEx, 4627, PATCH), REGISTER_OOVPA(XFileCreateMediaObjectEx, 5028, PATCH),
REGISTER_OOVPA(XWaveFileCreateMediaObject, 4627, PATCH), REGISTER_OOVPA(XWaveFileCreateMediaObject, 4627, PATCH),
// REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetNotificationPositions, 4627, XREF), // REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetNotificationPositions, 4627, XREF),
// REGISTER_OOVPA(IDirectSoundBuffer_SetNotificationPositions, 4627, XREF), // REGISTER_OOVPA(IDirectSoundBuffer_SetNotificationPositions, 4627, XREF),

2
src/CxbxKrnl/HLEDataBase/DSound.1.0.5233.inl
View File

@ -192,7 +192,7 @@ OOVPA_END;
// ****************************************************************** // ******************************************************************
// * DirectSound::CDirectSoundVoice::SetFormat // * DirectSound::CDirectSoundVoice::SetFormat
// ****************************************************************** // ******************************************************************
#define DirectSound_CDirectSoundVoice_SetFormat_5233 DirectSound_CDirectSoundVoice_SetFormat_5028 #define DirectSound_CDirectSoundVoice_SetFormat_5233 DirectSound_CDirectSoundVoice_SetFormat_4721
// ****************************************************************** // ******************************************************************
// DirectSound_CDirectSoundVoice::SetMode // DirectSound_CDirectSoundVoice::SetMode

65
src/CxbxKrnl/HLEDataBase/DSound.1.0.5788.inl
View File

@ -194,62 +194,6 @@ OOVPA_XREF(IDirectSoundBuffer_SetCurrentPosition, 5788, 8,
{ 0x1A, 0x08 }, { 0x1A, 0x08 },
OOVPA_END; OOVPA_END;
// ******************************************************************
// * DirectSound::CMcpxBuffer::Stop
// ******************************************************************
OOVPA_XREF(DirectSound_CMcpxBuffer_Stop, 5788, 8,
XREF_DSOUNDSTOP,
XRefZero)
{ 0x06, 0x56 },
{ 0x0E, 0xF1 },
{ 0x16, 0xFF },
{ 0x1D, 0x04 },
{ 0x1E, 0xFF },
{ 0x26, 0x75 },
{ 0x2F, 0x8B },
{ 0x36, 0xC2 },
OOVPA_END;
// ******************************************************************
// * DirectSound::CDirectSoundBuffer::StopEx
// ******************************************************************
OOVPA_XREF(DirectSound_CDirectSoundBuffer_StopEx, 5788, 8,
XREF_DSOUNDSTOP2,
XRefOne)
XREF_ENTRY( 0x3D, XREF_DSOUNDSTOP ),
{ 0x0C, 0x00 },
{ 0x16, 0x68 },
{ 0x22, 0x05 },
{ 0x2E, 0x20 },
{ 0x3A, 0x24 },
{ 0x46, 0x0B },
{ 0x52, 0x8B },
OOVPA_END;
// ******************************************************************
// * IDirectSoundBuffer_StopEx
// ******************************************************************
OOVPA_XREF(IDirectSoundBuffer_StopEx, 5788, 8,
XRefNoSaveIndex,
XRefOne)
XREF_ENTRY( 0x1D, XREF_DSOUNDSTOP2 ),
{ 0x03, 0x10 },
{ 0x08, 0xFF },
{ 0x0D, 0xC8 },
{ 0x12, 0x83 },
{ 0x17, 0x1B },
{ 0x1C, 0xE8 },
{ 0x21, 0xC2 },
OOVPA_END;
// ****************************************************************** // ******************************************************************
// * DirectSound::CDirectSound::SetRolloffFactor // * DirectSound::CDirectSound::SetRolloffFactor
// ****************************************************************** // ******************************************************************
@ -660,7 +604,7 @@ OOVPA_END;
#define IDirectSoundBuffer_SetMode_5788 IDirectSoundBuffer_SetMode_5233 #define IDirectSoundBuffer_SetMode_5788 IDirectSoundBuffer_SetMode_5233
// ****************************************************************** // ******************************************************************
// * Direct, 5788 // * DSound_5788
// ****************************************************************** // ******************************************************************
OOVPATable DSound_5788[] = { OOVPATable DSound_5788[] = {
@ -706,6 +650,10 @@ OOVPATable DSound_5788[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, XREF), REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, XREF),
// REGISTER_OOVPA(CMcpxBuffer_Play, 5788, XREF), // REGISTER_OOVPA(CMcpxBuffer_Play, 5788, XREF),
REGISTER_OOVPA(CMcpxBuffer_Stop, 4361, XREF),
REGISTER_OOVPA(CMcpxBuffer_Stop2, 4361, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_StopEx, 4361, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_StopEx, 4361, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), // (Possibly weak, but quite OK for 4627 DSOUND) REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), // (Possibly weak, but quite OK for 4627 DSOUND)
REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH),
REGISTER_OOVPA(DirectSound_CFullHRTFSource_GetCenterVolume, 5558, XREF), REGISTER_OOVPA(DirectSound_CFullHRTFSource_GetCenterVolume, 5558, XREF),
@ -750,9 +698,6 @@ OOVPATable DSound_5788[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetPlayRegion, 4361, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetPlayRegion, 4361, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetLoopRegion, 4134, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetLoopRegion, 4134, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Stop, 5788, XREF), // TODO: Use XREF ?Stop@CMcpxBuffer@DirectSound@@QAEJK@Z?
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_StopEx, 5788, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_StopEx, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSound_SetDistanceFactorA, 5558, XREF), REGISTER_OOVPA(DirectSound_CDirectSound_SetDistanceFactorA, 5558, XREF),
REGISTER_OOVPA(IDirectSound_SetDistanceFactor, 4134, PATCH), REGISTER_OOVPA(IDirectSound_SetDistanceFactor, 4134, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSound_SetRolloffFactor, 5788, XREF), REGISTER_OOVPA(DirectSound_CDirectSound_SetRolloffFactor, 5788, XREF),

9
src/CxbxKrnl/HLEDataBase/DSound.1.0.5849.inl
View File

@ -158,7 +158,7 @@ OOVPA_END;
#define DirectSound_CDirectSoundVoice_SetAllParameters_5849 DirectSound_CDirectSoundVoice_SetAllParameters_5558 #define DirectSound_CDirectSoundVoice_SetAllParameters_5849 DirectSound_CDirectSoundVoice_SetAllParameters_5558
// ****************************************************************** // ******************************************************************
// * Direct, 5849 // * DSound_5849
// ****************************************************************** // ******************************************************************
OOVPATable DSound_5849[] = { OOVPATable DSound_5849[] = {
@ -202,6 +202,10 @@ OOVPATable DSound_5849[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, XREF), REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, XREF),
// REGISTER_OOVPA(CMcpxBuffer_Play, 5849, XREF), // REGISTER_OOVPA(CMcpxBuffer_Play, 5849, XREF),
REGISTER_OOVPA(CMcpxBuffer_Stop, 4361, XREF),
REGISTER_OOVPA(CMcpxBuffer_Stop2, 4361, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_StopEx, 4361, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_StopEx, 4361, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), // (Possibly weak, but quite OK for 4627 DSOUND) REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH), // (Possibly weak, but quite OK for 4627 DSOUND)
REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetHeadroom, 5558, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetHeadroom, 5558, XREF),
@ -228,9 +232,6 @@ OOVPATable DSound_5849[] = {
REGISTER_OOVPA(IDirectSoundBuffer_GetCurrentPosition, 5558, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_GetCurrentPosition, 5558, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF), REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetLoopRegion, 4134, PATCH), REGISTER_OOVPA(IDirectSoundBuffer_SetLoopRegion, 4134, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Stop, 5788, XREF), // TODO: Use XREF ?Stop@CMcpxBuffer@DirectSound@@QAEJK@Z?
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_StopEx, 5788, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_StopEx, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSound_SetRolloffFactor, 5849, XREF), REGISTER_OOVPA(DirectSound_CDirectSound_SetRolloffFactor, 5849, XREF),
REGISTER_OOVPA(IDirectSound_SetRolloffFactor, 4134, PATCH), // TODO : Use 5344? REGISTER_OOVPA(IDirectSound_SetRolloffFactor, 4134, PATCH), // TODO : Use 5344?
REGISTER_OOVPA(DirectSound_CDirectSound_SetDopplerFactor, 5788, XREF), REGISTER_OOVPA(DirectSound_CDirectSound_SetDopplerFactor, 5788, XREF),

94
src/CxbxKrnl/HLEIntercept.cpp
View File

@ -77,15 +77,20 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
printf("*******************************************************************************\n"); printf("*******************************************************************************\n");
printf("\n"); printf("\n");
// Make sure the HLE Cache directory exists
std::string cachePath = std::string(szFolder_CxbxReloadedData) + "\\HLECache\\";
int result = SHCreateDirectoryEx(nullptr, cachePath.c_str(), nullptr);
if ((result != ERROR_SUCCESS) && (result != ERROR_ALREADY_EXISTS)) {
CxbxKrnlCleanup("Couldn't create Cxbx-Reloaded HLECache folder!");
}
// Hash the loaded XBE's header, use it as a filename // Hash the loaded XBE's header, use it as a filename
uint32_t uiHash = XXHash32::hash((void*)&CxbxKrnl_Xbe->m_Header, sizeof(Xbe::Header), 0); uint32_t uiHash = XXHash32::hash((void*)&CxbxKrnl_Xbe->m_Header, sizeof(Xbe::Header), 0);
std::stringstream sstream; std::stringstream sstream;
sstream << szFolder_CxbxReloadedData << "\\HLECache\\" << std::hex << uiHash << ".ini"; sstream << cachePath << std::hex << uiHash << ".ini";
std::string filename = sstream.str(); std::string filename = sstream.str();
// TODO: Fix HLE Cache if (PathFileExists(filename.c_str())) {
// if (PathFileExists(filename.c_str())) {
if (false) {
printf("Found HLE Cache File: %08X.ini\n", uiHash); printf("Found HLE Cache File: %08X.ini\n", uiHash);
// Verify the version of the cache file against the HLE Database // Verify the version of the cache file against the HLE Database
@ -93,6 +98,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
char* bufferPtr = buffer; char* bufferPtr = buffer;
GetPrivateProfileString("Info", "HLEDatabaseVersion", NULL, buffer, sizeof(buffer), filename.c_str()); GetPrivateProfileString("Info", "HLEDatabaseVersion", NULL, buffer, sizeof(buffer), filename.c_str());
g_BuildVersion = GetPrivateProfileInt("Libs", "D3D8_BuildVersion", 0, filename.c_str());
if (strcmp(buffer, szHLELastCompileTime) == 0) { if (strcmp(buffer, szHLELastCompileTime) == 0) {
printf("Using HLE Cache\n"); printf("Using HLE Cache\n");
@ -122,6 +128,34 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
} }
} }
// Fix up Render state and Texture States
if (g_HLECache.find("D3DDeferredRenderState") == g_HLECache.end()) {
CxbxKrnlCleanup("EmuD3DDeferredRenderState was not found!");
}
if (g_HLECache.find("D3DDeferredTextureState") == g_HLECache.end()) {
CxbxKrnlCleanup("EmuD3DDeferredTextureState was not found!");
}
if (g_HLECache.find("D3DDEVICE") == g_HLECache.end()) {
CxbxKrnlCleanup("D3DDEVICE was not found!");
}
XTL::EmuD3DDeferredRenderState = (DWORD*)g_HLECache["D3DDeferredRenderState"];
XTL::EmuD3DDeferredTextureState = (DWORD*)g_HLECache["D3DDeferredTextureState"];
XRefDataBase[XREF_D3DDEVICE] = g_HLECache["D3DDEVICE"];
// TODO: Move this into a function rather than duplicating from HLE scanning code
for (int v = 0; v<44; v++) {
XTL::EmuD3DDeferredRenderState[v] = X_D3DRS_UNK;
}
for (int s = 0; s<4; s++) {
for (int v = 0; v<32; v++)
XTL::EmuD3DDeferredTextureState[v + s * 32] = X_D3DTSS_UNK;
}
g_HLECacheUsed = true; g_HLECacheUsed = true;
} }
@ -132,6 +166,11 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
} }
} }
// If the HLE Cache was used, skip symbol maching/patching
if (g_HLECacheUsed) {
return;
}
// //
// initialize Microsoft XDK emulation // initialize Microsoft XDK emulation
// //
@ -352,6 +391,8 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
XRefDataBase[XREF_D3DDEVICE] = DerivedAddr_D3DDevice; XRefDataBase[XREF_D3DDEVICE] = DerivedAddr_D3DDevice;
} }
g_HLECache["D3DDEVICE"] = DerivedAddr_D3DDevice;
// Temporary verification - is XREF_D3DRS_CULLMODE derived correctly? // Temporary verification - is XREF_D3DRS_CULLMODE derived correctly?
if (XRefDataBase[XREF_D3DRS_CULLMODE] != DerivedAddr_D3DRS_CULLMODE) if (XRefDataBase[XREF_D3DRS_CULLMODE] != DerivedAddr_D3DRS_CULLMODE)
{ {
@ -379,6 +420,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
XTL::EmuD3DDeferredRenderState[v] = X_D3DRS_UNK; XTL::EmuD3DDeferredRenderState[v] = X_D3DRS_UNK;
} }
g_HLECache["D3DDeferredRenderState"] = (DWORD)XTL::EmuD3DDeferredRenderState;
printf("HLE: 0x%.08X -> EmuD3DDeferredRenderState\n", XTL::EmuD3DDeferredRenderState); printf("HLE: 0x%.08X -> EmuD3DDeferredRenderState\n", XTL::EmuD3DDeferredRenderState);
//DbgPrintf("HLE: 0x%.08X -> XREF_D3DRS_ROPZCMPALWAYSREAD\n", XRefDataBase[XREF_D3DRS_ROPZCMPALWAYSREAD] ); //DbgPrintf("HLE: 0x%.08X -> XREF_D3DRS_ROPZCMPALWAYSREAD\n", XRefDataBase[XREF_D3DRS_ROPZCMPALWAYSREAD] );
} }
@ -436,6 +478,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
XTL::EmuD3DDeferredTextureState[v+s*32] = X_D3DTSS_UNK; XTL::EmuD3DDeferredTextureState[v+s*32] = X_D3DTSS_UNK;
} }
g_HLECache["D3DDeferredTextureState"] = (DWORD)XTL::EmuD3DDeferredTextureState;
printf("HLE: 0x%.08X -> EmuD3DDeferredTextureState\n", XTL::EmuD3DDeferredTextureState); printf("HLE: 0x%.08X -> EmuD3DDeferredTextureState\n", XTL::EmuD3DDeferredTextureState);
} }
else else
@ -447,12 +490,6 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
} }
} }
// TODO: Re-enable this after fixing render states
// uIf the HLE Cache was used, skip symbol maching/patching
//if (g_HLECacheUsed) {
//continue;
//}
printf("HLE: * Searching HLE database for %s version 1.0.%d... ", LibraryName.c_str(), BuildVersion); printf("HLE: * Searching HLE database for %s version 1.0.%d... ", LibraryName.c_str(), BuildVersion);
const HLEData *FoundHLEData = nullptr; const HLEData *FoundHLEData = nullptr;
@ -497,6 +534,19 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
region << std::hex << pCertificate->dwGameRegion; region << std::hex << pCertificate->dwGameRegion;
WritePrivateProfileString("Certificate", "Region", region.str().c_str(), filename.c_str()); WritePrivateProfileString("Certificate", "Region", region.str().c_str(), filename.c_str());
// Write Library Details
for (int i = 0; i < pXbeHeader->dwLibraryVersions; i++) {
std::string LibraryName(pLibraryVersion[i].szName, pLibraryVersion[i].szName + 8);
std::stringstream buildVersion;
buildVersion << pLibraryVersion[i].wBuildVersion;
WritePrivateProfileString("Libs", LibraryName.c_str(), buildVersion.str().c_str(), filename.c_str());
}
std::stringstream buildVersion;
buildVersion << g_BuildVersion;
WritePrivateProfileString("Libs", "D3D8_BuildVersion", buildVersion.str().c_str(), filename.c_str());
// Write the found HLE Patches into the cache file // Write the found HLE Patches into the cache file
for(auto it = g_HLECache.begin(); it != g_HLECache.end(); ++it) { for(auto it = g_HLECache.begin(); it != g_HLECache.end(); ++it) {
std::stringstream cacheAddress; std::stringstream cacheAddress;
@ -894,30 +944,6 @@ void VerifyHLEOOVPA(HLEVerifyContext *context, OOVPA *oovpa)
void VerifyHLEDataEntry(HLEVerifyContext *context, const OOVPATable *table, uint32 index, uint32 count) void VerifyHLEDataEntry(HLEVerifyContext *context, const OOVPATable *table, uint32 index, uint32 count)
{ {
if (context->against == nullptr) {
context->main_index = index;
// does this entry specify a redirection (patch)?
void * entry_redirect = table[index].emuPatch;
if (entry_redirect != nullptr) {
if (table[index].Oovpa == nullptr) {
HLEError(context, "Patch without an OOVPA at index %d",
index);
} else
// check no patch occurs twice in this table
for (uint32 t = index + 1; t < count; t++) {
if (entry_redirect == table[t].emuPatch) {
if (table[index].Oovpa == table[t].Oovpa) {
HLEError(context, "Patch registered again (with same OOVPA) at index %d",
t);
} else {
HLEError(context, "Patch also used for another OOVPA at index %d",
t);
}
}
}
}
}
else
context->against_index = index; context->against_index = index;
// verify the OOVPA of this entry // verify the OOVPA of this entry

30
src/CxbxKrnl/OOVPA.h
View File

@ -36,23 +36,6 @@
#include "Cxbx.h" #include "Cxbx.h"
// ******************************************************************
// * Take THIS C++ !!
// ******************************************************************
template <class BaseClass, typename MFT> inline void *MFPtoFP(MFT pMemFunc)
{
union
{
MFT pMemFunc;
void(*pFunc)();
}
ThisConv;
ThisConv.pMemFunc = pMemFunc;
return ThisConv.pFunc;
}
#pragma pack(1) #pragma pack(1)
// ****************************************************************** // ******************************************************************
@ -150,7 +133,6 @@ OOVPA_XREF(Name, Version, Count, XRefNoSaveIndex, XRefZero)
struct OOVPATable struct OOVPATable
{ {
OOVPA *Oovpa; OOVPA *Oovpa;
void *emuPatch;
char *szFuncName; char *szFuncName;
uint16_t Version : 13; // 2^13 = 8192, enough to store lowest and higest possible Library Version number in uint16_t Version : 13; // 2^13 = 8192, enough to store lowest and higest possible Library Version number in
uint16_t Flags : 3; uint16_t Flags : 3;
@ -160,8 +142,8 @@ const uint16_t Flag_DontScan = 1; // Indicates an entry that's currently disable
const uint16_t Flag_XRef = 2; // Indicates that an entry is an X-Ref const uint16_t Flag_XRef = 2; // Indicates that an entry is an X-Ref
const uint16_t Flag_Reserved = 4; const uint16_t Flag_Reserved = 4;
#define OOVPA_TABLE_ENTRY_FULL(Oovpa, Patch, DebugName, Version, Flags) \ #define OOVPA_TABLE_ENTRY_FULL(Oovpa, DebugName, Version, Flags) \
{ & Oovpa ## _ ## Version.Header, Patch, DebugName, Version, Flags } { & Oovpa ## _ ## Version.Header, DebugName, Version, Flags }
// REGISTER_OOVPA is the ONLY allowed macro for registrations. // REGISTER_OOVPA is the ONLY allowed macro for registrations.
// Registrations MUST stay sorted to prevent duplicates and maintain overview. // Registrations MUST stay sorted to prevent duplicates and maintain overview.
@ -174,19 +156,19 @@ const uint16_t Flag_Reserved = 4;
#define PATCH /* most common registration, Symbol indicates both an OOVPA and Patch */ #define PATCH /* most common registration, Symbol indicates both an OOVPA and Patch */
#define REGISTER_OOVPA_PATCH(Symbol, Version, ...) \ #define REGISTER_OOVPA_PATCH(Symbol, Version, ...) \
OOVPA_TABLE_ENTRY_FULL(Symbol, XTL::EMUPATCH(Symbol), #Symbol ##, Version, 0) OOVPA_TABLE_ENTRY_FULL(Symbol, #Symbol ##, Version, 0)
#define XREF /* registration of an XRef-only OOVPA, for which no Patch is present */ #define XREF /* registration of an XRef-only OOVPA, for which no Patch is present */
#define REGISTER_OOVPA_XREF(Symbol, Version, ...) \ #define REGISTER_OOVPA_XREF(Symbol, Version, ...) \
OOVPA_TABLE_ENTRY_FULL(Symbol, nullptr, #Symbol ##, Version, Flag_XRef) OOVPA_TABLE_ENTRY_FULL(Symbol, #Symbol ##, Version, Flag_XRef)
#define ALIAS /* registration of a Patch using an alternatively named OOVPA */ #define ALIAS /* registration of a Patch using an alternatively named OOVPA */
#define REGISTER_OOVPA_ALIAS(Symbol, Version, AliasOovpa) \ #define REGISTER_OOVPA_ALIAS(Symbol, Version, AliasOovpa) \
OOVPA_TABLE_ENTRY_FULL(AliasOovpa, XTL::EMUPATCH(Symbol), #Symbol ##, Version, 0) OOVPA_TABLE_ENTRY_FULL(AliasOovpa, #Symbol ##, Version, 0)
#define DISABLED /* registration is (temporarily) disabled by a flag */ #define DISABLED /* registration is (temporarily) disabled by a flag */
#define REGISTER_OOVPA_DISABLED(Symbol, Version, ...) \ #define REGISTER_OOVPA_DISABLED(Symbol, Version, ...) \
OOVPA_TABLE_ENTRY_FULL(Symbol, nullptr, #Symbol ##, Version, Flag_DontScan) OOVPA_TABLE_ENTRY_FULL(Symbol, #Symbol ##, Version, Flag_DontScan)
#pragma pack() #pragma pack()