boxobstacle.h

Go to the documentation of this file.

/*
* Copyright 2016 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.
*/



#pragma once


#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:
    // ------------------------------ Functions -----------------------------

    BoxObstacleInitConfig() { SetDefaults(); }

    void SetDefaults()
    {
        m_world = nullptr;
        m_databaseBinding = nullptr;
        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 = nullptr;
        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) { m_transform = transform; }

    void SetLinearVelocity(const Vec3f& linearVelocity) { m_linearVelocity = linearVelocity; }

    void SetAngularVelocity(const Vec3f& angularVelocity) { m_angularVelocity = angularVelocity; };

    void SetRotationMode(BoxObstacleRotationMode mode) { m_rotationMode = mode; }

    void SetDoesTriggerTagVolume(bool doesTriggerTagVolume) { m_doesTriggerTagVolume = doesTriggerTagVolume; }


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

    const Vec3f& GetLocalCenter() const { return m_localCenter; }
    const Vec3f& GetLocalHalfExtents() const { return m_localHalfExtents; }

    const Vec3f& GetLinearVelocity() const { return m_linearVelocity; }
    const Vec3f& GetAngularVelocity() const { return m_angularVelocity; }
    const Transform& GetTransform() const { return m_transform; }
    BoxObstacleRotationMode GetRotationMode() const { return m_rotationMode; }
    const TagVolume* GetTagVolume() const { return m_tagVolumeTrigger.GetTagVolume(); }
    TagVolume* GetTagVolume() { return m_tagVolumeTrigger.GetTagVolume(); }
    const DynamicNavTag& GetNavTag() const { return m_navTag; }

    KyUInt32 GetSpatializedCylinderCount() const { return (GetRotationMode() == BoxObstacleRotation_Yaw) ? m_sampledSpatializedCylinderCount : 1; }

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

    TagVolume::IntegrationStatus GetTagVolumeIntegrationStatus() const { return m_tagVolumeTrigger.GetIntegrationStatus(); }
    const DatabaseBinding* GetDatabaseBinding() const { return m_databaseBinding; }

    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.
    const SpatializedCylinder& GetCentralSpatializedCylinder() const { return m_centralSpatializedCylinder; }

    KyUInt32 GetSampledSpatializedCylinderCount() const { return m_sampledSpatializedCylinderCount; }
    const SpatializedCylinder& GetSampledSpatializedCylinder(KyUInt32 index) const { return m_sampledSpatializedCylinders[index]; }

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;
};

} // Kaim