ExternalDeformer.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.
*/
 
#include <agx/BitState.h>
#include <agxTerrain/SoilParticleAggregate.h>
#include <agxTerrain/SoilPenetrationResistance.h>
#include <agxTerrain/AggregateContactGenerator.h>
#include <agxTerrain/DeformController.h>
#include <agxTerrain/ShovelSettings.h>
#include <agxStream/Serializable.h>
#include <agx/Plane.h>
 
#pragma once
 
namespace agxCollide
{
    class Geometry;
    class Shape;
}
 
namespace agxTerrain
{
    //--- Forward declarations ---//
    class Terrain;
    class TerrainMaterial;
 
    using TerrainPtrVec = agx::VectorPOD<Terrain*>;
 
    AGX_DECLARE_POINTER_TYPES(ExternalDeformer);
    AGX_DECLARE_VECTOR_TYPES(ExternalDeformer);
 
    class AGXTERRAIN_EXPORT ExternalDeformer : public agxSDK::TerrainToolInstance
    {
    public:
        class ExcavationSettings;
        class Settings;
 
        ExternalDeformer( agx::RigidBody* parentBody,
                          const agx::Line& cuttingEdge,
                          const agx::Line& topEdge,
                          const agx::Vec3& cuttingDirection );
 
        ExternalDeformer(agx::RigidBody* parentBody);
 
        void addDeformer( const agx::Line& cuttingEdge,
                          const agx::Line& topEdge,
                          const agx::Vec3& cuttingDirection );
 
        agx::RigidBody* getRigidBody() const;
 
        const agxCollide::GeometryRefVector& getVoxelCollisionGeometries() const;
 
        DeformController* getDeformController() const;
 
        /*
        \return the active terrain that the external deformer is acting on. If the external deformer is currently
        not interacting with the terrain, return nullptr.
        */
        Terrain* getActiveTerrain() const;
 
        bool collisionGeometriesAreInsideTerrain(Terrain* terrain) const;
 
        /*
        \return if the deformer is currently active. The deformer is active while interacting with a terrain.
        */
        bool isActive() const;
 
        /*
        \return if the deformer is valid after construction. If it is not valid, it will not be possible to add the deformer to
        a simulation.
        */
        virtual bool isValid() const override;
 
        /*
        Set whether the external deformer should be enabled or not.
        \param enable - true if the external deformer is enabled, false otherwise.
        */
        void setEnable( bool enable );
 
        /*
        return whether the external deformer should is enabled or not.
        */
        bool getEnable() const;
 
        void setEnableDebugRendering( bool enable );
 
        bool getEnableDebugRendering() const;
 
        DOXYGEN_START_INTERNAL_BLOCK()
 
        virtual void onAssemblyAdd(agxSDK::Assembly* assembly) override;
 
        AGXSTREAM_DECLARE_SERIALIZABLE(agxTerrain::ExternalDeformer);
 
        DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
        ExternalDeformer();
 
        virtual ~ExternalDeformer();
 
        /*
        Creates a frame which uses the parents body's frame as parent. Other internals
        attaches to this frame to make sure they follow along the parent rigid body.
        Requires that the parent body isn't nullptr.
        */
        agx::Frame* createParentFrame();
 
        virtual void addNotification()  override;
 
        virtual void removeNotification() override;
 
        void setAggregateMaterial(agx::Material* material);
 
        /*
        Checks if all internal contact materials are correct.
        If there is an active terrain (ie, we are interacting with a terrain)
        the contact material will be customized for that terrain.
        */
        void checkContactMaterials();
 
        void initalizeContactMaterialsForExistingTerrains(agxSDK::Simulation* simulation);
 
        virtual void preCollide() override;
 
        virtual void pre() override;
 
        virtual void post() override;
 
        virtual void last() override;
 
        agxSDK::TerrainManager* getTerrainManager();
 
        TerrainPtrVec getTerrainsInSimulation();
 
        void clearActiveZoneWedges() const;
 
    private:
        enum StateFlags : agx::UInt32
        {
          ENABLED = 1 << 0
        };
        using Flags = agx::BitState<StateFlags, agx::UInt32>;
 
 
        void addDeformers(const std::array<DeformerCollectionRef, 3>& deformers);
 
        bool shouldDeformMass(Terrain* terrain);
 
    protected:
 
        // Configuration:
        agx::RigidBodyRef                           m_parentBody;
        agx::FrameRef                               m_parentFrame; /* Parent frame for parent body geometries synchronized with model center of parent body. */
        Flags                                       m_flags;
        DeformControllerRef                         m_deformController;
 
        // Geometries used to find deformer-voxel collisions
        agx::MaterialRef                            m_aggregateMaterial;
        agxCollide::GeometryRefVector               m_voxelCollisionGeometries;
        Terrain*                                    m_activeTerrain;
        bool                                        m_isActive;
        agxCollide::BoundingAABB                    m_collisionBound;
 
 
        agx::Vector<DeformerCollectionRef>          m_deformers;
 
        bool                                        m_debugRenderForbiddenBound;
    };
}