boxobstacle.h

Go to the documentation of this file.

/*
* Copyright 2015 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/



// primary contact: LAPA - secondary contact: NOBODY
#ifndef Navigation_BoxObstacle_H
#define Navigation_BoxObstacle_H


#include "gwnavruntime/world/worldelement.h"
#include "gwnavruntime/math/box3f.h"
#include "gwnavruntime/math/transform.h"
#include "gwnavruntime/spatialization/spatializedcylinder.h"
#include "gwnavruntime/world/tagvolume.h"
#include "gwnavruntime/dynamicnavmesh/tagvolumetrigger.h"


namespace Kaim
{

class DatabaseBinding;


enum BoxObstacleRotationMode
{
    BoxObstacleRotation_Yaw = 0,

    BoxObstacleRotation_Free
};


enum BoxObstacleUpAxis
{
    BoxObstacleUp_X = 0,
    BoxObstacleUp_Minus_X,
    BoxObstacleUp_Y,
    BoxObstacleUp_Minus_Y,
    BoxObstacleUp_Z,
    BoxObstacleUp_Minus_Z
};


class BoxObstacleInitConfig
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_BoxObstacle)

public:
    // ---------------------------------- Public Member Functions ----------------------------------

    BoxObstacleInitConfig() { SetDefaults(); }

    void SetDefaults()
    {
        m_world = KY_NULL;
        m_databaseBinding = KY_NULL;
        m_navTag.Clear();
        m_navTag.SetAsExclusive();
        m_localCenter.Set(0.0f, 0.0f, 0.0f);
        m_localHalfExtents.Set(0.0f, 0.0f, 0.0f);
        m_startPosition.Set(0.0f, 0.0f, 0.0f);
        m_userData = KY_NULL;
        m_rotationMode = BoxObstacleRotation_Free;
        m_upAxis = BoxObstacleUp_Z;
    }


    // ---------------------------------- Public Data Members ----------------------------------

    World* m_world;

    Ptr<DatabaseBinding> m_databaseBinding;

    DynamicNavTag m_navTag;

    Vec3f m_localCenter;

    Vec3f m_localHalfExtents;
    Vec3f m_startPosition;

    void* m_userData;

    BoxObstacleRotationMode m_rotationMode;

    BoxObstacleUpAxis m_upAxis;
};



class BoxObstacle: public WorldElement
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_BoxObstacle)
    KY_CLASS_WITHOUT_COPY(BoxObstacle)

public:
    static  WorldElementType GetStaticType() { return TypeBoxObstacle; }
    virtual WorldElementType GetType() const { return TypeBoxObstacle; }

    virtual const char*      GetTypeName() const { return "BoxObstacle"; }


    // ---------------------------------- Main API Functions ----------------------------------

    BoxObstacle();
    BoxObstacle(const BoxObstacleInitConfig& initConfig);

    virtual ~BoxObstacle();

    void Init(const BoxObstacleInitConfig& initConfig);

    void Clear();

    void AddToWorld();

    void RemoveFromWorld();

    void SetTransform(const Transform& transform);

    void SetLinearVelocity(const Vec3f& linearVelocity);

    void SetAngularVelocity(const Vec3f& angularVelocity);

    void SetRotationMode(BoxObstacleRotationMode mode);

    void SetDoesTriggerTagVolume(bool triggerTagVolume);


    // ---------------------------------- Getters ----------------------------------

    const Vec3f&                   GetLocalCenter()                       const;
    const Vec3f&                   GetLocalHalfExtents()                  const;
    
    
    const Vec3f&                   GetLinearVelocity()                    const;
    const Vec3f&                   GetAngularVelocity()                   const;
    const Transform&               GetTransform()                         const;
    BoxObstacleRotationMode        GetRotationMode()                      const;
    const TagVolume*               GetTagVolume()                         const;
    const DynamicNavTag&           GetNavTag()                            const;
    KyUInt32                       GetSpatializedCylinderCount()          const;
    const SpatializedCylinder&     GetSpatializedCylinder(KyUInt32 index) const;
    
    TagVolume::IntegrationStatus   GetTagVolumeIntegrationStatus()        const;
    const DatabaseBinding*         GetDatabaseBinding()                   const;

    bool DoesTriggerTagVolume() const;

    static const char* GetRotationModeDescription(BoxObstacleRotationMode rotationMode);

private:
    void SetDefaults();

    // Computes the SpatializedCylinder set that best fit the obstacle extents, in
    // local coordinates.
    // This is called each time the BoxObstacle is reinitialized, and the first time
    // the obstacle is updated with BoxObstacleRotation_Yaw flag.
    void ComputeSampledPoints();

    // Computes the SpatializedCylinder positions as sampled on a given plane.
    // Automatically called by ComputeSampledPoints once the third dimension is reduced 
    // according to the BoxObstacleUpAxis provided in BoxObstacleInitConfig.
    void ComputeSampledPoints_2D(const Vec3f& baseCenter, const Vec3f& axis0, const Vec3f& axis1,
        KyFloat32 halfExt0, KyFloat32 halfExt1, KyFloat32 sampledPointsHeight);

    // Computes the SpatializedCylinder positions as sampled along a given line.
    // Automatically called by ComputeSampledPoints_2D, once the second dimension is reduced 
    // accordingly to the wider 2D extent.
    void ComputeSampledPoints_1D(const Vec3f& baseCenter, const Vec3f& axis,
        KyFloat32 length, KyFloat32 width, KyFloat32 sampledPointsHeight);

    // Computes the global position and the velocity at a given local position
    // according to transform, and linear and angular velocities.
    void ComputePositionAndVelocity(const Vec3f& localPosition, Vec3f& newPosition, Vec3f& newVelocity);


public: // internal
    virtual void DoSendVisualDebug(VisualDebugServer& visualDebugServer, VisualDebugSendChangeEvent changeEvent); // Inherited from WorldElement

    // Updates the SpatializedCylinders positions and velocities according to
    // the Transform, and linear and angular velocities of this BoxObstacle; 
    // then computes the spatialization of the set to be used accordingly to update status.
    void UpdateSpatialization();

    // Sets up the TagVolume with its DynamicNavTag and the contour that best fits the obstacle.
    // This is called by TagVolumeTrigger when the BoxObstacle is updated with a 
    // DoesTriggerTagVolume set to true.
    void SetupTagVolumeInitConfig(TagVolumeInitConfig& tagVolumeInitConfig);

    // Called when the TagVolume integration is complete. It invalidates all Db spatializations.
    void OnTagVolumeIntegration();


    // NOTE: direct access to spatialization sets should not be used.
    // Use the non-internal public sets that provide information
    // on the SpatializedCylinder set currently in use according to
    // rotation mode.
    // They are used only in unit tests to validate they are well managed
    // according to the rotation mode and the triggerTagVolume flag.
    SpatializedCylinder& GetCentralSpatializedCylinder();
    KyUInt32             GetSampledSpatializedCylinderCount();
    SpatializedCylinder& GetSampledSpatializedCylinder(KyUInt32 index);
    TagVolume*           GetTagVolume();


private:
    // -------- Input -----------
    
    Ptr<DatabaseBinding> m_databaseBinding;

    DynamicNavTag m_navTag;

    Vec3f m_localCenter;
    Vec3f m_localHalfExtents;

    BoxObstacleUpAxis m_upAxis;

    BoxObstacleRotationMode m_rotationMode;

    bool m_doesTriggerTagVolume;

    Transform m_transform;

    Vec3f m_linearVelocity;

    Vec3f m_angularVelocity;

    // --------- Obstacle state ----------

    TagVolumeTrigger<BoxObstacle> m_tagVolumeTrigger;

    SpatializedCylinder m_centralSpatializedCylinder;
    SpatializedCylinder* m_sampledSpatializedCylinders;
    Vec3f* m_sampledSpatializedCylinderLocalPositions;
    KyUInt32 m_sampledSpatializedCylinderCount;
};

KY_INLINE const DynamicNavTag&           BoxObstacle::GetNavTag()                     const { return m_navTag;                                      }
KY_INLINE const Vec3f&                   BoxObstacle::GetLocalCenter()                const { return m_localCenter;                                 }
KY_INLINE const Vec3f&                   BoxObstacle::GetLocalHalfExtents()           const { return m_localHalfExtents;                            }
KY_INLINE BoxObstacleRotationMode        BoxObstacle::GetRotationMode()               const { return m_rotationMode;         }

KY_INLINE bool                           BoxObstacle::DoesTriggerTagVolume()          const { return m_doesTriggerTagVolume; }
KY_INLINE const TagVolume*               BoxObstacle::GetTagVolume()                  const { return m_tagVolumeTrigger.GetTagVolume();             }
KY_INLINE TagVolume::IntegrationStatus   BoxObstacle::GetTagVolumeIntegrationStatus() const { return m_tagVolumeTrigger.GetIntegrationStatus();     }
KY_INLINE const DatabaseBinding*         BoxObstacle::GetDatabaseBinding()            const { return m_databaseBinding;                             }

KY_INLINE KyUInt32 BoxObstacle::GetSpatializedCylinderCount()          const
{
    return (GetRotationMode() == BoxObstacleRotation_Yaw) ? m_sampledSpatializedCylinderCount : 1;
}
KY_INLINE const SpatializedCylinder& BoxObstacle::GetSpatializedCylinder(KyUInt32 index) const
{
    return (GetRotationMode() == BoxObstacleRotation_Yaw) ? m_sampledSpatializedCylinders[index] : m_centralSpatializedCylinder;
}

KY_INLINE const Vec3f& BoxObstacle::GetLinearVelocity()  const { return m_linearVelocity; }
KY_INLINE const Vec3f& BoxObstacle::GetAngularVelocity() const { return m_angularVelocity; }
KY_INLINE const Transform& BoxObstacle::GetTransform() const { return m_transform; }

KY_INLINE SpatializedCylinder& BoxObstacle::GetCentralSpatializedCylinder()               { return m_centralSpatializedCylinder;         }
KY_INLINE KyUInt32             BoxObstacle::GetSampledSpatializedCylinderCount()          { return m_sampledSpatializedCylinderCount;    }
KY_INLINE SpatializedCylinder& BoxObstacle::GetSampledSpatializedCylinder(KyUInt32 index) { return m_sampledSpatializedCylinders[index]; }
KY_INLINE TagVolume*           BoxObstacle::GetTagVolume()                                { return m_tagVolumeTrigger.GetTagVolume();    }

} // Kaim

#endif // Navigation_BoxObstacle_H