557 Source/Core/VideoCommon/RenderBase.cpp
View file

Large diffs are not rendered by default.

86 Source/Core/VideoCommon/RenderBase.h
View file
@@ -40,6 +40,7 @@ class AbstractPipeline;
class AbstractShader;
class AbstractTexture;
class AbstractStagingTexture;
class NativeVertexFormat;
class PostProcessingShaderImplementation;
struct TextureConfig;
struct ComputePipelineConfig;
@@ -56,24 +57,14 @@ struct EfbPokeData

extern int frameCount;

enum class OSDMessage : s32
{
IRChanged = 1,
ARToggled = 2,
EFBCopyToggled = 3,
FogToggled = 4,
SpeedChanged = 5,
XFBChanged = 6,
VolumeChanged = 7,
};

// Renderer really isn't a very good name for this class - it's more like "Misc".
// The long term goal is to get rid of this class and replace it with others that make
// more sense.
class Renderer
{
public:
Renderer(int backbuffer_width, int backbuffer_height, AbstractTextureFormat backbuffer_format);
Renderer(int backbuffer_width, int backbuffer_height, float backbuffer_scale,
AbstractTextureFormat backbuffer_format);
virtual ~Renderer();

using ClearColor = std::array<float, 4>;
@@ -118,6 +109,14 @@ class Renderer
virtual void Draw(u32 base_vertex, u32 num_vertices) {}
virtual void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) {}

// Binds the backbuffer for rendering. The buffer will be cleared immediately after binding.
// This is where any window size changes are detected, therefore m_backbuffer_width and/or
// m_backbuffer_height may change after this function returns.
virtual void BindBackbuffer(const ClearColor& clear_color = {}) {}

// Presents the backbuffer to the window system, or "swaps buffers".
virtual void PresentBackbuffer() {}

// Shader modules/objects.
virtual std::unique_ptr<AbstractShader>
CreateShaderFromSource(ShaderStage stage, const char* source, size_t length) = 0;
@@ -135,6 +134,7 @@ class Renderer
// Display resolution
int GetBackbufferWidth() const { return m_backbuffer_width; }
int GetBackbufferHeight() const { return m_backbuffer_height; }
float GetBackbufferScale() const { return m_backbuffer_scale; }
void SetWindowSize(int width, int height);

// EFB coordinate conversion functions
@@ -166,7 +166,8 @@ class Renderer
void SaveScreenshot(const std::string& filename, bool wait_for_completion);
void DrawDebugText();

virtual void RenderText(const std::string& text, int left, int top, u32 color) = 0;
// ImGui initialization depends on being able to create textures and pipelines, so do it last.
bool InitializeImGui();

virtual void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z) = 0;
@@ -180,11 +181,18 @@ class Renderer
virtual u16 BBoxRead(int index) = 0;
virtual void BBoxWrite(int index, u16 value) = 0;

virtual void Flush() {}

// Finish up the current frame, print some stats
void Swap(u32 xfbAddr, u32 fbWidth, u32 fbStride, u32 fbHeight, const EFBRectangle& rc,
u64 ticks);
virtual void SwapImpl(AbstractTexture* texture, const EFBRectangle& rc, u64 ticks) = 0;
virtual void Flush() {}

// Draws the specified XFB buffer to the screen, performing any post-processing.
// Assumes that the backbuffer has already been bound and cleared.
virtual void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) {}

// Called when the configuration changes, and backend structures need to be updated.
virtual void OnConfigChanged(u32 bits) {}

PEControl::PixelFormat GetPrevPixelFormat() const { return m_prev_efb_format; }
void StorePixelFormat(PEControl::PixelFormat new_format) { m_prev_efb_format = new_format; }
@@ -197,17 +205,49 @@ class Renderer

virtual std::unique_ptr<VideoCommon::AsyncShaderCompiler> CreateAsyncShaderCompiler();

void ShowOSDMessage(OSDMessage message);
// Returns a lock for the ImGui mutex, enabling data structures to be modified from outside.
// Use with care, only non-drawing functions should be called from outside the video thread,
// as the drawing is tied to a "frame".
std::unique_lock<std::mutex> GetImGuiLock();

// Begins/presents a "UI frame". UI frames do not draw any of the console XFB, but this could
// change in the future.
void BeginUIFrame();
void EndUIFrame();

