diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.cpp
index 4e8cef183b3..f5b505357fe 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.cpp
+++ b/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
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.h
index 2940e94e79e..6a215bf83ab 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeModel.h
+++ b/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();
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.h
index 986c39bccee..ed1fbd88f95 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.h
+++ b/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;
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.inl
index 0d704b09a46..9d925f1d8d0 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderModel.inl
@@ -19,10 +19,11 @@
 *                                                                             *
 * Contact information: contact@sofa-framework.org                             *
 ******************************************************************************/
-#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
 {
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.h
index cf4c7876a20..43f0c2c7830 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.h
+++ b/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;
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.inl
index 6afd879c636..8bd168f782f 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.inl
+++ b/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>
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.h
index 65a5e5bcb9a..babfd1cf3e4 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.h
+++ b/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;
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.inl
index 39ad779b32f..fb178bf28ed 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.inl
+++ b/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);
+    }
 }
 
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.cpp
index 502a3cac3f7..e4942f9b39f 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.cpp
+++ b/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>();
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.h
index e56dd5a6c59..5e492069de7 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayModel.h
+++ b/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; }
     // ----------------------------
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.h
index 24f876caa67..be5dd53cdf8 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.h
+++ b/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(); }
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.inl
index e36d3bfa6ae..ef58926388e 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.inl
@@ -114,51 +114,44 @@ void SphereCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vpa
 
 
 template<class DataTypes>
-void SphereCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
+void SphereCollisionModel<DataTypes>::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if(d_componentState.getValue() != ComponentState::Valid)
-        return ;
-
     using namespace sofa::type;
     using namespace sofa::defaulttype;
 
-    if (!this->isActive()) return;
-    //if (!vparams->isSupported(core::visual::API_OpenGL)) return;
-    if (vparams->displayFlags().getShowCollisionModels())
-    {
-        // Force no wireframe mode to draw sphere collision
-        vparams->drawTool()->setPolygonMode(0,false);
+    //  Force no wireframe mode to draw sphere collision
+    vparams->drawTool()->setPolygonMode(0, false);
 
-        // Check topological modifications
-        const auto npoints = mstate->getSize();
+    // Check topological modifications
+    const auto npoints = mstate->getSize();
 
-        std::vector<Vec3> points;
-        std::vector<float> radius;
-        for (sofa::Size i=0; i<npoints; i++)
+    std::vector<Vec3> points;
+    std::vector<float> radius;
+    for (sofa::Size i = 0; i < npoints; i++)
+    {
+        TSphere<DataTypes> t(this, i);
+        if (t.isActive())
         {
-            TSphere<DataTypes> t(this,i);
-            if (t.isActive())
-            {
-                Vec3 p = t.p();
-                points.push_back(p);
-                radius.push_back((float)t.r());
-            }
+            Vec3 p = t.p();
+            points.push_back(p);
+            radius.push_back((float)t.r());
         }
-
-        vparams->drawTool()->setLightingEnabled(true); //Enable lightning
-        if(d_showImpostors.getValue())
-            vparams->drawTool()->drawFakeSpheres(points, radius, sofa::type::RGBAColor(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]));
-        else
-            vparams->drawTool()->drawSpheres(points, radius, sofa::type::RGBAColor(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]));
-        vparams->drawTool()->setLightingEnabled(false); //Disable lightning
-
     }
 
+    vparams->drawTool()->setLightingEnabled(true);  // Enable lightning
+    if (d_showImpostors.getValue())
+        vparams->drawTool()->drawFakeSpheres(
+            points, radius,
+            sofa::type::RGBAColor(getColor4f()[0], getColor4f()[1], getColor4f()[2],
+                                  getColor4f()[3]));
+    else
+        vparams->drawTool()->drawSpheres(points, radius,
+                                         sofa::type::RGBAColor(getColor4f()[0], getColor4f()[1],
+                                                               getColor4f()[2], getColor4f()[3]));
+    vparams->drawTool()->setLightingEnabled(false);  // Disable lightning
+
     // restore current polygon mode
     vparams->drawTool()->setPolygonMode(0,vparams->displayFlags().getShowWireFrame());
