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

Disables EmuXGUnswizzleRect patches 

Instead, use EmuUnswizzleRect where required.
This commit is contained in:
PatrickvL 2017-01-19 01:33:00 +01:00
parent 0c68f5e375
commit d8147ceeb9
13 changed files with 142 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/CxbxKrnl/EmuD3D8.cpp
View File

@ -1209,7 +1209,7 @@ static void EmuUnswizzleTextureStages()
void *pTemp = malloc(dwHeight*dwPitch);
XTL::EmuXGUnswizzleRect
XTL::EmuUnswizzleRect
(
LockedRect.pBits, dwWidth, dwHeight, dwDepth,
pTemp, dwPitch, iRect, iPoint, dwBPP
@ -4493,14 +4493,14 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
// TODO: check for dimensions
// TODO: HACK: Temporary?
if(X_Format == 0x2E)
if(X_Format == X_D3DFMT_LIN_D24S8)
{
/*CxbxKrnlCleanup*/EmuWarning("D3DFMT_LIN_D24S8 not yet supported!");
X_Format = X_D3DFMT_LIN_A8R8G8B8;
Format = D3DFMT_A8R8G8B8;
}
if(X_Format == 0x30)
if(X_Format == X_D3DFMT_LIN_D16)
{
/*CxbxKrnlCleanup*/EmuWarning("D3DFMT_LIN_D16 not yet supported!");
X_Format = X_D3DFMT_LIN_R5G6B5;
@ -4811,9 +4811,8 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
}
else
{
//__asm int 3;
// First we need to unswizzle the texture data
XTL::EmuXGUnswizzleRect
XTL::EmuUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
@ -4822,11 +4821,6 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
if (CacheFormat == D3DFMT_P8) //Palette
{
EmuWarning("Unsupported texture format D3DFMT_P8,\nexpanding to D3DFMT_A8R8G8B8");
//#if 0
//
// create texture resource
//
//__asm int 3;
BYTE *pPixelData = (BYTE*)LockedRect.pBits;
DWORD dwDataSize = dwMipWidth*dwMipHeight;
@ -4858,7 +4852,6 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
// Flush unused data buffers
CxbxFree(pExpandedTexture);
//#endif
}
}
}

98
src/CxbxKrnl/EmuD3D8/Convert.cpp
View File

@ -544,3 +544,101 @@ CONST DWORD XTL::EmuD3DRenderStateSimpleEncoded[174] =
X_D3DRSSE_UNK, 0x00040350, // 170
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 172
};
void XTL::EmuUnswizzleRect
(
PVOID pSrcBuff,
DWORD dwWidth,
DWORD dwHeight,
DWORD dwDepth,
PVOID pDstBuff,
DWORD dwPitch,
RECT rSrc, // Unused
POINT poDst, // Unused
DWORD dwBPP // expressed in Bytes Per Pixel
) // Source : Dxbx
{
// TODO : The following could be done using a lookup table :
DWORD dwMaskX = 0, dwMaskY = 0, dwMaskZ = 0;
for (uint i=1, j=1; (i <= dwWidth) || (i <= dwHeight) || (i <= dwDepth); i <<= 1) {
if (i < dwWidth) {
dwMaskX = dwMaskX | j;
j <<= 1;
};
if (i < dwHeight) {
dwMaskY = dwMaskY | j;
j <<= 1;
}
if (i < dwDepth) {
dwMaskZ = dwMaskZ | j;
j <<= 1;
}
}
// get the biggest mask
DWORD dwMaskMax;
if (dwMaskX > dwMaskY)
dwMaskMax = dwMaskX;
else
dwMaskMax = dwMaskY;
if (dwMaskZ > dwMaskMax)
dwMaskMax = dwMaskZ;
DWORD dwStartX = 0, dwOffsetX = 0;
DWORD dwStartY = 0, dwOffsetY = 0;
DWORD dwStartZ = 0, dwOffsetW = 0;
/* TODO : Use values from poDst and rSrc to initialize above values, after which the following makes more sense:
for (uint i=1; i <= dwMaskMax; i <<= 1) {
if (i <= dwMaskX) {
if (dwMaskX & i)
dwStartX |= (dwOffsetX & i);
else
dwOffsetX <<= 1;
}
if (i <= dwMaskY) {
if (dwMaskY & i)
dwStartY |= dwOffsetY & i;
else
dwOffsetY <<= 1;
}
if (i <= dwMaskZ) {
if (dwMaskZ & i)
dwStartZ |= dwOffsetZ & i;
else
dwOffsetZ <<= 1;
}
}*/
DWORD dwZ = dwStartZ;
for (uint z = 0; z < dwDepth; z++) {
DWORD dwY = dwStartY;
// TODO : How could we do one memcpy when lines AND pixels are next to eachother?
for (uint y = 0; y < dwHeight; y++) {
DWORD dwX = dwStartX;
// We use one memcpy for the entire line when pixels are next to eachother :
// TODO : How can we simplify the next check; (dwMaskX & 1) perhaps?
if (dwX + 1 == (dwX - dwMaskX) & dwMaskX) {
memcpy(pDstBuff, (PBYTE)pSrcBuff + (dwX | dwY | dwZ) * dwBPP, dwBPP * dwWidth); // copy one line
pDstBuff = (PBYTE)pDstBuff + dwBPP * dwWidth; // Step to next line in destination
}
else {
for (uint x = 0; x < dwWidth; x++) {
memcpy(pDstBuff, (PBYTE)pSrcBuff + (dwX | dwY | dwZ) * dwBPP, dwBPP); // copy one pixel
pDstBuff = (PBYTE)pDstBuff + dwBPP; // Step to next pixel in destination
dwX = (dwX - dwMaskX) & dwMaskX; // step to next pixel in source
}
}
pDstBuff = (PBYTE)pDstBuff + dwPitch - (dwWidth * dwBPP); // step to next line in destination
dwY = (dwY - dwMaskY) & dwMaskY; // step to next line in source
}
// TODO : How to step to next level in destination? Should X and Y be recalculated per level?
dwZ = (dwZ - dwMaskZ) & dwMaskZ; // step to next level in source
}
} // EmuUnswizzleRect NOPATCH

