[Core] Apply template method design pattern to CollisionModel::draw

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.cpp

@@ -161,10 +161,8 @@ void CubeCollisionModel::updateCubes()
         updateCube(i);
 }
 
-void CubeCollisionModel::draw(const core::visual::VisualParams* vparams)
+void CubeCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (!isActive() || !((getNext()==nullptr)?vparams->displayFlags().getShowCollisionModels():vparams->displayFlags().getShowBoundingCollisionModels())) return;
-
     // The deeper in the CubeModel graph, the higher the transparency of the bounding cube lines  
     const float* collisionColor = getColor4f();
     sofa::type::RGBAColor c(collisionColor[0], collisionColor[1], collisionColor[2], collisionColor[3]);
@@ -211,10 +209,6 @@ void CubeCollisionModel::draw(const core::visual::VisualParams* vparams)
     }
 
     vparams->drawTool()->drawLines(points, 1, c);
-
-
-    if (getPrevious()!=nullptr)
-        getPrevious()->draw(vparams);
 }
 
 std::pair<core::CollisionElementIterator,core::CollisionElementIterator> CubeCollisionModel::getInternalChildren(sofa::Index index) const

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.h

@@ -88,6 +88,8 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API CubeCollisionModel : public core::Co
     friend class Cube;
 protected:
     CubeCollisionModel();
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
     void resize(sofa::Size size) override;
 
@@ -138,8 +140,6 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API CubeCollisionModel : public core::Co
 
     bool isLeaf(sofa::Index index ) const override;
 
-    void draw(const core::visual::VisualParams* vparams) override;
-
     sofa::Index addCube(Cube subcellsBegin, Cube subcellsEnd);
     void updateCube(sofa::Index index);
     void updateCubes();

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.h

@@ -111,9 +111,6 @@ class CylinderCollisionModel : public core::CollisionModel
 
     void draw(const core::visual::VisualParams* vparams,sofa::Index index) override;
 
-    void draw(const core::visual::VisualParams* vparams) override;
-
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return m_mstate; }
 
     Real radius(sofa::Index index) const;

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.inl

@@ -19,10 +19,11 @@
 *                                                                             *
 * Contact information: [email protected]                             *
 ******************************************************************************/
-#include <sofa/component/collision/geometry/CylinderModel.h>
 #include <sofa/component/collision/geometry/CubeModel.h>
+#include <sofa/component/collision/geometry/CylinderModel.h>
 #include <sofa/core/ObjectFactory.h>
 #include <sofa/core/visual/DisplayFlags.h>
+#include <sofa/core/visual/VisualParams.h>
 #include <sofa/helper/visual/DrawTool.h>
 
 namespace sofa::component::collision::geometry
@@ -187,24 +188,6 @@ void CylinderCollisionModel<DataTypes>::draw(const core::visual::VisualParams* v
     sofa::core::visual::visualparams::getDrawTool(vparams)->drawCylinder(p2,p1,float(radius(i)),colour);
 }
 
