FrontendCommon: Add D3D11 helper for host display

src/frontend-common/CMakeLists.txt

@@ -17,6 +17,14 @@ add_library(frontend-common
 
 target_link_libraries(frontend-common PUBLIC core common imgui simpleini scmversion vulkan-loader)
 
+if(WIN32)
+  target_sources(frontend-common PRIVATE
+    d3d11_host_display.cpp
+    d3d11_host_display.h
+  )
+  target_link_libraries(frontend-common PRIVATE d3d11.lib dxgi.lib)
+endif()
+
 if(SDL2_FOUND)
   target_sources(frontend-common PRIVATE 
     sdl_audio_stream.cpp

src/frontend-common/d3d11_host_display.cpp

@@ -0,0 +1,475 @@
+#include "d3d11_host_display.h"
+#include "common/assert.h"
+#include "common/d3d11/shader_compiler.h"
+#include "common/log.h"
+#include "display_ps.hlsl.h"
+#include "display_vs.hlsl.h"
+#include <array>
+#include <dxgi1_5.h>
+#include <imgui.h>
+#include <imgui_impl_dx11.h>
+Log_SetChannel(D3D11HostDisplay);
+
+namespace FrontendCommon {
+
+class D3D11HostDisplayTexture : public HostDisplayTexture
+{
+public:
+  template<typename T>
+  using ComPtr = Microsoft::WRL::ComPtr<T>;
+
+  D3D11HostDisplayTexture(ComPtr<ID3D11Texture2D> texture, ComPtr<ID3D11ShaderResourceView> srv, u32 width, u32 height,
+                          bool dynamic)
+    : m_texture(std::move(texture)), m_srv(std::move(srv)), m_width(width), m_height(height), m_dynamic(dynamic)
+  {
+  }
+  ~D3D11HostDisplayTexture() override = default;
+
+  void* GetHandle() const override { return m_srv.Get(); }
+  u32 GetWidth() const override { return m_width; }
+  u32 GetHeight() const override { return m_height; }
+
+  ID3D11Texture2D* GetD3DTexture() const { return m_texture.Get(); }
+  ID3D11ShaderResourceView* GetD3DSRV() const { return m_srv.Get(); }
+  ID3D11ShaderResourceView* const* GetD3DSRVArray() const { return m_srv.GetAddressOf(); }
+  bool IsDynamic() const { return m_dynamic; }
+
+  static std::unique_ptr<D3D11HostDisplayTexture> Create(ID3D11Device* device, u32 width, u32 height, const void* data,
+                                                         u32 data_stride, bool dynamic)
+  {
+    const CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_R8G8B8A8_UNORM, width, height, 1, 1, D3D11_BIND_SHADER_RESOURCE,
+                                     dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT,
+                                     dynamic ? D3D11_CPU_ACCESS_WRITE : 0, 1, 0, 0);
+    const D3D11_SUBRESOURCE_DATA srd{data, data_stride, data_stride * height};
+    ComPtr<ID3D11Texture2D> texture;
+    HRESULT hr = device->CreateTexture2D(&desc, data ? &srd : nullptr, texture.GetAddressOf());
+    if (FAILED(hr))
+      return {};
+
+    const CD3D11_SHADER_RESOURCE_VIEW_DESC srv_desc(D3D11_SRV_DIMENSION_TEXTURE2D, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 1, 0,
+                                                    1);
+    ComPtr<ID3D11ShaderResourceView> srv;
+    hr = device->CreateShaderResourceView(texture.Get(), &srv_desc, srv.GetAddressOf());
+    if (FAILED(hr))
+      return {};
+
+    return std::make_unique<D3D11HostDisplayTexture>(std::move(texture), std::move(srv), width, height, dynamic);
+  }
+
+private:
+  ComPtr<ID3D11Texture2D> m_texture;
+  ComPtr<ID3D11ShaderResourceView> m_srv;
+  u32 m_width;
+  u32 m_height;
+  bool m_dynamic;
+};
+
+D3D11HostDisplay::D3D11HostDisplay() = default;
+
+D3D11HostDisplay::~D3D11HostDisplay() = default;
+
+std::unique_ptr<HostDisplayTexture> D3D11HostDisplay::CreateTexture(u32 width, u32 height, const void* initial_data,
+                                                                    u32 initial_data_stride, bool dynamic)
+{
+  return D3D11HostDisplayTexture::Create(m_device.Get(), width, height, initial_data, initial_data_stride, dynamic);
+}
+
+void D3D11HostDisplay::UpdateTexture(HostDisplayTexture* texture, u32 x, u32 y, u32 width, u32 height,
+                                     const void* texture_data, u32 texture_data_stride)
+{
+  D3D11HostDisplayTexture* d3d11_texture = static_cast<D3D11HostDisplayTexture*>(texture);
+  if (!d3d11_texture->IsDynamic())
+  {
+    const CD3D11_BOX dst_box(x, y, 0, x + width, y + height, 1);
+    m_context->UpdateSubresource(d3d11_texture->GetD3DTexture(), 0, &dst_box, texture_data, texture_data_stride,
+                                 texture_data_stride * height);
+  }
+  else
+  {
+    D3D11_MAPPED_SUBRESOURCE sr;
+    HRESULT hr = m_context->Map(d3d11_texture->GetD3DTexture(), 0, D3D11_MAP_WRITE_DISCARD, 0, &sr);
+    if (FAILED(hr))
+      Panic("Failed to map dynamic host display texture");
+
+    char* dst_ptr = static_cast<char*>(sr.pData) + (y * sr.RowPitch) + (x * sizeof(u32));
+    const char* src_ptr = static_cast<const char*>(texture_data);
+    if (sr.RowPitch == texture_data_stride)
+    {
+      std::memcpy(dst_ptr, src_ptr, texture_data_stride * height);
+    }
+    else
+    {
+      for (u32 row = 0; row < height; row++)
+      {
+        std::memcpy(dst_ptr, src_ptr, width * sizeof(u32));
+        src_ptr += texture_data_stride;
+        dst_ptr += sr.RowPitch;
+      }
+    }
+
+    m_context->Unmap(d3d11_texture->GetD3DTexture(), 0);
+  }
+}
+
+bool D3D11HostDisplay::DownloadTexture(const void* texture_handle, u32 x, u32 y, u32 width, u32 height, void* out_data,
+                                       u32 out_data_stride)
+{
+  ID3D11ShaderResourceView* srv =
+    const_cast<ID3D11ShaderResourceView*>(static_cast<const ID3D11ShaderResourceView*>(texture_handle));
+  ID3D11Resource* srv_resource;
+  D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
+  srv->GetResource(&srv_resource);
+  srv->GetDesc(&srv_desc);
+
+  if (!m_readback_staging_texture.EnsureSize(m_context.Get(), width, height, srv_desc.Format, false))
+    return false;
+
+  m_readback_staging_texture.CopyFromTexture(m_context.Get(), srv_resource, 0, x, y, 0, 0, width, height);
+  return m_readback_staging_texture.ReadPixels<u32>(m_context.Get(), 0, 0, width, height, out_data_stride / sizeof(u32),
+                                                    static_cast<u32*>(out_data));
+}
+
+void D3D11HostDisplay::SetVSync(bool enabled)
+{
+  m_vsync = enabled;
+}
+
+bool D3D11HostDisplay::HasContext() const
+{
+  return static_cast<bool>(m_device);
+}
+
+bool D3D11HostDisplay::CreateContextAndSwapChain(const WindowInfo& wi, bool use_flip_model, bool debug_device)
+{
+  UINT create_flags = 0;
+  if (debug_device)
+    create_flags |= D3D11_CREATE_DEVICE_DEBUG;
+
+  HRESULT hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, create_flags, nullptr, 0,
+                                 D3D11_SDK_VERSION, m_device.GetAddressOf(), nullptr, m_context.GetAddressOf());
+
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("Failed to create D3D device: 0x%08X", hr);
+    return false;
+  }
+
+  if (debug_device && IsDebuggerPresent())
+  {
+    ComPtr<ID3D11InfoQueue> info;
+    hr = m_device.As(&info);
+    if (SUCCEEDED(hr))
+    {
+      info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, TRUE);
+      info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, TRUE);
+    }
+  }
+
+  // we need the specific factory for the device, otherwise MakeWindowAssociation() is flaky.
+  ComPtr<IDXGIDevice> dxgi_device;
+  ComPtr<IDXGIAdapter> dxgi_adapter;
+  if (FAILED(m_device.As(&dxgi_device)) || FAILED(dxgi_device->GetParent(IID_PPV_ARGS(dxgi_adapter.GetAddressOf()))) ||
+      FAILED(dxgi_adapter->GetParent(IID_PPV_ARGS(m_dxgi_factory.GetAddressOf()))))
+  {
+    Log_WarningPrint("Failed to get parent adapter/device/factory");
+    return false;
+  }
+
+  DXGI_ADAPTER_DESC adapter_desc;
+  if (SUCCEEDED(dxgi_adapter->GetDesc(&adapter_desc)))
+  {
+    char adapter_name_buffer[128];
+    const int name_length =
+      WideCharToMultiByte(CP_UTF8, 0, adapter_desc.Description, static_cast<int>(std::wcslen(adapter_desc.Description)),
+                          adapter_name_buffer, countof(adapter_name_buffer), 0, nullptr);
+    if (name_length >= 0)
+    {
+      adapter_name_buffer[name_length] = 0;
+      Log_InfoPrintf("D3D Adapter: %s", adapter_name_buffer);
+    }
+  }
+
+  m_allow_tearing_supported = false;
+  ComPtr<IDXGIFactory5> dxgi_factory5;
+  hr = m_dxgi_factory.As(&dxgi_factory5);
+  if (SUCCEEDED(hr))
+  {
+    BOOL allow_tearing_supported = false;
+    hr = dxgi_factory5->CheckFeatureSupport(DXGI_FEATURE_PRESENT_ALLOW_TEARING, &allow_tearing_supported,
+                                            sizeof(allow_tearing_supported));
+    if (SUCCEEDED(hr))
+      m_allow_tearing_supported = (allow_tearing_supported == TRUE);
+  }
+
+  return CreateSwapChain(wi, use_flip_model);
+}
+
+void D3D11HostDisplay::DestroyContext()
+{
+  Assert(!m_swap_chain);
+  m_context.Reset();
+  m_device.Reset();
+}
+
+bool D3D11HostDisplay::CreateSwapChain(const WindowInfo& new_wi, bool use_flip_model)
+{
+  if (new_wi.type != WindowInfo::Type::Win32)
+    return false;
+
+  m_using_flip_model_swap_chain = use_flip_model;
+
+  const HWND window_hwnd = reinterpret_cast<HWND>(new_wi.window_handle);
+  RECT client_rc{};
+  GetClientRect(window_hwnd, &client_rc);
+  const u32 width = static_cast<u32>(client_rc.right - client_rc.left);
+  const u32 height = static_cast<u32>(client_rc.bottom - client_rc.top);
+
+  DXGI_SWAP_CHAIN_DESC swap_chain_desc = {};
+  swap_chain_desc.BufferDesc.Width = width;
+  swap_chain_desc.BufferDesc.Height = height;
+  swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+  swap_chain_desc.SampleDesc.Count = 1;
+  swap_chain_desc.BufferCount = 3;
+  swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+  swap_chain_desc.OutputWindow = window_hwnd;
+  swap_chain_desc.Windowed = TRUE;
+  swap_chain_desc.SwapEffect = m_using_flip_model_swap_chain ? DXGI_SWAP_EFFECT_FLIP_DISCARD : DXGI_SWAP_EFFECT_DISCARD;
+
+  m_using_allow_tearing = (m_allow_tearing_supported && m_using_flip_model_swap_chain);
+  if (m_using_allow_tearing)
+    swap_chain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
+
+  Log_InfoPrintf("Creating a %dx%d %s %s swap chain", width, height,
+                 m_using_flip_model_swap_chain ? "flip-discard" : "discard",
+                 swap_chain_desc.Windowed ? "windowed" : "full-screen");
+
+  HRESULT hr = m_dxgi_factory->CreateSwapChain(m_device.Get(), &swap_chain_desc, m_swap_chain.GetAddressOf());
+  if (FAILED(hr) && m_using_flip_model_swap_chain)
+  {
+    Log_WarningPrintf("Failed to create a flip-discard swap chain, trying discard.");
+    swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+    swap_chain_desc.Flags = 0;
+    m_using_flip_model_swap_chain = false;
+    m_using_allow_tearing = false;
+
+    hr = m_dxgi_factory->CreateSwapChain(m_device.Get(), &swap_chain_desc, m_swap_chain.GetAddressOf());
+    if (FAILED(hr))
+    {
+      Log_ErrorPrintf("CreateSwapChain failed: 0x%08X", hr);
+      return false;
+    }
+  }
+
+  hr = m_dxgi_factory->MakeWindowAssociation(swap_chain_desc.OutputWindow, DXGI_MWA_NO_WINDOW_CHANGES);
+  if (FAILED(hr))
+    Log_WarningPrintf("MakeWindowAssociation() to disable ALT+ENTER failed");
+
+  return CreateSwapChainRTV();
+}
+
+bool D3D11HostDisplay::CreateSwapChainRTV()
+{
+  ComPtr<ID3D11Texture2D> backbuffer;
+  HRESULT hr = m_swap_chain->GetBuffer(0, IID_PPV_ARGS(backbuffer.GetAddressOf()));
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("GetBuffer for RTV failed: 0x%08X", hr);
+    return false;
+  }
+
+  D3D11_TEXTURE2D_DESC backbuffer_desc;
+  backbuffer->GetDesc(&backbuffer_desc);
+
+  CD3D11_RENDER_TARGET_VIEW_DESC rtv_desc(D3D11_RTV_DIMENSION_TEXTURE2D, backbuffer_desc.Format, 0, 0,
+                                          backbuffer_desc.ArraySize);
+  hr = m_device->CreateRenderTargetView(backbuffer.Get(), &rtv_desc, m_swap_chain_rtv.GetAddressOf());
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("CreateRenderTargetView for swap chain failed: 0x%08X", hr);
+    return false;
+  }
+
+  m_swap_chain_width = backbuffer_desc.Width;
+  m_swap_chain_height = backbuffer_desc.Height;
+  return true;
+}
+
+void D3D11HostDisplay::DestroySwapChain()
+{
+  m_swap_chain_rtv.Reset();
+  m_swap_chain.Reset();
+}
+
+void D3D11HostDisplay::ResizeSwapChain(u32 new_width, u32 new_height)
+{
+  if (!m_swap_chain)
+    return;
+
+  m_swap_chain_rtv.Reset();
+
+  HRESULT hr = m_swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN,
+                                           m_using_allow_tearing ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0);
+  if (FAILED(hr))
+    Log_ErrorPrintf("ResizeBuffers() failed: 0x%08X", hr);
+
+  if (!CreateSwapChainRTV())
+    Panic("Failed to recreate swap chain RTV after resize");
+}
+
+bool D3D11HostDisplay::CreateResources()
+{
+  HRESULT hr;
+
+  m_display_vertex_shader =
+    D3D11::ShaderCompiler::CreateVertexShader(m_device.Get(), s_display_vs_bytecode, sizeof(s_display_vs_bytecode));
+  m_display_pixel_shader =
+    D3D11::ShaderCompiler::CreatePixelShader(m_device.Get(), s_display_ps_bytecode, sizeof(s_display_ps_bytecode));
+  if (!m_display_vertex_shader || !m_display_pixel_shader)
+    return false;
+
+  if (!m_display_uniform_buffer.Create(m_device.Get(), D3D11_BIND_CONSTANT_BUFFER, DISPLAY_UNIFORM_BUFFER_SIZE))
+    return false;
+
+  CD3D11_RASTERIZER_DESC rasterizer_desc = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
+  rasterizer_desc.CullMode = D3D11_CULL_NONE;
+  hr = m_device->CreateRasterizerState(&rasterizer_desc, m_display_rasterizer_state.GetAddressOf());
+  if (FAILED(hr))
+    return false;
+
+  CD3D11_DEPTH_STENCIL_DESC depth_stencil_desc = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
+  depth_stencil_desc.DepthEnable = FALSE;
+  depth_stencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
+  hr = m_device->CreateDepthStencilState(&depth_stencil_desc, m_display_depth_stencil_state.GetAddressOf());
+  if (FAILED(hr))
+    return false;
+
+  CD3D11_BLEND_DESC blend_desc = CD3D11_BLEND_DESC(CD3D11_DEFAULT());
+  hr = m_device->CreateBlendState(&blend_desc, m_display_blend_state.GetAddressOf());
+  if (FAILED(hr))
+    return false;
+
+  CD3D11_SAMPLER_DESC sampler_desc = CD3D11_SAMPLER_DESC(CD3D11_DEFAULT());
+  sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+  hr = m_device->CreateSamplerState(&sampler_desc, m_point_sampler.GetAddressOf());
+  if (FAILED(hr))
+    return false;
+
+  sampler_desc.Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT;
+  hr = m_device->CreateSamplerState(&sampler_desc, m_linear_sampler.GetAddressOf());
+  if (FAILED(hr))
+    return false;
+
+  return true;
+}
+
+void D3D11HostDisplay::DestroyResources()
+{
+  m_display_uniform_buffer.Release();
+  m_swap_chain_rtv.Reset();
+  m_linear_sampler.Reset();
+  m_point_sampler.Reset();
+  m_display_pixel_shader.Reset();
+  m_display_vertex_shader.Reset();
+  m_display_blend_state.Reset();
+  m_display_depth_stencil_state.Reset();
+  m_display_rasterizer_state.Reset();
+}
+
+bool D3D11HostDisplay::CreateImGuiContext()
+{
+  ImGui::GetIO().DisplaySize.x = static_cast<float>(m_swap_chain_width);
+  ImGui::GetIO().DisplaySize.y = static_cast<float>(m_swap_chain_height);
+
+  if (!ImGui_ImplDX11_Init(m_device.Get(), m_context.Get()))
+    return false;
+
+  ImGui_ImplDX11_NewFrame();
+  return true;
+}
+
+void D3D11HostDisplay::DestroyImGuiContext()
+{
+  ImGui_ImplDX11_Shutdown();
+}
+
+bool D3D11HostDisplay::BeginRender()
+{
+  static constexpr std::array<float, 4> clear_color = {};
+  m_context->ClearRenderTargetView(m_swap_chain_rtv.Get(), clear_color.data());
+  m_context->OMSetRenderTargets(1, m_swap_chain_rtv.GetAddressOf(), nullptr);
+
+  return true;
+}
+
+void D3D11HostDisplay::RenderImGui()
+{
+  ImGui::Render();
+  ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+}
+
+void D3D11HostDisplay::EndRenderAndPresent()
+{
+  if (!m_vsync && m_using_allow_tearing)
+    m_swap_chain->Present(0, DXGI_PRESENT_ALLOW_TEARING);
+  else
+    m_swap_chain->Present(BoolToUInt32(m_vsync), 0);
+
+  ImGui::NewFrame();
+  ImGui_ImplDX11_NewFrame();
+}
+
+void D3D11HostDisplay::RenderDisplay(s32 left, s32 top, s32 width, s32 height, void* texture_handle, u32 texture_width,
+                                     u32 texture_height, u32 texture_view_x, u32 texture_view_y, u32 texture_view_width,
+                                     u32 texture_view_height, bool linear_filter)
+{
+  m_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+  m_context->VSSetShader(m_display_vertex_shader.Get(), nullptr, 0);
+  m_context->PSSetShader(m_display_pixel_shader.Get(), nullptr, 0);
+  m_context->PSSetShaderResources(0, 1, reinterpret_cast<ID3D11ShaderResourceView**>(&texture_handle));
+  m_context->PSSetSamplers(0, 1, linear_filter ? m_linear_sampler.GetAddressOf() : m_point_sampler.GetAddressOf());
+
+  const float uniforms[4] = {static_cast<float>(texture_view_x) / static_cast<float>(texture_width),
+                             static_cast<float>(texture_view_y) / static_cast<float>(texture_height),
+                             (static_cast<float>(texture_view_width) - 0.5f) / static_cast<float>(texture_width),
+                             (static_cast<float>(texture_view_height) - 0.5f) / static_cast<float>(texture_height)};
+  const auto map = m_display_uniform_buffer.Map(m_context.Get(), sizeof(uniforms), sizeof(uniforms));
+  std::memcpy(map.pointer, uniforms, sizeof(uniforms));
+  m_display_uniform_buffer.Unmap(m_context.Get(), sizeof(uniforms));
+  m_context->VSSetConstantBuffers(0, 1, m_display_uniform_buffer.GetD3DBufferArray());
+
+  const CD3D11_VIEWPORT vp(static_cast<float>(left), static_cast<float>(top), static_cast<float>(width),
+                           static_cast<float>(height));
+  m_context->RSSetViewports(1, &vp);
+  m_context->RSSetState(m_display_rasterizer_state.Get());
+  m_context->OMSetDepthStencilState(m_display_depth_stencil_state.Get(), 0);
+  m_context->OMSetBlendState(m_display_blend_state.Get(), nullptr, 0xFFFFFFFFu);
+
+  m_context->Draw(3, 0);
+}
+
+void D3D11HostDisplay::RenderSoftwareCursor(s32 left, s32 top, s32 width, s32 height,
+                                            HostDisplayTexture* texture_handle)
+{
+  m_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+  m_context->VSSetShader(m_display_vertex_shader.Get(), nullptr, 0);
+  m_context->PSSetShader(m_display_pixel_shader.Get(), nullptr, 0);
+  m_context->PSSetShaderResources(0, 1, static_cast<D3D11HostDisplayTexture*>(texture_handle)->GetD3DSRVArray());
+  m_context->PSSetSamplers(0, 1, m_linear_sampler.GetAddressOf());
+
+  const float uniforms[4] = {0.0f, 0.0f, 1.0f, 1.0f};
+  const auto map = m_display_uniform_buffer.Map(m_context.Get(), sizeof(uniforms), sizeof(uniforms));
+  std::memcpy(map.pointer, uniforms, sizeof(uniforms));
+  m_display_uniform_buffer.Unmap(m_context.Get(), sizeof(uniforms));
+  m_context->VSSetConstantBuffers(0, 1, m_display_uniform_buffer.GetD3DBufferArray());
+
+  const CD3D11_VIEWPORT vp(static_cast<float>(left), static_cast<float>(top), static_cast<float>(width),
+                           static_cast<float>(height));
+  m_context->RSSetViewports(1, &vp);
+  m_context->RSSetState(m_display_rasterizer_state.Get());
+  m_context->OMSetDepthStencilState(m_display_depth_stencil_state.Get(), 0);
+  m_context->OMSetBlendState(m_software_cursor_blend_state.Get(), nullptr, 0xFFFFFFFFu);
+
+  m_context->Draw(3, 0);
+}
+
+} // namespace FrontendCommon

