agxRender/RenderProxy.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/DynamicsSystem.h>
 
namespace agxCollide
{
  class Shape;
  class Geometry;
  class Sphere;
  class Box;
  class HeightField;
  class Line;
  class Cylinder;
  class HollowCylinder;
  class Capsule;
  class Cone;
  class HollowCone;
  class Trimesh;
  class Plane;
  class WireShape;
}
 
namespace agxSDK
{
  class Simulation;
}
 
namespace agxRender
{
  AGX_DECLARE_POINTER_TYPES( RenderProxy );
 
  class AGXPHYSICS_EXPORT RenderProxy : public agx::Referenced
  {
    public:
 
      enum EventType {
        ENABLE,         
        TRANSFORM,      
        ALPHA,          
        COLOR,          
        SHAPE,          
        REMOVE,         
        RENDERMODE      
      };
 
      enum RenderMode {
        NOT_SET = 0x0,
        SOLID = 0x1,
        WIREFRAME = 0x2
      };
 
      RenderProxy( agxCollide::Shape* shape = nullptr );
 
      virtual void setTransform( const agx::AffineMatrix4x4& transform );
 
      virtual void setColor( const agx::Vec3& color );
 
      virtual agx::Vec3 getColor() const;
 
      virtual void setAlpha( float alpha );
 
      virtual float getAlpha() const;
 
      virtual bool updateShape() { return false; }
 
 
      const agx::AffineMatrix4x4& getTransform() const;
 
      agx::UInt32 getModifiedCount() const;
 
      const agxCollide::Shape* getShape() const;
      const agxCollide::Geometry* getGeometry() const;
 
      bool compare() const;
 
      void callOnChange( EventType type );
 
      void setEnable( bool flag );
 
      bool getEnable() const;
 
      inline bool isEnabled() const { return getEnable(); }
 
      void setRenderMode( RenderMode mode );
 
      RenderMode getRenderMode() const;
 
      virtual void reset();
 
      static agx::Bool shouldRender( const agx::RigidBody* rb );
 
      void setShape(agxCollide::Shape* shape, const agxCollide::Geometry* geometry);
 
    protected:
      virtual void  synchronizeParameters() {}
 
      virtual void onChange( EventType /*type*/ ) {}
 
      friend class RenderManager;
      void setModifiedCount( agx::UInt32 c );
      
      virtual ~RenderProxy();
 
      void setBeginToEndTransform( const agx::Vec3& begin,
                                   const agx::Vec3& end,
                                   float& retHeight,
                                   bool signalShapeChanged,
                                   bool offsetHalfHeight = true );
 
      agx::observer_ptr<agxCollide::Shape> m_shape;
      agx::AffineMatrix4x4 m_transform;
 
    private:
      const agxCollide::Geometry* m_geometry;
      agx::UInt32 m_modifiedCount;
      float m_alpha;
      agx::Vec3 m_color;
      bool m_enable;
      agx::Int32 m_renderMode;
  };
 
 
  class AGXPHYSICS_EXPORT TextProxy : public RenderProxy
  {
    public:
      TextProxy();
      TextProxy( const agx::String& text, const agx::Vec3& pos, float size=1 );
 
      void set( const agx::String& text, const agx::Vec3& pos, float size=1 );
 
      agx::String getText() const;
 
      agx::Vec3 getPosition() const;
 
    protected:
      virtual ~TextProxy() = default;
 
    protected:
      agx::String m_text;
      float m_size;
  };
 
 
  class AGXPHYSICS_EXPORT SphereProxy : public RenderProxy
  {
    public:
      SphereProxy();
      SphereProxy( float radius );
 
      void set( float radius );
 
      float getRadius() const;
 
      const agxCollide::Sphere* getCastShape() const;
 
    protected:
      virtual ~SphereProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_radius;
  };
 
 
  class AGXPHYSICS_EXPORT PlaneProxy : public RenderProxy
  {
    public:
      PlaneProxy();
      PlaneProxy( const agx::Vec3& normal, agx::Real distance );
 
      void set( const agx::Vec3& normal, agx::Real distance );
 
      const agxCollide::Plane* getCastShape() const;
 
      agx::Vec3 getNormal() const;
 
      agx::Real getDistance() const;
 
    protected:
      virtual ~PlaneProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      agx::Real m_distance;
      agx::Vec3 m_normal;
  };
 
 
  class AGXPHYSICS_EXPORT LineProxy : public RenderProxy
  {
    public:
      LineProxy();
      LineProxy( const agx::Vec3& p1, const agx::Vec3& p2  );
 
      void set( const agx::Vec3& p1, const agx::Vec3& p2 );
      
      agx::Vec3 getP1() const;
      
