dahjah/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2026-06-05 14:15:01 -06:00
Code Issues Packages Projects Releases Wiki Activity

Avoid copying shader source string

Browse Source
This commit is contained in:
goeiecool9999 2026-01-22 15:07:36 +01:00
parent d42bea0d3c
commit aea9023ee9
18 changed files with 27 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Cafe/HW/Latte/Core/LatteShader.cpp
View File

@ -360,7 +360,7 @@ void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compil
} }
// create shader // 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) if (shader->shader == nullptr)
shader->hasError = true; shader->hasError = true;
// after renderer shader creation we can throw away any intermediate info // after renderer shader creation we can throw away any intermediate info

4
src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.cpp
View File

@ -996,9 +996,9 @@ void MetalRenderer::buffer_bindUniformBuffer(LatteConst::ShaderType shaderType,
m_state.m_uniformBufferOffsets[GetMtlGeneralShaderType(shaderType)][bufferIndex] = offset; 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) void MetalRenderer::streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize)

2
src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.h
View File

@ -241,7 +241,7 @@ public:
void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override; void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override;
// shader // 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 // streamout
void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) override; void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) override;

4
src/Cafe/HW/Latte/Renderer/Metal/RendererShaderMtl.cpp
View File

@ -213,8 +213,8 @@ void RendererShaderMtl::Shutdown()
shaderMtlThreadPool.StopThreads(); shaderMtlThreadPool.StopThreads();
} }
RendererShaderMtl::RendererShaderMtl(MetalRenderer* mtlRenderer, ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& 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{mslCode} : RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_mtlr{mtlRenderer}, m_mslCode{std::move(mslCode)}
{ {
// start async compilation // start async compilation
shaderMtlThreadPool.s_compilationQueueMutex.lock(); shaderMtlThreadPool.s_compilationQueueMutex.lock();

2
src/Cafe/HW/Latte/Renderer/Metal/RendererShaderMtl.h
View File

@ -28,7 +28,7 @@ public:
static void Initialize(); static void Initialize();
static void Shutdown(); 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(); virtual ~RendererShaderMtl();
MTL::Function* GetFunction() const MTL::Function* GetFunction() const

4
src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp
View File

@ -1306,9 +1306,9 @@ void OpenGLRenderer::attributeStream_unbindVertexBuffer()
glBindBuffer(GL_ARRAY_BUFFER, 0); 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) void OpenGLRenderer::shader_bind(RendererShader* shader)

2
src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h
View File

@ -145,7 +145,7 @@ public:
void uniformData_update(); void uniformData_update();
// shader // 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_bind(RendererShader* shader);
void shader_unbind(RendererShader::ShaderType shaderType); void shader_unbind(RendererShader::ShaderType shaderType);

2
src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp
View File

@ -867,7 +867,7 @@ RendererShaderGL* rectsEmulationGS_generateShaderGL(LatteDecompilerShader* verte
gsSrc.append("}\r\n"); gsSrc.append("}\r\n");
auto glShader = new RendererShaderGL(RendererShader::ShaderType::kGeometry, 0, 0, false, false, gsSrc); auto glShader = new RendererShaderGL(RendererShader::ShaderType::kGeometry, 0, 0, false, false, std::move(gsSrc));
glShader->PreponeCompilation(); glShader->PreponeCompilation();
return glShader; return glShader;

4
src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp
View File

@ -73,8 +73,8 @@ void RendererShaderGL::storeBinary()
} }
} }
RendererShaderGL::RendererShaderGL(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslSource) RendererShaderGL::RendererShaderGL(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& glslSource)
: RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_glslSource(glslSource) : RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_glslSource(std::move(glslSource))
{ {
GLenum glShaderType; GLenum glShaderType;
switch (type) switch (type)

2
src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.h
View File

@ -6,7 +6,7 @@
class RendererShaderGL : public RendererShader class RendererShaderGL : public RendererShader
{ {
public: public:
RendererShaderGL(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslSource); RendererShaderGL(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& glslSource);
virtual ~RendererShaderGL(); virtual ~RendererShaderGL();

2
src/Cafe/HW/Latte/Renderer/Renderer.h
View File

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

4
src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp
View File

@ -251,8 +251,8 @@ RendererOutputShader::RendererOutputShader(const std::string& vertex_source, con
else else
finalFragmentSrc = PrependFragmentPreamble(fragment_source); finalFragmentSrc = PrependFragmentPreamble(fragment_source);
m_vertex_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, vertex_source, false, false)); m_vertex_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, std::string(vertex_source), false, false));
m_fragment_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, finalFragmentSrc, false, false)); m_fragment_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, std::string(finalFragmentSrc), false, false));
m_vertex_shader->PreponeCompilation(); m_vertex_shader->PreponeCompilation();
m_fragment_shader->PreponeCompilation(); m_fragment_shader->PreponeCompilation();

