utils.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 <agx/Vec4.h>
 
#include <agxUtil/agxUtil.h>
#include <agxUtil/Statistic.h>
#include <agxOSG/Node.h>
#include <agxOSG/ParticleSystemDrawable.h>
#include <agxOSG/RigidBodySystemDrawable.h>
#include <agxOSG/RigidBodyRenderCache.h>
#include <agxOSG/ScalarColorMap.h>
#include <agxOSG/DeformableRenderer.h>
 
#include <agxSDK/GuiEventListener.h>
 
#include <agxRender/Color.h>
 
 
#include <agx/PushDisableWarnings.h> // Disabling warnings. Include agx/PopDisableWarnings.h below!
#include <osg/observer_ptr>
#include <osgGA/NodeTrackerManipulator>
 
#include <agx/PopDisableWarnings.h> // End of disabled warnings.
 
#include <agx/config/AGX_USE_AGXTERRAIN.h>
 
 
namespace agx
{
  class RigidBody;
  class ParticleSystem;
 
  class RigidBodyEmitter;
}
 
namespace agxSDK
{
  class Simulation;
}
 
namespace agxCollide
{
  class Geometry;
}
 
namespace agxUtil
{
  class ExponentialMovingAverageStatistic;
}
 
namespace agxModel
{
  class FractureGenerator;
  class DeformableObject;
}
 
DOXYGEN_START_INTERNAL_BLOCK()
 
 
namespace osg {
  class Geometry;
  class Node;
  class Texture2D;
}
 
namespace osgSim
{
  class ColorRange;
}
 
namespace osgText
{
  class Text;
}
DOXYGEN_END_INTERNAL_BLOCK()
 
namespace agxOSG
{
  class GeometryNode;
  class FrameTrajectoryDrawable;
  class TerrainVoxelRenderer;
 
  enum TextureMode
  {
    DIFFUSE_TEXTURE=0,
    SHADOW_TEXTURE=1,
    SHADOW_JITTER_TEXTURE=2,
    NORMALMAP_TEXTURE=3,
    HEIGHTMAP_TEXTURE=4,
    ROUGHNESS_TEXTURE = 5,
    CUBEMAP_TEXTURE = 6,
    METALLIC_TEXTURE = 7
  };
 
  AGXOSG_EXPORT GeometryNode* findGeometryNode( const agxCollide::Geometry* geometry, osg::Group* rootNode );
 
  AGXOSG_EXPORT agx::Vector<GeometryNode*> findGeometryNodes(const agxCollide::Geometry * geometry, osg::Group * rootNode);
 
  AGXOSG_EXPORT bool setCubeMapTexture(osg::Node *node, const std::string& imagePath, const std::string& imageType = ".dds");
 
  AGXOSG_EXPORT void setEnvMapReflectionCoefficient(osg::Node* node, float coeff);
 
  AGXOSG_EXPORT bool setTexture(const agxCollide::Geometry* geometry, osg::Group* rootNode, const std::string& imagePath, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE);
 
  AGXOSG_EXPORT bool setTexture(
    const agx::RigidBody* rigidBody, osg::Group* rootNode, const std::string& imagePath,
    bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE);
 
  AGXOSG_EXPORT bool setTexture(
    osg::Node* node, const std::string& imagePath, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE,
    float scaleU = 1.0f, float scaleV = 1.0f);
 
  AGXOSG_EXPORT bool setTexture(
    osg::Node* node, const agxCollide::TextureDataRef data, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE,
    float scaleU = 1.0f, float scaleV = 1.0f);
 
 
  AGXOSG_EXPORT osg::Texture2D* createTexture(const std::string& filename);
 
 
  AGXOSG_EXPORT osg::Texture2D* createTexture(const agxCollide::TextureDataRef data, bool linear);
 
  AGXOSG_EXPORT bool setTexture(
    osg::Node *node, osg::Texture2D *texture, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE,
    float scaleU = 1.0f, float scaleV = 1.0f);
 
  AGXOSG_EXPORT bool setTexture(osg::Node *node, agxOSG::Texture2D *texture, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE, float scaleU = 1.0f, float scaleV = 1.0f);
 
 
  AGXOSG_EXPORT bool setTexture(agxOSG::GeometryNode *node, agxOSG::Texture2D *texture, bool repeat = false, TextureMode mode = DIFFUSE_TEXTURE, float scaleU = 1.0f, float scaleV = 1.0f);
 