      agx::Vec3 getP2() const;
 
      const agxCollide::Line* getCastShape() const;
 
    protected:
      virtual ~LineProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      agx::Vec3 m_p1;
      agx::Vec3 m_p2;
  };
 
 
  class AGXPHYSICS_EXPORT CylinderProxy : public RenderProxy
  {
    public:
      CylinderProxy();
      CylinderProxy( float radius, float height );
      CylinderProxy( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      void set( float radius, float height );
      void set( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      float getRadius() const;
 
      float getHeight() const;
 
      const agxCollide::Cylinder* getCastShape() const;
 
    protected:
      virtual ~CylinderProxy() {}
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_height;
      float m_radius;
  };
 
 
  class AGXPHYSICS_EXPORT HollowCylinderProxy : public RenderProxy
  {
    public:
      HollowCylinderProxy();
      HollowCylinderProxy( float outerRadius, float height, float thickness );
      HollowCylinderProxy( const agx::Vec3& begin, const agx::Vec3& end, float radius, float thickness );
 
      void set( float outerRadius, float height, float thickness );
 
      void set( const agx::Vec3& begin, const agx::Vec3& end, float outerRadius, float thickness );
 
      float getOuterRadius() const;
 
      float getHeight() const;
 
      float getThickness() const;
 
      const agxCollide::HollowCylinder* getCastShape() const;
 
    protected:
      virtual ~HollowCylinderProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_height;
      float m_outerRadius;
      float m_thickness;
  };
 
 
  class AGXPHYSICS_EXPORT ConeProxy : public RenderProxy
  {
    public:
      ConeProxy();
      ConeProxy( float radius, float height );
      ConeProxy( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      void set( float radius, float height );
      void set( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      float getRadius() const;
 
      float getHeight() const;
 
      const agxCollide::Cone* getCastShape() const;
 
    protected:
      virtual ~ConeProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_radius;
      float m_height;
  };
 
 
  class AGXPHYSICS_EXPORT TruncatedConeProxy : public RenderProxy
  {
    public:
      TruncatedConeProxy();
      TruncatedConeProxy( float topRadius, float bottomRadius, float height );
      TruncatedConeProxy( const agx::Vec3& begin,
                          const agx::Vec3& end,
                          float topRadius,
                          float bottomRadius );
 
      void set( float topRadius, float bottomRadius, float height );
 
      void set( const agx::Vec3& top,
                const agx::Vec3& bottom,
                float topRadius,
                float bottomRadius );
 
      float getTopRadius() const;
 
      float getBottomRadius() const;
 
      float getHeight() const;
 
      const agxCollide::Cone* getCastShape() const;
 
    protected:
      virtual ~TruncatedConeProxy() {}
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_topRadius;
      float m_bottomRadius;
      float m_height;
  };
 
  class AGXPHYSICS_EXPORT HollowConeProxy : public RenderProxy
  {
    public:
 
      HollowConeProxy();
      HollowConeProxy(float topRadius,
                      float bottomRadius,
                      float height,
                      float thickness );
 
      HollowConeProxy(const agx::Vec3& begin,
                      const agx::Vec3& end,
                      float topRadius,
                      float bottomRadius,
                      float thickness);
 
      void set(float topRadius,
               float bottomRadius,
               float height,
               float thickness );
 
      void set(const agx::Vec3& top,
               const agx::Vec3& bottom,
               float topRadius,
               float bottomRadius,
               float thickness);
 
      float getTopRadius() const;
 
      float getBottomRadius() const;
 
      float getHeight() const;
 
      float getThickness() const;
 
      const agxCollide::HollowCone* getCastShape() const;
 
    protected:
      virtual ~HollowConeProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_topRadius;
      float m_bottomRadius;
      float m_height;
      float m_thickness;
  };
 
 
  class AGXPHYSICS_EXPORT CapsuleProxy : public RenderProxy
  {
    public:
      CapsuleProxy();
      CapsuleProxy( float radius, float height );
      CapsuleProxy( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
      void set( float radius, float height );
 
      void set( const agx::Vec3& begin, const agx::Vec3& end, float radius );
 
 
      float getRadius() const;
 
      float getHeight() const;
 
      const agxCollide::Capsule* getCastShape() const;
 
    protected:
      virtual ~CapsuleProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      float m_height;
      float m_radius;
  };
 
 
  class AGXPHYSICS_EXPORT WireShapeProxy : public RenderProxy
  {
    public:
      WireShapeProxy();
      WireShapeProxy( float radius,
                      float height,
                      const agx::Vec3& previousEndPoint0,
                      const agx::Vec3& previousEndPoint1 );
      WireShapeProxy( const agx::Vec3& begin,
                      const agx::Vec3& end,
                      const agx::Vec3& previousEndPoint0,
                      const agx::Vec3& previousEndPoint1,
                      float radius );
 
      void set( float radius, float height );
 
      void set( float radius,
                float height,
                const agx::Vec3& previousEndPoint0,
                const agx::Vec3& previousEndPoint1 );
 
      void set( const agx::Vec3& begin,
                const agx::Vec3& end,
                const agx::Vec3& previousEndPoint0,
                const agx::Vec3& previousEndPoint1,
                float radius );
 
 
      float getRadius() const;
 
      float getHeight() const;
 
      agx::Vec3 getPreviousEndPoint0() const;
 
 
      agx::Vec3 getPreviousEndPoint1() const;
 
      const agxCollide::WireShape* getCastShape() const;
 
    protected:
      virtual ~WireShapeProxy() = default;
 
    protected:
      void synchronizeParameters();
 
    protected:
      agx::Vec3 m_previousEndPoint0;
      agx::Vec3 m_previousEndPoint1;
      float m_height;
      float m_radius;
  };
 
 
  class AGXPHYSICS_EXPORT BoxProxy : public RenderProxy
  {
    public:
      BoxProxy();
      BoxProxy( const agx::Vec3& halfExtents );
 
      void set( const agx::Vec3& halfExtents );
 
      agx::Vec3 getHalfExtents() const;
 
      const agxCollide::Box* getCastShape() const;
 
    protected:
      virtual ~BoxProxy() {}
 
    protected:
      void synchronizeParameters();
 
    protected:
      agx::Vec3 m_halfExtents;
  };
 
 
  class AGXPHYSICS_EXPORT HeightFieldProxy : public RenderProxy
  {
    public:
      HeightFieldProxy();
      HeightFieldProxy( agxCollide::HeightField* hf );
 
      HeightFieldProxy& operator=( const HeightFieldProxy& ) = delete;
 
      void setHeights(const agx::Vec2iVector& modifiedIndices, const agx::RealVector& heights);
 
      const agxCollide::HeightField* getCastShape() const;
 
    protected:
      virtual ~HeightFieldProxy() = default;
 
      virtual void set( const agx::Vec2iVector& modifiedIndices, const agx::RealVector& heights ) = 0;
  };
 
 
  class AGXPHYSICS_EXPORT TrimeshProxy : public RenderProxy
  {
    public:
      TrimeshProxy();
      TrimeshProxy( agxCollide::Trimesh* mesh );
 
      TrimeshProxy& operator=( const TrimeshProxy& ) = delete;
 
      const agxCollide::Trimesh* getCastShape() const;
 
    protected:
      virtual ~TrimeshProxy() {}
  };
 
 
  class AGXPHYSICS_EXPORT ContactsProxy : public RenderProxy
  {
    public:
      ContactsProxy( const agxCollide::GeometryContactPtrVector& contacts );
 
      void set( const agxCollide::GeometryContactPtrVector& contacts, float scale );
 
      const agxCollide::GeometryContactPtrVector& getContacts() const;
 
    protected:
      virtual ~ContactsProxy() {}
 
    protected:
      ContactsProxy();
 
    protected:
      const agxCollide::GeometryContactPtrVector* m_contacts;
      float m_scale;
  };
 
 
  class AGXPHYSICS_EXPORT RigidBodyBatchRenderProxy : public RenderProxy
  {
    public:
      typedef agx::Vector<const agx::RigidBody*> Container;
 
    public:
      RigidBodyBatchRenderProxy();
 
      void set( const agx::RigidBodyPtrSetVector* enabledBodies, float scale );
 
    protected:
      virtual ~RigidBodyBatchRenderProxy() = default;
 
    protected:
      agxRender::RigidBodyBatchRenderProxy::Container m_bodies;
      float                                           m_scale;
  };
 
  class AGXPHYSICS_EXPORT WireRenderProxy : public RenderProxy
  {
    public:
      struct SegmentDef
      {
        SegmentDef( const agx::Vec3& sp, const agx::Vec3& ep, float r )
          : startPoint( sp ), endPoint( ep ), radius( r ) {}
 
        const SegmentDef* operator->() const { return this; }
 
        agx::AffineMatrix4x4 getTransform() const;
        agx::Vec3f getScale() const;
 
        agx::Vec3 startPoint;
        agx::Vec3 endPoint;
        float radius;
      };
 
      struct SphereDef
      {
        SphereDef( const agx::Vec3& p )
          : point( p ) {}
 
        const SphereDef* operator->() const { return this; }
        agx::AffineMatrix4x4 getTransform() const;
 
        agx::Vec3 point;
      };
 
      typedef agx::VectorPOD<SegmentDef> SegmentDefContainer;
      typedef agx::VectorPOD<SphereDef>  SphereDefContainer;
 
    public:
      WireRenderProxy( float radius, const agx::Vec3& color );
 
      virtual void onAddNotification() {}
 
      virtual void onRemoveNotification() {}
 
      void prepare( agx::UInt numSegmentEstimate,
                    agx::UInt numEdgesEstimate,
                    agx::UInt numNodesEstimate );
 
      void commit();
 
      void addSegment( const agx::Vec3& startPoint,
                       const agx::Vec3& endPoint,
                       const agx::Vec3& prevStartPoint,
                       const agx::Vec3& prevEndPoint );
 
      void addSegment( const agx::Vec3& startPoint,
                       const agx::Vec3& endPoint,
                       float radius,
                       const agx::Vec3& color,
                       agxRender::RenderManager* manager ) const;
 
      void addEdge( const agx::Vec3& startPoint, const agx::Vec3& endPoint );
 
      void addNode( const agx::Vec3& point );
 
      void addNode( const agx::Vec3& point,
                    float radius,
                    const agx::Vec3& color,
                    agxRender::RenderManager* manager ) const;
 
    protected:
      virtual ~WireRenderProxy() {}
 
    protected:
      float               m_radius;
      SegmentDefContainer m_segments;
      SegmentDefContainer m_edges;
      SphereDefContainer  m_nodes;
  };
 
  typedef agx::ref_ptr<WireRenderProxy> WireRenderProxyRef;
 
  // -------- Implementation ----------------
 
  //inline PrimitiveType RenderProxy::getType() const { return m_type; }
 
  inline void RenderProxy::setTransform( const agx::AffineMatrix4x4& transform )
  {
    m_transform = transform;
    callOnChange( TRANSFORM );
  }
 
  inline const agx::AffineMatrix4x4& RenderProxy::getTransform() const
  {
    return m_transform;
  }
 
  inline void RenderProxy::setColor( const agx::Vec3& color )
  {
    if ( !agx::equivalent( m_color, color ) ) {
      m_color = color;
      callOnChange( COLOR );
    }
  }
 
  inline agx::Vec3 RenderProxy::getColor() const
  {
    return m_color;
  }
 
  inline void RenderProxy::setAlpha( float alpha )
  {
 
    if ( !agx::equivalent( m_alpha, alpha ) ) {
      m_alpha = alpha;
      callOnChange( ALPHA );
    }
  }
 
  inline float RenderProxy::getAlpha() const
  {
    return m_alpha;
  }
 
  inline void RenderProxy::setModifiedCount( agx::UInt32 c )
  {
    m_modifiedCount = c;
  }
 
  inline agx::UInt32 RenderProxy::getModifiedCount() const
  {
    return m_modifiedCount;
  }
 
  inline void RenderProxy::setShape( agxCollide::Shape* shape, const agxCollide::Geometry* geometry )
  {
    m_shape = shape;
    m_geometry = geometry;
    setModifiedCount( agx::UInt32( -1 ) );
  }
 
  inline const agxCollide::Shape* RenderProxy::getShape() const
  {
    return m_shape;
  }
 
  inline const agxCollide::Geometry* RenderProxy::getGeometry() const
  {
    return m_geometry;
  }
 
  inline void RenderProxy::setEnable( bool flag )
  {
    if ( m_enable != flag )
    {
      m_enable = flag;
      callOnChange( ENABLE );
    }
  }
 
  inline bool RenderProxy::getEnable() const
  {
    return m_enable;
  }
 
  inline void RenderProxy::setRenderMode( RenderProxy::RenderMode mode )
  {
    if ( mode != m_renderMode ) {
      m_renderMode = (RenderMode)mode;
      callOnChange( RENDERMODE );
    }
  }
 
  inline RenderProxy::RenderMode RenderProxy::getRenderMode() const
  {
    return (RenderMode)m_renderMode;
  }
 
  inline agx::AffineMatrix4x4 WireRenderProxy::SegmentDef::getTransform() const
  {
    return agx::AffineMatrix4x4::rotate( agx::Vec3::Z_AXIS(), (endPoint - startPoint).normal() ) * agx::AffineMatrix4x4::translate( (startPoint + endPoint) * agx::Real( 0.5 ) );
  }
 
  inline agx::Vec3f WireRenderProxy::SegmentDef::getScale() const
  {
    return agx::Vec3f( radius, radius, (float)startPoint.distance( endPoint ) );
  }
 
  inline agx::AffineMatrix4x4 WireRenderProxy::SphereDef::getTransform() const
  {
    return agx::AffineMatrix4x4::translate( point );
  }
}