Subversion Repositories eduke32

// "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman

// Ken Silverman's official web site: "http://www.advsys.net/ken"

// See the included license file "BUILDLIC.TXT" for license info.

//

// This file has been modified from Ken Silverman's original release

// by Jonathon Fowler (jf@jonof.id.au)

#ifndef build_h_

#define build_h_

#include "compat.h"

#include "pragmas.h"

#include "glbuild.h"

#ifdef __cplusplus

extern "C" {

#endif

enum rendmode_t {

    REND_CLASSIC,

    REND_POLYMOST = 3,

    REND_POLYMER

};

#define PI 3.14159265358979323846

#define MAXSECTORSV8 4096

#define MAXWALLSV8 16384

#define MAXSPRITESV8 16384

#define MAXSECTORSV7 1024

#define MAXWALLSV7 8192

#define MAXSPRITESV7 4096

#ifndef GEKKO

# define MAXSECTORS MAXSECTORSV8

# define MAXWALLS MAXWALLSV8

# define MAXSPRITES MAXSPRITESV8

# define MAXXDIM 7680

# define MAXYDIM 3200

// additional space beyond wall, in walltypes:

# define M32_FIXME_WALLS 512

# define M32_FIXME_SECTORS 2

#else

# define MAXSECTORS MAXSECTORSV7

# define MAXWALLS MAXWALLSV7

# define MAXSPRITES MAXSPRITESV7

# define MAXXDIM 860

# define MAXYDIM 490

# define M32_FIXME_WALLS 0

# define M32_FIXME_SECTORS 0

#endif

#ifdef LUNATIC

# define NEW_MAP_FORMAT

// A marker for LuaJIT C function callbacks, but not merely:

# define LUNATIC_CB ATTRIBUTE((used))

// Used for variables and functions referenced from Lua:

# define LUNATIC_EXTERN ATTRIBUTE((used))

#else

# ifdef NEW_MAP_FORMAT

#  error "New map format can only be used with Lunatic"

# endif

# define LUNATIC_EXTERN static

#endif

#define MAXWALLSB ((MAXWALLS>>2)+(MAXWALLS>>3))

#define MAXTILES 30720

#define MAXUSERTILES (MAXTILES-16)  // reserve 16 tiles at the end

#define MAXVOXELS 4096

#define MAXSTATUS 1024

#define MAXPLAYERS 16

#define MAXBASEPALS 8

#define MAXPALOOKUPS 256

#define MAXBLENDTABS 256

// Maximum number of defined multi-pskies:

#define MAXPSKYMULTIS 8

// Maximum number of component tiles in a multi-psky:

#define MAXPSKYTILES 8

#define MAXSPRITESONSCREEN 4096

#define MAXUNIQHUDID 256 //Extra slots so HUD models can store animation state without messing game sprites

#define RESERVEDPALS 4 // don't forget to increment this when adding reserved pals

#define DETAILPAL   (MAXPALOOKUPS - 1)

#define GLOWPAL     (MAXPALOOKUPS - 2)

#define SPECULARPAL (MAXPALOOKUPS - 3)

#define NORMALPAL   (MAXPALOOKUPS - 4)

#define TSPR_TEMP 99

#define PR_LIGHT_PRIO_MAX       0

#define PR_LIGHT_PRIO_MAX_GAME  1

#define PR_LIGHT_PRIO_HIGH      2

#define PR_LIGHT_PRIO_HIGH_GAME 3

#define PR_LIGHT_PRIO_LOW       4

#define PR_LIGHT_PRIO_LOW_GAME  5

// Convenient sprite iterators, must not be used if any sprites inside the loop

// are potentially deleted or their sector changed...

#define SPRITES_OF(Statnum, Iter)  Iter=headspritestat[Statnum]; Iter>=0; Iter=nextspritestat[Iter]

#define SPRITES_OF_SECT(Sectnum, Iter)  Iter=headspritesect[Sectnum]; Iter>=0; Iter=nextspritesect[Iter]

// ... in which case this iterator may be used:

#define SPRITES_OF_SECT_SAFE(Sectnum, Iter, Next)  Iter=headspritesect[Sectnum]; \

    Iter>=0 && (Next=nextspritesect[Iter], 1); Iter=Next

#define SPRITES_OF_STAT_SAFE(Statnum, Iter, Next)  Iter=headspritestat[Statnum]; \

    Iter>=0 && (Next=nextspritestat[Iter], 1); Iter=Next

#define CLEARLINES2D(Startline, Numlines, Color) \

    clearbuf((char *)(frameplace + ((Startline)*bytesperline)), (bytesperline*(Numlines))>>2, (Color))

////////// True Room over Room (YAX == rot -17 of "PRO") //////////

#define YAX_ENABLE

//#define YAX_DEBUG

//#define ENGINE_SCREENSHOT_DEBUG

#ifdef YAX_ENABLE

# if !defined NEW_MAP_FORMAT

#  define YAX_ENABLE__COMPAT

# endif

#endif

////////// yax defs //////////

#define SECTORFLD(Sect,Fld, Cf) (*((Cf) ? (&sector[Sect].floor##Fld) : (&sector[Sect].ceiling##Fld)))

#define YAX_CEILING 0  // don't change!

#define YAX_FLOOR 1  // don't change!

# ifdef NEW_MAP_FORMAT

#  define YAX_MAXBUNCHES 512

#  define YAX_BIT__COMPAT 1024

#  define YAX_NEXTWALLBIT__COMPAT(Cf) (1<<(10+Cf))

#  define YAX_NEXTWALLBITS__COMPAT (YAX_NEXTWALLBIT__COMPAT(0)|YAX_NEXTWALLBIT__COMPAT(1))

# else

#  define YAX_MAXBUNCHES 256

#  define YAX_BIT 1024

   // "has next wall when constrained"-bit (1<<10: ceiling, 1<<11: floor)

#  define YAX_NEXTWALLBIT(Cf) (1<<(10+Cf))

#  define YAX_NEXTWALLBITS (YAX_NEXTWALLBIT(0)|YAX_NEXTWALLBIT(1))

# endif

int32_t get_alwaysshowgray(void);  // editor only

void yax_updategrays(int32_t posze);

#ifdef YAX_ENABLE

# ifdef NEW_MAP_FORMAT

   // New map format -- no hijacking of otherwise used members.

#  define YAX_PTRNEXTWALL(Ptr, Wall, Cf) (*(&Ptr[Wall].upwall + Cf))

#  define YAX_NEXTWALLDEFAULT(Cf) (-1)

# else

   // More user tag hijacking: lotag/extra. :/

#  define YAX_PTRNEXTWALL(Ptr, Wall, Cf) (*(int16_t *)(&Ptr[Wall].lotag + 2*Cf))

#  define YAX_NEXTWALLDEFAULT(Cf) (((Cf)==YAX_CEILING) ? 0 : -1)

   extern int16_t yax_bunchnum[MAXSECTORS][2];

   extern int16_t yax_nextwall[MAXWALLS][2];

# endif

# define YAX_NEXTWALL(Wall, Cf) YAX_PTRNEXTWALL(wall, Wall, Cf)

# define YAX_ITER_WALLS(Wal, Itervar, Cfvar) Cfvar=0, Itervar=(Wal); Itervar!=-1; \

    Itervar=yax_getnextwall(Itervar, Cfvar), \

        (void)(Itervar==-1 && Cfvar==0 && (Cfvar=1) && (Itervar=yax_getnextwall((Wal), Cfvar)))

# define SECTORS_OF_BUNCH(Bunchnum, Cf, Itervar) Itervar = headsectbunch[Cf][Bunchnum]; \

    Itervar != -1; Itervar = nextsectbunch[Cf][Itervar]

extern int32_t r_tror_nomaskpass;

# ifdef NEW_MAP_FORMAT

// Moved below declarations of sector, wall, sprite.

# else

int16_t yax_getbunch(int16_t i, int16_t cf);

FORCE_INLINE void yax_getbunches(int16_t i, int16_t *cb, int16_t *fb)

{

    *cb = yax_getbunch(i, YAX_CEILING);

    *fb = yax_getbunch(i, YAX_FLOOR);

}

int16_t yax_getnextwall(int16_t wal, int16_t cf);

void yax_setnextwall(int16_t wal, int16_t cf, int16_t thenextwall);

# endif

void yax_setbunch(int16_t i, int16_t cf, int16_t bunchnum);

void yax_setbunches(int16_t i, int16_t cb, int16_t fb);

int16_t yax_vnextsec(int16_t line, int16_t cf);

void yax_update(int32_t resetstat);

int32_t yax_getneighborsect(int32_t x, int32_t y, int32_t sectnum, int32_t cf);

FORCE_INLINE int32_t yax_waltosecmask(int32_t walclipmask)

{

    // blocking: walstat&1 --> secstat&512

    // hitscan: walstat&64 --> secstat&2048

    return ((walclipmask&1)<<9) | ((walclipmask&64)<<5);

}

void yax_preparedrawrooms(void);

void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),

                   int16_t sectnum, int32_t didmirror, int32_t smoothr);

