typedefs.h

Go to the documentation of this file.

#pragma once

#include "defines.h"
#include "mathlib.h"
#include "shared.h"
#include "../common/filesys.h"

typedef struct cBspPlane_s {
    vec3_t normal;
    float dist;
    byte type;                      
} cBspPlane_t;

typedef struct cBspModel_s {
    AABB cbmBox;                    
    vec3_t origin, angles, shift;   
    int32_t headnode;
    int tile;                       
    int firstface, numfaces;        
} cBspModel_t;

typedef struct cBspSurface_s {
    char name[MAX_QPATH];           
    uint32_t surfaceFlags;          
} cBspSurface_t;

typedef struct cBspNode_s {
    cBspPlane_t* plane;
    vec3_t mins, maxs;
    int32_t children[2];            
} cBspNode_t;

typedef struct cBspBrushSide_s {
    cBspPlane_t* plane;
    cBspSurface_t* surface;
} cBspBrushSide_t;

typedef struct cBspLeaf_s {
    uint32_t contentFlags;
    unsigned short firstleafbrush;
    unsigned short numleafbrushes;
} cBspLeaf_t;

typedef struct cBspBrush_s {
    uint32_t brushContentFlags;     
    int numsides;                   
    int firstbrushside;             
    int checkcount;                 
} cBspBrush_t;

typedef struct tnode_s {
    int type;
    vec3_t normal;
    float dist;
    int32_t children[2];
    int pad;
} tnode_t;

typedef struct chead_s {
    int cnode;
    int level;
} cBspHead_t;

class MapTile {
public:
    char name[MAX_QPATH];
    int idx;

    int numbrushsides;
    cBspBrushSide_t* brushsides;

    int numtexinfo;
    cBspSurface_t* surfaces;

    int numplanes;
    cBspPlane_t* planes; /* numplanes + 12 for box hull */

    int numnodes;
    cBspNode_t* nodes; /* numnodes + 6 for box hull */

    int numleafs;
    cBspLeaf_t* leafs;
    int emptyleaf;

    int numleafbrushes;
    unsigned short* leafbrushes;

    int nummodels;
    cBspModel_t* models;

    int numbrushes;
    cBspBrush_t* brushes;

    /* tracing box */
    cBspPlane_t* box_planes;
    int box_headnode;
    cBspBrush_t* box_brush;
    cBspLeaf_t* box_leaf;

    /* line tracing */
    tnode_t* tnodes;
    int numtheads;
    intptr_t thead[LEVEL_MAX];
    int theadlevel[LEVEL_MAX];

    int numcheads;
    cBspHead_t cheads[MAX_MAP_NODES];

    ipos3_t wpMins;
    ipos3_t wpMaxs;

    byte lightquant;
    byte* lightdata;

    inline void getTileBox(AABB& box) {
        const vec3_t halfBox = {UNIT_SIZE / 2, UNIT_SIZE / 2, UNIT_HEIGHT / 2};
        PosToVec(wpMins, box.mins);
        VectorSubtract(box.mins, halfBox, box.mins);
        PosToVec(wpMaxs, box.maxs);
        VectorAdd(box.maxs, halfBox, box.maxs);
    }
};

typedef struct routing_s {
    byte _stepup[PATHFINDING_HEIGHT][PATHFINDING_WIDTH][PATHFINDING_WIDTH][CORE_DIRECTIONS];
    byte _route[PATHFINDING_HEIGHT][PATHFINDING_WIDTH][PATHFINDING_WIDTH][CORE_DIRECTIONS];
    signed char _floor[PATHFINDING_HEIGHT][PATHFINDING_WIDTH][PATHFINDING_WIDTH];
    byte _ceil[PATHFINDING_HEIGHT][PATHFINDING_WIDTH][PATHFINDING_WIDTH];

    inline void setStepup (const int x, const int y, const int z, const int dir, const int val) {
        _stepup[z][y][x][dir] = val;
    }
    inline byte getStepup (const int x, const int y, const int z, const int dir) const {
        return _stepup[z][y][x][dir];
    }

    inline void setConn (const int x, const int y, const int z, const int dir, const int val) {
        _route[z][y][x][dir] = val;
    }
    inline byte getConn (const int x, const int y, const int z, const int dir) const {
        return _route[z][y][x][dir];
    }

    inline void setCeiling (const int x, const int y, const int z, const int val) {
        _ceil[z][y][x] = val;
    }
    inline byte getCeiling (const int x, const int y, const int z) const {
        return _ceil[z][y][x];
    }
    inline byte getCeiling (const pos3_t pos) const {
        return getCeiling(pos[0], pos[1], pos[2]);
    }

    inline void setFloor (const int x, const int y, const int z, const int val) {
        _floor[z][y][x] = val;
    }
    inline signed char getFloor (const int x, const int y, const int z) const {
        return _floor[z][y][x];
    }
    inline signed char getFloor (const pos3_t pos) const {
        return getFloor(pos[0], pos[1], pos[2]);
    }
} routing_t;