-
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
 }
 
 template <class DataTypes>
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.cpp
index f8533385263..b949f90d3d9 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.cpp
@@ -161,10 +161,9 @@ void TetrahedronCollisionModel::draw(const core::visual::VisualParams* vparams,
 
 }
 
-void TetrahedronCollisionModel::draw(const core::visual::VisualParams* vparams)
+void TetrahedronCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    const auto stateLifeCycle = vparams->drawTool()->makeStateLifeCycle();
-    if (mstate && m_topology && vparams->displayFlags().getShowCollisionModels())
+    if (mstate && m_topology)
     {
         if (vparams->displayFlags().getShowWireFrame())
             vparams->drawTool()->setPolygonMode(0, true);
@@ -192,10 +191,6 @@ void TetrahedronCollisionModel::draw(const core::visual::VisualParams* vparams)
         if (vparams->displayFlags().getShowWireFrame())
             vparams->drawTool()->setPolygonMode(0, false);
     }
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
-
-
 }
 
 void TetrahedronCollisionModel::computeBoundingTree(int maxDepth)
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.h
index 76ac4880948..5c93d0fb484 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronModel.h
@@ -106,6 +106,8 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TetrahedronCollisionModel : public c
 
     virtual void updateFromTopology();
     void addTetraToDraw(const Tetrahedron& t, std::vector<sofa::type::Vec3>& tetraVertices, std::vector<sofa::type::Vec3>& normalVertices);
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
     void init() override;
 
@@ -119,8 +121,6 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TetrahedronCollisionModel : public c
 
     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; }
 
     /// Link to be set to the topology container in the component graph.
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.h
index 4671bae100a..0b8e2aa5e36 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.h
@@ -168,6 +168,7 @@ class TriangleCollisionModel : public core::CollisionModel
 
     virtual void updateFromTopology();
     virtual void updateNormals();
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 
 public:
     void init() override;
