swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-08 04:08:32 +09:00
Code Issues Packages Projects Releases Wiki Activity

[Fix] (Diligent/PSO): Try to bind input layout locations for GLSL.

Browse Source
This commit is contained in:
BZLZHH
2025-06-09 13:38:16 +08:00
parent 30b7f4d69d
commit 2fb0690804
5 changed files with 186 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MG/MG_GL/Implementations/EGL/Diligent/EGL_impl.cpp
+64 -3
View File
@@ -87,6 +87,50 @@ namespace MG_Diligent {
}
}
uint64_t PipelineStateManager::CalculateStateHash(
CommonState &commonState,
VertexArrayState &vaState,
GLFramebufferInfo& fbInfo) {
uint64_t hash = 0;
MG_Global::unordered_map<GLenum, bool> capabilities = commonState.capabilities;
hash ^= std::hash<int>()(commonState.blendSrcRGB);
hash ^= std::hash<int>()(commonState.blendDstRGB);
hash ^= std::hash<int>()(commonState.blendSrcAlpha);
hash ^= std::hash<int>()(commonState.blendDstAlpha);
hash ^= std::hash<bool>()(capabilities[GL_BLEND]);
hash ^= std::hash<int>()(commonState.depthFunc);
hash ^= std::hash<bool>()(commonState.depthMask);
hash ^= std::hash<bool>()(capabilities[GL_DEPTH_TEST]);
hash ^= std::hash<int>()(0); // TODO: Cull Face Mode
hash ^= std::hash<bool>()(capabilities[GL_CULL_FACE]);
hash ^= std::hash<bool>()(capabilities[GL_STENCIL_TEST]);
auto *pVAO = vaState.GetCurrentVAO();
for (const auto &[index, attrib]: pVAO->attribs) {
if (attrib.enabled) {
hash ^= std::hash<int>()(index);
hash ^= std::hash<int>()(attrib.size);
hash ^= std::hash<int>()(attrib.type);
hash ^= std::hash<bool>()(attrib.normalized);
}
}
hash ^= std::hash<size_t>()(fbInfo.ColorRTVs.size());
for (const auto& rtv : fbInfo.ColorRTVs) {
if (rtv) {
hash ^= std::hash<uint32_t>()(rtv->GetDesc().Format);
}
}
hash ^= std::hash<uint32_t>()(fbInfo.DepthStencilFormat);
return hash;
}
void PipelineStateManager::ConfigurePSO(
Diligent::GraphicsPipelineStateCreateInfo &PSOCreateInfo,
@@ -311,9 +355,26 @@ namespace MG_Diligent {
for (GLuint shaderId : programObj.attachedShaders) {
auto it = MG_State_T::programState->shaders_.find(shaderId);
if (it != MG_State_T::programState->shaders_.end() &&
!it->second.markedForDeletion) {
shaderSourcesMap[it->first] = it->second.source;
if (it != MG_State_T::programState->shaders_.end() && !it->second.markedForDeletion) {
std::string shaderSource;
if (it->second.type == GL_VERTEX_SHADER) {
std::string infoLog;
auto spirv =
MG_Util::Program::CompileGLSLToSPIRV(it->second.type,
it->second.source,
infoLog);
if (spirv.empty()) {
MG_Util::Debug::LogE("Failed to compile shader %u: %s", shaderId,
infoLog.c_str());
continue;
}
shaderSource = MG_Util::Program::BindInputLayoutLocationsForGLSL(spirv,
programObj.attribLocations);
} else {
shaderSource = it->second.source;
}
shaderSourcesMap[it->first] = shaderSource;
}
}
MG/MG_GL/Implementations/EGL/Diligent/EGL_impl.h
+1 -41
View File
@@ -192,47 +192,7 @@ namespace MG_Diligent {
uint64_t CalculateStateHash(
CommonState &commonState,
VertexArrayState &vaState,
GLFramebufferInfo& fbInfo) {
uint64_t hash = 0;
MG_Global::unordered_map<GLenum, bool> capabilities = commonState.capabilities;
hash ^= std::hash<int>()(commonState.blendSrcRGB);
hash ^= std::hash<int>()(commonState.blendDstRGB);
hash ^= std::hash<int>()(commonState.blendSrcAlpha);
hash ^= std::hash<int>()(commonState.blendDstAlpha);
hash ^= std::hash<bool>()(capabilities[GL_BLEND]);
hash ^= std::hash<int>()(commonState.depthFunc);
hash ^= std::hash<bool>()(commonState.depthMask);
hash ^= std::hash<bool>()(capabilities[GL_DEPTH_TEST]);
hash ^= std::hash<int>()(0); // TODO: Cull Face Mode
hash ^= std::hash<bool>()(capabilities[GL_CULL_FACE]);
hash ^= std::hash<bool>()(capabilities[GL_STENCIL_TEST]);
auto *pVAO = vaState.GetCurrentVAO();
for (const auto &[index, attrib]: pVAO->attribs) {
if (attrib.enabled) {
hash ^= std::hash<int>()(index);
hash ^= std::hash<int>()(attrib.size);
hash ^= std::hash<int>()(attrib.type);
hash ^= std::hash<bool>()(attrib.normalized);
}
}
hash ^= std::hash<size_t>()(fbInfo.ColorRTVs.size());
for (const auto& rtv : fbInfo.ColorRTVs) {
if (rtv) {
hash ^= std::hash<uint32_t>()(rtv->GetDesc().Format);
}
}
hash ^= std::hash<uint32_t>()(fbInfo.DepthStencilFormat);
return hash;
}
GLFramebufferInfo& fbInfo);
void ConfigurePSO(
Diligent::GraphicsPipelineStateCreateInfo &PSOCreateInfo,
MG/MG_GL/Implementations/GL/Program/GL_Program.cpp
+32 -4
View File
@@ -224,6 +224,11 @@ namespace MG_GL::GL {
void ShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint* length) {
MG_Util::Debug::LogD("glShaderSource, shader: %u, count: %d", shader, count);
if (count > 0 && string != nullptr && string[0] != nullptr) {
MG_Util::Debug::LogD("Shader source for shader %u:\n%s", shader, string[0]);
} else {
MG_Util::Debug::LogD("Shader source for shader %u is empty or null.", shader);
}
GLenum result = MG_State::UploadShaderSource(shader, count, (const GLchar **)string, length);
if (result == GL_NO_ERROR) return;
MG_State::SetError(result);
@@ -251,13 +256,36 @@ namespace MG_GL::GL {
}
MG_Global::unordered_map<GLuint, std::string> shaderSources;
for (GLuint shaderId : programInfo.AttachedShadersID) {
auto& shaderObj = MG_State_T::programState->shaders_[shaderId];
shaderSources[shaderId] = shaderObj.source;
for (GLuint shaderId : programObj.attachedShaders) {
auto it = MG_State_T::programState->shaders_.find(shaderId);
if (it != MG_State_T::programState->shaders_.end() && !it->second.markedForDeletion) {
std::string shaderSource;
if (it->second.type == GL_VERTEX_SHADER) {
std::string infoLog;
auto spirv =
MG_Util::Program::CompileGLSLToSPIRV(it->second.type,
it->second.source,
infoLog);
if (spirv.empty()) {
MG_Util::Debug::LogE("Failed to compile shader %u: %s", shaderId,
infoLog.c_str());
continue;
}
shaderSource = MG_Util::Program::BindInputLayoutLocationsForGLSL(spirv,
programObj.attribLocations);
} else {
shaderSource = it->second.source;
}
shaderSources[it->first] = shaderSource;
}
}
MG_Util::Program::GenerateDefaultUBOForGLSL_Multi(shaderSources, programInfo.uniformBufferNames);
MG_Util::Debug::LogD("Shader sources after UBO generation for program %u:", program);
for (const auto& [shaderId, source] : shaderSources) {
MG_Util::Debug::LogD(" Program %u Shader %u:\n%s", program, shaderId, source.c_str());
}
// Compile attached shaders
for (GLuint shaderId : programInfo.AttachedShadersID) {
auto& shaderObj = MG_State_T::programState->shaders_[shaderId];
MG/MG_UTIL/Program/GLSLTool.cpp
+86
View File
@@ -5,6 +5,92 @@
#include "GLSLTool.h"
namespace MG_Util::Program {
std::string BindInputLayoutLocationsForGLSL(const std::vector<uint32_t>& spirv,
const MG_Global::unordered_map<std::string, GLint>&
name_location_map) {
spvc_context context = nullptr;
spvc_parsed_ir ir = nullptr;
spvc_compiler compiler = nullptr;
spvc_resources resources = nullptr;
spvc_result result = SPVC_SUCCESS;
const char* glsl_source = nullptr;
std::string output_glsl;
if ((result = spvc_context_create(&context)) != SPVC_SUCCESS) {
return {};
}
if ((result = spvc_context_parse_spirv(context, spirv.data(), spirv.size(), &ir)) != SPVC_SUCCESS) {
spvc_context_destroy(context);
return {};
}
if ((result = spvc_context_create_compiler(
context,
SPVC_BACKEND_GLSL,
ir,
SPVC_CAPTURE_MODE_TAKE_OWNERSHIP,
&compiler
)) != SPVC_SUCCESS) {
spvc_context_destroy(context);
return {};
}
if ((result = spvc_compiler_create_shader_resources(compiler, &resources)) != SPVC_SUCCESS) {
spvc_context_destroy(context);
return {};
}
const spvc_reflected_resource* inputs = nullptr;
size_t num_inputs = 0;
if ((result = spvc_resources_get_resource_list_for_type(
resources,
SPVC_RESOURCE_TYPE_STAGE_INPUT,
&inputs,
&num_inputs
)) != SPVC_SUCCESS) {
spvc_context_destroy(context);
return {};
}
std::unordered_map<std::string, spvc_variable_id> name_to_id;
for (size_t i = 0; i < num_inputs; i++) {
name_to_id[inputs[i].name] = inputs[i].id;
}
for (const auto& [name, location] : name_location_map) {
auto it = name_to_id.find(name);
if (it == name_to_id.end()) {
spvc_context_destroy(context);
return {};
}
spvc_compiler_set_decoration(
compiler,
it->second,
SpvDecorationLocation,
location
);
}
spvc_compiler_options options = nullptr;
spvc_compiler_create_compiler_options(compiler, &options);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, 450);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_FALSE);
spvc_compiler_install_compiler_options(compiler, options);
if ((result = spvc_compiler_compile(compiler, &glsl_source)) != SPVC_SUCCESS) {
spvc_context_destroy(context);
return {};
}
output_glsl = glsl_source;
spvc_context_destroy(context);
return output_glsl;
}
static std::vector<bool> buildCommentMask(const std::string &src) {
enum State {
NORMAL,
MG/MG_UTIL/Program/GLSLTool.h
+3
View File
@@ -182,6 +182,9 @@ namespace MG_Util::Program {
std::string>& glslSources);
void GenerateDefaultUBOForGLSL_Multi(
MG_Global::unordered_map<GLuint, std::string> &shaderSources, std::vector<std::string>& outUniformBufferNames);
std::string BindInputLayoutLocationsForGLSL(const std::vector<uint32_t>& spirv,
const MG_Global::unordered_map<std::string, GLint>&
name_location_map);
}
#endif //MOBILEGL_GLSLTOOL_H