zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-01-18 22:51:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

- refactored the owner index in tspritetype.

Browse source 
This is now a separate type from spritetype which contains an actor pointer instead so that sprite display can be handled without requiring a static sprite array.
This commit is contained in:
Christoph Oelckers 2021-12-04 19:08:50 +01:00
parent 793dd032b0
commit eaff9e359f
50 changed files with 473 additions and 364 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
source/build/include/build.h
View file

@ -154,27 +154,6 @@ EXTERN int leveltimer;
extern TArray<sectortype> sectorbackup; extern TArray<sectortype> sectorbackup;
extern TArray<walltype> wallbackup; extern TArray<walltype> wallbackup;
inline tspriteptr_t renderAddTSpriteFromSprite(spritetype* tsprite, int& spritesortcnt, uint16_t const spritenum)
{
auto tspr = &tsprite[spritesortcnt++];
auto const spr = &sprite[spritenum];
*tspr = *spr;
tspr->clipdist = 0;
tspr->owner = spritenum;
return tspr;
}
// returns: 0=continue sprite collecting;
// 1=break out of sprite collecting;
inline int32_t renderAddTsprite(spritetype* tsprite, int& spritesortcnt, int16_t z, int16_t sectnum)
{
if (spritesortcnt >= MAXSPRITESONSCREEN) return 1;
renderAddTSpriteFromSprite(tsprite, spritesortcnt, z);
return 0;
}
EXTERN int32_t xdim, ydim; EXTERN int32_t xdim, ydim;
EXTERN int32_t yxaspect, viewingrange; EXTERN int32_t yxaspect, viewingrange;
@ -505,7 +484,7 @@ int32_t lintersect(int32_t originX, int32_t originY, int32_t originZ,
int32_t lineStartX, int32_t lineStartY, int32_t lineEndX, int32_t lineEndY, int32_t lineStartX, int32_t lineStartY, int32_t lineEndX, int32_t lineEndY,
int32_t *intersectionX, int32_t *intersectionY, int32_t *intersectionZ); int32_t *intersectionX, int32_t *intersectionY, int32_t *intersectionZ);
int32_t insertsprite(int16_t sectnum, int16_t statnum); int32_t insertsprite(int16_t sectnum, int16_t statnum, bool frominit = false);
int32_t deletesprite(int16_t spritenum); int32_t deletesprite(int16_t spritenum);
int32_t changespritesect(int16_t spritenum, int16_t newsectnum); int32_t changespritesect(int16_t spritenum, int16_t newsectnum);
@ -625,7 +604,6 @@ extern int32_t rintersect(int32_t x1, int32_t y1, int32_t z1,
int32_t x3, int32_t y3, int32_t x4, int32_t y4, int32_t x3, int32_t y3, int32_t x4, int32_t y4,
int32_t *intx, int32_t *inty, int32_t *intz); int32_t *intx, int32_t *inty, int32_t *intz);
extern int32_t(*animateoffs_replace)(int const tilenum, int fakevar);
extern void(*initspritelists_replace)(void); extern void(*initspritelists_replace)(void);
extern int32_t(*changespritesect_replace)(int16_t spritenum, int16_t newsectnum); extern int32_t(*changespritesect_replace)(int16_t spritenum, int16_t newsectnum);
@ -676,6 +654,25 @@ inline bool spritetype::insector() const
return validSectorIndex(sectnum); return validSectorIndex(sectnum);
} }
inline sectortype* tspritetype::sector() const
{
return !validSectorIndex(sectnum) ? nullptr : &::sector[sectnum];
}
inline bool tspritetype::insector() const
{
return validSectorIndex(sectnum);
}
inline void tspritetype::setsector(sectortype* sect)
{
// place for asserts.
sectnum = sect ? ::sector.IndexOf(sect) : -1;
}
inline sectortype* walltype::nextSector() const inline sectortype* walltype::nextSector() const
{ {
return !validSectorIndex(nextsector)? nullptr : &::sector[nextsector]; return !validSectorIndex(nextsector)? nullptr : &::sector[nextsector];

120
source/build/include/buildtypes.h
View file

@ -57,6 +57,7 @@ BEGIN_BLD_NS
END_BLD_NS END_BLD_NS
//40 bytes //40 bytes
class DCoreActor;
struct walltype; struct walltype;
struct sectortype struct sectortype
{ {
@ -369,9 +370,13 @@ struct spritetype
#endif #endif
void clear() void clear()
{ {
int sect = sectnum;
int stat = statnum;
int save = time; // this may not be cleared ever!!! int save = time; // this may not be cleared ever!!!
memset(this, 0, sizeof(*this)); memset(this, 0, sizeof(*this));
time = save; time = save;
sectnum = sect;
statnum = stat;
} }
void backupx() void backupx()
@ -459,7 +464,120 @@ struct spritetype
void setsector(sectortype*); void setsector(sectortype*);
}; };
using tspritetype = spritetype; // This is mostly the same, but it omits the 'owner' field in favor of a full actor pointer.
// Incompatibility with spritetype regarding assignments is deliberate as these serve a fundamentally different purpose!
struct tspritetype
{
union {
struct
{
int32_t x, y, z;
};
vec3_t pos;
};
union {
struct
{
int32_t ox, oy, oz;
};
vec3_t opos;
};
uint16_t cstat;
int16_t picnum;
int8_t shade;
uint8_t pal, clipdist, blend;
uint8_t xrepeat, yrepeat;
int8_t xoffset, yoffset;
int16_t sectnum, statnum;
int16_t oang, ang;
int16_t xvel;
int16_t yvel;
int16_t zvel;
union {
int16_t lotag, type;
};
union {
int16_t hitag, flags;
};
int16_t extra;
uint16_t cstat2;
int time;
DCoreActor* ownerActor;
sectortype* sector() const;
bool insector() const;
void setsector(sectortype*);
void copyfrom(spritetype* spr)
{
pos = spr->pos;
opos = spr->opos;
cstat = spr->cstat;
picnum = spr->picnum;
shade = spr->shade;
pal = spr->pal;
clipdist = spr->clipdist;
blend = spr->blend;
xrepeat = spr->xrepeat;
yrepeat = spr->yrepeat;
xoffset = spr->xoffset;
yoffset = spr->yoffset;
sectnum = spr->sectnum;
statnum = spr->statnum;
ang = spr->ang;
oang = spr->oang;
xvel = spr->xvel;
yvel = spr->yvel;
zvel = spr->zvel;
lotag = spr->lotag;
hitag = spr->hitag;
extra = spr->extra;
time = spr->time;
cstat2 = spr->cstat2;
ownerActor = nullptr;
}
int32_t interpolatedx(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(ox, x, smoothratio, scale);
}
int32_t interpolatedy(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(oy, y, smoothratio, scale);
}
int32_t interpolatedz(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(oz, z, smoothratio, scale);
}
vec2_t interpolatedvec2(double const smoothratio, int const scale = 16)
{
return
{
interpolatedx(smoothratio, scale),
interpolatedy(smoothratio, scale)
};
}
vec3_t interpolatedvec3(double const smoothratio, int const scale = 16)
{
return
{
interpolatedx(smoothratio, scale),
interpolatedy(smoothratio, scale),
interpolatedz(smoothratio, scale)
};
}
int16_t interpolatedang(double const smoothratio)
{
return interpolatedangle(oang, ang, smoothratio, 16);
}
};
#endif #endif
//////////////////// END Version 7 map format //////////////// //////////////////// END Version 7 map format ////////////////

4
source/build/include/polymost.h
View file

@ -16,9 +16,6 @@ extern double gxyaspect;
extern float grhalfxdown10x; extern float grhalfxdown10x;
extern float gcosang, gsinang, gcosang2, gsinang2; extern float gcosang, gsinang, gcosang2, gsinang2;
extern void Polymost_prepare_loadboard(void);
//void phex(char v, char *s); //void phex(char v, char *s);
void polymost_drawsprite(int32_t snum); void polymost_drawsprite(int32_t snum);
void polymost_drawmaskwall(int32_t damaskwallcnt); void polymost_drawmaskwall(int32_t damaskwallcnt);
@ -27,7 +24,6 @@ void polymost_initosdfuncs(void);
void polymost_drawrooms(void); void polymost_drawrooms(void);
void polymost_prepareMirror(int32_t dax, int32_t day, int32_t daz, fixed_t daang, fixed_t dahoriz, int16_t mirrorWall); void polymost_prepareMirror(int32_t dax, int32_t day, int32_t daz, fixed_t daang, fixed_t dahoriz, int16_t mirrorWall);
void polymost_completeMirror(); void polymost_completeMirror();
void polymost_deletesprite(int num);
int32_t polymost_maskWallHasTranslucency(walltype const * const wall); int32_t polymost_maskWallHasTranslucency(walltype const * const wall);
int32_t polymost_spriteHasTranslucency(spritetype const * const tspr); int32_t polymost_spriteHasTranslucency(spritetype const * const tspr);

15
source/build/src/engine.cpp
View file

@ -160,16 +160,18 @@ static int16_t numhits;
// Internal Engine Functions // Internal Engine Functions
// //
BEGIN_BLD_NS
int qanimateoffs(int a1, int a2);
END_BLD_NS
// //
// animateoffs (internal) // animateoffs (internal)
// //
int32_t (*animateoffs_replace)(int const tilenum, int fakevar) = NULL;
int32_t animateoffs(int const tilenum, int fakevar) int32_t animateoffs(int const tilenum, int fakevar)
{ {
if (animateoffs_replace) if (isBlood())
{ {
return animateoffs_replace(tilenum, fakevar); return Blood::qanimateoffs(tilenum, fakevar);
} }
int const animnum = picanm[tilenum].num; int const animnum = picanm[tilenum].num;
@ -311,13 +313,17 @@ static void do_deletespritestat(int16_t deleteme)
// //
// insertsprite // insertsprite
// //
int32_t insertsprite(int16_t sectnum, int16_t statnum) int32_t insertsprite(int16_t sectnum, int16_t statnum, bool frominit)
{ {
// TODO: guard against bad sectnum? // TODO: guard against bad sectnum?
int32_t const newspritenum = insertspritestat(statnum); int32_t const newspritenum = insertspritestat(statnum);
// Build's default init of sprites is insantity².
if (newspritenum >= 0) if (newspritenum >= 0)
{ {
// Make sure it's clear.
if (!frominit) sprite[newspritenum].clear();
assert(validSectorIndex(sectnum)); assert(validSectorIndex(sectnum));
do_insertsprite_at_headofsect(newspritenum, sectnum); do_insertsprite_at_headofsect(newspritenum, sectnum);
@ -334,7 +340,6 @@ int32_t insertsprite(int16_t sectnum, int16_t statnum)
// //
int32_t deletesprite(int16_t spritenum) int32_t deletesprite(int16_t spritenum)
{ {
Polymost::polymost_deletesprite(spritenum);
assert((sprite[spritenum].statnum == MAXSTATUS) assert((sprite[spritenum].statnum == MAXSTATUS)
== (sprite[spritenum].sectnum == MAXSECTORS)); == (sprite[spritenum].sectnum == MAXSECTORS));

2
source/build/src/engine_priv.h
View file

@ -36,7 +36,7 @@ inline int32_t bad_tspr(tspriteptr_t tspr)
{ {
// NOTE: tspr->owner >= MAXSPRITES (could be model) has to be handled by // NOTE: tspr->owner >= MAXSPRITES (could be model) has to be handled by
// caller. // caller.
return (tspr->owner < 0 || (unsigned)tspr->picnum >= MAXTILES); return (tspr->ownerActor == nullptr || (unsigned)tspr->picnum >= MAXTILES);
} }
inline void set_globalpos(int32_t const x, int32_t const y, int32_t const z) inline void set_globalpos(int32_t const x, int32_t const y, int32_t const z)

36
source/build/src/mdsprite.cpp
View file

@ -415,9 +415,10 @@ static void updateanimation(md2model_t *m, tspriteptr_t tspr, uint8_t lpal)
Printf("1: c > n\n"); Printf("1: c > n\n");
#endif #endif
auto ownerActor = tspr->ownerActor;
int32_t const smoothdurationp = (hw_animsmoothing && (tile2model[tile].smoothduration != 0)); int32_t const smoothdurationp = (hw_animsmoothing && (tile2model[tile].smoothduration != 0));
spritesmooth_t * const smooth = &spritesmooth[((unsigned)tspr->owner < MAXSPRITES+MAXUNIQHUDID) ? tspr->owner : MAXSPRITES+MAXUNIQHUDID-1]; spritesmooth_t* const smooth = &ownerActor->sm();
spriteext_t * const sprext = &spriteext[((unsigned)tspr->owner < MAXSPRITES) ? tspr->owner : MAXSPRITES-1]; spriteext_t* const sprext = &ownerActor->sx();
const mdanim_t *anim; const mdanim_t *anim;
for (anim = m->animations; anim && anim->startframe != m->cframe; anim = anim->next) for (anim = m->animations; anim && anim->startframe != m->cframe; anim = anim->next)
@ -1087,10 +1088,11 @@ void md3_vox_calcmat_common(tspriteptr_t tspr, const FVector3 *a0, float f, floa
{ {
float k0, k1, k2, k3, k4, k5, k6, k7; float k0, k1, k2, k3, k4, k5, k6, k7;
k0 = ((float)(tspr->x+spriteext[tspr->owner].position_offset.x-globalposx))*f*(1.f/1024.f); auto& sext = tspr->ownerActor->sx();
k1 = ((float)(tspr->y+spriteext[tspr->owner].position_offset.y-globalposy))*f*(1.f/1024.f); k0 = ((float)(tspr->x+sext.position_offset.x-globalposx))*f*(1.f/1024.f);
k4 = -bsinf(tspr->ang+spriteext[tspr->owner].angoff, -14); k1 = ((float)(tspr->y+sext.position_offset.y-globalposy))*f*(1.f/1024.f);
k5 = bcosf(tspr->ang+spriteext[tspr->owner].angoff, -14); k4 = -bsinf(tspr->ang+sext.angoff, -14);
k5 = bcosf(tspr->ang+sext.angoff, -14);
k2 = k0*(1-k4)+k1*k5; k2 = k0*(1-k4)+k1*k5;
k3 = k1*(1-k4)-k0*k5; k3 = k1*(1-k4)-k0*k5;
k6 = - gsinang; k6 = - gsinang;
@ -1145,9 +1147,10 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
float pc[4]; float pc[4];
// int32_t texunits = GL_TEXTURE0; // int32_t texunits = GL_TEXTURE0;
const int32_t owner = tspr->owner; auto ownerActor = tspr->ownerActor;
const spriteext_t *const sext = &spriteext[((unsigned)owner < MAXSPRITES) ? owner : MAXSPRITES-1]; const spritetype* const spr = &ownerActor->s();
const uint8_t lpal = ((unsigned)owner < MAXSPRITES) ? sprite[tspr->owner].pal : tspr->pal; const spriteext_t* const sext = &ownerActor->sx();
const uint8_t lpal = spr->pal;
const int32_t sizyrep = tileHeight(tspr->picnum) * tspr->yrepeat; const int32_t sizyrep = tileHeight(tspr->picnum) * tspr->yrepeat;
updateanimation((md2model_t *)m, tspr, lpal); updateanimation((md2model_t *)m, tspr, lpal);
@ -1177,8 +1180,8 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
a0.Z = m->zadd * m->scale; a0.Z = m->zadd * m->scale;
// Parkar: Moved up to be able to use k0 for the y-flipping code // Parkar: Moved up to be able to use k0 for the y-flipping code
k0 = (float)tspr->z+spriteext[tspr->owner].position_offset.z; k0 = (float)tspr->z+sext->position_offset.z;
f = ((globalorientation&8) && (sprite[tspr->owner].cstat&48)!=0) ? -4.f : 4.f; f = ((globalorientation&8) && (spr->cstat&48)!=0) ? -4.f : 4.f;
k0 -= (tspr->yoffset*tspr->yrepeat)*f; k0 -= (tspr->yoffset*tspr->yrepeat)*f;
if ((globalorientation&128) && !((globalorientation&48)==32)) if ((globalorientation&128) && !((globalorientation&48)==32))
k0 += (float)(sizyrep<<1); k0 += (float)(sizyrep<<1);
@ -1202,7 +1205,7 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
m0.Z *= f; m1.Z *= f; a0.Z *= f; m0.Z *= f; m1.Z *= f; a0.Z *= f;
// floor aligned // floor aligned
k1 = (float)tspr->y+spriteext[tspr->owner].position_offset.y; k1 = (float)tspr->y+sext->position_offset.y;
if ((globalorientation&48)==32) if ((globalorientation&48)==32)
{ {
m0.Z = -m0.Z; m1.Z = -m1.Z; a0.Z = -a0.Z; m0.Z = -m0.Z; m1.Z = -m1.Z; a0.Z = -a0.Z;
@ -1215,7 +1218,7 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
// calculations below again, but are needed for the base offsets. // calculations below again, but are needed for the base offsets.
f = (65536.f*512.f)/(fxdimen*fviewingrange); f = (65536.f*512.f)/(fxdimen*fviewingrange);
g = 32.f/(fxdimen*gxyaspect); g = 32.f/(fxdimen*gxyaspect);
m0.Y *= f; m1.Y *= f; a0.Y = (((float)(tspr->x+spriteext[tspr->owner].position_offset.x-globalposx))* (1.f/1024.f) + a0.Y)*f; m0.Y *= f; m1.Y *= f; a0.Y = (((float)(tspr->x+sext->position_offset.x-globalposx))* (1.f/1024.f) + a0.Y)*f;
m0.X *=-f; m1.X *=-f; a0.X = ((k1 -fglobalposy) * -(1.f/1024.f) + a0.X)*-f; m0.X *=-f; m1.X *=-f; a0.X = ((k1 -fglobalposy) * -(1.f/1024.f) + a0.X)*-f;
m0.Z *= g; m1.Z *= g; a0.Z = ((k0 -fglobalposz) * -(1.f/16384.f) + a0.Z)*g; m0.Z *= g; m1.Z *= g; a0.Z = ((k0 -fglobalposz) * -(1.f/16384.f) + a0.Z)*g;
@ -1237,11 +1240,9 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
// to use Z-buffer hacks to hide overdraw problems with the flat-tsprite-on-floor shadows, // to use Z-buffer hacks to hide overdraw problems with the flat-tsprite-on-floor shadows,
// also disabling detail, glow, normal, and specular maps. // also disabling detail, glow, normal, and specular maps.
// WTF??? This should be done with proper math.
if (tspr->clipdist & TSPR_FLAGS_MDHACK) if (tspr->clipdist & TSPR_FLAGS_MDHACK)
{ {
double f = (double) (tspr->owner + 1) * (std::numeric_limits<double>::epsilon() * 8.0); // What once was here had been neutered in EDuke32 already.
if (f != 0.0) f *= 1.0/(double) (FindDistance2D(globalposx - tspr->x, globalposy - tspr->y)>>5);
GLInterface.SetDepthFunc(DF_LEqual); GLInterface.SetDepthFunc(DF_LEqual);
} }
@ -1528,8 +1529,7 @@ int32_t polymost_mddraw(tspriteptr_t tspr)
allocmodelverts = maxmodelverts; allocmodelverts = maxmodelverts;
} }
mdmodel_t *const vm = models[tile2model[Ptile2tile(tspr->picnum, mdmodel_t *const vm = models[tile2model[Ptile2tile(tspr->picnum, tspr->ownerActor->s().pal)].modelid];
(tspr->owner >= MAXSPRITES) ? tspr->pal : sprite[tspr->owner].pal)].modelid];
if (vm->mdnum == 1) if (vm->mdnum == 1)
return polymost_voxdraw((voxmodel_t *)vm,tspr, false); // can't access rotating info anymore return polymost_voxdraw((voxmodel_t *)vm,tspr, false); // can't access rotating info anymore
else if (vm->mdnum == 3) else if (vm->mdnum == 3)

101
source/build/src/polymost.cpp
View file

@ -282,10 +282,10 @@ int32_t polymost_maskWallHasTranslucency(walltype const * const wall)
return checkTranslucentReplacement(tileGetTexture(wall->picnum)->GetID(), wall->pal); return checkTranslucentReplacement(tileGetTexture(wall->picnum)->GetID(), wall->pal);
} }
int32_t polymost_spriteHasTranslucency(spritetype const * const tspr) int32_t polymost_spriteHasTranslucency(tspritetype const * const tspr)
{ {
if ((tspr->cstat & CSTAT_SPRITE_TRANSLUCENT) || (tspr->clipdist & TSPR_FLAGS_DRAW_LAST) || if ((tspr->cstat & CSTAT_SPRITE_TRANSLUCENT) || (tspr->clipdist & TSPR_FLAGS_DRAW_LAST) ||
((unsigned)tspr->owner < MAXSPRITES && spriteext[tspr->owner].alpha)) (tspr->ownerActor && tspr->ownerActor->sx().alpha))
return true; return true;
return checkTranslucentReplacement(tileGetTexture(tspr->picnum)->GetID(), tspr->pal); return checkTranslucentReplacement(tileGetTexture(tspr->picnum)->GetID(), tspr->pal);
@ -1926,7 +1926,7 @@ void polymost_scansector(int32_t sectnum)
(r_voxels && tiletovox[spr->picnum] >= 0 && voxmodels[tiletovox[spr->picnum]]) || (r_voxels && tiletovox[spr->picnum] >= 0 && voxmodels[tiletovox[spr->picnum]]) ||
(r_voxels && gi->Voxelize(spr->picnum) > -1) || (r_voxels && gi->Voxelize(spr->picnum) > -1) ||
DMulScale(bcos(spr->ang), -s.x, bsin(spr->ang), -s.y, 6) > 0) DMulScale(bcos(spr->ang), -s.x, bsin(spr->ang), -s.y, 6) > 0)
if (renderAddTsprite(pm_tsprite, pm_spritesortcnt, act->GetSpriteIndex(), sectnum)) if (!renderAddTsprite(pm_tsprite, pm_spritesortcnt, act))
break; break;
} }
} }
@ -2603,26 +2603,6 @@ void polymost_completeMirror()
GLInterface.DisableStencil(); GLInterface.DisableStencil();
} }
typedef struct
{
int16_t wall;
int8_t wdist;
int8_t filler;
} wallspriteinfo_t;
static wallspriteinfo_t wsprinfo[MAXSPRITES];
void Polymost_prepare_loadboard(void)
{
memset(wsprinfo, 0, sizeof(wsprinfo));
}
void polymost_deletesprite(int num)
{
wsprinfo[num].wall = -1;
}
static inline int32_t polymost_findwall(tspritetype const * const tspr, vec2_t const * const tsiz, int32_t * rd) static inline int32_t polymost_findwall(tspritetype const * const tspr, vec2_t const * const tsiz, int32_t * rd)
{ {
@ -2691,7 +2671,7 @@ static int32_t polymost_lintersect(int32_t x1, int32_t y1, int32_t x2, int32_t y
} }
#define TSPR_OFFSET_FACTOR .0002f #define TSPR_OFFSET_FACTOR .0002f
#define TSPR_OFFSET(tspr) (TSPR_OFFSET_FACTOR + ((tspr->owner != -1 ? tspr->owner & 63 : 0) * TSPR_OFFSET_FACTOR)) #define TSPR_OFFSET(tspr) (TSPR_OFFSET_FACTOR + ((tspr->ownerActor ? tspr->ownerActor->GetIndex() & 63 : 0) * TSPR_OFFSET_FACTOR))
void polymost_drawsprite(int32_t snum) void polymost_drawsprite(int32_t snum)
{ {
@ -2702,10 +2682,10 @@ void polymost_drawsprite(int32_t snum)
usectorptr_t sec; usectorptr_t sec;
int32_t spritenum = tspr->owner; auto actor = tspr->ownerActor;
if ((tspr->cstat&48) != 48) if ((tspr->cstat&48) != 48)
tileUpdatePicnum(&tspr->picnum, spritenum + 32768); tileUpdatePicnum(&tspr->picnum, (actor->GetIndex() & 16383) + 32768);
globalpicnum = tspr->picnum; globalpicnum = tspr->picnum;
globalshade = tspr->shade; globalshade = tspr->shade;
@ -2731,12 +2711,12 @@ void polymost_drawsprite(int32_t snum)
SetRenderStyleFromBlend(!!(tspr->cstat & 2), tspr->blend, !!(tspr->cstat & 512)); SetRenderStyleFromBlend(!!(tspr->cstat & 2), tspr->blend, !!(tspr->cstat & 512));
drawpoly_alpha = spriteext[spritenum].alpha; drawpoly_alpha = actor->sx().alpha;
drawpoly_blend = tspr->blend; drawpoly_blend = tspr->blend;
sec = (usectorptr_t)tspr->sector(); sec = (usectorptr_t)tspr->sector();
while (!(spriteext[spritenum].flags & SPREXT_NOTMD)) while (!(actor->sx().flags & SPREXT_NOTMD))
{ {
if (hw_models && tile2model[Ptile2tile(tspr->picnum, tspr->pal)].modelid >= 0 && if (hw_models && tile2model[Ptile2tile(tspr->picnum, tspr->pal)].modelid >= 0 &&
tile2model[Ptile2tile(tspr->picnum, tspr->pal)].framenum >= 0) tile2model[Ptile2tile(tspr->picnum, tspr->pal)].framenum >= 0)
@ -2768,12 +2748,12 @@ void polymost_drawsprite(int32_t snum)
vec3_t pos = tspr->pos; vec3_t pos = tspr->pos;
if (spriteext[spritenum].flags & SPREXT_AWAY1) if (actor->sx().flags & SPREXT_AWAY1)
{ {
pos.x += bcos(tspr->ang, -13); pos.x += bcos(tspr->ang, -13);
pos.y += bsin(tspr->ang, -13); pos.y += bsin(tspr->ang, -13);
} }
else if (spriteext[spritenum].flags & SPREXT_AWAY2) else if (actor->sx().flags & SPREXT_AWAY2)
{ {
pos.x -= bcos(tspr->ang, -13); pos.x -= bcos(tspr->ang, -13);
pos.y -= bsin(tspr->ang, -13); pos.y -= bsin(tspr->ang, -13);
@ -2918,29 +2898,8 @@ void polymost_drawsprite(int32_t snum)
FVector2 vec0 = { (float)(pos.x - globalposx) - vf.X, FVector2 vec0 = { (float)(pos.x - globalposx) - vf.X,
(float)(pos.y - globalposy) - vf.Y }; (float)(pos.y - globalposy) - vf.Y };
int32_t const s = tspr->owner;
int32_t walldist = 1; int32_t walldist = 1;
int32_t w = (s == -1) ? -1 : wsprinfo[s].wall; int w = polymost_findwall(tspr, &tsiz, &walldist);
// find the wall most likely to be what the sprite is supposed to be ornamented against
// this is really slow, so cache the result. Also assume that this association never changes once it is set up
if (s == -1 || !wsprinfo[s].wall)
{
w = polymost_findwall(tspr, &tsiz, &walldist);
if (s != -1)
{
wallspriteinfo_t *ws = &wsprinfo[s];
ws->wall = w;
if (w != -1)
{
ws->wdist = walldist;
}
}
}
else if (s != -1)
walldist = wsprinfo[s].wdist;
// detect if the sprite is either on the wall line or the wall line and sprite intersect // detect if the sprite is either on the wall line or the wall line and sprite intersect
if (w != -1) if (w != -1)
@ -3172,10 +3131,10 @@ void polymost_drawsprite(int32_t snum)
// unfortunately, offsetting by only 1 isn't enough on most Android devices // unfortunately, offsetting by only 1 isn't enough on most Android devices
if (pos.z == sec->ceilingz || pos.z == sec->ceilingz + 1) if (pos.z == sec->ceilingz || pos.z == sec->ceilingz + 1)
pos.z = sec->ceilingz + 2, fadjust = (tspr->owner & 31); pos.z = sec->ceilingz + 2, fadjust = (tspr->ownerActor->GetIndex() & 31);
if (pos.z == sec->floorz || pos.z == sec->floorz - 1) if (pos.z == sec->floorz || pos.z == sec->floorz - 1)
pos.z = sec->floorz - 2, fadjust = -((tspr->owner & 31)); pos.z = sec->floorz - 2, fadjust = -((tspr->ownerActor->GetIndex() & 31));
float f = (float)(pos.z - globalposz + fadjust) * gyxscale; float f = (float)(pos.z - globalposz + fadjust) * gyxscale;
@ -3247,8 +3206,7 @@ void polymost_drawsprite(int32_t snum)
break; break;
} }
if ((unsigned)spritenum < MAXSPRITES) actor->s().cstat2 |= CSTAT2_SPRITE_MAPPED;
sprite[spritenum].cstat2 |= CSTAT2_SPRITE_MAPPED;
_drawsprite_return: _drawsprite_return:
; ;
@ -3309,6 +3267,7 @@ int32_t renderDrawRoomsQ16(int32_t daposx, int32_t daposy, int32_t daposz, fixed
int32_t renderDrawRoomsQ16(int32_t daposx, int32_t daposy, int32_t daposz, int32_t renderDrawRoomsQ16(int32_t daposx, int32_t daposy, int32_t daposz,
fixed_t daang, fixed_t dahoriz, int dacursectnum, bool fromoutside) fixed_t daang, fixed_t dahoriz, int dacursectnum, bool fromoutside)
{ {
memset(pm_tsprite, 0, sizeof(pm_tsprite));
pm_spritesortcnt = 0; pm_spritesortcnt = 0;
checkRotatedWalls(); checkRotatedWalls();
@ -3386,12 +3345,14 @@ static inline int comparetsprites(int const k, int const l)
if (tspriteptr[k]->statnum != tspriteptr[l]->statnum) if (tspriteptr[k]->statnum != tspriteptr[l]->statnum)
return tspriteptr[k]->statnum - tspriteptr[l]->statnum; return tspriteptr[k]->statnum - tspriteptr[l]->statnum;
if (!tspriteptr[k]->ownerActor || !tspriteptr[l]->ownerActor) return 0; // why are these getting dragged into here?
if (tspriteptr[k]->x == tspriteptr[l]->x && if (tspriteptr[k]->x == tspriteptr[l]->x &&
tspriteptr[k]->y == tspriteptr[l]->y && tspriteptr[k]->y == tspriteptr[l]->y &&
tspriteptr[k]->z == tspriteptr[l]->z && tspriteptr[k]->z == tspriteptr[l]->z &&
(tspriteptr[k]->cstat & 48) == (tspriteptr[l]->cstat & 48) && (tspriteptr[k]->cstat & 48) == (tspriteptr[l]->cstat & 48) &&
tspriteptr[k]->owner != tspriteptr[l]->owner) tspriteptr[k]->ownerActor != tspriteptr[l]->ownerActor)
return tspriteptr[k]->owner - tspriteptr[l]->owner; return tspriteptr[k]->ownerActor->GetIndex() - tspriteptr[l]->ownerActor->GetIndex();
if (abs(spritesxyz[k].z - globalposz) != abs(spritesxyz[l].z - globalposz)) if (abs(spritesxyz[k].z - globalposz) != abs(spritesxyz[l].z - globalposz))
return abs(spritesxyz[k].z - globalposz) - abs(spritesxyz[l].z - globalposz); return abs(spritesxyz[k].z - globalposz) - abs(spritesxyz[l].z - globalposz);
@ -3464,9 +3425,9 @@ static void sortsprites(int const start, int const end)
} }
} }
static bool spriteIsModelOrVoxel(const spritetype* tspr) static bool spriteIsModelOrVoxel(const tspritetype* tspr)
{ {
if ((unsigned)tspr->owner < MAXSPRITES && spriteext[tspr->owner].flags & SPREXT_NOTMD) if (!tspr->ownerActor || tspr->ownerActor->sx().flags & SPREXT_NOTMD)
return false; return false;
if (hw_models) if (hw_models)
@ -3818,11 +3779,11 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
k0 = m->bscale / 64.f; k0 = m->bscale / 64.f;
f = (float)tspr->xrepeat * (256.f / 320.f) * k0; f = (float)tspr->xrepeat * (256.f / 320.f) * k0;
if ((sprite[tspr->owner].cstat & 48) == 16) if ((tspr->ownerActor->s().cstat & 48) == 16)
{ {
f *= 1.25f; f *= 1.25f;
a0.Y -= tspr->xoffset * bcosf(spriteext[tspr->owner].angoff, -20); a0.Y -= tspr->xoffset * bcosf(tspr->ownerActor->sx().angoff, -20);
a0.X += tspr->xoffset * bsinf(spriteext[tspr->owner].angoff, -20); a0.X += tspr->xoffset * bsinf(tspr->ownerActor->sx().angoff, -20);
} }
if (globalorientation & 8) { m0.Z = -m0.Z; a0.Z = -a0.Z; } //y-flipping if (globalorientation & 8) { m0.Z = -m0.Z; a0.Z = -a0.Z; } //y-flipping
@ -3833,8 +3794,8 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
f = (float)tspr->yrepeat * k0; f = (float)tspr->yrepeat * k0;
m0.Z *= f; a0.Z *= f; m0.Z *= f; a0.Z *= f;
k0 = (float)(tspr->z + spriteext[tspr->owner].position_offset.z); k0 = (float)(tspr->z + tspr->ownerActor->sx().position_offset.z);
f = ((globalorientation & 8) && (sprite[tspr->owner].cstat & 48) != 0) ? -4.f : 4.f; f = ((globalorientation & 8) && (tspr->ownerActor->s().cstat & 48) != 0) ? -4.f : 4.f;
k0 -= (tspr->yoffset * tspr->yrepeat) * f * m->bscale; k0 -= (tspr->yoffset * tspr->yrepeat) * f * m->bscale;
zoff = m->siz.z * .5f; zoff = m->siz.z * .5f;
if (!(tspr->cstat & 128)) if (!(tspr->cstat & 128))
@ -3851,8 +3812,8 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
int const shadowHack = !!(tspr->clipdist & TSPR_FLAGS_MDHACK); int const shadowHack = !!(tspr->clipdist & TSPR_FLAGS_MDHACK);
m0.Y *= f; a0.Y = (((float)(tspr->x + spriteext[tspr->owner].position_offset.x - globalposx)) * (1.f / 1024.f) + a0.Y) * f; m0.Y *= f; a0.Y = (((float)(tspr->x + ownerActor->sx().position_offset.x - globalposx)) * (1.f / 1024.f) + a0.Y) * f;
m0.X *= -f; a0.X = (((float)(tspr->y + spriteext[tspr->owner].position_offset.y - globalposy)) * -(1.f / 1024.f) + a0.X) * -f; m0.X *= -f; a0.X = (((float)(tspr->y + ownerActor->sx().position_offset.y - globalposy)) * -(1.f / 1024.f) + a0.X) * -f;
m0.Z *= g; a0.Z = (((float)(k0 - globalposz - shadowHack)) * -(1.f / 16384.f) + a0.Z) * g; m0.Z *= g; a0.Z = (((float)(k0 - globalposz - shadowHack)) * -(1.f / 16384.f) + a0.Z) * g;
float mat[16]; float mat[16];
@ -3884,11 +3845,11 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
if (!shadowHack) if (!shadowHack)
{ {
pc[3] = (tspr->cstat & 2) ? glblend[tspr->blend].def[!!(tspr->cstat & 512)].alpha : 1.0f; pc[3] = (tspr->cstat & 2) ? glblend[tspr->blend].def[!!(tspr->cstat & 512)].alpha : 1.0f;
pc[3] *= 1.0f - spriteext[tspr->owner].alpha; pc[3] *= 1.0f - tspr->ownerActor->sx().alpha;
SetRenderStyleFromBlend(!!(tspr->cstat & 2), tspr->blend, !!(tspr->cstat & 512)); SetRenderStyleFromBlend(!!(tspr->cstat & 2), tspr->blend, !!(tspr->cstat & 512));
if (!(tspr->cstat & 2) || spriteext[tspr->owner].alpha > 0.f || pc[3] < 1.0f) if (!(tspr->cstat & 2) || tspr->ownerActor->sx().alpha > 0.f || pc[3] < 1.0f)
GLInterface.EnableBlend(true); // else GLInterface.EnableBlend(false); GLInterface.EnableBlend(true); // else GLInterface.EnableBlend(false);
} }
else pc[3] = 1.f; else pc[3] = 1.f;
@ -3948,7 +3909,7 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
RenderStyle = LegacyRenderStyles[STYLE_Translucent]; RenderStyle = LegacyRenderStyles[STYLE_Translucent];
alpha = 1.f; alpha = 1.f;
} }
alpha *= 1.f - spriteext[tspr->owner].alpha; alpha *= 1.f - tspr->ownerActor->sx().alpha;
GLInterface.SetRenderStyle(RenderStyle); GLInterface.SetRenderStyle(RenderStyle);
GLInterface.SetColor(pc[0], pc[1], pc[2], alpha); GLInterface.SetColor(pc[0], pc[1], pc[2], alpha);

11
source/core/coreactor.h
View file

@ -327,3 +327,14 @@ inline int pushmove(vec3_t* const vect, sectortype** const sect, int32_t const w
*sect = sectno == -1 ? nullptr : &sector[sectno]; *sect = sectno == -1 ? nullptr : &sector[sectno];
return res; return res;
} }
inline tspriteptr_t renderAddTsprite(tspritetype* tsprite, int& spritesortcnt, DCoreActor* actor)
{
if (spritesortcnt >= MAXSPRITESONSCREEN) return nullptr;
auto tspr = &tsprite[spritesortcnt++];
tspr->copyfrom(&actor->s());
tspr->clipdist = 0;
tspr->ownerActor = actor;
return tspr;
}

14
source/core/gamefuncs.cpp
View file

@ -182,7 +182,7 @@ void PlanesAtPoint(const sectortype* sec, int dax, int day, float* pceilz, float
// //
//========================================================================== //==========================================================================
void GetWallSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render) void GetWallSpritePosition(const tspritetype* spr, vec2_t pos, vec2_t* out, bool render)
{ {
auto tex = tileGetTexture(spr->picnum); auto tex = tileGetTexture(spr->picnum);
@ -218,7 +218,8 @@ void GetWallSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool
// //
//========================================================================== //==========================================================================
void GetFlatSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render) template<class sprt>
void TGetFlatSpritePosition(const sprt* spr, vec2_t pos, vec2_t* out, bool render)
{ {
auto tex = tileGetTexture(spr->picnum); auto tex = tileGetTexture(spr->picnum);
@ -258,6 +259,15 @@ void GetFlatSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool
out[3] = out[0] - sub; out[3] = out[0] - sub;
} }
void GetFlatSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render)
{
TGetFlatSpritePosition(spr, pos, out, render);
}
void GetFlatSpritePosition(const tspritetype* spr, vec2_t pos, vec2_t* out, bool render)
{
TGetFlatSpritePosition(spr, pos, out, render);
}
//========================================================================== //==========================================================================
// //

8
source/core/gamefuncs.h
View file

@ -124,7 +124,8 @@ inline void PlanesAtPoint(const sectortype* sec, float dax, float day, float* ce
PlanesAtPoint(sec, int(dax), int(day), ceilz, florz); PlanesAtPoint(sec, int(dax), int(day), ceilz, florz);
} }
void setWallSectors(); void setWallSectors();
void GetWallSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render = false); void GetWallSpritePosition(const tspritetype* spr, vec2_t pos, vec2_t* out, bool render = false);
void GetFlatSpritePosition(const tspritetype* spr, vec2_t pos, vec2_t* out, bool render = false);
void GetFlatSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render = false); void GetFlatSpritePosition(const spritetype* spr, vec2_t pos, vec2_t* out, bool render = false);
void checkRotatedWalls(); void checkRotatedWalls();
@ -232,6 +233,11 @@ inline void copyfloorpal(spritetype* spr, const sectortype* sect)
if (!lookups.noFloorPal(sect->floorpal)) spr->pal = sect->floorpal; if (!lookups.noFloorPal(sect->floorpal)) spr->pal = sect->floorpal;
} }
inline void copyfloorpal(tspritetype* spr, const sectortype* sect)
{
if (!lookups.noFloorPal(sect->floorpal)) spr->pal = sect->floorpal;
}
inline void spriteSetSlope(spritetype* spr, int heinum) inline void spriteSetSlope(spritetype* spr, int heinum)
{ {
if (spr->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) if (spr->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)

3
source/core/gamestruct.h
View file

@ -14,6 +14,7 @@ class FSerializer;
struct FRenderViewpoint; struct FRenderViewpoint;
struct spritetype; struct spritetype;
struct sectortype; struct sectortype;
struct tspritetype;
struct GameStats struct GameStats
{ {
@ -115,7 +116,7 @@ struct GameInterface
virtual int chaseCamX(binangle ang) { return 0; } virtual int chaseCamX(binangle ang) { return 0; }
virtual int chaseCamY(binangle ang) { return 0; } virtual int chaseCamY(binangle ang) { return 0; }
virtual int chaseCamZ(fixedhoriz horiz) { return 0; } virtual int chaseCamZ(fixedhoriz horiz) { return 0; }
virtual void processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) = 0; virtual void processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) = 0;
virtual void UpdateCameras(double smoothratio) {} virtual void UpdateCameras(double smoothratio) {}
virtual void EnterPortal(spritetype* viewer, int type) {} virtual void EnterPortal(spritetype* viewer, int type) {}
virtual void LeavePortal(spritetype* viewer, int type) {} virtual void LeavePortal(spritetype* viewer, int type) {}

4
source/core/maploader.cpp
View file

@ -387,7 +387,7 @@ void insertAllSprites(SpawnSpriteDef& sprites)
removeit = true; removeit = true;
} }
insertsprite(spr.sectnum, spr.statnum); insertsprite(spr.sectnum, spr.statnum, true);
if (removeit) if (removeit)
{ {
@ -435,7 +435,6 @@ void allocateMapArrays(int numsprites)
memset(spritesmooth, 0, sizeof(spritesmooth_t) * (MAXSPRITES + MAXUNIQHUDID)); memset(spritesmooth, 0, sizeof(spritesmooth_t) * (MAXSPRITES + MAXUNIQHUDID));
ClearAutomap(); ClearAutomap();
Polymost::Polymost_prepare_loadboard();
} }
void engineLoadBoard(const char* filename, int flags, vec3_t* pos, int16_t* ang, int* cursectnum, SpawnSpriteDef& sprites) void engineLoadBoard(const char* filename, int flags, vec3_t* pos, int16_t* ang, int* cursectnum, SpawnSpriteDef& sprites)
@ -471,6 +470,7 @@ void engineLoadBoard(const char* filename, int flags, vec3_t* pos, int16_t* ang,
allocateMapArrays(numsprites); allocateMapArrays(numsprites);
initspritelists(); // may not be used in Blood! initspritelists(); // may not be used in Blood!
sprites.sprites.Resize(numsprites); sprites.sprites.Resize(numsprites);
memset(sprites.sprites.Data(), 0, numsprites * sizeof(spritetype));
// Now load the actual data. // Now load the actual data.
fr.Seek(sectorpos, FileReader::SeekSet); fr.Seek(sectorpos, FileReader::SeekSet);

10
source/core/rendering/scene/hw_bunchdrawer.cpp
View file

@ -44,6 +44,7 @@
#include "mapinfo.h" #include "mapinfo.h"
#include "gamecontrol.h" #include "gamecontrol.h"
#include "hw_sections.h" #include "hw_sections.h"
#include "coreactor.h"
extern TArray<TArray<int>> blockingpairs; extern TArray<TArray<int>> blockingpairs;
//========================================================================== //==========================================================================
@ -559,15 +560,14 @@ void BunchDrawer::ProcessSection(int sectionnum, bool portal)
SetupSprite.Clock(); SetupSprite.Clock();
int z;
int sectnum = sections[sectionnum].sector; int sectnum = sections[sectionnum].sector;
if (!gotsector[sectnum]) if (!gotsector[sectnum])
{ {
gotsector.Set(sectnum); gotsector.Set(sectnum);
SectIterator it(sectnum); CoreSectIterator it(sectnum);
while ((z = it.NextIndex()) >= 0) while (auto actor = it.Next())
{ {
auto const spr = (uspriteptr_t)&sprite[z]; auto const spr = &actor->s();
if ((spr->cstat & CSTAT_SPRITE_INVISIBLE) || spr->xrepeat == 0 || spr->yrepeat == 0) // skip invisible sprites if ((spr->cstat & CSTAT_SPRITE_INVISIBLE) || spr->xrepeat == 0 || spr->yrepeat == 0) // skip invisible sprites
continue; continue;
@ -581,7 +581,7 @@ void BunchDrawer::ProcessSection(int sectionnum, bool portal)
(r_voxels && tiletovox[spr->picnum] >= 0 && voxmodels[tiletovox[spr->picnum]]) || (r_voxels && tiletovox[spr->picnum] >= 0 && voxmodels[tiletovox[spr->picnum]]) ||
(r_voxels && gi->Voxelize(spr->picnum) > -1) || (r_voxels && gi->Voxelize(spr->picnum) > -1) ||
DMulScale(bcos(spr->ang), -sx, bsin(spr->ang), -sy, 6) > 0) DMulScale(bcos(spr->ang), -sx, bsin(spr->ang), -sy, 6) > 0)
if (renderAddTsprite(di->tsprite, di->spritesortcnt, z, sectnum)) if (!renderAddTsprite(di->tsprite, di->spritesortcnt, actor))
break; break;
} }
} }

17
source/core/rendering/scene/hw_drawinfo.cpp
View file

@ -42,6 +42,7 @@
#include "gamestruct.h" #include "gamestruct.h"
#include "automap.h" #include "automap.h"
#include "hw_voxels.h" #include "hw_voxels.h"
#include "coreactor.h"
EXTERN_CVAR(Float, r_visibility) EXTERN_CVAR(Float, r_visibility)
CVAR(Bool, gl_no_skyclear, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG) CVAR(Bool, gl_no_skyclear, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
@ -276,19 +277,18 @@ void HWDrawInfo::DispatchSprites()
{ {
auto tspr = &tsprite[i]; auto tspr = &tsprite[i];
int tilenum = tspr->picnum; int tilenum = tspr->picnum;
int spritenum = tspr->owner; auto actor = tspr->ownerActor;
if (spritenum < 0 || (unsigned)tilenum >= MAXTILES) if (actor == nullptr || tspr->xrepeat == 0 || tspr->yrepeat == 0 || tilenum >= MAXTILES)
continue; continue;
if ((unsigned)spritenum < MAXSPRITES) actor->s().cstat2 |= CSTAT2_SPRITE_MAPPED;
sprite[spritenum].cstat2 |= CSTAT2_SPRITE_MAPPED;
tileUpdatePicnum(&tilenum, sprite->owner + 32768, 0); tileUpdatePicnum(&tilenum, (actor->GetIndex() & 16383) + 32768, 0);
tspr->picnum = tilenum; tspr->picnum = tilenum;
setgotpic(tilenum); setgotpic(tilenum);
if (!(spriteext[spritenum].flags & SPREXT_NOTMD)) if (!(actor->sx().flags & SPREXT_NOTMD))
{ {
int pt = Ptile2tile(tilenum, tspr->pal); int pt = Ptile2tile(tilenum, tspr->pal);
if (hw_models && tile2model[pt].modelid >= 0 && tile2model[pt].framenum >= 0) if (hw_models && tile2model[pt].modelid >= 0 && tile2model[pt].framenum >= 0)
@ -315,12 +315,12 @@ void HWDrawInfo::DispatchSprites()
} }
} }
if (spriteext[spritenum].flags & SPREXT_AWAY1) if (actor->sx().flags & SPREXT_AWAY1)
{ {
tspr->pos.x += bcos(tspr->ang, -13); tspr->pos.x += bcos(tspr->ang, -13);
tspr->pos.y += bsin(tspr->ang, -13); tspr->pos.y += bsin(tspr->ang, -13);
} }
else if (spriteext[spritenum].flags & SPREXT_AWAY2) else if (actor->sx().flags & SPREXT_AWAY2)
{ {
tspr->pos.x -= bcos(tspr->ang, -13); tspr->pos.x -= bcos(tspr->ang, -13);
tspr->pos.y -= bsin(tspr->ang, -13); tspr->pos.y -= bsin(tspr->ang, -13);
@ -377,6 +377,7 @@ void HWDrawInfo::CreateScene(bool portal)
screen->mVertexData->Map(); screen->mVertexData->Map();
screen->mLights->Map(); screen->mLights->Map();
memset(tsprite, 0, sizeof(tsprite));
spritesortcnt = 0; spritesortcnt = 0;
ingeo = false; ingeo = false;
geoofs = { 0,0 }; geoofs = { 0,0 };

2
source/core/rendering/scene/hw_drawinfo.h
View file

@ -108,7 +108,7 @@ struct HWDrawInfo
FRenderViewpoint Viewpoint; FRenderViewpoint Viewpoint;
HWViewpointUniforms VPUniforms; // per-viewpoint uniform state HWViewpointUniforms VPUniforms; // per-viewpoint uniform state
TArray<HWPortal *> Portals; TArray<HWPortal *> Portals;
spritetype tsprite[MAXSPRITESONSCREEN]; tspritetype tsprite[MAXSPRITESONSCREEN];
int spritesortcnt; int spritesortcnt;
// This is needed by the BSP traverser. // This is needed by the BSP traverser.

23
source/core/rendering/scene/hw_drawstructs.h
View file

@ -14,6 +14,7 @@
#include "gamecontrol.h" #include "gamecontrol.h"
#include "hw_renderstate.h" #include "hw_renderstate.h"
#include "hw_cvars.h" #include "hw_cvars.h"
#include "coreactor.h"
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(disable:4244) // this gets a bit annoying in the renderer... #pragma warning(disable:4244) // this gets a bit annoying in the renderer...
@ -187,7 +188,7 @@ public:
public: public:
walltype* seg; walltype* seg;
spritetype* Sprite; tspritetype* Sprite;
sectortype* frontsector, * backsector; sectortype* frontsector, * backsector;
//private: //private:
@ -231,7 +232,7 @@ public:
public: public:
void Process(HWDrawInfo* di, walltype* seg, sectortype* frontsector, sectortype* backsector); void Process(HWDrawInfo* di, walltype* seg, sectortype* frontsector, sectortype* backsector);
void ProcessWallSprite(HWDrawInfo* di, spritetype* spr, sectortype* frontsector); void ProcessWallSprite(HWDrawInfo* di, tspritetype* spr, sectortype* frontsector);
float PointOnSide(float x,float y) float PointOnSide(float x,float y)
{ {
@ -253,7 +254,7 @@ class HWFlat
public: public:
int section; int section;
sectortype * sec; sectortype * sec;
spritetype* Sprite; // for flat sprites. tspritetype* Sprite; // for flat sprites.
FGameTexture *texture; FGameTexture *texture;
float z; // the z position of the flat (only valid for non-sloped planes) float z; // the z position of the flat (only valid for non-sloped planes)
@ -279,7 +280,7 @@ public:
void PutFlat(HWDrawInfo* di, int whichplane); void PutFlat(HWDrawInfo* di, int whichplane);
void ProcessSector(HWDrawInfo *di, sectortype * frontsector, int sectionnum, int which = 7 /*SSRF_RENDERALL*/); // cannot use constant due to circular dependencies. void ProcessSector(HWDrawInfo *di, sectortype * frontsector, int sectionnum, int which = 7 /*SSRF_RENDERALL*/); // cannot use constant due to circular dependencies.
void ProcessFlatSprite(HWDrawInfo* di, spritetype* sprite, sectortype* sector); void ProcessFlatSprite(HWDrawInfo* di, tspritetype* sprite, sectortype* sector);
void DrawSubsectors(HWDrawInfo *di, FRenderState &state); void DrawSubsectors(HWDrawInfo *di, FRenderState &state);
void DrawFlat(HWDrawInfo* di, FRenderState& state, bool translucent); void DrawFlat(HWDrawInfo* di, FRenderState& state, bool translucent);
@ -296,7 +297,7 @@ class HWSprite
{ {
public: public:
spritetype* Sprite; tspritetype* Sprite;
PalEntry fade; PalEntry fade;
int shade, palette; int shade, palette;
float visibility; float visibility;
@ -334,8 +335,8 @@ public:
void CreateVertices(HWDrawInfo* di); void CreateVertices(HWDrawInfo* di);
void PutSprite(HWDrawInfo *di, bool translucent); void PutSprite(HWDrawInfo *di, bool translucent);
void Process(HWDrawInfo *di, spritetype* thing,sectortype * sector, int thruportal = false); void Process(HWDrawInfo *di, tspritetype* thing,sectortype * sector, int thruportal = false);
bool ProcessVoxel(HWDrawInfo* di, voxmodel_t* voxel, spritetype* tspr, sectortype* sector, bool rotate); bool ProcessVoxel(HWDrawInfo* di, voxmodel_t* voxel, tspritetype* tspr, sectortype* sector, bool rotate);
void DrawSprite(HWDrawInfo* di, FRenderState& state, bool translucent); void DrawSprite(HWDrawInfo* di, FRenderState& state, bool translucent);
}; };
@ -372,16 +373,16 @@ inline bool maskWallHasTranslucency(const walltype* wall)
return (wall->cstat & CSTAT_WALL_TRANSLUCENT) || checkTranslucentReplacement(tileGetTexture(wall->picnum)->GetID(), wall->pal); return (wall->cstat & CSTAT_WALL_TRANSLUCENT) || checkTranslucentReplacement(tileGetTexture(wall->picnum)->GetID(), wall->pal);
} }
inline bool spriteHasTranslucency(const spritetype* tspr) inline bool spriteHasTranslucency(const tspritetype* tspr)
{ {
if ((tspr->cstat & CSTAT_SPRITE_TRANSLUCENT) || //(tspr->clipdist & TSPR_FLAGS_DRAW_LAST) || if ((tspr->cstat & CSTAT_SPRITE_TRANSLUCENT) || //(tspr->clipdist & TSPR_FLAGS_DRAW_LAST) ||
((unsigned)tspr->owner < MAXSPRITES && spriteext[tspr->owner].alpha)) (tspr->ownerActor->sx().alpha))
return true; return true;
return checkTranslucentReplacement(tileGetTexture(tspr->picnum)->GetID(), tspr->pal); return checkTranslucentReplacement(tileGetTexture(tspr->picnum)->GetID(), tspr->pal);
} }
inline void SetSpriteTranslucency(const spritetype* sprite, float& alpha, FRenderStyle& RenderStyle) inline void SetSpriteTranslucency(const tspritetype* sprite, float& alpha, FRenderStyle& RenderStyle)
{ {
bool trans = (sprite->cstat & CSTAT_SPRITE_TRANSLUCENT); bool trans = (sprite->cstat & CSTAT_SPRITE_TRANSLUCENT);
if (trans) if (trans)
@ -394,7 +395,7 @@ inline void SetSpriteTranslucency(const spritetype* sprite, float& alpha, FRende
RenderStyle = LegacyRenderStyles[STYLE_Translucent]; RenderStyle = LegacyRenderStyles[STYLE_Translucent];
alpha = 1.f; alpha = 1.f;
} }
alpha *= 1.f - spriteext[sprite->owner].alpha; alpha *= 1.f - sprite->ownerActor->sx().alpha;
} }
//========================================================================== //==========================================================================

2
source/core/rendering/scene/hw_flats.cpp
View file

@ -346,7 +346,7 @@ void HWFlat::ProcessSector(HWDrawInfo *di, sectortype * frontsector, int section
} }
} }
void HWFlat::ProcessFlatSprite(HWDrawInfo* di, spritetype* sprite, sectortype* sector) void HWFlat::ProcessFlatSprite(HWDrawInfo* di, tspritetype* sprite, sectortype* sector)
{ {
int tilenum = sprite->picnum; int tilenum = sprite->picnum;
texture = tileGetTexture(tilenum); texture = tileGetTexture(tilenum);

10
source/core/rendering/scene/hw_sprites.cpp
View file

@ -311,7 +311,7 @@ inline void HWSprite::PutSprite(HWDrawInfo* di, bool translucent)
// //
//========================================================================== //==========================================================================
void HWSprite::Process(HWDrawInfo* di, spritetype* spr, sectortype* sector, int thruportal) void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int thruportal)
{ {
if (spr == nullptr) if (spr == nullptr)
return; return;
@ -445,10 +445,10 @@ void HWSprite::Process(HWDrawInfo* di, spritetype* spr, sectortype* sector, int
// //
//========================================================================== //==========================================================================
bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, spritetype* spr, sectortype* sector, bool rotate) bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, tspritetype* spr, sectortype* sector, bool rotate)
{ {
Sprite = spr; Sprite = spr;
auto sprext = &spriteext[spr->owner]; auto sprext = &spr->ownerActor->sx();
texture = nullptr; texture = nullptr;
modelframe = -1; modelframe = -1;
@ -477,7 +477,7 @@ bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, spritetype* spr, se
float basescale = voxel->bscale / 64.f; float basescale = voxel->bscale / 64.f;
float sprxscale = (float)spr->xrepeat * (256.f / 320.f) * basescale; float sprxscale = (float)spr->xrepeat * (256.f / 320.f) * basescale;
if ((::sprite[spr->owner].cstat & CSTAT_SPRITE_ALIGNMENT) == CSTAT_SPRITE_ALIGNMENT_WALL) if ((spr->ownerActor->s().cstat & CSTAT_SPRITE_ALIGNMENT) == CSTAT_SPRITE_ALIGNMENT_WALL)
{ {
sprxscale *= 1.25f; sprxscale *= 1.25f;
translatevec.Y -= spr->xoffset * bcosf(sprext->angoff, -20); translatevec.Y -= spr->xoffset * bcosf(sprext->angoff, -20);
@ -505,7 +505,7 @@ bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, spritetype* spr, se
translatevec.Z *= sprzscale; translatevec.Z *= sprzscale;
float zpos = (float)(spr->z + sprext->position_offset.z); float zpos = (float)(spr->z + sprext->position_offset.z);
float zscale = ((spr->cstat & CSTAT_SPRITE_YFLIP) && (::sprite[spr->owner].cstat & CSTAT_SPRITE_ALIGNMENT) != 0) ? -4.f : 4.f; float zscale = ((spr->cstat & CSTAT_SPRITE_YFLIP) && (spr->ownerActor->s().cstat & CSTAT_SPRITE_ALIGNMENT) != 0) ? -4.f : 4.f;
zpos -= (spr->yoffset * spr->yrepeat) * zscale * voxel->bscale; zpos -= (spr->yoffset * spr->yrepeat) * zscale * voxel->bscale;
x = (spr->x + sprext->position_offset.x) * (1 / 16.f); x = (spr->x + sprext->position_offset.x) * (1 / 16.f);

6
source/core/rendering/scene/hw_walls.cpp
View file

@ -46,7 +46,7 @@
// //
//========================================================================== //==========================================================================
static int GetClosestPointOnWall(spritetype* spr, walltype* wal, vec2_t* const n) static int GetClosestPointOnWall(tspritetype* spr, walltype* wal, vec2_t* const n)
{ {
auto w = wal->pos; auto w = wal->pos;
auto d = wal->point2Wall()->pos - w; auto d = wal->point2Wall()->pos - w;
@ -106,7 +106,7 @@ static int GetClosestPointOnWall(spritetype* spr, walltype* wal, vec2_t* const n
// //
//========================================================================== //==========================================================================
static int IsOnWall(spritetype* tspr, int height) static int IsOnWall(tspritetype* tspr, int height)
{ {
int dist = 3, closest = -1; int dist = 3, closest = -1;
auto sect = tspr->sector(); auto sect = tspr->sector();
@ -1124,7 +1124,7 @@ void HWWall::Process(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sec
} }
} }
void HWWall::ProcessWallSprite(HWDrawInfo* di, spritetype* spr, sectortype* sector) void HWWall::ProcessWallSprite(HWDrawInfo* di, tspritetype* spr, sectortype* sector)
{ {
auto tex = tileGetTexture(spr->picnum); auto tex = tileGetTexture(spr->picnum);
if (!tex || !tex->isValid()) return; if (!tex || !tex->isValid()) return;

2
source/games/blood/src/_polymost.cpp
View file

@ -49,7 +49,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
pTSprite->yoffset = pSprite->yoffset; pTSprite->yoffset = pSprite->yoffset;
pTSprite->cstat = pSprite->cstat; pTSprite->cstat = pSprite->cstat;
pTSprite->statnum = kStatDecoration; pTSprite->statnum = kStatDecoration;
pTSprite->owner = actor->GetSpriteIndex(); pTSprite->ownerActor = actor;
pTSprite->flags = pSprite->hitag | 0x200; pTSprite->flags = pSprite->hitag | 0x200;
pTSprite->x = dx + interpolatedvalue(pSprite->ox, pSprite->x, interpolation); pTSprite->x = dx + interpolatedvalue(pSprite->ox, pSprite->x, interpolation);
pTSprite->y = dy + interpolatedvalue(pSprite->oy, pSprite->y, interpolation); pTSprite->y = dy + interpolatedvalue(pSprite->oy, pSprite->y, interpolation);

49
source/games/blood/src/animatesprite.cpp
View file

@ -67,7 +67,7 @@ static void RotateXZ(int *pX, int *, int *pZ, int ang)
*pZ = dmulscale30r(oX,angSin,oZ,angCos); *pZ = dmulscale30r(oX,angSin,oZ,angCos);
} }
tspritetype* viewInsertTSprite(spritetype* tsprite, int& spritesortcnt, sectortype* pSector, int nStatnum, tspritetype const * const parentTSprite) tspritetype* viewInsertTSprite(tspritetype* tsprite, int& spritesortcnt, sectortype* pSector, int nStatnum, tspritetype const * const parentTSprite)
{ {
if (spritesortcnt >= MAXSPRITESONSCREEN) if (spritesortcnt >= MAXSPRITESONSCREEN)
return nullptr; return nullptr;
@ -78,17 +78,15 @@ tspritetype* viewInsertTSprite(spritetype* tsprite, int& spritesortcnt, sectorty
pTSprite->cstat = 128; pTSprite->cstat = 128;
pTSprite->xrepeat = 64; pTSprite->xrepeat = 64;
pTSprite->yrepeat = 64; pTSprite->yrepeat = 64;
pTSprite->owner = -1; pTSprite->ownerActor = nullptr;
pTSprite->type = -spritesortcnt; pTSprite->type = -spritesortcnt;
pTSprite->statnum = nStatnum; pTSprite->statnum = nStatnum;
pTSprite->setsector(pSector); pTSprite->setsector(pSector);
spritesortcnt++; spritesortcnt++;
if (parentTSprite) if (parentTSprite)
{ {
pTSprite->x = parentTSprite->x; pTSprite->pos = parentTSprite->pos;
pTSprite->y = parentTSprite->y; pTSprite->ownerActor = parentTSprite->ownerActor;
pTSprite->z = parentTSprite->z;
pTSprite->owner = parentTSprite->owner;
pTSprite->ang = parentTSprite->ang; pTSprite->ang = parentTSprite->ang;
} }
pTSprite->x += Cos(gCameraAng)>>25; pTSprite->x += Cos(gCameraAng)>>25;
@ -124,11 +122,11 @@ static const WEAPONICON gWeaponIcon[] = {
}; };
static tspritetype *viewAddEffect(spritetype* tsprite, int& spritesortcnt, int nTSprite, VIEW_EFFECT nViewEffect) static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int nTSprite, VIEW_EFFECT nViewEffect)
{ {
assert(nViewEffect >= 0 && nViewEffect < kViewEffectMax); assert(nViewEffect >= 0 && nViewEffect < kViewEffectMax);
auto pTSprite = &tsprite[nTSprite]; auto pTSprite = &tsprite[nTSprite];
auto owneractor = &bloodActors[pTSprite->owner]; auto owneractor = static_cast<DBloodActor*>(pTSprite->ownerActor);
if (gDetail < effectDetail[nViewEffect] || nTSprite >= MAXSPRITESONSCREEN) return NULL; if (gDetail < effectDetail[nViewEffect] || nTSprite >= MAXSPRITESONSCREEN) return NULL;
switch (nViewEffect) switch (nViewEffect)
{ {
@ -281,7 +279,7 @@ static tspritetype *viewAddEffect(spritetype* tsprite, int& spritesortcnt, int n
assert(pSector); assert(pSector);
FindSector(pNSprite->x, pNSprite->y, pNSprite->z, &pSector); FindSector(pNSprite->x, pNSprite->y, pNSprite->z, &pSector);
pNSprite->setsector(pSector); pNSprite->setsector(pSector);
pNSprite->owner = pTSprite->owner; pNSprite->ownerActor = pTSprite->ownerActor;
pNSprite->picnum = pTSprite->picnum; pNSprite->picnum = pTSprite->picnum;
pNSprite->cstat |= 2; pNSprite->cstat |= 2;
if (i < 2) if (i < 2)
@ -424,7 +422,7 @@ static tspritetype *viewAddEffect(spritetype* tsprite, int& spritesortcnt, int n
pNSprite->xrepeat = pNSprite->yrepeat = 64; pNSprite->xrepeat = pNSprite->yrepeat = 64;
pNSprite->cstat |= 106; pNSprite->cstat |= 106;
pNSprite->ang = pTSprite->ang; pNSprite->ang = pTSprite->ang;
pNSprite->owner = pTSprite->owner; pNSprite->ownerActor = pTSprite->ownerActor;
break; break;
} }
case kViewEffectFloorGlow: case kViewEffectFloorGlow:
@ -444,7 +442,7 @@ static tspritetype *viewAddEffect(spritetype* tsprite, int& spritesortcnt, int n
pNSprite->xrepeat = pNSprite->yrepeat = nShade; pNSprite->xrepeat = pNSprite->yrepeat = nShade;
pNSprite->cstat |= 98; pNSprite->cstat |= 98;
pNSprite->ang = pTSprite->ang; pNSprite->ang = pTSprite->ang;
pNSprite->owner = pTSprite->owner; pNSprite->ownerActor = pTSprite->ownerActor;
break; break;
} }
case kViewEffectSpear: case kViewEffectSpear:
@ -511,7 +509,7 @@ static void viewApplyDefaultPal(tspritetype *pTSprite, sectortype const *pSector
} }
} }
void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smoothratio) void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smoothratio)
{ {
// shift before interpolating to increase precision. // shift before interpolating to increase precision.
int myclock = (PlayClock<<3) + MulScale(4<<3, smoothratio, 16); int myclock = (PlayClock<<3) + MulScale(4<<3, smoothratio, 16);
@ -521,9 +519,9 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
for (int nTSprite = spritesortcnt-1; nTSprite >= 0; nTSprite--) for (int nTSprite = spritesortcnt-1; nTSprite >= 0; nTSprite--)
{ {
tspritetype *pTSprite = &tsprite[nTSprite]; tspritetype *pTSprite = &tsprite[nTSprite];
auto owneractor = &bloodActors[pTSprite->owner]; auto owneractor = static_cast<DBloodActor*>(pTSprite->ownerActor);
XSPRITE *pTXSprite = NULL; XSPRITE *pTXSprite = NULL;
if (sprite[pTSprite->owner].detail > gDetail) if (owneractor->s().detail > gDetail)
{ {
pTSprite->xrepeat = 0; pTSprite->xrepeat = 0;
continue; continue;
@ -547,7 +545,6 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
continue; continue;
} }
int nSprite = pTSprite->owner;
if (cl_interpolate && owneractor->interpolated && !(pTSprite->flags&512)) if (cl_interpolate && owneractor->interpolated && !(pTSprite->flags&512))
{ {
pTSprite->pos = pTSprite->interpolatedvec3(gInterpolate); pTSprite->pos = pTSprite->interpolatedvec3(gInterpolate);
@ -569,7 +566,7 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
break; break;
case 1: case 1:
{ {
if (tilehasmodelorvoxel(pTSprite->picnum, pTSprite->pal) && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if (tilehasmodelorvoxel(pTSprite->picnum, pTSprite->pal) && !(owneractor->sx().flags&SPREXT_NOTMD))
{ {
pTSprite->cstat &= ~4; pTSprite->cstat &= ~4;
break; break;
@ -591,7 +588,7 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
} }
case 2: case 2:
{ {
if (tilehasmodelorvoxel(pTSprite->picnum, pTSprite->pal) && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if (tilehasmodelorvoxel(pTSprite->picnum, pTSprite->pal) && !(owneractor->sx().flags&SPREXT_NOTMD))
{ {
pTSprite->cstat &= ~4; pTSprite->cstat &= ~4;
break; break;
@ -621,11 +618,11 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
case 6: case 6:
case 7: case 7:
{ {
if (hw_models && md_tilehasmodel(pTSprite->picnum, pTSprite->pal) >= 0 && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if (hw_models && md_tilehasmodel(pTSprite->picnum, pTSprite->pal) >= 0 && !(owneractor->sx().flags&SPREXT_NOTMD))
break; break;
// Can be overridden by def script // Can be overridden by def script
if (r_voxels && tiletovox[pTSprite->picnum] == -1 && voxelIndex[pTSprite->picnum] != -1 && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if (r_voxels && tiletovox[pTSprite->picnum] == -1 && voxelIndex[pTSprite->picnum] != -1 && !(owneractor->sx().flags&SPREXT_NOTMD))
{ {
if ((pTSprite->flags&kHitagRespawn) == 0) if ((pTSprite->flags&kHitagRespawn) == 0)
{ {
@ -648,10 +645,10 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
nAnim--; nAnim--;
} }
if ((pTSprite->cstat&48) != 48 && r_voxels && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if ((pTSprite->cstat&48) != 48 && r_voxels && !(owneractor->sx().flags&SPREXT_NOTMD))
{ {
int const nRootTile = pTSprite->picnum; int const nRootTile = pTSprite->picnum;
int nAnimTile = pTSprite->picnum + animateoffs_replace(pTSprite->picnum, 32768+pTSprite->owner); int nAnimTile = pTSprite->picnum + qanimateoffs(pTSprite->picnum, 32768 + (pTSprite->ownerActor->GetIndex() & 16383));
#if 0 #if 0
if (tiletovox[nAnimTile] != -1) if (tiletovox[nAnimTile] != -1)
@ -667,10 +664,10 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
pTSprite->cstat2 |= CSTAT2_SPRITE_MDLROTATE; // per-sprite rotation setting. pTSprite->cstat2 |= CSTAT2_SPRITE_MDLROTATE; // per-sprite rotation setting.
} }
if ((pTSprite->cstat&48) != 48 && hw_models && !(spriteext[nSprite].flags&SPREXT_NOTMD)) if ((pTSprite->cstat&48) != 48 && hw_models && !(owneractor->sx().flags&SPREXT_NOTMD))
{ {
int const nRootTile = pTSprite->picnum; int const nRootTile = pTSprite->picnum;
int nAnimTile = pTSprite->picnum + animateoffs_replace(pTSprite->picnum, 32768+pTSprite->owner); int nAnimTile = pTSprite->picnum + qanimateoffs(pTSprite->picnum, 32768 + (pTSprite->ownerActor->GetIndex() & 16383));
if (tile2model[Ptile2tile(nAnimTile, pTSprite->pal)].modelid >= 0 && if (tile2model[Ptile2tile(nAnimTile, pTSprite->pal)].modelid >= 0 &&
tile2model[Ptile2tile(nAnimTile, pTSprite->pal)].framenum >= 0) tile2model[Ptile2tile(nAnimTile, pTSprite->pal)].framenum >= 0)
@ -697,7 +694,7 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
} }
nShade += tileShade[pTSprite->picnum]; nShade += tileShade[pTSprite->picnum];
pTSprite->shade = ClipRange(nShade, -128, 127); pTSprite->shade = ClipRange(nShade, -128, 127);
if ((pTSprite->flags&kHitagRespawn) && sprite[pTSprite->owner].owner == 3) if ((pTSprite->flags&kHitagRespawn) && pTSprite->ownerActor->s().owner == 3) // Where does this 3 come from? Nothing sets it.
{ {
assert(pTXSprite != NULL); assert(pTXSprite != NULL);
pTSprite->xrepeat = 48; pTSprite->xrepeat = 48;
@ -892,7 +889,7 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
} }
} }
if (pTSprite->owner != gView->actor->GetSpriteIndex() || gViewPos != VIEWPOS_0) { if (pTSprite->ownerActor != gView->actor || gViewPos != VIEWPOS_0) {
if (getflorzofslopeptr(pTSprite->sector(), pTSprite->x, pTSprite->y) >= cZ) if (getflorzofslopeptr(pTSprite->sector(), pTSprite->x, pTSprite->y) >= cZ)
{ {
viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectShadow); viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectShadow);
@ -974,7 +971,7 @@ void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int
} }
void GameInterface::processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) void GameInterface::processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio)
{ {
viewProcessSprites(tsprite, spritesortcnt, viewx, viewy, viewz, viewang.asbuild(), int(smoothRatio)); viewProcessSprites(tsprite, spritesortcnt, viewx, viewy, viewz, viewang.asbuild(), int(smoothRatio));
} }

2
source/games/blood/src/blood.h
View file

@ -150,7 +150,7 @@ struct GameInterface : public ::GameInterface
int chaseCamX(binangle ang) override { return MulScale(-Cos(ang.asbuild()), 1280, 30); } int chaseCamX(binangle ang) override { return MulScale(-Cos(ang.asbuild()), 1280, 30); }
int chaseCamY(binangle ang) override { return MulScale(-Sin(ang.asbuild()), 1280, 30); } int chaseCamY(binangle ang) override { return MulScale(-Sin(ang.asbuild()), 1280, 30); }
int chaseCamZ(fixedhoriz horiz) override { return FixedToInt(MulScale(horiz.asq16(), 1280, 3)) - (16 << 8); } int chaseCamZ(fixedhoriz horiz) override { return FixedToInt(MulScale(horiz.asq16(), 1280, 3)) - (16 << 8); }
void processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override; void processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override;
void EnterPortal(spritetype* viewer, int type) override; void EnterPortal(spritetype* viewer, int type) override;
void LeavePortal(spritetype* viewer, int type) override; void LeavePortal(spritetype* viewer, int type) override;
void LoadGameTextures() override; void LoadGameTextures() override;

4
source/games/blood/src/db.cpp
View file

@ -352,10 +352,6 @@ void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, sect
#endif #endif
#ifdef USE_OPENGL
Polymost::Polymost_prepare_loadboard();
#endif
FString mapname = pPath; FString mapname = pPath;
DefaultExtension(mapname, ".map"); DefaultExtension(mapname, ".map");
auto fr = fileSystem.OpenFileReader(mapname); auto fr = fileSystem.OpenFileReader(mapname);

1
source/games/blood/src/loadsave.cpp
View file

@ -751,7 +751,6 @@ void GameInterface::SerializeGameState(FSerializer& arc)
viewSetErrorMessage(""); viewSetErrorMessage("");
Net_ClearFifo(); Net_ClearFifo();
paused = 0; paused = 0;
Polymost::Polymost_prepare_loadboard();
Mus_ResumeSaved(); Mus_ResumeSaved();
} }
validateLinks(); validateLinks();

1
source/games/blood/src/replace.cpp
View file

@ -66,7 +66,6 @@ int32_t qchangespritesect(int16_t nSprite, int16_t nSector);
void HookReplaceFunctions(void) void HookReplaceFunctions(void)
{ {
animateoffs_replace = qanimateoffs;
initspritelists_replace = qinitspritelists; initspritelists_replace = qinitspritelists;
changespritesect_replace = qchangespritesect; changespritesect_replace = qchangespritesect;
} }

2
source/games/blood/src/view.h
View file

@ -147,7 +147,7 @@ void viewCorrectViewOffsets(int nPlayer, vec3_t const *oldpos);
void InitStatusBar(void); void InitStatusBar(void);
void UpdateStatusBar(); void UpdateStatusBar();
void viewInit(void); void viewInit(void);
void viewProcessSprites(spritetype* tsprite, int& spritesortcnt, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smooth); void viewprocessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smooth);
void viewSetMessage(const char *pMessage, const int pal = 0, const MESSAGE_PRIORITY priority = MESSAGE_PRIORITY_NORMAL); void viewSetMessage(const char *pMessage, const int pal = 0, const MESSAGE_PRIORITY priority = MESSAGE_PRIORITY_NORMAL);

24
source/games/duke/src/animatesprites_d.cpp
View file

@ -44,9 +44,9 @@ EXTERN_CVAR(Bool, wt_commentary)
BEGIN_DUKE_NS BEGIN_DUKE_NS
void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio) void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio)
{ {
int i, j, k, p; int j, k, p;
int l, t1, t3, t4; int l, t1, t3, t4;
spritetype* s; spritetype* s;
tspritetype* t; tspritetype* t;
@ -55,8 +55,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
for (j = 0; j < spritesortcnt; j++) for (j = 0; j < spritesortcnt; j++)
{ {
t = &tsprite[j]; t = &tsprite[j];
i = t->owner; h = static_cast<DDukeActor*>(t->ownerActor);
h = &hittype[i];
s = h->s; s = h->s;
switch (t->picnum) switch (t->picnum)
@ -130,7 +129,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
case GREENSLIME + 7: case GREENSLIME + 7:
break; break;
default: default:
if (((t->cstat & 16)) || (badguy(t) && t->extra > 0) || t->statnum == 10) if (((t->cstat & 16)) || (badguypic(t->picnum) && t->extra > 0) || t->statnum == 10)
continue; continue;
} }
@ -143,8 +142,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
for (j = 0; j < spritesortcnt; j++) for (j = 0; j < spritesortcnt; j++)
{ {
t = &tsprite[j]; t = &tsprite[j];
i = t->owner; h = static_cast<DDukeActor*>(t->ownerActor);
h = &hittype[i];
s = h->s; s = h->s;
auto OwnerAc = h->GetOwner(); auto OwnerAc = h->GetOwner();
auto Owner = OwnerAc ? OwnerAc->s : nullptr; auto Owner = OwnerAc ? OwnerAc->s : nullptr;
@ -334,8 +332,8 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if ((display_mirror == 1 || screenpeek != p || !h->GetOwner()) && ud.multimode > 1 && cl_showweapon && ps[p].GetActor()->s->extra > 0 && ps[p].curr_weapon > 0) if ((display_mirror == 1 || screenpeek != p || !h->GetOwner()) && ud.multimode > 1 && cl_showweapon && ps[p].GetActor()->s->extra > 0 && ps[p].curr_weapon > 0)
{ {
auto newtspr = &tsprite[spritesortcnt]; auto newtspr = &tsprite[spritesortcnt++];
memcpy(newtspr, t, sizeof(spritetype)); newtspr = t;
newtspr->statnum = 99; newtspr->statnum = 99;
@ -378,7 +376,6 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
newtspr->yrepeat = 16; newtspr->yrepeat = 16;
} }
newtspr->pal = 0; newtspr->pal = 0;
spritesortcnt++;
} }
if (!h->GetOwner()) if (!h->GetOwner())
@ -427,7 +424,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if (h->GetOwner() && display_mirror == 0 && ps[p].over_shoulder_on == 0) if (h->GetOwner() && display_mirror == 0 && ps[p].over_shoulder_on == 0)
if (ud.multimode < 2 || (ud.multimode > 1 && p == screenpeek)) if (ud.multimode < 2 || (ud.multimode > 1 && p == screenpeek))
{ {
t->owner = -1; t->ownerActor = nullptr;
t->xrepeat = t->yrepeat = 0; t->xrepeat = t->yrepeat = 0;
continue; continue;
} }
@ -592,7 +589,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if ((s->z - daz) < (8 << 8) && ps[screenpeek].pos.z < daz) if ((s->z - daz) < (8 << 8) && ps[screenpeek].pos.z < daz)
{ {
auto shadowspr = &tsprite[spritesortcnt]; auto shadowspr = &tsprite[spritesortcnt++];
*shadowspr = *t; *shadowspr = *t;
shadowspr->statnum = 99; shadowspr->statnum = 99;
@ -620,7 +617,6 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
shadowspr->x += bcos(look, -9); shadowspr->x += bcos(look, -9);
shadowspr->y += bsin(look, -9); shadowspr->y += bsin(look, -9);
} }
spritesortcnt++;
} }
} }
@ -717,7 +713,7 @@ void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if (ud.cameraactor == nullptr) if (ud.cameraactor == nullptr)
if (screenpeek == Owner->yvel && display_mirror == 0) if (screenpeek == Owner->yvel && display_mirror == 0)
{ {
t->owner = -1; t->ownerActor = nullptr;
break; break;
} }
if ((Owner->cstat & 32768) == 0) if ((Owner->cstat & 32768) == 0)

24
source/games/duke/src/animatesprites_r.cpp
View file

@ -37,9 +37,9 @@ Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
BEGIN_DUKE_NS BEGIN_DUKE_NS
void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio) void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio)
{ {
int i, j, k, p; int j, k, p;
int l, t1, t3, t4; int l, t1, t3, t4;
spritetype* s; spritetype* s;
tspritetype* t; tspritetype* t;
@ -50,8 +50,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
for (j = 0; j < spritesortcnt; j++) for (j = 0; j < spritesortcnt; j++)
{ {
t = &tsprite[j]; t = &tsprite[j];
i = t->owner; h = static_cast<DDukeActor*>(t->ownerActor);
h = &hittype[i];
s = h->s; s = h->s;
switch (t->picnum) switch (t->picnum)
@ -108,7 +107,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
case NEON6: case NEON6:
continue; continue;
default: default:
if (((t->cstat & 16)) || (badguy(t) && t->extra > 0) || t->statnum == 10) if (((t->cstat & 16)) || (badguypic(t->picnum) && t->extra > 0) || t->statnum == 10)
{ {
if (s->sector()->shadedsector == 1 && s->statnum != 1) if (s->sector()->shadedsector == 1 && s->statnum != 1)
{ {
@ -128,8 +127,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
for (j = 0; j < spritesortcnt; j++) for (j = 0; j < spritesortcnt; j++)
{ {
t = &tsprite[j]; t = &tsprite[j];
i = t->owner; h = static_cast<DDukeActor*>(t->ownerActor);
h = &hittype[i];
s = h->s; s = h->s;
auto OwnerAc = h->GetOwner(); auto OwnerAc = h->GetOwner();
auto Owner = OwnerAc ? OwnerAc->s : nullptr; auto Owner = OwnerAc ? OwnerAc->s : nullptr;
@ -375,8 +373,8 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if ((display_mirror == 1 || screenpeek != p || !h->GetOwner()) && ud.multimode > 1 && cl_showweapon && ps[p].GetActor()->s->extra > 0 && ps[p].curr_weapon > 0) if ((display_mirror == 1 || screenpeek != p || !h->GetOwner()) && ud.multimode > 1 && cl_showweapon && ps[p].GetActor()->s->extra > 0 && ps[p].curr_weapon > 0)
{ {
auto newtspr = &tsprite[spritesortcnt]; auto newtspr = &tsprite[spritesortcnt++];
memcpy(newtspr, t, sizeof(spritetype)); newtspr = t;
newtspr->statnum = 99; newtspr->statnum = 99;
@ -422,7 +420,6 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
newtspr->yrepeat = 16; newtspr->yrepeat = 16;
} }
newtspr->pal = 0; newtspr->pal = 0;
spritesortcnt++;
} }
if (!h->GetOwner()) if (!h->GetOwner())
@ -470,7 +467,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if (h->GetOwner() && display_mirror == 0 && ps[p].over_shoulder_on == 0) if (h->GetOwner() && display_mirror == 0 && ps[p].over_shoulder_on == 0)
if (ud.multimode < 2 || (ud.multimode > 1 && p == screenpeek)) if (ud.multimode < 2 || (ud.multimode > 1 && p == screenpeek))
{ {
t->owner = -1; t->ownerActor = nullptr;
t->xrepeat = t->yrepeat = 0; t->xrepeat = t->yrepeat = 0;
continue; continue;
} }
@ -747,7 +744,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if ((s->z - daz) < (8 << 8)) if ((s->z - daz) < (8 << 8))
if (ps[screenpeek].pos.z < daz) if (ps[screenpeek].pos.z < daz)
{ {
auto shadowspr = &tsprite[spritesortcnt]; auto shadowspr = &tsprite[spritesortcnt++];
*shadowspr = *t; *shadowspr = *t;
shadowspr->statnum = 99; shadowspr->statnum = 99;
@ -775,7 +772,6 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
shadowspr->x += bcos(look, -9); shadowspr->x += bcos(look, -9);
shadowspr->y += bsin(look, -9); shadowspr->y += bsin(look, -9);
} }
spritesortcnt++;
} }
} }
} }
@ -946,7 +942,7 @@ void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int
if (ud.cameraactor == nullptr) if (ud.cameraactor == nullptr)
if (screenpeek == Owner->yvel && display_mirror == 0) if (screenpeek == Owner->yvel && display_mirror == 0)
{ {
t->owner = -1; t->ownerActor = nullptr;
break; break;
} }
if ((Owner->cstat & 32768) == 0) if ((Owner->cstat & 32768) == 0)

4
source/games/duke/src/dispatch.cpp
View file

@ -102,8 +102,8 @@ void displaymasks_d(int snum, int p, double smoothratio);
void displaymasks_r(int snum, int p, double smoothratio); void displaymasks_r(int snum, int p, double smoothratio);
void think_d(); void think_d();
void think_r(); void think_r();
void animatesprites_d(spritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio); void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio);
void animatesprites_r(spritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio); void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio);
Dispatcher fi; Dispatcher fi;

4
source/games/duke/src/duke3d.h
View file

@ -60,7 +60,7 @@ struct GameInterface : public ::GameInterface
int chaseCamX(binangle ang) { return -ang.bcos(-4); } int chaseCamX(binangle ang) { return -ang.bcos(-4); }
int chaseCamY(binangle ang) { return -ang.bsin(-4); } int chaseCamY(binangle ang) { return -ang.bsin(-4); }
int chaseCamZ(fixedhoriz horiz) { return horiz.asq16() >> 9; } int chaseCamZ(fixedhoriz horiz) { return horiz.asq16() >> 9; }
void processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override; void processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override;
void UpdateCameras(double smoothratio) override; void UpdateCameras(double smoothratio) override;
void EnterPortal(spritetype* viewer, int type) override; void EnterPortal(spritetype* viewer, int type) override;
void LeavePortal(spritetype* viewer, int type) override; void LeavePortal(spritetype* viewer, int type) override;
@ -113,7 +113,7 @@ struct Dispatcher
void (*displayweapon)(int snum, double smoothratio); void (*displayweapon)(int snum, double smoothratio);
void (*displaymasks)(int snum, int p, double smoothratio); void (*displaymasks)(int snum, int p, double smoothratio);
void (*animatesprites)(spritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio); void (*animatesprites)(tspritetype* tsprite, int& spritesortcnt, int x, int y, int a, int smoothratio);
}; };

8
source/games/duke/src/inlines.h
View file

@ -90,6 +90,14 @@ inline int ldist(const spritetype* s1, const spritetype* s2)
return(FindDistance2D(vx, vy) + 1); return(FindDistance2D(vx, vy) + 1);
} }
inline int ldist(const spritetype* s1, const tspritetype* s2)
{
int vx, vy;
vx = s1->x - s2->x;
vy = s1->y - s2->y;
return(FindDistance2D(vx, vy) + 1);
}
inline int dist(const spritetype* s1, const spritetype* s2) inline int dist(const spritetype* s1, const spritetype* s2)
{ {
int vx, vy, vz; int vx, vy, vz;

2
source/games/duke/src/render.cpp
View file

@ -433,7 +433,7 @@ bool GameInterface::GenerateSavePic()
return true; return true;
} }
void GameInterface::processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) void GameInterface::processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio)
{ {
fi.animatesprites(tsprite, spritesortcnt, viewx, viewy, viewang.asbuild(), int(smoothRatio)); fi.animatesprites(tsprite, spritesortcnt, viewx, viewy, viewang.asbuild(), int(smoothRatio));
} }

2
source/games/exhumed/src/anims.cpp
View file

@ -232,7 +232,7 @@ void AIAnim::Draw(RunListEvent* ev)
int nIndex2 = pActor->nIndex2; int nIndex2 = pActor->nIndex2;
seq_PlotSequence(ev->nParam, nIndex2, pActor->nIndex, 0x101); seq_PlotSequence(ev->nParam, nIndex2, pActor->nIndex, 0x101);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
} }
void BuildExplosion(DExhumedActor* pActor) void BuildExplosion(DExhumedActor* pActor)

2
source/games/exhumed/src/bubbles.cpp
View file

@ -113,7 +113,7 @@ void AIBubble::Draw(RunListEvent* ev)
if (!pActor) return; if (!pActor) return;
seq_PlotSequence(ev->nParam, pActor->nIndex, pActor->nFrame, 1); seq_PlotSequence(ev->nParam, pActor->nIndex, pActor->nFrame, 1);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
} }

2
source/games/exhumed/src/bullet.cpp
View file

@ -871,7 +871,7 @@ void AIBullet::Draw(RunListEvent* ev)
else else
{ {
seq_PlotSequence(ev->nParam, nSeq, BulletList[nBullet].nFrame, 0); seq_PlotSequence(ev->nParam, nSeq, BulletList[nBullet].nFrame, 0);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
} }
} }

2
source/games/exhumed/src/exhumed.h
View file

@ -240,7 +240,7 @@ struct GameInterface : public ::GameInterface
int chaseCamX(binangle ang) { return -(ang.bcos() * 3) >> 5; } int chaseCamX(binangle ang) { return -(ang.bcos() * 3) >> 5; }
int chaseCamY(binangle ang) { return -(ang.bsin() * 3) >> 5; } int chaseCamY(binangle ang) { return -(ang.bsin() * 3) >> 5; }
int chaseCamZ(fixedhoriz horiz) { return (horiz.asq16() * 3) >> 10; } int chaseCamZ(fixedhoriz horiz) { return (horiz.asq16() * 3) >> 10; }
void processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override; void processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override;
int GetCurrentSkill() override; int GetCurrentSkill() override;
::GameStats getStats() override; ::GameStats getStats() override;

2
source/games/exhumed/src/fish.cpp
View file

@ -244,7 +244,7 @@ void AIFish::Draw(RunListEvent* ev)
int nAction = pActor->nAction; int nAction = pActor->nAction;
seq_PlotSequence(ev->nParam, SeqOffsets[kSeqFish] + FishSeq[nAction].a, pActor->nFrame, FishSeq[nAction].b); seq_PlotSequence(ev->nParam, SeqOffsets[kSeqFish] + FishSeq[nAction].a, pActor->nFrame, FishSeq[nAction].b);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
return; return;
} }

2
source/games/exhumed/src/lavadude.cpp
View file

@ -167,7 +167,7 @@ void AILavaDude::Draw(RunListEvent* ev)
int nSeq = LavadudeSeq[nAction].a + SeqOffsets[kSeqLavag]; int nSeq = LavadudeSeq[nAction].a + SeqOffsets[kSeqLavag];
seq_PlotSequence(ev->nParam, nSeq, pActor->nFrame, LavadudeSeq[nAction].b); seq_PlotSequence(ev->nParam, nSeq, pActor->nFrame, LavadudeSeq[nAction].b);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
return; return;
} }

