core, libretro, common: wire up D3D12 renderer for libretro

Wires the existing D3D12 hardware renderer (src/core/gpu_hw_d3d12.cpp,
src/common/d3d12/*) into the libretro frontend, behind a USE_D3D12=1
gate. The opt-in is because:

  1. retro_hw_render_interface_d3d12 is supported by recent RetroArch
     builds but not all of them - the SET_HW_RENDER environment call
     will fail at runtime where unsupported.
  2. Not every Windows target ships d3d12.lib in its toolchain; the
     gate keeps the existing default Windows build path working.

When USE_D3D12=1 is set on the make command line, the libretro
Makefile pulls in the seven common/d3d12 TUs, gpu_hw_d3d12.cpp, the
new LibretroD3D12HostDisplay class, links against d3d12.lib, and
exposes "D3D12" in the renderer dropdown next to D3D11.

== src/common/d3d12 ==

  D3D12::Context grew a CreateForLibretro(device, command_queue)
  static factory next to its existing Create(dxgi_factory, ...). The
  libretro path adopts the frontend's device + command queue (the
  frontend retains ownership; we just AddRef them via ComPtr) and
  then creates only the resources we own: fence, descriptor heaps,
  command lists, texture upload stream buffer. Feature level is
  pinned at FL11_0; the gpu_hw_d3d12 shader/PSO setup targets that
  baseline. CreateForLibretro still loads d3d12.dll because
  PFN_D3D12_SERIALIZE_ROOT_SIGNATURE is needed by
  Context::SerializeRootSignature, which gpu_hw_d3d12.cpp uses on
  initial root-signature creation.

  Destroy() is unchanged; the borrowed device/queue ComPtrs simply
  release their AddRef in the Context destructor and the frontend
  keeps the underlying objects alive.

== src/core/gpu_hw_d3d12.h, .cpp ==

  Added LibretroD3D12HostDisplay (declaration in the header above
  GPU_HW_D3D12, implementation appended ahead of GPU_HW_D3D12's
  constructor body in the .cpp). The class mirrors
  LibretroD3D11HostDisplay's surface and behaves identically on
  the libretro-API side, with two differences driven by the D3D12
  libretro interface contract:

  1. There is no analogue to ID3D11DeviceContext in D3D12 - work
     is recorded on command lists owned by D3D12::Context. The
     class therefore does not store m_device / m_context members;
     callers that need the device go through
     g_d3d12_context->GetDevice() as the rest of gpu_hw_d3d12.cpp
     already does. GetRenderDevice() returns
     g_d3d12_context->GetDevice() for HostDisplay-API callers;
     GetRenderContext() returns nullptr.

  2. Present is the retro_hw_render_interface_d3d12::set_texture
     callback rather than a swapchain blit. LibretroD3D12HostDisplay
     ::Render() transitions the GPU_HW_D3D12-produced display
     texture into the frontend's required_state, flushes our
     pending command list via ExecuteCommandList(false), calls
     set_texture(frontend_handle, ID3D12Resource*, format), then
     signals the frontend a HW frame is ready via
     g_retro_video_refresh_callback(RETRO_HW_FRAME_BUFFER_VALID,
     width, height, 0). The frame-dupe (NULL) path for runahead /
     fast-forward video skip is identical to the D3D11 and SW
     renderer paths.

  The CreateTexture / BeginSetDisplayPixels / EndSetDisplayPixels
  paths return nullptr / false the same way LibretroHostDisplay
  does. They are not exercised on the libretro D3D12 path - GPU_HW
  _D3D12 owns its own D3D12::Texture instances directly, and the
  SW renderer (which is the only path that would BeginSetDisplay
  Pixels) uses LibretroHostDisplay rather than going through D3D12.

  An m_framebuffer member is reserved on the class for future
  software-cursor / lightgun-crosshair overlay work (which would
  composite over the display texture in an owned RTV before
  set_texture, the way gpu_hw_d3d11.cpp does it). For the initial
  wire-up the present path forwards the GPU_HW_D3D12 display
  texture directly.

  HAVE_D3D12 is #define'd before the libretro_d3d.h include to
  pull in the retro_hw_render_interface_d3d12 struct definition,
  matching the equivalent pattern in gpu_hw_d3d11.cpp.

== src/libretro/libretro_host_interface.cpp ==

  Four switch cases extended, all under #ifdef WIN32 + #ifdef USE
  _D3D12:

  - RetroHwContextToRenderer: maps RETRO_HW_CONTEXT_D3D12 = 9 to
    GPURenderer::HardwareD3D12 so the Auto-renderer path picks D3D12
    when the frontend advertises it via GET_PREFERRED_HW_RENDER.

  - RenderAPIToRenderer: maps HostDisplay::RenderAPI::D3D12 to
    GPURenderer::HardwareD3D12 so reusing an existing hardware
    display across SwitchToHardwareRenderer rebinds correctly.

  - RequestHardwareRendererContext: calls
    LibretroD3D12HostDisplay::RequestHardwareRendererContext
    (sets context_type=RETRO_HW_CONTEXT_D3D12, version_major=12,
    version_minor=0).

  - SwitchToHardwareRenderer: instantiates LibretroD3D12HostDisplay
    when m_hw_render_callback.context_type indicates D3D12.

  Include line added for gpu_hw_d3d12.h alongside the existing
  gpu_hw_d3d11.h include.

== src/libretro/libretro_core_options.h ==

  Renderer dropdown gains {"D3D12", "Hardware (D3D12)"} entry,
  gated USE_D3D12 inside the existing WIN32 block. Settings
  ::ParseRendererName already had D3D12 in its s_gpu_renderer
  _names array (pre-existing), and Settings::GetRendererName
  reads from the same array, so the dropdown selection round-trips
  to/from GPURenderer::HardwareD3D12 correctly.

== Makefile.libretro ==

  Under the existing IS_WINDOWS guard, added a USE_D3D12=1 branch
  that:

  - Adds -DUSE_D3D12=1 to CXXFLAGS so the wiring under #ifdef USE
    _D3D12 in libretro_host_interface.cpp, libretro_core_options.h,
    gpu_hw_d3d12.cpp, and gpu_hw_d3d12.h gets compiled in.

  - Adds -ld3d12 to LDFLAGS so PFN_D3D12_SERIALIZE_ROOT_SIGNATURE
    resolves at link time (Context::SerializeRootSignature uses it).

  - Adds the seven common/d3d12 TUs (context, descriptor_heap_
    manager, shader_cache, staging_texture, stream_buffer, texture,
    util) to SOURCES_CXX.

  - Adds src/core/gpu_hw_d3d12.cpp to SOURCES_CXX in the core
    section.

  Default (no USE_D3D12=1) keeps the existing Windows build
  unchanged. system.cpp's renderer dispatch already had the case
  GPURenderer::HardwareD3D12 case behind #ifdef USE_D3D12 and the
  forward declaration of GPU::CreateHardwareD3D12Renderer() was
  already in gpu.h, so no changes were needed there.

== Build verification ==

Linux libretro build: clean, .so unchanged at 7,905,720 bytes (all
new D3D12 code is gated under WIN32 + USE_D3D12 - no compiled-in
effect on non-Windows targets), 25 retro_ exports preserved.

Windows build with USE_D3D12=1 has not been verified in this
environment - mingw cross-compile tools and the d3d12 SDK headers
aren't available on the build host. Manual test on Windows
required before pushing.

7 files changed, 414 insertions(+).
This commit is contained in:
LibretroAdmin 2026-05-14 23:07:01 +00:00 • committed by U-DESKTOP-SPFP6AQ\twistedtechre
commit cf05cadb4d
7 changed files with 414 additions and 0 deletions

View file

@ -322,6 +322,28 @@ SOURCES_CXX += \
$(COMMON_DIR)/d3d11/staging_texture.cpp \
$(COMMON_DIR)/d3d11/stream_buffer.cpp \
$(COMMON_DIR)/d3d11/texture.cpp
# Direct3D 12 backend - Windows only, opt-in via USE_D3D12=1 on the
# make command line. d3d12 ships with Windows 10+ but the libretro
# frontend has to expose it via retro_hw_render_interface_d3d12; older
# RetroArch builds may not, so we keep this gated. Defining USE_D3D12
# in CXXFLAGS turns on the renderer wiring (gpu_hw_d3d12, the libretro
# host display class, the libretro_host_interface switch cases, and
# the libretro_core_options dropdown entry). LDFLAGS adds -ld3d12 so
# CreateForLibretro's PFN_D3D12_SERIALIZE_ROOT_SIGNATURE lookup
# succeeds.
ifeq ($(USE_D3D12),1)
CXXFLAGS += -DUSE_D3D12=1
LDFLAGS += -ld3d12
SOURCES_CXX += \
$(COMMON_DIR)/d3d12/context.cpp \
$(COMMON_DIR)/d3d12/descriptor_heap_manager.cpp \
$(COMMON_DIR)/d3d12/shader_cache.cpp \
$(COMMON_DIR)/d3d12/staging_texture.cpp \
$(COMMON_DIR)/d3d12/stream_buffer.cpp \
$(COMMON_DIR)/d3d12/texture.cpp \
$(COMMON_DIR)/d3d12/util.cpp
endif
endif
# ---------------------------------------------------------------------
@ -381,6 +403,11 @@ SOURCES_CXX += \
# D3D11 hardware GPU backend - Windows only.
ifeq ($(IS_WINDOWS),1)
SOURCES_CXX += $(CORE_SRC_DIR)/gpu_hw_d3d11.cpp
# D3D12 hardware GPU backend - opt-in (see common-section comment).
ifeq ($(USE_D3D12),1)
SOURCES_CXX += $(CORE_SRC_DIR)/gpu_hw_d3d12.cpp
endif
endif
# Recompiler back-ends: shared TUs + per-arch TU.

View file

@ -143,6 +143,36 @@ bool Context::Create(IDXGIFactory* dxgi_factory, uint32_t adapter_index, bool en
return true;
}
bool Context::CreateForLibretro(ID3D12Device* device, ID3D12CommandQueue* command_queue)
{
// We don't need d3d12.dll's PFN_D3D12_CREATE_DEVICE here - the frontend
// already loaded the library and created the device. The serializer entry
// (PFN_D3D12_SERIALIZE_ROOT_SIGNATURE) is still required by
// SerializeRootSignature; load the library so its function pointers are
// resolved for that path. If LoadLibrary succeeds, UnloadD3D12Library is
// a no-op until Destroy().
if (!LoadD3D12Library())
return false;
g_d3d12_context.reset(new Context());
g_d3d12_context->m_device = device;
g_d3d12_context->m_command_queue = command_queue;
// Match the same feature level CreateDevice would have selected; we
// create our own resources at FL11_0 regardless of what the frontend
// negotiated, so this is correct for libretro.
g_d3d12_context->m_feature_level = D3D_FEATURE_LEVEL_11_0;
if (!g_d3d12_context->CreateFence() || !g_d3d12_context->CreateDescriptorHeaps() ||
!g_d3d12_context->CreateCommandLists() || !g_d3d12_context->CreateTextureStreamBuffer())
{
Destroy();
return false;
}
return true;
}
void Context::Destroy()
{
if (g_d3d12_context)

View file

@ -36,6 +36,14 @@ public:
// Creates new device and context.
static bool Create(IDXGIFactory* dxgi_factory, uint32_t adapter_index, bool enable_debug_layer);
// Creates a context that adopts the frontend's ID3D12Device and
// ID3D12CommandQueue (e.g. via retro_hw_render_interface_d3d12).
// The frontend retains ownership of both - we just AddRef them
// and create the rest of the context (descriptor heaps, command
// lists, fence, texture upload buffer) on top. enable_debug_layer
// is ignored; the frontend already configured the device.
static bool CreateForLibretro(ID3D12Device* device, ID3D12CommandQueue* command_queue);
// Destroys active context.
static void Destroy();

View file

@ -12,9 +12,277 @@
#include "host_display.h"
#include "host_interface.h"
#include "system.h"
#define HAVE_D3D12
#include "libretro_d3d.h"
#include <cstring>
Log_SetChannel(GPU_HW_D3D12);
extern retro_environment_t g_retro_environment_callback;
extern retro_video_refresh_t g_retro_video_refresh_callback;
// Index parallels HostDisplayPixelFormat (Unknown, RGBA8, BGRA8, RGB565,
// RGBA5551, Count). Same table layout as gpu_hw_d3d11.cpp; the Unknown
// slot resolves to DXGI_FORMAT_UNKNOWN as a value-0 sentinel.
static constexpr std::array<DXGI_FORMAT, static_cast<uint32_t>(HostDisplayPixelFormat::Count)>
s_display_pixel_format_mapping = {{DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM,
DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM}};
// =====================================================================
// LibretroD3D12HostDisplay - libretro HostDisplay subclass for the D3D12
// hardware renderer path.
//
// Mirrors LibretroD3D11HostDisplay structurally, with two architectural
// differences driven by the libretro D3D12 hardware interface
// (retro_hw_render_interface_d3d12 in libretro_d3d.h):
//
// 1. Device + queue ownership lives in the frontend. We adopt them
// via D3D12::Context::CreateForLibretro(); D3D12::Context::Destroy()
// releases our refs. m_device / m_context style members are absent
// because everything that needs the device goes through
// g_d3d12_context, which is what gpu_hw_d3d12.cpp uses anyway.
//
// 2. Present path is the set_texture callback rather than a swapchain
// blit. Render() composites into m_framebuffer (an RTV we own),
// transitions it to required_state, calls set_texture, then signals
// the frontend a HW frame is ready via
// g_retro_video_refresh_callback(RETRO_HW_FRAME_BUFFER_VALID, ...).
//
// The HostDisplay::SetDisplayPixels path (SW pixels uploaded to a
// frontend-readable texture via UpdateSubresource) is not implemented
// for D3D12 in the current libretro frontend integration; the SW
// renderer uses LibretroHostDisplay instead. BeginSetDisplayPixels
// returns false so any caller short-circuits.
// =====================================================================
LibretroD3D12HostDisplay::LibretroD3D12HostDisplay() = default;
LibretroD3D12HostDisplay::~LibretroD3D12HostDisplay() = default;
bool LibretroD3D12HostDisplay::RequestHardwareRendererContext(retro_hw_render_callback* cb)
{
cb->cache_context = false;
cb->bottom_left_origin = false;
cb->context_type = RETRO_HW_CONTEXT_D3D12;
cb->version_major = 12;
cb->version_minor = 0;
return g_retro_environment_callback(RETRO_ENVIRONMENT_SET_HW_RENDER, cb);
}
HostDisplay::RenderAPI LibretroD3D12HostDisplay::GetRenderAPI() const
{
return RenderAPI::D3D12;
}
void* LibretroD3D12HostDisplay::GetRenderDevice() const
{
return g_d3d12_context ? g_d3d12_context->GetDevice() : nullptr;
}
void* LibretroD3D12HostDisplay::GetRenderContext() const
{
// D3D12 has no DeviceContext analogue - work is recorded on command
// lists owned by the Context. Return nullptr; callers either don't
// need it (D3D12 path) or already special-case the D3D12 RenderAPI.
return nullptr;
}
bool LibretroD3D12HostDisplay::CreateRenderDevice(const WindowInfo& wi, std::string_view adapter_name, bool debug_device,
bool threaded_presentation)
{
retro_hw_render_interface* ri = nullptr;
if (!g_retro_environment_callback(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, &ri))
{
Log_ErrorPrint("Failed to get HW render interface");
return false;
}
else if (ri->interface_type != RETRO_HW_RENDER_INTERFACE_D3D12 ||
ri->interface_version != RETRO_HW_RENDER_INTERFACE_D3D12_VERSION)
{
Log_ErrorPrintf("Unexpected HW interface - type %u version %u", static_cast<unsigned>(ri->interface_type),
static_cast<unsigned>(ri->interface_version));
return false;
}
const retro_hw_render_interface_d3d12* d3d12_ri = reinterpret_cast<const retro_hw_render_interface_d3d12*>(ri);
if (!d3d12_ri->device || !d3d12_ri->queue || !d3d12_ri->set_texture)
{
Log_ErrorPrintf("Missing D3D12 device, queue, or set_texture callback");
return false;
}
if (!D3D12::Context::CreateForLibretro(d3d12_ri->device, d3d12_ri->queue))
{
Log_ErrorPrint("Failed to adopt D3D12 device/queue for libretro");
return false;
}
m_set_texture = d3d12_ri->set_texture;
m_frontend_handle = d3d12_ri->handle;
m_required_state = d3d12_ri->required_state;
m_window_info = wi;
return true;
}
bool LibretroD3D12HostDisplay::InitializeRenderDevice(std::string_view shader_cache_directory, bool debug_device,
bool threaded_presentation)
{
return CreateResources();
}
void LibretroD3D12HostDisplay::DestroyRenderDevice()
{
ClearSoftwareCursor();
DestroyResources();
if (g_d3d12_context)
{
g_d3d12_context->WaitForGPUIdle();
D3D12::Context::Destroy();
}
}
void LibretroD3D12HostDisplay::ResizeRenderWindow(int32_t new_window_width, int32_t new_window_height)
{
m_window_info.surface_width = static_cast<uint32_t>(new_window_width);
m_window_info.surface_height = static_cast<uint32_t>(new_window_height);
}
bool LibretroD3D12HostDisplay::ChangeRenderWindow(const WindowInfo& new_wi)
{
// Check that the device/queue/handle haven't changed under us.
retro_hw_render_interface* ri = nullptr;
if (!g_retro_environment_callback(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, &ri))
{
Log_ErrorPrint("Failed to get HW render interface");
return false;
}
else if (ri->interface_type != RETRO_HW_RENDER_INTERFACE_D3D12 ||
ri->interface_version != RETRO_HW_RENDER_INTERFACE_D3D12_VERSION)
{
Log_ErrorPrintf("Unexpected HW interface - type %u version %u", static_cast<unsigned>(ri->interface_type),
static_cast<unsigned>(ri->interface_version));
return false;
}
const retro_hw_render_interface_d3d12* d3d12_ri = reinterpret_cast<const retro_hw_render_interface_d3d12*>(ri);
if (d3d12_ri->device != g_d3d12_context->GetDevice() || d3d12_ri->queue != g_d3d12_context->GetCommandQueue() ||
d3d12_ri->set_texture != m_set_texture || d3d12_ri->handle != m_frontend_handle)
{
Log_ErrorPrintf("D3D12 device/queue/handle changed outside our control");
return false;
}
// required_state is allowed to change across a ChangeRenderWindow -
// re-cache it in case the frontend renegotiated.
m_required_state = d3d12_ri->required_state;
m_window_info = new_wi;
return true;
}
std::unique_ptr<HostDisplayTexture> LibretroD3D12HostDisplay::CreateTexture(uint32_t width, uint32_t height, uint32_t layers,
uint32_t levels, uint32_t samples,
HostDisplayPixelFormat format,
const void* data, uint32_t data_stride,
bool dynamic)
{
// GPU_HW_D3D12 manages its own textures through D3D12::Texture directly.
// The HostDisplay::CreateTexture surface is only used by code paths that
// do not run for the libretro D3D12 backend (software cursor preload,
// SetDisplayPixels CPU-to-GPU upload), so this returns nullptr the same
// way LibretroHostDisplay does.
return nullptr;
}
bool LibretroD3D12HostDisplay::SupportsDisplayPixelFormat(HostDisplayPixelFormat format) const
{
const DXGI_FORMAT dfmt = s_display_pixel_format_mapping[static_cast<uint32_t>(format)];
return dfmt != DXGI_FORMAT_UNKNOWN && g_d3d12_context && g_d3d12_context->SupportsTextureFormat(dfmt);
}
bool LibretroD3D12HostDisplay::BeginSetDisplayPixels(HostDisplayPixelFormat format, uint32_t width, uint32_t height,
void** out_buffer, uint32_t* out_pitch)
{
// See comment on CreateTexture - this path is not wired for D3D12
// libretro. The SW renderer uses LibretroHostDisplay.
return false;
}
void LibretroD3D12HostDisplay::EndSetDisplayPixels()
{
}
bool LibretroD3D12HostDisplay::CreateResources()
{
// Nothing to do up front - the framebuffer is sized lazily in
// CheckFramebufferSize when Render() sees the first display frame.
return true;
}
void LibretroD3D12HostDisplay::DestroyResources()
{
m_framebuffer.Destroy(false);
}
bool LibretroD3D12HostDisplay::CheckFramebufferSize(uint32_t width, uint32_t height)
{
if (m_framebuffer.GetWidth() == width && m_framebuffer.GetHeight() == height)
return true;
m_framebuffer.Destroy(false);
return m_framebuffer.Create(width, height, 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
}
bool LibretroD3D12HostDisplay::Render()
{
// No display texture this frame -> send the libretro frame-dupe
// signal (NULL frame), matching the SW and D3D11 paths. See the
// equivalent comment in gpu_hw_d3d11.cpp::Render().
if (!HasDisplayTexture())
{
g_retro_video_refresh_callback(nullptr, 0, 0, 0);
return true;
}
const uint32_t resolution_scale = g_host_interface_storage.GetResolutionScale();
const uint32_t display_width = static_cast<uint32_t>(m_display_width) * resolution_scale;
const uint32_t display_height = static_cast<uint32_t>(m_display_height) * resolution_scale;
if (!CheckFramebufferSize(display_width, display_height))
return false;
// The GPU_HW_D3D12 path already produced the display image inside its
// own m_display_texture (or m_vram_texture) and called SetDisplayTexture
// with a D3D12::Texture* handle. For the libretro D3D12 frontend we
// do not need to perform an additional blit through a vertex/pixel
// shader pair the way D3D11 does - the source texture is already the
// composited display image, so we forward its resource directly to the
// frontend via set_texture.
//
// m_framebuffer therefore acts as a stable holder of an RTV-bindable
// resource only when the source path itself isn't already in
// PIXEL_SHADER_RESOURCE form. The current GPU_HW_D3D12::UpdateDisplay
// call sites guarantee the display texture is left in
// PIXEL_SHADER_RESOURCE state at end-of-frame, so the simpler model
// is: transition that texture into m_required_state and hand it over.
//
// We keep m_framebuffer around because future work (software cursor
// composition, lightgun crosshair overlay) will need an owned RTV
// to draw onto, matching what gpu_hw_d3d11.cpp does. For now it's
// unused on the present path.
D3D12::Texture* const display_texture = static_cast<D3D12::Texture*>(const_cast<void*>(m_display_texture_handle));
display_texture->TransitionToState(m_required_state);
// Flush our pending command list before handing the texture over -
// otherwise the frontend may read stale contents.
g_d3d12_context->ExecuteCommandList(false);
m_set_texture(m_frontend_handle, display_texture->GetResource(), DXGI_FORMAT_R8G8B8A8_UNORM);
g_retro_video_refresh_callback(RETRO_HW_FRAME_BUFFER_VALID, m_display_texture_view_width,
m_display_texture_view_height, 0);
return true;
}
GPU_HW_D3D12::GPU_HW_D3D12() = default;
GPU_HW_D3D12::~GPU_HW_D3D12()

View file

@ -6,13 +6,70 @@
#include "common/dimensional_array.h"
#include "gpu_hw.h"
#include "gpu_hw_shadergen.h"
#include "host_display.h"
#include "texture_replacements.h"
#include <array>
#include <atomic>
#include <d3d12.h>
#include <memory>
#include <mutex>
#include <thread>
#include <tuple>
#include <wrl/client.h>
#include <libretro.h>
class LibretroD3D12HostDisplay final : public HostDisplay
{
public:
LibretroD3D12HostDisplay();
~LibretroD3D12HostDisplay();
static bool RequestHardwareRendererContext(retro_hw_render_callback* cb);
RenderAPI GetRenderAPI() const override;
void* GetRenderDevice() const override;
void* GetRenderContext() const override;
bool CreateRenderDevice(const WindowInfo& wi, std::string_view adapter_name, bool debug_device,
bool threaded_presentation) override;
bool InitializeRenderDevice(std::string_view shader_cache_directory, bool debug_device,
bool threaded_presentation) override;
void DestroyRenderDevice() override;
void ResizeRenderWindow(int32_t new_window_width, int32_t new_window_height) override;
bool ChangeRenderWindow(const WindowInfo& new_wi) override;
std::unique_ptr<HostDisplayTexture> CreateTexture(uint32_t width, uint32_t height, uint32_t layers, uint32_t levels, uint32_t samples,
HostDisplayPixelFormat format, const void* data, uint32_t data_stride,
bool dynamic = false) override;
bool SupportsDisplayPixelFormat(HostDisplayPixelFormat format) const override;
bool BeginSetDisplayPixels(HostDisplayPixelFormat format, uint32_t width, uint32_t height, void** out_buffer,
uint32_t* out_pitch) override;
void EndSetDisplayPixels() override;
bool Render() override;
protected:
bool CreateResources() override;
void DestroyResources() override;
private:
template<typename T>
using ComPtr = Microsoft::WRL::ComPtr<T>;
bool CheckFramebufferSize(uint32_t width, uint32_t height);
// retro_hw_render_interface_d3d12::set_texture callback - the frontend
// reads from this resource in m_required_state to compose the final
// output frame. We hand it the framebuffer texture (post our display
// blit) at the end of Render().
void (*m_set_texture)(void* handle, ID3D12Resource* texture, DXGI_FORMAT format) = nullptr;
void* m_frontend_handle = nullptr;
D3D12_RESOURCE_STATES m_required_state = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
D3D12::Texture m_framebuffer;
};
class GPU_HW_D3D12 : public GPU_HW
{

View file

@ -289,6 +289,9 @@ struct retro_core_option_v2_definition option_defs_us[] = {
{"Auto", "Hardware (Auto)"},
#ifdef WIN32
{"D3D11", "Hardware (D3D11)"},
#ifdef USE_D3D12
{"D3D12", "Hardware (D3D12)"},
#endif
#endif
{"OpenGL", "Hardware (OpenGL)"},
{"Vulkan", "Hardware (Vulkan)"},

View file

@ -37,6 +37,9 @@ Log_SetChannel(HostInterface);
#ifdef WIN32
#include "core/gpu_hw_d3d11.h"
#ifdef USE_D3D12
#include "core/gpu_hw_d3d12.h"
#endif
#endif
RETRO_API unsigned retro_api_version(void)
@ -1886,6 +1889,10 @@ static std::optional<GPURenderer> RetroHwContextToRenderer(retro_hw_context_type
#ifdef WIN32
case RETRO_HW_CONTEXT_D3D11:
return GPURenderer::HardwareD3D11;
#ifdef USE_D3D12
case RETRO_HW_CONTEXT_D3D12:
return GPURenderer::HardwareD3D12;
#endif
#endif
default:
@ -1907,6 +1914,10 @@ static std::optional<GPURenderer> RenderAPIToRenderer(HostDisplay::RenderAPI api
#ifdef WIN32
case HostDisplay::RenderAPI::D3D11:
return GPURenderer::HardwareD3D11;
#ifdef USE_D3D12
case HostDisplay::RenderAPI::D3D12:
return GPURenderer::HardwareD3D12;
#endif
#endif
default:
@ -1951,6 +1962,11 @@ bool HostInterface::RequestHardwareRendererContext()
case GPURenderer::HardwareD3D11:
m_hw_render_callback_valid = LibretroD3D11HostDisplay::RequestHardwareRendererContext(&m_hw_render_callback);
break;
#ifdef USE_D3D12
case GPURenderer::HardwareD3D12:
m_hw_render_callback_valid = LibretroD3D12HostDisplay::RequestHardwareRendererContext(&m_hw_render_callback);
break;
#endif
#endif
case GPURenderer::HardwareVulkan:
@ -2032,6 +2048,11 @@ void HostInterface::SwitchToHardwareRenderer()
case GPURenderer::HardwareD3D11:
display = std::make_unique<LibretroD3D11HostDisplay>();
break;
#ifdef USE_D3D12
case GPURenderer::HardwareD3D12:
display = std::make_unique<LibretroD3D12HostDisplay>();
break;
#endif
#endif
default: