zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-24 10:40:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

A crapload of random stuff.

Browse source 
* Polymer light access to m32script (light[<lightidx>].<field>). As an application, provide a state 'insertlights' that takes the currently active lights and puts them into the map as SEs (e.g. for maphack recovery).
* Prototype of a mechanism to gray out certain portion of a map, making them inactive to various, but not all, editing operations. Highlighting a set of sectors and pressing Ctrl-R will make the Z bounds be [(least ceiling z), (greatest floor z)] of all selected ones, pressing Ctrl-R when no sectors are highlighted will reset them. Not sure if it's for production use at this stage...
* The 'align walls' feature [.] now has three independently toggleable behaviours: recurse nextwalls (toggled when Ctrl is pressed), iterate point2s (disabled when Shift is pressed), and also copy pixel width (toggled when Alt is pressed).
* Make shades clamp instead of overflowing in the editor

Fixes:
* crash when carrying out certain operations on walls with xrepeat 0
* the Pause key on linux. Also make demo recording start on Shift-ScrollLock because ScrollLock alone is too easily pressed when pausing


git-svn-id: https://svn.eduke32.com/eduke32@1877 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
helixhorned 2011-05-07 18:23:34 +00:00
parent bd410d8557
commit 203cf0b7b1
17 changed files with 1087 additions and 601 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
polymer/eduke32/build/include/build.h
View file

@ -62,7 +62,9 @@ extern "C" {
#define PR_LIGHT_PRIO_LOW_GAME 5
////////// yax defs //////////
#define YAX_MAXBUNCHES (MAXSECTORS>>1)
#define SECTORFLD(Sect,Fld, Cf) (*((Cf) ? (&sector[Sect].floor##Fld) : (&sector[Sect].ceiling##Fld)))
#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))
@ -70,12 +72,13 @@ extern "C" {
#define YAX_CEILING 0 // don't change!
#define YAX_FLOOR 1 // don't change!
#define SECTORFLD(Sect,Fld, Cf) (*((Cf) ? (&sector[Sect].floor##Fld) : (&sector[Sect].ceiling##Fld)))
void yax_updategrays(int32_t posze);
#ifdef YAX_ENABLE
// more user tag hijacking: lotag/extra :/
#define YAX_NEXTWALL(Wall, Cf) (*(&wall[Wall].lotag + 2*Cf))
# define YAX_NEXTWALL(Wall, Cf) (*(&wall[Wall].lotag + 2*Cf))
#define YAX_ITER_WALLS(Wal, Itervar, Cfvar) Cfvar=0, Itervar=(Wal); Itervar!=-1; \
# 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)))
int16_t yax_getbunch(int16_t i, int16_t cf);
@ -85,14 +88,21 @@ void yax_setbunches(int16_t i, int16_t cb, int16_t fb);
int16_t yax_getnextwall(int16_t wal, int16_t cf);
void yax_setnextwall(int16_t wal, int16_t cf, int16_t thenextwall);
void yax_update(int32_t onlyreset);
void yax_updategrays(int32_t posze);
int32_t yax_getneighborsect(int32_t x, int32_t y, int32_t sectnum, int32_t cf, int16_t *ret_bunchnum);
void yax_drawrooms(void (*ExtAnalyzeSprites)(void), int32_t horiz, int16_t sectnum);
#ifdef YAX_ENABLE
static 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 (*ExtAnalyzeSprites)(void), int32_t horiz, int16_t sectnum);
# 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(ExtAnalyzeSprites, horiz, sectnum)
# define YAX_SKIPSECTOR(i) (i)=(i)
# define YAX_SKIPWALL(i) (i)=(i)
#endif
@ -128,7 +138,8 @@ void yax_drawrooms(void (*ExtAnalyzeSprites)(void), int32_t horiz, int16_t sectn
// 11 = reverse transluscent masked floors
// bit 9: 1 = blocking ceiling/floor
// bit 10: 1 = YAX'ed ceiling/floor
// bits 11-15: reserved
// bit 11: 1 = hitscan-sensitive ceiling/floor
// bits 12-15: reserved
//40 bytes
typedef struct

7
polymer/eduke32/build/include/editor.h
View file

@ -70,10 +70,8 @@ extern int32_t m32_osd_tryscript;
extern int32_t showheightindicators;
extern int32_t showambiencesounds;
#ifdef YAX_ENABLE
extern uint8_t graysectbitmap[MAXSECTORS>>3];
extern uint8_t graywallbitmap[MAXWALLS>>3];
#endif
// editor side view
extern int32_t m32_sideview;
@ -97,9 +95,10 @@ extern void bfirst_search_try(int16_t *list, uint8_t *bitmap, int32_t *eltnumptr
extern int32_t wallength(int16_t i);
extern void fixrepeats(int16_t i);
extern void fixxrepeat(int16_t i, uint32_t lenrepquot);
extern uint32_t getlenbyrep(int32_t len, int32_t repeat);
extern void fixxrepeat(int16_t wallnum, uint32_t lenrepquot);
extern void AlignWallPoint2(int32_t w0);
extern int32_t AutoAlignWalls(int32_t w0, int32_t dorecurse, int32_t nrecurs);
extern int32_t AutoAlignWalls(int32_t w0, uint32_t flags, int32_t nrecurs);
extern int32_t ExtInit(void);
extern int32_t ExtPreInit(int32_t argc,const char **argv);

12
polymer/eduke32/build/include/m32script.h
View file

@ -247,16 +247,18 @@ extern int32_t halfxdim16, midydim16;
#define M32_SECTOR_VAR_ID 1
#define M32_WALL_VAR_ID 2
#define M32_TSPRITE_VAR_ID 3
#define M32_LIGHT_VAR_ID 4
#define M32_THISACTOR_VAR_ID 4
#define M32_RETURN_VAR_ID 5
#define M32_LOTAG_VAR_ID 6
#define M32_HITAG_VAR_ID 7
#define M32_TEXTURE_VAR_ID 8
#define M32_THISACTOR_VAR_ID 5
#define M32_RETURN_VAR_ID 6
#define M32_LOTAG_VAR_ID 7
#define M32_HITAG_VAR_ID 8
#define M32_TEXTURE_VAR_ID 9
#define M32_LOCAL_ARRAY_ID 0
#define M32_PRINTERROR(Text, ...) OSD_Printf(OSD_ERROR "Line %d, %s: " Text "\n", g_errorLineNum, keyw[g_tw], ## __VA_ARGS__)
#define M32_ERROR(Text, ...) do { M32_PRINTERROR(Text, ## __VA_ARGS__); vm.flags |= VMFLAG_ERROR; } while (0)
// how local gamevars are allocated:

91
polymer/eduke32/build/src/build.c
View file

@ -329,11 +329,8 @@ static void M32_drawdebug(void)
if (m32_numdebuglines>0)
{
begindrawing();
for (i=0; i<m32_numdebuglines; i++)
{
y+=8;
for (i=0; i<m32_numdebuglines && y<ydim-8; i++, y+=8)
printext256(x,y,whitecol,0,m32_debugstr[i],xdimgame>640?0:1);
}
enddrawing();
}
m32_numdebuglines=0;
@ -414,6 +411,9 @@ static void reset_default_mapstate(void)
numwalls = 0;
numsprites = 0;
editorzrange[0] = INT_MIN;
editorzrange[1] = INT_MAX;
initspritelists();
taglab_init();
@ -642,10 +642,10 @@ CANCEL:
ExtPreCheckKeys();
yax_preparedrawrooms();
drawrooms(pos.x,pos.y,pos.z,ang,horiz,cursectnum);
#ifdef YAX_ENABLE
yax_drawrooms(ExtAnalyzeSprites, horiz, cursectnum);
#endif
ExtAnalyzeSprites();
drawmasks();
@ -2229,7 +2229,7 @@ void overheadeditor(void)
int32_t tempint, tempint1, tempint2;
int32_t startwall=0, endwall, dax, day, x1, y1, x2, y2, x3, y3, x4, y4;
int32_t highlightx1, highlighty1, highlightx2, highlighty2;
int16_t pag, suckwall=0, sucksect, split=0, bad;
int16_t suckwall=0, sucksect, split=0, bad;
int16_t splitsect=0, joinsector[2];
int16_t splitstartwall=0;
int32_t mousx, mousy, bstatus;
@ -2256,13 +2256,14 @@ void overheadeditor(void)
searchy = clamp(scale(searchy,ydim2d-STATUS2DSIZ2,ydimgame), 8, ydim2d-STATUS2DSIZ-8-1);
oposz = pos.z;
yax_updategrays(pos.z);
begindrawing(); //{{{
CLEARLINES2D(0, ydim, 0);
enddrawing(); //}}}
ydim16 = ydim-STATUS2DSIZ2;
pag = 0;
cursectorhighlight = -1;
lastpm16time = -1;
@ -3542,7 +3543,10 @@ end_yax: ;
}
}
else
hlsectorbitmap[i>>3] |= (1<<(i&7));
{
if ((graysectbitmap[i>>3]&(1<<(i&7)))==0)
hlsectorbitmap[i>>3] |= (1<<(i&7));
}
}
}
@ -4263,7 +4267,11 @@ end_join_sectors:
NEXTWALL(i).nextwall = i;
NEXTWALL(i).nextsector = numsectors;
}
#ifdef YAX_ENABLE
yax_setbunches(numsectors, -1, -1);
yax_update(0);
yax_updategrays(pos.z);
#endif
numwalls = newnumwalls;
newnumwalls = -1;
numsectors++;
@ -5872,17 +5880,13 @@ int32_t LoadBoard(const char *filename, uint32_t flags)
if (filename != boardfilename)
Bstrcpy(boardfilename, filename);
if ((flags&1)==0)
{
highlightcnt = -1;
Bmemset(show2dwall, 0, sizeof(show2dwall)); //Clear all highlights
Bmemset(show2dsprite, 0, sizeof(show2dsprite));
}
for (i=0; i<MAXSECTORS; i++) sector[i].extra = -1;
for (i=0; i<MAXWALLS; i++) wall[i].extra = -1;
for (i=0; i<MAXSPRITES; i++) sprite[i].extra = -1;
editorzrange[0] = INT_MIN;
editorzrange[1] = INT_MAX;
ExtPreLoadMap();
i = loadboard(boardfilename,(flags&4)|loadingflags, &pos.x,&pos.y,&pos.z,&ang,&cursectnum);
if (i == -2)
@ -5893,6 +5897,9 @@ int32_t LoadBoard(const char *filename, uint32_t flags)
return i;
}
highlightcnt = -1;
Bmemset(show2dwall, 0, sizeof(show2dwall)); //Clear all highlights
Bmemset(show2dsprite, 0, sizeof(show2dsprite));
if ((flags&4)==0)
loadmhk(0);
@ -5915,9 +5922,6 @@ int32_t LoadBoard(const char *filename, uint32_t flags)
startposz = pos.z;
startang = ang;
startsectnum = cursectnum;
#ifdef YAX_ENABLE
// yax_resetbunchnums();
#endif
return 0;
}
@ -6220,7 +6224,7 @@ static void insertpoint(int16_t linehighlight, int32_t dax, int32_t day)
j = linehighlight;
sucksect = sectorofwall(j);
templenrepquot = divscale12(wallength(j), wall[j].xrepeat);
templenrepquot = getlenbyrep(wallength(j), wall[j].xrepeat);
sector[sucksect].wallnum++;
for (i=sucksect+1; i<numsectors; i++)
@ -6241,7 +6245,7 @@ static void insertpoint(int16_t linehighlight, int32_t dax, int32_t day)
if (wall[j].nextwall >= 0)
{
k = wall[j].nextwall;
templenrepquot = divscale12(wallength(k), wall[k].xrepeat);
templenrepquot = getlenbyrep(wallength(k), wall[k].xrepeat);
sucksect = sectorofwall(k);
@ -6452,12 +6456,20 @@ void fixrepeats(int16_t i)
wall[i].xrepeat = clamp(mulscale10(dist,day), 1, 255);
}
void fixxrepeat(int16_t i, uint32_t lenrepquot) // lenrepquot: divscale12(wallength,xrepeat)
uint32_t getlenbyrep(int32_t len, int32_t repeat)
{
if (repeat <= 0)
return ((uint32_t)len)<<12;
return divscale12(len, repeat);
}
void fixxrepeat(int16_t wallnum, uint32_t lenrepquot) // lenrepquot: divscale12(wallength,xrepeat)
{
if (lenrepquot != 0)
{
uint32_t res = (((wallength(i)<<12)+(1<<11))/lenrepquot);
wall[i].xrepeat = clamp(res, 1, 255);
uint32_t res = (((wallength(wallnum)<<12)+(1<<11))/lenrepquot);
wall[wallnum].xrepeat = clamp(res, 1, 255);
}
}
@ -6726,10 +6738,10 @@ int32_t _getnumber256(const char *namestart, int32_t num, int32_t maxnumber, cha
if (handleevents())
quitevent = 0;
yax_preparedrawrooms();
drawrooms(pos.x,pos.y,pos.z,ang,horiz,cursectnum);
#ifdef YAX_ENABLE
yax_drawrooms(ExtAnalyzeSprites, horiz, cursectnum);
#endif
ExtAnalyzeSprites();
drawmasks();
@ -8197,11 +8209,15 @@ void AlignWallPoint2(int32_t w0)
AlignWalls(w0,GetWallBaseZ(w0), w1,GetWallBaseZ(w1), wall[w0].picnum);
}
// pass maxrecurs=0 for unconstrained recursion
int32_t AutoAlignWalls(int32_t w0, int32_t dorecurse, int32_t nrecurs)
// flags:
// 1: recurse nextwalls
// 2: iterate point2's
// 4: carry pixel width from first wall over to the rest
int32_t AutoAlignWalls(int32_t w0, uint32_t flags, int32_t nrecurs)
{
int32_t z0, z1, tilenum, w1, visible, nextsec, sectnum;
static int32_t numaligned;
static int32_t numaligned, wall0;
static uint32_t lenrepquot;
tilenum = wall[w0].picnum;
@ -8211,6 +8227,8 @@ int32_t AutoAlignWalls(int32_t w0, int32_t dorecurse, int32_t nrecurs)
Bmemset(visited, 0, sizeof(visited));
visited[w0>>3] |= (1<<(w0&7));
numaligned = 0;
lenrepquot = getlenbyrep(wallength(w0), wall[w0].xrepeat);
wall0 = w0;
}
z0 = GetWallBaseZ(w0);
@ -8253,23 +8271,28 @@ int32_t AutoAlignWalls(int32_t w0, int32_t dorecurse, int32_t nrecurs)
if (visible)
{
numaligned++;
if ((flags&4) && w0!=wall0)
fixxrepeat(w0, lenrepquot);
AlignWalls(w0,z0, w1,z1, tilenum);
numaligned++;
//if wall was 1-sided, no need to recurse
if (wall[w1].nextwall < 0)
{
if (!(flags&2))
break;
w0 = w1;
z0 = GetWallBaseZ(w0);
w1 = wall[w0].point2;
continue;
}
else if (dorecurse)
AutoAlignWalls(w1, 1, nrecurs+1);
else if (flags&1)
AutoAlignWalls(w1, flags, nrecurs+1);
}
}
if (wall[w1].nextwall < 0) break;
if (wall[w1].nextwall < 0 || !(flags&2))
break;
w1 = NEXTWALL(w1).point2;
}

