miinwin: Get to the CD check (#76)

miniwin/miniwin/include/miniwin.h

@@ -205,9 +205,14 @@ typedef GUID REFIID;
 typedef GUID* LPGUID;
 
 struct IUnknown {
-	virtual ULONG AddRef() = 0;
+	IUnknown() : m_refCount(1) {}
-	virtual ULONG Release() = 0;
+	virtual ULONG AddRef();
-	virtual HRESULT QueryInterface(const GUID& riid, void** ppvObject) = 0;
+	virtual ULONG Release();
+	virtual HRESULT QueryInterface(const GUID& riid, void** ppvObject);
+	virtual ~IUnknown() = default;
+
+private:
+	int m_refCount;
 };
 typedef struct IUnknown* LPUNKNOWN;
 

miniwin/miniwin/include/miniwin_d3d.h

@@ -35,10 +35,10 @@ struct D3DDEVICEDESC {
 };
 typedef D3DDEVICEDESC* LPD3DDEVICEDESC;
 
-struct IDirect3DDevice2 : public IUnknown {};
+struct IDirect3DDevice2 : virtual public IUnknown {};
 
 typedef HRESULT (*LPD3DENUMDEVICESCALLBACK)(LPGUID, LPSTR, LPSTR, LPD3DDEVICEDESC, LPD3DDEVICEDESC, LPVOID);
-struct IDirect3D2 : public IUnknown {
+struct IDirect3D2 : virtual public IUnknown {
 	virtual HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) = 0;
 	virtual HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) = 0;
 };

miniwin/miniwin/include/miniwin_d3drm.h

@@ -127,10 +127,10 @@ struct D3DRMVERTEX {
 	float tu, tv;
 };
 
-struct IDirect3DRMVisual : public IUnknown {};
+struct IDirect3DRMVisual : virtual public IUnknown {};
 typedef IDirect3DRMVisual* LPDIRECT3DRMVISUAL;
 
-struct IDirect3DRMObject : public IUnknown {
+struct IDirect3DRMObject : virtual public IUnknown {
 	virtual HRESULT Clone(void** ppObject) = 0;
 	virtual HRESULT AddDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) = 0;
 	virtual HRESULT DeleteDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) = 0;
@@ -140,7 +140,7 @@ struct IDirect3DRMObject : public IUnknown {
 	virtual HRESULT GetName(DWORD* size, char* name) = 0;
 	virtual HRESULT GetClassName(DWORD* size, char* name) = 0;
 };
