octa.h

Go to the documentation of this file.

 
#ifndef OCTA_H_
#define OCTA_H_
 
const int Face_MaxVerts = 15;
 
struct cubeext; 
 
constexpr uint faceempty = 0;             
constexpr uint facesolid = 0x80808080;    

class cube
{
    public:
        std::array<cube, 8> *children; 
        cubeext *ext;            
        union
        {
            uchar edges[12];     
            uint faces[3];       
        };
        ushort texture[6];       
        ushort material;         
        uchar merged;            
        union
        {
            uchar escaped;       
            uchar visible;       
        };
        bool valid;              
        bool isempty() const
        {
            return faces[0]==faceempty;
        }

        bool issolid() const
        {
            return faces[0]==facesolid &&
                   faces[1]==facesolid &&
                   faces[2]==facesolid; //check all three
        }

        void setmat(ushort mat, ushort matmask, ushort filtermat, ushort filtermask, int filtergeom);

        void discardchildren(bool fixtex = false, int depth = 0);

        void calcmerges();

        bool isvalidcube() const;
 
    private:
 
        struct facebounds
        {
            ushort u1, u2, v1, v2;
 
            bool empty() const
            {
                return u1 >= u2 || v1 >= v2;
            }
        };
        struct pvert
        {
            ushort x, y;
 
            pvert() {}
            pvert(ushort x, ushort y) : x(x), y(y) {}
 
            bool operator==(const pvert &o) const
            {
                return x == o.x && y == o.y;
            }
            bool operator!=(const pvert &o) const
            {
                return x != o.x || y != o.y;
            }
        };
 
        struct pedge
        {
            pvert from, to;
 
            pedge() {}
            pedge(const pvert &from, const pvert &to) : from(from), to(to) {}
 
            bool operator==(const pedge &o) const
            {
                return from == o.from && to == o.to;
            }
            bool operator!=(const pedge &o) const
            {
                return from != o.from || to != o.to;
            }
        };
 
        class plink : public pedge
        {
            public:
                int polys[2];
 
                plink()
                {
                    clear();
                }
 
                plink(const pedge &p) : pedge(p)
                {
                    clear();
                }
            private:
                void clear()
                {
                    polys[0] = polys[1] = -1;
                }
        };
 
        struct poly
        {
            cube *c;
            int numverts;
            bool merged;
            pvert verts[Face_MaxVerts];
 
            bool clippoly(const facebounds &b);
            bool mergepolys(std::unordered_set<plink> &links, std::deque<const plink *> &queue, int owner, poly &q, const pedge &e);
        };
 
        bool mincubeface(const cube &cu, int orient, const ivec &co, int size, facebounds &orig) const;
        void mincubeface(const cube &cu, int orient, const ivec &o, int size, const facebounds &orig, facebounds &cf, ushort nmat, ushort matmask) const;
 
        void freecubeext(cube &c);
        void genmerges(cube * root, const ivec &o = ivec(0, 0, 0), int size = 9);
        bool genpoly(int orient, const ivec &o, int size, int vis, ivec &n, int &offset, poly &p);
        void clearmerge(int orient);
        void addmerge(int orient, const ivec &n, int offset, poly &p);
        void addmerges(int orient, const ivec &n, int offset, std::deque<poly> &polys);
        void mergepolys(int orient, const ivec &n, int offset, std::deque<poly> &polys);
 
        struct cfpolys
        {
            std::deque<poly> polys;
        };
 
        struct cfkey
        {
            uchar orient;
            ushort material, tex;
            ivec n;
            int offset;
        };
 
        //for unordered_map
        friend std::hash<plink>;
        friend std::hash<cfkey>;
        friend bool operator==(const cfkey &x, const cfkey &y);
};

struct selinfo
{
    int corner;
    int cx, cxs, cy, cys;
    ivec o, 
         s; 
    int grid, 
        orient; 
    selinfo() : corner(0), cx(0), cxs(0), cy(0), cys(0), o(0, 0, 0), s(0, 0, 0), grid(8), orient(0) {}

    int size() const
    {
        return s.x*s.y*s.z;
    }

    int us(int d) const
    {
        return s[d]*grid;
    }

    bool operator==(const selinfo &sel) const
    {
        return o==sel.o && s==sel.s && grid==sel.grid && orient==sel.orient;
    }

    bool validate();
};

struct block3
{
    ivec o, s;
    int grid, orient;
    block3() {}
    block3(const selinfo &sel) : o(sel.o), s(sel.s), grid(sel.grid), orient(sel.orient) {}
 
    const cube *getcube() const
    {
        return reinterpret_cast<const cube *>(this+1);
    }
 
    cube *c()
    {
        return reinterpret_cast<cube *>(this+1);
    }
 
    int size() const
    {
        return s.x*s.y*s.z;
    }
};
 
struct editinfo
{
    block3 *copy;
    editinfo() : copy(nullptr) {}
};
 
struct undoent
{
    size_t i; 
    entity e;
};
 
struct undoblock 
{
    undoblock *prev, *next;
    int size,       
        timestamp,  
        numents;    
 
    block3 *block()
    {
        return reinterpret_cast<block3 *>(this + 1);
    }
 
