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.

7
resource/Cxbx.rc
View File

@ -127,10 +127,15 @@ BEGIN
END
POPUP "&Settings"
BEGIN
MENUITEM "Config &Controller...", ID_SETTINGS_CONFIG_CONTROLLER
MENUITEM "Config &Controller...", ID_SETTINGS_CONFIG_CONTROLLER
MENUITEM "Config &Audio...", ID_SETTINGS_CONFIGURESOUND, GRAYED
MENUITEM "Config &Video...", ID_SETTINGS_CONFIG_VIDEO
MENUITEM SEPARATOR
POPUP "&HLE Cache"
BEGIN
MENUITEM "&Clear HLE Cache", ID_CACHE_CLEARHLECACHE
END
MENUITEM SEPARATOR
POPUP "&LLE (Experimental)"
BEGIN
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_DEBUGCONSOLE 40072
#define ID_EMULATION_STOP 40082
#define ID_SETTINGS_CACHE 40083
#define ID_CACHE_CLEARHLECACHE 40084
#define IDC_STATIC -1
// Next default values for new objects
@ -97,7 +99,7 @@
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#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_SYMED_VALUE 104
#endif

3
src/Cxbx/WinMain.cpp
View File

@ -59,6 +59,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
return 1;
}
/* Initialize Cxbx File Paths */
CxbxInitFilePaths();
/*! initialize shared memory */
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);
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:
{
if(m_KrnlDebug == DM_NONE || m_KrnlDebug == DM_FILE)

8
src/CxbxKrnl/CxbxKrnl.cpp
View File

@ -396,8 +396,6 @@ void CxbxKrnlMain(int argc, char* argv[])
RestoreExeImageHeader();
}
CxbxInitFilePaths();
CxbxRestoreContiguousMemory(szFilePath_memory_bin);
CxbxRestorePersistentMemoryRegions();
@ -756,6 +754,9 @@ void CxbxKrnlInit
// initialize grapchics
DbgPrintf("EmuMain: Initializing render window.\n");
XTL::CxbxInitWindow(pXbeHeader, dwXbeHeaderSize);
EmuHLEIntercept(pXbeHeader);
if (bLLE_GPU)
{
DbgPrintf("EmuMain: Initializing OpenGL.\n");
@ -767,7 +768,6 @@ void CxbxKrnlInit
XTL::EmuD3DInit();
}
EmuHLEIntercept(pXbeHeader);
// Apply Media Patches to bypass Anti-Piracy checks
// Required until we perfect emulation of X2 DVD Authentication
// See: https://multimedia.cx/eggs/xbox-sphinx-protocol/
@ -801,7 +801,7 @@ void CxbxInitFilePaths()
// Make sure our data folder exists :
int result = SHCreateDirectoryEx(nullptr, szFolder_CxbxReloadedData, nullptr);
if ((result != ERROR_SUCCESS) && (result != ERROR_ALREADY_EXISTS))
CxbxKrnlCleanup("CxbxInitFilePaths : Couldn't create Cxbx-Reloaded AppData folder!");
CxbxKrnlCleanup("CxbxInitFilePaths : Couldn't create Cxbx-Reloaded AppData folder!");
snprintf(szFilePath_LaunchDataPage_bin, MAX_PATH, "%s\\CxbxLaunchDataPage.bin", szFolder_CxbxReloadedData);
snprintf(szFilePath_EEPROM_bin, MAX_PATH, "%s\\EEPROM.bin", szFolder_CxbxReloadedData);

