PressureRenderer.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 AGXOSG_PRESSURE_RENDERER_H
#define AGXOSG_PRESSURE_RENDERER_H
 
#include <agxCollide/Trimesh.h>
#include <agxSDK/StepEventListener.h>
#include <agxSDK/ContactEventListener.h>
 
#include <agxOSG/export.h>
#include <agxOSG/PressureAtlasManager.h>
#include <agxOSG/Node.h>
#include <agxOSG/SceneDecorator.h>
 
#include <agx/PushDisableWarnings.h> // Disabling warnings. Include agx/PopDisableWarnings.h below!
#include <osg/observer_ptr>
#include <osgSim/ColorRange>
#include <agx/PopDisableWarnings.h> // End of disabled warnings.
 
#include <agxRender/Color.h>
#include <agxOSG/PressureFromContacts.h>
 
namespace osg
{
  class Group;
}
 
 
 
namespace agxOSG
{
  AGX_DECLARE_POINTER_TYPES(PressureRenderer);
  class AGXOSG_EXPORT PressureRenderer : public agx::Referenced
  {
    public:
      PressureRenderer(
        osg::Group* root,
        agxOSG::SceneDecorator* decorator,
        agxSDK::Simulation* simulation,
        osgSim::ColorRange* colorRange = new osgSim::ColorRange(0.0f, 1.0e5f),
        const agx::Real texelsPerMeter = agx::Real(50),
        const agx::Real rangeFactor = agx::Real(2.0e-5),
        agxOSG::PressureFromContacts::ForceType forceType = agxOSG::PressureFromContacts::TOTAL_FORCE
        );
 
      PressureRenderer(
        osg::Group* root,
        agxOSG::SceneDecorator* decorator,
        agxSDK::Simulation* simulation,
        const agx::Real minPressure,
        const agx::Real maxPressure,
        const agxRender::ColorVector& colors,
        const agx::Real texelsPerMeter = agx::Real(50),
        const agx::Real rangeFactor = agx::Real(2.0e-5),
        agxOSG::PressureFromContacts::ForceType forceType = agxOSG::PressureFromContacts::TOTAL_FORCE
        );
 
      bool addTrimesh(agxCollide::Trimesh* trimesh, bool keepGeometryNode = false);
 
      bool addGeometry(agxCollide::Geometry* geometry, bool keepGeometryNode = false);
 
 
      bool startMaxAvgRecording();
 
      size_t stopMaxAvgRecording();
 
      bool isRecording();
 
      size_t getNumRecordings();
 
      bool renderMaxPressure(size_t recording);
 
      bool renderAvgPressure(size_t recording);
 
      bool restoreRendering();
 
      void setEnableLegend(bool flag);
 
      agx::Vec2 getLegendPosition() const;
 
      void setLegendPosition(const agx::Vec2& pos);
 
      osgSim::ColorRange* getColorRange();
 
      agxOSG::PressureAtlasManager* getPressureAtlasManager();
 
      void addFilter(agxSDK::ExecuteFilter* filter);
 
 
    protected:
      virtual ~PressureRenderer();
 
      // Helper function used by render[Max|Avg]Pressure.
      bool renderPressure(size_t recording, bool useMax);
 
      // Trigger a color conversion for the recording currently being recorded.
      // Only valid between calls to startMaxAvgRecording() and
      // stopMaxAvgRecording(). Called from stopMaxAvgRecording() right before
      // copying color information to the recordings list.
      void updateTextureData();
 
      // Remove the maximum- and average gatherers from their respective PressureAtlases.
      void unregisterRecorders();
 
    protected:
      agx::Vector<agxCollide::TrimeshRef> m_meshes;
      osg::observer_ptr<osg::Group> m_root;
      osg::observer_ptr<agxOSG::SceneDecorator> m_decorator;
      agxOSG::PressureAtlasManagerRef m_atlasManager;
      osg::ref_ptr<osgSim::ColorRange> m_colorRange; // Holds min pressure, max pressure, and colors.
      osg::ref_ptr<agxOSG::Transform> m_legendTransform; // Holding the transform to the HUD-legend.
      agx::Vec2 m_legendPosition;
      agx::Real m_rangeFactor;
      agx::Vector<agxSDK::ExecuteFilterRef> m_filters;
 
 
      /*
       * Data used during recording. On per measured mesh.
       */
      struct MaxAvgData {
        MaxAvgData(const agxCollide::TrimeshConstObserver mesh, GatherMaxPressureRef maxGatherer, GatherAvgPressureRef avgGatherer, osg::Group* root);
        osg::Texture2D* getTexture(osg::Group* root);
 
        const agxCollide::TrimeshConstObserver mesh;
        GatherMaxPressureRef maxGatherer;
        GatherAvgPressureRef avgGatherer;
        osg::ref_ptr<osg::Image> originalTextureImage; // Borrowed from the osg::Texture2D originaly used to render the mesh.
      private:
        // Hiding assignment
        MaxAvgData& operator=(const MaxAvgData&) {return *this;}
 
      };
 
      // Non-empty while recording. One element per measured mesh.
      agx::Vector<MaxAvgData> m_maxAvgData;
 
 
      /*
       * Data held for each mesh for each finished recording.
       */
      struct MaxAvgRecording {
        MaxAvgRecording(const MaxAvgData& data);
        osg::Texture2D* getTexture(osg::Group* root);
 
        const agxCollide::TrimeshConstObserver mesh;
        osg::ref_ptr<osg::Image> maxPressure; // Copy of the color map generated by a MaxAvgData::maxGatherer.
        osg::ref_ptr<osg::Image> avgPressure; // Copy of the color map generated by a MaxAvgData::avgGatherer.
        osg::ref_ptr<osg::Image> originalTextureImage; // Given from MaxAvgData upon stopMaxAvgRecording().
      private:
        // Hiding assignment
        MaxAvgRecording& operator=(const MaxAvgRecording&) {return *this;}
      };
 
      // Vector holding all recorded data for a particular recording.
      typedef agx::Vector<MaxAvgRecording> MaxAvgRecordingVector;
 
      // Vector holding all recordings. Recording IDs are indices into this vector.
      agx::Vector<MaxAvgRecordingVector> m_maxAvgRecordings;
 
      // The record ID that is currently being used for rendering.
      size_t m_currentRecording;
 
      // The type of force to register. Normal, tangential or both.
      const agxOSG::PressureFromContacts::ForceType m_forceType;
    private:
      // Hiding assignment
      PressureRenderer& operator=(const PressureRenderer&) {return *this;}
  };
}
 
 
#endif