protected:
// Bitmask containing information about which configuration has changed for the backend.
enum ConfigChangeBits : u32
{
CONFIG_CHANGE_BIT_HOST_CONFIG = (1 << 0),
CONFIG_CHANGE_BIT_MULTISAMPLES = (1 << 1),
CONFIG_CHANGE_BIT_STEREO_MODE = (1 << 2),
CONFIG_CHANGE_BIT_TARGET_SIZE = (1 << 3),
CONFIG_CHANGE_BIT_ANISOTROPY = (1 << 4),
CONFIG_CHANGE_BIT_FORCE_TEXTURE_FILTERING = (1 << 5),
CONFIG_CHANGE_BIT_VSYNC = (1 << 6),
CONFIG_CHANGE_BIT_BBOX = (1 << 7)
};

std::tuple<int, int> CalculateTargetScale(int x, int y) const;
bool CalculateTargetSize();

bool CheckForHostConfigChanges();
void CheckForConfigChanges();

void CheckFifoRecording();
void RecordVideoMemory();

// Sets up ImGui state for the next frame.
// This function itself acquires the ImGui lock, so it should not be held.
void BeginImGuiFrame();

// Destroys all ImGui GPU resources, must do before shutdown.
void ShutdownImGui();

// Renders ImGui windows to the currently-bound framebuffer.
// Should be called with the ImGui lock held.
void RenderImGui();

// TODO: Remove the width/height parameters once we make the EFB an abstract framebuffer.
const AbstractFramebuffer* m_current_framebuffer = nullptr;
u32 m_current_framebuffer_width = 1;
@@ -226,6 +266,7 @@ class Renderer
// Backbuffer (window) size and render area
int m_backbuffer_width = 0;
int m_backbuffer_height = 0;
float m_backbuffer_scale = 1.0f;
AbstractTextureFormat m_backbuffer_format = AbstractTextureFormat::Undefined;
TargetRectangle m_target_rectangle = {};

@@ -238,8 +279,12 @@ class Renderer
Common::Flag m_surface_resized;
std::mutex m_swap_mutex;

u32 m_last_host_config_bits = 0;
u32 m_last_efb_multisamples = 1;
// ImGui resources.
std::unique_ptr<NativeVertexFormat> m_imgui_vertex_format;
std::vector<std::unique_ptr<AbstractTexture>> m_imgui_textures;
std::unique_ptr<AbstractPipeline> m_imgui_pipeline;
std::mutex m_imgui_mutex;
u64 m_imgui_last_frame_time;

private:
void RunFrameDumps();
@@ -284,9 +329,6 @@ class Renderer
u32 m_last_xfb_width = MAX_XFB_WIDTH;
u32 m_last_xfb_height = MAX_XFB_HEIGHT;

s32 m_osd_message = 0;
s32 m_osd_time = 0;

// NOTE: The methods below are called on the framedumping thread.
bool StartFrameDumpToAVI(const FrameDumpConfig& config);
void DumpFrameToAVI(const FrameDumpConfig& config);
28 Source/Core/VideoCommon/RenderState.cpp
View file
@@ -199,13 +199,27 @@ SamplerState& SamplerState::operator=(const SamplerState& rhs)

