#5584: Start migrating the ModelScaleManipulator

codereader · Jan 22, 2022 · df5fa39 · df5fa39
1 parent f006295
commit df5fa39
Show file tree

Hide file tree

Showing 14 changed files with 161 additions and 20 deletions.
diff --git a/include/irender.h b/include/irender.h
@@ -259,7 +259,7 @@ class LitObject
 typedef std::shared_ptr<LitObject> LitObjectPtr;
 
 class Renderable;
-typedef std::function<void(const Renderable&)> RenderableCallback;
+typedef std::function<void(Renderable&)> RenderableCallback;
 
 typedef std::function<void(const RendererLight&)> RendererLightCallback;
 
@@ -589,8 +589,8 @@ class RenderSystem
     /// Set the shader program to use.
     virtual void setShaderProgram(ShaderProgram prog) = 0;
 
-    virtual void attachRenderable(const Renderable& renderable) = 0;
-    virtual void detachRenderable(const Renderable& renderable) = 0;
+    virtual void attachRenderable(Renderable& renderable) = 0;
+    virtual void detachRenderable(Renderable& renderable) = 0;
     virtual void forEachRenderable(const RenderableCallback& callback) const = 0;
 
   	// Initialises the OpenGL extensions

diff --git a/include/irenderable.h b/include/irenderable.h
@@ -36,7 +36,7 @@ class IRenderableCollector
     virtual ~IRenderableCollector() {}
 
     // Process the given renderable object
