positiononpath.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/path/path.h"
#include "gwnavruntime/kernel/SF_RefCount.h"

namespace Kaim
{

enum PositionOnPathStatus
{
    PositionOnPathStatus_Undefined = 0, 
    PositionOnPathStatus_OnPathNode,    
    PositionOnPathStatus_OnPathEdge     
};


class PositionOnPath
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Path)

public:
    // ---------------------------------- Main API Functions ----------------------------------

    PositionOnPath() : m_onPathStatus(PositionOnPathStatus_Undefined), m_currentIndexOnPath(KyUInt32MAXVAL), m_distanceToEndOfPath(0.0f), m_mustUpdateDistanceInternalState(true) {}

    bool operator==(const PositionOnPath& positionOnPath) const;
    bool operator!=(const PositionOnPath& other) const { return !(*this == other); }

    void InitOnPathNode(Path* path, KyUInt32 pathNodeIdx);
    void InitOnPathFirstNode(Path* path) { InitOnPathNode(path, 0); }
    void InitOnPathLastNode(Path* path);
    void InitOnPathEdge(Path* path, const Vec3f& positionOnEdge, KyUInt32 pathEdgeIdx);

    void Clear();

    bool IsValid() const { return m_onPathStatus != PositionOnPathStatus_Undefined && m_path != nullptr && m_currentIndexOnPath < m_path->GetNodeCount(); }

    bool IsAtFirstNodeOfPath() const { return m_onPathStatus == PositionOnPathStatus_OnPathNode && m_currentIndexOnPath == 0; }
    bool IsAtLastNodeOfPath() const  { return m_onPathStatus == PositionOnPathStatus_OnPathNode && m_currentIndexOnPath + 1 == m_path->GetNodeCount(); }
    bool IsAtFirstEdgeOfPath() const { return m_onPathStatus != PositionOnPathStatus_Undefined  && m_currentIndexOnPath == 0; }

    bool IsAtLastEdgeOfPath() const { return IsAtLastNodeOfPath() || (m_onPathStatus == PositionOnPathStatus_OnPathEdge && m_currentIndexOnPath + 1 == m_path->GetEdgeCount()); }

    bool IsAtLastNodeOfAChannel()  const;

    Path* GetPath() const { return m_path; }

    const Vec3f& GetPosition() const { return m_position; }

    PositionOnPathStatus GetPositionOnPathStatus() const { return m_onPathStatus; }

    KyFloat32 GetRemainingDistanceToEndOfPath() const { return m_distanceToEndOfPath; }

    PathEdgeType GetPathEdgeType() const { return m_path->GetPathEdgeType(GetPathEdgeIndex()); }

    PathEdgeType GetEdgeTypeToMoveOnForward() const { return m_path->GetPathEdgeType(GetEdgeIdxToMoveOnForward()); }

    PathEdgeType GetEdgeTypeToMoveOnBackward() const { return m_path->GetPathEdgeType(GetEdgeIdxToMoveOnBackward()); }

    bool DoesPrecede(const PositionOnPath& other) const;

    bool IsStrictlyBefore(const PositionOnPath& other) const;


    // ---------------------------------- Path Edge Functions ----------------------------------

    KyUInt32 GetPathEdgeIndex() const;

    KyUInt32 GetEdgeIdxToMoveOnForward()  const;

    KyUInt32 GetEdgeIdxToMoveOnBackward() const { return GetPathEdgeIndex(); }

    // ---------------------------------- Move Functions ----------------------------------

    void MoveForward(KyFloat32 distanceMove);

    void MoveBackward(KyFloat32 distanceMove);

    KyFloat32 MoveForward_StopAtPathNode(KyFloat32 distanceMove);

    KyFloat32 MoveBackward_StopAtPathNode(KyFloat32 distanceMove);

    void MoveForwardToNextPathNode();

    void MoveBackwardToPrevPathNode();

    void MoveForwardToNextPathEdge();

    void MoveBackwardToPrevPathEdge();


    KyFloat32 ComputeDistance(const PositionOnPath& otherPositionOnPath) const;


    KyFloat32 MoveForwardToClosestPositionOnPath(const Vec3f& originalPosition, const PositionOnPath* upToPosOnPath = nullptr);

    // ---------------------------------- Unsafe Version of Functions ----------------------------------

    // cf. MoveForward_StopAtPathNode
    KyFloat32 MoveForward_StopAtPathNode_Unsafe(KyFloat32 distanceMove);
    // cf. MoveBackward_StopAtPathNode
    KyFloat32 MoveBackward_StopAtPathNode_Unsafe(KyFloat32 distanceMove);
    // cf. MoveForwardToNextPathNode
    void MoveForwardToNextPathNode_Unsafe();
    // cf. MoveBackwardToPrevPathNode
    void MoveBackwardToPrevPathNode_Unsafe();
    // cf. MoveForwardToNextPathEdge
    void MoveForwardToNextPathEdge_Unsafe();
    // cf. MoveBackwardToPrevPathEdge
    void MoveBackwardToPrevPathEdge_Unsafe();

private:
    KyFloat32 ComputeDistanceToEndOfPathFromPathEdge(KyUInt32 pathEdgeIdx, const Vec3f& positionOnEdge) const;
    KyFloat32 ComputeDistanceToEndOfPathFromPathNode(KyUInt32 pathNodeIdx) const;
    KyFloat32 ComputeDistance(KyUInt32 fromPathNodeIdx, KyUInt32 toPathNodeIdx) const;

    void ClampOnCurrentPathEdge(const Kaim::Vec3f& originalPosition);

public: // internal
    void GetRawValues(Path*& path, Vec3f& position, PositionOnPathStatus& onPathStatus, KyUInt32& currentIndexOnPath, KyFloat32& distanceToEndOfPath) const
    {
        path = m_path;
        position = m_position;
        onPathStatus = m_onPathStatus;
        currentIndexOnPath = m_currentIndexOnPath;
        distanceToEndOfPath = m_distanceToEndOfPath;
    }
    void SetRawValues(Path* path, const Vec3f& position, PositionOnPathStatus onPathStatus, KyUInt32 currentIndexOnPath, KyFloat32 distanceToEndOfPath)
    {
        m_path = path;
        m_position = position;
        m_onPathStatus = onPathStatus;
        m_currentIndexOnPath = currentIndexOnPath;
        m_distanceToEndOfPath = distanceToEndOfPath;
    }

private:
    Ptr<Path> m_path;
    Vec3f m_position;

    PositionOnPathStatus m_onPathStatus;
    KyUInt32 m_currentIndexOnPath; // index on the Path edge or index of the Path node. position is on ]EdgeStart, EdgeEnd]

    KyFloat32 m_distanceToEndOfPath; // Maintained informatively, ie.e it is not used to differentiate two PositionOnPath instances.
    bool m_mustUpdateDistanceInternalState; // Internal state used to prevent some useless computations of m_distanceToEndOfPath in some functions.
};

} // namespace Kaim


#include "gwnavruntime/path/positiononpath.inl"