TheCloud/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2025-09-23 03:55:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

put ifdefs around every d3drm backend so that any can be disabled (#569)

Browse Source 
* put ifdefs around every d3drm backend so that any can be disabled

* make clang-format happy

* move backend selection and enum to its own functions
This commit is contained in:
olebeck 2025-07-10 18:19:21 +02:00 committed by GitHub
parent 28b026f605
commit b26a707db2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 133 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
miniwin/CMakeLists.txt
View File

@ -19,42 +19,44 @@ add_library(miniwin STATIC EXCLUDE_FROM_ALL
src/d3drm/d3drmmesh.cpp
src/d3drm/d3drmtexture.cpp
src/d3drm/d3drmviewport.cpp
src/d3drm/d3drmrenderer.cpp
src/internal/meshutils.cpp
# D3DRM backends
src/d3drm/backends/sdl3gpu/renderer.cpp
src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.cpp
src/d3drm/backends/software/renderer.cpp
)
target_compile_definitions(miniwin PRIVATE
$<$<CONFIG:Debug>:DEBUG>
)
list(APPEND GRAPHICS_BACKENDS USE_SOFTWARE_RENDER)
list(APPEND GRAPHICS_BACKENDS USE_SDL_GPU)
if(NOT WINDOWS_STORE)
find_package(OpenGL)
if(OpenGL_FOUND AND NOT WINDOWS_STORE)
if(OpenGL_FOUND)
message(STATUS "Found OpenGL: enabling OpenGL 1.x renderer")
target_sources(miniwin PRIVATE
src/d3drm/backends/opengl1/actual.cpp
src/d3drm/backends/opengl1/renderer.cpp
)
target_compile_definitions(miniwin PRIVATE USE_OPENGL1)
list(APPEND GRAPHICS_BACKENDS USE_OPENGL1)
target_link_libraries(miniwin PRIVATE OpenGL::GL)
else()
message(STATUS "🧩 OpenGL 1.x support not enabled — needs OpenGL")
endif()
find_library(OPENGL_ES2_LIBRARY NAMES GLESv2)
if(EMSCRIPTEN OR OPENGL_ES2_LIBRARY AND NOT WINDOWS_STORE)
if(EMSCRIPTEN OR OPENGL_ES2_LIBRARY)
message(STATUS "Found OpenGL: enabling OpenGL ES 2.x renderer")
target_sources(miniwin PRIVATE src/d3drm/backends/opengles2/renderer.cpp)
target_compile_definitions(miniwin PRIVATE USE_OPENGLES2)
list(APPEND GRAPHICS_BACKENDS USE_OPENGLES2)
if(OPENGL_ES2_LIBRARY)
target_link_libraries(miniwin PRIVATE OpenGL::GL)
target_link_libraries(miniwin PRIVATE ${OPENGL_ES2_LIBRARY})
endif()
else()
message(STATUS "🧩 OpenGL ES 2.x support not enabled")
endif()
endif()
if(NINTENDO_3DS)
if(ISLE_DEBUG)
@ -68,6 +70,7 @@ if(NINTENDO_3DS)
ctr_add_shader_library(vshader src/d3drm/backends/citro3d/vshader.v.pica)
dkp_add_embedded_binary_library(3ds_shaders vshader)
target_link_libraries(miniwin PRIVATE ${CITRO3D_LIBRARY} 3ds_shaders)
list(APPEND GRAPHICS_BACKENDS USE_CITRO3D)
else()
message(STATUS "🧩 Citro3D support not enabled")
endif()
@ -79,12 +82,26 @@ if(WIN32 AND NOT WINDOWS_STORE)
src/d3drm/backends/directx9/renderer.cpp
)
target_link_libraries(miniwin PRIVATE d3d9)
list(APPEND GRAPHICS_BACKENDS USE_DIRECTX9)
endif()
if(WINDOWS_STORE)
add_compile_definitions(WINDOWS_STORE)
endif()
if(USE_SDL_GPU IN_LIST GRAPHICS_BACKENDS)
target_sources(miniwin PRIVATE
src/d3drm/backends/sdl3gpu/renderer.cpp
src/d3drm/backends/sdl3gpu/shaders/generated/ShaderIndex.cpp
)
endif()
if(USE_SOFTWARE_RENDER IN_LIST GRAPHICS_BACKENDS)
target_sources(miniwin PRIVATE
src/d3drm/backends/software/renderer.cpp
)
endif()
target_compile_definitions(miniwin PUBLIC MINIWIN)
target_include_directories(miniwin
@ -96,6 +113,9 @@ target_link_libraries(miniwin PUBLIC miniwin-headers)
target_link_libraries(miniwin PRIVATE SDL3::SDL3)
target_compile_definitions(miniwin PUBLIC ${GRAPHICS_BACKENDS})
# Shader stuff
set(shader_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/src/d3drm/backends/sdl3gpu/shaders/src")

43
miniwin/src/d3drm/d3drm.cpp
View File

@ -7,20 +7,6 @@
#include "d3drmmesh_impl.h"
#include "d3drmobject_impl.h"
#include "d3drmrenderer.h"
#ifdef USE_OPENGL1
#include "d3drmrenderer_opengl1.h"
#endif
#ifdef USE_OPENGLES2
#include "d3drmrenderer_opengles2.h"
#endif
#ifdef __3DS__
#include "d3drmrenderer_citro3d.h"
#endif
#ifdef _WIN32
#include "d3drmrenderer_directx9.h"
#endif
#include "d3drmrenderer_sdl3gpu.h"
#include "d3drmrenderer_software.h"
#include "d3drmtexture_impl.h"
#include "d3drmviewport_impl.h"
#include "ddraw_impl.h"
@ -146,33 +132,8 @@ HRESULT Direct3DRMImpl::CreateDeviceFromSurface(
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
surface->GetSurfaceDesc(&DDSDesc);
if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
DDRenderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
else if (SDL_memcmp(&guid, &SOFTWARE_GUID, sizeof(GUID)) == 0) {
DDRenderer = new Direct3DRMSoftwareRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#ifdef USE_OPENGLES2
else if (SDL_memcmp(&guid, &OpenGLES2_GUID, sizeof(GUID)) == 0) {
DDRenderer = OpenGLES2Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_OPENGL1
else if (SDL_memcmp(&guid, &OpenGL1_GUID, sizeof(GUID)) == 0) {
DDRenderer = OpenGL1Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef __3DS__
else if (SDL_memcmp(&guid, &Citro3D_GUID, sizeof(GUID)) == 0) {
DDRenderer = new Citro3DRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#if defined(_WIN32) && !defined(WINDOWS_STORE)
else if (SDL_memcmp(&guid, &DirectX9_GUID, sizeof(GUID)) == 0) {
DDRenderer = DirectX9Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
else {
DDRenderer = CreateDirect3DRMRenderer(DDSDesc, guid);
if (!DDRenderer) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Device GUID not recognized");
return E_NOINTERFACE;
}

76
miniwin/src/d3drm/d3drmrenderer.cpp Normal file
View File

@ -0,0 +1,76 @@
#include "d3drmrenderer.h"
#ifdef USE_OPENGL1
#include "d3drmrenderer_opengl1.h"
#endif
#ifdef USE_OPENGLES2
#include "d3drmrenderer_opengles2.h"
#endif
#ifdef USE_CITRO3D
#include "d3drmrenderer_citro3d.h"
#endif
#ifdef USE_DIRECTX9
#include "d3drmrenderer_directx9.h"
#endif
#ifdef USE_SDL_GPU
#include "d3drmrenderer_sdl3gpu.h"
#endif
#ifdef USE_SOFTWARE_RENDER
#include "d3drmrenderer_software.h"
#endif
Direct3DRMRenderer* CreateDirect3DRMRenderer(const DDSURFACEDESC& DDSDesc, const GUID* guid)
{
#ifdef USE_SDL_GPU
if (SDL_memcmp(guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
return Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_SOFTWARE_RENDER
if (SDL_memcmp(guid, &SOFTWARE_GUID, sizeof(GUID)) == 0) {
return new Direct3DRMSoftwareRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_OPENGLES2
if (SDL_memcmp(guid, &OpenGLES2_GUID, sizeof(GUID)) == 0) {
return OpenGLES2Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_OPENGL1
if (SDL_memcmp(guid, &OpenGL1_GUID, sizeof(GUID)) == 0) {
return OpenGL1Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_CITRO3D
if (SDL_memcmp(guid, &Citro3D_GUID, sizeof(GUID)) == 0) {
return new Citro3DRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_DIRECTX9
if (SDL_memcmp(guid, &DirectX9_GUID, sizeof(GUID)) == 0) {
return DirectX9Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
return nullptr;
}
void Direct3DRMRenderer_EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
{
#ifdef USE_SDL_GPU
Direct3DRMSDL3GPU_EnumDevice(cb, ctx);
#endif
#ifdef USE_OPENGLES2
OpenGLES2Renderer_EnumDevice(cb, ctx);
#endif
#ifdef USE_OPENGL1
OpenGL1Renderer_EnumDevice(cb, ctx);
#endif
#ifdef USE_CITRO3D
Citro3DRenderer_EnumDevice(cb, ctx);
#endif
#ifdef USE_DIRECTX9
DirectX9Renderer_EnumDevice(cb, ctx);
#endif
#ifdef USE_SOFTWARE_RENDER
Direct3DRMSoftware_EnumDevice(cb, ctx);
#endif
}

61
miniwin/src/ddraw/ddraw.cpp
View File

@ -1,17 +1,5 @@
#ifdef USE_OPENGL1
#include "d3drmrenderer_opengl1.h"
#endif
#ifdef USE_OPENGLES2
#include "d3drmrenderer_opengles2.h"
#endif
#ifdef __3DS__
#include "d3drmrenderer_citro3d.h"
#endif
#if defined(_WIN32) && !defined(WINDOWS_STORE)
#include "d3drmrenderer_directx9.h"
#endif
#include "d3drmrenderer_sdl3gpu.h"
#include "d3drmrenderer_software.h"
#include "d3drmrenderer.h"
#include "ddpalette_impl.h"
#include "ddraw_impl.h"
#include "ddsurface_impl.h"
@ -232,21 +220,7 @@ void EnumDevice(
HRESULT DirectDrawImpl::EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx)
{
Direct3DRMSDL3GPU_EnumDevice(cb, ctx);
#ifdef USE_OPENGLES2
OpenGLES2Renderer_EnumDevice(cb, ctx);
#endif
#ifdef USE_OPENGL1
OpenGL1Renderer_EnumDevice(cb, ctx);
#endif
#ifdef __3DS__
Citro3DRenderer_EnumDevice(cb, ctx);
#endif
#if defined(_WIN32) && !defined(WINDOWS_STORE)
DirectX9Renderer_EnumDevice(cb, ctx);
#endif
Direct3DRMSoftware_EnumDevice(cb, ctx);
Direct3DRMRenderer_EnumDevices(cb, ctx);
return S_OK;
}
@ -343,33 +317,8 @@ HRESULT DirectDrawImpl::CreateDevice(
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
pBackBuffer->GetSurfaceDesc(&DDSDesc);
if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
DDRenderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#ifdef USE_OPENGLES2
else if (SDL_memcmp(&guid, &OpenGLES2_GUID, sizeof(GUID)) == 0) {
DDRenderer = OpenGLES2Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef USE_OPENGL1
else if (SDL_memcmp(&guid, &OpenGL1_GUID, sizeof(GUID)) == 0) {
DDRenderer = OpenGL1Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#ifdef __3DS__
else if (SDL_memcmp(&guid, &Citro3D_GUID, sizeof(GUID)) == 0) {
DDRenderer = new Citro3DRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
#if defined(_WIN32) && !defined(WINDOWS_STORE)
else if (SDL_memcmp(&guid, &DirectX9_GUID, sizeof(GUID)) == 0) {
DDRenderer = DirectX9Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
#endif
else if (SDL_memcmp(&guid, &SOFTWARE_GUID, sizeof(GUID)) == 0) {
DDRenderer = new Direct3DRMSoftwareRenderer(DDSDesc.dwWidth, DDSDesc.dwHeight);
}
else {
DDRenderer = CreateDirect3DRMRenderer(DDSDesc, &guid);
if (!DDRenderer) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Device GUID not recognized");
return E_NOINTERFACE;
}

3
miniwin/src/internal/d3drmrenderer.h
View File

@ -60,3 +60,6 @@ protected:
int m_virtualWidth, m_virtualHeight;
ViewportTransform m_viewportTransform;
};
Direct3DRMRenderer* CreateDirect3DRMRenderer(const DDSURFACEDESC& DDSDesc, const GUID* guid);
void Direct3DRMRenderer_EnumDevices(LPD3DENUMDEVICESCALLBACK cb, void* ctx);