-    virtual void processRenderable(const Renderable& renderable, const VolumeTest& volume) = 0;
+    virtual void processRenderable(Renderable& renderable, const VolumeTest& volume) = 0;
 
     /**
      * \brief Submit a renderable object.

diff --git a/libs/render/CamRenderer.h b/libs/render/CamRenderer.h
@@ -197,8 +197,9 @@ class CamRenderer :
         ++_totalLights;
     }
 
-    void processRenderable(const Renderable& renderable, const VolumeTest& volume) override
+    void processRenderable(Renderable& renderable, const VolumeTest& volume) override
     {
+        renderable.onPreRender(volume);
         renderable.renderSolid(*this, volume);
     }
 

diff --git a/libs/render/RenderableCollectionWalker.h b/libs/render/RenderableCollectionWalker.h
@@ -32,7 +32,7 @@ class RenderableCollectionWalker
 
         // Submit any renderables that have been directly attached to the RenderSystem
 		// without belonging to an actual scene object
-		GlobalRenderSystem().forEachRenderable([&](const Renderable& renderable)
+		GlobalRenderSystem().forEachRenderable([&](Renderable& renderable)
 		{
 			collector.processRenderable(renderable, volume);
 		});

diff --git a/radiant/xyview/XYRenderer.h b/radiant/xyview/XYRenderer.h
@@ -61,8 +61,9 @@ class XYRenderer :
     // Ortho view never processes lights
     void addLight(const RendererLight&) override {}
 
-    void processRenderable(const Renderable& renderable, const VolumeTest& volume) override
+    void processRenderable(Renderable& renderable, const VolumeTest& volume) override
     {
+        renderable.onPreRender(volume);
         renderable.renderWireframe(*this, volume);
     }
 

diff --git a/radiantcore/rendersystem/OpenGLRenderSystem.cpp b/radiantcore/rendersystem/OpenGLRenderSystem.cpp
@@ -370,13 +370,13 @@ void OpenGLRenderSystem::eraseSortedState(const OpenGLStates::key_type& key) {
 }
 
 // renderables
-void OpenGLRenderSystem::attachRenderable(const Renderable& renderable) {
+void OpenGLRenderSystem::attachRenderable(Renderable& renderable) {
     ASSERT_MESSAGE(!m_traverseRenderablesMutex, "attaching renderable during traversal");
     ASSERT_MESSAGE(m_renderables.find(&renderable) == m_renderables.end(), "renderable could not be attached");
     m_renderables.insert(&renderable);
 }
 
-void OpenGLRenderSystem::detachRenderable(const Renderable& renderable) {
+void OpenGLRenderSystem::detachRenderable(Renderable& renderable) {
     ASSERT_MESSAGE(!m_traverseRenderablesMutex, "detaching renderable during traversal");
     ASSERT_MESSAGE(m_renderables.find(&renderable) != m_renderables.end(), "renderable could not be detached");
     m_renderables.erase(&renderable);
@@ -385,7 +385,7 @@ void OpenGLRenderSystem::detachRenderable(const Renderable& renderable) {
 void OpenGLRenderSystem::forEachRenderable(const RenderableCallback& callback) const {
     ASSERT_MESSAGE(!m_traverseRenderablesMutex, "for-each during traversal");
     m_traverseRenderablesMutex = true;
-    for (Renderables::const_iterator i = m_renderables.begin(); i != m_renderables.end(); ++i) {
+    for (Renderables::iterator i = m_renderables.begin(); i != m_renderables.end(); ++i) {
         callback(*(*i));
     }
     m_traverseRenderablesMutex = false;

diff --git a/radiantcore/rendersystem/OpenGLRenderSystem.h b/radiantcore/rendersystem/OpenGLRenderSystem.h
@@ -84,7 +84,7 @@ class OpenGLRenderSystem
 	bool shaderProgramsAvailable() const override;
 	void setShaderProgramsAvailable(bool available) override;
 
-	typedef std::set<const Renderable*> Renderables;
+	typedef std::set<Renderable*> Renderables;
 	Renderables m_renderables;
 	mutable bool m_traverseRenderablesMutex;
 
@@ -93,8 +93,8 @@ class OpenGLRenderSystem
 	void eraseSortedState(const OpenGLStates::key_type& key) override;
 
 	// renderables
-	void attachRenderable(const Renderable& renderable) override;
-	void detachRenderable(const Renderable& renderable) override;
+	void attachRenderable(Renderable& renderable) override;
+	void detachRenderable(Renderable& renderable) override;
 	void forEachRenderable(const RenderableCallback& callback) const override;
 
 	// RegisterableModule implementation

diff --git a/radiantcore/selection/RadiantSelectionSystem.cpp b/radiantcore/selection/RadiantSelectionSystem.cpp
@@ -290,6 +290,12 @@ void RadiantSelectionSystem::setActiveManipulator(std::size_t manipulatorId)
 		return;
 	}
 
+    // Remove any visuals from the previous manipulator
+    if (_activeManipulator)
+    {
+        _activeManipulator->clearRenderables();
+    }
+
 	_activeManipulator = found->second;
 
 	// Release the user lock when switching manipulators
@@ -871,7 +877,6 @@ void RadiantSelectionSystem::captureShaders()
     RotateManipulator::_stateOuter = GlobalRenderSystem().capture("$WIRE_OVERLAY");
 	RotateManipulator::_pivotPointShader = GlobalRenderSystem().capture("$POINT");
 	RotateManipulator::_glFont = GlobalOpenGL().getFont(manipulatorFontStyle, manipulatorFontSize);
-	ModelScaleManipulator::_lineShader = GlobalRenderSystem().capture("$WIRE_OVERLAY");
 	ModelScaleManipulator::_pointShader = GlobalRenderSystem().capture("$POINT");
 }
 
@@ -882,7 +887,6 @@ void RadiantSelectionSystem::releaseShaders()
     RotateManipulator::_glFont.reset();
 	RotateManipulator::_stateOuter.reset();
 	RotateManipulator::_pivotPointShader.reset();
-    ModelScaleManipulator::_lineShader.reset();
     ModelScaleManipulator::_pointShader.reset();
 }
 
@@ -950,13 +954,15 @@ void RadiantSelectionSystem::onPreRender(const VolumeTest& volume)
  */
 void RadiantSelectionSystem::renderSolid(IRenderableCollector& collector, const VolumeTest& volume) const
 {
+#if 0
     if (!nothingSelected())
 	{
         collector.setHighlightFlag(IRenderableCollector::Highlight::Faces, false);
         collector.setHighlightFlag(IRenderableCollector::Highlight::Primitives, false);
 
 		_activeManipulator->render(collector, volume);
     }
+#endif
 }
 
 void RadiantSelectionSystem::onSceneBoundsChanged()

