cylinderobstacle.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: none
#ifndef Navigation_CylinderObstacle_H
#define Navigation_CylinderObstacle_H

#include "gwnavruntime/world/worldelement.h"
#include "gwnavruntime/spatialization/spatializedcylinder.h"
#include "gwnavruntime/dynamicnavmesh/tagvolumetrigger.h"


namespace Kaim
{

class World;
class DatabaseBinding;


class CylinderObstacleInitConfig
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_CylinderObstacle)

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

    CylinderObstacleInitConfig() { SetDefaults(); }

    void SetDefaults()
    {
        m_world = KY_NULL;
        m_databaseBinding = KY_NULL;
        m_navTag.Clear();
        m_navTag.SetAsExclusive();
        m_startPosition.Set(0.0f, 0.0f, 0.0f);
        m_userData = KY_NULL;
        m_radius = 0.3f;
        m_height = 1.8f;
    }


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

    World* m_world;

    Ptr<DatabaseBinding> m_databaseBinding;

    DynamicNavTag m_navTag;

    Vec3f m_startPosition;
    void* m_userData;
    KyFloat32 m_radius;
    KyFloat32 m_height;
};



class CylinderObstacle: public WorldElement
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_CylinderObstacle)
    KY_CLASS_WITHOUT_COPY(CylinderObstacle)

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

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

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

    CylinderObstacle();
    CylinderObstacle(const CylinderObstacleInitConfig& initConfig);

    virtual ~CylinderObstacle();


    void Init(const CylinderObstacleInitConfig& initConfig);

    void Clear();

    void AddToWorld();

    void RemoveFromWorld();

    void SetPosition(const Vec3f& position);
    void SetVelocity(const Vec3f& velocity); 

    void SetDoesTriggerTagVolume(bool triggerTagVolume);


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

    const DynamicNavTag&         GetNavTag()                     const; 
    const SpatializedCylinder&   GetSpatializedCylinder()        const; 
    SpatializedCylinder&         GetSpatializedCylinder();              

    KyFloat32                    GetRadius()                     const; 
    KyFloat32                    GetHeight()                     const; 
    const Vec3f&                 GetPosition()                   const; 
    const Vec3f&                 GetVelocity()                   const; 

    bool                         DoesTriggerTagVolume()          const; 
    const TagVolume*             GetTagVolume()                  const; 
    TagVolume::IntegrationStatus GetTagVolumeIntegrationStatus() const; 

    const DatabaseBinding*       GetDatabaseBinding()            const; 

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

    // Updates the SpatializedCylinder position and velocity with the data provided
    // in the CylinderObstacleUpdateConfig.
    // Computes then the spatialization of the SpatializedCylinder.
    void UpdateSpatialization();


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

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


private:
    // ---------- Input ----------

    Vec3f m_position;
    Vec3f m_velocity; 
    bool m_doesTriggerTagVolume;

    DynamicNavTag m_navTag;
    Ptr<DatabaseBinding> m_databaseBinding;

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

    TagVolumeTrigger<CylinderObstacle> m_tagVolumeTrigger;
    SpatializedCylinder m_spatializedCylinder;
};


KY_INLINE const DynamicNavTag&         CylinderObstacle::GetNavTag()                     const { return m_navTag;              }

KY_INLINE SpatializedCylinder&         CylinderObstacle::GetSpatializedCylinder()              { return m_spatializedCylinder; }
KY_INLINE const SpatializedCylinder&   CylinderObstacle::GetSpatializedCylinder()        const { return m_spatializedCylinder; }
KY_INLINE KyFloat32                    CylinderObstacle::GetRadius()                     const { return m_spatializedCylinder.GetRadius();   }
KY_INLINE KyFloat32                    CylinderObstacle::GetHeight()                     const { return m_spatializedCylinder.GetHeight();   }

KY_INLINE const Vec3f&                 CylinderObstacle::GetPosition()                   const { return m_position; }
KY_INLINE const Vec3f&                 CylinderObstacle::GetVelocity()                   const { return m_velocity; }

KY_INLINE void                         CylinderObstacle::SetPosition(const Vec3f& position)    { m_position = position; }
KY_INLINE void                         CylinderObstacle::SetVelocity(const Vec3f& velocity)    { m_velocity = velocity; }

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

KY_INLINE const DatabaseBinding*       CylinderObstacle::GetDatabaseBinding()            const { return m_databaseBinding; }

KY_INLINE void CylinderObstacle::SetDoesTriggerTagVolume(bool doesTriggerTagVolume) { m_doesTriggerTagVolume = doesTriggerTagVolume; }

KY_INLINE void CylinderObstacle::OnTagVolumeIntegration()
{
    m_spatializedCylinder.InvalidateAllDbSpatializations();
    ForceSendAllVisualDebug();
}


KY_INLINE void CylinderObstacle::UpdateSpatialization()
{
    m_tagVolumeTrigger.Update(m_doesTriggerTagVolume);

    if (m_tagVolumeTrigger.GetIntegrationStatus() != TagVolume::IntegrationStatus_Integrated)
        m_spatializedCylinder.UpdateSpatialization(m_position);
    else
        m_spatializedCylinder.SetPosition(m_position);

    m_spatializedCylinder.SetVelocity(m_velocity);
    
    ForceSendAllVisualDebug();
}

} // namespace Kaim

#endif // Navigation_CylinderObstacle_H