#5912: Before drawing any geometry, make sure everything is committed…

… to the IGeometryStore

radiantcore/rendersystem/backend/FullBrightRenderer.cpp

@@ -1,6 +1,7 @@
 #include "FullBrightRenderer.h"
 
 #include "OpenGLShaderPass.h"
+#include "OpenGLShader.h"
 
 namespace render
 {
@@ -29,6 +30,12 @@ class FullBrightRenderResult :
 
 IRenderResult::Ptr FullBrightRenderer::render(RenderStateFlags globalstate, const IRenderView& view, std::size_t time)
 {
+    // Make sure all the geometry is ready for rendering
+    for (const auto& [_, pass] : _sortedStates)
+    {
+        pass->getShader().prepareForRendering();
+    }
+
     // Construct default OpenGL state
     OpenGLState current;
     setupState(current);

radiantcore/rendersystem/backend/LightingModeRenderer.cpp

@@ -45,6 +45,8 @@ IRenderResult::Ptr LightingModeRenderer::render(RenderStateFlags globalFlagsMask
         interactionLists.emplace_back(std::move(interaction));
     }
 
+    // Past this point, everything in the geometry store is up to date
+
     // Run the depth fill pass
     for (auto& interactionList : interactionLists)
     {

radiantcore/rendersystem/backend/OpenGLShader.cpp

@@ -135,6 +135,13 @@ bool OpenGLShader::hasSurfaces() const
     return !_geometryRenderer.empty() || !_surfaceRenderer.empty();
 }
 
+void OpenGLShader::prepareForRendering()
+{
+    _surfaceRenderer.prepareForRendering();
+    _windingRenderer->prepareForRendering();
+    // _geometryRenderer doesn't need to prepare at this point
+}
+
 IGeometryRenderer::Slot OpenGLShader::addGeometry(GeometryType indexType,
     const std::vector<MeshVertex>& vertices, const std::vector<unsigned int>& indices)
 {

radiantcore/rendersystem/backend/OpenGLShader.h

@@ -104,6 +104,7 @@ class OpenGLShader :
 
     bool hasSurfaces() const;
     void drawSurfaces(const VolumeTest& view);
+    void prepareForRendering();
 
     IGeometryRenderer::Slot addGeometry(GeometryType indexType,
         const std::vector<MeshVertex>& vertices, const std::vector<unsigned int>& indices) override;

radiantcore/rendersystem/backend/OpenGLShaderPass.h

@@ -87,6 +87,11 @@ class OpenGLShaderPass
 		_owner(owner)
 	{}
 
+    OpenGLShader& getShader()
+    {
+        return _owner;
+    }
+
     // Returns true if the stage associated to this pass is active and should be rendered
     bool stateIsActive();
 

radiantcore/rendersystem/backend/SurfaceRenderer.h

@@ -33,10 +33,14 @@ class SurfaceRenderer :
 
     Slot _freeSlotMappingHint;
 
+    std::vector<Slot> _surfacesNeedingUpdate;
+    bool _surfacesNeedUpdate;
+
 public:
     SurfaceRenderer(IGeometryStore& store) :
         _store(store),
-        _freeSlotMappingHint(0)
+        _freeSlotMappingHint(0),
+        _surfacesNeedUpdate(false)
     {}
 
     bool empty() const
@@ -78,6 +82,8 @@ class SurfaceRenderer :
     void updateSurface(Slot slot) override
     {
         _surfaces.at(slot).surfaceDataChanged = true;
+        _surfacesNeedingUpdate.push_back(slot);
+        _surfacesNeedUpdate = true;
     }
 
     void render(const VolumeTest& view)
@@ -98,6 +104,27 @@ class SurfaceRenderer :
         return _surfaces.at(slot).storageHandle;
     }
 
+    // Ensures the data in the IGeometryStore is up to date
+    void prepareForRendering()
+    {
+        if (!_surfacesNeedUpdate) return;
+
+        _surfacesNeedUpdate = false;
+
+        for (auto slotIndex : _surfacesNeedingUpdate)
+        {
+            auto& surfaceInfo = _surfaces.at(slotIndex);
+
+            if (surfaceInfo.surfaceDataChanged)
+            {
+                surfaceInfo.surfaceDataChanged = false;
+
+                auto& surface = surfaceInfo.surface.get();
+                _store.updateData(surfaceInfo.storageHandle, surface.getVertices(), surface.getIndices());
+            }
+        }
+    }
+
 private:
     void renderSlot(SurfaceInfo& slot, const VolumeTest* view = nullptr)
     {

radiantcore/rendersystem/backend/WindingRenderer.h

@@ -23,6 +23,9 @@ class IBackendWindingRenderer :
 
     // Submit the geometry of all windings in this renderer
     virtual void renderAllWindings() = 0;
+
+    // Ensures that everything in the IGeometryStore is up to date
+    virtual void prepareForRendering() = 0;
 };
 
 // Traits class to retrieve the GLenum render mode based on the indexer type
@@ -343,12 +346,15 @@ class WindingRenderer final :
 
     std::unique_ptr<EntityWindings> _entitySurfaces;
 
+    bool _geometryUpdatePending;
+
 public:
     WindingRenderer(IGeometryStore& geometryStore, Shader* owningShader) :
         _geometryStore(geometryStore),
         _owningShader(owningShader),
         _windingCount(0),
-        _freeSlotMappingHint(InvalidSlotMapping)
+        _freeSlotMappingHint(InvalidSlotMapping),
+        _geometryUpdatePending(false)
     {
         if (RenderingTraits<WindingIndexerT>::SupportsEntitySurfaces())
         {
@@ -484,12 +490,10 @@ class WindingRenderer final :
 
     void renderAllWindings() override
     {
-        for (auto bucketIndex = 0; bucketIndex < _buckets.size(); ++bucketIndex)
-        {
-            auto& bucket = _buckets[bucketIndex];
-
-            ensureBucketIsReady(bucket);
+        assert(!_geometryUpdatePending); // prepareForRendering should have been called
 
+        for (auto& bucket : _buckets)
+        {
             if (bucket.storageHandle == InvalidStorageHandle) continue; // nothing here
 
             auto primitiveMode = RenderingTraits<WindingIndexerT>::Mode();
@@ -499,14 +503,14 @@ class WindingRenderer final :
 
     void renderWinding(IWindingRenderer::RenderMode mode, IWindingRenderer::Slot slot) override
     {
+        assert(!_geometryUpdatePending); // prepareForRendering should have been called
+
         assert(slot < _slots.size());
         auto& slotMapping = _slots[slot];
 
         assert(slotMapping.bucketIndex != InvalidBucketIndex);
         auto& bucket = _buckets[slotMapping.bucketIndex];
 
-        ensureBucketIsReady(bucket);
-
         const auto& vertices = bucket.buffer.getVertices();
         const auto& indices = bucket.buffer.getIndices();
 
@@ -526,6 +530,19 @@ class WindingRenderer final :
         }
     }
 
+    // Ensure all data is written to the IGeometryStore
+    void prepareForRendering()
+    {
+        if (!_geometryUpdatePending) return;
+
+        _geometryUpdatePending = false;
+
+        for (auto& bucket : _buckets)
+        {
+            ensureBucketIsReady(bucket);
+        }
+    }
+
 private:
     void ensureBucketIsReady(BucketIndex bucketIndex)
     {
@@ -543,6 +560,7 @@ class WindingRenderer final :
         // Update the modified range
         bucket.modifiedSlotRange.first = std::min(bucket.modifiedSlotRange.first, modifiedSlot);
         bucket.modifiedSlotRange.second = std::max(bucket.modifiedSlotRange.second, modifiedSlot);
+        _geometryUpdatePending = true;
     }
 
     // Commit all local buffer changes to the geometry store