# define YAX_SKIPSECTOR(i) if (graysectbitmap[(i)>>3]&(1<<((i)&7))) continue

# define YAX_SKIPWALL(i) if (graywallbitmap[(i)>>3]&(1<<((i)&7))) continue

#else

# define yax_preparedrawrooms()

# define yax_drawrooms(SpriteAnimFunc, sectnum, didmirror, smoothr)

# define YAX_SKIPSECTOR(i) (i)=(i)

# define YAX_SKIPWALL(i) (i)=(i)

#endif

#define CLIPMASK0 (((1L)<<16)+1L)

#define CLIPMASK1 (((256L)<<16)+64L)

// max x/y val (= max editorgridextent in Mapster32)

#define BXY_MAX 524288

// rotatesprite 'orientation' (actually much more) bits

enum {

    RS_TRANS1 = 1,

    RS_AUTO = 2,

    RS_YFLIP = 4,

    RS_NOCLIP = 8,

    RS_TOPLEFT = 16,

    RS_TRANS2 = 32,

    RS_NOMASK = 64,

    RS_PERM = 128,

    RS_ALIGN_L = 256,

    RS_ALIGN_R = 512,

    RS_ALIGN_MASK = 768,

    RS_STRETCH = 1024,

    ROTATESPRITE_FULL16 = 2048,

