Merge branch 'master' of https://github.com/sofa-framework/sofa

Author: SperryBot

.github/workflows/nix.yml

@@ -12,7 +12,7 @@ jobs:
         os: [ubuntu, macos]
     steps:
       - uses: actions/checkout@v4
-      - uses: cachix/install-nix-action@v27
+      - uses: cachix/install-nix-action@v31
       # TODO: the "sofa" account on cachix does not exist yet
       #- uses: cachix/cachix-action@v15
         #with:

CHANGELOG.md

@@ -12,8 +12,8 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
 endif()
 
 # Manually define VERSION
-set(Sofa_VERSION_MAJOR 25)
-set(Sofa_VERSION_MINOR 12)
+set(Sofa_VERSION_MAJOR 26)
+set(Sofa_VERSION_MINOR 06)
 set(Sofa_VERSION_PATCH 99)
 set(Sofa_VERSION ${Sofa_VERSION_MAJOR}.${Sofa_VERSION_MINOR}.${Sofa_VERSION_PATCH})
 

CMakeLists.txt

@@ -52,6 +52,11 @@ void BaseSubCollisionPipeline::init()
     doInit();
 }
 
+void BaseSubCollisionPipeline::bwdInit()
+{
+    doBwdInit();
+}
+
 /**
  * @brief Queries all registered contact response types from the Contact factory.
  *

Sofa/Component/Collision/Detection/Algorithm/src/sofa/component/collision/detection/algorithm/BaseSubCollisionPipeline.cpp

@@ -85,6 +85,9 @@ class SOFA_COMPONENT_COLLISION_DETECTION_ALGORITHM_API BaseSubCollisionPipeline
 
     /// @brief Initializes the component. Marked final to enforce Template Method pattern.
     void init() override final;
+    
+    /// @brief Initialization of the component during the bottom-up traversal. Marked final to enforce Template Method pattern.
+    void bwdInit() override final;
 
     /// @brief Renders debug visualization. Marked final to enforce Template Method pattern.
     void draw(const core::visual::VisualParams* vparams) override final;

Sofa/Component/Collision/Detection/Algorithm/src/sofa/component/collision/detection/algorithm/BaseSubCollisionPipeline.h

@@ -122,6 +122,13 @@ void CompositeCollisionPipeline::init()
     }
 
 }
+void CompositeCollisionPipeline::bwdInit()
+{
+    for(const auto& subPipeline : l_subCollisionPipelines)
+    {
+        subPipeline->bwdInit();
+    }
+}
 
 void CompositeCollisionPipeline::reset()
 {

Sofa/Component/Collision/Detection/Algorithm/src/sofa/component/collision/detection/algorithm/CompositeCollisionPipeline.cpp

@@ -77,6 +77,7 @@ class SOFA_COMPONENT_COLLISION_DETECTION_ALGORITHM_API CompositeCollisionPipelin
     /// @brief Delegates response creation to all sub-pipelines.
     void doCollisionResponse() override;
 
+    void bwdInit() override;
     void reset() override;
 
     /// @brief Entry point for collision reset, called by the simulation loop.

Sofa/Component/Collision/Detection/Algorithm/src/sofa/component/collision/detection/algorithm/CompositeCollisionPipeline.h

@@ -32,6 +32,7 @@
 #include <cmath>
 #include <array>
 #include <cassert>
+#include <numeric>
 
 #define EQUALITY_THRESHOLD 1e-6
 
@@ -257,8 +258,7 @@ class Vec
     // assign one value to all elements
     constexpr void assign(const ValueType& value) noexcept
     {
-        for (size_type i = 0; i < N; i++)
-            elems[i] = value;
+        std::fill_n(this->elems.data(), N, value);
     }
 
     /// Sets every element to 0.
@@ -472,6 +472,10 @@ class Vec
     /// Squared norm.
     constexpr ValueType norm2() const noexcept
     {
+        // The STL function is slower when not compiling in full optimization.
+        // Therefore, the debugging would be slower.
+        // return std::inner_product(elems.begin(), elems.end(), elems.begin(), ValueType{});
+
         ValueType r = this->elems[0]*this->elems[0];
         for (Size i=1; i<N; i++)
             r += this->elems[i]*this->elems[i];
@@ -583,7 +587,10 @@ class Vec
     /// sum of all elements of the vector
     constexpr ValueType sum() const noexcept
     {
-        ValueType sum = ValueType(0.0);
+        // The STL function is slower when not compiling in full optimization.
+        // Therefore, the debugging would be slower.
+        // return std::accumulate(elems.begin(), elems.end(), ValueType{});
+        ValueType sum = static_cast<ValueType>(0.0);
         for (Size i=0; i<N; i++)
             sum += this->elems[i];
         return sum;
@@ -597,8 +604,8 @@ class Vec
     {
         if constexpr (std::is_floating_point_v<ValueType>)
         {
-            return std::equal(this->elems.begin(), this->elems.end(), b.elems.begin(),
-                                   [](auto x, auto y) { return std::abs(x - y) < EQUALITY_THRESHOLD; });
+            constexpr auto equalTest = [](auto x, auto y) { return std::abs(x - y) < EQUALITY_THRESHOLD; };
+            return std::equal(this->elems.begin(), this->elems.end(), b.elems.begin(), equalTest );
         }
         else
         {
@@ -680,19 +687,19 @@ class Vec
         return elems.end();
     }
 
-    constexpr reference front()
+    constexpr reference front() noexcept
     {
         return elems[0];
     }
-    constexpr const_reference front() const
+    constexpr const_reference front() const noexcept
     {
         return elems[0];
     }
-    constexpr reference back()
+    constexpr reference back() noexcept
     {
         return elems[N - 1];
     }
-    constexpr const_reference back() const
+    constexpr const_reference back() const noexcept
     {
         return elems[N - 1];
     }
@@ -717,7 +724,7 @@ class VecNoInit : public Vec<N,real>
     {}
 
     constexpr VecNoInit(Vec<N,real>&& v) noexcept
-        : Vec<N,real>(v)
+        : Vec<N,real>(std::move(v))
     {}
 
     using Vec<N,real>::Vec;

Sofa/framework/Type/src/sofa/type/Vec.h

@@ -21,31 +21,25 @@
 ******************************************************************************/
 #pragma once
 