853
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];
// EmuD3DActiveTexture
extern X_D3DResource *EmuD3DActiveTexture[4];
extern X_D3DPixelContainer *EmuD3DActiveTexture[TEXTURE_STAGES];
// ******************************************************************
// * patch: Direct3D_CreateDevice
@ -1208,7 +1208,7 @@ HRESULT WINAPI EMUPATCH(D3DDevice_GetTransform)
// ******************************************************************
VOID WINAPI EMUPATCH(D3DVertexBuffer_Lock)
(
X_D3DVertexBuffer *ppVertexBuffer,
X_D3DVertexBuffer *pVertexBuffer,
UINT OffsetToLock,
UINT SizeToLock,
BYTE **ppbData,
@ -1220,7 +1220,7 @@ VOID WINAPI EMUPATCH(D3DVertexBuffer_Lock)
// ******************************************************************
BYTE* WINAPI EMUPATCH(D3DVertexBuffer_Lock2)
(
X_D3DVertexBuffer *ppVertexBuffer,
X_D3DVertexBuffer *pVertexBuffer,
DWORD Flags
);
@ -1629,14 +1629,16 @@ VOID WINAPI EMUPATCH(D3DResource_BlockUntilNotBusy)
X_D3DResource *pThis
);
#if 0 // patch DISABLED
// ******************************************************************
// * patch: D3DVertexBuffer_GetDesc
// ******************************************************************
VOID WINAPI EMUPATCH(D3DVertexBuffer_GetDesc)
(
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
X_D3DVERTEXBUFFER_DESC *pDesc
);
#endif
// ******************************************************************
// * patch: D3DDevice_SetScissors
@ -1657,46 +1659,6 @@ HRESULT WINAPI EMUPATCH(D3DDevice_SetScreenSpaceOffset)
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
// ******************************************************************
@ -1705,15 +1667,6 @@ HRESULT WINAPI EMUPATCH(D3DDevice_SetPixelShaderProgram)
X_D3DPIXELSHADERDEF *pPSDef
);
// ******************************************************************
// * patch: D3DDevice_SetScreenSpaceOffset
// ******************************************************************
HRESULT WINAPI EMUPATCH(D3DDevice_SetScreenSpaceOffset)
(
FLOAT x,
FLOAT y
);
// ******************************************************************
// * patch: D3DDevice_CreateStateBlock
// ******************************************************************

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