/* A special bit mask indicating that the stepup causes the actor to rise a cell. */
#define PATHFINDING_BIG_STEPUP      0x80
/* A special bit mask indicating that the stepup causes the actor to walk down a cell. */
#define PATHFINDING_BIG_STEPDOWN    0x40

class Routing
{
    routing_t routes[ACTOR_MAX_SIZE];   
public:

    Routing () {
        init();
    }
    inline void init () {
        OBJZERO(routes);
    }
    inline void setFloor (const int actorSize, const int x, const int y, const int z, const int val) {
        routes[actorSize - 1].setFloor(x, y, z, val);
    }
    inline signed char getFloor (const actorSizeEnum_t actorSize, const pos3_t pos) const {
        return routes[actorSize - 1].getFloor(pos);
    }
    inline signed char getFloor (const actorSizeEnum_t actorSize, const int x, const int y, const int z) const {
        return routes[actorSize - 1].getFloor(x, y, z);
    }

    inline void setCeiling (const actorSizeEnum_t actorSize, const int x, const int y, const int z, const int val) {
        routes[actorSize - 1].setCeiling(x, y, z, val);
    }
    inline byte getCeiling (const int actorSize, const pos3_t pos) const {
        return routes[actorSize - 1].getCeiling(pos);
    }
    inline byte getCeiling (const int actorSize, const int x, const int y, const int z) const {
        return routes[actorSize - 1].getCeiling(x, y, z);
    }

    inline void setFilled (const actorSizeEnum_t actorSize, const int x, const int y, const int lowZ, const int highZ)
    {
        int i;
        for (i = lowZ; i <= highZ; i++) {
            routes[actorSize - 1].setFloor(x, y, i, CELL_HEIGHT);   /* There is no floor in this cell. */
            routes[actorSize - 1].setCeiling(x, y, i, 0);           /* There is no ceiling, the true indicator of a filled cell. */
        }
    }

    inline void setConn (const int actorSize, const int x, const int y, const int z, const int dir, const int val) {
        routes[actorSize - 1].setConn(x, y, z, dir, val);
    }
    inline byte getConn (const int actorSize, const int x, const int y, const int z, const int dir) const {
        return routes[actorSize - 1].getConn(x, y, z, dir);
    }
    inline byte getConn (const actorSizeEnum_t actorSize, const pos3_t pos, const int dir) const {
        return routes[actorSize - 1].getConn(pos[0], pos[1], pos[2], dir);
    }

    inline void setStepup (const int actorSize, const int x, const int y, const int z, const int dir, const int val) {
        routes[actorSize - 1].setStepup(x, y, z, dir, val);
    }
    inline byte getStepup (const int actorSize, const int x, const int y, const int z, const int dir) const {
        return routes[actorSize - 1].getStepup(x, y, z, dir);
    }
    inline byte getStepupHeight (const int actorSize, const int x, const int y, const int z, const int dir) const {
        return routes[actorSize - 1].getStepup(x, y, z, dir) & ~(PATHFINDING_BIG_STEPDOWN | PATHFINDING_BIG_STEPUP);
    }
    inline byte isStepDownLevel (const actorSizeEnum_t actorSize, const pos3_t pos, const int dir) const {
        return routes[actorSize - 1].getStepup(pos[0], pos[1], pos[2], dir) & PATHFINDING_BIG_STEPDOWN;
    }
    inline byte isStepUpLevel (const actorSizeEnum_t actorSize, const pos3_t pos, const int dir) const {
        return routes[actorSize - 1].getStepup(pos[0], pos[1], pos[2], dir) & PATHFINDING_BIG_STEPUP;
    }

