isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-01-11 18:41:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Anonymous Maarten 2025-05-25 19:38:02 +02:00 committed by GitHub
parent 110d9d4f7d
commit b24271a51b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
52 changed files with 891 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
CMakeLists.txt
View File

@ -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 "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/miniwin/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/miniwin/shaders/generated")
target_include_directories(miniwin PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/miniwin/include>")
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 "$<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)

34
ISLE/isleapp.cpp
View File

@ -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;

0
miniwin/miniwin/src/include/miniwin_p.h → miniwin/common/include/miniwin_p.h
View File

50
miniwin/common/src/d3drm.cpp Normal file
View File

@ -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));
}

0
miniwin/miniwin/src/miniwin.cpp → miniwin/common/src/miniwin.cpp
View File

0
miniwin/miniwin/include/bitflags.h → miniwin/include/bitflags.h
View File

0
miniwin/miniwin/include/miniwin.h → miniwin/include/miniwin.h
View File

23
miniwin/include/miniwin_config.h Normal file
View File

@ -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

0
miniwin/miniwin/include/miniwin_d3d.h → miniwin/include/miniwin_d3d.h
View File

0
miniwin/miniwin/include/miniwin_d3drm.h → miniwin/include/miniwin_d3drm.h
View File

0
miniwin/miniwin/include/miniwin_ddraw.h → miniwin/include/miniwin_ddraw.h
View File

0
miniwin/miniwin/include/miniwin_dinput.h → miniwin/include/miniwin_dinput.h
View File

0
miniwin/miniwin/include/miniwin_direct.h → miniwin/include/miniwin_direct.h
View File

0
miniwin/miniwin/include/miniwin_process.h → miniwin/include/miniwin_process.h
View File

61
miniwin/miniwin/src/include/miniwin_d3drm_p.h
View File

@ -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;
};

18
miniwin/miniwin/src/include/miniwin_d3drmlight_p.h
View File

@ -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;
};

8
miniwin/miniwin/src/include/miniwin_d3drmtexture_p.h
View File

@ -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;
};

9
miniwin/miniwin/src/include/miniwin_d3drmvisual_p.h
View File

@ -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;
};

1
miniwin/miniwin/src/include/miniwin_math_p.h
View File

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

301
miniwin/miniwin/src/miniwin_d3drm.cpp
View File

@ -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));
}

123
miniwin/miniwin/src/miniwin_d3drmdevice.cpp
View File

@ -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;
}

93
miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h Normal file
View File

@ -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;
};

8
miniwin/miniwin/src/include/miniwin_d3drmdevice_p.h → miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h
View File