@ -74,7 +74,7 @@ void XTL::EmuExecutePushBuffer
static void EmuUnswizzleActiveTexture()
{
// 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))
return;

160
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
// 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;
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 XTL::X_D3DVertexBuffer *g_pVertexBuffer = NULL;
@ -100,7 +100,7 @@ void XTL::VertexPatcher::CacheStream(VertexPatchDesc *pPatchDesc,
UINT uiStream)
{
UINT uiStride;
IDirect3DVertexBuffer8 *pOrigVertexBuffer;
IDirect3DVertexBuffer8 *pOrigVertexBuffer = nullptr;
XTL::D3DVERTEXBUFFER_DESC Desc;
void *pCalculateData = NULL;
uint32 uiKey;
@ -177,7 +177,7 @@ void XTL::VertexPatcher::CacheStream(VertexPatchDesc *pPatchDesc,
}
uint32_t uiHash = XXHash32::hash((void *)pCalculateData, uiLength, HASH_SEED);
if(!pPatchDesc->pVertexStreamZeroData)
if(pOrigVertexBuffer)
{
pOrigVertexBuffer->Unlock();
}
@ -222,7 +222,7 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
bool *pbFatalError)
{
UINT uiStride;
IDirect3DVertexBuffer8 *pOrigVertexBuffer;
IDirect3DVertexBuffer8 *pOrigVertexBuffer = nullptr;
XTL::D3DVERTEXBUFFER_DESC Desc;
void *pCalculateData = NULL;
UINT uiLength;
@ -232,7 +232,10 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
if(!pPatchDesc->pVertexStreamZeroData)
{
g_pD3DDevice8->GetStreamSource(uiStream, &pOrigVertexBuffer, &uiStride);
g_pD3DDevice8->GetStreamSource(
uiStream,
&pOrigVertexBuffer,
&uiStride);
if(!pOrigVertexBuffer)
{
/*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!");
}
uiStride = pPatchDesc->uiVertexStreamZeroStride;
pCalculateData = (uint08 *)pPatchDesc->pVertexStreamZeroData;
// 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;
if(pCachedStream->uiCount == (pCachedStream->uiCheckFrequency - 1))
{
if(!pPatchDesc->pVertexStreamZeroData)
if(pOrigVertexBuffer)
{
if(FAILED(pOrigVertexBuffer->Lock(0, 0, (uint08**)&pCalculateData, 0)))
{
CxbxKrnlCleanup("Couldn't lock the original buffer");
}
}
// Use the cached stream length (which is a must for the UP stream)
uint32_t uiHash = XXHash32::hash((void *)pCalculateData, pCachedStream->uiLength, HASH_SEED);
if(uiHash == pCachedStream->uiHash)
@ -311,7 +316,8 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
pCachedStream = NULL;
bMismatch = true;
}
if(!pPatchDesc->pVertexStreamZeroData)
if(pOrigVertexBuffer)
{
pOrigVertexBuffer->Unlock();
}
@ -320,6 +326,7 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
{
pCachedStream->uiCount++;
}
if(!bMismatch)
{
if(!pCachedStream->bIsUP)
@ -337,18 +344,21 @@ bool XTL::VertexPatcher::ApplyCachedStream(VertexPatchDesc *pPatchDesc,
pPatchDesc->pVertexStreamZeroData = pCachedStream->pStreamUP;
pPatchDesc->uiVertexStreamZeroStride = pCachedStream->Stream.uiNewStride;
}
if(pCachedStream->dwPrimitiveCount)
{
// The primitives were patched, draw with the correct number of primimtives from the cache
pPatchDesc->dwPrimitiveCount = pCachedStream->dwPrimitiveCount;
}
bApplied = true;
m_bPatched = true;
}
}
g_PatchedStreamsCache.Unlock();
if(!pPatchDesc->pVertexStreamZeroData)
if(pOrigVertexBuffer)
{
pOrigVertexBuffer->Release();
}
@ -358,9 +368,9 @@ bool XTL::VertexPatcher::ApplyCachedStream(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)
{
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
}
}
else if(g_CurrentVertexShader)
else if(pPatchDesc->hVertexShader)
{
return 1;
}
@ -405,6 +415,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
IDirect3DVertexBuffer8 *pNewVertexBuffer;
uint08 *pOrigData;
uint08 *pNewData;
UINT uiVertexCount;
UINT uiStride;
XTL::D3DVERTEXBUFFER_DESC Desc;
PATCHEDSTREAM *pStream = &m_pStreams[uiStream];
@ -413,14 +424,21 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
if(!pPatchDesc->pVertexStreamZeroData)
{
g_pD3DDevice8->GetStreamSource(uiStream, &pOrigVertexBuffer, &uiStride);
g_pD3DDevice8->GetStreamSource(
uiStream,
&pOrigVertexBuffer,
&uiStride);
if(FAILED(pOrigVertexBuffer->GetDesc(&Desc)))
{
CxbxKrnlCleanup("Could not retrieve original buffer size");
}
// Set a new (exact) vertex count
pPatchDesc->dwVertexCount = Desc.Size / uiStride;
dwNewSize = pPatchDesc->dwVertexCount * pStreamPatch->ConvertedStride;
uiVertexCount = Desc.Size / uiStride;
// 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)))
{
@ -445,9 +463,11 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
CxbxKrnlCleanup("Trying to patch a Draw..UP with more than stream zero!");
}
uiStride = pPatchDesc->uiVertexStreamZeroStride;
pOrigData = (uint08 *)pPatchDesc->pVertexStreamZeroData;
pStreamPatch->ConvertedStride = max(pStreamPatch->ConvertedStride, uiStride); // ??
pOrigData = (uint08 *)pPatchDesc->pVertexStreamZeroData;
// 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;
pNewData = (uint08*)g_MemoryManager.Allocate(dwNewSize);
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 *pNewDataPos = &pNewData[uiVertex * pStreamPatch->ConvertedStride];
@ -509,6 +529,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
break;
}
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)[1] = ((FLOAT)((BYTE*)pOrigVertex)[1]) / 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
// UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
//((FLOAT *)pNewDataPos)[1] = 0.0f; // Would be needed for FLOAT2
pOrigVertex += 1 * sizeof(SHORT);
break;
}
#if !DXBX_USE_D3D9 // No need for patching in D3D9
case X_D3DVSDT_NORMSHORT2: { // 0x21: // Make it FLOAT2
// UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -529,6 +552,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 2 * sizeof(SHORT);
break;
}
#endif
case X_D3DVSDT_NORMSHORT3: { // 0x31: // Make it FLOAT3
// UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -537,6 +561,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 3 * sizeof(SHORT);
break;
}
#if !DXBX_USE_D3D9 // No need for patching in D3D9
case X_D3DVSDT_NORMSHORT4: { // 0x41: // Make it FLOAT4
// UNTESTED - Need test-case!
((FLOAT *)pNewDataPos)[0] = ((FLOAT)((SHORT*)pOrigVertex)[0]) / 32767.0f;
@ -546,6 +571,7 @@ bool XTL::VertexPatcher::PatchStream(VertexPatchDesc *pPatchDesc,
pOrigVertex += 4 * sizeof(SHORT);
break;
}
#endif
case X_D3DVSDT_FLOAT2H: { // 0x72: // Make it FLOAT4 and set the third float to 0.0
((FLOAT *)pNewDataPos)[0] = ((FLOAT*)pOrigVertex)[0];
((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++)
{
X_D3DPixelContainer *pPixelContainer = (X_D3DPixelContainer*)EmuD3DActiveTexture[i];
X_D3DPixelContainer *pPixelContainer = EmuD3DActiveTexture[i];
if (pPixelContainer)
{
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;
// vertex data arrays
BYTE *pOrigVertexData = 0;
BYTE *pPatchedVertexData = 0;
BYTE *pOrigVertexData = nullptr;
BYTE *pPatchedVertexData = nullptr;
if(pPatchDesc->pVertexStreamZeroData == 0)
if(pPatchDesc->pVertexStreamZeroData == nullptr)
{
g_pD3DDevice8->GetStreamSource(0, &pStream->pOriginalStream, &pStream->uiOrigStride);
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;
}
if(pPatchDesc->pVertexStreamZeroData == 0)
if(pPatchDesc->pVertexStreamZeroData == nullptr)
{
// 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);
}
if(pPatchDesc->pVertexStreamZeroData == 0)
if(pPatchDesc->pVertexStreamZeroData == nullptr)
{
pStream->pOriginalStream->Unlock();
pStream->pPatchedStream->Unlock();
@ -1039,6 +1065,9 @@ bool XTL::VertexPatcher::Restore()
if(this->m_bAllocatedStreamZeroData)
{
free(m_pNewVertexStreamZeroData);
// Cleanup, just to be sure :
m_pNewVertexStreamZeroData = nullptr;
this->m_bAllocatedStreamZeroData = false;
}
}
else
@ -1055,7 +1084,7 @@ VOID XTL::EmuFlushIVB()
{
XTL::EmuUpdateDeferredStates();
DWORD *pdwVB = (DWORD*)g_IVBTable;
DWORD *pdwVB = (DWORD*)g_pIVBVertexBuffer;
UINT uiStride = 0;
@ -1080,23 +1109,18 @@ VOID XTL::EmuFlushIVB()
DbgPrintf("g_IVBTblOffs := %d\n", g_IVBTblOffs);
for(uint v=0;v<g_IVBTblOffs;v++)
{
DWORD dwPos = dwCurFVF & D3DFVF_POSITION_MASK;
DWORD dwPos = dwCurFVF & D3DFVF_POSITION_MASK;
DWORD dwTexN = (dwCurFVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
for(uint v=0;v<g_IVBTblOffs;v++)
{
if(dwPos == D3DFVF_XYZ)
{
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.y;
*(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);
}
else if(dwPos == D3DFVF_XYZRHW)
{
@ -1105,11 +1129,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z;
*(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);
}
else if(dwPos == D3DFVF_XYZB1)
@ -1119,14 +1138,8 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].Position.z;
*(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);
}
else
{
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.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);
}
if(dwCurFVF & D3DFVF_DIFFUSE)
{
*(DWORD*)pdwVB++ = g_IVBTable[v].dwDiffuse;
if(v == 0)
{
uiStride += sizeof(DWORD);
}
DbgPrintf("IVB Diffuse := 0x%.08X\n", g_IVBTable[v].dwDiffuse);
}
@ -1164,26 +1166,14 @@ VOID XTL::EmuFlushIVB()
{
*(DWORD*)pdwVB++ = g_IVBTable[v].dwSpecular;
if(v == 0)
{
uiStride += sizeof(DWORD);
}
DbgPrintf("IVB Specular := 0x%.08X\n", g_IVBTable[v].dwSpecular);
}
DWORD dwTexN = (dwCurFVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
if(dwTexN >= 1)
{
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord1.x;
*(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);
}
@ -1192,11 +1182,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord2.x;
*(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);
}
@ -1205,11 +1190,6 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord3.x;
*(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);
}
@ -1218,21 +1198,29 @@ VOID XTL::EmuFlushIVB()
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.x;
*(FLOAT*)pdwVB++ = g_IVBTable[v].TexCoord4.y;
if(v == 0)
{
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);
}
}
VertexPatchDesc VPDesc;
VPDesc.PrimitiveType = g_IVBPrimitiveType;
VPDesc.dwVertexCount = g_IVBTblOffs;
VPDesc.dwOffset = 0;
VPDesc.pVertexStreamZeroData = g_IVBTable;
VPDesc.pVertexStreamZeroData = g_pIVBVertexBuffer;
VPDesc.uiVertexStreamZeroStride = uiStride;
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);
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;
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 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
{
XTL::D3DXVECTOR3 Position; // Position

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

File diff suppressed because it is too large Load Diff

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
extern boolean IsValidCurrentShader(void);
extern boolean VshHandleIsValidShader(DWORD Handle);
inline boolean VshHandleIsVertexShader(DWORD Handle) { return (Handle & 0x80000000) ? TRUE : FALSE; }
inline X_D3DVertexShader *VshHandleGetVertexShader(DWORD Handle) { return (X_D3DVertexShader *)(Handle & 0x7FFFFFFF); }
// Dxbx note : On Xbox, a FVF is recognizable when the handle <= 0x0000FFFF
// (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);
#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_MIN X_D3DTEXTURE_PITCH_ALIGNMENT
#define TEXTURE_STAGES 4 // X_D3DTS_STAGECOUNT
typedef enum _X_D3DSET_DEPTH_CLIP_PLANES_FLAGS
{
X_D3DSDCP_SET_VERTEXPROGRAM_PLANES = 1,
@ -260,6 +262,21 @@ typedef struct _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
{
X_D3DFORMAT Format;
@ -358,7 +375,7 @@ typedef struct _PixelShader_
DWORD dwStatus;
X_D3DPIXELSHADERDEF PSDef;
DWORD dwStageMap[4];
DWORD dwStageMap[TEXTURE_STAGES];
} 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;
}
// 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()
// ******************************************************************
@ -81,47 +87,7 @@ XBSYSAPI EXPORTNUM(1) xboxkrnl::PVOID NTAPI xboxkrnl::AvGetSavedDataAddress(void
{
LOG_FUNC();
__asm int 3;
// 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;
RETURN(g_AvSavedDataAddress);
}
// ******************************************************************
@ -244,5 +210,5 @@ XBSYSAPI EXPORTNUM(4) xboxkrnl::VOID NTAPI xboxkrnl::AvSetSavedDataAddress
LOG_FUNC_ARG(Address)
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_GetModelView, 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_GetVertexShader, 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
{ 0x32, 0x08 }, // (Offset,Value)-Pair #7
// D3DDevice_DrawVerticesUP+0xC2 : cmp esi, 0x80
{ 0xC2, 0x81 }, // (Offset,Value)-Pair #8
{ 0xC3, 0xFE }, // (Offset,Value)-Pair #9
{ 0xC4, 0x80 }, // (Offset,Value)-Pair #10
// D3DDevice_DrawVerticesUP+0x8A : mov [ebp+arg_C], eax
{ 0x8A, 0x89 }, // (Offset,Value)-Pair #8
{ 0x8B, 0x45 }, // (Offset,Value)-Pair #9
{ 0x8C, 0x14 }, // (Offset,Value)-Pair #10
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
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
// ******************************************************************
@ -905,7 +920,7 @@ OOVPATable D3D8_5028[] = {
REGISTER_OOVPA(D3D_SetFence, 5028, XREF),
REGISTER_OOVPA(D3DDevice_InsertFence, 3925, 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_SetRenderState_TwoSidedLighting, 4134, PATCH), // Beware of the typo...
REGISTER_OOVPA(D3DDevice_GetTexture2, 4627, PATCH),
@ -960,7 +975,7 @@ OOVPATable D3D8_5028[] = {
REGISTER_OOVPA(D3DDevice_SetVertexData2s, 4361, PATCH),
REGISTER_OOVPA(D3DDevice_SetVertexData4s, 4361, 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_DrawIndexedVertices, 5028, 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(D3DResource_Register, 3925, 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_DrawIndexedVertices, 5028, PATCH),
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(D3DResource_Register, 3925, PATCH),
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(D3D_BlockOnResource, 5558, XREF),
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_SetScissors, 5558, 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(D3D_BlockOnResource, 5558, XREF),
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(D3DDevice_CopyRects, 5233, 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
// ******************************************************************
// * 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
// ******************************************************************
@ -1563,6 +1581,7 @@ OOVPATable DSound_4627[] = {
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Release, 3936, PATCH), // +s
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4627, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetFormat, 4721, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetFormat, 4627, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetFormat, 4627, 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,
XRefZero)
{ 0x06, 0x4E },
{ 0x0E, 0xE8 },
{ 0x18, 0x4E },
{ 0x25, 0xFF },
{ 0x2E, 0x0C },
{ 0x34, 0x85 },
{ 0x38, 0x8B },
{ 0x43, 0x00 },
{ 0x03, 0x56 },
{ 0x22, 0x1B },
{ 0x89, 0x1B },
{ 0xA9, 0x85 },
{ 0xAA, 0xF6 },
{ 0xAB, 0x7C },
{ 0xAC, 0x0C },
{ 0xAD, 0x57 },
OOVPA_END;
// ******************************************************************
// * Direct, 5028
// * DSound_5028
// ******************************************************************
OOVPATable DSound_5028[] = {
@ -183,7 +180,7 @@ OOVPATable DSound_5028[] = {
REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetI3DL2Source, 4134, PATCH),
REGISTER_OOVPA(IDirectSoundBuffer_Stop, 4134, PATCH),
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(IDirectSoundBuffer_SetFormat, 4627, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSound_EnableHeadphones, 4627, XREF),
@ -241,7 +238,7 @@ OOVPATable DSound_5028[] = {
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetRolloffCurve, 4627, XREF),
REGISTER_OOVPA(DirectSound_CDirectSoundStream_SetRolloffCurve, 4627, XREF),
REGISTER_OOVPA(IDirectSoundBuffer_SetRolloffCurve, 4627, PATCH),
REGISTER_OOVPA(XFileCreateMediaObjectEx, 4627, PATCH),
REGISTER_OOVPA(XFileCreateMediaObjectEx, 5028, PATCH),
REGISTER_OOVPA(XWaveFileCreateMediaObject, 4627, PATCH),
// REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_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
// ******************************************************************
#define DirectSound_CDirectSoundVoice_SetFormat_5233 DirectSound_CDirectSoundVoice_SetFormat_5028
#define DirectSound_CDirectSoundVoice_SetFormat_5233 DirectSound_CDirectSoundVoice_SetFormat_4721
// ******************************************************************
// 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 },
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
// ******************************************************************
@ -660,7 +604,7 @@ OOVPA_END;
#define IDirectSoundBuffer_SetMode_5788 IDirectSoundBuffer_SetMode_5233
// ******************************************************************
// * Direct, 5788
// * DSound_5788
// ******************************************************************
OOVPATable DSound_5788[] = {
@ -706,6 +650,10 @@ OOVPATable DSound_5788[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, 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_Release, 3936, PATCH),
REGISTER_OOVPA(DirectSound_CFullHRTFSource_GetCenterVolume, 5558, XREF),
@ -750,9 +698,6 @@ OOVPATable DSound_5788[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetPlayRegion, 4361, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF),
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(IDirectSound_SetDistanceFactor, 4134, PATCH),
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
// ******************************************************************
// * Direct, 5849
// * DSound_5849
// ******************************************************************
OOVPATable DSound_5849[] = {
@ -202,6 +202,10 @@ OOVPATable DSound_5849[] = {
REGISTER_OOVPA(IDirectSoundBuffer_SetMinDistance, 5788, PATCH),
REGISTER_OOVPA(DirectSound_CMcpxBuffer_Play, 3925, 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_Release, 3936, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundVoice_SetHeadroom, 5558, XREF),
@ -228,9 +232,6 @@ OOVPATable DSound_5849[] = {
REGISTER_OOVPA(IDirectSoundBuffer_GetCurrentPosition, 5558, PATCH),
REGISTER_OOVPA(DirectSound_CDirectSoundBuffer_SetLoopRegion, 5558, XREF),
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(IDirectSound_SetRolloffFactor, 4134, PATCH), // TODO : Use 5344?
REGISTER_OOVPA(DirectSound_CDirectSound_SetDopplerFactor, 5788, XREF),

96
src/CxbxKrnl/HLEIntercept.cpp
View File

@ -77,15 +77,20 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
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
uint32_t uiHash = XXHash32::hash((void*)&CxbxKrnl_Xbe->m_Header, sizeof(Xbe::Header), 0);
std::stringstream sstream;
sstream << szFolder_CxbxReloadedData << "\\HLECache\\" << std::hex << uiHash << ".ini";
sstream << cachePath << std::hex << uiHash << ".ini";
std::string filename = sstream.str();
// TODO: Fix HLE Cache
// if (PathFileExists(filename.c_str())) {
if (false) {
if (PathFileExists(filename.c_str())) {
printf("Found HLE Cache File: %08X.ini\n", uiHash);
// Verify the version of the cache file against the HLE Database
@ -93,6 +98,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
char* bufferPtr = buffer;
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) {
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;
}
@ -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
//
@ -352,6 +391,8 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
XRefDataBase[XREF_D3DDEVICE] = DerivedAddr_D3DDevice;
}
g_HLECache["D3DDEVICE"] = DerivedAddr_D3DDevice;
// Temporary verification - is XREF_D3DRS_CULLMODE derived correctly?
if (XRefDataBase[XREF_D3DRS_CULLMODE] != DerivedAddr_D3DRS_CULLMODE)
{
@ -379,6 +420,7 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
XTL::EmuD3DDeferredRenderState[v] = X_D3DRS_UNK;
}
g_HLECache["D3DDeferredRenderState"] = (DWORD)XTL::EmuD3DDeferredRenderState;
printf("HLE: 0x%.08X -> EmuD3DDeferredRenderState\n", XTL::EmuD3DDeferredRenderState);
//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;
}
g_HLECache["D3DDeferredTextureState"] = (DWORD)XTL::EmuD3DDeferredTextureState;
printf("HLE: 0x%.08X -> EmuD3DDeferredTextureState\n", XTL::EmuD3DDeferredTextureState);
}
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);
const HLEData *FoundHLEData = nullptr;
@ -497,6 +534,19 @@ void EmuHLEIntercept(Xbe::Header *pXbeHeader)
region << std::hex << pCertificate->dwGameRegion;
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
for(auto it = g_HLECache.begin(); it != g_HLECache.end(); ++it) {
std::stringstream cacheAddress;
@ -894,31 +944,7 @@ void VerifyHLEOOVPA(HLEVerifyContext *context, OOVPA *oovpa)
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
if (table[index].Oovpa != nullptr)

30
src/CxbxKrnl/OOVPA.h
View File

@ -36,23 +36,6 @@
#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)
// ******************************************************************
@ -150,7 +133,6 @@ OOVPA_XREF(Name, Version, Count, XRefNoSaveIndex, XRefZero)
struct OOVPATable
{
OOVPA *Oovpa;
void *emuPatch;
char *szFuncName;
uint16_t Version : 13; // 2^13 = 8192, enough to store lowest and higest possible Library Version number in
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_Reserved = 4;
#define OOVPA_TABLE_ENTRY_FULL(Oovpa, Patch, DebugName, Version, Flags) \
{ & Oovpa ## _ ## Version.Header, Patch, DebugName, Version, Flags }
#define OOVPA_TABLE_ENTRY_FULL(Oovpa, DebugName, Version, Flags) \
{ & Oovpa ## _ ## Version.Header, DebugName, Version, Flags }
// REGISTER_OOVPA is the ONLY allowed macro for registrations.
// 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 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 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 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 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()