namespace RenderState
{
RasterizationState GetInvalidRasterizationState()
{
RasterizationState state;
state.hex = UINT32_C(0xFFFFFFFF);
return state;
}

RasterizationState GetNoCullRasterizationState()
{
RasterizationState state = {};
state.cullmode = GenMode::CULL_NONE;
return state;
}

DepthState GetInvalidDepthState()
{
DepthState state;
state.hex = UINT32_C(0xFFFFFFFF);
return state;
}

DepthState GetNoDepthTestingDepthStencilState()
{
DepthState state = {};
@@ -215,6 +229,13 @@ DepthState GetNoDepthTestingDepthStencilState()
return state;
}

BlendingState GetInvalidBlendingState()
{
BlendingState state;
state.hex = UINT32_C(0xFFFFFFFF);
return state;
}

BlendingState GetNoBlendingBlendState()
{
BlendingState state = {};
@@ -230,6 +251,13 @@ BlendingState GetNoBlendingBlendState()
return state;
}

SamplerState GetInvalidSamplerState()
{
SamplerState state;
state.hex = UINT64_C(0xFFFFFFFFFFFFFFFF);
return state;
}

SamplerState GetPointSamplerState()
{
SamplerState state = {};
4 Source/Core/VideoCommon/RenderState.h
View file
@@ -113,9 +113,13 @@ union SamplerState

namespace RenderState
{
RasterizationState GetInvalidRasterizationState();
RasterizationState GetNoCullRasterizationState();
DepthState GetInvalidDepthState();
DepthState GetNoDepthTestingDepthStencilState();
BlendingState GetInvalidBlendingState();
BlendingState GetNoBlendingBlendState();
SamplerState GetInvalidSamplerState();
SamplerState GetPointSamplerState();
SamplerState GetLinearSamplerState();
}
26 Source/Core/VideoCommon/ShaderCache.cpp
View file
@@ -8,14 +8,15 @@
#include "Common/FileUtil.h"
#include "Common/MsgHandler.h"
#include "Core/ConfigManager.h"
#include "Core/Host.h"

#include "VideoCommon/FramebufferManagerBase.h"
#include "VideoCommon/RenderBase.h"
#include "VideoCommon/Statistics.h"
#include "VideoCommon/VertexLoaderManager.h"
#include "VideoCommon/VertexManagerBase.h"

#include "imgui.h"

std::unique_ptr<VideoCommon::ShaderCache> g_shader_cache;

namespace VideoCommon
@@ -153,12 +154,29 @@ void ShaderCache::WaitForAsyncCompiler()
while (m_async_shader_compiler->HasPendingWork() || m_async_shader_compiler->HasCompletedWork())
{
m_async_shader_compiler->WaitUntilCompletion([](size_t completed, size_t total) {
Host_UpdateProgressDialog(GetStringT("Compiling shaders...").c_str(),
static_cast<int>(completed), static_cast<int>(total));
g_renderer->BeginUIFrame();

const float scale = ImGui::GetIO().DisplayFramebufferScale.x;

ImGui::SetNextWindowSize(ImVec2(400.0f * scale, 50.0f * scale), ImGuiCond_Always);
ImGui::SetNextWindowPosCenter(ImGuiCond_Always);
if (ImGui::Begin(GetStringT("Compiling Shaders").c_str(), nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs |
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing))
{
ImGui::Text("Compiling shaders: %zu/%zu", completed, total);
ImGui::ProgressBar(static_cast<float>(completed) /
static_cast<float>(std::max(total, static_cast<size_t>(1))),
ImVec2(-1.0f, 0.0f), "");
}
ImGui::End();

g_renderer->EndUIFrame();
});
m_async_shader_compiler->RetrieveWorkItems();
}
Host_UpdateProgressDialog("", -1, -1);
}

template <ShaderStage stage, typename K, typename T>
163 Source/Core/VideoCommon/Statistics.cpp
View file
@@ -6,6 +6,8 @@
#include <string>
#include <utility>

#include "imgui.h"

#include "Common/StringUtil.h"
#include "VideoCommon/Statistics.h"
#include "VideoCommon/VertexLoaderManager.h"
@@ -26,91 +28,98 @@ void Statistics::SwapDL()
std::swap(stats.thisFrame.numBPLoadsInDL, stats.thisFrame.numBPLoads);
}

