DetourTileCache.h

Go to the documentation of this file.

#ifndef DETOURTILECACHE_H
#define DETOURTILECACHE_H

#include "SharedConfig.h"
#include "DetourStatus.h"

typedef unsigned int dtObstacleRef;

typedef unsigned int dtCompressedTileRef;

enum dtCompressedTileFlags
{
    DT_COMPRESSEDTILE_FREE_DATA = 0x01,                 
};

struct dtCompressedTile
{
    unsigned int salt;                      
    struct dtTileCacheLayerHeader* header;
    unsigned char* compressed;
    int compressedSize;
    unsigned char* data;
    int dataSize;
    unsigned int flags;
    dtCompressedTile* next;
};

enum ObstacleState
{
    DT_OBSTACLE_EMPTY,
    DT_OBSTACLE_PROCESSING,
    DT_OBSTACLE_PROCESSED,
    DT_OBSTACLE_REMOVING,
};

static const int DT_MAX_TOUCHED_TILES = 8;
struct dtTileCacheObstacle
{
    float pos[3], radius, height;
    dtCompressedTileRef touched[DT_MAX_TOUCHED_TILES];
    dtCompressedTileRef pending[DT_MAX_TOUCHED_TILES];
    unsigned short salt;
    unsigned char state;
    unsigned char ntouched;
    unsigned char npending;
    dtTileCacheObstacle* next;
};

struct dtTileCacheParams
{
    float orig[3];
    float cs, ch;
    int width, height;
    float walkableHeight;
    float walkableRadius;
    float walkableClimb;
    float maxSimplificationError;
    int maxTiles;
    int maxObstacles;
};

struct dtTileCacheMeshProcess
{
    virtual ~dtTileCacheMeshProcess() { }

    virtual void process(struct dtNavMeshCreateParams* params,
        navAreaMask* polyAreas) = 0;
};


class dtTileCache
{
public:
    dtTileCache();
    ~dtTileCache();

    struct dtTileCacheAlloc* getAlloc() { return m_talloc; }
    struct dtTileCacheCompressor* getCompressor() { return m_tcomp; }
    const dtTileCacheParams* getParams() const { return &m_params; }

    inline int getTileCount() const { return m_params.maxTiles; }
    inline const dtCompressedTile* getTile(const int i) const { return &m_tiles[i]; }

    inline int getObstacleCount() const { return m_params.maxObstacles; }
    inline const dtTileCacheObstacle* getObstacle(const int i) const { return &m_obstacles[i]; }

    const dtTileCacheObstacle* getObstacleByRef(dtObstacleRef ref);

    dtObstacleRef getObstacleRef(const dtTileCacheObstacle* obmin) const;

    dtStatus init(const dtTileCacheParams* params,
    struct dtTileCacheAlloc* talloc,
    struct dtTileCacheCompressor* tcomp,
    struct dtTileCacheMeshProcess* tmproc);

    int getTilesAt(const int tx, const int ty, dtCompressedTileRef* tiles, const int maxTiles) const;

    dtCompressedTile* getTileAt(const int tx, const int ty, const int tlayer);
    dtCompressedTileRef getTileRef(const dtCompressedTile* tile) const;
    const dtCompressedTile* getTileByRef(dtCompressedTileRef ref) const;

    dtStatus addTile(unsigned char* data, const int dataSize, unsigned char flags, dtCompressedTileRef* result);

    dtStatus removeTile(dtCompressedTileRef ref, unsigned char** data, int* dataSize);

    dtStatus addObstacle(const float* pos, const float radius, const float height, dtObstacleRef* result);
    dtStatus removeObstacle(const dtObstacleRef ref);

    dtStatus queryTiles(const float* bmin, const float* bmax,
        dtCompressedTileRef* results, int* resultCount, const int maxResults) const;

    dtStatus update(const float /*dt*/, class dtNavMesh* navmesh);

    dtStatus buildNavMeshTilesAt(const int tx, const int ty, class dtNavMesh* navmesh);

    dtStatus buildNavMeshTile(const dtCompressedTileRef ref, class dtNavMesh* navmesh);

    void calcTightTileBounds(const struct dtTileCacheLayerHeader* header, float* bmin, float* bmax) const;

    void getObstacleBounds(const struct dtTileCacheObstacle* ob, float* bmin, float* bmax) const;


    inline dtCompressedTileRef encodeTileId(unsigned int salt, unsigned int it) const
    {
        return ((dtCompressedTileRef)salt << m_tileBits) | (dtCompressedTileRef)it;
    }

    inline unsigned int decodeTileIdSalt(dtCompressedTileRef ref) const
    {
        const dtCompressedTileRef saltMask = ((dtCompressedTileRef)1 << m_saltBits) - 1;
        return (unsigned int)((ref >> m_tileBits) & saltMask);
    }

    inline unsigned int decodeTileIdTile(dtCompressedTileRef ref) const
    {
        const dtCompressedTileRef tileMask = ((dtCompressedTileRef)1 << m_tileBits) - 1;
        return (unsigned int)(ref & tileMask);
    }

    inline dtObstacleRef encodeObstacleId(unsigned int salt, unsigned int it) const
    {
        return ((dtObstacleRef)salt << 16) | (dtObstacleRef)it;
    }

    inline unsigned int decodeObstacleIdSalt(dtObstacleRef ref) const
    {
        const dtObstacleRef saltMask = ((dtObstacleRef)1 << 16) - 1;
        return (unsigned int)((ref >> 16) & saltMask);
    }

    inline unsigned int decodeObstacleIdObstacle(dtObstacleRef ref) const
    {
        const dtObstacleRef tileMask = ((dtObstacleRef)1 << 16) - 1;
        return (unsigned int)(ref & tileMask);
    }


private:

    enum ObstacleRequestAction
    {
        REQUEST_ADD,
        REQUEST_REMOVE,
    };

    struct ObstacleRequest
    {
        int action;
        dtObstacleRef ref;
    };

    int m_tileLutSize;                      
    int m_tileLutMask;                      

    dtCompressedTile** m_posLookup;         
    dtCompressedTile* m_nextFreeTile;       
    dtCompressedTile* m_tiles;              

    unsigned int m_saltBits;                
    unsigned int m_tileBits;                

    dtTileCacheParams m_params;

    dtTileCacheAlloc* m_talloc;
    dtTileCacheCompressor* m_tcomp;
    dtTileCacheMeshProcess* m_tmproc;

    dtTileCacheObstacle* m_obstacles;
    dtTileCacheObstacle* m_nextFreeObstacle;

    static const int MAX_REQUESTS = 64;
    ObstacleRequest m_reqs[MAX_REQUESTS];
    int m_nreqs;

    static const int MAX_UPDATE = 64;
    dtCompressedTileRef m_update[MAX_UPDATE];
    int m_nupdate;

};

dtTileCache* dtAllocTileCache();
void dtFreeTileCache(dtTileCache* tc);

#endif