void APathFollower::Tick ()
{
if (!bActive)
return;
if (bJustStepped)
{
bJustStepped = false;
if (CurrNode->args[2])
{
HoldTime = level.time + CurrNode->args[2] * TICRATE / 8;
SetXYZ(CurrNode->X(), CurrNode->Y(), CurrNode->Z());
}
}
if (HoldTime > level.time)
return;
// Splines must have a previous node.
if (PrevNode == NULL && !(args[2] & 1))
{
bActive = false;
return;
}
// All paths must have a current node.
if (CurrNode->Next == NULL)
{
bActive = false;
return;
}
if (Interpolate ())
{
Time += 8.f / ((float)CurrNode->args[1] * (float)TICRATE);
if (Time > 1.f)
{
Time -= 1.f;
bJustStepped = true;
PrevNode = CurrNode;
CurrNode = CurrNode->Next;
if (CurrNode != NULL)
NewNode ();
if (CurrNode == NULL || CurrNode->Next == NULL)
Deactivate (this);
if ((args[2] & 1) == 0 && CurrNode->Next->Next == NULL)
Deactivate (this);
}
}
}
//==========================================================================
//
//
//
//==========================================================================
void ADynamicLight::UpdateLocation()
{
fixed_t oldx=X();
fixed_t oldy=Y();
fixed_t oldradius=radius;
float intensity;
if (IsActive())
{
if (target)
{
angle_t angle = target->angle>>ANGLETOFINESHIFT;
fixedvec3 pos = target->Vec3Offset(
FixedMul(m_offX, finecosine[angle]) + FixedMul(m_offZ, finesine[angle]),
FixedMul(m_offX, finesine[angle]) - FixedMul(m_offZ, finecosine[angle]),
m_offY + target->GetBobOffset());
SetXYZ(pos); // attached lights do not need to go into the regular blockmap
PrevX = pos.x;
PrevY = pos.y;
PrevZ = pos.z;
subsector = R_PointInSubsector(pos.x, pos.y);
Sector = subsector->sector;
}
// The radius being used here is always the maximum possible with the
// current settings. This avoids constant relinking of flickering lights
if (lighttype == FlickerLight || lighttype == RandomFlickerLight)
{
intensity = float(m_intensity[1]);
}
else
{
intensity = m_currentIntensity;
}
radius = FLOAT2FIXED(intensity * 2.0f * gl_lights_size);
if (X()!=oldx || Y()!=oldy || radius!=oldradius)
{
//Update the light lists
LinkLight();
}
}
}
//==========================================================================
//
//
//
//==========================================================================
void ADynamicLight::UpdateLocation()
{
double oldx= X();
double oldy= Y();
double oldradius= radius;
float intensity;
if (IsActive())
{
if (target)
{
DAngle angle = target->Angles.Yaw;
double s = angle.Sin();
double c = angle.Cos();
DVector3 pos = target->Vec3Offset(m_off.X * c + m_off.Y * s, m_off.X * s - m_off.Y * c, m_off.Z + target->GetBobOffset());
SetXYZ(pos); // attached lights do not need to go into the regular blockmap
Prev = target->Pos();
subsector = R_PointInSubsector(Prev);
Sector = subsector->sector;
}
// The radius being used here is always the maximum possible with the
// current settings. This avoids constant relinking of flickering lights
if (lighttype == FlickerLight || lighttype == RandomFlickerLight || lighttype == PulseLight)
{
intensity = float(MAX(m_Radius[0], m_Radius[1]));
}
else
{
intensity = m_currentRadius;
}
radius = intensity * 2.0f * gl_lights_size;
if (X() != oldx || Y() != oldy || radius != oldradius)
{
//Update the light lists
LinkLight();
}
}
}
bool CItem::AddToGround(long lMapIndex, const PIXEL_POSITION & pos, bool skipOwnerCheck)
{
if (0 == lMapIndex)
{
sys_err("wrong map index argument: %d", lMapIndex);
return false;
}
if (GetSectree())
{
sys_err("sectree already assigned");
return false;
}
if (!skipOwnerCheck && m_pOwner)
{
sys_err("owner pointer not null");
return false;
}
LPSECTREE tree = SECTREE_MANAGER::instance().Get(lMapIndex, pos.x, pos.y);
if (!tree)
{
sys_err("cannot find sectree by %dx%d", pos.x, pos.y);
return false;
}
//tree->Touch();
SetWindow(GROUND);
SetXYZ(pos.x, pos.y, pos.z);
tree->InsertEntity(this);
UpdateSectree();
Save();
return true;
}
void RAS_TexVert::Transform(const MT_Matrix4x4& mat, const MT_Matrix4x4& nmat)
{
SetXYZ((mat*MT_Vector4(m_localxyz[0], m_localxyz[1], m_localxyz[2], 1.0)).getValue());
SetNormal((nmat*MT_Vector4(m_normal[0], m_normal[1], m_normal[2], 1.0)).getValue());
SetTangent((nmat*MT_Vector4(m_tangent[0], m_tangent[1], m_tangent[2], 1.0)).getValue());
}
bool APathFollower::Interpolate ()
{
fixed_t dx = 0, dy = 0, dz = 0;
if ((args[2] & 8) && Time > 0.f)
{
dx = X();
dy = Y();
dz = Z();
}
if (CurrNode->Next==NULL) return false;
UnlinkFromWorld ();
fixed_t x, y, z;
if (args[2] & 1)
{ // linear
x = FLOAT2FIXED(Lerp (FIXED2FLOAT(CurrNode->X()), FIXED2FLOAT(CurrNode->Next->X())));
y = FLOAT2FIXED(Lerp (FIXED2FLOAT(CurrNode->Y()), FIXED2FLOAT(CurrNode->Next->Y())));
z = FLOAT2FIXED(Lerp (FIXED2FLOAT(CurrNode->Z()), FIXED2FLOAT(CurrNode->Next->Z())));
}
else
{ // spline
if (CurrNode->Next->Next==NULL) return false;
x = FLOAT2FIXED(Splerp (FIXED2FLOAT(PrevNode->X()), FIXED2FLOAT(CurrNode->X()),
FIXED2FLOAT(CurrNode->Next->X()), FIXED2FLOAT(CurrNode->Next->Next->X())));
y = FLOAT2FIXED(Splerp (FIXED2FLOAT(PrevNode->Y()), FIXED2FLOAT(CurrNode->Y()),
FIXED2FLOAT(CurrNode->Next->Y()), FIXED2FLOAT(CurrNode->Next->Next->Y())));
z = FLOAT2FIXED(Splerp (FIXED2FLOAT(PrevNode->Z()), FIXED2FLOAT(CurrNode->Z()),
FIXED2FLOAT(CurrNode->Next->Z()), FIXED2FLOAT(CurrNode->Next->Next->Z())));
}
SetXYZ(x, y, z);
LinkToWorld ();
if (args[2] & 6)
{
if (args[2] & 8)
{
if (args[2] & 1)
{ // linear
dx = CurrNode->Next->X() - CurrNode->X();
dy = CurrNode->Next->Y() - CurrNode->Y();
dz = CurrNode->Next->Z() - CurrNode->Z();
}
else if (Time > 0.f)
{ // spline
dx = x - dx;
dy = y - dy;
dz = z - dz;
}
else
{
int realarg = args[2];
args[2] &= ~(2|4|8);
Time += 0.1f;
dx = x;
dy = y;
dz = z;
Interpolate ();
Time -= 0.1f;
args[2] = realarg;
dx = x - dx;
dy = y - dy;
dz = z - dz;
x -= dx;
y -= dy;
z -= dz;
SetXYZ(x, y, z);
}
if (args[2] & 2)
{ // adjust yaw
angle = R_PointToAngle2 (0, 0, dx, dy);
}
if (args[2] & 4)
{ // adjust pitch; use floats for precision
double fdx = FIXED2DBL(dx);
double fdy = FIXED2DBL(dy);
double fdz = FIXED2DBL(-dz);
double dist = sqrt (fdx*fdx + fdy*fdy);
double ang = dist != 0.f ? atan2 (fdz, dist) : 0;
pitch = (fixed_t)RAD2ANGLE(ang);
}
}
else
{
if (args[2] & 2)
{ // interpolate angle
float angle1 = (float)CurrNode->angle;
float angle2 = (float)CurrNode->Next->angle;
if (angle2 - angle1 <= -2147483648.f)
{
float lerped = Lerp (angle1, angle2 + 4294967296.f);
if (lerped >= 4294967296.f)
{
angle = xs_CRoundToUInt(lerped - 4294967296.f);
}
else
{
angle = xs_CRoundToUInt(lerped);
}
}
else if (angle2 - angle1 >= 2147483648.f)
{
float lerped = Lerp (angle1, angle2 - 4294967296.f);
if (lerped < 0.f)
{
angle = xs_CRoundToUInt(lerped + 4294967296.f);
}
else
{
angle = xs_CRoundToUInt(lerped);
}
}
else
{
angle = xs_CRoundToUInt(Lerp (angle1, angle2));
}
}
if (args[2] & 1)
{ // linear
if (args[2] & 4)
{ // interpolate pitch
pitch = FLOAT2FIXED(Lerp (FIXED2FLOAT(CurrNode->pitch), FIXED2FLOAT(CurrNode->Next->pitch)));
}
}
else
{ // spline
if (args[2] & 4)
{ // interpolate pitch
pitch = FLOAT2FIXED(Splerp (FIXED2FLOAT(PrevNode->pitch), FIXED2FLOAT(CurrNode->pitch),
FIXED2FLOAT(CurrNode->Next->pitch), FIXED2FLOAT(CurrNode->Next->Next->pitch)));
}
}
}
}
return true;
}
bool APathFollower::Interpolate ()
{
DVector3 dpos(0, 0, 0);
FLinkContext ctx;
if ((args[2] & 8) && Time > 0.f)
{
dpos = Pos();
}
if (CurrNode->Next==NULL) return false;
UnlinkFromWorld (&ctx);
DVector3 newpos;
if (args[2] & 1)
{ // linear
newpos.X = Lerp(CurrNode->X(), CurrNode->Next->X());
newpos.Y = Lerp(CurrNode->Y(), CurrNode->Next->Y());
newpos.Z = Lerp(CurrNode->Z(), CurrNode->Next->Z());
}
else
{ // spline
if (CurrNode->Next->Next==NULL) return false;
newpos.X = Splerp(PrevNode->X(), CurrNode->X(), CurrNode->Next->X(), CurrNode->Next->Next->X());
newpos.Y = Splerp(PrevNode->Y(), CurrNode->Y(), CurrNode->Next->Y(), CurrNode->Next->Next->Y());
newpos.Z = Splerp(PrevNode->Z(), CurrNode->Z(), CurrNode->Next->Z(), CurrNode->Next->Next->Z());
}
SetXYZ(newpos);
LinkToWorld (&ctx);
if (args[2] & 6)
{
if (args[2] & 8)
{
if (args[2] & 1)
{ // linear
dpos.X = CurrNode->Next->X() - CurrNode->X();
dpos.Y = CurrNode->Next->Y() - CurrNode->Y();
dpos.Z = CurrNode->Next->Z() - CurrNode->Z();
}
else if (Time > 0.f)
{ // spline
dpos = newpos - dpos;
}
else
{
int realarg = args[2];
args[2] &= ~(2|4|8);
Time += 0.1f;
dpos = newpos;
Interpolate ();
Time -= 0.1f;
args[2] = realarg;
dpos = newpos - dpos;
newpos -= dpos;
SetXYZ(newpos);
}
if (args[2] & 2)
{ // adjust yaw
Angles.Yaw = dpos.Angle();
}
if (args[2] & 4)
{ // adjust pitch; use floats for precision
double dist = dpos.XY().Length();
Angles.Pitch = dist != 0.f ? VecToAngle(dist, -dpos.Z) : 0.;
}
}
else
{
if (args[2] & 2)
{ // interpolate angle
DAngle angle1 = CurrNode->Angles.Yaw.Normalized180();
DAngle angle2 = angle1 + deltaangle(angle1, CurrNode->Next->Angles.Yaw);
Angles.Yaw = Lerp(angle1.Degrees, angle2.Degrees);
}
if (args[2] & 1)
{ // linear
if (args[2] & 4)
{ // interpolate pitch
Angles.Pitch = Lerp(CurrNode->Angles.Pitch.Degrees, CurrNode->Next->Angles.Pitch.Degrees);
}
}
else
{ // spline
if (args[2] & 4)
{ // interpolate pitch
Angles.Pitch = Splerp(PrevNode->Angles.Pitch.Degrees, CurrNode->Angles.Pitch.Degrees,
CurrNode->Next->Angles.Pitch.Degrees, CurrNode->Next->Next->Angles.Pitch.Degrees);
}
}
}
}
return true;
}