TheCloud/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2025-08-03 15:47:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

Restructure miniwin and add support for 3D backends

Browse Source
This commit is contained in:
Anders Jenbo 2025-05-28 22:04:32 +02:00
parent ea7cac8359
commit ef7499bdb9
93 changed files with 1411 additions and 1444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
CMakeLists.txt
View File

@ -91,134 +91,9 @@ 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/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/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/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"
)
set(miniwin_shaders_DEPENDS
"${shader_src_dir}/Common.hlsl"
)
if(ISLE_COMPILE_SHADERS)
set(compiled_bindir "${CMAKE_CURRENT_BINARY_DIR}/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})
add_custom_target(create-generated-shader-directories DEPENDS ${generated_dirs})
if(ISLE_MINIWIN)
add_subdirectory(miniwin)
endif()
target_sources(miniwin PRIVATE ${py_gencshadersource})
set(shader_variables )
set(shader_headers )
set(shader_stages )
foreach(shader_src IN LISTS miniwin_shaders)
get_filename_component(filename_wle "${shader_src}" NAME_WLE)
get_filename_component(shader_name "${filename_wle}" NAME_WLE)
get_filename_component(src_format_ext "${shader_src}" LAST_EXT)
get_filename_component(src_stage_ext "${filename_wle}" LAST_EXT)
string(MAKE_C_IDENTIFIER "${filename_wle}" shader_variable)
set(shader_json "${shader_src}.json")
if(src_format_ext STREQUAL ".hlsl")
set(src_format "HLSL")
else()
message(FATAL_ERROR "Unknown source format (${src_format_ext})")
endif()
if(src_stage_ext STREQUAL ".vert")
set(shader_stage "vertex")
elseif(src_stage_ext STREQUAL ".frag")
set(shader_stage "fragment")
elseif(src_stage_ext STREQUAL ".comp")
set(shader_stage "compute")
message(FATAL_ERROR "Compute shaders are not (yet) supported")
else()
message(FATAL_ERROR "Unknown stage (${src_stage_ext})")
endif()
set(dxil "${compiled_bindir}/dxil/${filename_wle}.dxil")
set(msl "${compiled_bindir}/msl/${filename_wle}.msl")
set(spirv "${compiled_bindir}/spirv/${filename_wle}.spv")
set(shader_filename "${filename_wle}.h")
set(shader_header "${shader_gen_dir}/${shader_filename}")
if(ISLE_COMPILE_SHADERS)
add_custom_command(OUTPUT "${dxil}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${dxil}"
-s "${src_format}" -d "DXIL" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${msl}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${msl}"
-s "${src_format}" -d "MSL" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${spirv}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${spirv}"
-s "${src_format}" -d "SPIRV" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${shader_header}"
COMMAND Python3::Interpreter "${py_gencshadersource}" "header" "--output" "${shader_header}"
"--stage" "${shader_stage}" "--variable" "${shader_variable}"
"--dxil" "${dxil}" "--msl" "${msl}" "--spirv" "${spirv}"
DEPENDS "${py_gencshadersource}" "${dxil}" "${msl}" "${spirv}")
endif()
target_sources(miniwin PRIVATE "${shader_header}")
list(APPEND shader_names "${shader_name}")
list(APPEND shader_variables "${shader_variable}")
list(APPEND shader_headers "${shader_header}")
list(APPEND shader_stages "${shader_stage}")
list(APPEND shader_jsons "${shader_json}")
endforeach()
set(index_cpp "${shader_gen_dir}/ShaderIndex.cpp")
set(index_h "${shader_gen_dir}/ShaderIndex.h")
if(ISLE_COMPILE_SHADERS)
add_custom_command(OUTPUT "${index_h}" "${index_cpp}"
COMMAND Python3::Interpreter "${py_gencshadersource}" "index"
"--output" "${index_cpp}"
"--header" "${index_h}"
"--shader-names" ${shader_names}
"--shader-variables" ${shader_variables}
"--shader-headers" ${shader_headers}
"--shader-stages" ${shader_stages}
"--shader-jsons" ${shader_jsons}
DEPENDS "${py_gencshadersource}" ${shader_headers} ${shader_jsons})
endif()
target_sources(miniwin PRIVATE "${index}" "${index_cpp}")
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/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)
set(isle_targets)

2
CONFIG/MainDlg.cpp
View File

@ -1,7 +1,7 @@
#include "MainDlg.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
CONFIG/StdAfx.h
View File

@ -4,7 +4,7 @@
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#ifdef MINIMFC
#include "minimfc.h"
#include "miniwin/mfc.h"
#else
#include <afxext.h> // MFC extensions
#include <afxwin.h> // MFC core and standard components

4
CONFIG/config.cpp
View File

@ -7,8 +7,8 @@
#include <mxdirectx/legodxinfo.h>
#include <mxdirectx/mxdirect3d.h>
#ifdef MINIWIN
#include "miniwin_direct.h"
#include "miniwin_process.h"
#include "miniwin/direct.h"
#include "miniwin/process.h"
#else
#include <direct.h> // _chdir
#include <process.h> // _spawnl

2
CONFIG/config.h
View File

@ -6,7 +6,7 @@
#include "decomp.h"
#ifdef MINIWIN
#include "miniwin_d3d.h"
#include "miniwin/d3d.h"
#else
#include <d3d.h>
#endif

6
CONFIG/detectdx5.cpp
View File

@ -1,9 +1,9 @@
#include "detectdx5.h"
#ifdef MINIWIN
#include "minimfc.h"
#include "miniwin_ddraw.h"
#include "miniwin_dinput.h"
#include "miniwin/ddraw.h"
#include "miniwin/dinput.h"
#include "miniwin/mfc.h"
#else
#include <ddraw.h>
#include <dinput.h>

2
CONFIG/detectdx5.h
View File

@ -2,7 +2,7 @@
#define AFX_DETECTDX5_H
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

30
ISLE/isleapp.cpp
View File

@ -31,10 +31,6 @@
#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>
@ -80,10 +76,6 @@ MxS32 g_reqEnableRMDevice = FALSE;
SDL_Window* window;
#ifdef MINIWIN
static MiniwinBackendType g_miniwinBackendType = MiniwinBackendType::eInvalid;
#endif
// FUNCTION: ISLE 0x401000
IsleApp::IsleApp()
{
@ -129,10 +121,6 @@ IsleApp::IsleApp()
LegoOmni::CreateInstance();
m_iniPath = NULL;
#ifdef MINIWIN
g_miniwinBackendType = MiniwinBackendType::eSDL3GPU;
#endif
}
// FUNCTION: ISLE 0x4011a0
@ -280,12 +268,6 @@ 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(
@ -878,18 +860,6 @@ MxResult IsleApp::ParseArguments(int argc, char** argv)
#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;

2
ISLE/isleapp.h
View File

@ -8,7 +8,7 @@
#include <SDL3/SDL.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/lego/legoomni/include/legoinputmanager.h
View File

@ -13,7 +13,7 @@
#include <SDL3/SDL_keycode.h>
#include <SDL3/SDL_timer.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/lego/legoomni/include/legopointofviewcontroller.h
View File

@ -6,7 +6,7 @@
#include "mxgeometry.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

4
LEGO1/lego/legoomni/include/legotextureinfo.h
View File

@ -5,8 +5,8 @@
#include "tgl/tgl.h"
#ifdef MINIWIN
#include "miniwin_d3drm.h"
#include "miniwin_ddraw.h"
#include "miniwin/d3drm.h"
#include "miniwin/ddraw.h"
#else
#include <d3drmobj.h>
#include <ddraw.h>

2
LEGO1/lego/legoomni/include/legoutils.h
View File

@ -9,7 +9,7 @@
#include <SDL3/SDL_stdinc.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

4
LEGO1/lego/legoomni/include/legovideomanager.h
View File

@ -7,8 +7,8 @@
#include "mxvideomanager.h"
#ifdef MINIWIN
#include "miniwin_d3drm.h"
#include "miniwin_ddraw.h"
#include "miniwin/d3drm.h"
#include "miniwin/ddraw.h"
#else
#include <d3drm.h>
#include <ddraw.h>

2
LEGO1/lego/legoomni/include/mxtransitionmanager.h
View File

@ -7,7 +7,7 @@
#include <SDL3/SDL_stdinc.h>
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/main.cpp
View File

@ -1,5 +1,5 @@
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/mxdirectx/mxdirect3d.h
View File

@ -7,7 +7,7 @@
#include "mxstl/stlcompat.h"
#ifdef MINIWIN
#include "miniwin_d3d.h"
#include "miniwin/d3d.h"
#else
#include <d3d.h>
#endif

4
LEGO1/mxdirectx/mxdirectdraw.h
View File

@ -5,8 +5,8 @@
#include "mxdirectxinfo.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#include "miniwin/windows.h"
#else
#include <ddraw.h>
#include <windows.h>

2
LEGO1/mxdirectx/mxdirectxinfo.h
View File

@ -5,7 +5,7 @@
#include "mxstl/stlcompat.h"
#ifdef MINIWIN
#include "miniwin_d3d.h"
#include "miniwin/d3d.h"
#else
#include <d3d.h>
#endif

2
LEGO1/mxdirectx/mxstopwatch.h
View File

@ -8,7 +8,7 @@
#include <limits.h> // ULONG_MAX
#include <math.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/omni/include/flic.h
View File

@ -4,7 +4,7 @@
#include "decomp.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/omni/include/mxbitmap.h
View File

@ -6,7 +6,7 @@
#include <SDL3/SDL_iostream.h>
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/omni/include/mxdisplaysurface.h
View File

@ -6,7 +6,7 @@
#include "mxvideoparam.h"
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/omni/include/mxomni.h
View File

@ -9,7 +9,7 @@
#include <SDL3/SDL_video.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/omni/include/mxpalette.h
View File

@ -5,7 +5,7 @@
#include "mxtypes.h"
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/omni/include/mxvideomanager.h
View File

@ -5,7 +5,7 @@
#include "mxvideoparam.h"
#ifdef MINIWIN
#include "miniwin_d3d.h"
#include "miniwin/d3d.h"
#else
#include <d3d.h>
#endif

2
LEGO1/omni/include/mxvideoparam.h
View File

@ -8,7 +8,7 @@
#include "mxvideoparamflags.h"
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/omni/include/mxvideoparamflags.h
View File

@ -5,7 +5,7 @@
#include "mxtypes.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/omni/include/mxvideopresenter.h
View File

@ -7,7 +7,7 @@
#include "mxmediapresenter.h"
#ifdef MINIWIN
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
#else
#include <ddraw.h>
#endif

2
LEGO1/omni/src/video/mxdisplaysurface.cpp
View File

@ -11,7 +11,7 @@
#include <SDL3/SDL_log.h>
#include <assert.h>
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/realtime/orientableroi.h
View File

@ -6,7 +6,7 @@
#include "roi.h"
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/tgl/d3drm/device.cpp
View File

@ -2,7 +2,7 @@
#include <assert.h>
#ifdef MINIWIN
#include "miniwin_d3drm.h"
#include "miniwin/d3drm.h"
#else
#include <d3drmwin.h>
#endif

2
LEGO1/tgl/d3drm/impl.h
View File

@ -6,7 +6,7 @@
#include "tgl/tgl.h"
#ifdef MINIWIN
#include "miniwin_d3drm.h"
#include "miniwin/d3drm.h"
typedef void* LPD3DRM_APPDATA;
#else
#include <d3drm.h>

6
LEGO1/tgl/tgl.h
View File

@ -6,15 +6,15 @@
#include "tglvector.h"
#ifdef MINIWIN
#include "miniwin_d3d.h"
#include "miniwin_ddraw.h"
#include "miniwin/d3d.h"
#include "miniwin/ddraw.h"
#else
#include <d3d.h>
#include <ddraw.h>
#endif
#ifdef MINIWIN
#include "miniwin.h"
#include "miniwin/windows.h"
#else
#include <windows.h>
#endif

2
LEGO1/viewmanager/viewmanager.h
View File

@ -7,7 +7,7 @@
#include "viewroi.h"
#ifdef MINIWIN
#include "miniwin_d3drm.h"
#include "miniwin/d3drm.h"
#else
#include <d3drm.h>
#endif

150
miniwin/CMakeLists.txt Normal file
View File

@ -0,0 +1,150 @@
add_library(miniwin STATIC EXCLUDE_FROM_ALL
# Core
src/windows/windows.cpp
src/mfc/mfc.cpp
# DDraw
src/ddraw/ddraw.cpp
src/ddraw/ddpalette.cpp
src/ddraw/ddsurface.cpp
# D3DRM
src/d3drm/d3drm.cpp
src/d3drm/d3drmdevice.cpp
src/d3drm/d3drmframe.cpp
src/d3drm/d3drmlight.cpp
src/d3drm/d3drmmesh.cpp
src/d3drm/d3drmtexture.cpp
src/d3drm/d3drmviewport.cpp
# D3DRM backends
src/d3drm/backends/sdl3gpu/renderer.cpp
src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.cpp
)
# Force reported render mods from MiniWin
target_compile_definitions(miniwin PRIVATE MINIWIN_PIXELFORMAT=SDL_PIXELFORMAT_RGB565)
target_compile_definitions(miniwin PUBLIC MINIWIN)
target_include_directories(miniwin
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src/internal
${CMAKE_CURRENT_SOURCE_DIR}/src/d3drm/backends/sdl3gpu/shaders/generated
)
target_link_libraries(miniwin PRIVATE SDL3::SDL3)
# Shader stuff
set(shader_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/src/d3drm/backends/sdl3gpu/shaders/src")
set(shader_gen_dir "${CMAKE_CURRENT_SOURCE_DIR}/src/d3drm/backends/sdl3gpu/shaders/generated")
set(py_gencshadersource "${CMAKE_CURRENT_SOURCE_DIR}/src/d3drm/backends/sdl3gpu/shaders/gencshadersource.py")
set(miniwin_shaders
"${shader_src_dir}/PositionColor.vert.hlsl"
"${shader_src_dir}/SolidColor.frag.hlsl"
)
set(miniwin_shaders_DEPENDS
"${shader_src_dir}/Common.hlsl"
)
if(ISLE_COMPILE_SHADERS)
set(compiled_bindir "${CMAKE_CURRENT_BINARY_DIR}/shaders/compiled")
set(generated_dirs "${compiled_bindir}/dxil" "${compiled_bindir}/msl" "${compiled_bindir}/spirv")
add_custom_command(OUTPUT ${generated_dirs}
COMMAND "${CMAKE_COMMAND}" -E make_directory ${generated_dirs}
)
add_custom_target(create-generated-shader-directories DEPENDS ${generated_dirs})
endif()
target_sources(miniwin PRIVATE ${py_gencshadersource})
set(shader_variables )
set(shader_headers )
set(shader_stages )
foreach(shader_src IN LISTS miniwin_shaders)
get_filename_component(filename_wle "${shader_src}" NAME_WLE)
get_filename_component(shader_name "${filename_wle}" NAME_WLE)
get_filename_component(src_format_ext "${shader_src}" LAST_EXT)
get_filename_component(src_stage_ext "${filename_wle}" LAST_EXT)
string(MAKE_C_IDENTIFIER "${filename_wle}" shader_variable)
set(shader_json "${shader_src}.json")
if(src_format_ext STREQUAL ".hlsl")
set(src_format "HLSL")
else()
message(FATAL_ERROR "Unknown source format (${src_format_ext})")
endif()
if(src_stage_ext STREQUAL ".vert")
set(shader_stage "vertex")
elseif(src_stage_ext STREQUAL ".frag")
set(shader_stage "fragment")
elseif(src_stage_ext STREQUAL ".comp")
set(shader_stage "compute")
message(FATAL_ERROR "Compute shaders are not (yet) supported")
else()
message(FATAL_ERROR "Unknown stage (${src_stage_ext})")
endif()
set(dxil "${compiled_bindir}/dxil/${filename_wle}.dxil")
set(msl "${compiled_bindir}/msl/${filename_wle}.msl")
set(spirv "${compiled_bindir}/spirv/${filename_wle}.spv")
set(shader_filename "${filename_wle}.h")
set(shader_header "${shader_gen_dir}/${shader_filename}")
if(ISLE_COMPILE_SHADERS)
add_custom_command(OUTPUT "${dxil}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${dxil}"
-s "${src_format}" -d "DXIL" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${msl}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${msl}"
-s "${src_format}" -d "MSL" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${spirv}"
COMMAND "${SDL_SHADERCROSS_BIN}" "${shader_src}" -o "${spirv}"
-s "${src_format}" -d "SPIRV" -t "${shader_stage}"
DEPENDS create-generated-shader-directories "${shader_src}" ${miniwin_shaders_DEPENDS})
add_custom_command(OUTPUT "${shader_header}"
COMMAND Python3::Interpreter "${py_gencshadersource}" "header" "--output" "${shader_header}"
"--stage" "${shader_stage}" "--variable" "${shader_variable}"
"--dxil" "${dxil}" "--msl" "${msl}" "--spirv" "${spirv}"
DEPENDS "${py_gencshadersource}" "${dxil}" "${msl}" "${spirv}")
endif()
target_sources(miniwin PRIVATE "${shader_header}")
list(APPEND shader_names "${shader_name}")
list(APPEND shader_variables "${shader_variable}")
list(APPEND shader_headers "${shader_header}")
list(APPEND shader_stages "${shader_stage}")
list(APPEND shader_jsons "${shader_json}")
endforeach()
set(index_cpp "${shader_gen_dir}/ShaderIndex.cpp")
set(index_h "${shader_gen_dir}/ShaderIndex.h")
if(ISLE_COMPILE_SHADERS)
add_custom_command(OUTPUT "${index_h}" "${index_cpp}"
COMMAND Python3::Interpreter "${py_gencshadersource}" "index"
"--output" "${index_cpp}"
"--header" "${index_h}"
"--shader-names" ${shader_names}
"--shader-variables" ${shader_variables}
"--shader-headers" ${shader_headers}
"--shader-stages" ${shader_stages}
"--shader-jsons" ${shader_jsons}
DEPENDS "${py_gencshadersource}" ${shader_headers} ${shader_jsons})
endif()
target_sources(miniwin PRIVATE "${index}" "${index_cpp}")
# Minimfc lib
add_library(minimfc STATIC EXCLUDE_FROM_ALL
src/mfc/mfc.cpp
)
target_include_directories(minimfc
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/internal
)
target_compile_definitions(minimfc PUBLIC MINIMFC)
target_link_libraries(minimfc PRIVATE SDL3::SDL3 miniwin)

76
miniwin/common/src/d3drm.cpp
View File

@ -1,76 +0,0 @@
#include "miniwin_config.h"
#include "miniwin_d3drm.h"
#include "miniwin_d3drm_sdl3gpu.h"
#include "miniwin_ddraw_sdl3gpu.h"
#include "miniwin_p.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));
}
HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter)
{
if (lpGuid) {
MINIWIN_NOT_IMPLEMENTED();
}
switch (g_backendType) {
case MiniwinBackendType::eSDL3GPU:
return DirectDrawCreate_SDL3GPU(lpGuid, lplpDD, pUnkOuter);
default:
*lplpDD = nullptr;
return DDERR_GENERIC;
}
}
HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context)
{
switch (g_backendType) {
case MiniwinBackendType::eSDL3GPU:
return DirectDrawEnumerate_SDL3GPU(cb, context);
default:
return DDERR_GENERIC;
}
}

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

