zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-06-04 11:11:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

- renaming spritetype::pos

Browse source
This commit is contained in:
Christoph Oelckers 2022-02-02 18:59:37 +01:00
parent ad9931081e
commit dc94dedc6b
23 changed files with 251 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

48
source/core/coreactor.h
View file

@ -72,91 +72,91 @@ public:
void copy_pos(const DCoreActor* other) void copy_pos(const DCoreActor* other)
{ {
spr.pos = other->spr.pos; spr.__int_pos = other->spr.__int_pos;
} }
const vec3_t int_pos() const const vec3_t int_pos() const
{ {
return spr.pos; return spr.__int_pos;
} }
void set_int_z(int z) void set_int_z(int z)
{ {
spr.pos.Z = z; spr.__int_pos.Z = z;
} }
void add_int_z(int z) void add_int_z(int z)
{ {
spr.pos.Z += z; spr.__int_pos.Z += z;
} }
void add_int_pos(const vec3_t& add) void add_int_pos(const vec3_t& add)
{ {
spr.pos += add; spr.__int_pos += add;
} }
void set_int_pos(const vec3_t& add) void set_int_pos(const vec3_t& add)
{ {
spr.pos = add; spr.__int_pos = add;
} }
void copy_int_xy(DCoreActor* other) void copy_int_xy(DCoreActor* other)
{ {
spr.pos.X = other->spr.pos.X; spr.__int_pos.X = other->spr.__int_pos.X;
spr.pos.Y = other->spr.pos.Y; spr.__int_pos.Y = other->spr.__int_pos.Y;
} }
void set_int_xy(int x, int y) void set_int_xy(int x, int y)
{ {
spr.pos.X = x; spr.__int_pos.X = x;
spr.pos.Y = y; spr.__int_pos.Y = y;
} }
DVector3 float_pos() const DVector3 float_pos() const
{ {
return { spr.pos.X * inttoworld, spr.pos.Y * inttoworld, spr.pos.Z * zinttoworld }; return { spr.__int_pos.X * inttoworld, spr.__int_pos.Y * inttoworld, spr.__int_pos.Z * zinttoworld };
} }
void set_float_pos(const DVector3& pos) void set_float_pos(const DVector3& pos)
{ {
spr.pos = { int(pos.X * worldtoint), int(pos.Y * worldtoint), int(pos.Z * zworldtoint) }; spr.__int_pos = { int(pos.X * worldtoint), int(pos.Y * worldtoint), int(pos.Z * zworldtoint) };
} }
void add_float_pos(const DVector3& pos) void add_float_pos(const DVector3& pos)
{ {
spr.pos += { int(pos.X * worldtoint), int(pos.Y * worldtoint), int(pos.Z * zworldtoint) }; spr.__int_pos += { int(pos.X * worldtoint), int(pos.Y * worldtoint), int(pos.Z * zworldtoint) };
} }
void set_float_z(int z) void set_float_z(int z)
{ {
spr.pos.Z = int(z * zworldtoint); spr.__int_pos.Z = int(z * zworldtoint);
} }
void add_float_z(int z) void add_float_z(int z)
{ {
spr.pos.Z += int(z * zworldtoint); spr.__int_pos.Z += int(z * zworldtoint);
} }
// Same as above but with invertex y and z axes to match the renderer's coordinate system. // Same as above but with invertex y and z axes to match the renderer's coordinate system.
DVector3 render_pos() const DVector3 render_pos() const
{ {
return { spr.pos.X * inttoworld, -spr.pos.Y * inttoworld, -spr.pos.Z * zinttoworld }; return { spr.__int_pos.X * inttoworld, -spr.__int_pos.Y * inttoworld, -spr.__int_pos.Z * zinttoworld };
} }
int32_t interpolatedx(double const smoothratio, int const scale = 16) int32_t interpolatedx(double const smoothratio, int const scale = 16)
{ {
return interpolatedvalue(opos.X, spr.pos.X, smoothratio, scale); return interpolatedvalue(opos.X, spr.__int_pos.X, smoothratio, scale);
} }
int32_t interpolatedy(double const smoothratio, int const scale = 16) int32_t interpolatedy(double const smoothratio, int const scale = 16)
{ {
return interpolatedvalue(opos.Y, spr.pos.Y, smoothratio, scale); return interpolatedvalue(opos.Y, spr.__int_pos.Y, smoothratio, scale);
} }
int32_t interpolatedz(double const smoothratio, int const scale = 16) int32_t interpolatedz(double const smoothratio, int const scale = 16)
{ {
return interpolatedvalue(opos.Z, spr.pos.Z, smoothratio, scale); return interpolatedvalue(opos.Z, spr.__int_pos.Z, smoothratio, scale);
} }
vec2_t interpolatedvec2(double const smoothratio, int const scale = 16) vec2_t interpolatedvec2(double const smoothratio, int const scale = 16)
@ -185,27 +185,27 @@ public:
void backupx() void backupx()
{ {
opos.X = spr.pos.X; opos.X = spr.__int_pos.X;
} }
void backupy() void backupy()
{ {
opos.Y = spr.pos.Y; opos.Y = spr.__int_pos.Y;
} }
void backupz() void backupz()
{ {
opos.Z = spr.pos.Z; opos.Z = spr.__int_pos.Z;
} }
void backupvec2() void backupvec2()
{ {
opos.vec2 = spr.pos.vec2; opos.vec2 = spr.__int_pos.vec2;
} }
void backuppos() void backuppos()
{ {
opos = spr.pos; opos = spr.__int_pos;
} }
void backupang() void backupang()

4
source/core/gamefuncs.cpp
View file

@ -377,7 +377,7 @@ void TGetFlatSpritePosition(const spritetypebase* spr, vec2_t pos, vec2_t* out,
{ {
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
int spos = DMulScale(-sinang, out[i].Y - spr->pos.Y, -cosang, out[i].X - spr->pos.X, 4); int spos = DMulScale(-sinang, out[i].Y - pos.Y, -cosang, out[i].X - pos.X, 4);
outz[i] = MulScale(heinum, spos, 18); outz[i] = MulScale(heinum, spos, 18);
} }
} }
@ -557,7 +557,7 @@ tspritetype* renderAddTsprite(tspriteArray& tsprites, DCoreActor* actor)
{ {
auto tspr = tsprites.newTSprite(); auto tspr = tsprites.newTSprite();
tspr->pos = actor->int_pos(); tspr->__int_pos = actor->int_pos();
tspr->cstat = actor->spr.cstat; tspr->cstat = actor->spr.cstat;
tspr->picnum = actor->spr.picnum; tspr->picnum = actor->spr.picnum;
tspr->shade = actor->spr.shade; tspr->shade = actor->spr.shade;

6
source/core/gamefuncs.h
View file

@ -322,10 +322,10 @@ inline int tspriteGetSlope(const tspritetype* spr)
inline int32_t tspriteGetZOfSlope(const tspritetype* tspr, int dax, int day) inline int32_t tspriteGetZOfSlope(const tspritetype* tspr, int dax, int day)
{ {
int heinum = tspriteGetSlope(tspr); int heinum = tspriteGetSlope(tspr);
if (heinum == 0) return tspr->pos.Z; if (heinum == 0) return tspr->__int_pos.Z;
int const j = DMulScale(bsin(tspr->ang + 1024), day - tspr->pos.Y, -bsin(tspr->ang + 512), dax - tspr->pos.X, 4); int const j = DMulScale(bsin(tspr->ang + 1024), day - tspr->__int_pos.Y, -bsin(tspr->ang + 512), dax - tspr->__int_pos.X, 4);
return tspr->pos.Z + MulScale(heinum, j, 18); return tspr->__int_pos.Z + MulScale(heinum, j, 18);
} }
inline int inside(int x, int y, const sectortype* sect) inline int inside(int x, int y, const sectortype* sect)

25
source/core/maploader.cpp
View file

@ -257,38 +257,39 @@ static void SetWallPalV5()
} }
} }
void validateSprite(spritetype& spr, int sectnum, int index) void validateSprite(spritetype& spri, int sectnum, int index)
{ {
auto pos = spri.__int_pos;
bool bugged = false; bool bugged = false;
if ((unsigned)spr.statnum >= MAXSTATUS) if ((unsigned)spri.statnum >= MAXSTATUS)
{ {
Printf("Sprite #%d (%d,%d) has invalid statnum %d.\n", index, spr.pos.X, spr.pos.Y, spr.statnum); Printf("Sprite #%d (%d,%d) has invalid statnum %d.\n", index, pos.X, pos.Y, spri.statnum);
bugged = true; bugged = true;
} }
else if ((unsigned)spr.picnum >= MAXTILES) else if ((unsigned)spri.picnum >= MAXTILES)
{ {
Printf("Sprite #%d (%d,%d) has invalid picnum %d.\n", index, spr.pos.X, spr.pos.Y, spr.picnum); Printf("Sprite #%d (%d,%d) has invalid picnum %d.\n", index, pos.X, pos.Y, spri.picnum);
bugged = true; bugged = true;
} }
else if (!validSectorIndex(sectnum)) else if (!validSectorIndex(sectnum))
{ {
sectnum = -1; sectnum = -1;
updatesector(spr.pos.X, spr.pos.Y, &sectnum); updatesector(pos.X, pos.Y, &sectnum);
bugged = sectnum < 0; bugged = sectnum < 0;
if (!DPrintf(DMSG_WARNING, "Sprite #%d (%d,%d) with invalid sector %d was corrected to sector %d\n", index, spr.pos.X, spr.pos.Y, sectnum, sectnum)) if (!DPrintf(DMSG_WARNING, "Sprite #%d (%d,%d) with invalid sector %d was corrected to sector %d\n", index, pos.X, pos.Y, sectnum, sectnum))
{ {
if (bugged) Printf("Sprite #%d (%d,%d) with invalid sector %d\n", index, spr.pos.X, spr.pos.Y, sectnum); if (bugged) Printf("Sprite #%d (%d,%d) with invalid sector %d\n", index, pos.X, pos.Y, sectnum);
} }
} }
if (bugged) if (bugged)
{ {
spr = {}; spri = {};
spr.statnum = MAXSTATUS; spri.statnum = MAXSTATUS;
sectnum = -1; sectnum = -1;
} }
if (sectnum >= 0) spr.sectp = &sector[sectnum]; if (sectnum >= 0) spri.sectp = &sector[sectnum];
else spr.sectp = nullptr; else spri.sectp = nullptr;
} }
static void ReadSpriteV7(FileReader& fr, spritetype& spr, int& secno) static void ReadSpriteV7(FileReader& fr, spritetype& spr, int& secno)

