various improvements & cleanup for shader compilation

CMakeLists.txt

@@ -73,8 +73,8 @@ add_definitions(-DEMULATOR_VERSION_PATCH=${EMULATOR_VERSION_PATCH})
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 # enable link time optimization for release builds
-set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
-set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO ON)
+#set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)#
+#set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO ON)#
 
 if (MSVC)
 	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT CemuBin)

src/Cafe/HW/Latte/Core/LatteShader.cpp

@@ -14,6 +14,7 @@
 #include "util/helpers/StringParser.h"
 #include "config/ActiveSettings.h"
 #include "Cafe/GameProfile/GameProfile.h"
+#include "HW/Latte/Renderer/OpenGL/RendererShaderGL.h"
 #include "util/containers/flat_hash_map.hpp"
 #if ENABLE_METAL
 #include "Cafe/HW/Latte/Renderer/Metal/LatteToMtl.h"
@@ -360,23 +361,15 @@ void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compil
 	}
 
 	// create shader
-	shader->shader = g_renderer->shader_create(shaderType, shader->baseHash, shader->auxHash, shaderSrc, true, shader->isCustomShader);
+	shader->shader = g_renderer->shader_create(shaderType, shader->baseHash, shader->auxHash, std::move(shaderSrc), true, shader->isCustomShader);
 	if (shader->shader == nullptr)
 		shader->hasError = true;
-	// after renderer shader creation we can throw away any intermediate info
-	LatteShader_CleanupAfterCompile(shader);
-}
-
-void LatteShader_FinishCompilation(LatteDecompilerShader* shader)
-{
-	if (shader->hasError)
+	if (g_renderer->GetType() == RendererAPI::OpenGL)
 	{
-		cemuLog_logDebug(LogType::Force, "LatteShader_finishCompilation(): Skipped because of error in shader {:x}", shader->baseHash);
-		return;
+		RendererShaderGL* shaderGL = static_cast<RendererShaderGL*>(shader->shader);
+		shaderGL->SetDecompilerShader(shader);
 	}
-	shader->shader->WaitForCompiled();
-
-	LatteShader_prepareSeparableUniforms(shader);
+	// after renderer shader creation we can throw away any intermediate info
 	LatteShader_CleanupAfterCompile(shader);
 }
 
@@ -845,13 +838,6 @@ LatteDecompilerShader* LatteShader_CompileSeparableVertexShader(uint64 baseHash,
 	LatteShader_CreateRendererShader(vertexShader, false);
 	performanceMonitor.numCompiledVS++;
 
-	if (g_renderer->GetType() == RendererAPI::OpenGL)
-	{
-		if (vertexShader->shader)
-			vertexShader->shader->PreponeCompilation(true);
-		LatteShader_FinishCompilation(vertexShader);
-	}
-
 	LatteSHRC_RegisterShader(vertexShader, vertexShader->baseHash, vertexShader->auxHash);
 	return vertexShader;
 }
@@ -874,13 +860,6 @@ LatteDecompilerShader* LatteShader_CompileSeparableGeometryShader(uint64 baseHas
 	LatteShader_CreateRendererShader(geometryShader, false);
 	performanceMonitor.numCompiledGS++;
 
-	if (g_renderer->GetType() == RendererAPI::OpenGL)
-	{
-		if (geometryShader->shader)
-			geometryShader->shader->PreponeCompilation(true);
-		LatteShader_FinishCompilation(geometryShader);
-	}
-
 	LatteSHRC_RegisterShader(geometryShader, geometryShader->baseHash, geometryShader->auxHash);
 	return geometryShader;
 }
@@ -903,13 +882,6 @@ LatteDecompilerShader* LatteShader_CompileSeparablePixelShader(uint64 baseHash,
 		LatteShaderCache_writeSeparablePixelShader(_shaderBaseHash_ps, psAuxHash, pixelShaderPtr, pixelShaderSize, LatteGPUState.contextRegister, usesGeometryShader);
 	}
 
-	if (g_renderer->GetType() == RendererAPI::OpenGL)
-	{
-		if (pixelShader->shader)
-			pixelShader->shader->PreponeCompilation(true);
-		LatteShader_FinishCompilation(pixelShader);
-	}
-
 	LatteSHRC_RegisterShader(pixelShader, _shaderBaseHash_ps, psAuxHash);
 	return pixelShader;
 }

src/Cafe/HW/Latte/Core/LatteShader.h

@@ -100,7 +100,6 @@ void LatteShader_GetDecompilerOptions(struct LatteDecompilerOptions& options, La
 LatteDecompilerShader* LatteShader_CreateShaderFromDecompilerOutput(LatteDecompilerOutput_t& decompilerOutput, uint64 baseHash, bool calculateAuxHash, uint64 optionalAuxHash, uint32* contextRegister);
 
 void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compileAsync);
