spatializedpoint.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/navgraph/identifiers/navgraphedgerawptr.h"
#include "gwnavruntime/kernel/SF_RefCount.h"
#include "gwnavruntime/base/memory.h"

namespace Kaim
{

class DatabaseBinding;
class Database;
class PositionSpatializationRange;
class WorldIntegerPos;
class NavTrianglePtr;

class Bot;
class CylinderObstacle;
class BoxObstacle;
class PointOfInterest;


enum SpatializedPointObjectType
{
    SpatializedPointObjectType_Undefined = 0,
    SpatializedPointObjectType_Bot,
    SpatializedPointObjectType_CylinderObstacle,
    SpatializedPointObjectType_BoxObstacle,
    SpatializedPointObjectType_PointOfInterest,

    SpatializedPointObjectType_Count
};

enum SpatializationUpdateCoherency
{
    SpatializationUpdateCoherency_Maximum,  // The update is conservative, the current floor is flavored
    SpatializationUpdateCoherency_Minimum,  // The update won't favor current floor, so it will ease vertical transition
};

// { NavTriangle, navMeshChangeIdx }
class PointDbSpatialization
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Spatialization)
public:
    PointDbSpatialization() : m_navMeshChangeIdx(KyUInt32MAXVAL) {}

    // calls UpdateFromScratch() if the RayCanGo fails
    void UpdateFromPrevious(
        Database* database, const PositionSpatializationRange& range,
        const Vec3f& prevPosition, const PointDbSpatialization& prevDbSpatialization, const Vec3f& newPosition);

    void UpdateFromScratch(
        Database* database, const PositionSpatializationRange& range,
        const Vec3f& newPosition, const WorldIntegerPos* newPositionInteger = nullptr);

public:
    static PositionSpatializationRange ComputeRange(
        const Database* database, SpatializationUpdateCoherency updateMode, KyFloat32 height = 0.f);

public:
    NavTriangleRawPtr m_navTriangle;
    KyUInt32 m_navMeshChangeIdx;
};


// Maintain { NavTriangle, navMeshChangeIdx } for each database (in the database binding).
// The 3D position is not part of PointSpatialization, it's part of SpatializedPoint.
// PointSpatialization is used in SpatializedPoint and in Bot. Merging both classes into one could make things simpler.
class PointSpatialization
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Spatialization)
    KY_CLASS_WITHOUT_COPY(PointSpatialization)

public:
    PointSpatialization() : m_pointDbSpatialization(nullptr) {}

    void Init(DatabaseBinding* databaseBinding);
    void Clear(); // reset the state as if freshly constructed.

    void InvalidateAllDbSpatializations();    // called from Bot, not from SpatializedPoint
    bool OneBoundDatabaseNavMeshHasChanged(); // called from Bot, not from SpatializedPoint

    NavTrianglePtr GetNavTrianglePtr(Database* database) const;

public: // internal
    // does not update navFloors, called in Bot::GetAndUpdatePositionSpatialiaation
    void UpdateSpatializationButNotFloors(const Vec3f& prevPosition, const PointSpatialization& prevPointSpatialization, const Vec3f& newPosition, SpatializationUpdateCoherency updateMode, KyFloat32 height);

private:
    void CreateDbSpatializationPoints();
    void DestroyDbSpatializationPoints();
    bool BoundDatabaseNavMeshHasChanged(KyUInt32 boundDatabaseIndex);

public: // internal
    Ptr<DatabaseBinding> m_databaseBinding;
    PointDbSpatialization* m_pointDbSpatialization; // array indexed like m_databaseBinding
    // Note: most of the time, there is only 1 database, and we alloc 8 bytes.
    // we should have a small array optimization with a union { PointDbSpatialization, PointDbSpatialization* }
};

class SpatializedPointInitConfig
{
public:
    // ---------------------------------- Main API Functions ----------------------------------

    SpatializedPointInitConfig() { SetDefaults(); }

    void SetDefaults();

    // ---------------------------------- Initialization ----------------------------------

    // All these 4 function do quite the same thing and have bad taste dependency (even if forward declared) to Bot, CylinderObstacle, BoxObstacle, PointOfInterest
    // TODo: kill them
    void InitFromBot(             Ptr<DatabaseBinding> databaseBinding, Bot* bot                          , KyFloat32 height);
    void InitFromCylinderObstacle(Ptr<DatabaseBinding> databaseBinding, CylinderObstacle* cylinderObstacle, KyFloat32 height);
    void InitFromBoxObstacle(     Ptr<DatabaseBinding> databaseBinding, BoxObstacle* boxObstacle          , KyUInt32 indexInObject, KyFloat32 height);
    void InitFromPointOfInterest( Ptr<DatabaseBinding> databaseBinding, PointOfInterest* pointOfInterest  , KyFloat32 height);

