world.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/world/databasebinding.h"
#include "gwnavruntime/world/visualdebugregistry.h"
#include "gwnavruntime/world/worldstatistics.h"

#include "gwnavruntime/path/livepath.h"
#include "gwnavruntime/visualsystem/displaylist.h"
#include "gwnavruntime/visualdebug/visualdebugserver.h"

#include "gwnavruntime/pathfollower/basepathprogresscomputer.h"
#include "gwnavruntime/pathfollower/ipositiononpathvalidator.h"
#include "gwnavruntime/pathfollower/avoidanceworkspace.h"
#include "gwnavruntime/querysystem/queryqueuearray.h"
#include "gwnavruntime/world/asyncquerydispatcher.h"
#include "gwnavruntime/collision/collisionworld.h"
#include "gwnavruntime/world/basenavigationprofile.h"


namespace Kaim
{

class Database;
class DatabaseBinding;
class WorldElementSpatializer;
class PointOfInterest;
class CylinderObstacle;
class BoxObstacle;
class TagVolume;
class LivePath;
class FileOpenerBase;
class BotConfig;
class Trajectory;
class IAvoidanceComputer;
class QueryQueueArray;
class QueryQueue;
class AsyncQueryDispatcher;
class DatabaseUpdateManager;
class VisualDebugAttributesManager;
class BaseNavigationProfile;


class World : public RefCountBaseNTS<World, MemStat_WorldFwk>
{
    KY_CLASS_WITHOUT_COPY(World)

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

    explicit World(KyUInt32 databaseCount = 1);
    virtual ~World();

    void SetUserData(void* userData);
    void* GetUserData();

    // ---------------------------------- Update ----------------------------------

    void Update(KyFloat32 simulationTimeInSeconds = 0.016f);

    KyUInt32 GetUpdateCount() const;

#if defined(KY_CONFIG_DEBUG_OR_DEV)
    WorldStatistics* GetWorldStatistics();
#endif

    // ---------------------------------- VisualDebug ----------------------------------

    KyResult StartVisualDebug(const VisualDebugServerConfig& visualDebugServerConfig);
    void StopVisualDebug();

    void NewVisualDebugFrame(KyUInt32 gameFrameIndex = KyUInt32MAXVAL);
    VisualDebugServer* GetVisualDebugServer();

    VisualDebugRegistry* GetElementRegistry();

    DisplayListManager* GetDisplayListManager();

    VisualDebugAttributesManager* GetAttributesManager();


    // ---------------------------------- WorldElement Getters ----------------------------------

    KyUInt32 GetDatabasesCount() const;
    Database* GetDatabase(KyUInt32 index); 

    KyUInt32 GetPointsOfInterestCount() const;
    PointOfInterest* GetPointOfInterest(KyUInt32 index); 

    KyUInt32 GetCylinderObstaclesCount() const;
    CylinderObstacle* GetCylinderObstacle(KyUInt32 index); 

    KyUInt32 GetBoxObstaclesCount() const;
    BoxObstacle* GetBoxObstacle(KyUInt32 index); 

    KyUInt32 GetTagVolumesCount() const;
    KyUInt32 GetTagVolumesToBeIntegratedCount() const;
    KyUInt32 GetTagVolumesIntegratedCount() const;
    KyUInt32 GetTagVolumesToBeRemovedCount() const;
    TagVolume* GetTagVolumesToBeIntegrated(KyUInt32 index); 
    TagVolume* GetTagVolumesIntegrated(KyUInt32 index); 
    TagVolume* GetTagVolumesToBeRemoved(KyUInt32 index); 

    KyUInt32 GetQueryQueueArraysCount() const;
    QueryQueueArray* GetQueryQueueArray(KyUInt32 index); 

    KyUInt32 GetQueryPendingOperationCount() const;

    // ---------------------------------- NavigationProfile ----------------------------------

    KyUInt32 AddNavigationProfile(Ptr<BaseNavigationProfile> navigationProfile);
    Ptr<BaseNavigationProfile> GetNavigationProfile(KyUInt32 profileId);

    // ---------------------------------- Async Queries ----------------------------------

    void SetAsyncQueryDispatcher(IAsyncQueryDispatcher* asyncQueryDispatcher);

    IAsyncQueryDispatcher* GetAsyncQueryDispatcher();

    void PushAsyncQuery(IQuery* query, AsyncQueryDispatchId asyncQueryDispatchId = AsyncQueryDispatchId_Default, Bot* bot = nullptr);

    void CancelAsyncQuery(IQuery* query);

