MergeSplitProperties.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agxSDK/MergeSplitAlgorithm.h>
#include <agxSDK/GeometryContactMergeSplitThresholds.h>
#include <agxSDK/ConstraintMergeSplitThresholds.h>
#include <agxSDK/WireMergeSplitThresholds.h>
#include <agxSDK/MergeIgnoreFilter.h>
#include <agxSDK/MergeIgnoreGroups.h>
 
#include <agx/ICloneable.h>
#include <agx/BitState.h>
 
 
namespace agxSDK
{
  class GeometryContactMergeSplitThresholds;
  class ConstraintMergeSplitThresholds;
  class WireMergeSplitThresholds;
 
  AGX_DECLARE_POINTER_TYPES( MergeSplitProperties );
 
  class AGXPHYSICS_EXPORT MergeSplitProperties : public agx::ICloneable
  {
    public:
      static agx::UInt findCallbackIndex( agxSDK::MergeSplitAlgorithm::Callback callback );
 
    public:
      MergeSplitProperties();
 
      void setEnableMergeSplit( agx::Bool enable );
 
      agx::Bool getEnableMergeSplit() const;
 
      void setEnableMerge( agx::Bool enable );
 
      agx::Bool getEnableMerge() const;
 
      void setEnableSplit( agx::Bool enable );
 
      agx::Bool getEnableSplit() const;
 
      void addGroup(const agx::Name& group);
 
      void addGroup(agx::UInt32 group);
 
      void removeGroup(const agx::Name& group);
 
      void removeGroup(agx::UInt32 group);
 
      const agx::UInt32Vector& getGroupIds() const;
 
      const agx::NameVector& getGroupNames() const;
 
      agxSDK::GeometryContactMergeSplitThresholds* getContactThresholds() const;
 
      agxSDK::GeometryContactMergeSplitThresholds* getOrCreateContactThresholds();
 
      void setContactThresholds( agxSDK::GeometryContactMergeSplitThresholds* contactThresholds );
 
      agxSDK::ConstraintMergeSplitThresholds* getConstraintThresholds() const;
 
      agxSDK::ConstraintMergeSplitThresholds* getOrCreateConstraintThresholds();
 
      void setConstraintThresholds( agxSDK::ConstraintMergeSplitThresholds* constraintThresholds );
 
      agxSDK::WireMergeSplitThresholds* getWireThresholds() const;
 
      agxSDK::WireMergeSplitThresholds* getOrCreateWireThresholds();
 
      void setWireThresholds( agxSDK::WireMergeSplitThresholds* wireThresholds );
 
      void setEnableSerialization( agx::Bool flag );
 
      agx::Bool getEnableSerialization() const;
 
    public:
      DOXYGEN_START_INTERNAL_BLOCK()
      virtual agx::ICloneableRef clone( agx::ICloneable* child = nullptr ) override;
      void store( agxStream::OutputArchive& out ) const;
      void restore( agxStream::InputArchive& in );
      void storeLightData( agxStream::StorageStream& str ) const;
      void restoreLightData( agxStream::StorageStream& str );
 
      template<typename T>
      T* getMergeSplitThresholds( const agx::UInt index ) const;
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      virtual ~MergeSplitProperties();
 
    private:
      enum EState
      {
        MERGE_ENABLED         = 1 << 0,
        SPLIT_ENABLED         = 1 << 1,
        SERIALIZATION_ENABLED = 1 << 2
      };
 
    private:
      typedef agx::BitState< EState, agx::Int32 > State;
      typedef agx::Vector<MergeSplitThresholdsRef> ThresholdsContainer;
 
    private:
      template<typename T>
      T* getOrCreateMergeSplitThresholds( const agx::UInt index );
 
      template<typename T>
      T* setMergeSplitThresholds( const agx::UInt index, agx::ref_ptr<T> thresholds );
 
    private:
      State m_state;
      ThresholdsContainer m_thresholds;
      agxSDK::MergeIgnoreGroups m_mergeIgnoreGroups;
  };
 
  AGX_FORCE_INLINE agx::Bool MergeSplitProperties::getEnableMergeSplit() const
  {
    return getEnableMerge() && getEnableSplit();
  }
 
  AGX_FORCE_INLINE agx::Bool MergeSplitProperties::getEnableMerge() const
  {
    return m_state.Is( MERGE_ENABLED );
  }
 
  AGX_FORCE_INLINE agx::Bool MergeSplitProperties::getEnableSplit() const
  {
    return m_state.Is( SPLIT_ENABLED );
  }
 
  inline GeometryContactMergeSplitThresholds* MergeSplitProperties::getContactThresholds() const
  {
    return getMergeSplitThresholds<GeometryContactMergeSplitThresholds>( MergeSplitProperties::findCallbackIndex( MergeSplitAlgorithm::CONTACTS ) );
  }
 
  inline ConstraintMergeSplitThresholds* MergeSplitProperties::getConstraintThresholds() const
  {
    return getMergeSplitThresholds<ConstraintMergeSplitThresholds>( MergeSplitProperties::findCallbackIndex( MergeSplitAlgorithm::CONSTRAINTS ) );
  }
 
  inline WireMergeSplitThresholds* MergeSplitProperties::getWireThresholds() const
  {
    return getMergeSplitThresholds<WireMergeSplitThresholds>( MergeSplitProperties::findCallbackIndex( MergeSplitAlgorithm::WIRES ) );
  }
 
  inline agx::UInt MergeSplitProperties::findCallbackIndex( agxSDK::MergeSplitAlgorithm::Callback callback )
  {
    agxAssert( callback != MergeSplitAlgorithm::NONE );
    return agx::pow2Exponent( callback );
  }
 
  template<typename T>
  inline T* MergeSplitProperties::getMergeSplitThresholds( const agx::UInt index ) const
  {
    agxAssert( index >= m_thresholds.size() || m_thresholds[ index ] == nullptr || m_thresholds[ index ]->is<T>() );
 
    return index < m_thresholds.size() ? (T*)m_thresholds[ index ].get() : nullptr;
  }
 
  template<typename T>
  T* MergeSplitProperties::getOrCreateMergeSplitThresholds( const agx::UInt index )
  {
    if ( index < m_thresholds.size() && m_thresholds[ index ] != nullptr ) {
      agxAssert( m_thresholds[ index ]->is<T>() );
      return (T*)m_thresholds[ index ].get();
    }
 
    return setMergeSplitThresholds<T>( index, new T() );
  }
 
  template<typename T>
  T* MergeSplitProperties::setMergeSplitThresholds( const agx::UInt index, agx::ref_ptr<T> thresholds )
  {
    if ( index >= m_thresholds.size() )
      m_thresholds.resize( index + 1 );
 
    return (T*)( m_thresholds[ index ] = thresholds ).get();
  }
}