    // ROTATESPRITE_MAX-1 is the mask of all externally available orientation bits

    ROTATESPRITE_MAX = 4096,

    RS_CENTERORIGIN = (1<<30),

};

    //Make all variables in BUILD.H defined in the ENGINE,

    //and externed in GAME

#ifdef ENGINE

#  define EXTERN

#else

#  define EXTERN extern

#endif

#ifdef __cplusplus

FORCE_INLINE void sector_tracker_hook(uintptr_t address);

FORCE_INLINE void wall_tracker_hook(uintptr_t address);

FORCE_INLINE void sprite_tracker_hook(uintptr_t address);

}

#define TRACKER_NAME_ SectorTracker

#define TRACKER_GLOBAL_HOOK_ sector_tracker_hook

#include "tracker.hpp"

#undef TRACKER_NAME_

#undef TRACKER_GLOBAL_HOOK_

#define TRACKER_NAME_ WallTracker

#define TRACKER_GLOBAL_HOOK_ wall_tracker_hook

#include "tracker.hpp"

#undef TRACKER_NAME_

#undef TRACKER_GLOBAL_HOOK_

#define TRACKER_NAME_ SpriteTracker

#define TRACKER_GLOBAL_HOOK_ sprite_tracker_hook

#include "tracker.hpp"

#undef TRACKER_NAME_

#undef TRACKER_GLOBAL_HOOK_

#define Tracker(Container, Type) Container##Tracker<Type>

#define TrackerCast(x) x.cast()

