Move miniwin to sdl3gpu subdirectory + add suffix to classes (#170)

CMakeLists.txt

@@ -91,37 +91,43 @@ if (ISLE_UBSAN)
   add_link_options(-fsanitize=undefined)
 endif()
 
+set(miniwin_sdl3gpu_sources
+  miniwin/sdl3gpu/src/miniwin_ddpalette.cpp
+  miniwin/sdl3gpu/src/miniwin_ddsurface.cpp
+  miniwin/sdl3gpu/src/miniwin_ddraw.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drm.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp
+  miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp
+)
+set_property(SOURCE ${miniwin_sdl3gpu_sources} APPEND PROPERTY INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/generated")
+
 add_library(miniwin STATIC EXCLUDE_FROM_ALL
-  miniwin/miniwin/src/miniwin.cpp
+  miniwin/common/src/d3drm.cpp
-  miniwin/miniwin/src/miniwin_ddpalette.cpp
+  miniwin/common/src/miniwin.cpp
-  miniwin/miniwin/src/miniwin_ddsurface.cpp
+  ${miniwin_sdl3gpu_sources}
-  miniwin/miniwin/src/miniwin_ddraw.cpp
-  miniwin/miniwin/src/miniwin_d3drm.cpp
-  miniwin/miniwin/src/miniwin_d3drmdevice.cpp
-  miniwin/miniwin/src/miniwin_d3drmframe.cpp
-  miniwin/miniwin/src/miniwin_d3drmlight.cpp
-  miniwin/miniwin/src/miniwin_d3drmmesh.cpp
-  miniwin/miniwin/src/miniwin_d3drmtexture.cpp
-  miniwin/miniwin/src/miniwin_d3drmviewport.cpp
 )
 # Force reported render mods from MiniWin
 target_compile_definitions(miniwin PRIVATE MINIWIN_PIXELFORMAT=SDL_PIXELFORMAT_RGB565)
-target_include_directories(miniwin PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/include>")
+target_include_directories(miniwin PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/miniwin/include>")
-target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/src/include")
+target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/common/include")
-target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/generated")
+target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/include")
 target_compile_definitions(miniwin PUBLIC "MINIWIN")
 target_link_libraries(miniwin PRIVATE SDL3::SDL3)
 
-set(shader_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/src")
+set(shader_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/src")
-set(shader_gen_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/generated")
+set(shader_gen_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/generated")
-set(py_gencshadersource "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/gencshadersource.py")
+set(py_gencshadersource "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/gencshadersource.py")
 set(miniwin_shaders
   "${shader_src_dir}/PositionColor.vert.hlsl"
   "${shader_src_dir}/SolidColor.frag.hlsl"
 )
 if(ISLE_COMPILE_SHADERS)
   set(compiled_bindir "${CMAKE_CURRENT_BINARY_DIR}/shaders/compiled")
-  set(compiled_srcdir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/compiled")
+  set(compiled_srcdir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/compiled")
   set(generated_dirs "${compiled_srcdir}" "${compiled_bindir}/dxil" "${compiled_bindir}/msl" "${compiled_bindir}/spirv")
   add_custom_command(OUTPUT ${generated_dirs}
     COMMAND "${CMAKE_COMMAND}" -E make_directory ${generated_dirs})
@@ -206,7 +212,8 @@ add_library(minimfc STATIC EXCLUDE_FROM_ALL
   miniwin/minimfc/src/minimfc.cpp
 )
 target_include_directories(minimfc PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/miniwin/minimfc/include>")
-target_include_directories(minimfc PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/src/include")
+target_include_directories(minimfc PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/include")
+target_include_directories(minimfc PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/common/include")
 target_compile_definitions(minimfc PUBLIC "MINIMFC")
 target_link_libraries(minimfc PRIVATE SDL3::SDL3 miniwin)
 

ISLE/isleapp.cpp

@@ -31,6 +31,10 @@
 #include "roi/legoroi.h"
 #include "viewmanager/viewmanager.h"
 
+#ifdef MINIWIN
+#include "miniwin_config.h"
+#endif
+
 #define SDL_MAIN_USE_CALLBACKS
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_main.h>
@@ -76,6 +80,10 @@ MxS32 g_reqEnableRMDevice = FALSE;
 
 SDL_Window* window;
 
+#ifdef MINIWIN
+static MiniwinBackendType g_miniwinBackendType = MiniwinBackendType::eInvalid;
+#endif
+
 // FUNCTION: ISLE 0x401000
 IsleApp::IsleApp()
 {
@@ -121,6 +129,10 @@ IsleApp::IsleApp()
 	LegoOmni::CreateInstance();
 
 	m_iniPath = NULL;
+
+#ifdef MINIWIN
+	g_miniwinBackendType = MiniwinBackendType::eSDL3GPU;
+#endif
 }
 
 // FUNCTION: ISLE 0x4011a0
@@ -268,6 +280,12 @@ SDL_AppResult SDL_AppInit(void** appstate, int argc, char** argv)
 		return SDL_APP_FAILURE;
 	}
 
+#ifdef MINIWIN
+	Miniwin_ConfigureBackend(g_miniwinBackendType);
+	auto miniwinBackendString = Miniwin_BackendTypeToString(g_miniwinBackendType);
+	SDL_Log("miniwin backend: %s", miniwinBackendString.c_str());
+#endif
+
 	// Create window
 	if (g_isle->SetupWindow() != SUCCESS) {
 		SDL_ShowSimpleMessageBox(
@@ -852,12 +870,26 @@ MxResult IsleApp::ParseArguments(int argc, char** argv)
 			m_iniPath = argv[i + 1];
 			consumed = 2;
 		}
-#ifdef ISLE_DEBUG
 		else if (strcmp(argv[i], "--debug") == 0) {
+#ifdef ISLE_DEBUG
 			IsleDebug_SetEnabled(true);
+#else
+			SDL_Log("isle is built without debug support. Ignoring --debug argument.");
+#endif
 			consumed = 1;
 		}
+		else if (strcmp(argv[i], "--backend") == 0 && i + i < argc) {
+#ifdef MINIWIN
+			g_miniwinBackendType = Miniwin_StringToBackendType(argv[i + 1]);
+			if (g_miniwinBackendType == MiniwinBackendType::eInvalid) {
+				SDL_Log("Invalid backend type: %s", argv[i + 1]);
+				return FAILURE;
+			}
+#else
+			SDL_Log("isle is built without miniwin. Ignoring --backend XXX argument.");
 #endif
+			consumed = 2;
+		}
 		if (consumed <= 0) {
 			SDL_Log("Invalid argument(s): %s", argv[i]);
 			return FAILURE;

miniwin/common/src/d3drm.cpp

@@ -0,0 +1,50 @@
+#include "miniwin_config.h"
+#include "miniwin_d3drm.h"
+#include "miniwin_d3drm_sdl3gpu.h"
+
+#define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))
+
+namespace
+{
+MiniwinBackendType g_backendType = MiniwinBackendType::eInvalid;
+}
+
+void Miniwin_ConfigureBackend(MiniwinBackendType type)
+{
+	g_backendType = type;
+}
+
+MiniwinBackendType Miniwin_StringToBackendType(const char* str)
+{
+	if (SDL_strcasecmp(str, "sdl3gpu") == 0) {
+		return MiniwinBackendType ::eSDL3GPU;
+	}
+	return MiniwinBackendType ::eInvalid;
+}
+
+std::string Miniwin_BackendTypeToString(MiniwinBackendType type)
+{
+	switch (type) {
+	case MiniwinBackendType::eSDL3GPU:
+		return "sdl3gpu";
+	default:
+		return "<invalid>";
+	}
+}
+
+HRESULT WINAPI Direct3DRMCreate(IDirect3DRM** direct3DRM)
+{
+	switch (g_backendType) {
+	case MiniwinBackendType::eSDL3GPU:
+		*direct3DRM = new Direct3DRM_SDL3GPUImpl;
+		return DD_OK;
+	default:
+		*direct3DRM = nullptr;
+		return DDERR_GENERIC;
+	}
+}
+
+D3DCOLOR D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)
+{
+	return RGBA_MAKE((int) (255.f * red), (int) (255.f * green), (int) (255.f * blue), (int) (255.f * alpha));
+}

miniwin/include/miniwin_config.h

@@ -0,0 +1,23 @@
+#ifndef MINIWIN_CONFIG_H
+#define MINIWIN_CONFIG_H
+
+#include <string>
+
+#ifdef _WIN32
+#define MINIWIN_EXPORT __declspec(dllexport)
+#else
+#define MINIWIN_EXPORT __attribute__((visibility("default")))
+#endif
+
+enum MiniwinBackendType {
+	eInvalid,
+	eSDL3GPU,
+};
+
+MiniwinBackendType MINIWIN_EXPORT Miniwin_StringToBackendType(const char* str);
+
+std::string MINIWIN_EXPORT Miniwin_BackendTypeToString(MiniwinBackendType type);
+
+void MINIWIN_EXPORT Miniwin_ConfigureBackend(MiniwinBackendType type);
+
+#endif

miniwin/miniwin/src/include/miniwin_d3drm_p.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "miniwin_d3drm.h"
-
-#include <SDL3/SDL.h>
-#include <algorithm>
-#include <vector>
-
-typedef struct PositionColorVertex {
-	float x, y, z;
-	Uint8 r, g, b, a;
-} PositionColorVertex;
-
-template <typename InterfaceType, typename ActualType, typename ArrayInterface>
-class Direct3DRMArrayBase : public ArrayInterface {
-public:
-	~Direct3DRMArrayBase() override
-	{
-		for (auto* item : m_items) {
-			if (item) {
-				item->Release();
-			}
-		}
-	}
-	DWORD GetSize() override { return static_cast<DWORD>(m_items.size()); }
-	HRESULT AddElement(InterfaceType* in) override
-	{
-		if (!in) {
-			return DDERR_INVALIDPARAMS;
-		}
-		auto inImpl = static_cast<ActualType*>(in);
-		inImpl->AddRef();
-		m_items.push_back(inImpl);
-		return DD_OK;
-	}
-	HRESULT GetElement(DWORD index, InterfaceType** out) override
-	{
-		if (index >= m_items.size()) {
-			return DDERR_INVALIDPARAMS;
-		}
-		*out = static_cast<InterfaceType*>(m_items[index]);
-		if (*out) {
-			(*out)->AddRef();
-		}
-		return DD_OK;
-	}
-	HRESULT DeleteElement(InterfaceType* element) override
-	{
-		auto it = std::find(m_items.begin(), m_items.end(), element);
-		if (it == m_items.end()) {
-			return DDERR_INVALIDPARAMS;
-		}
-
-		(*it)->Release();
-		m_items.erase(it);
-		return DD_OK;
-	}
-
-protected:
-	std::vector<ActualType*> m_items;
-};

miniwin/miniwin/src/include/miniwin_d3drmlight_p.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "miniwin_d3drm_p.h"
-#include "miniwin_d3drmobject_p.h"
-#include "miniwin_p.h"
-
-struct Direct3DRMLightImpl : public Direct3DRMObjectBase<IDirect3DRMLight> {
-	Direct3DRMLightImpl(float r, float g, float b);
-	HRESULT SetColorRGB(float r, float g, float b) override;
-
-private:
-	D3DCOLOR m_color = 0xFFFFFFFF;
-};
-
-struct Direct3DRMLightArrayImpl
-	: public Direct3DRMArrayBase<IDirect3DRMLight, Direct3DRMLightImpl, IDirect3DRMLightArray> {
-	using Direct3DRMArrayBase::Direct3DRMArrayBase;
-};

miniwin/miniwin/src/include/miniwin_d3drmtexture_p.h

@@ -1,8 +0,0 @@
-#pragma once
-
-#include "miniwin_d3drmobject_p.h"
-
-struct Direct3DRMTextureImpl : public Direct3DRMObjectBase<IDirect3DRMTexture2> {
-	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
-	HRESULT Changed(BOOL pixels, BOOL palette) override;
-};

miniwin/miniwin/src/include/miniwin_d3drmvisual_p.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include "miniwin_d3drm.h"
-#include "miniwin_d3drmobject_p.h"
-
-struct Direct3DRMVisualArrayImpl
-	: public Direct3DRMArrayBase<IDirect3DRMVisual, IDirect3DRMVisual, IDirect3DRMVisualArray> {
-	using Direct3DRMArrayBase::Direct3DRMArrayBase;
-};

miniwin/miniwin/src/include/miniwin_math_p.h

@@ -1 +0,0 @@
-#pragma once

miniwin/miniwin/src/miniwin_d3drm.cpp

@@ -1,301 +0,0 @@
-#include "miniwin_d3drm.h"
-
-#include "ShaderIndex.h"
-#include "miniwin_d3drm_p.h"
-#include "miniwin_d3drmdevice_p.h"
-#include "miniwin_d3drmframe_p.h"
-#include "miniwin_d3drmlight_p.h"
-#include "miniwin_d3drmmesh_p.h"
-#include "miniwin_d3drmobject_p.h"
-#include "miniwin_d3drmtexture_p.h"
-#include "miniwin_d3drmviewport_p.h"
-#include "miniwin_ddsurface_p.h"
-#include "miniwin_p.h"
-
-#include <SDL3/SDL.h>
-
-#define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))
-
-struct PickRecord {
-	IDirect3DRMVisual* visual;
-	IDirect3DRMFrameArray* frameArray;
-	D3DRMPICKDESC desc;
-};
-
-struct Direct3DRMPickedArrayImpl : public IDirect3DRMPickedArray {
-	~Direct3DRMPickedArrayImpl() override
-	{
-		for (PickRecord& pick : picks) {
-			if (pick.visual) {
-				pick.visual->Release();
-			}
-			if (pick.frameArray) {
-				pick.frameArray->Release();
-			}
-		}
-	}
-	DWORD GetSize() override { return static_cast<DWORD>(picks.size()); }
-	HRESULT GetPick(DWORD index, IDirect3DRMVisual** visual, IDirect3DRMFrameArray** frameArray, D3DRMPICKDESC* desc)
-		override
-	{
-		if (index >= picks.size()) {
-			return DDERR_INVALIDPARAMS;
-		}
-
-		const PickRecord& pick = picks[index];
-
-		*visual = pick.visual;
-		*frameArray = pick.frameArray;
-		*desc = pick.desc;
-
-		if (*visual) {
-			(*visual)->AddRef();
-		}
-		if (*frameArray) {
-			(*frameArray)->AddRef();
-		}
-
-		return DD_OK;
-	}
-
-private:
-	std::vector<PickRecord> picks;
-};
-
-struct Direct3DRMWinDeviceImpl : public IDirect3DRMWinDevice {
-	HRESULT Activate() override
-	{
-		MINIWIN_NOT_IMPLEMENTED();
-		return DD_OK;
-	}
-	HRESULT Paint() override
-	{
-		MINIWIN_NOT_IMPLEMENTED();
-		return DD_OK;
-	}
-	void HandleActivate(WORD wParam) override { MINIWIN_NOT_IMPLEMENTED(); }
-	void HandlePaint(void* p_dc) override { MINIWIN_NOT_IMPLEMENTED(); }
-};
-
-struct Direct3DRMMaterialImpl : public Direct3DRMObjectBase<IDirect3DRMMaterial> {
-	Direct3DRMMaterialImpl(D3DVALUE power) : m_power(power) {}
-	D3DVALUE GetPower() override { return m_power; }
-
-private:
-	D3DVALUE m_power;
-};
-
-SDL_GPUGraphicsPipeline* InitializeGraphicsPipeline(SDL_GPUDevice* device)
-{
-	const SDL_GPUShaderCreateInfo* vertexCreateInfo =
-		GetVertexShaderCode(VertexShaderId::PositionColor, SDL_GetGPUShaderFormats(device));
-	if (!vertexCreateInfo) {
-		return nullptr;
-	}
-	SDL_GPUShader* vertexShader = SDL_CreateGPUShader(device, vertexCreateInfo);
-	if (!vertexShader) {
-		return nullptr;
-	}
-
-	const SDL_GPUShaderCreateInfo* fragmentCreateInfo =
-		GetFragmentShaderCode(FragmentShaderId::SolidColor, SDL_GetGPUShaderFormats(device));
-	if (!fragmentCreateInfo) {
-		return nullptr;
-	}
-	SDL_GPUShader* fragmentShader = SDL_CreateGPUShader(device, fragmentCreateInfo);
-	if (!fragmentShader) {
-		return nullptr;
-	}
-
-	SDL_GPUVertexBufferDescription vertexBufferDescs[1] = {};
-	vertexBufferDescs[0].slot = 0;
-	vertexBufferDescs[0].pitch = sizeof(PositionColorVertex);
-	vertexBufferDescs[0].input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
-	vertexBufferDescs[0].instance_step_rate = 0;
-
-	SDL_GPUVertexAttribute vertexAttrs[2] = {};
-	vertexAttrs[0].location = 0;
-	vertexAttrs[0].buffer_slot = 0;
-	vertexAttrs[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
-	vertexAttrs[0].offset = 0;
-
-	vertexAttrs[1].location = 1;
-	vertexAttrs[1].buffer_slot = 0;
-	vertexAttrs[1].format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM;
-	vertexAttrs[1].offset = sizeof(float) * 3;
-
-	SDL_GPUVertexInputState vertexInputState = {};
-	vertexInputState.vertex_buffer_descriptions = vertexBufferDescs;
-	vertexInputState.num_vertex_buffers = 1;
-	vertexInputState.vertex_attributes = vertexAttrs;
-	vertexInputState.num_vertex_attributes = 2;
-
-	SDL_GPUColorTargetDescription colorTargets = {};
-	colorTargets.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB;
-
-	SDL_GPUGraphicsPipelineCreateInfo pipelineCreateInfo = {};
-	pipelineCreateInfo.vertex_shader = vertexShader;
-	pipelineCreateInfo.fragment_shader = fragmentShader;
-	pipelineCreateInfo.vertex_input_state = vertexInputState;
-	pipelineCreateInfo.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
-	pipelineCreateInfo.target_info.color_target_descriptions = &colorTargets;
-	pipelineCreateInfo.target_info.num_color_targets = 1;
-
-	SDL_GPUGraphicsPipeline* pipeline = SDL_CreateGPUGraphicsPipeline(device, &pipelineCreateInfo);
-	// Clean up shader resources
-	SDL_ReleaseGPUShader(device, vertexShader);
-	SDL_ReleaseGPUShader(device, fragmentShader);
-
-	return pipeline;
-}
-
-struct Direct3DRMImpl : virtual 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 DD_OK;
-		}
-		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRMImpl does not implement guid");
-		return E_NOINTERFACE;
-	}
-	// IDirect3DRM interface
-	HRESULT CreateDevice(IDirect3DRMDevice2** outDevice, DWORD width, DWORD height)
-	{
-		SDL_GPUDevice* device = SDL_CreateGPUDevice(
-			SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_MSL,
-			true,
-			NULL
-		);
-		if (device == NULL) {
-			return DDERR_GENERIC;
-		}
-		if (DDWindow == NULL) {
-			return DDERR_GENERIC;
-		}
-		if (!SDL_ClaimWindowForGPUDevice(device, DDWindow)) {
-			return DDERR_GENERIC;
-		}
-
-		*outDevice = static_cast<IDirect3DRMDevice2*>(new Direct3DRMDevice2Impl(width, height, device));
-		return DD_OK;
-	}
-	HRESULT CreateDeviceFromD3D(const IDirect3D2* d3d, IDirect3DDevice2* d3dDevice, IDirect3DRMDevice2** outDevice)
-		override
-	{
-		MINIWIN_NOT_IMPLEMENTED();
-		return CreateDevice(outDevice, 640, 480);
-	}
-	HRESULT CreateDeviceFromSurface(
-		const GUID* guid,
-		IDirectDraw* dd,
-		IDirectDrawSurface* surface,
-		IDirect3DRMDevice2** outDevice
-	) override
-	{
-		MINIWIN_NOT_IMPLEMENTED(); // Respect the chosen GUID
-		DDSURFACEDESC DDSDesc;
-		DDSDesc.dwSize = sizeof(DDSURFACEDESC);
-		surface->GetSurfaceDesc(&DDSDesc);
-		return CreateDevice(outDevice, DDSDesc.dwWidth, DDSDesc.dwHeight);
-	}
-	HRESULT CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) override
-	{
-		MINIWIN_NOT_IMPLEMENTED();
-		*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
-		return DD_OK;
-	}
-	HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) override
-	{
-		MINIWIN_NOT_IMPLEMENTED();
-		*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
-		return DD_OK;
-	}
-	HRESULT CreateMesh(IDirect3DRMMesh** outMesh) override
-	{
-		*outMesh = static_cast<IDirect3DRMMesh*>(new Direct3DRMMeshImpl);
-		return DD_OK;
-	}
-	HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) override
-	{
-		*outMaterial = static_cast<IDirect3DRMMaterial*>(new Direct3DRMMaterialImpl(power));
-		return DD_OK;
-	}
-	HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) override
-	{
-		*outLight = static_cast<IDirect3DRMLight*>(new Direct3DRMLightImpl(r, g, b));
-		return DD_OK;
-	}
-	HRESULT CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) override
-	{
-		auto parentImpl = static_cast<Direct3DRMFrameImpl*>(parent);
-		*outFrame = static_cast<IDirect3DRMFrame2*>(new Direct3DRMFrameImpl{parentImpl});
-		return DD_OK;
-	}
-	HRESULT CreateViewport(
-		IDirect3DRMDevice2* iDevice,
-		IDirect3DRMFrame* camera,
-		int x,
-		int y,
-		int width,
-		int height,
-		IDirect3DRMViewport** outViewport
-	) override
-	{
-		auto device = static_cast<Direct3DRMDevice2Impl*>(iDevice);
-
-		SDL_GPUGraphicsPipeline* pipeline = InitializeGraphicsPipeline(device->m_device);
-		if (!pipeline) {
-			return DDERR_GENERIC;
-		}
-
-		SDL_GPUTextureCreateInfo textureInfo = {};
-		textureInfo.type = SDL_GPU_TEXTURETYPE_2D;
-		textureInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB;
-		textureInfo.width = width;
-		textureInfo.height = height;
-		textureInfo.layer_count_or_depth = 1;
-		textureInfo.num_levels = 1;
-		textureInfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
-		SDL_GPUTexture* transferTexture = SDL_CreateGPUTexture(device->m_device, &textureInfo);
-		if (!transferTexture) {
-			return DDERR_GENERIC;
-		}
-
-		// Setup texture GPU-to-CPU transfer
-		SDL_GPUTransferBufferCreateInfo downloadTransferInfo = {};
-		downloadTransferInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD;
-		downloadTransferInfo.size = static_cast<Uint32>(width * height * 4);
-		SDL_GPUTransferBuffer* downloadTransferBuffer =
-			SDL_CreateGPUTransferBuffer(device->m_device, &downloadTransferInfo);
-		if (!downloadTransferBuffer) {
-			return DDERR_GENERIC;
-		}
-
-		*outViewport = static_cast<IDirect3DRMViewport*>(new Direct3DRMViewportImpl(
-			width,
-			height,
-			device->m_device,
-			transferTexture,
-			downloadTransferBuffer,
-			pipeline
-		));
-		device->AddViewport(*outViewport);
-		return DD_OK;
-	}
-	HRESULT SetDefaultTextureShades(DWORD count) override { return DD_OK; }
-	HRESULT SetDefaultTextureColors(DWORD count) override { return DD_OK; }
-};
-
-HRESULT WINAPI Direct3DRMCreate(IDirect3DRM** direct3DRM)
-{
-	*direct3DRM = new Direct3DRMImpl;
-	return DD_OK;
-}
-
-D3DCOLOR D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)
-{
-	return RGBA_MAKE((int) (255.f * red), (int) (255.f * green), (int) (255.f * blue), (int) (255.f * alpha));
-}

miniwin/miniwin/src/miniwin_d3drmdevice.cpp

@@ -1,123 +0,0 @@
-#include "miniwin_d3drm.h"
-#include "miniwin_d3drm_p.h"
-#include "miniwin_d3drmdevice_p.h"
-#include "miniwin_d3drmobject_p.h"
-#include "miniwin_d3drmviewport_p.h"
-#include "miniwin_p.h"
-
-#include <SDL3/SDL.h>
-
-Direct3DRMDevice2Impl::Direct3DRMDevice2Impl(DWORD width, DWORD height, SDL_GPUDevice* device)
-	: m_width(width), m_height(height), m_device(device), m_viewports(new Direct3DRMViewportArrayImpl)
-{
-}
-
-Direct3DRMDevice2Impl::~Direct3DRMDevice2Impl()
-{
-	for (int i = 0; i < m_viewports->GetSize(); i++) {
-		IDirect3DRMViewport* viewport;
-		m_viewports->GetElement(i, &viewport);
-		static_cast<Direct3DRMViewportImpl*>(viewport)->CloseDevice();
-		viewport->Release();
-	}
-	m_viewports->Release();
-
-	SDL_ReleaseWindowFromGPUDevice(m_device, DDWindow);
-	SDL_DestroyGPUDevice(m_device);
-}
-
-DWORD Direct3DRMDevice2Impl::GetWidth()
-{
-	return m_width;
-}
-
-DWORD Direct3DRMDevice2Impl::GetHeight()
-{
-	return m_height;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetBufferCount(int count)
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-DWORD Direct3DRMDevice2Impl::GetBufferCount()
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return 2;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetShades(DWORD shadeCount)
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-HRESULT Direct3DRMDevice2Impl::GetShades()
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetQuality(D3DRMRENDERQUALITY quality)
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-D3DRMRENDERQUALITY Direct3DRMDevice2Impl::GetQuality()
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return D3DRMRENDERQUALITY::GOURAUD;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetDither(BOOL dither)
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-BOOL Direct3DRMDevice2Impl::GetDither()
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return false;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetTextureQuality(D3DRMTEXTUREQUALITY quality)
-{
-	return DD_OK;
-}
-
-D3DRMTEXTUREQUALITY Direct3DRMDevice2Impl::GetTextureQuality()
-{
-	return D3DRMTEXTUREQUALITY::LINEAR;
-}
-
-HRESULT Direct3DRMDevice2Impl::SetRenderMode(D3DRMRENDERMODE mode)
-{
-	return DD_OK;
-}
-
-D3DRMRENDERMODE Direct3DRMDevice2Impl::GetRenderMode()
-{
-	return D3DRMRENDERMODE::BLENDEDTRANSPARENCY;
-}
-
-HRESULT Direct3DRMDevice2Impl::Update()
-{
-	MINIWIN_NOT_IMPLEMENTED();
-	return DD_OK;
-}
-
-HRESULT Direct3DRMDevice2Impl::AddViewport(IDirect3DRMViewport* viewport)
-{
-	return m_viewports->AddElement(viewport);
-}
-
-HRESULT Direct3DRMDevice2Impl::GetViewports(IDirect3DRMViewportArray** ppViewportArray)
-{
-	m_viewports->AddRef();
-	*ppViewportArray = m_viewports;
-	return DD_OK;
-}

miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "miniwin_d3drm.h"
+
+#include <SDL3/SDL.h>
+#include <algorithm>
+#include <vector>
+
+struct Direct3DRM_SDL3GPUImpl : virtual public IDirect3DRM2 {
+	// IUnknown interface
+	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
+	// IDirect3DRM interface
+	HRESULT CreateDevice(IDirect3DRMDevice2** outDevice, DWORD width, DWORD height);
+	HRESULT CreateDeviceFromD3D(const IDirect3D2* d3d, IDirect3DDevice2* d3dDevice, IDirect3DRMDevice2** outDevice)
+		override;
+	HRESULT CreateDeviceFromSurface(
+		const GUID* guid,
+		IDirectDraw* dd,
+		IDirectDrawSurface* surface,
+		IDirect3DRMDevice2** outDevice
+	) override;
+	HRESULT CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) override;
+	HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) override;
+	HRESULT CreateMesh(IDirect3DRMMesh** outMesh) override;
+	HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) override;
+	HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) override;
+	HRESULT CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) override;
+	HRESULT CreateViewport(
+		IDirect3DRMDevice2* iDevice,
+		IDirect3DRMFrame* camera,
+		int x,
+		int y,
+		int width,
+		int height,
+		IDirect3DRMViewport** outViewport
+	) override;
+	HRESULT SetDefaultTextureShades(DWORD count) override;
+	HRESULT SetDefaultTextureColors(DWORD count) override;
+};
+
+typedef struct PositionColorVertex {
+	float x, y, z;
+	Uint8 r, g, b, a;
+} PositionColorVertex;
+
+template <typename InterfaceType, typename ActualType, typename ArrayInterface>
+class Direct3DRMArrayBase_SDL3GPUImpl : public ArrayInterface {
+public:
+	~Direct3DRMArrayBase_SDL3GPUImpl() override
+	{
+		for (auto* item : m_items) {
+			if (item) {
+				item->Release();
+			}
+		}
+	}
+	DWORD GetSize() override { return static_cast<DWORD>(m_items.size()); }
+	HRESULT AddElement(InterfaceType* in) override
+	{
+		if (!in) {
+			return DDERR_INVALIDPARAMS;
+		}
+		auto inImpl = static_cast<ActualType*>(in);
+		inImpl->AddRef();
+		m_items.push_back(inImpl);
+		return DD_OK;
+	}
+	HRESULT GetElement(DWORD index, InterfaceType** out) override
+	{
+		if (index >= m_items.size()) {
+			return DDERR_INVALIDPARAMS;
+		}
+		*out = static_cast<InterfaceType*>(m_items[index]);
+		if (*out) {
+			(*out)->AddRef();
+		}
+		return DD_OK;
+	}
+	HRESULT DeleteElement(InterfaceType* element) override
+	{
+		auto it = std::find(m_items.begin(), m_items.end(), element);
+		if (it == m_items.end()) {
+			return DDERR_INVALIDPARAMS;
+		}
+
+		(*it)->Release();
+		m_items.erase(it);
+		return DD_OK;
+	}
+
+protected:
+	std::vector<ActualType*> m_items;
+};

miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h

@@ -1,13 +1,13 @@
 #pragma once
 
 #include "miniwin_d3drm.h"
-#include "miniwin_d3drmobject_p.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
 
 #include <SDL3/SDL.h>
 
-struct Direct3DRMDevice2Impl : public Direct3DRMObjectBase<IDirect3DRMDevice2> {
+struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMDevice2> {
-	Direct3DRMDevice2Impl(DWORD width, DWORD height, SDL_GPUDevice* device);
+	Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device);
-	~Direct3DRMDevice2Impl() override;
+	~Direct3DRMDevice2_SDL3GPUImpl() override;
 	DWORD GetWidth() override;
 	DWORD GetHeight() override;
 	HRESULT SetBufferCount(int count) override;

miniwin/sdl3gpu/include/miniwin_d3drmframe_sdl3gpu.h

@@ -1,15 +1,15 @@
 #pragma once
 
-#include "miniwin_d3drmobject_p.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
 
-class Direct3DRMTextureImpl;
+class Direct3DRMTexture_SDL3GPUImpl;
-class Direct3DRMLightArrayImpl;
+class Direct3DRMLightArray_SDL3GPUImpl;
-class Direct3DRMVisualArrayImpl;
+class Direct3DRMVisualArray_SDL3GPUImpl;
-class Direct3DRMFrameArrayImpl;
+class Direct3DRMFrameArray_SDL3GPUImpl;
 
-struct Direct3DRMFrameImpl : public Direct3DRMObjectBase<IDirect3DRMFrame2> {
+struct Direct3DRMFrame_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMFrame2> {
-	Direct3DRMFrameImpl(Direct3DRMFrameImpl* parent = nullptr);
+	Direct3DRMFrame_SDL3GPUImpl(Direct3DRMFrame_SDL3GPUImpl* parent = nullptr);
-	~Direct3DRMFrameImpl() override;
+	~Direct3DRMFrame_SDL3GPUImpl() override;
 	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
 	HRESULT AddChild(IDirect3DRMFrame* child) override;
 	HRESULT DeleteChild(IDirect3DRMFrame* child) override;
@@ -30,23 +30,23 @@ struct Direct3DRMFrameImpl : public Direct3DRMObjectBase<IDirect3DRMFrame2> {
 	HRESULT GetChildren(IDirect3DRMFrameArray** children) override;
 
 private:
-	Direct3DRMFrameImpl* m_parent{};
+	Direct3DRMFrame_SDL3GPUImpl* m_parent{};
-	Direct3DRMFrameArrayImpl* m_children{};
+	Direct3DRMFrameArray_SDL3GPUImpl* m_children{};
-	Direct3DRMLightArrayImpl* m_lights{};
+	Direct3DRMLightArray_SDL3GPUImpl* m_lights{};
-	Direct3DRMVisualArrayImpl* m_visuals{};
+	Direct3DRMVisualArray_SDL3GPUImpl* m_visuals{};
-	Direct3DRMTextureImpl* m_texture{};
+	Direct3DRMTexture_SDL3GPUImpl* m_texture{};
 	D3DRMMATRIX4D m_transform =
 		{{1.f, 0.f, 0.f, 0.f}, {0.f, 1.f, 0.f, 0.f}, {0.f, 0.f, 1.f, 0.f}, {0.f, 0.f, 0.f, 1.f}};
 
 	D3DCOLOR m_backgroundColor = 0xFF000000;
 	D3DCOLOR m_color = 0xffffff;
 
-	friend class Direct3DRMViewportImpl;
+	friend class Direct3DRMViewport_SDL3GPUImpl;
 };
 
-struct Direct3DRMFrameArrayImpl
+struct Direct3DRMFrameArray_SDL3GPUImpl
-	: public Direct3DRMArrayBase<IDirect3DRMFrame, Direct3DRMFrameImpl, IDirect3DRMFrameArray> {
+	: public Direct3DRMArrayBase_SDL3GPUImpl<IDirect3DRMFrame, Direct3DRMFrame_SDL3GPUImpl, IDirect3DRMFrameArray> {
-	using Direct3DRMArrayBase::Direct3DRMArrayBase;
+	using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
 
-	friend class Direct3DRMFrameImpl;
+	friend class Direct3DRMFrame_SDL3GPUImpl;
 };

miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "miniwin_d3drm_sdl3gpu.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
+#include "miniwin_p.h"
+
+struct Direct3DRMLight_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMLight> {
+	Direct3DRMLight_SDL3GPUImpl(float r, float g, float b);
+	HRESULT SetColorRGB(float r, float g, float b) override;
+
+private:
+	D3DCOLOR m_color = 0xFFFFFFFF;
+};
+
+struct Direct3DRMLightArray_SDL3GPUImpl
+	: public Direct3DRMArrayBase_SDL3GPUImpl<IDirect3DRMLight, Direct3DRMLight_SDL3GPUImpl, IDirect3DRMLightArray> {
+	using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
+};

miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "miniwin_d3drmobject_p.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
 
 #include <algorithm>
 #include <vector>
@@ -63,7 +63,7 @@ struct MeshGroup {
 	}
 };
 
-struct Direct3DRMMeshImpl : public Direct3DRMObjectBase<IDirect3DRMMesh> {
+struct Direct3DRMMesh_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMMesh> {
 	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
 	HRESULT Clone(int flags, GUID iid, void** object) override;
 	HRESULT AddGroup(int vertexCount, int faceCount, int vertexPerFace, DWORD* faceBuffer, D3DRMGROUPINDEX* groupIndex)

miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 template <typename T>
-struct Direct3DRMObjectBase : public T {
+struct Direct3DRMObjectBase_SDL3GPUImpl : public T {
 	ULONG Release() override
 	{
 		if (IUnknown::m_refCount == 1) {

miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "miniwin_d3drmobject_sdl3gpu.h"
+
+struct Direct3DRMTexture_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMTexture2> {
+	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
+	HRESULT Changed(BOOL pixels, BOOL palette) override;
+};

miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h

@@ -1,15 +1,15 @@
 #pragma once
 
 #include "miniwin_d3drm.h"
-#include "miniwin_d3drmobject_p.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
 
 #include <SDL3/SDL.h>
 
-class Direct3DRMDeviceImpl;
+class Direct3DRMDevice_SDL3GPUImpl;
-class Direct3DRMFrameImpl;
+class Direct3DRMFrame_SDL3GPUImpl;
 
-struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport> {
+struct Direct3DRMViewport_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMViewport> {
-	Direct3DRMViewportImpl(
+	Direct3DRMViewport_SDL3GPUImpl(
 		DWORD width,
 		DWORD height,
 		SDL_GPUDevice* device,
@@ -17,7 +17,7 @@ struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport>
 		SDL_GPUTransferBuffer* downloadTransferBuffer,
 		SDL_GPUGraphicsPipeline* pipeline
 	);
-	~Direct3DRMViewportImpl() override;
+	~Direct3DRMViewport_SDL3GPUImpl() override;
 	HRESULT Render(IDirect3DRMFrame* group) override;
 	/**
 	 * @brief Blit the render back to our backbuffer
@@ -65,7 +65,9 @@ struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport>
 	D3DVALUE m_field = 0.5f;
 };
 
-struct Direct3DRMViewportArrayImpl
+struct Direct3DRMViewportArray_SDL3GPUImpl : public Direct3DRMArrayBase_SDL3GPUImpl<
-	: public Direct3DRMArrayBase<IDirect3DRMViewport, Direct3DRMViewportImpl, IDirect3DRMViewportArray> {
+												 IDirect3DRMViewport,
-	using Direct3DRMArrayBase::Direct3DRMArrayBase;
+												 Direct3DRMViewport_SDL3GPUImpl,
+												 IDirect3DRMViewportArray> {
+	using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
 };

miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "miniwin_d3drm.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
+
+struct Direct3DRMVisualArray_SDL3GPUImpl
+	: public Direct3DRMArrayBase_SDL3GPUImpl<IDirect3DRMVisual, IDirect3DRMVisual, IDirect3DRMVisualArray> {
+	using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
+};

miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h

@@ -2,9 +2,9 @@
 
 #include "miniwin_ddraw.h"
 
-struct DirectDrawPaletteImpl : public IDirectDrawPalette {
+struct DirectDrawPalette_SDL3GPUImpl : public IDirectDrawPalette {
-	DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable);
+	DirectDrawPalette_SDL3GPUImpl(LPPALETTEENTRY lpColorTable);
-	~DirectDrawPaletteImpl() override;
+	~DirectDrawPalette_SDL3GPUImpl() override;
 	HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) override;
 	HRESULT SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries) override;
 

miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h

@@ -3,7 +3,7 @@
 #include "miniwin_d3d.h"
 #include "miniwin_ddraw.h"
 
-struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
+struct DirectDraw_SDL3GPUImpl : public IDirectDraw2, public IDirect3D2 {
 	// IUnknown interface
 	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
 	// IDirectDraw interface

miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h

@@ -3,10 +3,10 @@
 #include <SDL3/SDL.h>
 #include <miniwin_ddraw.h>
 
-struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 {
+struct DirectDrawSurface_SDL3GPUImpl : public IDirectDrawSurface3 {
-	DirectDrawSurfaceImpl();
+	DirectDrawSurface_SDL3GPUImpl();
-	DirectDrawSurfaceImpl(int width, int height, SDL_PixelFormat format);
+	DirectDrawSurface_SDL3GPUImpl(int width, int height, SDL_PixelFormat format);
-	~DirectDrawSurfaceImpl() override;
+	~DirectDrawSurface_SDL3GPUImpl() override;
 
 	// IUnknown interface
 	HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;

miniwin/sdl3gpu/src/miniwin_d3drm.cpp

@@ -0,0 +1,312 @@
+#include "miniwin_d3drm.h"
+
+#include "ShaderIndex.h"
+#include "miniwin_d3drm_sdl3gpu.h"
+#include "miniwin_d3drmdevice_sdl3gpu.h"
+#include "miniwin_d3drmframe_sdl3gpu.h"
+#include "miniwin_d3drmlight_sdl3gpu.h"
+#include "miniwin_d3drmmesh_sdl3gpu.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
+#include "miniwin_d3drmtexture_sdl3gpu.h"
+#include "miniwin_d3drmviewport_sdl3gpu.h"
+#include "miniwin_ddsurface_sdl3gpu.h"
+#include "miniwin_p.h"
+
+#include <SDL3/SDL.h>
+
+struct PickRecord {
+	IDirect3DRMVisual* visual;
+	IDirect3DRMFrameArray* frameArray;
+	D3DRMPICKDESC desc;
+};
+
+struct Direct3DRMPickedArray_SDL3GPUImpl : public IDirect3DRMPickedArray {
+	~Direct3DRMPickedArray_SDL3GPUImpl() override
+	{
+		for (PickRecord& pick : picks) {
+			if (pick.visual) {
+				pick.visual->Release();
+			}
+			if (pick.frameArray) {
+				pick.frameArray->Release();
+			}
+		}
+	}
+	DWORD GetSize() override { return static_cast<DWORD>(picks.size()); }
+	HRESULT GetPick(DWORD index, IDirect3DRMVisual** visual, IDirect3DRMFrameArray** frameArray, D3DRMPICKDESC* desc)
+		override
+	{
+		if (index >= picks.size()) {
+			return DDERR_INVALIDPARAMS;
+		}
+
+		const PickRecord& pick = picks[index];
+
+		*visual = pick.visual;
+		*frameArray = pick.frameArray;
+		*desc = pick.desc;
+
+		if (*visual) {
+			(*visual)->AddRef();
+		}
+		if (*frameArray) {
+			(*frameArray)->AddRef();
+		}
+
+		return DD_OK;
+	}
+
+private:
+	std::vector<PickRecord> picks;
+};
+
+struct Direct3DRMWinDevice_SDL3GPUImpl : public IDirect3DRMWinDevice {
+	HRESULT Activate() override
+	{
+		MINIWIN_NOT_IMPLEMENTED();
+		return DD_OK;
+	}
+	HRESULT Paint() override
+	{
+		MINIWIN_NOT_IMPLEMENTED();
+		return DD_OK;
+	}
+	void HandleActivate(WORD wParam) override { MINIWIN_NOT_IMPLEMENTED(); }
+	void HandlePaint(void* p_dc) override { MINIWIN_NOT_IMPLEMENTED(); }
+};
+
+struct Direct3DRMMaterial_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMMaterial> {
+	Direct3DRMMaterial_SDL3GPUImpl(D3DVALUE power) : m_power(power) {}
+	D3DVALUE GetPower() override { return m_power; }
+
+private:
+	D3DVALUE m_power;
+};
+
+SDL_GPUGraphicsPipeline* InitializeGraphicsPipeline(SDL_GPUDevice* device)
+{
+	const SDL_GPUShaderCreateInfo* vertexCreateInfo =
+		GetVertexShaderCode(VertexShaderId::PositionColor, SDL_GetGPUShaderFormats(device));
+	if (!vertexCreateInfo) {
+		return nullptr;
+	}
+	SDL_GPUShader* vertexShader = SDL_CreateGPUShader(device, vertexCreateInfo);
+	if (!vertexShader) {
+		return nullptr;
+	}
+
+	const SDL_GPUShaderCreateInfo* fragmentCreateInfo =
+		GetFragmentShaderCode(FragmentShaderId::SolidColor, SDL_GetGPUShaderFormats(device));
+	if (!fragmentCreateInfo) {
+		return nullptr;
+	}
+	SDL_GPUShader* fragmentShader = SDL_CreateGPUShader(device, fragmentCreateInfo);
+	if (!fragmentShader) {
+		return nullptr;
+	}
+
+	SDL_GPUVertexBufferDescription vertexBufferDescs[1] = {};
+	vertexBufferDescs[0].slot = 0;
+	vertexBufferDescs[0].pitch = sizeof(PositionColorVertex);
+	vertexBufferDescs[0].input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
+	vertexBufferDescs[0].instance_step_rate = 0;
+
+	SDL_GPUVertexAttribute vertexAttrs[2] = {};
+	vertexAttrs[0].location = 0;
+	vertexAttrs[0].buffer_slot = 0;
+	vertexAttrs[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
+	vertexAttrs[0].offset = 0;
+
+	vertexAttrs[1].location = 1;
+	vertexAttrs[1].buffer_slot = 0;
+	vertexAttrs[1].format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM;
+	vertexAttrs[1].offset = sizeof(float) * 3;
+
+	SDL_GPUVertexInputState vertexInputState = {};
+	vertexInputState.vertex_buffer_descriptions = vertexBufferDescs;
+	vertexInputState.num_vertex_buffers = 1;
+	vertexInputState.vertex_attributes = vertexAttrs;
+	vertexInputState.num_vertex_attributes = 2;
+
+	SDL_GPUColorTargetDescription colorTargets = {};
+	colorTargets.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB;
+
+	SDL_GPUGraphicsPipelineCreateInfo pipelineCreateInfo = {};
+	pipelineCreateInfo.vertex_shader = vertexShader;
+	pipelineCreateInfo.fragment_shader = fragmentShader;
+	pipelineCreateInfo.vertex_input_state = vertexInputState;
+	pipelineCreateInfo.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+	pipelineCreateInfo.target_info.color_target_descriptions = &colorTargets;
+	pipelineCreateInfo.target_info.num_color_targets = 1;
+
+	SDL_GPUGraphicsPipeline* pipeline = SDL_CreateGPUGraphicsPipeline(device, &pipelineCreateInfo);
+	// Clean up shader resources
+	SDL_ReleaseGPUShader(device, vertexShader);
+	SDL_ReleaseGPUShader(device, fragmentShader);
+
+	return pipeline;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
+{
+	if (SDL_memcmp(&riid, &IID_IDirect3DRM2, sizeof(GUID)) == 0) {
+		this->IUnknown::AddRef();
+		*ppvObject = static_cast<IDirect3DRM2*>(this);
+		return DD_OK;
+	}
+	SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRM_SDL3GPUImpl does not implement guid");
+	return E_NOINTERFACE;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateDevice(IDirect3DRMDevice2** outDevice, DWORD width, DWORD height)
+{
+	SDL_GPUDevice* device = SDL_CreateGPUDevice(
+		SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_MSL,
+		true,
+		NULL
+	);
+	if (device == NULL) {
+		return DDERR_GENERIC;
+	}
+	if (DDWindow == NULL) {
+		return DDERR_GENERIC;
+	}
+	if (!SDL_ClaimWindowForGPUDevice(device, DDWindow)) {
+		return DDERR_GENERIC;
+	}
+
+	*outDevice = static_cast<IDirect3DRMDevice2*>(new Direct3DRMDevice2_SDL3GPUImpl(width, height, device));
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateDeviceFromD3D(
+	const IDirect3D2* d3d,
+	IDirect3DDevice2* d3dDevice,
+	IDirect3DRMDevice2** outDevice
+)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return CreateDevice(outDevice, 640, 480);
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateDeviceFromSurface(
+	const GUID* guid,
+	IDirectDraw* dd,
+	IDirectDrawSurface* surface,
+	IDirect3DRMDevice2** outDevice
+)
+{
+	MINIWIN_NOT_IMPLEMENTED(); // Respect the chosen GUID
+	DDSURFACEDESC DDSDesc;
+	DDSDesc.dwSize = sizeof(DDSURFACEDESC);
+	surface->GetSurfaceDesc(&DDSDesc);
+	return CreateDevice(outDevice, DDSDesc.dwWidth, DDSDesc.dwHeight);
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTexture_SDL3GPUImpl);
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture)
+
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTexture_SDL3GPUImpl);
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateMesh(IDirect3DRMMesh** outMesh)
+{
+	*outMesh = static_cast<IDirect3DRMMesh*>(new Direct3DRMMesh_SDL3GPUImpl);
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial)
+{
+	*outMaterial = static_cast<IDirect3DRMMaterial*>(new Direct3DRMMaterial_SDL3GPUImpl(power));
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateLightRGB(
+	D3DRMLIGHTTYPE type,
+	D3DVAL r,
+	D3DVAL g,
+	D3DVAL b,
+	IDirect3DRMLight** outLight
+)
+{
+	*outLight = static_cast<IDirect3DRMLight*>(new Direct3DRMLight_SDL3GPUImpl(r, g, b));
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame)
+{
+	auto parentImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(parent);
+	*outFrame = static_cast<IDirect3DRMFrame2*>(new Direct3DRMFrame_SDL3GPUImpl{parentImpl});
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::CreateViewport(
+	IDirect3DRMDevice2* iDevice,
+	IDirect3DRMFrame* camera,
+	int x,
+	int y,
+	int width,
+	int height,
+	IDirect3DRMViewport** outViewport
+)
+{
+	auto device = static_cast<Direct3DRMDevice2_SDL3GPUImpl*>(iDevice);
+
+	SDL_GPUGraphicsPipeline* pipeline = InitializeGraphicsPipeline(device->m_device);
+	if (!pipeline) {
+		return DDERR_GENERIC;
+	}
+
+	SDL_GPUTextureCreateInfo textureInfo = {};
+	textureInfo.type = SDL_GPU_TEXTURETYPE_2D;
+	textureInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB;
+	textureInfo.width = width;
+	textureInfo.height = height;
+	textureInfo.layer_count_or_depth = 1;
+	textureInfo.num_levels = 1;
+	textureInfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
+	SDL_GPUTexture* transferTexture = SDL_CreateGPUTexture(device->m_device, &textureInfo);
+	if (!transferTexture) {
+		return DDERR_GENERIC;
+	}
+
+	// Setup texture GPU-to-CPU transfer
+	SDL_GPUTransferBufferCreateInfo downloadTransferInfo = {};
+	downloadTransferInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD;
+	downloadTransferInfo.size = static_cast<Uint32>(width * height * 4);
+	SDL_GPUTransferBuffer* downloadTransferBuffer =
+		SDL_CreateGPUTransferBuffer(device->m_device, &downloadTransferInfo);
+	if (!downloadTransferBuffer) {
+		return DDERR_GENERIC;
+	}
+
+	*outViewport = static_cast<IDirect3DRMViewport*>(new Direct3DRMViewport_SDL3GPUImpl(
+		width,
+		height,
+		device->m_device,
+		transferTexture,
+		downloadTransferBuffer,
+		pipeline
+	));
+	device->AddViewport(*outViewport);
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::SetDefaultTextureShades(DWORD count)
+{
+	return DD_OK;
+}
+
+HRESULT Direct3DRM_SDL3GPUImpl::SetDefaultTextureColors(DWORD count)
+{
+	return DD_OK;
+}

miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp

@@ -0,0 +1,123 @@
+#include "miniwin_d3drm.h"
+#include "miniwin_d3drm_sdl3gpu.h"
+#include "miniwin_d3drmdevice_sdl3gpu.h"
+#include "miniwin_d3drmobject_sdl3gpu.h"
+#include "miniwin_d3drmviewport_sdl3gpu.h"
+#include "miniwin_p.h"
+
+#include <SDL3/SDL.h>
+
+Direct3DRMDevice2_SDL3GPUImpl::Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device)
+	: m_width(width), m_height(height), m_device(device), m_viewports(new Direct3DRMViewportArray_SDL3GPUImpl)
+{
+}
+
+Direct3DRMDevice2_SDL3GPUImpl::~Direct3DRMDevice2_SDL3GPUImpl()
+{
+	for (int i = 0; i < m_viewports->GetSize(); i++) {
+		IDirect3DRMViewport* viewport;
+		m_viewports->GetElement(i, &viewport);
+		static_cast<Direct3DRMViewport_SDL3GPUImpl*>(viewport)->CloseDevice();
+		viewport->Release();
+	}
+	m_viewports->Release();
+
+	SDL_ReleaseWindowFromGPUDevice(m_device, DDWindow);
+	SDL_DestroyGPUDevice(m_device);
+}
+
+DWORD Direct3DRMDevice2_SDL3GPUImpl::GetWidth()
+{
+	return m_width;
+}
+
+DWORD Direct3DRMDevice2_SDL3GPUImpl::GetHeight()
+{
+	return m_height;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetBufferCount(int count)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+DWORD Direct3DRMDevice2_SDL3GPUImpl::GetBufferCount()
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return 2;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetShades(DWORD shadeCount)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::GetShades()
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetQuality(D3DRMRENDERQUALITY quality)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+D3DRMRENDERQUALITY Direct3DRMDevice2_SDL3GPUImpl::GetQuality()
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return D3DRMRENDERQUALITY::GOURAUD;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetDither(BOOL dither)
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+BOOL Direct3DRMDevice2_SDL3GPUImpl::GetDither()
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return false;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetTextureQuality(D3DRMTEXTUREQUALITY quality)
+{
+	return DD_OK;
+}
+
+D3DRMTEXTUREQUALITY Direct3DRMDevice2_SDL3GPUImpl::GetTextureQuality()
+{
+	return D3DRMTEXTUREQUALITY::LINEAR;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::SetRenderMode(D3DRMRENDERMODE mode)
+{
+	return DD_OK;
+}
+
+D3DRMRENDERMODE Direct3DRMDevice2_SDL3GPUImpl::GetRenderMode()
+{
+	return D3DRMRENDERMODE::BLENDEDTRANSPARENCY;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::Update()
+{
+	MINIWIN_NOT_IMPLEMENTED();
+	return DD_OK;
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::AddViewport(IDirect3DRMViewport* viewport)
+{
+	return m_viewports->AddElement(viewport);
+}
+
+HRESULT Direct3DRMDevice2_SDL3GPUImpl::GetViewports(IDirect3DRMViewportArray** ppViewportArray)
+{
+	m_viewports->AddRef();
+	*ppViewportArray = m_viewports;
+	return DD_OK;
+}

miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp

@@ -1,26 +1,26 @@
-#include "miniwin_d3drm_p.h"
+#include "miniwin_d3drm_sdl3gpu.h"
-#include "miniwin_d3drmframe_p.h"
+#include "miniwin_d3drmframe_sdl3gpu.h"
-#include "miniwin_d3drmlight_p.h"
+#include "miniwin_d3drmlight_sdl3gpu.h"
-#include "miniwin_d3drmtexture_p.h"
+#include "miniwin_d3drmtexture_sdl3gpu.h"
-#include "miniwin_d3drmvisual_p.h"
+#include "miniwin_d3drmvisual_sdl3gpu.h"
 #include "miniwin_p.h"
 
 #include <cstring>
 
-Direct3DRMFrameImpl::Direct3DRMFrameImpl(Direct3DRMFrameImpl* parent)
+Direct3DRMFrame_SDL3GPUImpl::Direct3DRMFrame_SDL3GPUImpl(Direct3DRMFrame_SDL3GPUImpl* parent)
 {
-	m_children = new Direct3DRMFrameArrayImpl;
+	m_children = new Direct3DRMFrameArray_SDL3GPUImpl;
 	m_children->AddRef();
-	m_lights = new Direct3DRMLightArrayImpl;
+	m_lights = new Direct3DRMLightArray_SDL3GPUImpl;
 	m_lights->AddRef();
-	m_visuals = new Direct3DRMVisualArrayImpl;
+	m_visuals = new Direct3DRMVisualArray_SDL3GPUImpl;
 	m_visuals->AddRef();
 	if (parent) {
 		parent->AddChild(this);
 	}
 }
 
-Direct3DRMFrameImpl::~Direct3DRMFrameImpl()
+Direct3DRMFrame_SDL3GPUImpl::~Direct3DRMFrame_SDL3GPUImpl()
 {
 	m_children->Release();
 	m_lights->Release();
@@ -30,7 +30,7 @@ Direct3DRMFrameImpl::~Direct3DRMFrameImpl()
 	}
 }
 
-HRESULT Direct3DRMFrameImpl::QueryInterface(const GUID& riid, void** ppvObject)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
 {
 	if (SDL_memcmp(&riid, &IID_IDirect3DRMFrame, sizeof(GUID)) == 0) {
 		this->IUnknown::AddRef();
@@ -40,13 +40,13 @@ HRESULT Direct3DRMFrameImpl::QueryInterface(const GUID& riid, void** ppvObject)
 	if (SDL_memcmp(&riid, &IID_IDirect3DRMMesh, sizeof(GUID)) == 0) {
 		return E_NOINTERFACE;
 	}
-	SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRMFrameImpl does not implement guid");
+	SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRMFrame_SDL3GPUImpl does not implement guid");
 	return E_NOINTERFACE;
 }
 
-HRESULT Direct3DRMFrameImpl::AddChild(IDirect3DRMFrame* child)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::AddChild(IDirect3DRMFrame* child)
 {
-	Direct3DRMFrameImpl* childImpl = static_cast<Direct3DRMFrameImpl*>(child);
+	Direct3DRMFrame_SDL3GPUImpl* childImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(child);
 	if (childImpl->m_parent) {
 		if (childImpl->m_parent == this) {
 			return DD_OK;
@@ -58,9 +58,9 @@ HRESULT Direct3DRMFrameImpl::AddChild(IDirect3DRMFrame* child)
 	return m_children->AddElement(child);
 }
 
-HRESULT Direct3DRMFrameImpl::DeleteChild(IDirect3DRMFrame* child)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::DeleteChild(IDirect3DRMFrame* child)
 {
-	Direct3DRMFrameImpl* childImpl = static_cast<Direct3DRMFrameImpl*>(child);
+	Direct3DRMFrame_SDL3GPUImpl* childImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(child);
 	HRESULT result = m_children->DeleteElement(childImpl);
 	if (result == DD_OK) {
 		childImpl->m_parent = nullptr;
@@ -68,26 +68,26 @@ HRESULT Direct3DRMFrameImpl::DeleteChild(IDirect3DRMFrame* child)
 	return result;
 }
 
-HRESULT Direct3DRMFrameImpl::SetSceneBackgroundRGB(float r, float g, float b)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetSceneBackgroundRGB(float r, float g, float b)
 {
 	m_backgroundColor = (0xFF << 24) | (static_cast<BYTE>(r * 255.0f) << 16) | (static_cast<BYTE>(g * 255.0f) << 8) |
 						(static_cast<BYTE>(b * 255.0f));
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::AddLight(IDirect3DRMLight* light)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::AddLight(IDirect3DRMLight* light)
 {
 	return m_lights->AddElement(light);
 }
 
-HRESULT Direct3DRMFrameImpl::GetLights(IDirect3DRMLightArray** lightArray)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::GetLights(IDirect3DRMLightArray** lightArray)
 {
 	*lightArray = m_lights;
 	m_lights->AddRef();
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::AddTransform(D3DRMCOMBINETYPE combine, D3DRMMATRIX4D matrix)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::AddTransform(D3DRMCOMBINETYPE combine, D3DRMMATRIX4D matrix)
 {
 	switch (combine) {
 	case D3DRMCOMBINETYPE::REPLACE:
@@ -99,7 +99,7 @@ HRESULT Direct3DRMFrameImpl::AddTransform(D3DRMCOMBINETYPE combine, D3DRMMATRIX4
 	}
 }
 
-HRESULT Direct3DRMFrameImpl::GetPosition(IDirect3DRMFrame* reference, D3DVECTOR* position)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::GetPosition(IDirect3DRMFrame* reference, D3DVECTOR* position)
 {
 	if (reference) {
 		MINIWIN_NOT_IMPLEMENTED();
@@ -111,26 +111,26 @@ HRESULT Direct3DRMFrameImpl::GetPosition(IDirect3DRMFrame* reference, D3DVECTOR*
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::AddVisual(IDirect3DRMVisual* visual)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::AddVisual(IDirect3DRMVisual* visual)
 {
 	return m_visuals->AddElement(visual);
 }
 
-HRESULT Direct3DRMFrameImpl::DeleteVisual(IDirect3DRMVisual* visual)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::DeleteVisual(IDirect3DRMVisual* visual)
 {
 	return m_visuals->DeleteElement(visual);
 }
 
-HRESULT Direct3DRMFrameImpl::GetVisuals(IDirect3DRMVisualArray** visuals)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::GetVisuals(IDirect3DRMVisualArray** visuals)
 {
 	*visuals = m_visuals;
 	m_visuals->AddRef();
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::SetTexture(IDirect3DRMTexture* texture)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetTexture(IDirect3DRMTexture* texture)
 {
-	auto textureImpl = static_cast<Direct3DRMTextureImpl*>(texture);
+	auto textureImpl = static_cast<Direct3DRMTexture_SDL3GPUImpl*>(texture);
 	if (m_texture) {
 		m_texture->Release();
 	}
@@ -140,7 +140,7 @@ HRESULT Direct3DRMFrameImpl::SetTexture(IDirect3DRMTexture* texture)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::GetTexture(IDirect3DRMTexture** texture)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::GetTexture(IDirect3DRMTexture** texture)
 {
 	if (!m_texture) {
 		return DDERR_GENERIC;
@@ -153,31 +153,31 @@ HRESULT Direct3DRMFrameImpl::GetTexture(IDirect3DRMTexture** texture)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::SetColor(float r, float g, float b, float a)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetColor(float r, float g, float b, float a)
 {
 	m_color = (static_cast<BYTE>(a * 255.0f) << 24) | (static_cast<BYTE>(r * 255.0f) << 16) |
 			  (static_cast<BYTE>(g * 255.0f) << 8) | (static_cast<BYTE>(b * 255.0f));
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::SetColor(D3DCOLOR c)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetColor(D3DCOLOR c)
 {
 	m_color = c;
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::SetColorRGB(float r, float g, float b)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetColorRGB(float r, float g, float b)
 {
 	return SetColor(r, g, b, 1.f);
 }
 
-HRESULT Direct3DRMFrameImpl::SetMaterialMode(D3DRMMATERIALMODE mode)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::SetMaterialMode(D3DRMMATERIALMODE mode)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT Direct3DRMFrameImpl::GetChildren(IDirect3DRMFrameArray** children)
+HRESULT Direct3DRMFrame_SDL3GPUImpl::GetChildren(IDirect3DRMFrameArray** children)
 {
 	*children = m_children;
 	m_children->AddRef();

miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp

@@ -1,12 +1,12 @@
-#include "miniwin_d3drmlight_p.h"
+#include "miniwin_d3drmlight_sdl3gpu.h"
 #include "miniwin_p.h"
 
-Direct3DRMLightImpl::Direct3DRMLightImpl(float r, float g, float b)
+Direct3DRMLight_SDL3GPUImpl::Direct3DRMLight_SDL3GPUImpl(float r, float g, float b)
 {
 	SetColorRGB(r, g, b);
 }
 
-HRESULT Direct3DRMLightImpl::SetColorRGB(float r, float g, float b)
+HRESULT Direct3DRMLight_SDL3GPUImpl::SetColorRGB(float r, float g, float b)
 {
 	m_color = (0xFF << 24) | (static_cast<BYTE>(r * 255.0f) << 16) | (static_cast<BYTE>(g * 255.0f) << 8) |
 			  (static_cast<BYTE>(b * 255.0f));

miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp

@@ -1,9 +1,9 @@
-#include "miniwin_d3drmmesh_p.h"
+#include "miniwin_d3drmmesh_sdl3gpu.h"
 #include "miniwin_p.h"
 
 #include <limits>
 
-HRESULT Direct3DRMMeshImpl::QueryInterface(const GUID& riid, void** ppvObject)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
 {
 	if (SDL_memcmp(&riid, &IID_IDirect3DRMMesh, sizeof(GUID)) == 0) {
 		this->IUnknown::AddRef();
@@ -17,13 +17,13 @@ HRESULT Direct3DRMMeshImpl::QueryInterface(const GUID& riid, void** ppvObject)
 	return E_NOINTERFACE;
 }
 
-HRESULT Direct3DRMMeshImpl::Clone(int flags, GUID iid, void** object)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::Clone(int flags, GUID iid, void** object)
 {
 	if (!object || SDL_memcmp(&iid, &IID_IDirect3DRMMesh, sizeof(GUID)) != 0) {
 		return DDERR_INVALIDPARAMS;
 	}
 
-	auto* clone = new Direct3DRMMeshImpl(*this);
+	auto* clone = new Direct3DRMMesh_SDL3GPUImpl(*this);
 
 	for (auto& group : clone->m_groups) {
 		// Reusing the same texture and material on the new mesh instead of cloning them might not be correct
@@ -39,7 +39,7 @@ HRESULT Direct3DRMMeshImpl::Clone(int flags, GUID iid, void** object)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::AddGroup(
+HRESULT Direct3DRMMesh_SDL3GPUImpl::AddGroup(
 	int vertexCount,
 	int faceCount,
 	int vertexPerFace,
@@ -66,7 +66,7 @@ HRESULT Direct3DRMMeshImpl::AddGroup(
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::GetGroup(
+HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroup(
 	DWORD groupIndex,
 	DWORD* vertexCount,
 	DWORD* faceCount,
@@ -100,12 +100,12 @@ HRESULT Direct3DRMMeshImpl::GetGroup(
 	return DD_OK;
 }
 
-DWORD Direct3DRMMeshImpl::GetGroupCount()
+DWORD Direct3DRMMesh_SDL3GPUImpl::GetGroupCount()
 {
 	return m_groups.size();
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_INVALIDPARAMS;
@@ -115,7 +115,7 @@ HRESULT Direct3DRMMeshImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupColorRGB(DWORD groupIndex, float r, float g, float b)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColorRGB(DWORD groupIndex, float r, float g, float b)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_INVALIDPARAMS;
@@ -128,7 +128,7 @@ HRESULT Direct3DRMMeshImpl::SetGroupColorRGB(DWORD groupIndex, float r, float g,
 	return DD_OK;
 }
 
-D3DCOLOR Direct3DRMMeshImpl::GetGroupColor(D3DRMGROUPINDEX index)
+D3DCOLOR Direct3DRMMesh_SDL3GPUImpl::GetGroupColor(D3DRMGROUPINDEX index)
 {
 	if (index < 0 || index >= static_cast<int>(m_groups.size())) {
 		return 0xFFFFFFFF;
@@ -136,7 +136,7 @@ D3DCOLOR Direct3DRMMeshImpl::GetGroupColor(D3DRMGROUPINDEX index)
 	return m_groups[index].color;
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupMaterial(DWORD groupIndex, IDirect3DRMMaterial* material)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupMaterial(DWORD groupIndex, IDirect3DRMMaterial* material)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_INVALIDPARAMS;
@@ -147,7 +147,7 @@ HRESULT Direct3DRMMeshImpl::SetGroupMaterial(DWORD groupIndex, IDirect3DRMMateri
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture* texture)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture* texture)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_INVALIDPARAMS;
@@ -158,7 +158,7 @@ HRESULT Direct3DRMMeshImpl::SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3DRMTEXTURE* texture)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3DRMTEXTURE* texture)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_GENERIC;
@@ -174,17 +174,17 @@ HRESULT Direct3DRMMeshImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3DRMTEXTUR
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupMapping(D3DRMGROUPINDEX groupIndex, D3DRMMAPPING mapping)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupMapping(D3DRMGROUPINDEX groupIndex, D3DRMMAPPING mapping)
 {
 	return DD_OK;
 }
 
-D3DRMMAPPING Direct3DRMMeshImpl::GetGroupMapping(DWORD groupIndex)
+D3DRMMAPPING Direct3DRMMesh_SDL3GPUImpl::GetGroupMapping(DWORD groupIndex)
 {
 	return D3DRMMAP_PERSPCORRECT;
 }
 
-HRESULT Direct3DRMMeshImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDERQUALITY quality)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDERQUALITY quality)
 {
 	if (groupIndex >= m_groups.size()) {
 		return DDERR_INVALIDPARAMS;
@@ -194,7 +194,7 @@ HRESULT Direct3DRMMeshImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDERQUALITY
 	return DD_OK;
 }
 
-D3DRMRENDERQUALITY Direct3DRMMeshImpl::GetGroupQuality(DWORD groupIndex)
+D3DRMRENDERQUALITY Direct3DRMMesh_SDL3GPUImpl::GetGroupQuality(DWORD groupIndex)
 {
 	if (groupIndex >= m_groups.size()) {
 		return D3DRMRENDER_GOURAUD;
@@ -203,7 +203,7 @@ D3DRMRENDERQUALITY Direct3DRMMeshImpl::GetGroupQuality(DWORD groupIndex)
 	return m_groups[groupIndex].quality;
 }
 
-HRESULT Direct3DRMMeshImpl::SetVertices(DWORD groupIndex, int offset, int count, D3DRMVERTEX* vertices)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::SetVertices(DWORD groupIndex, int offset, int count, D3DRMVERTEX* vertices)
 {
 	if (count <= 0 || offset < 0 || groupIndex < 0 || groupIndex >= static_cast<int>(m_groups.size())) {
 		return DDERR_INVALIDPARAMS;
@@ -219,7 +219,7 @@ HRESULT Direct3DRMMeshImpl::SetVertices(DWORD groupIndex, int offset, int count,
 	return DD_OK;
 }
 
-HRESULT Direct3DRMMeshImpl::GetVertices(DWORD groupIndex, int startIndex, int count, D3DRMVERTEX* vertices)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::GetVertices(DWORD groupIndex, int startIndex, int count, D3DRMVERTEX* vertices)
 {
 	if (count <= 0 || startIndex < 0 || groupIndex < 0 || groupIndex >= static_cast<int>(m_groups.size())) {
 		return DDERR_INVALIDPARAMS;
@@ -238,7 +238,7 @@ HRESULT Direct3DRMMeshImpl::GetVertices(DWORD groupIndex, int startIndex, int co
 /**
  * @todo Maybe a good idea to cache this
  */
-HRESULT Direct3DRMMeshImpl::GetBox(D3DRMBOX* box)
+HRESULT Direct3DRMMesh_SDL3GPUImpl::GetBox(D3DRMBOX* box)
 {
 	box->min.x = box->min.y = box->min.z = std::numeric_limits<float>::max();
 	box->max.x = box->max.y = box->max.z = std::numeric_limits<float>::min();

miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp

@@ -1,7 +1,7 @@
-#include "miniwin_d3drmtexture_p.h"
+#include "miniwin_d3drmtexture_sdl3gpu.h"
 #include "miniwin_p.h"
 
-HRESULT Direct3DRMTextureImpl::QueryInterface(const GUID& riid, void** ppvObject)
+HRESULT Direct3DRMTexture_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
 {
 	if (SDL_memcmp(&riid, &IID_IDirect3DRMTexture2, sizeof(GUID)) == 0) {
 		this->IUnknown::AddRef();
@@ -12,7 +12,7 @@ HRESULT Direct3DRMTextureImpl::QueryInterface(const GUID& riid, void** ppvObject
 	return E_NOINTERFACE;
 }
 
-HRESULT Direct3DRMTextureImpl::Changed(BOOL pixels, BOOL palette)
+HRESULT Direct3DRMTexture_SDL3GPUImpl::Changed(BOOL pixels, BOOL palette)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;

miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp

@@ -1,12 +1,12 @@
-#include "miniwin_d3drm_p.h"
+#include "miniwin_d3drm_sdl3gpu.h"
-#include "miniwin_d3drmframe_p.h"
+#include "miniwin_d3drmframe_sdl3gpu.h"
-#include "miniwin_d3drmviewport_p.h"
+#include "miniwin_d3drmviewport_sdl3gpu.h"
 #include "miniwin_p.h"
 
 #include <SDL3/SDL.h>
 #include <functional>
 
-Direct3DRMViewportImpl::Direct3DRMViewportImpl(
+Direct3DRMViewport_SDL3GPUImpl::Direct3DRMViewport_SDL3GPUImpl(
 	DWORD width,
 	DWORD height,
 	SDL_GPUDevice* device,
@@ -19,13 +19,13 @@ Direct3DRMViewportImpl::Direct3DRMViewportImpl(
 {
 }
 
-void Direct3DRMViewportImpl::FreeDeviceResources()
+void Direct3DRMViewport_SDL3GPUImpl::FreeDeviceResources()
 {
 	SDL_ReleaseGPUBuffer(m_device, m_vertexBuffer);
 	SDL_ReleaseGPUGraphicsPipeline(m_device, m_pipeline);
 }
 
-Direct3DRMViewportImpl::~Direct3DRMViewportImpl()
+Direct3DRMViewport_SDL3GPUImpl::~Direct3DRMViewport_SDL3GPUImpl()
 {
 	FreeDeviceResources();
 }
@@ -42,7 +42,7 @@ void D3DRMMatrixMultiply(D3DRMMATRIX4D out, const D3DRMMATRIX4D a, const D3DRMMA
 	}
 }
 
-HRESULT Direct3DRMViewportImpl::CollectSceneData(IDirect3DRMFrame* group)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::CollectSceneData(IDirect3DRMFrame* group)
 {
 	MINIWIN_NOT_IMPLEMENTED(); // Lights, camera, textures, materials
 
@@ -51,7 +51,7 @@ HRESULT Direct3DRMViewportImpl::CollectSceneData(IDirect3DRMFrame* group)
 
 	recurseFrame = [&](IDirect3DRMFrame* frame, D3DRMMATRIX4D parentMatrix) {
 		// Retrieve the current frame's transform
-		Direct3DRMFrameImpl* frameImpl = static_cast<Direct3DRMFrameImpl*>(frame);
+		Direct3DRMFrame_SDL3GPUImpl* frameImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(frame);
 		D3DRMMATRIX4D localMatrix;
 		memcpy(localMatrix, frameImpl->m_transform, sizeof(D3DRMMATRIX4D));
 
@@ -135,7 +135,7 @@ HRESULT Direct3DRMViewportImpl::CollectSceneData(IDirect3DRMFrame* group)
 	return D3DRM_OK;
 }
 
-void Direct3DRMViewportImpl::PushVertices(const PositionColorVertex* vertices, size_t count)
+void Direct3DRMViewport_SDL3GPUImpl::PushVertices(const PositionColorVertex* vertices, size_t count)
 {
 	if (count > m_vertexBufferCount) {
 		if (m_vertexBuffer) {
@@ -184,7 +184,7 @@ void Direct3DRMViewportImpl::PushVertices(const PositionColorVertex* vertices, s
 	SDL_ReleaseGPUTransferBuffer(m_device, transferBuffer);
 }
 
-HRESULT Direct3DRMViewportImpl::Render(IDirect3DRMFrame* group)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::Render(IDirect3DRMFrame* group)
 {
 	if (!m_device) {
 		return DDERR_GENERIC;
@@ -258,7 +258,7 @@ HRESULT Direct3DRMViewportImpl::Render(IDirect3DRMFrame* group)
 	return ForceUpdate(0, 0, DDBackBuffer->w, DDBackBuffer->h);
 }
 
-HRESULT Direct3DRMViewportImpl::ForceUpdate(int x, int y, int w, int h)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::ForceUpdate(int x, int y, int w, int h)
 {
 	if (!m_renderedImage) {
 		return DDERR_GENERIC;
@@ -292,7 +292,7 @@ HRESULT Direct3DRMViewportImpl::ForceUpdate(int x, int y, int w, int h)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::Clear()
+HRESULT Direct3DRMViewport_SDL3GPUImpl::Clear()
 {
 	if (!DDBackBuffer) {
 		return DDERR_GENERIC;
@@ -307,7 +307,7 @@ HRESULT Direct3DRMViewportImpl::Clear()
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::SetCamera(IDirect3DRMFrame* camera)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::SetCamera(IDirect3DRMFrame* camera)
 {
 	if (m_camera) {
 		m_camera->Release();
@@ -319,7 +319,7 @@ HRESULT Direct3DRMViewportImpl::SetCamera(IDirect3DRMFrame* camera)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::GetCamera(IDirect3DRMFrame** camera)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::GetCamera(IDirect3DRMFrame** camera)
 {
 	if (m_camera) {
 		m_camera->AddRef();
@@ -328,78 +328,78 @@ HRESULT Direct3DRMViewportImpl::GetCamera(IDirect3DRMFrame** camera)
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::SetProjection(D3DRMPROJECTIONTYPE type)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::SetProjection(D3DRMPROJECTIONTYPE type)
 {
 	return DD_OK;
 }
 
-D3DRMPROJECTIONTYPE Direct3DRMViewportImpl::GetProjection()
+D3DRMPROJECTIONTYPE Direct3DRMViewport_SDL3GPUImpl::GetProjection()
 {
 	return D3DRMPROJECTIONTYPE::PERSPECTIVE;
 }
 
-HRESULT Direct3DRMViewportImpl::SetFront(D3DVALUE z)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::SetFront(D3DVALUE z)
 {
 	m_zMin = z;
 	return DD_OK;
 }
 
-D3DVALUE Direct3DRMViewportImpl::GetFront()
+D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetFront()
 {
 	return m_zMin;
 }
 
-HRESULT Direct3DRMViewportImpl::SetBack(D3DVALUE z)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::SetBack(D3DVALUE z)
 {
 	m_zMax = z;
 	return DD_OK;
 }
 
-D3DVALUE Direct3DRMViewportImpl::GetBack()
+D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetBack()
 {
 	return m_zMax;
 }
 
-HRESULT Direct3DRMViewportImpl::SetField(D3DVALUE field)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::SetField(D3DVALUE field)
 {
 	m_fov = field;
 	return DD_OK;
 }
 
-D3DVALUE Direct3DRMViewportImpl::GetField()
+D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetField()
 {
 	return m_fov;
 }
 
-DWORD Direct3DRMViewportImpl::GetWidth()
+DWORD Direct3DRMViewport_SDL3GPUImpl::GetWidth()
 {
 	return m_width;
 }
 
-DWORD Direct3DRMViewportImpl::GetHeight()
+DWORD Direct3DRMViewport_SDL3GPUImpl::GetHeight()
 {
 	return m_height;
 }
 
-HRESULT Direct3DRMViewportImpl::Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT Direct3DRMViewportImpl::Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray)
+HRESULT Direct3DRMViewport_SDL3GPUImpl::Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-void Direct3DRMViewportImpl::CloseDevice()
+void Direct3DRMViewport_SDL3GPUImpl::CloseDevice()
 {
 	FreeDeviceResources();
 	m_device = nullptr;

miniwin/sdl3gpu/src/miniwin_ddpalette.cpp

@@ -1,20 +1,25 @@
-#include "miniwin_ddpalette_p.h"
+#include "miniwin_ddpalette_sdl3gpu.h"
 #include "miniwin_ddraw.h"
 
 #include <SDL3/SDL.h>
 
-DirectDrawPaletteImpl::DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable)
+DirectDrawPalette_SDL3GPUImpl::DirectDrawPalette_SDL3GPUImpl(LPPALETTEENTRY lpColorTable)
 {
 	m_palette = SDL_CreatePalette(256);
 	SetEntries(0, 0, 256, lpColorTable);
 }
 
-DirectDrawPaletteImpl::~DirectDrawPaletteImpl()
+DirectDrawPalette_SDL3GPUImpl::~DirectDrawPalette_SDL3GPUImpl()
 {
 	SDL_DestroyPalette(m_palette);
 }
 
-HRESULT DirectDrawPaletteImpl::GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries)
+HRESULT DirectDrawPalette_SDL3GPUImpl::GetEntries(
+	DWORD dwFlags,
+	DWORD dwBase,
+	DWORD dwNumEntries,
+	LPPALETTEENTRY lpEntries
+)
 {
 	for (DWORD i = 0; i < dwNumEntries; i++) {
 		lpEntries[i].peRed = m_palette->colors[dwBase + i].r;
@@ -25,7 +30,12 @@ HRESULT DirectDrawPaletteImpl::GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwN
 	return DD_OK;
 }
 
-HRESULT DirectDrawPaletteImpl::SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries)
+HRESULT DirectDrawPalette_SDL3GPUImpl::SetEntries(
+	DWORD dwFlags,
+	DWORD dwStartingEntry,
+	DWORD dwCount,
+	LPPALETTEENTRY lpEntries
+)
 {
 	SDL_Color colors[256];
 	for (DWORD i = 0; i < dwCount; i++) {

miniwin/sdl3gpu/src/miniwin_ddraw.cpp

@@ -1,8 +1,8 @@
 
 #include "miniwin_d3d.h"
-#include "miniwin_ddpalette_p.h"
+#include "miniwin_ddpalette_sdl3gpu.h"
-#include "miniwin_ddraw_p.h"
+#include "miniwin_ddraw_sdl3gpu.h"
-#include "miniwin_ddsurface_p.h"
+#include "miniwin_ddsurface_sdl3gpu.h"
 #include "miniwin_p.h"
 
 #include <SDL3/SDL.h>
@@ -19,7 +19,7 @@ HRESULT IDirectDrawClipper::SetHWnd(DWORD unnamedParam1, HWND hWnd)
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::QueryInterface(const GUID& riid, void** ppvObject)
+HRESULT DirectDraw_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
 {
 	if (SDL_memcmp(&riid, &IID_IDirectDraw2, sizeof(GUID)) == 0) {
 		this->IUnknown::AddRef();
@@ -36,14 +36,14 @@ HRESULT DirectDrawImpl::QueryInterface(const GUID& riid, void** ppvObject)
 }
 
 // IDirectDraw interface
-HRESULT DirectDrawImpl::CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter)
+HRESULT DirectDraw_SDL3GPUImpl::CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter)
 {
 	*lplpDDClipper = new IDirectDrawClipper;
 
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::CreatePalette(
+HRESULT DirectDraw_SDL3GPUImpl::CreatePalette(
 	DDPixelCaps dwFlags,
 	LPPALETTEENTRY lpColorTable,
 	LPDIRECTDRAWPALETTE* lplpDDPalette,
@@ -54,11 +54,11 @@ HRESULT DirectDrawImpl::CreatePalette(
 		return DDERR_INVALIDPARAMS;
 	}
 
-	*lplpDDPalette = static_cast<LPDIRECTDRAWPALETTE>(new DirectDrawPaletteImpl(lpColorTable));
+	*lplpDDPalette = static_cast<LPDIRECTDRAWPALETTE>(new DirectDrawPalette_SDL3GPUImpl(lpColorTable));
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::CreateSurface(
+HRESULT DirectDraw_SDL3GPUImpl::CreateSurface(
 	LPDDSURFACEDESC lpDDSurfaceDesc,
 	LPDIRECTDRAWSURFACE* lplpDDSurface,
 	IUnknown* pUnkOuter
@@ -88,7 +88,7 @@ HRESULT DirectDrawImpl::CreateSurface(
 				return DDERR_INVALIDPARAMS;
 			}
 			SDL_Log("Todo: Set %dbit Z-Buffer", lpDDSurfaceDesc->dwZBufferBitDepth);
-			*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurfaceImpl);
+			*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurface_SDL3GPUImpl);
 			return DD_OK;
 		}
 		if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) == DDSCAPS_PRIMARYSURFACE) {
@@ -99,7 +99,7 @@ HRESULT DirectDrawImpl::CreateSurface(
 			int width, height;
 			SDL_GetWindowSize(DDWindow, &width, &height);
 			bool implicitFlip = (lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_FLIP) != DDSCAPS_FLIP;
-			auto frontBuffer = new DirectDrawSurfaceImpl(width, height, windowSurface->format);
+			auto frontBuffer = new DirectDrawSurface_SDL3GPUImpl(width, height, windowSurface->format);
 			frontBuffer->SetAutoFlip(implicitFlip);
 			*lplpDDSurface = static_cast<IDirectDrawSurface*>(frontBuffer);
 			return DD_OK;
@@ -130,11 +130,11 @@ HRESULT DirectDrawImpl::CreateSurface(
 	if (width == 0 || height == 0) {
 		return DDERR_INVALIDPARAMS;
 	}
-	*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurfaceImpl(width, height, format));
+	*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurface_SDL3GPUImpl(width, height, format));
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::EnumDisplayModes(
+HRESULT DirectDraw_SDL3GPUImpl::EnumDisplayModes(
 	DWORD dwFlags,
 	LPDDSURFACEDESC lpDDSurfaceDesc,
 	LPVOID lpContext,
@@ -190,13 +190,13 @@ HRESULT DirectDrawImpl::EnumDisplayModes(
 	return status;
 }
 
-HRESULT DirectDrawImpl::FlipToGDISurface()
+HRESULT DirectDraw_SDL3GPUImpl::FlipToGDISurface()
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
+HRESULT DirectDraw_SDL3GPUImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
 {
 	if (lpDDDriverCaps) {
 		if (lpDDDriverCaps->dwSize >= sizeof(DDCAPS)) {
@@ -213,7 +213,7 @@ HRESULT DirectDrawImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
 	return S_OK;
 }
 
-HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
+HRESULT DirectDraw_SDL3GPUImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
 {
 	int numDrivers = SDL_GetNumRenderDrivers();
 	if (numDrivers <= 0) {
@@ -269,7 +269,7 @@ HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
 	return S_OK;
 }
 
-HRESULT DirectDrawImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
+HRESULT DirectDraw_SDL3GPUImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
 {
 	SDL_DisplayID displayID = SDL_GetPrimaryDisplay();
 	if (!displayID) {
@@ -305,13 +305,13 @@ HRESULT DirectDrawImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::RestoreDisplayMode()
+HRESULT DirectDraw_SDL3GPUImpl::RestoreDisplayMode()
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
+HRESULT DirectDraw_SDL3GPUImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
 {
 	if (hWnd) {
 		bool fullscreen;
@@ -333,14 +333,14 @@ HRESULT DirectDrawImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
 	return DD_OK;
 }
 
-HRESULT DirectDrawImpl::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
+HRESULT DirectDraw_SDL3GPUImpl::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
 // IDirect3D2 interface
-HRESULT DirectDrawImpl::CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice)
+HRESULT DirectDraw_SDL3GPUImpl::CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice)
 {
 	*ppDirect3DDevice = new IDirect3DDevice2;
 	return DD_OK;
@@ -352,7 +352,7 @@ HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOute
 		MINIWIN_NOT_IMPLEMENTED();
 	}
 
-	*lplpDD = new DirectDrawImpl;
+	*lplpDD = new DirectDraw_SDL3GPUImpl;
 
 	return DD_OK;
 }

miniwin/sdl3gpu/src/miniwin_ddsurface.cpp

@@ -1,15 +1,15 @@
-#include "miniwin_ddpalette_p.h"
+#include "miniwin_ddpalette_sdl3gpu.h"
-#include "miniwin_ddraw_p.h"
+#include "miniwin_ddraw_sdl3gpu.h"
-#include "miniwin_ddsurface_p.h"
+#include "miniwin_ddsurface_sdl3gpu.h"
 #include "miniwin_p.h"
 
 #include <assert.h>
 
-DirectDrawSurfaceImpl::DirectDrawSurfaceImpl()
+DirectDrawSurface_SDL3GPUImpl::DirectDrawSurface_SDL3GPUImpl()
 {
 }
 
-DirectDrawSurfaceImpl::DirectDrawSurfaceImpl(int width, int height, SDL_PixelFormat format)
+DirectDrawSurface_SDL3GPUImpl::DirectDrawSurface_SDL3GPUImpl(int width, int height, SDL_PixelFormat format)
 {
 	m_surface = SDL_CreateSurface(width, height, format);
 	if (!m_surface) {
@@ -17,7 +17,7 @@ DirectDrawSurfaceImpl::DirectDrawSurfaceImpl(int width, int height, SDL_PixelFor
 	}
 }
 
-DirectDrawSurfaceImpl::~DirectDrawSurfaceImpl()
+DirectDrawSurface_SDL3GPUImpl::~DirectDrawSurface_SDL3GPUImpl()
 {
 	if (m_surface) {
 		SDL_DestroySurface(m_surface);
@@ -28,7 +28,7 @@ DirectDrawSurfaceImpl::~DirectDrawSurfaceImpl()
 }
 
 // IUnknown interface
-HRESULT DirectDrawSurfaceImpl::QueryInterface(const GUID& riid, void** ppvObject)
+HRESULT DirectDrawSurface_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
 {
 	if (SDL_memcmp(&riid, &IID_IDirectDrawSurface3, sizeof(GUID)) == 0) {
 		this->IUnknown::AddRef();
@@ -40,12 +40,12 @@ HRESULT DirectDrawSurfaceImpl::QueryInterface(const GUID& riid, void** ppvObject
 }
 
 // IDirectDrawSurface interface
-HRESULT DirectDrawSurfaceImpl::AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
+HRESULT DirectDrawSurface_SDL3GPUImpl::AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
 {
 	return DD_OK;
 }
 
-void DirectDrawSurfaceImpl::SetAutoFlip(bool enabled)
+void DirectDrawSurface_SDL3GPUImpl::SetAutoFlip(bool enabled)
 {
 	m_autoFlip = enabled;
 }
@@ -55,7 +55,7 @@ static SDL_Rect ConvertRect(const RECT* r)
 	return {r->left, r->top, r->right - r->left, r->bottom - r->top};
 }
 
-HRESULT DirectDrawSurfaceImpl::Blt(
+HRESULT DirectDrawSurface_SDL3GPUImpl::Blt(
 	LPRECT lpDestRect,
 	LPDIRECTDRAWSURFACE lpDDSrcSurface,
 	LPRECT lpSrcRect,
@@ -63,7 +63,7 @@ HRESULT DirectDrawSurfaceImpl::Blt(
 	LPDDBLTFX lpDDBltFx
 )
 {
-	auto srcSurface = static_cast<DirectDrawSurfaceImpl*>(lpDDSrcSurface);
+	auto srcSurface = static_cast<DirectDrawSurface_SDL3GPUImpl*>(lpDDSrcSurface);
 	if (!srcSurface || !srcSurface->m_surface) {
 		return DDERR_GENERIC;
 	}
@@ -110,7 +110,7 @@ HRESULT DirectDrawSurfaceImpl::Blt(
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::BltFast(
+HRESULT DirectDrawSurface_SDL3GPUImpl::BltFast(
 	DWORD dwX,
 	DWORD dwY,
 	LPDIRECTDRAWSURFACE lpDDSrcSurface,
@@ -127,7 +127,7 @@ HRESULT DirectDrawSurfaceImpl::BltFast(
 	return Blt(&destRect, lpDDSrcSurface, lpSrcRect, DDBLT_NONE, nullptr);
 }
 
-HRESULT DirectDrawSurfaceImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags)
+HRESULT DirectDrawSurface_SDL3GPUImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags)
 {
 	if (!DDBackBuffer) {
 		return DDERR_GENERIC;
@@ -144,7 +144,10 @@ HRESULT DirectDrawSurfaceImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverrid
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface)
+HRESULT DirectDrawSurface_SDL3GPUImpl::GetAttachedSurface(
+	LPDDSCAPS lpDDSCaps,
+	LPDIRECTDRAWSURFACE* lplpDDAttachedSurface
+)
 {
 	if ((lpDDSCaps->dwCaps & DDSCAPS_BACKBUFFER) != DDSCAPS_BACKBUFFER) {
 		return DDERR_INVALIDPARAMS;
@@ -154,13 +157,13 @@ HRESULT DirectDrawSurfaceImpl::GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTD
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::GetDC(HDC* lphDC)
+HRESULT DirectDrawSurface_SDL3GPUImpl::GetDC(HDC* lphDC)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette)
+HRESULT DirectDrawSurface_SDL3GPUImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette)
 {
 	if (!m_palette) {
 		return DDERR_GENERIC;
@@ -170,7 +173,7 @@ HRESULT DirectDrawSurfaceImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette)
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat)
+HRESULT DirectDrawSurface_SDL3GPUImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat)
 {
 	if (!m_surface) {
 		return DDERR_GENERIC;
@@ -188,7 +191,7 @@ HRESULT DirectDrawSurfaceImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat)
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc)
+HRESULT DirectDrawSurface_SDL3GPUImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc)
 {
 	if (!m_surface) {
 		return DDERR_GENERIC;
@@ -203,12 +206,12 @@ HRESULT DirectDrawSurfaceImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc)
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::IsLost()
+HRESULT DirectDrawSurface_SDL3GPUImpl::IsLost()
 {
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::Lock(
+HRESULT DirectDrawSurface_SDL3GPUImpl::Lock(
 	LPRECT lpDestRect,
 	LPDDSURFACEDESC lpDDSurfaceDesc,
 	DDLockFlags dwFlags,
@@ -230,23 +233,23 @@ HRESULT DirectDrawSurfaceImpl::Lock(
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::ReleaseDC(HDC hDC)
+HRESULT DirectDrawSurface_SDL3GPUImpl::ReleaseDC(HDC hDC)
 {
 	MINIWIN_NOT_IMPLEMENTED();
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::Restore()
+HRESULT DirectDrawSurface_SDL3GPUImpl::Restore()
 {
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper)
+HRESULT DirectDrawSurface_SDL3GPUImpl::SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper)
 {
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey)
+HRESULT DirectDrawSurface_SDL3GPUImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey)
 {
 	if (lpDDColorKey->dwColorSpaceLowValue != lpDDColorKey->dwColorSpaceHighValue) {
 		MINIWIN_NOT_IMPLEMENTED();
@@ -259,7 +262,7 @@ HRESULT DirectDrawSurfaceImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette)
+HRESULT DirectDrawSurface_SDL3GPUImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette)
 {
 	if (m_surface->format != SDL_PIXELFORMAT_INDEX8) {
 		MINIWIN_NOT_IMPLEMENTED();
@@ -270,12 +273,12 @@ HRESULT DirectDrawSurfaceImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette)
 	}
 
 	m_palette = lpDDPalette;
-	SDL_SetSurfacePalette(m_surface, ((DirectDrawPaletteImpl*) m_palette)->m_palette);
+	SDL_SetSurfacePalette(m_surface, ((DirectDrawPalette_SDL3GPUImpl*) m_palette)->m_palette);
 	m_palette->AddRef();
 	return DD_OK;
 }
 
-HRESULT DirectDrawSurfaceImpl::Unlock(LPVOID lpSurfaceData)
+HRESULT DirectDrawSurface_SDL3GPUImpl::Unlock(LPVOID lpSurfaceData)
 {
 	if (!m_surface) {
 		return DDERR_GENERIC;