@@ -182,8 +183,6 @@ class TriangleCollisionModel : public core::CollisionModel
 
     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;
 
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return m_mstate; }
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.inl
index a4fb0bddea0..5e8e9abd892 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.inl
@@ -426,60 +426,54 @@ void TriangleCollisionModel<DataTypes>::draw(const core::visual::VisualParams* v
 
 
 template<class DataTypes>
-void TriangleCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
+void TriangleCollisionModel<DataTypes>::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (vparams->displayFlags().getShowCollisionModels())
-    {
-        // In case topology has changed but drawing is called before the updateFromTopology has been computed, just exit to avoid computation in drawing thread.
-        if (m_topology->getRevision() != m_topologyRevision)
-            return;
-
-        if (d_bothSide.getValue() || vparams->displayFlags().getShowWireFrame())
-            vparams->drawTool()->setPolygonMode(0,vparams->displayFlags().getShowWireFrame());
-        else
-        {
-            vparams->drawTool()->setPolygonMode(2,true);
-            vparams->drawTool()->setPolygonMode(1,false);
-        }
+    // In case topology has changed but drawing is called before the updateFromTopology has been
+    // computed, just exit to avoid computation in drawing thread.
+    if (m_topology->getRevision() != m_topologyRevision) return;
 
-        std::vector< type::Vec3 > points;
-        std::vector< type::Vec<3,int> > indices;
-        std::vector< type::Vec3 > normals;
-        int index=0;
-        for (sofa::Size i=0; i<size; i++)
-        {
-            Element t(this,i);
-            normals.push_back(t.n());
-            points.push_back(t.p1());
-            points.push_back(t.p2());
-            points.push_back(t.p3());
-            indices.push_back(type::Vec<3,int>(index,index+1,index+2));
-            index+=3;
-        }
+    if (d_bothSide.getValue() || vparams->displayFlags().getShowWireFrame())
+        vparams->drawTool()->setPolygonMode(0, vparams->displayFlags().getShowWireFrame());
+    else
+    {
+        vparams->drawTool()->setPolygonMode(2, true);
+        vparams->drawTool()->setPolygonMode(1, false);
+    }
 
-        vparams->drawTool()->setLightingEnabled(true);
-        const auto c = getColor4f();
-        vparams->drawTool()->drawTriangles(points, indices, normals, sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
-        vparams->drawTool()->setLightingEnabled(false);
-        vparams->drawTool()->setPolygonMode(0,false);
+    std::vector<type::Vec3> points;
+    std::vector<type::Vec<3, int> > indices;
+    std::vector<type::Vec3> normals;
+    int index = 0;
+    for (sofa::Size i = 0; i < size; i++)
+    {
+        Element t(this, i);
+        normals.push_back(t.n());
+        points.push_back(t.p1());
+        points.push_back(t.p2());
+        points.push_back(t.p3());
+        indices.push_back(type::Vec<3, int>(index, index + 1, index + 2));
+        index += 3;
+    }
 
+    vparams->drawTool()->setLightingEnabled(true);
+    const auto c = getColor4f();
+    vparams->drawTool()->drawTriangles(points, indices, normals,
+                                       sofa::type::RGBAColor(c[0], c[1], c[2], c[3]));
+    vparams->drawTool()->setLightingEnabled(false);
+    vparams->drawTool()->setPolygonMode(0, false);
 
-        if (vparams->displayFlags().getShowNormals())
+    if (vparams->displayFlags().getShowNormals())
+    {
+        std::vector<type::Vec3> points;
+        for (sofa::Size i = 0; i < size; i++)
         {
-            std::vector< type::Vec3 > points;
-            for (sofa::Size i=0; i<size; i++)
-            {
-                Element t(this,i);
-                points.push_back((t.p1()+t.p2()+t.p3())/3.0);
-                points.push_back(points.back()+t.n());
-            }
-
-            vparams->drawTool()->drawLines(points, 1, sofa::type::RGBAColor::white());
-
+            Element t(this, i);
+            points.push_back((t.p1() + t.p2() + t.p3()) / 3.0);
+            points.push_back(points.back() + t.n());
         }
+
+        vparams->drawTool()->drawLines(points, 1, sofa::type::RGBAColor::white());
     }
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
 }
 
 template<class DataTypes>
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.cpp
index 7af6462b9aa..873240adb2d 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.cpp
@@ -44,30 +44,24 @@ TriangleOctreeModel::TriangleOctreeModel ()
 {
 }
 
-void TriangleOctreeModel::draw (const core::visual::VisualParams* vparams)
+void TriangleOctreeModel::drawCollisionModel (const core::visual::VisualParams* vparams)
 {
-    const auto stateLifeCycle = vparams->drawTool()->makeStateLifeCycle();
+    TriangleCollisionModel<sofa::defaulttype::Vec3Types>::drawCollisionModel(vparams);
 
-    TriangleCollisionModel<sofa::defaulttype::Vec3Types>::draw(vparams);
-    if (isActive () && vparams->displayFlags().getShowCollisionModels ())
+    if (vparams->displayFlags().getShowWireFrame())
     {
-        if (vparams->displayFlags().getShowWireFrame ())
-            vparams->drawTool()->setPolygonMode(0, true);
-
-        vparams->drawTool()->enableLighting();
-        const float* getCol = getColor4f();
-        const auto color = sofa::type::RGBAColor(getCol[0], getCol[1], getCol[2], getCol[3]);
-        vparams->drawTool()->setMaterial(color);
-
-        if(octreeRoot)
-            octreeRoot->draw(vparams->drawTool());
-
-        vparams->drawTool()->disableLighting();
-        if (vparams->displayFlags().getShowWireFrame ())
-            vparams->drawTool()->setPolygonMode(0, false);
+        vparams->drawTool()->setPolygonMode(0, true);
     }
 
+    vparams->drawTool()->enableLighting();
+    const float* getCol = getColor4f();
+    const auto color = sofa::type::RGBAColor(getCol[0], getCol[1], getCol[2], getCol[3]);
+    vparams->drawTool()->setMaterial(color);
+
+    if (octreeRoot) octreeRoot->draw(vparams->drawTool());
 
+    vparams->drawTool()->disableLighting();
+    if (vparams->displayFlags().getShowWireFrame()) vparams->drawTool()->setPolygonMode(0, false);
 }
 
 void TriangleOctreeModel::computeBoundingTree(int maxDepth)
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.h
index d33bc7e860f..883eb25bffd 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeModel.h
@@ -39,11 +39,11 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TriangleOctreeModel : public  Triang
     SOFA_CLASS(TriangleOctreeModel, TriangleCollisionModel<sofa::defaulttype::Vec3Types>);
 protected:
     TriangleOctreeModel();
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
 
     /// the normals for each point
     type::vector<type::Vec3> pNorms;
-    void draw(const core::visual::VisualParams* vparams) override;
     void computeBoundingTree(int maxDepth=0) override;
     void computeContinuousBoundingTree(SReal dt, int maxDepth=0) override;
     /// init the octree creation
diff --git a/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp b/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
index a752127333a..0e005767c02 100644
--- a/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
+++ b/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
@@ -22,6 +22,7 @@
 #include <sofa/core/CollisionModel.h>
 #include <sofa/core/objectmodel/BaseNode.h>
 #include <sofa/type/RGBAColor.h>
+#include <sofa/core/visual/VisualParams.h>
 
 using sofa::type::RGBAColor ;
 
@@ -140,6 +141,50 @@ void CollisionModel::setPrevious(CollisionModel::SPtr val)
         val->next.set(this);
 }
 
+void CollisionModel::draw(const core::visual::VisualParams* vparams)
+{
+    // don't draw if the component is not in valid state
+    if (isComponentStateInvalid())
+        return;
+
+    // don't draw if the component is not active
+    if(!isActive())
+        return;
+
+    struct DrawPrevious //RAII struct to draw the coarser collision model when exiting the scope
+    {
+        DrawPrevious(CollisionModel* previous, const core::visual::VisualParams* vparams) : m_previous(previous), m_vparams(vparams) {}
+        ~DrawPrevious()
+        {
+            if (m_previous && m_vparams->displayFlags().getShowBoundingCollisionModels())
+                m_previous->draw(m_vparams);
+        }
+        CollisionModel* m_previous { nullptr };
+        const core::visual::VisualParams* m_vparams { nullptr };
+    } drawPrevious(previous, vparams);
+
+    // don't draw if specified not to do so in the user interface
+    if (getNext() == nullptr)
+    {
+        if (!vparams->displayFlags().getShowCollisionModels())
+        {
+            return;
+        }
+    }
+    else
+    {
+        if (!vparams->displayFlags().getShowBoundingCollisionModels())
+        {
+            return;
+        }
+    }
+
+    {
+        const auto stateLifeCycle = vparams->drawTool()->makeStateLifeCycle();
+        drawCollisionModel(vparams);
+    }
+}
+
 /// Return the first (i.e. root) CollisionModel in the hierarchy.
 CollisionModel* CollisionModel::getFirst()
 {
@@ -162,15 +207,16 @@ CollisionModel* CollisionModel::getLast()
 
 bool CollisionModel::canCollideWith(CollisionModel* model)
 {
-    if (model->getContext() == this->getContext()) // models are in the Node -> is self collision activated?
+    if (model->getContext() ==
+        this->getContext())  // models are in the Node -> is self collision activated?
         return bSelfCollision.getValue();
 
     const auto& myGroups = this->group.getValue();
-    if (myGroups.empty()) // a collision model without any group always collides
+    if (myGroups.empty())  // a collision model without any group always collides
         return true;
 
     const auto& modelGroups = model->group.getValue();
-    if (modelGroups.empty()) // a collision model without any group always collides
+    if (modelGroups.empty())  // a collision model without any group always collides
         return true;
 
     std::set<int>::const_iterator myGroupsFirst = myGroups.cbegin();
@@ -199,7 +245,13 @@ bool CollisionModel::canCollideWith(CollisionModel* model)
     return true;
 }
 
-
+void CollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
+{
+    for (sofa::Index i = 0; i < size; i++)
+    {
+        draw(vparams, i);
+    }
+}
 
 bool CollisionModel::insertInNode( objectmodel::BaseNode* node )
 {
diff --git a/Sofa/framework/Core/src/sofa/core/CollisionModel.h b/Sofa/framework/Core/src/sofa/core/CollisionModel.h
index 05305c352c6..bab46f4fb56 100644
--- a/Sofa/framework/Core/src/sofa/core/CollisionModel.h
+++ b/Sofa/framework/Core/src/sofa/core/CollisionModel.h
@@ -273,7 +273,7 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseObject
     virtual void draw(const core::visual::VisualParams* /*vparams*/, Index /*index*/) {}
 
     /// Render the whole collision model.
-    void draw(const core::visual::VisualParams* ) override {}
+    void draw(const core::visual::VisualParams* vparams) final;
 
     /// Return the first (i.e. root) CollisionModel in the hierarchy.
     CollisionModel* getFirst();
@@ -429,6 +429,9 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseObject
     /// Pointer to the  Controller component heritating from CollisionElementActiver
     SingleLink<CollisionModel, sofa::core::objectmodel::BaseObject, BaseLink::FLAG_STOREPATH | BaseLink::FLAG_STRONGLINK> l_collElemActiver;
 
+    /// Render the whole collision model.
+    virtual void drawCollisionModel(const core::visual::VisualParams* vparams);
+
 public:
     CollisionElementActiver *myCollElemActiver; ///< CollisionElementActiver that activate or deactivate collision element during execution
 
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
index 0619a655d66..d521b07e0de 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
@@ -105,6 +105,9 @@ class CapsuleCollisionModel : public core::CollisionModel
     CapsuleCollisionModel(core::behavior::MechanicalState<TDataTypes>* mstate );
 
     ~CapsuleCollisionModel() override;
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+
 public:
     void init() override;
 
@@ -118,9 +121,6 @@ class CapsuleCollisionModel : public core::CollisionModel
 
     void draw(const core::visual::VisualParams* vparams, Index index) override;
 
-    void draw(const core::visual::VisualParams* vparams) override;
-
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return _mstate; }
 
     Real radius(Index index) const;
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
index c67b25ec740..3d018ecb681 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
@@ -177,28 +177,23 @@ void CapsuleCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vp
 }
 
 template<class DataTypes>
-void CapsuleCollisionModel<DataTypes>::draw(const core::visual::VisualParams* vparams)
+void CapsuleCollisionModel<DataTypes>::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
     auto df = sofa::core::visual::visualparams::getDisplayFlags(vparams);
     auto dt = sofa::core::visual::visualparams::getDrawTool(vparams);
-    if (df.getShowCollisionModels())
-    {
-        sofa::type::RGBAColor col4f(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]);
-        dt->setPolygonMode(0,df.getShowWireFrame());//maybe ??
-        dt->setLightingEnabled(true); //Enable lightning
+    sofa::type::RGBAColor col4f(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]);
+    dt->setPolygonMode(0, df.getShowWireFrame());  // maybe ??
+    dt->setLightingEnabled(true);                  // Enable lightning
 
