diff --git a/CMakeLists.txt b/CMakeLists.txt index 81939a28..beb44744 100644 --- a/CMakeLists.txt +++ b/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/miniwin/src/miniwin_ddpalette.cpp - miniwin/miniwin/src/miniwin_ddsurface.cpp - 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 + miniwin/common/src/d3drm.cpp + miniwin/common/src/miniwin.cpp + ${miniwin_sdl3gpu_sources} ) # Force reported render mods from MiniWin target_compile_definitions(miniwin PRIVATE MINIWIN_PIXELFORMAT=SDL_PIXELFORMAT_RGB565) -target_include_directories(miniwin PUBLIC "$") -target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/src/include") -target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/generated") +target_include_directories(miniwin PUBLIC "$") +target_include_directories(miniwin PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/common/include") +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_gen_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/generated") -set(py_gencshadersource "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/miniwin/shaders/gencshadersource.py") +set(shader_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/src") +set(shader_gen_dir "${CMAKE_CURRENT_SOURCE_DIR}/miniwin/sdl3gpu/shaders/generated") +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 "$") -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) diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp index 5d724c67..82c9c817 100644 --- a/ISLE/isleapp.cpp +++ b/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 #include @@ -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; diff --git a/miniwin/miniwin/src/include/miniwin_p.h b/miniwin/common/include/miniwin_p.h similarity index 100% rename from miniwin/miniwin/src/include/miniwin_p.h rename to miniwin/common/include/miniwin_p.h diff --git a/miniwin/common/src/d3drm.cpp b/miniwin/common/src/d3drm.cpp new file mode 100644 index 00000000..f7596720 --- /dev/null +++ b/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 ""; + } +} + +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)); +} diff --git a/miniwin/miniwin/src/miniwin.cpp b/miniwin/common/src/miniwin.cpp similarity index 100% rename from miniwin/miniwin/src/miniwin.cpp rename to miniwin/common/src/miniwin.cpp diff --git a/miniwin/miniwin/include/bitflags.h b/miniwin/include/bitflags.h similarity index 100% rename from miniwin/miniwin/include/bitflags.h rename to miniwin/include/bitflags.h diff --git a/miniwin/miniwin/include/miniwin.h b/miniwin/include/miniwin.h similarity index 100% rename from miniwin/miniwin/include/miniwin.h rename to miniwin/include/miniwin.h diff --git a/miniwin/include/miniwin_config.h b/miniwin/include/miniwin_config.h new file mode 100644 index 00000000..b392e8b7 --- /dev/null +++ b/miniwin/include/miniwin_config.h @@ -0,0 +1,23 @@ +#ifndef MINIWIN_CONFIG_H +#define MINIWIN_CONFIG_H + +#include + +#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 diff --git a/miniwin/miniwin/include/miniwin_d3d.h b/miniwin/include/miniwin_d3d.h similarity index 100% rename from miniwin/miniwin/include/miniwin_d3d.h rename to miniwin/include/miniwin_d3d.h diff --git a/miniwin/miniwin/include/miniwin_d3drm.h b/miniwin/include/miniwin_d3drm.h similarity index 100% rename from miniwin/miniwin/include/miniwin_d3drm.h rename to miniwin/include/miniwin_d3drm.h diff --git a/miniwin/miniwin/include/miniwin_ddraw.h b/miniwin/include/miniwin_ddraw.h similarity index 100% rename from miniwin/miniwin/include/miniwin_ddraw.h rename to miniwin/include/miniwin_ddraw.h diff --git a/miniwin/miniwin/include/miniwin_dinput.h b/miniwin/include/miniwin_dinput.h similarity index 100% rename from miniwin/miniwin/include/miniwin_dinput.h rename to miniwin/include/miniwin_dinput.h diff --git a/miniwin/miniwin/include/miniwin_direct.h b/miniwin/include/miniwin_direct.h similarity index 100% rename from miniwin/miniwin/include/miniwin_direct.h rename to miniwin/include/miniwin_direct.h diff --git a/miniwin/miniwin/include/miniwin_process.h b/miniwin/include/miniwin_process.h similarity index 100% rename from miniwin/miniwin/include/miniwin_process.h rename to miniwin/include/miniwin_process.h diff --git a/miniwin/miniwin/src/include/miniwin_d3drm_p.h b/miniwin/miniwin/src/include/miniwin_d3drm_p.h deleted file mode 100644 index 88b5bda0..00000000 --- a/miniwin/miniwin/src/include/miniwin_d3drm_p.h +++ /dev/null @@ -1,61 +0,0 @@ -#pragma once - -#include "miniwin_d3drm.h" - -#include -#include -#include - -typedef struct PositionColorVertex { - float x, y, z; - Uint8 r, g, b, a; -} PositionColorVertex; - -template -class Direct3DRMArrayBase : public ArrayInterface { -public: - ~Direct3DRMArrayBase() override - { - for (auto* item : m_items) { - if (item) { - item->Release(); - } - } - } - DWORD GetSize() override { return static_cast(m_items.size()); } - HRESULT AddElement(InterfaceType* in) override - { - if (!in) { - return DDERR_INVALIDPARAMS; - } - auto inImpl = static_cast(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(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 m_items; -}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmlight_p.h b/miniwin/miniwin/src/include/miniwin_d3drmlight_p.h deleted file mode 100644 index 6bb68ace..00000000 --- a/miniwin/miniwin/src/include/miniwin_d3drmlight_p.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#include "miniwin_d3drm_p.h" -#include "miniwin_d3drmobject_p.h" -#include "miniwin_p.h" - -struct Direct3DRMLightImpl : public Direct3DRMObjectBase { - 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 { - using Direct3DRMArrayBase::Direct3DRMArrayBase; -}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmtexture_p.h b/miniwin/miniwin/src/include/miniwin_d3drmtexture_p.h deleted file mode 100644 index 55405e1d..00000000 --- a/miniwin/miniwin/src/include/miniwin_d3drmtexture_p.h +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -#include "miniwin_d3drmobject_p.h" - -struct Direct3DRMTextureImpl : public Direct3DRMObjectBase { - HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; - HRESULT Changed(BOOL pixels, BOOL palette) override; -}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmvisual_p.h b/miniwin/miniwin/src/include/miniwin_d3drmvisual_p.h deleted file mode 100644 index 89510645..00000000 --- a/miniwin/miniwin/src/include/miniwin_d3drmvisual_p.h +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once - -#include "miniwin_d3drm.h" -#include "miniwin_d3drmobject_p.h" - -struct Direct3DRMVisualArrayImpl - : public Direct3DRMArrayBase { - using Direct3DRMArrayBase::Direct3DRMArrayBase; -}; diff --git a/miniwin/miniwin/src/include/miniwin_math_p.h b/miniwin/miniwin/src/include/miniwin_math_p.h deleted file mode 100644 index 6f70f09b..00000000 --- a/miniwin/miniwin/src/include/miniwin_math_p.h +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/miniwin/miniwin/src/miniwin_d3drm.cpp b/miniwin/miniwin/src/miniwin_d3drm.cpp deleted file mode 100644 index 03b95313..00000000 --- a/miniwin/miniwin/src/miniwin_d3drm.cpp +++ /dev/null @@ -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 - -#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(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 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 { - 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(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(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(new Direct3DRMTextureImpl); - return DD_OK; - } - HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) override - { - MINIWIN_NOT_IMPLEMENTED(); - *outTexture = static_cast(new Direct3DRMTextureImpl); - return DD_OK; - } - HRESULT CreateMesh(IDirect3DRMMesh** outMesh) override - { - *outMesh = static_cast(new Direct3DRMMeshImpl); - return DD_OK; - } - HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) override - { - *outMaterial = static_cast(new Direct3DRMMaterialImpl(power)); - return DD_OK; - } - HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) override - { - *outLight = static_cast(new Direct3DRMLightImpl(r, g, b)); - return DD_OK; - } - HRESULT CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) override - { - auto parentImpl = static_cast(parent); - *outFrame = static_cast(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(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(width * height * 4); - SDL_GPUTransferBuffer* downloadTransferBuffer = - SDL_CreateGPUTransferBuffer(device->m_device, &downloadTransferInfo); - if (!downloadTransferBuffer) { - return DDERR_GENERIC; - } - - *outViewport = static_cast(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)); -} diff --git a/miniwin/miniwin/src/miniwin_d3drmdevice.cpp b/miniwin/miniwin/src/miniwin_d3drmdevice.cpp deleted file mode 100644 index f03e10b1..00000000 --- a/miniwin/miniwin/src/miniwin_d3drmdevice.cpp +++ /dev/null @@ -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 - -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(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; -} diff --git a/miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h new file mode 100644 index 00000000..aa15e7e0 --- /dev/null +++ b/miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h @@ -0,0 +1,93 @@ +#pragma once + +#include "miniwin_d3drm.h" + +#include +#include +#include + +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 +class Direct3DRMArrayBase_SDL3GPUImpl : public ArrayInterface { +public: + ~Direct3DRMArrayBase_SDL3GPUImpl() override + { + for (auto* item : m_items) { + if (item) { + item->Release(); + } + } + } + DWORD GetSize() override { return static_cast(m_items.size()); } + HRESULT AddElement(InterfaceType* in) override + { + if (!in) { + return DDERR_INVALIDPARAMS; + } + auto inImpl = static_cast(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(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 m_items; +}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmdevice_p.h b/miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h similarity index 79% rename from miniwin/miniwin/src/include/miniwin_d3drmdevice_p.h rename to miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h index aabc0633..428c05ca 100644 --- a/miniwin/miniwin/src/include/miniwin_d3drmdevice_p.h +++ b/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 -struct Direct3DRMDevice2Impl : public Direct3DRMObjectBase { - Direct3DRMDevice2Impl(DWORD width, DWORD height, SDL_GPUDevice* device); - ~Direct3DRMDevice2Impl() override; +struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { + Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device); + ~Direct3DRMDevice2_SDL3GPUImpl() override; DWORD GetWidth() override; DWORD GetHeight() override; HRESULT SetBufferCount(int count) override; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmframe_p.h b/miniwin/sdl3gpu/include/miniwin_d3drmframe_sdl3gpu.h similarity index 58% rename from miniwin/miniwin/src/include/miniwin_d3drmframe_p.h rename to miniwin/sdl3gpu/include/miniwin_d3drmframe_sdl3gpu.h index 7c13835e..dc416b38 100644 --- a/miniwin/miniwin/src/include/miniwin_d3drmframe_p.h +++ b/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 Direct3DRMLightArrayImpl; -class Direct3DRMVisualArrayImpl; -class Direct3DRMFrameArrayImpl; +class Direct3DRMTexture_SDL3GPUImpl; +class Direct3DRMLightArray_SDL3GPUImpl; +class Direct3DRMVisualArray_SDL3GPUImpl; +class Direct3DRMFrameArray_SDL3GPUImpl; -struct Direct3DRMFrameImpl : public Direct3DRMObjectBase { - Direct3DRMFrameImpl(Direct3DRMFrameImpl* parent = nullptr); - ~Direct3DRMFrameImpl() override; +struct Direct3DRMFrame_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { + Direct3DRMFrame_SDL3GPUImpl(Direct3DRMFrame_SDL3GPUImpl* parent = nullptr); + ~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 { HRESULT GetChildren(IDirect3DRMFrameArray** children) override; private: - Direct3DRMFrameImpl* m_parent{}; - Direct3DRMFrameArrayImpl* m_children{}; - Direct3DRMLightArrayImpl* m_lights{}; - Direct3DRMVisualArrayImpl* m_visuals{}; - Direct3DRMTextureImpl* m_texture{}; + Direct3DRMFrame_SDL3GPUImpl* m_parent{}; + Direct3DRMFrameArray_SDL3GPUImpl* m_children{}; + Direct3DRMLightArray_SDL3GPUImpl* m_lights{}; + Direct3DRMVisualArray_SDL3GPUImpl* m_visuals{}; + 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 - : public Direct3DRMArrayBase { - using Direct3DRMArrayBase::Direct3DRMArrayBase; +struct Direct3DRMFrameArray_SDL3GPUImpl + : public Direct3DRMArrayBase_SDL3GPUImpl { + using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; - friend class Direct3DRMFrameImpl; + friend class Direct3DRMFrame_SDL3GPUImpl; }; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h new file mode 100644 index 00000000..22dd8653 --- /dev/null +++ b/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 { + 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 { + using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; +}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h b/miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h similarity index 95% rename from miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h rename to miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h index f0063904..f6742a58 100644 --- a/miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h +++ b/miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h @@ -1,6 +1,6 @@ #pragma once -#include "miniwin_d3drmobject_p.h" +#include "miniwin_d3drmobject_sdl3gpu.h" #include #include @@ -63,7 +63,7 @@ struct MeshGroup { } }; -struct Direct3DRMMeshImpl : public Direct3DRMObjectBase { +struct Direct3DRMMesh_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { 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) diff --git a/miniwin/miniwin/src/include/miniwin_d3drmobject_p.h b/miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h similarity index 96% rename from miniwin/miniwin/src/include/miniwin_d3drmobject_p.h rename to miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h index a441fbf7..7e0da937 100644 --- a/miniwin/miniwin/src/include/miniwin_d3drmobject_p.h +++ b/miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h @@ -6,7 +6,7 @@ #include template -struct Direct3DRMObjectBase : public T { +struct Direct3DRMObjectBase_SDL3GPUImpl : public T { ULONG Release() override { if (IUnknown::m_refCount == 1) { diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h new file mode 100644 index 00000000..c8f95742 --- /dev/null +++ b/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h @@ -0,0 +1,8 @@ +#pragma once + +#include "miniwin_d3drmobject_sdl3gpu.h" + +struct Direct3DRMTexture_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { + HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; + HRESULT Changed(BOOL pixels, BOOL palette) override; +}; diff --git a/miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h b/miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h similarity index 76% rename from miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h rename to miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h index b4c16776..aef22e6c 100644 --- a/miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h +++ b/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 -class Direct3DRMDeviceImpl; -class Direct3DRMFrameImpl; +class Direct3DRMDevice_SDL3GPUImpl; +class Direct3DRMFrame_SDL3GPUImpl; -struct Direct3DRMViewportImpl : public Direct3DRMObjectBase { - Direct3DRMViewportImpl( +struct Direct3DRMViewport_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { + Direct3DRMViewport_SDL3GPUImpl( DWORD width, DWORD height, SDL_GPUDevice* device, @@ -17,7 +17,7 @@ struct Direct3DRMViewportImpl : public Direct3DRMObjectBase 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 D3DVALUE m_field = 0.5f; }; -struct Direct3DRMViewportArrayImpl - : public Direct3DRMArrayBase { - using Direct3DRMArrayBase::Direct3DRMArrayBase; +struct Direct3DRMViewportArray_SDL3GPUImpl : public Direct3DRMArrayBase_SDL3GPUImpl< + IDirect3DRMViewport, + Direct3DRMViewport_SDL3GPUImpl, + IDirect3DRMViewportArray> { + using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; }; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h new file mode 100644 index 00000000..7752833f --- /dev/null +++ b/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 { + using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; +}; diff --git a/miniwin/miniwin/src/include/miniwin_ddpalette_p.h b/miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h similarity index 62% rename from miniwin/miniwin/src/include/miniwin_ddpalette_p.h rename to miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h index 0d1b3766..0442a8a5 100644 --- a/miniwin/miniwin/src/include/miniwin_ddpalette_p.h +++ b/miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h @@ -2,9 +2,9 @@ #include "miniwin_ddraw.h" -struct DirectDrawPaletteImpl : public IDirectDrawPalette { - DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable); - ~DirectDrawPaletteImpl() override; +struct DirectDrawPalette_SDL3GPUImpl : public IDirectDrawPalette { + DirectDrawPalette_SDL3GPUImpl(LPPALETTEENTRY lpColorTable); + ~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; diff --git a/miniwin/miniwin/src/include/miniwin_ddraw_p.h b/miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h similarity index 94% rename from miniwin/miniwin/src/include/miniwin_ddraw_p.h rename to miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h index fca7a0e5..f4e5ec8e 100644 --- a/miniwin/miniwin/src/include/miniwin_ddraw_p.h +++ b/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 diff --git a/miniwin/miniwin/src/include/miniwin_ddsurface_p.h b/miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h similarity index 87% rename from miniwin/miniwin/src/include/miniwin_ddsurface_p.h rename to miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h index 610e17c0..36598e61 100644 --- a/miniwin/miniwin/src/include/miniwin_ddsurface_p.h +++ b/miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h @@ -3,10 +3,10 @@ #include #include -struct DirectDrawSurfaceImpl : public IDirectDrawSurface3 { - DirectDrawSurfaceImpl(); - DirectDrawSurfaceImpl(int width, int height, SDL_PixelFormat format); - ~DirectDrawSurfaceImpl() override; +struct DirectDrawSurface_SDL3GPUImpl : public IDirectDrawSurface3 { + DirectDrawSurface_SDL3GPUImpl(); + DirectDrawSurface_SDL3GPUImpl(int width, int height, SDL_PixelFormat format); + ~DirectDrawSurface_SDL3GPUImpl() override; // IUnknown interface HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; diff --git a/miniwin/miniwin/shaders/gencshadersource.py b/miniwin/sdl3gpu/shaders/gencshadersource.py similarity index 100% rename from miniwin/miniwin/shaders/gencshadersource.py rename to miniwin/sdl3gpu/shaders/gencshadersource.py diff --git a/miniwin/miniwin/shaders/generated/PositionColor.vert.h b/miniwin/sdl3gpu/shaders/generated/PositionColor.vert.h similarity index 100% rename from miniwin/miniwin/shaders/generated/PositionColor.vert.h rename to miniwin/sdl3gpu/shaders/generated/PositionColor.vert.h diff --git a/miniwin/miniwin/shaders/generated/ShaderIndex.cpp b/miniwin/sdl3gpu/shaders/generated/ShaderIndex.cpp similarity index 100% rename from miniwin/miniwin/shaders/generated/ShaderIndex.cpp rename to miniwin/sdl3gpu/shaders/generated/ShaderIndex.cpp diff --git a/miniwin/miniwin/shaders/generated/ShaderIndex.h b/miniwin/sdl3gpu/shaders/generated/ShaderIndex.h similarity index 100% rename from miniwin/miniwin/shaders/generated/ShaderIndex.h rename to miniwin/sdl3gpu/shaders/generated/ShaderIndex.h diff --git a/miniwin/miniwin/shaders/generated/SolidColor.frag.h b/miniwin/sdl3gpu/shaders/generated/SolidColor.frag.h similarity index 100% rename from miniwin/miniwin/shaders/generated/SolidColor.frag.h rename to miniwin/sdl3gpu/shaders/generated/SolidColor.frag.h diff --git a/miniwin/miniwin/shaders/src/PositionColor.vert.hlsl b/miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl similarity index 100% rename from miniwin/miniwin/shaders/src/PositionColor.vert.hlsl rename to miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl diff --git a/miniwin/miniwin/shaders/src/PositionColor.vert.hlsl.json b/miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json similarity index 100% rename from miniwin/miniwin/shaders/src/PositionColor.vert.hlsl.json rename to miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json diff --git a/miniwin/miniwin/shaders/src/SolidColor.frag.hlsl b/miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl similarity index 100% rename from miniwin/miniwin/shaders/src/SolidColor.frag.hlsl rename to miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl diff --git a/miniwin/miniwin/shaders/src/SolidColor.frag.hlsl.json b/miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json similarity index 100% rename from miniwin/miniwin/shaders/src/SolidColor.frag.hlsl.json rename to miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json diff --git a/miniwin/sdl3gpu/src/miniwin_d3drm.cpp b/miniwin/sdl3gpu/src/miniwin_d3drm.cpp new file mode 100644 index 00000000..7d1b1b27 --- /dev/null +++ b/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 + +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(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 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 { + 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(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(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(new Direct3DRMTexture_SDL3GPUImpl); + return DD_OK; +} + +HRESULT Direct3DRM_SDL3GPUImpl::CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) + +{ + MINIWIN_NOT_IMPLEMENTED(); + *outTexture = static_cast(new Direct3DRMTexture_SDL3GPUImpl); + return DD_OK; +} + +HRESULT Direct3DRM_SDL3GPUImpl::CreateMesh(IDirect3DRMMesh** outMesh) +{ + *outMesh = static_cast(new Direct3DRMMesh_SDL3GPUImpl); + return DD_OK; +} + +HRESULT Direct3DRM_SDL3GPUImpl::CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) +{ + *outMaterial = static_cast(new Direct3DRMMaterial_SDL3GPUImpl(power)); + return DD_OK; +} + +HRESULT Direct3DRM_SDL3GPUImpl::CreateLightRGB( + D3DRMLIGHTTYPE type, + D3DVAL r, + D3DVAL g, + D3DVAL b, + IDirect3DRMLight** outLight +) +{ + *outLight = static_cast(new Direct3DRMLight_SDL3GPUImpl(r, g, b)); + return DD_OK; +} + +HRESULT Direct3DRM_SDL3GPUImpl::CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) +{ + auto parentImpl = static_cast(parent); + *outFrame = static_cast(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(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(width * height * 4); + SDL_GPUTransferBuffer* downloadTransferBuffer = + SDL_CreateGPUTransferBuffer(device->m_device, &downloadTransferInfo); + if (!downloadTransferBuffer) { + return DDERR_GENERIC; + } + + *outViewport = static_cast(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; +} diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp new file mode 100644 index 00000000..ebb6ddcd --- /dev/null +++ b/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 + +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(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; +} diff --git a/miniwin/miniwin/src/miniwin_d3drmframe.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp similarity index 51% rename from miniwin/miniwin/src/miniwin_d3drmframe.cpp rename to miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp index 325f23e4..04200d71 100644 --- a/miniwin/miniwin/src/miniwin_d3drmframe.cpp +++ b/miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp @@ -1,26 +1,26 @@ -#include "miniwin_d3drm_p.h" -#include "miniwin_d3drmframe_p.h" -#include "miniwin_d3drmlight_p.h" -#include "miniwin_d3drmtexture_p.h" -#include "miniwin_d3drmvisual_p.h" +#include "miniwin_d3drm_sdl3gpu.h" +#include "miniwin_d3drmframe_sdl3gpu.h" +#include "miniwin_d3drmlight_sdl3gpu.h" +#include "miniwin_d3drmtexture_sdl3gpu.h" +#include "miniwin_d3drmvisual_sdl3gpu.h" #include "miniwin_p.h" #include -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(child); + Direct3DRMFrame_SDL3GPUImpl* childImpl = static_cast(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(child); + Direct3DRMFrame_SDL3GPUImpl* childImpl = static_cast(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(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | (static_cast(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(texture); + auto textureImpl = static_cast(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(a * 255.0f) << 24) | (static_cast(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | (static_cast(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(); diff --git a/miniwin/miniwin/src/miniwin_d3drmlight.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp similarity index 51% rename from miniwin/miniwin/src/miniwin_d3drmlight.cpp rename to miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp index 932351bd..37e80369 100644 --- a/miniwin/miniwin/src/miniwin_d3drmlight.cpp +++ b/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(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | (static_cast(b * 255.0f)); diff --git a/miniwin/miniwin/src/miniwin_d3drmmesh.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp similarity index 75% rename from miniwin/miniwin/src/miniwin_d3drmmesh.cpp rename to miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp index 1a8fc7a7..e30b14f7 100644 --- a/miniwin/miniwin/src/miniwin_d3drmmesh.cpp +++ b/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 -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(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(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(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::max(); box->max.x = box->max.y = box->max.z = std::numeric_limits::min(); diff --git a/miniwin/miniwin/src/miniwin_d3drmtexture.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp similarity index 59% rename from miniwin/miniwin/src/miniwin_d3drmtexture.cpp rename to miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp index 2ebebde2..cb3b0fe1 100644 --- a/miniwin/miniwin/src/miniwin_d3drmtexture.cpp +++ b/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; diff --git a/miniwin/miniwin/src/miniwin_d3drmviewport.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp similarity index 84% rename from miniwin/miniwin/src/miniwin_d3drmviewport.cpp rename to miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp index 8140bd08..4fd79f12 100644 --- a/miniwin/miniwin/src/miniwin_d3drmviewport.cpp +++ b/miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp @@ -1,12 +1,12 @@ -#include "miniwin_d3drm_p.h" -#include "miniwin_d3drmframe_p.h" -#include "miniwin_d3drmviewport_p.h" +#include "miniwin_d3drm_sdl3gpu.h" +#include "miniwin_d3drmframe_sdl3gpu.h" +#include "miniwin_d3drmviewport_sdl3gpu.h" #include "miniwin_p.h" #include #include -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(frame); + Direct3DRMFrame_SDL3GPUImpl* frameImpl = static_cast(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; diff --git a/miniwin/miniwin/src/miniwin_ddpalette.cpp b/miniwin/sdl3gpu/src/miniwin_ddpalette.cpp similarity index 63% rename from miniwin/miniwin/src/miniwin_ddpalette.cpp rename to miniwin/sdl3gpu/src/miniwin_ddpalette.cpp index 5d9a2125..be0a96f5 100644 --- a/miniwin/miniwin/src/miniwin_ddpalette.cpp +++ b/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 -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++) { diff --git a/miniwin/miniwin/src/miniwin_ddraw.cpp b/miniwin/sdl3gpu/src/miniwin_ddraw.cpp similarity index 87% rename from miniwin/miniwin/src/miniwin_ddraw.cpp rename to miniwin/sdl3gpu/src/miniwin_ddraw.cpp index 6cd007e1..add30f71 100644 --- a/miniwin/miniwin/src/miniwin_ddraw.cpp +++ b/miniwin/sdl3gpu/src/miniwin_ddraw.cpp @@ -1,8 +1,8 @@ #include "miniwin_d3d.h" -#include "miniwin_ddpalette_p.h" -#include "miniwin_ddraw_p.h" -#include "miniwin_ddsurface_p.h" +#include "miniwin_ddpalette_sdl3gpu.h" +#include "miniwin_ddraw_sdl3gpu.h" +#include "miniwin_ddsurface_sdl3gpu.h" #include "miniwin_p.h" #include @@ -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(new DirectDrawPaletteImpl(lpColorTable)); + *lplpDDPalette = static_cast(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(new DirectDrawSurfaceImpl); + *lplpDDSurface = static_cast(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(frontBuffer); return DD_OK; @@ -130,11 +130,11 @@ HRESULT DirectDrawImpl::CreateSurface( if (width == 0 || height == 0) { return DDERR_INVALIDPARAMS; } - *lplpDDSurface = static_cast(new DirectDrawSurfaceImpl(width, height, format)); + *lplpDDSurface = static_cast(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; } diff --git a/miniwin/miniwin/src/miniwin_ddsurface.cpp b/miniwin/sdl3gpu/src/miniwin_ddsurface.cpp similarity index 71% rename from miniwin/miniwin/src/miniwin_ddsurface.cpp rename to miniwin/sdl3gpu/src/miniwin_ddsurface.cpp index f43a7838..9d0c611c 100644 --- a/miniwin/miniwin/src/miniwin_ddsurface.cpp +++ b/miniwin/sdl3gpu/src/miniwin_ddsurface.cpp @@ -1,15 +1,15 @@ -#include "miniwin_ddpalette_p.h" -#include "miniwin_ddraw_p.h" -#include "miniwin_ddsurface_p.h" +#include "miniwin_ddpalette_sdl3gpu.h" +#include "miniwin_ddraw_sdl3gpu.h" +#include "miniwin_ddsurface_sdl3gpu.h" #include "miniwin_p.h" #include -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(lpDDSrcSurface); + auto srcSurface = static_cast(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;