Removing the different versions of stereo drawcall to make a simple PR

libraries/gpu/src/gpu/GLBackend.cpp

@@ -253,23 +253,11 @@ void GLBackend::render(Batch& batch) {
         renderPassTransfer(batch);
     }
 
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-    if (_stereo._enable) {
-        glEnable(GL_CLIP_DISTANCE0);
-    }
-#endif
-
     {
         PROFILE_RANGE(_stereo._enable ? "Render Stereo" : "Render");
         renderPassDraw(batch);
     }
 
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-    if (_stereo._enable) {
-        glDisable(GL_CLIP_DISTANCE0);
-    }
-#endif
-
     // Restore the saved stereo state for the next batch
     _stereo._enable = savedStereo;
 }
@@ -325,23 +313,13 @@ void GLBackend::syncCache() {
     glEnable(GL_LINE_SMOOTH);
 }
 
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
 void GLBackend::setupStereoSide(int side) {
     ivec4 vp = _transform._viewport;
     vp.z /= 2;
     glViewport(vp.x + side * vp.z, vp.y, vp.z, vp.w);
 
-
-#ifdef GPU_STEREO_CAMERA_BUFFER
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
-    glVertexAttribI1i(14, side);
-#endif
-#else
     _transform.bindCurrentCamera(side);
-#endif
-
 }
