From 89dd7dc1802cc53e828cb71c1f3e2bc0879459ce Mon Sep 17 00:00:00 2001 From: Liam Date: Sun, 27 Nov 2022 20:37:37 -0500 Subject: video_core: add null backend --- src/common/settings.h | 3 +- src/core/telemetry_session.cpp | 2 + src/video_core/CMakeLists.txt | 4 ++ src/video_core/renderer_null/null_rasterizer.cpp | 90 ++++++++++++++++++++++++ src/video_core/renderer_null/null_rasterizer.h | 78 ++++++++++++++++++++ src/video_core/renderer_null/renderer_null.cpp | 24 +++++++ src/video_core/renderer_null/renderer_null.h | 36 ++++++++++ src/video_core/video_core.cpp | 4 ++ src/yuzu/bootmanager.cpp | 18 +++-- src/yuzu/bootmanager.h | 1 + src/yuzu/configuration/configure_graphics.cpp | 5 ++ src/yuzu/configuration/configure_graphics.ui | 5 ++ src/yuzu/main.cpp | 52 ++++++++------ src/yuzu/main.h | 2 + src/yuzu_cmd/CMakeLists.txt | 2 + src/yuzu_cmd/emu_window/emu_window_sdl2.h | 2 + src/yuzu_cmd/emu_window/emu_window_sdl2_null.cpp | 51 ++++++++++++++ src/yuzu_cmd/emu_window/emu_window_sdl2_null.h | 26 +++++++ src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h | 2 - src/yuzu_cmd/yuzu.cpp | 4 ++ 20 files changed, 383 insertions(+), 28 deletions(-) create mode 100644 src/video_core/renderer_null/null_rasterizer.cpp create mode 100644 src/video_core/renderer_null/null_rasterizer.h create mode 100644 src/video_core/renderer_null/renderer_null.cpp create mode 100644 src/video_core/renderer_null/renderer_null.h create mode 100644 src/yuzu_cmd/emu_window/emu_window_sdl2_null.cpp create mode 100644 src/yuzu_cmd/emu_window/emu_window_sdl2_null.h diff --git a/src/common/settings.h b/src/common/settings.h index 00e4421f7..c0620066c 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -19,6 +19,7 @@ namespace Settings { enum class RendererBackend : u32 { OpenGL = 0, Vulkan = 1, + Null = 2, }; enum class ShaderBackend : u32 { @@ -411,7 +412,7 @@ struct Values { // Renderer SwitchableSetting renderer_backend{ - RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"}; + RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"}; Setting renderer_debug{false, "debug"}; Setting renderer_shader_feedback{false, "shader_feedback"}; Setting enable_nsight_aftermath{false, "nsight_aftermath"}; diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp index abcf6eb11..8d5f2be2f 100644 --- a/src/core/telemetry_session.cpp +++ b/src/core/telemetry_session.cpp @@ -55,6 +55,8 @@ static const char* TranslateRenderer(Settings::RendererBackend backend) { return "OpenGL"; case Settings::RendererBackend::Vulkan: return "Vulkan"; + case Settings::RendererBackend::Null: + return "Null"; } return "Unknown"; } diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt index b03a30992..0d6bf1f0d 100644 --- a/src/video_core/CMakeLists.txt +++ b/src/video_core/CMakeLists.txt @@ -91,6 +91,10 @@ add_library(video_core STATIC rasterizer_interface.h renderer_base.cpp renderer_base.h + renderer_null/null_rasterizer.cpp + renderer_null/null_rasterizer.h + renderer_null/renderer_null.cpp + renderer_null/renderer_null.h renderer_opengl/gl_buffer_cache.cpp renderer_opengl/gl_buffer_cache.h renderer_opengl/gl_compute_pipeline.cpp diff --git a/src/video_core/renderer_null/null_rasterizer.cpp b/src/video_core/renderer_null/null_rasterizer.cpp new file mode 100644 index 000000000..9734d84bc --- /dev/null +++ b/src/video_core/renderer_null/null_rasterizer.cpp @@ -0,0 +1,90 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "video_core/host1x/host1x.h" +#include "video_core/memory_manager.h" +#include "video_core/renderer_null/null_rasterizer.h" + +namespace Null { + +AccelerateDMA::AccelerateDMA() = default; + +bool AccelerateDMA::BufferCopy(GPUVAddr start_address, GPUVAddr end_address, u64 amount) { + return true; +} +bool AccelerateDMA::BufferClear(GPUVAddr src_address, u64 amount, u32 value) { + return true; +} + +RasterizerNull::RasterizerNull(Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu) + : RasterizerAccelerated(cpu_memory_), m_gpu{gpu} {} +RasterizerNull::~RasterizerNull() = default; + +void RasterizerNull::Draw(bool is_indexed, u32 instance_count) {} +void RasterizerNull::Clear(u32 layer_count) {} +void RasterizerNull::DispatchCompute() {} +void RasterizerNull::ResetCounter(VideoCore::QueryType type) {} +void RasterizerNull::Query(GPUVAddr gpu_addr, VideoCore::QueryType type, + std::optional timestamp) { + if (!gpu_memory) { + return; + } + + gpu_memory->Write(gpu_addr, u64{0}); + if (timestamp) { + gpu_memory->Write(gpu_addr + 8, *timestamp); + } +} +void RasterizerNull::BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr, + u32 size) {} +void RasterizerNull::DisableGraphicsUniformBuffer(size_t stage, u32 index) {} +void RasterizerNull::FlushAll() {} +void RasterizerNull::FlushRegion(VAddr addr, u64 size) {} +bool RasterizerNull::MustFlushRegion(VAddr addr, u64 size) { + return false; +} +void RasterizerNull::InvalidateRegion(VAddr addr, u64 size) {} +void RasterizerNull::OnCPUWrite(VAddr addr, u64 size) {} +void RasterizerNull::InvalidateGPUCache() {} +void RasterizerNull::UnmapMemory(VAddr addr, u64 size) {} +void RasterizerNull::ModifyGPUMemory(size_t as_id, GPUVAddr addr, u64 size) {} +void RasterizerNull::SignalFence(std::function&& func) { + func(); +} +void RasterizerNull::SyncOperation(std::function&& func) { + func(); +} +void RasterizerNull::SignalSyncPoint(u32 value) { + auto& syncpoint_manager = m_gpu.Host1x().GetSyncpointManager(); + syncpoint_manager.IncrementGuest(value); + syncpoint_manager.IncrementHost(value); +} +void RasterizerNull::SignalReference() {} +void RasterizerNull::ReleaseFences() {} +void RasterizerNull::FlushAndInvalidateRegion(VAddr addr, u64 size) {} +void RasterizerNull::WaitForIdle() {} +void RasterizerNull::FragmentBarrier() {} +void RasterizerNull::TiledCacheBarrier() {} +void RasterizerNull::FlushCommands() {} +void RasterizerNull::TickFrame() {} +Tegra::Engines::AccelerateDMAInterface& RasterizerNull::AccessAccelerateDMA() { + return m_accelerate_dma; +} +bool RasterizerNull::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surface& src, + const Tegra::Engines::Fermi2D::Surface& dst, + const Tegra::Engines::Fermi2D::Config& copy_config) { + return true; +} +void RasterizerNull::AccelerateInlineToMemory(GPUVAddr address, size_t copy_size, + std::span memory) {} +bool RasterizerNull::AccelerateDisplay(const Tegra::FramebufferConfig& config, + VAddr framebuffer_addr, u32 pixel_stride) { + return true; +} +void RasterizerNull::LoadDiskResources(u64 title_id, std::stop_token stop_loading, + const VideoCore::DiskResourceLoadCallback& callback) {} +void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {} +void RasterizerNull::BindChannel(Tegra::Control::ChannelState& channel) {} +void RasterizerNull::ReleaseChannel(s32 channel_id) {} + +} // namespace Null diff --git a/src/video_core/renderer_null/null_rasterizer.h b/src/video_core/renderer_null/null_rasterizer.h new file mode 100644 index 000000000..ecf77ba42 --- /dev/null +++ b/src/video_core/renderer_null/null_rasterizer.h @@ -0,0 +1,78 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/common_types.h" +#include "video_core/control/channel_state_cache.h" +#include "video_core/engines/maxwell_dma.h" +#include "video_core/rasterizer_accelerated.h" +#include "video_core/rasterizer_interface.h" + +namespace Core { +class System; +} + +namespace Null { + +class RasterizerNull; + +class AccelerateDMA : public Tegra::Engines::AccelerateDMAInterface { +public: + explicit AccelerateDMA(); + bool BufferCopy(GPUVAddr start_address, GPUVAddr end_address, u64 amount) override; + bool BufferClear(GPUVAddr src_address, u64 amount, u32 value) override; +}; + +class RasterizerNull final : public VideoCore::RasterizerAccelerated, + protected VideoCommon::ChannelSetupCaches { +public: + explicit RasterizerNull(Core::Memory::Memory& cpu_memory, Tegra::GPU& gpu); + ~RasterizerNull() override; + + void Draw(bool is_indexed, u32 instance_count) override; + void Clear(u32 layer_count) override; + void DispatchCompute() override; + void ResetCounter(VideoCore::QueryType type) override; + void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional timestamp) override; + void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr, u32 size) override; + void DisableGraphicsUniformBuffer(size_t stage, u32 index) override; + void FlushAll() override; + void FlushRegion(VAddr addr, u64 size) override; + bool MustFlushRegion(VAddr addr, u64 size) override; + void InvalidateRegion(VAddr addr, u64 size) override; + void OnCPUWrite(VAddr addr, u64 size) override; + void InvalidateGPUCache() override; + void UnmapMemory(VAddr addr, u64 size) override; + void ModifyGPUMemory(size_t as_id, GPUVAddr addr, u64 size) override; + void SignalFence(std::function&& func) override; + void SyncOperation(std::function&& func) override; + void SignalSyncPoint(u32 value) override; + void SignalReference() override; + void ReleaseFences() override; + void FlushAndInvalidateRegion(VAddr addr, u64 size) override; + void WaitForIdle() override; + void FragmentBarrier() override; + void TiledCacheBarrier() override; + void FlushCommands() override; + void TickFrame() override; + bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surface& src, + const Tegra::Engines::Fermi2D::Surface& dst, + const Tegra::Engines::Fermi2D::Config& copy_config) override; + Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override; + void AccelerateInlineToMemory(GPUVAddr address, size_t copy_size, + std::span memory) override; + bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr, + u32 pixel_stride) override; + void LoadDiskResources(u64 title_id, std::stop_token stop_loading, + const VideoCore::DiskResourceLoadCallback& callback) override; + void InitializeChannel(Tegra::Control::ChannelState& channel) override; + void BindChannel(Tegra::Control::ChannelState& channel) override; + void ReleaseChannel(s32 channel_id) override; + +private: + Tegra::GPU& m_gpu; + AccelerateDMA m_accelerate_dma; +}; + +} // namespace Null diff --git a/src/video_core/renderer_null/renderer_null.cpp b/src/video_core/renderer_null/renderer_null.cpp new file mode 100644 index 000000000..e2a189b63 --- /dev/null +++ b/src/video_core/renderer_null/renderer_null.cpp @@ -0,0 +1,24 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "video_core/renderer_null/renderer_null.h" + +namespace Null { + +RendererNull::RendererNull(Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory, + Tegra::GPU& gpu, + std::unique_ptr context_) + : RendererBase(emu_window, std::move(context_)), m_gpu(gpu), m_rasterizer(cpu_memory, gpu) {} + +RendererNull::~RendererNull() = default; + +void RendererNull::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) { + if (!framebuffer) { + return; + } + + m_gpu.RendererFrameEndNotify(); + render_window.OnFrameDisplayed(); +} + +} // namespace Null diff --git a/src/video_core/renderer_null/renderer_null.h b/src/video_core/renderer_null/renderer_null.h new file mode 100644 index 000000000..967ff5645 --- /dev/null +++ b/src/video_core/renderer_null/renderer_null.h @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include + +#include "video_core/renderer_base.h" +#include "video_core/renderer_null/null_rasterizer.h" + +namespace Null { + +class RendererNull final : public VideoCore::RendererBase { +public: + explicit RendererNull(Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory, + Tegra::GPU& gpu, + std::unique_ptr context); + ~RendererNull() override; + + void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override; + + VideoCore::RasterizerInterface* ReadRasterizer() override { + return &m_rasterizer; + } + + [[nodiscard]] std::string GetDeviceVendor() const override { + return "NULL"; + } + +private: + Tegra::GPU& m_gpu; + RasterizerNull m_rasterizer; +}; + +} // namespace Null diff --git a/src/video_core/video_core.cpp b/src/video_core/video_core.cpp index 04ac4af11..fedb4a7bb 100644 --- a/src/video_core/video_core.cpp +++ b/src/video_core/video_core.cpp @@ -7,6 +7,7 @@ #include "common/settings.h" #include "core/core.h" #include "video_core/renderer_base.h" +#include "video_core/renderer_null/renderer_null.h" #include "video_core/renderer_opengl/renderer_opengl.h" #include "video_core/renderer_vulkan/renderer_vulkan.h" #include "video_core/video_core.h" @@ -26,6 +27,9 @@ std::unique_ptr CreateRenderer( case Settings::RendererBackend::Vulkan: return std::make_unique(telemetry_session, emu_window, cpu_memory, gpu, std::move(context)); + case Settings::RendererBackend::Null: + return std::make_unique(emu_window, cpu_memory, gpu, + std::move(context)); default: return nullptr; } diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp index c934069dd..f140e951f 100644 --- a/src/yuzu/bootmanager.cpp +++ b/src/yuzu/bootmanager.cpp @@ -237,8 +237,7 @@ private: GRenderWindow* render_window; }; -class OpenGLRenderWidget : public RenderWidget { -public: +struct OpenGLRenderWidget : public RenderWidget { explicit OpenGLRenderWidget(GRenderWindow* parent) : RenderWidget(parent) { windowHandle()->setSurfaceType(QWindow::OpenGLSurface); } @@ -251,13 +250,16 @@ private: std::unique_ptr context; }; -class VulkanRenderWidget : public RenderWidget { -public: +struct VulkanRenderWidget : public RenderWidget { explicit VulkanRenderWidget(GRenderWindow* parent) : RenderWidget(parent) { windowHandle()->setSurfaceType(QWindow::VulkanSurface); } }; +struct NullRenderWidget : public RenderWidget { + explicit NullRenderWidget(GRenderWindow* parent) : RenderWidget(parent) {} +}; + static Core::Frontend::WindowSystemType GetWindowSystemType() { // Determine WSI type based on Qt platform. QString platform_name = QGuiApplication::platformName(); @@ -874,6 +876,9 @@ bool GRenderWindow::InitRenderTarget() { return false; } break; + case Settings::RendererBackend::Null: + InitializeNull(); + break; } // Update the Window System information with the new render target @@ -970,6 +975,11 @@ bool GRenderWindow::InitializeVulkan() { return true; } +void GRenderWindow::InitializeNull() { + child_widget = new NullRenderWidget(this); + main_context = std::make_unique(); +} + bool GRenderWindow::LoadOpenGL() { auto context = CreateSharedContext(); auto scope = context->Acquire(); diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h index 4a01481cd..2e19a879e 100644 --- a/src/yuzu/bootmanager.h +++ b/src/yuzu/bootmanager.h @@ -218,6 +218,7 @@ private: bool InitializeOpenGL(); bool InitializeVulkan(); + void InitializeNull(); bool LoadOpenGL(); QStringList GetUnsupportedGLExtensions() const; diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp index f1385e972..4a875f86a 100644 --- a/src/yuzu/configuration/configure_graphics.cpp +++ b/src/yuzu/configuration/configure_graphics.cpp @@ -260,6 +260,7 @@ void ConfigureGraphics::ApplyConfiguration() { Settings::values.renderer_backend.SetValue(GetCurrentGraphicsBackend()); switch (GetCurrentGraphicsBackend()) { case Settings::RendererBackend::OpenGL: + case Settings::RendererBackend::Null: Settings::values.shader_backend.SetGlobal(false); Settings::values.vulkan_device.SetGlobal(true); Settings::values.shader_backend.SetValue(shader_backend); @@ -348,6 +349,10 @@ void ConfigureGraphics::UpdateAPILayout() { ui->device_widget->setVisible(true); ui->backend_widget->setVisible(false); break; + case Settings::RendererBackend::Null: + ui->device_widget->setVisible(false); + ui->backend_widget->setVisible(false); + break; } } diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui index 37271f956..f78396690 100644 --- a/src/yuzu/configuration/configure_graphics.ui +++ b/src/yuzu/configuration/configure_graphics.ui @@ -139,6 +139,11 @@ Vulkan + + + None + + diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp index 2aae746f0..be13024c6 100644 --- a/src/yuzu/main.cpp +++ b/src/yuzu/main.cpp @@ -1007,29 +1007,11 @@ void GMainWindow::InitializeWidgets() { renderer_status_button->setObjectName(QStringLiteral("RendererStatusBarButton")); renderer_status_button->setCheckable(true); renderer_status_button->setFocusPolicy(Qt::NoFocus); - connect(renderer_status_button, &QPushButton::toggled, [this](bool checked) { - renderer_status_button->setText(checked ? tr("VULKAN") : tr("OPENGL")); - }); - renderer_status_button->toggle(); - + connect(renderer_status_button, &QPushButton::clicked, this, &GMainWindow::OnToggleGraphicsAPI); + UpdateAPIText(); + renderer_status_button->setCheckable(true); renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::Vulkan); - connect(renderer_status_button, &QPushButton::clicked, [this] { - if (emulation_running) { - return; - } - if (renderer_status_button->isChecked()) { - Settings::values.renderer_backend.SetValue(Settings::RendererBackend::Vulkan); - } else { - Settings::values.renderer_backend.SetValue(Settings::RendererBackend::OpenGL); - if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) { - Settings::values.scaling_filter.SetValue(Settings::ScalingFilter::NearestNeighbor); - UpdateFilterText(); - } - } - - system->ApplySettings(); - }); statusBar()->insertPermanentWidget(0, renderer_status_button); statusBar()->setVisible(true); @@ -3248,6 +3230,18 @@ void GMainWindow::OnToggleAdaptingFilter() { UpdateFilterText(); } +void GMainWindow::OnToggleGraphicsAPI() { + auto api = Settings::values.renderer_backend.GetValue(); + if (api == Settings::RendererBackend::OpenGL) { + api = Settings::RendererBackend::Vulkan; + } else { + api = Settings::RendererBackend::OpenGL; + } + Settings::values.renderer_backend.SetValue(api); + renderer_status_button->setChecked(api == Settings::RendererBackend::Vulkan); + UpdateAPIText(); +} + void GMainWindow::OnConfigurePerGame() { const u64 title_id = system->GetCurrentProcessProgramID(); OpenPerGameConfiguration(title_id, current_game_path.toStdString()); @@ -3568,6 +3562,21 @@ void GMainWindow::UpdateDockedButton() { dock_status_button->setText(is_docked ? tr("DOCKED") : tr("HANDHELD")); } +void GMainWindow::UpdateAPIText() { + const auto api = Settings::values.renderer_backend.GetValue(); + switch (api) { + case Settings::RendererBackend::OpenGL: + renderer_status_button->setText(tr("OPENGL")); + break; + case Settings::RendererBackend::Vulkan: + renderer_status_button->setText(tr("VULKAN")); + break; + case Settings::RendererBackend::Null: + renderer_status_button->setText(tr("NULL")); + break; + } +} + void GMainWindow::UpdateFilterText() { const auto filter = Settings::values.scaling_filter.GetValue(); switch (filter) { @@ -3613,6 +3622,7 @@ void GMainWindow::UpdateAAText() { void GMainWindow::UpdateStatusButtons() { renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::Vulkan); + UpdateAPIText(); UpdateGPUAccuracyButton(); UpdateDockedButton(); UpdateFilterText(); diff --git a/src/yuzu/main.h b/src/yuzu/main.h index 6a9992d05..af6fcec3c 100644 --- a/src/yuzu/main.h +++ b/src/yuzu/main.h @@ -307,6 +307,7 @@ private slots: void OnTasStartStop(); void OnTasRecord(); void OnTasReset(); + void OnToggleGraphicsAPI(); void OnToggleDockedMode(); void OnToggleGpuAccuracy(); void OnToggleAdaptingFilter(); @@ -347,6 +348,7 @@ private: void UpdateWindowTitle(std::string_view title_name = {}, std::string_view title_version = {}, std::string_view gpu_vendor = {}); void UpdateDockedButton(); + void UpdateAPIText(); void UpdateFilterText(); void UpdateAAText(); void UpdateStatusBar(); diff --git a/src/yuzu_cmd/CMakeLists.txt b/src/yuzu_cmd/CMakeLists.txt index 7d8ca3d8a..774d026aa 100644 --- a/src/yuzu_cmd/CMakeLists.txt +++ b/src/yuzu_cmd/CMakeLists.txt @@ -22,6 +22,8 @@ add_executable(yuzu-cmd emu_window/emu_window_sdl2.h emu_window/emu_window_sdl2_gl.cpp emu_window/emu_window_sdl2_gl.h + emu_window/emu_window_sdl2_null.cpp + emu_window/emu_window_sdl2_null.h emu_window/emu_window_sdl2_vk.cpp emu_window/emu_window_sdl2_vk.h yuzu.cpp diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.h b/src/yuzu_cmd/emu_window/emu_window_sdl2.h index 90bb0b415..25c23e2a5 100644 --- a/src/yuzu_cmd/emu_window/emu_window_sdl2.h +++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.h @@ -89,3 +89,5 @@ protected: /// yuzu core instance Core::System& system; }; + +class DummyContext : public Core::Frontend::GraphicsContext {}; diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_null.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2_null.cpp new file mode 100644 index 000000000..259192f3c --- /dev/null +++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_null.cpp @@ -0,0 +1,51 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include + +#include + +#include "common/logging/log.h" +#include "common/scm_rev.h" +#include "video_core/renderer_null/renderer_null.h" +#include "yuzu_cmd/emu_window/emu_window_sdl2_null.h" + +#ifdef YUZU_USE_EXTERNAL_SDL2 +// Include this before SDL.h to prevent the external from including a dummy +#define USING_GENERATED_CONFIG_H +#include +#endif + +#include + +EmuWindow_SDL2_Null::EmuWindow_SDL2_Null(InputCommon::InputSubsystem* input_subsystem_, + Core::System& system_, bool fullscreen) + : EmuWindow_SDL2{input_subsystem_, system_} { + const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name, + Common::g_scm_branch, Common::g_scm_desc); + render_window = + SDL_CreateWindow(window_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, + Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height, + SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI); + + SetWindowIcon(); + + if (fullscreen) { + Fullscreen(); + ShowCursor(false); + } + + OnResize(); + OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size); + SDL_PumpEvents(); + LOG_INFO(Frontend, "yuzu Version: {} | {}-{} (Null)", Common::g_build_name, + Common::g_scm_branch, Common::g_scm_desc); +} + +EmuWindow_SDL2_Null::~EmuWindow_SDL2_Null() = default; + +std::unique_ptr EmuWindow_SDL2_Null::CreateSharedContext() const { + return std::make_unique(); +} diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_null.h b/src/yuzu_cmd/emu_window/emu_window_sdl2_null.h new file mode 100644 index 000000000..35aee286d --- /dev/null +++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_null.h @@ -0,0 +1,26 @@ +// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "core/frontend/emu_window.h" +#include "yuzu_cmd/emu_window/emu_window_sdl2.h" + +namespace Core { +class System; +} + +namespace InputCommon { +class InputSubsystem; +} + +class EmuWindow_SDL2_Null final : public EmuWindow_SDL2 { +public: + explicit EmuWindow_SDL2_Null(InputCommon::InputSubsystem* input_subsystem_, + Core::System& system, bool fullscreen); + ~EmuWindow_SDL2_Null() override; + + std::unique_ptr CreateSharedContext() const override; +}; diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h index e39ad754d..9467d164a 100644 --- a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h +++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h @@ -24,5 +24,3 @@ public: std::unique_ptr CreateSharedContext() const override; }; - -class DummyContext : public Core::Frontend::GraphicsContext {}; diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp index dfe5a30ea..a80649703 100644 --- a/src/yuzu_cmd/yuzu.cpp +++ b/src/yuzu_cmd/yuzu.cpp @@ -34,6 +34,7 @@ #include "yuzu_cmd/config.h" #include "yuzu_cmd/emu_window/emu_window_sdl2.h" #include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h" +#include "yuzu_cmd/emu_window/emu_window_sdl2_null.h" #include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h" #ifdef _WIN32 @@ -317,6 +318,9 @@ int main(int argc, char** argv) { case Settings::RendererBackend::Vulkan: emu_window = std::make_unique(&input_subsystem, system, fullscreen); break; + case Settings::RendererBackend::Null: + emu_window = std::make_unique(&input_subsystem, system, fullscreen); + break; } system.SetContentProvider(std::make_unique()); -- cgit v1.2.3