    uchar *gridmap()
    {
        block3 *ub = block();
        return reinterpret_cast<uchar *>(ub->c() + ub->size());
    }
 
    undoent *ents()
    {
        return reinterpret_cast<undoent *>(this + 1);
    }
};
 
extern int selchildcount, selchildmat;

inline void setcubefaces(cube &c, uint face)
{
    c.faces[0] = c.faces[1] = c.faces[2] = face;
}
 
inline int octadim(int d)
{
    return 1<<d;
}
 
//note that these macros actually loop in the opposite order: e.g. loopxy runs a for loop of x inside y
#define LOOP_XY(b)        for(int y = 0; y < (b).s[C[DIMENSION((b).orient)]]; ++y) for(int x = 0; x < (b).s[R[DIMENSION((b).orient)]]; ++x)
#define LOOP_XYZ(b, r, f) { for(int z = 0; z < (b).s[D[DIMENSION((b).orient)]]; ++z) LOOP_XY((b)) { cube &c = blockcube(x,y,z,b,r); f; } }
#define LOOP_SEL_XYZ(f)    { if(local) makeundo(); LOOP_XYZ(sel, sel.grid, f); rootworld.changed(sel); }
#define SELECT_CUBE(x, y, z) blockcube(x, y, z, sel, sel.grid)
 
// guard against subdivision
#define PROTECT_SEL(f) { undoblock *_u = newundocube(sel); f; if(_u) { pasteundoblock(_u->block(), _u->gridmap()); freeundo(_u); } }
 
#define DIMENSION(orient)  ((orient)>>1)
#define DIM_COORD(orient)  ((orient)&1)
 
extern ivec lu;
extern int lusize;
struct prefab;
struct clipplanes;

class cubeworld
{
    public:
        std::array<cube, 8> *worldroot;

        int lookupmaterial(const vec &v);

        bool emptymap(int factor, bool force, bool usecfg = true);

        bool enlargemap();
        bool modifyoctaent(int flags, int id, extentity &e);

        void shrinkmap();

        bool load_world(const char *mname, const char *gameident, const char *gameinfo = nullptr, const char *cname = nullptr);

        bool save_world(const char *mname, const char *gameident);

        int compactvslots(bool cull = false);
        void genprefabmesh(prefab &p);

        void cleanupva();

        float raycube   (const vec &o, const vec &ray, float radius = 0, int mode = 3, int size = 0, const extentity *t = 0) const;

        cube &lookupcube(const ivec &to, int tsize = 0, ivec &ro = lu, int &rsize = lusize);
        bool bboccluded(const ivec &bo, const ivec &br) const;
        void findtjoints();
        void allchanged(bool load = false);
        const cube &neighborcube(int orient, const ivec &co, int size, ivec &ro, int &rsize);

        void calclight();
        float shadowray(const vec &o, const vec &ray, float radius, int mode, const extentity *t = nullptr);
        void changed(const ivec &bbmin, const ivec &bbmax, bool commit = true);
        void changed(const block3 &sel, bool commit = true);
        clipplanes &getclipbounds(const cube &c, const ivec &o, int size, int offset);
        void calcnormals(bool lerptjoints);

        void remip();
        uint getmapcrc() const;

        void clearmapcrc();
 
        void entitiesinoctanodes();
        void commitchanges(bool force = false);
        void updateparticles();

        int mapscale() const;

        int mapsize() const;
    private:
        uint mapcrc; 
        bool haschanged;
        string ogzname, bakname, cfgname, picname;
        int worldscale; 
 

        struct emptycube : cube
        {
            emptycube()
            {
                children = nullptr;
                ext = nullptr;
                visible = 0;
                merged = 0;
                material = 0;
                setcubefaces(*this, faceempty);
                for(int i = 0; i < 6; ++i)
                {
                    texture[i] = 0;
                }
            }
        } emptycube;
 
        struct mapheader
        {
            char magic[4];              // "TMAP"
            int version;                // any >8bit quantity is little endian
            int headersize;             // sizeof(header)
            int worldsize;
            int numents;
            int numpvs;                 // no longer used, kept for backwards compatibility
            int blendmap;               // also no longer used
            int numvars;
            int numvslots;
        };
 
        struct octaheader
        {
            char magic[4];              // "OCTA"
            int version;                // any >8bit quantity is little endian
            int headersize;             // sizeof(header)
            int worldsize;
            int numents;
            int numvars;
            int numvslots;
        };
        void octarender();
        void seedparticles();
        void makeparticles(const entity &e);

        void resetmap();
        void resetclipplanes();

        void savec(const std::array<cube, 8> &c, const ivec &o, int size, stream * const f);

        bool loadmapheader(stream *f, const char *ogzname, mapheader &hdr, octaheader &ohdr) const;

        void setmapfilenames(const char *fname, const char *cname = nullptr);
 
        bool upoctree(const vec& v, int& x, int& y, int& z, const ivec& lo, int& lshift) const;
        bool checkinsideworld(const vec &invray, float radius, float &outrad, const vec &o, vec &v, const vec &ray, float &dist) const;
 
};
 
extern cubeworld rootworld;
 
#endif /* OCTA_H_ */