    void ProcessQueuesOutsideWorldUpdate();

    void SetWorldUpdateThreadId(ThreadId threadId);
    ThreadId GetWorldUpdateThreadId() const;

    // ---------------------------------- RemoveAll... ----------------------------------

    void RemoveAndCancellAll();

    void RemoveAllBots();
    void RemoveAllPointsOfInterest();
    void RemoveAllCylinderObstacles();
    void RemoveAllBoxObstacles();
    void RemoveAllTagVolumes();
    // RemoveAllQueryQueueArrays function is not relevant.

    void ClearDatabase(KyUInt32 databaseIndex);


    // -------- Specific optimization to the ShortcutTrajectory --------

    KyUInt32 GetNumberOfFramesForShortcutTrajectoryPeriodicUpdate() const;

    void SetNumberOfFramesForShortcutTrajectoryPeriodicUpdate(KyUInt32 numberOfFrames);

    // -------- Specific optimization  --------

    void ForceClearWorkingMemory();

private:
    // World::Update() steps
    void FlushCommandsInWorldUpdate();
    void ProcessQueuesInWorldUpdate();
    void FlushQueries();
    void UpdateDatabases();
    void UpdateSpatializations();
    void UpdateBotsPathFollowing(KyFloat32 simulationTimeInSeconds);
    void SendVisualDebugData(KyFloat32 simulationTimeInSeconds);
    void UpdateStatistics(KyFloat32 worldUpdateMs);
    void FlushCommandsOutOfWorldUpdate();

    // World::RemoveAndCancellAll() steps
    void CancelAllQueriesAndClearCommandsInAllQueryQueueArray();
    void ClearAllDatabases();

public: // internal
    void* m_userData;

    // Navigation profiles
    KyArray<Ptr<BaseNavigationProfile> > m_navigationProfiles;

    // Update counters
    KyUInt32 m_updateCount; // counter incremented at the very beginning of World::Update(). So it's 1 during the first World::Update().
    KyUInt32 m_nbFramesForShortcutTrajectoryPeriodicUpdate; // Update period used specifically with ShortcutTrajectory.

    // databases
    KyUInt32 m_databaseCount;
    KyArray<Ptr<Database>, MemStat_WorldFwk> m_databases;
    Ptr<DatabaseBinding> m_allDatabaseBinding;

    // CollisionWorld
    Ptr<CollisionWorld> m_collisionWorld;

    // WorldElements
    TrackedCollection<Ptr<PointOfInterest >, MemStat_PointOfInterest>  m_pointsOfInterests;
    TrackedCollection<Ptr<CylinderObstacle>, MemStat_CylinderObstacle> m_cylinderObstacles;
    TrackedCollection<Ptr<BoxObstacle     >, MemStat_BoxObstacle>      m_boxObstacles;

    TrackedCollection<Ptr<QueryQueueArray> , MemStat_QuerySystem> m_queryQueueArrays;

    TrackedCollection<Ptr<TagVolume>, MemStat_TagVolume> m_tagVolumesToBeIntegrated;
    TrackedCollection<Ptr<TagVolume>, MemStat_TagVolume> m_tagVolumesIntegrated;
    TrackedCollection<Ptr<TagVolume>, MemStat_TagVolume> m_tagVolumesToBeRemoved;

    // Spatialization
    WorldElementSpatializer* m_worldElementSpatializer;

    // Default Profile and BotConfig
    Ptr<BaseNavigationProfile> m_defaultNavigationProfile;
    Ptr<BotConfig> m_defaultPathFollowerConfig;

    // Visual Debug
    VisualDebugServerConfig m_visualDebugServerConfig;
    VisualDebugServer* m_visualDebugServer;
    bool m_wasConnected; // to detect a connection
    DisplayListManager* m_displayListManager;
    VisualDebugRegistry* m_visualDebugRegistry;
    VisualDebugAttributesManager* m_visualDebugAttributesManager;

    // WorldStatistics
    WorldStatistics* m_statistics;

    DatabaseUpdateManager* m_databaseUpdateManager;

    // Shared Avoidances workspace
    AvoidanceWorkspace m_avoidanceWorkspace;

