iquery.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: JAPA - secondary contact: NOBODY
#ifndef Navigation_IQuery_H
#define Navigation_IQuery_H

#include "gwnavruntime/blob/baseblobhandler.h"
#include "gwnavruntime/basesystem/logger.h"
#include "gwnavruntime/base/memory.h"
#include "gwnavruntime/kernel/SF_RefCount.h"
#include "gwnavruntime/kernel/SF_Debug.h"


namespace Kaim
{

class World;
class Database;
class WorkingMemory;
class QueryQueue;

enum QueryType
{
    TypeRayCanGo = 0,
    TypeRayCast,
    TypeDiskCanGo,
    TypeDiskCast,
    TypeDiskCollision,
    TypeAStar,
    TypeTriangleFromPos,
    TypeMoveOnNavMesh,
    TypeSpatializedPointCollectorInAABB,
    TypeTriangleFromPosAndTriangleSeed,
    TypeNearestBorderHalfEdgeFromPos,
    TypeSegmentCast,
    TypeSegmentCanGo,
    TypeDiskExpansion,
    TypeInsidePosFromOutsidePos,
    TypeMultipleFloorTrianglesFromPos,
    TypeRayCanGoOnSegment,
    TypeRayCastOnSegment,
    TypeDynamicNavMesh,
    TypeFindFirstVisiblePositionOnPath,
    TypeBestGraphVertexPathFinderQuery,
    TypeMakeNavFloorStitchQuery,
    TypeCollisionRayCast,
    TypeRayCastFull3D,
    TypePathFromPolyline,
    TypeTagVolumesFromPos,
    TypeMultiDestinationPathFinderQuery,
    TypeCircleArcSplineComputation,

    QueryType_FirstCustom
};

// Gives the context in which an IAtomicQuery's PerformQuery function is called 
// in order to monitor when such queries are performed,
// used by ScopedPerformedQueryCounter
enum PerformQueryStat
{
    QueryStat_Generation,
    QueryStat_Spatialization,
    QueryStat_NavGraph,
    QueryStat_PathFinder,
    QueryStat_ProgressOnPath,
    QueryStat_PathValidityInterval,
    QueryStat_TargetOnPathIsStillVisible,
    QueryStat_TargetOnPathShortcutForward,
    QueryStat_TargetOnPathSearchBackward,
    QueryStat_Avoidance,
    QueryStat_Channel,
    QueryStat_Spline,

    QueryStat_GameKit,
    QueryStat_LabEngine,

    QueryStat_Other, 

    PerformQueryStat_Count,
    PerformQueryStat_Unspecified = PerformQueryStat_Count,
};

enum QueryProcessStatus
{
    QueryNotStarted = 0,
    QueryInProcess,
    QueryDone,
    QueryCanceled,
    QueryResultMax,
};

enum QueryStatusInQueue
{
    QueryNotInQueue,
    QueryPushedAsCommand,
    QueryInQueryQueue,
};

enum QueryProcessMode
{
    QueryProcessMode_Sync,
    QueryProcessMode_ASync
};

class IOnDone : public RefCountBase<IOnDone, MemStat_Query>
{
public:
    // ---------------------------------- Public Member Functions ----------------------------------
    virtual ~IOnDone() {}
    virtual void OnDone() = 0;
};

class IQuery : public RefCountBase<IQuery, MemStat_Query>
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Query)
public:
    IQuery();
    virtual ~IQuery();

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

    bool CanBeInitialized() const;

    bool IsInAQueryQueue() const;

    bool IsSafeToReadResult() const;

    void PerformQueryBlocking(WorkingMemory* workingMemory = KY_NULL);

    void OnDone();


    // Function that can be used to send a query to the NavigationLab.
    // Currently the implementation transform the query using a ScopedDisplayList,
    // and the display list is shown only at the frame SendVisualDebug is called,
    KyResult SendVisualDebug();

    void SetTraverseLogicUserData(void* traverseLogicUserData);
    void* GetTraverseLogicUserData() const;

    // ---------------------------------- Pure virtual functions - Query framework contract ----------------------------------

    virtual QueryType GetType() const = 0;

    virtual void Advance(WorkingMemory* workingMemory) = 0;

public: // internal
    // ---------------------------------- Internal Virtual functions for NavigationLab Remote Query processing ----------------------------------

    virtual Ptr<BaseBlobHandler> CreateQueryBlobHandler() { return KY_NULL; }
    virtual void BuildQueryBlob(Kaim::BaseBlobHandler* /*blobHandler*/) {}
    virtual void InitFromQueryBlob(World* /*world*/, void* /*blob*/) {}