  template <typename T>
  void setUniform( osg::Node *node, const std::string& name, T value)
  {
    if ( node == nullptr )
      return;
 
    node->getOrCreateStateSet()->addUniform( new osg::Uniform(name.c_str(), value));
  }
 
  AGXOSG_EXPORT bool addText(const agxCollide::Geometry* geometry,
                             osg::Group* root,
                             const std::string& text,
                             const agx::Vec3& relPosition = agx::Vec3(0, 0, 0),
                             const agx::Vec4f& color = agxRender::Color::Yellow(),
                             agx::Real size = 0.2,
                             int alignment = 6);
 
  AGXOSG_EXPORT osg::Geode* createCubeLines( const agx::Vec3& position,
                                             const agx::Vec3& boxHalfVec3,
                                             const agxRender::Color& color = agxRender::Color::BlueViolet(),
                                             const agx::Real lineWidth = 2.0f );
 
  AGXOSG_EXPORT osg::Geode* createText(const std::string& text,
                                       const agx::Vec3& relPosition = agx::Vec3(0,0,0),
                                       const agx::Vec4f& color = agxRender::Color::Yellow(),
                                       agx::Real size = 0.2);
 
 
  AGXOSG_EXPORT bool removeText(const agxCollide::Geometry* geometry, osg::Group * root, size_t index = 0);
 
  AGXOSG_EXPORT osgText::Text* findText( const agxCollide::Geometry* geometry, osg::Group* root, size_t index = 0 );
 
  AGXOSG_EXPORT osg::Geometry* createGrid(
    unsigned int resU,
    unsigned int resV,
    const osg::Vec3& origin,
    const osg::Vec3& endPointX,
    const osg::Vec3& endPointY,
    bool wireFrameMode = false);
 
  AGXOSG_EXPORT osg::Geode* createGrid(
    unsigned int resU,
    unsigned int resV,
    const agx::Vec3& origin,
    const agx::Vec3& endPointX,
    const agx::Vec3& endPointY,
    osg::Group* root);
 
 
  AGXOSG_EXPORT osg::Geometry* create3DGrid(
    unsigned int resU,
    unsigned int resV,
    unsigned int resW,
    const osg::Vec3& origin,
    const osg::Vec3& endPointX,
    const osg::Vec3& endPointY,
    const osg::Vec3& endPointZ,
    float width
  );
 
  AGXOSG_EXPORT osg::Geode* create3DGrid(
    unsigned int resU,
    unsigned int resV,
    unsigned int resW,
    const agx::Vec3& origin,
    const agx::Vec3& endPointX,
    const agx::Vec3& endPointY,
    const agx::Vec3& endPointZ,
    float width);
 
 
  AGXOSG_EXPORT osg::Geode* createSphere(const agx::Vec3& center, const agx::Vec4& color, float radius);
 
  AGXOSG_EXPORT osg::MatrixTransform* createCylinder( const agx::AffineMatrix4x4& transform, const agx::Vec4& color, float radius, float height );
 
  AGXOSG_EXPORT osg::Geode* createLine(const agx::Vec3& p1, const agx::Vec3& p2, const agx::Vec4& color, float width);
 
  AGXOSG_EXPORT osg::Geode* createPolyline(const agx::Vec3Vector& points, const agx::Vec4& color, float width);
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(float scale=1, float width=3);
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(agxCollide::Geometry* geometry, agx::Frame* relativeTransform, osg::Group* root, float scale = 1, float width=3);
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(agxCollide::Geometry* geometry, agx::AffineMatrix4x4 relativeTransform, osg::Group* root, float scale = 1, float width = 3);
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(agx::RigidBody* rb, agx::Frame* relativeTransform, osg::Group* root, float scale = 1, float width = 3);
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(agx::RigidBody* rb, agx::AffineMatrix4x4 relativeTransform, osg::Group* root, float scale = 1, float width = 3);
 
 
  AGXOSG_EXPORT osg::MatrixTransform* createAxes(agx::AffineMatrix4x4 absoluteTransform, osg::Group* root, float scale = 1, float width = 3);
 
