mirror of
https://github.com/DrBeef/Raze.git
synced 2024-11-15 17:01:51 +00:00
5f18109371
This also caches a wall's length to avoid taking the square root every single time for a slope calculation.
390 lines
12 KiB
C++
390 lines
12 KiB
C++
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2021 Christoph Oelckers & Mitchell Richters
|
|
|
|
This is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
|
|
#include "gamefuncs.h"
|
|
#include "gamestruct.h"
|
|
#include "intvec.h"
|
|
#include "coreactor.h"
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Unified chasecam function for all games.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
int cameradist, cameraclock;
|
|
|
|
bool calcChaseCamPos(int* px, int* py, int* pz, spritetype* pspr, sectortype** psect, binangle ang, fixedhoriz horiz, double const smoothratio)
|
|
{
|
|
HitInfoBase hitinfo;
|
|
binangle daang;
|
|
short bakcstat;
|
|
int newdist;
|
|
|
|
if (!*psect) return false;
|
|
// Calculate new pos to shoot backwards, using averaged values from the big three.
|
|
int nx = gi->chaseCamX(ang);
|
|
int ny = gi->chaseCamY(ang);
|
|
int nz = gi->chaseCamZ(horiz);
|
|
|
|
bakcstat = pspr->cstat;
|
|
pspr->cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
|
|
updatesectorz(*px, *py, *pz, psect);
|
|
hitscan({ *px, *py, *pz }, *psect, { nx, ny, nz }, hitinfo, CLIPMASK1);
|
|
pspr->cstat = bakcstat;
|
|
|
|
int hx = hitinfo.hitpos.x - *px;
|
|
int hy = hitinfo.hitpos.y - *py;
|
|
|
|
if (*psect == nullptr)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If something is in the way, make pp->camera_dist lower if necessary
|
|
if (abs(nx) + abs(ny) > abs(hx) + abs(hy))
|
|
{
|
|
if (hitinfo.hitWall != nullptr)
|
|
{
|
|
// Push you a little bit off the wall
|
|
*psect = hitinfo.hitSector;
|
|
daang = bvectangbam(hitinfo.hitWall->point2Wall()->x - hitinfo.hitWall->x,
|
|
hitinfo.hitWall->point2Wall()->y - hitinfo.hitWall->y);
|
|
newdist = nx * daang.bsin() + ny * -daang.bcos();
|
|
|
|
if (abs(nx) > abs(ny))
|
|
hx -= MulScale(nx, newdist, 28);
|
|
else
|
|
hy -= MulScale(ny, newdist, 28);
|
|
}
|
|
else if (hitinfo.hitActor == nullptr)
|
|
{
|
|
// Push you off the ceiling/floor
|
|
*psect = hitinfo.hitSector;
|
|
|
|
if (abs(nx) > abs(ny))
|
|
hx -= (nx >> 5);
|
|
else
|
|
hy -= (ny >> 5);
|
|
}
|
|
else
|
|
{
|
|
// If you hit a sprite that's not a wall sprite - try again.
|
|
spritetype* hspr = &hitinfo.hitActor->s();
|
|
|
|
if (!(hspr->cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
|
|
{
|
|
bakcstat = hspr->cstat;
|
|
hspr->cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
|
|
calcChaseCamPos(px, py, pz, pspr, psect, ang, horiz, smoothratio);
|
|
hspr->cstat = bakcstat;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// same as wall calculation.
|
|
daang = buildang(pspr->ang - 512);
|
|
newdist = nx * daang.bsin() + ny * -daang.bcos();
|
|
|
|
if (abs(nx) > abs(ny))
|
|
hx -= MulScale(nx, newdist, 28);
|
|
else
|
|
hy -= MulScale(ny, newdist, 28);
|
|
}
|
|
}
|
|
|
|
if (abs(nx) > abs(ny))
|
|
newdist = DivScale(hx, nx, 16);
|
|
else
|
|
newdist = DivScale(hy, ny, 16);
|
|
|
|
if (newdist < cameradist)
|
|
cameradist = newdist;
|
|
}
|
|
|
|
// Actually move you! (Camerdist is 65536 if nothing is in the way)
|
|
*px += MulScale(nx, cameradist, 16);
|
|
*py += MulScale(ny, cameradist, 16);
|
|
*pz += MulScale(nz, cameradist, 16);
|
|
|
|
// Caculate clock using GameTicRate so it increases the same rate on all speed computers.
|
|
int myclock = PlayClock + MulScale(120 / GameTicRate, int(smoothratio), 16);
|
|
if (cameraclock == INT_MIN)
|
|
{
|
|
// Third person view was just started.
|
|
cameraclock = myclock;
|
|
}
|
|
|
|
// Slowly increase cameradist until it reaches 65536.
|
|
cameradist = min(cameradist + ((myclock - cameraclock) << 10), 65536);
|
|
cameraclock = myclock;
|
|
|
|
// Make sure psectnum is correct.
|
|
updatesectorz(*px, *py, *pz, psect);
|
|
|
|
return true;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// consolidated slope calculation
|
|
//
|
|
//==========================================================================
|
|
|
|
void calcSlope(const sectortype* sec, float xpos, float ypos, float* pceilz, float* pflorz)
|
|
{
|
|
int bits = 0;
|
|
if (pceilz)
|
|
{
|
|
bits |= sec->ceilingstat;
|
|
*pceilz = float(sec->ceilingz);
|
|
}
|
|
if (pflorz)
|
|
{
|
|
bits |= sec->floorstat;
|
|
*pflorz = float(sec->floorz);
|
|
}
|
|
|
|
if ((bits & CSTAT_SECTOR_SLOPE) == CSTAT_SECTOR_SLOPE)
|
|
{
|
|
auto wal = sec->firstWall();
|
|
int len = wal->Length();
|
|
if (len != 0)
|
|
{
|
|
float den = (wal->deltax() * (float(ypos - wal->y)) - wal->deltay() * (float(xpos - wal->x))) * (1.f / 8.f);
|
|
if (pceilz && sec->ceilingstat & CSTAT_SECTOR_SLOPE) *pceilz += (sec->ceilingheinum * den) / len;
|
|
if (pflorz && sec->floorstat & CSTAT_SECTOR_SLOPE) *pflorz += (sec->floorheinum * den) / len;
|
|
}
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// for the renderer (Polymost variants are in polymost.cpp)
|
|
//
|
|
//==========================================================================
|
|
|
|
void PlanesAtPoint(const sectortype* sec, int dax, int day, float* pceilz, float* pflorz)
|
|
{
|
|
calcSlope(sec, dax, day, pceilz, pflorz);
|
|
if (pceilz) *pceilz *= -(1 / 256.f);
|
|
if (pflorz) *pflorz *= -(1 / 256.f);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// for the games
|
|
//
|
|
//==========================================================================
|
|
|
|
int32_t getceilzofslopeptr(usectorptr_t sec, int32_t dax, int32_t day)
|
|
{
|
|
float z;
|
|
calcSlope(sec, dax, day, &z, nullptr);
|
|
return int(z);
|
|
}
|
|
|
|
int32_t getflorzofslopeptr(usectorptr_t sec, int32_t dax, int32_t day)
|
|
{
|
|
float z;
|
|
calcSlope(sec, dax, day, nullptr, &z);
|
|
return int(z);
|
|
}
|
|
|
|
void getzsofslopeptr(usectorptr_t sec, int32_t dax, int32_t day, int32_t* ceilz, int32_t* florz)
|
|
{
|
|
float c, f;
|
|
calcSlope(sec, dax, day, &c, &f);
|
|
*ceilz = int(c);
|
|
*florz = int(f);
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// Calculate the position of a wall sprite in the world
|
|
//
|
|
//==========================================================================
|
|
|
|
void GetWallSpritePosition(const tspritetype* spr, vec2_t pos, vec2_t* out, bool render)
|
|
{
|
|
auto tex = tileGetTexture(spr->picnum);
|
|
|
|
int width, leftofs;
|
|
if (render && hw_hightile && TileFiles.tiledata[spr->picnum].hiofs.xsize)
|
|
{
|
|
width = TileFiles.tiledata[spr->picnum].hiofs.xsize;
|
|
leftofs = (TileFiles.tiledata[spr->picnum].hiofs.xoffs + spr->xoffset);
|
|
}
|
|
else
|
|
{
|
|
width = (int)tex->GetDisplayWidth();
|
|
leftofs = ((int)tex->GetDisplayLeftOffset() + spr->xoffset);
|
|
}
|
|
|
|
int x = bsin(spr->ang) * spr->xrepeat;
|
|
int y = -bcos(spr->ang) * spr->xrepeat;
|
|
|
|
int xoff = leftofs;
|
|
if (spr->cstat & CSTAT_SPRITE_XFLIP) xoff = -xoff;
|
|
int origin = (width >> 1) + xoff;
|
|
|
|
out[0].x = pos.x - MulScale(x, origin, 16);
|
|
out[0].y = pos.y - MulScale(y, origin, 16);
|
|
out[1].x = out[0].x + MulScale(x, width, 16);
|
|
out[1].y = out[0].y + MulScale(y, width, 16);
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// Calculate the position of a wall sprite in the world
|
|
//
|
|
//==========================================================================
|
|
|
|
template<class sprt>
|
|
void TGetFlatSpritePosition(const sprt* spr, vec2_t pos, vec2_t* out, bool render)
|
|
{
|
|
auto tex = tileGetTexture(spr->picnum);
|
|
|
|
int width, height, leftofs, topofs;
|
|
if (render && hw_hightile && TileFiles.tiledata[spr->picnum].hiofs.xsize)
|
|
{
|
|
width = TileFiles.tiledata[spr->picnum].hiofs.xsize * spr->xrepeat;
|
|
height = TileFiles.tiledata[spr->picnum].hiofs.ysize * spr->yrepeat;
|
|
leftofs = (TileFiles.tiledata[spr->picnum].hiofs.xoffs + spr->xoffset) * spr->xrepeat;
|
|
topofs = (TileFiles.tiledata[spr->picnum].hiofs.yoffs + spr->yoffset) * spr->yrepeat;
|
|
}
|
|
else
|
|
{
|
|
width = (int)tex->GetDisplayWidth() * spr->xrepeat;
|
|
height = (int)tex->GetDisplayHeight() * spr->yrepeat;
|
|
leftofs = ((int)tex->GetDisplayLeftOffset() + spr->xoffset) * spr->xrepeat;
|
|
topofs = ((int)tex->GetDisplayTopOffset() + spr->yoffset) * spr->yrepeat;
|
|
}
|
|
|
|
if (spr->cstat & CSTAT_SPRITE_XFLIP) leftofs = -leftofs;
|
|
if (spr->cstat & CSTAT_SPRITE_YFLIP) topofs = -topofs;
|
|
|
|
int sprcenterx = (width >> 1) + leftofs;
|
|
int sprcentery = (height >> 1) + topofs;
|
|
|
|
int cosang = bcos(spr->ang);
|
|
int sinang = bsin(spr->ang);
|
|
|
|
out[0].x = pos.x + DMulScale(sinang, sprcenterx, cosang, sprcentery, 16);
|
|
out[0].y = pos.y + DMulScale(sinang, sprcentery, -cosang, sprcenterx, 16);
|
|
|
|
out[1].x = out[0].x - MulScale(sinang, width, 16);
|
|
out[1].y = out[0].y + MulScale(cosang, width, 16);
|
|
|
|
vec2_t sub = { MulScale(cosang, height, 16), MulScale(sinang, height, 16) };
|
|
out[2] = out[1] - 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);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Check if some walls are set to use rotated textures.
|
|
// Ideally this should just have been done with texture rotation,
|
|
// but the effects on the render code would be too severe due to the alignment mess.
|
|
//
|
|
//==========================================================================
|
|
|
|
void checkRotatedWalls()
|
|
{
|
|
for (int i = 0; i < numwalls; ++i)
|
|
{
|
|
if (wall[i].cstat & CSTAT_WALL_ROTATE_90)
|
|
{
|
|
auto& w = wall[i];
|
|
auto& tile = RotTile(w.picnum + animateoffs(w.picnum, 16384));
|
|
|
|
if (tile.newtile == -1 && tile.owner == -1)
|
|
{
|
|
auto owner = w.picnum + animateoffs(w.picnum, 16384);
|
|
|
|
tile.newtile = TileFiles.tileCreateRotated(owner);
|
|
assert(tile.newtile != -1);
|
|
|
|
RotTile(tile.newtile).owner = w.picnum + animateoffs(w.picnum, 16384);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// check if two sectors share a wall connection
|
|
//
|
|
//==========================================================================
|
|
|
|
bool sectorsConnected(int sect1, int sect2)
|
|
{
|
|
for (auto& wal : wallsofsector(sect1))
|
|
{
|
|
if (wal.nextsector == sect2) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// vector serializers
|
|
//
|
|
//==========================================================================
|
|
|
|
FSerializer& Serialize(FSerializer& arc, const char* key, vec2_t& c, vec2_t* def)
|
|
{
|
|
if (arc.isWriting() && def && !memcmp(&c, def, sizeof(c))) return arc;
|
|
if (arc.BeginObject(key))
|
|
{
|
|
arc("x", c.x, def ? &def->x : nullptr)
|
|
("y", c.y, def ? &def->y : nullptr)
|
|
.EndObject();
|
|
}
|
|
return arc;
|
|
}
|
|
|
|
FSerializer& Serialize(FSerializer& arc, const char* key, vec3_t& c, vec3_t* def)
|
|
{
|
|
if (arc.isWriting() && def && !memcmp(&c, def, sizeof(c))) return arc;
|
|
if (arc.BeginObject(key))
|
|
{
|
|
arc("x", c.x, def ? &def->x : nullptr)
|
|
("y", c.y, def ? &def->y : nullptr)
|
|
("z", c.z, def ? &def->z : nullptr)
|
|
.EndObject();
|
|
}
|
|
return arc;
|
|
}
|