DeformableRenderer.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/ShaderGeometryGroup.h>
 
#include <agxModel/DeformableObject.h>
 
#include <agxRender/Color.h>
 
#include <osg/MatrixTransform>
#include <osg/Geometry>
 
namespace agxOSG
{
  class AGXOSG_EXPORT DeformableRenderer : public ShaderGeometryGroup
  {
    public:
      using OsgGeometryRef = osg::ref_ptr<osg::Geometry>;
 
      using RenderVertexIndexVector = std::vector<size_t>;
      using TrimeshVertexToRenderVertices = std::vector<RenderVertexIndexVector>;
 
    public:
      static DeformableRenderer* find( const agxModel::DeformableObject* deformable, osg::Group* root );
 
    public:
      DeformableRenderer( const agxModel::DeformableObject* deformable,
                          agxRender::Color color = agxRender::Color::DarkOliveGreen() );
 
      const agxModel::DTetrahedronMesh& getMesh() const;
 
      const agxModel::DeformableObject* getDeformable() const;
 
      void setCreaseAngle( agx::Real creaseAngleRad );
 
      agx::Real getCreaseAngle() const;
 
      void setBaseColor( const agxRender::Color& baseColor );
 
      agxRender::Color getBaseColor() const;
 
      void setAlpha( float alpha );
 
      float getAlpha() const;
 
      void setEnableColorStresses( bool enable );
 
      bool getEnableColorStresses() const;
 
      void setMaxStressColor( const agxRender::Color& maxStressColor );
 
      agxRender::Color getMaxStressColor() const;
 
      void setMaxStressLimit( agx::Real maxStressLimit );
 
      agx::Real getMaxStressLimit() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      osg::Geometry* getSurfaceGeometry() const;
 
    protected:
      struct InternalState
      {
        enum Flag : agx::UInt16
        {
          COLOR_STRESSES = 1 << 0,
        };
        using Flags = agx::BitState<Flag, std::underlying_type_t<Flag>>;
 
        Flags flags{};
        agxRender::Color baseColor = agxRender::Color::DarkOliveGreen();
        agxRender::Color maxStressColor = agxRender::Color::Red();
        agx::Real maxStressLimit = 60000.0;
        agx::Real creaseAngle = 0.8 * agx::PI_2;
      };
 
    protected:
      virtual ~DeformableRenderer();
 
      virtual bool initialize() override;
 
      virtual void update() override;
 
      virtual void updateVertices();
 
      virtual void updateNormals();
 
      virtual void updateColors();
 
      virtual void handleSurfaceGeometryAlphaTriangleSort();
 
    protected:
      osg::Vec3Array* getVertexArray() const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      agxModel::DeformableObjectConstObserver m_deformable;
      OsgGeometryRef m_osgSurfaceGeometry;
      TrimeshVertexToRenderVertices m_trimeshToRenderVertices;
      InternalState m_state;
  };
 
  using DeformableRendererRef = osg::ref_ptr<DeformableRenderer>;
}