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

MG/MG_GL/Implementations/EGL/Diligent/EGL_impl.cpp

@@ -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() &&
+            if (it != MG_State_T::programState->shaders_.end() && !it->second.markedForDeletion) {
-                !it->second.markedForDeletion) {
+                std::string shaderSource;
-                shaderSourcesMap[it->first] = it->second.source;
+                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

@@ -192,47 +192,7 @@ namespace MG_Diligent {
         uint64_t CalculateStateHash(
                 CommonState &commonState,
                 VertexArrayState &vaState,
-                GLFramebufferInfo& fbInfo) {
+                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 ConfigurePSO(
                 Diligent::GraphicsPipelineStateCreateInfo &PSOCreateInfo,

MG/MG_GL/Implementations/GL/Program/GL_Program.cpp

@@ -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) {
+            for (GLuint shaderId : programObj.attachedShaders) {
-                auto& shaderObj = MG_State_T::programState->shaders_[shaderId];
+                auto it = MG_State_T::programState->shaders_.find(shaderId);
-                shaderSources[shaderId] = shaderObj.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;
+                    }
+                    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

@@ -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

@@ -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