639
polymer/eduke32/build/src/engine.c
View file

@ -188,19 +188,73 @@ int16_t editstatus = 0;
////////// YAX //////////
#if YAX_M32_DEBUG
extern char m32_debugstr[64][128];
extern int32_t m32_numdebuglines;
# define yaxdebug(fmt, ...) do { if (m32_numdebuglines<64) Bsprintf(m32_debugstr[m32_numdebuglines++], fmt, ##__VA_ARGS__); } while (0)
#else
# define yaxdebug(fmt, ...)
#endif
uint8_t graysectbitmap[MAXSECTORS>>3];
uint8_t graywallbitmap[MAXWALLS>>3];
#ifdef ENGINE_SCREENSHOT_DEBUG
int32_t engine_screenshot = 0;
#endif
void yax_updategrays(int32_t posze)
{
int32_t i, j, k=1;
#ifndef YAX_ENABLE
UNREFERENCED_PARAMETER(posze);
#endif
Bmemset(graysectbitmap, 0, sizeof(graysectbitmap));
Bmemset(graywallbitmap, 0, sizeof(graywallbitmap));
// update grayouts due to editorzrange
for (i=0; i<numsectors; i++)
{
#ifdef YAX_ENABLE
int16_t cb, fb;
yax_getbunches(i, &cb, &fb);
k = ((cb<0 || sector[i].ceilingz < posze) && (fb<0 || posze <= sector[i].floorz));
#endif
k &= (sector[i].ceilingz >= editorzrange[0] && sector[i].floorz <= editorzrange[1]);
if (!k) // outside bounds, gray out!
{
graysectbitmap[i>>3] |= (1<<(i&7));
for (j=sector[i].wallptr; j<sector[i].wallptr+sector[i].wallnum; j++)
graywallbitmap[j>>3] |= (1<<(j&7));
}
}
}
#ifdef YAX_ENABLE
// all references to floor/ceiling bunchnums should be through the
// get/set functions!
static int32_t g_nodraw = 0;
static int32_t scansector_retfast = 0;
static int32_t scansector_collectsprites = 1;
static int32_t yax_globalcf = -1;
static int32_t yax_globallev = YAX_MAXDRAWS;
// duplicated tsprites
// [i]:
// i==MAXDRAWS: base level
// i<MAXDRAWS: MAXDRAWS-i-1 is level towards ceiling
// i>MAXDRAWS: i-MAXDRAWS-1 is level towards floor
static int16_t yax_spritesortcnt[1 + 2*YAX_MAXDRAWS];
static int16_t yax_tsprite[1 + 2*YAX_MAXDRAWS][MAXSPRITESONSCREEN];
// game-time YAX data structures
static int16_t yax_bunchnum[MAXSECTORS][2];
static int16_t yax_nextwall[MAXWALLS][2];
uint8_t graysectbitmap[MAXSECTORS>>3];
uint8_t graywallbitmap[MAXWALLS>>3];
static int32_t yax_islockededge(/*int16_t sec,*/ int16_t line, int16_t cf)
#if 1
{
@ -223,7 +277,7 @@ static int32_t yax_islockededge(/*int16_t sec,*/ int16_t line, int16_t cf)
}
#endif
#define YAX_BUNCHNUM(Sect, Cf) (*(int16_t *)(&sector[Sect].ceilingxpanning + 8*Cf))
#define YAX_BUNCHNUM(Sect, Cf) (*(&sector[Sect].ceilingxpanning + 8*Cf))
//// bunch getters/setters
int16_t yax_getbunch(int16_t i, int16_t cf)
@ -312,6 +366,7 @@ void yax_setnextwall(int16_t wal, int16_t cf, int16_t thenextwall)
//// in-struct --> array transfer; list construction
void yax_update(int32_t onlyreset)
{
// TODO: always make bunchnums consecutive
int32_t i, j, oeditstatus=editstatus;
int16_t cb, fb, tmpsect;
@ -382,34 +437,6 @@ void yax_update(int32_t onlyreset)
editstatus = oeditstatus;
}
void yax_updategrays(int32_t posze)
{
int32_t i, j, k;
int16_t cb, fb;
Bmemset(graysectbitmap, 0, sizeof(graysectbitmap));
Bmemset(graywallbitmap, 0, sizeof(graywallbitmap));
if (numyaxbunches==0)
return;
for (i=0; i<numsectors; i++)
{
yax_getbunches(i, &cb, &fb);
if (cb<0 && fb<0)
continue;
k = ((cb<0 || sector[i].ceilingz < posze) && (fb<0 || posze <= sector[i].floorz));
if (!k) // outside bounds, gray out!
{
graysectbitmap[i>>3] |= (1<<(i&7));
for (j=sector[i].wallptr; j<sector[i].wallptr+sector[i].wallnum; j++)
graywallbitmap[j>>3] |= (1<<(j&7));
}
}
}
int32_t yax_getneighborsect(int32_t x, int32_t y, int32_t sectnum, int32_t cf, int16_t *ret_bunchnum)
{
int16_t bunchnum = yax_getbunch(sectnum, cf);
@ -429,144 +456,326 @@ int32_t yax_getneighborsect(int32_t x, int32_t y, int32_t sectnum, int32_t cf, i
return -1;
}
static int32_t globalcf;
// >0 b2 is farther away than b1
static int yax_cmpbunches(const int16_t *b1, const int16_t *b2)
{
int32_t s1,s2, w1,w2;
int64_t x1,y1, x2,y2, r;
s1 = headsectbunch[globalcf][*b1];
s2 = headsectbunch[globalcf][*b2];
#if 1
int32_t dx1,dy1, dx2,dy2, r;
#else
int64_t dx1,dy1, dx2,dy2, r;
#endif
s1 = headsectbunch[yax_globalcf][*b1];
s2 = headsectbunch[yax_globalcf][*b2];
w1 = sector[s1].wallptr;
w2 = sector[s2].wallptr;
x1 = wall[w1].x-globalposx; y1 = wall[w1].y-globalposy;
x2 = wall[w2].x-globalposx; y2 = wall[w2].y-globalposy;
r = (x2*x2 + y2*y2) - (x1*x1 + y1*y1);
dx1 = wall[w1].x-globalposx; dy1 = wall[w1].y-globalposy;
dx2 = wall[w2].x-globalposx; dy2 = wall[w2].y-globalposy;
#if 1
r = klabs(dx2+dy2) - klabs(dx1+dy1);
return r;
#else
r = (dx2*dx2 + dy2*dy2) - (dx1*dx1 + dy1*dy1);
if (r > 0)
return 1;
return r>>63;
#endif
}
static int32_t yax_getbestsector(int32_t bunchnum, int32_t cf, const int16_t *ourbunch, int16_t sectnum)
{
int32_t k;
if (bunchnum==ourbunch[cf])
{
k = yax_getneighborsect(globalposx, globalposy, sectnum, cf, NULL);
if (k < 0)
k = headsectbunch[!cf][bunchnum];
return k;
}
else
{
// return headsectbunch[!cf][bunchnum];
scansector_retfast = 1;
scansector_collectsprites = 0;
for (k = headsectbunch[!cf][bunchnum]; k != -1; k = nextsectbunch[!cf][k])
{
numscans = numbunches = 0;
scansector(k);
if (numbunches > 0)
break;
}
scansector_collectsprites = 1;
scansector_retfast = 0;
return k;
}
}
static void yax_tweakpicnums(int32_t bunchnum, int32_t cf, int32_t restore)
{
static int16_t opicnum[2][MAXSECTORS];
int32_t i;
for (i=headsectbunch[cf][bunchnum]; i!=-1; i=nextsectbunch[cf][i])
if ((SECTORFLD(i,stat, cf)&(128+256))==0)
{
if (!restore)
{
opicnum[cf][i] = SECTORFLD(i,picnum, cf);
if (editstatus && showinvisibility)
SECTORFLD(i,picnum, cf) = MAXTILES-1;
else
SECTORFLD(i,picnum, cf) = 13; //FOF;
}
else
{
SECTORFLD(i,picnum, cf) = opicnum[cf][i];
}
}
}
static void yax_copytsprite(int16_t curbunchnum)
{
int16_t bunchnum;
int32_t i, spritenum, gotthrough, sectnum, cf;
int32_t sortcnt = yax_spritesortcnt[yax_globallev];
const spritetype *spr;
spritesortcnt = 0;
for (i=0; i<sortcnt; i++)
{
spritenum = yax_tsprite[yax_globallev][i];
gotthrough = spritenum&((MAXSPRITES<<1)+MAXSPRITES);
spritenum &= MAXSPRITES-1;
spr = &sprite[spritenum];
sectnum = spr->sectnum;
cf = -1;
if (gotthrough & MAXSPRITES)
cf = YAX_CEILING; // sprite got here through the ceiling of lower sector
else if (gotthrough & (MAXSPRITES<<1))
cf = YAX_FLOOR; // sprite got here through the floor of upper sector
if (cf != -1)
{
bunchnum = yax_getbunch(sectnum, cf);
if (yax_globallev != YAX_MAXDRAWS && curbunchnum != bunchnum)
continue;
sectnum = yax_getneighborsect(spr->x, spr->y, sectnum, cf, NULL);
if (sectnum < 0)
continue;
}
Bmemcpy(&tsprite[spritesortcnt], spr, sizeof(spritetype));
spriteext[spritenum].tspr = &tsprite[spritesortcnt];
tsprite[spritesortcnt].owner = spritenum;
tsprite[spritesortcnt].sectnum = sectnum; // tweak sectnum!
spritesortcnt++;
}
}
void yax_preparedrawrooms(void)
{
if (rendmode!=0 || numyaxbunches==0)
return;
g_nodraw = 1;
Bmemset(yax_spritesortcnt, 0, sizeof(yax_spritesortcnt));
}
void yax_drawrooms(void (*ExtAnalyzeSprites)(void), int32_t horiz, int16_t sectnum)
{
static uint8_t havebunch[2][YAX_MAXBUNCHES>>3];
static int16_t bunches[2][YAX_MAXBUNCHES];
static uint8_t havebunch[YAX_MAXBUNCHES>>3];
static int16_t bunches[2][YAX_MAXBUNCHES], bestsec[2][YAX_MAXBUNCHES];
int32_t i, j, k, cf, diddraw = 0;
int32_t bnchcnt, bnchnum[2] = {0,0};
int16_t ourbunch[2] = {-1,-1};
int32_t i, j, k, lev, cf;
int32_t bnchcnt, bnchnum[2] = {0,0}, maxlev[2];
int16_t ourbunch[2] = {-1,-1}, osectnum=sectnum;
int32_t bnchbeg[YAX_MAXDRAWS][2], bnchend[YAX_MAXDRAWS][2];
int32_t bbeg, numhere;
static uint8_t allgotsector[MAXSECTORS>>3];
static int16_t opicnum[MAXSECTORS];
// original (1st-draw) and accumulated ('per-level') gotsector bitmaps
static uint8_t ogotsector[MAXSECTORS>>3], lgotsector[MAXSECTORS>>3];
// int32_t t;
if (rendmode == 4 || numyaxbunches==0)
if (rendmode!=0 || numyaxbunches==0)
{
#ifdef ENGINE_SCREENSHOT_DEBUG
engine_screenshot = 0;
#endif
return;
}
Bmemset(&havebunch[0], 0, (numsectors+7)>>3);
Bmemset(&havebunch[1], 0, (numsectors+7)>>3);
// if we're here, there was just a drawrooms() call with g_nodraw=1
Bmemcpy(ogotsector, gotsector, (numsectors+7)>>3);
if (sectnum >= 0)
yax_getbunches(sectnum, &ourbunch[0], &ourbunch[1]);
Bmemset(&havebunch, 0, (numyaxbunches+7)>>3);
for (i=0; i<numsectors; i++)
{
if (!(gotsector[i>>3]&(1<<(i&7))))
continue;
for (cf=0; cf<2; cf++)
{
j = yax_getbunch(i, cf);
if (j >= 0 && !(havebunch[cf][j>>3]&(1<<(j&7))))
{
havebunch[cf][j>>3] |= (1<<(j&7));
bunches[cf][bnchnum[cf]++] = j;
}
}
}
Bmemcpy(allgotsector, gotsector, (numsectors+7)>>3);
// first scan all bunches above, then all below...
for (cf=0; cf<2; cf++)
{
globalcf = cf;
yax_globalcf = cf;
qsort(bunches[cf], bnchnum[cf], sizeof(int16_t), (int(*)(const void *, const void *))&yax_cmpbunches);
for (bnchcnt=0; bnchcnt<bnchnum[cf]; bnchcnt++)
if (cf==1)
{
j = bunches[cf][bnchcnt]; // the actual bunchnum...
if (j==ourbunch[cf])
{
k = yax_getneighborsect(globalposx, globalposy, sectnum, cf, NULL);
if (k < 0)
continue;
}
else
{
scansector_retfast = 1;
for (k = headsectbunch[!cf][j]; k != -1; k = nextsectbunch[!cf][k])
{
numscans = numbunches = 0;
scansector(k);
if (numbunches > 0)
break;
}
scansector_retfast = 0;
if (k < 0)
continue;
}
// tweak picnums vvv
for (i=headsectbunch[cf][j]; i!=-1; i=nextsectbunch[cf][i])
{
if ((SECTORFLD(i,stat, cf)&(128+256))==0)
{
opicnum[i] = SECTORFLD(i,picnum, cf);
if (editstatus && showinvisibility)
SECTORFLD(i,picnum, cf) = MAXTILES-1;
else
SECTORFLD(i,picnum, cf) = 13; //FOF;
}
}
// if (allgotsector[k>>3]&(1<<(k&7)))
// continue;
drawrooms(globalposx,globalposy,globalposz,globalang,horiz,k+MAXSECTORS); // +MAXSECTORS: force
ExtAnalyzeSprites();
drawmasks();
for (i=0; i<(numsectors+7)>>3; i++)
allgotsector[i] |= gotsector[i];
diddraw = 1;
sectnum = osectnum;
Bmemcpy(gotsector, ogotsector, (numsectors+7)>>3);
}
}
if (diddraw)
{
drawrooms(globalposx,globalposy,globalposz,globalang,horiz,sectnum);
if (editstatus)
for (lev=0; /*lev<YAX_MAXDRAWS*/; lev++)
{
for (cf=0; cf<2; cf++)
for (bnchcnt=0; bnchcnt<bnchnum[cf]; bnchcnt++)
yax_globallev = YAX_MAXDRAWS + (-1 + 2*cf)*(lev+1);
bbeg = bnchbeg[lev][cf] = bnchend[lev][cf] = bnchnum[cf];
numhere = 0;
for (i=0; i<numsectors; i++)
{
if (!(gotsector[i>>3]&(1<<(i&7))))
continue;
j = yax_getbunch(i, cf);
if (j >= 0 && !(havebunch[j>>3]&(1<<(j&7))))
{
havebunch[j>>3] |= (1<<(j&7));
bunches[cf][bnchnum[cf]++] = j;
bnchend[lev][cf]++;
numhere++;
}
}
if (numhere > 0)
{
// found bunches -- need to fake-draw
if (numhere > 1 && lev != YAX_MAXDRAWS-1)
Bmemset(lgotsector, 0, (numsectors+7)>>3);
qsort(&bunches[cf][bbeg], numhere, sizeof(int16_t),
(int(*)(const void *, const void *))&yax_cmpbunches);
for (bnchcnt=bbeg; bnchcnt < bbeg+numhere; bnchcnt++)
{
j = bunches[cf][bnchcnt]; // the actual bunchnum...
// restore picnums ^^^
for (i=headsectbunch[cf][j]; i!=-1; i=nextsectbunch[cf][i])
if ((SECTORFLD(i,stat, cf)&(128+256))==0)
SECTORFLD(i,picnum, cf) = opicnum[i];
// t=getticks();
k = yax_getbestsector(j, cf, ourbunch, sectnum);
bestsec[cf][bnchcnt] = k;
if (k < 0)
{
// initprintf("cf %d, lev %d: skipped bunch %d\n", cf, lev, j);
continue;
}
if (ourbunch[cf]==j)
{
ourbunch[cf] = yax_getbunch(k, cf);
sectnum = k;
}
if (lev != YAX_MAXDRAWS-1)
{
// +MAXSECTORS: force
drawrooms(globalposx,globalposy,globalposz,globalang,horiz,k+MAXSECTORS);
if (numhere > 1)
for (i=0; i<(numsectors+7)>>3; i++)
lgotsector[i] |= gotsector[i];
// yaxdebug("cf %d, lev %d: fake-drawn sec %d (bunch %d), %d dspr, %2d ms",
// cf, lev, k, j, yax_spritesortcnt[yax_globallev], getticks()-t);
}
}
if (numhere > 1 && lev != YAX_MAXDRAWS-1)
Bmemcpy(gotsector, lgotsector, (numsectors+7)>>3);
}
if (numhere==0 || lev==YAX_MAXDRAWS-1)
{
// no new bunches or max level reached
maxlev[cf] = lev - (numhere==0);
break;
}
}
}
yax_globalcf = -1;
// now comes the real drawing!
g_nodraw = 0;
scansector_collectsprites = 0;
#if 0
begindrawing();
for (i=0; i<xdim*ydim; i++)
*((char *)frameplace + i) = i;
enddrawing();
#endif
for (cf=0; cf<2; cf++)
{
for (lev=maxlev[cf]; lev>=0; lev--)
{
yax_globallev = YAX_MAXDRAWS + (-1 + 2*cf)*(lev+1);
for (bnchcnt=bnchbeg[lev][cf]; bnchcnt<bnchend[lev][cf]; bnchcnt++)
{
j = bunches[cf][bnchcnt]; // the actual bunchnum...
k = bestsec[cf][bnchcnt]; // best start-drawing sector
// t=getticks();
yax_tweakpicnums(j, cf, 0);
if (k < 0)
continue;
drawrooms(globalposx,globalposy,globalposz,globalang,horiz,k+MAXSECTORS); // +MAXSECTORS: force
yax_copytsprite(j);
// yaxdebug("cf %d, lev %d: DRAWN sec %d (bunch %d), %d tspr, %2d ms",
// cf, lev, k, j, spritesortcnt, getticks()-t);
ExtAnalyzeSprites();
drawmasks();
}
if (lev < maxlev[cf])
for (bnchcnt=bnchbeg[lev+1][cf]; bnchcnt<bnchend[lev+1][cf]; bnchcnt++)
yax_tweakpicnums(bunches[cf][bnchcnt], cf, 1); // restore picnums
}
}
// t=getticks();
yax_globallev = YAX_MAXDRAWS;
// draw base level
drawrooms(globalposx,globalposy,globalposz,globalang,horiz,osectnum);
yax_copytsprite(-1);
scansector_collectsprites = 1;
for (cf=0; cf<2; cf++)
if (maxlev[cf] >= 0)
for (bnchcnt=bnchbeg[0][cf]; bnchcnt<bnchend[0][cf]; bnchcnt++)
yax_tweakpicnums(bunches[cf][bnchcnt], cf, 1); // restore picnums
// yaxdebug("DRAWN base level sec %d, %2d ms", osectnum, getticks()-t);
#ifdef ENGINE_SCREENSHOT_DEBUG
engine_screenshot = 0;
#endif
}
#undef YAX_BUNCHNUM
@ -1667,6 +1876,10 @@ static void scansector(int16_t sectnum)
int32_t xs, ys, x1, y1, x2, y2, xp1, yp1, xp2=0, yp2=0, tempint;
int16_t z, zz, startwall, endwall, numscansbefore, scanfirst, bunchfrst;
int16_t nextsectnum;
#ifdef YAX_ENABLE
int16_t cb, fb, *sortcnt;
int32_t spheight, spzofs;
#endif
if (sectnum < 0) return;
@ -1676,20 +1889,70 @@ static void scansector(int16_t sectnum)
do
{
sectnum = sectorborder[--sectorbordercnt];
#ifdef YAX_ENABLE
if (scansector_collectsprites)
#endif
for (z=headspritesect[sectnum]; z>=0; z=nextspritesect[z])
{
spr = &sprite[z];
if ((((spr->cstat&0x8000) == 0) || (showinvisibility)) &&
(spr->xrepeat > 0) && (spr->yrepeat > 0) &&
(spritesortcnt < MAXSPRITESONSCREEN))
(spr->xrepeat > 0) && (spr->yrepeat > 0))
{
xs = spr->x-globalposx; ys = spr->y-globalposy;
if ((spr->cstat&48) || (xs*cosglobalang+ys*singlobalang > 0))
{
copybufbyte(spr,&tsprite[spritesortcnt],sizeof(spritetype));
spriteext[z].tspr = (spritetype *)&tsprite[spritesortcnt];
tsprite[spritesortcnt++].owner = z;
#ifdef YAX_ENABLE
if (g_nodraw==0)
{
#endif
if (spritesortcnt >= MAXSPRITESONSCREEN)
break;
copybufbyte(spr,&tsprite[spritesortcnt],sizeof(spritetype));
spriteext[z].tspr = (spritetype *)&tsprite[spritesortcnt];
tsprite[spritesortcnt++].owner = z;
#ifdef YAX_ENABLE
}
else
{
sortcnt = &yax_spritesortcnt[yax_globallev];
if (*sortcnt >= MAXSPRITESONSCREEN)
break;
yax_tsprite[yax_globallev][*sortcnt] = z;
(*sortcnt)++;
// now check whether the tsprite needs duplication into another level
if ((spr->cstat&48)==32)
continue;
yax_getbunches(sectnum, &cb, &fb);
if (cb < 0 && fb < 0)
continue;
spriteheightofs(z, &spheight, &spzofs);
// TODO: get*zofslope?
if (cb>=0 && spr->z+spzofs-spheight < sector[sectnum].ceilingz)
{
sortcnt = &yax_spritesortcnt[yax_globallev-1];
if (*sortcnt < MAXSPRITESONSCREEN)
{
yax_tsprite[yax_globallev-1][*sortcnt] = z|MAXSPRITES;
(*sortcnt)++;
}
}
if (fb>=0 && spr->z+spzofs > sector[sectnum].floorz)
{
sortcnt = &yax_spritesortcnt[yax_globallev+1];
if (*sortcnt < MAXSPRITESONSCREEN)
{
yax_tsprite[yax_globallev+1][*sortcnt] = z|(MAXSPRITES<<1);
(*sortcnt)++;
}
}
}
#endif
}
}
}
@ -2863,7 +3126,10 @@ static void wallscan(int32_t x1, int32_t x2, int16_t *uwal, int16_t *dwal, int32
char bad;
int32_t i, u4, d4, z;
#endif
#ifdef YAX_ENABLE
if (g_nodraw)
return;
#endif
if (x2 >= xdim) x2 = xdim-1;
tsizx = tilesizx[globalpicnum];
@ -3605,23 +3871,28 @@ static void drawalls(int32_t bunch)
andwstat2 &= wallmost(dplc,z,sectnum,(uint8_t)1);
}
if ((andwstat1&3) != 3) //draw ceilings
#ifdef YAX_ENABLE
if (!g_nodraw)
#endif
{
if ((sec->ceilingstat&3) == 2)
grouscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,0);
else if ((sec->ceilingstat&1) == 0)
ceilscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum);
else
parascan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,0,bunch);
}
if ((andwstat2&12) != 12) //draw floors
{
if ((sec->floorstat&3) == 2)
grouscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,1);
else if ((sec->floorstat&1) == 0)
florscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum);
else
parascan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,1,bunch);
if ((andwstat1&3) != 3) //draw ceilings
{
if ((sec->ceilingstat&3) == 2)
grouscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,0);
else if ((sec->ceilingstat&1) == 0)
ceilscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum);
else
parascan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,0,bunch);
}
if ((andwstat2&12) != 12) //draw floors
{
if ((sec->floorstat&3) == 2)
grouscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,1);
else if ((sec->floorstat&1) == 0)
florscan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum);
else
parascan(xb1[bunchfirst[bunch]],xb2[bunchlast[bunch]],sectnum,1,bunch);
}
}
//DRAW WALLS SECTION!
@ -3929,7 +4200,8 @@ static void drawalls(int32_t bunch)
if (gotswall == 0) { gotswall = 1; prepwall(z,wal); }
wallscan(x1,x2,uplc,dplc,swall,lwall);
#ifdef YAX_ENABLE
if ((wal->cstat&YAX_NEXTWALLBIT(YAX_FLOOR)) && globalposz > sec->floorz)
// TODO: slopes?
if (globalposz > sec->floorz && (x = yax_getnextwall(wallnum, YAX_FLOOR)) >= 0 && wall[x].nextwall>=0)
{
for (x=x1; x<=x2; x++)
if (dplc[x] > umost[x] && umost[x] <= dmost[x])
@ -3938,7 +4210,7 @@ static void drawalls(int32_t bunch)
if (umost[x] > dmost[x]) numhits--;
}
}
else if ((wal->cstat&YAX_NEXTWALLBIT(YAX_CEILING)) && globalposz < sec->ceilingz)
else if (globalposz < sec->ceilingz && (x = yax_getnextwall(wallnum, YAX_CEILING)) >= 0 && wall[x].nextwall>=0)
{
for (x=x1; x<=x2; x++)
if (uplc[x] < dmost[x] && umost[x] <= dmost[x])
@ -3962,6 +4234,17 @@ static void drawalls(int32_t bunch)
if (nextsectnum < 0) searchstat = 0; else searchstat = 4;
}
}
#ifdef ENGINE_SCREENSHOT_DEBUG
if (engine_screenshot && !g_nodraw)
{
static char fn[BMAX_PATH];
Bsprintf(fn, "engshot%04d.png", engine_screenshot);
screencapture(fn, 0, "BUILD engine");
engine_screenshot++;
}
#endif
}
}
@ -7308,7 +7591,7 @@ void drawmasks(void)
}
else if ((tspriteptr[i]->cstat&48) == 0)
{
killsprite:
killsprite:
spritesortcnt--; //Delete face sprite if on wrong side!
if (i == spritesortcnt) continue;
tspriteptr[i] = tspriteptr[spritesortcnt];
@ -10113,15 +10396,15 @@ restart_grand:
return 0;
}
// 1st, 2nd, ... ceil/floor hit
// hitinfo->hitsect is >=0 because if oldhitsect's init and check above
if (SECTORFLD(hitinfo->hitsect,stat, hitscan_hitsectcf)&yax_waltosecmask(dawalclipmask))
return 0;
i = yax_getneighborsect(hitinfo->pos.x, hitinfo->pos.y, hitinfo->hitsect,
hitscan_hitsectcf, NULL);
if (i >= 0)
{
// 1st, 2nd, ... ceil/floor hit
// hitinfo->hitsect is >=0 because if oldhitsect's init and check above
// TODO: check against cstat
Bmemcpy(&newsv, &hitinfo->pos, sizeof(vec3_t));
sectnum = i;
sv = &newsv;
@ -11212,6 +11495,20 @@ void updatesectorz(int32_t x, int32_t y, int32_t z, int16_t *sectnum)
getzsofslope(*sectnum, x, y, &cz, &fz);
if ((z >= cz) && (z <= fz))
if (inside(x,y,*sectnum) != 0) return;
#ifdef YAX_ENABLE
if (z < cz)
{
i = yax_getneighborsect(x, y, *sectnum, YAX_CEILING, NULL);
if (i >= 0 && z >= getceilzofslope(i, x, y))
{ *sectnum = i; return; }
}
if (z > fz)
{
i = yax_getneighborsect(x, y, *sectnum, YAX_FLOOR, NULL);
if (i >= 0 && z <= getflorzofslope(i, x, y))
{ *sectnum = i; return; }
}
#endif
wal = &wall[sector[*sectnum].wallptr];
j = sector[*sectnum].wallnum;
@ -11220,6 +11517,7 @@ void updatesectorz(int32_t x, int32_t y, int32_t z, int16_t *sectnum)
i = wal->nextsector;
if (i >= 0)
{
// YAX: TODO: check neighboring sectors here too?
getzsofslope(i, x, y, &cz, &fz);
if ((z >= cz) && (z <= fz))
if (inside(x,y,(int16_t)i) == 1)
@ -11661,7 +11959,7 @@ restart_grand:
#ifdef YAX_ENABLE
if (numyaxbunches > 0)
{
int32_t dasecclipmask = (dawalclipmask&1)<<9; // blocking: walstat&1 --> secstat&512
int32_t dasecclipmask = yax_waltosecmask(dawalclipmask);
int16_t cb, fb, didchange;
yax_getbunches(sectnum, &cb, &fb);
@ -13417,11 +13715,16 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
if (!m32_sideview && (j >= 0) && (i > j)) return;
}
#ifdef YAX_ENABLE
#if 1
//def YAX_ENABLE
if ((graywallbitmap[i>>3] & (1<<(i&7))) || (j>=0 && (graywallbitmap[j>>3] & (1<<(j&7)))))
{
if (!m32_sideview)
#ifdef YAX_ENABLE
// yax'ed grayed out walls are always cleared from the overhead map.
// normal walls cleared out due to editorzrange are displayed, though
if (!m32_sideview && ((wall[i].cstat&YAX_NEXTWALLBITS) || (j>=0 && wall[j].cstat&YAX_NEXTWALLBITS)))
return;
#endif
col = 8;
}
else

4
polymer/eduke32/build/src/engine_priv.h
View file

@ -8,6 +8,10 @@
#define MAXNODESPERLINE 42 //Warning: This depends on MAXYSAVES & MAXYDIM!
#define MAXCLIPDIST 1024
#ifdef YAX_ENABLE
# define YAX_MAXDRAWS 4
#endif
extern uint8_t **basepaltableptr;
extern uint8_t basepalcount;
extern uint8_t curbasepal;

11
polymer/eduke32/build/src/sdlayer.c
View file

@ -1586,6 +1586,13 @@ int32_t handleevents(void)
}
else
{
#ifdef __linux
// The pause key generates a release event right after
// the pressing one on linux. As a result, it gets unseen
// by the game most of the time.
if (code == 0x59) // pause
break;
#endif
SetKey(code, 0);
if (keypresscallback)
keypresscallback(code, 0);
@ -1668,6 +1675,10 @@ int32_t handleevents(void)
}
else
{
#ifdef __linux
if (code == 0x59) // pause
break;
#endif
SetKey(code, 0);
if (keypresscallback)
keypresscallback(code, 0);

50
polymer/eduke32/samples/a.m32
View file

@ -115,6 +115,56 @@ defstate printlights
print "--ENDPRLIGHTS--"
ends
defstate insertlights
var sectnum
set k 0
for i activelights
{
insertsprite light[i].sector
// I is the inserted sprites' index now
set .picnum 1
set .x light[i].x
set .y light[i].y
set .z light[i].z
set .hitag light[i].range
set .xvel light[i].r
set .yvel light[i].g
set .zvel light[i].b
set .extra light[i].horiz
set .xoffset light[i].minshade
set .yoffset light[i].maxshade
set .owner light[i].tilenum
// now those that are calculated
ifge light[i].priority 4 or .cstat 512
ifge light[i].priority 2 or .cstat 2
ife light[i].radius 0
{
set .lotag 49
}
else
{
set .lotag 50
set j light[i].radius, shiftr j 1, sub j 128, inv j
clamp j -128 127
set .shade j
}
add k 1
}
qsprintf TQUOTE "* Inserted %d SE sprites based on active lights." k
print TQUOTE
ends
// convenient polymer SE light manipulation with keypad keys
// when aiming at light SE (49 or 50):
// KP 4,5,6,8: angle/horiz

7
polymer/eduke32/source/actors.c
View file

@ -409,7 +409,14 @@ int32_t A_MoveSprite(int32_t spritenum, const vec3_t *change, uint32_t cliptype)
&&
(osectnum == dasectnum || cansee(oldx, oldy, spr->z - bg, osectnum, spr->x, spr->y, daz - bg, dasectnum))*/
)
{
spr->z = daz;
#ifdef YAX_ENABLE
if (change->z && yax_getbunch(spr->sectnum, !!change->z)>=0)
if ((SECTORFLD(spr->sectnum,stat, !!change->z)&yax_waltosecmask(cliptype))==0)
setspritez(spritenum, (vec3_t *)spr);
#endif
}
else if (retval == 0) retval = 16384+dasectnum;
if (retval == (16384+dasectnum))

219
polymer/eduke32/source/astub.c
View file

@ -298,7 +298,8 @@ static void drawgradient(void)
static void message_common1(const char *tmpstr)
{
Bstrcpy(getmessage,tmpstr);
Bstrncpy(getmessage,tmpstr,sizeof(getmessage));
getmessage[sizeof(getmessage)-1] = 0;
getmessageleng = Bstrlen(getmessage);
getmessagetimeoff = totalclock + 120*2 + getmessageleng*(120/30);
@ -1011,8 +1012,8 @@ static uint64_t taglab_nolink_SEs = (1ull<<10)|(1ull<<27)|(1ull<<28)|(1ull<<29)|
// 16: yvel
// 32: zvel
// 64: owner
// The caller is responsible for checking bounds (usually tag>0), because
// this function is supposed to say something about the potential of a tag
// This function is only supposed to say something about the potential of a tag:
// it will also 'say yes' if a particular tag is zero.
int32_t taglab_linktags(int32_t spritep, int32_t num)
{
int32_t picnum;
@ -4360,12 +4361,13 @@ static void getnumberptr256(const char *namestart, void *num, int32_t bytes, int
if (handleevents())
quitevent = 0;
yax_preparedrawrooms();
drawrooms(pos.x,pos.y,pos.z,ang,horiz,cursectnum);
#ifdef YAX_ENABLE
yax_drawrooms(ExtAnalyzeSprites, horiz, cursectnum);
#endif
ExtAnalyzeSprites();
drawmasks();
#ifdef POLYMER
if (rendmode == 4 && searchit == 2)
{
@ -4569,12 +4571,14 @@ ENDFOR1:
if (PRESSED_KEYSC(PGDN))
sprite[linebegspr].pal -= (sprite[linebegspr].pal>0);
yax_preparedrawrooms();
drawrooms(pos.x,pos.y,pos.z,ang,horiz,cursectnum);
#ifdef YAX_ENABLE
yax_drawrooms(ExtAnalyzeSprites, horiz, cursectnum);
#endif
ExtAnalyzeSprites();
drawmasks();
#ifdef POLYMER
if (rendmode == 4 && searchit == 2)
{
@ -4830,6 +4834,16 @@ static void mouseaction_movesprites(int32_t *sumxvect, int32_t *sumyvect, int32_
}
}
static int32_t addtobyte(int8_t *byte, int32_t num)
{
int32_t onum = *byte, clamped=0;
if (onum + num != (int8_t)(onum + num))
clamped = 1;
if (!clamped)
*byte = (onum + num);
return clamped;
}
static void Keys3d(void)
{
int32_t i = 0, changedir,tsign; // ,count,nexti
@ -5200,19 +5214,22 @@ static void Keys3d(void)
ShowFileText("sthelp.hlp", 1);
}
// . Search & fix panning to the right (3D)
if (AIMING_AT_WALL_OR_MASK && PRESSED_KEYSC(PERIOD))
{
int32_t naligned=AutoAlignWalls(searchwall, eitherCTRL, 0);
message("Auto-aligned %d wall%s%s based on wall %d", naligned,
naligned==1?"":"s", eitherCTRL?" recursively":"", searchwall);
int32_t naligned=AutoAlignWalls(searchwall, eitherCTRL|((!eitherSHIFT)<<1)|eitherALT<<2, 0);
message("Aligned %d wall%s based on wall %d%s%s%s", naligned,
naligned==1?"":"s", searchwall,
eitherCTRL?", recursing nextwalls":"",
!eitherSHIFT?", iterating point2s":"",
eitherALT?", aligning xrepeats":"");
}
tsign = 0;
tsign -= PRESSED_KEYSC(COMMA);
tsign += PRESSED_KEYSC(PERIOD);
if (tsign) // , . Search & fix panning to the left/right (3D)
if (tsign)
{
if (AIMING_AT_SPRITE)
{
@ -5426,18 +5443,29 @@ static void Keys3d(void)
message("Sprite %d hitscan sensitivity bit %s", searchwall, ONOFF(sprite[searchwall].cstat&256));
asksave = 1;
}
else
else if (AIMING_AT_WALL_OR_MASK || AIMING_AT_CEILING_OR_FLOOR)
{
wall[searchwall].cstat ^= 64;
if (wall[searchwall].nextwall >= 0 && !eitherSHIFT)
#ifdef YAX_ENABLE
if (AIMING_AT_CEILING_OR_FLOOR && yax_getbunch(searchsector, AIMING_AT_FLOOR)>=0)
{
NEXTWALL(searchwall).cstat &= ~64;
NEXTWALL(searchwall).cstat |= (wall[searchwall].cstat&64);
SECTORFLD(searchsector,stat, AIMING_AT_FLOOR) ^= 2048;
message("Sector %d's %s hitscan sensitivity bit %s", searchsector, typestr[searchstat],
ONOFF(SECTORFLD(searchsector,stat, AIMING_AT_FLOOR)&2048));
asksave = 1;
}
message("Wall %d hitscan sensitivity bit %s", searchwall, ONOFF(wall[searchwall].cstat&64));
else
#endif
{
wall[searchwall].cstat ^= 64;
asksave = 1;
if (wall[searchwall].nextwall >= 0 && !eitherSHIFT)
{
NEXTWALL(searchwall).cstat &= ~64;
NEXTWALL(searchwall).cstat |= (wall[searchwall].cstat&64);
}
message("Wall %d hitscan sensitivity bit %s", searchwall, ONOFF(wall[searchwall].cstat&64));
asksave = 1;
}
}
}
}
@ -5524,6 +5552,8 @@ static void Keys3d(void)
}
else // if !eitherALT
{
int32_t clamped=0;
k = (highlightsectorcnt>0 && (hlsectorbitmap[searchsector>>3]&(1<<(searchsector&7))));
tsign *= (1+3*eitherCTRL);
@ -5531,8 +5561,9 @@ static void Keys3d(void)
{
if (ASSERT_AIMING)
{
AIMED_CF_SEL(shade) += tsign;
message("%s %d shade %d", Typestr[searchstat], i, AIMED_CF_SEL(shade));
clamped = addtobyte(&AIMED_CF_SEL(shade), tsign);
message("%s %d shade %d%s", Typestr[searchstat], i, AIMED_CF_SEL(shade),
clamped ? " (clamped)":"");
}
}
else
@ -5542,18 +5573,19 @@ static void Keys3d(void)
dasector = highlightsector[i];
// sector shade
sector[dasector].ceilingshade += tsign;
sector[dasector].floorshade += tsign;
clamped |= addtobyte(&sector[dasector].ceilingshade, tsign);
clamped |= addtobyte(&sector[dasector].floorshade, tsign);
// wall shade
for (WALLS_OF_SECTOR(dasector, j))
wall[j].shade += tsign;
clamped |= addtobyte(&wall[j].shade, tsign);
// sprite shade
for (j=headspritesect[dasector]; j!=-1; j=nextspritesect[j])
sprite[j].shade += tsign;
clamped |= addtobyte(&sprite[j].shade, tsign);
}
message("Highlighted sector shade changed by %d", tsign);
message("Highlighted sector shade changed by %d%s", tsign,
clamped?" (some objects' shade clamped)":"");
}
asksave = 1;
}
@ -5826,44 +5858,41 @@ static void Keys3d(void)
}
else
{
k = 0;
if (highlightcnt > 0)
for (i=0; i<highlightcnt; i++)
if (highlight[i] == searchwall+16384)
k = !!(show2dsprite[searchwall>>3]&(1<<(searchwall&7)));
tsign *= (updownunits << ((eitherCTRL && mouseaction)*3));
for (i=0; i<highlightcnt || k==0; i++)
{
if (k==0 || (highlight[i]&0xc000) == 16384)
{
int16_t sp = k==0 ? searchwall : highlight[i]&16383;
sprite[sp].z += tsign;
if (!spnoclip)
{
k = 1;
spriteoncfz(sp, &cz, &fz);
inpclamp(&sprite[sp].z, cz, fz);
}
#ifdef YAX_ENABLE
else if (sprite[sp].sectnum >= 0)
{
int16_t cb, fb;
yax_getbunches(sprite[sp].sectnum, &cb, &fb);
if (cb >= 0 || fb >= 0)
setspritez(sp, (vec3_t *)&sprite[sp]);
}
#endif
if (k==0)
{
silentmessage("Sprite %d z = %d", searchwall, sprite[searchwall].z);
break;
}
if (k == 0)
{
sprite[searchwall].z += tsign * (updownunits << ((eitherCTRL && mouseaction)*3));
if (!spnoclip)
{
spriteoncfz(searchwall, &cz, &fz);
inpclamp(&sprite[searchwall].z, cz, fz);
}
silentmessage("Sprite %d z = %d", searchwall, sprite[searchwall].z);
}
else
{
for (i=0; i<highlightcnt; i++)
if ((highlight[i]&0xc000) == 16384)
{
int16_t sp = highlight[i]&16383;
sprite[sp].z += tsign * updownunits;
if (!spnoclip)
{
spriteoncfz(searchwall, &cz, &fz);
inpclamp(&sprite[searchwall].z, cz, fz);
}
}
silentmessage("Sprites %s by %d units", tsign<0 ? "raised" : "lowered", updownunits);
if (k==1)
silentmessage("Sprites %s by %d units", tsign<0 ? "raised" : "lowered", tsign);
}
}
}
@ -6431,8 +6460,6 @@ static void Keys3d(void)
#endif
{
int32_t newslope = clamp(AIMED_CEILINGFLOOR(heinum) + tsign*i, -BHEINUM_MAX, BHEINUM_MAX);
if (!(AIMED_CEILINGFLOOR(stat)&2))
AIMED_CEILINGFLOOR(heinum) = 0;
setslope(searchsector, AIMING_AT_FLOOR, newslope);
#ifdef YAX_ENABLE
@ -6813,7 +6840,7 @@ static void Keys3d(void)
tempxrepeat = max(1, tempxrepeat);
tempyrepeat = AIMED_SEL_WALL(yrepeat);
tempcstat = AIMED_SEL_WALL(cstat) & ~YAX_NEXTWALLBITS;
templenrepquot = divscale12(wallength(searchwall), tempxrepeat);
templenrepquot = getlenbyrep(wallength(searchwall), tempxrepeat);
}
else if (AIMING_AT_CEILING_OR_FLOOR)
{
@ -7209,12 +7236,11 @@ paste_ceiling_or_floor:
AIMED_CEILINGFLOOR(heinum) = 0;
#ifdef YAX_ENABLE
if (j >= 0)
for (i=0; i<numsectors; i++)
if (yax_getbunch(i, !AIMING_AT_FLOOR) == j)
{
SECTORFLD(i,stat, !AIMING_AT_FLOOR) &= ~2;
SECTORFLD(i,heinum, !AIMING_AT_FLOOR) = 0;
}
for (i=headsectbunch[!AIMING_AT_FLOOR][j]; i != -1; i=nextsectbunch[!AIMING_AT_FLOOR][i])
{
SECTORFLD(i,stat, !AIMING_AT_FLOOR) &= ~2;
SECTORFLD(i,heinum, !AIMING_AT_FLOOR) = 0;
}
#endif
}
else if (AIMING_AT_SPRITE)
@ -7491,7 +7517,7 @@ static void Keys2d(void)
#ifdef YAX_ENABLE
if (/*!m32_sideview &&*/ numyaxbunches>0)
{
int32_t zsign=0, bestzdiff=INT32_MAX, hiz=0, loz=0, bottomp=0;
int32_t zsign=0;
if (PRESSED_KEYSC(PGDN) || (eitherCTRL && PRESSED_KEYSC(DOWN)))
zsign = 1;
@ -7500,9 +7526,11 @@ static void Keys2d(void)
if (zsign)
{
int32_t bestzdiff=INT32_MAX, hiz=0, loz=0, bottomp=0;
for (i=0; i<numsectors; i++)
{
if (yax_getbunch(i, YAX_FLOOR) < 0)
if (yax_getbunch(i, YAX_FLOOR) < 0 /*&& yax_getbunch(i, YAX_CEILING) < 0*/)
continue;
loz = min(loz, sector[i].floorz);
@ -7522,18 +7550,46 @@ static void Keys2d(void)
bestzdiff = pos.z - loz;
}
if (bestzdiff != INT32_MAX)
{
pos.z += zsign*bestzdiff;
yax_updategrays(pos.z);
pos.z += zsign*bestzdiff;
yax_updategrays(pos.z);
printmessage16("Z position: %d%s", pos.z,
bottomp ? " (bottom)":(pos.z==loz ? " (top)":""));
}
printmessage16("Z position: %d%s", pos.z,
bottomp ? " (bottom)":(pos.z==loz ? " (top)":""));
updatesectorz(pos.x, pos.y, pos.z, &cursectnum);
}
}
#endif
// Ctrl-R set editor z range to hightlightsectors' c/f bounds
if (eitherCTRL && PRESSED_KEYSC(R))
{
if (highlightsectorcnt <= 0)
{
editorzrange[0] = INT32_MIN;
editorzrange[1] = INT32_MAX;
printmessage16("Reset Z range");
}
else
{
int32_t damin=INT_MAX, damax=INT_MIN;
for (i=0; i<highlightsectorcnt; i++)
{
damin = min(damin, sector[highlightsector[i]].ceilingz);
damax = max(damax, sector[highlightsector[i]].floorz);
}
if (damin < damax)
{
editorzrange[0] = damin;
editorzrange[1] = damax;
printmessage16("Set Z range to highlighted sector bounds (%d..%d)",
editorzrange[0], editorzrange[1]);
}
}
yax_updategrays(pos.z);
}
#if 0
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(Z)) // ' z
{
@ -10873,9 +10929,14 @@ void ExtCheckKeys(void)
if (PRESSED_KEYSC(F12)) //F12
{
#ifdef ENGINE_SCREENSHOT_DEBUG
extern int32_t engine_screenshot;
engine_screenshot = 1;
#else
Bsprintf(tempbuf, "Mapster32 %s", ExtGetVer());
screencapture("captxxxx.tga", keystatus[KEYSC_LSHIFT]|keystatus[KEYSC_RSHIFT], tempbuf);
screencapture("captxxxx.tga", eitherSHIFT, tempbuf);
message("Saved screenshot %04d", capturecount-1);
#endif
}
}