-#endif
 
 
 void GLBackend::do_draw(Batch& batch, size_t paramOffset) {
@@ -351,15 +329,11 @@ void GLBackend::do_draw(Batch& batch, size_t paramOffset) {
     uint32 startVertex = batch._params[paramOffset + 0]._uint;
 
     if (isStereo()) {
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
-#endif
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
         setupStereoSide(0);
         glDrawArrays(mode, startVertex, numVertices);
         setupStereoSide(1);
         glDrawArrays(mode, startVertex, numVertices);
-#endif
+
         _stats._DSNumTriangles += 2 * numVertices / 3;
         _stats._DSNumDrawcalls += 2;
 
@@ -385,15 +359,11 @@ void GLBackend::do_drawIndexed(Batch& batch, size_t paramOffset) {
     GLvoid* indexBufferByteOffset = reinterpret_cast<GLvoid*>(startIndex * typeByteSize + _input._indexBufferOffset);
 
     if (isStereo()) {
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-        glDrawElementsInstanced(mode, numIndices, glType, indexBufferByteOffset, 2);
-#endif
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
         setupStereoSide(0);
         glDrawElements(mode, numIndices, glType, indexBufferByteOffset);
         setupStereoSide(1);
         glDrawElements(mode, numIndices, glType, indexBufferByteOffset);
-#endif
+
         _stats._DSNumTriangles += 2 * numIndices / 3;
         _stats._DSNumDrawcalls += 2;
     } else {
@@ -417,15 +387,11 @@ void GLBackend::do_drawInstanced(Batch& batch, size_t paramOffset) {
     if (isStereo()) {
         GLint trueNumInstances = (isStereo() ? 2 * numInstances : numInstances);
 
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-        glDrawArraysInstancedARB(mode, startVertex, numVertices, trueNumInstances);
-#endif
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
         setupStereoSide(0);
         glDrawArraysInstancedARB(mode, startVertex, numVertices, numInstances);
         setupStereoSide(1);
         glDrawArraysInstancedARB(mode, startVertex, numVertices, numInstances);
-#endif
+
         _stats._DSNumTriangles += (trueNumInstances * numVertices) / 3;
         _stats._DSNumDrawcalls += trueNumInstances;
     } else {
@@ -464,23 +430,15 @@ void GLBackend::do_drawIndexedInstanced(Batch& batch, size_t paramOffset) {
     if (isStereo()) {
         GLint trueNumInstances = (isStereo() ? 2 * numInstances : numInstances);
 
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-        glbackend_glDrawElementsInstancedBaseVertexBaseInstance(mode, numIndices, glType, indexBufferByteOffset, trueNumInstances, 0, startInstance);
-#endif
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
         setupStereoSide(0);
         glbackend_glDrawElementsInstancedBaseVertexBaseInstance(mode, numIndices, glType, indexBufferByteOffset, numInstances, 0, startInstance);
         setupStereoSide(1);
         glbackend_glDrawElementsInstancedBaseVertexBaseInstance(mode, numIndices, glType, indexBufferByteOffset, numInstances, 0, startInstance);
-#endif
+
         _stats._DSNumTriangles += (trueNumInstances * numIndices) / 3;
         _stats._DSNumDrawcalls += trueNumInstances;
     } else {
-#if (GPU_INPUT_PROFILE == GPU_CORE_43)
+        glbackend_glDrawElementsInstancedBaseVertexBaseInstance(mode, numIndices, glType, indexBufferByteOffset, numInstances, 0, startInstance);
-        glDrawElementsInstancedBaseVertexBaseInstance(mode, numIndices, glType, indexBufferByteOffset, numInstances, 0, startInstance);
-#else
-        glDrawElementsInstanced(mode, numIndices, glType, indexBufferByteOffset, numInstances);
-#endif
         _stats._DSNumTriangles += (numInstances * numIndices) / 3;
         _stats._DSNumDrawcalls += numInstances;
     }

libraries/gpu/src/gpu/GLBackend.h

@@ -23,27 +23,6 @@
 
 #include "Context.h"
 
-// Pick one from the 3: THis version is the most efficient as of now
-#define GPU_STEREO_TECHNIQUE_DOUBLED_SIMPLE
-//#define GPU_STEREO_TECHNIQUE_DOUBLED_SMARTER
-//#define GPU_STEREO_TECHNIQUE_INSTANCED
-
-
-// Let these be configured by the one define picked above
-#ifdef GPU_STEREO_TECHNIQUE_DOUBLED_SIMPLE
-#define GPU_STEREO_DRAWCALL_DOUBLED
-#endif
-
-#ifdef GPU_STEREO_TECHNIQUE_DOUBLED_SMARTER
-#define GPU_STEREO_DRAWCALL_DOUBLED
-#define GPU_STEREO_CAMERA_BUFFER
-#endif
-
-#ifdef GPU_STEREO_TECHNIQUE_INSTANCED
-#define GPU_STEREO_DRAWCALL_INSTANCED
-#define GPU_STEREO_CAMERA_BUFFER
-#endif
-
 namespace gpu {
 
 class GLTextureTransferHelper;
@@ -177,7 +156,6 @@ public:
     public:
         enum Version {
             Mono = 0,
-            Stereo,
 
             NumVersions
         };
@@ -205,7 +183,7 @@ public:
         }
 
         GLint getUniformLocation(GLint srcLoc, Version version = Mono) {
-            // THIS will be used in the next PR
+            // THIS will be used in the future PR as we grow the number of versions
             // return _uniformMappings[version][srcLoc];
             return srcLoc;
         }
@@ -348,9 +326,7 @@ protected:
     void renderPassTransfer(Batch& batch);
     void renderPassDraw(Batch& batch);
 
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
     void setupStereoSide(int side);
-#endif
 
     void initTextureTransferHelper();
     static void transferGPUObject(const TexturePointer& texture);
@@ -434,19 +410,7 @@ protected:
     void resetTransformStage();
 
     struct TransformStageState {
-#ifdef GPU_STEREO_CAMERA_BUFFER
-        struct Cameras {
-            TransformCamera _cams[2];
-
-            Cameras() {};
-            Cameras(const TransformCamera& cam) { memcpy(_cams, &cam, sizeof(TransformCamera)); };
-            Cameras(const TransformCamera& camL, const TransformCamera& camR) { memcpy(_cams, &camL, sizeof(TransformCamera)); memcpy(_cams + 1, &camR, sizeof(TransformCamera)); };
-        };
-
-        using CameraBufferElement = Cameras;
-#else
         using CameraBufferElement = TransformCamera;
-#endif
         using TransformCameras = std::vector<CameraBufferElement>;
 
         TransformCamera _camera;

libraries/gpu/src/gpu/GLBackendShader.cpp

@@ -312,24 +312,13 @@ GLBackend::GLShader* compileBackendShader(const Shader& shader) {
 
     // Domain specific defines
     const std::string domainDefines[NUM_SHADER_DOMAINS] = {
-        "#define VERTEX_SHADER",
+        "#define GPU_VERTEX_SHADER",
-        "#define PIXEL_SHADER"
+        "#define GPU_PIXEL_SHADER"
     };
 
     // Versions specific of the shader
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-    const std::string stereoVersion("#define GPU_TRANSFORM_IS_STEREO\n#define GPU_TRANSFORM_STEREO_CAMERA\n#define GPU_TRANSFORM_STEREO_CAMERA_INSTANCED\n#define GPU_TRANSFORM_STEREO_SPLIT_SCREEN");
-#endif
-#ifdef GPU_STEREO_DRAWCALL_DOUBLED
-#ifdef GPU_STEREO_CAMERA_BUFFER
-    const std::string stereoVersion("#define GPU_TRANSFORM_IS_STEREO\n#define GPU_TRANSFORM_STEREO_CAMERA\n#define GPU_TRANSFORM_STEREO_CAMERA_ATTRIBUTED");
-#else
-    const std::string stereoVersion("#define GPU_TRANSFORM_IS_STEREO");
-#endif
-#endif
     const std::string versionDefines[GLBackend::GLShader::NumVersions] = {
-        "",
+        ""
-        stereoVersion
     };
 
     GLBackend::GLShader::ShaderObjects shaderObjects;

libraries/gpu/src/gpu/GLBackendTransform.cpp

@@ -31,25 +31,10 @@ void GLBackend::do_setProjectionTransform(Batch& batch, size_t paramOffset) {
 void GLBackend::do_setViewportTransform(Batch& batch, size_t paramOffset) {
     memcpy(&_transform._viewport, batch.editData(batch._params[paramOffset]._uint), sizeof(Vec4i));
 
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-    {
-        ivec4& vp = _transform._viewport;
-        glViewport(vp.x, vp.y, vp.z, vp.w);
-
-        // Where we assign the GL viewport
-        if (_stereo._enable) {
-            vp.z /= 2;
-            if (_stereo._pass) {
-                vp.x += vp.z;
-            }
-        }
-    } 
-#else
     if (!_inRenderTransferPass && !isStereo()) {
         ivec4& vp = _transform._viewport;
         glViewport(vp.x, vp.y, vp.z, vp.w);
     }
-#endif
 
     // The Viewport is tagged invalid because the CameraTransformUBO is not up to date and will need update on next drawcall
     _transform._invalidViewport = true;
@@ -121,18 +106,10 @@ void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const Stereo
         size_t offset = _cameraUboSize * _cameras.size();
         _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
         if (stereo._enable) {
-#ifdef GPU_STEREO_CAMERA_BUFFER
-            _cameras.push_back(CameraBufferElement(_camera.getEyeCamera(0, stereo, _view), _camera.getEyeCamera(1, stereo, _view)));
-#else
             _cameras.push_back((_camera.getEyeCamera(0, stereo, _view)));
             _cameras.push_back((_camera.getEyeCamera(1, stereo, _view)));
-#endif
         } else {
-#ifdef GPU_STEREO_CAMERA_BUFFER
-            _cameras.push_back(CameraBufferElement(_camera.recomputeDerived(_view)));
-#else
             _cameras.push_back((_camera.recomputeDerived(_view)));
-#endif
         }
 
     }
@@ -206,13 +183,9 @@ void GLBackend::TransformStageState::update(size_t commandIndex, const StereoSta
     }
 
     if (offset != INVALID_OFFSET) {
-#ifdef GPU_STEREO_CAMERA_BUFFER
-        bindCurrentCamera(0);
-#else 
         if (!stereo._enable) {
             bindCurrentCamera(0);
         }
-#endif
     }
     (void)CHECK_GL_ERROR();
 }
@@ -236,12 +209,7 @@ void GLBackend::updateTransform(const Batch& batch) {
         glBindBuffer(GL_ARRAY_BUFFER, _transform._drawCallInfoBuffer);
         glVertexAttribIPointer(gpu::Stream::DRAW_CALL_INFO, 2, GL_UNSIGNED_SHORT, 0,
                                _transform._drawCallInfoOffsets[batch._currentNamedCall]);
-
-#ifdef GPU_STEREO_DRAWCALL_INSTANCED
-        glVertexAttribDivisor(gpu::Stream::DRAW_CALL_INFO, (isStereo() ? 2 : 1));
-#else
         glVertexAttribDivisor(gpu::Stream::DRAW_CALL_INFO, 1);
-#endif
     }
     
     (void)CHECK_GL_ERROR();

libraries/gpu/src/gpu/Transform.slh

@@ -21,56 +21,11 @@ struct TransformCamera {
 };
 
 layout(std140) uniform transformCameraBuffer {
-#ifdef GPU_TRANSFORM_IS_STEREO
-#ifdef GPU_TRANSFORM_STEREO_CAMERA
-   TransformCamera _camera[2];
-#else
     TransformCamera _camera;
-#endif
-#else
-    TransformCamera _camera;
-#endif
 };
 
-#ifdef VERTEX_SHADER
-#ifdef GPU_TRANSFORM_IS_STEREO
-
-#ifdef GPU_TRANSFORM_STEREO_CAMERA
-#ifdef GPU_TRANSFORM_STEREO_CAMERA_ATTRIBUTED
-layout(location=14) in int _inStereoSide;
-#endif
-
-flat out int _stereoSide;
-#endif
-
-#endif
-
-#endif
-
-#ifdef PIXEL_SHADER
-#ifdef GPU_TRANSFORM_STEREO_CAMERA
-flat in int _stereoSide;
-#endif
-#endif
-
 TransformCamera getTransformCamera() {
-#ifdef GPU_TRANSFORM_IS_STEREO
-    #ifdef GPU_TRANSFORM_STEREO_CAMERA
-        #ifdef VERTEX_SHADER
-            #ifdef GPU_TRANSFORM_STEREO_CAMERA_ATTRIBUTED
-                _stereoSide = _inStereoSide;
-            #endif
-            #ifdef GPU_TRANSFORM_STEREO_CAMERA_INSTANCED
-                _stereoSide = gl_InstanceID % 2;
-            #endif
-        #endif
-        return _camera[_stereoSide];
-    #else
-        return _camera;
-    #endif
-#else
     return _camera;
-#endif
 }
 <@endfunc@>
 
@@ -122,25 +77,6 @@ TransformObject getTransformObject() {
      <$viewport$> = <$cameraTransform$>._viewport;
 <@endfunc@>
 
-<@func transformStereoClipsSpace(cameraTransform, clipPos)@>
-    {
-#ifdef GPU_TRANSFORM_IS_STEREO
-
-#ifdef GPU_TRANSFORM_STEREO_SPLIT_SCREEN
-        vec4 eyeClipEdge[2]= vec4[2](vec4(-1,0,0,1), vec4(1,0,0,1));
-        vec2 eyeOffsetScale = vec2(-0.5, +0.5);
-        uint eyeIndex = _stereoSide;
-        gl_ClipDistance[0] = dot(<$clipPos$>, eyeClipEdge[eyeIndex]);
-        float newClipPosX = <$clipPos$>.x * 0.5 + eyeOffsetScale[eyeIndex] * <$clipPos$>.w;
-        <$clipPos$>.x = newClipPosX;
-#endif
-
-#else
-#endif
-    }
-<@endfunc@>
-
-
 <@func transformModelToEyeWorldAlignedPos(cameraTransform, objectTransform, modelPos, eyeWorldAlignedPos)@>
     <!// Bring the model pos in the world aligned space centered on the eye axis !>
     { // _transformModelToEyeWorldAlignedPos
@@ -157,8 +93,6 @@ TransformObject getTransformObject() {
         <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
 
         <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos;
-        
-        <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$>
     }
 <@endfunc@>
 
@@ -168,8 +102,6 @@ TransformObject getTransformObject() {
         <$transformModelToEyeWorldAlignedPos($cameraTransform$, $objectTransform$, $modelPos$, eyeWAPos)$>
         <$clipPos$> = <$cameraTransform$>._projectionViewUntranslated * eyeWAPos;
         <$eyePos$> = vec4((<$cameraTransform$>._view * vec4(eyeWAPos.xyz, 0.0)).xyz, 1.0);
-        
-        <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$>
     }
 <@endfunc@>
 
@@ -217,8 +149,6 @@ TransformObject getTransformObject() {
 <@func transformEyeToClipPos(cameraTransform, eyePos, clipPos)@>
     { // transformEyeToClipPos
         <$clipPos$> = <$cameraTransform$>._projection * vec4(<$eyePos$>.xyz, 1.0);
-
-        <$transformStereoClipsSpace($cameraTransform$, $clipPos$)$>
     }
 <@endfunc@>