8
miniwin/include/miniwin_d3d.h → miniwin/include/miniwin/d3d.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
// --- GUIDs ---
DEFINE_GUID(IID_IDirect3D2, 0x6aae1ec1, 0x662a, 0x11d0, 0x88, 0x9d, 0x00, 0xaa, 0x00, 0xbb, 0xb7, 0x6a);
@ -73,7 +73,11 @@ struct IDirect3DDevice2 : virtual public IUnknown {};
typedef HRESULT (*LPD3DENUMDEVICESCALLBACK)(LPGUID, LPSTR, LPSTR, LPD3DDEVICEDESC, LPD3DDEVICEDESC, LPVOID);
struct IDirect3D2 : virtual public IUnknown {
virtual HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) = 0;
virtual HRESULT CreateDevice(
const GUID& guid,
IDirectDrawSurface* pBackBuffer,
IDirect3DDevice2** ppDirect3DDevice
) = 0;
virtual HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) = 0;
};
typedef IDirect3D2* LPDIRECT3D2;

2
miniwin/include/miniwin_d3drm.h → miniwin/include/miniwin/d3drm.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "miniwin_d3d.h"
#include "miniwin/d3d.h"
#include <stdlib.h> // abort // FIXME: remove

2
miniwin/include/miniwin_ddraw.h → miniwin/include/miniwin/ddraw.h
View File

@ -1,7 +1,7 @@
#pragma once
#include "bitflags.h"
#include "miniwin.h"
#include "miniwin/windows.h"
#define DDENUMRET_OK TRUE

2
miniwin/include/miniwin_dinput.h → miniwin/include/miniwin/dinput.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "miniwin.h"
#include "miniwin/windows.h"
// --- Typedefs ---
typedef struct IDirectInputA* LPDIRECTINPUTA;

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

2
miniwin/minimfc/include/minimfc.h → miniwin/include/miniwin/mfc.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "miniwin.h"
#include "miniwin/windows.h"
#include <assert.h>
#include <stdarg.h>

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

2
miniwin/include/miniwin.h → miniwin/include/miniwin/windows.h
View File

@ -16,7 +16,7 @@
#define CALLBACK
#define FAR
#define WINAPI
#define HWND_NOTOPMOST ((HWND) -2)
#define HWND_NOTOPMOST ((HWND) (-2))
#define RGB(r, g, b) (((BYTE) (r) | ((BYTE) (g) << 8) | ((BYTE) (b) << 16)))
#define S_OK ((HRESULT) 0)
#define E_NOINTERFACE (0x80004002)

23
miniwin/include/miniwin_config.h
View File

@ -1,23 +0,0 @@
#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

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

@ -1,18 +0,0 @@
#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;
};

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

@ -1,8 +0,0 @@
#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;
};

79
miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h
View File

@ -1,79 +0,0 @@
#pragma once
#include "miniwin_d3drm.h"
#include "miniwin_d3drmobject_sdl3gpu.h"
#include <SDL3/SDL.h>
class Direct3DRMDevice_SDL3GPUImpl;
class Direct3DRMFrame_SDL3GPUImpl;
typedef struct {
D3DRMMATRIX4D perspective;
} ViewportUniforms;
struct Direct3DRMViewport_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMViewport> {
Direct3DRMViewport_SDL3GPUImpl(
DWORD width,
DWORD height,
SDL_GPUDevice* device,
SDL_GPUTexture* transferTexture,
SDL_GPUTexture* depthTexture,
SDL_GPUTransferBuffer* downloadTransferBuffer,
SDL_GPUGraphicsPipeline* pipeline
);
~Direct3DRMViewport_SDL3GPUImpl() override;
HRESULT Render(IDirect3DRMFrame* group) override;
/**
* @brief Blit the render back to our backbuffer
*/
HRESULT ForceUpdate(int x, int y, int w, int h) override;
HRESULT Clear() override;
HRESULT SetCamera(IDirect3DRMFrame* camera) override;
HRESULT GetCamera(IDirect3DRMFrame** camera) override;
HRESULT SetProjection(D3DRMPROJECTIONTYPE type) override;
D3DRMPROJECTIONTYPE GetProjection() override;
HRESULT SetFront(D3DVALUE z) override;
D3DVALUE GetFront() override;
HRESULT SetBack(D3DVALUE z) override;
D3DVALUE GetBack() override;
HRESULT SetField(D3DVALUE field) override;
D3DVALUE GetField() override;
DWORD GetWidth() override;
DWORD GetHeight() override;
HRESULT Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world) override;
HRESULT InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen) override;
HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) override;
void CloseDevice();
HRESULT CollectSceneData();
void PushVertices(const PositionColorVertex* vertices, size_t count);
private:
void FreeDeviceResources();
int m_vertexBufferCount = 0;
int m_vertexCount;
D3DCOLOR m_backgroundColor = 0xFF000000;
DWORD m_width;
DWORD m_height;
IDirect3DRMFrame* m_rootFrame = nullptr;
IDirect3DRMFrame* m_camera = nullptr;
SDL_GPUDevice* m_device;
SDL_GPUGraphicsPipeline* m_pipeline;
SDL_GPUTexture* m_transferTexture;
SDL_GPUTexture* m_depthTexture;
SDL_GPUTransferBuffer* m_downloadTransferBuffer;
SDL_GPUBuffer* m_vertexBuffer = nullptr;
SDL_Surface* m_renderedImage = nullptr;
D3DVALUE m_front = 1.f;
D3DVALUE m_back = 10.f;
D3DVALUE m_field = 0.5f;
ViewportUniforms m_uniforms;
};
struct Direct3DRMViewportArray_SDL3GPUImpl : public Direct3DRMArrayBase_SDL3GPUImpl<
IDirect3DRMViewport,
Direct3DRMViewport_SDL3GPUImpl,
IDirect3DRMViewportArray> {
using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
};

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

@ -1,9 +0,0 @@
#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;
};

366
miniwin/sdl3gpu/src/miniwin_d3drm.cpp
View File

@ -1,366 +0,0 @@
#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>
Direct3DRMPickedArray_SDL3GPUImpl::Direct3DRMPickedArray_SDL3GPUImpl(const PickRecord* inputPicks, size_t count)
{
picks.reserve(count);
for (size_t i = 0; i < count; ++i) {
const PickRecord& pick = inputPicks[i];
if (pick.visual) {
pick.visual->AddRef();
}
if (pick.frameArray) {
pick.frameArray->AddRef();
}
picks.push_back(pick);
}
}
Direct3DRMPickedArray_SDL3GPUImpl::~Direct3DRMPickedArray_SDL3GPUImpl()
{
for (PickRecord& pick : picks) {
if (pick.visual) {
pick.visual->Release();
}
if (pick.frameArray) {
pick.frameArray->Release();
}
}
}
DWORD Direct3DRMPickedArray_SDL3GPUImpl::GetSize()
{
return static_cast<DWORD>(picks.size());
}
HRESULT Direct3DRMPickedArray_SDL3GPUImpl::GetPick(
DWORD index,
IDirect3DRMVisual** visual,
IDirect3DRMFrameArray** frameArray,
D3DRMPICKDESC* desc
)
{
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;
}
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[3] = {};
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_FLOAT3;
vertexAttrs[1].offset = sizeof(float) * 3;
vertexAttrs[2].location = 2;
vertexAttrs[2].buffer_slot = 0;
vertexAttrs[2].format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM;
vertexAttrs[2].offset = sizeof(float) * 6;
SDL_GPUVertexInputState vertexInputState = {};
vertexInputState.vertex_buffer_descriptions = vertexBufferDescs;
vertexInputState.num_vertex_buffers = SDL_arraysize(vertexBufferDescs);
vertexInputState.vertex_attributes = vertexAttrs;
vertexInputState.num_vertex_attributes = SDL_arraysize(vertexAttrs);
SDL_GPUColorTargetDescription colorTargets = {};
colorTargets.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
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;
pipelineCreateInfo.target_info.has_depth_stencil_target = true;
pipelineCreateInfo.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
pipelineCreateInfo.depth_stencil_state.enable_depth_test = true;
pipelineCreateInfo.depth_stencil_state.enable_depth_write = true;
pipelineCreateInfo.depth_stencil_state.enable_stencil_test = false;
pipelineCreateInfo.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_GREATER;
pipelineCreateInfo.depth_stencil_state.write_mask = 0xff;
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) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUDevice failed (%s)", SDL_GetError());
return DDERR_GENERIC;
}
if (DDWindow_SDL3GPU == NULL) {
return DDERR_GENERIC;
}
if (!SDL_ClaimWindowForGPUDevice(device, DDWindow_SDL3GPU)) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_ClaimWindowForGPUDevice failed (%s)", SDL_GetError());
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;
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) {
SDL_ReleaseGPUGraphicsPipeline(device->m_device, pipeline);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTexture for backbuffer failed (%s)", SDL_GetError());
return DDERR_GENERIC;
}
SDL_GPUTextureCreateInfo depthTextureInfo = {};
depthTextureInfo.type = SDL_GPU_TEXTURETYPE_2D;
depthTextureInfo.format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
depthTextureInfo.width = width;
depthTextureInfo.height = height;
depthTextureInfo.layer_count_or_depth = 1;
depthTextureInfo.num_levels = 1;
depthTextureInfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
SDL_GPUTexture* depthTexture = SDL_CreateGPUTexture(device->m_device, &depthTextureInfo);
if (!depthTexture) {
SDL_ReleaseGPUGraphicsPipeline(device->m_device, pipeline);
SDL_ReleaseGPUTexture(device->m_device, transferTexture);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTexture for depth buffer (%s)", SDL_GetError());
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) {
SDL_ReleaseGPUGraphicsPipeline(device->m_device, pipeline);
SDL_ReleaseGPUTexture(device->m_device, depthTexture);
SDL_ReleaseGPUTexture(device->m_device, transferTexture);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTransferBuffer failed (%s)", SDL_GetError());
return DDERR_GENERIC;
}
auto* viewport = new Direct3DRMViewport_SDL3GPUImpl(
width,
height,
device->m_device,
transferTexture,
depthTexture,
downloadTransferBuffer,
pipeline
);
if (camera) {
viewport->SetCamera(camera);
}
*outViewport = static_cast<IDirect3DRMViewport*>(viewport);
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
View File

