spatializedpoint.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: LAPA - secondary contact: JUBA
#ifndef Navigation_SpatializedPoint_H
#define Navigation_SpatializedPoint_H


#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 World;
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 favored
    SpatializationUpdateCoherency_Minimum,  // The update won't favor current floor, so it will ease vertical transition
};

// INTERNAL CLASS: Point spatialization in one Database. The point is either:
// - in a NavMesh triangle
// - outside any NavData.
class PointDbSpatialization
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Spatialization)
public:
    PointDbSpatialization();

    void Invalidate();

    KyResult UpdateFromPrevious(Database* database, const PositionSpatializationRange& spatializationRange, const Vec3f& oldPosition, const PointDbSpatialization& oldDbSpatialization,
        const Vec3f& newPosition, WorldIntegerPos& newPositionInteger);

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

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

public:
    KyUInt32 m_navDataChangeIdx;
    NavTriangleRawPtr m_navTriangle;
};

// INTERNAL CLASS: Point spatialization into all databases defined by a DatabaseBinding. 
// The position must be maintained by the user of this class.
// Note that validity of PointDbSpatialization is the responsibility of the user of this class since it uses NavTriangleRawPtr!
class PointSpatialization
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Spatialization)
    KY_CLASS_WITHOUT_COPY(PointSpatialization)

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

    void Init(DatabaseBinding* databaseBinding);
    void Clear();
    
    void Invalidate(KyUInt32 index);
    void InvalidateAllDbSpatializations();

    NavTrianglePtr GetNavTrianglePtr(Database* database) const;

public: // internal
    // Note that SpatializedPoint does not use this function since SpatializedPoint::UpdateSpatialization also needs to update NavFloors, it is only used by the Bot to lazily update the spatialization out of world update
    bool UpdateSpatialization(const Vec3f& currentPosition, const PointSpatialization* updatedCurrentSpatialization, const Vec3f& newPosition, SpatializationUpdateCoherency updateMode, KyFloat32 height);

private:
    void CreateDbSpatializationPoints();
    void DestroyDbSpatializationPoints();

public: // internal
    Ptr<DatabaseBinding> m_databaseBinding;
    PointDbSpatialization* m_pointDbSpatialization; // array indexed like m_databaseBinding
};

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

    SpatializedPointInitConfig() { SetDefaults(); }

    void SetDefaults();


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

    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;
    SpatializedPointObjectType m_objectType;
    KyUInt32 m_indexInObject;

    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();

    void Init(const SpatializedPointInitConfig& initConfig);
    void Clear();
    void Invalidate(KyUInt32 boundDatabaseIdx);
    void InvalidateAllDbSpatializations();


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

    const DatabaseBinding*           GetDatabaseBinding()                           const;
          KyUInt32                   GetDbSpatializationCount()                     const;
          PointDbSpatialization&     GetDbSpatialization(KyUInt32 boundDatabaseIdx)      ;
    const PointDbSpatialization&     GetDbSpatialization(KyUInt32 boundDatabaseIdx) const;
    const Vec3f&                     GetPosition()                                  const;
          KyFloat32                  GetHeight()                                    const;
          void*                      GetObject()                                    const;
          SpatializedPointObjectType GetObjectType()                                const;
          KyUInt32                   GetIndexInObject()                             const;

    NavTrianglePtr GetNavTrianglePtr(Database* database) const;


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

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

    // Computes new spatialization of PointDbSpatialization,
    // and updated NavFloors that contained and now contains the SpatializedPoint.
    // inputOutputIntermediateSpatialization must have been computed for newPos on the same DatabaseBinding, it will serve both as input spatialization but will also be refreshed if necessary.
    // Returns Spatialization has changed, i.e. at least one PointDbSpatialization is spatialized differently
    bool UpdateSpatialization(const Vec3f& newPosition, SpatializationUpdateCoherency updateMode = SpatializationUpdateCoherency_Maximum, PointSpatialization* inputOutputUpdatedSpatialization = KY_NULL);

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

    static const char* GetObjectTypeDescrition(SpatializedPointObjectType objectType);

    const PointSpatialization& GetPointSpatialization() const;

private:
    Vec3f m_position; // position last time the spatialization was updated, shared by all databases
    PointSpatialization m_pointSpatialization;
    void* m_object;
    SpatializedPointObjectType m_objectType;
    KyUInt32 m_indexInObject;
    KyFloat32 m_height;
    bool m_wasSpatializationInvalidatedOutOfUpdate;
};


