isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-01-11 18:41:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Additional strict type checking in DirectX implementation (#91)

Browse Source
This commit is contained in:
Anders Jenbo 2025-05-15 23:18:21 +02:00 committed by GitHub
parent 68f209b18c
commit 96c962f857
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 311 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CONFIG/config.cpp
View File

@ -354,17 +354,17 @@ DWORD CConfigApp::GetConditionalDeviceRenderBitDepth() const
if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) { if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) {
return 0; return 0;
} }
return m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_8; return (m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_8) == DDBD_8;
} }
// FUNCTION: CONFIG 0x004037e0 // FUNCTION: CONFIG 0x004037e0
DWORD CConfigApp::GetDeviceRenderBitStatus() const DWORD CConfigApp::GetDeviceRenderBitStatus() const
{ {
if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) { if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) {
return m_device->m_HWDesc.dwDeviceRenderBitDepth & DDBD_16; return (m_device->m_HWDesc.dwDeviceRenderBitDepth & DDBD_16) == DDBD_16;
} }
else { else {
return m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_16; return (m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_16) == DDBD_16;
} }
} }

2
LEGO1/lego/legoomni/src/common/legotextureinfo.cpp
View File

@ -106,7 +106,7 @@ LegoTextureInfo* LegoTextureInfo::Create(const char* p_name, LegoTexture* p_text
for (i = 0; i < sizeOfArray(entries); i++) { for (i = 0; i < sizeOfArray(entries); i++) {
if (i < image->GetCount()) { if (i < image->GetCount()) {
entries[i].peFlags = 0; entries[i].peFlags = PC_NONE;
entries[i].peRed = image->GetPalette()->colors[i].r; entries[i].peRed = image->GetPalette()->colors[i].r;
entries[i].peGreen = image->GetPalette()->colors[i].g; entries[i].peGreen = image->GetPalette()->colors[i].g;
entries[i].peBlue = image->GetPalette()->colors[i].b; entries[i].peBlue = image->GetPalette()->colors[i].b;

2
LEGO1/lego/legoomni/src/common/legoutils.cpp
View File

@ -745,7 +745,7 @@ void WriteDefaultTexture(LegoStorage* p_storage, const char* p_name)
if (textureInfo->m_palette->GetEntries(0, 0, sizeOfArray(entries), entries) == DD_OK) { if (textureInfo->m_palette->GetEntries(0, 0, sizeOfArray(entries), entries) == DD_OK) {
MxS32 i; MxS32 i;
for (i = 0; i < sizeOfArray(entries); i++) { for (i = 0; i < sizeOfArray(entries); i++) {
if (entries[i].peFlags != 0) { if (entries[i].peFlags != PC_NONE) {
break; break;
} }

8
LEGO1/lego/legoomni/src/video/legovideomanager.cpp
View File

@ -135,7 +135,7 @@ MxResult LegoVideoManager::Create(MxVideoParam& p_videoParam, MxU32 p_frequencyM
m_direct3d->SetDevice(deviceEnumerate, driver, device); m_direct3d->SetDevice(deviceEnumerate, driver, device);
if (!driver->m_ddCaps.dwCaps2 && driver->m_ddCaps.dwSVBRops[7] != 2) { if (driver->m_ddCaps.dwCaps2 != DDCAPS2_CERTIFIED && driver->m_ddCaps.dwSVBRops[7] != 2) {
p_videoParam.Flags().SetLacksLightSupport(TRUE); p_videoParam.Flags().SetLacksLightSupport(TRUE);
} }
else { else {
@ -819,13 +819,15 @@ MxResult LegoVideoManager::ConfigureD3DRM()
MxAssignedDevice* assignedDevice = m_direct3d->AssignedDevice(); MxAssignedDevice* assignedDevice = m_direct3d->AssignedDevice();
if (assignedDevice && assignedDevice->GetFlags() & MxAssignedDevice::c_hardwareMode) { if (assignedDevice && assignedDevice->GetFlags() & MxAssignedDevice::c_hardwareMode) {
if (assignedDevice->GetDesc().dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_LINEAR) { if ((assignedDevice->GetDesc().dpcTriCaps.dwTextureFilterCaps & D3DPTFILTERCAPS_LINEAR) ==
D3DPTFILTERCAPS_LINEAR) {
d3drm->SetTextureQuality(D3DRMTEXTURE_LINEAR); d3drm->SetTextureQuality(D3DRMTEXTURE_LINEAR);
} }
d3drm->SetDither(TRUE); d3drm->SetDither(TRUE);
if (assignedDevice->GetDesc().dpcTriCaps.dwShadeCaps & D3DPSHADECAPS_ALPHAFLATBLEND) { if ((assignedDevice->GetDesc().dpcTriCaps.dwShadeCaps & D3DPSHADECAPS_ALPHAFLATBLEND) ==
D3DPSHADECAPS_ALPHAFLATBLEND) {
d3drm->SetRenderMode(D3DRMRENDERMODE_BLENDEDTRANSPARENCY); d3drm->SetRenderMode(D3DRMRENDERMODE_BLENDEDTRANSPARENCY);
} }
} }

2
LEGO1/lego/sources/3dmanager/tglsurface.cpp
View File

@ -66,7 +66,7 @@ int GetBitsPerPixel(IDirectDrawSurface* pSurface)
result = pSurface->GetPixelFormat(&pixelFormat); result = pSurface->GetPixelFormat(&pixelFormat);
assert(result == DD_OK); assert(result == DD_OK);
assert(pixelFormat.dwFlags & DDPF_RGB); assert((pixelFormat.dwFlags & DDPF_RGB) == DDPF_RGB);
return pixelFormat.dwRGBBitCount; return pixelFormat.dwRGBBitCount;
} }

4
LEGO1/mxdirectx/legodxinfo.cpp
View File

@ -342,8 +342,8 @@ unsigned char LegoDeviceEnumerate::FUN_1009d3d0(Direct3DDeviceInfo& p_device)
} }
if (p_device.m_HWDesc.dcmColorModel != D3DCOLOR_NONE) { if (p_device.m_HWDesc.dcmColorModel != D3DCOLOR_NONE) {
if (p_device.m_HWDesc.dwDeviceZBufferBitDepth & DDBD_16 && if ((p_device.m_HWDesc.dwDeviceZBufferBitDepth & DDBD_16) == DDBD_16 &&
p_device.m_HWDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) { (p_device.m_HWDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) == D3DPTEXTURECAPS_PERSPECTIVE) {
return TRUE; return TRUE;
} }
else { else {

20
LEGO1/mxdirectx/mxdirect3d.cpp
View File

@ -132,7 +132,8 @@ BOOL MxDirect3D::D3DSetMode()
return FALSE; return FALSE;
} }
if (m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) { if ((m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) ==
D3DPTEXTURECAPS_PERSPECTIVE) {
m_bTexturesDisabled = FALSE; m_bTexturesDisabled = FALSE;
} }
else { else {
@ -144,7 +145,8 @@ BOOL MxDirect3D::D3DSetMode()
} }
} }
else { else {
if (m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) { if ((m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) ==
D3DPTEXTURECAPS_PERSPECTIVE) {
m_bTexturesDisabled = FALSE; m_bTexturesDisabled = FALSE;
} }
else { else {
@ -221,25 +223,25 @@ BOOL MxDirect3D::D3DSetMode()
int MxDirect3D::ZBufferDepth(MxAssignedDevice* p_assignedDevice) int MxDirect3D::ZBufferDepth(MxAssignedDevice* p_assignedDevice)
{ {
int depth; int depth;
DWORD deviceDepth; DDBitDepths deviceDepth;
if (p_assignedDevice->m_desc.dwFlags & D3DDD_DEVICEZBUFFERBITDEPTH) { if ((p_assignedDevice->m_desc.dwFlags & D3DDD_DEVICEZBUFFERBITDEPTH) == D3DDD_DEVICEZBUFFERBITDEPTH) {
deviceDepth = p_assignedDevice->m_desc.dwDeviceZBufferBitDepth; deviceDepth = p_assignedDevice->m_desc.dwDeviceZBufferBitDepth;
} }
else { else {
deviceDepth = 0; return -1;
} }
if (deviceDepth & DDBD_32) { if ((deviceDepth & DDBD_32) == DDBD_32) {
depth = 32; depth = 32;
} }
else if (deviceDepth & DDBD_24) { else if ((deviceDepth & DDBD_24) == DDBD_24) {
depth = 24; depth = 24;
} }
else if (deviceDepth & DDBD_16) { else if ((deviceDepth & DDBD_16) == DDBD_16) {
depth = 16; depth = 16;
} }
else if (deviceDepth & DDBD_8) { else if ((deviceDepth & DDBD_8) == DDBD_8) {
depth = 8; depth = 8;
} }
else { else {

4
LEGO1/mxdirectx/mxdirectdraw.cpp
View File

@ -75,7 +75,7 @@ int MxDirectDraw::GetPrimaryBitDepth()
pDDraw->GetDisplayMode(&ddsd); pDDraw->GetDisplayMode(&ddsd);
dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount; dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount;
g_isPaletteIndexed8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) != 0; g_isPaletteIndexed8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) == DDPF_PALETTEINDEXED8;
pDDraw->Release(); pDDraw->Release();
} }
@ -406,7 +406,7 @@ BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp)
return FALSE; return FALSE;
} }
if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) { if ((ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) == DDPF_PALETTEINDEXED8) {
m_bPrimaryPalettized = TRUE; m_bPrimaryPalettized = TRUE;
} }
else { else {

6
LEGO1/omni/src/video/mxdisplaysurface.cpp
View File

@ -302,7 +302,7 @@ void MxDisplaySurface::Destroy()
// FUNCTION: BETA10 0x1013fe15 // FUNCTION: BETA10 0x1013fe15
void MxDisplaySurface::SetPalette(MxPalette* p_palette) void MxDisplaySurface::SetPalette(MxPalette* p_palette)
{ {
if (m_surfaceDesc.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) { if ((m_surfaceDesc.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) == DDPF_PALETTEINDEXED8) {
m_ddSurface1->SetPalette(p_palette->CreateNativePalette()); m_ddSurface1->SetPalette(p_palette->CreateNativePalette());
m_ddSurface2->SetPalette(p_palette->CreateNativePalette()); m_ddSurface2->SetPalette(p_palette->CreateNativePalette());
@ -895,9 +895,9 @@ void MxDisplaySurface::Display(MxS32 p_left, MxS32 p_top, MxS32 p_left2, MxS32 p
data.dwSize = sizeof(data); data.dwSize = sizeof(data);
data.dwDDFX = 8; data.dwDDFX = 8;
if (m_ddSurface1->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, 0, &data) == DDERR_SURFACELOST) { if (m_ddSurface1->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, DDBLT_NONE, &data) == DDERR_SURFACELOST) {
m_ddSurface1->Restore(); m_ddSurface1->Restore();
m_ddSurface1->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, 0, &data); m_ddSurface1->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, DDBLT_NONE, &data);
} }
} }
} }

130
LEGO1/omni/src/video/mxpalette.cpp
View File

@ -6,70 +6,70 @@
// GLOBAL: LEGO1 0x10102188 // GLOBAL: LEGO1 0x10102188
// GLOBAL: BETA10 0x10203558 // GLOBAL: BETA10 0x10203558
PALETTEENTRY g_defaultPaletteEntries[256] = { PALETTEENTRY g_defaultPaletteEntries[256] = {
{0u, 0u, 0u, 0u}, {128u, 0u, 0u, 0u}, {0u, 128u, 0u, 0u}, {128u, 128u, 0u, 0u}, {0u, 0u, 0u, PC_NONE}, {128u, 0u, 0u, PC_NONE}, {0u, 128u, 0u, PC_NONE}, {128u, 128u, 0u, PC_NONE},
{0u, 0u, 128u, 0u}, {128u, 0u, 128u, 0u}, {0u, 128u, 128u, 0u}, {128u, 128u, 128u, 0u}, {0u, 0u, 128u, PC_NONE}, {128u, 0u, 128u, PC_NONE}, {0u, 128u, 128u, PC_NONE}, {128u, 128u, 128u, PC_NONE},
{192u, 220u, 192u, 0u}, {166u, 202u, 240u, 0u}, {255u, 255u, 255u, 0u}, {250u, 250u, 250u, 0u}, {192u, 220u, 192u, PC_NONE}, {166u, 202u, 240u, PC_NONE}, {255u, 255u, 255u, PC_NONE}, {250u, 250u, 250u, PC_NONE},
{239u, 239u, 239u, 0u}, {228u, 228u, 228u, 0u}, {217u, 217u, 217u, 0u}, {206u, 206u, 206u, 0u}, {239u, 239u, 239u, PC_NONE}, {228u, 228u, 228u, PC_NONE}, {217u, 217u, 217u, PC_NONE}, {206u, 206u, 206u, PC_NONE},
{195u, 195u, 195u, 0u}, {185u, 185u, 185u, 0u}, {174u, 174u, 174u, 0u}, {163u, 163u, 163u, 0u}, {195u, 195u, 195u, PC_NONE}, {185u, 185u, 185u, PC_NONE}, {174u, 174u, 174u, PC_NONE}, {163u, 163u, 163u, PC_NONE},
{152u, 152u, 152u, 0u}, {141u, 141u, 141u, 0u}, {130u, 130u, 130u, 0u}, {123u, 123u, 123u, 0u}, {152u, 152u, 152u, PC_NONE}, {141u, 141u, 141u, PC_NONE}, {130u, 130u, 130u, PC_NONE}, {123u, 123u, 123u, PC_NONE},
{115u, 115u, 115u, 0u}, {108u, 108u, 108u, 0u}, {101u, 101u, 101u, 0u}, {93u, 93u, 93u, 0u}, {115u, 115u, 115u, PC_NONE}, {108u, 108u, 108u, PC_NONE}, {101u, 101u, 101u, PC_NONE}, {93u, 93u, 93u, PC_NONE},
{86u, 86u, 86u, 0u}, {79u, 79u, 79u, 0u}, {71u, 71u, 71u, 0u}, {64u, 64u, 64u, 0u}, {86u, 86u, 86u, PC_NONE}, {79u, 79u, 79u, PC_NONE}, {71u, 71u, 71u, PC_NONE}, {64u, 64u, 64u, PC_NONE},
{54u, 54u, 54u, 0u}, {43u, 43u, 43u, 0u}, {33u, 33u, 33u, 0u}, {22u, 22u, 22u, 0u}, {54u, 54u, 54u, PC_NONE}, {43u, 43u, 43u, PC_NONE}, {33u, 33u, 33u, PC_NONE}, {22u, 22u, 22u, PC_NONE},
{12u, 12u, 12u, 0u}, {8u, 8u, 8u, 0u}, {4u, 4u, 4u, 0u}, {0u, 0u, 0u, 0u}, {12u, 12u, 12u, PC_NONE}, {8u, 8u, 8u, PC_NONE}, {4u, 4u, 4u, PC_NONE}, {0u, 0u, 0u, PC_NONE},
{225u, 218u, 217u, 0u}, {195u, 182u, 179u, 0u}, {165u, 145u, 141u, 0u}, {134u, 108u, 102u, 0u}, {225u, 218u, 217u, PC_NONE}, {195u, 182u, 179u, PC_NONE}, {165u, 145u, 141u, PC_NONE}, {134u, 108u, 102u, PC_NONE},
{104u, 72u, 64u, 0u}, {74u, 35u, 26u, 0u}, {59u, 28u, 21u, 0u}, {44u, 21u, 16u, 0u}, {104u, 72u, 64u, PC_NONE}, {74u, 35u, 26u, PC_NONE}, {59u, 28u, 21u, PC_NONE}, {44u, 21u, 16u, PC_NONE},
{30u, 14u, 10u, 0u}, {15u, 7u, 5u, 0u}, {250u, 231u, 232u, 0u}, {240u, 185u, 189u, 0u}, {30u, 14u, 10u, PC_NONE}, {15u, 7u, 5u, PC_NONE}, {250u, 231u, 232u, PC_NONE}, {240u, 185u, 189u, PC_NONE},
{233u, 154u, 160u, 0u}, {226u, 124u, 131u, 0u}, {219u, 93u, 102u, 0u}, {213u, 62u, 73u, 0u}, {233u, 154u, 160u, PC_NONE}, {226u, 124u, 131u, PC_NONE}, {219u, 93u, 102u, PC_NONE}, {213u, 62u, 73u, PC_NONE},
{203u, 18u, 32u, 0u}, {172u, 15u, 27u, 0u}, {159u, 14u, 25u, 0u}, {146u, 13u, 23u, 0u}, {203u, 18u, 32u, PC_NONE}, {172u, 15u, 27u, PC_NONE}, {159u, 14u, 25u, PC_NONE}, {146u, 13u, 23u, PC_NONE},
{133u, 12u, 21u, 0u}, {120u, 11u, 19u, 0u}, {107u, 10u, 17u, 0u}, {94u, 8u, 15u, 0u}, {133u, 12u, 21u, PC_NONE}, {120u, 11u, 19u, PC_NONE}, {107u, 10u, 17u, PC_NONE}, {94u, 8u, 15u, PC_NONE},
{81u, 7u, 13u, 0u}, {68u, 6u, 11u, 0u}, {55u, 5u, 9u, 0u}, {42u, 4u, 7u, 0u}, {81u, 7u, 13u, PC_NONE}, {68u, 6u, 11u, PC_NONE}, {55u, 5u, 9u, PC_NONE}, {42u, 4u, 7u, PC_NONE},
{29u, 3u, 5u, 0u}, {10u, 1u, 2u, 0u}, {227u, 236u, 242u, 0u}, {178u, 203u, 220u, 0u}, {29u, 3u, 5u, PC_NONE}, {10u, 1u, 2u, PC_NONE}, {227u, 236u, 242u, PC_NONE}, {178u, 203u, 220u, PC_NONE},
{145u, 181u, 205u, 0u}, {112u, 159u, 191u, 0u}, {79u, 137u, 176u, 0u}, {30u, 104u, 154u, 0u}, {145u, 181u, 205u, PC_NONE}, {112u, 159u, 191u, PC_NONE}, {79u, 137u, 176u, PC_NONE}, {30u, 104u, 154u, PC_NONE},
{0u, 84u, 140u, 0u}, {0u, 79u, 132u, 0u}, {0u, 72u, 119u, 0u}, {0u, 66u, 110u, 0u}, {0u, 84u, 140u, PC_NONE}, {0u, 79u, 132u, PC_NONE}, {0u, 72u, 119u, PC_NONE}, {0u, 66u, 110u, PC_NONE},
{0u, 61u, 101u, 0u}, {0u, 55u, 92u, 0u}, {0u, 47u, 78u, 0u}, {0u, 39u, 65u, 0u}, {0u, 61u, 101u, PC_NONE}, {0u, 55u, 92u, PC_NONE}, {0u, 47u, 78u, PC_NONE}, {0u, 39u, 65u, PC_NONE},
{0u, 34u, 56u, 0u}, {0u, 28u, 47u, 0u}, {0u, 23u, 38u, 0u}, {0u, 18u, 29u, 0u}, {0u, 34u, 56u, PC_NONE}, {0u, 28u, 47u, PC_NONE}, {0u, 23u, 38u, PC_NONE}, {0u, 18u, 29u, PC_NONE},
{0u, 12u, 20u, 0u}, {0u, 4u, 7u, 0u}, {230u, 242u, 234u, 0u}, {180u, 215u, 193u, 0u}, {0u, 12u, 20u, PC_NONE}, {0u, 4u, 7u, PC_NONE}, {230u, 242u, 234u, PC_NONE}, {180u, 215u, 193u, PC_NONE},
{147u, 198u, 166u, 0u}, {113u, 180u, 138u, 0u}, {80u, 162u, 111u, 0u}, {30u, 136u, 70u, 0u}, {147u, 198u, 166u, PC_NONE}, {113u, 180u, 138u, PC_NONE}, {80u, 162u, 111u, PC_NONE}, {30u, 136u, 70u, PC_NONE},
{0u, 120u, 45u, 0u}, {0u, 114u, 43u, 0u}, {0u, 102u, 38u, 0u}, {0u, 95u, 35u, 0u}, {0u, 120u, 45u, PC_NONE}, {0u, 114u, 43u, PC_NONE}, {0u, 102u, 38u, PC_NONE}, {0u, 95u, 35u, PC_NONE},
{0u, 83u, 31u, 0u}, {0u, 72u, 27u, 0u}, {0u, 63u, 24u, 0u}, {0u, 56u, 21u, 0u}, {0u, 83u, 31u, PC_NONE}, {0u, 72u, 27u, PC_NONE}, {0u, 63u, 24u, PC_NONE}, {0u, 56u, 21u, PC_NONE},
{0u, 48u, 18u, 0u}, {0u, 36u, 14u, 0u}, {0u, 25u, 9u, 0u}, {0u, 17u, 6u, 0u}, {0u, 48u, 18u, PC_NONE}, {0u, 36u, 14u, PC_NONE}, {0u, 25u, 9u, PC_NONE}, {0u, 17u, 6u, PC_NONE},
{0u, 9u, 3u, 0u}, {0u, 1u, 1u, 0u}, {254u, 244u, 220u, 0u}, {255u, 239u, 181u, 0u}, {0u, 9u, 3u, PC_NONE}, {0u, 1u, 1u, PC_NONE}, {254u, 244u, 220u, PC_NONE}, {255u, 239u, 181u, PC_NONE},
{255u, 231u, 156u, 0u}, {255u, 222u, 132u, 0u}, {255u, 222u, 115u, 0u}, {255u, 214u, 99u, 0u}, {255u, 231u, 156u, PC_NONE}, {255u, 222u, 132u, PC_NONE}, {255u, 222u, 115u, PC_NONE}, {255u, 214u, 99u, PC_NONE},
{255u, 206u, 66u, 0u}, {255u, 198u, 41u, 0u}, {255u, 185u, 0u, 0u}, {255u, 189u, 8u, 0u}, {255u, 206u, 66u, PC_NONE}, {255u, 198u, 41u, PC_NONE}, {255u, 185u, 0u, PC_NONE}, {255u, 189u, 8u, PC_NONE},
{247u, 181u, 0u, 0u}, {222u, 156u, 0u, 0u}, {189u, 140u, 0u, 0u}, {173u, 123u, 0u, 0u}, {247u, 181u, 0u, PC_NONE}, {222u, 156u, 0u, PC_NONE}, {189u, 140u, 0u, PC_NONE}, {173u, 123u, 0u, PC_NONE},
{148u, 107u, 0u, 0u}, {132u, 90u, 0u, 0u}, {107u, 74u, 0u, 0u}, {74u, 49u, 0u, 0u}, {148u, 107u, 0u, PC_NONE}, {132u, 90u, 0u, PC_NONE}, {107u, 74u, 0u, PC_NONE}, {74u, 49u, 0u, PC_NONE},
{57u, 41u, 0u, 0u}, {33u, 24u, 0u, 0u}, {117u, 52u, 87u, 0u}, {176u, 158u, 50u, 0u}, {57u, 41u, 0u, PC_NONE}, {33u, 24u, 0u, PC_NONE}, {117u, 52u, 87u, PC_NONE}, {176u, 158u, 50u, PC_NONE},
{122u, 165u, 29u, 0u}, {242u, 142u, 8u, 0u}, {164u, 43u, 36u, 0u}, {113u, 67u, 20u, 0u}, {122u, 165u, 29u, PC_NONE}, {242u, 142u, 8u, PC_NONE}, {164u, 43u, 36u, PC_NONE}, {113u, 67u, 20u, PC_NONE},
{255u, 0u, 255u, 0u}, {255u, 0u, 255u, 0u}, {255u, 0u, 255u, 0u}, {255u, 0u, 255u, 0u}, {255u, 0u, 255u, PC_NONE}, {255u, 0u, 255u, PC_NONE}, {255u, 0u, 255u, PC_NONE}, {255u, 0u, 255u, PC_NONE},
{255u, 0u, 255u, 0u}, {57u, 163u, 217u, 0u}, {255u, 255u, 255u, 0u}, {254u, 255u, 247u, 0u}, {255u, 0u, 255u, PC_NONE}, {57u, 163u, 217u, PC_NONE}, {255u, 255u, 255u, PC_NONE}, {254u, 255u, 247u, PC_NONE},
{253u, 253u, 239u, 0u}, {248u, 247u, 247u, 0u}, {248u, 247u, 231u, 0u}, {240u, 240u, 240u, 0u}, {253u, 253u, 239u, PC_NONE}, {248u, 247u, 247u, PC_NONE}, {248u, 247u, 231u, PC_NONE}, {240u, 240u, 240u, PC_NONE},
{239u, 239u, 218u, 0u}, {227u, 232u, 236u, 0u}, {224u, 221u, 209u, 0u}, {215u, 222u, 215u, 0u}, {239u, 239u, 218u, PC_NONE}, {227u, 232u, 236u, PC_NONE}, {224u, 221u, 209u, PC_NONE}, {215u, 222u, 215u, PC_NONE},
{213u, 214u, 215u, 0u}, {214u, 214u, 203u, 0u}, {255u, 219u, 57u, 0u}, {206u, 206u, 206u, 0u}, {213u, 214u, 215u, PC_NONE}, {214u, 214u, 203u, PC_NONE}, {255u, 219u, 57u, PC_NONE}, {206u, 206u, 206u, PC_NONE},
{206u, 206u, 198u, 0u}, {255u, 214u, 18u, 0u}, {207u, 203u, 186u, 0u}, {197u, 199u, 199u, 0u}, {206u, 206u, 198u, PC_NONE}, {255u, 214u, 18u, PC_NONE}, {207u, 203u, 186u, PC_NONE}, {197u, 199u, 199u, PC_NONE},
{255u, 206u, 0u, 0u}, {207u, 198u, 159u, 0u}, {247u, 204u, 0u, 0u}, {189u, 198u, 189u, 0u}, {255u, 206u, 0u, PC_NONE}, {207u, 198u, 159u, PC_NONE}, {247u, 204u, 0u, PC_NONE}, {189u, 198u, 189u, PC_NONE},
{189u, 189u, 189u, 0u}, {238u, 199u, 0u, 0u}, {189u, 189u, 181u, 0u}, {238u, 190u, 24u, 0u}, {189u, 189u, 189u, PC_NONE}, {238u, 199u, 0u, PC_NONE}, {189u, 189u, 181u, PC_NONE}, {238u, 190u, 24u, PC_NONE},
{181u, 189u, 184u, 0u}, {161u, 186u, 224u, 0u}, {181u, 181u, 181u, 0u}, {231u, 189u, 0u, 0u}, {181u, 189u, 184u, PC_NONE}, {161u, 186u, 224u, PC_NONE}, {181u, 181u, 181u, PC_NONE}, {231u, 189u, 0u, PC_NONE},
{173u, 182u, 173u, 0u}, {222u, 181u, 0u, 0u}, {173u, 173u, 173u, 0u}, {213u, 182u, 0u, 0u}, {173u, 182u, 173u, PC_NONE}, {222u, 181u, 0u, PC_NONE}, {173u, 173u, 173u, PC_NONE}, {213u, 182u, 0u, PC_NONE},
{172u, 173u, 160u, 0u}, {214u, 173u, 0u, 0u}, {165u, 165u, 165u, 0u}, {206u, 173u, 0u, 0u}, {172u, 173u, 160u, PC_NONE}, {214u, 173u, 0u, PC_NONE}, {165u, 165u, 165u, PC_NONE}, {206u, 173u, 0u, PC_NONE},
{160u, 168u, 151u, 0u}, {206u, 164u, 0u, 0u}, {198u, 165u, 0u, 0u}, {157u, 156u, 156u, 0u}, {160u, 168u, 151u, PC_NONE}, {206u, 164u, 0u, PC_NONE}, {198u, 165u, 0u, PC_NONE}, {157u, 156u, 156u, PC_NONE},
{134u, 156u, 200u, 0u}, {153u, 156u, 144u, 0u}, {142u, 156u, 161u, 0u}, {189u, 156u, 0u, 0u}, {134u, 156u, 200u, PC_NONE}, {153u, 156u, 144u, PC_NONE}, {142u, 156u, 161u, PC_NONE}, {189u, 156u, 0u, PC_NONE},
{148u, 148u, 148u, 0u}, {146u, 148u, 138u, 0u}, {133u, 143u, 161u, 0u}, {189u, 143u, 0u, 0u}, {148u, 148u, 148u, PC_NONE}, {146u, 148u, 138u, PC_NONE}, {133u, 143u, 161u, PC_NONE}, {189u, 143u, 0u, PC_NONE},
{140u, 140u, 140u, 0u}, {177u, 147u, 0u, 0u}, {131u, 140u, 136u, 0u}, {146u, 130u, 126u, 0u}, {140u, 140u, 140u, PC_NONE}, {177u, 147u, 0u, PC_NONE}, {131u, 140u, 136u, PC_NONE}, {146u, 130u, 126u, PC_NONE},
{170u, 137u, 0u, 0u}, {132u, 132u, 130u, 0u}, {123u, 125u, 125u, 0u}, {123u, 123u, 133u, 0u}, {170u, 137u, 0u, PC_NONE}, {132u, 132u, 130u, PC_NONE}, {123u, 125u, 125u, PC_NONE}, {123u, 123u, 133u, PC_NONE},
{153u, 126u, 0u, 0u}, {114u, 116u, 118u, 0u}, {110u, 112u, 108u, 0u}, {97u, 109u, 136u, 0u}, {153u, 126u, 0u, PC_NONE}, {114u, 116u, 118u, PC_NONE}, {110u, 112u, 108u, PC_NONE}, {97u, 109u, 136u, PC_NONE},
{127u, 108u, 6u, 0u}, {0u, 173u, 0u, 0u}, {100u, 99u, 101u, 0u}, {176u, 71u, 41u, 0u}, {127u, 108u, 6u, PC_NONE}, {0u, 173u, 0u, PC_NONE}, {100u, 99u, 101u, PC_NONE}, {176u, 71u, 41u, PC_NONE},
{36u, 142u, 33u, 0u}, {98u, 91u, 75u, 0u}, {80u, 88u, 104u, 0u}, {252u, 0u, 0u, 0u}, {36u, 142u, 33u, PC_NONE}, {98u, 91u, 75u, PC_NONE}, {80u, 88u, 104u, PC_NONE}, {252u, 0u, 0u, PC_NONE},
{78u, 71u, 73u, 0u}, {73u, 71u, 78u, 0u}, {62u, 63u, 61u, 0u}, {0u, 66u, 211u, 0u}, {78u, 71u, 73u, PC_NONE}, {73u, 71u, 78u, PC_NONE}, {62u, 63u, 61u, PC_NONE}, {0u, 66u, 211u, PC_NONE},
{99u, 51u, 14u, 0u}, {198u, 0u, 0u, 0u}, {189u, 0u, 0u, 0u}, {0u, 57u, 206u, 0u}, {99u, 51u, 14u, PC_NONE}, {198u, 0u, 0u, PC_NONE}, {189u, 0u, 0u, PC_NONE}, {0u, 57u, 206u, PC_NONE},
{181u, 0u, 0u, 0u}, {0u, 56u, 185u, 0u}, {173u, 0u, 0u, 0u}, {165u, 0u, 0u, 0u}, {181u, 0u, 0u, PC_NONE}, {0u, 56u, 185u, PC_NONE}, {173u, 0u, 0u, PC_NONE}, {165u, 0u, 0u, PC_NONE},
{49u, 49u, 49u, 0u}, {0u, 49u, 165u, 0u}, {156u, 0u, 0u, 0u}, {42u, 45u, 60u, 0u}, {49u, 49u, 49u, PC_NONE}, {0u, 49u, 165u, PC_NONE}, {156u, 0u, 0u, PC_NONE}, {42u, 45u, 60u, PC_NONE},
{148u, 0u, 0u, 0u}, {140u, 0u, 0u, 0u}, {41u, 41u, 41u, 0u}, {0u, 41u, 144u, 0u}, {148u, 0u, 0u, PC_NONE}, {140u, 0u, 0u, PC_NONE}, {41u, 41u, 41u, PC_NONE}, {0u, 41u, 144u, PC_NONE},
{132u, 0u, 0u, 0u}, {123u, 0u, 0u, 0u}, {7u, 35u, 114u, 0u}, {34u, 36u, 32u, 0u}, {132u, 0u, 0u, PC_NONE}, {123u, 0u, 0u, PC_NONE}, {7u, 35u, 114u, PC_NONE}, {34u, 36u, 32u, PC_NONE},
{115u, 0u, 0u, 0u}, {107u, 0u, 0u, 0u}, {90u, 0u, 0u, 0u}, {23u, 24u, 27u, 0u}, {115u, 0u, 0u, PC_NONE}, {107u, 0u, 0u, PC_NONE}, {90u, 0u, 0u, PC_NONE}, {23u, 24u, 27u, PC_NONE},
{74u, 0u, 0u, 0u}, {15u, 15u, 16u, 0u}, {49u, 0u, 0u, 0u}, {16u, 12u, 4u, 0u}, {74u, 0u, 0u, PC_NONE}, {15u, 15u, 16u, PC_NONE}, {49u, 0u, 0u, PC_NONE}, {16u, 12u, 4u, PC_NONE},
{7u, 8u, 8u, 0u}, {0u, 0u, 8u, 0u}, {255u, 251u, 240u, 0u}, {160u, 160u, 164u, 0u}, {7u, 8u, 8u, PC_NONE}, {0u, 0u, 8u, PC_NONE}, {255u, 251u, 240u, PC_NONE}, {160u, 160u, 164u, PC_NONE},
{128u, 128u, 128u, 0u}, {255u, 0u, 0u, 0u}, {0u, 255u, 0u, 0u}, {255u, 255u, 0u, 0u}, {128u, 128u, 128u, PC_NONE}, {255u, 0u, 0u, PC_NONE}, {0u, 255u, 0u, PC_NONE}, {255u, 255u, 0u, PC_NONE},
{0u, 0u, 255u, 0u}, {255u, 0u, 255u, 0u}, {0u, 255u, 255u, 0u}, {255u, 255u, 255u, 0u} {0u, 0u, 255u, PC_NONE}, {255u, 0u, 255u, PC_NONE}, {0u, 255u, 255u, PC_NONE}, {255u, 255u, 255u, PC_NONE}
}; };
// FUNCTION: LEGO1 0x100bee30 // FUNCTION: LEGO1 0x100bee30
@ -94,7 +94,7 @@ MxPalette::MxPalette(const RGBQUAD* p_colors)
m_entries[i].peRed = p_colors[i].rgbRed; m_entries[i].peRed = p_colors[i].rgbRed;
m_entries[i].peGreen = p_colors[i].rgbGreen; m_entries[i].peGreen = p_colors[i].rgbGreen;
m_entries[i].peBlue = p_colors[i].rgbBlue; m_entries[i].peBlue = p_colors[i].rgbBlue;
m_entries[i].peFlags = 0; m_entries[i].peFlags = PC_NONE;
} }
m_skyColor = m_entries[141]; m_skyColor = m_entries[141];

2
LEGO1/omni/src/video/mxvideopresenter.cpp
View File

@ -315,7 +315,7 @@ void MxVideoPresenter::PutFrame()
} }
else if (m_unk0x58) { else if (m_unk0x58) {
if (PrepareRects(src, dest) >= 0) { if (PrepareRects(src, dest) >= 0) {
ddSurface->Blt(&dest, m_unk0x58, &src, 0, NULL); ddSurface->Blt(&dest, m_unk0x58, &src, DDBLT_NONE, NULL);
} }
} }
else { else {

34
miniwin/miniwin/include/miniwin.h
View File

@ -126,14 +126,6 @@ struct BITMAPINFO {
RGBQUAD bmiColors[1]; RGBQUAD bmiColors[1];
}; };
struct PALETTEENTRY {
BYTE peRed;
BYTE peGreen;
BYTE peBlue;
BYTE peFlags;
};
typedef PALETTEENTRY* LPPALETTEENTRY;
struct GUID { struct GUID {
uint32_t m_data1; uint32_t m_data1;
uint16_t m_data2; uint16_t m_data2;
@ -152,23 +144,12 @@ struct IUnknown {
private: private:
int m_refCount; int m_refCount;
}; };
struct LOGPALETTE {
WORD palVersion;
WORD palNumEntries;
PALETTEENTRY palPalEntry[1];
};
typedef LOGPALETTE* LPLOGPALETTE;
inline BOOL SetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags) inline BOOL SetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
{ {
return TRUE; return TRUE;
} }
inline UINT WINAPI GetSystemPaletteEntries(HDC hdc, UINT iStart, UINT cEntries, LPPALETTEENTRY pPalEntries)
{
return 0;
}
inline HDC WINAPI GetDC(HWND hWnd) inline HDC WINAPI GetDC(HWND hWnd)
{ {
return 0; return 0;
@ -308,21 +289,6 @@ inline int SetRect(RECT* rc, int left, int top, int right, int bottom)
VOID WINAPI Sleep(DWORD dwMilliseconds); VOID WINAPI Sleep(DWORD dwMilliseconds);
inline HPALETTE CreatePalette(LPLOGPALETTE lpLogPalette)
{
return nullptr;
}
inline int SelectPalette(HDC hdc, HPALETTE hpal, BOOL bForceBackground)
{
return 0;
}
inline int RealizePalette(HDC hdc)
{
return 0;
}
inline BOOL ClientToScreen(HWND hWnd, LPPOINT lpPoint) inline BOOL ClientToScreen(HWND hWnd, LPPOINT lpPoint)
{ {
return TRUE; return TRUE;

70
miniwin/miniwin/include/miniwin_d3d.h
View File

@ -2,51 +2,69 @@
#include "miniwin_ddraw.h" #include "miniwin_ddraw.h"
// --- Defines and Macros --- // --- GUIDs ---
#define D3DPAL_RESERVED 0x80 DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1, 0x662a, 0x11d0, 0x88, 0x9d, 0x00, 0xaa, 0x00, 0xbb, 0xb7, 0x6a);
#define D3DPAL_READONLY 0x40
#define DDBD_8 0x00000800 // --- Enums ---
#define DDBD_16 0x00000400 #define DDBD_8 DDBitDepths::BPP_8
#define DDBD_24 0x00000200 #define DDBD_16 DDBitDepths::BPP_16
#define DDBD_32 0x00000100 #define DDBD_24 DDBitDepths::BPP_24
#define DDBD_32 DDBitDepths::BPP_32
enum class DDBitDepths : uint32_t {
BPP_8 = 1 << 11,
BPP_16 = 1 << 10,
BPP_24 = 1 << 9,
BPP_32 = 1 << 8,
};
ENABLE_BITMASK_OPERATORS(DDBitDepths)
#define D3DDD_DEVICEZBUFFERBITDEPTH 0x00000100 // dwDeviceZBufferBitDepth is valid #define D3DDD_DEVICEZBUFFERBITDEPTH D3DDeviceDescFlags::DEVICEZBUFFERBITDEPTH
enum class D3DDeviceDescFlags : uint32_t {
DEVICEZBUFFERBITDEPTH = 1 << 8,
};
ENABLE_BITMASK_OPERATORS(D3DDeviceDescFlags)
#define D3DPSHADECAPS_ALPHAFLATBLEND 0x00001000 // Supports D3DRMRENDERMODE_BLENDEDTRANSPARENCY #define D3DPSHADECAPS_ALPHAFLATBLEND D3DPShadeCaps::ALPHAFLATBLEND
enum class D3DPShadeCaps : uint32_t {
ALPHAFLATBLEND = 1 << 12,
};
ENABLE_BITMASK_OPERATORS(D3DPShadeCaps)
#define D3DPTEXTURECAPS_PERSPECTIVE 0x00000001 // Supports perspective correction texturing #define D3DPTEXTURECAPS_PERSPECTIVE D3DPTextureCaps::PERSPECTIVE
enum class D3DPTextureCaps : uint32_t {
PERSPECTIVE = 1 << 0,
};
ENABLE_BITMASK_OPERATORS(D3DPTextureCaps)
#define D3DPTFILTERCAPS_LINEAR 0x00000002 // Supports bilinear filtering #define D3DPTFILTERCAPS_LINEAR D3DPTextureFilterCaps::LINEAR
enum class D3DPTextureFilterCaps : uint32_t {
LINEAR = 1 << 1,
};
ENABLE_BITMASK_OPERATORS(D3DPTextureFilterCaps)
#define D3DCOLOR_NONE D3DCOLORMODEL::NONE #define D3DCOLOR_NONE D3DCOLORMODEL::NONE
#define D3DCOLOR_RGB D3DCOLORMODEL::RGB #define D3DCOLOR_RGB D3DCOLORMODEL::RGB
#define D3DCOLOR_MONO D3DCOLORMODEL::MONO #define D3DCOLOR_MONO D3DCOLORMODEL::MONO
// --- Enums ---
enum class D3DCOLORMODEL { enum class D3DCOLORMODEL {
NONE = 0, NONE,
RGB = 1, RGB,
MONO = 2 MONO,
}; };
// --- GUIDs ---
DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1, 0x662a, 0x11d0, 0x88, 0x9d, 0x00, 0xaa, 0x00, 0xbb, 0xb7, 0x6a);
// --- Structs --- // --- Structs ---
struct D3DVECTOR { struct D3DVECTOR {
float x, y, z; float x, y, z;
}; };
struct D3DDEVICEDESC { struct D3DDEVICEDESC {
DWORD dwFlags; // D3DDD_* D3DDeviceDescFlags dwFlags;
DWORD dwDeviceZBufferBitDepth; // DDBD_* DDBitDepths dwDeviceZBufferBitDepth;
D3DCOLORMODEL dcmColorModel; // D3DCOLOR_* Bit flag, but Isle think it's an enum D3DCOLORMODEL dcmColorModel; // D3DCOLOR_* Bit flag, but Isle think it's an enum
DWORD dwDeviceRenderBitDepth; // DDBD_* DDBitDepths dwDeviceRenderBitDepth;
struct { struct {
DWORD dwShadeCaps; // D3DPSHADECAPS_* D3DPShadeCaps dwShadeCaps;
DWORD dwTextureCaps; // D3DPTEXTURECAPS_* D3DPTextureCaps dwTextureCaps;
DWORD dwTextureFilterCaps; // D3DPTFILTERCAPS_* D3DPTextureFilterCaps dwTextureFilterCaps;
} dpcTriCaps; } dpcTriCaps;
}; };
typedef D3DDEVICEDESC* LPD3DDEVICEDESC; typedef D3DDEVICEDESC* LPD3DDEVICEDESC;

244
miniwin/miniwin/include/miniwin_ddraw.h
View File

@ -3,56 +3,9 @@
#include "bitflags.h" #include "bitflags.h"
#include "miniwin.h" #include "miniwin.h"
#define _FACDD 0x876 #define DDENUMRET_OK TRUE
#define DDCKEY_SRCBLT 0x00000008
#define DDENUMRET_OK 1
#define DDFLIP_WAIT 0x00000001
#define DISCL_BACKGROUND 0x00000008
#define PC_NOCOLLAPSE 0x04
#define DDCAPS2_CERTIFIED 0x00000001 #define MAKE_DDHRESULT(code) MAKE_HRESULT(1, 0x876, code)
// DirectDraw Surface Description flags
#define DDSD_CAPS DDSurfaceDescFlags::CAPS
#define DDSD_HEIGHT DDSurfaceDescFlags::HEIGHT
#define DDSD_WIDTH DDSurfaceDescFlags::WIDTH
#define DDSD_BACKBUFFERCOUNT DDSurfaceDescFlags::BACKBUFFERCOUNT
#define DDSD_ZBUFFERBITDEPTH DDSurfaceDescFlags::ZBUFFERBITDEPTH
#define DDSD_PIXELFORMAT DDSurfaceDescFlags::PIXELFORMAT
#define DDSCAPS_BACKBUFFER DDSCapsFlags::BACKBUFFER
#define DDSCAPS_COMPLEX DDSCapsFlags::COMPLEX
#define DDSCAPS_FLIP DDSCapsFlags::FLIP
#define DDSCAPS_OFFSCREENPLAIN DDSCapsFlags::OFFSCREENPLAIN
#define DDSCAPS_PRIMARYSURFACE DDSCapsFlags::PRIMARYSURFACE
#define DDSCAPS_SYSTEMMEMORY DDSCapsFlags::SYSTEMMEMORY
#define DDSCAPS_TEXTURE DDSCapsFlags::TEXTURE
#define DDSCAPS_3DDEVICE DDSCapsFlags::D3DDEVICE
#define DDSCAPS_VIDEOMEMORY DDSCapsFlags::VIDEOMEMORY
#define DDSCAPS_ZBUFFER DDSCapsFlags::ZBUFFER
#define DDPCAPS_8BIT DDPixelCaps::_8BIT
#define DDPCAPS_INITIALIZE DDPixelCaps::INITIALIZE
#define DDPCAPS_ALLOW256 DDPixelCaps::ALLOW256
#define DDBLT_KEYSRC 0x00008000
#define DDBLT_ROP 0x00020000
#define DDPF_PALETTEINDEXED8 0x00000020 // The texture uses an 8 bit palette
#define DDPF_RGB 0x00000040 // dwRGBBitCount, dwRBitMask, dwGBitMask, and dwBBitMask is valid
#define DDBLTFAST_SRCCOLORKEY 0x00000001
#define DDBLTFAST_WAIT 0x00000010
#define DDLOCK_WAIT 0x00000001
#define DDLOCK_SURFACEMEMORYPTR 0x00000000
#define DDSCL_NORMAL 0x00000008
#define DDSCL_FULLSCREEN 0x00000001
#define DDSCL_ALLOWREBOOT 0x00000002
#define DDSCL_EXCLUSIVE 0x00000010
#define MAKE_DDHRESULT(code) MAKE_HRESULT(1, _FACDD, code)
#define DD_OK S_OK #define DD_OK S_OK
#define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT(5) #define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT(5)
@ -150,47 +103,139 @@
DEFINE_GUID(IID_IDirectDraw2, 0xB3A6F3E0, 0x2B43, 0x11CF, 0xA2, 0xDE, 0x00, 0xAA, 0x00, 0xB9, 0x33, 0x56); DEFINE_GUID(IID_IDirectDraw2, 0xB3A6F3E0, 0x2B43, 0x11CF, 0xA2, 0xDE, 0x00, 0xAA, 0x00, 0xB9, 0x33, 0x56);
DEFINE_GUID(IID_IDirectDrawSurface3, 0xDA044E00, 0x69B2, 0x11D0, 0xA1, 0xD5, 0x00, 0xAA, 0x00, 0xB8, 0xDF, 0xBB); DEFINE_GUID(IID_IDirectDrawSurface3, 0xDA044E00, 0x69B2, 0x11D0, 0xA1, 0xD5, 0x00, 0xAA, 0x00, 0xB8, 0xDF, 0xBB);
// --- Enums ---
#define DDCKEY_SRCBLT DDColorKeyFlags::SRCBLT
enum class DDColorKeyFlags : uint32_t {
SRCBLT = 1 << 3,
};
#define DDFLIP_WAIT DDFlipFlags::WAIT
enum class DDFlipFlags : uint32_t {
WAIT = 1,
};
#define DDCAPS2_CERTIFIED DDCaps2Flags::CERTIFIED
enum class DDCaps2Flags : uint32_t {
CERTIFIED = 1,
};
#define DDPCAPS_8BIT DDPixelCaps::_8BIT
#define DDPCAPS_INITIALIZE DDPixelCaps::INITIALIZE
#define DDPCAPS_ALLOW256 DDPixelCaps::ALLOW256
enum class DDPixelCaps : uint32_t {
_8BIT = 1 << 2,
INITIALIZE = 1 << 3,
ALLOW256 = 1 << 6,
};
ENABLE_BITMASK_OPERATORS(DDPixelCaps)
#define DDBLT_NONE DDBltFlags::NONE
#define DDBLT_KEYSRC DDBltFlags::KEYSRC
#define DDBLT_ROP DDBltFlags::ROP
enum class DDBltFlags : uint32_t {
NONE = 0,
KEYSRC = 1 << 15,
ROP = 1 << 17,
};
ENABLE_BITMASK_OPERATORS(DDBltFlags)
#define DDPF_PALETTEINDEXED8 DDPixelFormatFlags::PALETTEINDEXED8
#define DDPF_RGB DDPixelFormatFlags::RGB
enum class DDPixelFormatFlags : uint32_t {
PALETTEINDEXED8 = 1 << 5, // The texture uses an 8 bit palette
RGB = 1 << 6, // dwRGBBitCount, dwRBitMask, dwGBitMask, and dwBBitMask is valid
};
ENABLE_BITMASK_OPERATORS(DDPixelFormatFlags)
#define DDBLTFAST_SRCCOLORKEY DDBltFastFlags::SRCCOLORKEY
#define DDBLTFAST_WAIT DDBltFastFlags::WAIT
enum class DDBltFastFlags : uint32_t {
SRCCOLORKEY = 1 << 0,
WAIT = 1 << 4,
};
ENABLE_BITMASK_OPERATORS(DDBltFastFlags)
#define DDLOCK_WAIT DDLockFlags::WAIT
#define DDLOCK_SURFACEMEMORYPTR DDLockFlags::SURFACEMEMORYPTR
enum class DDLockFlags : uint32_t {
SURFACEMEMORYPTR,
WAIT,
};
#define DDSCL_FULLSCREEN DDSCLFlags::FULLSCREEN
#define DDSCL_ALLOWREBOOT DDSCLFlags::ALLOWREBOOT
#define DDSCL_NORMAL DDSCLFlags::NORMAL
#define DDSCL_EXCLUSIVE DDSCLFlags::EXCLUSIVE
enum class DDSCLFlags : uint32_t {
FULLSCREEN = 1 << 0,
ALLOWREBOOT = 1 << 1,
NORMAL = 1 << 3,
EXCLUSIVE = 1 << 4,
};
ENABLE_BITMASK_OPERATORS(DDSCLFlags)
#define DDSD_CAPS DDSurfaceDescFlags::CAPS
#define DDSD_HEIGHT DDSurfaceDescFlags::HEIGHT
#define DDSD_WIDTH DDSurfaceDescFlags::WIDTH
#define DDSD_BACKBUFFERCOUNT DDSurfaceDescFlags::BACKBUFFERCOUNT
#define DDSD_ZBUFFERBITDEPTH DDSurfaceDescFlags::ZBUFFERBITDEPTH
#define DDSD_PIXELFORMAT DDSurfaceDescFlags::PIXELFORMAT
enum class DDSurfaceDescFlags : uint32_t { enum class DDSurfaceDescFlags : uint32_t {
CAPS = 0x00000001, // ddsCaps is valid CAPS = 1 << 0, // ddsCaps is valid
HEIGHT = 0x00000002, // dwHeight is valid HEIGHT = 1 << 1, // dwHeight is valid
WIDTH = 0x00000004, // dwWidth is valid WIDTH = 1 << 2, // dwWidth is valid
BACKBUFFERCOUNT = 0x00000020, // dwBackBufferCount is valid BACKBUFFERCOUNT = 1 << 5, // dwBackBufferCount is valid
ZBUFFERBITDEPTH = 0x00000040, // dwZBufferBitDepth is valid ZBUFFERBITDEPTH = 1 << 6, // dwZBufferBitDepth is valid
PIXELFORMAT = 0x00001000, // ddpfPixelFormat is valid PIXELFORMAT = 1 << 12, // ddpfPixelFormat is valid
}; };
ENABLE_BITMASK_OPERATORS(DDSurfaceDescFlags) ENABLE_BITMASK_OPERATORS(DDSurfaceDescFlags)
#define DDSCAPS_BACKBUFFER DDSCapsFlags::BACKBUFFER
#define DDSCAPS_COMPLEX DDSCapsFlags::COMPLEX
#define DDSCAPS_FLIP DDSCapsFlags::FLIP
#define DDSCAPS_OFFSCREENPLAIN DDSCapsFlags::OFFSCREENPLAIN
#define DDSCAPS_PRIMARYSURFACE DDSCapsFlags::PRIMARYSURFACE
#define DDSCAPS_SYSTEMMEMORY DDSCapsFlags::SYSTEMMEMORY
#define DDSCAPS_TEXTURE DDSCapsFlags::TEXTURE
#define DDSCAPS_3DDEVICE DDSCapsFlags::D3DDEVICE
#define DDSCAPS_VIDEOMEMORY DDSCapsFlags::VIDEOMEMORY
#define DDSCAPS_ZBUFFER DDSCapsFlags::ZBUFFER
enum class DDSCapsFlags : uint32_t { enum class DDSCapsFlags : uint32_t {
BACKBUFFER = 0x00000004, BACKBUFFER = 1 << 2,
COMPLEX = 0x00000008, COMPLEX = 1 << 3,
FLIP = 0x00000010, FLIP = 1 << 4,
OFFSCREENPLAIN = 0x00000040, OFFSCREENPLAIN = 1 << 6,
PRIMARYSURFACE = 0x00000200, PRIMARYSURFACE = 1 << 9,
SYSTEMMEMORY = 0x00000800, SYSTEMMEMORY = 1 << 11,
TEXTURE = 0x00001000, TEXTURE = 1 << 12,
D3DDEVICE = 0x00002000, D3DDEVICE = 1 << 13,
VIDEOMEMORY = 0x00004000, VIDEOMEMORY = 1 << 14,
ZBUFFER = 0x00020000, ZBUFFER = 1 << 17,
}; };
ENABLE_BITMASK_OPERATORS(DDSCapsFlags) ENABLE_BITMASK_OPERATORS(DDSCapsFlags)
enum class DDPixelCaps : uint32_t { #define PC_NONE PCFlags::NONE
_8BIT = 0x00000004, #define PC_NOCOLLAPSE PCFlags::NOCOLLAPSE
INITIALIZE = 0x00000008, #define D3DPAL_READONLY PCFlags::D3DREADONLY
ALLOW256 = 0x00000040, #define D3DPAL_RESERVED PCFlags::D3DRESERVED
enum class PCFlags : uint8_t {
NONE = 0,
NOCOLLAPSE = 1 << 2,
D3DREADONLY = 1 << 6,
D3DRESERVED = 1 << 7,
}; };
ENABLE_BITMASK_OPERATORS(DDPixelCaps) ENABLE_BITMASK_OPERATORS(PCFlags)
// --- Structs --- // --- Structs ---
struct DDCAPS { struct DDCAPS {
DWORD dwSize; DWORD dwSize;
DWORD dwCaps2; // DDCAPS2_* DDCaps2Flags dwCaps2;
DWORD dwSVBRops[8]; DWORD dwSVBRops[8];
}; };
typedef DDCAPS* LPDDCAPS; typedef DDCAPS* LPDDCAPS;
struct DDSCAPS { struct DDSCAPS {
DDSCapsFlags dwCaps; // DDSCAPS_* DDSCapsFlags dwCaps;
}; };
typedef struct DDSCAPS* LPDDSCAPS; typedef struct DDSCAPS* LPDDSCAPS;
@ -201,8 +246,8 @@ struct DDBLTFX {
}; };
struct DDPIXELFORMAT { struct DDPIXELFORMAT {
DWORD dwSize; // sizeof(DDPIXELFORMAT) DWORD dwSize;
DWORD dwFlags; // DDPF_RGB DDPixelFormatFlags dwFlags;
DWORD dwRGBBitCount; // Bit count, Lego Island only handles 8 or 16 DWORD dwRGBBitCount; // Bit count, Lego Island only handles 8 or 16
DWORD dwRBitMask; // Red bit mask (0xF800) DWORD dwRBitMask; // Red bit mask (0xF800)
DWORD dwGBitMask; // Green bit mask (0x07E0) DWORD dwGBitMask; // Green bit mask (0x07E0)
@ -217,8 +262,8 @@ struct DDCOLORKEY {
typedef DDCOLORKEY* LPDDCOLORKEY; typedef DDCOLORKEY* LPDDCOLORKEY;
struct DDSURFACEDESC { struct DDSURFACEDESC {
DWORD dwSize; // sizeof(DDSURFACEDESC) DWORD dwSize;
DDSurfaceDescFlags dwFlags; // DDSD_* DDSurfaceDescFlags dwFlags;
DWORD dwHeight; DWORD dwHeight;
DWORD dwWidth; DWORD dwWidth;
LONG lPitch; LONG lPitch;
@ -230,6 +275,21 @@ struct DDSURFACEDESC {
}; };
typedef struct DDSURFACEDESC* LPDDSURFACEDESC; typedef struct DDSURFACEDESC* LPDDSURFACEDESC;
struct PALETTEENTRY {
BYTE peRed;
BYTE peGreen;
BYTE peBlue;
PCFlags peFlags;
};
typedef PALETTEENTRY* LPPALETTEENTRY;
struct LOGPALETTE {
WORD palVersion;
WORD palNumEntries;
PALETTEENTRY palPalEntry[1];
};
typedef LOGPALETTE* LPLOGPALETTE;
typedef struct IDirectDraw* LPDIRECTDRAW; typedef struct IDirectDraw* LPDIRECTDRAW;
struct IDirectDrawPalette : virtual public IUnknown { struct IDirectDrawPalette : virtual public IUnknown {
virtual HRESULT GetCaps(LPDWORD lpdwCaps) = 0; virtual HRESULT GetCaps(LPDWORD lpdwCaps) = 0;
@ -252,7 +312,7 @@ struct IDirectDrawSurface : virtual public IUnknown {
LPRECT lpDestRect, LPRECT lpDestRect,
LPDIRECTDRAWSURFACE lpDDSrcSurface, LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect, LPRECT lpSrcRect,
DWORD dwFlags, DDBltFlags dwFlags,
LPDDBLTFX lpDDBltFx LPDDBLTFX lpDDBltFx
) = 0; ) = 0;
virtual HRESULT BltFast( virtual HRESULT BltFast(
@ -260,10 +320,10 @@ struct IDirectDrawSurface : virtual public IUnknown {
DWORD dwY, DWORD dwY,
LPDIRECTDRAWSURFACE lpDDSrcSurface, LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect, LPRECT lpSrcRect,
DWORD dwTrans DDBltFastFlags dwTrans
) = 0; ) = 0;
virtual HRESULT DeleteAttachedSurface(DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface) = 0; virtual HRESULT DeleteAttachedSurface(DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface) = 0;
virtual HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags) = 0; virtual HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags) = 0;
virtual HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) = 0; virtual HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) = 0;
virtual HRESULT GetCaps(LPDDSCAPS lpDDSCaps) = 0; virtual HRESULT GetCaps(LPDDSCAPS lpDDSCaps) = 0;
virtual HRESULT GetDC(HDC* lphDC) = 0; virtual HRESULT GetDC(HDC* lphDC) = 0;
@ -273,11 +333,11 @@ struct IDirectDrawSurface : virtual public IUnknown {
virtual HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) = 0; virtual HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) = 0;
virtual HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) = 0; virtual HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) = 0;
virtual HRESULT IsLost() = 0; virtual HRESULT IsLost() = 0;
virtual HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent) = 0; virtual HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DDLockFlags dwFlags, HANDLE hEvent) = 0;
virtual HRESULT ReleaseDC(HDC hDC) = 0; virtual HRESULT ReleaseDC(HDC hDC) = 0;
virtual HRESULT Restore() = 0; virtual HRESULT Restore() = 0;
virtual HRESULT SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) = 0; virtual HRESULT SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) = 0;
virtual HRESULT SetColorKey(DWORD dwFlags, LPDDCOLORKEY lpDDColorKey) = 0; virtual HRESULT SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey) = 0;
virtual HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) = 0; virtual HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) = 0;
virtual HRESULT Unlock(LPVOID lpSurfaceData) = 0; virtual HRESULT Unlock(LPVOID lpSurfaceData) = 0;
}; };
@ -316,7 +376,7 @@ struct IDirectDraw : virtual public IUnknown {
virtual HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) = 0; virtual HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) = 0;
virtual HRESULT Initialize(GUID* lpGUID) = 0; virtual HRESULT Initialize(GUID* lpGUID) = 0;
virtual HRESULT RestoreDisplayMode() = 0; virtual HRESULT RestoreDisplayMode() = 0;
virtual HRESULT SetCooperativeLevel(HWND hWnd, DWORD dwFlags) = 0; virtual HRESULT SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) = 0;
virtual HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) = 0; virtual HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) = 0;
}; };
@ -329,3 +389,23 @@ HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOute
typedef BOOL (*LPDDENUMCALLBACKA)(GUID*, LPSTR, LPSTR, LPVOID); typedef BOOL (*LPDDENUMCALLBACKA)(GUID*, LPSTR, LPSTR, LPVOID);
HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context); HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context);
inline UINT WINAPI GetSystemPaletteEntries(HDC hdc, UINT iStart, UINT cEntries, LPPALETTEENTRY pPalEntries)
{
return 0;
}
inline HPALETTE CreatePalette(LPLOGPALETTE lpLogPalette)
{
return nullptr;
}
inline int SelectPalette(HDC hdc, HPALETTE hpal, BOOL bForceBackground)
{
return 0;
}
inline int RealizePalette(HDC hdc)
{
return 0;
}

