RenderManager.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 <agx/agxPhysics_export.h>
#include <agx/Referenced.h>
#include <agx/HashVector.h>
#include <agx/AffineMatrix4x4.h>
#include <agxCollide/Space.h>
 
#include <agxRender/RenderProxy.h>
#include <agxRender/RenderProxyFactory.h>
#include <agxRender/Renderable.h>
#include <agxRender/Graph.h>
 
namespace agxSDK
{
  class Simulation;
  class StatisticsEntries;
}
 
namespace agxRender
{
 
  class RenderProxyFactory;
  class RenderProxy;
  class SpaceListener;
  class SphereProxy;
  class BoxProxy;
  class LineProxy;
  class HeightFieldProxy;
  class CylinderProxy;
  class HollowCylinderProxy;
  class ConeProxy;
  class TruncatedConeProxy;
  class HollowConeProxy;
  class CapsuleProxy;
  class TextProxy;
  class PlaneProxy;
  class GraphRenderer;
  class Graph;
 
  enum Flags {
    RENDER_GEOMETRIES = 1,                      
    RENDER_BOUNDING_VOLUMES = 1 << 1,           
    RENDER_GEOMETRY_CONTACTS = 1 << 2,          
    RENDER_PARTICLE_CONTACTS = 1 << 3,          
    RENDER_PARTICLE_GEOMETRY_CONTACTS = 1 << 4, 
    RENDER_CONSTRAINTS = 1 << 5,                
    RENDER_BODIES = 1 << 6,                     
    RENDER_PARTICLE_SYSTEMS = 1 << 7,           
    RENDER_PARTICLE_EMITTERS = 1 << 8,          
    RENDER_TEXT = 1 << 9,                       
    RENDER_AABB_TREES = 1 << 10,                
    RENDER_SENSORS = 1 << 11,                   
    RENDER_MESH = 1 << 12,                      
    RENDER_NICE_CONTACTS = 1 << 13,             
    RENDER_STATISTICS = 1 << 14,                
    RENDER_RENDERABLES = 1 << 15,               
    RENDER_BODY_PARTITION = 1 << 16,            
    RENDER_BATCH_CONTACTS = 1 << 17,            
    RENDER_BATCH_BODIES = 1 << 18,              
    RENDER_BATCH_WIRES = 1 << 19,               
    RENDER_OBSERVER_FRAMES = 1 << 20,           
    RENDER_CONTACTS =
      RENDER_GEOMETRY_CONTACTS | RENDER_PARTICLE_CONTACTS | RENDER_PARTICLE_GEOMETRY_CONTACTS, 
    RENDER_DEFAULT =
      RENDER_GEOMETRIES |
      RENDER_BODIES |
      RENDER_CONTACTS |
      RENDER_CONSTRAINTS |
      RENDER_RENDERABLES |
      RENDER_PARTICLE_SYSTEMS |
      RENDER_PARTICLE_EMITTERS |
      RENDER_SENSORS |
      RENDER_MESH |
      RENDER_OBSERVER_FRAMES 
  };
 
  AGX_DECLARE_POINTER_TYPES( RenderManager );
 
  class AGXPHYSICS_EXPORT RenderManager : public agx::Referenced
  {
    public:
 
      RenderManager( agxSDK::Simulation* sim );
 
      void update();
 
      void setProxyFactory ( RenderProxyFactory* factory );
 
      RenderProxyFactory* getProxyFactory();
 
      void setEnable( bool flag );
 
      bool getEnable( ) const;
 
      bool isEnabled() const;
 
      void setAlpha( float alpha );
 
      float getAlpha( ) const;
 
      void disableFlags( unsigned int flags );
 
      void enableFlags( unsigned int flags );
 
      bool isEnabledFlags( unsigned int flags ) const;
 
      void setFlags( unsigned int flags );
 
      void updateAllProxies( agxRender::RenderProxy::EventType eventType );
 
      SphereProxy*    acquireSphere( float radius );
 
      BoxProxy*       acquireBox( const agx::Vec3& halfExtents );
 
      LineProxy*      acquireLine( const agx::Vec3& p1, const agx::Vec3& p2  );
 
      TextProxy*      acquireText( const agx::String& text, const agx::Vec3& pos, float size=1 );
 
      PlaneProxy*     acquirePlane( const agx::Vec3& normal, agx::Real distance );
 
      CylinderProxy*  acquireCylinder( float radius, float height );
 
