adding support for the 2 versions of the shaders nad solving the mapping of uniforms that arise with it

libraries/gpu/src/gpu/GLBackend.cpp

@@ -523,8 +523,10 @@ void GLBackend::do_glUniform1i(Batch& batch, size_t paramOffset) {
         return;
     }
     updatePipeline();
+    GLint location = _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 1]._int);
+
     glUniform1f(
-        batch._params[paramOffset + 1]._int,
+        location,
         batch._params[paramOffset + 0]._int);
     (void) CHECK_GL_ERROR();
 }
@@ -546,9 +548,10 @@ void GLBackend::do_glUniform1f(Batch& batch, size_t paramOffset) {
         return;
     }
     updatePipeline();
+    GLint location = _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 1]._int);
 
     glUniform1f(
-        batch._params[paramOffset + 1]._int,
+        location,
         batch._params[paramOffset + 0]._float);
     (void) CHECK_GL_ERROR();
 }
@@ -571,7 +574,7 @@ void GLBackend::do_glUniform2f(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     glUniform2f(
-        batch._params[paramOffset + 2]._int,
+        _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 2]._int),
         batch._params[paramOffset + 1]._float,
         batch._params[paramOffset + 0]._float);
     (void) CHECK_GL_ERROR();
@@ -596,7 +599,7 @@ void GLBackend::do_glUniform3f(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     glUniform3f(
-        batch._params[paramOffset + 3]._int,
+        _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 3]._int),
         batch._params[paramOffset + 2]._float,
         batch._params[paramOffset + 1]._float,
         batch._params[paramOffset + 0]._float);
@@ -625,7 +628,7 @@ void GLBackend::do_glUniform4f(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     glUniform4f(
-        batch._params[paramOffset + 4]._int,
+        _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 4]._int),
         batch._params[paramOffset + 3]._float,
         batch._params[paramOffset + 2]._float,
         batch._params[paramOffset + 1]._float,
@@ -651,7 +654,7 @@ void GLBackend::do_glUniform3fv(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     glUniform3fv(
-        batch._params[paramOffset + 2]._int,
+        _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 2]._int),
         batch._params[paramOffset + 1]._uint,
         (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint));
 
@@ -677,7 +680,7 @@ void GLBackend::do_glUniform4fv(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     
-    GLint location = batch._params[paramOffset + 2]._int;
+    GLint location = _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 2]._int);
     GLsizei count = batch._params[paramOffset + 1]._uint;
     const GLfloat* value = (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint);
     glUniform4fv(location, count, value);
@@ -703,7 +706,7 @@ void GLBackend::do_glUniform4iv(Batch& batch, size_t paramOffset) {
     }
     updatePipeline();
     glUniform4iv(
-        batch._params[paramOffset + 2]._int,
+        _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 2]._int),
         batch._params[paramOffset + 1]._uint,
         (const GLint*)batch.editData(batch._params[paramOffset + 0]._uint));
 
@@ -728,8 +731,9 @@ void GLBackend::do_glUniformMatrix4fv(Batch& batch, size_t paramOffset) {
         return;
     }
     updatePipeline();
+    GLint location = _pipeline._programShader->getUniformLocation(isStereo(), batch._params[paramOffset + 3]._int);
     glUniformMatrix4fv(
-        batch._params[paramOffset + 3]._int,
+        location,
         batch._params[paramOffset + 2]._uint,
         batch._params[paramOffset + 1]._uint,
         (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint));

libraries/gpu/src/gpu/GLBackend.h

@@ -153,11 +153,16 @@ public:
 
         using ShaderObjects = std::array< ShaderObject, NumVersions >;
 
+        using UniformMapping = std::map<GLint, GLint>;
+        using UniformMappingVersions = std::vector<UniformMapping>;
+        
         GLShader();
         ~GLShader();
 
         ShaderObjects _shaderObjects;
 
