580 lines
16 KiB
C++
580 lines
16 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: The Escort's Shield weapon effect
|
|
//
|
|
// $Workfile: $
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
|
|
#include "tf_shieldshared.h"
|
|
#include "edict.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "engine/IEngineTrace.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
#include "cdll_client_int.h"
|
|
#else
|
|
#include "gameinterface.h"
|
|
#endif
|
|
|
|
|
|
|
|
BEGIN_PREDICTION_DATA_NO_BASE( CShieldEffect )
|
|
|
|
DEFINE_FIELD( m_TestPoint, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_Position, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_Velocity, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_CurrentAngles, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_Theta, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_Phi, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_ThetaVelocity, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_PhiVelocity, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_vecDesiredOrigin, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_angDesiredAngles, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_ShieldTheta, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_ShieldPhi, FIELD_FLOAT ),
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CShieldEffect::CShieldEffect( )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// compute rest positions of the springs
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::ComputeRestPositions()
|
|
{
|
|
int i;
|
|
|
|
m_vecRenderMins.Init( FLT_MAX, FLT_MAX, FLT_MAX );
|
|
m_vecRenderMaxs.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );
|
|
|
|
// Set the initial directions and distances (in shield space)...
|
|
for ( i = 0; i < SHIELD_NUM_VERTICAL_POINTS; ++i)
|
|
{
|
|
// Choose phi centered at pi/2
|
|
float phi = (M_PI - m_ShieldPhi) * 0.5f + m_ShieldPhi *
|
|
(float)i / (float)(SHIELD_NUM_VERTICAL_POINTS - 1);
|
|
|
|
for (int j = 0; j < SHIELD_NUM_HORIZONTAL_POINTS; ++j)
|
|
{
|
|
// Choose theta centered at pi/2 also (y, or forward axis)
|
|
float theta = (M_PI - m_ShieldTheta) * 0.5f + m_ShieldTheta *
|
|
(float)j / (float)(SHIELD_NUM_HORIZONTAL_POINTS - 1);
|
|
|
|
int idx = i * SHIELD_NUM_HORIZONTAL_POINTS + j;
|
|
|
|
m_pFixedDirection[idx].x = cos(theta) * sin(phi);
|
|
m_pFixedDirection[idx].y = sin(theta) * sin(phi);
|
|
m_pFixedDirection[idx].z = cos(phi);
|
|
|
|
m_pFixedDirection[idx] *= m_RestLength;
|
|
|
|
VectorMin( m_vecRenderMins, m_pFixedDirection[idx], m_vecRenderMins );
|
|
VectorMax( m_vecRenderMaxs, m_pFixedDirection[idx], m_vecRenderMaxs );
|
|
}
|
|
}
|
|
|
|
// Compute box for fake volume testing
|
|
Vector dist = m_pFixedDirection[0] - m_pFixedDirection[1];
|
|
float l = dist.Length(); // * m_RestLength;
|
|
SetShieldPanelSize( Vector( -l * 0.25f, -l * 0.25f, -l * 0.25f),
|
|
Vector( l * 0.25f, l * 0.25f, l * 0.25f) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets orientation + position
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SetDesiredOrigin( const Vector& origin )
|
|
{
|
|
VectorCopy( origin, m_vecDesiredOrigin );
|
|
}
|
|
|
|
void CShieldEffect::SetDesiredAngles( const QAngle& angles )
|
|
{
|
|
VectorCopy( angles, m_angDesiredAngles );
|
|
}
|
|
|
|
const QAngle& CShieldEffect::GetDesiredAngles() const
|
|
{
|
|
return m_angDesiredAngles;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets a point...
|
|
//-----------------------------------------------------------------------------
|
|
const Vector& CShieldEffect::GetPoint( int x, int y ) const
|
|
{
|
|
return m_pControlPoint[ x + y * SHIELD_NUM_HORIZONTAL_POINTS ];
|
|
}
|
|
|
|
const Vector& CShieldEffect::GetPoint( int i ) const
|
|
{
|
|
return m_pControlPoint[ i ];
|
|
}
|
|
|
|
Vector& CShieldEffect::GetPoint( int i )
|
|
{
|
|
return m_pControlPoint[ i ];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the collision group
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SetCollisionGroup( int group )
|
|
{
|
|
m_CollisionGroup = group;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Hooks in active bits...
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SetActiveVertexList( IActiveVertList *pActiveVerts )
|
|
{
|
|
m_pActiveVerts = pActiveVerts;
|
|
|
|
// No points are visible initially
|
|
for ( int i=0; i < SHIELD_VERTEX_BYTES*8; i++ )
|
|
m_pActiveVerts->SetActiveVertState( i, 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is a particular vertex active?
|
|
//-----------------------------------------------------------------------------
|
|
bool CShieldEffect::IsVertexActive( int x, int y ) const
|
|
{
|
|
if ((x < 0) || (y < 0) || (x >= SHIELD_NUM_HORIZONTAL_POINTS) ||
|
|
(y >= SHIELD_NUM_VERTICAL_POINTS))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int idx = x + (SHIELD_NUM_HORIZONTAL_POINTS) * y;
|
|
return m_pActiveVerts->GetActiveVertState( idx ) != 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is a particular panel active?
|
|
//-----------------------------------------------------------------------------
|
|
bool CShieldEffect::IsPanelActive( int x, int y ) const
|
|
{
|
|
if ((x < 0) || (y < 0) || (x >= SHIELD_HORIZONTAL_PANEL_COUNT) ||
|
|
(y >= SHIELD_VERTICAL_PANEL_COUNT))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int idx = x + (SHIELD_HORIZONTAL_PANEL_COUNT) * y;
|
|
return m_pActivePanels[idx];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Recompute whether the panels are active or not
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::ComputePanelActivity()
|
|
{
|
|
// Check neighbors to see how many squares we've got
|
|
for ( int i = 0; i < SHIELD_NUM_HORIZONTAL_POINTS - 1; ++i)
|
|
{
|
|
for ( int j = 0; j < SHIELD_NUM_VERTICAL_POINTS - 1; ++j)
|
|
{
|
|
int idx = i + j * (SHIELD_NUM_HORIZONTAL_POINTS - 1);
|
|
|
|
// Test the neighbors
|
|
m_pActivePanels[idx] =
|
|
IsVertexActive( i, j ) ||
|
|
IsVertexActive( i+1, j ) ||
|
|
IsVertexActive( i, j+1 ) ||
|
|
IsVertexActive( i+1, j+1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute vertex activity
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum
|
|
{
|
|
SHIELD_TESTS_PER_FRAME = 4
|
|
};
|
|
|
|
|
|
void CShieldEffect::ComputeVertexActivity()
|
|
{
|
|
int i;
|
|
for ( i = 0; i < SHIELD_TESTS_PER_FRAME; ++i )
|
|
{
|
|
// Visit points in random order...
|
|
int pt = m_PointList[m_TestPoint];
|
|
|
|
// Collision test...
|
|
// Check a line that goes farther out than our current point...
|
|
// This will let us check for resting contact
|
|
trace_t tr;
|
|
CTraceFilterWorldOnly traceFilter;
|
|
UTIL_TraceHull( m_Position, m_pControlPoint[pt],
|
|
m_PanelBoxMin, m_PanelBoxMax, MASK_SOLID_BRUSHONLY, &traceFilter, &tr );
|
|
bool isActive = (!tr.allsolid) && ( (tr.fraction - 1.0f) >= 0.0f );
|
|
|
|
m_pActiveVerts->SetActiveVertState( pt, isActive );
|
|
|
|
if (++m_TestPoint >= SHIELD_NUM_CONTROL_POINTS)
|
|
m_TestPoint = 0;
|
|
|
|
}
|
|
|
|
ComputePanelActivity();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// bounding box for collision
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SetShieldPanelSize( Vector& mins, Vector& maxs )
|
|
{
|
|
m_PanelBoxMin = mins;
|
|
m_PanelBoxMax = maxs;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// bounding box for collision
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::ComputeBounds( Vector& mins, Vector& maxs )
|
|
{
|
|
VectorCopy( m_pControlPoint[0], mins );
|
|
VectorCopy( m_pControlPoint[0], maxs );
|
|
|
|
for (int i = 1; i < SHIELD_NUM_CONTROL_POINTS; ++i)
|
|
{
|
|
VectorMin( mins, m_pControlPoint[i], mins );
|
|
VectorMax( maxs, m_pControlPoint[i], maxs );
|
|
}
|
|
|
|
// Bounds are in local coords
|
|
mins -= m_Position;
|
|
maxs -= m_Position;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::Precache( void )
|
|
{
|
|
m_RestLength = 200.0;
|
|
|
|
m_SpringConstant = 30.0f;
|
|
m_DampConstant = 4.0f;
|
|
m_ViscousDrag = 4.0f;
|
|
m_Mass = 1.0f;
|
|
|
|
m_AngularSpringConstant = 2.0f;
|
|
m_AngularViscousDrag = 4.0f;
|
|
|
|
SetThetaPhi( SHIELD_INITIAL_THETA, SHIELD_INITIAL_PHI );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute orientation matrix:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::ComputeOrientationMatrix()
|
|
{
|
|
// Generate the orientation matrix from theta and phi...
|
|
// X = forward direction, Y - left direction
|
|
Vector forward, left, up;
|
|
forward.x = cos(m_Theta) * sin(m_Phi);
|
|
forward.y = sin(m_Theta) * sin(m_Phi);
|
|
forward.z = cos(m_Phi);
|
|
|
|
left.x = -forward.y;
|
|
left.y = forward.x;
|
|
left.z = 0;
|
|
|
|
if ( VectorNormalize(left) == 0.0f )
|
|
left.Init( 0.0f, 1.0f, 0.0f );
|
|
|
|
CrossProduct( forward, left, up );
|
|
|
|
m_Orientation.SetBasisVectors( forward, left, up );
|
|
|
|
// Turn the current matrix into angles...
|
|
MatrixToAngles( m_Orientation, m_CurrentAngles );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::Spawn( const Vector& currentPosition, const QAngle& currentAngles )
|
|
{
|
|
Precache();
|
|
|
|
VectorCopy( currentPosition, m_Position );
|
|
m_Velocity.Init();
|
|
|
|
Vector forward;
|
|
AngleVectors( currentAngles, &forward, 0, 0 );
|
|
m_Phi = acos( forward.z );
|
|
m_Theta = atan2( forward.y, forward.x );
|
|
m_PhiVelocity = 0.0f;
|
|
m_ThetaVelocity = 0.0f;
|
|
ComputeOrientationMatrix();
|
|
VectorCopy( currentAngles, m_CurrentAngles );
|
|
VectorCopy( currentAngles, m_angDesiredAngles );
|
|
|
|
// No points are visible initially
|
|
memset( m_pActivePanels, 0, SHIELD_PANELS_COUNT );
|
|
|
|
m_TestPoint = 0;
|
|
|
|
// Choose random order to visit shield verts
|
|
int i;
|
|
for ( i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
|
|
{
|
|
m_PointList[i] = i;
|
|
}
|
|
|
|
for ( i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
|
|
{
|
|
int j = rand() % SHIELD_NUM_CONTROL_POINTS;
|
|
swap( m_PointList[i], m_PointList[j] );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the opacity....
|
|
//-----------------------------------------------------------------------------
|
|
float CShieldEffect::ComputeOpacity( const Vector& pt, const Vector& center ) const
|
|
{
|
|
float dist = pt.DistTo( center ) / m_RestLength;
|
|
if (dist > 1.0)
|
|
dist = 1.0f;
|
|
return 32 + (1.0 - dist) * 192;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes control points
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::ComputeControlPoints()
|
|
{
|
|
Vector forward, right, up;
|
|
AngleVectors(m_CurrentAngles, &forward, &right, &up);
|
|
|
|
for ( int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
|
|
{
|
|
// Compute the world space position...
|
|
VectorCopy( m_Position, m_pControlPoint[i] );
|
|
m_pControlPoint[i] += right * m_pFixedDirection[i].x;
|
|
m_pControlPoint[i] += up * m_pFixedDirection[i].z;
|
|
m_pControlPoint[i] += forward * m_pFixedDirection[i].y;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the frustum size
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::GetPanelSize( Vector& mins, Vector& maxs ) const
|
|
{
|
|
VectorCopy( m_PanelBoxMin, mins );
|
|
VectorCopy( m_PanelBoxMax, maxs );
|
|
}
|
|
|
|
|
|
void CShieldEffect::SetAngularSpringConstant( float flConstant )
|
|
{
|
|
m_AngularSpringConstant = flConstant;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set the shield theta & phi
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SetThetaPhi( float flTheta, float flPhi )
|
|
{
|
|
m_ShieldTheta = M_PI * flTheta / 180.0f;
|
|
m_ShieldPhi = M_PI * flPhi / 180.0f;
|
|
|
|
// Computes the rest positions
|
|
ComputeRestPositions();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The current position (computed by Simulate on the server)
|
|
//-----------------------------------------------------------------------------
|
|
const Vector& CShieldEffect::GetCurrentPosition()
|
|
{
|
|
return m_Position;
|
|
}
|
|
|
|
void CShieldEffect::SetCurrentPosition( const Vector& pos )
|
|
{
|
|
m_Position = pos;
|
|
}
|
|
|
|
void CShieldEffect::SetCurrentAngles( const QAngle& angles )
|
|
{
|
|
VectorCopy( angles, m_CurrentAngles );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Simulate the center of mass
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::SimulateTranslation( float dt )
|
|
{
|
|
// Hook's law for a damped spring:
|
|
// got two particles, a and b with positions xa and xb and velocities va and vb
|
|
// and l = xa - xb
|
|
// fa = -( ks * (|l| - r) + kd * (va - vb) dot (l) / |l|) * l/|l|
|
|
Vector dx, force;
|
|
|
|
// Case where we're connected to a control point
|
|
dx = m_Position - m_vecDesiredOrigin;
|
|
|
|
// rest condition
|
|
float length = dx.Length();
|
|
float speedSq = m_Velocity.LengthSqr();
|
|
if ((length < 1e-3) && (speedSq < 1e-6))
|
|
return;
|
|
|
|
// Compute force
|
|
if (length > 1e-3)
|
|
dx /= length;
|
|
else
|
|
dx.Init( 0, 0, 0 );
|
|
|
|
float springfactor = m_SpringConstant * length;
|
|
float dampfactor = m_DampConstant * DotProduct( m_Velocity, dx );
|
|
force = dx * -( springfactor + dampfactor );
|
|
|
|
assert( force.IsValid( ) );
|
|
Vector drag = m_Velocity * m_ViscousDrag;
|
|
force -= drag;
|
|
|
|
// Update position and velocity
|
|
m_Position += m_Velocity * dt;
|
|
m_Velocity += force * dt / m_Mass;
|
|
|
|
assert( m_Velocity.IsValid( ) );
|
|
|
|
// clamp for stability
|
|
if (speedSq > 1e6)
|
|
{
|
|
m_Velocity *= 1e3 / sqrt(speedSq);
|
|
}
|
|
}
|
|
|
|
|
|
void CShieldEffect::SimulateRotation( float dt, const Vector& forward )
|
|
{
|
|
// Here's a torsional spring for the angular component...
|
|
// A little tricky: We need to actually think about 2 torsional springs,
|
|
// one in thetha (x-y plane), and one in phi (z-plane)
|
|
|
|
float phi2 = acos( forward.z );
|
|
float dPhi = m_Phi - phi2;
|
|
|
|
float theta2 = atan2( forward.y, forward.x );
|
|
float dTheta = (m_Theta - theta2);
|
|
if (dTheta > M_PI)
|
|
dTheta -= 2 * M_PI;
|
|
else if (dTheta < -M_PI)
|
|
dTheta += 2 * M_PI;
|
|
|
|
// rest condition...
|
|
if ((fabs(dTheta) < 1e-3) && (fabs(m_ThetaVelocity) < 1e-6) &&
|
|
(fabs(dPhi) < 1e-3) && (fabs(m_PhiVelocity) < 1e-6))
|
|
{
|
|
return;
|
|
}
|
|
|
|
float springfactor = m_AngularSpringConstant * dTheta;
|
|
float torqueTheta = -springfactor; // + dampfactor);
|
|
torqueTheta -= m_ThetaVelocity * m_AngularViscousDrag;
|
|
|
|
springfactor = m_AngularSpringConstant * dPhi;
|
|
float torqueTPhi = -springfactor; // + dampfactor);
|
|
torqueTPhi -= m_PhiVelocity * m_AngularViscousDrag;
|
|
|
|
// Update position and velocity
|
|
m_Theta += m_ThetaVelocity * dt;
|
|
m_ThetaVelocity += torqueTheta * dt;
|
|
m_Phi += m_PhiVelocity * dt;
|
|
m_PhiVelocity += torqueTPhi * dt;
|
|
|
|
// clamp for stability
|
|
if (fabs(m_ThetaVelocity) > 1e2)
|
|
{
|
|
m_ThetaVelocity *= 1e2 / m_ThetaVelocity;
|
|
}
|
|
if (fabs(m_PhiVelocity) > 1e2)
|
|
{
|
|
m_PhiVelocity *= 1e2 / m_PhiVelocity;
|
|
}
|
|
|
|
ComputeOrientationMatrix();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update the shield position:
|
|
//-----------------------------------------------------------------------------
|
|
void CShieldEffect::Simulate( float dt )
|
|
{
|
|
// We're gonna basically assume a spring connected to the center control point
|
|
Vector forward;
|
|
AngleVectors(m_angDesiredAngles, &forward, 0, 0);
|
|
|
|
// We've got two springs: a spring connected to the origin
|
|
// and a torsional spring connected to the view direction.
|
|
|
|
// Stiff spring, subdivide time....
|
|
dt /= SHIELD_TIME_SUBVISIBIONS;
|
|
for (int i = 0; i < SHIELD_TIME_SUBVISIBIONS; ++i)
|
|
{
|
|
SimulateTranslation( dt );
|
|
SimulateRotation( dt, forward );
|
|
}
|
|
|
|
ComputeControlPoints();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines shield obstructions
|
|
//-----------------------------------------------------------------------------
|
|
static inline bool IsPointValid( bool* pActivePoints, int i, int j )
|
|
{
|
|
// Here's the control point we're checking
|
|
int idx = j * SHIELD_NUM_HORIZONTAL_POINTS + i;
|
|
|
|
return pActivePoints[idx];
|
|
}
|
|
|
|
|
|
|