@ -1,123 +0,0 @@
#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_SDL3GPU);
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;
}

14
miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp
View File

@ -1,14 +0,0 @@
#include "miniwin_d3drmlight_sdl3gpu.h"
#include "miniwin_p.h"
Direct3DRMLight_SDL3GPUImpl::Direct3DRMLight_SDL3GPUImpl(float r, float g, float b)
{
SetColorRGB(r, g, 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));
return DD_OK;
}

3
miniwin/sdl3gpu/src/miniwn_d3drmmath.h
View File

@ -1,3 +0,0 @@
#pragma once
static void

383
miniwin/src/d3drm/backends/sdl3gpu/renderer.cpp Normal file
View File

@ -0,0 +1,383 @@
#include "ShaderIndex.h"
#include "d3drmrenderer_sdl3gpu.h"
#include "ddraw_impl.h"
#include "miniwin.h"
#include <SDL3/SDL.h>
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[3] = {};
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_FLOAT3;
vertexAttrs[1].offset = sizeof(float) * 3;
vertexAttrs[2].location = 2;
vertexAttrs[2].buffer_slot = 0;
vertexAttrs[2].format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM;
vertexAttrs[2].offset = sizeof(float) * 6;
SDL_GPUVertexInputState vertexInputState = {};
vertexInputState.vertex_buffer_descriptions = vertexBufferDescs;
vertexInputState.num_vertex_buffers = SDL_arraysize(vertexBufferDescs);
vertexInputState.vertex_attributes = vertexAttrs;
vertexInputState.num_vertex_attributes = SDL_arraysize(vertexAttrs);
SDL_GPUColorTargetDescription colorTargets = {};
colorTargets.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
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;
pipelineCreateInfo.target_info.has_depth_stencil_target = true;
pipelineCreateInfo.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
pipelineCreateInfo.depth_stencil_state.enable_depth_test = true;
pipelineCreateInfo.depth_stencil_state.enable_depth_write = true;
pipelineCreateInfo.depth_stencil_state.enable_stencil_test = false;
pipelineCreateInfo.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_GREATER;
pipelineCreateInfo.depth_stencil_state.write_mask = 0xff;
SDL_GPUGraphicsPipeline* pipeline = SDL_CreateGPUGraphicsPipeline(device, &pipelineCreateInfo);
// Clean up shader resources
SDL_ReleaseGPUShader(device, vertexShader);
SDL_ReleaseGPUShader(device, fragmentShader);
return pipeline;
}
Direct3DRMRenderer* Direct3DRMSDL3GPURenderer::Create(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) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUDevice failed (%s)", SDL_GetError());
return nullptr;
}
SDL_GPUGraphicsPipeline* pipeline = InitializeGraphicsPipeline(device);
if (!pipeline) {
return nullptr;
}
SDL_GPUTextureCreateInfo textureInfo = {};
textureInfo.type = SDL_GPU_TEXTURETYPE_2D;
textureInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
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, &textureInfo);
if (!transferTexture) {
SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTexture for backbuffer failed (%s)", SDL_GetError());
return nullptr;
}
SDL_GPUTextureCreateInfo depthTextureInfo = {};
depthTextureInfo.type = SDL_GPU_TEXTURETYPE_2D;
depthTextureInfo.format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
depthTextureInfo.width = width;
depthTextureInfo.height = height;
depthTextureInfo.layer_count_or_depth = 1;
depthTextureInfo.num_levels = 1;
depthTextureInfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
SDL_GPUTexture* depthTexture = SDL_CreateGPUTexture(device, &depthTextureInfo);
if (!depthTexture) {
SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
SDL_ReleaseGPUTexture(device, transferTexture);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTexture for depth buffer (%s)", SDL_GetError());
return nullptr;
}
// 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, &downloadTransferInfo);
if (!downloadTransferBuffer) {
SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
SDL_ReleaseGPUTexture(device, depthTexture);
SDL_ReleaseGPUTexture(device, transferTexture);
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUTransferBuffer failed (%s)", SDL_GetError());
return nullptr;
}
return new Direct3DRMSDL3GPURenderer(
width,
height,
device,
pipeline,
transferTexture,
depthTexture,
downloadTransferBuffer
);
}
Direct3DRMSDL3GPURenderer::Direct3DRMSDL3GPURenderer(
DWORD width,
DWORD height,
SDL_GPUDevice* device,
SDL_GPUGraphicsPipeline* pipeline,
SDL_GPUTexture* transferTexture,
SDL_GPUTexture* depthTexture,
SDL_GPUTransferBuffer* downloadTransferBuffer
)
: m_width(width), m_height(height), m_device(device), m_pipeline(pipeline), m_transferTexture(transferTexture),
m_depthTexture(depthTexture), m_downloadTransferBuffer(downloadTransferBuffer)
{
}
Direct3DRMSDL3GPURenderer::~Direct3DRMSDL3GPURenderer()
{
SDL_ReleaseGPUBuffer(m_device, m_vertexBuffer);
SDL_ReleaseGPUTransferBuffer(m_device, m_downloadTransferBuffer);
SDL_ReleaseGPUTexture(m_device, m_depthTexture);
SDL_ReleaseGPUTexture(m_device, m_transferTexture);
SDL_ReleaseGPUGraphicsPipeline(m_device, m_pipeline);
SDL_DestroyGPUDevice(m_device);
}
void Direct3DRMSDL3GPURenderer::SetBackbuffer(SDL_Surface* buf)
{
m_backbuffer = buf;
}
void Direct3DRMSDL3GPURenderer::PushVertices(const PositionColorVertex* vertices, size_t count)
{
if (count > m_vertexBufferCount) {
if (m_vertexBuffer) {
SDL_ReleaseGPUBuffer(m_device, m_vertexBuffer);
}
SDL_GPUBufferCreateInfo bufferCreateInfo = {};
bufferCreateInfo.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
bufferCreateInfo.size = static_cast<Uint32>(sizeof(PositionColorVertex) * count);
m_vertexBuffer = SDL_CreateGPUBuffer(m_device, &bufferCreateInfo);
if (!m_vertexBuffer) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUBuffer returned NULL buffer (%s)", SDL_GetError());
}
m_vertexBufferCount = count;
}
m_vertexCount = count;
if (!count) {
return;
}
SDL_GPUTransferBufferCreateInfo transferCreateInfo = {};
transferCreateInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
transferCreateInfo.size = static_cast<Uint32>(sizeof(PositionColorVertex) * m_vertexCount);
SDL_GPUTransferBuffer* transferBuffer = SDL_CreateGPUTransferBuffer(m_device, &transferCreateInfo);
if (!transferBuffer) {
SDL_LogError(
LOG_CATEGORY_MINIWIN,
"SDL_CreateGPUTransferBuffer returned NULL transfer buffer (%s)",
SDL_GetError()
);
}
PositionColorVertex* transferData =
(PositionColorVertex*) SDL_MapGPUTransferBuffer(m_device, transferBuffer, false);
if (!transferData) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_MapGPUTransferBuffer returned NULL buffer (%s)", SDL_GetError());
}
memcpy(transferData, vertices, m_vertexCount * sizeof(PositionColorVertex));
SDL_UnmapGPUTransferBuffer(m_device, transferBuffer);
// Upload the transfer data to the vertex buffer
SDL_GPUCommandBuffer* uploadCmdBuf = SDL_AcquireGPUCommandBuffer(m_device);
SDL_GPUCopyPass* copyPass = SDL_BeginGPUCopyPass(uploadCmdBuf);
SDL_GPUTransferBufferLocation transferLocation = {};
transferLocation.transfer_buffer = transferBuffer;
transferLocation.offset = 0;
SDL_GPUBufferRegion bufferRegion = {};
bufferRegion.buffer = m_vertexBuffer;
bufferRegion.offset = 0;
bufferRegion.size = static_cast<Uint32>(sizeof(PositionColorVertex) * m_vertexCount);
SDL_UploadToGPUBuffer(copyPass, &transferLocation, &bufferRegion, false);
SDL_EndGPUCopyPass(copyPass);
if (!SDL_SubmitGPUCommandBuffer(uploadCmdBuf)) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_SubmitGPUCommandBuffer failes (%s)", SDL_GetError());
}
SDL_ReleaseGPUTransferBuffer(m_device, transferBuffer);
}
void Direct3DRMSDL3GPURenderer::SetProjection(D3DRMMATRIX4D perspective, D3DVALUE front, D3DVALUE back)
{
m_front = front;
m_back = back;
memcpy(&m_uniforms.perspective, perspective, sizeof(D3DRMMATRIX4D));
}
DWORD Direct3DRMSDL3GPURenderer::GetWidth()
{
return m_width;
}
DWORD Direct3DRMSDL3GPURenderer::GetHeight()
{
return m_height;
}
void Direct3DRMSDL3GPURenderer::GetDesc(D3DDEVICEDESC* halDesc, D3DDEVICEDESC* helDesc)
{
halDesc->dcmColorModel = D3DCOLORMODEL::RGB;
halDesc->dwFlags = D3DDD_DEVICEZBUFFERBITDEPTH;
halDesc->dwDeviceZBufferBitDepth = DDBD_16; // Todo add support for other depths
halDesc->dwDeviceRenderBitDepth = DDBD_32;
halDesc->dpcTriCaps.dwTextureCaps = D3DPTEXTURECAPS_PERSPECTIVE;
halDesc->dpcTriCaps.dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND;
halDesc->dpcTriCaps.dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR;
memset(helDesc, 0, sizeof(D3DDEVICEDESC));
}
const char* Direct3DRMSDL3GPURenderer::GetName()
{
return "SDL3 GPU Rendere";
}
HRESULT Direct3DRMSDL3GPURenderer::Render()
{
SDL_GPUCommandBuffer* cmdbuf = SDL_AcquireGPUCommandBuffer(m_device);
if (cmdbuf == NULL) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_AcquireGPUCommandBuffer failed (%s)", SDL_GetError());
return DDERR_GENERIC;
}
// Render the graphics
SDL_GPUColorTargetInfo colorTargetInfo = {};
colorTargetInfo.texture = m_transferTexture;
// Make the render target transparent so we can combine it with the back buffer
colorTargetInfo.clear_color = {0, 0, 0, 0};
colorTargetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
SDL_GPUDepthStencilTargetInfo depthStencilTargetInfo = {};
depthStencilTargetInfo.texture = m_depthTexture;
depthStencilTargetInfo.clear_depth = 0.f;
depthStencilTargetInfo.clear_stencil = 0;
depthStencilTargetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
depthStencilTargetInfo.store_op = SDL_GPU_STOREOP_STORE;
depthStencilTargetInfo.stencil_load_op = SDL_GPU_LOADOP_CLEAR;
depthStencilTargetInfo.stencil_store_op = SDL_GPU_STOREOP_STORE;
SDL_GPURenderPass* renderPass = SDL_BeginGPURenderPass(cmdbuf, &colorTargetInfo, 1, &depthStencilTargetInfo);
SDL_BindGPUGraphicsPipeline(renderPass, m_pipeline);
SDL_PushGPUVertexUniformData(cmdbuf, 0, &m_uniforms, sizeof(m_uniforms));
if (m_vertexCount) {
SDL_GPUBufferBinding vertexBufferBinding = {};
vertexBufferBinding.buffer = m_vertexBuffer;
vertexBufferBinding.offset = 0;
SDL_BindGPUVertexBuffers(renderPass, 0, &vertexBufferBinding, 1);
SDL_DrawGPUPrimitives(renderPass, m_vertexCount, 1, 0, 0);
}
SDL_EndGPURenderPass(renderPass);
// Download rendered image
SDL_GPUCopyPass* copyPass = SDL_BeginGPUCopyPass(cmdbuf);
SDL_GPUTextureRegion region = {};
region.texture = m_transferTexture;
region.w = m_width;
region.h = m_height;
region.d = 1;
SDL_GPUTextureTransferInfo transferInfo = {};
transferInfo.transfer_buffer = m_downloadTransferBuffer;
transferInfo.offset = 0;
SDL_DownloadFromGPUTexture(copyPass, &region, &transferInfo);
SDL_EndGPUCopyPass(copyPass);
SDL_GPUFence* fence = SDL_SubmitGPUCommandBufferAndAcquireFence(cmdbuf);
if (!SDL_WaitForGPUFences(m_device, true, &fence, 1)) {
return DDERR_GENERIC;
}
SDL_ReleaseGPUFence(m_device, fence);
void* downloadedData = SDL_MapGPUTransferBuffer(m_device, m_downloadTransferBuffer, false);
if (!downloadedData) {
return DDERR_GENERIC;
}
SDL_DestroySurface(m_renderedImage);
m_renderedImage = SDL_CreateSurfaceFrom(m_width, m_height, SDL_PIXELFORMAT_ABGR8888, downloadedData, m_width * 4);
SDL_Surface* convertedRender = SDL_ConvertSurface(m_renderedImage, SDL_PIXELFORMAT_RGBA8888);
SDL_DestroySurface(m_renderedImage);
SDL_UnmapGPUTransferBuffer(m_device, m_downloadTransferBuffer);
m_renderedImage = convertedRender;
return Blit();
}
HRESULT Direct3DRMSDL3GPURenderer::Blit()
{
// Blit the render back to our backbuffer
SDL_Rect srcRect{0, 0, (int) m_width, (int) m_height};
const SDL_PixelFormatDetails* details = SDL_GetPixelFormatDetails(m_backbuffer->format);
if (details->Amask != 0) {
// Backbuffer supports transparnacy
SDL_Surface* convertedRender = SDL_ConvertSurface(m_renderedImage, m_backbuffer->format);
SDL_DestroySurface(m_renderedImage);
m_renderedImage = convertedRender;
return DD_OK;
}
if (m_renderedImage->format == m_backbuffer->format) {
// No conversion needed
SDL_BlitSurface(m_renderedImage, &srcRect, m_backbuffer, &srcRect);
return DD_OK;
}
// Convert backbuffer to a format that supports transparancy
SDL_Surface* tempBackbuffer = SDL_ConvertSurface(m_backbuffer, m_renderedImage->format);
SDL_BlitSurface(m_renderedImage, &srcRect, tempBackbuffer, &srcRect);
// Then convert the result back to the backbuffer format and write it back
SDL_Surface* newBackBuffer = SDL_ConvertSurface(tempBackbuffer, m_backbuffer->format);
SDL_DestroySurface(tempBackbuffer);
SDL_BlitSurface(newBackBuffer, &srcRect, m_backbuffer, &srcRect);
SDL_DestroySurface(newBackBuffer);
return DD_OK;
}

