#5912: Code cleanup in WindingRenderer and callers

radiantcore/rendersystem/backend/OpenGLShader.cpp

@@ -101,7 +101,7 @@ void OpenGLShader::addRenderable(const OpenGLRenderable& renderable,
     }
 }
 
-void OpenGLShader::drawSurfaces(const VolumeTest& view, const RenderInfo& info)
+void OpenGLShader::drawSurfaces(const VolumeTest& view)
 {
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
@@ -123,7 +123,7 @@ void OpenGLShader::drawSurfaces(const VolumeTest& view, const RenderInfo& info)
 
     // Render all windings (without vertex colours)
     glDisableClientState(GL_COLOR_ARRAY);
-    _windingRenderer->renderAllWindings(info.checkFlag(RENDER_BUMP));
+    _windingRenderer->renderAllWindings();
 
     glDisableClientState(GL_NORMAL_ARRAY);
     glDisableClientState(GL_COLOR_ARRAY);

radiantcore/rendersystem/backend/OpenGLShader.h

@@ -103,7 +103,7 @@ class OpenGLShader :
 					   const Matrix4& modelview) override;
 
     bool hasSurfaces() const;
-    void drawSurfaces(const VolumeTest& view, const RenderInfo& info);
+    void drawSurfaces(const VolumeTest& view);
 
     IGeometryRenderer::Slot addGeometry(GeometryType indexType,
         const std::vector<ArbitraryMeshVertex>& vertices, const std::vector<unsigned int>& indices) override;

radiantcore/rendersystem/backend/OpenGLShaderPass.cpp

@@ -525,10 +525,9 @@ void OpenGLShaderPass::render(OpenGLState& current,
     glMatrixMode(GL_MODELVIEW);
 
     // Apply our state to the current state object
-    applyState(current, flagsMask, viewer, time, NULL);
+    applyState(current, flagsMask, viewer, time, nullptr);
 
-    RenderInfo info(current.getRenderFlags(), viewer, current.cubeMapMode);
-    _owner.drawSurfaces(view, info);
+    _owner.drawSurfaces(view);
 
     if (!_renderablesWithoutEntity.empty())
     {

radiantcore/rendersystem/backend/WindingRenderer.h

@@ -21,8 +21,8 @@ class IBackendWindingRenderer :
     // Returns true if the vertex buffers are empty
     virtual bool empty() const = 0;
 
-    // Issues the openGL calls to render the vertex buffers
-    virtual void renderAllWindings(bool renderBump) = 0;
+    // Submit the geometry of all windings in this renderer
+    virtual void renderAllWindings() = 0;
 };
 
 // Traits class to retrieve the GLenum render mode based on the indexer type
@@ -437,45 +437,19 @@ class WindingRenderer final :
         }
     }
 
-    void renderAllWindings(bool renderBump) override
+    void renderAllWindings() override
     {
         for (auto bucketIndex = 0; bucketIndex < _buckets.size(); ++bucketIndex)
         {
             auto& bucket = _buckets[bucketIndex];
+
             commitDeletions(bucketIndex);
             syncWithGeometryStore(bucket);
 
-#if 0
-            if (bucket.buffer.getVertices().empty()) continue;
-
-            const auto& vertices = bucket.buffer.getVertices();
-            const auto& indices = bucket.buffer.getIndices();
-
-            glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &vertices.front().vertex);
-
-            if (renderBump)
-            {
-                glVertexAttribPointer(GLProgramAttribute::Normal, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &vertices.front().normal);
-                glVertexAttribPointer(GLProgramAttribute::TexCoord, 2, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &vertices.front().texcoord);
-                glVertexAttribPointer(GLProgramAttribute::Tangent, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &vertices.front().tangent);
-                glVertexAttribPointer(GLProgramAttribute::Bitangent, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &vertices.front().bitangent);
-            }
-            else
-            {
-                glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &vertices.front().texcoord);
-                glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), &vertices.front().normal);
-            }
-
-            auto primitiveMode = RenderingTraits<WindingIndexerT>::Mode();
-            glDrawElements(primitiveMode, static_cast<GLsizei>(indices.size()), GL_UNSIGNED_INT, &indices.front());
-
-            debug::checkGLErrors();
-#else
             if (bucket.storageHandle == InvalidStorageHandle) continue; // nothing here
 
             auto primitiveMode = RenderingTraits<WindingIndexerT>::Mode();
             ObjectRenderer::SubmitGeometry(bucket.storageHandle, primitiveMode, _geometryStore);
-#endif
         }
     }
 
@@ -501,11 +475,11 @@ class WindingRenderer final :
 
         if (mode == IWindingRenderer::RenderMode::Triangles)
         {
-            renderElements<WindingIndexer_Triangles>(bucket.buffer, slotMapping.slotNumber);
+            renderSingleWinding<WindingIndexer_Triangles>(bucket.buffer, slotMapping.slotNumber);
         }
         else if (mode == IWindingRenderer::RenderMode::Polygon)
         {
-            renderElements<WindingIndexer_Polygon>(bucket.buffer, slotMapping.slotNumber);
+            renderSingleWinding<WindingIndexer_Polygon>(bucket.buffer, slotMapping.slotNumber);
         }
     }
 
@@ -605,7 +579,7 @@ class WindingRenderer final :
         bucket.modifiedSlotRange.second = 0;
     }
 
-    void commitDeletions(std::size_t bucketIndex)
+    void commitDeletions(BucketIndex bucketIndex)
     {
         auto& bucket = _buckets[bucketIndex];
 
@@ -652,7 +626,7 @@ class WindingRenderer final :
     }
 
     template<class CustomWindingIndexerT>
-    void renderElements(const VertexBuffer& buffer, typename VertexBuffer::Slot slotNumber) const
+    void renderSingleWinding(const VertexBuffer& buffer, typename VertexBuffer::Slot slotNumber) const
     {
         std::vector<unsigned int> indices;
         indices.reserve(CustomWindingIndexerT::GetNumberOfIndicesPerWinding(buffer.getWindingSize()));