4
src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp
View File

@ -195,8 +195,8 @@ private:
std::atomic<bool> m_threadsActive; std::atomic<bool> m_threadsActive;
}ShaderVkThreadPool; }ShaderVkThreadPool;
RendererShaderVk::RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslCode) RendererShaderVk::RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& glslCode)
: RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_glslCode(glslCode) : RendererShader(type, baseHash, auxHash, isGameShader, isGfxPackShader), m_glslCode(std::move(glslCode))
{ {
// start async compilation // start async compilation
ShaderVkThreadPool.s_compilationQueueMutex.lock(); ShaderVkThreadPool.s_compilationQueueMutex.lock();

2
src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h
View File

@ -25,7 +25,7 @@ public:
static void ShaderCacheLoading_end(); static void ShaderCacheLoading_end();
static void ShaderCacheLoading_Close(); static void ShaderCacheLoading_Close();
RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslCode); RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, std::string&& glslCode);
virtual ~RendererShaderVk(); virtual ~RendererShaderVk();
static void Init(); static void Init();

2
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp
View File

@ -157,7 +157,7 @@ RendererShaderVk* rectsEmulationGS_generate(LatteDecompilerShader* vertexShader,
gsSrc.append("}\r\n"); gsSrc.append("}\r\n");
auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kGeometry, 0, 0, false, false, gsSrc); auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kGeometry, 0, 0, false, false, std::move(gsSrc));
vkShader->PreponeCompilation(); vkShader->PreponeCompilation();
return vkShader; return vkShader;
} }

4
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
View File

@ -1293,9 +1293,9 @@ VkDeviceCreateInfo VulkanRenderer::CreateDeviceCreateInfo(const std::vector<VkDe
return createInfo; return createInfo;
} }
RendererShader* VulkanRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader) RendererShader* VulkanRenderer::shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, std::string&& source, bool isGameShader, bool isGfxPackShader)
{ {
return new RendererShaderVk(type, baseHash, auxHash, isGameShader, isGfxPackShader, source); return new RendererShaderVk(type, baseHash, auxHash, isGameShader, isGfxPackShader, std::move(source));
} }
VulkanRenderer::QueueFamilyIndices VulkanRenderer::FindQueueFamilies(VkSurfaceKHR surface, VkPhysicalDevice device) VulkanRenderer::QueueFamilyIndices VulkanRenderer::FindQueueFamilies(VkSurfaceKHR surface, VkPhysicalDevice device)

2
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h
View File

@ -330,7 +330,7 @@ public:
std::pair<VkBuffer, uint32> buffer_genStrideWorkaroundVertexBuffer(MPTR buffer, uint32 size, uint32 oldStride); std::pair<VkBuffer, uint32> buffer_genStrideWorkaroundVertexBuffer(MPTR buffer, uint32 size, uint32 oldStride);
void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override; void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override;
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;
IndexAllocation indexData_reserveIndexMemory(uint32 size) override; IndexAllocation indexData_reserveIndexMemory(uint32 size) override;
void indexData_releaseIndexMemory(IndexAllocation& allocation) override; void indexData_releaseIndexMemory(IndexAllocation& allocation) override;

6
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
View File

@ -180,7 +180,7 @@ RendererShaderVk* _vkGenSurfaceCopyShader_vs()
"}\r\n"; "}\r\n";
std::string shaderStr(vsShaderSrc); std::string shaderStr(vsShaderSrc);
auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kVertex, 0, 0, false, false, shaderStr); auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kVertex, 0, 0, false, false, std::move(shaderStr));
vkShader->PreponeCompilation(); vkShader->PreponeCompilation();
return vkShader; return vkShader;
} }
@ -198,7 +198,7 @@ RendererShaderVk* _vkGenSurfaceCopyShader_ps_colorToDepth()
"}\r\n"; "}\r\n";
std::string shaderStr(psShaderSrc); std::string shaderStr(psShaderSrc);
auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kFragment, 0, 0, false, false, shaderStr); auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kFragment, 0, 0, false, false, std::move(shaderStr));
vkShader->PreponeCompilation(); vkShader->PreponeCompilation();
return vkShader; return vkShader;
} }
@ -217,7 +217,7 @@ RendererShaderVk* _vkGenSurfaceCopyShader_ps_depthToColor()
"}\r\n"; "}\r\n";
std::string shaderStr(psShaderSrc); std::string shaderStr(psShaderSrc);
auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kFragment, 0, 0, false, false, shaderStr); auto vkShader = new RendererShaderVk(RendererShader::ShaderType::kFragment, 0, 0, false, false, std::move(shaderStr));
vkShader->PreponeCompilation(); vkShader->PreponeCompilation();
return vkShader; return vkShader;
} }