    // ---------------------------------- Public Data Members ----------------------------------

    Ptr<DatabaseBinding> m_databaseBinding;
    void* m_object;                           // Bot, CylinderObstacle, BoxObstacle or PointOfInterest
    SpatializedPointObjectType m_objectType;  // Bot, CylinderObstacle, BoxObstacle or PointOfInterest
    KyUInt32 m_indexInObject; // Relevant in the case of BoxObstacle, always zero otherwise
    KyFloat32 m_height;
};


class SpatializedPoint : public RefCountBase<SpatializedPoint, MemStat_Spatialization>
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Spatialization)
    KY_CLASS_WITHOUT_COPY(SpatializedPoint)

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

    SpatializedPoint();
    ~SpatializedPoint() { Clear(); }

    void Init(const SpatializedPointInitConfig& initConfig);
    void Clear(); // reset SpatializedPoint as if it was freshly constructed

    void InvalidateAllDbSpatializations();

    // ---------------------------------- Getters ----------------------------------

    const DatabaseBinding* GetDatabaseBinding()        const { return m_pointSpatialization.m_databaseBinding;                          }
          KyUInt32         GetDbSpatializationCount()  const { return m_pointSpatialization.m_databaseBinding->GetBoundDatabaseCount(); }

    const PointDbSpatialization& GetDbSpatialization(KyUInt32 boundDatabaseIdx) const { return m_pointSpatialization.m_pointDbSpatialization[boundDatabaseIdx]; }

    const Vec3f&               GetPosition()      const { return m_position;      }
    KyFloat32                  GetHeight()        const { return m_height;        }
    void*                      GetObject()        const { return m_object;        }
    SpatializedPointObjectType GetObjectType()    const { return m_objectType;    }
    KyUInt32                   GetIndexInObject() const { return m_indexInObject; }

    NavTrianglePtr GetNavTrianglePtr(Database* database) const;

    bool GetHasChanged() const { return m_hasChanged; }

    const PointSpatialization& GetPointSpatialization() const { return m_pointSpatialization; }

public: // internal
    // Just sets the position. Does not update any spatialization information.
    void SetPosition(const Vec3f& position) { m_position = position; }

    // Just sets the height. Does not update any spatialization information.
    void SetHeight(KyFloat32 height) { m_height = height; }

    // Computes m_pointSpatialization from newPosition and update NavFloors->SpatializedPoints accordingly
    // Returns Spatialization has changed, i.e. at least one PointDbSpatialization is spatialized differently
    void UpdateSpatialization(const Vec3f& newPosition);

    // Copy m_pointSpatialization from newPointSpatialization and update NavFloors->SpatializedPoints accordingly
    // Returns Spatialization has changed, i.e. at least one PointDbSpatialization is spatialized differently
    void UpdateSpatialization(const Vec3f& newPosition, const PointSpatialization& newPointSpatialization);

    // When a navFloor is deactivated, this function will invalidate all
    // references to it in this SpatializedPoint.
    void OnNavFloorDeActivation(NavFloor* navFloor);

    void SetHasChanged(bool hasChanged) { m_hasChanged = hasChanged; }

    DatabaseBinding* GetDatabaseBinding() { return m_pointSpatialization.m_databaseBinding; }

    static const char* GetObjectTypeDescrition(SpatializedPointObjectType objectType);

private:
    PointDbSpatialization& GetDbSpatialization(KyUInt32 boundDatabaseIdx) { return m_pointSpatialization.m_pointDbSpatialization[boundDatabaseIdx]; }
    void Invalidate(KyUInt32 boundDatabaseIdx);

private:
    Vec3f m_position; // position last time the spatialization was updated, shared by all databases
    PointSpatialization m_pointSpatialization;
    void* m_object;                             // Bot, CylinderObstacle, BoxObstacle or PointOfInterest
    SpatializedPointObjectType m_objectType;    // Bot, CylinderObstacle, BoxObstacle or PointOfInterest
    KyUInt32 m_indexInObject;                   // Relevant in the case of BoxObstacle, always zero otherwise
    KyFloat32 m_height;
    bool m_hasChanged; // When a NavFloor Allow to force to send visual debug of spatialization when it goes outside navmesh
};


} // namespace Kaim