-namespace sofa::type::pairwise
-{
+#include <algorithm>
 
-/// @brief clamp a single value. This function should be removed when std::clamp will be available
-template<class T>
-const T& stdclamp( const T& v, const T& lo, const T& hi )
+namespace sofa::type::pairwise
 {
-    assert( !(hi < lo) );
-    return (v < lo) ? lo : (hi < v) ? hi : v;
-}
 
 /// @brief clamp all the values of a fixed_array to be within a given interval.
-template<class T, class TT=typename T::value_type, size_t TN=T::static_size>
-T clamp(const T& in, const TT& minValue, const TT& maxValue)
+template<class T, size_t TN=T::static_size>
+T clamp(const T& in, const typename T::value_type& minValue, const typename T::value_type& maxValue)
 {
     T result {};
     for(typename T::size_type i=0; i < typename T::size_type(TN); ++i)
     {
-        result[i] = stdclamp(in[i], minValue, maxValue);
+        result[i] = std::clamp(in[i], minValue, maxValue);
     }
     return result;
 }
 
 /// @brief pairwise add of two fixed_array
-template<class T, class TT=typename T::value_type, size_t TN=T::static_size>
+template<class T, size_t TN=T::static_size>
 constexpr T operator+(const T& l, const T& r)
 {
     T result {};
@@ -57,7 +51,7 @@ constexpr T operator+(const T& l, const T& r)
 }
 
 /// @brief pairwise subtract of two fixed_array
-template<class T, class TT=typename T::value_type, size_t TN=T::static_size>
+template<class T, size_t TN=T::static_size>
 constexpr T operator-(const T& l, const T& r)
 {
     T result {};
@@ -69,7 +63,7 @@ constexpr T operator-(const T& l, const T& r)
 }
 
 /// @brief multiply from l the r components.
-template<class T, class TT=typename T::value_type, size_t TN=T::static_size>
+template<class T, size_t TN=T::static_size>
 T operator*(const T& r, const typename T::value_type& f)
 {
     T result {};
@@ -81,7 +75,7 @@ T operator*(const T& r, const typename T::value_type& f)
 }
 
 /// @brief multiply from l the r components.
-template<class T, class TT=typename T::value_type, size_t TN=T::static_size>
+template<class T, size_t TN=T::static_size>
 T operator/(const T& r, const typename T::value_type& f)
 {
     T result {};