ForceArrowRenderer.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 <agxOSG/export.h>
#include <agxOSG/GuiEventListener.h>
#include <agx/HashVector.h>
#include <agx/Constraint.h>
#include <agxUtil/Statistic.h>
#include <agxRender/Color.h>
 
namespace agxOSG
{
  class AGXOSG_EXPORT ForceArrowRenderer : public agxSDK::GuiEventListener
  {
  public:
    
    enum ConstraintForceStatistics
    {
      MOTOR1D = 0x1,
      RANGE1D = 0x2,
      LOCK1D = 0x4,
      ALL = MOTOR1D | RANGE1D | LOCK1D,
      DEFAULT = MOTOR1D
    };
 
    ForceArrowRenderer();
 
    bool add(agx::RigidBody* body, const agx::Vec3& localOffsetRelBody, const agxRender::Color& color = agxRender::Color::Red());
 
    agx::Bool remove(agx::RigidBody* body);
 
 
    /*
    Add a 1DOF constraint. The sum of the motor forces are visualized with one arrow.
    \param constraint - The constraint that should be added.
    \param localOffsetRelBody1 - the start point of the arrow relative the first rigid body of the first constraint.
    \param color - Color of the arrow.
    \param statisticsMask - Selects which forces that should be part of the calculation of the length of the force vector.
    \return true if constraint is successfully added.
    */
    bool add(agx::Constraint1DOF* constraint, const agx::Vec3& localOffsetRelBody1, const agxRender::Color& color = agxRender::Color::Red(), ConstraintForceStatistics statisticsMask = DEFAULT);
 
    agx::Bool remove(agx::Constraint1DOF* constraint);
 
    agx::Bool setColor(agx::RigidBody* body, const agxRender::Color& color);
 
    agx::Bool setColor(agx::Constraint1DOF* constraint, const agxRender::Color& color);
 
    void setSmoothFactor(agx::Real smoothFactor);
 
    agx::Real getSmoothFactor() const;
 
    void setConeHeight(agx::Real height);
 
    agx::Real getConeHeight() const;
    
    void setArrowRadius(agx::Real radius);
 
    agx::Real getArrowRadius() const;
 
    void setScale(agx::Real scale);
 
    agx::Real getScale() const;
 
 
  protected:
    virtual void update(float x, float y);
    virtual ~ForceArrowRenderer();
 
    void drawArrow(const agx::Vec3& start, const agx::Vec3& force, const agxRender::Color& color);
 
    agx::Bool m_enabled;
    agx::Real m_smoothFactor;
    agx::Real m_coneHeight;
    agx::Real m_arrowRadius;
    agx::Real m_scale;
 
#ifndef SWIG
    enum ContactForceStatistics
    {
      NORMAL_X = 0,
      NORMAL_Y,
      NORMAL_Z,
      FRICTION_X,
      FRICTION_Y,
      FRICTION_Z,
      NUM_FORCES
    };
 
    template<typename T>
    struct Statistic : public agx::Referenced, public T
    {
      using T::T;
    };
 
    typedef Statistic<agxUtil::ExponentialMovingAverageStatistic> RendererStatistic;
 
    class ConstraintData : public agx::Referenced {
    public:
      ConstraintData(
        agx::Constraint1DOF* c, 
        RendererStatistic* s, 
        const agx::Vec3& r, 
        const agxRender::Color& col, 
        ConstraintForceStatistics mask) : constraint(c), 
                                          statistic(s), 
                                          relative(r), 
                                          statisticsMask(mask),
                                          color(col) {}
      
 
      agx::Constraint1DOFObserver constraint;
      agx::ref_ptr<RendererStatistic> statistic;
      agx::Vec3 relative;
      ConstraintForceStatistics statisticsMask;
      agxRender::Color color;
    };
    
    class BodyData : public agx::Referenced {
    public:
      BodyData(agx::RigidBody* b, 
               agx::Real smoothFactor, 
               const agx::Vec3& r, 
               const agxRender::Color& c) : body(b), relative(r), color(c)
      {
        for (int i = 0; i < NUM_FORCES; i++)
          statistics.push_back(new RendererStatistic(smoothFactor));
      }
 
      agx::RigidBodyObserver body;
      agx::Vector<agx::ref_ptr<RendererStatistic>> statistics;
      agx::Vec3 relative;
      agxRender::Color color;
    };
 
    typedef agx::HashVector<agx::Constraint1DOF*, agx::ref_ptr< ConstraintData>> ConstraintHashVector;
    typedef agx::HashVector<agx::RigidBody*, agx::ref_ptr<BodyData>> RigidBodyHashVector;
    
    ConstraintHashVector m_constraints;
    RigidBodyHashVector m_bodies;
#endif
  };
 
}