KY_INLINE void SpatializedPointInitConfig::SetDefaults()
{
    m_databaseBinding = KY_NULL;
    m_object = KY_NULL;
    m_objectType = SpatializedPointObjectType_Undefined;
    m_indexInObject = 0;
}

KY_INLINE PointDbSpatialization::PointDbSpatialization() : m_navDataChangeIdx(KyUInt32MAXVAL) {}

KY_INLINE void PointDbSpatialization::Invalidate()
{
    m_navTriangle.Invalidate();
}

KY_INLINE void SpatializedPointInitConfig::InitFromBot(Ptr<DatabaseBinding> databaseBinding, Bot* bot, KyFloat32 height)
{
    m_databaseBinding = databaseBinding;
    m_object = bot;
    m_objectType = SpatializedPointObjectType_Bot;
    m_indexInObject = 0;
    m_height = height;
}

KY_INLINE void SpatializedPointInitConfig::InitFromCylinderObstacle(Ptr<DatabaseBinding> databaseBinding, CylinderObstacle* cylinderObstacle, KyFloat32 height)
{
    m_databaseBinding = databaseBinding;
    m_object = cylinderObstacle;
    m_objectType = SpatializedPointObjectType_CylinderObstacle;
    m_indexInObject = 0;
    m_height = height;
}

KY_INLINE void SpatializedPointInitConfig::InitFromBoxObstacle(Ptr<DatabaseBinding> databaseBinding, BoxObstacle* boxObstacle, KyUInt32 indexInObject, KyFloat32 height)
{
    m_databaseBinding = databaseBinding;
    m_object = boxObstacle;
    m_objectType = SpatializedPointObjectType_BoxObstacle;
    m_indexInObject = indexInObject;
    m_height = height;
}

KY_INLINE void SpatializedPointInitConfig::InitFromPointOfInterest(Ptr<DatabaseBinding> databaseBinding, PointOfInterest* pointOfInterest, KyFloat32 height)
{
    m_databaseBinding = databaseBinding;
    m_object = pointOfInterest;
    m_objectType = SpatializedPointObjectType_PointOfInterest;
    m_indexInObject = 0;
    m_height = height;
}

KY_INLINE SpatializedPoint::SpatializedPoint()
    : m_object(KY_NULL)
    , m_objectType(SpatializedPointObjectType_Undefined)
    , m_indexInObject(0)
    , m_wasSpatializationInvalidatedOutOfUpdate(true)
{}

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

KY_INLINE const DatabaseBinding*           SpatializedPoint::GetDatabaseBinding()                           const { return m_pointSpatialization.m_databaseBinding;                                   }
KY_INLINE       KyUInt32                   SpatializedPoint::GetDbSpatializationCount()                     const { return m_pointSpatialization.m_databaseBinding->GetBoundDatabaseCount(); }
KY_INLINE const Vec3f&                     SpatializedPoint::GetPosition()                                  const { return m_position; }
KY_INLINE       KyFloat32                  SpatializedPoint::GetHeight()                                    const { return m_height;                                            }
KY_INLINE       void*                      SpatializedPoint::GetObject()                                    const { return m_object;                                            }
KY_INLINE       SpatializedPointObjectType SpatializedPoint::GetObjectType()                                const { return m_objectType;                                        }
KY_INLINE       KyUInt32                   SpatializedPoint::GetIndexInObject()                             const { return m_indexInObject;                                     }
KY_INLINE       PointDbSpatialization&     SpatializedPoint::GetDbSpatialization(KyUInt32 boundDatabaseIdx)       { return m_pointSpatialization.m_pointDbSpatialization[boundDatabaseIdx]; }
KY_INLINE const PointDbSpatialization&     SpatializedPoint::GetDbSpatialization(KyUInt32 boundDatabaseIdx) const { return m_pointSpatialization.m_pointDbSpatialization[boundDatabaseIdx]; }

KY_INLINE void SpatializedPoint::SetPosition(const Vec3f& position) { m_position = position; }
KY_INLINE void SpatializedPoint::SetHeight(KyFloat32 height)        { m_height = height;     }

KY_INLINE const PointSpatialization& SpatializedPoint::GetPointSpatialization() const { return m_pointSpatialization; }


} // namespace Kaim

#endif // Navigation_SpatializedPoint_H