14
source/core/maptypes.h
View file

@ -445,7 +445,7 @@ struct walltype
struct spritetypebase struct spritetypebase
{ {
vec3_t pos; vec3_t __int_pos;
sectortype* sectp; sectortype* sectp;
@ -473,7 +473,7 @@ struct spritetypebase
void SetMapPos(int x, int y, int z) void SetMapPos(int x, int y, int z)
{ {
pos = { x, y, z }; __int_pos = { x, y, z };
} }
}; };
@ -494,6 +494,16 @@ struct tspritetype : public spritetypebase
{ {
DCoreActor* ownerActor; DCoreActor* ownerActor;
int time; int time;
const vec3_t int_pos() const
{
return __int_pos;
}
void set_int_pos(const vec3_t& pos)
{
__int_pos = pos;
}
}; };
class tspriteArray class tspriteArray

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

@ -318,13 +318,13 @@ void HWDrawInfo::DispatchSprites()
if (actor->sprext.renderflags & SPREXT_AWAY1) if (actor->sprext.renderflags & SPREXT_AWAY1)
{ {
tspr->pos.X += bcos(tspr->ang, -13); tspr->__int_pos.X += bcos(tspr->ang, -13);
tspr->pos.Y += bsin(tspr->ang, -13); tspr->__int_pos.Y += bsin(tspr->ang, -13);
} }
else if (actor->sprext.renderflags & SPREXT_AWAY2) else if (actor->sprext.renderflags & SPREXT_AWAY2)
{ {
tspr->pos.X -= bcos(tspr->ang, -13); tspr->__int_pos.X -= bcos(tspr->ang, -13);
tspr->pos.Y -= bsin(tspr->ang, -13); tspr->__int_pos.Y -= bsin(tspr->ang, -13);
} }
switch (tspr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) switch (tspr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK)

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

