GL3+: validate VertexDeclaration against shader inputs

RenderSystems/GL3Plus/src/GLSL/include/OgreGLSLShader.h

@@ -70,6 +70,8 @@ namespace Ogre {
         void extractUniforms(int block = -1) const;
         void extractBufferBlocks(GLenum type) const;
 
+        void extractAttributes();
+
         mutable HardwareBufferPtr mDefaultBuffer;
         bool mHasSamplerBinding;
     };

RenderSystems/GL3Plus/src/GLSL/src/OgreGLSLShader.cpp

@@ -486,6 +486,20 @@ namespace Ogre {
         mLinked = 0;
     }
 
+    void GLSLShader::extractAttributes()
+    {
+        GLint numAttributes = 0;
+        OGRE_CHECK_GL_ERROR(glGetProgramInterfaceiv(mGLProgramHandle, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &numAttributes));
+        GLenum prop = GL_LOCATION;
+        for (int attr = 0; attr < numAttributes; ++attr)
+        {
+            GLint val;
+            OGRE_CHECK_GL_ERROR(
+                glGetProgramResourceiv(mGLProgramHandle, GL_PROGRAM_INPUT, attr, 1, &prop, 1, NULL, &val));
+            mActiveInputs.push_back(val);
+        }
+    }
+
     void GLSLShader::extractUniforms(int block) const
     {
         GLint numUniforms = 0;
@@ -642,6 +656,8 @@ namespace Ogre {
             extractUniforms();
             extractBufferBlocks(GL_UNIFORM_BLOCK);
             extractBufferBlocks(GL_SHADER_STORAGE_BLOCK);
+            if(mType == GPT_VERTEX_PROGRAM)
+                extractAttributes();
             return;
         }
 

RenderSystems/GL3Plus/src/OgreGL3PlusRenderSystem.cpp

@@ -1098,6 +1098,8 @@ namespace Ogre {
         if (updateVAO)
             vao->bindToGpu(this, op.vertexData->vertexBufferBinding, 0);
 
+        mCurrentShader[GPT_VERTEX_PROGRAM]->validateDeclaration(op.vertexData->vertexDeclaration);
+
         // We treat index buffer binding inside VAO as volatile, always updating and never relying onto it,
         // as one shared vertex buffer could be rendered with several index buffers, from submeshes and/or LODs
         if (op.useIndexes)

RenderSystems/GLSupport/include/GLSL/OgreGLSLShaderCommon.h

@@ -106,6 +106,8 @@ namespace Ogre {
 
         /// GLSL does not provide access to the low level code of the shader, so use this shader for binding as well
         GpuProgram* _getBindingDelegate(void) override { return this; }
+
+        void validateDeclaration(const VertexDeclaration* decl);
     protected:
         /// GLSL does not provide access to the low level implementation of the shader, so this method s a no-op
         void createLowLevelImpl() override {}
@@ -144,6 +146,8 @@ namespace Ogre {
         /// Pointer to the uniform cache for this shader
         GLUniformCache    mUniformCache;
 
+        std::vector<int>  mActiveInputs; // only for vertex shaders
+
         /// Keep track of the number of shaders created.
         static uint mShaderCount;
     };

RenderSystems/GLSupport/src/GLSL/OgreGLSLShaderCommon.cpp

@@ -36,6 +36,7 @@ THE SOFTWARE.
 
 #include "OgreGLSLShaderCommon.h"
 #include "OgreGLSLPreprocessor.h"
+#include "OgreGLSLProgramCommon.h"
 
 namespace Ogre {
     //-----------------------------------------------------------------------
@@ -44,6 +45,28 @@ namespace Ogre {
     GLSLShaderCommon::CmdAttach GLSLShaderCommon::msCmdAttach;
     GLSLShaderCommon::CmdColumnMajorMatrices GLSLShaderCommon::msCmdColumnMajorMatrices;
 
+    void GLSLShaderCommon::validateDeclaration(const VertexDeclaration* decl)
+    {
+        for(auto sloc : mActiveInputs)
+        {
+            bool found = false;
+            for (const VertexElement & elem : decl->getElements())
+            {
+                auto eidx = GLSLProgramCommon::getFixedAttributeIndex(elem.getSemantic(), elem.getIndex());
+                if(eidx == sloc)
+                {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+            {
+                LogManager::getSingleton().logError("Vertex Shader " + mName + " consumes input at location " +
+                                                    std::to_string(sloc) + " but no such VertexElement provided");
+            }
+        }
+    }
+
     String GLSLShaderCommon::getResourceLogName() const
     {
         if(mLoadFromFile)