      CylinderProxy*  acquireCylinder( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      HollowCylinderProxy*  acquireHollowCylinder( float radius, float height, float thickness );
 
 
      ConeProxy*      acquireCone( const agx::Vec3& p1, const agx::Vec3& p2, float radius );
 
      TruncatedConeProxy* acquireTruncatedCone( const agx::Vec3& p1, const agx::Vec3& p2, float topRadius, float bottomRadius );
 
      HollowConeProxy* acquireHollowCone( const agx::Vec3& p1, const agx::Vec3& p2, float topRadius, float bottomRadius, float thickness );
 
      CapsuleProxy*  acquireCapsule( float radius, float height );
 
      CapsuleProxy*  acquireCapsule( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      agxRender::ContactsProxy*  acquireContacts( const agxCollide::GeometryContactPtrVector& contacts, float scale );
 
      agxRender::RigidBodyBatchRenderProxy* acquireRigidBodies( const agx::RigidBodyPtrSetVector* enabledBodies, float scale );
 
      agxRender::WireRenderProxy* acquireWire( float radius, const agx::Vec3& color );
 
      void clear( bool clearText = true, bool clearGlobalProxies = true );
 
      void addRenderable( Renderable* renderable );
 
      bool hasRenderable( Renderable* renderable ) const;
 
      bool removeRenderable( Renderable* renderable );
 
      void acquireGeometry( const agxCollide::Geometry* geometry, const agx::Vec3& color );
 
      RenderProxy* findShapeProxy( const agxCollide::Shape* shape );
 
      void setDefaultRenderMode( RenderProxy::RenderMode mode );
 
      void setScaleFactor( float scaleFactor = 1.0f );
 
      float getScaleFactor() const;
 
    public:
      typedef std::pair< const agx::ParticleSystem*, agxRender::RenderProxyRef > ConstParticleSystemPtrRenderProxyPtrPair;
      typedef agx::Vector< ConstParticleSystemPtrRenderProxyPtrPair > ParticleSystemProxyContainer;
 
      agxSDK::Simulation* getSimulation() { return m_simulation; }
 
    protected:
 
 
      void flush();
 
      friend class SpaceListener;
      friend class agxCollide::Space;
      friend class agxSDK::Simulation;
      friend class agxSDK::StatisticsEntries;
 
 
      void setSpace( agxCollide::Space* space );
 
      Graph* getGraph();
 
      void add( const agx::ParticleSystem* particleSystem );
      void remove( const agx::ParticleSystem* particleSystem );
 
      void add( const agxCollide::Geometry* geometry, const agx::Vec3& color = agx::Vec3( -1, 0, 0 ), bool addToProxies = true );
 
      RenderProxy* add( agxCollide::Shape* shape, const agxCollide::Geometry* geometry, const agx::Vec3& color = agx::Vec3( -1, 0, 0 ), bool addToProxies = true );
 
      void remove( const agxCollide::Shape* shape );
 
      void remove( const agxCollide::Geometry* geometry );
 
      void renderBoundingVolume( const agxCollide::Geometry* geometry );
 
      void renderAABBTrees( RenderProxy* proxy );
 
      void addAllGeometries();
 
      void updateText();
 
      void updateGraphs();
 
      void updateAABBProxies( );
 
      void updateObserverFrames();
 
      void renderObserverFrame(const agx::ObserverFrame* observerFrame);
 
      void updateBodyProxies( agxData::EntityStorage* islandStorage = nullptr );
 
      void updateShapeProxies(agxData::EntityStorage* islandStorage = nullptr );
 
      void updateParticleSystemProxies();
 
      void updateRenderables();
 
      void updateContactProxies();
 
 
      void updateParticleContactProxies();
      void updateParticleGeometryContactProxies();
 
      void updateConstraintProxies();
 
      void clearShapeProxies();
 
      void updateProxy( RenderProxy* proxy, agxData::EntityStorage* islandStorage = nullptr );
 
      virtual ~RenderManager();
 
      // Attributes
      typedef agx::HashVector<agx::UInt32, agx::ref_ptr<RenderProxy> > RenderProxyHashVector;
      RenderProxyHashVector m_proxies;
      agx::ref_ptr<RenderProxyFactory> m_factory;
      bool m_enable;
      float m_alpha;
      agxSDK::Simulation* m_simulation;
      agxRender::GraphRef m_graph;
 
      float m_ContactsProxySize;
      float m_scaleFactor;
 
      ParticleSystemProxyContainer m_particleSystems;
 
      // Abstract base class for a ProxyCache
      struct CacheBase {
        CacheBase( RenderManager* mgr ) : m_mgr( mgr ) {
          m_mgr->m_cacheVector.push_back( this );
        }
 
        virtual void clear() = 0;
        virtual void flush() = 0;
        virtual void setAlpha( float alpha ) = 0;
        RenderManager* m_mgr;
 
        virtual ~CacheBase() {}
      };
 
 
      template <typename T>
      class PrimitiveCache : public CacheBase
      {
        public:
 
          typedef agx::Vector<agx::ref_ptr<T> > ProxyVector;
          typedef typename ProxyVector::const_iterator const_iterator;
          typedef typename ProxyVector::iterator iterator;
 
          PrimitiveCache( RenderManager* mgr ) : CacheBase( mgr ), m_index( 0 ) {}
 
          T* acquire();
 
          void flush() {
            for ( size_t i = m_index; i < m_pool.size(); i++ )
              m_pool[i]->callOnChange( RenderProxy::REMOVE );
 
            m_pool.resize( std::min( m_index, m_pool.size() ) );
            m_index = 0;
          }
 
          void setAlpha( float alpha ) {
            for ( size_t i = 0; i < m_pool.size(); i++ )
              m_pool[i]->setAlpha( alpha );
          }
 
          void clear() {
            for ( typename ProxyVector::iterator it = m_pool.begin(); it != m_pool.end(); ++it )
              ( *it )->callOnChange( RenderProxy::REMOVE );
            m_pool.clear( agx::Container::SHRINK_BUFFER );
            m_index = 0;
          }
 
          virtual ~PrimitiveCache() {
            clear();
          }
 
          iterator begin() { return m_pool.begin(); }
          const_iterator begin() const { return m_pool.begin(); }
 
          iterator end() { return m_pool.end(); }
          const_iterator end() const { return m_pool.end(); }
 
        protected:
 
          ProxyVector m_pool;
          size_t m_index;
      };
 
      template <typename T, typename P1>
      class PrimitiveCache1 : public PrimitiveCache<T>
      {
        public:
 
          PrimitiveCache1( RenderManager* mgr ) : PrimitiveCache<T>( mgr ) {}
 
          T* acquire( const P1& param );
 
        private:
 
          T* acquire() { return nullptr; }
      };
 
      typedef agx::Vector<CacheBase*> CacheVector;
      CacheVector m_cacheVector;
 
      PrimitiveCache<TextProxy> m_textCache;
      PrimitiveCache<PlaneProxy> m_planeCache;
      PrimitiveCache<CapsuleProxy> m_capsuleCache;
      PrimitiveCache<CylinderProxy> m_cylinderCache;
      PrimitiveCache<HollowCylinderProxy> m_hollowCylinderCache;
      PrimitiveCache<ConeProxy> m_coneCache;
      PrimitiveCache<TruncatedConeProxy> m_truncatedConeCache;
      PrimitiveCache<HollowConeProxy> m_hollowConeCache;
      PrimitiveCache1<SphereProxy, float> m_sphereCache;
      PrimitiveCache1<BoxProxy, agx::Vec3> m_boxCache;
      PrimitiveCache<LineProxy> m_lineCache;
      PrimitiveCache1<ContactsProxy, agxCollide::GeometryContactPtrVector> m_contactsCache;
      PrimitiveCache1<RigidBodyBatchRenderProxy, const agx::RigidBodyPtrSetVector*> m_rbCache;
 
      agx::ref_ptr<SpaceListener> m_listener;
 
      agx::UInt32 m_flags;
      typedef agx::Vector<RenderableRef> RenderableRefVector;
      RenderableRefVector m_renderables;
      typedef agx::Vector< agx::ref_ptr< agxRender::RenderProxy > > RenderProxyRefContainer;
      RenderProxyRefContainer m_globalProxies; 
      RenderProxy::RenderMode m_defaultRenderMode;
 
      agxData::BufferRef m_particleContactRadiusBuffer;
      agxData::BufferRef m_particleGeometryContactRadiusBuffer;
      agxData::ValueRef m_particleContactBound;
      agxData::ValueRef m_particleGeometryContactBound;
      RenderProxyRef m_particleContactRenderProxy;
      RenderProxyRef m_particleGeometryContactRenderProxy;
 
  };
 
 
  
 
  class AGXPHYSICS_EXPORT SpaceListener : public agxCollide::SpaceListener
  {
    public:
 
      SpaceListener( RenderManager* mgr );
 
      agxCollide::Space* getSpace();
    protected:
 
      virtual ~SpaceListener();
 
      void addNotification( agxCollide::Space* space );
 
      void addGeometryNotification( agxCollide::Space* space, agxCollide::Geometry* geometry );
      void removeGeometryNotification( agxCollide::Space* space, agxCollide::Geometry* geometry );
      void addShapeNotification( agxCollide::Space* space, agxCollide::Geometry* geometry, agxCollide::Shape* shape );
      void removeShapeNotification( agxCollide::Space* space, agxCollide::Geometry* geometry, agxCollide::Shape* shape );
 
      agx::observer_ptr<RenderManager> m_mgr;
      agx::observer_ptr<agxCollide::Space> m_space;
  };
 
 
 
 
  // Implementation
 
  inline bool RenderManager::getEnable( ) const
  {
    return m_enable;
  }
 
 
  inline float RenderManager::getAlpha( ) const
  {
    return m_alpha;
  }
 
 
  inline bool RenderManager::isEnabled() const
  {
    return getEnable();
  }
 
 
  inline SphereProxy* RenderProxyFactory::create( float radius )
  {
    return createSphere( radius );
  }
  inline BoxProxy* RenderProxyFactory::create( const agx::Vec3& halfExtents )
  {
    return createBox( halfExtents );
  }
  inline LineProxy* RenderProxyFactory::create( const LineProxy* )
  {
    return createLine( agx::Vec3( agx::Real( 0 ) ), agx::Vec3( agx::Real( 1 ) ) );
  }
  inline CylinderProxy* RenderProxyFactory::create( const CylinderProxy* )
  {
    return createCylinder( 1, 1 );
  }
  inline HollowCylinderProxy* RenderProxyFactory::create( const HollowCylinderProxy* )
  {
    return createHollowCylinder( 1, 1, 0.1f );
  }
 
  inline ConeProxy* RenderProxyFactory::create( const ConeProxy* )
  {
    return createCone( 1, 1 );
  }
  inline TruncatedConeProxy* RenderProxyFactory::create( const TruncatedConeProxy* )
  {
    return createTruncatedCone( 1, 1, 1 );
  }
  inline HollowConeProxy* RenderProxyFactory::create( const HollowConeProxy* )
  {
    return createHollowCone( 1, 1, 1, 0.1f );
  }
 
  inline CapsuleProxy* RenderProxyFactory::create( const CapsuleProxy* )
  {
    return createCapsule( 1, 1 );
  }
  inline TextProxy* RenderProxyFactory::create( const TextProxy* )
  {
    return createText( "", agx::Vec3( 0, 0, 0 ) );
  }
  inline PlaneProxy* RenderProxyFactory::create( const PlaneProxy* )
  {
    return createPlane( agx::Vec3( 0, 0, 1 ), 0 );
  }
 
  inline ContactsProxy* RenderProxyFactory::create( const agxCollide::GeometryContactPtrVector& contacts )
  {
    return createContacts( contacts );
  }
 
  inline RigidBodyBatchRenderProxy* RenderProxyFactory::create( const agx::RigidBodyPtrSetVector* enabledBodies )
  {
    return createRigidBodies( enabledBodies );
  }
 
  inline RenderProxy::RenderMode RenderProxyFactory::getDefaultRenderMode() const
  {
    return m_defaultRenderMode;
  }
 
  template< typename T>
  T* RenderManager::PrimitiveCache<T>::acquire( void )
  {
    if ( m_index < m_pool.size() ) {
      T* proxy = m_pool[m_index++];
 
      // Reset color, alpha and enabled state
      proxy->reset();
      return proxy;
    } else {
      const void* p = nullptr;
      const T* px = static_cast<const T*>( p );
      T* proxy = m_mgr->getProxyFactory()->create( px);
      if (proxy) {
        proxy->setEnable( true );
        m_pool.push_back( proxy );
        m_index = m_pool.size();
      }
      return proxy;
    }
  }
 
  template< typename T, typename P1>
  T* RenderManager::PrimitiveCache1<T, P1>::acquire( const P1& param )
  {
    if ( this->m_index < this->m_pool.size() ) {
      T* proxy = this->m_pool[this->m_index++];
      // Reset color, alpha and enabled state
      proxy->reset();
      return proxy;
    } else {
      T* proxy = this->m_mgr->getProxyFactory()->create( param );
      if (proxy) {
        proxy->setEnable( true );
        this->m_pool.push_back( proxy );
        this->m_index = this->m_pool.size();
      }
      return proxy;
    }
  }
}