diff --git a/CMakeLists.txt b/CMakeLists.txt index 645781fd..bd311e42 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 "$") -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 "$") -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) diff --git a/CONFIG/MainDlg.cpp b/CONFIG/MainDlg.cpp index 7988de56..7d4f6d2a 100644 --- a/CONFIG/MainDlg.cpp +++ b/CONFIG/MainDlg.cpp @@ -1,7 +1,7 @@ #include "MainDlg.h" #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/CONFIG/StdAfx.h b/CONFIG/StdAfx.h index 7c957c9c..a411b312 100644 --- a/CONFIG/StdAfx.h +++ b/CONFIG/StdAfx.h @@ -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 // MFC extensions #include // MFC core and standard components diff --git a/CONFIG/config.cpp b/CONFIG/config.cpp index 5443e3e0..7cc6beb5 100644 --- a/CONFIG/config.cpp +++ b/CONFIG/config.cpp @@ -7,8 +7,8 @@ #include #include #ifdef MINIWIN -#include "miniwin_direct.h" -#include "miniwin_process.h" +#include "miniwin/direct.h" +#include "miniwin/process.h" #else #include // _chdir #include // _spawnl diff --git a/CONFIG/config.h b/CONFIG/config.h index f60e5541..bcc02cc5 100644 --- a/CONFIG/config.h +++ b/CONFIG/config.h @@ -6,7 +6,7 @@ #include "decomp.h" #ifdef MINIWIN -#include "miniwin_d3d.h" +#include "miniwin/d3d.h" #else #include #endif diff --git a/CONFIG/detectdx5.cpp b/CONFIG/detectdx5.cpp index 559a37ad..bf9f6f61 100644 --- a/CONFIG/detectdx5.cpp +++ b/CONFIG/detectdx5.cpp @@ -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 #include diff --git a/CONFIG/detectdx5.h b/CONFIG/detectdx5.h index 5ec75295..3034b775 100644 --- a/CONFIG/detectdx5.h +++ b/CONFIG/detectdx5.h @@ -2,7 +2,7 @@ #define AFX_DETECTDX5_H #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp index 82c9c817..20fc9437 100644 --- a/ISLE/isleapp.cpp +++ b/ISLE/isleapp.cpp @@ -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 #include @@ -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; diff --git a/ISLE/isleapp.h b/ISLE/isleapp.h index b3885e6d..fc1c4ef7 100644 --- a/ISLE/isleapp.h +++ b/ISLE/isleapp.h @@ -8,7 +8,7 @@ #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/lego/legoomni/include/legoinputmanager.h b/LEGO1/lego/legoomni/include/legoinputmanager.h index 8cf1cb7c..2c847cab 100644 --- a/LEGO1/lego/legoomni/include/legoinputmanager.h +++ b/LEGO1/lego/legoomni/include/legoinputmanager.h @@ -13,7 +13,7 @@ #include #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/lego/legoomni/include/legopointofviewcontroller.h b/LEGO1/lego/legoomni/include/legopointofviewcontroller.h index 4d67a51e..11944b82 100644 --- a/LEGO1/lego/legoomni/include/legopointofviewcontroller.h +++ b/LEGO1/lego/legoomni/include/legopointofviewcontroller.h @@ -6,7 +6,7 @@ #include "mxgeometry.h" #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/lego/legoomni/include/legotextureinfo.h b/LEGO1/lego/legoomni/include/legotextureinfo.h index 7a3fd643..e839e295 100644 --- a/LEGO1/lego/legoomni/include/legotextureinfo.h +++ b/LEGO1/lego/legoomni/include/legotextureinfo.h @@ -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 #include diff --git a/LEGO1/lego/legoomni/include/legoutils.h b/LEGO1/lego/legoomni/include/legoutils.h index 656fe7e2..0bc229cd 100644 --- a/LEGO1/lego/legoomni/include/legoutils.h +++ b/LEGO1/lego/legoomni/include/legoutils.h @@ -9,7 +9,7 @@ #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/lego/legoomni/include/legovideomanager.h b/LEGO1/lego/legoomni/include/legovideomanager.h index 23da06e9..e28c581d 100644 --- a/LEGO1/lego/legoomni/include/legovideomanager.h +++ b/LEGO1/lego/legoomni/include/legovideomanager.h @@ -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 #include diff --git a/LEGO1/lego/legoomni/include/mxtransitionmanager.h b/LEGO1/lego/legoomni/include/mxtransitionmanager.h index 647e3423..50b80055 100644 --- a/LEGO1/lego/legoomni/include/mxtransitionmanager.h +++ b/LEGO1/lego/legoomni/include/mxtransitionmanager.h @@ -7,7 +7,7 @@ #include #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/main.cpp b/LEGO1/main.cpp index ac1093ef..750da5bf 100644 --- a/LEGO1/main.cpp +++ b/LEGO1/main.cpp @@ -1,5 +1,5 @@ #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/mxdirectx/mxdirect3d.h b/LEGO1/mxdirectx/mxdirect3d.h index 67d3f66b..db4072cd 100644 --- a/LEGO1/mxdirectx/mxdirect3d.h +++ b/LEGO1/mxdirectx/mxdirect3d.h @@ -7,7 +7,7 @@ #include "mxstl/stlcompat.h" #ifdef MINIWIN -#include "miniwin_d3d.h" +#include "miniwin/d3d.h" #else #include #endif diff --git a/LEGO1/mxdirectx/mxdirectdraw.h b/LEGO1/mxdirectx/mxdirectdraw.h index 4e94e841..b430751c 100644 --- a/LEGO1/mxdirectx/mxdirectdraw.h +++ b/LEGO1/mxdirectx/mxdirectdraw.h @@ -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 #include diff --git a/LEGO1/mxdirectx/mxdirectxinfo.h b/LEGO1/mxdirectx/mxdirectxinfo.h index c7ad71cf..3b3c0600 100644 --- a/LEGO1/mxdirectx/mxdirectxinfo.h +++ b/LEGO1/mxdirectx/mxdirectxinfo.h @@ -5,7 +5,7 @@ #include "mxstl/stlcompat.h" #ifdef MINIWIN -#include "miniwin_d3d.h" +#include "miniwin/d3d.h" #else #include #endif diff --git a/LEGO1/mxdirectx/mxstopwatch.h b/LEGO1/mxdirectx/mxstopwatch.h index f8959368..f8233774 100644 --- a/LEGO1/mxdirectx/mxstopwatch.h +++ b/LEGO1/mxdirectx/mxstopwatch.h @@ -8,7 +8,7 @@ #include // ULONG_MAX #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/omni/include/flic.h b/LEGO1/omni/include/flic.h index da89817e..b7783404 100644 --- a/LEGO1/omni/include/flic.h +++ b/LEGO1/omni/include/flic.h @@ -4,7 +4,7 @@ #include "decomp.h" #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/omni/include/mxbitmap.h b/LEGO1/omni/include/mxbitmap.h index c7a1d9c4..dd437cbb 100644 --- a/LEGO1/omni/include/mxbitmap.h +++ b/LEGO1/omni/include/mxbitmap.h @@ -6,7 +6,7 @@ #include #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/omni/include/mxdisplaysurface.h b/LEGO1/omni/include/mxdisplaysurface.h index cccbca4d..925f0c58 100644 --- a/LEGO1/omni/include/mxdisplaysurface.h +++ b/LEGO1/omni/include/mxdisplaysurface.h @@ -6,7 +6,7 @@ #include "mxvideoparam.h" #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/omni/include/mxomni.h b/LEGO1/omni/include/mxomni.h index 250a4554..38a077f8 100644 --- a/LEGO1/omni/include/mxomni.h +++ b/LEGO1/omni/include/mxomni.h @@ -9,7 +9,7 @@ #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/omni/include/mxpalette.h b/LEGO1/omni/include/mxpalette.h index 0dbb2787..3fdb4a54 100644 --- a/LEGO1/omni/include/mxpalette.h +++ b/LEGO1/omni/include/mxpalette.h @@ -5,7 +5,7 @@ #include "mxtypes.h" #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/omni/include/mxvideomanager.h b/LEGO1/omni/include/mxvideomanager.h index 4d4c5b97..5826cb64 100644 --- a/LEGO1/omni/include/mxvideomanager.h +++ b/LEGO1/omni/include/mxvideomanager.h @@ -5,7 +5,7 @@ #include "mxvideoparam.h" #ifdef MINIWIN -#include "miniwin_d3d.h" +#include "miniwin/d3d.h" #else #include #endif diff --git a/LEGO1/omni/include/mxvideoparam.h b/LEGO1/omni/include/mxvideoparam.h index 9e14bea0..ccc073ab 100644 --- a/LEGO1/omni/include/mxvideoparam.h +++ b/LEGO1/omni/include/mxvideoparam.h @@ -8,7 +8,7 @@ #include "mxvideoparamflags.h" #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/omni/include/mxvideoparamflags.h b/LEGO1/omni/include/mxvideoparamflags.h index cf5aeb01..4fef2145 100644 --- a/LEGO1/omni/include/mxvideoparamflags.h +++ b/LEGO1/omni/include/mxvideoparamflags.h @@ -5,7 +5,7 @@ #include "mxtypes.h" #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/omni/include/mxvideopresenter.h b/LEGO1/omni/include/mxvideopresenter.h index 6ac8e212..b380a3a7 100644 --- a/LEGO1/omni/include/mxvideopresenter.h +++ b/LEGO1/omni/include/mxvideopresenter.h @@ -7,7 +7,7 @@ #include "mxmediapresenter.h" #ifdef MINIWIN -#include "miniwin_ddraw.h" +#include "miniwin/ddraw.h" #else #include #endif diff --git a/LEGO1/omni/src/video/mxdisplaysurface.cpp b/LEGO1/omni/src/video/mxdisplaysurface.cpp index 878129d2..b5f7611a 100644 --- a/LEGO1/omni/src/video/mxdisplaysurface.cpp +++ b/LEGO1/omni/src/video/mxdisplaysurface.cpp @@ -11,7 +11,7 @@ #include #include #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/realtime/orientableroi.h b/LEGO1/realtime/orientableroi.h index 2e9fe1a8..0a347a93 100644 --- a/LEGO1/realtime/orientableroi.h +++ b/LEGO1/realtime/orientableroi.h @@ -6,7 +6,7 @@ #include "roi.h" #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/tgl/d3drm/device.cpp b/LEGO1/tgl/d3drm/device.cpp index d846a01d..053f4c85 100644 --- a/LEGO1/tgl/d3drm/device.cpp +++ b/LEGO1/tgl/d3drm/device.cpp @@ -2,7 +2,7 @@ #include #ifdef MINIWIN -#include "miniwin_d3drm.h" +#include "miniwin/d3drm.h" #else #include #endif diff --git a/LEGO1/tgl/d3drm/impl.h b/LEGO1/tgl/d3drm/impl.h index 9a74688a..d4a9a420 100644 --- a/LEGO1/tgl/d3drm/impl.h +++ b/LEGO1/tgl/d3drm/impl.h @@ -6,7 +6,7 @@ #include "tgl/tgl.h" #ifdef MINIWIN -#include "miniwin_d3drm.h" +#include "miniwin/d3drm.h" typedef void* LPD3DRM_APPDATA; #else #include diff --git a/LEGO1/tgl/tgl.h b/LEGO1/tgl/tgl.h index 9486b45b..aabe6c96 100644 --- a/LEGO1/tgl/tgl.h +++ b/LEGO1/tgl/tgl.h @@ -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 #include #endif #ifdef MINIWIN -#include "miniwin.h" +#include "miniwin/windows.h" #else #include #endif diff --git a/LEGO1/viewmanager/viewmanager.h b/LEGO1/viewmanager/viewmanager.h index df70b62b..00e39c03 100644 --- a/LEGO1/viewmanager/viewmanager.h +++ b/LEGO1/viewmanager/viewmanager.h @@ -7,7 +7,7 @@ #include "viewroi.h" #ifdef MINIWIN -#include "miniwin_d3drm.h" +#include "miniwin/d3drm.h" #else #include #endif diff --git a/miniwin/CMakeLists.txt b/miniwin/CMakeLists.txt new file mode 100644 index 00000000..481b3479 --- /dev/null +++ b/miniwin/CMakeLists.txt @@ -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 + $ + 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 $ + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/internal +) + +target_compile_definitions(minimfc PUBLIC MINIMFC) +target_link_libraries(minimfc PRIVATE SDL3::SDL3 miniwin) diff --git a/miniwin/common/src/d3drm.cpp b/miniwin/common/src/d3drm.cpp deleted file mode 100644 index e3b453ff..00000000 --- a/miniwin/common/src/d3drm.cpp +++ /dev/null @@ -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 ""; - } -} - -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; - } -} diff --git a/miniwin/include/bitflags.h b/miniwin/include/miniwin/bitflags.h similarity index 100% rename from miniwin/include/bitflags.h rename to miniwin/include/miniwin/bitflags.h diff --git a/miniwin/include/miniwin_d3d.h b/miniwin/include/miniwin/d3d.h similarity index 93% rename from miniwin/include/miniwin_d3d.h rename to miniwin/include/miniwin/d3d.h index 8641aff9..10313c4d 100644 --- a/miniwin/include/miniwin_d3d.h +++ b/miniwin/include/miniwin/d3d.h @@ -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; diff --git a/miniwin/include/miniwin_d3drm.h b/miniwin/include/miniwin/d3drm.h similarity index 99% rename from miniwin/include/miniwin_d3drm.h rename to miniwin/include/miniwin/d3drm.h index 8972f267..7a76ae0a 100644 --- a/miniwin/include/miniwin_d3drm.h +++ b/miniwin/include/miniwin/d3drm.h @@ -1,6 +1,6 @@ #pragma once -#include "miniwin_d3d.h" +#include "miniwin/d3d.h" #include // abort // FIXME: remove diff --git a/miniwin/include/miniwin_ddraw.h b/miniwin/include/miniwin/ddraw.h similarity index 99% rename from miniwin/include/miniwin_ddraw.h rename to miniwin/include/miniwin/ddraw.h index 8e3a8499..37dfb9d1 100644 --- a/miniwin/include/miniwin_ddraw.h +++ b/miniwin/include/miniwin/ddraw.h @@ -1,7 +1,7 @@ #pragma once #include "bitflags.h" -#include "miniwin.h" +#include "miniwin/windows.h" #define DDENUMRET_OK TRUE diff --git a/miniwin/include/miniwin_dinput.h b/miniwin/include/miniwin/dinput.h similarity index 73% rename from miniwin/include/miniwin_dinput.h rename to miniwin/include/miniwin/dinput.h index a50d028e..7767abc7 100644 --- a/miniwin/include/miniwin_dinput.h +++ b/miniwin/include/miniwin/dinput.h @@ -1,6 +1,6 @@ #pragma once -#include "miniwin.h" +#include "miniwin/windows.h" // --- Typedefs --- typedef struct IDirectInputA* LPDIRECTINPUTA; diff --git a/miniwin/include/miniwin_direct.h b/miniwin/include/miniwin/direct.h similarity index 100% rename from miniwin/include/miniwin_direct.h rename to miniwin/include/miniwin/direct.h diff --git a/miniwin/minimfc/include/minimfc.h b/miniwin/include/miniwin/mfc.h similarity index 99% rename from miniwin/minimfc/include/minimfc.h rename to miniwin/include/miniwin/mfc.h index 8856ebb4..4ea09053 100644 --- a/miniwin/minimfc/include/minimfc.h +++ b/miniwin/include/miniwin/mfc.h @@ -1,6 +1,6 @@ #pragma once -#include "miniwin.h" +#include "miniwin/windows.h" #include #include diff --git a/miniwin/include/miniwin_process.h b/miniwin/include/miniwin/process.h similarity index 100% rename from miniwin/include/miniwin_process.h rename to miniwin/include/miniwin/process.h diff --git a/miniwin/include/miniwin.h b/miniwin/include/miniwin/windows.h similarity index 99% rename from miniwin/include/miniwin.h rename to miniwin/include/miniwin/windows.h index 1c5c1538..f4b9da44 100644 --- a/miniwin/include/miniwin.h +++ b/miniwin/include/miniwin/windows.h @@ -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) diff --git a/miniwin/include/miniwin_config.h b/miniwin/include/miniwin_config.h deleted file mode 100644 index b392e8b7..00000000 --- a/miniwin/include/miniwin_config.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef MINIWIN_CONFIG_H -#define MINIWIN_CONFIG_H - -#include - -#ifdef _WIN32 -#define MINIWIN_EXPORT __declspec(dllexport) -#else -#define MINIWIN_EXPORT __attribute__((visibility("default"))) -#endif - -enum MiniwinBackendType { - eInvalid, - eSDL3GPU, -}; - -MiniwinBackendType MINIWIN_EXPORT Miniwin_StringToBackendType(const char* str); - -std::string MINIWIN_EXPORT Miniwin_BackendTypeToString(MiniwinBackendType type); - -void MINIWIN_EXPORT Miniwin_ConfigureBackend(MiniwinBackendType type); - -#endif diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h deleted file mode 100644 index 22dd8653..00000000 --- a/miniwin/sdl3gpu/include/miniwin_d3drmlight_sdl3gpu.h +++ /dev/null @@ -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 { - Direct3DRMLight_SDL3GPUImpl(float r, float g, float b); - HRESULT SetColorRGB(float r, float g, float b) override; - -private: - D3DCOLOR m_color = 0xFFFFFFFF; -}; - -struct Direct3DRMLightArray_SDL3GPUImpl - : public Direct3DRMArrayBase_SDL3GPUImpl { - using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; -}; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h deleted file mode 100644 index c8f95742..00000000 --- a/miniwin/sdl3gpu/include/miniwin_d3drmtexture_sdl3gpu.h +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -#include "miniwin_d3drmobject_sdl3gpu.h" - -struct Direct3DRMTexture_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { - HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; - HRESULT Changed(BOOL pixels, BOOL palette) override; -}; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h deleted file mode 100644 index 641e56e6..00000000 --- a/miniwin/sdl3gpu/include/miniwin_d3drmviewport_sdl3gpu.h +++ /dev/null @@ -1,79 +0,0 @@ -#pragma once - -#include "miniwin_d3drm.h" -#include "miniwin_d3drmobject_sdl3gpu.h" - -#include - -class Direct3DRMDevice_SDL3GPUImpl; -class Direct3DRMFrame_SDL3GPUImpl; - -typedef struct { - D3DRMMATRIX4D perspective; -} ViewportUniforms; - -struct Direct3DRMViewport_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { - 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; -}; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h b/miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h deleted file mode 100644 index 7752833f..00000000 --- a/miniwin/sdl3gpu/include/miniwin_d3drmvisual_sdl3gpu.h +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once - -#include "miniwin_d3drm.h" -#include "miniwin_d3drmobject_sdl3gpu.h" - -struct Direct3DRMVisualArray_SDL3GPUImpl - : public Direct3DRMArrayBase_SDL3GPUImpl { - using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; -}; diff --git a/miniwin/sdl3gpu/src/miniwin_d3drm.cpp b/miniwin/sdl3gpu/src/miniwin_d3drm.cpp deleted file mode 100644 index c326d22d..00000000 --- a/miniwin/sdl3gpu/src/miniwin_d3drm.cpp +++ /dev/null @@ -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 - -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(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 { - 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(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(new Direct3DRMDevice2_SDL3GPUImpl(width, height, device)); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateDeviceFromD3D( - const IDirect3D2* d3d, - IDirect3DDevice2* d3dDevice, - IDirect3DRMDevice2** outDevice -) -{ - MINIWIN_NOT_IMPLEMENTED(); - return CreateDevice(outDevice, 640, 480); -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateDeviceFromSurface( - const GUID* guid, - IDirectDraw* dd, - IDirectDrawSurface* surface, - IDirect3DRMDevice2** outDevice -) -{ - MINIWIN_NOT_IMPLEMENTED(); // Respect the chosen GUID - DDSURFACEDESC DDSDesc; - DDSDesc.dwSize = sizeof(DDSURFACEDESC); - surface->GetSurfaceDesc(&DDSDesc); - return CreateDevice(outDevice, DDSDesc.dwWidth, DDSDesc.dwHeight); -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) -{ - MINIWIN_NOT_IMPLEMENTED(); - *outTexture = static_cast(new Direct3DRMTexture_SDL3GPUImpl); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) - -{ - MINIWIN_NOT_IMPLEMENTED(); - *outTexture = static_cast(new Direct3DRMTexture_SDL3GPUImpl); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateMesh(IDirect3DRMMesh** outMesh) -{ - *outMesh = static_cast(new Direct3DRMMesh_SDL3GPUImpl); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) -{ - *outMaterial = static_cast(new Direct3DRMMaterial_SDL3GPUImpl(power)); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateLightRGB( - D3DRMLIGHTTYPE type, - D3DVAL r, - D3DVAL g, - D3DVAL b, - IDirect3DRMLight** outLight -) -{ - *outLight = static_cast(new Direct3DRMLight_SDL3GPUImpl(r, g, b)); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) -{ - auto parentImpl = static_cast(parent); - *outFrame = static_cast(new Direct3DRMFrame_SDL3GPUImpl{parentImpl}); - return DD_OK; -} - -HRESULT Direct3DRM_SDL3GPUImpl::CreateViewport( - IDirect3DRMDevice2* iDevice, - IDirect3DRMFrame* camera, - int x, - int y, - int width, - int height, - IDirect3DRMViewport** outViewport -) -{ - auto device = static_cast(iDevice); - - SDL_GPUGraphicsPipeline* pipeline = InitializeGraphicsPipeline(device->m_device); - if (!pipeline) { - return DDERR_GENERIC; - } - - SDL_GPUTextureCreateInfo textureInfo = {}; - textureInfo.type = SDL_GPU_TEXTURETYPE_2D; - textureInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM; - 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(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(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; -} diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp deleted file mode 100644 index 9a1e22ab..00000000 --- a/miniwin/sdl3gpu/src/miniwin_d3drmdevice.cpp +++ /dev/null @@ -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 - -Direct3DRMDevice2_SDL3GPUImpl::Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device) - : m_width(width), m_height(height), m_device(device), m_viewports(new Direct3DRMViewportArray_SDL3GPUImpl) -{ -} - -Direct3DRMDevice2_SDL3GPUImpl::~Direct3DRMDevice2_SDL3GPUImpl() -{ - for (int i = 0; i < m_viewports->GetSize(); i++) { - IDirect3DRMViewport* viewport; - m_viewports->GetElement(i, &viewport); - static_cast(viewport)->CloseDevice(); - viewport->Release(); - } - m_viewports->Release(); - - SDL_ReleaseWindowFromGPUDevice(m_device, DDWindow_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; -} diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp b/miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp deleted file mode 100644 index 37e80369..00000000 --- a/miniwin/sdl3gpu/src/miniwin_d3drmlight.cpp +++ /dev/null @@ -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(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | - (static_cast(b * 255.0f)); - return DD_OK; -} diff --git a/miniwin/sdl3gpu/src/miniwn_d3drmmath.h b/miniwin/sdl3gpu/src/miniwn_d3drmmath.h deleted file mode 100644 index 194f6a7b..00000000 --- a/miniwin/sdl3gpu/src/miniwn_d3drmmath.h +++ /dev/null @@ -1,3 +0,0 @@ -#pragma once - -static void diff --git a/miniwin/src/d3drm/backends/sdl3gpu/renderer.cpp b/miniwin/src/d3drm/backends/sdl3gpu/renderer.cpp new file mode 100644 index 00000000..def87577 --- /dev/null +++ b/miniwin/src/d3drm/backends/sdl3gpu/renderer.cpp @@ -0,0 +1,383 @@ +#include "ShaderIndex.h" +#include "d3drmrenderer_sdl3gpu.h" +#include "ddraw_impl.h" +#include "miniwin.h" + +#include + +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(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(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(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(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, ®ion, &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; +} diff --git a/miniwin/sdl3gpu/shaders/gencshadersource.py b/miniwin/src/d3drm/backends/sdl3gpu/shaders/gencshadersource.py similarity index 100% rename from miniwin/sdl3gpu/shaders/gencshadersource.py rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/gencshadersource.py diff --git a/miniwin/sdl3gpu/shaders/generated/PositionColor.vert.h b/miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/PositionColor.vert.h similarity index 100% rename from miniwin/sdl3gpu/shaders/generated/PositionColor.vert.h rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/PositionColor.vert.h diff --git a/miniwin/sdl3gpu/shaders/generated/ShaderIndex.cpp b/miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.cpp similarity index 100% rename from miniwin/sdl3gpu/shaders/generated/ShaderIndex.cpp rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.cpp diff --git a/miniwin/sdl3gpu/shaders/generated/ShaderIndex.h b/miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.h similarity index 100% rename from miniwin/sdl3gpu/shaders/generated/ShaderIndex.h rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.h diff --git a/miniwin/sdl3gpu/shaders/generated/SolidColor.frag.h b/miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/SolidColor.frag.h similarity index 100% rename from miniwin/sdl3gpu/shaders/generated/SolidColor.frag.h rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/generated/SolidColor.frag.h diff --git a/miniwin/sdl3gpu/shaders/src/Common.hlsl b/miniwin/src/d3drm/backends/sdl3gpu/shaders/src/Common.hlsl similarity index 100% rename from miniwin/sdl3gpu/shaders/src/Common.hlsl rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/src/Common.hlsl diff --git a/miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl b/miniwin/src/d3drm/backends/sdl3gpu/shaders/src/PositionColor.vert.hlsl similarity index 100% rename from miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/src/PositionColor.vert.hlsl diff --git a/miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json b/miniwin/src/d3drm/backends/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json similarity index 100% rename from miniwin/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/src/PositionColor.vert.hlsl.json diff --git a/miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl b/miniwin/src/d3drm/backends/sdl3gpu/shaders/src/SolidColor.frag.hlsl similarity index 100% rename from miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/src/SolidColor.frag.hlsl diff --git a/miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json b/miniwin/src/d3drm/backends/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json similarity index 100% rename from miniwin/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json rename to miniwin/src/d3drm/backends/sdl3gpu/shaders/src/SolidColor.frag.hlsl.json diff --git a/miniwin/src/d3drm/d3drm.cpp b/miniwin/src/d3drm/d3drm.cpp new file mode 100644 index 00000000..1464929c --- /dev/null +++ b/miniwin/src/d3drm/d3drm.cpp @@ -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 + +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(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 { + 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(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(d3dDevice); + *outDevice = static_cast( + 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(new Direct3DRMDevice2Impl(DDSDesc.dwWidth, DDSDesc.dwHeight, renderer)); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) +{ + MINIWIN_NOT_IMPLEMENTED(); + *outTexture = static_cast(new Direct3DRMTextureImpl); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) + +{ + MINIWIN_NOT_IMPLEMENTED(); + *outTexture = static_cast(new Direct3DRMTextureImpl); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateMesh(IDirect3DRMMesh** outMesh) +{ + *outMesh = static_cast(new Direct3DRMMeshImpl); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) +{ + *outMaterial = static_cast(new Direct3DRMMaterialImpl(power)); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) +{ + *outLight = static_cast(new Direct3DRMLightImpl(r, g, b)); + return DD_OK; +} + +HRESULT Direct3DRMImpl::CreateFrame(IDirect3DRMFrame* parent, IDirect3DRMFrame2** outFrame) +{ + auto parentImpl = static_cast(parent); + *outFrame = static_cast(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(iDevice); + auto* viewport = new Direct3DRMViewportImpl(width, height, device->m_renderer); + if (camera) { + viewport->SetCamera(camera); + } + *outViewport = static_cast(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(255.f * alpha); + int r = static_cast(255.f * red); + int g = static_cast(255.f * green); + int b = static_cast(255.f * blue); + + return (a << 24) | (r << 16) | (g << 8) | b; +} diff --git a/miniwin/src/d3drm/d3drmdevice.cpp b/miniwin/src/d3drm/d3drmdevice.cpp new file mode 100644 index 00000000..61ad96d8 --- /dev/null +++ b/miniwin/src/d3drm/d3drmdevice.cpp @@ -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 + +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(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; +} diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp b/miniwin/src/d3drm/d3drmframe.cpp similarity index 51% rename from miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp rename to miniwin/src/d3drm/d3drmframe.cpp index 04200d71..0fbc05df 100644 --- a/miniwin/sdl3gpu/src/miniwin_d3drmframe.cpp +++ b/miniwin/src/d3drm/d3drmframe.cpp @@ -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 -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(child); + Direct3DRMFrameImpl* childImpl = static_cast(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(child); + Direct3DRMFrameImpl* childImpl = static_cast(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(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | (static_cast(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(texture); + auto textureImpl = static_cast(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(a * 255.0f) << 24) | (static_cast(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | (static_cast(b * 255.0f)); return DD_OK; } -HRESULT 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(); diff --git a/miniwin/src/d3drm/d3drmlight.cpp b/miniwin/src/d3drm/d3drmlight.cpp new file mode 100644 index 00000000..ffbdeff2 --- /dev/null +++ b/miniwin/src/d3drm/d3drmlight.cpp @@ -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(r * 255.0f) << 16) | (static_cast(g * 255.0f) << 8) | + (static_cast(b * 255.0f)); + return DD_OK; +} diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp b/miniwin/src/d3drm/d3drmmesh.cpp similarity index 74% rename from miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp rename to miniwin/src/d3drm/d3drmmesh.cpp index 0ebde661..8b79d925 100644 --- a/miniwin/sdl3gpu/src/miniwin_d3drmmesh.cpp +++ b/miniwin/src/d3drm/d3drmmesh.cpp @@ -1,9 +1,9 @@ -#include "miniwin_d3drmmesh_sdl3gpu.h" -#include "miniwin_p.h" +#include "d3drmmesh_impl.h" +#include "miniwin.h" #include -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(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(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(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::max(); box->max.x = box->max.y = box->max.z = std::numeric_limits::min(); diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp b/miniwin/src/d3drm/d3drmtexture.cpp similarity index 54% rename from miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp rename to miniwin/src/d3drm/d3drmtexture.cpp index cb3b0fe1..063eba6b 100644 --- a/miniwin/sdl3gpu/src/miniwin_d3drmtexture.cpp +++ b/miniwin/src/d3drm/d3drmtexture.cpp @@ -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; diff --git a/miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp b/miniwin/src/d3drm/d3drmviewport.cpp similarity index 58% rename from miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp rename to miniwin/src/d3drm/d3drmviewport.cpp index 7cfb11fd..848b0b7d 100644 --- a/miniwin/sdl3gpu/src/miniwin_d3drmviewport.cpp +++ b/miniwin/src/d3drm/d3drmviewport.cpp @@ -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 +#include #include #include #include @@ -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(cur); + auto* impl = static_cast(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(frame); + Direct3DRMFrameImpl* frameImpl = static_cast(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(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(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(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, ®ion, &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&)> recurse; recurse = [&](IDirect3DRMFrame* frame, std::vector& path) { - Direct3DRMFrame_SDL3GPUImpl* frameImpl = static_cast(frame); + Direct3DRMFrameImpl* frameImpl = static_cast(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; } diff --git a/miniwin/sdl3gpu/src/miniwin_ddpalette.cpp b/miniwin/src/ddraw/ddpalette.cpp similarity index 61% rename from miniwin/sdl3gpu/src/miniwin_ddpalette.cpp rename to miniwin/src/ddraw/ddpalette.cpp index 7c3dd9e2..80730d2c 100644 --- a/miniwin/sdl3gpu/src/miniwin_ddpalette.cpp +++ b/miniwin/src/ddraw/ddpalette.cpp @@ -1,25 +1,20 @@ -#include "miniwin_ddpalette_sdl3gpu.h" -#include "miniwin_ddraw.h" +#include "ddpalette_impl.h" +#include "miniwin/ddraw.h" #include -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++) { diff --git a/miniwin/sdl3gpu/src/miniwin_ddraw.cpp b/miniwin/src/ddraw/ddraw.cpp similarity index 65% rename from miniwin/sdl3gpu/src/miniwin_ddraw.cpp rename to miniwin/src/ddraw/ddraw.cpp index 176548cc..c8d81fe4 100644 --- a/miniwin/sdl3gpu/src/miniwin_ddraw.cpp +++ b/miniwin/src/ddraw/ddraw.cpp @@ -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 #include @@ -11,10 +11,10 @@ #include #include -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(new DirectDrawPalette_SDL3GPUImpl(lpColorTable)); + *lplpDDPalette = static_cast(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(new DirectDrawSurface_SDL3GPUImpl); + *lplpDDSurface = static_cast(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(frontBuffer); return DD_OK; @@ -125,11 +125,11 @@ HRESULT DirectDraw_SDL3GPUImpl::CreateSurface( if (width == 0 || height == 0) { return DDERR_INVALIDPARAMS; } - *lplpDDSurface = static_cast(new DirectDrawSurface_SDL3GPUImpl(width, height, format)); + *lplpDDSurface = static_cast(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(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; } diff --git a/miniwin/sdl3gpu/src/miniwin_ddsurface.cpp b/miniwin/src/ddraw/ddsurface.cpp similarity index 65% rename from miniwin/sdl3gpu/src/miniwin_ddsurface.cpp rename to miniwin/src/ddraw/ddsurface.cpp index 0d697f66..93776d81 100644 --- a/miniwin/sdl3gpu/src/miniwin_ddsurface.cpp +++ b/miniwin/src/ddraw/ddsurface.cpp @@ -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 -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(lpDDSrcSurface); + auto srcSurface = static_cast(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(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; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h b/miniwin/src/internal/d3drm_impl.h similarity index 78% rename from miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h rename to miniwin/src/internal/d3drm_impl.h index 2a6864fe..c4426f1e 100644 --- a/miniwin/sdl3gpu/include/miniwin_d3drm_sdl3gpu.h +++ b/miniwin/src/internal/d3drm_impl.h @@ -1,25 +1,20 @@ #pragma once -#include "miniwin_d3drm.h" +#include "miniwin/d3drm.h" -#include #include #include -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 -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 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; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h b/miniwin/src/internal/d3drmdevice_impl.h similarity index 75% rename from miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h rename to miniwin/src/internal/d3drmdevice_impl.h index 428c05ca..8ff90d4a 100644 --- a/miniwin/sdl3gpu/include/miniwin_d3drmdevice_sdl3gpu.h +++ b/miniwin/src/internal/d3drmdevice_impl.h @@ -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 -struct Direct3DRMDevice2_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { - Direct3DRMDevice2_SDL3GPUImpl(DWORD width, DWORD height, SDL_GPUDevice* device); - ~Direct3DRMDevice2_SDL3GPUImpl() override; +struct Direct3DRMDevice2Impl : public Direct3DRMObjectBaseImpl { + 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 { - Direct3DRMFrame_SDL3GPUImpl(Direct3DRMFrame_SDL3GPUImpl* parent = nullptr); - ~Direct3DRMFrame_SDL3GPUImpl() override; +struct Direct3DRMFrameImpl : public Direct3DRMObjectBaseImpl { + 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 { - using Direct3DRMArrayBase_SDL3GPUImpl::Direct3DRMArrayBase_SDL3GPUImpl; +struct Direct3DRMFrameArrayImpl + : public Direct3DRMArrayBaseImpl { + using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl; - friend class Direct3DRMFrame_SDL3GPUImpl; + friend class Direct3DRMFrameImpl; }; diff --git a/miniwin/src/internal/d3drmlight_impl.h b/miniwin/src/internal/d3drmlight_impl.h new file mode 100644 index 00000000..382206ab --- /dev/null +++ b/miniwin/src/internal/d3drmlight_impl.h @@ -0,0 +1,18 @@ +#pragma once + +#include "d3drm_impl.h" +#include "d3drmobject_impl.h" +#include "miniwin.h" + +struct Direct3DRMLightImpl : public Direct3DRMObjectBaseImpl { + 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 { + using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl; +}; diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h b/miniwin/src/internal/d3drmmesh_impl.h similarity index 95% rename from miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h rename to miniwin/src/internal/d3drmmesh_impl.h index a8d07380..26cfe448 100644 --- a/miniwin/sdl3gpu/include/miniwin_d3drmmesh_sdl3gpu.h +++ b/miniwin/src/internal/d3drmmesh_impl.h @@ -1,6 +1,6 @@ #pragma once -#include "miniwin_d3drmobject_sdl3gpu.h" +#include "d3drmobject_impl.h" #include #include @@ -63,7 +63,7 @@ struct MeshGroup { } }; -struct Direct3DRMMesh_SDL3GPUImpl : public Direct3DRMObjectBase_SDL3GPUImpl { +struct Direct3DRMMeshImpl : public Direct3DRMObjectBaseImpl { HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; HRESULT Clone(int flags, GUID iid, void** object) override; HRESULT AddGroup(int vertexCount, int faceCount, int vertexPerFace, DWORD* faceBuffer, D3DRMGROUPINDEX* groupIndex) diff --git a/miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h b/miniwin/src/internal/d3drmobject_impl.h similarity index 94% rename from miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h rename to miniwin/src/internal/d3drmobject_impl.h index 7e0da937..a4a7cd1e 100644 --- a/miniwin/sdl3gpu/include/miniwin_d3drmobject_sdl3gpu.h +++ b/miniwin/src/internal/d3drmobject_impl.h @@ -1,12 +1,12 @@ #pragma once -#include "miniwin_d3drm.h" +#include "miniwin/d3drm.h" #include #include template -struct Direct3DRMObjectBase_SDL3GPUImpl : public T { +struct Direct3DRMObjectBaseImpl : public T { ULONG Release() override { if (IUnknown::m_refCount == 1) { diff --git a/miniwin/src/internal/d3drmrenderer.h b/miniwin/src/internal/d3drmrenderer.h new file mode 100644 index 00000000..53a7f4ac --- /dev/null +++ b/miniwin/src/internal/d3drmrenderer.h @@ -0,0 +1,23 @@ +#pragma once + +#include "miniwin/d3drm.h" + +#include + +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; +}; diff --git a/miniwin/src/internal/d3drmrenderer_sdl3gpu.h b/miniwin/src/internal/d3drmrenderer_sdl3gpu.h new file mode 100644 index 00000000..539264fb --- /dev/null +++ b/miniwin/src/internal/d3drmrenderer_sdl3gpu.h @@ -0,0 +1,54 @@ +#pragma once + +#include "d3drmrenderer.h" + +#include + +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; +}; diff --git a/miniwin/src/internal/d3drmtexture_impl.h b/miniwin/src/internal/d3drmtexture_impl.h new file mode 100644 index 00000000..cb06c368 --- /dev/null +++ b/miniwin/src/internal/d3drmtexture_impl.h @@ -0,0 +1,8 @@ +#pragma once + +#include "d3drmobject_impl.h" + +struct Direct3DRMTextureImpl : public Direct3DRMObjectBaseImpl { + HRESULT QueryInterface(const GUID& riid, void** ppvObject) override; + HRESULT Changed(BOOL pixels, BOOL palette) override; +}; diff --git a/miniwin/src/internal/d3drmviewport_impl.h b/miniwin/src/internal/d3drmviewport_impl.h new file mode 100644 index 00000000..1f819734 --- /dev/null +++ b/miniwin/src/internal/d3drmviewport_impl.h @@ -0,0 +1,54 @@ +#pragma once + +#include "d3drmobject_impl.h" +#include "d3drmrenderer.h" +#include "miniwin/d3drm.h" + +#include + +class Direct3DRMDeviceImpl; +class Direct3DRMFrameImpl; + +struct Direct3DRMViewportImpl : public Direct3DRMObjectBaseImpl { + 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 { + using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl; +}; diff --git a/miniwin/src/internal/d3drmvisual_impl.h b/miniwin/src/internal/d3drmvisual_impl.h new file mode 100644 index 00000000..49ae472c --- /dev/null +++ b/miniwin/src/internal/d3drmvisual_impl.h @@ -0,0 +1,9 @@ +#pragma once + +#include "d3drmobject_impl.h" +#include "miniwin/d3drm.h" + +struct Direct3DRMVisualArrayImpl + : public Direct3DRMArrayBaseImpl { + using Direct3DRMArrayBaseImpl::Direct3DRMArrayBaseImpl; +}; diff --git a/miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h b/miniwin/src/internal/ddpalette_impl.h similarity index 56% rename from miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h rename to miniwin/src/internal/ddpalette_impl.h index 0442a8a5..27c71ff6 100644 --- a/miniwin/sdl3gpu/include/miniwin_ddpalette_sdl3gpu.h +++ b/miniwin/src/internal/ddpalette_impl.h @@ -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; diff --git a/miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h b/miniwin/src/internal/ddraw_impl.h similarity index 70% rename from miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h rename to miniwin/src/internal/ddraw_impl.h index bc4cc3d0..c911cafe 100644 --- a/miniwin/sdl3gpu/include/miniwin_ddraw_sdl3gpu.h +++ b/miniwin/src/internal/ddraw_impl.h @@ -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 + +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); diff --git a/miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h b/miniwin/src/internal/ddsurface_impl.h similarity index 86% rename from miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h rename to miniwin/src/internal/ddsurface_impl.h index 36598e61..1c97216e 100644 --- a/miniwin/sdl3gpu/include/miniwin_ddsurface_sdl3gpu.h +++ b/miniwin/src/internal/ddsurface_impl.h @@ -1,12 +1,12 @@ #pragma once #include -#include +#include -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; diff --git a/miniwin/common/include/miniwin_p.h b/miniwin/src/internal/miniwin.h similarity index 100% rename from miniwin/common/include/miniwin_p.h rename to miniwin/src/internal/miniwin.h diff --git a/miniwin/minimfc/src/minimfc.cpp b/miniwin/src/mfc/mfc.cpp similarity index 99% rename from miniwin/minimfc/src/minimfc.cpp rename to miniwin/src/mfc/mfc.cpp index d291c91f..628f4914 100644 --- a/miniwin/minimfc/src/minimfc.cpp +++ b/miniwin/src/mfc/mfc.cpp @@ -1,7 +1,6 @@ -#include "minimfc.h" +#include "miniwin/mfc.h" #include "miniwin.h" -#include "miniwin_p.h" #include #include diff --git a/miniwin/common/src/miniwin.cpp b/miniwin/src/windows/windows.cpp similarity index 98% rename from miniwin/common/src/miniwin.cpp rename to miniwin/src/windows/windows.cpp index d98688f7..4c2f458d 100644 --- a/miniwin/common/src/miniwin.cpp +++ b/miniwin/src/windows/windows.cpp @@ -1,7 +1,5 @@ #include "miniwin.h" - -#include "miniwin_ddraw.h" -#include "miniwin_p.h" +#include "miniwin/ddraw.h" #include #include