@ -124,7 +124,7 @@ void HWFlat::MakeVertices(HWDrawInfo* di)
int ofsz[4]; int ofsz[4];
auto cstat = Sprite->cstat; auto cstat = Sprite->cstat;
if (tspriteGetSlope(Sprite)) cstat &= ~CSTAT_SPRITE_YFLIP; // NBlood doesn't y-flip slope sprites. if (tspriteGetSlope(Sprite)) cstat &= ~CSTAT_SPRITE_YFLIP; // NBlood doesn't y-flip slope sprites.
GetFlatSpritePosition(Sprite, Sprite->pos.vec2, pos, ofsz, true); GetFlatSpritePosition(Sprite, Sprite->__int_pos.vec2, pos, ofsz, true);
Sprite->cstat = cstat; Sprite->cstat = cstat;
auto ret = screen->mVertexData->AllocVertices(6); auto ret = screen->mVertexData->AllocVertices(6);
@ -177,7 +177,7 @@ void HWFlat::MakeVertices(HWDrawInfo* di)
auto svp = &di->SlopeSpriteVertices[svi]; auto svp = &di->SlopeSpriteVertices[svi];
auto& vpt = di->Viewpoint; auto& vpt = di->Viewpoint;
depth = (float)((Sprite->pos.X * (1/16.f) - vpt.Pos.X) * vpt.TanCos + (Sprite->pos.Y * (1 / -16.f) - vpt.Pos.Y) * vpt.TanSin); depth = (float)((Sprite->__int_pos.X * (1/16.f) - vpt.Pos.X) * vpt.TanCos + (Sprite->__int_pos.Y * (1 / -16.f) - vpt.Pos.Y) * vpt.TanSin);
for (unsigned j = 0; j < 4; j++) for (unsigned j = 0; j < 4; j++)
{ {
@ -421,12 +421,12 @@ void HWFlat::ProcessFlatSprite(HWDrawInfo* di, tspritetype* sprite, sectortype*
int tilenum = sprite->picnum; int tilenum = sprite->picnum;
texture = tileGetTexture(tilenum); texture = tileGetTexture(tilenum);
bool belowfloor = false; bool belowfloor = false;
if (sprite->pos.Z > sprite->sectp->floorz) if (sprite->__int_pos.Z > sprite->sectp->floorz)
{ {
belowfloor = true; belowfloor = true;
sprite->pos.Z = sprite->sectp->floorz; sprite->__int_pos.Z = sprite->sectp->floorz;
} }
z = sprite->pos.Z * (1 / -256.f); z = sprite->__int_pos.Z * (1 / -256.f);
if (z == di->Viewpoint.Pos.Z) return; // looking right at the edge. if (z == di->Viewpoint.Pos.Z) return; // looking right at the edge.
dynlightindex = -1; dynlightindex = -1;

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

@ -332,9 +332,9 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
SetSpriteTranslucency(spr, alpha, RenderStyle); SetSpriteTranslucency(spr, alpha, RenderStyle);
x = spr->pos.X * (1 / 16.f); x = spr->__int_pos.X * (1 / 16.f);
z = spr->pos.Z * (1 / -256.f); z = spr->__int_pos.Z * (1 / -256.f);
y = spr->pos.Y * (1 / -16.f); y = spr->__int_pos.Y * (1 / -16.f);
auto vp = di->Viewpoint; auto vp = di->Viewpoint;
if ((vp.Pos.XY() - DVector2(x, y)).LengthSquared() < 0.125) return; if ((vp.Pos.XY() - DVector2(x, y)).LengthSquared() < 0.125) return;
@ -395,9 +395,9 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
float viewvecX = vp.ViewVector.X; float viewvecX = vp.ViewVector.X;
float viewvecY = vp.ViewVector.Y; float viewvecY = vp.ViewVector.Y;
x = spr->pos.X * (1 / 16.f); x = spr->__int_pos.X * (1 / 16.f);
y = spr->pos.Y * (1 / -16.f); y = spr->__int_pos.Y * (1 / -16.f);
z = spr->pos.Z * (1 / -256.f); z = spr->__int_pos.Z * (1 / -256.f);
x1 = x - viewvecY * (xoff - (width * 0.5f)); x1 = x - viewvecY * (xoff - (width * 0.5f));
x2 = x - viewvecY * (xoff + (width * 0.5f)); x2 = x - viewvecY * (xoff + (width * 0.5f));
@ -504,13 +504,13 @@ bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, tspritetype* spr, s
scalevec.Z *= sprzscale; scalevec.Z *= sprzscale;
translatevec.Z *= sprzscale; translatevec.Z *= sprzscale;
float zpos = (float)(spr->pos.Z + ownerActor->sprext.position_offset.Z); float zpos = (float)(spr->__int_pos.Z + ownerActor->sprext.position_offset.Z);
float zscale = ((spr->cstat & CSTAT_SPRITE_YFLIP) && (spr->ownerActor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != 0) ? -4.f : 4.f; float zscale = ((spr->cstat & CSTAT_SPRITE_YFLIP) && (spr->ownerActor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != 0) ? -4.f : 4.f;
zpos -= (spr->yoffset * spr->yrepeat) * zscale * voxel->bscale; zpos -= (spr->yoffset * spr->yrepeat) * zscale * voxel->bscale;
x = (spr->pos.X + ownerActor->sprext.position_offset.X) * (1 / 16.f); x = (spr->__int_pos.X + ownerActor->sprext.position_offset.X) * (1 / 16.f);
z = zpos * (1 / -256.f); z = zpos * (1 / -256.f);
y = (spr->pos.Y + ownerActor->sprext.position_offset.Y) * (1 / -16.f); y = (spr->__int_pos.Y + ownerActor->sprext.position_offset.Y) * (1 / -16.f);
float zoff = voxel->siz.Z * .5f; float zoff = voxel->siz.Z * .5f;
if (!(spr->cstat & CSTAT_SPRITE_YCENTER)) if (!(spr->cstat & CSTAT_SPRITE_YCENTER))

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

@ -55,8 +55,8 @@ static walltype* IsOnWall(tspritetype* tspr, int height, DVector2& outpos)
auto sect = tspr->sectp; auto sect = tspr->sectp;
float tx = tspr->pos.X * (float)inttoworld; float tx = tspr->__int_pos.X * (float)inttoworld;
float ty = tspr->pos.Y * (float)inttoworld; float ty = tspr->__int_pos.Y * (float)inttoworld;
for(auto& wal : wallsofsector(sect)) for(auto& wal : wallsofsector(sect))
{ {
@ -1102,7 +1102,7 @@ void HWWall::Process(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sec
int HWWall::CheckWallSprite(tspritetype* spr, tspritetype* last) int HWWall::CheckWallSprite(tspritetype* spr, tspritetype* last)
{ {
// If the position changed we need to recalculate everything. // If the position changed we need to recalculate everything.
if (spr->pos.X != last->pos.X || spr->pos.Y != last->pos.Y || spr->sectp != last->sectp || spr->ang != last->ang) return 3; if (spr->__int_pos.X != last->__int_pos.X || spr->__int_pos.Y != last->__int_pos.Y || spr->sectp != last->sectp || spr->ang != last->ang) return 3;
// if the horizontal orientation changes we need to recalculate the walls this attaches to, but not the positioning. // if the horizontal orientation changes we need to recalculate the walls this attaches to, but not the positioning.
if (spr->xrepeat != last->xrepeat || spr->xoffset != last->xoffset || spr->picnum != last->picnum || ((spr->cstat ^ last->cstat) & CSTAT_SPRITE_XFLIP)) return 2; if (spr->xrepeat != last->xrepeat || spr->xoffset != last->xoffset || spr->picnum != last->picnum || ((spr->cstat ^ last->cstat) & CSTAT_SPRITE_XFLIP)) return 2;
@ -1128,9 +1128,9 @@ void HWWall::ProcessWallSprite(HWDrawInfo* di, tspritetype* spr, sectortype* sec
seg = nullptr; seg = nullptr;
Sprite = spr; Sprite = spr;
vec2_t pos[2]; vec2_t pos[2];
int sprz = spr->pos.Z; int sprz = spr->__int_pos.Z;
GetWallSpritePosition(spr, spr->pos.vec2, pos, true); GetWallSpritePosition(spr, spr->__int_pos.vec2, pos, true);
glseg.x1 = pos[0].X * (1 / 16.f); glseg.x1 = pos[0].X * (1 / 16.f);
glseg.y1 = pos[0].Y * (1 / -16.f); glseg.y1 = pos[0].Y * (1 / -16.f);
glseg.x2 = pos[1].X * (1 / 16.f); glseg.x2 = pos[1].X * (1 / 16.f);

6
source/core/savegamehelp.cpp
View file

@ -446,9 +446,9 @@ FSerializer &Serialize(FSerializer &arc, const char *key, spritetype &c, spritet
def = &zsp; // always delta against 0 def = &zsp; // always delta against 0
if (arc.BeginObject(key)) if (arc.BeginObject(key))
{ {
arc("x", c.pos.X, def->pos.X) arc("x", c.__int_pos.X, def->__int_pos.X)
("y", c.pos.Y, def->pos.Y) ("y", c.__int_pos.Y, def->__int_pos.Y)
("z", c.pos.Z, def->pos.Z) ("z", c.__int_pos.Z, def->__int_pos.Z)
("cstat", c.cstat, def->cstat) ("cstat", c.cstat, def->cstat)
("picnum", c.picnum, def->picnum) ("picnum", c.picnum, def->picnum)
("shade", c.shade, def->shade) ("shade", c.shade, def->shade)

16
source/core/vmexports.cpp
View file

@ -537,15 +537,15 @@ DEFINE_ACTION_FUNCTION_NATIVE(_walltype, twosided, wall_twosided)
DEFINE_ACTION_FUNCTION(_tspritetype, pos) DEFINE_ACTION_FUNCTION(_tspritetype, pos)
{ {
PARAM_SELF_STRUCT_PROLOGUE(tspritetype); PARAM_SELF_STRUCT_PROLOGUE(tspritetype);
ACTION_RETURN_VEC3(DVector3(self->pos.X * inttoworld, self->pos.Y * inttoworld, self->pos.Z * zinttoworld)); ACTION_RETURN_VEC3(DVector3(self->__int_pos.X * inttoworld, self->__int_pos.Y * inttoworld, self->__int_pos.Z * zinttoworld));
} }
void tsprite_setpos(tspritetype* tsp, double x, double y, double z) void tsprite_setpos(tspritetype* tsp, double x, double y, double z)
{ {
if (!tsp) ThrowAbortException(X_READ_NIL, nullptr); if (!tsp) ThrowAbortException(X_READ_NIL, nullptr);
tsp->pos.X = int(x * worldtoint); tsp->__int_pos.X = int(x * worldtoint);
tsp->pos.Y = int(y * worldtoint); tsp->__int_pos.Y = int(y * worldtoint);
tsp->pos.Z = int(z * zworldtoint); tsp->__int_pos.Z = int(z * zworldtoint);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, setpos, tsprite_setpos) DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, setpos, tsprite_setpos)
@ -561,9 +561,9 @@ DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, setpos, tsprite_setpos)
void tsprite_addpos(tspritetype* tsp, double x, double y, double z) void tsprite_addpos(tspritetype* tsp, double x, double y, double z)
{ {
if (!tsp) ThrowAbortException(X_READ_NIL, nullptr); if (!tsp) ThrowAbortException(X_READ_NIL, nullptr);
tsp->pos.X = int(x * worldtoint); tsp->__int_pos.X += int(x * worldtoint);
tsp->pos.Y = int(y * worldtoint); tsp->__int_pos.Y += int(y * worldtoint);
tsp->pos.Z = int(z * zworldtoint); tsp->__int_pos.Z += int(z * zworldtoint);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, addpos, tsprite_addpos) DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, addpos, tsprite_addpos)
@ -583,4 +583,4 @@ struct tsprite
void setPic(string texture); void setPic(string texture);
} }
#endif #endif

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

@ -97,12 +97,12 @@ tspritetype* viewInsertTSprite(tspriteArray& tsprites, sectortype* pSector, int
pTSprite->sectp = pSector; pTSprite->sectp = pSector;
if (parentTSprite) if (parentTSprite)
{ {
pTSprite->pos = parentTSprite->pos; pTSprite->__int_pos = parentTSprite->__int_pos;
pTSprite->ownerActor = parentTSprite->ownerActor; pTSprite->ownerActor = parentTSprite->ownerActor;
pTSprite->ang = parentTSprite->ang; pTSprite->ang = parentTSprite->ang;
} }
pTSprite->pos.X += Cos(gCameraAng) >> 25; pTSprite->__int_pos.X += Cos(gCameraAng) >> 25;
pTSprite->pos.Y += Sin(gCameraAng) >> 25; pTSprite->__int_pos.Y += Sin(gCameraAng) >> 25;
return pTSprite; return pTSprite;
} }
@ -167,7 +167,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
if (perc >= 75) pNSprite2->pal = 0; if (perc >= 75) pNSprite2->pal = 0;
else if (perc >= 50) pNSprite2->pal = 6; else if (perc >= 50) pNSprite2->pal = 6;
pNSprite2->pos.Z = top - 2048; pNSprite2->__int_pos.Z = top - 2048;
pNSprite2->shade = -128; pNSprite2->shade = -128;
break; break;
} }
@ -188,9 +188,9 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int z = 0; int z = 0;
RotateYZ(&x, &y, &z, nRand1); RotateYZ(&x, &y, &z, nRand1);
RotateXZ(&x, &y, &z, nRand2); RotateXZ(&x, &y, &z, nRand2);
pNSprite->pos.X = pTSprite->pos.X + x; pNSprite->__int_pos.X = pTSprite->__int_pos.X + x;
pNSprite->pos.Y = pTSprite->pos.Y + y; pNSprite->__int_pos.Y = pTSprite->__int_pos.Y + y;
pNSprite->pos.Z = pTSprite->pos.Z + (z << 4); pNSprite->__int_pos.Z = pTSprite->__int_pos.Z + (z << 4);
pNSprite->picnum = 1720; pNSprite->picnum = 1720;
pNSprite->shade = -128; pNSprite->shade = -128;
} }
@ -206,7 +206,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->pal = 0; pNSprite->pal = 0;
pNSprite->pos.Z = top; pNSprite->__int_pos.Z = top;
if (nViewEffect == kViewEffectFlag) if (nViewEffect == kViewEffectFlag)
pNSprite->xrepeat = pNSprite->yrepeat = 24; pNSprite->xrepeat = pNSprite->yrepeat = 24;
else else
@ -220,7 +220,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
if (!pNSprite) if (!pNSprite)
break; break;
pNSprite->pos.Z = pTSprite->pos.Z; pNSprite->__int_pos.Z = pTSprite->__int_pos.Z;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT; pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->xrepeat = pTSprite->xrepeat; pNSprite->xrepeat = pTSprite->xrepeat;
@ -266,7 +266,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT; pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->xrepeat = pNSprite->yrepeat = 24; pNSprite->xrepeat = pNSprite->yrepeat = 24;
pNSprite->picnum = 626; pNSprite->picnum = 626;
pNSprite->pos.Z = top; pNSprite->__int_pos.Z = top;
break; break;
} }
case kViewEffectTrail: case kViewEffectTrail:
@ -289,12 +289,12 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int nLen = 128 + (i << 7); int nLen = 128 + (i << 7);
int x = MulScale(nLen, Cos(nAng), 30); int x = MulScale(nLen, Cos(nAng), 30);
pNSprite->pos.X = pTSprite->pos.X + x; pNSprite->__int_pos.X = pTSprite->__int_pos.X + x;
int y = MulScale(nLen, Sin(nAng), 30); int y = MulScale(nLen, Sin(nAng), 30);
pNSprite->pos.Y = pTSprite->pos.Y + y; pNSprite->__int_pos.Y = pTSprite->__int_pos.Y + y;
pNSprite->pos.Z = pTSprite->pos.Z; pNSprite->__int_pos.Z = pTSprite->__int_pos.Z;
assert(pSector); assert(pSector);
FindSector(pNSprite->pos.X, pNSprite->pos.Y, pNSprite->pos.Z, &pSector); FindSector(pNSprite->__int_pos.X, pNSprite->__int_pos.Y, pNSprite->__int_pos.Z, &pSector);
pNSprite->sectp = pSector; pNSprite->sectp = pSector;
pNSprite->ownerActor = pTSprite->ownerActor; pNSprite->ownerActor = pTSprite->ownerActor;
pNSprite->picnum = pTSprite->picnum; pNSprite->picnum = pTSprite->picnum;
@ -315,7 +315,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
break; break;
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->pos.Z = pTSprite->pos.Z; pNSprite->__int_pos.Z = pTSprite->__int_pos.Z;
pNSprite->picnum = 908; pNSprite->picnum = 908;
pNSprite->statnum = kStatDecoration; pNSprite->statnum = kStatDecoration;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 64; pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 64;
@ -329,7 +329,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int top, bottom; int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom); GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->pos.Z = top; pNSprite->__int_pos.Z = top;
if (IsDudeSprite(pTSprite)) if (IsDudeSprite(pTSprite))
pNSprite->picnum = 672; pNSprite->picnum = 672;
else else
@ -348,7 +348,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int top, bottom; int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom); GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->pos.Z = bottom; pNSprite->__int_pos.Z = bottom;
if (pTSprite->type >= kDudeBase && pTSprite->type < kDudeMax) if (pTSprite->type >= kDudeBase && pTSprite->type < kDudeMax)
pNSprite->picnum = 672; pNSprite->picnum = 672;
else else
@ -367,7 +367,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int top, bottom; int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom); GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->pos.Z = top; pNSprite->__int_pos.Z = top;
pNSprite->picnum = 2101; pNSprite->picnum = 2101;
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 32; pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 32;
@ -381,7 +381,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
int top, bottom; int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom); GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->pos.Z = bottom; pNSprite->__int_pos.Z = bottom;
pNSprite->picnum = 2101; pNSprite->picnum = 2101;
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 32; pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum) * pTSprite->xrepeat) / 32;
@ -392,10 +392,10 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
auto pNSprite = viewInsertTSprite(tsprites, pTSprite->sectp, 32767, pTSprite); auto pNSprite = viewInsertTSprite(tsprites, pTSprite->sectp, 32767, pTSprite);
if (!pNSprite) if (!pNSprite)
break; break;
pNSprite->pos.Z = getflorzofslopeptr(pTSprite->sectp, pNSprite->pos.X, pNSprite->pos.Y); pNSprite->__int_pos.Z = getflorzofslopeptr(pTSprite->sectp, pNSprite->__int_pos.X, pNSprite->__int_pos.Y);
if ((pNSprite->sectp->floorpicnum >= 4080) && (pNSprite->sectp->floorpicnum <= 4095) && !VanillaMode()) // if floor has ror, find actual floor if ((pNSprite->sectp->floorpicnum >= 4080) && (pNSprite->sectp->floorpicnum <= 4095) && !VanillaMode()) // if floor has ror, find actual floor
{ {
int cX = pNSprite->pos.X, cY = pNSprite->pos.Y, cZ = pNSprite->pos.Z, cZrel = pNSprite->pos.Z; int cX = pNSprite->__int_pos.X, cY = pNSprite->__int_pos.Y, cZ = pNSprite->__int_pos.Z, cZrel = pNSprite->__int_pos.Z;
auto cSect = pNSprite->sectp; auto cSect = pNSprite->sectp;
for (int i = 0; i < 16; i++) // scan through max stacked sectors for (int i = 0; i < 16; i++) // scan through max stacked sectors
{ {
@ -408,7 +408,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
cZ = newFloorZ; cZ = newFloorZ;
} }
pNSprite->sectp = cSect; pNSprite->sectp = cSect;
pNSprite->pos.Z = cZrel; pNSprite->__int_pos.Z = cZrel;
} }
pNSprite->shade = 127; pNSprite->shade = 127;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT; pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
@ -420,7 +420,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
pNSprite->pal = 5; pNSprite->pal = 5;
int height = tileHeight(pNSprite->picnum); int height = tileHeight(pNSprite->picnum);
int center = height / 2 + tileTopOffset(pNSprite->picnum); int center = height / 2 + tileTopOffset(pNSprite->picnum);
pNSprite->pos.Z -= (pNSprite->yrepeat << 2) * (height - center); pNSprite->__int_pos.Z -= (pNSprite->yrepeat << 2) * (height - center);
break; break;
} }
case kViewEffectFlareHalo: case kViewEffectFlareHalo:
@ -432,7 +432,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
pNSprite->shade = -128; pNSprite->shade = -128;
pNSprite->pal = 2; pNSprite->pal = 2;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT; pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->pos.Z = pTSprite->pos.Z; pNSprite->__int_pos.Z = pTSprite->__int_pos.Z;
pNSprite->xrepeat = pTSprite->xrepeat; pNSprite->xrepeat = pTSprite->xrepeat;
pNSprite->yrepeat = pTSprite->yrepeat; pNSprite->yrepeat = pTSprite->yrepeat;
pNSprite->picnum = 2427; pNSprite->picnum = 2427;
@ -445,11 +445,11 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
break; break;
sectortype* pSector = pTSprite->sectp; sectortype* pSector = pTSprite->sectp;
pNSprite->pos.X = pTSprite->pos.X; pNSprite->__int_pos.X = pTSprite->__int_pos.X;
pNSprite->pos.Y = pTSprite->pos.Y; pNSprite->__int_pos.Y = pTSprite->__int_pos.Y;
pNSprite->pos.Z = pSector->ceilingz; pNSprite->__int_pos.Z = pSector->ceilingz;
pNSprite->picnum = 624; pNSprite->picnum = 624;
pNSprite->shade = ((pTSprite->pos.Z - pSector->ceilingz) >> 8) - 64; pNSprite->shade = ((pTSprite->__int_pos.Z - pSector->ceilingz) >> 8) - 64;
pNSprite->pal = 2; pNSprite->pal = 2;
pNSprite->xrepeat = pNSprite->yrepeat = 64; pNSprite->xrepeat = pNSprite->yrepeat = 64;
pNSprite->cstat |= CSTAT_SPRITE_ONE_SIDE | CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_YFLIP | CSTAT_SPRITE_TRANSLUCENT; pNSprite->cstat |= CSTAT_SPRITE_ONE_SIDE | CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_YFLIP | CSTAT_SPRITE_TRANSLUCENT;
@ -464,11 +464,11 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
break; break;
sectortype* pSector = pTSprite->sectp; sectortype* pSector = pTSprite->sectp;
pNSprite->pos.X = pTSprite->pos.X; pNSprite->__int_pos.X = pTSprite->__int_pos.X;
pNSprite->pos.Y = pTSprite->pos.Y; pNSprite->__int_pos.Y = pTSprite->__int_pos.Y;
pNSprite->pos.Z = pSector->floorz; pNSprite->__int_pos.Z = pSector->floorz;
pNSprite->picnum = 624; pNSprite->picnum = 624;
uint8_t nShade = (pSector->floorz - pTSprite->pos.Z) >> 8; uint8_t nShade = (pSector->floorz - pTSprite->__int_pos.Z) >> 8;
pNSprite->shade = nShade - 32; pNSprite->shade = nShade - 32;
pNSprite->pal = 2; pNSprite->pal = 2;
pNSprite->xrepeat = pNSprite->yrepeat = nShade; pNSprite->xrepeat = pNSprite->yrepeat = nShade;
@ -483,7 +483,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
if (!pNSprite) if (!pNSprite)
break; break;
pNSprite->pos.Z = pTSprite->pos.Z; pNSprite->__int_pos.Z = pTSprite->__int_pos.Z;
if (gDetail > 1) if (gDetail > 1)
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT | CSTAT_SPRITE_TRANS_FLIP; pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT | CSTAT_SPRITE_TRANS_FLIP;
pNSprite->shade = ClipLow(pTSprite->shade - 32, -128); pNSprite->shade = ClipLow(pTSprite->shade - 32, -128);
@ -503,10 +503,10 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
if (!pNSprite) if (!pNSprite)
break; break;
pNSprite->pos.X = pTSprite->pos.X; pNSprite->__int_pos.X = pTSprite->__int_pos.X;
pNSprite->pos.Y = pTSprite->pos.Y; pNSprite->__int_pos.Y = pTSprite->__int_pos.Y;
pNSprite->pos.Z = pTSprite->pos.Z - (32 << 8); pNSprite->__int_pos.Z = pTSprite->__int_pos.Z - (32 << 8);
pNSprite->pos.Z -= weaponIcon.zOffset << 8; // offset up pNSprite->__int_pos.Z -= weaponIcon.zOffset << 8; // offset up
pNSprite->picnum = nTile; pNSprite->picnum = nTile;
pNSprite->shade = pTSprite->shade; pNSprite->shade = pTSprite->shade;
pNSprite->xrepeat = 32; pNSprite->xrepeat = 32;
@ -520,8 +520,8 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
pNSprite->picnum = nVoxel; pNSprite->picnum = nVoxel;
if (pPlayer->curWeapon == kWeapLifeLeech) // position lifeleech behind player if (pPlayer->curWeapon == kWeapLifeLeech) // position lifeleech behind player
{ {
pNSprite->pos.X += MulScale(128, Cos(gView->actor->spr.ang), 30); pNSprite->__int_pos.X += MulScale(128, Cos(gView->actor->spr.ang), 30);
pNSprite->pos.Y += MulScale(128, Sin(gView->actor->spr.ang), 30); pNSprite->__int_pos.Y += MulScale(128, Sin(gView->actor->spr.ang), 30);
} }
if ((pPlayer->curWeapon == kWeapLifeLeech) || (pPlayer->curWeapon == kWeapVoodooDoll)) // make lifeleech/voodoo doll always face viewer like sprite if ((pPlayer->curWeapon == kWeapLifeLeech) || (pPlayer->curWeapon == kWeapVoodooDoll)) // make lifeleech/voodoo doll always face viewer like sprite
pNSprite->ang = (pNSprite->ang + 512) & 2047; // offset angle 90 degrees pNSprite->ang = (pNSprite->ang + 512) & 2047; // offset angle 90 degrees
@ -585,7 +585,7 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
if (cl_interpolate && owneractor->interpolated && !(pTSprite->flags & 512)) if (cl_interpolate && owneractor->interpolated && !(pTSprite->flags & 512))
{ {
pTSprite->pos = owneractor->interpolatedvec3(gInterpolate); pTSprite->__int_pos = owneractor->interpolatedvec3(gInterpolate);
pTSprite->ang = owneractor->interpolatedang(gInterpolate); pTSprite->ang = owneractor->interpolatedang(gInterpolate);
} }
int nAnim = 0; int nAnim = 0;
@ -615,8 +615,8 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
pTSprite->cstat &= ~CSTAT_SPRITE_XFLIP; pTSprite->cstat &= ~CSTAT_SPRITE_XFLIP;
break; break;
} }
int dX = cX - pTSprite->pos.X; int dX = cX - pTSprite->__int_pos.X;
int dY = cY - pTSprite->pos.Y; int dY = cY - pTSprite->__int_pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang); RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY); nAnim = GetOctant(dX, dY);
if (nAnim <= 4) if (nAnim <= 4)
@ -637,8 +637,8 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
pTSprite->cstat &= ~CSTAT_SPRITE_XFLIP; pTSprite->cstat &= ~CSTAT_SPRITE_XFLIP;
break; break;
} }
int dX = cX - pTSprite->pos.X; int dX = cX - pTSprite->__int_pos.X;
int dY = cY - pTSprite->pos.Y; int dY = cY - pTSprite->__int_pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang); RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY); nAnim = GetOctant(dX, dY);
break; break;
@ -654,7 +654,7 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
{ {
int top, bottom; int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom); GetSpriteExtents(pTSprite, &top, &bottom);
if (getflorzofslopeptr(pTSprite->sectp, pTSprite->pos.X, pTSprite->pos.Y) > bottom) if (getflorzofslopeptr(pTSprite->sectp, pTSprite->__int_pos.X, pTSprite->__int_pos.Y) > bottom)
nAnim = 1; nAnim = 1;
} }
break; break;
@ -855,12 +855,12 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
if (pTSprite->type != kMissileFlareRegular) break; if (pTSprite->type != kMissileFlareRegular) break;
sectortype* pSector1 = pTSprite->sectp; sectortype* pSector1 = pTSprite->sectp;
int zDiff = (pTSprite->pos.Z - pSector1->ceilingz) >> 8; int zDiff = (pTSprite->__int_pos.Z - pSector1->ceilingz) >> 8;
if ((pSector1->ceilingstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) { if ((pSector1->ceilingstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) {
viewAddEffect(tsprites, nTSprite, kViewEffectCeilGlow); viewAddEffect(tsprites, nTSprite, kViewEffectCeilGlow);
} }
zDiff = (pSector1->floorz - pTSprite->pos.Z) >> 8; zDiff = (pSector1->floorz - pTSprite->__int_pos.Z) >> 8;
if ((pSector1->floorstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) { if ((pSector1->floorstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) {
viewAddEffect(tsprites, nTSprite, kViewEffectFloorGlow); viewAddEffect(tsprites, nTSprite, kViewEffectFloorGlow);
} }
@ -909,9 +909,9 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
auto pNTSprite = viewAddEffect(tsprites, nTSprite, kViewEffectShoot); auto pNTSprite = viewAddEffect(tsprites, nTSprite, kViewEffectShoot);
if (pNTSprite) { if (pNTSprite) {
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pNTSprite->pos.X += MulScale(pPosture->zOffset, Cos(pTSprite->ang), 28); pNTSprite->__int_pos.X += MulScale(pPosture->zOffset, Cos(pTSprite->ang), 28);
pNTSprite->pos.Y += MulScale(pPosture->zOffset, Sin(pTSprite->ang), 28); pNTSprite->__int_pos.Y += MulScale(pPosture->zOffset, Sin(pTSprite->ang), 28);
pNTSprite->pos.Z = pPlayer->actor->int_pos().Z - pPosture->xOffset; pNTSprite->__int_pos.Z = pPlayer->actor->int_pos().Z - pPosture->xOffset;
} }
} }
@ -936,7 +936,7 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
} }
if (pTSprite->ownerActor != gView->actor || gViewPos != VIEWPOS_0) { if (pTSprite->ownerActor != gView->actor || gViewPos != VIEWPOS_0) {
if (getflorzofslopeptr(pTSprite->sectp, pTSprite->pos.X, pTSprite->pos.Y) >= cZ) if (getflorzofslopeptr(pTSprite->sectp, pTSprite->__int_pos.X, pTSprite->__int_pos.Y) >= cZ)
{ {
viewAddEffect(tsprites, nTSprite, kViewEffectShadow); viewAddEffect(tsprites, nTSprite, kViewEffectShadow);
} }
@ -968,7 +968,7 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
if (pTSprite->type < kThingBase || pTSprite->type >= kThingMax || owneractor->hit.florhit.type == kHitNone) if (pTSprite->type < kThingBase || pTSprite->type >= kThingMax || owneractor->hit.florhit.type == kHitNone)
{ {
if ((pTSprite->flags & kPhysMove) && getflorzofslopeptr(pTSprite->sectp, pTSprite->pos.X, pTSprite->pos.Y) >= cZ) if ((pTSprite->flags & kPhysMove) && getflorzofslopeptr(pTSprite->sectp, pTSprite->__int_pos.X, pTSprite->__int_pos.Y) >= cZ)
viewAddEffect(tsprites, nTSprite, kViewEffectShadow); viewAddEffect(tsprites, nTSprite, kViewEffectShadow);
} }
} }
@ -984,8 +984,8 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
{ {
case 1: case 1:
{ {
int dX = cX - pTSprite->pos.X; int dX = cX - pTSprite->__int_pos.X;
int dY = cY - pTSprite->pos.Y; int dY = cY - pTSprite->__int_pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang); RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY); nAnim = GetOctant(dX, dY);
if (nAnim <= 4) if (nAnim <= 4)
@ -1001,8 +1001,8 @@ void viewProcessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t
} }
case 2: case 2:
{ {
int dX = cX - pTSprite->pos.X; int dX = cX - pTSprite->__int_pos.X;
int dY = cY - pTSprite->pos.Y; int dY = cY - pTSprite->__int_pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang); RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY); nAnim = GetOctant(dX, dY);
break; break;

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

