ForbiddenBound.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 <agxTerrain/export.h>
#include <agxCollide/BoundingAABB.h>
#include <agxRender/Color.h>
#include <agx/AffineMatrix4x4.h>
#include <agx/Frame.h>
#include <agx/BitState.h>
#include <agx/Vector.h>
#include <agx/Referenced.h>
 
 
namespace agxTerrain
{
  class Terrain;
 
  AGX_DECLARE_POINTER_TYPES( IForbiddenBound );
  AGX_DECLARE_VECTOR_TYPES( IForbiddenBound );
  class AGXTERRAIN_EXPORT IForbiddenBound : public agx::Referenced, public agxStream::Serializable
  {
  public:
    virtual bool containsIndex( const agx::Vec3i& terrainIndex, agxTerrain::Terrain* terrain ) const = 0;
 
    virtual bool containsPosition( const agx::Vec3& position, agxTerrain::Terrain* terrain ) const = 0;
 
 
    virtual void debugRender( agxTerrain::Terrain* terrain,
                              agx::Real size,
                              const agxRender::Color& color,
                              bool isStatic ) const = 0;
 
    AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( IForbiddenBound );
 
    void setEnable( bool enable ) { m_enable = enable; }
 
    bool getEnable() const { return m_enable; }
 
    void setEnableDebugRendering( bool enable ) { m_enableDebugRendering = enable; }
 
    bool getEnableDebugRendering() const { return m_enableDebugRendering; }
 
  protected:
    IForbiddenBound();
    virtual ~IForbiddenBound() = default;
 
    void restore( agxStream::InputArchive& in ) override;
 
    void store( agxStream::OutputArchive& out ) const override;
 
  protected:
    bool m_enable;
    // We do not serialize this variable
    bool m_enableDebugRendering;
  };
 
 
 
  AGX_DECLARE_POINTER_TYPES( ForbiddenBound );
  class AGXTERRAIN_EXPORT ForbiddenBound : public IForbiddenBound
  {
  public:
    ForbiddenBound(
      const agxCollide::BoundingAABB& bound,
      agx::AffineMatrix4x4 localTransform = agx::AffineMatrix4x4(),
      agx::Frame* parentTransform = nullptr );
 
    virtual bool containsIndex( const agx::Vec3i& terrainIndex, agxTerrain::Terrain* terrain ) const override;
 
    virtual bool containsPosition( const agx::Vec3& position, agxTerrain::Terrain* terrain ) const override;
 
    agxCollide::BoundingAABB getBound() const { return m_bound; }
    void setBound(const agxCollide::BoundingAABB& bound) { m_bound = bound; }
 
    agx::Frame* getParentFrame() const { return m_parentTransform; }
 
    const agx::AffineMatrix4x4& getLocalTransform() const { return m_localTransform; }
    void setLocalTransform(const agx::AffineMatrix4x4& transform);
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
      virtual void debugRender( agxTerrain::Terrain* terrain,
      agx::Real size,
      const agxRender::Color& color,
      bool isStatic ) const override;
 
    AGXSTREAM_DECLARE_SERIALIZABLE( ForbiddenBound );
 
    DOXYGEN_END_INTERNAL_BLOCK()
  protected:
    ForbiddenBound();
    virtual ~ForbiddenBound() = default;
 
  protected:
    agxCollide::BoundingAABB  m_bound;
    agx::AffineMatrix4x4      m_localTransform;
    agx::AffineMatrix4x4      m_invLocalTransform;
    agx::FrameRef             m_parentTransform;
  };
 
 
 
  AGX_DECLARE_POINTER_TYPES( ForbiddenIndexBound );
  class AGXTERRAIN_EXPORT ForbiddenIndexBound : public IForbiddenBound
  {
  public:
    ForbiddenIndexBound( const agx::Bound3i& bound );
 
    virtual bool containsIndex( const agx::Vec3i& terrainIndex, agxTerrain::Terrain* terrain ) const override;
 
    virtual bool containsPosition( const agx::Vec3& position, agxTerrain::Terrain* terrain ) const override;
 
    agx::Bound3i getBound() const { return m_bound; }
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
    virtual void debugRender( agxTerrain::Terrain* terrain,
                              agx::Real size,
                              const agxRender::Color& color,
                              bool isStatic ) const override;
 
    AGXSTREAM_DECLARE_SERIALIZABLE( ForbiddenIndexBound );
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    ForbiddenIndexBound();
    virtual ~ForbiddenIndexBound() = default;
 
  protected:
    agx::Bound3i m_bound;
  };
 
 
 
  AGX_DECLARE_POINTER_TYPES( ForbiddenIndex2DBound );
  class AGXTERRAIN_EXPORT ForbiddenIndex2DBound : public IForbiddenBound
  {
  public:
    ForbiddenIndex2DBound( const agx::Bound2i& bound );
 
    virtual bool containsIndex( const agx::Vec3i& terrainIndex, agxTerrain::Terrain* terrain ) const override;
 
    virtual bool containsPosition( const agx::Vec3& position, agxTerrain::Terrain* terrain ) const override;
 
 
    agx::Bound2i getBound() const { return m_bound; }
 
    DOXYGEN_START_INTERNAL_BLOCK();
 
      virtual void debugRender( agxTerrain::Terrain* terrain,
        agx::Real size,
        const agxRender::Color& color,
        bool isStatic ) const override;
 
    AGXSTREAM_DECLARE_SERIALIZABLE( ForbiddenIndex2DBound );
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    ForbiddenIndex2DBound();
    virtual ~ForbiddenIndex2DBound() = default;
 
  protected:
    agx::Bound2i m_bound;
  };
}