  AGXOSG_EXPORT bool createAxes( agx::Constraint* constraint, osg::Group* root, float scale = 1, float width = 3);
 
  AGXOSG_EXPORT void setSpecularColor( osg::Node * node, const agx::Vec4f& color, bool override = false);
 
  AGXOSG_EXPORT void setShininess( osg::Node *node, float shininess, bool override = false);
 
  AGXOSG_EXPORT void setGamma(osg::Node* node, float gamma, bool override = false);
 
  AGXOSG_EXPORT void setRoughness(osg::Node* node, float roughness, bool override = false);
 
  AGXOSG_EXPORT void setMetallic(osg::Node* node, float metallic, bool override = false);
 
  AGXOSG_EXPORT void setAmbientColor( osg::Node * node, const agx::Vec4f& color, bool override = false);
 
  AGXOSG_EXPORT void setAlpha( osg::Node * node, float alpha, bool override = false);
 
  AGXOSG_EXPORT void setDiffuseColor( osg::Node* node, const agx::Vec4f& color, bool override = false );
 
 
  AGXOSG_EXPORT void setDiffuseColor( agx::RigidBody* rb, const agx::Vec4f& color, osg::Group* root );
 
  AGXOSG_EXPORT void setDiffuseColor( agxCollide::Geometry* geometry, const agx::Vec4f& color, osg::Group* root );
 
  AGXOSG_EXPORT agxOSG::GeometryNode *createVisual( const agxCollide::Geometry* geometry, osg::Group* root, float detailRatio = 1.0f, bool createAxes = false, bool evenIfSensor=true );
 
  AGXOSG_EXPORT osg::Geode *createVisual( agx::ParticleSystem* particleSystem, osg::Group* root, agxOSG::ParticleSystemDrawable::ParticleRenderingMode mode = DEFAULT_PARTICLE_RENDERING_MODE, agxOSG::ParticleSystemDrawable::ParticleShaderMode particleShaderMode = agxOSG::ParticleSystemDrawable::ROTATION_SPRITES);
 
  AGXOSG_EXPORT agxOSG::ParticleSystemDrawable *findParticleSystemDrawable(osg::Group* root);
 
  AGXOSG_EXPORT agxOSG::RigidBodySystemDrawable* findRigidBodySystemDrawable( osg::Group* root );
 
  AGXOSG_EXPORT osg::Group *createVisual( agx::RigidBodyEmitter* emitter, osg::Group* root);
 
  AGXOSG_EXPORT osg::Group *createVisual(agx::Emitter* emitter, osg::Group* root);
 
#if AGX_USE_AGXTERRAIN()
 
  AGXOSG_EXPORT agxOSG::TerrainVoxelRenderer* createVisual(agxSDK::TerrainInstance* terrainInstance, osg::Group* root);
#endif
 
  AGXOSG_EXPORT osg::MatrixTransform *createVisual(agx::ObserverFrame *frame, osg::Group* root, float scale = 1);
 
 
  AGXOSG_EXPORT osg::Geode *createParticleContactGraph(agx::ParticleSystem* particleSystem, osg::Group* root, agx::Real minForce, agx::Real maxForce);
 
  AGXOSG_EXPORT osg::Geode *createParticleTrajectoriesVisual(agx::ParticleSystem* particleSystem, osg::Group* root, agx::Real sampling, agx::UInt numPositions);
 
  AGXOSG_EXPORT osg::Geode *createRigidBodyTrajectoriesVisual(agxSDK::Simulation * simulation, osg::Group* root, agx::Real sampling, agx::UInt numPositions, ScalarColorMap* scalarColorMap = nullptr );
 
  AGXOSG_EXPORT osg::Geode *createFrameTrajectoryDrawable(agxSDK::Simulation * simulation, osg::Group* root, agx::UInt numPositions, const agx::Vec4f& defaultColor = agx::Vec4f(0.5, 0.5, 0.5, 1.0));
 
  AGXOSG_EXPORT agxOSG::FrameTrajectoryDrawable* findFrameTrajectoryDrawable(osg::Group* root);
 