@ -473,9 +473,9 @@ void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, int*
} }
auto pSprite = &sprites.sprites[i]; auto pSprite = &sprites.sprites[i];
*pSprite = {}; *pSprite = {};
pSprite->pos.X = LittleLong(load.x); pSprite->__int_pos.X = LittleLong(load.x);
pSprite->pos.Y = LittleLong(load.y); pSprite->__int_pos.Y = LittleLong(load.y);
pSprite->pos.Z = LittleLong(load.z); pSprite->__int_pos.Z = LittleLong(load.z);
pSprite->cstat = ESpriteFlags::FromInt(LittleShort(load.cstat)); pSprite->cstat = ESpriteFlags::FromInt(LittleShort(load.cstat));
pSprite->picnum = LittleShort(load.picnum); pSprite->picnum = LittleShort(load.picnum);
int secno = LittleShort(load.sectnum); int secno = LittleShort(load.sectnum);

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

@ -82,7 +82,7 @@ extern int gSkyCount;
void GetSpriteExtents(spritetypebase const* const pSprite, int* top, int* bottom) void GetSpriteExtents(spritetypebase const* const pSprite, int* top, int* bottom)
{ {
*top = *bottom = pSprite->pos.Z; *top = *bottom = pSprite->__int_pos.Z;
if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FLOOR) if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FLOOR)
{ {
int height = tileHeight(pSprite->picnum); int height = tileHeight(pSprite->picnum);

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

@ -165,14 +165,14 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (t->statnum == 99) continue; if (t->statnum == 99) continue;
if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner()) if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner())
{ {
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].opos.X, 16); t->__int_pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].opos.X, 16);
t->pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].opos.Y, 16); t->__int_pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].opos.Y, 16);
t->pos.Z = interpolatedvalue(ps[h->spr.yvel].opos.Z, ps[h->spr.yvel].pos.Z, smoothratio); t->__int_pos.Z = interpolatedvalue(ps[h->spr.yvel].opos.Z, ps[h->spr.yvel].pos.Z, smoothratio);
t->pos.Z += PHEIGHT_DUKE; t->__int_pos.Z += PHEIGHT_DUKE;
} }
else if (!actorflag(h, SFLAG_NOINTERPOLATE)) else if (!actorflag(h, SFLAG_NOINTERPOLATE))
{ {
t->pos = h->interpolatedvec3(smoothratio); t->__int_pos = h->interpolatedvec3(smoothratio);
} }
auto sectp = h->sector(); auto sectp = h->sector();
@ -183,7 +183,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
switch (h->spr.picnum) switch (h->spr.picnum)
{ {
case DUKELYINGDEAD: case DUKELYINGDEAD:
t->pos.Z += (24 << 8); t->__int_pos.Z += (24 << 8);
break; break;
case BLOODPOOL: case BLOODPOOL:
case FOOTPRINTS: case FOOTPRINTS:
@ -209,8 +209,8 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
OwnerAc->int_pos().Y - ps[screenpeek].pos.Y); OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
int sqb = int sqb =
getangle( getangle(
OwnerAc->int_pos().X - t->pos.X, OwnerAc->int_pos().X - t->__int_pos.X,
OwnerAc->int_pos().Y - t->pos.Y); OwnerAc->int_pos().Y - t->__int_pos.Y);
if (abs(getincangle(sqa, sqb)) > 512) if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc)) if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -225,17 +225,17 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
t->xrepeat = 0; t->xrepeat = 0;
else else
{ {
t->ang = getangle(x - t->pos.X, y - t->pos.Y); t->ang = getangle(x - t->__int_pos.X, y - t->__int_pos.Y);
t->pos.X = OwnerAc->int_pos().X; t->__int_pos.X = OwnerAc->int_pos().X;
t->pos.Y = OwnerAc->int_pos().Y; t->__int_pos.Y = OwnerAc->int_pos().Y;
t->pos.X += bcos(t->ang, -10); t->__int_pos.X += bcos(t->ang, -10);
t->pos.Y += bsin(t->ang, -10); t->__int_pos.Y += bsin(t->ang, -10);
} }
} }
break; break;
case ATOMICHEALTH: case ATOMICHEALTH:
t->pos.Z -= (4 << 8); t->__int_pos.Z -= (4 << 8);
break; break;
case CRYSTALAMMO: case CRYSTALAMMO:
t->shade = bsin(PlayClock << 4, -10); t->shade = bsin(PlayClock << 4, -10);
@ -307,7 +307,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
p = h->spr.yvel; p = h->spr.yvel;
if (t->pal == 1) t->pos.Z -= (18 << 8); if (t->pal == 1) t->__int_pos.Z -= (18 << 8);
if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr) if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr)
{ {
@ -357,8 +357,8 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
} }
if (h->GetOwner()) if (h->GetOwner())
newtspr->pos.Z = ps[p].pos.Z - (12 << 8); newtspr->__int_pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->int_pos().Z - (51 << 8); else newtspr->__int_pos.Z = h->int_pos().Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON) if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{ {
newtspr->xrepeat = 10; newtspr->xrepeat = 10;
@ -430,8 +430,8 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (!h->GetOwner()) continue; if (!h->GetOwner()) continue;
if (t->pos.Z > h->floorz && t->xrepeat < 32) if (t->__int_pos.Z > h->floorz && t->xrepeat < 32)
t->pos.Z = h->floorz; t->__int_pos.Z = h->floorz;
break; break;
@ -590,7 +590,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
shadowspr->shade = 127; shadowspr->shade = 127;
shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT; shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT;
shadowspr->pos.Z = daz; shadowspr->__int_pos.Z = daz;
shadowspr->pal = 4; shadowspr->pal = 4;
if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0) if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0)
@ -604,9 +604,9 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else else
{ {
// Alter the shadow's position so that it appears behind the sprite itself. // Alter the shadow's position so that it appears behind the sprite itself.
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->pos.Y - ps[screenpeek].pos.Y); int look = getangle(shadowspr->__int_pos.X - ps[screenpeek].pos.X, shadowspr->__int_pos.Y - ps[screenpeek].pos.Y);
shadowspr->pos.X += bcos(look, -9); shadowspr->__int_pos.X += bcos(look, -9);
shadowspr->pos.Y += bsin(look, -9); shadowspr->__int_pos.Y += bsin(look, -9);
} }
} }
} }
@ -625,7 +625,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
case LASERLINE: case LASERLINE:
if (!OwnerAc) break; if (!OwnerAc) break;
if (t->sectp->lotag == 2) t->pal = 8; if (t->sectp->lotag == 2) t->pal = 8;
t->pos.Z = OwnerAc->int_pos().Z - (3 << 8); t->__int_pos.Z = OwnerAc->int_pos().Z - (3 << 8);
if (gs.lasermode == 2 && ps[screenpeek].heat_on == 0) if (gs.lasermode == 2 && ps[screenpeek].heat_on == 0)
t->yrepeat = 0; t->yrepeat = 0;
t->shade = -127; t->shade = -127;
@ -656,7 +656,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
case BURNING2: case BURNING2:
if (!OwnerAc) break; if (!OwnerAc) break;
if (!actorflag(OwnerAc, SFLAG_NOFLOORFIRE)) if (!actorflag(OwnerAc, SFLAG_NOFLOORFIRE))
t->pos.Z = t->sectp->floorz; t->__int_pos.Z = t->sectp->floorz;
t->shade = -127; t->shade = -127;
break; break;
case COOLEXPLOSION1: case COOLEXPLOSION1:

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