    inline void copyPosData (const Routing& other, actorSizeEnum_t actorSize, const int x, const int y, const int z, const int sX, const int sY, const int sZ)
    {
        setFloor(actorSize, x, y, z, other.getFloor(actorSize, x - sX, y - sY, z - sZ));
        setCeiling(actorSize, x, y, z, other.getCeiling(actorSize, x - sX, y - sY, z - sZ));
        int dir;
        for (dir = 0; dir < CORE_DIRECTIONS; dir++) {
            setConn(actorSize, x, y, z, dir, other.getConn(actorSize, x - sX, y - sY, z - sZ, dir));
            setStepup(actorSize, x, y, z, dir, other.getStepup(actorSize, x - sX, y - sY, z - sZ, dir));
        }
    }
};

typedef struct mapData_s {
    char mapEntityString[MAX_MAP_ENTSTRING];

    int numInline;

    unsigned mapChecksum;

    byte reroute[ACTOR_MAX_SIZE][PATHFINDING_WIDTH][PATHFINDING_WIDTH];
    Routing routing;

    AABB mapBox;
} mapData_t;

typedef struct {
    AABB dbmBox;
    vec3_t origin;              
    int32_t headnode;
    int firstface, numfaces;    
} dBspModel_t;

typedef struct {
    float point[3];
} dBspVertex_t;

typedef struct {
    vec3_t normal;
} dBspNormal_t;

typedef struct {
    vec3_t normal;              
    float dist;                 
    int type;                   
} dBspPlane_t;

typedef struct {
    int32_t planenum;           
    int32_t children[2];        
    short mins[3];              
    short maxs[3];              
    unsigned short firstface;   
    unsigned short numfaces;    
} dBspNode_t;

typedef struct texinfo_s {
    float vecs[2][4];           
    uint32_t surfaceFlags;      
    uint32_t value;             
    char texture[32];           
} dBspTexinfo_t;

typedef struct {
    unsigned short v[2];        
} dBspEdge_t;

typedef struct {
    uint16_t planenum;          
    short side;

    int firstedge;              
    short numedges;
    short texinfo;              
    int lightofs[LIGHTMAP_MAX]; 
} dBspSurface_t;

typedef struct {
    uint32_t contentFlags;      
    short area;

    short mins[3];              
    short maxs[3];              
    uint16_t firstleafbrush;
    uint16_t numleafbrushes;
} dBspLeaf_t;

typedef struct {
    uint16_t planenum;          
    short texinfo;
} dBspBrushSide_t;

typedef struct {
    int firstbrushside;
    int numsides;
    uint32_t brushContentFlags; 
} dBspBrush_t;

typedef struct {
    /* tracing box */
    dBspPlane_t* box_planes;
    int box_headnode;
    dBspBrush_t* box_brush;
    dBspLeaf_t* box_leaf;

    /* line tracing */
    tnode_t* tnodes;
    int numtheads;
    int thead[LEVEL_MAX];
    int theadlevel[LEVEL_MAX];

    /* Used by TR_TileBoxTrace */
    int numcheads;
    cBspHead_t cheads[MAX_MAP_NODES];

    /* ---- */
    int             entdatasize;
    char            entdata[MAX_MAP_ENTSTRING];

    int             routedatasize;
    byte            routedata[MAX_MAP_ROUTING];

    int             lightdatasize[LIGHTMAP_MAX];
    byte            lightdata[LIGHTMAP_MAX][MAX_MAP_LIGHTING];

    int             nummodels;
    dBspModel_t     models[MAX_MAP_MODELS];

    int             numleafs;
    dBspLeaf_t      leafs[MAX_MAP_LEAFS];
    int             emptyleaf;

    int             numplanes;
    dBspPlane_t     planes[MAX_MAP_PLANES];

    int             numnormals;
    dBspNormal_t    normals[MAX_MAP_VERTS];

    int             numvertexes;
    dBspVertex_t    vertexes[MAX_MAP_VERTS];

    int             numnodes;
    dBspNode_t      nodes[MAX_MAP_NODES];

    int             numtexinfo;
    dBspTexinfo_t   texinfo[MAX_MAP_TEXINFO];

    int             numfaces;
    dBspSurface_t       faces[MAX_MAP_FACES];

    int             numedges;
    dBspEdge_t      edges[MAX_MAP_EDGES];

    int             numleafbrushes;
    unsigned short  leafbrushes[MAX_MAP_LEAFBRUSHES];

    int             numsurfedges;
    int             surfedges[MAX_MAP_SURFEDGES];

    int             numbrushes;
    dBspBrush_t     dbrushes[MAX_MAP_BRUSHES];
    cBspBrush_t     brushes[MAX_MAP_BRUSHES];

    int             numbrushsides;
    dBspBrushSide_t brushsides[MAX_MAP_BRUSHSIDES];
} dMapTile_t;