2
source/games/exhumed/src/ra.cpp
View file

@ -294,7 +294,7 @@ void AIRa::Draw(RunListEvent* ev)
int nSeq = SeqOffsets[kSeqEyeHit] + RaSeq[Ra[nPlayer].nAction].a; int nSeq = SeqOffsets[kSeqEyeHit] + RaSeq[Ra[nPlayer].nAction].a;
seq_PlotSequence(ev->nParam, nSeq, Ra[nPlayer].nFrame, 1); seq_PlotSequence(ev->nParam, nSeq, Ra[nPlayer].nFrame, 1);
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
} }

23
source/games/exhumed/src/sequence.cpp
View file

@ -561,7 +561,7 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
esi += edx; esi += edx;
int var_14 = edx + 1; int var_14 = edx + 1;
int16_t nOwner = pTSprite->owner; auto pOwner = pTSprite->ownerActor;
while (1) while (1)
{ {
@ -573,17 +573,18 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
} }
tspriteptr_t tsp = &mytsprite[(*myspritesortcnt)++]; tspriteptr_t tsp = &mytsprite[(*myspritesortcnt)++];
tsp->x = pTSprite->x; tsp->x = pTSprite->x;
tsp->y = pTSprite->y; tsp->y = pTSprite->y;
tsp->z = pTSprite->z; tsp->z = pTSprite->z;
tsp->shade = shade; tsp->shade = shade;
tsp->pal = pTSprite->pal; tsp->pal = pTSprite->pal;
tsp->xrepeat = pTSprite->xrepeat; tsp->xrepeat = pTSprite->xrepeat;
tsp->yrepeat = pTSprite->yrepeat; tsp->yrepeat = pTSprite->yrepeat;
tsp->ang = pTSprite->ang; tsp->ang = pTSprite->ang;
tsp->owner = pTSprite->owner; tsp->ownerActor = pTSprite->ownerActor;
tsp->sectnum = pTSprite->sectnum; tsp->sectnum = pTSprite->sectnum;
tsp->cstat = pTSprite->cstat |= 0x80; tsp->cstat = pTSprite->cstat |= 0x80;
tsp->cstat2 = pTSprite->cstat2;
tsp->statnum = esi; tsp->statnum = esi;
if (ChunkFlag[nBase] & 1) if (ChunkFlag[nBase] & 1)
@ -602,9 +603,9 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
nBase++; nBase++;
} }
if (!(pTSprite->cstat & 0x101) || (sprite[nOwner].statnum == 100 && nNetPlayerCount)) if (!(pTSprite->cstat & 0x101) || (pOwner->s().statnum == 100 && nNetPlayerCount))
{ {
pTSprite->owner = -1; pTSprite->ownerActor = nullptr;
} }
else else
{ {
@ -612,7 +613,7 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
int nFloorZ = pSector->floorz; int nFloorZ = pSector->floorz;
if (nFloorZ <= PlayerList[nLocalPlayer].eyelevel + initz) { if (nFloorZ <= PlayerList[nLocalPlayer].eyelevel + initz) {
pTSprite->owner = -1; pTSprite->ownerActor = nullptr;
} }
else else
{ {

2
source/games/exhumed/src/snake.cpp
View file

@ -406,7 +406,7 @@ void AISnake::Draw(RunListEvent* ev)
seq_PlotSequence(nSprite, SeqOffsets[kSeqSnakBody], 0, 0); seq_PlotSequence(nSprite, SeqOffsets[kSeqSnakBody], 0, 0);
} }
ev->pTSprite->owner = -1; ev->pTSprite->ownerActor = nullptr;
} }
END_PS_NS END_PS_NS