-struct IDirect3DRMTexture : public IUnknown {
+struct IDirect3DRMTexture : virtual public IUnknown {
 	virtual HRESULT AddDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) = 0;
 	virtual LPVOID GetAppData() = 0;
 	virtual HRESULT SetAppData(LPD3DRM_APPDATA appData) = 0;
@@ -154,7 +154,7 @@ typedef IDirect3DRMTexture2* LPDIRECT3DRMTEXTURE2;
 
 typedef struct IDirect3DRMMaterial *LPDIRECT3DRMMATERIAL, **LPLPDIRECT3DRMMATERIAL;
 
-struct IDirect3DRMMesh : public IUnknown {
+struct IDirect3DRMMesh : virtual public IUnknown {
 	virtual HRESULT Clone(int flags, GUID iid, void** object) = 0;
 	virtual HRESULT GetBox(D3DRMBOX* box) = 0;
 	virtual HRESULT AddGroup(
@@ -186,22 +186,22 @@ struct IDirect3DRMMesh : public IUnknown {
 	virtual HRESULT GetVertices(int groupIndex, int startIndex, int count, D3DRMVERTEX* vertices) = 0;
 };
 
-struct IDirect3DRMLight : public IUnknown {
+struct IDirect3DRMLight : virtual public IUnknown {
 	virtual HRESULT SetColorRGB(float r, float g, float b) = 0;
 };
 
-struct IDirect3DRMLightArray : public IUnknown {
+struct IDirect3DRMLightArray : virtual public IUnknown {
 	virtual DWORD GetSize() = 0;
 	virtual HRESULT GetElement(int index, IDirect3DRMLight** light) const = 0;
 };
 
-struct IDirect3DRMVisualArray : public IUnknown {
+struct IDirect3DRMVisualArray : virtual public IUnknown {
 	virtual DWORD GetSize() = 0;
 	virtual HRESULT GetElement(int index, IDirect3DRMVisual** visual) const = 0;
 };
 
 typedef struct IDirect3DRMFrameArray* LPDIRECT3DRMFRAMEARRAY;
-struct IDirect3DRMFrame : public IUnknown {
+struct IDirect3DRMFrame : virtual public IUnknown {
 	virtual HRESULT SetAppData(LPD3DRM_APPDATA appData) = 0;
 	virtual LPVOID GetAppData() = 0;
 	virtual HRESULT AddChild(IDirect3DRMFrame* child) = 0;
@@ -231,7 +231,7 @@ typedef IDirect3DRMFrame* LPDIRECT3DRMFRAME;
 struct IDirect3DRMFrame2 : public IDirect3DRMFrame {};
 typedef IDirect3DRMFrame2* LPDIRECT3DRMFRAME2;
 
-struct IDirect3DRMFrameArray : public IUnknown {
+struct IDirect3DRMFrameArray : virtual public IUnknown {
 	virtual DWORD GetSize() = 0;
 	virtual HRESULT GetElement(DWORD index, IDirect3DRMFrame** frame) = 0;
 };
@@ -242,7 +242,7 @@ struct D3DRMPICKDESC {
 	float dist;
 };
 
-struct IDirect3DRMPickedArray : public IUnknown {
+struct IDirect3DRMPickedArray : virtual public IUnknown {
 	virtual DWORD GetSize() = 0;
 	virtual HRESULT GetPick(
 		DWORD index,
@@ -274,19 +274,19 @@ struct IDirect3DRMViewport : public IDirect3DRMObject {
 	virtual HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) = 0;
 };
 
-struct IDirect3DRMWinDevice : public IUnknown {
+struct IDirect3DRMWinDevice : virtual public IUnknown {
 	virtual HRESULT Activate() = 0;
 	virtual HRESULT Paint() = 0;
 	virtual void HandleActivate(WORD wParam) = 0;
 	virtual void HandlePaint(void* p_dc) = 0;
 };
 
-struct IDirect3DRMViewportArray : public IUnknown {
+struct IDirect3DRMViewportArray : virtual public IUnknown {
 	virtual DWORD GetSize() = 0;
 	virtual HRESULT GetElement(int index, IDirect3DRMViewport** viewport) = 0;
 };
 
-struct IDirect3DRMDevice2 : public IUnknown {
+struct IDirect3DRMDevice2 : virtual public IUnknown {
 	virtual unsigned long GetWidth() = 0;
 	virtual unsigned long GetHeight() = 0;
 	virtual HRESULT SetBufferCount(int count) = 0;
@@ -305,7 +305,7 @@ struct IDirect3DRMDevice2 : public IUnknown {
 	virtual HRESULT GetViewports(IDirect3DRMViewportArray** ppViewportArray) = 0;
 };
 
-struct IDirect3DRM : public IUnknown {
+struct IDirect3DRM : virtual public IUnknown {
 	virtual HRESULT CreateDeviceFromD3D(
 		const IDirect3D2* d3d,
 		IDirect3DDevice2* d3dDevice,

miniwin/miniwin/include/miniwin_ddraw.h

@@ -212,7 +212,7 @@ struct DDSURFACEDESC {
 typedef struct DDSURFACEDESC* LPDDSURFACEDESC;
 
 typedef struct IDirectDraw* LPDIRECTDRAW;
-struct IDirectDrawPalette : public IUnknown {
+struct IDirectDrawPalette : virtual public IUnknown {
 	virtual HRESULT GetCaps(LPDWORD lpdwCaps) = 0;
 	virtual HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) = 0;
 	virtual HRESULT Initialize(LPDIRECTDRAW lpDD, DWORD dwFlags, LPPALETTEENTRY lpDDColorTable) = 0;
@@ -220,14 +220,14 @@ struct IDirectDrawPalette : public IUnknown {
 };
 typedef struct IDirectDrawPalette* LPDIRECTDRAWPALETTE;
 
-struct IDirectDrawClipper : public IUnknown {
+struct IDirectDrawClipper : virtual public IUnknown {
 	virtual HRESULT SetHWnd(DWORD unnamedParam1, HWND hWnd) = 0;
 };
 typedef IDirectDrawClipper* LPDIRECTDRAWCLIPPER;
 
 typedef void *LPDDBLTFX, *LPDDENUMSURFACESCALLBACK;
 typedef struct IDirectDrawSurface* LPDIRECTDRAWSURFACE;
-struct IDirectDrawSurface : public IUnknown {
+struct IDirectDrawSurface : virtual public IUnknown {
 	virtual HRESULT AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface) = 0;
 	virtual HRESULT Blt(
 		LPRECT lpDestRect,
@@ -267,7 +267,7 @@ struct IDirectDrawSurface3 : public IDirectDrawSurface {};
 typedef IDirectDrawSurface3* LPDIRECTDRAWSURFACE3;
 
 typedef HRESULT (*LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
-struct IDirectDraw : public IUnknown {
+struct IDirectDraw : virtual public IUnknown {
 	virtual HRESULT CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter) = 0;
 	virtual HRESULT CreatePalette(
 		DWORD dwFlags,

miniwin/miniwin/src/miniwin.cpp

@@ -4,6 +4,27 @@
 #include <utility>
 #include <vector>
 
+ULONG IUnknown::AddRef()
+{
+	m_refCount += 1;
+	return m_refCount;
+}
+
+ULONG IUnknown::Release()
+{
+	m_refCount -= 1;
+	if (m_refCount == 0) {
+		delete this;
+		return 0;
+	}
+	return m_refCount;
+}
+
+HRESULT IUnknown::QueryInterface(const GUID& riid, void** ppvObject)
+{
+	return E_NOINTERFACE;
+}
+
 static std::vector<std::pair<SDL_Window*, HWND>> sdl_hwnd_mapping;
 
 SDL_Window* miniwin_GetSdlWindow(HWND hWnd)

miniwin/miniwin/src/miniwin_d3drm.cpp

@@ -1,8 +1,210 @@
 #include "miniwin_d3drm.h"
 
+#include <SDL3/SDL.h>
+#include <assert.h>
+
+struct Direct3DRMDevice2Impl : public IDirect3DRMDevice2 {
+	unsigned long GetWidth() override { return 640; }
+	unsigned long GetHeight() override { return 480; }
+	HRESULT SetBufferCount(int count) override { return DD_OK; }
+	HRESULT GetBufferCount() override { return DD_OK; }
+	HRESULT SetShades(unsigned long shadeCount) override { return DD_OK; }
+	HRESULT GetShades() override { return DD_OK; }
+	HRESULT SetQuality(int quality) override { return DD_OK; }
+	HRESULT GetQuality() override { return DD_OK; }
+	HRESULT SetDither(int dither) override { return DD_OK; }
+	HRESULT GetDither() override { return DD_OK; }
+	HRESULT SetTextureQuality(D3DRMTEXTUREQUALITY quality) override { return DD_OK; }
+	D3DRMTEXTUREQUALITY GetTextureQuality() override { return D3DRMTEXTURE_NEAREST; }
+	HRESULT SetRenderMode(int mode) override { return DD_OK; }
+	HRESULT GetRenderMode() override { return DD_OK; }
+	HRESULT Update() override { return DD_OK; }
+	HRESULT GetViewports(IDirect3DRMViewportArray** ppViewportArray) override { return DD_OK; }
+};
+
+struct Direct3DRMFrameImpl : public IDirect3DRMFrame2 {
+	HRESULT SetAppData(LPD3DRM_APPDATA appData) override { return DD_OK; }
+	LPVOID GetAppData() override { return 0; }
+	HRESULT AddChild(IDirect3DRMFrame* child) override
+	{
+		child->AddRef();
+		return DD_OK;
+	}
+	HRESULT DeleteChild(IDirect3DRMFrame* child) override
+	{
+		child->Release();
+		return DD_OK;
+	}
+	HRESULT SetSceneBackgroundRGB(float r, float g, float b) override { return DD_OK; }
+	HRESULT AddLight(IDirect3DRMLight* light) override
+	{
+		light->AddRef();
+		return DD_OK;
+	}
+	HRESULT GetLights(IDirect3DRMLightArray** lightArray) override { return DD_OK; }
+	HRESULT AddTransform(int combine, D3DRMMATRIX4D matrix) override { return DD_OK; }
+	HRESULT GetPosition(int index, D3DVECTOR* position) override { return DD_OK; }
+	HRESULT AddVisual(IDirect3DRMVisual* visual) override
+	{
+		visual->AddRef();
+		return DD_OK;
+	}
+	HRESULT DeleteVisual(IDirect3DRMVisual* visual) override
+	{
+		visual->Release();
+		return DD_OK;
+	}
+	HRESULT AddVisual(IDirect3DRMMesh* visual) override
+	{
+		visual->AddRef();
+		return DD_OK;
+	}
+	HRESULT DeleteVisual(IDirect3DRMMesh* visual) override
+	{
+		visual->Release();
+		return DD_OK;
+	}
+	HRESULT AddVisual(IDirect3DRMFrame* visual) override
+	{
+		visual->AddRef();
+		return DD_OK;
+	}
+	HRESULT DeleteVisual(IDirect3DRMFrame* visual) override
+	{
+		visual->Release();
+		return DD_OK;
+	}
+	HRESULT GetVisuals(IDirect3DRMVisualArray** visuals) override { return DD_OK; }
+	HRESULT SetTexture(const IDirect3DRMTexture* texture) override { return DD_OK; }
+	HRESULT GetTexture(IDirect3DRMTexture** texture) override { return DD_OK; }
+	HRESULT SetColor(float r, float g, float b, float a) override { return DD_OK; }
+	HRESULT SetColor(D3DCOLOR) override { return DD_OK; }
+	HRESULT SetColorRGB(float r, float g, float b) override { return DD_OK; }
+	HRESULT SetMaterialMode(D3DRMMATERIALMODE mode) override { return DD_OK; }
+	HRESULT GetChildren(IDirect3DRMFrameArray** children) override { return DD_OK; }
+};
+
+struct Direct3DRMViewportImpl : public IDirect3DRMViewport {
+	Direct3DRMViewportImpl() : m_data(nullptr) {}
+	HRESULT Clone(void** ppObject) override { return DD_OK; }
+	HRESULT AddDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) override { return DD_OK; }
+	HRESULT DeleteDestroyCallback(void (*cb)(IDirect3DRMObject*, void*), void* arg) override { return DD_OK; }
+	HRESULT SetAppData(LPD3DRM_APPDATA appData) override
+	{
+		m_data = appData;
+		return DD_OK;
+	}
+	LPVOID GetAppData() override { return m_data; }
+	HRESULT SetName(const char* name) override { return DD_OK; }
+	HRESULT GetName(DWORD* size, char* name) override { return DD_OK; }
+	HRESULT GetClassName(DWORD* size, char* name) override { return DD_OK; }
+	HRESULT Render(IDirect3DRMFrame* group) override { return DD_OK; }
+	HRESULT ForceUpdate(int x, int y, int w, int h) override { return DD_OK; }
+	HRESULT Clear() override { return DD_OK; }
+	HRESULT SetCamera(IDirect3DRMFrame* camera) override { return DD_OK; }
+	HRESULT GetCamera(IDirect3DRMFrame** camera) override { return DD_OK; }
+	HRESULT SetProjection(D3DRMPROJECTIONTYPE type) override { return DD_OK; }
+	D3DRMPROJECTIONTYPE GetProjection() override { return D3DRMPROJECT_PERSPECTIVE; }
+	HRESULT SetFront(D3DVALUE z) override { return DD_OK; }
+	D3DVALUE GetFront() override { return 0; }
+	HRESULT SetBack(D3DVALUE z) override { return DD_OK; }
+	D3DVALUE GetBack() override { return 0; }
+	HRESULT SetField(D3DVALUE field) override { return DD_OK; }
+	D3DVALUE GetField() override { return 0; }
+	int GetWidth() override { return 640; }
+	int GetHeight() override { return 480; }
+	HRESULT Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world) override { return DD_OK; }
+	HRESULT InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen) override { return DD_OK; }
+	HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) override { return DD_OK; }
+
+private:
+	LPD3DRM_APPDATA m_data;
+};
+
+struct Direct3DRMLightImpl : public IDirect3DRMLight {
+	HRESULT SetColorRGB(float r, float g, float b) override { return DD_OK; }
+};
+
+struct Direct3DRMImpl : public IDirect3DRM2 {
+	// IUnknown interface
+	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override
+	{
+		if (SDL_memcmp(&riid, &IID_IDirect3DRM2, sizeof(GUID)) == 0) {
+			this->IUnknown::AddRef();
+			*ppvObject = static_cast<IDirect3DRM2*>(this);
+			return S_OK;
+		}
+		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "DirectDrawImpl does not implement guid");
+		return E_NOINTERFACE;
+	}
+	// IDirect3DRM interface
+	HRESULT CreateDeviceFromD3D(const IDirect3D2* d3d, IDirect3DDevice2* d3dDevice, IDirect3DRMDevice2** outDevice)
+		override
+	{
+		*outDevice = static_cast<IDirect3DRMDevice2*>(new Direct3DRMDevice2Impl);
+		return S_OK;
+	}
+	HRESULT CreateDeviceFromSurface(
+		const GUID* guid,
+		IDirectDraw* dd,
+		IDirectDrawSurface* surface,
+		IDirect3DRMDevice2** outDevice
+	) override
+	{
+		assert(false && "unimplemented");
+		return DDERR_GENERIC;
+	}
+	HRESULT CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) override
+	{
+		assert(false && "unimplemented");
+		return DDERR_GENERIC;
+	}
+	HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) override
+	{
+		assert(false && "unimplemented");
+		return DDERR_GENERIC;
+	}
+	HRESULT CreateMesh(IDirect3DRMMesh** outMesh) override
+	{
+		assert(false && "unimplemented");
+		return DDERR_GENERIC;
+	}
+	HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) override
+	{
+		assert(false && "unimplemented");
+		return DDERR_GENERIC;
+	}
+	HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) override
+	{
+		*outLight = static_cast<IDirect3DRMLight*>(new Direct3DRMLightImpl);
+		return DD_OK;
+	}
+	HRESULT CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) override
+	{
+		*outFrame = static_cast<IDirect3DRMFrame2*>(new Direct3DRMFrameImpl);
+		return DD_OK;
+	}
+	HRESULT CreateViewport(
+		IDirect3DRMDevice2* device,
+		IDirect3DRMFrame* camera,
+		int x,
+		int y,
+		int width,
+		int height,
+		IDirect3DRMViewport** outViewport
+	) override
+	{
+		*outViewport = static_cast<IDirect3DRMViewport*>(new Direct3DRMViewportImpl);
+		return DD_OK;
+	}
+	HRESULT SetDefaultTextureShades(unsigned int count) override { return DD_OK; }
+	HRESULT SetDefaultTextureColors(unsigned int count) override { return DD_OK; }
+};
+
 HRESULT WINAPI Direct3DRMCreate(IDirect3DRM** direct3DRM)
 {
-	return DDERR_GENERIC;
+	*direct3DRM = new Direct3DRMImpl;
+	return DD_OK;
 }
 
 D3DCOLOR D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)

miniwin/miniwin/src/miniwin_ddraw.cpp

@@ -4,32 +4,81 @@
 
 #include <SDL3/SDL.h>
 
-struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
+struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
-	DirectDrawImpl() : m_refCount(1) {}
 	// IUnknown interface
-	ULONG AddRef() override
+	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override
 	{
-		m_refCount += 1;
+		if (SDL_memcmp(&riid, &IID_IDirectDrawSurface3, sizeof(GUID)) == 0) {
-		return m_refCount;
+			this->IUnknown::AddRef();
-	}
+			*ppvObject = static_cast<IDirectDrawSurface3*>(this);
-	ULONG Release() override
+			return S_OK;
-	{
-		m_refCount -= 1;
-		if (m_refCount == 0) {
-			delete this;
-			return 0;
 		}
-		return m_refCount;
+		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,
+		DWORD dwFlags,
+		LPDDBLTFX lpDDBltFx
+	) override
+	{
+		return DD_OK;
+	}
+	HRESULT BltFast(DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD 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 GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface) override
+	{
+		return DDERR_GENERIC;
+	}
+	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 { 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
+	{
+		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 SetPalette(LPDIRECTDRAWPALETTE lpDDPalette) override { return DD_OK; }
+	HRESULT Unlock(LPVOID lpSurfaceData) override { return DD_OK; }
+};
+
+struct DirectDrawClipperImpl : public IDirectDrawClipper {
+	// IDirectDrawClipper interface
+	HRESULT SetHWnd(DWORD unnamedParam1, HWND hWnd) 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) {
-			AddRef();
+			this->IUnknown::AddRef();
 			*ppvObject = static_cast<IDirectDraw2*>(this);
 			return S_OK;
 		}
 		if (SDL_memcmp(&riid, &IID_IDirect3D2, sizeof(GUID)) == 0) {
-			AddRef();
+			this->IUnknown::AddRef();
 			*ppvObject = static_cast<IDirect3D2*>(this);
 			return S_OK;
 		}
@@ -39,7 +88,9 @@ struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
 	// IDirecdtDraw interface
 	HRESULT CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter) override
 	{
-		return DDERR_GENERIC;
+		*lplpDDClipper = static_cast<IDirectDrawClipper*>(new DirectDrawClipperImpl);
+
+		return DD_OK;
 	}
 	HRESULT CreatePalette(
 		DWORD dwFlags,
@@ -53,7 +104,9 @@ struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
 	HRESULT CreateSurface(LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE* lplpDDSurface, IUnknown* pUnkOuter)
 		override
 	{
-		return DDERR_GENERIC;
+		*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurfaceImpl);
+
+		return DD_OK;
 	}
 	HRESULT EnumDisplayModes(
 		DWORD dwFlags,
@@ -80,12 +133,10 @@ struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
 	// IDirect3D2 interface
 	HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override
 	{
-		return DDERR_GENERIC;
+		*ppDirect3DDevice = new IDirect3DDevice2;
+		return DD_OK;
 	}
 	HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) override;
-
-private:
-	int m_refCount;
 };
 
 HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)