bestgraphvertexpathfinderquery.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/queries/utils/basebestgraphvertexpathfinderquery.h"
#include "gwnavruntime/queries/utils/pathclampercontext.h"
#include "gwnavruntime/queries/utils/astartraversal.h"
#include "gwnavruntime/channel/channelarraycomputer.h"


namespace Kaim
{

class PathFinderQueryUtils;

enum OnGraphVertexVisitedResult
{
    OnGraphVertexVisited_IgnoreVertex_GoOn,
    OnGraphVertexVisited_IgnoreVertex_StopWithBestSoFar,
    OnGraphVertexVisited_StopOnThisVertex,
    OnGraphVertexVisited_VertexIsTheBestSoFar_GoOn,
    OnGraphVertexVisited_NeedToCheckRefinePathToThisVertex
};

enum OnPathToGraphVertexComputedResult
{
    OnPathToGraphVertexComputed_IgnoreVertex_GoOn,
    OnPathToGraphVertexComputed_IgnoreVertex_StopWithBestSoFar,
    OnPathToGraphVertexComputed_StopOnThisVertex,
    OnPathToGraphVertexComputed_VertexIsTheBestSoFar_GoOn,
};


template<class VertexFinderLogic>
class BestGraphVertexPathFinderQuery : public BaseBestGraphVertexPathFinderQuery
{
public:
    // ------------------------------ Functions -----------------------------

    BestGraphVertexPathFinderQuery()
        : BaseBestGraphVertexPathFinderQuery() , m_traversal(TraversalCustomizer())
    {
        m_traversal.m_traversalParams = &m_traversalParams;
    }

    virtual ~BestGraphVertexPathFinderQuery() {}

    // ---------------------------------- Query framework functions ----------------------------------

    virtual void Advance(WorkingMemory* workingMemory);

    virtual void ReleaseWorkingMemoryOnCancelDuringProcess(WorkingMemory* workingMemory = nullptr);

public: // internal
    bool TraversalHasVisitedNavDataChanged();

protected:
    void SetFinish(WorkingMemory* workingMemory);
    KyResult ComputeStartGraphEdgeOrGraphVertexOrTriangle(PathFinderQueryUtils& queryUtils);
    KyResult ComputeStartTriangle(PathFinderQueryUtils& queryUtils);

    KyResult CheckNavDataChangeDuringTraversal(WorkingMemory* workingMemory);
    KyResult CheckNavDataChangeAfterTraversal(WorkingMemory* workingMemory);
    KyResult InitTraversalFromStartNode(PathFinderQueryUtils& queryUtils);
    KyResult InitializeContextAndStartNode(PathFinderQueryUtils& queryUtils);

protected:
    class TraversalCustomizer
    {
    public:
        typedef VertexFinderLogic TLogic;

        TraversalCustomizer() : m_maxRadius(0.0f), m_traverseLogicUserData(nullptr) {}

        bool CanTraverse(const NavTriangleRawPtr& triangleRawPtr, KyFloat32* costMultiplier)       {return triangleRawPtr.CanBeTraversed<TLogic>(m_traverseLogicUserData, costMultiplier); }
        bool CanTraverse(const NavGraphEdgeRawPtr& edgeRawPtr, KyFloat32* costMultiplier)          { return edgeRawPtr.CanBeTraversed<TLogic>(m_traverseLogicUserData, costMultiplier); }
        bool CanEnterNavTag(const NavTag& exitNavTag, const NavTag& enterNavTag, const Vec3f& pos) { return TLogic::CanEnterNavTag(m_traverseLogicUserData, exitNavTag, enterNavTag, pos); }
        KyFloat32 GetHeuristicFromNodePosition(const Vec3f& ) { return 0.0f; }

        void* GetTraverseLogicUserData() const { return m_traverseLogicUserData; }

        bool ShouldVisitNode(AStarTraversalContext*, AStarNodeIndex) { return true; }

        bool IsNodeOutsidePropagationBounds(AStarTraversalContext* astarContext, AStarNodeIndex nodeIndex)
        {
            if (m_maxRadius == 0.0f)
                return false;
            const AStarNode& astarNode = astarContext->m_aStarNodes[nodeIndex];
            return SquareDistance(astarNode.m_nodePosition, m_startPos) > m_maxRadius * m_maxRadius;
        }

        bool ShouldOpenHalfEdgeNode(const NavHalfEdgeRawPtr& , NavHalfEdgeRawPtr& )       { return true; }
        bool ShouldOpenGraphVertexNode(const NavGraphVertexRawPtr& )                      { return true; }
        bool ShouldOpenAbstractGraphNode(const AbstractGraphNodeRawPtr& )                 { return false; }
        bool ShouldOpenNavTriangleUnderAbstractGraphNode(const AbstractGraphNodeRawPtr& ) { return false; }

        Vec3f ComputeNodePositionOnHalfEdge(AStarTraversalContext*, const Vec3f& startPosOfEdge, const Vec3f& endPosOfEdge, AStarNodeIndex)
        {
            return (endPosOfEdge + startPosOfEdge) * 0.5f;
        }

        KyResult OnNavTriangleExplored(AStarTraversalContext*, const NavTriangleRawPtr&, AStarNodeIndex)   { return KY_SUCCESS; }
        KyResult OnNavGraphEdgeExplored(AStarTraversalContext*, const NavGraphEdgeRawPtr&, AStarNodeIndex) { return KY_SUCCESS; }

        Vec3f m_startPos;
        KyFloat32 m_maxRadius;
        void* m_traverseLogicUserData;
    };

    AStarTraversal<TraversalCustomizer> m_traversal;
};

}

#include "gwnavruntime/queries/bestgraphvertexpathfinderquery.inl"