public: // internal
    static const char* GetQueryTypeName(QueryType queryType);

    // ---------------------------------- Mandatory initialization calls to be done by derived classes ----------------------------------
    
    void BindToDatabase(Database* database);

    void Initialize();

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

    QueryProcessStatus m_processStatus; 
    Ptr<IOnDone> m_onDone;              

public: // Internal
    Database* m_database;               
    void* m_traverseLogicUserData;      

    QueryQueue* m_queue;                
    QueryStatusInQueue m_inQueueStatus; 
    KyUInt32 m_queryInfoId;
};


class IAtomicQuery : public IQuery
{
public:
    IAtomicQuery();
    virtual ~IAtomicQuery() {}

    void SetPerformQueryStat(PerformQueryStat contextOfPerformQueryCall);
    PerformQueryStat GetPerformQueryStat();

public:
    PerformQueryStat m_performQueryStat; // used by ScopedPerformedQueryCounter to know in which context PerformQuery was called
};


class ITimeSlicedQuery : public IQuery
{
public:
    ITimeSlicedQuery();
    virtual ~ITimeSlicedQuery();

    // ---------------------------------- Public Member Functions ----------------------------------

    void Initialize();


    // ---------------------------------- Pure virtual functions  ----------------------------------

    virtual void ReleaseWorkingMemoryOnCancelDuringProcess(WorkingMemory* workingMemory) = 0;

public:
    KyUInt32 m_advanceCount;
    KyUInt32 m_lastAdvanceFrameIdx;
};

enum CommonQueryResult
{
    QUERY_NOT_INITIALIZED = 0, 
    QUERY_NOT_PROCESSED = 1    
};


//------------------------------------- IQuery -----------------------------------------------

KY_INLINE IQuery::IQuery() :
    m_processStatus(QueryNotStarted),
    m_database(KY_NULL),
    m_traverseLogicUserData(KY_NULL),
    m_queue(KY_NULL),
    m_inQueueStatus(QueryNotInQueue),
    m_queryInfoId(0)
{}

KY_INLINE IQuery::~IQuery() {}

KY_INLINE void IQuery::BindToDatabase(Database* database)
{
    KY_LOG_ERROR_IF(database == KY_NULL, ("The database you are bounding the query to is not valid."));
    KY_LOG_ERROR_IF(CanBeInitialized() == false, ("You cannot bind a query to a Database while it is registered in a QueryQueue."));
    m_database = database;
    m_traverseLogicUserData = KY_NULL;
}

KY_INLINE void IQuery::Initialize()
{
    KY_LOG_ERROR_IF(m_database == KY_NULL, ("This query must have been bound to a valid Database before calling Initialize"));
    KY_LOG_ERROR_IF(CanBeInitialized() == false, ("You cannot initialized a query while it is registered in a QueryQueue."));
    m_processStatus = QueryNotStarted;
}

KY_INLINE bool IQuery::CanBeInitialized() const { return m_inQueueStatus != QueryInQueryQueue; }
KY_INLINE bool IQuery::IsInAQueryQueue()  const { return m_inQueueStatus != QueryNotInQueue;   }
KY_INLINE bool IQuery::IsSafeToReadResult() const { return (IsInAQueryQueue() == false) && (m_processStatus == QueryDone); }

KY_INLINE void* IQuery::GetTraverseLogicUserData() const { return m_traverseLogicUserData; }
KY_INLINE void  IQuery::SetTraverseLogicUserData(void* traverseLogicUserData) { m_traverseLogicUserData = traverseLogicUserData; }

KY_INLINE void IQuery::OnDone()
{
    if (m_onDone != KY_NULL)
        m_onDone->OnDone();

    m_onDone = KY_NULL;
}

//------------------------------------- IAtomicQuery -----------------------------------------------

KY_INLINE IAtomicQuery::IAtomicQuery() : m_performQueryStat(PerformQueryStat_Unspecified) {}
KY_INLINE void IAtomicQuery::SetPerformQueryStat(PerformQueryStat performQueryStat) { m_performQueryStat = performQueryStat; }
KY_INLINE PerformQueryStat IAtomicQuery::GetPerformQueryStat() { return m_performQueryStat; }

//------------------------------------- ITimeSlicedQuery -----------------------------------------------

KY_INLINE ITimeSlicedQuery::ITimeSlicedQuery() : m_advanceCount(0), m_lastAdvanceFrameIdx(0) {}
KY_INLINE ITimeSlicedQuery::~ITimeSlicedQuery() {}
KY_INLINE void ITimeSlicedQuery::Initialize()
{
    IQuery::Initialize();
    m_advanceCount = 0;
    m_lastAdvanceFrameIdx = 0;
}


}

#endif