0
miniwin/sdl3gpu/shaders/gencshadersource.py → miniwin/src/d3drm/backends/sdl3gpu/shaders/gencshadersource.py
View File

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

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

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

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

0
miniwin/sdl3gpu/shaders/src/Common.hlsl → miniwin/src/d3drm/backends/sdl3gpu/shaders/src/Common.hlsl
View File

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

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

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

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

233
miniwin/src/d3drm/d3drm.cpp Normal file
View File

@ -0,0 +1,233 @@
#include "miniwin/d3drm.h"
#include "d3drm_impl.h"
#include "d3drmdevice_impl.h"
#include "d3drmframe_impl.h"
#include "d3drmlight_impl.h"
#include "d3drmmesh_impl.h"
#include "d3drmobject_impl.h"
#include "d3drmrenderer.h"
#include "d3drmrenderer_sdl3gpu.h"
#include "d3drmtexture_impl.h"
#include "d3drmviewport_impl.h"
#include "ddraw_impl.h"
#include "ddsurface_impl.h"
#include "miniwin.h"
#include <SDL3/SDL.h>
Direct3DRMPickedArrayImpl::Direct3DRMPickedArrayImpl(const PickRecord* inputPicks, size_t count)
{
picks.reserve(count);
for (size_t i = 0; i < count; ++i) {
const PickRecord& pick = inputPicks[i];
if (pick.visual) {
pick.visual->AddRef();
}
if (pick.frameArray) {
pick.frameArray->AddRef();
}
picks.push_back(pick);
}
}
Direct3DRMPickedArrayImpl::~Direct3DRMPickedArrayImpl()
{
for (PickRecord& pick : picks) {
if (pick.visual) {
pick.visual->Release();
}
if (pick.frameArray) {
pick.frameArray->Release();
}
}
}
DWORD Direct3DRMPickedArrayImpl::GetSize()
{
return static_cast<DWORD>(picks.size());
}
HRESULT Direct3DRMPickedArrayImpl::GetPick(
DWORD index,
IDirect3DRMVisual** visual,
IDirect3DRMFrameArray** frameArray,
D3DRMPICKDESC* desc
)
{
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;
}
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 Direct3DRMObjectBaseImpl<IDirect3DRMMaterial> {
Direct3DRMMaterialImpl(D3DVALUE power) : m_power(power) {}
D3DVALUE GetPower() override { return m_power; }
private:
D3DVALUE m_power;
};
HRESULT Direct3DRMImpl::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, "Direct3DRMImpl does not implement guid");
return E_NOINTERFACE;
}
HRESULT Direct3DRMImpl::CreateDeviceFromD3D(
const IDirect3D2* d3d,
IDirect3DDevice2* d3dDevice,
IDirect3DRMDevice2** outDevice
)
{
auto renderer = static_cast<Direct3DRMRenderer*>(d3dDevice);
*outDevice = static_cast<IDirect3DRMDevice2*>(
new Direct3DRMDevice2Impl(renderer->GetWidth(), renderer->GetHeight(), renderer)
);
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateDeviceFromSurface(
const GUID* guid,
IDirectDraw* dd,
IDirectDrawSurface* surface,
IDirect3DRMDevice2** outDevice
)
{
DDSURFACEDESC DDSDesc;
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
surface->GetSurfaceDesc(&DDSDesc);
Direct3DRMRenderer* renderer;
if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
renderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Device GUID not recognized");
return E_NOINTERFACE;
}
*outDevice =
static_cast<IDirect3DRMDevice2*>(new Direct3DRMDevice2Impl(DDSDesc.dwWidth, DDSDesc.dwHeight, renderer));
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture)
{
MINIWIN_NOT_IMPLEMENTED();
*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture)
{
MINIWIN_NOT_IMPLEMENTED();
*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateMesh(IDirect3DRMMesh** outMesh)
{
*outMesh = static_cast<IDirect3DRMMesh*>(new Direct3DRMMeshImpl);
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial)
{
*outMaterial = static_cast<IDirect3DRMMaterial*>(new Direct3DRMMaterialImpl(power));
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight)
{
*outLight = static_cast<IDirect3DRMLight*>(new Direct3DRMLightImpl(r, g, b));
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame)
{
auto parentImpl = static_cast<Direct3DRMFrameImpl*>(parent);
*outFrame = static_cast<IDirect3DRMFrame2*>(new Direct3DRMFrameImpl{parentImpl});
return DD_OK;
}
HRESULT Direct3DRMImpl::CreateViewport(
IDirect3DRMDevice2* iDevice,
IDirect3DRMFrame* camera,
int x,
int y,
int width,
int height,
IDirect3DRMViewport** outViewport
)
{
auto device = static_cast<Direct3DRMDevice2Impl*>(iDevice);
auto* viewport = new Direct3DRMViewportImpl(width, height, device->m_renderer);
if (camera) {
viewport->SetCamera(camera);
}
*outViewport = static_cast<IDirect3DRMViewport*>(viewport);
device->AddViewport(*outViewport);
return DD_OK;
}
HRESULT Direct3DRMImpl::SetDefaultTextureShades(DWORD count)
{
return DD_OK;
}
HRESULT Direct3DRMImpl::SetDefaultTextureColors(DWORD count)
{
return DD_OK;
}
HRESULT WINAPI Direct3DRMCreate(IDirect3DRM** direct3DRM)
{
*direct3DRM = new Direct3DRMImpl;
return DD_OK;
}
D3DCOLOR D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)
{
int a = static_cast<int>(255.f * alpha);
int r = static_cast<int>(255.f * red);
int g = static_cast<int>(255.f * green);
int b = static_cast<int>(255.f * blue);
return (a << 24) | (r << 16) | (g << 8) | b;
}

123
miniwin/src/d3drm/d3drmdevice.cpp Normal file
View File

@ -0,0 +1,123 @@
#include "d3drm_impl.h"
#include "d3drmdevice_impl.h"
#include "d3drmobject_impl.h"
#include "d3drmrenderer.h"
#include "d3drmviewport_impl.h"
#include "ddraw_impl.h"
#include "miniwin.h"
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
Direct3DRMDevice2Impl::Direct3DRMDevice2Impl(DWORD width, DWORD height, Direct3DRMRenderer* renderer)
: m_width(width), m_height(height), m_renderer(renderer), 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();
delete m_renderer;
}
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;
}

66
miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp → miniwin/src/d3drm/d3drmframe.cpp
View File

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

13
miniwin/src/d3drm/d3drmlight.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "d3drmlight_impl.h"
Direct3DRMLightImpl::Direct3DRMLightImpl(float r, float g, float b)
{
SetColorRGB(r, g, b);
}
HRESULT Direct3DRMLightImpl::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));
return DD_OK;
}

44
miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp → miniwin/src/d3drm/d3drmmesh.cpp
View File