-        // Check topological modifications
-        //const int npoints = _mstate->getSize()/2;
+    // Check topological modifications
+    // const int npoints = _mstate->getSize()/2;
 
-        for (sofa::Size i=0; i<size; i++){
-            dt->drawCapsule(point1(i),point2(i),(float)radius(i),col4f);
-        }
-
-        dt->setLightingEnabled(false); //Disable lightning
+    for (sofa::Size i = 0; i < size; i++)
+    {
+        dt->drawCapsule(point1(i), point2(i), (float)radius(i), col4f);
     }
 
-    if (getPrevious()!=nullptr && df.getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
+    dt->setLightingEnabled(false);  // Disable lightning
 
     dt->setPolygonMode(0,false);
 }
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
index d78206b9846..bc83980277e 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
@@ -147,6 +147,7 @@ class OBBCollisionModel : public core::CollisionModel
 protected:
     OBBCollisionModel();
     OBBCollisionModel(sofa::core::behavior::MechanicalState<TDataTypes>* mstate );
+    void drawCollisionModel(const sofa::core::visual::VisualParams* vparams) override;
 public:
     void init() override;
 
@@ -160,8 +161,6 @@ class OBBCollisionModel : public core::CollisionModel
 
     void draw(const sofa::core::visual::VisualParams* vparams, sofa::Index index) override;
 
