path.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/containers/kyarray.h"
#include "gwnavruntime/navmesh/identifiers/navtriangleptr.h"
#include "gwnavruntime/navgraph/identifiers/navgraphvertexptr.h"
#include "gwnavruntime/navgraph/identifiers/navgraphedgeptr.h"
#include "gwnavruntime/navmesh/worldintegerpos.h"

namespace Kaim
{
class DatabaseGenMetrics;
class ChannelArray;

enum PathEdgeType
{
    PathEdgeType_Undefined = 0        , 
    PathEdgeType_OnNavMesh            , 
    PathEdgeType_OnNavGraph           , 
    PathEdgeType_FromOutsideToNavMesh , 
    PathEdgeType_FromNavMeshToOutside , 
    PathEdgeType_FromOutsideToNavGraph, 
    PathEdgeType_FromNavGraphToOutside, 
    PathEdgeType_OutsideAlongGraphEdge, 
    PathEdgeType_AbstractEdge,          
    PathEdgeType_Count,
};

inline const char* ToString(PathEdgeType e)
{
    static const char* s_strs[] =
    {
        "PathEdgeType_Undefined",
        "PathEdgeType_OnNavMesh",
        "PathEdgeType_OnNavGraph",
        "PathEdgeType_FromOutsideToNavMesh",
        "PathEdgeType_FromNavMeshToOutside",
        "PathEdgeType_FromOutsideToNavGraph",
        "PathEdgeType_FromNavGraphToOutside",
        "PathEdgeType_OutsideAlongGraphEdge",
        "PathEdgeType_AbstractEdge"
    };
    const KyInt32 enumCount = PathEdgeType_Count;
    KY_COMPILER_ASSERT(enumCount == sizeof(s_strs) / sizeof(const char*));
    KyInt32 idx = (KyInt32)e;
    return idx >= 0 && idx < enumCount ? s_strs[idx] : "PathEdgeType_UNKNOWN";
}

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, PathEdgeType e) { os << ToString(e); return os; }

class Path
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Path)
    KY_CLASS_WITHOUT_COPY(Path)

    Path();

