InternalData.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.
*/
 
#ifndef AGX_INTERNALDATA_H
#define AGX_INTERNALDATA_H
 
#include <agx/Referenced.h>
#include <agx/agxPhysics_export.h>
 
namespace agx
{
  class AGXPHYSICS_EXPORT InternalData : public agx::Referenced
  {
    public:
      enum Source
      {
        WIRE,               
        MERGED_BODY,        
        MERGE_SPLIT,        
        DEFORMABLE1D,       
        RIGID_BODY_EMITTER, 
        LINKED_STRUCTURE,   
        ENERGY,             
        SENSOR_ENVIRONMENT, 
        NUM_SOURCES
      };
 
    public:
      template<typename DataT, typename ObjT, typename... Args>
      static DataT* getOrCreate( ObjT obj, Source source, Args&&... args );
 
      template<typename DataT, typename ObjT>
      static DataT* get( const ObjT& obj, Source source );
 
      template<typename ObjT>
      static void set( ObjT obj, agx::Referenced* data, Source source );
 
      template<typename ObjT>
      static agx::Bool hasData( const ObjT& obj, Source source );
 
    protected:
      virtual ~InternalData() {}
 
    private:
      template<typename ObjT>
      static InternalData* getOrCreateInternal( ObjT obj );
 
      template<typename ObjT>
      static InternalData* getInternal( const ObjT& obj );
 
    private:
      agx::ref_ptr<agx::Referenced> m_data[ NUM_SOURCES ];
  };
 
  template<typename DataT, typename ObjT, typename... Args>
  DataT* InternalData::getOrCreate( ObjT obj, InternalData::Source source, Args&&... args )
  {
    agxAssert( obj != nullptr );
 
    InternalData* iData = getOrCreateInternal( obj );
    if ( iData->m_data[ source ] == nullptr )
      iData->m_data[ source ] = new DataT( std::forward<Args>( args )... );
 
    return iData->m_data[ source ]->as<DataT>();
  }
 
  template<typename DataT, typename ObjT>
  DataT* InternalData::get( const ObjT& obj, InternalData::Source source )
  {
    InternalData* iData = getInternal( obj );
    return iData != nullptr && iData->m_data[ source ] != nullptr ? iData->m_data[ source ]->as<DataT>() : nullptr;
  }
 
  template<typename ObjT>
  void InternalData::set( ObjT obj, Referenced* data, InternalData::Source source )
  {
    if ( obj == nullptr )
      return;
 
    InternalData* iData = getInternal( obj );
    if ( iData == nullptr && data == nullptr )
      return;
 
    iData = getOrCreateInternal( obj );
    iData->m_data[ source ] = data;
  }
 
  template<typename ObjT>
  agx::Bool InternalData::hasData( const ObjT& obj, InternalData::Source source )
  {
    const InternalData* iData = getInternal( obj );
    return iData != nullptr && iData->m_data[ source ] != nullptr;
  }
 
  template<typename ObjT>
  InternalData* InternalData::getOrCreateInternal( ObjT obj )
  {
    agx::Referenced* data = obj->getInternalData();
    if ( data == nullptr ) {
      data = new InternalData();
      obj->setInternalData( data );
    }
 
    return data->as<InternalData>();
  }
 
  template<typename ObjT>
  InternalData* InternalData::getInternal( const ObjT& obj )
  {
    return obj != nullptr && obj->getInternalData() != nullptr ? obj->getInternalData()->template as<InternalData>() : nullptr;
  }
}
 
#endif