src/frontend-common/d3d11_host_display.h

@@ -0,0 +1,98 @@
+#pragma once
+#include "common/d3d11/staging_texture.h"
+#include "common/d3d11/stream_buffer.h"
+#include "common/d3d11/texture.h"
+#include "common/window_info.h"
+#include "common/windows_headers.h"
+#include "core/host_display.h"
+#include <d3d11.h>
+#include <dxgi.h>
+#include <memory>
+#include <wrl/client.h>
+
+namespace FrontendCommon {
+
+class D3D11HostDisplay final
+{
+public:
+  template<typename T>
+  using ComPtr = Microsoft::WRL::ComPtr<T>;
+
+  D3D11HostDisplay();
+  ~D3D11HostDisplay();
+
+  ALWAYS_INLINE HostDisplay::RenderAPI GetRenderAPI() const { return HostDisplay::RenderAPI::D3D11; }
+  ALWAYS_INLINE void* GetRenderDevice() const { return m_device.Get(); }
+  ALWAYS_INLINE void* GetRenderContext() const { return m_context.Get(); }
+
+  bool CreateContextAndSwapChain(const WindowInfo& wi, bool use_flip_model, bool debug_device);
+  bool HasContext() const;
+  void DestroyContext();
+
+  bool CreateResources();
+  void DestroyResources();
+
+  bool CreateImGuiContext();
+  void DestroyImGuiContext();
+
+  ALWAYS_INLINE u32 GetSwapChainWidth() const { return m_swap_chain_width; }
+  ALWAYS_INLINE u32 GetSwapChainHeight() const { return m_swap_chain_height; }
+  ALWAYS_INLINE bool HasSwapChain() const { return static_cast<bool>(m_swap_chain); }
+
+  bool RecreateSwapChain(const WindowInfo& new_wi, bool use_flip_model);
+  void ResizeSwapChain(u32 new_width, u32 new_height);
+  void DestroySwapChain();
+
+  std::unique_ptr<HostDisplayTexture> CreateTexture(u32 width, u32 height, const void* initial_data,
+                                                    u32 initial_data_stride, bool dynamic);
+  void UpdateTexture(HostDisplayTexture* texture, u32 x, u32 y, u32 width, u32 height, const void* texture_data,
+                     u32 texture_data_stride);
+  bool DownloadTexture(const void* texture_handle, u32 x, u32 y, u32 width, u32 height, void* out_data,
+                       u32 out_data_stride);
+
+  void SetVSync(bool enabled);
+
+  bool BeginRender();
+  void RenderDisplay(s32 left, s32 top, s32 width, s32 height, void* texture_handle, u32 texture_width,
+                     u32 texture_height, u32 texture_view_x, u32 texture_view_y, u32 texture_view_width,
+                     u32 texture_view_height, bool linear_filter);
+  void RenderImGui();
+  void RenderSoftwareCursor(s32 left, s32 top, s32 width, s32 height, HostDisplayTexture* texture_handle);
+  void EndRenderAndPresent();
+
+private:
+  static constexpr u32 DISPLAY_UNIFORM_BUFFER_SIZE = 16;
+
+  bool CreateSwapChain(const WindowInfo& new_wi, bool use_flip_model);
+  bool CreateSwapChainRTV();
+
+  ComPtr<IDXGIFactory> m_dxgi_factory;
+
+  ComPtr<ID3D11Device> m_device;
+  ComPtr<ID3D11DeviceContext> m_context;
+  ComPtr<IDXGISwapChain> m_swap_chain;
+  ComPtr<ID3D11RenderTargetView> m_swap_chain_rtv;
+
+  ComPtr<ID3D11RasterizerState> m_display_rasterizer_state;
+  ComPtr<ID3D11DepthStencilState> m_display_depth_stencil_state;
+  ComPtr<ID3D11BlendState> m_display_blend_state;
+  ComPtr<ID3D11BlendState> m_software_cursor_blend_state;
+  ComPtr<ID3D11VertexShader> m_display_vertex_shader;
+  ComPtr<ID3D11PixelShader> m_display_pixel_shader;
+  ComPtr<ID3D11SamplerState> m_point_sampler;
+  ComPtr<ID3D11SamplerState> m_linear_sampler;
+
+  D3D11::Texture m_display_pixels_texture;
+  D3D11::StreamBuffer m_display_uniform_buffer;
+  D3D11::AutoStagingTexture m_readback_staging_texture;
+
+  u32 m_swap_chain_width = 0;
+  u32 m_swap_chain_height = 0;
+
+  bool m_allow_tearing_supported = false;
+  bool m_using_flip_model_swap_chain = true;
+  bool m_using_allow_tearing = false;
+  bool m_vsync = true;
+};
+
+} // namespace FrontendCommon

