raze/source/games/sw/src/interpso.cpp

447 lines
14 KiB
C++
Raw Normal View History

//-------------------------------------------------------------------------
/*
Copyright (C) 1997, 2005 - 3D Realms Entertainment
This file is part of Shadow Warrior version 1.2
Shadow Warrior 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.
Original Source: 1997 - Frank Maddin and Jim Norwood
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "compat.h"
#include "game.h"
#include "interpso.h"
#include "names2.h"
BEGIN_SW_NS
#define SO_MAXINTERPOLATIONS 1024
enum
{
soi_base = 0xffffff,
soi_wallx = 0x1000000,
soi_wally = 0x2000000,
soi_ceil = 0x3000000,
soi_floor = 0x4000000,
soi_sox = 0x5000000,
soi_soy = 0x6000000,
soi_soz = 0x7000000,
soi_sprx = 0x8000000,
soi_spry = 0x9000000,
soi_sprz = 0xa000000,
};
static struct so_interp
{
struct interp_data
{
int curelement;
int32_t oldipos;
int32_t bakipos;
int32_t lastipos;
int32_t lastoldipos;
int32_t lastangdiff;
int32_t spriteofang;
} data[SO_MAXINTERPOLATIONS];
int32_t numinterpolations;
int32_t tic, lasttic;
2020-09-09 18:32:24 +00:00
bool hasvator;
} so_interpdata[MAX_SECTOR_OBJECTS];
static int &getvalue(int element)
{
static int scratch;
int index = element & soi_base;
int type = element & ~soi_base;
switch (type)
{
case soi_wallx:
return wall[index].x;
case soi_wally:
return wall[index].y;
case soi_ceil:
return sector[index].ceilingz;
case soi_floor:
return sector[index].floorz;
case soi_sox:
return SectorObject[index].xmid;
case soi_soy:
return SectorObject[index].ymid;
case soi_soz:
return SectorObject[index].zmid;
case soi_sprx:
return sprite[index].x;
case soi_spry:
return sprite[index].y;
case soi_sprz:
return sprite[index].z;
default:
return scratch;
}
}
static void so_setpointinterpolation(so_interp *interp, int element)
{
int32_t i;
if (interp->numinterpolations >= SO_MAXINTERPOLATIONS)
return;
for (i = 0; i < interp->numinterpolations; i++)
if (interp->data[i].curelement == element)
return;
so_interp::interp_data *data = &interp->data[interp->numinterpolations++];
data->curelement = element;
data->oldipos =
data->lastipos =
data->lastoldipos = getvalue(element);
data->spriteofang = -1;
}
static void so_setspriteanginterpolation(so_interp *interp, int32_t spritenum)
{
int32_t i;
if (interp->numinterpolations >= SO_MAXINTERPOLATIONS)
return;
for (i = 0; i < interp->numinterpolations; i++)
if (interp->data[i].curelement == -1)
return;
so_interp::interp_data *data = &interp->data[interp->numinterpolations++];
data->curelement = -1;
data->oldipos =
data->lastipos =
data->lastoldipos = sprite[spritenum].ang;
data->lastangdiff = 0;
data->spriteofang = spritenum;
}
// Covers points and angles altogether
static void so_stopdatainterpolation(so_interp *interp, int element)
{
int32_t i;
for (i = 0; i < interp->numinterpolations; i++)
if (interp->data[i].curelement == element)
break;
if (i == interp->numinterpolations)
return;
interp->data[i] = interp->data[--(interp->numinterpolations)];
}
void so_addinterpolation(SECTOR_OBJECTp sop)
{
SECTORp *sectp;
int32_t startwall, endwall;
int32_t i;
so_interp *interp = &so_interpdata[sop - SectorObject];
interp->numinterpolations = 0;
interp->hasvator = false;
for (sectp = sop->sectp; *sectp; sectp++)
{
startwall = (*sectp)->wallptr;
endwall = startwall + (*sectp)->wallnum - 1;
for (i = startwall; i <= endwall; i++)
{
int32_t nextwall = wall[i].nextwall;
so_setpointinterpolation(interp, i|soi_wallx);
so_setpointinterpolation(interp, i|soi_wally);
if (nextwall >= 0)
{
so_setpointinterpolation(interp, wall[nextwall].point2|soi_wallx);
so_setpointinterpolation(interp, wall[nextwall].point2|soi_wally);
}
}
int i;
SectIterator it(*sectp - sector);
while ((i = it.NextIndex()) >= 0)
if (sprite[i].statnum == STAT_VATOR && SP_TAG1(sprite+i) == SECT_VATOR)
break;
interp->hasvator |= (i >= 0);
}
if (!interp->hasvator)
for (sectp = sop->sectp; *sectp; sectp++)
{
so_setpointinterpolation(interp, int(*sectp - sector) | soi_floor);
so_setpointinterpolation(interp, int(*sectp - sector) | soi_ceil);
}
// interpolate midpoint, for aiming at a remote controlled SO
so_setpointinterpolation(interp, int(sop - SectorObject) | soi_sox);
so_setpointinterpolation(interp, int(sop - SectorObject) | soi_soy);
so_setpointinterpolation(interp, int(sop - SectorObject) | soi_soz);
interp->tic = 0;
interp->lasttic = synctics;
}
void so_setspriteinterpolation(SECTOR_OBJECTp sop, spritetype *sp)
{
so_interp *interp = &so_interpdata[sop - SectorObject];
int snum = int(sp - sprite);
so_setpointinterpolation(interp, snum | soi_sprx);
so_setpointinterpolation(interp, snum | soi_spry);
if (!interp->hasvator)
so_setpointinterpolation(interp, snum | soi_sprz);
so_setspriteanginterpolation(interp, int(sp - sprite));
}
void so_stopspriteinterpolation(SECTOR_OBJECTp sop, spritetype *sp)
{
so_interp *interp = &so_interpdata[sop - SectorObject];
int snum = int(sp - sprite);
so_stopdatainterpolation(interp, snum | soi_sprx);
so_stopdatainterpolation(interp, snum | soi_spry);
if (!interp->hasvator)
so_stopdatainterpolation(interp, snum | soi_sprz);
so_stopdatainterpolation(interp, -1);
}
void so_setinterpolationtics(SECTOR_OBJECTp sop, int16_t locktics)
{
so_interp *interp = &so_interpdata[sop - SectorObject];
interp->tic = 0;
interp->lasttic = locktics;
}
void so_updateinterpolations(void) // Stick at beginning of domovethings
{
int32_t i;
SECTOR_OBJECTp sop;
so_interp *interp;
so_interp::interp_data *data;
2020-09-09 18:32:24 +00:00
bool interpolating = cl_sointerpolation && !CommEnabled; // If changing from menu
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
bool skip = !SyncInput() && (sop->track == SO_TURRET);
if (SO_EMPTY(sop) || skip)
continue;
if (interp->tic < interp->lasttic)
interp->tic += synctics;
for (i = 0, data = interp->data; i < interp->numinterpolations; i++, data++)
{
if (data->spriteofang >= 0)
{
USERp u = User[data->spriteofang];
if (u)
u->oangdiff = 0;
if (!interpolating)
data->lastangdiff = 0;
data->oldipos = sprite[data->spriteofang].ang;
}
else
data->oldipos = getvalue(data->curelement);
if (!interpolating)
data->lastipos = data->lastoldipos = data->oldipos;
}
}
}
// must call restore for every do interpolations
// make sure you don't exit
void so_dointerpolations(int32_t smoothratio) // Stick at beginning of drawscreen
{
int32_t i, delta;
SECTOR_OBJECTp sop;
so_interp *interp;
so_interp::interp_data *data;
// Set the bakipos values separately, in case a point is shared.
// Also set lastipos if there's been an actual change in a point.
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
bool skip = !SyncInput() && (sop->track == SO_TURRET);
if (SO_EMPTY(sop) || skip)
continue;
for (i = 0; i < interp->numinterpolations; i++)
interp->data[i].bakipos = (interp->data[i].spriteofang >= 0) ?
sprite[interp->data[i].spriteofang].ang :
getvalue(interp->data[i].curelement);
if (interp->tic == 0) // Only if the SO has just moved
{
for (i = 0, data = interp->data; i < interp->numinterpolations; i++, data++)
{
data->lastipos = data->bakipos;
data->lastoldipos = data->oldipos;
if (data->spriteofang >= 0)
{
USERp u = User[data->spriteofang];
data->lastangdiff = u ? u->oangdiff : 0;
}
}
}
}
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
bool skip = !SyncInput() && (sop->track == SO_TURRET);
if (SO_EMPTY(sop) || skip)
continue;
// Check if interpolation has been explicitly disabled
if (interp->lasttic == 0)
continue;
// Unfortunately, interpolating over less samples doesn't work well
// in multiplayer. We also skip any sector object not
// remotely controlled by some player.
if (CommEnabled &&
((interp->lasttic != synctics) ||
!(sop->controller) ||
((Player[screenpeek].sop_control == sop) &&
!Player[screenpeek].sop_remote)))
continue;
int32_t ratio = smoothratio * synctics + 65536 * interp->tic;
ratio /= interp->lasttic;
ratio = (interp->tic == interp->lasttic) ? 65536 : ratio;
for (i = 0, data = interp->data; i < interp->numinterpolations; i++, data++)
{
// Hack for jittery coolies in level 1's train.
// Based in idea on code from draw.cpp:analyzesprites.
// TODO: It could be better. In particular, it could be better
// to conditionally disable the interpolation from analyzesprites
// instead, using TSPRITE info if possible.
if (data->curelement >= soi_sprx)
{
int32_t sprnum = data->curelement & soi_base;
USERp u = User[sprnum];
if (u && (sprite[sprnum].statnum != STAT_DEFAULT) &&
((TEST(u->Flags, SPR_SKIP4) && (sprite[sprnum].statnum <= STAT_SKIP4_INTERP_END)) ||
(TEST(u->Flags, SPR_SKIP2) && (sprite[sprnum].statnum <= STAT_SKIP2_INTERP_END))))
continue;
}
if (data->spriteofang >= 0)
sprite[data->spriteofang].ang = NORM_ANGLE(data->lastoldipos + MulScale(data->lastangdiff, ratio, 16));
else
{
delta = data->lastipos - data->lastoldipos;
getvalue(data->curelement) = data->lastoldipos + MulScale(delta, ratio, 16);
}
}
}
}
void so_restoreinterpolations(void) // Stick at end of drawscreen
{
int32_t i;
SECTOR_OBJECTp sop;
so_interp *interp;
so_interp::interp_data *data;
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
bool skip = !SyncInput() && (sop->track == SO_TURRET);
if (SO_EMPTY(sop) || skip)
continue;
for (i = 0, data = interp->data; i < interp->numinterpolations; i++, data++)
if (data->spriteofang >= 0)
sprite[data->spriteofang].ang = data->bakipos;
else
getvalue(data->curelement) = data->bakipos;
}
}
int SaveSymDataInfo(MFILE_WRITE fil, void *ptr);
2020-09-09 18:32:24 +00:00
int so_writeinterpolations(MFILE_WRITE fil)
{
int32_t i;
SECTOR_OBJECTp sop;
so_interp *interp;
int saveisshot = 0;
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
so_interp::interp_data *data = interp->data;
MWRITE(&interp->numinterpolations,sizeof(interp->numinterpolations),1,fil);
MWRITE(&interp->hasvator,sizeof(interp->hasvator),1,fil);
for (i = 0; i < interp->numinterpolations; i++, data++)
{
MWRITE(&data->curelement, sizeof(data->curelement), 1, fil);
MWRITE(&data->oldipos,sizeof(data->oldipos),1,fil);
MWRITE(&data->spriteofang,sizeof(data->spriteofang),1,fil);
}
}
2020-09-09 18:32:24 +00:00
return saveisshot;
}
int LoadSymDataInfo(MFILE_READ fil, void** ptr);
2020-09-09 18:32:24 +00:00
int so_readinterpolations(MFILE_READ fil)
{
int32_t i;
SECTOR_OBJECTp sop;
so_interp *interp;
int saveisshot = 0;
for (sop = SectorObject, interp = so_interpdata;
sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++, interp++)
{
so_interp::interp_data *data = interp->data;
MREAD(&interp->numinterpolations,sizeof(interp->numinterpolations),1,fil);
MREAD(&interp->hasvator,sizeof(interp->hasvator),1,fil);
for (i = 0; i < interp->numinterpolations; i++, data++)
{
MREAD(&data->curelement, sizeof(data->curelement), 1, fil);
MREAD(&data->oldipos,sizeof(data->oldipos),1,fil);
MREAD(&data->spriteofang,sizeof(data->spriteofang),1,fil);
data->lastipos = data->lastoldipos = data->oldipos;
data->lastangdiff = 0;
}
interp->tic = 0;
interp->lasttic = synctics;
}
2020-09-09 18:32:24 +00:00
return saveisshot;
}
END_SW_NS