diff --git a/radiantcore/selection/manipulators/ModelScaleManipulator.cpp b/radiantcore/selection/manipulators/ModelScaleManipulator.cpp
@@ -7,10 +7,16 @@ namespace selection
 
 ModelScaleManipulator::ModelScaleManipulator(ManipulationPivot& pivot) :
 	_pivot(pivot),
+    _renderableAABBs(_aabbs),
 	_renderableCornerPoints(GL_POINTS)
 {
 }
 
+ModelScaleManipulator::~ModelScaleManipulator()
+{
+    clearRenderables();
+}
+
 ModelScaleManipulator::Type ModelScaleManipulator::getType() const
 {
 	return Type::ModelScale;
@@ -65,8 +71,45 @@ bool ModelScaleManipulator::isSelected() const
 	return _curManipulatable != nullptr;
 }
 
+void ModelScaleManipulator::onPreRender(const RenderSystemPtr& renderSystem, const VolumeTest& volume)
+{
+    if (!renderSystem)
+    {
+        clearRenderables();
+        _aabbs.clear();
+        return;
+    }
+
+    if (!_lineShader)
+    {
+        _lineShader = renderSystem->capture("$WIRE_OVERLAY");
+    }
+
+    _aabbs.clear();
+
+    foreachSelectedTransformable([&](const scene::INodePtr& node, Entity* entity)
+    {
+        _aabbs.push_back(node->worldAABB());
+#if 0
+        Vector3 points[8];
+        aabb.getCorners(points);
+
+        bool isSelected = (node == _curManipulatable);
+
+        for (std::size_t i = 0; i < 8; ++i)
+        {
+            _renderableCornerPoints.push_back(VertexCb(points[i], isSelected ? COLOUR_SELECTED() : COLOUR_SCREEN()));
+        }
+#endif
+    });
+
+    _renderableAABBs.queueUpdate();
+    _renderableAABBs.update(_lineShader);
+}
+
 void ModelScaleManipulator::render(IRenderableCollector& collector, const VolumeTest& volume)
 {
+#if 0
 	_renderableAabbs.clear();
 	_renderableCornerPoints.clear();
 
@@ -92,6 +135,13 @@ void ModelScaleManipulator::render(IRenderableCollector& collector, const Volume
 	}
 
 	collector.addRenderable(*_pointShader, _renderableCornerPoints, Matrix4::getIdentity());
+#endif
+}
+
+void ModelScaleManipulator::clearRenderables()
+{
+    _renderableAABBs.clear();
+    _lineShader.reset();
 }
 
 void ModelScaleManipulator::foreachSelectedTransformable(
@@ -108,7 +158,6 @@ void ModelScaleManipulator::foreachSelectedTransformable(
 	});
 }
 
-ShaderPtr ModelScaleManipulator::_lineShader;
 ShaderPtr ModelScaleManipulator::_pointShader;
 
 }

diff --git a/radiantcore/selection/manipulators/ModelScaleManipulator.h b/radiantcore/selection/manipulators/ModelScaleManipulator.h
@@ -10,13 +10,14 @@
 #include "selection/BasicSelectable.h"
 
 #include "entitylib.h"