-void LatteShader_FinishCompilation(LatteDecompilerShader* shader);
 
 void LatteShader_prepareSeparableUniforms(LatteDecompilerShader* shader);
 

src/Cafe/HW/Latte/Core/LatteShaderCache.cpp

@@ -106,13 +106,24 @@ void LatteShaderCache_removeFromCompileQueue(sint32 index)
  */
 void LatteShaderCache_updateCompileQueue(sint32 maxRemainingEntries)
 {
+	// remove any shaders that are already done
+	for (size_t i = 0; i < shaderCompileQueue.count; i++)
+	{
+		auto shaderEntry = shaderCompileQueue.entry[i].shader;
+		if (!shaderEntry)
+			continue;
+		if (shaderEntry->shader->IsCompiled())
+		{
+			LatteShaderCache_removeFromCompileQueue(i);
+		}
+	}
 	while (true)
 	{
 		if (shaderCompileQueue.count <= maxRemainingEntries)
 			break;
 		auto shader = shaderCompileQueue.entry[0].shader;
 		if (shader)
-			LatteShader_FinishCompilation(shader);
+			shader->shader->PreponeCompilation();
 		LatteShaderCache_removeFromCompileQueue(0);
 	}
 }

src/Cafe/HW/Latte/Core/LatteShaderGL.cpp

@@ -26,7 +26,7 @@ bool gxShader_checkIfSuccessfullyLinked(GLuint glProgram)
 
 void LatteShader_prepareSeparableUniforms(LatteDecompilerShader* shader)
 {
-	if (g_renderer->GetType() != RendererAPI::OpenGL)
+	if(shader->hasError)
 		return;
 
 	auto shaderGL = (RendererShaderGL*)shader->shader;

src/Cafe/HW/Latte/Renderer/Metal/MetalPipelineCompiler.cpp

@@ -176,8 +176,8 @@ static RendererShaderMtl* rectsEmulationGS_generate(MetalRenderer* metalRenderer
 
 	gsSrc.append("}\r\n");
 
-	auto mtlShader = new RendererShaderMtl(metalRenderer, RendererShader::ShaderType::kGeometry, 0, 0, false, false, gsSrc);
-	mtlShader->PreponeCompilation(true);
+	auto mtlShader = new RendererShaderMtl(metalRenderer, RendererShader::ShaderType::kGeometry, 0, 0, false, false, std::move(gsSrc));
+	mtlShader->PreponeCompilation();
 
 	return mtlShader;
 }
@@ -321,11 +321,11 @@ bool MetalPipelineCompiler::Compile(bool forceCompile, bool isRenderThread, bool
 	{
 		// if some shader stages are not compiled yet, compile them now
 		if (m_vertexShaderMtl && !m_vertexShaderMtl->IsCompiled())
-			m_vertexShaderMtl->PreponeCompilation(isRenderThread);
+			m_vertexShaderMtl->PreponeCompilation();
 		if (m_geometryShaderMtl && !m_geometryShaderMtl->IsCompiled())
-			m_geometryShaderMtl->PreponeCompilation(isRenderThread);
+			m_geometryShaderMtl->PreponeCompilation();
 		if (m_pixelShaderMtl && !m_pixelShaderMtl->IsCompiled())
-			m_pixelShaderMtl->PreponeCompilation(isRenderThread);
+			m_pixelShaderMtl->PreponeCompilation();
 	}
 	else
 	{

src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.cpp

@@ -996,9 +996,9 @@ void MetalRenderer::buffer_bindUniformBuffer(LatteConst::ShaderType shaderType,
     m_state.m_uniformBufferOffsets[GetMtlGeneralShaderType(shaderType)][bufferIndex] = offset;
 }
 
-RendererShader* MetalRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader)
+RendererShader* MetalRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, std::string&& source, bool isGameShader, bool isGfxPackShader)
 {
-    return new RendererShaderMtl(this, type, baseHash, auxHash, isGameShader, isGfxPackShader, source);
+    return new RendererShaderMtl(this, type, baseHash, auxHash, isGameShader, isGfxPackShader, std::move(source));
 }
 
 void MetalRenderer::streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize)

src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.h

@@ -241,7 +241,7 @@ class MetalRenderer : public Renderer
 	void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override;
 
 	// shader
-	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool compileAsync, bool isGfxPackSource) override;
+	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, std::string&& source, bool compileAsync, bool isGfxPackSource) override;
 
 	// streamout
 	void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) override;

src/Cafe/HW/Latte/Renderer/Metal/RendererShaderMtl.cpp

