diff --git a/src/frontend-common/CMakeLists.txt b/src/frontend-common/CMakeLists.txt index c70ce8ae3..ca3e649a8 100644 --- a/src/frontend-common/CMakeLists.txt +++ b/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 diff --git a/src/frontend-common/d3d11_host_display.cpp b/src/frontend-common/d3d11_host_display.cpp new file mode 100644 index 000000000..9bc9c0383 --- /dev/null +++ b/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 +#include +#include +#include +Log_SetChannel(D3D11HostDisplay); + +namespace FrontendCommon { + +class D3D11HostDisplayTexture : public HostDisplayTexture +{ +public: + template + using ComPtr = Microsoft::WRL::ComPtr; + + D3D11HostDisplayTexture(ComPtr texture, ComPtr 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 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 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 srv; + hr = device->CreateShaderResourceView(texture.Get(), &srv_desc, srv.GetAddressOf()); + if (FAILED(hr)) + return {}; + + return std::make_unique(std::move(texture), std::move(srv), width, height, dynamic); + } + +private: + ComPtr m_texture; + ComPtr m_srv; + u32 m_width; + u32 m_height; + bool m_dynamic; +}; + +D3D11HostDisplay::D3D11HostDisplay() = default; + +D3D11HostDisplay::~D3D11HostDisplay() = default; + +std::unique_ptr 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(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(sr.pData) + (y * sr.RowPitch) + (x * sizeof(u32)); + const char* src_ptr = static_cast(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(static_cast(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(m_context.Get(), 0, 0, width, height, out_data_stride / sizeof(u32), + static_cast(out_data)); +} + +void D3D11HostDisplay::SetVSync(bool enabled) +{ + m_vsync = enabled; +} + +bool D3D11HostDisplay::HasContext() const +{ + return static_cast(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 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 dxgi_device; + ComPtr 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(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 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(new_wi.window_handle); + RECT client_rc{}; + GetClientRect(window_hwnd, &client_rc); + const u32 width = static_cast(client_rc.right - client_rc.left); + const u32 height = static_cast(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 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(m_swap_chain_width); + ImGui::GetIO().DisplaySize.y = static_cast(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 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(&texture_handle)); + m_context->PSSetSamplers(0, 1, linear_filter ? m_linear_sampler.GetAddressOf() : m_point_sampler.GetAddressOf()); + + const float uniforms[4] = {static_cast(texture_view_x) / static_cast(texture_width), + static_cast(texture_view_y) / static_cast(texture_height), + (static_cast(texture_view_width) - 0.5f) / static_cast(texture_width), + (static_cast(texture_view_height) - 0.5f) / static_cast(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(left), static_cast(top), static_cast(width), + static_cast(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(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(left), static_cast(top), static_cast(width), + static_cast(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 \ No newline at end of file diff --git a/src/frontend-common/d3d11_host_display.h b/src/frontend-common/d3d11_host_display.h new file mode 100644 index 000000000..e086107c2 --- /dev/null +++ b/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 +#include +#include +#include + +namespace FrontendCommon { + +class D3D11HostDisplay final +{ +public: + template + using ComPtr = Microsoft::WRL::ComPtr; + + 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(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 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 m_dxgi_factory; + + ComPtr m_device; + ComPtr m_context; + ComPtr m_swap_chain; + ComPtr m_swap_chain_rtv; + + ComPtr m_display_rasterizer_state; + ComPtr m_display_depth_stencil_state; + ComPtr m_display_blend_state; + ComPtr m_software_cursor_blend_state; + ComPtr m_display_vertex_shader; + ComPtr m_display_pixel_shader; + ComPtr m_point_sampler; + ComPtr 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 diff --git a/src/frontend-common/frontend-common.vcxproj b/src/frontend-common/frontend-common.vcxproj index 983918f48..00be65a23 100644 --- a/src/frontend-common/frontend-common.vcxproj +++ b/src/frontend-common/frontend-common.vcxproj @@ -63,6 +63,7 @@ + @@ -75,6 +76,7 @@ + diff --git a/src/frontend-common/frontend-common.vcxproj.filters b/src/frontend-common/frontend-common.vcxproj.filters index 93791c9ee..d16067b62 100644 --- a/src/frontend-common/frontend-common.vcxproj.filters +++ b/src/frontend-common/frontend-common.vcxproj.filters @@ -11,6 +11,7 @@ + @@ -23,6 +24,7 @@ +