extern "C" {

#else

#define Tracker(Container, Type) Type

#define TrackerCast(x) x

#endif // __cplusplus

// Links to various ABIs specifying (or documenting non-normatively) the

// alignment requirements of aggregates:

//

//  System V AMD64: http://www.x86-64.org/documentation/abi-0.99.pdf

//   (x86-64.org down as of 2013-02-02?)

//  "An array uses the same alignment as its elements, except that a local or global

//   array variable of length at least 16 bytes or a C99 variable-length array variable

//   always has alignment of at least 16 bytes."

//   (Not reproducible with GCC or LuaJIT on Ubuntu)

//

//  Win64: http://msdn.microsoft.com/en-us/library/9dbwhz68.aspx

//

//  x86: http://en.wikipedia.org/wiki/Data_structure_alignment#Typical_alignment_of_C_structs_on_x86

enum {

    SPR_XFLIP = 4,

    SPR_YFLIP = 8,

    SPR_WALL = 16,

    SPR_FLOOR = 32,

    SPR_ALIGN_MASK = 32+16,

};

#if !defined NEW_MAP_FORMAT

#include "buildtypes.h"

#define UNTRACKED_STRUCTS

#undef buildtypes_h__

#include "buildtypes.h"

#undef UNTRACKED_STRUCTS

#endif

#ifdef NEW_MAP_FORMAT

//////////////////// Lunatic new-generation map format ////////////////////

#include "buildtypes.h"

// 44 bytes

typedef struct

{

    Tracker(Sector, int16_t) wallptr, wallnum;

    Tracker(Sector, int16_t) ceilingpicnum, ceilingheinum, ceilingbunch;

    Tracker(Sector, uint16_t) ceilingstat;

    Tracker(Sector, int32_t) ceilingz;

    Tracker(Sector, int8_t) ceilingshade;

    Tracker(Sector, uint8_t) ceilingpal, /*CM_FLOORZ:*/ ceilingxpanning, ceilingypanning;

    Tracker(Sector, int16_t) floorpicnum, floorheinum, floorbunch;

    Tracker(Sector, uint16_t) floorstat;

    Tracker(Sector, int32_t) floorz;

    Tracker(Sector, int8_t) floorshade;

    Tracker(Sector, uint8_t) floorpal, floorxpanning, floorypanning;

    Tracker(Sector, uint8_t) /*CM_CEILINGZ:*/ visibility, fogpal;

    Tracker(Sector, uint16_t) lotag, hitag;

    Tracker(Sector, int16_t) extra;

} sectortypevx;

# define SECTORVX_SZ1 offsetof(sectortypevx, ceilingpicnum)

# define SECTORVX_SZ4 sizeof(sectortypevx)-offsetof(sectortypevx, visibility)

static inline void copy_v7_from_vx_sector(sectortypev7 *v7sec, const sectortypevx *vxsec)

{

    /* [wallptr..wallnum] */

    Bmemcpy(v7sec, vxsec, SECTORVX_SZ1);

    /* ceiling* */

    v7sec->ceilingpicnum = vxsec->ceilingpicnum;

    v7sec->ceilingheinum = vxsec->ceilingheinum;

    v7sec->ceilingstat = vxsec->ceilingstat;

    v7sec->ceilingz = vxsec->ceilingz;

    v7sec->ceilingshade = vxsec->ceilingshade;

    v7sec->ceilingpal = vxsec->ceilingpal;

    v7sec->ceilingxpanning = vxsec->ceilingxpanning;

    v7sec->ceilingypanning = vxsec->ceilingypanning;

    /* floor* */

    v7sec->floorpicnum = vxsec->floorpicnum;

    v7sec->floorheinum = vxsec->floorheinum;

    v7sec->floorstat = vxsec->floorstat;

    v7sec->floorz = vxsec->floorz;

    v7sec->floorshade = vxsec->floorshade;

    v7sec->floorpal = vxsec->floorpal;

    v7sec->floorxpanning = vxsec->floorxpanning;

    v7sec->floorypanning = vxsec->floorypanning;

    /* [visibility..extra] */

    Bmemcpy(&v7sec->visibility, &vxsec->visibility, SECTORVX_SZ4);

    /* Clear YAX_BIT of ceiling and floor. (New-map format build saves TROR

     * maps as map-text.) */

    v7sec->ceilingstat &= ~YAX_BIT__COMPAT;

    v7sec->floorstat &= ~YAX_BIT__COMPAT;

}

static inline void inplace_vx_from_v7_sector(sectortypevx *vxsec)

{

    const sectortypev7 *v7sec = (sectortypev7 *)vxsec;

    sectortypev7 bakv7sec;

    // Can't do this in-place since the members were rearranged.

    Bmemcpy(&bakv7sec, v7sec, sizeof(sectortypev7));

    /* [wallptr..wallnum] is already at the right place */

    /* ceiling* */

    vxsec->ceilingpicnum = bakv7sec.ceilingpicnum;

    vxsec->ceilingheinum = bakv7sec.ceilingheinum;

    vxsec->ceilingstat = bakv7sec.ceilingstat;

    vxsec->ceilingz = bakv7sec.ceilingz;

    vxsec->ceilingshade = bakv7sec.ceilingshade;

    vxsec->ceilingpal = bakv7sec.ceilingpal;

    vxsec->ceilingxpanning = bakv7sec.ceilingxpanning;

    vxsec->ceilingypanning = bakv7sec.ceilingypanning;

    /* floor* */

    vxsec->floorpicnum = bakv7sec.floorpicnum;

    vxsec->floorheinum = bakv7sec.floorheinum;

    vxsec->floorstat = bakv7sec.floorstat;

    vxsec->floorz = bakv7sec.floorz;

    vxsec->floorshade = bakv7sec.floorshade;

    vxsec->floorpal = bakv7sec.floorpal;

    vxsec->floorxpanning = bakv7sec.floorxpanning;

    vxsec->floorypanning = bakv7sec.floorypanning;

    /* [visibility..extra] */

    Bmemmove(&vxsec->visibility, &bakv7sec.visibility, SECTORVX_SZ4);

}

static inline void inplace_vx_tweak_sector(sectortypevx *vxsec, int32_t yaxp)

{

    if (yaxp)

    {

        int32_t cisext = (vxsec->ceilingstat&YAX_BIT__COMPAT);

        int32_t fisext = (vxsec->floorstat&YAX_BIT__COMPAT);

        vxsec->ceilingbunch = cisext ? vxsec->ceilingxpanning : -1;

        vxsec->floorbunch = fisext ? vxsec->floorxpanning : -1;

        if (cisext)

            vxsec->ceilingxpanning = 0;

        if (fisext)

            vxsec->floorxpanning = 0;

    }

    else

    {

        vxsec->ceilingbunch = vxsec->floorbunch = -1;

    }

    /* Clear YAX_BIT of ceiling and floor (map-int VX doesn't use it). */

    vxsec->ceilingstat &= ~YAX_BIT__COMPAT;

    vxsec->floorstat &= ~YAX_BIT__COMPAT;

}

# undef SECTORVX_SZ1

# undef SECTORVX_SZ4

// 38 bytes

typedef struct

{

    Tracker(Wall, int32_t) x, y;

    Tracker(Wall, int16_t) point2, nextwall, nextsector;

    Tracker(Wall, int16_t) upwall, dnwall;

    Tracker(Wall, uint16_t) cstat;

    Tracker(Wall, int16_t) picnum, overpicnum;

    Tracker(Wall, int8_t) shade;

    Tracker(Wall, uint8_t) pal, xrepeat, yrepeat, xpanning, ypanning;

    Tracker(Wall, uint16_t) lotag, hitag;

    Tracker(Wall, int16_t) extra;

    Tracker(Wall, uint8_t) blend, filler_;

} walltypevx;

# define WALLVX_SZ2 offsetof(walltypevx, blend)-offsetof(walltypevx, cstat)

static inline void copy_v7_from_vx_wall(walltypev7 *v7wal, const walltypevx *vxwal)

{

    /* [x..nextsector] */

    Bmemcpy(v7wal, vxwal, offsetof(walltypevx, upwall));

    /* [cstat..extra] */

    Bmemcpy(&v7wal->cstat, &vxwal->cstat, WALLVX_SZ2);

    /* Clear YAX_NEXTWALLBITS. */

    v7wal->cstat &= ~YAX_NEXTWALLBITS__COMPAT;

}

static inline void inplace_vx_from_v7_wall(walltypevx *vxwal)

{

    const walltypev7 *v7wal = (walltypev7 *)vxwal;

    /* [cstat..extra] */

    Bmemmove(&vxwal->cstat, &v7wal->cstat, WALLVX_SZ2);

    vxwal->blend = vxwal->filler_ = 0;

}

static inline void inplace_vx_tweak_wall(walltypevx *vxwal, int32_t yaxp)

{

    if (yaxp)

    {

        int32_t haveupwall = (vxwal->cstat & YAX_NEXTWALLBIT__COMPAT(YAX_CEILING));

        int32_t havednwall = (vxwal->cstat & YAX_NEXTWALLBIT__COMPAT(YAX_FLOOR));

        vxwal->upwall = haveupwall ? vxwal->lotag : -1;

        vxwal->dnwall = havednwall ? vxwal->extra : -1;

        if (haveupwall)

            vxwal->lotag = 0;

        if (havednwall)

            vxwal->extra = -1;

    }

    else

    {

        vxwal->upwall = vxwal->dnwall = -1;

    }

    /* Clear YAX_NEXTWALLBITS (map-int VX doesn't use it). */

    vxwal->cstat &= ~YAX_NEXTWALLBITS__COMPAT;

}

# undef WALLVX_SZ2

// NOTE: spritetype is currently the same for V7/8/9 and VX in-memory map formats.

typedef sectortypevx sectortype;

typedef walltypevx walltype;

typedef sectortype tsectortype;

typedef walltype twalltype;

typedef spritetype tspritetype;

//////////////////// END Lunatic new-generation map format ////////////////

#else

typedef sectortypev7 sectortype;

typedef walltypev7 walltype;

#endif

typedef struct {

    uint32_t mdanimtims;

    int16_t mdanimcur;

    int16_t angoff, pitch, roll;

    vec3_t offset;

    uint8_t flags;

    uint8_t xpanning, ypanning;

    uint8_t filler;

    float alpha;

    // NOTE: keep 'tspr' on an 8-byte boundary:

    tspritetype *tspr;

#if !defined UINTPTR_MAX

# error Need UINTPTR_MAX define to select between 32- and 64-bit structs

#endif

#if UINTPTR_MAX == 0xffffffff

    /* On a 32-bit build, pad the struct so it has the same size everywhere. */

    intptr_t dummy_;

#endif

} spriteext_t;

typedef struct {

    float smoothduration;

    int16_t mdcurframe, mdoldframe;

    int16_t mdsmooth;

    uint8_t filler[2];

} spritesmooth_t;

#define SPREXT_NOTMD 1

#define SPREXT_NOMDANIM 2

#define SPREXT_AWAY1 4

#define SPREXT_AWAY2 8

#define SPREXT_TSPRACCESS 16

#define SPREXT_TEMPINVISIBLE 32

#define CSTAT_SPRITE_MDHACK 1024

EXTERN int32_t guniqhudid;

EXTERN int32_t spritesortcnt;

extern int32_t g_loadedMapVersion;

typedef struct {

    char *mhkfile;

    char *title;

    uint8_t md4[16];

} usermaphack_t;

extern usermaphack_t g_loadedMapHack;

extern int32_t compare_usermaphacks(const void *, const void *);

extern usermaphack_t *usermaphacks;

extern int32_t num_usermaphacks;

#if !defined DEBUG_MAIN_ARRAYS

EXTERN spriteext_t *spriteext;

EXTERN spritesmooth_t *spritesmooth;

EXTERN sectortype *sector;

EXTERN walltype *wall;

EXTERN spritetype *sprite;

EXTERN tspritetype *tsprite;

#else

EXTERN spriteext_t spriteext[MAXSPRITES+MAXUNIQHUDID];

EXTERN spritesmooth_t spritesmooth[MAXSPRITES+MAXUNIQHUDID];

EXTERN sectortype sector[MAXSECTORS + M32_FIXME_SECTORS];

EXTERN walltype wall[MAXWALLS + M32_FIXME_WALLS];

EXTERN spritetype sprite[MAXSPRITES];

EXTERN tspritetype tsprite[MAXSPRITESONSCREEN];

#endif

EXTERN uint32_t sectorchanged[MAXSECTORS + M32_FIXME_SECTORS];

EXTERN uint32_t wallchanged[MAXWALLS + M32_FIXME_WALLS];

EXTERN uint32_t spritechanged[MAXSPRITES];

#ifdef NEW_MAP_FORMAT

FORCE_INLINE int16_t yax_getbunch(int16_t i, int16_t cf)

{

    return cf ? sector[i].floorbunch : sector[i].ceilingbunch;

}

FORCE_INLINE void yax_getbunches(int16_t i, int16_t *cb, int16_t *fb)

{

    *cb = yax_getbunch(i, YAX_CEILING);

    *fb = yax_getbunch(i, YAX_FLOOR);

}

FORCE_INLINE int16_t yax_getnextwall(int16_t wal, int16_t cf)

{

    return cf ? wall[wal].dnwall : wall[wal].upwall;

}

FORCE_INLINE void yax_setnextwall(int16_t wal, int16_t cf, int16_t thenextwall)

{

    YAX_NEXTWALL(wal, cf) = thenextwall;

}

#endif

FORCE_INLINE void sector_tracker_hook(uintptr_t address)

{

    uintptr_t const usector = address - (uintptr_t)sector;

#if DEBUGGINGAIDS

    Bassert(usector < ((MAXSECTORS + M32_FIXME_SECTORS) * sizeof(sectortype)));

#endif

    sectorchanged[usector / sizeof(sectortype)]++;

}

FORCE_INLINE void wall_tracker_hook(uintptr_t address)

{

    uintptr_t const uwall = address - (uintptr_t)wall;

#if DEBUGGINGAIDS

    Bassert(uwall < ((MAXWALLS + M32_FIXME_WALLS) * sizeof(walltype)));

#endif

    wallchanged[uwall / sizeof(walltype)]++;

}

FORCE_INLINE void sprite_tracker_hook(uintptr_t address)

{

    uintptr_t const usprite = address - (uintptr_t)sprite;

#if DEBUGGINGAIDS

    Bassert(usprite < (MAXSPRITES * sizeof(spritetype)));

#endif

    spritechanged[usprite / sizeof(spritetype)]++;

}

EXTERN int16_t maskwall[MAXWALLSB], maskwallcnt;

EXTERN int16_t thewall[MAXWALLSB];

EXTERN tspritetype *tspriteptr[MAXSPRITESONSCREEN + 1];

EXTERN int32_t xdim, ydim, numpages;

EXTERN int32_t yxaspect, viewingrange;

EXTERN intptr_t *ylookup;

#ifndef GEKKO

#define MAXVALIDMODES 256

#else

#define MAXVALIDMODES 16

#endif

EXTERN int32_t validmodecnt;

struct validmode_t {

    int32_t xdim,ydim;

    char bpp;

    char fs;    // bit 0 = fullscreen flag

    char filler[2];

    int32_t extra; // internal use

};

EXTERN struct validmode_t validmode[MAXVALIDMODES];

EXTERN int32_t numyaxbunches;

#ifdef YAX_ENABLE

// Singly-linked list of sectnums grouped by bunches and ceiling (0)/floor (1)

// Usage e.g.:

//   int16_t bunchnum = yax_getbunch(somesector, YAX_CEILING);

// Iteration over all sectors whose floor bunchnum equals 'bunchnum' (i.e. "all

// floors of the other side"):

//   for (i=headsectbunch[1][bunchnum]; i!=-1; i=nextsectbunch[1][i])

//       <do stuff with sector i...>

EXTERN int16_t headsectbunch[2][YAX_MAXBUNCHES], nextsectbunch[2][MAXSECTORS];

#endif

EXTERN int32_t Numsprites;

EXTERN int16_t numsectors, numwalls;

EXTERN char display_mirror;

// totalclocklock: the totalclock value that is backed up once on each

// drawrooms() and is used for animateoffs().

EXTERN int32_t totalclock, totalclocklock;

static inline int32_t BGetTime(void) { return totalclock; }

EXTERN int32_t numframes, randomseed;

EXTERN int16_t sintable[2048];

EXTERN uint8_t palette[768];

EXTERN int16_t numshades;

EXTERN char *palookup[MAXPALOOKUPS];

EXTERN uint8_t **basepaltableptr;

EXTERN char showinvisibility;

EXTERN int32_t g_visibility, parallaxvisibility;

EXTERN int32_t g_rotatespriteNoWidescreen;

EXTERN int32_t windowx1, windowy1, windowx2, windowy2;

EXTERN int16_t *startumost, *startdmost;

// The maximum tile offset ever used in any tiled parallaxed multi-sky.

#define PSKYOFF_MAX 4

typedef struct {

    // The proportion at which looking up/down affects the apparent 'horiz' of

    // a parallaxed sky, scaled by 65536 (so, a value of 65536 makes it align

    // with the drawn surrounding scene):

    int32_t horizfrac;

    // The texel index offset in the y direction of a parallaxed sky:

    // XXX: currently always 0.

    int32_t yoffs;

    int8_t lognumtiles;  // 1<<lognumtiles: number of tiles in multi-sky

    int8_t tileofs[MAXPSKYTILES];  // for 0 <= j < (1<<lognumtiles): tile offset relative to basetile

} psky_t;

// Index of map-global (legacy) multi-sky:

EXTERN int32_t g_pskyidx;

// New multi-psky -- up to MAXPSKYMULTIS (effectively constant after initialization):

EXTERN int32_t pskynummultis;

EXTERN psky_t multipsky[MAXPSKYMULTIS];

// Mapping of multi-sky index to base sky tile number:

EXTERN int32_t multipskytile[MAXPSKYMULTIS];

FORCE_INLINE int32_t getpskyidx(int32_t picnum)

{

    int32_t j;

    for (j=pskynummultis; j>0; j--)  // NOTE: j==0 on non-early loop end

        if (picnum == multipskytile[j])

            break;  // Have a match.

    return j;

}

EXTERN char parallaxtype;

// last sprite in the freelist, that is the spritenum for which

//   .statnum==MAXSTATUS && nextspritestat[spritenum]==-1

// (or -1 if freelist is empty):

EXTERN int16_t tailspritefree;

EXTERN int16_t headspritesect[MAXSECTORS+1], headspritestat[MAXSTATUS+1];

EXTERN int16_t prevspritesect[MAXSPRITES], prevspritestat[MAXSPRITES];

EXTERN int16_t nextspritesect[MAXSPRITES], nextspritestat[MAXSPRITES];

EXTERN vec2_t tilesiz[MAXTILES];

EXTERN char picsiz[MAXTILES];

EXTERN char walock[MAXTILES];

extern const char pow2char[8];

extern const int32_t pow2long[32];

// picanm[].sf:

// |bit(1<<7)

// |animtype|animtype|texhitscan|nofullbright|speed|speed|speed|speed|

enum {

    PICANM_ANIMTYPE_NONE = 0,

    PICANM_ANIMTYPE_OSC = (1<<6),

    PICANM_ANIMTYPE_FWD = (2<<6),

    PICANM_ANIMTYPE_BACK = (3<<6),

    PICANM_ANIMTYPE_SHIFT = 6,

    PICANM_ANIMTYPE_MASK = (3<<6),  // must be 192

    PICANM_MISC_MASK = (3<<4),

    PICANM_TEXHITSCAN_BIT = (2<<4),

    PICANM_NOFULLBRIGHT_BIT = (1<<4),

    PICANM_ANIMSPEED_MASK = 15,  // must be 15

};

// NOTE: If the layout of this struct is changed, loadpics() must be modified

// accordingly.

typedef struct {

    uint8_t num;  // animate number

    int8_t xofs, yofs;

    uint8_t sf;  // anim. speed and flags

} picanm_t;

EXTERN picanm_t picanm[MAXTILES];

EXTERN intptr_t waloff[MAXTILES];  // stores pointers to cache  -- SA

EXTERN int32_t windowpos, windowx, windowy;

    //These variables are for auto-mapping with the draw2dscreen function.

    //When you load a new board, these bits are all set to 0 - since

    //you haven't mapped out anything yet.  Note that these arrays are

    //bit-mapped.

    //If you want draw2dscreen() to show sprite #54 then you say:

    //   spritenum = 54;

    //   show2dsprite[spritenum>>3] |= (1<<(spritenum&7));

    //And if you want draw2dscreen() to not show sprite #54 then you say:

    //   spritenum = 54;

    //   show2dsprite[spritenum>>3] &= ~(1<<(spritenum&7));

EXTERN char show2dsector[(MAXSECTORS+7)>>3];

EXTERN char show2dwall[(MAXWALLS+7)>>3];

EXTERN char show2dsprite[(MAXSPRITES+7)>>3];

// In the editor, gotpic is only referenced from inline assembly;

// the compiler needs that hint or building with LTO will discard it.

#if !defined __clang__ && !defined NOASM

# define GOTPIC_USED ATTRIBUTE((used))

#else

# define GOTPIC_USED

#endif

EXTERN char GOTPIC_USED gotpic[(MAXTILES+7)>>3];

EXTERN char gotsector[(MAXSECTORS+7)>>3];

EXTERN char editorcolors[256];

EXTERN int32_t faketilesiz[MAXTILES];

EXTERN char *faketiledata[MAXTILES];

EXTERN char spritecol2d[MAXTILES][2];

extern char vgapal16[4*256];

extern uint32_t drawlinepat;

extern void faketimerhandler(void);