+        UniformMappingVersions _uniformMappings;
+
         GLuint getProgram(bool isStereo) const {
             if (isStereo && _shaderObjects[Stereo].glprogram) {
                 return _shaderObjects[Stereo].glprogram;
@@ -165,6 +170,15 @@ public:
                 return _shaderObjects[Mono].glprogram;
             }
         }
+
+        GLint getUniformLocation(bool isStereo, GLint srcLoc) {
+            if (isStereo) {
+                if (srcLoc >= 0) {
+                    return _uniformMappings[0][srcLoc];
+                }
+            }
+            return srcLoc;
+        }
     };
     static GLShader* syncGPUObject(const Shader& shader);
 
@@ -467,6 +481,7 @@ protected:
         PipelinePointer _pipeline;
 
         GLuint _program;
+        GLShader* _programShader;
         bool _invalidProgram;
 
         State::Data _stateCache;
@@ -478,6 +493,7 @@ protected:
         PipelineStageState() :
             _pipeline(),
             _program(0),
+            _programShader(nullptr),
             _invalidProgram(false),
             _stateCache(State::DEFAULT),
             _stateSignatureCache(0),

libraries/gpu/src/gpu/GLBackendPipeline.cpp

@@ -69,6 +69,7 @@ void GLBackend::do_setPipeline(Batch& batch, size_t paramOffset) {
         _pipeline._pipeline.reset();
 
         _pipeline._program = 0;
+        _pipeline._programShader = nullptr;
         _pipeline._invalidProgram = true;
 
         _pipeline._state = nullptr;
@@ -84,6 +85,7 @@ void GLBackend::do_setPipeline(Batch& batch, size_t paramOffset) {
         GLuint glprogram = pipelineObject->_program->getProgram(isStereo());
         if (_pipeline._program != glprogram) {
             _pipeline._program = glprogram;
+            _pipeline._programShader = pipelineObject->_program;
             _pipeline._invalidProgram = true;
         }
 
@@ -144,6 +146,7 @@ void GLBackend::resetPipelineStage() {
     // Second the shader side
     _pipeline._invalidProgram = false;
     _pipeline._program = 0;
+    _pipeline._programShader = nullptr;
     _pipeline._pipeline.reset();
     glUseProgram(0);
 }

libraries/gpu/src/gpu/GLBackendShader.cpp

@@ -42,8 +42,9 @@ bool compileShader(GLenum shaderDomain, const std::string& shaderSource, const s
     }
 
     // Assign the source
+    const int NUM_SOURCE_STRINGS = 3;
     const GLchar* srcstr[] = { "#version 410 core\n", defines.c_str(), shaderSource.c_str() };
-    glShaderSource(glshader, 3, srcstr, NULL);
+    glShaderSource(glshader, NUM_SOURCE_STRINGS, srcstr, NULL);
 
     // Compile !
     glCompileShader(glshader);
@@ -79,7 +80,9 @@ bool compileShader(GLenum shaderDomain, const std::string& shaderSource, const s
         */
 
         qCWarning(gpulogging) << "GLShader::compileShader - failed to compile the gl shader object:";
-        qCWarning(gpulogging) << srcstr;
+        for (auto s : srcstr) {
+            qCWarning(gpulogging) << s;
+        }
         qCWarning(gpulogging) << "GLShader::compileShader - errors:";
         qCWarning(gpulogging) << temp;
         delete[] temp;
@@ -295,21 +298,34 @@ GLBackend::GLShader* compileBackendShader(const Shader& shader) {
     const std::string& shaderSource = shader.getSource().getCode();
 
     // Shader domain
-    const GLenum SHADER_DOMAINS[2] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER };
+    const int NUM_SHADER_DOMAINS = 2;
+    const GLenum SHADER_DOMAINS[NUM_SHADER_DOMAINS] = {
+        GL_VERTEX_SHADER,
+        GL_FRAGMENT_SHADER
+    };
     GLenum shaderDomain = SHADER_DOMAINS[shader.getType()];
 
-    // Make several versions of the shader
-    std::string shaderDefines[GLBackend::GLShader::NumVersions] = {
+    // Domain specific defines
+    const std::string domainDefines[NUM_SHADER_DOMAINS] = {
+        "#define VERTEX_SHADER",
+        "#define PIXEL_SHADER"
+    };
+
+    // Versions specific of the shader
+    const std::string versionDefines[GLBackend::GLShader::NumVersions] = {
         "",
         "#define GPU_TRANSFORM_IS_STEREO"
     };
 
+
     GLBackend::GLShader::ShaderObjects shaderObjects;
 
     for (int version = 0; version < GLBackend::GLShader::NumVersions; version++) {
         auto& shaderObject = shaderObjects[version];
 
-        bool result = compileShader(shaderDomain, shaderSource, shaderDefines[version], shaderObject.glshader, shaderObject.glprogram);
+        std::string shaderDefines = domainDefines[shader.getType()] + "\n" + versionDefines[version];
+
+        bool result = compileShader(shaderDomain, shaderSource, shaderDefines, shaderObject.glshader, shaderObject.glprogram);
         if (!result) {
             return nullptr;
         }
@@ -742,7 +758,6 @@ bool GLBackend::makeProgram(Shader& shader, const Shader::BindingSet& slotBindin
     // APply bindings to all program versions and generate list of slots from default version
     for (int version = 0; version < GLBackend::GLShader::NumVersions; version++) {
         auto& shaderObject = object->_shaderObjects[version];
-
         if (shaderObject.glprogram) {
             Shader::SlotSet buffers;
             makeUniformBlockSlots(shaderObject.glprogram, slotBindings, buffers);
@@ -761,6 +776,12 @@ bool GLBackend::makeProgram(Shader& shader, const Shader::BindingSet& slotBindin
             // Define the public slots only from the default version
             if (version == 0) {
                 shader.defineSlots(uniforms, buffers, textures, samplers, inputs, outputs);
+            } else {
+                GLShader::UniformMapping mapping;
+                for (auto srcUniform : shader.getUniforms()) {
+                    mapping[srcUniform._location] = uniforms.findLocation(srcUniform._name);
+                }
+                object->_uniformMappings.push_back(mapping);
             }
         }
     }

libraries/gpu/src/gpu/Transform.slh

@@ -27,10 +27,23 @@ layout(std140) uniform transformCameraBuffer {
     TransformCamera _camera;
 #endif
 };
+
+#ifdef GPU_TRANSFORM_IS_STEREO
+#ifdef VERTEX_SHADER
+flat out int _stereoSide;
+#endif
+
+#ifdef PIXEL_SHADER
+flat in int _stereoSide;
+#endif
+#endif
+
 TransformCamera getTransformCamera() {
 #ifdef GPU_TRANSFORM_IS_STEREO
-    uint eyeIndex = gl_InstanceID % 2;
-    return _camera[eyeIndex];
+#ifdef VERTEX_SHADER
+    _stereoSide = gl_InstanceID % 2;
+#endif
+    return _camera[_stereoSide];
 #else
     return _camera;
 #endif
@@ -77,8 +90,8 @@ TransformObject getTransformObject() {
 
 
 <@func declareStandardTransform()@>
-<$declareStandardObjectTransform()$>
 <$declareStandardCameraTransform()$>
+<$declareStandardObjectTransform()$>
 <@endfunc@>
 
 <@func transformCameraViewport(cameraTransform, viewport)@>

libraries/render-utils/src/MeshPartPayload.cpp

@@ -246,7 +246,8 @@ void MeshPartPayload::bindMaterial(gpu::Batch& batch, const ShapePipeline::Locat
 
     // Texcoord transforms ?
     if (locations->texcoordMatrices >= 0) {
-        batch._glUniformMatrix4fv(locations->texcoordMatrices, 2, false, (const float*)&texcoordTransform);
+        //batch._glUniformMatrix4fv(locations->texcoordMatrices, 2, false, (const float*)&texcoordTransform);
+        batch._glUniformMatrix4fv(locations->texcoordMatrices, (materialKey.isLightmapMap() ? 2 : 1), false, (const float*)&texcoordTransform);
     }
 }