@ -145,16 +145,16 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (t->statnum == 99) continue; if (t->statnum == 99) continue;
if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner()) if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner())
{ {
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].opos.X, 16); t->__int_pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].opos.X, 16);
t->pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].opos.Y, 16); t->__int_pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].opos.Y, 16);
t->pos.Z = interpolatedvalue(ps[h->spr.yvel].opos.Z, ps[h->spr.yvel].pos.Z, smoothratio); t->__int_pos.Z = interpolatedvalue(ps[h->spr.yvel].opos.Z, ps[h->spr.yvel].pos.Z, smoothratio);
t->pos.Z += PHEIGHT_RR; t->__int_pos.Z += PHEIGHT_RR;
h->spr.xrepeat = 24; h->spr.xrepeat = 24;
h->spr.yrepeat = 17; h->spr.yrepeat = 17;
} }
else if (!actorflag(h, SFLAG_NOINTERPOLATE)) else if (!actorflag(h, SFLAG_NOINTERPOLATE))
{ {
t->pos = h->interpolatedvec3(smoothratio); t->__int_pos = h->interpolatedvec3(smoothratio);
} }
auto sectp = h->sector(); auto sectp = h->sector();
@ -181,7 +181,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
h->spr.xrepeat = 24; h->spr.xrepeat = 24;
h->spr.yrepeat = 17; h->spr.yrepeat = 17;
if (h->spr.extra > 0) if (h->spr.extra > 0)
t->pos.Z += (6 << 8); t->__int_pos.Z += (6 << 8);
break; break;
case BLOODPOOL: case BLOODPOOL:
case FOOTPRINTS: case FOOTPRINTS:
@ -204,8 +204,8 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
OwnerAc->int_pos().Y - ps[screenpeek].pos.Y); OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
int sqb = int sqb =
getangle( getangle(
OwnerAc->int_pos().X - t->pos.X, OwnerAc->int_pos().X - t->__int_pos.X,
OwnerAc->int_pos().Y - t->pos.Y); OwnerAc->int_pos().Y - t->__int_pos.Y);
if (abs(getincangle(sqa, sqb)) > 512) if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc)) if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -219,17 +219,17 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
t->xrepeat = 0; t->xrepeat = 0;
else else
{ {
t->ang = getangle(x - t->pos.X, y - t->pos.Y); t->ang = getangle(x - t->__int_pos.X, y - t->__int_pos.Y);
t->pos.X = OwnerAc->int_pos().X; t->__int_pos.X = OwnerAc->int_pos().X;
t->pos.Y = OwnerAc->int_pos().Y; t->__int_pos.Y = OwnerAc->int_pos().Y;
t->pos.X += bcos(t->ang, -10); t->__int_pos.X += bcos(t->ang, -10);
t->pos.Y += bsin(t->ang, -10); t->__int_pos.Y += bsin(t->ang, -10);
} }
} }
break; break;
case ATOMICHEALTH: case ATOMICHEALTH:
t->pos.Z -= (4 << 8); t->__int_pos.Z -= (4 << 8);
break; break;
case CRYSTALAMMO: case CRYSTALAMMO:
t->shade = bsin(PlayClock << 4, -10); t->shade = bsin(PlayClock << 4, -10);
@ -349,7 +349,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
p = h->spr.yvel; p = h->spr.yvel;
if (t->pal == 1) t->pos.Z -= (18 << 8); if (t->pal == 1) t->__int_pos.Z -= (18 << 8);
if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr) if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr)
{ {
@ -397,8 +397,8 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
} }
if (h->GetOwner()) if (h->GetOwner())
newtspr->pos.Z = ps[p].pos.Z - (12 << 8); newtspr->__int_pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->int_pos().Z - (51 << 8); else newtspr->__int_pos.Z = h->int_pos().Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON) if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{ {
newtspr->xrepeat = 10; newtspr->xrepeat = 10;
@ -474,8 +474,8 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (!h->GetOwner()) continue; if (!h->GetOwner()) continue;
if (t->pos.Z > h->floorz && t->xrepeat < 32) if (t->__int_pos.Z > h->floorz && t->xrepeat < 32)
t->pos.Z = h->floorz; t->__int_pos.Z = h->floorz;
if (ps[p].OnMotorcycle && p == screenpeek) if (ps[p].OnMotorcycle && p == screenpeek)
{ {
@ -746,7 +746,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
shadowspr->shade = 127; shadowspr->shade = 127;
shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT; shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT;
shadowspr->pos.Z = daz; shadowspr->__int_pos.Z = daz;
shadowspr->pal = 4; shadowspr->pal = 4;
if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0) if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0)
@ -760,9 +760,9 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else else
{ {
// Alter the shadow's position so that it appears behind the sprite itself. // Alter the shadow's position so that it appears behind the sprite itself.
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->pos.Y - ps[screenpeek].pos.Y); int look = getangle(shadowspr->__int_pos.X - ps[screenpeek].pos.X, shadowspr->__int_pos.Y - ps[screenpeek].pos.Y);
shadowspr->pos.X += bcos(look, -9); shadowspr->__int_pos.X += bcos(look, -9);
shadowspr->pos.Y += bsin(look, -9); shadowspr->__int_pos.Y += bsin(look, -9);
} }
} }
} }
@ -813,7 +813,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
case FIRE: case FIRE:
case BURNING: case BURNING:
if (!OwnerAc || !actorflag(OwnerAc, SFLAG_NOFLOORFIRE)) if (!OwnerAc || !actorflag(OwnerAc, SFLAG_NOFLOORFIRE))
t->pos.Z = t->sectp->floorz; t->__int_pos.Z = t->sectp->floorz;
t->shade = -127; t->shade = -127;
break; break;
case WALLLIGHT3: case WALLLIGHT3:

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

