diff --git a/.gitignore b/.gitignore index 402fb660..8768f944 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ Debug/ Release/ *.ncb +/.vs ISLE.EXE LEGO1.DLL build/ diff --git a/LEGO1/decomp.h b/LEGO1/decomp.h index 5466e6d8..cd179ae6 100644 --- a/LEGO1/decomp.h +++ b/LEGO1/decomp.h @@ -4,6 +4,10 @@ #define DECOMP_STATIC_ASSERT(V) namespace { typedef int foo[(V)?1:-1]; } #define DECOMP_SIZE_ASSERT(T, S) DECOMP_STATIC_ASSERT(sizeof(T) == S) +#ifndef _countof +#define _countof(arr) sizeof(arr) / sizeof(arr[0]) +#endif + typedef unsigned char undefined; typedef unsigned short undefined2; typedef unsigned int undefined4; diff --git a/LEGO1/mxdirect3d.cpp b/LEGO1/mxdirect3d.cpp new file mode 100644 index 00000000..e69de29b diff --git a/LEGO1/mxdirect3d.h b/LEGO1/mxdirect3d.h new file mode 100644 index 00000000..e69de29b diff --git a/LEGO1/mxdirectdraw.cpp b/LEGO1/mxdirectdraw.cpp index dde59ba0..dbe07d12 100644 --- a/LEGO1/mxdirectdraw.cpp +++ b/LEGO1/mxdirectdraw.cpp @@ -1,22 +1,1223 @@ -#include "mxdirectdraw.h" -// OFFSET: LEGO1 0x1009e7f0 -int MxDirectDraw::FlipToGDISurface() +#include "mxdirectdraw.h" +#include "decomp.h" + + +#ifndef DDSCAPS_3DDEVICE +#define DDSCAPS_3DDEVICE 0x00002000l +#endif + +// GLOBAL OFFSET: LEGO1 0x10100C68 +extern BOOL g_is_PALETTEINDEXED8 = 0; + +// OFFSET: LEGO1 0x1009DA20 +void EnableResizing(HWND hwnd, BOOL flag) { - // TODO - return 0; + static DWORD dwStyle; + + if (!flag) + { + dwStyle = GetWindowLong(hwnd, GWL_STYLE); + if (dwStyle & WS_THICKFRAME) + { + SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) ^ WS_THICKFRAME); + } + } + else + { + SetWindowLong(hwnd, GWL_STYLE, dwStyle); + } +} + +// OFFSET: LEGO1 0x1009EFD0 +MxDirectDraw::DeviceModesInfo::~DeviceModesInfo() +{ + if (p_guid != NULL) + { + delete p_guid; + } + + if (m_mode_ARRAY != NULL) + { + delete m_mode_ARRAY; + } +} + +// OFFSET: LEGO1 0x1009D490 +MxDirectDraw::MxDirectDraw() +{ + m_pFrontBuffer = NULL; + m_pBackBuffer = NULL; + m_pZBuffer = NULL; + m_pClipper = NULL; + m_pPalette = NULL; + m_pDirectDraw = NULL; + m_pText1Surface = NULL; + m_pText2Surface = NULL; + m_hWndMain = NULL; + m_bIgnoreWM_SIZE = FALSE; + m_bPrimaryPalettized = FALSE; + m_bOnlySystemMemory = FALSE; + m_bFullScreen = FALSE; + m_bOnlySoftRender = FALSE; + m_pauseCount = 0; + m_pErrorHandler = NULL; + m_pFatalErrorHandler = NULL; + m_pErrorHandlerArg = NULL; + m_pFatalErrorHandlerArg = NULL; + m_pCurrentDeviceModesList = NULL; + m_bIsOnPrimaryDevice = TRUE; + m_hFont = NULL; +} + +// OFFSET: LEGO1 0x1009D530 +MxDirectDraw::~MxDirectDraw() +{ + Destroy(); + + if (m_pCurrentDeviceModesList != NULL) + { + delete m_pCurrentDeviceModesList; + m_pCurrentDeviceModesList = NULL; + } } // OFFSET: LEGO1 0x1009d570 int MxDirectDraw::GetPrimaryBitDepth() { - // TODO - return 0; + DWORD dwRGBBitCount; + LPDIRECTDRAW pDDraw; + DDSURFACEDESC ddsd; + + HRESULT result = DirectDrawCreate(NULL, &pDDraw, NULL); + dwRGBBitCount = 8; + if (!result) + { + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + + pDDraw->GetDisplayMode(&ddsd); + dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount; + g_is_PALETTEINDEXED8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) != 0; + pDDraw->Release(); +} + + return dwRGBBitCount; +} + +// OFFSET: LEGO1 0x1009D5E0 +BOOL MxDirectDraw::Create( + HWND hWnd, + BOOL fullscreen_1, + BOOL surface_fullscreen, + BOOL onlySystemMemory, + int width, + int height, + int bpp, + const PALETTEENTRY* pPaletteEntries, + int paletteEntryCount) +{ + m_hWndMain = hWnd; + + CacheOriginalPaletteEntries(); + + if (!RecreateDirectDraw(&m_pCurrentDeviceModesList->p_guid)) + { + return FALSE; + } + + m_bFlipSurfaces = surface_fullscreen; + m_bOnlySystemMemory = onlySystemMemory; + m_bIsOnPrimaryDevice = !m_pCurrentDeviceModesList->p_guid; + BOOL fullscreen = 1; + + if (m_bIsOnPrimaryDevice) + { + fullscreen = fullscreen_1; + } + + if (!SetPaletteEntries(pPaletteEntries, paletteEntryCount, fullscreen)) + { + return FALSE; + } + + if (!DDInit(fullscreen)) + { + return FALSE; + } + + if (!DDSetMode(width, height, bpp)) + { + return FALSE; + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009D800 +void MxDirectDraw::Destroy() +{ + DestroyButNotDirectDraw(); + + FUN_1009D920(); + + if (m_pDirectDraw != NULL) + { + m_pDirectDraw->Release(); + m_pDirectDraw = NULL; + } + + m_bIsOnPrimaryDevice = TRUE; + + if (m_pCurrentDeviceModesList != NULL) + { + delete m_pCurrentDeviceModesList; + m_pCurrentDeviceModesList = NULL; + } +} + +// OFFSET: LEGO1 0x1009D860 +void MxDirectDraw::DestroyButNotDirectDraw() +{ + RestoreOriginalPaletteEntries(); + if (m_bFullScreen) + { + if (m_pDirectDraw != NULL) + { + m_bIgnoreWM_SIZE = TRUE; + m_pDirectDraw->RestoreDisplayMode(); + m_bIgnoreWM_SIZE = FALSE; + } + } + + if (m_pPalette) + { + m_pPalette->Release(); + m_pPalette = NULL; + } + + if (m_pClipper) + { + m_pClipper->Release(); + m_pClipper = NULL; + } + + if (m_pText1Surface) + { + m_pText1Surface->Release(); + m_pText1Surface = NULL; + } + + if (m_pText2Surface) + { + m_pText2Surface->Release(); + m_pText2Surface = NULL; + } + + if (m_pZBuffer) + { + m_pZBuffer->Release(); + m_pZBuffer = NULL; + } + + if (m_pBackBuffer) + { + m_pBackBuffer->Release(); + m_pBackBuffer = NULL; + } + + if (m_pFrontBuffer) + { + m_pFrontBuffer->Release(); + m_pFrontBuffer = NULL; + } } // OFFSET: LEGO1 0x1009e6a0 -int MxDirectDraw::Pause(int) +int MxDirectDraw::Pause(int p_increment) { - // TODO - return 0; + if (p_increment) + { + m_pauseCount++; + + if (m_pauseCount > 1) + { + return TRUE; + } + + if (!RestoreOriginalPaletteEntries()) + { + return FALSE; + } + + if (m_bFullScreen) + { + if (!FlipToGDISurface()) + { + return FALSE; + } + + DrawMenuBar(m_hWndMain); + RedrawWindow(m_hWndMain, NULL, NULL, RDW_FRAME); + } + } + else + { + m_pauseCount--; + if (m_pauseCount > 0) + { + return TRUE; + } + else if (m_pauseCount < 0) + { + m_pauseCount = 0; + } + + if (!RestorePaletteEntries()) + { + return FALSE; + } + } + + return TRUE; } + +// OFFSET: LEGO1 0x1009E880 +const char* MxDirectDraw::ErrorToString(HRESULT error) +{ + switch(error) { + case DD_OK: + return "No error.\0"; + case DDERR_ALREADYINITIALIZED: + return "This object is already initialized.\0"; + case DDERR_BLTFASTCANTCLIP: + return "Return if a clipper object is attached to the source surface passed into a BltFast call.\0"; + case DDERR_CANNOTATTACHSURFACE: + return "This surface can not be attached to the requested surface.\0"; + case DDERR_CANNOTDETACHSURFACE: + return "This surface can not be detached from the requested surface.\0"; + case DDERR_CANTCREATEDC: + return "Windows can not create any more DCs.\0"; + case DDERR_CANTDUPLICATE: + return "Can't duplicate primary & 3D surfaces, or surfaces that are implicitly created.\0"; + case DDERR_CLIPPERISUSINGHWND: + return "An attempt was made to set a cliplist for a clipper object that is already monitoring an hwnd.\0"; + case DDERR_COLORKEYNOTSET: + return "No src color key specified for this operation.\0"; + case DDERR_CURRENTLYNOTAVAIL: + return "Support is currently not available.\0"; + case DDERR_DIRECTDRAWALREADYCREATED: + return "A DirectDraw object representing this driver has already been created for this process.\0"; + case DDERR_EXCEPTION: + return "An exception was encountered while performing the requested operation.\0"; + case DDERR_EXCLUSIVEMODEALREADYSET: + return "An attempt was made to set the cooperative level when it was already set to exclusive.\0"; + case DDERR_GENERIC: + return "Generic failure.\0"; + case DDERR_HEIGHTALIGN: + return "Height of rectangle provided is not a multiple of reqd alignment.\0"; + case DDERR_HWNDALREADYSET: + return "The CooperativeLevel HWND has already been set. It can not be reset while the process has surfaces or palettes created.\0"; + case DDERR_HWNDSUBCLASSED: + return "HWND used by DirectDraw CooperativeLevel has been subclassed, this prevents DirectDraw from restoring state.\0"; + case DDERR_IMPLICITLYCREATED: + return "This surface can not be restored because it is an implicitly created surface.\0"; + case DDERR_INCOMPATIBLEPRIMARY: + return "Unable to match primary surface creation request with existing primary surface.\0"; + case DDERR_INVALIDCAPS: + return "One or more of the caps bits passed to the callback are incorrect.\0"; + case DDERR_INVALIDCLIPLIST: + return "DirectDraw does not support the provided cliplist.\0"; + case DDERR_INVALIDDIRECTDRAWGUID: + return "The GUID passed to DirectDrawCreate is not a valid DirectDraw driver identifier.\0"; + case DDERR_INVALIDMODE: + return "DirectDraw does not support the requested mode.\0"; + case DDERR_INVALIDOBJECT: + return "DirectDraw received a pointer that was an invalid DIRECTDRAW object.\0"; + case DDERR_INVALIDPARAMS: + return "One or more of the parameters passed to the function are incorrect.\0"; + case DDERR_INVALIDPIXELFORMAT: + return "The pixel format was invalid as specified.\0"; + case DDERR_INVALIDPOSITION: + return "Returned when the position of the overlay on the destination is no longer legal for that destination.\0"; + case DDERR_INVALIDRECT: + return "Rectangle provided was invalid.\0"; + case DDERR_LOCKEDSURFACES: + return "Operation could not be carried out because one or more surfaces are locked.\0"; + case DDERR_NO3D: + return "There is no 3D present.\0"; + case DDERR_NOALPHAHW: + return "Operation could not be carried out because there is no alpha accleration hardware present or available.\0"; + case DDERR_NOBLTHW: + return "No blitter hardware present.\0"; + case DDERR_NOCLIPLIST: + return "No cliplist available.\0"; + case DDERR_NOCLIPPERATTACHED: + return "No clipper object attached to surface object.\0"; + case DDERR_NOCOLORCONVHW: + return "Operation could not be carried out because there is no color conversion hardware present or available.\0"; + case DDERR_NOCOLORKEY: + return "Surface doesn't currently have a color key\0"; + case DDERR_NOCOLORKEYHW: + return "Operation could not be carried out because there is no hardware support of the destination color key.\0"; + case DDERR_NOCOOPERATIVELEVELSET: + return "Create function called without DirectDraw object method SetCooperativeLevel being called.\0"; + case DDERR_NODC: + return "No DC was ever created for this surface.\0"; + case DDERR_NODDROPSHW: + return "No DirectDraw ROP hardware.\0"; + case DDERR_NODIRECTDRAWHW: + return "A hardware-only DirectDraw object creation was attempted but the driver did not support any hardware.\0"; + case DDERR_NOEMULATION: + return "Software emulation not available.\0"; + case DDERR_NOEXCLUSIVEMODE: + return "Operation requires the application to have exclusive mode but the application does not have exclusive mode.\0"; + case DDERR_NOFLIPHW: + return "Flipping visible surfaces is not supported.\0"; + case DDERR_NOGDI: + return "There is no GDI present.\0"; + case DDERR_NOHWND: + return "Clipper notification requires an HWND or no HWND has previously been set as the CooperativeLevel HWND.\0"; + case DDERR_NOMIRRORHW: + return "Operation could not be carried out because there is no hardware present or available.\0"; + case DDERR_NOOVERLAYDEST: + return "Returned when GetOverlayPosition is called on an overlay that UpdateOverlay has never been called on to establish a destination.\0"; + case DDERR_NOOVERLAYHW: + return "Operation could not be carried out because there is no overlay hardware present or available.\0"; + case DDERR_NOPALETTEATTACHED: + return "No palette object attached to this surface.\0"; + case DDERR_NOPALETTEHW: + return "No hardware support for 16 or 256 color palettes.\0"; + case DDERR_NORASTEROPHW: + return "Operation could not be carried out because there is no appropriate raster op hardware present or available.\0"; + case DDERR_NOROTATIONHW: + return "Operation could not be carried out because there is no rotation hardware present or available.\0"; + case DDERR_NOSTRETCHHW: + return "Operation could not be carried out because there is no hardware support for stretching.\0"; + case DDERR_NOT4BITCOLOR: + return "DirectDrawSurface is not in 4 bit color palette and the requested operation requires 4 bit color palette.\0"; + case DDERR_NOT4BITCOLORINDEX: + return "DirectDrawSurface is not in 4 bit color index palette and the requested operation requires 4 bit color index palette.\0"; + case DDERR_NOT8BITCOLOR: + return "DirectDrawSurface is not in 8 bit color mode and the requested operation requires 8 bit color.\0"; + case DDERR_NOTAOVERLAYSURFACE: + return "Returned when an overlay member is called for a non-overlay surface.\0"; + case DDERR_NOTEXTUREHW: + return "Operation could not be carried out because there is no texture mapping hardware present or available.\0"; + case DDERR_NOTFLIPPABLE: + return "An attempt has been made to flip a surface that is not flippable.\0"; + case DDERR_NOTFOUND: + return "Requested item was not found.\0"; + case DDERR_NOTLOCKED: + return "Surface was not locked. An attempt to unlock a surface that was not locked at all, or by this process, has been attempted.\0"; + case DDERR_NOTPALETTIZED: + return "The surface being used is not a palette-based surface.\0"; + case DDERR_NOVSYNCHW: + return "Operation could not be carried out because there is no hardware support for vertical blank synchronized operations.\0"; + case DDERR_NOZBUFFERHW: + return "Operation could not be carried out because there is no hardware support for zbuffer blitting.\0"; + case DDERR_NOZOVERLAYHW: + return "Overlay surfaces could not be z layered based on their BltOrder because the hardware does not support z layering of overlays.\0"; + case DDERR_OUTOFCAPS: + return "The hardware needed for the requested operation has already been allocated.\0"; + case DDERR_OUTOFMEMORY: + return "DirectDraw does not have enough memory to perform the operation.\0"; + case DDERR_OUTOFVIDEOMEMORY: + return "DirectDraw does not have enough memory to perform the operation.\0"; + case DDERR_OVERLAYCANTCLIP: + return "The hardware does not support clipped overlays.\0"; + case DDERR_OVERLAYCOLORKEYONLYONEACTIVE: + return "Can only have ony color key active at one time for overlays.\0"; + case DDERR_OVERLAYNOTVISIBLE: + return "Returned when GetOverlayPosition is called on a hidden overlay.\0"; + case DDERR_PALETTEBUSY: + return "Access to this palette is being refused because the palette is already locked by another thread.\0"; + case DDERR_PRIMARYSURFACEALREADYEXISTS: + return "This process already has created a primary surface.\0"; + case DDERR_REGIONTOOSMALL: + return "Region passed to Clipper::GetClipList is too small.\0"; + case DDERR_SURFACEALREADYATTACHED: + return "This surface is already attached to the surface it is being attached to.\0"; + case DDERR_SURFACEALREADYDEPENDENT: + return "This surface is already a dependency of the surface it is being made a dependency of.\0"; + case DDERR_SURFACEBUSY: + return "Access to this surface is being refused because the surface is already locked by another thread.\0"; + case DDERR_SURFACEISOBSCURED: + return "Access to surface refused because the surface is obscured.\0"; + case DDERR_SURFACELOST: + return "Access to this surface is being refused because the surface memory is gone. The DirectDrawSurface object representing this surface should have Restore called on it.\0"; + case DDERR_SURFACENOTATTACHED: + return "The requested surface is not attached.\0"; + case DDERR_TOOBIGHEIGHT: + return "Height requested by DirectDraw is too large.\0"; + case DDERR_TOOBIGSIZE: + return "Size requested by DirectDraw is too large, but the individual height and width are OK.\0"; + case DDERR_TOOBIGWIDTH: + return "Width requested by DirectDraw is too large.\0"; + case DDERR_UNSUPPORTED: + return "Action not supported.\0"; + case DDERR_UNSUPPORTEDFORMAT: + return "FOURCC format requested is unsupported by DirectDraw.\0"; + case DDERR_UNSUPPORTEDMASK: + return "Bitmask in the pixel format requested is unsupported by DirectDraw.\0"; + case DDERR_VERTICALBLANKINPROGRESS: + return "Vertical blank is in progress.\0"; + case DDERR_WASSTILLDRAWING: + return "Informs DirectDraw that the previous Blt which is transfering information to or from this Surface is incomplete.\0"; + case DDERR_WRONGMODE: + return "This surface can not be restored because it was created in a different mode.\0"; + case DDERR_XALIGN: + return "Rectangle provided was not horizontally aligned on required boundary.\0"; + default: + return "Unrecognized error value.\0"; + } +} + + +// OFFSET: LEGO1 0x1009D6C0 +BOOL MxDirectDraw::CacheOriginalPaletteEntries() +{ + HDC DC; + + if (g_is_PALETTEINDEXED8) + { + DC = GetDC(0); + GetSystemPaletteEntries(DC, 0, _countof(m_originalPaletteEntries), m_originalPaletteEntries); + ReleaseDC(0, DC); + } + return TRUE; +} + + +// OFFSET: LEGO1 0x1009DD80 +HRESULT MxDirectDraw::CreateDDSurface( + LPDDSURFACEDESC a2, + LPDIRECTDRAWSURFACE* a3, + IUnknown* a4) +{ + return m_pDirectDraw->CreateSurface(a2, a3, a4); +} + +// OFFSET: LEGO1 0x1009E250 +BOOL MxDirectDraw::CreateTextSurfaces() +{ + HRESULT result; + DDCOLORKEY ddck; + DDSURFACEDESC ddsd; + HDC DC; + char dummyinfo[] = "000x000x00 (RAMP) 0000"; + char dummyfps[] = "000.00 fps (000.00 fps (000.00 fps) 00000 tps)"; + + if (m_hFont != NULL) + { + DeleteObject(m_hFont); + } + + m_hFont = CreateFontA(m_currentMode.width <= 600 ? 12 : 24, + 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, + ANSI_CHARSET, + OUT_DEFAULT_PRECIS, + CLIP_DEFAULT_PRECIS, + DEFAULT_QUALITY, + VARIABLE_PITCH, + "Arial"); + + DC = GetDC(NULL); + SelectObject(DC, m_hFont); + GetTextExtentPointA(DC, dummyfps, strlen(dummyfps), &m_text1SizeOnSurface); + GetTextExtentPointA(DC, dummyinfo, strlen(dummyinfo), &m_text2SizeOnSurface); + ReleaseDC(NULL, DC); + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; + if (m_bOnlySystemMemory) + ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN; + ddsd.dwHeight = m_text1SizeOnSurface.cy; + ddsd.dwWidth = m_text1SizeOnSurface.cx; + + result = CreateDDSurface(&ddsd, &m_pText1Surface, 0); + if (result != DD_OK) + { + Error("CreateSurface for text surface 1 failed", result); + return FALSE; + } + + memset(&ddck, 0, sizeof(ddck)); + m_pText1Surface->SetColorKey(DDCKEY_SRCBLT, &ddck); + if (!TextToTextSurface1(dummyfps)) + { + return FALSE; + } + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; + if (m_bOnlySystemMemory) + ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN; + ddsd.dwHeight = m_text2SizeOnSurface.cy; + ddsd.dwWidth = m_text2SizeOnSurface.cx; + + result = CreateDDSurface(&ddsd, &m_pText2Surface, 0); + if (result != DD_OK) + { + Error("CreateSurface for text surface 2 failed", result); + return FALSE; + } + + memset(&ddck, 0, sizeof(ddck)); + m_pText2Surface->SetColorKey(DDCKEY_SRCBLT, &ddck); + if (!TextToTextSurface2(dummyinfo)) + { + return FALSE; + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009E5E0 +BOOL MxDirectDraw::CreateZBuffer(DWORD memorytype, DWORD depth) +{ + HRESULT result; // eax + LPDIRECTDRAWSURFACE lpZBuffer; // [esp+8h] [ebp-70h] BYREF + DDSURFACEDESC ddsd; + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwHeight = m_currentMode.height; + ddsd.dwWidth = m_currentMode.width; + ddsd.dwZBufferBitDepth = depth; + ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_ZBUFFERBITDEPTH; + ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | memorytype; + + result = CreateDDSurface(&ddsd, &lpZBuffer, 0); + if (result != DD_OK) + { + Error("CreateSurface for fullScreen Z-buffer failed", result); + return FALSE; + } + + result = m_pBackBuffer->AddAttachedSurface(lpZBuffer); + if (result != DD_OK) + { + Error("AddAttachedBuffer failed for Z-Buffer", result); + return FALSE; + } + + m_pZBuffer = lpZBuffer; + return TRUE; +} + +// OFFSET: LEGO1 0x1009DDF0 +BOOL MxDirectDraw::DDCreateSurfaces() +{ + HRESULT result; + DDSCAPS ddscaps; + DDSURFACEDESC ddsd; + + if (m_bFlipSurfaces) + { + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX; + if (m_bOnlySystemMemory) + { + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX | DDSCAPS_SYSTEMMEMORY; + } + ddsd.dwBackBufferCount = 1; + result = CreateDDSurface(&ddsd, &m_pFrontBuffer, 0); + if (result != DD_OK) + { + Error("CreateSurface for front/back fullScreen buffer failed", result); + return FALSE; + } + + ddscaps.dwCaps = DDSCAPS_BACKBUFFER; + result = m_pFrontBuffer->GetAttachedSurface(&ddscaps, &m_pBackBuffer); + if (result != DD_OK) + { + Error("GetAttachedSurface failed to get back buffer", result); + return FALSE; + } + if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer)) + { + return FALSE; + } + } + else + { + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS; + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; + result = CreateDDSurface(&ddsd, &m_pFrontBuffer, NULL); + if (result != DD_OK) + { + Error("CreateSurface for window front buffer failed", result); + return FALSE; + } + ddsd.dwHeight = m_currentMode.height; + ddsd.dwWidth = m_currentMode.width; + ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE; + if (m_bOnlySystemMemory) + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_SYSTEMMEMORY; + result = CreateDDSurface(&ddsd, &m_pBackBuffer, NULL); + if (result != DD_OK) + { + Error("CreateSurface for window back buffer failed", result); + return FALSE; + } + + if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer)) + { + return FALSE; + } + + result = m_pDirectDraw->CreateClipper(0, &m_pClipper, NULL); + if (result != DD_OK) + { + Error("CreateClipper failed", result); + return FALSE; + } + result = m_pClipper->SetHWnd(0, m_hWndMain); + if (result != DD_OK) + { + Error("Clipper SetHWnd failed", result); + return FALSE; + } + result = m_pFrontBuffer->SetClipper(m_pClipper); + if (result != DD_OK) + { + Error("SetClipper failed", result); + return FALSE; + } + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009D960 +BOOL MxDirectDraw::DDInit(BOOL fullscreen) +{ + HRESULT result; + + if (fullscreen) + { + m_bIgnoreWM_SIZE = 1; + result = m_pDirectDraw->SetCooperativeLevel(m_hWndMain, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); + m_bIgnoreWM_SIZE = 0; + } + else + { + result = m_pDirectDraw->SetCooperativeLevel(m_hWndMain, DDSCL_NORMAL); + } + + if (result != DD_OK) + { + Error("SetCooperativeLevel failed", result); + return FALSE; + } + + m_bFullScreen = fullscreen; + + return TRUE; +} + +// OFFSET: LEGO1 0x1009DA80 +BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp) +{ + HRESULT result; + + if (m_bFullScreen) + { + LPDIRECTDRAW lpDD; + + EnableResizing(m_hWndMain, FALSE); + + if (!m_bIsOnPrimaryDevice) + { + lpDD = NULL; + result = DirectDrawCreate(0, &lpDD, 0); + if (result == DD_OK) + { + result = lpDD->SetCooperativeLevel(m_hWndMain, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT); + if (result == DD_OK) + { + lpDD->SetDisplayMode(width, height, 8); + } + } + } + + if (!IsSupportedMode(width, height, bpp)) + { + width = m_pCurrentDeviceModesList->m_mode_ARRAY[0].width; + height = m_pCurrentDeviceModesList->m_mode_ARRAY[0].height; + bpp = m_pCurrentDeviceModesList->m_mode_ARRAY[0].bitsPerPixel; + } + + m_bIgnoreWM_SIZE = TRUE; + result = m_pDirectDraw->SetDisplayMode(width, height, bpp); + m_bIgnoreWM_SIZE = FALSE; + if (result != DD_OK) + { + Error("SetDisplayMode failed", result); + return FALSE; + } + } + else + { + RECT rc; + DWORD dwStyle; + + if (!m_bIsOnPrimaryDevice) + { + Error("Attempt made enter a windowed mode on a DirectDraw device that is not the primary display", E_FAIL); + return FALSE; + } + + m_bIgnoreWM_SIZE = TRUE; + dwStyle = GetWindowLong(m_hWndMain, GWL_STYLE); + dwStyle &= ~(WS_POPUP | WS_CAPTION | WS_THICKFRAME | WS_OVERLAPPED); + dwStyle |= WS_CAPTION | WS_THICKFRAME | WS_OVERLAPPED; + SetWindowLong(m_hWndMain, GWL_STYLE, dwStyle); + + SetRect(&rc, 0, 0, width - 1, height - 1); + AdjustWindowRectEx( + &rc, + GetWindowLong(m_hWndMain, GWL_STYLE), + GetMenu(m_hWndMain) != NULL, + GetWindowLong(m_hWndMain, GWL_EXSTYLE) + ); + SetWindowPos(m_hWndMain, NULL, 0, 0, rc.right - rc.left + 1, rc.bottom - rc.top + 1, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); + SetWindowPos(m_hWndMain, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); + m_bIgnoreWM_SIZE = FALSE; + } + + m_currentMode.width = width; + m_currentMode.height = height; + m_currentMode.bitsPerPixel = bpp; + + if (!DDCreateSurfaces()) + { + return FALSE; + } + + DDSURFACEDESC ddsd; + + FUN_1009E020(); + + if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer)) + { + return FALSE; + } + + if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) + { + m_bPrimaryPalettized = TRUE; + } + else + { + m_bPrimaryPalettized = FALSE; + } + + if (m_bPrimaryPalettized) + { + result = m_pDirectDraw->CreatePalette( + DDPCAPS_8BIT | DDPCAPS_ALLOW256 | DDPCAPS_INITIALIZE, //0x4c + m_paletteEntries, + &m_pPalette, + NULL); + if (result != DD_OK) + { + Error("CreatePalette failed", result); + return 0; + } + result = m_pBackBuffer->SetPalette(m_pPalette); // TODO: add FIX_BUGS define and fix this + result = m_pFrontBuffer->SetPalette(m_pPalette); + if (result != DD_OK) + { + Error("SetPalette failed", result); + return FALSE; + } + } + + // create debug text only in windowed mode? + return m_bFullScreen || CreateTextSurfaces(); +} + +// OFFSET: LEGO1 0x1009E830 +void MxDirectDraw::Error(const char* message, int error) +{ + // OFFSET: LEGO1 0x10100C70 + static BOOL isInsideError = FALSE; + if (!isInsideError) + { + isInsideError = TRUE; + Destroy(); + if (m_pErrorHandler) + { + m_pErrorHandler(message, error, m_pErrorHandlerArg); + } + isInsideError = FALSE; + } +} + +// OFFSET: LEGO1 0x1009DDA0 +BOOL MxDirectDraw::GetDDSurfaceDesc(LPDDSURFACEDESC lpDDSurfDesc, LPDIRECTDRAWSURFACE lpDDSurf) +{ + HRESULT result; + + memset(lpDDSurfDesc, 0, sizeof(*lpDDSurfDesc)); + lpDDSurfDesc->dwSize = sizeof(*lpDDSurfDesc); + result = lpDDSurf->GetSurfaceDesc(lpDDSurfDesc); + if (result != DD_OK) + { + Error("Error getting a surface description", result); + } + + return (result == DD_OK); +} + +// OFFSET: LEGO1 0x1009D9D0 +BOOL MxDirectDraw::IsSupportedMode(int width, int height, int bpp) +{ + Mode mode = { width, height, bpp }; + + for (int i = 0; i < m_pCurrentDeviceModesList->count; i++) + { + if (m_pCurrentDeviceModesList->m_mode_ARRAY[i] == mode) + { + return TRUE; + } + } + + return FALSE; +} + +// OFFSET: LEGO1 0x1009D690 +BOOL MxDirectDraw::RecreateDirectDraw(GUID** ppGUID) +{ + if (m_pDirectDraw) + { + m_pDirectDraw->Release(); + m_pDirectDraw = NULL; + } + + return (DirectDrawCreate(*ppGUID, &m_pDirectDraw, 0) == DD_OK); +} + +// OFFSET: LEGO1 0x1009E7A0 +BOOL MxDirectDraw::RestoreOriginalPaletteEntries() +{ + HRESULT result; + + if (m_bPrimaryPalettized) + { + if (m_pPalette) + { + result = m_pPalette->SetEntries(0, 0, 256, m_originalPaletteEntries); + if (result != DD_OK) + { + Error("SetEntries failed", result); + return FALSE; + } + } + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009E750 +BOOL MxDirectDraw::RestorePaletteEntries() +{ + HRESULT result; + + if (m_bFullScreen && m_bPrimaryPalettized) + { + if (m_pPalette) + { + result = m_pPalette->SetEntries(0, 0, _countof(m_paletteEntries), m_paletteEntries); + if (result != DD_OK) + { + Error("SetEntries failed", result); + return FALSE; + } + } + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009e7f0 +int MxDirectDraw::FlipToGDISurface() +{ + HRESULT ret; + + if (m_pDirectDraw) + { + ret = m_pDirectDraw->FlipToGDISurface(); + if (ret != DD_OK) + { + Error("FlipToGDISurface failed", ret); + } + return !ret; + } + + return 1; +} + +// OFFSET: LEGO1 0x1009E4D0 +BOOL MxDirectDraw::RestoreSurfaces() +{ + HRESULT result; + + if (m_pFrontBuffer != NULL) + { + if (m_pFrontBuffer->IsLost() == DDERR_SURFACELOST) + { + result = m_pFrontBuffer->Restore(); + if (result != DD_OK) + { + Error("Restore of front buffer failed", result); + return FALSE; + } + } + } + + if (m_pBackBuffer != NULL) + { + if (m_pBackBuffer->IsLost() == DDERR_SURFACELOST) + { + result = m_pBackBuffer->Restore(); + if (result != DD_OK) + { + Error("Restore of back buffer failed", result); + return FALSE; + } + } + } + + if (m_pZBuffer != NULL) + { + if (m_pZBuffer->IsLost() == DDERR_SURFACELOST) + { + result = m_pZBuffer->Restore(); + if (result != DD_OK) + { + Error("Restore of Z-buffer failed", result); + return FALSE; + } + } + } + + if (m_pText1Surface != NULL) + { + if (m_pText1Surface->IsLost() == DDERR_SURFACELOST) + { + result = m_pText1Surface->Restore(); + if (result != DD_OK) + { + Error("Restore of text surface 1 failed", result); + return FALSE; + } + } + } + + if (m_pText2Surface != NULL) + { + if (m_pText2Surface->IsLost() == DDERR_SURFACELOST) + { + result = m_pText2Surface->Restore(); + if (result != DD_OK) + { + Error("Restore of text surface 2 failed", result); + return FALSE; + } + } + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009D700 +BOOL MxDirectDraw::SetPaletteEntries( + const PALETTEENTRY* pPaletteEntries, + int paletteEntryCount, + BOOL fullscreen) +{ + int reservedLowEntryCount = 10; + int reservedHighEntryCount = 10; + int arraySize = _countof(m_paletteEntries); + HDC hdc; + int i; + + if (g_is_PALETTEINDEXED8) + { + hdc = GetDC(NULL); + GetSystemPaletteEntries(hdc, 0, arraySize, m_paletteEntries); + ReleaseDC(NULL, hdc); + } + + for (i = 0; i < reservedLowEntryCount; i++) + { + m_paletteEntries[i].peFlags = 0x80; + } + + for (i = reservedLowEntryCount; i < 142; i++) + { + m_paletteEntries[i].peFlags = 0x44; + } + + for (i = 142; i < arraySize - reservedHighEntryCount; i++) + { + m_paletteEntries[i].peFlags = 0x84; + } + + for (i = arraySize - reservedHighEntryCount; i < arraySize; i++) + { + m_paletteEntries[i].peFlags = 0x80; + } + + if (paletteEntryCount != 0) + { + for (i = reservedLowEntryCount; + (i < paletteEntryCount) && (i < arraySize - reservedHighEntryCount); + i++) + { + m_paletteEntries[i].peRed = pPaletteEntries[i].peRed; + m_paletteEntries[i].peGreen = pPaletteEntries[i].peGreen; + m_paletteEntries[i].peBlue = pPaletteEntries[i].peBlue; + } + } + + if (m_pPalette != NULL) + { + HRESULT result; + result = m_pPalette->SetEntries(0, 0, _countof(m_paletteEntries), m_paletteEntries); + if (result != DD_OK) + { + Error("SetEntries failed", result); + return FALSE; + } + } + + return TRUE; +} + +// OFFSET: LEGO1 0x1009E110 +BOOL MxDirectDraw::TextToTextSurface( + const char* text, + IDirectDrawSurface* pSurface, + SIZE& textSizeOnSurface) +{ + HRESULT result; + HDC hdc; + RECT rc; + size_t textLength; + + if (pSurface == NULL) + { + return FALSE; + } + + result = pSurface->GetDC(&hdc); + if (result != DD_OK) + { + Error("GetDC for text surface failed", result); + return FALSE; + } + + textLength = strlen(text); + + SelectObject(hdc, m_hFont); + SetTextColor(hdc, RGB(255, 255, 0)); + SetBkColor(hdc, RGB(0, 0, 0)); + SetBkMode(hdc, OPAQUE); + GetTextExtentPoint32(hdc, text, textLength, &textSizeOnSurface); + SetRect(&rc, 0, 0, textSizeOnSurface.cx, textSizeOnSurface.cy); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, text, textLength, NULL); + pSurface->ReleaseDC(hdc); + + return TRUE; +} + +// OFFSET: LEGO1 0x1009E210 +BOOL MxDirectDraw::TextToTextSurface1(const char* text) +{ + return TextToTextSurface( + text, + m_pText1Surface, + m_text1SizeOnSurface); +} + +// OFFSET: LEGO1 0x1009E230 +BOOL MxDirectDraw::TextToTextSurface2(const char* text) +{ + return TextToTextSurface( + text, + m_pText2Surface, + m_text2SizeOnSurface); +} + +// OFFSET: LEGO1 0x1009E020 +void MxDirectDraw::FUN_1009E020() +{ + HRESULT result; + byte* line; + DDSURFACEDESC ddsd; + int j; + int count = m_bFlipSurfaces ? 2 : 1; + + for (int i = 0; i < count; i++) + { + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + + result = m_pBackBuffer->Lock(NULL, &ddsd, 1, NULL); + if (result == DDERR_SURFACELOST) + { + m_pBackBuffer->Restore(); + result = m_pBackBuffer->Lock(NULL, &ddsd, 1, NULL); + } + + if (result != DD_OK) + { + // lock failed + return; + } + + // clear backBuffer + line = (byte*)ddsd.lpSurface; + for (j = ddsd.dwHeight; j-- ;) + { + memset(line, 0, ddsd.dwWidth); + line += ddsd.lPitch; + } + + m_pBackBuffer->Unlock(ddsd.lpSurface); + + + if (m_bFlipSurfaces) + { + m_pFrontBuffer->Flip(NULL, DDFLIP_WAIT); + } + } +} + +// OFFSET: LEGO1 0x1009D920 +void MxDirectDraw::FUN_1009D920() +{ + RestoreOriginalPaletteEntries(); + if (m_pDirectDraw != NULL) + { + m_bIgnoreWM_SIZE = TRUE; + m_pDirectDraw->RestoreDisplayMode(); + m_pDirectDraw->SetCooperativeLevel(NULL, DDSCL_NORMAL); + m_bIgnoreWM_SIZE = FALSE; + } +} + diff --git a/LEGO1/mxdirectdraw.h b/LEGO1/mxdirectdraw.h index 04f73dde..2024a3ac 100644 --- a/LEGO1/mxdirectdraw.h +++ b/LEGO1/mxdirectdraw.h @@ -1,12 +1,130 @@ + #ifndef MXDIRECTDRAW_H #define MXDIRECTDRAW_H +#include +#include + +extern BOOL g_is_PALETTEINDEXED8; + +//size 0x880 class MxDirectDraw { +public: + typedef void (*ErrorHandler)(const char*, HRESULT, void*); + + //size 0x0c + struct Mode + { + int width; + int height; + int bitsPerPixel; + + int operator==(const Mode& rMode) const + { + return ((width == rMode.width) && + (height == rMode.height) && + (bitsPerPixel == rMode.bitsPerPixel)); + } + }; + + //size 0x17c + struct DeviceModesInfo + { + GUID* p_guid; + Mode* m_mode_ARRAY; + int count; + DDCAPS m_ddcaps; + void* a_178; + + ~DeviceModesInfo(); + }; + + +private: + BOOL m_bOnlySoftRender; + BOOL m_bFlipSurfaces; + IDirectDraw* m_pDirectDraw; + IDirectDrawSurface* m_pFrontBuffer; + IDirectDrawSurface* m_pBackBuffer; + IDirectDrawSurface* m_pZBuffer; + IDirectDrawSurface* m_pText1Surface; + IDirectDrawSurface* m_pText2Surface; + IDirectDrawClipper* m_pClipper; + IDirectDrawPalette* m_pPalette; + PALETTEENTRY m_paletteEntries[256]; + PALETTEENTRY m_originalPaletteEntries[256]; + SIZE m_text1SizeOnSurface; + SIZE m_text2SizeOnSurface; + HWND m_hWndMain; + HFONT m_hFont; + BOOL m_bIgnoreWM_SIZE; + BOOL m_bPrimaryPalettized; + BOOL m_bFullScreen; + void* a_850; + BOOL m_bOnlySystemMemory; + BOOL m_bIsOnPrimaryDevice; + ErrorHandler m_pErrorHandler; + ErrorHandler m_pFatalErrorHandler; + void* m_pErrorHandlerArg; + void* m_pFatalErrorHandlerArg; + int m_pauseCount; + DeviceModesInfo* m_pCurrentDeviceModesList; + Mode m_currentMode; + public: __declspec(dllexport) int FlipToGDISurface(); __declspec(dllexport) static int GetPrimaryBitDepth(); __declspec(dllexport) int Pause(int); + + MxDirectDraw(); + + virtual ~MxDirectDraw(); + virtual BOOL Create( + HWND hWnd, + BOOL fullscreen_1, + BOOL surface_fullscreen, + BOOL onlySystemMemory, + int width, + int height, + int bpp, + const PALETTEENTRY* pPaletteEntries, + int paletteEntryCount); + virtual void Destroy(); + virtual void DestroyButNotDirectDraw(); + virtual const char* ErrorToString(HRESULT error); + +private: + BOOL CacheOriginalPaletteEntries(); + HRESULT CreateDDSurface( + LPDDSURFACEDESC a2, + LPDIRECTDRAWSURFACE* a3, + IUnknown* a4); + BOOL CreateTextSurfaces(); + BOOL CreateZBuffer(DWORD memorytype, DWORD depth); + BOOL DDCreateSurfaces(); + BOOL DDInit(BOOL fullscreen); + BOOL DDSetMode(int width, int height, int bpp); + void Error(const char* message, int error); + + BOOL GetDDSurfaceDesc(LPDDSURFACEDESC lpDDSurfDesc, LPDIRECTDRAWSURFACE lpDDSurf); + BOOL IsSupportedMode(int width, int height, int bpp); + BOOL RecreateDirectDraw(GUID** a2); + BOOL RestoreOriginalPaletteEntries(); + BOOL RestorePaletteEntries(); + BOOL RestoreSurfaces(); + BOOL SetPaletteEntries( + const PALETTEENTRY* pPaletteEntries, + int paletteEntryCount, + BOOL fullscreen); + BOOL TextToTextSurface( + const char* text, + IDirectDrawSurface* pSurface, + SIZE& textSizeOnSurface); + BOOL TextToTextSurface1(const char* text); + BOOL TextToTextSurface2(const char* lpString); + void FUN_1009E020(); + void FUN_1009D920(); }; #endif // MXDIRECTDRAW_H