src/frontend-common/frontend-common.vcxproj

@@ -63,6 +63,7 @@
   <ItemGroup>
     <ClCompile Include="common_host_interface.cpp" />
     <ClCompile Include="controller_interface.cpp" />
+    <ClCompile Include="d3d11_host_display.cpp" />
     <ClCompile Include="icon.cpp" />
     <ClCompile Include="imgui_styles.cpp" />
     <ClCompile Include="ini_settings_interface.cpp" />
@@ -75,6 +76,7 @@
   <ItemGroup>
     <ClInclude Include="common_host_interface.h" />
     <ClInclude Include="controller_interface.h" />
+    <ClInclude Include="d3d11_host_display.h" />
     <ClInclude Include="icon.h" />
     <ClInclude Include="imgui_styles.h" />
     <ClInclude Include="ini_settings_interface.h" />

src/frontend-common/frontend-common.vcxproj.filters

@@ -11,6 +11,7 @@
     <ClCompile Include="controller_interface.cpp" />
     <ClCompile Include="save_state_selector_ui.cpp" />
     <ClCompile Include="vulkan_host_display.cpp" />
+    <ClCompile Include="d3d11_host_display.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="icon.h" />
@@ -23,6 +24,7 @@
     <ClInclude Include="controller_interface.h" />
     <ClInclude Include="save_state_selector_ui.h" />
     <ClInclude Include="vulkan_host_display.h" />
+    <ClInclude Include="d3d11_host_display.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="font_roboto_regular.inl" />