std::string Statistics::ToString()
void Statistics::Display()
{
std::string str;
const float scale = ImGui::GetIO().DisplayFramebufferScale.x;
ImGui::SetNextWindowPos(ImVec2(10.0f * scale, 10.0f * scale), ImGuiCond_FirstUseEver);
ImGui::SetNextWindowSizeConstraints(ImVec2(275.0f * scale, 400.0f * scale),
ImGui::GetIO().DisplaySize);
if (!ImGui::Begin("Statistics", nullptr, ImGuiWindowFlags_NoNavInputs))
{
ImGui::End();
return;
}

ImGui::Columns(2, "Statistics", true);

#define DRAW_STAT(name, format, ...) \
ImGui::Text(name); \
ImGui::NextColumn(); \
ImGui::Text(format, __VA_ARGS__); \
ImGui::NextColumn();

if (g_ActiveConfig.backend_info.api_type == APIType::Nothing)
{
str += StringFromFormat("Objects: %i\n", stats.thisFrame.numDrawnObjects);
str += StringFromFormat("Vertices Loaded: %i\n", stats.thisFrame.numVerticesLoaded);
str += StringFromFormat("Triangles Input: %i\n", stats.thisFrame.numTrianglesIn);
str += StringFromFormat("Triangles Rejected: %i\n", stats.thisFrame.numTrianglesRejected);
str += StringFromFormat("Triangles Culled: %i\n", stats.thisFrame.numTrianglesCulled);
str += StringFromFormat("Triangles Clipped: %i\n", stats.thisFrame.numTrianglesClipped);
str += StringFromFormat("Triangles Drawn: %i\n", stats.thisFrame.numTrianglesDrawn);
str += StringFromFormat("Rasterized Pix: %i\n", stats.thisFrame.rasterizedPixels);
str += StringFromFormat("TEV Pix In: %i\n", stats.thisFrame.tevPixelsIn);
str += StringFromFormat("TEV Pix Out: %i\n", stats.thisFrame.tevPixelsOut);
DRAW_STAT("Objects", "%d", stats.thisFrame.numDrawnObjects);
DRAW_STAT("Vertices Loaded", "%d", stats.thisFrame.numVerticesLoaded);
DRAW_STAT("Triangles Input", "%d", stats.thisFrame.numTrianglesIn);
DRAW_STAT("Triangles Rejected", "%d", stats.thisFrame.numTrianglesRejected);
DRAW_STAT("Triangles Culled", "%d", stats.thisFrame.numTrianglesCulled);
DRAW_STAT("Triangles Clipped", "%d", stats.thisFrame.numTrianglesClipped);
DRAW_STAT("Triangles Drawn", "%d", stats.thisFrame.numTrianglesDrawn);
DRAW_STAT("Rasterized Pix", "%d", stats.thisFrame.rasterizedPixels);
DRAW_STAT("TEV Pix In", "%d", stats.thisFrame.tevPixelsIn);
DRAW_STAT("TEV Pix Out", "%d", stats.thisFrame.tevPixelsOut);
}

str += StringFromFormat("Textures created: %i\n", stats.numTexturesCreated);
str += StringFromFormat("Textures uploaded: %i\n", stats.numTexturesUploaded);
str += StringFromFormat("Textures alive: %i\n", stats.numTexturesAlive);
str += StringFromFormat("pshaders created: %i\n", stats.numPixelShadersCreated);
str += StringFromFormat("pshaders alive: %i\n", stats.numPixelShadersAlive);
str += StringFromFormat("vshaders created: %i\n", stats.numVertexShadersCreated);
str += StringFromFormat("vshaders alive: %i\n", stats.numVertexShadersAlive);
str += StringFromFormat("shaders changes: %i\n", stats.thisFrame.numShaderChanges);
str += StringFromFormat("dlists called: %i\n", stats.thisFrame.numDListsCalled);
str += StringFromFormat("Primitive joins: %i\n", stats.thisFrame.numPrimitiveJoins);
str += StringFromFormat("Draw calls: %i\n", stats.thisFrame.numDrawCalls);
str += StringFromFormat("Primitives: %i\n", stats.thisFrame.numPrims);
str += StringFromFormat("Primitives (DL): %i\n", stats.thisFrame.numDLPrims);
str += StringFromFormat("XF loads: %i\n", stats.thisFrame.numXFLoads);
str += StringFromFormat("XF loads (DL): %i\n", stats.thisFrame.numXFLoadsInDL);
str += StringFromFormat("CP loads: %i\n", stats.thisFrame.numCPLoads);
str += StringFromFormat("CP loads (DL): %i\n", stats.thisFrame.numCPLoadsInDL);
str += StringFromFormat("BP loads: %i\n", stats.thisFrame.numBPLoads);
str += StringFromFormat("BP loads (DL): %i\n", stats.thisFrame.numBPLoadsInDL);
str += StringFromFormat("Vertex streamed: %i kB\n", stats.thisFrame.bytesVertexStreamed / 1024);
str += StringFromFormat("Index streamed: %i kB\n", stats.thisFrame.bytesIndexStreamed / 1024);
str += StringFromFormat("Uniform streamed: %i kB\n", stats.thisFrame.bytesUniformStreamed / 1024);
str += StringFromFormat("Vertex Loaders: %i\n", stats.numVertexLoaders);

std::string vertex_list = VertexLoaderManager::VertexLoadersToString();

// TODO : at some point text1 just becomes too huge and overflows, we can't even read the added
// stuff
// since it gets added at the far bottom of the screen anyway (actually outside the rendering
// window)
// we should really reset the list instead of using substr
if (vertex_list.size() + str.size() > 8170)
vertex_list = vertex_list.substr(0, 8170 - str.size());

str += vertex_list;

return str;
DRAW_STAT("Textures created", "%d", stats.numTexturesCreated);
DRAW_STAT("Textures uploaded", "%d", stats.numTexturesUploaded);
DRAW_STAT("Textures alive", "%d", stats.numTexturesAlive);
DRAW_STAT("pshaders created", "%d", stats.numPixelShadersCreated);
DRAW_STAT("pshaders alive", "%d", stats.numPixelShadersAlive);
DRAW_STAT("vshaders created", "%d", stats.numVertexShadersCreated);
DRAW_STAT("vshaders alive", "%d", stats.numVertexShadersAlive);
DRAW_STAT("shaders changes", "%d", stats.thisFrame.numShaderChanges);
DRAW_STAT("dlists called", "%d", stats.thisFrame.numDListsCalled);
DRAW_STAT("Primitive joins", "%d", stats.thisFrame.numPrimitiveJoins);
DRAW_STAT("Draw calls", "%d", stats.thisFrame.numDrawCalls);
DRAW_STAT("Primitives", "%d", stats.thisFrame.numPrims);
DRAW_STAT("Primitives (DL)", "%d", stats.thisFrame.numDLPrims);
DRAW_STAT("XF loads", "%d", stats.thisFrame.numXFLoads);
DRAW_STAT("XF loads (DL)", "%d", stats.thisFrame.numXFLoadsInDL);
DRAW_STAT("CP loads", "%d", stats.thisFrame.numCPLoads);
DRAW_STAT("CP loads (DL)", "%d", stats.thisFrame.numCPLoadsInDL);
DRAW_STAT("BP loads", "%d", stats.thisFrame.numBPLoads);
DRAW_STAT("BP loads (DL)", "%d", stats.thisFrame.numBPLoadsInDL);
DRAW_STAT("Vertex streamed", "%i kB", stats.thisFrame.bytesVertexStreamed / 1024);
DRAW_STAT("Index streamed", "%i kB", stats.thisFrame.bytesIndexStreamed / 1024);
DRAW_STAT("Uniform streamed", "%i kB", stats.thisFrame.bytesUniformStreamed / 1024);
DRAW_STAT("Vertex Loaders", "%d", stats.numVertexLoaders);

#undef DRAW_STAT

ImGui::Columns(1);

ImGui::End();
}