public:
    class CreateConfig
    {
    public:
        // ------------------------------ Public -----------------------------
        CreateConfig(KyUInt32 nodesCount = 0) : m_nodesCount(nodesCount) {}

        KyUInt32 m_nodesCount;
        // ------------------------------ end -----------------------------
    };


    // ------------------------------ Path Creation ------------------------------

    static Ptr<Path> CreatePath(const CreateConfig& createConfig);

    void     SetNavigationProfileId(KyUInt32 navigationProfileId) { m_navigationProfileId = navigationProfileId; }
    KyUInt32 GetNavigationProfileId() const { return m_navigationProfileId; }

    // ------------------------------ Get Counts ------------------------------

    KyUInt32 GetNodeCount() const { return m_nodesCount; }
    KyUInt32 GetEdgeCount() const { return m_edgesCount; }

    // ------------------------------ Get Cost and Distance ------------------------------

    KyFloat32 GetPathDistance() const { return m_pathDistance; }

    KyFloat32 GetPathCost() const { return m_pathCost; }

    // ------------------------------ Get Node Data ------------------------------

    const Vec3f& GetPathStartPosition() const { return GetNodePosition(0); }
    const Vec3f& GetPathEndPosition() const { return GetNodePosition(GetNodeCount() - 1); }

    const Vec3f* GetNodePositionBuffer() const { return m_nodePositions; }

    const Vec3f& GetNodePosition(KyUInt32 nodeIdx) const { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodePositions[nodeIdx]; }
          Vec3f& GetNodePosition(KyUInt32 nodeIdx)       { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodePositions[nodeIdx]; }

    const WorldIntegerPos* GetNodeIntegerPositionBuffer() const { return m_nodeIntegerPositions; }

    const WorldIntegerPos& GetNodeIntegerPosition(KyUInt32 nodeIdx) const { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodeIntegerPositions[nodeIdx]; }
          WorldIntegerPos& GetNodeIntegerPosition(KyUInt32 nodeIdx)       { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodeIntegerPositions[nodeIdx]; }

    const NavTrianglePtr& GetNodeNavTrianglePtr(KyUInt32 nodeIdx) const { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodeTrianglePtrs[nodeIdx]; }
          NavTrianglePtr& GetNodeNavTrianglePtr(KyUInt32 nodeIdx)       { KY_ASSERT(nodeIdx < m_nodesCount); return m_nodeTrianglePtrs[nodeIdx]; }

    const NavGraphVertexPtr& GetNodeNavGraphVertexPtr(KyUInt32 nodeIdx) const { KY_ASSERT(nodeIdx < m_nodesCount);     return m_nodeGraphVertexPtrs[nodeIdx];     }
          NavGraphVertexPtr& GetNodeNavGraphVertexPtr(KyUInt32 nodeIdx)       { KY_ASSERT(nodeIdx < m_nodesCount);     return m_nodeGraphVertexPtrs[nodeIdx];     }

    bool HasEpsilonEdges() const;

    // ------------------------------ Get Edge Data ------------------------------

    const Vec3f& GetPathEdgeStartPosition(KyUInt32 edgeIdx) const { return GetNodePosition(edgeIdx); }
    const Vec3f& GetPathEdgeEndPosition(KyUInt32 edgeIdx) const { return GetNodePosition(edgeIdx + 1); }

    const NavTrianglePtr& GetPathEdgeStartNavTrianglePtr(KyUInt32 edgeIdx) const { return GetNodeNavTrianglePtr(edgeIdx); }
    const NavTrianglePtr& GetPathEdgeEndNavTrianglePtr(KyUInt32 edgeIdx) const { return GetNodeNavTrianglePtr(edgeIdx + 1); }

    const NavGraphEdgePtr& GetEdgeNavGraphEdgePtr(KyUInt32 edgeIdx) const { KY_ASSERT(edgeIdx < m_edgesCount); return m_edgeNavGraphEdgePtr[edgeIdx]; }
          NavGraphEdgePtr& GetEdgeNavGraphEdgePtr(KyUInt32 edgeIdx)       { KY_ASSERT(edgeIdx < m_edgesCount); return m_edgeNavGraphEdgePtr[edgeIdx]; }

    PathEdgeType GetPathEdgeType(KyUInt32 edgeIdx) const { return (PathEdgeType)m_edgeTypes[edgeIdx]; }

    // ------------------------------ Set Node Data ------------------------------

    void SetNodePosition         (KyUInt32 nodeIdx, const Vec3f& position                     ) { KY_ASSERT(nodeIdx < m_nodesCount); m_nodePositions[nodeIdx]        = position;          }
    void SetNodeIntegerPosition  (KyUInt32 nodeIdx, const WorldIntegerPos& integerPos         ) { KY_ASSERT(nodeIdx < m_nodesCount); m_nodeIntegerPositions[nodeIdx] = integerPos;        }
    void SetNodeNavTrianglePtr   (KyUInt32 nodeIdx, const NavTrianglePtr& navTrianglePtr      ) { KY_ASSERT(nodeIdx < m_nodesCount); m_nodeTrianglePtrs[nodeIdx]     = navTrianglePtr;    }
    void SetNodeNavGraphVertexPtr(KyUInt32 nodeIdx, const NavGraphVertexPtr& navGraphVertexPtr) { KY_ASSERT(nodeIdx < m_nodesCount); m_nodeGraphVertexPtrs[nodeIdx]  = navGraphVertexPtr; }

    void SetNodePosition3fAndInteger(KyUInt32 nodeIdx, const Vec3f& position, const WorldIntegerPos& integerPos);

    // ------------------------------ Set Edge Data ------------------------------

    void SetEdgeNavGraphEdgePtr(KyUInt32 edgeIdx, const NavGraphEdgePtr& navGraphEdgePtr) { m_edgeNavGraphEdgePtr[edgeIdx] = navGraphEdgePtr; }
    void SetPathEdgeType(KyUInt32 edgeIdx, PathEdgeType edgeType) { KY_ASSERT(edgeType < PathEdgeType_Count); m_edgeTypes[edgeIdx] = (KyUInt8)edgeType; }

    void SetPathCostAndDistance(KyFloat32 pathCost, KyFloat32 pathDistance) { m_pathCost = pathCost; m_pathDistance = pathDistance; }

    const CellBox& GetPathCellBox() const { return m_pathCellBox;  }
    CellBox& GetPathCellBox()             { return m_pathCellBox;  }

    void SetPathCellBox(const CellBox& cellBox) { m_pathCellBox = cellBox; }

    void ComputeAllNodeIntegerPositionAndPathCellBox(const DatabaseGenMetrics& genMetrics);

    KyUInt32 GetByteSize() const { return m_byteSize; }

private:
    static KyUInt32 ComputeByteSize(const CreateConfig& createConfig);

    void InitBuffers();
    void ClearAllBeforeDestruction();

    template <class T> void ClearBufferCPP(T*& buffer, KyUInt32 count);
    template <class T> void ClearBufferPOD(T*& buffer, KyUInt32 count);
    template <class T> void InitBufferCPP(T*& buffer, KyUInt32 count, char*& memory);
    template <class T> void InitBufferPOD(T*& buffer, KyUInt32 count, char*& memory);

public:
    // ------------------------------ Public Data Members ------------------------------

    Database* m_database;

    Ptr<ChannelArray> m_channelArray;

private:
    KyUInt32 m_navigationProfileId;

    KyUInt32 m_byteSize;

    KyUInt32 m_nodesCount;
    KyUInt32 m_edgesCount;

    KyFloat32 m_pathDistance;
    KyFloat32 m_pathCost;

    CellBox m_pathCellBox;

    Vec3f*             m_nodePositions;
    WorldIntegerPos*   m_nodeIntegerPositions;
    NavTrianglePtr*    m_nodeTrianglePtrs;
    NavGraphVertexPtr* m_nodeGraphVertexPtrs;

    NavGraphEdgePtr* m_edgeNavGraphEdgePtr;
    KyUInt8*         m_edgeTypes;

    KyUInt32 RefCount; // consider thread-safetyness here with mutable std::atomic<int> RefCount;

public: // internal

    // Lifetime - separate implementation due to Create function
    void AddRef() { ++RefCount; }
    void Release();

    // Debug method only.
    int GetRefCount() const { return RefCount; }
};


}

#include "gwnavruntime/path/path.inl"