diff --git a/CONFIG/config.cpp b/CONFIG/config.cpp
index 134b3c5e..5443e3e0 100644
--- a/CONFIG/config.cpp
+++ b/CONFIG/config.cpp
@@ -354,17 +354,17 @@ DWORD CConfigApp::GetConditionalDeviceRenderBitDepth() const
 	if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) {
 		return 0;
 	}
-	return m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_8;
+	return (m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_8) == DDBD_8;
 }
 
 // FUNCTION: CONFIG 0x004037e0
 DWORD CConfigApp::GetDeviceRenderBitStatus() const
 {
 	if (GetHardwareDeviceColorModel() != D3DCOLOR_NONE) {
-		return m_device->m_HWDesc.dwDeviceRenderBitDepth & DDBD_16;
+		return (m_device->m_HWDesc.dwDeviceRenderBitDepth & DDBD_16) == DDBD_16;
 	}
 	else {
-		return m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_16;
+		return (m_device->m_HELDesc.dwDeviceRenderBitDepth & DDBD_16) == DDBD_16;
 	}
 }
 
diff --git a/LEGO1/lego/legoomni/src/common/legotextureinfo.cpp b/LEGO1/lego/legoomni/src/common/legotextureinfo.cpp
index 771fc3ab..b6e0e12a 100644
--- a/LEGO1/lego/legoomni/src/common/legotextureinfo.cpp
+++ b/LEGO1/lego/legoomni/src/common/legotextureinfo.cpp
@@ -106,7 +106,7 @@ LegoTextureInfo* LegoTextureInfo::Create(const char* p_name, LegoTexture* p_text
 
 	for (i = 0; i < sizeOfArray(entries); i++) {
 		if (i < image->GetCount()) {
-			entries[i].peFlags = 0;
+			entries[i].peFlags = PC_NONE;
 			entries[i].peRed = image->GetPalette()->colors[i].r;
 			entries[i].peGreen = image->GetPalette()->colors[i].g;
 			entries[i].peBlue = image->GetPalette()->colors[i].b;
diff --git a/LEGO1/lego/legoomni/src/common/legoutils.cpp b/LEGO1/lego/legoomni/src/common/legoutils.cpp
index 874b72d3..832fc3dd 100644
--- a/LEGO1/lego/legoomni/src/common/legoutils.cpp
+++ b/LEGO1/lego/legoomni/src/common/legoutils.cpp
@@ -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) {
 					MxS32 i;
 					for (i = 0; i < sizeOfArray(entries); i++) {
-						if (entries[i].peFlags != 0) {
+						if (entries[i].peFlags != PC_NONE) {
 							break;
 						}
 
diff --git a/LEGO1/lego/legoomni/src/video/legovideomanager.cpp b/LEGO1/lego/legoomni/src/video/legovideomanager.cpp
index 4779e53d..a85e9ec0 100644
--- a/LEGO1/lego/legoomni/src/video/legovideomanager.cpp
+++ b/LEGO1/lego/legoomni/src/video/legovideomanager.cpp
@@ -135,7 +135,7 @@ MxResult LegoVideoManager::Create(MxVideoParam& p_videoParam, MxU32 p_frequencyM
 
 	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);
 	}
 	else {
@@ -819,13 +819,15 @@ MxResult LegoVideoManager::ConfigureD3DRM()
 	MxAssignedDevice* assignedDevice = m_direct3d->AssignedDevice();
 
 	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->SetDither(TRUE);
 
-		if (assignedDevice->GetDesc().dpcTriCaps.dwShadeCaps & D3DPSHADECAPS_ALPHAFLATBLEND) {
+		if ((assignedDevice->GetDesc().dpcTriCaps.dwShadeCaps & D3DPSHADECAPS_ALPHAFLATBLEND) ==
+			D3DPSHADECAPS_ALPHAFLATBLEND) {
 			d3drm->SetRenderMode(D3DRMRENDERMODE_BLENDEDTRANSPARENCY);
 		}
 	}
diff --git a/LEGO1/lego/sources/3dmanager/tglsurface.cpp b/LEGO1/lego/sources/3dmanager/tglsurface.cpp
index f03206d9..89d851dd 100644
--- a/LEGO1/lego/sources/3dmanager/tglsurface.cpp
+++ b/LEGO1/lego/sources/3dmanager/tglsurface.cpp
@@ -66,7 +66,7 @@ int GetBitsPerPixel(IDirectDrawSurface* pSurface)
 
 	result = pSurface->GetPixelFormat(&pixelFormat);
 	assert(result == DD_OK);
-	assert(pixelFormat.dwFlags & DDPF_RGB);
+	assert((pixelFormat.dwFlags & DDPF_RGB) == DDPF_RGB);
 
 	return pixelFormat.dwRGBBitCount;
 }
diff --git a/LEGO1/mxdirectx/legodxinfo.cpp b/LEGO1/mxdirectx/legodxinfo.cpp
index a00c97dc..b7de7209 100644
--- a/LEGO1/mxdirectx/legodxinfo.cpp
+++ b/LEGO1/mxdirectx/legodxinfo.cpp
@@ -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.dwDeviceZBufferBitDepth & DDBD_16 &&
-			p_device.m_HWDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) {
+		if ((p_device.m_HWDesc.dwDeviceZBufferBitDepth & DDBD_16) == DDBD_16 &&
+			(p_device.m_HWDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) == D3DPTEXTURECAPS_PERSPECTIVE) {
 			return TRUE;
 		}
 		else {
diff --git a/LEGO1/mxdirectx/mxdirect3d.cpp b/LEGO1/mxdirectx/mxdirect3d.cpp
index c35a3e2d..75ba5e70 100644
--- a/LEGO1/mxdirectx/mxdirect3d.cpp
+++ b/LEGO1/mxdirectx/mxdirect3d.cpp
@@ -132,7 +132,8 @@ BOOL MxDirect3D::D3DSetMode()
 			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;
 		}
 		else {
@@ -144,7 +145,8 @@ BOOL MxDirect3D::D3DSetMode()
 		}
 	}
 	else {
-		if (m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) {
+		if ((m_currentDeviceInfo->m_desc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) ==
+			D3DPTEXTURECAPS_PERSPECTIVE) {
 			m_bTexturesDisabled = FALSE;
 		}
 		else {
@@ -221,25 +223,25 @@ BOOL MxDirect3D::D3DSetMode()
 int MxDirect3D::ZBufferDepth(MxAssignedDevice* p_assignedDevice)
 {
 	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;
 	}
 	else {
-		deviceDepth = 0;
+		return -1;
 	}
 
-	if (deviceDepth & DDBD_32) {
+	if ((deviceDepth & DDBD_32) == DDBD_32) {
 		depth = 32;
 	}
-	else if (deviceDepth & DDBD_24) {
+	else if ((deviceDepth & DDBD_24) == DDBD_24) {
 		depth = 24;
 	}
-	else if (deviceDepth & DDBD_16) {
+	else if ((deviceDepth & DDBD_16) == DDBD_16) {
 		depth = 16;
 	}
-	else if (deviceDepth & DDBD_8) {
+	else if ((deviceDepth & DDBD_8) == DDBD_8) {
 		depth = 8;
 	}
 	else {
diff --git a/LEGO1/mxdirectx/mxdirectdraw.cpp b/LEGO1/mxdirectx/mxdirectdraw.cpp
index 6a2fa968..9972a4db 100644
--- a/LEGO1/mxdirectx/mxdirectdraw.cpp
+++ b/LEGO1/mxdirectx/mxdirectdraw.cpp
@@ -75,7 +75,7 @@ int MxDirectDraw::GetPrimaryBitDepth()
 
 		pDDraw->GetDisplayMode(&ddsd);
 		dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount;
-		g_isPaletteIndexed8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) != 0;
+		g_isPaletteIndexed8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) == DDPF_PALETTEINDEXED8;
 		pDDraw->Release();
 	}
 
@@ -406,7 +406,7 @@ BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp)
 		return FALSE;
 	}
 
-	if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
+	if ((ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) == DDPF_PALETTEINDEXED8) {
 		m_bPrimaryPalettized = TRUE;
 	}
 	else {
diff --git a/LEGO1/omni/src/video/mxdisplaysurface.cpp b/LEGO1/omni/src/video/mxdisplaysurface.cpp
index 01aa103e..f68a048c 100644
--- a/LEGO1/omni/src/video/mxdisplaysurface.cpp
+++ b/LEGO1/omni/src/video/mxdisplaysurface.cpp
@@ -302,7 +302,7 @@ void MxDisplaySurface::Destroy()
 // FUNCTION: BETA10 0x1013fe15
 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_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.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->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, 0, &data);
+				m_ddSurface1->Blt((LPRECT) &b, m_ddSurface2, (LPRECT) &a, DDBLT_NONE, &data);
 			}
 		}
 	}
diff --git a/LEGO1/omni/src/video/mxpalette.cpp b/LEGO1/omni/src/video/mxpalette.cpp
index 7738a198..4c871971 100644
--- a/LEGO1/omni/src/video/mxpalette.cpp
+++ b/LEGO1/omni/src/video/mxpalette.cpp
@@ -6,70 +6,70 @@
 // GLOBAL: LEGO1 0x10102188
 // GLOBAL: BETA10 0x10203558
 PALETTEENTRY g_defaultPaletteEntries[256] = {
-	{0u, 0u, 0u, 0u},       {128u, 0u, 0u, 0u},     {0u, 128u, 0u, 0u},     {128u, 128u, 0u, 0u},
-	{0u, 0u, 128u, 0u},     {128u, 0u, 128u, 0u},   {0u, 128u, 128u, 0u},   {128u, 128u, 128u, 0u},
-	{192u, 220u, 192u, 0u}, {166u, 202u, 240u, 0u}, {255u, 255u, 255u, 0u}, {250u, 250u, 250u, 0u},
-	{239u, 239u, 239u, 0u}, {228u, 228u, 228u, 0u}, {217u, 217u, 217u, 0u}, {206u, 206u, 206u, 0u},
-	{195u, 195u, 195u, 0u}, {185u, 185u, 185u, 0u}, {174u, 174u, 174u, 0u}, {163u, 163u, 163u, 0u},
-	{152u, 152u, 152u, 0u}, {141u, 141u, 141u, 0u}, {130u, 130u, 130u, 0u}, {123u, 123u, 123u, 0u},
-	{115u, 115u, 115u, 0u}, {108u, 108u, 108u, 0u}, {101u, 101u, 101u, 0u}, {93u, 93u, 93u, 0u},
-	{86u, 86u, 86u, 0u},    {79u, 79u, 79u, 0u},    {71u, 71u, 71u, 0u},    {64u, 64u, 64u, 0u},
-	{54u, 54u, 54u, 0u},    {43u, 43u, 43u, 0u},    {33u, 33u, 33u, 0u},    {22u, 22u, 22u, 0u},
-	{12u, 12u, 12u, 0u},    {8u, 8u, 8u, 0u},       {4u, 4u, 4u, 0u},       {0u, 0u, 0u, 0u},
-	{225u, 218u, 217u, 0u}, {195u, 182u, 179u, 0u}, {165u, 145u, 141u, 0u}, {134u, 108u, 102u, 0u},
-	{104u, 72u, 64u, 0u},   {74u, 35u, 26u, 0u},    {59u, 28u, 21u, 0u},    {44u, 21u, 16u, 0u},
-	{30u, 14u, 10u, 0u},    {15u, 7u, 5u, 0u},      {250u, 231u, 232u, 0u}, {240u, 185u, 189u, 0u},
-	{233u, 154u, 160u, 0u}, {226u, 124u, 131u, 0u}, {219u, 93u, 102u, 0u},  {213u, 62u, 73u, 0u},
-	{203u, 18u, 32u, 0u},   {172u, 15u, 27u, 0u},   {159u, 14u, 25u, 0u},   {146u, 13u, 23u, 0u},
-	{133u, 12u, 21u, 0u},   {120u, 11u, 19u, 0u},   {107u, 10u, 17u, 0u},   {94u, 8u, 15u, 0u},
-	{81u, 7u, 13u, 0u},     {68u, 6u, 11u, 0u},     {55u, 5u, 9u, 0u},      {42u, 4u, 7u, 0u},
-	{29u, 3u, 5u, 0u},      {10u, 1u, 2u, 0u},      {227u, 236u, 242u, 0u}, {178u, 203u, 220u, 0u},
-	{145u, 181u, 205u, 0u}, {112u, 159u, 191u, 0u}, {79u, 137u, 176u, 0u},  {30u, 104u, 154u, 0u},
-	{0u, 84u, 140u, 0u},    {0u, 79u, 132u, 0u},    {0u, 72u, 119u, 0u},    {0u, 66u, 110u, 0u},
-	{0u, 61u, 101u, 0u},    {0u, 55u, 92u, 0u},     {0u, 47u, 78u, 0u},     {0u, 39u, 65u, 0u},
-	{0u, 34u, 56u, 0u},     {0u, 28u, 47u, 0u},     {0u, 23u, 38u, 0u},     {0u, 18u, 29u, 0u},
-	{0u, 12u, 20u, 0u},     {0u, 4u, 7u, 0u},       {230u, 242u, 234u, 0u}, {180u, 215u, 193u, 0u},
-	{147u, 198u, 166u, 0u}, {113u, 180u, 138u, 0u}, {80u, 162u, 111u, 0u},  {30u, 136u, 70u, 0u},
-	{0u, 120u, 45u, 0u},    {0u, 114u, 43u, 0u},    {0u, 102u, 38u, 0u},    {0u, 95u, 35u, 0u},
-	{0u, 83u, 31u, 0u},     {0u, 72u, 27u, 0u},     {0u, 63u, 24u, 0u},     {0u, 56u, 21u, 0u},
-	{0u, 48u, 18u, 0u},     {0u, 36u, 14u, 0u},     {0u, 25u, 9u, 0u},      {0u, 17u, 6u, 0u},
-	{0u, 9u, 3u, 0u},       {0u, 1u, 1u, 0u},       {254u, 244u, 220u, 0u}, {255u, 239u, 181u, 0u},
-	{255u, 231u, 156u, 0u}, {255u, 222u, 132u, 0u}, {255u, 222u, 115u, 0u}, {255u, 214u, 99u, 0u},
-	{255u, 206u, 66u, 0u},  {255u, 198u, 41u, 0u},  {255u, 185u, 0u, 0u},   {255u, 189u, 8u, 0u},
-	{247u, 181u, 0u, 0u},   {222u, 156u, 0u, 0u},   {189u, 140u, 0u, 0u},   {173u, 123u, 0u, 0u},
-	{148u, 107u, 0u, 0u},   {132u, 90u, 0u, 0u},    {107u, 74u, 0u, 0u},    {74u, 49u, 0u, 0u},
-	{57u, 41u, 0u, 0u},     {33u, 24u, 0u, 0u},     {117u, 52u, 87u, 0u},   {176u, 158u, 50u, 0u},
-	{122u, 165u, 29u, 0u},  {242u, 142u, 8u, 0u},   {164u, 43u, 36u, 0u},   {113u, 67u, 20u, 0u},
-	{255u, 0u, 255u, 0u},   {255u, 0u, 255u, 0u},   {255u, 0u, 255u, 0u},   {255u, 0u, 255u, 0u},
-	{255u, 0u, 255u, 0u},   {57u, 163u, 217u, 0u},  {255u, 255u, 255u, 0u}, {254u, 255u, 247u, 0u},
-	{253u, 253u, 239u, 0u}, {248u, 247u, 247u, 0u}, {248u, 247u, 231u, 0u}, {240u, 240u, 240u, 0u},
-	{239u, 239u, 218u, 0u}, {227u, 232u, 236u, 0u}, {224u, 221u, 209u, 0u}, {215u, 222u, 215u, 0u},
-	{213u, 214u, 215u, 0u}, {214u, 214u, 203u, 0u}, {255u, 219u, 57u, 0u},  {206u, 206u, 206u, 0u},
-	{206u, 206u, 198u, 0u}, {255u, 214u, 18u, 0u},  {207u, 203u, 186u, 0u}, {197u, 199u, 199u, 0u},
-	{255u, 206u, 0u, 0u},   {207u, 198u, 159u, 0u}, {247u, 204u, 0u, 0u},   {189u, 198u, 189u, 0u},
-	{189u, 189u, 189u, 0u}, {238u, 199u, 0u, 0u},   {189u, 189u, 181u, 0u}, {238u, 190u, 24u, 0u},
-	{181u, 189u, 184u, 0u}, {161u, 186u, 224u, 0u}, {181u, 181u, 181u, 0u}, {231u, 189u, 0u, 0u},
-	{173u, 182u, 173u, 0u}, {222u, 181u, 0u, 0u},   {173u, 173u, 173u, 0u}, {213u, 182u, 0u, 0u},
-	{172u, 173u, 160u, 0u}, {214u, 173u, 0u, 0u},   {165u, 165u, 165u, 0u}, {206u, 173u, 0u, 0u},
-	{160u, 168u, 151u, 0u}, {206u, 164u, 0u, 0u},   {198u, 165u, 0u, 0u},   {157u, 156u, 156u, 0u},
-	{134u, 156u, 200u, 0u}, {153u, 156u, 144u, 0u}, {142u, 156u, 161u, 0u}, {189u, 156u, 0u, 0u},
-	{148u, 148u, 148u, 0u}, {146u, 148u, 138u, 0u}, {133u, 143u, 161u, 0u}, {189u, 143u, 0u, 0u},
-	{140u, 140u, 140u, 0u}, {177u, 147u, 0u, 0u},   {131u, 140u, 136u, 0u}, {146u, 130u, 126u, 0u},
-	{170u, 137u, 0u, 0u},   {132u, 132u, 130u, 0u}, {123u, 125u, 125u, 0u}, {123u, 123u, 133u, 0u},
-	{153u, 126u, 0u, 0u},   {114u, 116u, 118u, 0u}, {110u, 112u, 108u, 0u}, {97u, 109u, 136u, 0u},
-	{127u, 108u, 6u, 0u},   {0u, 173u, 0u, 0u},     {100u, 99u, 101u, 0u},  {176u, 71u, 41u, 0u},
-	{36u, 142u, 33u, 0u},   {98u, 91u, 75u, 0u},    {80u, 88u, 104u, 0u},   {252u, 0u, 0u, 0u},
-	{78u, 71u, 73u, 0u},    {73u, 71u, 78u, 0u},    {62u, 63u, 61u, 0u},    {0u, 66u, 211u, 0u},
-	{99u, 51u, 14u, 0u},    {198u, 0u, 0u, 0u},     {189u, 0u, 0u, 0u},     {0u, 57u, 206u, 0u},
-	{181u, 0u, 0u, 0u},     {0u, 56u, 185u, 0u},    {173u, 0u, 0u, 0u},     {165u, 0u, 0u, 0u},
-	{49u, 49u, 49u, 0u},    {0u, 49u, 165u, 0u},    {156u, 0u, 0u, 0u},     {42u, 45u, 60u, 0u},
-	{148u, 0u, 0u, 0u},     {140u, 0u, 0u, 0u},     {41u, 41u, 41u, 0u},    {0u, 41u, 144u, 0u},
-	{132u, 0u, 0u, 0u},     {123u, 0u, 0u, 0u},     {7u, 35u, 114u, 0u},    {34u, 36u, 32u, 0u},
-	{115u, 0u, 0u, 0u},     {107u, 0u, 0u, 0u},     {90u, 0u, 0u, 0u},      {23u, 24u, 27u, 0u},
-	{74u, 0u, 0u, 0u},      {15u, 15u, 16u, 0u},    {49u, 0u, 0u, 0u},      {16u, 12u, 4u, 0u},
-	{7u, 8u, 8u, 0u},       {0u, 0u, 8u, 0u},       {255u, 251u, 240u, 0u}, {160u, 160u, 164u, 0u},
-	{128u, 128u, 128u, 0u}, {255u, 0u, 0u, 0u},     {0u, 255u, 0u, 0u},     {255u, 255u, 0u, 0u},
-	{0u, 0u, 255u, 0u},     {255u, 0u, 255u, 0u},   {0u, 255u, 255u, 0u},   {255u, 255u, 255u, 0u}
+	{0u, 0u, 0u, PC_NONE},       {128u, 0u, 0u, PC_NONE},     {0u, 128u, 0u, PC_NONE},     {128u, 128u, 0u, PC_NONE},
+	{0u, 0u, 128u, PC_NONE},     {128u, 0u, 128u, PC_NONE},   {0u, 128u, 128u, PC_NONE},   {128u, 128u, 128u, PC_NONE},
+	{192u, 220u, 192u, PC_NONE}, {166u, 202u, 240u, PC_NONE}, {255u, 255u, 255u, PC_NONE}, {250u, 250u, 250u, PC_NONE},
+	{239u, 239u, 239u, PC_NONE}, {228u, 228u, 228u, PC_NONE}, {217u, 217u, 217u, PC_NONE}, {206u, 206u, 206u, PC_NONE},
+	{195u, 195u, 195u, PC_NONE}, {185u, 185u, 185u, PC_NONE}, {174u, 174u, 174u, PC_NONE}, {163u, 163u, 163u, PC_NONE},
+	{152u, 152u, 152u, PC_NONE}, {141u, 141u, 141u, PC_NONE}, {130u, 130u, 130u, PC_NONE}, {123u, 123u, 123u, PC_NONE},
+	{115u, 115u, 115u, PC_NONE}, {108u, 108u, 108u, PC_NONE}, {101u, 101u, 101u, PC_NONE}, {93u, 93u, 93u, PC_NONE},
+	{86u, 86u, 86u, PC_NONE},    {79u, 79u, 79u, PC_NONE},    {71u, 71u, 71u, PC_NONE},    {64u, 64u, 64u, PC_NONE},
+	{54u, 54u, 54u, PC_NONE},    {43u, 43u, 43u, PC_NONE},    {33u, 33u, 33u, PC_NONE},    {22u, 22u, 22u, PC_NONE},
+	{12u, 12u, 12u, PC_NONE},    {8u, 8u, 8u, PC_NONE},       {4u, 4u, 4u, PC_NONE},       {0u, 0u, 0u, PC_NONE},
+	{225u, 218u, 217u, PC_NONE}, {195u, 182u, 179u, PC_NONE}, {165u, 145u, 141u, PC_NONE}, {134u, 108u, 102u, PC_NONE},
+	{104u, 72u, 64u, PC_NONE},   {74u, 35u, 26u, PC_NONE},    {59u, 28u, 21u, PC_NONE},    {44u, 21u, 16u, PC_NONE},
+	{30u, 14u, 10u, PC_NONE},    {15u, 7u, 5u, PC_NONE},      {250u, 231u, 232u, PC_NONE}, {240u, 185u, 189u, PC_NONE},
+	{233u, 154u, 160u, PC_NONE}, {226u, 124u, 131u, PC_NONE}, {219u, 93u, 102u, PC_NONE},  {213u, 62u, 73u, PC_NONE},
+	{203u, 18u, 32u, PC_NONE},   {172u, 15u, 27u, PC_NONE},   {159u, 14u, 25u, PC_NONE},   {146u, 13u, 23u, PC_NONE},
+	{133u, 12u, 21u, PC_NONE},   {120u, 11u, 19u, PC_NONE},   {107u, 10u, 17u, PC_NONE},   {94u, 8u, 15u, PC_NONE},
+	{81u, 7u, 13u, PC_NONE},     {68u, 6u, 11u, PC_NONE},     {55u, 5u, 9u, PC_NONE},      {42u, 4u, 7u, PC_NONE},
+	{29u, 3u, 5u, PC_NONE},      {10u, 1u, 2u, PC_NONE},      {227u, 236u, 242u, PC_NONE}, {178u, 203u, 220u, PC_NONE},
+	{145u, 181u, 205u, PC_NONE}, {112u, 159u, 191u, PC_NONE}, {79u, 137u, 176u, PC_NONE},  {30u, 104u, 154u, PC_NONE},
+	{0u, 84u, 140u, PC_NONE},    {0u, 79u, 132u, PC_NONE},    {0u, 72u, 119u, PC_NONE},    {0u, 66u, 110u, PC_NONE},
+	{0u, 61u, 101u, PC_NONE},    {0u, 55u, 92u, PC_NONE},     {0u, 47u, 78u, PC_NONE},     {0u, 39u, 65u, PC_NONE},
+	{0u, 34u, 56u, PC_NONE},     {0u, 28u, 47u, PC_NONE},     {0u, 23u, 38u, PC_NONE},     {0u, 18u, 29u, PC_NONE},
+	{0u, 12u, 20u, PC_NONE},     {0u, 4u, 7u, PC_NONE},       {230u, 242u, 234u, PC_NONE}, {180u, 215u, 193u, PC_NONE},
+	{147u, 198u, 166u, PC_NONE}, {113u, 180u, 138u, PC_NONE}, {80u, 162u, 111u, PC_NONE},  {30u, 136u, 70u, PC_NONE},
+	{0u, 120u, 45u, PC_NONE},    {0u, 114u, 43u, PC_NONE},    {0u, 102u, 38u, PC_NONE},    {0u, 95u, 35u, PC_NONE},
+	{0u, 83u, 31u, PC_NONE},     {0u, 72u, 27u, PC_NONE},     {0u, 63u, 24u, PC_NONE},     {0u, 56u, 21u, PC_NONE},
+	{0u, 48u, 18u, PC_NONE},     {0u, 36u, 14u, PC_NONE},     {0u, 25u, 9u, PC_NONE},      {0u, 17u, 6u, PC_NONE},
+	{0u, 9u, 3u, PC_NONE},       {0u, 1u, 1u, PC_NONE},       {254u, 244u, 220u, PC_NONE}, {255u, 239u, 181u, PC_NONE},
+	{255u, 231u, 156u, PC_NONE}, {255u, 222u, 132u, PC_NONE}, {255u, 222u, 115u, PC_NONE}, {255u, 214u, 99u, PC_NONE},
+	{255u, 206u, 66u, PC_NONE},  {255u, 198u, 41u, PC_NONE},  {255u, 185u, 0u, PC_NONE},   {255u, 189u, 8u, PC_NONE},
+	{247u, 181u, 0u, PC_NONE},   {222u, 156u, 0u, PC_NONE},   {189u, 140u, 0u, PC_NONE},   {173u, 123u, 0u, PC_NONE},
+	{148u, 107u, 0u, PC_NONE},   {132u, 90u, 0u, PC_NONE},    {107u, 74u, 0u, PC_NONE},    {74u, 49u, 0u, PC_NONE},
+	{57u, 41u, 0u, PC_NONE},     {33u, 24u, 0u, PC_NONE},     {117u, 52u, 87u, PC_NONE},   {176u, 158u, 50u, PC_NONE},
+	{122u, 165u, 29u, PC_NONE},  {242u, 142u, 8u, PC_NONE},   {164u, 43u, 36u, PC_NONE},   {113u, 67u, 20u, PC_NONE},
+	{255u, 0u, 255u, PC_NONE},   {255u, 0u, 255u, PC_NONE},   {255u, 0u, 255u, PC_NONE},   {255u, 0u, 255u, PC_NONE},
+	{255u, 0u, 255u, PC_NONE},   {57u, 163u, 217u, PC_NONE},  {255u, 255u, 255u, PC_NONE}, {254u, 255u, 247u, PC_NONE},
+	{253u, 253u, 239u, PC_NONE}, {248u, 247u, 247u, PC_NONE}, {248u, 247u, 231u, PC_NONE}, {240u, 240u, 240u, PC_NONE},
+	{239u, 239u, 218u, PC_NONE}, {227u, 232u, 236u, PC_NONE}, {224u, 221u, 209u, PC_NONE}, {215u, 222u, 215u, PC_NONE},
+	{213u, 214u, 215u, PC_NONE}, {214u, 214u, 203u, PC_NONE}, {255u, 219u, 57u, PC_NONE},  {206u, 206u, 206u, PC_NONE},
+	{206u, 206u, 198u, PC_NONE}, {255u, 214u, 18u, PC_NONE},  {207u, 203u, 186u, PC_NONE}, {197u, 199u, 199u, PC_NONE},
+	{255u, 206u, 0u, PC_NONE},   {207u, 198u, 159u, PC_NONE}, {247u, 204u, 0u, PC_NONE},   {189u, 198u, 189u, PC_NONE},
+	{189u, 189u, 189u, PC_NONE}, {238u, 199u, 0u, PC_NONE},   {189u, 189u, 181u, PC_NONE}, {238u, 190u, 24u, PC_NONE},
+	{181u, 189u, 184u, PC_NONE}, {161u, 186u, 224u, PC_NONE}, {181u, 181u, 181u, PC_NONE}, {231u, 189u, 0u, PC_NONE},
+	{173u, 182u, 173u, PC_NONE}, {222u, 181u, 0u, PC_NONE},   {173u, 173u, 173u, PC_NONE}, {213u, 182u, 0u, PC_NONE},
+	{172u, 173u, 160u, PC_NONE}, {214u, 173u, 0u, PC_NONE},   {165u, 165u, 165u, PC_NONE}, {206u, 173u, 0u, PC_NONE},
+	{160u, 168u, 151u, PC_NONE}, {206u, 164u, 0u, PC_NONE},   {198u, 165u, 0u, PC_NONE},   {157u, 156u, 156u, PC_NONE},
+	{134u, 156u, 200u, PC_NONE}, {153u, 156u, 144u, PC_NONE}, {142u, 156u, 161u, PC_NONE}, {189u, 156u, 0u, PC_NONE},
+	{148u, 148u, 148u, PC_NONE}, {146u, 148u, 138u, PC_NONE}, {133u, 143u, 161u, PC_NONE}, {189u, 143u, 0u, PC_NONE},
+	{140u, 140u, 140u, PC_NONE}, {177u, 147u, 0u, PC_NONE},   {131u, 140u, 136u, PC_NONE}, {146u, 130u, 126u, PC_NONE},
+	{170u, 137u, 0u, PC_NONE},   {132u, 132u, 130u, PC_NONE}, {123u, 125u, 125u, PC_NONE}, {123u, 123u, 133u, PC_NONE},
+	{153u, 126u, 0u, PC_NONE},   {114u, 116u, 118u, PC_NONE}, {110u, 112u, 108u, PC_NONE}, {97u, 109u, 136u, PC_NONE},
+	{127u, 108u, 6u, PC_NONE},   {0u, 173u, 0u, PC_NONE},     {100u, 99u, 101u, PC_NONE},  {176u, 71u, 41u, PC_NONE},
+	{36u, 142u, 33u, PC_NONE},   {98u, 91u, 75u, PC_NONE},    {80u, 88u, 104u, PC_NONE},   {252u, 0u, 0u, PC_NONE},
+	{78u, 71u, 73u, PC_NONE},    {73u, 71u, 78u, PC_NONE},    {62u, 63u, 61u, PC_NONE},    {0u, 66u, 211u, PC_NONE},
+	{99u, 51u, 14u, PC_NONE},    {198u, 0u, 0u, PC_NONE},     {189u, 0u, 0u, PC_NONE},     {0u, 57u, 206u, PC_NONE},
+	{181u, 0u, 0u, PC_NONE},     {0u, 56u, 185u, PC_NONE},    {173u, 0u, 0u, PC_NONE},     {165u, 0u, 0u, PC_NONE},
+	{49u, 49u, 49u, PC_NONE},    {0u, 49u, 165u, PC_NONE},    {156u, 0u, 0u, PC_NONE},     {42u, 45u, 60u, PC_NONE},
+	{148u, 0u, 0u, PC_NONE},     {140u, 0u, 0u, PC_NONE},     {41u, 41u, 41u, PC_NONE},    {0u, 41u, 144u, PC_NONE},
+	{132u, 0u, 0u, PC_NONE},     {123u, 0u, 0u, PC_NONE},     {7u, 35u, 114u, PC_NONE},    {34u, 36u, 32u, PC_NONE},
+	{115u, 0u, 0u, PC_NONE},     {107u, 0u, 0u, PC_NONE},     {90u, 0u, 0u, PC_NONE},      {23u, 24u, 27u, PC_NONE},
+	{74u, 0u, 0u, PC_NONE},      {15u, 15u, 16u, PC_NONE},    {49u, 0u, 0u, PC_NONE},      {16u, 12u, 4u, PC_NONE},
+	{7u, 8u, 8u, PC_NONE},       {0u, 0u, 8u, PC_NONE},       {255u, 251u, 240u, PC_NONE}, {160u, 160u, 164u, PC_NONE},
+	{128u, 128u, 128u, PC_NONE}, {255u, 0u, 0u, PC_NONE},     {0u, 255u, 0u, PC_NONE},     {255u, 255u, 0u, PC_NONE},
+	{0u, 0u, 255u, PC_NONE},     {255u, 0u, 255u, PC_NONE},   {0u, 255u, 255u, PC_NONE},   {255u, 255u, 255u, PC_NONE}
 };
 
 // FUNCTION: LEGO1 0x100bee30
@@ -94,7 +94,7 @@ MxPalette::MxPalette(const RGBQUAD* p_colors)
 		m_entries[i].peRed = p_colors[i].rgbRed;
 		m_entries[i].peGreen = p_colors[i].rgbGreen;
 		m_entries[i].peBlue = p_colors[i].rgbBlue;
-		m_entries[i].peFlags = 0;
+		m_entries[i].peFlags = PC_NONE;
 	}
 
 	m_skyColor = m_entries[141];
diff --git a/LEGO1/omni/src/video/mxvideopresenter.cpp b/LEGO1/omni/src/video/mxvideopresenter.cpp
index 93a886a5..db0ab581 100644
--- a/LEGO1/omni/src/video/mxvideopresenter.cpp
+++ b/LEGO1/omni/src/video/mxvideopresenter.cpp
@@ -315,7 +315,7 @@ void MxVideoPresenter::PutFrame()
 				}
 				else if (m_unk0x58) {
 					if (PrepareRects(src, dest) >= 0) {
-						ddSurface->Blt(&dest, m_unk0x58, &src, 0, NULL);
+						ddSurface->Blt(&dest, m_unk0x58, &src, DDBLT_NONE, NULL);
 					}
 				}
 				else {
diff --git a/miniwin/miniwin/include/miniwin.h b/miniwin/miniwin/include/miniwin.h
index 0b750dbd..6a7a0353 100644
--- a/miniwin/miniwin/include/miniwin.h
+++ b/miniwin/miniwin/include/miniwin.h
@@ -126,14 +126,6 @@ struct BITMAPINFO {
 	RGBQUAD bmiColors[1];
 };
 
-struct PALETTEENTRY {
-	BYTE peRed;
-	BYTE peGreen;
-	BYTE peBlue;
-	BYTE peFlags;
-};
-typedef PALETTEENTRY* LPPALETTEENTRY;
-
 struct GUID {
 	uint32_t m_data1;
 	uint16_t m_data2;
@@ -152,23 +144,12 @@ struct IUnknown {
 private:
 	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)
 {
 	return TRUE;
 }
 
-inline UINT WINAPI GetSystemPaletteEntries(HDC hdc, UINT iStart, UINT cEntries, LPPALETTEENTRY pPalEntries)
-{
-	return 0;
-}
-
 inline HDC WINAPI GetDC(HWND hWnd)
 {
 	return 0;
@@ -308,21 +289,6 @@ inline int SetRect(RECT* rc, int left, int top, int right, int bottom)
 
 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)
 {
 	return TRUE;
diff --git a/miniwin/miniwin/include/miniwin_d3d.h b/miniwin/miniwin/include/miniwin_d3d.h
index d31a0be7..8641aff9 100644
--- a/miniwin/miniwin/include/miniwin_d3d.h
+++ b/miniwin/miniwin/include/miniwin_d3d.h
@@ -2,51 +2,69 @@
 
 #include "miniwin_ddraw.h"
 
-// --- Defines and Macros ---
-#define D3DPAL_RESERVED 0x80
-#define D3DPAL_READONLY 0x40
+// --- GUIDs ---
+DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1, 0x662a, 0x11d0, 0x88, 0x9d, 0x00, 0xaa, 0x00, 0xbb, 0xb7, 0x6a);
 
-#define DDBD_8 0x00000800
-#define DDBD_16 0x00000400
-#define DDBD_24 0x00000200
-#define DDBD_32 0x00000100
+// --- Enums ---
+#define DDBD_8 DDBitDepths::BPP_8
+#define DDBD_16 DDBitDepths::BPP_16
+#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_RGB D3DCOLORMODEL::RGB
 #define D3DCOLOR_MONO D3DCOLORMODEL::MONO
-
-// --- Enums ---
 enum class D3DCOLORMODEL {
-	NONE = 0,
-	RGB = 1,
-	MONO = 2
+	NONE,
+	RGB,
+	MONO,
 };
 
-// --- GUIDs ---
-DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1, 0x662a, 0x11d0, 0x88, 0x9d, 0x00, 0xaa, 0x00, 0xbb, 0xb7, 0x6a);
-
 // --- Structs ---
 struct D3DVECTOR {
 	float x, y, z;
 };
 
 struct D3DDEVICEDESC {
-	DWORD dwFlags;                 // D3DDD_*
-	DWORD dwDeviceZBufferBitDepth; // DDBD_*
-	D3DCOLORMODEL dcmColorModel;   // D3DCOLOR_* Bit flag, but Isle think it's an enum
-	DWORD dwDeviceRenderBitDepth;  // DDBD_*
+	D3DDeviceDescFlags dwFlags;
+	DDBitDepths dwDeviceZBufferBitDepth;
+	D3DCOLORMODEL dcmColorModel; // D3DCOLOR_* Bit flag, but Isle think it's an enum
+	DDBitDepths dwDeviceRenderBitDepth;
 	struct {
-		DWORD dwShadeCaps;         // D3DPSHADECAPS_*
-		DWORD dwTextureCaps;       // D3DPTEXTURECAPS_*
-		DWORD dwTextureFilterCaps; // D3DPTFILTERCAPS_*
+		D3DPShadeCaps dwShadeCaps;
+		D3DPTextureCaps dwTextureCaps;
+		D3DPTextureFilterCaps dwTextureFilterCaps;
 	} dpcTriCaps;
 };
 typedef D3DDEVICEDESC* LPD3DDEVICEDESC;
diff --git a/miniwin/miniwin/include/miniwin_ddraw.h b/miniwin/miniwin/include/miniwin_ddraw.h
index f8d0e580..326cf74d 100644
--- a/miniwin/miniwin/include/miniwin_ddraw.h
+++ b/miniwin/miniwin/include/miniwin_ddraw.h
@@ -3,56 +3,9 @@
 #include "bitflags.h"
 #include "miniwin.h"
 
-#define _FACDD 0x876
-#define DDCKEY_SRCBLT 0x00000008
-#define DDENUMRET_OK 1
-#define DDFLIP_WAIT 0x00000001
-#define DISCL_BACKGROUND 0x00000008
-#define PC_NOCOLLAPSE 0x04
+#define DDENUMRET_OK TRUE
 
-#define DDCAPS2_CERTIFIED 0x00000001
-
-// 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 MAKE_DDHRESULT(code) MAKE_HRESULT(1, 0x876, code)
 
 #define DD_OK S_OK
 #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_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 {
-	CAPS = 0x00000001,            // ddsCaps is valid
-	HEIGHT = 0x00000002,          // dwHeight is valid
-	WIDTH = 0x00000004,           // dwWidth is valid
-	BACKBUFFERCOUNT = 0x00000020, // dwBackBufferCount is valid
-	ZBUFFERBITDEPTH = 0x00000040, // dwZBufferBitDepth is valid
-	PIXELFORMAT = 0x00001000,     // ddpfPixelFormat is valid
+	CAPS = 1 << 0,            // ddsCaps is valid
+	HEIGHT = 1 << 1,          // dwHeight is valid
+	WIDTH = 1 << 2,           // dwWidth is valid
+	BACKBUFFERCOUNT = 1 << 5, // dwBackBufferCount is valid
+	ZBUFFERBITDEPTH = 1 << 6, // dwZBufferBitDepth is valid
+	PIXELFORMAT = 1 << 12,    // ddpfPixelFormat is valid
 };
 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 {
-	BACKBUFFER = 0x00000004,
-	COMPLEX = 0x00000008,
-	FLIP = 0x00000010,
-	OFFSCREENPLAIN = 0x00000040,
-	PRIMARYSURFACE = 0x00000200,
-	SYSTEMMEMORY = 0x00000800,
-	TEXTURE = 0x00001000,
-	D3DDEVICE = 0x00002000,
-	VIDEOMEMORY = 0x00004000,
-	ZBUFFER = 0x00020000,
+	BACKBUFFER = 1 << 2,
+	COMPLEX = 1 << 3,
+	FLIP = 1 << 4,
+	OFFSCREENPLAIN = 1 << 6,
+	PRIMARYSURFACE = 1 << 9,
+	SYSTEMMEMORY = 1 << 11,
+	TEXTURE = 1 << 12,
+	D3DDEVICE = 1 << 13,
+	VIDEOMEMORY = 1 << 14,
+	ZBUFFER = 1 << 17,
 };
 ENABLE_BITMASK_OPERATORS(DDSCapsFlags)
 
-enum class DDPixelCaps : uint32_t {
-	_8BIT = 0x00000004,
-	INITIALIZE = 0x00000008,
-	ALLOW256 = 0x00000040,
+#define PC_NONE PCFlags::NONE
+#define PC_NOCOLLAPSE PCFlags::NOCOLLAPSE
+#define D3DPAL_READONLY PCFlags::D3DREADONLY
+#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 ---
 struct DDCAPS {
 	DWORD dwSize;
-	DWORD dwCaps2; // DDCAPS2_*
+	DDCaps2Flags dwCaps2;
 	DWORD dwSVBRops[8];
 };
 typedef DDCAPS* LPDDCAPS;
 
 struct DDSCAPS {
-	DDSCapsFlags dwCaps; // DDSCAPS_*
+	DDSCapsFlags dwCaps;
 };
 typedef struct DDSCAPS* LPDDSCAPS;
 
@@ -201,8 +246,8 @@ struct DDBLTFX {
 };
 
 struct DDPIXELFORMAT {
-	DWORD dwSize;        // sizeof(DDPIXELFORMAT)
-	DWORD dwFlags;       // DDPF_RGB
+	DWORD dwSize;
+	DDPixelFormatFlags dwFlags;
 	DWORD dwRGBBitCount; // Bit count, Lego Island only handles 8 or 16
 	DWORD dwRBitMask;    // Red bit mask (0xF800)
 	DWORD dwGBitMask;    // Green bit mask (0x07E0)
@@ -217,8 +262,8 @@ struct DDCOLORKEY {
 typedef DDCOLORKEY* LPDDCOLORKEY;
 
 struct DDSURFACEDESC {
-	DWORD dwSize;               // sizeof(DDSURFACEDESC)
-	DDSurfaceDescFlags dwFlags; // DDSD_*
+	DWORD dwSize;
+	DDSurfaceDescFlags dwFlags;
 	DWORD dwHeight;
 	DWORD dwWidth;
 	LONG lPitch;
@@ -230,6 +275,21 @@ struct DDSURFACEDESC {
 };
 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;
 struct IDirectDrawPalette : virtual public IUnknown {
 	virtual HRESULT GetCaps(LPDWORD lpdwCaps) = 0;
@@ -252,7 +312,7 @@ struct IDirectDrawSurface : virtual public IUnknown {
 		LPRECT lpDestRect,
 		LPDIRECTDRAWSURFACE lpDDSrcSurface,
 		LPRECT lpSrcRect,
-		DWORD dwFlags,
+		DDBltFlags dwFlags,
 		LPDDBLTFX lpDDBltFx
 	) = 0;
 	virtual HRESULT BltFast(
@@ -260,10 +320,10 @@ struct IDirectDrawSurface : virtual public IUnknown {
 		DWORD dwY,
 		LPDIRECTDRAWSURFACE lpDDSrcSurface,
 		LPRECT lpSrcRect,
-		DWORD dwTrans
+		DDBltFastFlags dwTrans
 	) = 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 GetCaps(LPDDSCAPS lpDDSCaps) = 0;
 	virtual HRESULT GetDC(HDC* lphDC) = 0;
@@ -273,11 +333,11 @@ struct IDirectDrawSurface : virtual public IUnknown {
 	virtual HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) = 0;
 	virtual HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) = 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 Restore() = 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 Unlock(LPVOID lpSurfaceData) = 0;
 };
@@ -316,7 +376,7 @@ struct IDirectDraw : virtual public IUnknown {
 	virtual HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) = 0;
 	virtual HRESULT Initialize(GUID* lpGUID) = 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;
 };
 
@@ -329,3 +389,23 @@ HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOute
 
 typedef BOOL (*LPDDENUMCALLBACKA)(GUID*, LPSTR, LPSTR, LPVOID);
 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;
+}
diff --git a/miniwin/miniwin/src/miniwin_ddraw.cpp b/miniwin/miniwin/src/miniwin_ddraw.cpp
index 9b12fa6b..20c849b8 100644
--- a/miniwin/miniwin/src/miniwin_ddraw.cpp
+++ b/miniwin/miniwin/src/miniwin_ddraw.cpp
@@ -22,18 +22,19 @@ struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
 		LPRECT lpDestRect,
 		LPDIRECTDRAWSURFACE lpDDSrcSurface,
 		LPRECT lpSrcRect,
-		DWORD dwFlags,
+		DDBltFlags dwFlags,
 		LPDDBLTFX lpDDBltFx
 	) override
 	{
 		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;
 	}
 	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
 	{
 		return DDERR_GENERIC;
@@ -51,14 +52,14 @@ struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
 	HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) override { return DD_OK; }
 	HRESULT Initialize(LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc) 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;
 	}
 	HRESULT ReleaseDC(HDC hDC) override { return DD_OK; }
 	HRESULT Restore() 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 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 Initialize(GUID* lpGUID) 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; }
 	// IDirect3D2 interface
 	HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override
diff --git a/util/compat.h b/util/compat.h
index 9b0fd541..d3abca3e 100644
--- a/util/compat.h
+++ b/util/compat.h
@@ -10,8 +10,11 @@
 #ifndef MINIWIN
 #define D3DCOLOR_NONE 0
 #define D3DRMMAP_NONE 0
+#define PC_NONE 0
+#define DDBLT_NONE 0
 #define D3DRMRENDERMODE DWORD
 #define DDSCapsFlags DWORD
+#define DDBitDepths DWORD
 #endif
 
 // Disable "identifier was truncated to '255' characters" warning.