// Is this really needed?
std::string Statistics::ToStringProj()
void Statistics::DisplayProj()
{
std::string projections;

projections += "Projection #: X for Raw 6=0 (X for Raw 6!=0)\n\n";
projections += StringFromFormat("Projection 0: %f (%f) Raw 0: %f\n", stats.gproj_0,
stats.g2proj_0, stats.proj_0);
projections += StringFromFormat("Projection 1: %f (%f)\n", stats.gproj_1, stats.g2proj_1);
projections += StringFromFormat("Projection 2: %f (%f) Raw 1: %f\n", stats.gproj_2,
stats.g2proj_2, stats.proj_1);
projections += StringFromFormat("Projection 3: %f (%f)\n\n", stats.gproj_3, stats.g2proj_3);
projections += StringFromFormat("Projection 4: %f (%f)\n", stats.gproj_4, stats.g2proj_4);
projections += StringFromFormat("Projection 5: %f (%f) Raw 2: %f\n", stats.gproj_5,
stats.g2proj_5, stats.proj_2);
projections += StringFromFormat("Projection 6: %f (%f) Raw 3: %f\n", stats.gproj_6,
stats.g2proj_6, stats.proj_3);
projections += StringFromFormat("Projection 7: %f (%f)\n\n", stats.gproj_7, stats.g2proj_7);
projections += StringFromFormat("Projection 8: %f (%f)\n", stats.gproj_8, stats.g2proj_8);
projections += StringFromFormat("Projection 9: %f (%f)\n", stats.gproj_9, stats.g2proj_9);
projections += StringFromFormat("Projection 10: %f (%f) Raw 4: %f\n\n", stats.gproj_10,
stats.g2proj_10, stats.proj_4);
projections += StringFromFormat("Projection 11: %f (%f) Raw 5: %f\n\n", stats.gproj_11,
stats.g2proj_11, stats.proj_5);
projections += StringFromFormat("Projection 12: %f (%f)\n", stats.gproj_12, stats.g2proj_12);
projections += StringFromFormat("Projection 13: %f (%f)\n", stats.gproj_13, stats.g2proj_13);
projections += StringFromFormat("Projection 14: %f (%f)\n", stats.gproj_14, stats.g2proj_14);
projections += StringFromFormat("Projection 15: %f (%f)\n", stats.gproj_15, stats.g2proj_15);

return projections;
if (!ImGui::Begin("Projection Statistics", nullptr, ImGuiWindowFlags_NoNavInputs))
{
ImGui::End();
return;
}

ImGui::Text("Projection #: X for Raw 6=0 (X for Raw 6!=0)");
ImGui::NewLine();
ImGui::Text("Projection 0: %f (%f) Raw 0: %f", stats.gproj_0, stats.g2proj_0, stats.proj_0);
ImGui::Text("Projection 1: %f (%f)", stats.gproj_1, stats.g2proj_1);
ImGui::Text("Projection 2: %f (%f) Raw 1: %f", stats.gproj_2, stats.g2proj_2, stats.proj_1);
ImGui::Text("Projection 3: %f (%f)", stats.gproj_3, stats.g2proj_3);
ImGui::Text("Projection 4: %f (%f)", stats.gproj_4, stats.g2proj_4);
ImGui::Text("Projection 5: %f (%f) Raw 2: %f", stats.gproj_5, stats.g2proj_5, stats.proj_2);
ImGui::Text("Projection 6: %f (%f) Raw 3: %f", stats.gproj_6, stats.g2proj_6, stats.proj_3);
ImGui::Text("Projection 7: %f (%f)", stats.gproj_7, stats.g2proj_7);
ImGui::Text("Projection 8: %f (%f)", stats.gproj_8, stats.g2proj_8);
ImGui::Text("Projection 9: %f (%f)", stats.gproj_9, stats.g2proj_9);
ImGui::Text("Projection 10: %f (%f) Raw 4: %f", stats.gproj_10, stats.g2proj_10, stats.proj_4);
ImGui::Text("Projection 11: %f (%f) Raw 5: %f", stats.gproj_11, stats.g2proj_11, stats.proj_5);
ImGui::Text("Projection 12: %f (%f)", stats.gproj_12, stats.g2proj_12);
ImGui::Text("Projection 13: %f (%f)", stats.gproj_13, stats.g2proj_13);
ImGui::Text("Projection 14: %f (%f)", stats.gproj_14, stats.g2proj_14);
ImGui::Text("Projection 15: %f (%f)", stats.gproj_15, stats.g2proj_15);

ImGui::End();
}
5 Source/Core/VideoCommon/Statistics.h
View file
@@ -65,9 +65,8 @@ struct Statistics
ThisFrame thisFrame;
void ResetFrame();
static void SwapDL();