    // Multi Threading
    Ptr<IAsyncQueryDispatcher> m_asyncQueryDispatcher;
    bool m_isInWorldUpdate;
    ThreadId m_worldUpdateThreadId;
};

KY_INLINE void World::SetUserData(void* userData) { m_userData = userData; }
KY_INLINE void* World::GetUserData() { return m_userData; }

KY_INLINE KyUInt32 World::GetUpdateCount() const { return m_updateCount; }

#if defined(KY_CONFIG_DEBUG_OR_DEV)
KY_INLINE WorldStatistics* World::GetWorldStatistics() { return m_statistics; }
#endif

KY_INLINE KyUInt32 World::GetDatabasesCount() const                    { return m_databases.GetCount(); }
KY_INLINE Database* World::GetDatabase(KyUInt32 index)                 { return m_databases[index]; }

KY_INLINE KyUInt32 World::GetPointsOfInterestCount() const             { return m_pointsOfInterests.GetCount(); }
KY_INLINE PointOfInterest* World::GetPointOfInterest(KyUInt32 index)   { return m_pointsOfInterests[index]; }

KY_INLINE KyUInt32 World::GetCylinderObstaclesCount() const            { return m_cylinderObstacles.GetCount(); }
KY_INLINE CylinderObstacle* World::GetCylinderObstacle(KyUInt32 index) { return m_cylinderObstacles[index]; }

KY_INLINE KyUInt32 World::GetBoxObstaclesCount() const                 { return m_boxObstacles.GetCount(); }
KY_INLINE BoxObstacle* World::GetBoxObstacle(KyUInt32 index)           { return m_boxObstacles[index]; }

KY_INLINE KyUInt32 World::GetTagVolumesCount() const
{
    return m_tagVolumesToBeIntegrated.GetCount() + m_tagVolumesIntegrated.GetCount() + m_tagVolumesToBeRemoved.GetCount();
}
KY_INLINE KyUInt32 World::GetTagVolumesToBeIntegratedCount() const      { return m_tagVolumesToBeIntegrated.GetCount(); }
KY_INLINE KyUInt32 World::GetTagVolumesIntegratedCount() const          { return m_tagVolumesIntegrated.GetCount(); }
KY_INLINE KyUInt32 World::GetTagVolumesToBeRemovedCount() const         { return m_tagVolumesToBeRemoved.GetCount(); }
KY_INLINE TagVolume* World::GetTagVolumesToBeIntegrated(KyUInt32 index) { return m_tagVolumesToBeIntegrated[index]; }
KY_INLINE TagVolume* World::GetTagVolumesIntegrated(KyUInt32 index)     { return m_tagVolumesIntegrated[index]; }
KY_INLINE TagVolume* World::GetTagVolumesToBeRemoved(KyUInt32 index)    { return m_tagVolumesToBeRemoved[index]; }

KY_INLINE KyUInt32 World::GetQueryQueueArraysCount() const           { return m_queryQueueArrays.GetCount(); }
KY_INLINE QueryQueueArray* World::GetQueryQueueArray(KyUInt32 index) { return m_queryQueueArrays[index]; }

KY_INLINE IAsyncQueryDispatcher* World::GetAsyncQueryDispatcher() { return m_asyncQueryDispatcher; }

KY_INLINE void World::SetWorldUpdateThreadId(ThreadId threadId) { m_worldUpdateThreadId = threadId; }
KY_INLINE ThreadId World::GetWorldUpdateThreadId() const { return m_worldUpdateThreadId; }

KY_INLINE KyUInt32 World::GetNumberOfFramesForShortcutTrajectoryPeriodicUpdate() const { return m_nbFramesForShortcutTrajectoryPeriodicUpdate; }
KY_INLINE void World::SetNumberOfFramesForShortcutTrajectoryPeriodicUpdate(KyUInt32 numberOfFrames) { m_nbFramesForShortcutTrajectoryPeriodicUpdate = (numberOfFrames == 0 ? 1 : numberOfFrames); }

KY_INLINE void World::NewVisualDebugFrame(KyUInt32 gameFrameIndex) { if (m_visualDebugServer) m_visualDebugServer->NewFrame(gameFrameIndex); }
KY_INLINE VisualDebugServer* World::GetVisualDebugServer() { return m_visualDebugServer; }
KY_INLINE VisualDebugRegistry* World::GetElementRegistry() { return m_visualDebugRegistry; }
KY_INLINE DisplayListManager* World::GetDisplayListManager() { return m_displayListManager; }
KY_INLINE VisualDebugAttributesManager* World::GetAttributesManager() { return m_visualDebugAttributesManager; }

#ifdef KY_CONFIG_RELEASE
KY_INLINE KyResult World::StartVisualDebug(const VisualDebugServerConfig&) { return KY_ERROR; }
KY_INLINE void World::StopVisualDebug() {}
#endif

} // namespace Kaim