13
src/CxbxKrnl/EmuD3D8/Convert.h
View File

@ -205,4 +205,17 @@ inline D3DPRIMITIVETYPE EmuPrimitiveType(X_D3DPRIMITIVETYPE PrimitiveType)
return EmuPrimitiveTypeLookup[PrimitiveType];
}
extern void EmuUnswizzleRect
(
PVOID pSrcBuff,
DWORD dwWidth,
DWORD dwHeight,
DWORD dwDepth,
PVOID pDstBuff,
DWORD dwPitch,
RECT rSrc, // Unused
POINT poDst, // Unused
DWORD dwBPP // expressed in Bytes Per Pixel
); // NOPATCH
#endif

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

@ -133,7 +133,7 @@ static void EmuUnswizzleActiveTexture()
void *pTemp = malloc(dwHeight*dwPitch);
XTL::EmuXGUnswizzleRect
XTL::EmuUnswizzleRect
(
LockedRect.pBits, dwWidth, dwHeight, dwDepth,
pTemp, dwPitch, iRect, iPoint, dwBPP

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

@ -1364,7 +1364,7 @@ VOID XTL::EmuFlushIVB()
return;
}
VOID XTL::EmuUpdateActiveTexture()
VOID XTL::EmuUpdateActiveTexture() // Never called!
{
//
// DEBUGGING
@ -1513,7 +1513,7 @@ VOID XTL::EmuUpdateActiveTexture()
}
else
{
XTL::EmuXGUnswizzleRect
XTL::EmuUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP

107
src/CxbxKrnl/EmuXG.cpp
View File

@ -192,113 +192,6 @@ VOID WINAPI XTL::EmuXGSwizzleBox
}
}
// ******************************************************************
// * func: EmuXGUnswizzleRect
// ******************************************************************
VOID WINAPI XTL::EmuXGUnswizzleRect
(
PVOID pSrcBuff,
DWORD dwWidth,
DWORD dwHeight,
DWORD dwDepth,
PVOID pDstBuff,
DWORD dwPitch,
RECT rSrc,
POINT poDst,
DWORD dwBPP
)
{
DWORD dwOffsetU = 0, dwMaskU = 0;
DWORD dwOffsetV = 0, dwMaskV = 0;
DWORD dwOffsetW = 0, dwMaskW = 0;
DWORD i = 1;
DWORD j = 1;
// while( (i >= dwWidth) || (i >= dwHeight) || (i >= dwDepth) )
while( (i <= dwWidth) || (i <= dwHeight) || (i <= dwDepth) )
{
if(i < dwWidth)
{
dwMaskU |= j;
j<<=1;
}
if(i < dwHeight)
{
dwMaskV |= j;
j<<=1;
}
if(i < dwDepth)
{
dwMaskW |= j;
j<<=1;
}
i<<=1;
}
DWORD dwSU = 0;
DWORD dwSV = 0;
DWORD dwSW = 0;
DWORD dwMaskMax=0;
// get the biggest mask
if(dwMaskU > dwMaskV)
dwMaskMax=dwMaskU;
else
dwMaskMax=dwMaskV;
if(dwMaskW > dwMaskMax)
dwMaskMax=dwMaskW;
for(i = 1; i <= dwMaskMax; i<<=1)
{
if(i<=dwMaskU)
{
if(dwMaskU & i) dwSU |= (dwOffsetU & i);
else dwOffsetU<<=1;
}
if(i<=dwMaskV)
{
if(dwMaskV & i) dwSV |= (dwOffsetV & i);
else dwOffsetV<<=1;
}
if(i<=dwMaskW)
{
if(dwMaskW & i) dwSW |= (dwOffsetW & i);
else dwOffsetW<<=1;
}
}
DWORD dwW = dwSW;
DWORD dwV = dwSV;
DWORD dwU = dwSU;
for(DWORD z=0; z<dwDepth; z++)
{
dwV = dwSV;
for(DWORD y=0; y<dwHeight; y++)
{
dwU = dwSU;
for (DWORD x=0; x<dwWidth; x++)
{
memcpy(pDstBuff, &((BYTE*)pSrcBuff)[(dwU|dwV|dwW)*dwBPP], dwBPP);
pDstBuff=(PVOID)(((DWORD)pDstBuff)+dwBPP);
dwU = (dwU - dwMaskU) & dwMaskU;
}
pDstBuff=(PVOID)(((DWORD)pDstBuff)+(dwPitch-dwWidth*dwBPP));
dwV = (dwV - dwMaskV) & dwMaskV;
}
dwW = (dwW - dwMaskW) & dwMaskW;
}
}
// ******************************************************************
// * func: EmuXGWriteSurfaceOrTextureToXPR
// ******************************************************************