11
source/games/exhumed/src/view.cpp
View file

@ -64,11 +64,11 @@ DExhumedActor* pEnemy;
int nEnemyPal = 0; int nEnemyPal = 0;
// We cannot drag these through the entire event system... :( // We cannot drag these through the entire event system... :(
spritetype* mytsprite; tspritetype* mytsprite;
int* myspritesortcnt; int* myspritesortcnt;
// NOTE - not to be confused with Ken's analyzesprites() // NOTE - not to be confused with Ken's analyzesprites()
static void analyzesprites(spritetype* tsprite, int& spritesortcnt, int x, int y, int z, double const smoothratio) static void analyzesprites(tspritetype* tsprite, int& spritesortcnt, int x, int y, int z, double const smoothratio)
{ {
tspritetype *pTSprite; tspritetype *pTSprite;
@ -78,7 +78,7 @@ static void analyzesprites(spritetype* tsprite, int& spritesortcnt, int x, int y
for (int i = 0; i < spritesortcnt; i++) { for (int i = 0; i < spritesortcnt; i++) {
pTSprite = &tsprite[i]; pTSprite = &tsprite[i];
if (pTSprite->owner != -1) if (pTSprite->ownerActor)
{ {
// interpolate sprite position // interpolate sprite position
pTSprite->pos = pTSprite->interpolatedvec3(smoothratio); pTSprite->pos = pTSprite->interpolatedvec3(smoothratio);
@ -105,8 +105,7 @@ static void analyzesprites(spritetype* tsprite, int& spritesortcnt, int x, int y
for (nTSprite = spritesortcnt-1, pTSprite = &tsprite[nTSprite]; nTSprite >= 0; nTSprite--, pTSprite--) for (nTSprite = spritesortcnt-1, pTSprite = &tsprite[nTSprite]; nTSprite >= 0; nTSprite--, pTSprite--)
{ {
int nSprite = pTSprite->owner; auto pActor = static_cast<DExhumedActor*>(pTSprite->ownerActor);
auto pActor = &exhumedActors[nSprite];
spritetype *pSprite = &pActor->s(); spritetype *pSprite = &pActor->s();
if (pTSprite->sector() != nullptr) if (pTSprite->sector() != nullptr)
@ -471,7 +470,7 @@ bool GameInterface::GenerateSavePic()
return true; return true;
} }
void GameInterface::processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) void GameInterface::processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio)
{ {
analyzesprites(tsprite, spritesortcnt, viewx, viewy, viewz, smoothRatio); analyzesprites(tsprite, spritesortcnt, viewx, viewy, viewz, smoothRatio);
} }

2
source/games/exhumed/src/view.h
View file

@ -40,7 +40,7 @@ extern bool bTouchFloor;
extern int nChunkTotal; extern int nChunkTotal;
extern int gFov; extern int gFov;
extern spritetype* mytsprite; extern tspritetype* mytsprite;
extern int* myspritesortcnt; extern int* myspritesortcnt;
END_PS_NS END_PS_NS

4
source/games/sw/src/bunny.cpp
View file

@ -1158,8 +1158,6 @@ void BunnyHatch(DSWActor* actor)
auto actorNew = InsertActor(sp->sector(), STAT_DEFAULT); auto actorNew = InsertActor(sp->sector(), STAT_DEFAULT);
np = &actorNew->s(); np = &actorNew->s();
np->clear(); np->clear();
np->setsector(sp->sector());
np->statnum = STAT_DEFAULT;
np->x = sp->x; np->x = sp->x;
np->y = sp->y; np->y = sp->y;
np->z = sp->z; np->z = sp->z;
@ -1223,8 +1221,6 @@ DSWActor* BunnyHatch2(DSWActor* actor)
auto actorNew = InsertActor(wp->sector(), STAT_DEFAULT); auto actorNew = InsertActor(wp->sector(), STAT_DEFAULT);
auto np = &actorNew->s(); auto np = &actorNew->s();
np->clear(); np->clear();
np->setsector(wp->sector());
np->statnum = STAT_DEFAULT;
np->x = wp->x; np->x = wp->x;
np->y = wp->y; np->y = wp->y;
np->z = wp->z; np->z = wp->z;

188
source/games/sw/src/draw.cpp
View file

@ -70,7 +70,6 @@ extern int f_c;
extern ParentalStruct aVoxelArray[MAXTILES]; extern ParentalStruct aVoxelArray[MAXTILES];
DSWActor* ConnectCopySprite(spritetype const * tsp);
void PreDrawStackedWater(void); void PreDrawStackedWater(void);
void SW_InitMultiPsky(void) void SW_InitMultiPsky(void)
@ -99,14 +98,14 @@ ShadeSprite(tspriteptr_t tsp)
#endif #endif
int GetRotation(spritetype* tsprite, int& spritesortcnt, int tSpriteNum, int viewx, int viewy) int GetRotation(tspritetype* tsprite, int& spritesortcnt, int tSpriteNum, int viewx, int viewy)
{ {
static const uint8_t RotTable8[] = {0, 7, 6, 5, 4, 3, 2, 1}; static const uint8_t RotTable8[] = {0, 7, 6, 5, 4, 3, 2, 1};
static const uint8_t RotTable5[] = {0, 1, 2, 3, 4, 3, 2, 1}; static const uint8_t RotTable5[] = {0, 1, 2, 3, 4, 3, 2, 1};
int rotation; int rotation;
tspriteptr_t tsp = &tsprite[tSpriteNum]; tspriteptr_t tsp = &tsprite[tSpriteNum];
USERp tu = swActors[tsp->owner].u(); USERp tu = static_cast<DSWActor*>(tsp->ownerActor)->u();
int angle2; int angle2;
if (tu->RotNum == 0) if (tu->RotNum == 0)
@ -169,10 +168,10 @@ directions was not standardized.
*/ */
int SetActorRotation(spritetype* tsprite, int& spritesortcnt, int tSpriteNum, int viewx, int viewy) int SetActorRotation(tspritetype* tsprite, int& spritesortcnt, int tSpriteNum, int viewx, int viewy)
{ {
tspriteptr_t tsp = &tsprite[tSpriteNum]; tspriteptr_t tsp = &tsprite[tSpriteNum];
USERp tu = swActors[tsp->owner].u(); USERp tu = static_cast<DSWActor*>(tsp->ownerActor)->u();
int StateOffset, Rotation; int StateOffset, Rotation;
// don't modify ANY tu vars - back them up! // don't modify ANY tu vars - back them up!
@ -206,7 +205,7 @@ int SetActorRotation(spritetype* tsprite, int& spritesortcnt, int tSpriteNum, in
int DoShadowFindGroundPoint(tspriteptr_t sp) int DoShadowFindGroundPoint(tspriteptr_t sp)
{ {
// USES TSPRITE !!!!! // USES TSPRITE !!!!!
USERp u = swActors[sp->owner].u(); USERp u = static_cast<DSWActor*>(sp->ownerActor)->u();
SPRITEp hsp; SPRITEp hsp;
Collision ceilhit, florhit; Collision ceilhit, florhit;
int hiz, loz = u->loz; int hiz, loz = u->loz;
@ -259,10 +258,10 @@ int DoShadowFindGroundPoint(tspriteptr_t sp)
} }
void void
DoShadows(spritetype* tsprite, int& spritesortcnt, tspriteptr_t tsp, int viewz, int camang) DoShadows(tspritetype* tsprite, int& spritesortcnt, tspriteptr_t tsp, int viewz, int camang)
{ {
tspriteptr_t tSpr = &tsprite[spritesortcnt]; tspriteptr_t tSpr = &tsprite[spritesortcnt];
USERp tu = swActors[tsp->owner].u(); USERp tu = static_cast<DSWActor*>(tsp->ownerActor)->u();
int ground_dist = 0; int ground_dist = 0;
int view_dist = 0; int view_dist = 0;
int loz; int loz;
@ -357,9 +356,9 @@ DoShadows(spritetype* tsprite, int& spritesortcnt, tspriteptr_t tsp, int viewz,
} }
void void
DoMotionBlur(spritetype* tsprite, int& spritesortcnt, tspritetype const * const tsp) DoMotionBlur(tspritetype* tsprite, int& spritesortcnt, tspritetype const * const tsp)
{ {
USERp tu = swActors[tsp->owner].u(); USERp tu = static_cast<DSWActor*>(tsp->ownerActor)->u();
int nx,ny,nz = 0,dx,dy,dz; int nx,ny,nz = 0,dx,dy,dz;
int i, ang; int i, ang;
int xrepeat, yrepeat, repeat_adj = 0; int xrepeat, yrepeat, repeat_adj = 0;
@ -444,7 +443,7 @@ void SetVoxelSprite(SPRITEp sp, int pic)
sp->picnum = pic; sp->picnum = pic;
} }
void WarpCopySprite(spritetype* tsprite, int& spritesortcnt) void WarpCopySprite(tspritetype* tsprite, int& spritesortcnt)
{ {
SPRITEp sp1, sp2, sp; SPRITEp sp1, sp2, sp;
int spnum; int spnum;
@ -480,7 +479,7 @@ void WarpCopySprite(spritetype* tsprite, int& spritesortcnt)
if (spit->picnum == ST1) if (spit->picnum == ST1)
continue; continue;
tspriteptr_t newTSpr = renderAddTSpriteFromSprite(tsprite, spritesortcnt, itActor2->GetSpriteIndex()); tspriteptr_t newTSpr = renderAddTsprite(tsprite, spritesortcnt, itActor2);
newTSpr->statnum = 0; newTSpr->statnum = 0;
xoff = sp1->x - newTSpr->x; xoff = sp1->x - newTSpr->x;
@ -503,7 +502,7 @@ void WarpCopySprite(spritetype* tsprite, int& spritesortcnt)
if (spit->picnum == ST1) if (spit->picnum == ST1)
continue; continue;
tspriteptr_t newTSpr = renderAddTSpriteFromSprite(tsprite, spritesortcnt, itActor2->GetSpriteIndex()); tspriteptr_t newTSpr = renderAddTsprite(tsprite, spritesortcnt, itActor2);
newTSpr->statnum = 0; newTSpr->statnum = 0;
xoff = sp2->x - newTSpr->x; xoff = sp2->x - newTSpr->x;
@ -543,7 +542,74 @@ void DoStarView(tspriteptr_t tsp, USERp tu, int viewz)
} }
} }
void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, int camang) template<class sprt>
DSWActor* CopySprite(sprt const* tsp, sectortype* newsector)
{
SPRITEp sp;
auto actorNew = InsertActor(newsector, STAT_FAF_COPY);
sp = &actorNew->s();
sp->x = tsp->x;
sp->y = tsp->y;
sp->z = tsp->z;
sp->cstat = tsp->cstat;
sp->picnum = tsp->picnum;
sp->pal = tsp->pal;
sp->xrepeat = tsp->xrepeat;
sp->yrepeat = tsp->yrepeat;
sp->xoffset = tsp->xoffset;
sp->yoffset = tsp->yoffset;
sp->ang = tsp->ang;
sp->xvel = tsp->xvel;
sp->yvel = tsp->yvel;
sp->zvel = tsp->zvel;
sp->shade = tsp->shade;
RESET(sp->cstat, CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
return actorNew;
}
template<class sprt>
DSWActor* ConnectCopySprite(sprt const* tsp)
{
sectortype* newsector;
int testz;
if (FAF_ConnectCeiling(tsp->sector()))
{
newsector = tsp->sector();
testz = SPRITEp_TOS(tsp) - Z(10);
if (testz < tsp->sector()->ceilingz)
updatesectorz(tsp->x, tsp->y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sector())
{
return CopySprite(tsp, newsector);
}
}
if (FAF_ConnectFloor(tsp->sector()))
{
newsector = tsp->sector();
testz = SPRITEp_BOS(tsp) + Z(10);
if (testz > tsp->sector()->floorz)
updatesectorz(tsp->x, tsp->y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sector())
{
return CopySprite(tsp, newsector);
}
}
return nullptr;
}
void analyzesprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, int camang)
{ {
int tSpriteNum; int tSpriteNum;
int smr4, smr2; int smr4, smr2;
@ -562,9 +628,8 @@ void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int view
for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--) for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--)
{ {
int SpriteNum = tsprite[tSpriteNum].owner;
auto tActor = &swActors[SpriteNum];
tspriteptr_t tsp = &tsprite[tSpriteNum]; tspriteptr_t tsp = &tsprite[tSpriteNum];
auto tActor = static_cast<DSWActor*>(tsp->ownerActor);
tu = tActor->hasU()? tActor->u() : nullptr; tu = tActor->hasU()? tActor->u() : nullptr;
auto tsectp = tsp->sector(); auto tsectp = tsp->sector();
@ -585,7 +650,7 @@ void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int view
// don't draw these // don't draw these
if (tsp->statnum >= STAT_DONT_DRAW) if (tsp->statnum >= STAT_DONT_DRAW)
{ {
tsp->owner = -1; tsp->ownerActor = nullptr;
continue; continue;
} }
@ -752,7 +817,7 @@ void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int view
else else
{ {
// dont draw your sprite // dont draw your sprite
tsp->owner = -1; tsp->ownerActor = nullptr;
//SET(tsp->cstat, CSTAT_SPRITE_INVISIBLE); //SET(tsp->cstat, CSTAT_SPRITE_INVISIBLE);
} }
} }
@ -767,7 +832,7 @@ void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int view
} }
} }
if (OverlapDraw && FAF_ConnectArea(tsp->sector()) && tsp->owner >= 0) if (OverlapDraw && FAF_ConnectArea(tsp->sector()) && tsp->ownerActor)
{ {
ConnectCopySprite(tsp); ConnectCopySprite(tsp);
} }
@ -846,13 +911,13 @@ void analyzesprites(spritetype* tsprite, int& spritesortcnt, int viewx, int view
#if 1 #if 1
tspriteptr_t get_tsprite(spritetype* tsprite, int& spritesortcnt, int SpriteNum) tspriteptr_t get_tsprite(tspritetype* tsprite, int& spritesortcnt, DSWActor* actor)
{ {
int tSpriteNum; int tSpriteNum;
for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--) for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--)
{ {
if (tsprite[tSpriteNum].owner == SpriteNum) if (tsprite[tSpriteNum].ownerActor == actor)
return &tsprite[tSpriteNum]; return &tsprite[tSpriteNum];
} }
@ -860,23 +925,23 @@ tspriteptr_t get_tsprite(spritetype* tsprite, int& spritesortcnt, int SpriteNum)
} }
void void
post_analyzesprites(spritetype* tsprite, int& spritesortcnt) post_analyzesprites(tspritetype* tsprite, int& spritesortcnt)
{ {
int tSpriteNum; int tSpriteNum;
USERp tu; USERp tu;
for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--) for (tSpriteNum = spritesortcnt - 1; tSpriteNum >= 0; tSpriteNum--)
{ {
int SpriteNum = tsprite[tSpriteNum].owner; auto actor = static_cast<DSWActor*>(tsprite[tSpriteNum].ownerActor);
if (SpriteNum < 0) continue; // JBF: verify this is safe if (!actor) continue; // JBF: verify this is safe
tspriteptr_t tsp = &tsprite[tSpriteNum]; tspriteptr_t tsp = &tsprite[tSpriteNum];
tu = swActors[SpriteNum].u();
if (tu) if (actor->hasU())
{ {
tu = actor->u();
if (tu->ID == FIREBALL_FLAMES && tu->attachActor != nullptr) if (tu->ID == FIREBALL_FLAMES && tu->attachActor != nullptr)
{ {
tspriteptr_t const atsp = get_tsprite(tsprite, spritesortcnt, tu->attachActor->GetSpriteIndex()); tspriteptr_t const atsp = get_tsprite(tsprite, spritesortcnt, tu->attachActor);
if (!atsp) if (!atsp)
{ {
@ -1216,71 +1281,6 @@ PostDraw(void)
} }
} }
DSWActor* CopySprite(spritetype const * tsp, sectortype* newsector)
{
SPRITEp sp;
auto actorNew = InsertActor(newsector, STAT_FAF_COPY);
sp = &actorNew->s();
sp->x = tsp->x;
sp->y = tsp->y;
sp->z = tsp->z;
sp->cstat = tsp->cstat;
sp->picnum = tsp->picnum;
sp->pal = tsp->pal;
sp->xrepeat = tsp->xrepeat;
sp->yrepeat = tsp->yrepeat;
sp->xoffset = tsp->xoffset;
sp->yoffset = tsp->yoffset;
sp->ang = tsp->ang;
sp->xvel = tsp->xvel;
sp->yvel = tsp->yvel;
sp->zvel = tsp->zvel;
sp->shade = tsp->shade;
RESET(sp->cstat, CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
return actorNew;
}
DSWActor* ConnectCopySprite(spritetype const * tsp)
{
sectortype* newsector;
int testz;
if (FAF_ConnectCeiling(tsp->sector()))
{
newsector = tsp->sector();
testz = SPRITEp_TOS(tsp) - Z(10);
if (testz < tsp->sector()->ceilingz)
updatesectorz(tsp->x, tsp->y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sector())
{
return CopySprite(tsp, newsector);
}
}
if (FAF_ConnectFloor(tsp->sector()))
{
newsector = tsp->sector();
testz = SPRITEp_BOS(tsp) + Z(10);
if (testz > tsp->sector()->floorz)
updatesectorz(tsp->x, tsp->y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sector())
{
return CopySprite(tsp, newsector);
}
}
return nullptr;
}
void PreDrawStackedWater(void) void PreDrawStackedWater(void)
{ {
SWStatIterator it(STAT_CEILING_FLOOR_PIC_OVERRIDE); SWStatIterator it(STAT_CEILING_FLOOR_PIC_OVERRIDE);
@ -1303,7 +1303,7 @@ void PreDrawStackedWater(void)
if (u->xchange == -989898) if (u->xchange == -989898)
continue; continue;
auto actorNew = ConnectCopySprite((spritetype const *)sp); auto actorNew = ConnectCopySprite(sp);
if (actorNew != nullptr) if (actorNew != nullptr)
{ {
// spawn a user // spawn a user
@ -1863,7 +1863,7 @@ bool GameInterface::DrawAutomapPlayer(int mx, int my, int cposx, int cposy, int
return true; return true;
} }
void GameInterface::processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) void GameInterface::processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio)
{ {
analyzesprites(tsprite, spritesortcnt, viewx, viewy, viewz, viewang.asbuild()); analyzesprites(tsprite, spritesortcnt, viewx, viewy, viewz, viewang.asbuild());
post_analyzesprites(tsprite, spritesortcnt); post_analyzesprites(tsprite, spritesortcnt);

23
source/games/sw/src/game.h
View file

@ -253,6 +253,17 @@ inline int SPRITEp_SIZE_Z(const spritetype* sp)
return (tileHeight(sp->picnum) * sp->yrepeat) << 2; return (tileHeight(sp->picnum) * sp->yrepeat) << 2;
} }
inline int SPRITEp_SIZE_Y(const tspritetype* sp)
{
return MulScale(tileHeight(sp->picnum), sp->yrepeat, 6);
}
inline int SPRITEp_SIZE_Z(const tspritetype* sp)
{
return (tileHeight(sp->picnum) * sp->yrepeat) << 2;
}
// Given a z height and sprite return the correct y repeat value // Given a z height and sprite return the correct y repeat value
inline int SPRITEp_SIZE_Z_2_YREPEAT(const spritetype* sp, int zh) inline int SPRITEp_SIZE_Z_2_YREPEAT(const spritetype* sp, int zh)
@ -267,11 +278,21 @@ inline int SPRITEp_SIZE_TOS(const spritetype* sp)
return (DIV2(SPRITEp_SIZE_Z(sp)) + (tileTopOffset(sp->picnum) << 8)); return (DIV2(SPRITEp_SIZE_Z(sp)) + (tileTopOffset(sp->picnum) << 8));
} }
inline int SPRITEp_SIZE_TOS(const tspritetype* sp)
{
return (DIV2(SPRITEp_SIZE_Z(sp)) + (tileTopOffset(sp->picnum) << 8));
}
inline int SPRITEp_SIZE_BOS(const spritetype* sp) inline int SPRITEp_SIZE_BOS(const spritetype* sp)
{ {
return (DIV2(SPRITEp_SIZE_Z(sp)) - (tileTopOffset(sp->picnum) << 8)); return (DIV2(SPRITEp_SIZE_Z(sp)) - (tileTopOffset(sp->picnum) << 8));
} }
inline int SPRITEp_SIZE_BOS(const tspritetype* sp)
{
return (DIV2(SPRITEp_SIZE_Z(sp)) - (tileTopOffset(sp->picnum) << 8));
}
// actual Z for TOS and BOS - handles both WYSIWYG and old style // actual Z for TOS and BOS - handles both WYSIWYG and old style
#define SPRITEp_TOS(sp) (TEST((sp)->cstat, CSTAT_SPRITE_YCENTER) ? \ #define SPRITEp_TOS(sp) (TEST((sp)->cstat, CSTAT_SPRITE_YCENTER) ? \
((sp)->z - SPRITEp_SIZE_TOS(sp)) : \ ((sp)->z - SPRITEp_SIZE_TOS(sp)) : \
@ -2153,7 +2174,7 @@ struct GameInterface : public ::GameInterface
int chaseCamX(binangle ang) override { return -ang.bcos(-3); } int chaseCamX(binangle ang) override { return -ang.bcos(-3); }
int chaseCamY(binangle ang) override { return -ang.bsin(-3); } int chaseCamY(binangle ang) override { return -ang.bsin(-3); }
int chaseCamZ(fixedhoriz horiz) override { return horiz.asq16() >> 8; } int chaseCamZ(fixedhoriz horiz) override { return horiz.asq16() >> 8; }
void processSprites(spritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override; void processSprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int viewy, int viewz, binangle viewang, double smoothRatio) override;
void UpdateCameras(double smoothratio) override; void UpdateCameras(double smoothratio) override;
void EnterPortal(spritetype* viewer, int type) override; void EnterPortal(spritetype* viewer, int type) override;
void LeavePortal(spritetype* viewer, int type) override; void LeavePortal(spritetype* viewer, int type) override;

4
source/games/sw/src/jsector.cpp
View file

@ -868,7 +868,7 @@ JAnalyzeSprites(tspriteptr_t tspr)
//if (bVoxelsOn) //if (bVoxelsOn)
if (r_voxels) if (r_voxels)
{ {
if (aVoxelArray[tspr->picnum].Voxel >= 0 && !(spriteext[tspr->owner].flags & SPREXT_NOTMD)) if (aVoxelArray[tspr->picnum].Voxel >= 0 && !(tspr->ownerActor->sx().flags & SPREXT_NOTMD))
{ {
// Turn on voxels // Turn on voxels
tspr->picnum = aVoxelArray[tspr->picnum].Voxel; // Get the voxel number tspr->picnum = aVoxelArray[tspr->picnum].Voxel; // Get the voxel number
@ -881,7 +881,7 @@ JAnalyzeSprites(tspriteptr_t tspr)
{ {
case 764: // Gun barrel case 764: // Gun barrel
if (!r_voxels || (spriteext[tspr->owner].flags & SPREXT_NOTMD)) if (!r_voxels || (tspr->ownerActor->sx().flags & SPREXT_NOTMD))
{ {
tspr->cstat |= 16; tspr->cstat |= 16;
break; break;

2
source/games/sw/src/ripper.cpp
View file

@ -1220,8 +1220,6 @@ void RipperHatch(DSWActor* actor)
np = &actorNew->s(); np = &actorNew->s();
np->clear(); np->clear();
ClearOwner(actorNew); ClearOwner(actorNew);
np->setsector(wp->sector());
np->statnum = STAT_DEFAULT;
np->x = wp->x; np->x = wp->x;
np->y = wp->y; np->y = wp->y;
np->z = wp->z; np->z = wp->z;

2
source/games/sw/src/ripper2.cpp
View file

@ -1238,8 +1238,6 @@ void Ripper2Hatch(DSWActor* actor)
np = &actorNew->s(); np = &actorNew->s();
np->clear(); np->clear();
ClearOwner(actorNew); ClearOwner(actorNew);
np->setsector(wp->sector());
np->statnum = STAT_DEFAULT;
np->x = wp->x; np->x = wp->x;
np->y = wp->y; np->y = wp->y;
np->z = wp->z; np->z = wp->z;

4
source/games/sw/src/sprite.cpp
View file

@ -775,10 +775,8 @@ void KillActor(DSWActor* actor)
soundEngine->RelinkSound(SOURCE_Actor, &actor->s(), nullptr, &pos); soundEngine->RelinkSound(SOURCE_Actor, &actor->s(), nullptr, &pos);
deletesprite(actor->GetSpriteIndex()); deletesprite(actor->GetSpriteIndex());
// shred your garbage - but not statnum and sectnum, which the backend needs to manage the sprite. // shred your garbage
sp->clear(); sp->clear();
sp->statnum = MAXSTATUS;
sp->sectnum = MAXSECTORS;
// Kill references in all users - slow but unavoidable if we don't want the game to crash on stale pointers. // Kill references in all users - slow but unavoidable if we don't want the game to crash on stale pointers.
SWSpriteIterator it; SWSpriteIterator it;