-template<class DataTypes>
-void CylinderCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
-{
-    const auto df = sofa::core::visual::visualparams::getDisplayFlags(vparams);
-    if (df.getShowCollisionModels())
-    {
-
-        for (sofa::Index i=0; i<size; i++){
-            draw(vparams,i);
-        }
-
-    }
-
-    if (getPrevious()!=nullptr && df.getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
-}
-
-
 template<class DataTypes>
 typename CylinderCollisionModel<DataTypes>::Real CylinderCollisionModel< DataTypes >::defaultRadius() const
 {

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.h

@@ -101,6 +101,8 @@ public :
 
     LineCollisionModel();
 
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+
 public:
     typedef TDataTypes DataTypes;
     typedef DataTypes InDataTypes;
@@ -123,12 +125,6 @@ public :
 
     void computeContinuousBoundingTree(SReal dt, int maxDepth=0) override;
 
-    /// Import the draw(param, index) method from the parent scope, this is needed to make it accessible
-    /// in the current and child class. Otherwise the draw(param) will prevent name resolution
-    /// to locate it.
-    using Inherit1::draw;
-    void draw(const core::visual::VisualParams* vparams) override;
-
     void handleTopologyChange() override;
 
     bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.inl

@@ -307,50 +307,50 @@ void LineCollisionModel<DataTypes>::updateFromTopology()
 }
 
 template<class DataTypes>
-void LineCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
+void LineCollisionModel<DataTypes>::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (vparams->displayFlags().getShowCollisionModels())
+    if (vparams->displayFlags().getShowWireFrame())
     {
-        if (vparams->displayFlags().getShowWireFrame())
-            vparams->drawTool()->setPolygonMode(0,true);
+        vparams->drawTool()->setPolygonMode(0, true);
+    }
 
-        std::vector<helper::visual::DrawTool::Vec3> points;
-        points.reserve(size * 2);
-        for (sofa::Size i=0; i<size; i++)
+    std::vector<helper::visual::DrawTool::Vec3> points;
+    points.reserve(size * 2);
+    for (sofa::Size i = 0; i < size; i++)
+    {
+        TLine<DataTypes> l(this, i);
+        if (l.isActive())
         {
-            TLine<DataTypes> l(this,i);
-            if(l.isActive())
-            {
-                // note the conversion if !std::is_same_v<helper::visual::DrawTool::Vec3, Coord>
-                points.emplace_back(helper::visual::DrawTool::Vec3{l.p1()});
-                points.emplace_back(helper::visual::DrawTool::Vec3{l.p2()});
-            }
+            // note the conversion if !std::is_same_v<helper::visual::DrawTool::Vec3, Coord>
+            points.emplace_back(helper::visual::DrawTool::Vec3{l.p1()});
+            points.emplace_back(helper::visual::DrawTool::Vec3{l.p2()});
         }
+    }
 
-        const auto c = getColor4f();
-        vparams->drawTool()->drawLines(points, 1, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
+    const auto c = getColor4f();
+    vparams->drawTool()->drawLines(points, 1, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
 
-        if (d_displayFreePosition.getValue())
+    if (d_displayFreePosition.getValue())
+    {
+        std::vector<type::Vec3> pointsFree;
+        for (sofa::Size i = 0; i < size; i++)
         {
-            std::vector< type::Vec3 > pointsFree;
-            for (sofa::Size i=0; i<size; i++)
+            TLine<DataTypes> l(this, i);
+            if (l.isActive())
             {
-                TLine<DataTypes> l(this,i);
-                if(l.isActive())
-                {
-                    pointsFree.push_back(l.p1Free());
-                    pointsFree.push_back(l.p2Free());
-                }
+                pointsFree.push_back(l.p1Free());
+                pointsFree.push_back(l.p2Free());
             }
-
-            vparams->drawTool()->drawLines(pointsFree, 1, sofa::type::RGBAColor(0.0f,1.0f,0.2f,1.0f));
         }
 
-        if (vparams->displayFlags().getShowWireFrame())
-            vparams->drawTool()->setPolygonMode(0,false);
+        vparams->drawTool()->drawLines(pointsFree, 1,
+                                       sofa::type::RGBAColor(0.0f, 1.0f, 0.2f, 1.0f));
+    }
+
+    if (vparams->displayFlags().getShowWireFrame())
+    {
+        vparams->drawTool()->setPolygonMode(0, false);
     }
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
 }
 
 template<class DataTypes>

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.h

@@ -79,6 +79,9 @@ class PointCollisionModel : public core::CollisionModel
     friend class TPoint<DataTypes>;
 protected:
     PointCollisionModel();
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+
 public:
     void init() override;
 
@@ -91,7 +94,6 @@ class PointCollisionModel : public core::CollisionModel
     void computeContinuousBoundingTree(SReal dt, int maxDepth=0) override;
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
-    void draw(const core::visual::VisualParams* vparams) override;
 
     bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
 

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.inl

@@ -330,60 +330,58 @@ void PointCollisionModel<DataTypes>::draw(const core::visual::VisualParams*, sof
 
 
 template<class DataTypes>
-void PointCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
+void PointCollisionModel<DataTypes>::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (vparams->displayFlags().getShowCollisionModels())
+    if (vparams->displayFlags().getShowWireFrame())
     {
-        if (vparams->displayFlags().getShowWireFrame())
-            vparams->drawTool()->setPolygonMode(0, true);
+        vparams->drawTool()->setPolygonMode(0, true);
+    }
 
-        // Check topological modifications
-        const auto npoints = mstate->getSize();
-        if (npoints != size)
-            return;
+    // Check topological modifications
+    const auto npoints = mstate->getSize();
+    if (npoints != size) return;
 
-        std::vector< type::Vec3 > pointsP;
-        std::vector< type::Vec3 > pointsL;
-        for (sofa::Size i = 0; i < size; i++)
+    std::vector<type::Vec3> pointsP;
+    std::vector<type::Vec3> pointsL;
+    for (sofa::Size i = 0; i < size; i++)
+    {
+        TPoint<DataTypes> p(this, i);
+        if (p.isActive())
         {
-            TPoint<DataTypes> p(this, i);
-            if (p.isActive())
+            pointsP.push_back(p.p());
+            if (i < sofa::Size(normals.size()))
             {
-                pointsP.push_back(p.p());
-                if (i < sofa::Size(normals.size()))
-                {
-                    pointsL.push_back(p.p());
-                    pointsL.push_back(p.p() + normals[i] * 0.1f);
-                }
+                pointsL.push_back(p.p());
+                pointsL.push_back(p.p() + normals[i] * 0.1f);
             }
         }
+    }
 
-        const auto c = getColor4f();
-        vparams->drawTool()->drawPoints(pointsP, 3, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
-        vparams->drawTool()->drawLines(pointsL, 1, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
+    const auto c = getColor4f();
+    vparams->drawTool()->drawPoints(pointsP, 3, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
+    vparams->drawTool()->drawLines(pointsL, 1, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
 
-        if (d_displayFreePosition.getValue())
-        {
-            std::vector< type::Vec3 > pointsPFree;
+    if (d_displayFreePosition.getValue())
+    {
+        std::vector<type::Vec3> pointsPFree;
 
-            for (sofa::Size i = 0; i < size; i++)
+        for (sofa::Size i = 0; i < size; i++)
+        {
+            TPoint<DataTypes> p(this, i);
+            if (p.isActive())
             {
-                TPoint<DataTypes> p(this, i);
-                if (p.isActive())
-                {
-                    pointsPFree.push_back(p.pFree());
-                }
+                pointsPFree.push_back(p.pFree());
             }
-
-            vparams->drawTool()->drawPoints(pointsPFree, 3, sofa::type::RGBAColor(0.0f, 1.0f, 0.2f, 1.0f));
         }
 
-        if (vparams->displayFlags().getShowWireFrame())
-            vparams->drawTool()->setPolygonMode(0, false);
+        vparams->drawTool()->drawPoints(pointsPFree, 3,
+                                        sofa::type::RGBAColor(0.0f, 1.0f, 0.2f, 1.0f));
     }
 
-    if (getPrevious() != nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
+    if (vparams->displayFlags().getShowWireFrame())
+    {
+        vparams->drawTool()->setPolygonMode(0, false);
+    }
 }
 
 

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.cpp

@@ -110,21 +110,6 @@ void RayCollisionModel::draw(const core::visual::VisualParams* vparams, sofa::In
 
 }
 
-void RayCollisionModel::draw(const core::visual::VisualParams* vparams)
-{
-    if (vparams->displayFlags().getShowCollisionModels())
-    {       
-        for (sofa::Index i=0; i<size; i++)
-        {
-            draw(vparams,i);
-        }
-    }
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-    {
-        getPrevious()->draw(vparams);
-    }
-}
-
 void RayCollisionModel::computeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.h

@@ -72,7 +72,6 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API RayCollisionModel : public core::Col
     void computeBoundingTree(int maxDepth) override;
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
-    void draw(const core::visual::VisualParams* vparams) override;
 
     core::behavior::MechanicalState<defaulttype::Vec3Types>* getMechanicalState() { return mstate; }
     // ----------------------------

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.h

@@ -98,6 +98,9 @@ class SphereCollisionModel : public core::CollisionModel
     SphereCollisionModel();
 
     SphereCollisionModel(core::behavior::MechanicalState<TDataTypes>* _mstate );
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+
 public:
     void init() override;
 
@@ -111,9 +114,6 @@ class SphereCollisionModel : public core::CollisionModel
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
-    void draw(const core::visual::VisualParams* vparams) override;
-
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return mstate; }
 
     const VecReal& getR() const { return this->d_radius.getValue(); }