25
polymer/eduke32/source/game.c
View file

@ -3212,8 +3212,8 @@ void G_SE40(int32_t smoothratio)
}
}
#ifdef YAX_ENABLE
static int32_t g_yax_smoothratio;
#ifdef YAX_ENABLE
static void G_AnalyzeSprites(void)
{
G_DoSpriteAnimations(ud.camera.x,ud.camera.y,ud.cameraang,g_yax_smoothratio);
@ -3277,11 +3277,11 @@ void G_DrawRooms(int32_t snum, int32_t smoothratio)
if (getrendermode() == 4)
polymer_setanimatesprites(G_DoSpriteAnimations, s->x, s->y, ud.cameraang, smoothratio);
#endif
yax_preparedrawrooms();
drawrooms(s->x,s->y,s->z-(4<<8),ud.cameraang,s->yvel,s->sectnum);
g_yax_smoothratio = smoothratio;
yax_drawrooms(G_AnalyzeSprites, s->yvel, s->sectnum);
G_DoSpriteAnimations(s->x,s->y,ud.cameraang,smoothratio);
drawmasks();
}
else
@ -3418,8 +3418,14 @@ void G_DrawRooms(int32_t snum, int32_t smoothratio)
if (ud.camerasect >= 0)
{
getzsofslope(ud.camerasect,ud.camera.x,ud.camera.y,&cz,&fz);
if (ud.camera.z < cz+(4<<8)) ud.camera.z = cz+(4<<8);
if (ud.camera.z > fz-(4<<8)) ud.camera.z = fz-(4<<8);
#ifdef YAX_ENABLE
if (yax_getbunch(ud.camerasect, YAX_CEILING) < 0)
#endif
if (ud.camera.z < cz+(4<<8)) ud.camera.z = cz+(4<<8);
#ifdef YAX_ENABLE
if (yax_getbunch(ud.camerasect, YAX_FLOOR) < 0)
#endif
if (ud.camera.z > fz-(4<<8)) ud.camera.z = fz-(4<<8);
}
if (ud.camerahoriz > HORIZ_MAX) ud.camerahoriz = HORIZ_MAX;
@ -3470,11 +3476,11 @@ void G_DrawRooms(int32_t snum, int32_t smoothratio)
polymer_setanimatesprites(G_DoSpriteAnimations, ud.camera.x,ud.camera.y,ud.cameraang,smoothratio);
#endif
yax_preparedrawrooms();
drawrooms(ud.camera.x,ud.camera.y,ud.camera.z,ud.cameraang,ud.camerahoriz,ud.camerasect);
#ifdef YAX_ENABLE
g_yax_smoothratio = smoothratio;
yax_drawrooms(G_AnalyzeSprites, ud.camerahoriz, ud.camerasect);
#endif
// dupe the sprites touching the portal to the other sector
if (ror_sprite != -1)
@ -7242,7 +7248,8 @@ void G_HandleLocalKeys(void)
switch (ud.recstat)
{
case 0:
G_OpenDemoWrite();
if (SHIFTS_IS_PRESSED)
G_OpenDemoWrite();
break;
case 1:
G_CloseDemoWrite();

28
polymer/eduke32/source/gameexec.c
View file

@ -310,7 +310,9 @@ void A_Fall(int32_t iActor)
{
spritetype *s = &sprite[iActor];
int32_t hz,lz,c = g_spriteGravity;
#ifdef YAX_ENABLE
int16_t fbunch;
#endif
if (G_CheckForSpaceFloor(s->sectnum))
c = 0;
else
@ -334,12 +336,27 @@ void A_Fall(int32_t iActor)
actor[iActor].floorz = sector[s->sectnum].floorz;
}
if (s->z < actor[iActor].floorz-(ZOFFSET))
#ifdef YAX_ENABLE
if (sector[s->sectnum].floorstat&512)
fbunch = -1;
else
fbunch = yax_getbunch(s->sectnum, YAX_FLOOR);
#endif
if (s->z < actor[iActor].floorz-(ZOFFSET)
#ifdef YAX_ENABLE
|| (fbunch >= 0)
#endif
)
{
if (sector[s->sectnum].lotag == 2 && s->zvel > 3122)
s->zvel = 3144;
s->z += s->zvel = min(6144, s->zvel+c);
}
#ifdef YAX_ENABLE
if (fbunch >= 0)
setspritez(iActor, (vec3_t *)s);
if (fbunch < 0)
#endif
if (s->z >= actor[iActor].floorz-(ZOFFSET))
{
s->z = actor[iActor].floorz - ZOFFSET;
@ -1106,7 +1123,12 @@ skip_check:
if (vm.g_sp->z < (actor[vm.g_i].floorz-ZOFFSET))
{
vm.g_sp->z += vm.g_sp->zvel = min(6144, vm.g_sp->zvel+j);
#ifdef YAX_ENABLE
j = yax_getbunch(vm.g_sp->sectnum, YAX_FLOOR);
if (j >= 0 && (sector[vm.g_sp->sectnum].floorstat&512)==0)
setspritez(vm.g_i, (vec3_t *)vm.g_sp);
else
#endif
if (vm.g_sp->z > (actor[vm.g_i].floorz - ZOFFSET))
vm.g_sp->z = (actor[vm.g_i].floorz - ZOFFSET);
continue;

140
polymer/eduke32/source/m32def.c
View file

@ -189,16 +189,6 @@ const char *keyw[] =
"jump",
"{",
"}",
#if 0
"setsector",
"getsector",
"setwall",
"getwall",
"setsprite",
"getsprite",
"gettspr",
"settspr",
#endif
"gamearray",
"setarray",
"getarraysize",
@ -503,7 +493,29 @@ const memberlabel_t SpriteLabels[]=
{ "extra", SPRITE_EXTRA, 0, 0, 0 },
// aliases
{ "filler", SPRITE_DETAIL, 1, 0, 0 },
{ "", -1, 0, 0, 0 } // END OF LIST
};
const memberlabel_t LightLabels[]=
{
{ "x", LIGHT_X, 0, -BXY_MAX, BXY_MAX },
{ "y", LIGHT_Y, 0, -BXY_MAX, BXY_MAX },
{ "z", LIGHT_Z, 0, 0, 0 },
{ "horiz", LIGHT_HORIZ, 0, 0, 0 },
{ "range", LIGHT_RANGE, 0, 0, 0 },
{ "angle", LIGHT_ANGLE, 0, 0, 0 },
{ "faderadius", LIGHT_FADERADIUS, 0, 0, 0 },
{ "radius", LIGHT_RADIUS, 0, 0, 0 },
{ "sector", LIGHT_SECTOR, 0, 0, 0 },
{ "r", LIGHT_R, 0, 0, 255 },
{ "g", LIGHT_G, 0, 0, 255 },
{ "b", LIGHT_B, 0, 0, 255 },
{ "priority", LIGHT_PRIORITY, 0, 0, PR_MAXLIGHTPRIORITY-1 },
{ "tilenum", LIGHT_TILENUM, 0, 0, MAXTILES-1 },
{ "minshade", LIGHT_MINSHADE, 0, -128, 127 },
{ "maxshade", LIGHT_MAXSHADE, 0, -128, 127 },
//
{ "active", LIGHT_ACTIVE, 0, 0, 1 },
{ "", -1, 0, 0, 0 } // END OF LIST
};
@ -512,6 +524,7 @@ const tokenmap_t iter_tokens[] =
{ "allsprites", ITER_ALLSPRITES },
{ "allsectors", ITER_ALLSECTORS },
{ "allwalls", ITER_ALLWALLS },
{ "activelights", ITER_ACTIVELIGHTS },
{ "selsprites", ITER_SELSPRITES },
{ "selsectors", ITER_SELSECTORS },
{ "selwalls", ITER_SELWALLS },
@ -523,6 +536,7 @@ const tokenmap_t iter_tokens[] =
// vvv alternatives go here vvv
{ "selspr", ITER_SELSPRITES },
{ "selsec", ITER_SELSECTORS },
{ "lights", ITER_ACTIVELIGHTS },
{ "sprofsec", ITER_SPRITESOFSECTOR },
{ "walofsec", ITER_WALLSOFSECTOR },
{ "", -1 } // END OF LIST
@ -541,6 +555,7 @@ static hashtable_t h_iter = { ITER_END, NULL };
static hashtable_t h_sector = { SECTOR_END>>1, NULL };
static hashtable_t h_wall = { WALL_END>>1, NULL };
static hashtable_t h_sprite = { SPRITE_END>>1, NULL };
static hashtable_t h_light = { SPRITE_END>>1, NULL };
static void C_InitHashes()
@ -574,6 +589,10 @@ static void C_InitHashes()
hash_add(&h_sprite,SpriteLabels[i].name,i, 0);
// hash_add(&h_sprite,"filler", SPRITE_DETAIL, 0);
hash_init(&h_light);
for (i=0; LightLabels[i].lId >=0; i++)
hash_add(&h_light,LightLabels[i].name,i, 0);
hash_init(&h_iter);
for (i=0; iter_tokens[i].val >=0; i++)
hash_add(&h_iter, iter_tokens[i].token, iter_tokens[i].val, 0);
@ -926,7 +945,7 @@ static int32_t parse_integer_literal(int32_t *num)
{
long lnum;
errno = 0;
lnum = strtol(textptr, NULL, 10);
lnum = Bstrtol(textptr, NULL, 10);
if (errno || (sizeof(long)>4 && (lnum<INT_MIN || lnum>INT_MAX)))
{
C_CUSTOMERROR("integer literal exceeds bitwidth.");
@ -1084,6 +1103,9 @@ static void C_GetNextVarType(int32_t type)
if (*textptr == '[') //read of array as a gamevar
{
int32_t lLabelID = -1, aridx;
#ifdef POLYMER
int32_t lightp = 0;
#endif
textptr++;
flags |= M32_FLAG_ARRAY;
@ -1100,12 +1122,18 @@ static void C_GetNextVarType(int32_t type)
{
id = GetGamevarID(tlabel, 0);
if (id < 0 || id >= 4)
if (id < 0 || id >= 5)
{
C_CUSTOMERROR("symbol `%s' is neither an array name nor one of `(t)sprite', `sector' or `wall'.", tlabel);
C_CUSTOMERROR("symbol `%s' is neither an array name nor one of `(t)sprite', `sector', `wall' or `light'.", tlabel);
return;
}
if (id==4)
{
id = 3; // smuggle lights into tspr
lightp = 1;
}
flags &= ~M32_FLAG_ARRAY; // not an array
flags |= M32_FLAG_STRUCT;
}
@ -1175,7 +1203,9 @@ static void C_GetNextVarType(int32_t type)
if (*textptr != '.')
{
static const char *types[4] = {"sprite","sector","wall","tsprite"};
const char *types[4] = {"sprite","sector","wall","tsprite"};
if (lightp)
types[3] = "light";
C_CUSTOMERROR("syntax error. Expected `.<label>' after `%s[...]'", types[id&3]);
return;
}
@ -1186,7 +1216,9 @@ static void C_GetNextVarType(int32_t type)
C_GetNextLabelName(0);
/*initprintf("found xxx label of '%s'\n", label+(g_numLabels*MAXLABELLEN));*/
if (id==M32_SPRITE_VAR_ID || id==M32_TSPRITE_VAR_ID)
if (lightp)
lLabelID = C_GetLabelNameID(LightLabels, &h_light, Bstrtolower(tlabel));
else if (id==M32_SPRITE_VAR_ID || id==M32_TSPRITE_VAR_ID)
lLabelID = C_GetLabelNameID(SpriteLabels, &h_sprite, Bstrtolower(tlabel));
else if (id==M32_SECTOR_VAR_ID)
lLabelID = C_GetLabelNameID(SectorLabels, &h_sector, Bstrtolower(tlabel));
@ -2413,84 +2445,6 @@ repeatcase:
return 1;
// *** more basic commands
#if 0
case CON_SETSECTOR:
case CON_GETSECTOR:
case CON_SETWALL:
case CON_GETWALL:
case CON_SETSPRITE:
case CON_GETSPRITE:
case CON_SETTSPR:
case CON_GETTSPR:
{
int32_t lLabelID;
// syntax getsector[<var>].x <VAR>
// gets the value of sector[<var>].xxx into <VAR>
if ((tw==CON_GETTSPR || tw==CON_SETTSPR) && cs.currentEvent != EVENT_ANALYZESPRITES)
{
C_ReportError(WARNING_OUTSIDEDRAWSPRITE);
g_numCompilerWarnings++;
}
// now get name of .xxx
while (*textptr != '[')
textptr++;
if (*textptr == '[')
textptr++;
// get the ID of the DEF
cs.labelsOnly = 1;
C_GetNextVar();
cs.labelsOnly = 0;
// now get name of .xxx
while (*textptr != '.')
{
if (!*textptr || *textptr == 0xa)
break;
textptr++;
}
if (*textptr!='.')
{
C_CUSTOMERROR("syntax error. Expected `.<label>' after `%s[...]'", keyw[tw]);
return 0;
}
textptr++;
/// now pointing at 'xxx'
C_GetNextLabelName(0);
//printf("found xxx label of '%s'\n", label+(g_numLabels*MAXLABELLEN));
if (tw==CON_GETSECTOR || tw==CON_SETSECTOR)
lLabelID = C_GetLabelNameID(SectorLabels, &h_sector, Bstrtolower(tlabel));
else if (tw==CON_GETWALL || tw==CON_SETWALL)
lLabelID = C_GetLabelNameID(WallLabels, &h_wall, Bstrtolower(tlabel));
else // if (tw==CON_GETSPRITE || tw==CON_SETSPRITE || tw==CON_GETTSPR || tw==CON_SETTSPR)
lLabelID = C_GetLabelNameID(SpriteLabels, &h_sprite, Bstrtolower(tlabel));
if (lLabelID == -1)
{
g_numCompilerErrors++;
C_ReportError(ERROR_SYMBOLNOTRECOGNIZED);
return 0;
}
*g_scriptPtr++ = lLabelID;
// now at target VAR...
// get the ID of the DEF
if (tw==CON_GETSECTOR || tw==CON_GETWALL || tw==CON_GETSPRITE || tw==CON_GETTSPR)
C_GetNextVarType(GV_WRITABLE);
else
C_GetNextVar();
break;
}
#endif
case CON_GAMEVAR:
// syntax: gamevar <var1> <initial value> <flags>

31
polymer/eduke32/source/m32def.h
View file

@ -79,6 +79,7 @@ typedef struct
extern const memberlabel_t SectorLabels[];
extern const memberlabel_t WallLabels[];
extern const memberlabel_t SpriteLabels[];
extern const memberlabel_t LightLabels[];
typedef struct {
@ -202,29 +203,48 @@ enum WallLabel_t
enum SpriteLabel_t
{
SPRITE_X,
SPRITE_X, // 0
SPRITE_Y,
SPRITE_Z,
SPRITE_CSTAT,
SPRITE_PICNUM,
SPRITE_SHADE,
SPRITE_SHADE, // 5
SPRITE_PAL,
SPRITE_CLIPDIST,
SPRITE_DETAIL,
SPRITE_XREPEAT,
SPRITE_YREPEAT,
SPRITE_YREPEAT, // 10
SPRITE_XOFFSET,
SPRITE_YOFFSET,
SPRITE_SECTNUM,
SPRITE_STATNUM,
SPRITE_ANG,
SPRITE_ANG, // 15
SPRITE_OWNER,
SPRITE_XVEL,
SPRITE_YVEL,
SPRITE_ZVEL,
SPRITE_LOTAG,
SPRITE_LOTAG, // 20
SPRITE_HITAG,
SPRITE_EXTRA,
LIGHT_X, // must be first here
LIGHT_Y,
LIGHT_Z, // 25
LIGHT_HORIZ,
LIGHT_RANGE,
LIGHT_ANGLE,
LIGHT_FADERADIUS,
LIGHT_RADIUS, // 30
LIGHT_SECTOR,
LIGHT_R,
LIGHT_G,
LIGHT_B,
LIGHT_PRIORITY, // 35
LIGHT_TILENUM,
LIGHT_MINSHADE,
LIGHT_MAXSHADE,
LIGHT_ACTIVE,
SPRITE_END
};
@ -233,6 +253,7 @@ enum IterationTypes_t
ITER_ALLSPRITES,
ITER_ALLSECTORS,
ITER_ALLWALLS,
ITER_ACTIVELIGHTS,
ITER_SELSPRITES,
ITER_SELSECTORS,
ITER_SELWALLS,

224
polymer/eduke32/source/m32exec.c
View file

@ -261,46 +261,40 @@ static int32_t X_DoSort(const int32_t *lv, const int32_t *rv)
if ((vm.g_i < 0 || vm.g_i>=MAXSPRITES) && \
(vm.g_st!=0 || searchstat!=3 || (vm.g_i=searchwall, vm.g_sp=&sprite[vm.g_i], 0))) \
{ \
M32_PRINTERROR("Current sprite index invalid!"); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Current sprite index invalid!"); \
continue; \
}
#define X_ERROR_INVALIDSPRI(dasprite) \
if (dasprite < 0 || dasprite>=MAXSPRITES) \
{ \
M32_PRINTERROR("Invalid sprite index %d!", dasprite); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Invalid sprite index %d!", dasprite); \
continue; \
}
#define X_ERROR_INVALIDSECT(dasect) \
if (dasect < 0 || dasect>=numsectors) \
{ \
M32_PRINTERROR("Invalid sector index %d!", dasect); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Invalid sector index %d!", dasect); \
continue; \
}
#define X_ERROR_INVALIDSP() \
if (!vm.g_sp && (vm.g_st!=0 || searchstat!=3 || (vm.g_sp=&sprite[searchwall], 0))) \
{ \
M32_PRINTERROR("Current sprite invalid!"); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Current sprite invalid!"); \
continue; \
}
#define X_ERROR_INVALIDQUOTE(q, array) \
if (q<0 || q>=MAXQUOTES) \
{ \
M32_PRINTERROR("Invalid quote number %d!", q); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Invalid quote number %d!", q); \
continue; \
} \
else if (array[q] == NULL) \
{ \
M32_PRINTERROR("Null quote %d!", q); \
vm.flags |= VMFLAG_ERROR; \
M32_ERROR("Null quote %d!", q); \
continue; \
} \
@ -479,8 +473,7 @@ skip_check:
int32_t j = Gv_GetVarX(*insptr++);
if (j<0 || j>=(g_scriptPtr-script))
{
M32_PRINTERROR("script index out of bounds (%d)", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("script index out of bounds (%d)", j);
continue;
}
insptr = (instype *)(j+script);
@ -495,72 +488,6 @@ skip_check:
VM_Execute(0);
continue;
#if 0
// *** more basic commands
case CON_SETSECTOR:
case CON_GETSECTOR:
insptr++;
{
// syntax [gs]etsector[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_AccessSector((tw==CON_SETSECTOR)|2, lVar1, lLabelID, lVar2);
continue;
}
case CON_SETWALL:
case CON_GETWALL:
insptr++;
{
// syntax [gs]etwall[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_AccessWall((tw==CON_SETWALL)|2, lVar1, lLabelID, lVar2);
continue;
}
case CON_SETSPRITE:
case CON_GETSPRITE:
insptr++;
{
// syntax [gs]etsprite[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_AccessSprite((tw==CON_SETSPRITE)|2, lVar1, lLabelID, lVar2);
continue;
}
case CON_SETTSPR:
case CON_GETTSPR:
insptr++;
{
// syntax [gs]ettspr[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_AccessTsprite((tw==CON_SETTSPR)|2|4, lVar1, lLabelID, lVar2);
continue;
}
case CON_SETSPRITE:
insptr++;
{
// syntax [gs]etsprite[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_SetSprite(lVar1, lLabelID, lVar2);
continue;
}
case CON_GETSPRITE:
insptr++;
{
// syntax [gs]etsprite[<var>].x <VAR>
// <varid> <xxxid> <varid>
int32_t lVar1=*insptr++, lLabelID=*insptr++, lVar2=*insptr++;
VM_GetSprite(lVar1, lLabelID, lVar2);
continue;
}
#endif
// *** arrays
case CON_SETARRAY:
insptr++;
@ -571,18 +498,15 @@ skip_check:
if (j<0 || j >= g_gameArrayCount)
{
M32_PRINTERROR("Tried to set invalid array ID (%d)", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Tried to set invalid array ID (%d)", j);
}
if (aGameArrays[j].dwFlags & GAMEARRAY_READONLY)
{
M32_PRINTERROR("Tried to set on read-only array `%s'", aGameArrays[j].szLabel);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Tried to set on read-only array `%s'", aGameArrays[j].szLabel);
}
if (index >= aGameArrays[j].size || index < 0)
{
M32_PRINTERROR("Array index %d out of bounds", index);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Array index %d out of bounds", index);
}
if (vm.flags&VMFLAG_ERROR) continue;
((int32_t *)aGameArrays[j].vals)[index]=value; // REM: other array types not implemented, since they're read-only
@ -606,8 +530,7 @@ skip_check:
if (asize<=0 || asize>65536)
{
M32_PRINTERROR("Invalid array size %d (must be between 1 and 65536)", asize);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid array size %d (must be between 1 and 65536)", asize);
continue;
}
@ -616,8 +539,7 @@ skip_check:
if (aGameArrays[j].vals == NULL)
{
aGameArrays[j].size = 0;
M32_PRINTERROR("Out of memory!");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Out of memory!");
return 1;
}
aGameArrays[j].size = asize;
@ -636,18 +558,15 @@ skip_check:
if (si<0 || si>=g_gameArrayCount)
{
M32_PRINTERROR("Invalid array %d!", si);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid array %d!", si);
}
if (di<0 || di>=g_gameArrayCount)
{
M32_PRINTERROR("Invalid array %d!", di);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid array %d!", di);
}
if (aGameArrays[di].dwFlags & GAMEARRAY_READONLY)
{
M32_PRINTERROR("Array %d is read-only!", di);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Array %d is read-only!", di);
}
if (vm.flags&VMFLAG_ERROR) continue;
@ -715,7 +634,7 @@ skip_check:
insptr++;
if (*(insptr+1) == 0)
{
M32_PRINTERROR("Divide by zero.");
M32_ERROR("Divide by zero.");
insptr += 2;
continue;
}
@ -727,7 +646,7 @@ skip_check:
insptr++;
if (*(insptr+1) == 0)
{
M32_PRINTERROR("Mod by zero.");
M32_ERROR("Mod by zero.");
insptr += 2;
continue;
}
@ -785,7 +704,7 @@ skip_check:
if (l2==0)
{
M32_PRINTERROR("Divide by zero.");
M32_ERROR("Divide by zero.");
continue;
}
Gv_SetVarX(j, Gv_GetVarX(j)/l2);
@ -800,7 +719,7 @@ skip_check:
if (l2==0)
{
M32_PRINTERROR("Mod by zero.");
M32_ERROR("Mod by zero.");
continue;
}
@ -962,13 +881,11 @@ skip_check:
if (xvar < 0 || xvar >= MAXSPRITES || sprite[xvar].statnum==MAXSTATUS)
{
M32_PRINTERROR("invalid sprite %d", xvar);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("invalid sprite %d", xvar);
}
if (yvar < 0 || yvar >= MAXSPRITES || sprite[yvar].statnum==MAXSTATUS)
{
M32_PRINTERROR("invalid sprite %d", yvar);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("invalid sprite %d", yvar);
}
if (vm.flags&VMFLAG_ERROR) continue;
@ -1255,8 +1172,7 @@ skip_check:
if (count<=0) continue;
if (count > aGameArrays[aridx].size)
{
M32_PRINTERROR("Count of elements to sort (%d) exceeds array size (%d)!", count,aGameArrays[aridx].size);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Count of elements to sort (%d) exceeds array size (%d)!", count,aGameArrays[aridx].size);
continue;
}
@ -1317,6 +1233,22 @@ skip_check:
VM_Execute(1);
}
break;
case ITER_ACTIVELIGHTS:
#ifdef POLYMER
for (jj=0; jj<PR_MAXLIGHTS; jj++)
{
if (!prlights[jj].flags.active)
continue;
Gv_SetVarX(var, jj);
insptr = beg;
VM_Execute(1);
}
#else
M32_ERROR("Polymer not compiled in, iteration over lights forbidden.");
#endif
break;
case ITER_SELSPRITES:
for (ii=0; ii<highlightcnt && !vm.flags; ii++)
{
@ -1406,8 +1338,7 @@ skip_check:
}
break;
default:
M32_PRINTERROR("Unknown iteration type %d!", how);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Unknown iteration type %d!", how);
continue;
badindex:
OSD_Printf(OSD_ERROR "Line %d, %s %s: index %d out of range!\n",g_errorLineNum,keyw[g_tw],
@ -1506,8 +1437,7 @@ badindex:
int32_t key=Gv_GetVarX(*insptr);
if (key<0 || key >= (int32_t)(sizeof(keystatus)/sizeof(keystatus[0])))
{
M32_PRINTERROR("Invalid key %d!", key);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid key %d!", key);
continue;
}
@ -1552,8 +1482,7 @@ badindex:
if (index<0 || (id==M32_SPRITE_VAR_ID && index>=MAXSPRITES) || (id==M32_WALL_VAR_ID && index>=numwalls))
{
M32_PRINTERROR("%s index %d out of range!", id==M32_SPRITE_VAR_ID?"Sprite":"Wall", index);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("%s index %d out of range!", id==M32_SPRITE_VAR_ID?"Sprite":"Wall", index);
continue;
}
@ -1635,8 +1564,7 @@ badindex:
res = inside(x, y, sectnum);
if (res == -1)
{
M32_PRINTERROR("Sector index %d out of range!", sectnum);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Sector index %d out of range!", sectnum);
continue;
}
insptr--;
@ -1675,8 +1603,7 @@ badindex:
X_ERROR_INVALIDSECT(dasectnum);
if (numsprites >= MAXSPRITES)
{
M32_PRINTERROR("Maximum number of sprites reached.");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Maximum number of sprites reached.");
continue;
}
@ -1695,14 +1622,12 @@ badindex:
if (ospritenum<0 || ospritenum>=MAXSPRITES || sprite[ospritenum].statnum==MAXSTATUS)
{
M32_PRINTERROR("Tried to duplicate nonexistent sprite %d", ospritenum);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Tried to duplicate nonexistent sprite %d", ospritenum);
}
if ((tw==CON_DUPSPRITE && numsprites >= MAXSPRITES) ||
(tw==CON_DUPSPRITE && spritesortcnt >= MAXSPRITESONSCREEN))
{
M32_PRINTERROR("Maximum number of sprites reached.");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Maximum number of sprites reached.");
}
if (vm.flags&VMFLAG_ERROR) continue;
@ -1712,8 +1637,7 @@ badindex:
if (nspritenum < 0)
{
M32_PRINTERROR("Internal error.");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Internal error.");
continue;
}
@ -1753,8 +1677,7 @@ badindex:
if (dapoint<0 || dapoint>=numwalls)
{
M32_PRINTERROR("Invalid wall %d", dapoint);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid wall %d", dapoint);
continue;
}
@ -2026,8 +1949,7 @@ badindex:
int32_t j=Gv_GetVarX(*insptr++);
if (j < 0 || j > MAXSTATUS)
{
M32_PRINTERROR("invalid status list %d", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("invalid status list %d", j);
continue;
}
Gv_SetVarX(i,headspritestat[j]);
@ -2096,13 +2018,11 @@ badindex:
if (lVar1<0 || lVar1>=MAXSPRITES || sprite[lVar1].statnum==MAXSTATUS)
{
M32_PRINTERROR("Invalid sprite %d", lVar1);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sprite %d", lVar1);
}
if (lVar2<0 || lVar2>=MAXSPRITES || sprite[lVar2].statnum==MAXSTATUS)
{
M32_PRINTERROR("Invalid sprite %d", lVar2);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sprite %d", lVar2);
}
if (vm.flags&VMFLAG_ERROR) res=0;
@ -2123,8 +2043,7 @@ badindex:
X_ERROR_INVALIDSPRI(i);
if (j<0 || j >= (tw==CON_CHANGESPRITESTAT?MAXSTATUS:numsectors))
{
M32_PRINTERROR("Invalid %s: %d", tw==CON_CHANGESPRITESTAT?"statnum":"sector", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid %s: %d", tw==CON_CHANGESPRITESTAT?"statnum":"sector", j);
continue;
}
@ -2148,8 +2067,7 @@ badindex:
if (wallnum<0 || wallnum>=numwalls)
{
M32_PRINTERROR("Invalid wall %d", wallnum);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid wall %d", wallnum);
continue;
}
dragpoint(wallnum,newx,newy);
@ -2196,8 +2114,7 @@ badindex:
index &= ~16384;
if (index < 0 || index>=MAXSPRITES || sprite[index].statnum==MAXSTATUS)
{
M32_PRINTERROR("Invalid sprite index %d", index);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sprite index %d", index);
continue;
}
@ -2208,8 +2125,7 @@ badindex:
}
else if (index < 0 || index>=numwalls)
{
M32_PRINTERROR("Invalid wall index %d", index);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid wall index %d", index);
continue;
if (doset)
@ -2262,9 +2178,6 @@ badindex:
if (code & (0xFFFFFFFF-(MAXGAMEVARS-1)))
{
char pp1[4][8] = {"sprite","sector","wall","tsprite"};
const memberlabel_t *pp2[4] = {SpriteLabels, SectorLabels, WallLabels, SpriteLabels};
if ((code&M32_VARTYPE_MASK)==M32_FLAG_ARRAY || (code&M32_VARTYPE_MASK)==M32_FLAG_STRUCT)
{
if (code&M32_FLAG_CONSTANT)
@ -2297,8 +2210,20 @@ badindex:
aGameArrays[code&(MAXGAMEARRAYS-1)].szLabel:"???", buf2);
break;
case M32_FLAG_STRUCT:
Bsprintf(buf, "%s[%s].%s", pp1[code&3], buf2, pp2[code&3][(code>>2)&31].name);
break;
{
int32_t memberid=(code>>2)&63, lightp = (memberid >= LIGHT_X);
const char *pp1[4] = {"sprite","sector","wall","tsprite"};
const memberlabel_t *pp2[4] = {SpriteLabels, SectorLabels, WallLabels, SpriteLabels};
if (lightp)
{
pp1[3] = "light";
pp2[3] = LightLabels;
memberid -= LIGHT_X;
}
Bsprintf(buf, "%s[%s].%s", pp1[code&3], buf2, pp2[code&3][memberid].name);
}
break;
case M32_FLAG_VAR:
Bsprintf(buf, "???");
break;
@ -2512,7 +2437,7 @@ badindex:
case CON_QGETSYSSTR:
if (ScriptQuotes[i] == NULL)
{
M32_PRINTERROR("null quote %d %d", i,j);
M32_ERROR("null quote %d %d", i,j);
break;
}
switch (j)
@ -2524,7 +2449,7 @@ badindex:
Bstrcpy(ScriptQuotes[i], "Mapster32"VERSION BUILDDATE);
break;
default:
M32_PRINTERROR("unknown str ID %d %d", i,j);
M32_ERROR("unknown str ID %d %d", i,j);
}
break;
#endif
@ -2944,8 +2869,7 @@ dodefault:
int32_t j=Gv_GetVarX(*insptr);
if (j<0 || j>=MAXSOUNDS)
{
M32_PRINTERROR("Invalid sound %d", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sound %d", j);
insptr++;
continue;
}
@ -2985,8 +2909,7 @@ dodefault:
int32_t j=Gv_GetVarX(*insptr++), var=*insptr++;
if (j<0 || j>=MAXSOUNDS)
{
M32_PRINTERROR("Invalid sound %d", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sound %d", j);
insptr++;
continue;
}
@ -3005,8 +2928,7 @@ dodefault:
if (j<0 || j>=MAXSOUNDS)
{
M32_PRINTERROR("Invalid sound %d", j);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Invalid sound %d", j);
continue;
}

137
polymer/eduke32/source/m32structures.c
View file

@ -26,7 +26,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "compat.h"
#include "m32script.h"
#include "m32def.h"
#ifdef POLYMER
# include "prlights.h"
#endif
// how: bitfield: 1=set? 2=vars? 4=use spriteext[].tspr? (otherwise use tsprite[])
#define ACCESS_SET 1
@ -121,10 +123,10 @@ static int32_t __fastcall VM_AccessWall(int32_t how, int32_t lVar1, int32_t lLab
}
badwall:
M32_PRINTERROR("Invalid wall %d", i);
M32_ERROR("Invalid wall %d", i);
return -1;
readonly:
M32_PRINTERROR("Wall structure member `%s' is read-only.", WallLabels[lLabelID].name);
M32_ERROR("Wall structure member `%s' is read-only.", WallLabels[lLabelID].name);
return -1;
}
@ -238,10 +240,10 @@ static int32_t __fastcall VM_AccessSector(int32_t how, int32_t lVar1, int32_t lL
}
badsector:
M32_PRINTERROR("Invalid sector %d", i);
M32_ERROR("Invalid sector %d", i);
return -1;
readonly:
M32_PRINTERROR("Sector structure member `%s' is read-only.", SectorLabels[lLabelID].name);
M32_ERROR("Sector structure member `%s' is read-only.", SectorLabels[lLabelID].name);
return -1;
}
@ -254,7 +256,7 @@ static int32_t __fastcall VM_AccessSprite(int32_t how, int32_t lVar1, int32_t lL
if ((how&ACCESS_USEVARS) && lVar1 != M32_THISACTOR_VAR_ID)
i = Gv_GetVarX(lVar1);
if (i < 0 || i >= MAXSPRITES)
if ((unsigned)i >= MAXSPRITES)
goto badsprite;
if (how&ACCESS_SET)
@ -346,42 +348,93 @@ static int32_t __fastcall VM_AccessSprite(int32_t how, int32_t lVar1, int32_t lL
return lValue;
}
badsprite:
M32_PRINTERROR("tried to set %s on invalid target sprite (%d)", SpriteLabels[lLabelID].name, i);
M32_ERROR("tried to set %s on invalid target sprite (%d)", SpriteLabels[lLabelID].name, i);
return -1;
readonly:
M32_PRINTERROR("sprite structure member `%s' is read-only.", SpriteLabels[lLabelID].name);
M32_ERROR("sprite structure member `%s' is read-only.", SpriteLabels[lLabelID].name);
return -1;
}
// how: bitfield: 1=set? 2=vars? 4=use spriteext[].tspr? (otherwise use tsprite[])
static int32_t __fastcall VM_AccessTsprite(int32_t how, int32_t lVar1, int32_t lLabelID, int32_t lVar2)
{
int32_t lValue;
int32_t lValue, lightp = (lLabelID >= LIGHT_X);
int32_t i = (how&ACCESS_USEVARS) ? vm.g_i : lVar1;
spritetype *datspr;
spritetype *datspr = NULL;
const memberlabel_t *dalabel = lightp ? &LightLabels[lLabelID-LIGHT_X] : SpriteLabels;
if ((how&ACCESS_USEVARS) && lVar1 != M32_THISACTOR_VAR_ID)
i = Gv_GetVarX(lVar1);
if (how&ACCESS_SPRITEEXT)
if (!lightp)
{
if (i < 0 || i >= MAXSPRITES)
goto badsprite;
datspr = spriteext[i].tspr;
if (!datspr)
goto badtspr;
if (how&ACCESS_SPRITEEXT)
{
if ((unsigned)i >= MAXSPRITES)
goto badsprite;
datspr = spriteext[i].tspr;
if (!datspr)
goto badtspr;
}
else
{
if (i<0 || i>=spritesortcnt)
goto badsprite;
datspr = &tsprite[i];
}
}
else
{
if (i<0 || i>=spritesortcnt)
goto badsprite;
datspr = &tsprite[i];
// access Polymer light
#ifndef POLYMER
M32_ERROR("Polymer not compiled in, accessing lights is invalid.");
return -1;
#else
if ((how&ACCESS_USEVARS) && lVar1 == M32_THISACTOR_VAR_ID)
{
if ((unsigned)i >= MAXSPRITES)
goto badsprite;
M32_ERROR("Polymer light access via current sprite not implemented.");
return -1;
}
else
{
// check whether rendmode==4 ?
if ((unsigned)i >= PR_MAXLIGHTS)
{
M32_ERROR("invalid light index (%d)", i);
return -1;
}
if (lLabelID != LIGHT_ACTIVE && !prlights[i].flags.active)
{
M32_ERROR("light with index %d is inactive!", i);
return -1;
}
}
#endif
}
if (how&ACCESS_SET)
{
int32_t damin, damax;
if (!m32_script_expertmode && (dalabel->flags & 1))
goto readonly;
lValue = (how&ACCESS_USEVARS) ? Gv_GetVarX(lVar2) : lVar2;
damin = dalabel->min;
damax = dalabel->max;
if (!m32_script_expertmode && (damin|damax))
{
if (lValue < damin)
lValue = damin;
if (lValue > damax)
lValue = damax;
}
switch (lLabelID)
{
case SPRITE_X: datspr->x=lValue; break;
@ -411,6 +464,25 @@ static int32_t __fastcall VM_AccessTsprite(int32_t how, int32_t lVar1, int32_t l
case SPRITE_LOTAG: datspr->lotag=lValue; break;
case SPRITE_HITAG: datspr->hitag=lValue; break;
case SPRITE_EXTRA: datspr->extra=lValue; break;
#ifdef POLYMER
// lights
case LIGHT_X: prlights[i].x = lValue; break;
case LIGHT_Y: prlights[i].y = lValue; break;
case LIGHT_Z: prlights[i].z = lValue; break;
case LIGHT_HORIZ: prlights[i].horiz = lValue; break;
case LIGHT_RANGE: prlights[i].range = lValue; break;
case LIGHT_ANGLE: prlights[i].angle = lValue; break;
case LIGHT_FADERADIUS: prlights[i].faderadius = lValue; break;
case LIGHT_RADIUS: prlights[i].radius = lValue; break;
case LIGHT_SECTOR: prlights[i].sector = lValue; break;
case LIGHT_R: prlights[i].color[0] = lValue; break;
case LIGHT_G: prlights[i].color[1] = lValue; break;
case LIGHT_B: prlights[i].color[2] = lValue; break;
case LIGHT_PRIORITY: prlights[i].priority = lValue; break;
case LIGHT_TILENUM: prlights[i].tilenum = lValue; break;
case LIGHT_MINSHADE: prlights[i].minshade = lValue; break;
case LIGHT_MAXSHADE: prlights[i].maxshade = lValue; break;
#endif
default:
return -1;
}
@ -444,6 +516,26 @@ static int32_t __fastcall VM_AccessTsprite(int32_t how, int32_t lVar1, int32_t l
case SPRITE_LOTAG: lValue=datspr->lotag; break;
case SPRITE_HITAG: lValue=datspr->hitag; break;
case SPRITE_EXTRA: lValue=datspr->extra; break;
#ifdef POLYMER
// lights
case LIGHT_X: lValue = prlights[i].x; break;
case LIGHT_Y: lValue = prlights[i].y; break;
case LIGHT_Z: lValue = prlights[i].z; break;
case LIGHT_HORIZ: lValue = prlights[i].horiz; break;
case LIGHT_RANGE: lValue = prlights[i].range; break;
case LIGHT_ANGLE: lValue = prlights[i].angle; break;
case LIGHT_FADERADIUS: lValue = prlights[i].faderadius; break;
case LIGHT_RADIUS: lValue = prlights[i].radius; break;
case LIGHT_SECTOR: lValue = prlights[i].sector; break;
case LIGHT_R: lValue = prlights[i].color[0]; break;
case LIGHT_G: lValue = prlights[i].color[1]; break;
case LIGHT_B: lValue = prlights[i].color[2]; break;
case LIGHT_PRIORITY: lValue = prlights[i].priority; break;
case LIGHT_TILENUM: lValue = prlights[i].tilenum; break;
case LIGHT_MINSHADE: lValue = prlights[i].minshade; break;
case LIGHT_MAXSHADE: lValue = prlights[i].maxshade; break;
case LIGHT_ACTIVE: lValue = !!prlights[i].flags.active; break;
#endif
default:
return -1;
}
@ -455,10 +547,13 @@ static int32_t __fastcall VM_AccessTsprite(int32_t how, int32_t lVar1, int32_t l
}
badsprite:
M32_PRINTERROR("invalid target sprite (%d)", i);
M32_ERROR("invalid target sprite (%d)", i);
return -1;
badtspr:
M32_PRINTERROR("Internal bug, tsprite is unavailable");
M32_ERROR("Internal bug, tsprite is unavailable");
return -1;
readonly:
M32_ERROR("structure member `%s' is read-only.", dalabel->name);
return -1;
}

36
polymer/eduke32/source/m32vars.c
View file

@ -241,8 +241,7 @@ int32_t __fastcall Gv_GetVarN(register int32_t id) // 'N' for "no side-effects"
case GAMEVAR_CHARPTR:
return *((uint8_t *)aGameVars[id].val.lValue);
default:
M32_PRINTERROR("Gv_GetVarN(): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_GetVarN(): WTF??");
return -1;
}
@ -254,8 +253,7 @@ int32_t __fastcall Gv_GetVarN(register int32_t id) // 'N' for "no side-effects"
}
default:
M32_PRINTERROR("Gv_GetVarN(): invalid var code %0x08x", id);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_GetVarN(): invalid var code %0x08x", id);
return -1;
}
}
@ -278,8 +276,7 @@ int32_t __fastcall Gv_GetVarX(register int32_t id)
case 2:
return (labelval[(id>>16)&0xffff] ^ -negateResult) + negateResult;
default:
M32_PRINTERROR("Gv_GetVarX() (constant): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_GetVarX() (constant): WTF??");
return -1;
}
}
@ -305,7 +302,7 @@ int32_t __fastcall Gv_GetVarX(register int32_t id)
if (index < 0 || index >= siz)
{
M32_PRINTERROR("Gv_GetVarX(): invalid array index (%s[%d])", aGameArrays[id].szLabel, index);
M32_ERROR("Gv_GetVarX(): invalid array index (%s[%d])", aGameArrays[id].szLabel, index);
return -1;
}
@ -319,8 +316,7 @@ int32_t __fastcall Gv_GetVarX(register int32_t id)
case GAMEARRAY_OFCHAR:
return (((uint8_t *)aGameArrays[id].vals)[index] ^ -negateResult) + negateResult;
default:
M32_PRINTERROR("Gv_GetVarX() (array): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_GetVarX() (array): WTF??");
return -1;
}
}
@ -332,7 +328,7 @@ int32_t __fastcall Gv_GetVarX(register int32_t id)
if (!(id&M32_FLAG_CONSTANTINDEX))
index = Gv_GetVarN(index);
memberid = (id>>2)&31;
memberid = (id>>2)&63;
switch (id&3)
{
@ -370,8 +366,7 @@ int32_t __fastcall Gv_GetVarX(register int32_t id)
case GAMEVAR_CHARPTR:
return (*((uint8_t *)aGameVars[id].val.lValue) ^ -negateResult) + negateResult;
default:
M32_PRINTERROR("Gv_GetVarX(): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_GetVarX(): WTF??");
return -1;
}
}
@ -408,8 +403,7 @@ void __fastcall Gv_SetVarX(register int32_t id, register int32_t lValue)
if (index < 0 || index >= siz)
{
M32_PRINTERROR("Gv_SetVarX(): invalid array index %s[%d], size=%d", aGameArrays[id].szLabel, index, siz);
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_SetVarX(): invalid array index %s[%d], size=%d", aGameArrays[id].szLabel, index, siz);
return;
}
@ -426,8 +420,7 @@ void __fastcall Gv_SetVarX(register int32_t id, register int32_t lValue)
((uint8_t *)aGameArrays[id].vals)[index] = (uint8_t)lValue;
return;
default:
M32_PRINTERROR("Gv_SetVarX() (array): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_SetVarX() (array): WTF??");
return;
}
return;
@ -440,7 +433,7 @@ void __fastcall Gv_SetVarX(register int32_t id, register int32_t lValue)
if (!(id&M32_FLAG_CONSTANTINDEX))
index = Gv_GetVarN(index);
memberid = (id>>2)&31;
memberid = (id>>2)&63;
switch (id&3)
{
@ -476,8 +469,7 @@ void __fastcall Gv_SetVarX(register int32_t id, register int32_t lValue)
float fval = *(float *)&ival;
if (fval!=fval || fval<-3.4e38 || fval > 3.4e38)
{
M32_PRINTERROR("Gv_SetVarX(): tried to set float var to NaN or infinity");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_SetVarX(): tried to set float var to NaN or infinity");
return;
}
}
@ -491,8 +483,7 @@ void __fastcall Gv_SetVarX(register int32_t id, register int32_t lValue)
*((uint8_t *)aGameVars[id].val.lValue)=(uint8_t)lValue;
return;
default:
M32_PRINTERROR("Gv_SetVarX(): WTF??");
vm.flags |= VMFLAG_ERROR;
M32_ERROR("Gv_SetVarX(): WTF??");
return;
}
}
@ -534,8 +525,11 @@ static void Gv_AddSystemVars(void)
Gv_NewVar("sector", -1, GAMEVAR_READONLY | GAMEVAR_SYSTEM | GAMEVAR_SPECIAL);
Gv_NewVar("wall", -1, GAMEVAR_READONLY | GAMEVAR_SYSTEM | GAMEVAR_SPECIAL);
Gv_NewVar("tsprite", -1, GAMEVAR_READONLY | GAMEVAR_SYSTEM | GAMEVAR_SPECIAL);
Gv_NewVar("light", -1, GAMEVAR_READONLY | GAMEVAR_SYSTEM | GAMEVAR_SPECIAL);
// these too have to be in here and in order!
// keep in sync with m32script.h: IDs of special vars
Gv_NewVar("I", 0, GAMEVAR_READONLY | GAMEVAR_SYSTEM); // THISACTOR
Gv_NewVar("RETURN", (intptr_t)&g_iReturnVar, GAMEVAR_INTPTR | GAMEVAR_SYSTEM);
Gv_NewVar("LOTAG", 0, GAMEVAR_SYSTEM);