@ -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> {
Direct3DRMDevice2Impl(DWORD width, DWORD height, SDL_GPUDevice* device);
~Direct3DRMDevice2Impl() override;
struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMDevice2> {
Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device);
~Direct3DRMDevice2_SDL3GPUImpl() override;
DWORD GetWidth() override;
DWORD GetHeight() override;
HRESULT SetBufferCount(int count) override;

36
miniwin/miniwin/src/include/miniwin_d3drmframe_p.h → miniwin/sdl3gpu/include/miniwin_d3drmframe_sdl3gpu.h
View File

@ -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<IDirect3DRMFrame2> {
Direct3DRMFrameImpl(Direct3DRMFrameImpl* parent = nullptr);
~Direct3DRMFrameImpl() override;
struct Direct3DRMFrame_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMFrame2> {
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<IDirect3DRMFrame2> {
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<IDirect3DRMFrame, Direct3DRMFrameImpl, IDirect3DRMFrameArray> {
using Direct3DRMArrayBase::Direct3DRMArrayBase;
struct Direct3DRMFrameArray_SDL3GPUImpl
: public Direct3DRMArrayBase_SDL3GPUImpl<IDirect3DRMFrame, Direct3DRMFrame_SDL3GPUImpl, IDirect3DRMFrameArray> {
using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
friend class Direct3DRMFrameImpl;
friend class Direct3DRMFrame_SDL3GPUImpl;
};

18
miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h Normal file
View File

@ -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;
};

4
miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h → miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h
View File

@ -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)

2
miniwin/miniwin/src/include/miniwin_d3drmobject_p.h → miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h
View File

@ -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) {

8
miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h Normal file
View File

@ -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;
};

20
miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h → miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h
View File

@ -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 Direct3DRMFrameImpl;
class Direct3DRMDevice_SDL3GPUImpl;
class Direct3DRMFrame_SDL3GPUImpl;
struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport> {
Direct3DRMViewportImpl(
struct Direct3DRMViewport_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMViewport> {
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
: public Direct3DRMArrayBase<IDirect3DRMViewport, Direct3DRMViewportImpl, IDirect3DRMViewportArray> {
using Direct3DRMArrayBase::Direct3DRMArrayBase;
struct Direct3DRMViewportArray_SDL3GPUImpl : public Direct3DRMArrayBase_SDL3GPUImpl<
IDirect3DRMViewport,
Direct3DRMViewport_SDL3GPUImpl,
IDirect3DRMViewportArray> {
using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
};

9
miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h Normal file
View File

@ -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;
};

6
miniwin/miniwin/src/include/miniwin_ddpalette_p.h → miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h
View File

@ -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;

2
miniwin/miniwin/src/include/miniwin_ddraw_p.h → miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h
View File

@ -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

8
miniwin/miniwin/src/include/miniwin_ddsurface_p.h → miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h
View File

@ -3,10 +3,10 @@
#include <SDL3/SDL.h>
#include <miniwin_ddraw.h>
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;

0
miniwin/miniwin/shaders/gencshadersource.py → miniwin/sdl3gpu/shaders/gencshadersource.py
View File

0
miniwin/miniwin/shaders/generated/PositionColor.vert.h → miniwin/sdl3gpu/shaders/generated/PositionColor.vert.h
View File

0
miniwin/miniwin/shaders/generated/ShaderIndex.cpp → miniwin/sdl3gpu/shaders/generated/ShaderIndex.cpp
View File

0
miniwin/miniwin/shaders/generated/ShaderIndex.h → miniwin/sdl3gpu/shaders/generated/ShaderIndex.h
View File

0
miniwin/miniwin/shaders/generated/SolidColor.frag.h → miniwin/sdl3gpu/shaders/generated/SolidColor.frag.h
View File

0
miniwin/miniwin/shaders/src/PositionColor.vert.hlsl → miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl
View File

0
miniwin/miniwin/shaders/src/PositionColor.vert.hlsl.json → miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json
View File

0
miniwin/miniwin/shaders/src/SolidColor.frag.hlsl → miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl
View File

0
miniwin/miniwin/shaders/src/SolidColor.frag.hlsl.json → miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json
View File

312
miniwin/sdl3gpu/src/miniwin_d3drm.cpp Normal file
View File

@ -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;
}

123
miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp Normal file
View File

@ -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;
}

64
miniwin/miniwin/src/miniwin_d3drmframe.cpp → miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp
View File

@ -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 <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();

6
miniwin/miniwin/src/miniwin_d3drmlight.cpp → miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp
View File

@ -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));

40
miniwin/miniwin/src/miniwin_d3drmmesh.cpp → miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp
View File

@ -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();

6
miniwin/miniwin/src/miniwin_d3drmtexture.cpp → miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp
View File

@ -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;

56
miniwin/miniwin/src/miniwin_d3drmviewport.cpp → miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp
View File

@ -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 <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;

20
miniwin/miniwin/src/miniwin_ddpalette.cpp → miniwin/sdl3gpu/src/miniwin_ddpalette.cpp
View File

@ -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++) {

42
miniwin/miniwin/src/miniwin_ddraw.cpp → miniwin/sdl3gpu/src/miniwin_ddraw.cpp
View File

@ -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 <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;
}

57
miniwin/miniwin/src/miniwin_ddsurface.cpp → miniwin/sdl3gpu/src/miniwin_ddsurface.cpp
View File

@ -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 <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;