@@ -213,8 +213,8 @@ void RendererShaderMtl::Shutdown()
     shaderMtlThreadPool.StopThreads();
 }
 
-RendererShaderMtl::RendererShaderMtl(MetalRenderer* mtlRenderer, ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& mslCode)
-	: RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_mtlr{mtlRenderer}, m_mslCode{mslCode}
+RendererShaderMtl::RendererShaderMtl(MetalRenderer* mtlRenderer, ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& mslCode)
+	: RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_mtlr{mtlRenderer}, m_mslCode{std::move(mslCode)}
 {
 	// start async compilation
 	shaderMtlThreadPool.s_compilationQueueMutex.lock();
@@ -231,7 +231,7 @@ RendererShaderMtl::~RendererShaderMtl()
         m_function->release();
 }
 
-void RendererShaderMtl::PreponeCompilation(bool isRenderThread)
+void RendererShaderMtl::PreponeCompilation()
 {
 	shaderMtlThreadPool.s_compilationQueueMutex.lock();
 	bool isStillQueued = m_compilationState.hasState(COMPILATION_STATE::QUEUED);

src/Cafe/HW/Latte/Renderer/Metal/RendererShaderMtl.h

@@ -28,15 +28,15 @@ class RendererShaderMtl : public RendererShader
     static void Initialize();
 	static void Shutdown();
 
-	RendererShaderMtl(class MetalRenderer* mtlRenderer, ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& mslCode);
+	RendererShaderMtl(class MetalRenderer* mtlRenderer, ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& mslCode);
 	virtual ~RendererShaderMtl();
 
 	MTL::Function* GetFunction() const
 	{
 	    return m_function;
 	}
 
-	void PreponeCompilation(bool isRenderThread) override;
+	void PreponeCompilation() override;
 	bool IsCompiled() override;
 	bool WaitForCompiled() override;
 

src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp

@@ -1306,9 +1306,9 @@ void OpenGLRenderer::attributeStream_unbindVertexBuffer()
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
-RendererShader* OpenGLRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader)
+RendererShader* OpenGLRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, std::string&& source, bool isGameShader, bool isGfxPackShader)
 {
-	return new RendererShaderGL(type, baseHash, auxHash, isGameShader, isGfxPackShader, source);
+	return new RendererShaderGL(type, baseHash, auxHash, isGameShader, isGfxPackShader, std::move(source));
 }
 
 void OpenGLRenderer::shader_bind(RendererShader* shader)

src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h

@@ -145,7 +145,7 @@ class OpenGLRenderer : public Renderer
 	void uniformData_update();
 
 	// shader
-	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader) override;
+	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, std::string&& source, bool isGameShader, bool isGfxPackShader) override;
 	void shader_bind(RendererShader* shader);
 	void shader_unbind(RendererShader::ShaderType shaderType);
 

src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp

@@ -867,8 +867,8 @@ RendererShaderGL* rectsEmulationGS_generateShaderGL(LatteDecompilerShader* verte
 
 	gsSrc.append("}\r\n");
 
-	auto glShader = new RendererShaderGL(RendererShader::ShaderType::kGeometry, 0, 0, false, false, gsSrc);
-	glShader->PreponeCompilation(true);
+	auto glShader = new RendererShaderGL(RendererShader::ShaderType::kGeometry, 0, 0, false, false, std::move(gsSrc));
+	glShader->PreponeCompilation();
 
 	return glShader;
 }
@@ -912,9 +912,20 @@ void OpenGLRenderer::draw_genericDrawHandler(uint32 baseVertex, uint32 baseInsta
 	{
 		beginPerfMonProfiling(performanceMonitor.gpuTime_dcStageShaderAndUniformMgr);
 		LatteSHRC_UpdateActiveShaders();
-		LatteDecompilerShader* vs = (LatteDecompilerShader*)LatteSHRC_GetActiveVertexShader();
-		LatteDecompilerShader* gs = (LatteDecompilerShader*)LatteSHRC_GetActiveGeometryShader();
-		LatteDecompilerShader* ps = (LatteDecompilerShader*)LatteSHRC_GetActivePixelShader();
+		LatteDecompilerShader* vs = LatteSHRC_GetActiveVertexShader();
+		LatteDecompilerShader* gs = LatteSHRC_GetActiveGeometryShader();
+		LatteDecompilerShader* ps = LatteSHRC_GetActivePixelShader();
+
+		for (auto& i : {vs, gs, ps})
+		{
+			if (!i)
+				continue;
+			if (!i->shader->IsCompiled())
+			{
+				i->shader->WaitForCompiled();
+			}
+		}
+
 		if (vs)
 			shader_bind(vs->shader);
 		else