-    void draw(const sofa::core::visual::VisualParams* vparams) override;
-
     sofa::core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return _mstate; }
 
     /// Pre-construction check method called by ObjectFactory.
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
index e5d3dd76a6b..7ea63b36aea 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
@@ -195,20 +195,17 @@ void OBBCollisionModel<DataTypes>::draw(const sofa::core::visual::VisualParams*
 }
 
 template<class DataTypes>
-void OBBCollisionModel<DataTypes>::draw(const sofa::core::visual::VisualParams* vparams){
-    if (vparams->displayFlags().getShowCollisionModels())
-    {
-        vparams->drawTool()->setPolygonMode(0,vparams->displayFlags().getShowWireFrame());
+void OBBCollisionModel<DataTypes>::drawCollisionModel(const sofa::core::visual::VisualParams* vparams)
+{
+    vparams->drawTool()->setPolygonMode(0, vparams->displayFlags().getShowWireFrame());
 
-        const auto npoints = _mstate->getSize();
-        vparams->drawTool()->setLightingEnabled(true); //Enable lightning
-        for(sofa::Size i = 0 ; i < npoints ; ++i )
-            draw(vparams,i);
-        vparams->drawTool()->setLightingEnabled(false); //Disable lightning
+    const auto npoints = _mstate->getSize();
+    vparams->drawTool()->setLightingEnabled(true);  // Enable lightning
+    for (sofa::Size i = 0; i < npoints; ++i)
+    {
+        draw(vparams, i);
     }
-
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
+    vparams->drawTool()->setLightingEnabled(false);  // Disable lightning
 
     vparams->drawTool()->setPolygonMode(0,false);
 }
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
index 0cdd92f24e7..6c0745b8c16 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
@@ -114,6 +114,7 @@ class CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> > : publi
 
     CapsuleCollisionModel();
     CapsuleCollisionModel(core::behavior::MechanicalState<DataTypes>* mstate );
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
     void init() override;
 
@@ -127,9 +128,6 @@ class CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> > : publi
 
     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 _mstate; }
 
     Real radius(sofa::Index index) const;
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
index 380ff7af2db..50e2101e7bc 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
@@ -160,23 +160,18 @@ void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::draw(co
 }
 
 template<class MyReal>
-void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::draw(const core::visual::VisualParams* vparams)
+void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (vparams->displayFlags().getShowCollisionModels())
-    {
-        sofa::type::RGBAColor col4f(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]);
-        vparams->drawTool()->setPolygonMode(0,vparams->displayFlags().getShowWireFrame());//maybe ??
-        vparams->drawTool()->setLightingEnabled(true); //Enable lightning
-
-        for (sofa::Size i=0; i<size; i++){
-            vparams->drawTool()->drawCapsule(point1(i),point2(i),(float)radius(i),col4f);
-        }
+    sofa::type::RGBAColor col4f(getColor4f()[0], getColor4f()[1], getColor4f()[2], getColor4f()[3]);
+    vparams->drawTool()->setPolygonMode(0, vparams->displayFlags().getShowWireFrame());  // maybe ??
+    vparams->drawTool()->setLightingEnabled(true);  // Enable lightning
 
-        vparams->drawTool()->setLightingEnabled(false); //Disable lightning
+    for (sofa::Size i = 0; i < size; i++)
+    {
+        vparams->drawTool()->drawCapsule(point1(i), point2(i), (float)radius(i), col4f);
     }
 
-    if (getPrevious()!=nullptr && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
+    vparams->drawTool()->setLightingEnabled(false);  // Disable lightning
 
     vparams->drawTool()->setPolygonMode(0,false);
 }
diff --git a/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp b/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
index a906ab1025d..1bf05afcfe8 100644
--- a/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
+++ b/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
@@ -78,31 +78,25 @@ void CudaPointCollisionModel::draw(const core::visual::VisualParams* , Index ind
 #endif // SOFACUDA_HAVE_SOFA_GL == 1
 }
 
-void CudaPointCollisionModel::draw(const core::visual::VisualParams* vparams)
+void CudaPointCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
 #if SOFACUDA_HAVE_SOFA_GL == 1
-    if (isActive() && vparams->displayFlags().getShowCollisionModels())
-    {
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-
-        glDisable(GL_LIGHTING);
-        glPointSize(3);
-        glColor4fv(getColor4f());
+    if (vparams->displayFlags().getShowWireFrame()) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
-        for (Size i=0; i<size; i++)
-        {
-            draw(vparams,i);
-        }
+    glDisable(GL_LIGHTING);
+    glPointSize(3);
+    glColor4fv(getColor4f());
 
-        glColor3f(1.0f, 1.0f, 1.0f);
-        glDisable(GL_LIGHTING);
-        glPointSize(1);
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    for (Size i = 0; i < size; i++)
+    {
+        draw(vparams, i);
     }
-    if (isActive() && getPrevious()!=NULL && vparams->displayFlags().getShowBoundingCollisionModels())
-        getPrevious()->draw(vparams);
+
+    glColor3f(1.0f, 1.0f, 1.0f);
+    glDisable(GL_LIGHTING);
+    glPointSize(1);
+    if (vparams->displayFlags().getShowWireFrame()) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
 #endif // SOFACUDA_HAVE_SOFA_GL == 1
 }
 
diff --git a/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.h b/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
index eb9327ac8d6..f59bf88d72a 100644
--- a/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
+++ b/applications/plugins/SofaCUDA/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
@@ -76,12 +76,11 @@ class SOFA_GPU_CUDA_API CudaPointCollisionModel : public core::CollisionModel
 
     void draw(const core::visual::VisualParams*,Index index) override;
 
-    void draw(const core::visual::VisualParams*) override;
-
     core::behavior::MechanicalState<InDataTypes>* getMechanicalState() { return mstate; }
 
 protected:
 
+    void drawCollisionModel(const core::visual::VisualParams*) override;
     core::behavior::MechanicalState<InDataTypes>* mstate;
 };
 