@ -1,9 +1,9 @@
#include "miniwin_d3drmmesh_sdl3gpu.h"
#include "miniwin_p.h"
#include "d3drmmesh_impl.h"
#include "miniwin.h"
#include <limits>
HRESULT Direct3DRMMesh_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
HRESULT Direct3DRMMeshImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
if (SDL_memcmp(&riid, &IID_IDirect3DRMMesh, sizeof(GUID)) == 0) {
this->IUnknown::AddRef();
@ -17,13 +17,13 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvO
return E_NOINTERFACE;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::Clone(int flags, GUID iid, void** object)
HRESULT Direct3DRMMeshImpl::Clone(int flags, GUID iid, void** object)
{
if (!object || SDL_memcmp(&iid, &IID_IDirect3DRMMesh, sizeof(GUID)) != 0) {
return DDERR_INVALIDPARAMS;
}
auto* clone = new Direct3DRMMesh_SDL3GPUImpl(*this);
auto* clone = new Direct3DRMMeshImpl(*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 Direct3DRMMesh_SDL3GPUImpl::Clone(int flags, GUID iid, void** object)
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::AddGroup(
HRESULT Direct3DRMMeshImpl::AddGroup(
int vertexCount,
int faceCount,
int vertexPerFace,
@ -66,7 +66,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::AddGroup(
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroup(
HRESULT Direct3DRMMeshImpl::GetGroup(
DWORD groupIndex,
DWORD* vertexCount,
DWORD* faceCount,
@ -100,12 +100,12 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroup(
return DD_OK;
}
DWORD Direct3DRMMesh_SDL3GPUImpl::GetGroupCount()
DWORD Direct3DRMMeshImpl::GetGroupCount()
{
return m_groups.size();
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
HRESULT Direct3DRMMeshImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
{
if (groupIndex >= m_groups.size()) {
return DDERR_INVALIDPARAMS;
@ -115,7 +115,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR col
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColorRGB(DWORD groupIndex, float r, float g, float b)
HRESULT Direct3DRMMeshImpl::SetGroupColorRGB(DWORD groupIndex, float r, float g, float b)
{
if (groupIndex >= m_groups.size()) {
return DDERR_INVALIDPARAMS;
@ -128,7 +128,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupColorRGB(DWORD groupIndex, float r,
return DD_OK;
}
D3DCOLOR Direct3DRMMesh_SDL3GPUImpl::GetGroupColor(D3DRMGROUPINDEX index)
D3DCOLOR Direct3DRMMeshImpl::GetGroupColor(D3DRMGROUPINDEX index)
{
if (index < 0 || index >= static_cast<int>(m_groups.size())) {
return 0xFFFFFFFF;
@ -136,7 +136,7 @@ D3DCOLOR Direct3DRMMesh_SDL3GPUImpl::GetGroupColor(D3DRMGROUPINDEX index)
return m_groups[index].color;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupMaterial(DWORD groupIndex, IDirect3DRMMaterial* material)
HRESULT Direct3DRMMeshImpl::SetGroupMaterial(DWORD groupIndex, IDirect3DRMMaterial* material)
{
if (groupIndex >= m_groups.size()) {
return DDERR_INVALIDPARAMS;
@ -147,7 +147,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupMaterial(DWORD groupIndex, IDirect3D
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture* texture)
HRESULT Direct3DRMMeshImpl::SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture* texture)
{
if (groupIndex >= m_groups.size()) {
return DDERR_INVALIDPARAMS;
@ -158,7 +158,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupTexture(DWORD groupIndex, IDirect3DR
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroupMaterial(DWORD groupIndex, LPDIRECT3DRMMATERIAL* material)
HRESULT Direct3DRMMeshImpl::GetGroupMaterial(DWORD groupIndex, LPDIRECT3DRMMATERIAL* material)
{
if (groupIndex >= m_groups.size()) {
return DDERR_GENERIC;
@ -174,7 +174,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroupMaterial(DWORD groupIndex, LPDIRECT3
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3DRMTEXTURE* texture)
HRESULT Direct3DRMMeshImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3DRMTEXTURE* texture)
{
if (groupIndex >= m_groups.size()) {
return DDERR_GENERIC;
@ -190,17 +190,17 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::GetGroupTexture(DWORD groupIndex, LPDIRECT3D
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupMapping(D3DRMGROUPINDEX groupIndex, D3DRMMAPPING mapping)
HRESULT Direct3DRMMeshImpl::SetGroupMapping(D3DRMGROUPINDEX groupIndex, D3DRMMAPPING mapping)
{
return DD_OK;
}
D3DRMMAPPING Direct3DRMMesh_SDL3GPUImpl::GetGroupMapping(DWORD groupIndex)
D3DRMMAPPING Direct3DRMMeshImpl::GetGroupMapping(DWORD groupIndex)
{
return D3DRMMAP_PERSPCORRECT;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDERQUALITY quality)
HRESULT Direct3DRMMeshImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDERQUALITY quality)
{
if (groupIndex >= m_groups.size()) {
return DDERR_INVALIDPARAMS;
@ -210,7 +210,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetGroupQuality(DWORD groupIndex, D3DRMRENDE
return DD_OK;
}
D3DRMRENDERQUALITY Direct3DRMMesh_SDL3GPUImpl::GetGroupQuality(DWORD groupIndex)
D3DRMRENDERQUALITY Direct3DRMMeshImpl::GetGroupQuality(DWORD groupIndex)
{
if (groupIndex >= m_groups.size()) {
return D3DRMRENDER_GOURAUD;
@ -219,7 +219,7 @@ D3DRMRENDERQUALITY Direct3DRMMesh_SDL3GPUImpl::GetGroupQuality(DWORD groupIndex)
return m_groups[groupIndex].quality;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::SetVertices(DWORD groupIndex, int offset, int count, D3DRMVERTEX* vertices)
HRESULT Direct3DRMMeshImpl::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;
@ -235,7 +235,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::SetVertices(DWORD groupIndex, int offset, in
return DD_OK;
}
HRESULT Direct3DRMMesh_SDL3GPUImpl::GetVertices(DWORD groupIndex, int startIndex, int count, D3DRMVERTEX* vertices)
HRESULT Direct3DRMMeshImpl::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;
@ -254,7 +254,7 @@ HRESULT Direct3DRMMesh_SDL3GPUImpl::GetVertices(DWORD groupIndex, int startIndex
/**
* @todo Maybe a good idea to cache this
*/
HRESULT Direct3DRMMesh_SDL3GPUImpl::GetBox(D3DRMBOX* box)
HRESULT Direct3DRMMeshImpl::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();

8
miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp → miniwin/src/d3drm/d3drmtexture.cpp
View File

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

313
miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp → miniwin/src/d3drm/d3drmviewport.cpp
View File

@ -1,10 +1,12 @@
#include "SDL3/SDL_stdinc.h"
#include "miniwin_d3drm_sdl3gpu.h"
#include "miniwin_d3drmframe_sdl3gpu.h"
#include "miniwin_d3drmviewport_sdl3gpu.h"
#include "miniwin_p.h"
#include "d3drm_impl.h"
#include "d3drmframe_impl.h"
#include "d3drmrenderer.h"
#include "d3drmviewport_impl.h"
#include "ddraw_impl.h"
#include "miniwin.h"
#include <SDL3/SDL.h>
#include <SDL3/SDL_stdinc.h>
#include <cassert>
#include <float.h>
#include <functional>
@ -12,32 +14,11 @@
typedef D3DVALUE Matrix3x3[3][3];
Direct3DRMViewport_SDL3GPUImpl::Direct3DRMViewport_SDL3GPUImpl(
DWORD width,
DWORD height,
SDL_GPUDevice* device,
SDL_GPUTexture* transferTexture,
SDL_GPUTexture* depthTexture,
SDL_GPUTransferBuffer* downloadTransferBuffer,
SDL_GPUGraphicsPipeline* pipeline
)
: m_width(width), m_height(height), m_device(device), m_transferTexture(transferTexture),
m_depthTexture(depthTexture), m_downloadTransferBuffer(downloadTransferBuffer), m_pipeline(pipeline)
Direct3DRMViewportImpl::Direct3DRMViewportImpl(DWORD width, DWORD height, Direct3DRMRenderer* rendere)
: m_width(width), m_height(height), m_renderer(rendere)
{
}
void Direct3DRMViewport_SDL3GPUImpl::FreeDeviceResources()
{
SDL_ReleaseGPUBuffer(m_device, m_vertexBuffer);
SDL_ReleaseGPUTexture(m_device, m_depthTexture);
SDL_ReleaseGPUGraphicsPipeline(m_device, m_pipeline);
}
Direct3DRMViewport_SDL3GPUImpl::~Direct3DRMViewport_SDL3GPUImpl()
{
FreeDeviceResources();
}
static void D3DRMMatrixMultiply(D3DRMMATRIX4D out, const D3DRMMATRIX4D a, const D3DRMMATRIX4D b)
{
for (int i = 0; i < 4; ++i) {
@ -88,28 +69,13 @@ static void D3DRMMatrixInvertOrthogonal(D3DRMMATRIX4D out, const D3DRMMATRIX4D m
out[3][2] = -(out[0][2] * t.x + out[1][2] * t.y + out[2][2] * t.z);
}
static void CalculateProjectionMatrix(D3DRMMATRIX4D Result, float field, float aspect, float near, float far)
{
float f = near / field;
float depth = far - near;
D3DRMMATRIX4D perspective = {
{f, 0, 0, 0},
{0, f * aspect, 0, 0},
{0, 0, far / depth, 1},
{0, 0, (-near * far) / depth, 0},
};
memcpy(Result, &perspective, sizeof(D3DRMMATRIX4D));
}
static void ComputeFrameWorldMatrix(IDirect3DRMFrame* frame, D3DRMMATRIX4D out)
{
D3DRMMATRIX4D acc = {{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}};
IDirect3DRMFrame* cur = frame;
while (cur) {
auto* impl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(cur);
auto* impl = static_cast<Direct3DRMFrameImpl*>(cur);
D3DRMMATRIX4D local;
memcpy(local, impl->m_transform, sizeof(local));
@ -125,7 +91,7 @@ static void ComputeFrameWorldMatrix(IDirect3DRMFrame* frame, D3DRMMATRIX4D out)
memcpy(out, acc, sizeof(acc));
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::CollectSceneData()
HRESULT Direct3DRMViewportImpl::CollectSceneData()
{
MINIWIN_NOT_IMPLEMENTED(); // Lights, camera, textures, materials
@ -140,7 +106,7 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::CollectSceneData()
recurseFrame = [&](IDirect3DRMFrame* frame, D3DRMMATRIX4D parentMatrix) {
// Retrieve the current frame's transform
Direct3DRMFrame_SDL3GPUImpl* frameImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(frame);
Direct3DRMFrameImpl* frameImpl = static_cast<Direct3DRMFrameImpl*>(frame);
D3DRMMATRIX4D localMatrix;
memcpy(localMatrix, frameImpl->m_transform, sizeof(D3DRMMATRIX4D));
@ -243,202 +209,34 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::CollectSceneData()
recurseFrame(m_rootFrame, identity);
PushVertices(verts.data(), verts.size());
CalculateProjectionMatrix(m_uniforms.perspective, m_field, (float) m_width / (float) m_height, m_front, m_back);
m_renderer->PushVertices(verts.data(), verts.size());
m_renderer->SetBackbuffer(DDBackBuffer);
return D3DRM_OK;
}
void Direct3DRMViewport_SDL3GPUImpl::PushVertices(const PositionColorVertex* vertices, size_t count)
HRESULT Direct3DRMViewportImpl::Render(IDirect3DRMFrame* rootFrame)
{
if (count > m_vertexBufferCount) {
if (m_vertexBuffer) {
SDL_ReleaseGPUBuffer(m_device, m_vertexBuffer);
}
SDL_GPUBufferCreateInfo bufferCreateInfo = {};
bufferCreateInfo.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
bufferCreateInfo.size = static_cast<Uint32>(sizeof(PositionColorVertex) * count);
m_vertexBuffer = SDL_CreateGPUBuffer(m_device, &bufferCreateInfo);
if (!m_vertexBuffer) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_CreateGPUBuffer returned NULL buffer (%s)", SDL_GetError());
}
m_vertexBufferCount = count;
}
m_vertexCount = count;
if (!count) {
return;
}
SDL_GPUTransferBufferCreateInfo transferCreateInfo = {};
transferCreateInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
transferCreateInfo.size = static_cast<Uint32>(sizeof(PositionColorVertex) * m_vertexCount);
SDL_GPUTransferBuffer* transferBuffer = SDL_CreateGPUTransferBuffer(m_device, &transferCreateInfo);
if (!transferBuffer) {
SDL_LogError(
LOG_CATEGORY_MINIWIN,
"SDL_CreateGPUTransferBuffer returned NULL transfer buffer (%s)",
SDL_GetError()
);
}
PositionColorVertex* transferData =
(PositionColorVertex*) SDL_MapGPUTransferBuffer(m_device, transferBuffer, false);
if (!transferData) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_MapGPUTransferBuffer returned NULL buffer (%s)", SDL_GetError());
}
memcpy(transferData, vertices, m_vertexCount * sizeof(PositionColorVertex));
SDL_UnmapGPUTransferBuffer(m_device, transferBuffer);
// Upload the transfer data to the vertex buffer
SDL_GPUCommandBuffer* uploadCmdBuf = SDL_AcquireGPUCommandBuffer(m_device);
SDL_GPUCopyPass* copyPass = SDL_BeginGPUCopyPass(uploadCmdBuf);
SDL_GPUTransferBufferLocation transferLocation = {};
transferLocation.transfer_buffer = transferBuffer;
transferLocation.offset = 0;
SDL_GPUBufferRegion bufferRegion = {};
bufferRegion.buffer = m_vertexBuffer;
bufferRegion.offset = 0;
bufferRegion.size = static_cast<Uint32>(sizeof(PositionColorVertex) * m_vertexCount);
SDL_UploadToGPUBuffer(copyPass, &transferLocation, &bufferRegion, false);
SDL_EndGPUCopyPass(copyPass);
if (!SDL_SubmitGPUCommandBuffer(uploadCmdBuf)) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_SubmitGPUCommandBuffer failes (%s)", SDL_GetError());
}
SDL_ReleaseGPUTransferBuffer(m_device, transferBuffer);
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::Render(IDirect3DRMFrame* rootFrame)
{
if (!m_device) {
if (!m_renderer) {
return DDERR_GENERIC;
}
m_rootFrame = rootFrame;
HRESULT success = CollectSceneData();
if (success != DD_OK) {
return success;
}
SDL_GPUCommandBuffer* cmdbuf = SDL_AcquireGPUCommandBuffer(m_device);
if (cmdbuf == NULL) {
SDL_LogError(LOG_CATEGORY_MINIWIN, "SDL_AcquireGPUCommandBuffer failed (%s)", SDL_GetError());
return DDERR_GENERIC;
}
// Render the graphics
SDL_GPUColorTargetInfo colorTargetInfo = {};
colorTargetInfo.texture = m_transferTexture;
// Make the render target transparent so we can combine it with the back buffer
colorTargetInfo.clear_color = {0, 0, 0, 0};
colorTargetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
SDL_GPUDepthStencilTargetInfo depthStencilTargetInfo = {};
depthStencilTargetInfo.texture = m_depthTexture;
depthStencilTargetInfo.clear_depth = 0.f;
depthStencilTargetInfo.clear_stencil = 0;
depthStencilTargetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
depthStencilTargetInfo.store_op = SDL_GPU_STOREOP_STORE;
depthStencilTargetInfo.stencil_load_op = SDL_GPU_LOADOP_CLEAR;
depthStencilTargetInfo.stencil_store_op = SDL_GPU_STOREOP_STORE;
SDL_GPURenderPass* renderPass = SDL_BeginGPURenderPass(cmdbuf, &colorTargetInfo, 1, &depthStencilTargetInfo);
SDL_BindGPUGraphicsPipeline(renderPass, m_pipeline);
SDL_PushGPUVertexUniformData(cmdbuf, 0, &m_uniforms, sizeof(m_uniforms));
if (m_vertexCount) {
SDL_GPUBufferBinding vertexBufferBinding = {};
vertexBufferBinding.buffer = m_vertexBuffer;
vertexBufferBinding.offset = 0;
SDL_BindGPUVertexBuffers(renderPass, 0, &vertexBufferBinding, 1);
SDL_DrawGPUPrimitives(renderPass, m_vertexCount, 1, 0, 0);
}
SDL_EndGPURenderPass(renderPass);
// Download rendered image
SDL_GPUCopyPass* copyPass = SDL_BeginGPUCopyPass(cmdbuf);
SDL_GPUTextureRegion region = {};
region.texture = m_transferTexture;
region.w = DDBackBuffer_SDL3GPU->w;
region.h = DDBackBuffer_SDL3GPU->h;
region.d = 1;
SDL_GPUTextureTransferInfo transferInfo = {};
transferInfo.transfer_buffer = m_downloadTransferBuffer;
transferInfo.offset = 0;
SDL_DownloadFromGPUTexture(copyPass, &region, &transferInfo);
SDL_EndGPUCopyPass(copyPass);
SDL_GPUFence* fence = SDL_SubmitGPUCommandBufferAndAcquireFence(cmdbuf);
if (!SDL_WaitForGPUFences(m_device, true, &fence, 1)) {
return DDERR_GENERIC;
}
SDL_ReleaseGPUFence(m_device, fence);
void* downloadedData = SDL_MapGPUTransferBuffer(m_device, m_downloadTransferBuffer, false);
if (!downloadedData) {
return DDERR_GENERIC;
}
SDL_DestroySurface(m_renderedImage);
m_renderedImage = SDL_CreateSurfaceFrom(
DDBackBuffer_SDL3GPU->w,
DDBackBuffer_SDL3GPU->h,
SDL_PIXELFORMAT_ABGR8888,
downloadedData,
DDBackBuffer_SDL3GPU->w * 4
);
SDL_Surface* convertedRender = SDL_ConvertSurface(m_renderedImage, SDL_PIXELFORMAT_RGBA8888);
SDL_DestroySurface(m_renderedImage);
SDL_UnmapGPUTransferBuffer(m_device, m_downloadTransferBuffer);
m_renderedImage = convertedRender;
return ForceUpdate(0, 0, DDBackBuffer_SDL3GPU->w, DDBackBuffer_SDL3GPU->h);
return m_renderer->Render();
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::ForceUpdate(int x, int y, int w, int h)
HRESULT Direct3DRMViewportImpl::ForceUpdate(int x, int y, int w, int h)
{
if (!m_renderedImage) {
return DDERR_GENERIC;
}
// Blit the render back to our backbuffer
SDL_Rect srcRect{0, 0, DDBackBuffer_SDL3GPU->w, DDBackBuffer_SDL3GPU->h};
const SDL_PixelFormatDetails* details = SDL_GetPixelFormatDetails(DDBackBuffer_SDL3GPU->format);
if (details->Amask != 0) {
// Backbuffer supports transparnacy
SDL_Surface* convertedRender = SDL_ConvertSurface(m_renderedImage, DDBackBuffer_SDL3GPU->format);
SDL_DestroySurface(m_renderedImage);
m_renderedImage = convertedRender;
return DD_OK;
}
if (m_renderedImage->format == DDBackBuffer_SDL3GPU->format) {
// No conversion needed
SDL_BlitSurface(m_renderedImage, &srcRect, DDBackBuffer_SDL3GPU, &srcRect);
return DD_OK;
}
// Convert backbuffer to a format that supports transparancy
SDL_Surface* tempBackbuffer = SDL_ConvertSurface(DDBackBuffer_SDL3GPU, m_renderedImage->format);
SDL_BlitSurface(m_renderedImage, &srcRect, tempBackbuffer, &srcRect);
// Then convert the result back to the backbuffer format and write it back
SDL_Surface* newBackBuffer = SDL_ConvertSurface(tempBackbuffer, DDBackBuffer_SDL3GPU->format);
SDL_DestroySurface(tempBackbuffer);
SDL_BlitSurface(newBackBuffer, &srcRect, DDBackBuffer_SDL3GPU, &srcRect);
SDL_DestroySurface(newBackBuffer);
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::Clear()
HRESULT Direct3DRMViewportImpl::Clear()
{
if (!DDBackBuffer_SDL3GPU) {
if (!DDBackBuffer) {
return DDERR_GENERIC;
}
@ -446,12 +244,12 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::Clear()
uint8_t g = (m_backgroundColor >> 8) & 0xFF;
uint8_t b = m_backgroundColor & 0xFF;
Uint32 color = SDL_MapRGB(SDL_GetPixelFormatDetails(DDBackBuffer_SDL3GPU->format), nullptr, r, g, b);
SDL_FillSurfaceRect(DDBackBuffer_SDL3GPU, NULL, color);
Uint32 color = SDL_MapRGB(SDL_GetPixelFormatDetails(DDBackBuffer->format), nullptr, r, g, b);
SDL_FillSurfaceRect(DDBackBuffer, NULL, color);
return DD_OK;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::SetCamera(IDirect3DRMFrame* camera)
HRESULT Direct3DRMViewportImpl::SetCamera(IDirect3DRMFrame* camera)
{
if (m_camera) {
m_camera->Release();
@ -463,7 +261,7 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::SetCamera(IDirect3DRMFrame* camera)
return DD_OK;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::GetCamera(IDirect3DRMFrame** camera)
HRESULT Direct3DRMViewportImpl::GetCamera(IDirect3DRMFrame** camera)
{
if (m_camera) {
m_camera->AddRef();
@ -472,66 +270,85 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::GetCamera(IDirect3DRMFrame** camera)
return DD_OK;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::SetProjection(D3DRMPROJECTIONTYPE type)
HRESULT Direct3DRMViewportImpl::SetProjection(D3DRMPROJECTIONTYPE type)
{
return DD_OK;
}
D3DRMPROJECTIONTYPE Direct3DRMViewport_SDL3GPUImpl::GetProjection()
D3DRMPROJECTIONTYPE Direct3DRMViewportImpl::GetProjection()
{
return D3DRMPROJECTIONTYPE::PERSPECTIVE;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::SetFront(D3DVALUE z)
HRESULT Direct3DRMViewportImpl::SetFront(D3DVALUE z)
{
m_front = z;
UpdateProjectionMatrix();
return DD_OK;
}
D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetFront()
D3DVALUE Direct3DRMViewportImpl::GetFront()
{
return m_front;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::SetBack(D3DVALUE z)
HRESULT Direct3DRMViewportImpl::SetBack(D3DVALUE z)
{
m_back = z;
UpdateProjectionMatrix();
return DD_OK;
}
D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetBack()
D3DVALUE Direct3DRMViewportImpl::GetBack()
{
return m_back;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::SetField(D3DVALUE field)
HRESULT Direct3DRMViewportImpl::SetField(D3DVALUE field)
{
m_field = field;
UpdateProjectionMatrix();
return DD_OK;
}
D3DVALUE Direct3DRMViewport_SDL3GPUImpl::GetField()
void Direct3DRMViewportImpl::UpdateProjectionMatrix()
{
float aspect = (float) m_width / (float) m_height;
float f = m_front / m_field;
float depth = m_back - m_front;
D3DRMMATRIX4D perspective = {
{f, 0, 0, 0},
{0, f * aspect, 0, 0},
{0, 0, m_back / depth, 1},
{0, 0, (-m_front * m_back) / depth, 0},
};
m_renderer->SetProjection(perspective, m_front, m_back);
}
D3DVALUE Direct3DRMViewportImpl::GetField()
{
return m_field;
}
DWORD Direct3DRMViewport_SDL3GPUImpl::GetWidth()
DWORD Direct3DRMViewportImpl::GetWidth()
{
return m_width;
}
DWORD Direct3DRMViewport_SDL3GPUImpl::GetHeight()
DWORD Direct3DRMViewportImpl::GetHeight()
{
return m_height;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world)
HRESULT Direct3DRMViewportImpl::Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world)
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT Direct3DRMViewport_SDL3GPUImpl::InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen)
HRESULT Direct3DRMViewportImpl::InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen)
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
@ -599,10 +416,7 @@ Ray BuildPickingRay(
)
{
float nx = (2.0f * x) / width - 1.0f;
float ny = 1.0f - (2.0f * y) / height; // flip Y since screen Y down
D3DRMMATRIX4D proj;
CalculateProjectionMatrix(proj, field, aspect, front, back);
float ny = 1.0f - (2.0f * y) / height;
float f = front / field;
@ -639,7 +453,7 @@ Ray BuildPickingRay(
/**
* @todo additionally check that we hit a triangle in the mesh
*/
HRESULT Direct3DRMViewport_SDL3GPUImpl::Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray)
HRESULT Direct3DRMViewportImpl::Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray)
{
if (!m_rootFrame) {
return DDERR_GENERIC;
@ -661,7 +475,7 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::Pick(float x, float y, LPDIRECT3DRMPICKE
std::function<void(IDirect3DRMFrame*, std::vector<IDirect3DRMFrame*>&)> recurse;
recurse = [&](IDirect3DRMFrame* frame, std::vector<IDirect3DRMFrame*>& path) {
Direct3DRMFrame_SDL3GPUImpl* frameImpl = static_cast<Direct3DRMFrame_SDL3GPUImpl*>(frame);
Direct3DRMFrameImpl* frameImpl = static_cast<Direct3DRMFrameImpl*>(frame);
path.push_back(frame); // Push current frame
IDirect3DRMVisualArray* visuals = nullptr;
@ -742,7 +556,7 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::Pick(float x, float y, LPDIRECT3DRMPICKE
float distance = 0.0f;
if (RayIntersectsBox(pickRay, worldBox, distance)) {
auto* arr = new Direct3DRMFrameArray_SDL3GPUImpl();
auto* arr = new Direct3DRMFrameArrayImpl();
for (IDirect3DRMFrame* f : path) {
arr->AddElement(f);
}
@ -770,13 +584,12 @@ HRESULT Direct3DRMViewport_SDL3GPUImpl::Pick(float x, float y, LPDIRECT3DRMPICKE
return a.desc.dist < b.desc.dist;
});
*pickedArray = new Direct3DRMPickedArray_SDL3GPUImpl(hits.data(), hits.size());
*pickedArray = new Direct3DRMPickedArrayImpl(hits.data(), hits.size());
return D3DRM_OK;
}
void Direct3DRMViewport_SDL3GPUImpl::CloseDevice()
void Direct3DRMViewportImpl::CloseDevice()
{
FreeDeviceResources();
m_device = nullptr;
m_renderer = nullptr;
}

22
miniwin/sdl3gpu/src/miniwin_ddpalette.cpp → miniwin/src/ddraw/ddpalette.cpp
View File

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

157
miniwin/sdl3gpu/src/miniwin_ddraw.cpp → miniwin/src/ddraw/ddraw.cpp
View File

@ -1,9 +1,9 @@
#include "miniwin_d3d.h"
#include "miniwin_ddpalette_sdl3gpu.h"
#include "miniwin_ddraw_sdl3gpu.h"
#include "miniwin_ddsurface_sdl3gpu.h"
#include "miniwin_p.h"
#include "d3drmrenderer_sdl3gpu.h"
#include "ddpalette_impl.h"
#include "ddraw_impl.h"
#include "ddsurface_impl.h"
#include "miniwin.h"
#include "miniwin/d3d.h"
#include <SDL3/SDL.h>
#include <assert.h>
@ -11,10 +11,10 @@
#include <cstdlib>
#include <cstring>
SDL_Window* DDWindow_SDL3GPU;
SDL_Surface* DDBackBuffer_SDL3GPU;
SDL_Window* DDWindow;
SDL_Surface* DDBackBuffer;
HRESULT DirectDraw_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
HRESULT DirectDrawImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
if (SDL_memcmp(&riid, &IID_IDirectDraw2, sizeof(GUID)) == 0) {
this->IUnknown::AddRef();
@ -31,14 +31,14 @@ HRESULT DirectDraw_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObjec
}
// IDirectDraw interface
HRESULT DirectDraw_SDL3GPUImpl::CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter)
HRESULT DirectDrawImpl::CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER* lplpDDClipper, IUnknown* pUnkOuter)
{
*lplpDDClipper = new IDirectDrawClipper;
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::CreatePalette(
HRESULT DirectDrawImpl::CreatePalette(
DDPixelCaps dwFlags,
LPPALETTEENTRY lpColorTable,
LPDIRECTDRAWPALETTE* lplpDDPalette,
@ -49,11 +49,11 @@ HRESULT DirectDraw_SDL3GPUImpl::CreatePalette(
return DDERR_INVALIDPARAMS;
}
*lplpDDPalette = static_cast<LPDIRECTDRAWPALETTE>(new DirectDrawPalette_SDL3GPUImpl(lpColorTable));
*lplpDDPalette = static_cast<LPDIRECTDRAWPALETTE>(new DirectDrawPaletteImpl(lpColorTable));
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::CreateSurface(
HRESULT DirectDrawImpl::CreateSurface(
LPDDSURFACEDESC lpDDSurfaceDesc,
LPDIRECTDRAWSURFACE* lplpDDSurface,
IUnknown* pUnkOuter
@ -83,18 +83,18 @@ HRESULT DirectDraw_SDL3GPUImpl::CreateSurface(
return DDERR_INVALIDPARAMS;
}
SDL_Log("Todo: Set %dbit Z-Buffer", lpDDSurfaceDesc->dwZBufferBitDepth);
*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurface_SDL3GPUImpl);
*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurfaceImpl);
return DD_OK;
}
if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) == DDSCAPS_PRIMARYSURFACE) {
SDL_Surface* windowSurface = SDL_GetWindowSurface(DDWindow_SDL3GPU);
SDL_Surface* windowSurface = SDL_GetWindowSurface(DDWindow);
if (!windowSurface) {
return DDERR_GENERIC;
}
int width, height;
SDL_GetWindowSize(DDWindow_SDL3GPU, &width, &height);
SDL_GetWindowSize(DDWindow, &width, &height);
bool implicitFlip = (lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_FLIP) != DDSCAPS_FLIP;
auto frontBuffer = new DirectDrawSurface_SDL3GPUImpl(width, height, windowSurface->format);
auto frontBuffer = new DirectDrawSurfaceImpl(width, height, windowSurface->format);
frontBuffer->SetAutoFlip(implicitFlip);
*lplpDDSurface = static_cast<IDirectDrawSurface*>(frontBuffer);
return DD_OK;
@ -125,11 +125,11 @@ HRESULT DirectDraw_SDL3GPUImpl::CreateSurface(
if (width == 0 || height == 0) {
return DDERR_INVALIDPARAMS;
}
*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurface_SDL3GPUImpl(width, height, format));
*lplpDDSurface = static_cast<IDirectDrawSurface*>(new DirectDrawSurfaceImpl(width, height, format));
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::EnumDisplayModes(
HRESULT DirectDrawImpl::EnumDisplayModes(
DWORD dwFlags,
LPDDSURFACEDESC lpDDSurfaceDesc,
LPVOID lpContext,
@ -185,13 +185,13 @@ HRESULT DirectDraw_SDL3GPUImpl::EnumDisplayModes(
return status;
}
HRESULT DirectDraw_SDL3GPUImpl::FlipToGDISurface()
HRESULT DirectDrawImpl::FlipToGDISurface()
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
HRESULT DirectDrawImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
{
if (lpDDDriverCaps) {
if (lpDDDriverCaps->dwSize >= sizeof(DDCAPS)) {
@ -208,63 +208,28 @@ HRESULT DirectDraw_SDL3GPUImpl::GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHE
return S_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
{
int numDrivers = SDL_GetNumRenderDrivers();
if (numDrivers <= 0) {
return DDERR_GENERIC;
auto device = Direct3DRMSDL3GPURenderer::Create(640, 480);
if (!device) {
return S_OK;
}
DDBitDepths renderBitDepth = DDBD_32;
#ifdef MINIWIN_PIXELFORMAT
SDL_PixelFormat format = MINIWIN_PIXELFORMAT;
const SDL_PixelFormatDetails* details = SDL_GetPixelFormatDetails(format);
switch (details->bits_per_pixel) {
case 8:
renderBitDepth = DDBD_8;
break;
case 16:
renderBitDepth = DDBD_16;
break;
case 24:
renderBitDepth = DDBD_24;
break;
default:
break;
}
#endif
const char* deviceDesc = "SDL3 SDL_Renderer";
for (int i = 0; i < numDrivers; ++i) {
const char* deviceName = SDL_GetRenderDriver(i);
if (!deviceName) {
return DDERR_GENERIC;
}
GUID deviceGuid = {0x682656F3, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (uint8_t) i}};
D3DDEVICEDESC halDesc = {};
halDesc.dcmColorModel = D3DCOLORMODEL::RGB;
halDesc.dwFlags = D3DDD_DEVICEZBUFFERBITDEPTH;
halDesc.dwDeviceZBufferBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
halDesc.dwDeviceRenderBitDepth = renderBitDepth;
halDesc.dpcTriCaps.dwTextureCaps = D3DPTEXTURECAPS_PERSPECTIVE;
halDesc.dpcTriCaps.dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND;
halDesc.dpcTriCaps.dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR;
char* deviceNameDup = SDL_strdup(deviceName);
char* deviceDescDup = SDL_strdup(deviceDesc);
cb(&deviceGuid, deviceNameDup, deviceDescDup, &halDesc, &halDesc, ctx);
SDL_free(deviceDescDup);
SDL_free(deviceNameDup);
}
GUID deviceGuid = SDL3_GPU_GUID;
D3DDEVICEDESC halDesc = {};
D3DDEVICEDESC helDesc = {};
device->GetDesc(&halDesc, &helDesc);
char* deviceNameDup = SDL_strdup(device->GetName());
char* deviceDescDup = SDL_strdup("Miniwin driver");
cb(&deviceGuid, deviceNameDup, deviceDescDup, &halDesc, &helDesc, ctx);
SDL_free(deviceDescDup);
SDL_free(deviceNameDup);
delete device;
return S_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT DirectDrawImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
{
SDL_DisplayID displayID = SDL_GetPrimaryDisplay();
if (!displayID) {
@ -300,13 +265,13 @@ HRESULT DirectDraw_SDL3GPUImpl::GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::RestoreDisplayMode()
HRESULT DirectDrawImpl::RestoreDisplayMode()
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
HRESULT DirectDrawImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
{
if (hWnd) {
bool fullscreen;
@ -323,43 +288,55 @@ HRESULT DirectDraw_SDL3GPUImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlag
if (!SDL_SetWindowFullscreen(hWnd, fullscreen)) {
return DDERR_GENERIC;
}
DDWindow_SDL3GPU = hWnd;
DDWindow = hWnd;
}
return DD_OK;
}
HRESULT DirectDraw_SDL3GPUImpl::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
HRESULT DirectDrawImpl::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
// IDirect3D2 interface
HRESULT DirectDraw_SDL3GPUImpl::CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice)
HRESULT DirectDrawImpl::CreateDevice(
const GUID& guid,
IDirectDrawSurface* pBackBuffer,
IDirect3DDevice2** ppDirect3DDevice
)
{
*ppDirect3DDevice = new IDirect3DDevice2;
DDSURFACEDESC DDSDesc;
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
pBackBuffer->GetSurfaceDesc(&DDSDesc);
Direct3DRMRenderer* renderer;
if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
renderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Device GUID not recognized");
return E_NOINTERFACE;
}
*ppDirect3DDevice = static_cast<IDirect3DDevice2*>(renderer);
return DD_OK;
}
HRESULT DirectDrawEnumerate_SDL3GPU(LPDDENUMCALLBACKA cb, void* context)
HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context)
{
int numDrivers = SDL_GetNumVideoDrivers();
for (int i = 0; i < numDrivers; ++i) {
const char* driverName = SDL_GetVideoDriver(i);
char* driverNameDup = SDL_strdup(driverName);
BOOL callback_result = cb(NULL, driverNameDup, NULL, context);
SDL_free(driverNameDup);
if (!callback_result) {
return DDERR_GENERIC;
}
const char* driverName = SDL_GetCurrentVideoDriver();
char* driverNameDup = SDL_strdup(driverName);
BOOL callback_result = cb(NULL, driverNameDup, NULL, context);
SDL_free(driverNameDup);
if (!callback_result) {
return DDERR_GENERIC;
}
return DD_OK;
}
HRESULT DirectDrawCreate_SDL3GPU(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter)
HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter)
{
*lplpDD = new DirectDraw_SDL3GPUImpl;
*lplpDD = new DirectDrawImpl;
return DD_OK;
}

74
miniwin/sdl3gpu/src/miniwin_ddsurface.cpp → miniwin/src/ddraw/ddsurface.cpp
View File

@ -1,16 +1,15 @@
#include "miniwin_d3drm_sdl3gpu.h"
#include "miniwin_ddpalette_sdl3gpu.h"
#include "miniwin_ddraw_sdl3gpu.h"
#include "miniwin_ddsurface_sdl3gpu.h"
#include "miniwin_p.h"
#include "ddpalette_impl.h"
#include "ddraw_impl.h"
#include "ddsurface_impl.h"
#include "miniwin.h"
#include <assert.h>
DirectDrawSurface_SDL3GPUImpl::DirectDrawSurface_SDL3GPUImpl()
DirectDrawSurfaceImpl::DirectDrawSurfaceImpl()
{
}
DirectDrawSurface_SDL3GPUImpl::DirectDrawSurface_SDL3GPUImpl(int width, int height, SDL_PixelFormat format)
DirectDrawSurfaceImpl::DirectDrawSurfaceImpl(int width, int height, SDL_PixelFormat format)
{
m_surface = SDL_CreateSurface(width, height, format);
if (!m_surface) {
@ -18,7 +17,7 @@ DirectDrawSurface_SDL3GPUImpl::DirectDrawSurface_SDL3GPUImpl(int width, int heig
}
}
DirectDrawSurface_SDL3GPUImpl::~DirectDrawSurface_SDL3GPUImpl()
DirectDrawSurfaceImpl::~DirectDrawSurfaceImpl()
{
if (m_surface) {
SDL_DestroySurface(m_surface);
@ -29,7 +28,7 @@ DirectDrawSurface_SDL3GPUImpl::~DirectDrawSurface_SDL3GPUImpl()
}
// IUnknown interface
HRESULT DirectDrawSurface_SDL3GPUImpl::QueryInterface(const GUID& riid, void** ppvObject)
HRESULT DirectDrawSurfaceImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
if (SDL_memcmp(&riid, &IID_IDirectDrawSurface3, sizeof(GUID)) == 0) {
this->IUnknown::AddRef();
@ -41,12 +40,12 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::QueryInterface(const GUID& riid, void** p
}
// IDirectDrawSurface interface
HRESULT DirectDrawSurface_SDL3GPUImpl::AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
HRESULT DirectDrawSurfaceImpl::AddAttachedSurface(LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
{
return DD_OK;
}
void DirectDrawSurface_SDL3GPUImpl::SetAutoFlip(bool enabled)
void DirectDrawSurfaceImpl::SetAutoFlip(bool enabled)
{
m_autoFlip = enabled;
}
@ -56,7 +55,7 @@ static SDL_Rect ConvertRect(const RECT* r)
return {r->left, r->top, r->right - r->left, r->bottom - r->top};
}
HRESULT DirectDrawSurface_SDL3GPUImpl::Blt(
HRESULT DirectDrawSurfaceImpl::Blt(
LPRECT lpDestRect,
LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect,
@ -64,12 +63,12 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::Blt(
LPDDBLTFX lpDDBltFx
)
{
auto srcSurface = static_cast<DirectDrawSurface_SDL3GPUImpl*>(lpDDSrcSurface);
auto srcSurface = static_cast<DirectDrawSurfaceImpl*>(lpDDSrcSurface);
if (!srcSurface || !srcSurface->m_surface) {
return DDERR_GENERIC;
}
if (m_autoFlip) {
DDBackBuffer_SDL3GPU = srcSurface->m_surface;
DDBackBuffer = srcSurface->m_surface;
return Flip(nullptr, DDFLIP_WAIT);
}
@ -111,7 +110,7 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::Blt(
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::BltFast(
HRESULT DirectDrawSurfaceImpl::BltFast(
DWORD dwX,
DWORD dwY,
LPDIRECTDRAWSURFACE lpDDSrcSurface,
@ -128,43 +127,40 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::BltFast(
return Blt(&destRect, lpDDSrcSurface, lpSrcRect, DDBLT_NONE, nullptr);
}
HRESULT DirectDrawSurface_SDL3GPUImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags)
HRESULT DirectDrawSurfaceImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags)
{
if (!DDBackBuffer_SDL3GPU) {
if (!DDBackBuffer) {
return DDERR_GENERIC;
}
SDL_Surface* windowSurface = SDL_GetWindowSurface(DDWindow_SDL3GPU);
SDL_Surface* windowSurface = SDL_GetWindowSurface(DDWindow);
if (!windowSurface) {
return DDERR_GENERIC;
}
SDL_Rect srcRect{0, 0, DDBackBuffer_SDL3GPU->w, DDBackBuffer_SDL3GPU->h};
SDL_Surface* copy = SDL_ConvertSurface(DDBackBuffer_SDL3GPU, windowSurface->format);
SDL_Rect srcRect{0, 0, DDBackBuffer->w, DDBackBuffer->h};
SDL_Surface* copy = SDL_ConvertSurface(DDBackBuffer, windowSurface->format);
SDL_BlitSurface(copy, &srcRect, windowSurface, &srcRect);
SDL_DestroySurface(copy);
SDL_UpdateWindowSurface(DDWindow_SDL3GPU);
SDL_UpdateWindowSurface(DDWindow);
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::GetAttachedSurface(
LPDDSCAPS lpDDSCaps,
LPDIRECTDRAWSURFACE* lplpDDAttachedSurface
)
HRESULT DirectDrawSurfaceImpl::GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface)
{
if ((lpDDSCaps->dwCaps & DDSCAPS_BACKBUFFER) != DDSCAPS_BACKBUFFER) {
return DDERR_INVALIDPARAMS;
}
DDBackBuffer_SDL3GPU = m_surface;
DDBackBuffer = m_surface;
*lplpDDAttachedSurface = static_cast<IDirectDrawSurface*>(this);
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::GetDC(HDC* lphDC)
HRESULT DirectDrawSurfaceImpl::GetDC(HDC* lphDC)
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette)
HRESULT DirectDrawSurfaceImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPalette)
{
if (!m_palette) {
return DDERR_GENERIC;
@ -174,7 +170,7 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::GetPalette(LPDIRECTDRAWPALETTE* lplpDDPal
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat)
HRESULT DirectDrawSurfaceImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelFormat)
{
if (!m_surface) {
return DDERR_GENERIC;
@ -192,7 +188,7 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::GetPixelFormat(LPDDPIXELFORMAT lpDDPixelF
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT DirectDrawSurfaceImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfaceDesc)
{
if (!m_surface) {
return DDERR_GENERIC;
@ -207,12 +203,12 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::GetSurfaceDesc(LPDDSURFACEDESC lpDDSurfac
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::IsLost()
HRESULT DirectDrawSurfaceImpl::IsLost()
{
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::Lock(
HRESULT DirectDrawSurfaceImpl::Lock(
LPRECT lpDestRect,
LPDDSURFACEDESC lpDDSurfaceDesc,
DDLockFlags dwFlags,
@ -234,23 +230,23 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::Lock(
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::ReleaseDC(HDC hDC)
HRESULT DirectDrawSurfaceImpl::ReleaseDC(HDC hDC)
{
MINIWIN_NOT_IMPLEMENTED();
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::Restore()
HRESULT DirectDrawSurfaceImpl::Restore()
{
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper)
HRESULT DirectDrawSurfaceImpl::SetClipper(LPDIRECTDRAWCLIPPER lpDDClipper)
{
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey)
HRESULT DirectDrawSurfaceImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDDCOLORKEY lpDDColorKey)
{
if (lpDDColorKey->dwColorSpaceLowValue != lpDDColorKey->dwColorSpaceHighValue) {
MINIWIN_NOT_IMPLEMENTED();
@ -263,7 +259,7 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::SetColorKey(DDColorKeyFlags dwFlags, LPDD
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette)
HRESULT DirectDrawSurfaceImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalette)
{
if (m_surface->format != SDL_PIXELFORMAT_INDEX8) {
MINIWIN_NOT_IMPLEMENTED();
@ -274,12 +270,12 @@ HRESULT DirectDrawSurface_SDL3GPUImpl::SetPalette(LPDIRECTDRAWPALETTE lpDDPalett
}
m_palette = lpDDPalette;
SDL_SetSurfacePalette(m_surface, ((DirectDrawPalette_SDL3GPUImpl*) m_palette)->m_palette);
SDL_SetSurfacePalette(m_surface, ((DirectDrawPaletteImpl*) m_palette)->m_palette);
m_palette->AddRef();
return DD_OK;
}
HRESULT DirectDrawSurface_SDL3GPUImpl::Unlock(LPVOID lpSurfaceData)
HRESULT DirectDrawSurfaceImpl::Unlock(LPVOID lpSurfaceData)
{
if (!m_surface) {
return DDERR_GENERIC;

25
miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h → miniwin/src/internal/d3drm_impl.h
View File

@ -1,25 +1,20 @@
#pragma once
#include "miniwin_d3drm.h"
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
#include <algorithm>
#include <vector>
extern SDL_Window* DDWindow_SDL3GPU;
extern SDL_Surface* DDBackBuffer_SDL3GPU;
struct PickRecord {
IDirect3DRMVisual* visual;
IDirect3DRMFrameArray* frameArray;
D3DRMPICKDESC desc;
};
struct Direct3DRM_SDL3GPUImpl : virtual public IDirect3DRM2 {
struct Direct3DRMImpl : 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(
@ -47,16 +42,10 @@ struct Direct3DRM_SDL3GPUImpl : virtual public IDirect3DRM2 {
HRESULT SetDefaultTextureColors(DWORD count) override;
};
typedef struct PositionColorVertex {
float x, y, z;
float nx, ny, nz;
Uint8 r, g, b, a;
} PositionColorVertex;
template <typename InterfaceType, typename ActualType, typename ArrayInterface>
class Direct3DRMArrayBase_SDL3GPUImpl : public ArrayInterface {
class Direct3DRMArrayBaseImpl : public ArrayInterface {
public:
~Direct3DRMArrayBase_SDL3GPUImpl() override
~Direct3DRMArrayBaseImpl() override
{
for (auto* item : m_items) {
if (item) {
@ -102,9 +91,9 @@ protected:
std::vector<ActualType*> m_items;
};
struct Direct3DRMPickedArray_SDL3GPUImpl : public IDirect3DRMPickedArray {
Direct3DRMPickedArray_SDL3GPUImpl(const PickRecord* inputPicks, size_t count);
~Direct3DRMPickedArray_SDL3GPUImpl() override;
struct Direct3DRMPickedArrayImpl : public IDirect3DRMPickedArray {
Direct3DRMPickedArrayImpl(const PickRecord* inputPicks, size_t count);
~Direct3DRMPickedArrayImpl() override;
DWORD GetSize() override;
HRESULT GetPick(DWORD index, IDirect3DRMVisual** visual, IDirect3DRMFrameArray** frameArray, D3DRMPICKDESC* desc)
override;

13
miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h → miniwin/src/internal/d3drmdevice_impl.h
View File

@ -1,13 +1,14 @@
#pragma once
#include "miniwin_d3drm.h"
#include "miniwin_d3drmobject_sdl3gpu.h"
#include "d3drmobject_impl.h"
#include "d3drmrenderer.h"
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMDevice2> {
Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device);
~Direct3DRMDevice2_SDL3GPUImpl() override;
struct Direct3DRMDevice2Impl : public Direct3DRMObjectBaseImpl<IDirect3DRMDevice2> {
Direct3DRMDevice2Impl(DWORD width, DWORD height, Direct3DRMRenderer* renderer);
~Direct3DRMDevice2Impl() override;
DWORD GetWidth() override;
DWORD GetHeight() override;
HRESULT SetBufferCount(int count) override;
@ -29,7 +30,7 @@ struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<I
HRESULT AddViewport(IDirect3DRMViewport* viewport) override;
HRESULT GetViewports(IDirect3DRMViewportArray** ppViewportArray) override;
SDL_GPUDevice* m_device;
Direct3DRMRenderer* m_renderer;
private:
DWORD m_width;

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

@ -1,15 +1,15 @@
#pragma once
#include "miniwin_d3drmobject_sdl3gpu.h"
#include "d3drmobject_impl.h"
class Direct3DRMTexture_SDL3GPUImpl;
class Direct3DRMLightArray_SDL3GPUImpl;
class Direct3DRMVisualArray_SDL3GPUImpl;
class Direct3DRMFrameArray_SDL3GPUImpl;
class Direct3DRMTextureImpl;
class Direct3DRMLightArrayImpl;
class Direct3DRMVisualArrayImpl;
class Direct3DRMFrameArrayImpl;
struct Direct3DRMFrame_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMFrame2> {
Direct3DRMFrame_SDL3GPUImpl(Direct3DRMFrame_SDL3GPUImpl* parent = nullptr);
~Direct3DRMFrame_SDL3GPUImpl() override;
struct Direct3DRMFrameImpl : public Direct3DRMObjectBaseImpl<IDirect3DRMFrame2> {
Direct3DRMFrameImpl(Direct3DRMFrameImpl* parent = nullptr);
~Direct3DRMFrameImpl() override;
HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
HRESULT AddChild(IDirect3DRMFrame* child) override;
HRESULT DeleteChild(IDirect3DRMFrame* child) override;
@ -29,25 +29,25 @@ struct Direct3DRMFrame_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDi
HRESULT SetMaterialMode(D3DRMMATERIALMODE mode) override;
HRESULT GetChildren(IDirect3DRMFrameArray** children) override;
Direct3DRMFrame_SDL3GPUImpl* m_parent{};
Direct3DRMFrameImpl* m_parent{};
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}};
private:
Direct3DRMFrameArray_SDL3GPUImpl* m_children{};
Direct3DRMLightArray_SDL3GPUImpl* m_lights{};
Direct3DRMVisualArray_SDL3GPUImpl* m_visuals{};
Direct3DRMTexture_SDL3GPUImpl* m_texture{};
Direct3DRMFrameArrayImpl* m_children{};
Direct3DRMLightArrayImpl* m_lights{};
Direct3DRMVisualArrayImpl* m_visuals{};
Direct3DRMTextureImpl* m_texture{};
D3DCOLOR m_backgroundColor = 0xFF000000;
D3DCOLOR m_color = 0xffffff;
friend class Direct3DRMViewport_SDL3GPUImpl;
friend class Direct3DRMViewportImpl;
};
struct Direct3DRMFrameArray_SDL3GPUImpl
: public Direct3DRMArrayBase_SDL3GPUImpl<IDirect3DRMFrame, Direct3DRMFrame_SDL3GPUImpl, IDirect3DRMFrameArray> {
using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl;
struct Direct3DRMFrameArrayImpl
: public Direct3DRMArrayBaseImpl<IDirect3DRMFrame, Direct3DRMFrameImpl, IDirect3DRMFrameArray> {
using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl;
friend class Direct3DRMFrame_SDL3GPUImpl;
friend class Direct3DRMFrameImpl;
};

18
miniwin/src/internal/d3drmlight_impl.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "d3drm_impl.h"
#include "d3drmobject_impl.h"
#include "miniwin.h"
struct Direct3DRMLightImpl : public Direct3DRMObjectBaseImpl<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 Direct3DRMArrayBaseImpl<IDirect3DRMLight, Direct3DRMLightImpl, IDirect3DRMLightArray> {
using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl;
};

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

@ -1,6 +1,6 @@
#pragma once
#include "miniwin_d3drmobject_sdl3gpu.h"
#include "d3drmobject_impl.h"
#include <algorithm>
#include <vector>
@ -63,7 +63,7 @@ struct MeshGroup {
}
};
struct Direct3DRMMesh_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl<IDirect3DRMMesh> {
struct Direct3DRMMeshImpl : public Direct3DRMObjectBaseImpl<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)

4
miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h → miniwin/src/internal/d3drmobject_impl.h
View File

@ -1,12 +1,12 @@
#pragma once
#include "miniwin_d3drm.h"
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
#include <vector>
template <typename T>
struct Direct3DRMObjectBase_SDL3GPUImpl : public T {
struct Direct3DRMObjectBaseImpl : public T {
ULONG Release() override
{
if (IUnknown::m_refCount == 1) {

23
miniwin/src/internal/d3drmrenderer.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
typedef struct PositionColorVertex {
float x, y, z;
float nx, ny, nz;
Uint8 r, g, b, a;
} PositionColorVertex;
class Direct3DRMRenderer : public IDirect3DDevice2 {
public:
virtual void SetBackbuffer(SDL_Surface* backbuffer) = 0;
virtual void PushVertices(const PositionColorVertex* vertices, size_t count) = 0;
virtual void SetProjection(D3DRMMATRIX4D perspective, D3DVALUE front, D3DVALUE back) = 0;
virtual DWORD GetWidth() = 0;
virtual DWORD GetHeight() = 0;
virtual void GetDesc(D3DDEVICEDESC* halDesc, D3DDEVICEDESC* helDesc) = 0;
virtual const char* GetName() = 0;
virtual HRESULT Render() = 0;
};

54
miniwin/src/internal/d3drmrenderer_sdl3gpu.h Normal file
View File

@ -0,0 +1,54 @@
#pragma once
#include "d3drmrenderer.h"
#include <SDL3/SDL.h>
DEFINE_GUID(SDL3_GPU_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01);
typedef struct {
D3DRMMATRIX4D perspective;
} ViewportUniforms;
class Direct3DRMSDL3GPURenderer : public Direct3DRMRenderer {
public:
static Direct3DRMRenderer* Create(DWORD width, DWORD height);
~Direct3DRMSDL3GPURenderer() override;
void SetBackbuffer(SDL_Surface* backbuffer) override;
void PushVertices(const PositionColorVertex* vertices, size_t count) override;
void SetProjection(D3DRMMATRIX4D perspective, D3DVALUE front, D3DVALUE back) override;
DWORD GetWidth() override;
DWORD GetHeight() override;
void GetDesc(D3DDEVICEDESC* halDesc, D3DDEVICEDESC* helDesc) override;
const char* GetName() override;
HRESULT Render() override;
private:
Direct3DRMSDL3GPURenderer(
DWORD width,
DWORD height,
SDL_GPUDevice* device,
SDL_GPUGraphicsPipeline* pipeline,
SDL_GPUTexture* transferTexture,
SDL_GPUTexture* depthTexture,
SDL_GPUTransferBuffer* downloadTransferBuffer
);
HRESULT Blit();
DWORD m_width;
DWORD m_height;
D3DVALUE m_front;
D3DVALUE m_back;
int m_vertexCount;
int m_vertexBufferCount = 0;
ViewportUniforms m_uniforms;
D3DDEVICEDESC m_desc;
SDL_Surface* m_backbuffer = nullptr;
SDL_GPUDevice* m_device;
SDL_GPUGraphicsPipeline* m_pipeline;
SDL_GPUTexture* m_transferTexture;
SDL_GPUTexture* m_depthTexture;
SDL_GPUTransferBuffer* m_downloadTransferBuffer;
SDL_GPUBuffer* m_vertexBuffer = nullptr;
SDL_Surface* m_renderedImage = nullptr;
};

8
miniwin/src/internal/d3drmtexture_impl.h Normal file
View File

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

54
miniwin/src/internal/d3drmviewport_impl.h Normal file
View File

@ -0,0 +1,54 @@
#pragma once
#include "d3drmobject_impl.h"
#include "d3drmrenderer.h"
#include "miniwin/d3drm.h"
#include <SDL3/SDL.h>
class Direct3DRMDeviceImpl;
class Direct3DRMFrameImpl;
struct Direct3DRMViewportImpl : public Direct3DRMObjectBaseImpl<IDirect3DRMViewport> {
Direct3DRMViewportImpl(DWORD width, DWORD height, Direct3DRMRenderer* renderer);
HRESULT Render(IDirect3DRMFrame* group) override;
/**
* @brief Blit the render back to our backbuffer
*/
HRESULT ForceUpdate(int x, int y, int w, int h) override;
HRESULT Clear() override;
HRESULT SetCamera(IDirect3DRMFrame* camera) override;
HRESULT GetCamera(IDirect3DRMFrame** camera) override;
HRESULT SetProjection(D3DRMPROJECTIONTYPE type) override;
D3DRMPROJECTIONTYPE GetProjection() override;
HRESULT SetFront(D3DVALUE z) override;
D3DVALUE GetFront() override;
HRESULT SetBack(D3DVALUE z) override;
D3DVALUE GetBack() override;
HRESULT SetField(D3DVALUE field) override;
D3DVALUE GetField() override;
DWORD GetWidth() override;
DWORD GetHeight() override;
HRESULT Transform(D3DRMVECTOR4D* screen, D3DVECTOR* world) override;
HRESULT InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen) override;
HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) override;
void CloseDevice();
private:
HRESULT CollectSceneData();
void UpdateProjectionMatrix();
Direct3DRMRenderer* m_renderer;
D3DCOLOR m_backgroundColor = 0xFF000000;
DWORD m_width;
DWORD m_height;
IDirect3DRMFrame* m_rootFrame = nullptr;
IDirect3DRMFrame* m_camera = nullptr;
D3DVALUE m_front = 1.f;
D3DVALUE m_back = 10.f;
D3DVALUE m_field = 0.5f;
};
struct Direct3DRMViewportArrayImpl
: public Direct3DRMArrayBaseImpl<IDirect3DRMViewport, Direct3DRMViewportImpl, IDirect3DRMViewportArray> {
using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl;
};

9
miniwin/src/internal/d3drmvisual_impl.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include "d3drmobject_impl.h"
#include "miniwin/d3drm.h"
struct Direct3DRMVisualArrayImpl
: public Direct3DRMArrayBaseImpl<IDirect3DRMVisual, IDirect3DRMVisual, IDirect3DRMVisualArray> {
using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl;
};

8
miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h → miniwin/src/internal/ddpalette_impl.h
View File

@ -1,10 +1,10 @@
#pragma once
#include "miniwin_ddraw.h"
#include "miniwin/ddraw.h"
struct DirectDrawPalette_SDL3GPUImpl : public IDirectDrawPalette {
DirectDrawPalette_SDL3GPUImpl(LPPALETTEENTRY lpColorTable);
~DirectDrawPalette_SDL3GPUImpl() override;
struct DirectDrawPaletteImpl : public IDirectDrawPalette {
DirectDrawPaletteImpl(LPPALETTEENTRY lpColorTable);
~DirectDrawPaletteImpl() override;
HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries) override;
HRESULT SetEntries(DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries) override;

18
miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h → miniwin/src/internal/ddraw_impl.h
View File

@ -1,9 +1,14 @@
#pragma once
#include "miniwin_d3d.h"
#include "miniwin_ddraw.h"
#include "miniwin/d3d.h"
#include "miniwin/ddraw.h"
struct DirectDraw_SDL3GPUImpl : public IDirectDraw2, public IDirect3D2 {
#include <SDL3/SDL.h>
extern SDL_Window* DDWindow;
extern SDL_Surface* DDBackBuffer;
struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
// IUnknown interface
HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
// IDirectDraw interface
@ -30,10 +35,11 @@ struct DirectDraw_SDL3GPUImpl : public IDirectDraw2, public IDirect3D2 {
HRESULT SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags) override;
HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP) override;
// IDirect3D2 interface
HRESULT CreateDevice(const GUID& guid, void* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice) override;
HRESULT CreateDevice(const GUID& guid, IDirectDrawSurface* pBackBuffer, IDirect3DDevice2** ppDirect3DDevice)
override;
HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx) override;
};
HRESULT DirectDrawEnumerate_SDL3GPU(LPDDENUMCALLBACKA cb, void* context);
HRESULT DirectDrawEnumerate(LPDDENUMCALLBACKA cb, void* context);
HRESULT DirectDrawCreate_SDL3GPU(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter);
HRESULT DirectDrawCreate(LPGUID lpGuid, LPDIRECTDRAW* lplpDD, IUnknown* pUnkOuter);

10
miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h → miniwin/src/internal/ddsurface_impl.h
View File

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

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

3
miniwin/minimfc/src/minimfc.cpp → miniwin/src/mfc/mfc.cpp
View File

@ -1,7 +1,6 @@
#include "minimfc.h"
#include "miniwin/mfc.h"
#include "miniwin.h"
#include "miniwin_p.h"
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>

4
miniwin/common/src/miniwin.cpp → miniwin/src/windows/windows.cpp
View File

@ -1,7 +1,5 @@
#include "miniwin.h"
#include "miniwin_ddraw.h"
#include "miniwin_p.h"
#include "miniwin/ddraw.h"
#include <SDL3/SDL.h>
#include <vector>