iquery.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/base/memory.h"
#include "gwnavruntime/basesystem/logger.h"
#include "gwnavruntime/blob/baseblobhandler.h"
#include "gwnavruntime/kernel/SF_Debug.h"
#include "gwnavruntime/kernel/SF_RefCount.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:
    // ------------------------------ Functions -----------------------------
    virtual ~IOnDone() {}
    virtual void OnDone() = 0;
};

class IQuery : public RefCountBase<IQuery, MemStat_Query>
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Query)
public:
    // ------------------------------ IQuery Functions -----------------------------
    IQuery() : m_processStatus(QueryNotStarted), m_database(nullptr), m_traverseLogicUserData(nullptr), m_queue(nullptr), m_inQueueStatus(QueryNotInQueue), m_queryInfoId(0) {}

    virtual ~IQuery() {}

    bool CanBeInitialized() const { return m_inQueueStatus != QueryInQueryQueue; }

    bool IsInAQueryQueue() const { return m_inQueueStatus != QueryNotInQueue; }

    bool IsSafeToReadResult() const { return IsInAQueryQueue() == false && m_processStatus == QueryDone; }

    KyUInt32 PerformQueryBlocking(WorkingMemory* workingMemory = nullptr);

    void OnDone()
    {
        if (m_onDone != nullptr)
            m_onDone->OnDone();
        m_onDone = nullptr;
    }

    KyResult SendVisualDebug();

    void SetTraverseLogicUserData(void* traverseLogicUserData) { m_traverseLogicUserData = traverseLogicUserData; }

    void* GetTraverseLogicUserData() const { return m_traverseLogicUserData; }

    // ------------------------------ 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 ----------------------------------

    // These functions are used by IQuery::SendVisualDebug()
    // and also used by the NavigationLab to request remote execution:
    //   using VisualDebugClient::Send(IQuery*) to ask for a query to be executed
    //   using VisualDebugServer::Send(IQuery*) to send back the query result.
    // Queries that can be visual debug override these 3 functions.
    // By convenience, such queries provide a static function with the following signature: /code
    //    static Ptr<BaseBlobHandler>  CreateStaticQueryBlobHandler();  /endcode
    virtual Ptr<BaseBlobHandler> CreateQueryBlobHandler() { return nullptr; }
    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)
    {
        KY_LOG_ERROR_IF(database == nullptr, ("The database you are bounding the query to is null."));
        KY_LOG_ERROR_IF(CanBeInitialized() == false, ("You cannot bind a query to a database while it is in a QueryQueue."));
        m_database = database;
        m_traverseLogicUserData = nullptr;
    }

    void Initialize()
    {
        KY_LOG_ERROR_IF(m_database == nullptr, ("This query must have been bound to a valid database before calling Initialize"));
        KY_LOG_ERROR_IF(CanBeInitialized() == false, ("You cannot initialize a query while it is in a QueryQueue."));
        m_processStatus = QueryNotStarted;
    }

public:

    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 -----------------------------------------------
    IAtomicQuery() : m_performQueryStat(PerformQueryStat_Unspecified) {}

    virtual ~IAtomicQuery() {}

    void SetPerformQueryStat(PerformQueryStat performQueryStat) { m_performQueryStat = performQueryStat; }

    PerformQueryStat GetPerformQueryStat() { return m_performQueryStat; }

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

class ITimeSlicedQuery : public IQuery
{
public:
    // ------------------------------ Functions -----------------------------
    ITimeSlicedQuery() : m_advanceCount(0), m_lastAdvanceFrameIdx(0) {}

    virtual ~ITimeSlicedQuery() {}

    void Initialize()
    {
        IQuery::Initialize();
        m_advanceCount = 0;
        m_lastAdvanceFrameIdx = 0;
    }

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

}