diff --git a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
index 93e20d35356..f38b4666a3d 100644
--- a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
+++ b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
@@ -649,26 +649,20 @@ void CudaRigidDistanceGridCollisionModel::updateGrid()
 {
 }
 
-void CudaRigidDistanceGridCollisionModel::draw(const core::visual::VisualParams* vparams)
+void CudaRigidDistanceGridCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
-    if (!isActive()) return;
-    if (vparams->displayFlags().getShowCollisionModels())
+    if (vparams->displayFlags().getShowWireFrame())
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    glDisable(GL_LIGHTING);
+    glColor4fv(getColor4f());
+    glPointSize(3);
+    for (unsigned int i = 0; i < elems.size(); i++)
     {
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-        glDisable(GL_LIGHTING);
-        glColor4fv(getColor4f());
-        glPointSize(3);
-        for (unsigned int i=0; i<elems.size(); i++)
-        {
-            draw(vparams,i);
-        }
-        glPointSize(1);
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        draw(vparams, i);
     }
-    if (getPrevious()!=NULL)
-        getPrevious()->draw(vparams);
+    glPointSize(1);
+    if (vparams->displayFlags().getShowWireFrame())
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 }
 
 void CudaRigidDistanceGridCollisionModel::draw(const core::visual::VisualParams* , Index index)