+#include "Renderables.h"
 
 class Entity;
 
 namespace selection
 {
 
-class ModelScaleManipulator :
+class ModelScaleManipulator final :
 	public ManipulatorBase
 {
 private:
@@ -25,23 +26,30 @@ class ModelScaleManipulator :
 	// Resize component
 	ModelScaleComponent _scaleComponent;
 
-	std::list<RenderableSolidAABB> _renderableAabbs;
+    ShaderPtr _lineShader;
+
+	std::vector<AABB> _aabbs;
+    RenderableBoundingBoxes _renderableAABBs;
 	RenderablePointVector _renderableCornerPoints;
 
+
+
 	scene::INodePtr _curManipulatable;
 
 public:
-	static ShaderPtr _lineShader;
 	static ShaderPtr _pointShader;
 
 	ModelScaleManipulator(ManipulationPivot& pivot);
+    ~ModelScaleManipulator();
 
 	Type getType() const override;
 	Component* getActiveComponent() override;
 	void testSelect(SelectionTest& test, const Matrix4& pivot2world) override;
 	void setSelected(bool select) override;
 	bool isSelected() const override;
+    void onPreRender(const RenderSystemPtr& renderSystem, const VolumeTest& volume) override;
 	void render(IRenderableCollector& collector, const VolumeTest& volume) override;
+    void clearRenderables() override;
 
 private:
 	void foreachSelectedTransformable(

diff --git a/radiantcore/selection/manipulators/Renderables.h b/radiantcore/selection/manipulators/Renderables.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "math/AABB.h"
+#include "render/RenderableGeometry.h"
+#include "render/RenderableBox.h"
+
+namespace selection
+{
+
+class RenderableBoundingBoxes :
+    public render::RenderableGeometry
+{
+private:
+    const std::vector<AABB>& _aabbs;
+    bool _needsUpdate;
+    Vector4 _colour;
+
+public:
+    RenderableBoundingBoxes(const std::vector<AABB>& aabbs, const Vector4& colour = { 1,1,1,1 }) :
+        _aabbs(aabbs),
+        _needsUpdate(true),
+        _colour(colour)
+    {}
+
+    void queueUpdate()
+    {
+        _needsUpdate = true;
+    }
+
+protected:
+    void updateGeometry() override
+    {
+        if (!_needsUpdate) return;
+
+        _needsUpdate = false;
+
+        std::vector<ArbitraryMeshVertex> vertices;
+        std::vector<unsigned int> indices;
+
+        static auto WireframeBoxIndices = render::detail::generateWireframeBoxIndices();
+
+        vertices.reserve(_aabbs.size() * 8); // 8 vertices per box
+        indices.reserve(WireframeBoxIndices.size() * _aabbs.size()); // indices per box * boxes
+
+        for (const auto& aabb : _aabbs)
+        {
+            // Calculate the corner vertices of this bounding box
+            Vector3 max(aabb.origin + aabb.extents);
+            Vector3 min(aabb.origin - aabb.extents);
+
+            auto boxVertices = render::detail::getWireframeBoxVertices(min, max, _colour);
+
+            auto indexOffset = static_cast<unsigned int>(vertices.size());
+
+            for (const auto& vertex : boxVertices)
+            {
+                vertices.insert(vertices.begin(),
+                    std::make_move_iterator(boxVertices.begin()), 
+                    std::make_move_iterator(boxVertices.end()));
+            }
+
+            for (auto index : WireframeBoxIndices)
+            {
+                indices.push_back(indexOffset + index);
+            }
+        }
+
+        RenderableGeometry::updateGeometry(render::GeometryType::Lines, vertices, indices);
+    }
+};
+
+}
diff --git a/test/Entity.cpp b/test/Entity.cpp
@@ -491,7 +491,7 @@ namespace
         void setHighlightFlag(Highlight::Flags flags, bool enabled) override
         {}
 
-        void processRenderable(const Renderable& renderable, const VolumeTest& volume) override
+        void processRenderable(Renderable& renderable, const VolumeTest& volume) override
         {
             if (renderSolid)
             {

diff --git a/tools/msvc/DarkRadiantCore.vcxproj b/tools/msvc/DarkRadiantCore.vcxproj
@@ -1025,6 +1025,7 @@
     <ClInclude Include="..\..\radiantcore\selection\manipulators\ManipulatorBase.h" />
     <ClInclude Include="..\..\radiantcore\selection\manipulators\ManipulatorComponents.h" />
     <ClInclude Include="..\..\radiantcore\selection\manipulators\ModelScaleManipulator.h" />
+    <ClInclude Include="..\..\radiantcore\selection\manipulators\Renderables.h" />
     <ClInclude Include="..\..\radiantcore\selection\manipulators\RotateManipulator.h" />
     <ClInclude Include="..\..\radiantcore\selection\manipulators\ScaleManipulator.h" />
     <ClInclude Include="..\..\radiantcore\selection\manipulators\TranslateManipulator.h" />

diff --git a/tools/msvc/DarkRadiantCore.vcxproj.filters b/tools/msvc/DarkRadiantCore.vcxproj.filters
@@ -2280,5 +2280,8 @@
     <ClInclude Include="..\..\radiantcore\entity\doom3group\RenderableVertex.h">
       <Filter>src\entity\doom3group</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\radiantcore\selection\manipulators\Renderables.h">
+      <Filter>src\selection\manipulators</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>