  AGXOSG_EXPORT osg::Group *createVisual( agx::RigidBody* rb, osg::Group* root, float detailRatio = 1.0f, bool createAxes = false );
 
  AGXOSG_EXPORT std::tuple<osg::Group*, std::vector<size_t>> createVisualWithGeometryConnection(agx::RigidBody* rb, osg::Group* root, float detailRatio = 1.0f, bool createAxes = false);
 
  AGXOSG_EXPORT osg::Group *createVisual( agxSDK::Assembly *parent, osg::Group* root, float detailRatio = 1.0f, bool createAxes = false );
 
  AGXOSG_EXPORT osg::Group* createVisualTemplateCaching( agxSDK::Assembly* parent, osg::Group* root, agxOSG::RigidBodyRenderCache* cache = nullptr, float detailRatio = 1.0f, bool createAxes = false );
 
  AGXOSG_EXPORT agxSDK::EventListener* createVisualUpdater(agxSDK::EventListener* listener, osg::Group* root);
 
  AGXOSG_EXPORT osg::Group *createVisual(agxSDK::Simulation *simulation, osg::Group* root, float detailRatio = 1.0f, bool createAxes = false);
 
  AGXOSG_EXPORT bool setEnableOutline(osg::Node *node, bool enabled, const agxRender::Color& color=agxRender::Color(1,1,0,1), float width = 2.0);
  AGXOSG_EXPORT bool getEnableOutline(osg::Node *node);
 
  AGXOSG_EXPORT size_t smoothNormals( osg::Node* node, float creaseAngle = 1.48353f);
 
  AGXOSG_EXPORT void setEnableLight( bool enable, int lightNum, osg::Node* node  );
 
  AGXOSG_EXPORT void getNearFarPoints(const osg::Camera* camera, float x, float y, agx::Vec3& near, agx::Vec3& far);
 
  AGXOSG_EXPORT agxCollide::LocalGeometryContact getHoveredGeometryContact(const osg::Camera * camera, agxCollide::Space * space, float x, float y);
 
  AGXOSG_EXPORT bool setEnableWireFrameMode(osg::Node* node, bool flag);
 
  AGXOSG_EXPORT bool forceWireFrameModeOn( osg::Node* node );
 
  AGXOSG_EXPORT bool toggleWireFrameMode(osg::Node* node);
 
  AGXOSG_EXPORT bool setOrbitCamera(osgViewer::Viewer* viewer,
                                    osg::Group* node,
                                    const agx::Vec3& eye,
                                    const agx::Vec3& center,
                                    const agx::Vec3& up,
                                    int trackerMode=osgGA::NodeTrackerManipulator::NODE_CENTER);
 
 
 
  AGXOSG_EXPORT bool  loadCubeMapImages(const std::string& imagename, const std::string& filetype, agx::Vector<osg::ref_ptr<osg::Image> >& images);
 
  AGXOSG_EXPORT osg::TextureCubeMap * createTextureCubeMap(agx::Vector<osg::ref_ptr<osg::Image> >& images);
  AGXOSG_EXPORT osg::TextureCubeMap * createTextureCubeMap(const std::string& imagename, const std::string& filetype);
 
  AGXOSG_EXPORT void addRenderColorCallbackToFracture( agxModel::FractureGenerator * listener, osg::Group * root, const agx::Vec4f& color );
 
  AGXOSG_EXPORT void addRenderCallbackToFracture( agxModel::FractureGenerator * listener, osg::Group * root );
 
  AGXOSG_EXPORT agxCollide::Trimesh *createTrimesh(osg::Node *node);
 
  AGXOSG_EXPORT agxOSG::DeformableRenderer* createVisual( const agxModel::DeformableObject* deformable,
                                                          osg::Group* root,
                                                          const agxRender::Color& color = agxRender::Color::DarkOliveGreen(),
                                                          bool colorSurfaceStress = false,
                                                          const agxRender::Color& maxStressColor = agxRender::Color::Red(),
                                                          agx::Real maxStressLimit = 6.0E4 );
 
  AGXOSG_EXPORT agxOSG::DeformableRenderer* findDeformableRenderer( const agxModel::DeformableObject* deformable,
                                                                    osg::Group* root );
}