diff --git a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
index 0f58bec68b3..8da7b24b5d6 100644
--- a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
+++ b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
@@ -474,6 +474,8 @@ class CudaRigidDistanceGridCollisionModel : public core::CollisionModel
 
     void updateGrid();
 
+    void drawCollisionModel(const core::visual::VisualParams*) override;
+
 public:
     // Input data parameters
     sofa::core::objectmodel::DataFileName fileCudaRigidDistanceGrid;
@@ -552,8 +554,6 @@ class CudaRigidDistanceGridCollisionModel : public core::CollisionModel
     void computeBoundingTree(int maxDepth=0) override;
 
     void draw(const core::visual::VisualParams*, Index index) override;
-
-    void draw(const core::visual::VisualParams*) override;
 };
 
 inline CudaRigidDistanceGridCollisionElement::CudaRigidDistanceGridCollisionElement(CudaRigidDistanceGridCollisionModel* model, Index index)
diff --git a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
index 3ae03d2ddda..97e9bcdfd76 100644
--- a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
+++ b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
@@ -246,27 +246,21 @@ void RigidDistanceGridCollisionModel::updateGrid()
 {
 }
 
-void RigidDistanceGridCollisionModel::draw(const core::visual::VisualParams* vparams)
+void RigidDistanceGridCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
 #if SOFADISTANCEGRID_HAVE_SOFA_GL == 1