13
miniwin/miniwin/src/miniwin_ddraw.cpp
View File

@ -22,18 +22,19 @@ struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
LPRECT lpDestRect, LPRECT lpDestRect,
LPDIRECTDRAWSURFACE lpDDSrcSurface, LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect, LPRECT lpSrcRect,
DWORD dwFlags, DDBltFlags dwFlags,
LPDDBLTFX lpDDBltFx LPDDBLTFX lpDDBltFx
) override ) override
{ {
return DD_OK; return DD_OK;
} }
HRESULT BltFast(DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwTrans) override HRESULT BltFast(DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DDBltFastFlags dwTrans)
override
{ {
return DD_OK; return DD_OK;
} }
HRESULT DeleteAttachedSurface(DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface) override { return DD_OK; } HRESULT DeleteAttachedSurface(DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface) override { return DD_OK; }
HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags) override { return DDERR_GENERIC; } HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags) override { return DDERR_GENERIC; }
HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) override HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) override
{ {
return DDERR_GENERIC; return DDERR_GENERIC;
@ -51,14 +52,14 @@ struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; } HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; }
HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; } HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; }
HRESULT IsLost() override { return DD_OK; } HRESULT IsLost() override { return DD_OK; }
HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent) override HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DDLockFlags dwFlags, HANDLE hEvent) override
{ {
return DD_OK; return DD_OK;
} }
HRESULT ReleaseDC(HDC hDC) override { return DD_OK; } HRESULT ReleaseDC(HDC hDC) override { return DD_OK; }
HRESULT Restore() override { return DD_OK; } HRESULT Restore() override { return DD_OK; }
HRESULT SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) override { return DD_OK; } HRESULT SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) override { return DD_OK; }
HRESULT SetColorKey(DWORD dwFlags, LPDDCOLORKEY lpDDColorKey) override { return DD_OK; } HRESULT SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey) override { return DD_OK; }
HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) override { return DD_OK; } HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) override { return DD_OK; }
HRESULT Unlock(LPVOID lpSurfaceData) override { return DD_OK; } HRESULT Unlock(LPVOID lpSurfaceData) override { return DD_OK; }
}; };
@ -128,7 +129,7 @@ struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; } HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; }
HRESULT Initialize(GUID* lpGUID) override { return DD_OK; } HRESULT Initialize(GUID* lpGUID) override { return DD_OK; }
HRESULT RestoreDisplayMode() override { return DD_OK; } HRESULT RestoreDisplayMode() override { return DD_OK; }
HRESULT SetCooperativeLevel(HWND hWnd, DWORD dwFlags) override { return DD_OK; } HRESULT SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) override { return DD_OK; }
HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) override { return DD_OK; } HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) override { return DD_OK; }
// IDirect3D2 interface // IDirect3D2 interface
HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override

3
util/compat.h
View File

@ -10,8 +10,11 @@
#ifndef MINIWIN #ifndef MINIWIN
#define D3DCOLOR_NONE 0 #define D3DCOLOR_NONE 0
#define D3DRMMAP_NONE 0 #define D3DRMMAP_NONE 0
#define PC_NONE 0
#define DDBLT_NONE 0
#define D3DRMRENDERMODE DWORD #define D3DRMRENDERMODE DWORD
#define DDSCapsFlags DWORD #define DDSCapsFlags DWORD
#define DDBitDepths DWORD
#endif #endif
// Disable "identifier was truncated to '255' characters" warning. // Disable "identifier was truncated to '255' characters" warning.