diff --git a/CMakeLists.txt b/CMakeLists.txt index 303e7619..b0a952a4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -87,11 +87,14 @@ endif() #if (NOT WIN32) add_library(miniwin STATIC EXCLUDE_FROM_ALL miniwin/miniwin/src/miniwin.cpp + miniwin/miniwin/src/miniwin_ddclipper.cpp + miniwin/miniwin/src/miniwin_ddpalette.cpp + miniwin/miniwin/src/miniwin_ddsurface.cpp miniwin/miniwin/src/miniwin_ddraw.cpp - miniwin/miniwin/src/miniwin_d3d.cpp miniwin/miniwin/src/miniwin_d3drm.cpp ) target_include_directories(miniwin PUBLIC "$") +target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/src/include") target_compile_definitions(miniwin PUBLIC "MINIWIN") target_link_libraries(miniwin PRIVATE SDL3::SDL3) diff --git a/miniwin/miniwin/src/include/miniwin_ddclipper_p.h b/miniwin/miniwin/src/include/miniwin_ddclipper_p.h new file mode 100644 index 00000000..0c094824 --- /dev/null +++ b/miniwin/miniwin/src/include/miniwin_ddclipper_p.h @@ -0,0 +1,14 @@ +#pragma once + +#include +#include + +class DirectDrawImpl; + +struct DirectDrawClipperImpl : public IDirectDrawClipper { + DirectDrawClipperImpl(DirectDrawImpl* lpDD); + ~DirectDrawClipperImpl() override; + + // IDirectDrawClipper interface + HRESULT SetHWnd(DWORD unnamedParam1, HWND hWnd) override; +}; diff --git a/miniwin/miniwin/src/include/miniwin_ddpalette_p.h b/miniwin/miniwin/src/include/miniwin_ddpalette_p.h new file mode 100644 index 00000000..04804431 --- /dev/null +++ b/miniwin/miniwin/src/include/miniwin_ddpalette_p.h @@ -0,0 +1,10 @@ +#pragma once + +#include "miniwin_ddraw.h" + +struct DirectDrawPaletteImpl : public IDirectDrawPalette { + DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable); + HRESULT GetCaps(LPDWORD lpdwCaps) override; + HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) override; + HRESULT SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries) override; +}; diff --git a/miniwin/miniwin/src/include/miniwin_ddraw_p.h b/miniwin/miniwin/src/include/miniwin_ddraw_p.h new file mode 100644 index 00000000..1dba2d71 --- /dev/null +++ b/miniwin/miniwin/src/include/miniwin_ddraw_p.h @@ -0,0 +1,37 @@ +#pragma once + +#include "miniwin_d3d.h" +#include "miniwin_ddraw.h" + +extern struct SDL_Renderer* renderer; + +struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 { + // IUnknown interface + HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; + // IDirectDraw interface + HRESULT CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter) override; + HRESULT + CreatePalette( + DDPixelCaps dwFlags, + LPPALETTEENTRY lpColorTable, + LPDIRECTDRAWPALETTE* lplpDDPalette, + IUnknown* pUnkOuter + ) override; + HRESULT CreateSurface(LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE* lplpDDSurface, IUnknown* pUnkOuter) + override; + HRESULT EnumDisplayModes( + DWORD dwFlags, + LPDDSURFACEDESC lpDDSurfaceDesc, + LPVOID lpContext, + LPDDENUMMODESCALLBACK lpEnumModesCallback + ) override; + HRESULT FlipToGDISurface() override; + HRESULT GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps) override; + HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) override; + HRESULT RestoreDisplayMode() override; + HRESULT SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) override; + HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) override; + // IDirect3D2 interface + HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override; + HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) override; +}; diff --git a/miniwin/miniwin/src/include/miniwin_ddsurface_p.h b/miniwin/miniwin/src/include/miniwin_ddsurface_p.h new file mode 100644 index 00000000..df8ec4a8 --- /dev/null +++ b/miniwin/miniwin/src/include/miniwin_ddsurface_p.h @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 { + DirectDrawSurfaceImpl(); + DirectDrawSurfaceImpl(int width, int height); + ~DirectDrawSurfaceImpl() override; + + // IUnknown interface + HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; + // IDirectDrawSurface interface + HRESULT AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface) override; + HRESULT Blt( + LPRECT lpDestRect, + LPDIRECTDRAWSURFACE lpDDSrcSurface, + LPRECT lpSrcRect, + DDBltFlags dwFlags, + LPDDBLTFX lpDDBltFx + ) override; + HRESULT BltFast(DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DDBltFastFlags dwTrans) + override; + HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags) override; + HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) override; + HRESULT GetCaps(LPDDSCAPS lpDDSCaps) override; + HRESULT GetDC(HDC* lphDC) override; + HRESULT GetOverlayPosition(LPLONG lplX, LPLONG lplY) override; + HRESULT GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette) override; + HRESULT GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat) override; + HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) override; + HRESULT IsLost() override; + HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DDLockFlags dwFlags, HANDLE hEvent) override; + HRESULT ReleaseDC(HDC hDC) override; + HRESULT Restore() override; + HRESULT SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) override; + HRESULT SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey) override; + HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) override; + HRESULT Unlock(LPVOID lpSurfaceData) override; + +private: + SDL_Texture* texture = nullptr; +}; diff --git a/miniwin/miniwin/src/include/miniwin_p.h b/miniwin/miniwin/src/include/miniwin_p.h new file mode 100644 index 00000000..c5fcc201 --- /dev/null +++ b/miniwin/miniwin/src/include/miniwin_p.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#define LOG_CATEGORY_MINIWIN (SDL_LOG_CATEGORY_CUSTOM) + +#define MINIWIN_TRACE(FUNCTION, MSG, ...) \ + do { \ + SDL_LogTrace(LOG_CATEGORY_MINIWIN, FUNCTION); \ + } + +#define MINIWIN_ERROR(MSG) \ + do { \ + SDL_LogError(LOG_CATEGORY_MINIWIN, "%s:%s", __func__, MSG); \ + } while (0) + +static SDL_FRect ConvertRect(const RECT* r) +{ + SDL_FRect sdlRect; + sdlRect.x = r->left; + sdlRect.y = r->top; + sdlRect.w = r->right - r->left; + sdlRect.h = r->bottom - r->top; + return sdlRect; +} diff --git a/miniwin/miniwin/src/miniwin.cpp b/miniwin/miniwin/src/miniwin.cpp index 92da13ce..7eaad90e 100644 --- a/miniwin/miniwin/src/miniwin.cpp +++ b/miniwin/miniwin/src/miniwin.cpp @@ -1,7 +1,6 @@ #include "miniwin.h" #include -#include #include ULONG IUnknown::AddRef() diff --git a/miniwin/miniwin/src/miniwin_d3d.cpp b/miniwin/miniwin/src/miniwin_d3d.cpp deleted file mode 100644 index f91143af..00000000 --- a/miniwin/miniwin/src/miniwin_d3d.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "miniwin_d3d.h" diff --git a/miniwin/miniwin/src/miniwin_d3drm.cpp b/miniwin/miniwin/src/miniwin_d3drm.cpp index 867240ad..a7fc9fd2 100644 --- a/miniwin/miniwin/src/miniwin_d3drm.cpp +++ b/miniwin/miniwin/src/miniwin_d3drm.cpp @@ -1,5 +1,7 @@ #include "miniwin_d3drm.h" +#include "miniwin_ddsurface_p.h" + #include #include diff --git a/miniwin/miniwin/src/miniwin_ddclipper.cpp b/miniwin/miniwin/src/miniwin_ddclipper.cpp new file mode 100644 index 00000000..79dfa882 --- /dev/null +++ b/miniwin/miniwin/src/miniwin_ddclipper.cpp @@ -0,0 +1,15 @@ +#include "miniwin_ddclipper_p.h" +#include "miniwin_ddraw_p.h" + +DirectDrawClipperImpl::DirectDrawClipperImpl(DirectDrawImpl* lpDD) +{ +} + +DirectDrawClipperImpl::~DirectDrawClipperImpl() +{ +} + +HRESULT DirectDrawClipperImpl::SetHWnd(DWORD unnamedParam1, HWND hWnd) +{ + return DD_OK; +} diff --git a/miniwin/miniwin/src/miniwin_ddpalette.cpp b/miniwin/miniwin/src/miniwin_ddpalette.cpp new file mode 100644 index 00000000..0615f06c --- /dev/null +++ b/miniwin/miniwin/src/miniwin_ddpalette.cpp @@ -0,0 +1,21 @@ +#include "miniwin_ddpalette_p.h" +#include "miniwin_ddraw.h" + +DirectDrawPaletteImpl::DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable) +{ +} + +HRESULT DirectDrawPaletteImpl::GetCaps(LPDWORD lpdwCaps) +{ + return DD_OK; +} + +HRESULT DirectDrawPaletteImpl::GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) +{ + return DD_OK; +} + +HRESULT DirectDrawPaletteImpl::SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries) +{ + return DD_OK; +} diff --git a/miniwin/miniwin/src/miniwin_ddraw.cpp b/miniwin/miniwin/src/miniwin_ddraw.cpp index 85036003..7d4a7c43 100644 --- a/miniwin/miniwin/src/miniwin_ddraw.cpp +++ b/miniwin/miniwin/src/miniwin_ddraw.cpp @@ -1,6 +1,10 @@ -#include "miniwin_ddraw.h" #include "miniwin_d3d.h" +#include "miniwin_ddclipper_p.h" +#include "miniwin_ddpalette_p.h" +#include "miniwin_ddraw_p.h" +#include "miniwin_ddsurface_p.h" +#include "miniwin_p.h" #include #include @@ -10,360 +14,96 @@ SDL_Renderer* renderer; -static SDL_FRect ConvertRect(const RECT* r) +HRESULT DirectDrawImpl::QueryInterface(const GUID& riid, void** ppvObject) { - SDL_FRect sdlRect; - sdlRect.x = r->left; - sdlRect.y = r->top; - sdlRect.w = r->right - r->left; - sdlRect.h = r->bottom - r->top; - return sdlRect; + if (SDL_memcmp(&riid, &IID_IDirectDraw2, sizeof(GUID)) == 0) { + this->IUnknown::AddRef(); + *ppvObject = static_cast(this); + return S_OK; + } + if (SDL_memcmp(&riid, &IID_IDirect3D2, sizeof(GUID)) == 0) { + this->IUnknown::AddRef(); + *ppvObject = static_cast(this); + return S_OK; + } + SDL_LogError(LOG_CATEGORY_MINIWIN, "DirectDrawImpl does not implement guid"); + return E_NOINTERFACE; } -struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 { - DirectDrawSurfaceImpl() {} - DirectDrawSurfaceImpl(int width, int height) - { - texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STREAMING, width, height); - if (!texture) { - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to create texture: %s", SDL_GetError()); - } - } +// IDirectDraw interface +HRESULT DirectDrawImpl::CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter) +{ + *lplpDDClipper = static_cast(new DirectDrawClipperImpl(this)); - ~DirectDrawSurfaceImpl() override - { - if (texture) { - SDL_DestroyTexture(texture); - } - } - // IUnknown interface - HRESULT QueryInterface(const GUID& riid, void** ppvObject) override - { - if (SDL_memcmp(&riid, &IID_IDirectDrawSurface3, sizeof(GUID)) == 0) { - this->IUnknown::AddRef(); - *ppvObject = static_cast(this); - return S_OK; - } - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "DirectDrawImpl does not implement guid"); - return E_NOINTERFACE; - } - // IDirectDrawSurface interface - HRESULT AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface) override { return DD_OK; } - HRESULT Blt( - LPRECT lpDestRect, - LPDIRECTDRAWSURFACE lpDDSrcSurface, - LPRECT lpSrcRect, - DDBltFlags dwFlags, - LPDDBLTFX lpDDBltFx - ) override - { - if (!renderer) { - return DDERR_GENERIC; - } - SDL_FRect srcRect = ConvertRect(lpSrcRect); - SDL_FRect dstRect = ConvertRect(lpDestRect); - SDL_RenderTexture(renderer, static_cast(lpDDSrcSurface)->texture, &srcRect, &dstRect); - SDL_RenderPresent(renderer); - return DD_OK; - } - HRESULT BltFast(DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DDBltFastFlags dwTrans) - override - { - if (!renderer) { - return DDERR_GENERIC; - } - SDL_FRect dstRect = { - (float) dwX, - (float) dwY, - (float) (lpSrcRect->right - lpSrcRect->left), - (float) (lpSrcRect->bottom - lpSrcRect->top) - }; - SDL_FRect srcRect = ConvertRect(lpSrcRect); - SDL_RenderTexture(renderer, static_cast(lpDDSrcSurface)->texture, &srcRect, &dstRect); - SDL_RenderPresent(renderer); - return DD_OK; - } - HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags) override - { - if (!renderer || !texture) { - return DDERR_GENERIC; - } - float width, height; - SDL_GetTextureSize(texture, &width, &height); - SDL_FRect rect{0, 0, width, height}; - SDL_RenderTexture(renderer, texture, &rect, &rect); - SDL_RenderPresent(renderer); - return DD_OK; - } - HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) override - { - if ((lpDDSCaps->dwCaps & DDSCAPS_BACKBUFFER) != DDSCAPS_BACKBUFFER) { - return DDERR_INVALIDPARAMS; - } - *lplpDDAttachedSurface = static_cast(this); - return DD_OK; - } - HRESULT GetCaps(LPDDSCAPS lpDDSCaps) override { return DD_OK; } - HRESULT GetDC(HDC* lphDC) override { return DD_OK; } - HRESULT GetOverlayPosition(LPLONG lplX, LPLONG lplY) override { return DD_OK; } - HRESULT GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette) override { return DDERR_GENERIC; } - HRESULT GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat) override - { - memset(lpDDPixelFormat, 0, sizeof(*lpDDPixelFormat)); - lpDDPixelFormat->dwFlags = DDPF_RGB; - return DD_OK; - } - HRESULT GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) override - { - if (!texture) { - return DDERR_GENERIC; - } - const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(texture->format); - lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; - lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; - return DD_OK; - } - HRESULT IsLost() override { return DD_OK; } - HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DDLockFlags dwFlags, HANDLE hEvent) override - { - if (!lpDDSurfaceDesc) { - return DDERR_INVALIDPARAMS; - } - if (!texture) { - return DDERR_GENERIC; - } + return DD_OK; +} - int pitch = 0; - void* pixels = nullptr; - if (SDL_LockTexture(texture, (SDL_Rect*) lpDestRect, &pixels, &pitch) < 0) { - return DDERR_GENERIC; - } +HRESULT DirectDrawImpl::CreatePalette( + DDPixelCaps dwFlags, + LPPALETTEENTRY lpColorTable, + LPDIRECTDRAWPALETTE* lplpDDPalette, + IUnknown* pUnkOuter +) +{ + *lplpDDPalette = static_cast(new DirectDrawPaletteImpl(lpColorTable)); + return DD_OK; +} - lpDDSurfaceDesc->lpSurface = pixels; - lpDDSurfaceDesc->lPitch = pitch; - const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(texture->format); - lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; - lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; - - 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(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey) override { return DD_OK; } - HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) override { return DD_OK; } - HRESULT Unlock(LPVOID lpSurfaceData) override - { - if (texture) { - SDL_UnlockTexture(texture); +HRESULT DirectDrawImpl::CreateSurface( + LPDDSURFACEDESC lpDDSurfaceDesc, + LPDIRECTDRAWSURFACE* lplpDDSurface, + IUnknown* pUnkOuter +) +{ + if ((lpDDSurfaceDesc->dwFlags & DDSD_CAPS) == DDSD_CAPS) { + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER) == DDSCAPS_ZBUFFER) { + if ((lpDDSurfaceDesc->dwFlags & DDSD_ZBUFFERBITDEPTH) != DDSD_ZBUFFERBITDEPTH) { + return DDERR_INVALIDPARAMS; + } + SDL_Log("Todo: Set %dbit Z-Buffer", lpDDSurfaceDesc->dwZBufferBitDepth); + *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl); return DD_OK; } - return DDERR_GENERIC; - } - -private: - SDL_Texture* texture = nullptr; -}; - -struct DirectDrawClipperImpl : public IDirectDrawClipper { - // IDirectDrawClipper interface - HRESULT SetHWnd(DWORD unnamedParam1, HWND hWnd) override { return DD_OK; } -}; - -struct DirectDrawPaletteImpl : public IDirectDrawPalette { - HRESULT GetCaps(LPDWORD lpdwCaps) override { return DD_OK; } - HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) override - { - return DD_OK; - } - HRESULT SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries) override - { - return DD_OK; - } -}; - -struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 { - // IUnknown interface - HRESULT QueryInterface(const GUID& riid, void** ppvObject) override - { - if (SDL_memcmp(&riid, &IID_IDirectDraw2, sizeof(GUID)) == 0) { - this->IUnknown::AddRef(); - *ppvObject = static_cast(this); - return S_OK; - } - if (SDL_memcmp(&riid, &IID_IDirect3D2, sizeof(GUID)) == 0) { - this->IUnknown::AddRef(); - *ppvObject = static_cast(this); - return S_OK; - } - SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "DirectDrawImpl does not implement guid"); - return E_NOINTERFACE; - } - // IDirecdtDraw interface - HRESULT CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter) override - { - *lplpDDClipper = static_cast(new DirectDrawClipperImpl); - - return DD_OK; - } - HRESULT CreatePalette( - DDPixelCaps dwFlags, - LPPALETTEENTRY lpColorTable, - LPDIRECTDRAWPALETTE* lplpDDPalette, - IUnknown* pUnkOuter - ) override - { - *lplpDDPalette = static_cast(new DirectDrawPaletteImpl); - return DD_OK; - } - HRESULT CreateSurface(LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE* lplpDDSurface, IUnknown* pUnkOuter) - override - { - if ((lpDDSurfaceDesc->dwFlags & DDSD_CAPS) == DDSD_CAPS) { - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER) == DDSCAPS_ZBUFFER) { - if ((lpDDSurfaceDesc->dwFlags & DDSD_ZBUFFERBITDEPTH) != DDSD_ZBUFFERBITDEPTH) { - return DDERR_INVALIDPARAMS; - } - SDL_Log("Todo: Set %dbit Z-Buffer", lpDDSurfaceDesc->dwZBufferBitDepth); - *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl); - return DD_OK; - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) == DDSCAPS_PRIMARYSURFACE) { - if ((lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT) == DDSD_BACKBUFFERCOUNT) { - SDL_Log("Todo: Switch to %d buffering", lpDDSurfaceDesc->dwBackBufferCount); - } - int width, height; - SDL_GetRenderOutputSize(renderer, &width, &height); - *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl(width, height)); - return DD_OK; - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN) == DDSCAPS_OFFSCREENPLAIN) { - SDL_Log("DDSCAPS_OFFSCREENPLAIN"); // 2D surfaces? - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) == DDSCAPS_SYSTEMMEMORY) { - SDL_Log("DDSCAPS_SYSTEMMEMORY"); // Software rendering? - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_TEXTURE) == DDSCAPS_TEXTURE) { - SDL_Log("DDSCAPS_TEXTURE"); // Texture for use in 3D - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) == DDSCAPS_3DDEVICE) { - SDL_Log("DDSCAPS_3DDEVICE"); // back buffer - } - if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) == DDSCAPS_VIDEOMEMORY) { - SDL_Log("DDSCAPS_VIDEOMEMORY"); // front / back buffer + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) == DDSCAPS_PRIMARYSURFACE) { + if ((lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT) == DDSD_BACKBUFFERCOUNT) { + SDL_Log("Todo: Switch to %d buffering", lpDDSurfaceDesc->dwBackBufferCount); } + int width, height; + SDL_GetRenderOutputSize(renderer, &width, &height); + *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl(width, height)); + return DD_OK; } - - if ((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) == DDSD_PIXELFORMAT) { - if ((lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGB) == DDPF_RGB) { - SDL_Log("DDPF_RGB"); // Use dwRGBBitCount to choose the texture format - } + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN) == DDSCAPS_OFFSCREENPLAIN) { + SDL_Log("DDSCAPS_OFFSCREENPLAIN"); // 2D surfaces? } - - if ((lpDDSurfaceDesc->dwFlags & (DDSD_WIDTH | DDSD_HEIGHT)) != (DDSD_WIDTH | DDSD_HEIGHT)) { - return DDERR_INVALIDPARAMS; + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) == DDSCAPS_SYSTEMMEMORY) { + SDL_Log("DDSCAPS_SYSTEMMEMORY"); // Software rendering? + } + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_TEXTURE) == DDSCAPS_TEXTURE) { + SDL_Log("DDSCAPS_TEXTURE"); // Texture for use in 3D + } + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) == DDSCAPS_3DDEVICE) { + SDL_Log("DDSCAPS_3DDEVICE"); // back buffer + } + if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) == DDSCAPS_VIDEOMEMORY) { + SDL_Log("DDSCAPS_VIDEOMEMORY"); // front / back buffer } - - int width = lpDDSurfaceDesc->dwWidth; - int height = lpDDSurfaceDesc->dwHeight; - *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl(width, height)); - return DD_OK; } - HRESULT EnumDisplayModes( - DWORD dwFlags, - LPDDSURFACEDESC lpDDSurfaceDesc, - LPVOID lpContext, - LPDDENUMMODESCALLBACK lpEnumModesCallback - ) override; - HRESULT FlipToGDISurface() override { return DD_OK; } - HRESULT GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps) override; - HRESULT GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) override - { - SDL_DisplayID displayID = SDL_GetPrimaryDisplay(); - if (!displayID) { - return DDERR_GENERIC; + + if ((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) == DDSD_PIXELFORMAT) { + if ((lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGB) == DDPF_RGB) { + SDL_Log("DDPF_RGB"); // Use dwRGBBitCount to choose the texture format } - - const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(displayID); - if (!mode) { - return DDERR_GENERIC; - } - - const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(mode->format); - - lpDDSurfaceDesc->dwFlags = DDSD_WIDTH | DDSD_HEIGHT; - lpDDSurfaceDesc->dwWidth = mode->w; - lpDDSurfaceDesc->dwHeight = mode->h; - lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; - lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; - lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; - - return DD_OK; } - HRESULT RestoreDisplayMode() override { return DD_OK; } - HRESULT SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) override - { - if (hWnd) { - renderer = SDL_CreateRenderer(hWnd, NULL); - } - 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 - { - *ppDirect3DDevice = new IDirect3DDevice2; - return DD_OK; - } - HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) override; -}; -HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) -{ - if (!cb) { + if ((lpDDSurfaceDesc->dwFlags & (DDSD_WIDTH | DDSD_HEIGHT)) != (DDSD_WIDTH | DDSD_HEIGHT)) { return DDERR_INVALIDPARAMS; } - int numDrivers = SDL_GetNumRenderDrivers(); - if (numDrivers <= 0) { - return DDERR_GENERIC; - } - - const char* deviceDesc = "SDL3-backed renderer"; - char* deviceDescDup = SDL_strdup(deviceDesc); - - for (int i = 0; i < numDrivers; ++i) { - const char* deviceName = SDL_GetRenderDriver(i); - if (!deviceName) { - return DDERR_GENERIC; - } - - GUID deviceGuid = {0x682656F3, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (uint8_t) i}}; - - D3DDEVICEDESC halDesc = {}; - halDesc.dcmColorModel = D3DCOLORMODEL::RGB; - halDesc.dwFlags = D3DDD_DEVICEZBUFFERBITDEPTH; - halDesc.dwDeviceZBufferBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32; - halDesc.dwDeviceRenderBitDepth = DDBD_8 | DDBD_16; - halDesc.dpcTriCaps.dwTextureCaps = D3DPTEXTURECAPS_PERSPECTIVE; - halDesc.dpcTriCaps.dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND; - halDesc.dpcTriCaps.dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR; - - char* deviceNameDup = SDL_strdup(deviceName); - cb(&deviceGuid, deviceNameDup, deviceDescDup, &halDesc, &halDesc, ctx); - SDL_free(deviceNameDup); - } - SDL_free(deviceDescDup); - - return S_OK; + int width = lpDDSurfaceDesc->dwWidth; + int height = lpDDSurfaceDesc->dwHeight; + *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl(width, height)); + return DD_OK; } HRESULT DirectDrawImpl::EnumDisplayModes( @@ -417,25 +157,137 @@ HRESULT DirectDrawImpl::EnumDisplayModes( return status; } +HRESULT DirectDrawImpl::FlipToGDISurface() +{ + return DD_OK; +} + HRESULT DirectDrawImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps) { if (lpDDDriverCaps) { - memset(lpDDDriverCaps, 0, sizeof(DDCAPS)); - lpDDDriverCaps->dwSize = sizeof(DDCAPS); - lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED; // Required to enable lighting + if (lpDDDriverCaps->dwSize >= sizeof(DDCAPS)) { + lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED; // Required to enable lighting + } } if (lpDDHELCaps) { - memset(lpDDHELCaps, 0, sizeof(DDCAPS)); - lpDDHELCaps->dwSize = sizeof(DDCAPS); - lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED; // Required to enable lighting + if (lpDDDriverCaps->dwSize >= sizeof(DDCAPS)) { + lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED; // Required to enable lighting + } } return S_OK; } +HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) +{ + if (!cb) { + return DDERR_INVALIDPARAMS; + } + + int numDrivers = SDL_GetNumRenderDrivers(); + if (numDrivers <= 0) { + return DDERR_GENERIC; + } + + const char* deviceDesc = "SDL3 SDL_Renderer"; + + for (int i = 0; i < numDrivers; ++i) { + const char* deviceName = SDL_GetRenderDriver(i); + if (!deviceName) { + return DDERR_GENERIC; + } + + GUID deviceGuid = {0x682656F3, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (uint8_t) i}}; + + D3DDEVICEDESC halDesc = {}; + halDesc.dcmColorModel = D3DCOLORMODEL::RGB; + halDesc.dwFlags = D3DDD_DEVICEZBUFFERBITDEPTH; + halDesc.dwDeviceZBufferBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32; + halDesc.dwDeviceRenderBitDepth = DDBD_8 | DDBD_16; + halDesc.dpcTriCaps.dwTextureCaps = D3DPTEXTURECAPS_PERSPECTIVE; + halDesc.dpcTriCaps.dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND; + halDesc.dpcTriCaps.dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR; + + char* deviceNameDup = SDL_strdup(deviceName); + char* deviceDescDup = SDL_strdup(deviceDesc); + cb(&deviceGuid, deviceNameDup, deviceDescDup, &halDesc, &halDesc, ctx); + SDL_free(deviceDescDup); + SDL_free(deviceNameDup); + } + + return S_OK; +} + +HRESULT DirectDrawImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc) +{ + SDL_DisplayID displayID = SDL_GetPrimaryDisplay(); + if (!displayID) { + return DDERR_GENERIC; + } + + const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(displayID); + if (!mode) { + return DDERR_GENERIC; + } + + const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(mode->format); + + lpDDSurfaceDesc->dwFlags = DDSD_WIDTH | DDSD_HEIGHT; + lpDDSurfaceDesc->dwWidth = mode->w; + lpDDSurfaceDesc->dwHeight = mode->h; + lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; + lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; + lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; + + return DD_OK; +} + +HRESULT DirectDrawImpl::RestoreDisplayMode() +{ + return DD_OK; +} + +HRESULT DirectDrawImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) +{ + if (hWnd) { + bool fullscreen; + if ((dwFlags & DDSCL_NORMAL) == DDSCL_NORMAL) { + fullscreen = false; + } + else if ((dwFlags & DDSCL_FULLSCREEN) == DDSCL_FULLSCREEN) { + fullscreen = true; + } + else { + return DDERR_INVALIDPARAMS; + } + + if (!SDL_SetWindowFullscreen(hWnd, fullscreen)) { + return DDERR_GENERIC; + } + renderer = SDL_CreateRenderer(hWnd, NULL); + } + return DD_OK; +} + +HRESULT DirectDrawImpl::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) +{ + return DD_OK; +} +// IDirect3D2 interface +HRESULT DirectDrawImpl::CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) +{ + *ppDirect3DDevice = new IDirect3DDevice2; + return DD_OK; +} + HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter) { + if (lpGuid) { + MINIWIN_ERROR("Specifying a DirectDraw driver is not implemented"); + } if (!lplpDD) { return DDERR_INVALIDPARAMS; } @@ -451,8 +303,10 @@ HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context) for (int i = 0; i < numDrivers; ++i) { const char* driverName = SDL_GetVideoDriver(i); - - if (!cb(NULL, (LPSTR) driverName, NULL, context)) { + char* driverNameDup = SDL_strdup(driverName); + BOOL callback_result = cb(NULL, driverNameDup, NULL, context); + SDL_free(driverNameDup); + if (!callback_result) { return DDERR_GENERIC; } } diff --git a/miniwin/miniwin/src/miniwin_ddsurface.cpp b/miniwin/miniwin/src/miniwin_ddsurface.cpp new file mode 100644 index 00000000..e4461d2a --- /dev/null +++ b/miniwin/miniwin/src/miniwin_ddsurface.cpp @@ -0,0 +1,216 @@ +#include "miniwin_ddraw_p.h" +#include "miniwin_ddsurface_p.h" +#include "miniwin_p.h" + +#include + +DirectDrawSurfaceImpl::DirectDrawSurfaceImpl() +{ +} + +DirectDrawSurfaceImpl::DirectDrawSurfaceImpl(int width, int height) +{ + texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STREAMING, width, height); + if (!texture) { + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to create texture: %s", SDL_GetError()); + } +} + +DirectDrawSurfaceImpl::~DirectDrawSurfaceImpl() +{ + if (texture) { + SDL_DestroyTexture(texture); + } +} + +// IUnknown interface +HRESULT DirectDrawSurfaceImpl::QueryInterface(const GUID& riid, void** ppvObject) +{ + if (SDL_memcmp(&riid, &IID_IDirectDrawSurface3, sizeof(GUID)) == 0) { + this->IUnknown::AddRef(); + *ppvObject = static_cast(this); + return S_OK; + } + SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "DirectDrawImpl does not implement guid"); + return E_NOINTERFACE; +} + +// IDirectDrawSurface interface +HRESULT DirectDrawSurfaceImpl::AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface) +{ + return DD_OK; +} +HRESULT DirectDrawSurfaceImpl::Blt( + LPRECT lpDestRect, + LPDIRECTDRAWSURFACE lpDDSrcSurface, + LPRECT lpSrcRect, + DDBltFlags dwFlags, + LPDDBLTFX lpDDBltFx +) +{ + if (!renderer) { + return DDERR_GENERIC; + } + SDL_FRect srcRect = ConvertRect(lpSrcRect); + SDL_FRect dstRect = ConvertRect(lpDestRect); + SDL_RenderTexture(renderer, static_cast(lpDDSrcSurface)->texture, &srcRect, &dstRect); + SDL_RenderPresent(renderer); + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::BltFast( + DWORD dwX, + DWORD dwY, + LPDIRECTDRAWSURFACE lpDDSrcSurface, + LPRECT lpSrcRect, + DDBltFastFlags dwTrans +) +{ + if (!renderer) { + return DDERR_GENERIC; + } + SDL_FRect dstRect = { + (float) dwX, + (float) dwY, + (float) (lpSrcRect->right - lpSrcRect->left), + (float) (lpSrcRect->bottom - lpSrcRect->top) + }; + SDL_FRect srcRect = ConvertRect(lpSrcRect); + SDL_RenderTexture(renderer, static_cast(lpDDSrcSurface)->texture, &srcRect, &dstRect); + SDL_RenderPresent(renderer); + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags) +{ + if (!renderer || !texture) { + return DDERR_GENERIC; + } + float width, height; + SDL_GetTextureSize(texture, &width, &height); + SDL_FRect rect{0, 0, width, height}; + SDL_RenderTexture(renderer, texture, &rect, &rect); + SDL_RenderPresent(renderer); + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) +{ + if ((lpDDSCaps->dwCaps & DDSCAPS_BACKBUFFER) != DDSCAPS_BACKBUFFER) { + return DDERR_INVALIDPARAMS; + } + *lplpDDAttachedSurface = static_cast(this); + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetCaps(LPDDSCAPS lpDDSCaps) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetDC(HDC* lphDC) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetOverlayPosition(LPLONG lplX, LPLONG lplY) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette) +{ + assert(false && "unimplemented"); + return DDERR_GENERIC; +} + +HRESULT DirectDrawSurfaceImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat) +{ + memset(lpDDPixelFormat, 0, sizeof(*lpDDPixelFormat)); + lpDDPixelFormat->dwFlags = DDPF_RGB; + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc) +{ + if (!texture) { + return DDERR_GENERIC; + } + const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(texture->format); + lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; + lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; + lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::IsLost() +{ + return DD_OK; +} +HRESULT DirectDrawSurfaceImpl::Lock( + LPRECT lpDestRect, + LPDDSURFACEDESC lpDDSurfaceDesc, + DDLockFlags dwFlags, + HANDLE hEvent +) +{ + if (!lpDDSurfaceDesc) { + return DDERR_INVALIDPARAMS; + } + if (!texture) { + return DDERR_GENERIC; + } + + int pitch = 0; + void* pixels = nullptr; + if (SDL_LockTexture(texture, (SDL_Rect*) lpDestRect, &pixels, &pitch) < 0) { + return DDERR_GENERIC; + } + + lpDDSurfaceDesc->lpSurface = pixels; + lpDDSurfaceDesc->lPitch = pitch; + const SDL_PixelFormatDetails* format = SDL_GetPixelFormatDetails(texture->format); + lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB; + lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = (format->bits_per_pixel == 8) ? 8 : 16; + lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = format->Rmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = format->Gmask; + lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = format->Bmask; + + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::ReleaseDC(HDC hDC) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::Restore() +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) +{ + return DD_OK; +} + +HRESULT DirectDrawSurfaceImpl::Unlock(LPVOID lpSurfaceData) +{ + if (!texture) { + return DDERR_GENERIC; + } + SDL_UnlockTexture(texture); + return DD_OK; +}