282adfc70b
Changes the GraphicsContext to be managed by the GPU core. This eliminates the need for the frontends to fool around with tricky MakeCurrent/DoneCurrent calls that are dependent on the settings (such as async gpu option). This also refactors out the need to use QWidget::fromWindowContainer as that caused issues with focus and input handling. Now we use a regular QWidget and just access the native windowHandle() directly. Another change is removing the debug tool setting in FrameMailbox. Instead of trying to block the frontend until a new frame is ready, the core will now take over presentation and draw directly to the window if the renderer detects that its hooked by NSight or RenderDoc Lastly, since it was in the way, I removed ScopeAcquireWindowContext and replaced it with a simple subclass in GraphicsContext that achieves the same result
107 lines
2.8 KiB
C++
107 lines
2.8 KiB
C++
// Copyright 2014 Citra Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <atomic>
|
|
#include <memory>
|
|
#include <optional>
|
|
|
|
#include "common/common_types.h"
|
|
#include "core/frontend/emu_window.h"
|
|
#include "video_core/gpu.h"
|
|
#include "video_core/rasterizer_interface.h"
|
|
|
|
namespace Core::Frontend {
|
|
class EmuWindow;
|
|
}
|
|
|
|
namespace VideoCore {
|
|
|
|
struct RendererSettings {
|
|
std::atomic_bool use_framelimiter{false};
|
|
std::atomic_bool set_background_color{false};
|
|
|
|
// Screenshot
|
|
std::atomic<bool> screenshot_requested{false};
|
|
void* screenshot_bits;
|
|
std::function<void()> screenshot_complete_callback;
|
|
Layout::FramebufferLayout screenshot_framebuffer_layout;
|
|
};
|
|
|
|
class RendererBase : NonCopyable {
|
|
public:
|
|
explicit RendererBase(Core::Frontend::EmuWindow& window);
|
|
virtual ~RendererBase();
|
|
|
|
/// Initialize the renderer
|
|
virtual bool Init() = 0;
|
|
|
|
/// Shutdown the renderer
|
|
virtual void ShutDown() = 0;
|
|
|
|
/// Finalize rendering the guest frame and draw into the presentation texture
|
|
virtual void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) = 0;
|
|
|
|
/// Draws the latest frame to the window waiting timeout_ms for a frame to arrive (Renderer
|
|
/// specific implementation)
|
|
/// Returns true if a frame was drawn
|
|
virtual bool TryPresent(int timeout_ms) = 0;
|
|
|
|
// Getter/setter functions:
|
|
// ------------------------
|
|
|
|
f32 GetCurrentFPS() const {
|
|
return m_current_fps;
|
|
}
|
|
|
|
int GetCurrentFrame() const {
|
|
return m_current_frame;
|
|
}
|
|
|
|
RasterizerInterface& Rasterizer() {
|
|
return *rasterizer;
|
|
}
|
|
|
|
const RasterizerInterface& Rasterizer() const {
|
|
return *rasterizer;
|
|
}
|
|
|
|
Core::Frontend::EmuWindow& GetRenderWindow() {
|
|
return render_window;
|
|
}
|
|
|
|
const Core::Frontend::EmuWindow& GetRenderWindow() const {
|
|
return render_window;
|
|
}
|
|
|
|
RendererSettings& Settings() {
|
|
return renderer_settings;
|
|
}
|
|
|
|
const RendererSettings& Settings() const {
|
|
return renderer_settings;
|
|
}
|
|
|
|
/// Refreshes the settings common to all renderers
|
|
void RefreshBaseSettings();
|
|
|
|
/// Request a screenshot of the next frame
|
|
void RequestScreenshot(void* data, std::function<void()> callback,
|
|
const Layout::FramebufferLayout& layout);
|
|
|
|
protected:
|
|
Core::Frontend::EmuWindow& render_window; ///< Reference to the render window handle.
|
|
std::unique_ptr<RasterizerInterface> rasterizer;
|
|
f32 m_current_fps = 0.0f; ///< Current framerate, should be set by the renderer
|
|
int m_current_frame = 0; ///< Current frame, should be set by the renderer
|
|
|
|
RendererSettings renderer_settings;
|
|
|
|
private:
|
|
/// Updates the framebuffer layout of the contained render window handle.
|
|
void UpdateCurrentFramebufferLayout();
|
|
};
|
|
|
|
} // namespace VideoCore
|