@ -105,8 +105,8 @@ inline int ldist(DDukeActor* s1, DDukeActor* s2)
inline int ldist(const DDukeActor* s1, const tspritetype* s2) inline int ldist(const DDukeActor* s1, const tspritetype* s2)
{ {
int vx, vy; int vx, vy;
vx = s1->int_pos().X - s2->pos.X; vx = s1->int_pos().X - s2->__int_pos.X;
vy = s1->int_pos().Y - s2->pos.Y; vy = s1->int_pos().Y - s2->__int_pos.Y;
return(FindDistance2D(vx, vy) + 1); return(FindDistance2D(vx, vy) + 1);
} }
inline int dist(DDukeActor* s1, DDukeActor* s2) inline int dist(DDukeActor* s1, DDukeActor* s2)

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

@ -479,7 +479,7 @@ int seq_GetSeqPicnum(int16_t nSeq, int16_t edx, int16_t ebx)
int seq_PlotArrowSequence(int nSprite, int16_t nSeq, int nVal) int seq_PlotArrowSequence(int nSprite, int16_t nSeq, int nVal)
{ {
tspritetype* pTSprite = mytspriteArray->get(nSprite); tspritetype* pTSprite = mytspriteArray->get(nSprite);
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->pos.Y); int nAngle = GetMyAngle(nCamerax - pTSprite->__int_pos.X, nCameray - pTSprite->__int_pos.Y);
int nSeqOffset = ((((pTSprite->ang + 512) - nAngle) + 128) & kAngleMask) >> 8; int nSeqOffset = ((((pTSprite->ang + 512) - nAngle) + 128) & kAngleMask) >> 8;
@ -527,7 +527,7 @@ int seq_PlotArrowSequence(int nSprite, int16_t nSeq, int nVal)
int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx) int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
{ {
tspritetype* pTSprite = mytspriteArray->get(nSprite); tspritetype* pTSprite = mytspriteArray->get(nSprite);
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->pos.Y); int nAngle = GetMyAngle(nCamerax - pTSprite->__int_pos.X, nCameray - pTSprite->__int_pos.Y);
int val; int val;
@ -580,9 +580,7 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
} }
tspritetype* tsp = mytspriteArray->newTSprite(); tspritetype* tsp = mytspriteArray->newTSprite();
tsp->pos.X = pTSprite->pos.X; tsp->__int_pos = pTSprite->__int_pos;
tsp->pos.Y = pTSprite->pos.Y;
tsp->pos.Z = pTSprite->pos.Z;
tsp->shade = shade; tsp->shade = shade;
tsp->pal = pTSprite->pal; tsp->pal = pTSprite->pal;
tsp->xrepeat = pTSprite->xrepeat; tsp->xrepeat = pTSprite->xrepeat;
@ -626,13 +624,13 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
{ {
pTSprite->picnum = nShadowPic; pTSprite->picnum = nShadowPic;
edx = ((tileWidth(nPict) << 5) / nShadowWidth) - ((nFloorZ - pTSprite->pos.Z) >> 10); edx = ((tileWidth(nPict) << 5) / nShadowWidth) - ((nFloorZ - pTSprite->__int_pos.Z) >> 10);
if (edx < 1) { if (edx < 1) {
edx = 1; edx = 1;
} }
pTSprite->cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_TRANSLUCENT; pTSprite->cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_TRANSLUCENT;
pTSprite->pos.Z = nFloorZ; pTSprite->__int_pos.Z = nFloorZ;
pTSprite->yrepeat = (uint8_t)edx; pTSprite->yrepeat = (uint8_t)edx;
pTSprite->xrepeat = (uint8_t)edx; pTSprite->xrepeat = (uint8_t)edx;
pTSprite->statnum = -3; pTSprite->statnum = -3;

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

@ -73,7 +73,7 @@ static void analyzesprites(tspriteArray& tsprites, int x, int y, int z, double c
if (pTSprite->ownerActor) if (pTSprite->ownerActor)
{ {
// interpolate sprite position // interpolate sprite position
pTSprite->pos = pTSprite->ownerActor->interpolatedvec3(smoothratio); pTSprite->__int_pos = pTSprite->ownerActor->interpolatedvec3(smoothratio);
pTSprite->ang = pTSprite->ownerActor->interpolatedang(smoothratio); pTSprite->ang = pTSprite->ownerActor->interpolatedang(smoothratio);
} }
} }
@ -110,7 +110,7 @@ static void analyzesprites(tspriteArray& tsprites, int x, int y, int z, double c
{ {
pTSprite->cstat |= CSTAT_SPRITE_YCENTER; pTSprite->cstat |= CSTAT_SPRITE_YCENTER;
int nTileY = (tileHeight(pTSprite->picnum) * pTSprite->yrepeat) * 2; int nTileY = (tileHeight(pTSprite->picnum) * pTSprite->yrepeat) * 2;
pTSprite->pos.Z -= nTileY; pTSprite->__int_pos.Z -= nTileY;
} }
if (pTSprite->pal == 4 && pTSprite->shade >= numshades) pTSprite->shade = numshades - 1; if (pTSprite->pal == 4 && pTSprite->shade >= numshades) pTSprite->shade = numshades - 1;

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

@ -103,7 +103,7 @@ int GetRotation(tspriteArray& tsprites, int tSpriteNum, int viewx, int viewy)
// Get which of the 8 angles of the sprite to draw (0-7) // Get which of the 8 angles of the sprite to draw (0-7)
// rotation ranges from 0-7 // rotation ranges from 0-7
angle2 = getangle(tsp->pos.X - viewx, tsp->pos.Y - viewy); angle2 = getangle(tsp->__int_pos.X - viewx, tsp->__int_pos.Y - viewy);
rotation = ((tsp->ang + 3072 + 128 - angle2) & 2047); rotation = ((tsp->ang + 3072 + 128 - angle2) & 2047);
rotation = (rotation >> 8) & 7; rotation = (rotation >> 8) & 7;
@ -211,7 +211,7 @@ int DoShadowFindGroundPoint(tspritetype* tspr)
save_cstat = tspr->cstat; save_cstat = tspr->cstat;
tspr->cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN); tspr->cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
FAFgetzrangepoint(tspr->pos.X, tspr->pos.Y, tspr->pos.Z, tspr->sectp, &hiz, &ceilhit, &loz, &florhit); FAFgetzrangepoint(tspr->__int_pos.X, tspr->__int_pos.Y, tspr->__int_pos.Z, tspr->sectp, &hiz, &ceilhit, &loz, &florhit);
tspr->cstat = save_cstat; tspr->cstat = save_cstat;
switch (florhit.type) switch (florhit.type)
@ -263,7 +263,7 @@ void DoShadows(tspriteArray& tsprites, tspritetype* tsp, int viewz, int camang)
auto sect = tsp->sectp; auto sect = tsp->sectp;
// make sure its the correct sector // make sure its the correct sector
// DoShadowFindGroundPoint calls FAFgetzrangepoint and this is sensitive // DoShadowFindGroundPoint calls FAFgetzrangepoint and this is sensitive
updatesector(tsp->pos.X, tsp->pos.Y, &sect); updatesector(tsp->__int_pos.X, tsp->__int_pos.Y, &sect);
if (sect == nullptr) if (sect == nullptr)
{ {
@ -300,7 +300,7 @@ void DoShadows(tspriteArray& tsprites, tspritetype* tsp, int viewz, int camang)
} }
// need to find the ground here // need to find the ground here
tSpr->pos.Z = loz; tSpr->__int_pos.Z = loz;
// if below or close to sprites z don't bother to draw it // if below or close to sprites z don't bother to draw it
if ((viewz - loz) > -Z(8)) if ((viewz - loz) > -Z(8))
@ -335,9 +335,9 @@ void DoShadows(tspriteArray& tsprites, tspritetype* tsp, int viewz, int camang)
else else
{ {
// Alter the shadow's position so that it appears behind the sprite itself. // Alter the shadow's position so that it appears behind the sprite itself.
int look = getangle(tSpr->pos.X - Player[screenpeek].si.X, tSpr->pos.Y - Player[screenpeek].si.Y); int look = getangle(tSpr->__int_pos.X - Player[screenpeek].si.X, tSpr->__int_pos.Y - Player[screenpeek].si.Y);
tSpr->pos.X += bcos(look, -9); tSpr->__int_pos.X += bcos(look, -9);
tSpr->pos.Y += bsin(look, -9); tSpr->__int_pos.Y += bsin(look, -9);
} }
// Check for voxel items and use a round generic pic if so // Check for voxel items and use a round generic pic if so
@ -406,12 +406,12 @@ void DoMotionBlur(tspriteArray& tsprites, tspritetype const * const tsp)
*tSpr = *tsp; *tSpr = *tsp;
tSpr->cstat |= CSTAT_SPRITE_TRANSLUCENT|CSTAT_SPRITE_TRANS_FLIP; tSpr->cstat |= CSTAT_SPRITE_TRANSLUCENT|CSTAT_SPRITE_TRANS_FLIP;
tSpr->pos.X += dx; tSpr->__int_pos.X += dx;
tSpr->pos.Y += dy; tSpr->__int_pos.Y += dy;
dx += nx; dx += nx;
dy += ny; dy += ny;
tSpr->pos.Z += dz; tSpr->__int_pos.Z += dz;
dz += nz; dz += nz;
tSpr->xrepeat = uint8_t(xrepeat); tSpr->xrepeat = uint8_t(xrepeat);
@ -456,13 +456,13 @@ void WarpCopySprite(tspriteArray& tsprites)
tspritetype* newTSpr = renderAddTsprite(tsprites, itActor2); tspritetype* newTSpr = renderAddTsprite(tsprites, itActor2);
newTSpr->statnum = 0; newTSpr->statnum = 0;
xoff = itActor->int_pos().X - newTSpr->pos.X; xoff = itActor->int_pos().X - newTSpr->__int_pos.X;
yoff = itActor->int_pos().Y - newTSpr->pos.Y; yoff = itActor->int_pos().Y - newTSpr->__int_pos.Y;
zoff = itActor->int_pos().Z - newTSpr->pos.Z; zoff = itActor->int_pos().Z - newTSpr->__int_pos.Z;
newTSpr->pos.X = itActor1->int_pos().X - xoff; newTSpr->__int_pos.X = itActor1->int_pos().X - xoff;
newTSpr->pos.Y = itActor1->int_pos().Y - yoff; newTSpr->__int_pos.Y = itActor1->int_pos().Y - yoff;
newTSpr->pos.Z = itActor1->int_pos().Z - zoff; newTSpr->__int_pos.Z = itActor1->int_pos().Z - zoff;
newTSpr->sectp = itActor1->sector(); newTSpr->sectp = itActor1->sector();
} }
@ -478,8 +478,8 @@ void WarpCopySprite(tspriteArray& tsprites)
tspritetype* newTSpr = renderAddTsprite(tsprites, itActor2); tspritetype* newTSpr = renderAddTsprite(tsprites, itActor2);
newTSpr->statnum = 0; newTSpr->statnum = 0;
auto off = itActor1->int_pos() - newTSpr->pos; auto off = itActor1->int_pos() - newTSpr->__int_pos;
newTSpr->pos = itActor->int_pos() - off; newTSpr->__int_pos = itActor->int_pos() - off;
newTSpr->sectp = itActor->sector(); newTSpr->sectp = itActor->sector();
} }
} }
@ -491,7 +491,7 @@ void DoStarView(tspritetype* tsp, DSWActor* tActor, int viewz)
{ {
extern STATE s_Star[], s_StarDown[]; extern STATE s_Star[], s_StarDown[];
extern STATE s_StarStuck[], s_StarDownStuck[]; extern STATE s_StarStuck[], s_StarDownStuck[];
int zdiff = viewz - tsp->pos.Z; int zdiff = viewz - tsp->__int_pos.Z;
if (labs(zdiff) > Z(24)) if (labs(zdiff) > Z(24))
{ {
@ -516,7 +516,7 @@ DSWActor* CopySprite(sprt const* tsp, sectortype* newsector)
auto actorNew = insertActor(newsector, STAT_FAF_COPY); auto actorNew = insertActor(newsector, STAT_FAF_COPY);
actorNew->set_int_pos(tsp->pos); actorNew->set_int_pos(tsp->__int_pos);
actorNew->spr.cstat = tsp->cstat; actorNew->spr.cstat = tsp->cstat;
actorNew->spr.picnum = tsp->picnum; actorNew->spr.picnum = tsp->picnum;
actorNew->spr.pal = tsp->pal; actorNew->spr.pal = tsp->pal;
@ -546,7 +546,7 @@ DSWActor* ConnectCopySprite(spritetypebase const* tsp)
testz = GetSpriteZOfTop(tsp) - Z(10); testz = GetSpriteZOfTop(tsp) - Z(10);
if (testz < tsp->sectp->ceilingz) if (testz < tsp->sectp->ceilingz)
updatesectorz(tsp->pos.X, tsp->pos.Y, testz, &newsector); updatesectorz(tsp->__int_pos.X, tsp->__int_pos.Y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sectp) if (newsector != nullptr && newsector != tsp->sectp)
{ {
@ -560,7 +560,7 @@ DSWActor* ConnectCopySprite(spritetypebase const* tsp)
testz = GetSpriteZOfBottom(tsp) + Z(10); testz = GetSpriteZOfBottom(tsp) + Z(10);
if (testz > tsp->sectp->floorz) if (testz > tsp->sectp->floorz)
updatesectorz(tsp->pos.X, tsp->pos.Y, testz, &newsector); updatesectorz(tsp->__int_pos.X, tsp->__int_pos.Y, testz, &newsector);
if (newsector != nullptr && newsector != tsp->sectp) if (newsector != nullptr && newsector != tsp->sectp)
{ {
@ -623,7 +623,7 @@ void analyzesprites(tspriteArray& tsprites, int viewx, int viewy, int viewz, int
{ {
if (tsp->statnum <= STAT_SKIP4_INTERP_END) if (tsp->statnum <= STAT_SKIP4_INTERP_END)
{ {
tsp->pos = tActor->interpolatedvec3(smr4, 18); tsp->__int_pos = tActor->interpolatedvec3(smr4, 18);
} }
} }
@ -631,7 +631,7 @@ void analyzesprites(tspriteArray& tsprites, int viewx, int viewy, int viewz, int
{ {
if (tsp->statnum <= STAT_SKIP2_INTERP_END) if (tsp->statnum <= STAT_SKIP2_INTERP_END)
{ {
tsp->pos = tActor->interpolatedvec3(smr2, 17); tsp->__int_pos = tActor->interpolatedvec3(smr2, 17);
} }
} }
} }
@ -641,7 +641,7 @@ void analyzesprites(tspriteArray& tsprites, int viewx, int viewy, int viewz, int
{ {
int32_t const floorz = getflorzofslopeptr(tActor->sector(), tActor->int_pos().X, tActor->int_pos().Y); int32_t const floorz = getflorzofslopeptr(tActor->sector(), tActor->int_pos().X, tActor->int_pos().Y);
if (tActor->int_pos().Z > floorz) if (tActor->int_pos().Z > floorz)
tsp->pos.Z = floorz; tsp->__int_pos.Z = floorz;
} }
if (r_shadows && (tActor->user.Flags & SPR_SHADOW)) if (r_shadows && (tActor->user.Flags & SPR_SHADOW))
@ -761,16 +761,16 @@ void analyzesprites(tspriteArray& tsprites, int viewx, int viewy, int viewz, int
{ {
// move sprite forward some so he looks like he's // move sprite forward some so he looks like he's
// climbing // climbing
tsp->pos.X = pp->si.X + MOVEx(128 + 80, tsp->ang); tsp->__int_pos.X = pp->si.X + MOVEx(128 + 80, tsp->ang);
tsp->pos.Y = pp->si.Y + MOVEy(128 + 80, tsp->ang); tsp->__int_pos.Y = pp->si.Y + MOVEy(128 + 80, tsp->ang);
} }
else else
{ {
tsp->pos.X = pp->si.X; tsp->__int_pos.X = pp->si.X;
tsp->pos.Y = pp->si.Y; tsp->__int_pos.Y = pp->si.Y;
} }
tsp->pos.Z = tsp->pos.Z + pp->si.Z; tsp->__int_pos.Z = tsp->__int_pos.Z + pp->si.Z;
tsp->ang = pp->siang; tsp->ang = pp->siang;
//continue; //continue;
} }
@ -785,9 +785,9 @@ void analyzesprites(tspriteArray& tsprites, int viewx, int viewy, int viewz, int
{ {
pp = tActor->user.PlayerP; pp = tActor->user.PlayerP;
int sr = 65536 - int(smoothratio); int sr = 65536 - int(smoothratio);
tsp->pos.X -= MulScale(pp->pos.X - pp->opos.X, sr, 16); tsp->__int_pos.X -= MulScale(pp->pos.X - pp->opos.X, sr, 16);
tsp->pos.Y -= MulScale(pp->pos.Y - pp->opos.Y, sr, 16); tsp->__int_pos.Y -= MulScale(pp->pos.Y - pp->opos.Y, sr, 16);
tsp->pos.Z -= MulScale(pp->pos.Z - pp->opos.Z, sr, 16); tsp->__int_pos.Z -= MulScale(pp->pos.Z - pp->opos.Z, sr, 16);
tsp->ang -= MulScale(pp->angle.ang.asbuild() - pp->angle.oang.asbuild(), sr, 16); tsp->ang -= MulScale(pp->angle.ang.asbuild() - pp->angle.oang.asbuild(), sr, 16);
} }
} }
@ -905,8 +905,8 @@ void post_analyzesprites(tspriteArray& tsprites)
continue; continue;
} }
tsp->pos.X = atsp->pos.X; tsp->__int_pos.X = atsp->__int_pos.X;
tsp->pos.Y = atsp->pos.Y; tsp->__int_pos.Y = atsp->__int_pos.Y;
// statnum is priority - draw this ALWAYS first at 0 // statnum is priority - draw this ALWAYS first at 0
// statnum is priority - draw this ALWAYS last at MAXSTATUS // statnum is priority - draw this ALWAYS last at MAXSTATUS
if ((atsp->extra & SPRX_BURNABLE)) if ((atsp->extra & SPRX_BURNABLE))

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

@ -242,15 +242,15 @@ inline int GetSpriteSizeToBottom(const spritetypebase* sp)
inline int GetSpriteZOfTop(const spritetypebase* sp) inline int GetSpriteZOfTop(const spritetypebase* sp)
{ {
return (sp->cstat & CSTAT_SPRITE_YCENTER) ? return (sp->cstat & CSTAT_SPRITE_YCENTER) ?
sp->pos.Z - GetSpriteSizeToTop(sp) : sp->__int_pos.Z - GetSpriteSizeToTop(sp) :
sp->pos.Z - GetSpriteSizeZ(sp); sp->__int_pos.Z - GetSpriteSizeZ(sp);
} }
inline int GetSpriteZOfBottom(const spritetypebase* sp) inline int GetSpriteZOfBottom(const spritetypebase* sp)
{ {
return (sp->cstat & CSTAT_SPRITE_YCENTER) ? return (sp->cstat & CSTAT_SPRITE_YCENTER) ?
sp->pos.Z + GetSpriteSizeToBottom(sp) : sp->__int_pos.Z + GetSpriteSizeToBottom(sp) :
sp->pos.Z; sp->__int_pos.Z;
} }
// mid and upper/lower sprite calculations // mid and upper/lower sprite calculations
@ -2119,7 +2119,7 @@ struct ANIM
return SectorObject[animindex].pmid.Z; return SectorObject[animindex].pmid.Z;
case ANIM_Spritez: case ANIM_Spritez:
if (animactor == nullptr) return scratch; if (animactor == nullptr) return scratch;
return animactor->spr.pos.Z; return animactor->spr.__int_pos.Z;
case ANIM_Userz: case ANIM_Userz:
if (animactor == nullptr) return scratch; if (animactor == nullptr) return scratch;
return animactor->user.pos.Z; return animactor->user.pos.Z;

6
source/games/sw/src/interpso.cpp
View file

@ -157,15 +157,15 @@ static void setvalue(so_interp::interp_data& element, double value)
break; break;
case soi_sprx: case soi_sprx:
if (element.actorofang) if (element.actorofang)
element.actorofang->spr.pos.X = (int)value; element.actorofang->spr.__int_pos.X = (int)value;
break; break;
case soi_spry: case soi_spry:
if (element.actorofang) if (element.actorofang)
element.actorofang->spr.pos.Y = (int)value; element.actorofang->spr.__int_pos.Y = (int)value;
break; break;
case soi_sprz: case soi_sprz:
if (element.actorofang) if (element.actorofang)
element.actorofang->spr.pos.Z = (int)value; element.actorofang->spr.__int_pos.Z = (int)value;
break; break;
default: default:
break; break;

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

@ -532,7 +532,7 @@ void SWSoundEngine::CalcPosVel(int type, const void* source, const float pt[3],
} }
else if (type == SOURCE_Actor || type == SOURCE_Player) else if (type == SOURCE_Actor || type == SOURCE_Player)
{ {
vpos = type == SOURCE_Actor ? &((DSWActor*)source)->spr.pos : &((PLAYER*)source)->pos; vpos = type == SOURCE_Actor ? &((DSWActor*)source)->spr.__int_pos : &((PLAYER*)source)->pos;
FVector3 npos = GetSoundPos(vpos); FVector3 npos = GetSoundPos(vpos);
*pos = npos; *pos = npos;
@ -552,7 +552,7 @@ void SWSoundEngine::CalcPosVel(int type, const void* source, const float pt[3],
else if (type == SOURCE_Ambient) else if (type == SOURCE_Ambient)
{ {
auto spot = ((AmbientSound*)source)->spot; auto spot = ((AmbientSound*)source)->spot;
vpos = &spot->spr.pos; vpos = &spot->spr.__int_pos;
FVector3 npos = GetSoundPos(vpos); FVector3 npos = GetSoundPos(vpos);
// Can the ambient sound see the player? If not, tone it down some. // Can the ambient sound see the player? If not, tone it down some.