static std::string ToString();
static std::string ToStringProj();
static void Display();
static void DisplayProj();
};

extern Statistics stats;
6 Source/Core/VideoCommon/VideoBackendBase.cpp
View file
@@ -278,9 +278,6 @@ void VideoBackendBase::InitializeShared()
memset(&g_preprocess_cp_state, 0, sizeof(g_preprocess_cp_state));
memset(texMem, 0, TMEM_SIZE);

// Do our OSD callbacks
OSD::DoCallbacks(OSD::CallbackType::Initialization);

// do not initialize again for the config window
m_initialized = true;

@@ -303,9 +300,6 @@ void VideoBackendBase::InitializeShared()

void VideoBackendBase::ShutdownShared()
{
// Do our OSD callbacks
OSD::DoCallbacks(OSD::CallbackType::Shutdown);

m_initialized = false;

VertexLoaderManager::Clear();
5 Source/Core/VideoCommon/VideoCommon.vcxproj
View file
@@ -183,8 +183,11 @@
<ProjectReference Include="$(CoreDir)Common\Common.vcxproj">
<Project>{2e6c348c-c75c-4d94-8d1e-9c1fcbf3efe4}</Project>
</ProjectReference>
<ProjectReference Include="..\..\..\Externals\imgui\imgui.vcxproj">
<Project>{4c3b2264-ea73-4a7b-9cfe-65b0fd635ebb}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
</Project>