-    if (!isActive()) return;
-    if (vparams->displayFlags().getShowCollisionModels())
+    if (vparams->displayFlags().getShowWireFrame())
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    glDisable(GL_LIGHTING);
+    glColor4fv(getColor4f());
+    glPointSize(3);
+    for (unsigned int i = 0; i < elems.size(); i++)
     {
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-        glDisable(GL_LIGHTING);
-        glColor4fv(getColor4f());
-        glPointSize(3);
-        for (unsigned int i=0; i<elems.size(); i++)
-        {
-            draw(vparams,i);
-        }
-        glPointSize(1);
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        draw(vparams, i);
     }
-    if (getPrevious()!=nullptr)
-        getPrevious()->draw(vparams);
+    glPointSize(1);
+    if (vparams->displayFlags().getShowWireFrame())
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 #endif // SOFADISTANCEGRID_HAVE_SOFA_GL == 1
 }
 
@@ -685,25 +679,23 @@ FFDDistanceGridCollisionModel::DeformedCube::Plane FFDDistanceGridCollisionModel
     return Plane(N,N*C4*(-0.25f));
 }
 
-void FFDDistanceGridCollisionModel::draw(const core::visual::VisualParams* vparams)
+void FFDDistanceGridCollisionModel::drawCollisionModel(const core::visual::VisualParams* vparams)
 {
 #if SOFADISTANCEGRID_HAVE_SOFA_GL == 1
-    if (!isActive()) return;
-    if (vparams->displayFlags().getShowCollisionModels())
+    if (vparams->displayFlags().getShowWireFrame())
     {
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-        glDisable(GL_LIGHTING);
-        glColor4fv(getColor4f());
-        for (unsigned int i=0; i<elems.size(); i++)
-        {
-            draw(vparams,i);
-        }
-        if (vparams->displayFlags().getShowWireFrame())
-            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    }
+    glDisable(GL_LIGHTING);
+    glColor4fv(getColor4f());
+    for (unsigned int i = 0; i < elems.size(); i++)
+    {
+        draw(vparams, i);
+    }
+    if (vparams->displayFlags().getShowWireFrame())
+    {
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     }
-    if (getPrevious()!=nullptr)
-        getPrevious()->draw(vparams);
 #endif // SOFADISTANCEGRID_HAVE_SOFA_GL == 1
 }
 
diff --git a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
index d7106e8695b..675094f8922 100644
--- a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
+++ b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
@@ -143,6 +143,8 @@ class SOFA_SOFADISTANCEGRID_API RigidDistanceGridCollisionModel : public core::C
     RigidDistanceGridCollisionModel();
 
     ~RigidDistanceGridCollisionModel() override;
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
     core::behavior::MechanicalState<InDataTypes>* getRigidModel() { return this->mstate ; }
     core::behavior::MechanicalState<InDataTypes>* getMechanicalState() { return this->mstate ; }
@@ -222,7 +224,6 @@ class SOFA_SOFADISTANCEGRID_API RigidDistanceGridCollisionModel : public core::C
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
-    void draw(const core::visual::VisualParams* vparams) override;
 };
 
 inline RigidDistanceGridCollisionElement::RigidDistanceGridCollisionElement(RigidDistanceGridCollisionModel* model, Index index)
@@ -447,6 +448,8 @@ class SOFA_SOFADISTANCEGRID_API FFDDistanceGridCollisionModel : public core::Col
     FFDDistanceGridCollisionModel();
 
     ~FFDDistanceGridCollisionModel() override;
+
+    void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 public:
     core::behavior::MechanicalState<DataTypes>* getDeformModel() { return this->mstate; }
     core::topology::BaseMeshTopology* getDeformGrid() { return l_ffdMesh; }
@@ -476,8 +479,6 @@ class SOFA_SOFADISTANCEGRID_API FFDDistanceGridCollisionModel : public core::Col
     bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
-
-    void draw(const core::visual::VisualParams* vparams) override;
 };
 
 inline FFDDistanceGridCollisionElement::FFDDistanceGridCollisionElement(FFDDistanceGridCollisionModel* model, Index index)