16
src/CxbxKrnl/EmuXG.h
View File

@ -82,22 +82,6 @@ VOID WINAPI EmuXGSwizzleBox
DWORD BytesPerPixel
);
// ******************************************************************
// * func: EmuXGUnswizzleRect
// ******************************************************************
VOID WINAPI EmuXGUnswizzleRect
(
PVOID pSrcBuffer,
DWORD dwWidth,
DWORD dwHeight,
DWORD dwDepth,
PVOID pDstBuff,
DWORD dwPitch,
RECT rSrc,
POINT poDst,
DWORD dwBPP
);
// ******************************************************************
// * func: EmuXGWriteSurfaceOrTextureToXPR
// ******************************************************************

4
src/CxbxKrnl/HLEDataBase/XG.1.0.3911.inl
View File

@ -76,6 +76,7 @@ OOVPA_NO_XREF(XGSwizzleBox_1_0_3911, 8)
{ 0xFE, 0x45 },
OOVPA_END;
/* Leave unpatched
// ******************************************************************
// * XGUnswizzleRect
// ******************************************************************
@ -90,6 +91,7 @@ OOVPA_NO_XREF(XGUnswizzleRect_1_0_3911, 8)
{ 0xDE, 0x89 },
{ 0xFE, 0x60 },
OOVPA_END;
*/
// ******************************************************************
// * XGWriteSurfaceOrTextureToXPR
@ -129,7 +131,9 @@ OOVPATable XG_1_0_3911[] = {
// XGSwizzleRect
OOVPA_TABLE_PATCH(XGSwizzleRect_1_0_3911, XTL::EmuXGSwizzleRect),
// XGUnswizzleRect
/* Leave unpatched
OOVPA_TABLE_PATCH(XGUnswizzleRect_1_0_3911, XTL::EmuXGUnswizzleRect),
*/
// XGSwizzleBox
OOVPA_TABLE_PATCH(XGSwizzleBox_1_0_3911, XTL::EmuXGSwizzleBox),
// XGWriteSurfaceOrTextureToXPR

2
src/CxbxKrnl/HLEDataBase/XG.1.0.4034.inl
View File

@ -77,6 +77,7 @@ OOVPA_NO_XREF(XGSwizzleBox_1_0_3911, 8)
{ 0xFE, 0x45 },
OOVPA_END;
/* Leave unpatched
// ******************************************************************
// * XGUnswizzleRect
// ******************************************************************
@ -91,6 +92,7 @@ OOVPA_NO_XREF(XGUnswizzleRect_1_0_3911, 8)
{ 0xDE, 0x89 },
{ 0xFE, 0x60 },
OOVPA_END;
*/
// ******************************************************************
// * XGWriteSurfaceOrTextureToXPR

4
src/CxbxKrnl/HLEDataBase/XG.1.0.4361.inl
View File

@ -84,6 +84,7 @@ OOVPA_NO_XREF(XGSwizzleRect_1_0_4361, 10)
{ 0xED, 0x0B }, // (Offset,Value)-Pair #10
OOVPA_END;
/* Leave unpatched
// ******************************************************************
// * XGUnswizzleRect
// ******************************************************************
@ -98,6 +99,7 @@ OOVPA_NO_XREF(XGUnswizzleRect_1_0_4361, 8)
{ 0xDE, 0x89 },
{ 0xFE, 0x60 },
OOVPA_END;
*/
// ******************************************************************
// * XGSetVertexBufferHeader
@ -154,7 +156,9 @@ OOVPATable XG_1_0_4361[] = {
// XGSwizzleRect
OOVPA_TABLE_PATCH(XGSwizzleRect_1_0_4361, XTL::EmuXGSwizzleRect),
// XGUnswizzleRect
/* Leave unpatched
OOVPA_TABLE_PATCH(XGUnswizzleRect_1_0_4361, XTL::EmuXGUnswizzleRect),
*/
// XGSetTextureHeader (* Unchanged since 3911 *)
OOVPA_TABLE_PATCH(XGSetTextureHeader_1_0_3911, XTL::EmuXGSetTextureHeader),
// XGSetVertexBufferHeader

4
src/CxbxKrnl/HLEDataBase/XG.1.0.4627.inl
View File

@ -70,6 +70,7 @@ OOVPA_NO_XREF(XGWriteSurfaceOrTextureToXPR_1_0_4627, 7)
{ 0xE2, 0x8B },
OOVPA_END;
/* Leave unpatched
// ******************************************************************
// * XGUnswizzleRect
// ******************************************************************
@ -84,6 +85,7 @@ OOVPA_NO_XREF(XGUnswizzleRect_1_0_4627, 8)
{ 0xDE, 0x89 },
{ 0xFE, 0x60 },
OOVPA_END;
*/
// ******************************************************************
// * XG_1_0_4627
@ -95,7 +97,9 @@ OOVPATable XG_1_0_4627[] = {
// XGSwizzleRect (* unchanged since 4361 *)
OOVPA_TABLE_PATCH(XGSwizzleRect_1_0_4361, XTL::EmuXGSwizzleRect),
// XGUnswizzleRect
/* Leave unpatched
OOVPA_TABLE_PATCH(XGUnswizzleRect_1_0_4627, XTL::EmuXGUnswizzleRect),
*/
// XGSwizzleBox
OOVPA_TABLE_PATCH(XGSwizzleBox_1_0_4627, XTL::EmuXGSwizzleBox),
// XGWriteSurfaceOrTextureToXPR

4
src/CxbxKrnl/HLEDataBase/XG.1.0.5558.inl
View File

@ -71,6 +71,7 @@ OOVPA_NO_XREF(XGSwizzleRect_1_0_5558, 8)
{ 0xFE, 0x89 },
OOVPA_END;
/* Leave unpatched
// ******************************************************************
// * XGUnswizzleRect
// ******************************************************************
@ -85,6 +86,7 @@ OOVPA_NO_XREF(XGUnswizzleRect_1_0_5558, 8)
{ 0xDE, 0x89 },
{ 0xFE, 0x60 },
OOVPA_END;
*/
// ******************************************************************
// * XGSwizzleBox
@ -128,7 +130,9 @@ OOVPATable XG_1_0_5558[] = {
// XGSwizzleBox (* UNTESTED *)
OOVPA_TABLE_PATCH(XGSwizzleBox_1_0_5558, XTL::EmuXGSwizzleBox),
// XGUnswizzleRect
/* Leave unpatched
OOVPA_TABLE_PATCH(XGUnswizzleRect_1_0_5558, XTL::EmuXGUnswizzleRect),
*/
// XGUnswizzleBox (* UNTESTED *)
/*
OOVPA_TABLE_PATCH(XGUnswizzleBox_1_0_5558, XTL::EmuXGUnswizzleBox),

2
src/CxbxKrnl/HLEDataBase/XG.1.0.5849.inl
View File

@ -81,7 +81,9 @@ OOVPATable XG_1_0_5849[] = {
// XGSwizzleRect (* unchanged since 5558 *)
OOVPA_TABLE_PATCH(XGSwizzleRect_1_0_5558, XTL::EmuXGSwizzleRect),
// XGUnswizzleRect (* unchanged since 5558 *)
/* Leave unpatched
OOVPA_TABLE_PATCH(XGUnswizzleRect_1_0_5558, XTL::EmuXGUnswizzleRect),
*/
// XFONT_OpenBitmapFontFromMemory
/*
OOVPA_TABLE_PATCH(XFONT_OpenBitmapFontFromMemory_1_0_5849, XTL::EmuXFONT_OpenBitmapFontFromMemory),