TerrainVoxelRenderer.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/config/AGX_USE_AGXTERRAIN.h>
#if defined(SWIG) || AGX_USE_AGXTERRAIN()
 
#include <agxOSG/Node.h>
#include <agxOSG/SoilParticleSystemDrawable.h>
#include <agxOSG/TerrainVoxelDrawable.h>
 
#include <agx/PushDisableWarnings.h> // Disabling warnings. Include agx/PopDisableWarnings.h below!
#include <osg/Drawable>
#include <osgViewer/Viewer>
#include <osgSim/ColorRange>
#include <osgSim/ScalarsToColors>
#include <osg/Version>
#include <agx/PopDisableWarnings.h> // End of disabled warnings.
 
#include <agx/config/AGX_USE_AGXTERRAIN.h>
#include <agxSDK/StepEventListener.h>
#include <agxTerrain/Terrain.h>
#include <agx/Task.h>
#include <vector>
 
namespace agxOSG
{
  AGX_DECLARE_POINTER_TYPES(TerrainVoxelRenderer);
 
  class AGXOSG_EXPORT TerrainVoxelRenderer : public agxSDK::StepEventListener
  {
    public:
      static TerrainVoxelRenderer* find( const agxTerrain::Terrain* terrain, const agxSDK::Simulation* simulation );
 
    public:
      enum RenderMode
      {
        DEPTH,
        COMPACTION
      };
 
    public:
      TerrainVoxelRenderer( agxTerrain::Terrain* terrain, osg::Group* group );
 
      TerrainVoxelRenderer(agxSDK::TerrainInstance* terrainInstance, osg::Group* group);
 
      agxTerrain::Terrain* getTerrain() const;
 
      agxOSG::GeometryNode* getNode() const;
 
      void setRenderVoxelSolidMass(bool enable);
 
      bool getRenderVoxelSolidMass() const;
 
      void setRenderVoxelFluidMass(bool enable);
 
      bool getRenderVoxelFluidMass() const;
 
      void setRenderVoxelBoundingBox(bool enable);
 
      bool getRenderVoxelBoundingBox() const;
 
      void setRenderHeightField(bool enable);
 
      bool getRenderHeightField() const;
 
      void setRenderVoxelCompaction(bool enable);
 
      bool getRenderVoxelCompaction() const;
 
      void setRenderTerrainMaterials(bool enable);
 
      bool getRenderTerrainMaterials() const;
 
 
      void setRenderDefaultTerrainMaterial(bool enable);
 
      bool getRenderDefaultTerrainMaterial() const;
 
      void setTerrainMaterialsColors(const agxRender::ColorVector& colors);
 
      agxRender::ColorVector getTerrainMaterialColors() const;
 
      void setRenderVelocityField(bool enable);
 
      bool getRenderVelocityField() const;
 
      void setRenderSoilParticles(bool enable);
 
      bool getRenderSoilParticles() const;
 
      void setRenderSoilParticlesMesh(bool enable);
 
      bool getRenderSoilParticlesMesh() const;
 
      void setSoilParticleMeshData( const agx::String& modelFilename, const agx::String& textureFilename = "" );
 
      const agx::String& getSoilParticleMeshModelFilename() const;
 
      const agx::String& getSoilParticleMeshTextureFilename() const;
 
      void setRenderHeights(
        bool enable,
        agx::RangeReal heightRange = agx::RangeReal(),
        bool useRelativeHeights = false,
        const osg::Vec4& lowColor  = osg::Vec4( 0.0, 0.0, 1.0, 1.0 ),
        const osg::Vec4& midColor  = osg::Vec4( 0.0, 1.0, 0.0, 1.0 ),
        const osg::Vec4& highColor = osg::Vec4( 1.0, 0.0, 0.0, 1.0 ) );
 
      bool getRenderHeights() const;
 
      void setRenderCompaction(bool enable, agx::RangeReal compactionRange = agx::RangeReal( 0.75, 1.5 ));
 
      bool getRenderCompaction() const;
 
      void setColor(agx::Vec4f color);
 
      agx::Vec4f getColor() const;
 
      void setVelocityFieldLineColor(const agx::Vec4& lineColor);
 
      void setMaxVoxelValueColor(const agx::Vec4f& maxVoxelColor);
 
#ifndef SWIG
    public:
      struct ContextData
      {
        ContextData();
        ~ContextData();
 
        agx::Bool isValid() const;
 
        osg::ref_ptr<agxOSG::GeometryNode> node;
        osg::observer_ptr<osg::Group>      parent;
        osg::ref_ptr<osg::Geometry>        geometry;
        osg::ref_ptr<osg::Geode>           geode;
        osg::StateSet*                     stateSet;
 
        osg::ref_ptr<osgSim::ColorRange> colorRange;
        osg::ref_ptr<osg::Vec4Array>     colorArray;
      };
 
      struct SoilParticleMeshData
      {
        osg::ref_ptr<osg::Node> node;
        osg::ref_ptr<osg::Group> group;
        agx::String modelFilename;
        agx::String textureFilename;
      };
 
    public:
      virtual void addNotification() override;
      virtual void removeNotification() override;
      virtual void last( const agx::TimeStamp& ) override;
#endif
 
    protected:
      virtual ~TerrainVoxelRenderer();
 
    protected:
      agxTerrain::TerrainObserver              m_terrain;
      ContextData                              m_surfaceContextData;
      ContextData                              m_heightsContextData;
      osg::Vec4                                m_color;
      osg::ref_ptr<TerrainVoxelDrawable>       m_voxelDrawable;
      osg::ref_ptr<SoilParticleSystemDrawable> m_soilParticleDrawable;
      SoilParticleMeshData                     m_soilParticleMeshData;
      bool                                     m_useRelativeHeights = false;  // RELATIVE HEIGHT COLORING
      std::vector<agx::Real>                   m_originalHeights;  // RELATIVE HEIGHT COLORING
  };
 
  AGXOSG_EXPORT void setupTerrainJournalPlaybackSettings( agxSDK::Simulation* simulation );
}
#endif