// Corrects errors in the physics engine that cause projectiles to be far away from the objects they attached to
// issue #8122
bool CProjectileSA::CorrectPhysics ( void )
{
// make sure we have an interface for our bomb/satchel
CPhysicalSAInterface * pInterface = static_cast < CPhysicalSAInterface * > ( m_pInterface );
// make sure we have an interface
if ( pInterface != NULL )
{
// make sure we have an attached entity
if ( pInterface->m_pAttachedEntity )
{
// get our position
CVector vecStart = *GetPosition ( );
// get the entity we collided with
CEntitySAInterface * pCollidedWithInterface = pInterface->m_pAttachedEntity;
// get our end position by projecting forward a few velocities more
CVector vecEnd = vecStart - ( pInterface->m_vecCollisionImpactVelocity * 3 );
// process forward another 1 unit
if ( pGame->GetWorld ( )->CalculateImpactPosition ( vecStart, vecEnd ) )
{
// setup some variables
CVector vecRotation;
CVector vecTemp;
CVector vecCollisionOffset;
// get our current offset ( we want the rotation! )
GetAttachedOffsets ( vecTemp, vecRotation );
// create a matrix variable
CMatrix attachedToMatrix;
if ( pCollidedWithInterface->Placeable.matrix != NULL )
{
// get our matrix
pCollidedWithInterface->Placeable.matrix->ConvertToMatrix ( attachedToMatrix );
}
else
{
// get our matrix
attachedToMatrix = CMatrix ( pCollidedWithInterface->Placeable.m_transform.m_translate );
}
// transform our matrix into local (attached) space
CVector vecPosition = attachedToMatrix.Inverse ().TransformVector ( vecEnd );
// offset by enough that it isn't sticking inside anything
vecPosition += attachedToMatrix.Inverse () * ( pInterface->m_vecCollisionImpactVelocity * CVector ( 0.2f, 0.2f, 0.3f ) );
// set our attached offsets
SetAttachedOffsets ( vecPosition, vecRotation );
}
return true;
}
}
return false;
}
void CClientWeapon::DoPulse ( void )
{
/*if ( m_bHasTargetDirection )
{
CVector vecDirection = m_vecLastDirection;
CVector vecOffset = m_vecTargetDirection - vecDirection;
vecOffset /= CVector ( 10, 10, 10 );
vecDirection += vecOffset;
vecDirection.Normalize ();
m_vecLastDirection = vecDirection;
SetDirection ( vecDirection );
}*/
if ( m_targetType != TARGET_TYPE_FIXED )
{
CVector vecTargetPos;
if ( m_targetType == TARGET_TYPE_ENTITY )
{
if ( m_pTarget )
{
if ( m_pTarget->GetType ( ) == CCLIENTPED || m_pTarget->GetType ( ) == CCLIENTPLAYER )
{
CClientPed * pPed = (CClientPed *) (CClientEntity *)(m_pTarget);
pPed->GetBonePosition( m_targetBone, vecTargetPos );
}
else
{
m_pTarget->GetPosition( vecTargetPos );
}
}
else
{
ResetWeaponTarget ( );
}
}
else if ( m_targetType == TARGET_TYPE_VECTOR )
{
vecTargetPos = m_vecTarget;
}
if ( !m_pAttachedToEntity )
{
// Calculate direction to target
CVector vecPosition;
GetPosition ( vecPosition );
CVector vecDirection = vecTargetPos - vecPosition;
// Convert direction to rotation
CVector vecRotation = vecDirection.ToRotation ();
SetRotationRadians ( vecRotation );
}
else
{
// Transform target position into local (AttachedToEntity) space
CMatrix attachedToMatrix;
m_pAttachedToEntity->GetMatrix ( attachedToMatrix );
CVector vecLocalTargetPos = attachedToMatrix.Inverse ().TransformVector ( vecTargetPos );
// Calculate local direction
CVector vecDirection = vecLocalTargetPos - m_vecAttachedPosition;
// Convert local direction to local rotation
CVector vecRotation = vecDirection.ToRotation ();
// Apply local rotation
SetAttachedOffsets ( m_vecAttachedPosition, vecRotation );
}
}
if ( m_nAmmoInClip <= 0 )
{
if ( m_weaponConfig.bInstantReload == false )
{
if ( m_nAmmoTotal >= m_pWeaponStat->GetMaximumClipAmmo() && m_State != WEAPONSTATE_RELOADING )
{
m_PreviousState = m_State;
m_State = WEAPONSTATE_RELOADING;
m_reloadTimer.Reset();
}
else if ( m_State == WEAPONSTATE_RELOADING && m_reloadTimer.Get() >= m_pWeapon->GetWeaponReloadTime ( m_pWeaponStat ) )
{
m_State = m_PreviousState;
m_nAmmoInClip = m_pWeaponStat->GetMaximumClipAmmo();
m_nAmmoTotal -= m_pWeaponStat->GetMaximumClipAmmo();
}
else
return;
}
else
{
if ( m_nAmmoTotal >= m_pWeaponStat->GetMaximumClipAmmo() && m_State != WEAPONSTATE_RELOADING )
{
m_nAmmoInClip = m_pWeaponStat->GetMaximumClipAmmo();
m_nAmmoTotal -= m_pWeaponStat->GetMaximumClipAmmo();
}
}
}
if ( m_nAmmoInClip > 0 && ( IsLocalEntity ( ) || m_pOwner == g_pClientGame->GetLocalPlayer ( ) ) )
{
if ( m_State == WEAPONSTATE_FIRING && m_fireTimer.Get() >= m_iWeaponFireRate )
{
Fire ();
}
}
}
bool CFXRings::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
if(!m_pResHorTexture)
{
FXRuntimeError("Horizontal texture resource not found");
return false;
}
UtilGL::Texturing::CTexture2D* pHorTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResHorTexture)->GetTexture2D());
if(!pHorTexture)
{
FXRuntimeError("WARNING: Horizontal texture not available");
return false;
}
if(!m_pResVertTexture)
{
FXRuntimeError("Vertical texture resource not found");
return false;
}
UtilGL::Texturing::CTexture2D* pVertTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResVertTexture)->GetTexture2D());
if(!pVertTexture)
{
FXRuntimeError("WARNING: Texture not available");
return false;
}
// Vars
CVarFloat::CValueFloat valueAlpha;
CVarFloat::CValueFloat valueHorRingRadius;
CVarFloat::CValueFloat valueHorRingWidth;
CVarFloat::CValueFloat valueVertRingRadius;
CVarFloat::CValueFloat valueVertRingWidth;
CVarFloat::CValueFloat valueCylinderHeight;
CVarCombo::CValueCombo valueBlendMode;
CVarCombo::CValueCombo valueKeepPreviousCamera;
CVarFloat::CValueFloat valueOscillationAmplitude;
CVarFloat::CValueFloat valueOscillationFrequency;
CVarFloat::CValueFloat valueRotationSpeed;
CVarFloat::CValueFloat valueTileU;
CVarFloat::CValueFloat valueTileV;
EvaluateVar("Alpha", fEffectTime, &valueAlpha);
EvaluateVar("Horizontal Ring Radius", fEffectTime, &valueHorRingRadius);
EvaluateVar("Horizontal Ring Width", fEffectTime, &valueHorRingWidth);
EvaluateVar("Vertical Ring Radius", fEffectTime, &valueVertRingRadius);
EvaluateVar("Vertical Ring Width", fEffectTime, &valueVertRingWidth);
EvaluateVar("Cylinder Height", fEffectTime, &valueCylinderHeight);
EvaluateVar("Blend Mode", fEffectTime, &valueBlendMode);
EvaluateVar("Keep Previous Camera", fEffectTime, &valueKeepPreviousCamera);
EvaluateVar("Oscillation Amplitude", fEffectTime, &valueOscillationAmplitude);
EvaluateVar("Oscillation Frequency", fEffectTime, &valueOscillationFrequency);
EvaluateVar("Rotation Speed", fEffectTime, &valueRotationSpeed);
EvaluateVar("Tile U", fEffectTime, &valueTileU);
EvaluateVar("Tile V", fEffectTime, &valueTileV);
// States
int nSrcBlend = UtilGL::States::BLEND_SRCALPHA;
int nDstBlend = UtilGL::States::BLEND_INVSRCALPHA;
if(valueBlendMode.GetValue() == "Add")
{
nDstBlend = UtilGL::States::BLEND_ONE;
}
else if(valueBlendMode.GetValue() == "Color Mult")
{
nSrcBlend = UtilGL::States::BLEND_DSTCOLOR;
nDstBlend = UtilGL::States::BLEND_ZERO;
}
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::ENABLED);
UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BFCULLING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::SRCBLEND, nSrcBlend);
UtilGL::States::Set(UtilGL::States::DSTBLEND, nDstBlend);
// Transforming
CMatrix mtxCam;
CMatrix mtxAddLocal, mtxAddWorld;
CVector3 v3AddCamPos, v3AddCamAngles;
EvaluateAddTransformVars(this, fEffectTime, &mtxAddLocal, &mtxAddWorld, &v3AddCamPos, &v3AddCamAngles);
mtxCam.RotateX(v3AddCamAngles.X());
mtxCam.RotateY(v3AddCamAngles.Y());
mtxCam.RotateZ(v3AddCamAngles.Z());
mtxCam.SetPosition(v3AddCamPos);
if(valueKeepPreviousCamera.GetValue() == "No")
{
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_VIEW, mtxCam.Inverse());
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_PROJECTION);
glMatrixMode(GL_PROJECTION);
gluPerspective(60.0f, pDemo->GetAspect(), 1.0f, 1000.0f);
}
CMatrix mtxTexturing;
mtxTexturing.BuildScaling(valueTileU.GetValue(), valueTileV.GetValue(), 1.0f);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_WORLD, mtxAddWorld);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTexturing);
// Render
glEnableClientState(GL_VERTEX_ARRAY);
VECRINGS::iterator it;
for(it = m_vecRings.begin(); it != m_vecRings.end(); ++it)
{
float fDistToCenter = it->fDistToCenter * valueCylinderHeight.GetValue();
float fRotSpeed = it->fRotSpeed * valueRotationSpeed.GetValue();
float fOscillationAmplitude = it->fOscillationAmplitude * valueOscillationAmplitude.GetValue();
float fOscillationFrequency = it->fOscillationFrequency * valueOscillationFrequency.GetValue();
float fHorRingWidth = it->fWidth * valueHorRingWidth.GetValue();
float fHorRingRadius = it->fRadius * valueHorRingRadius.GetValue();
float fVertRingWidth = it->fWidth * valueVertRingWidth.GetValue();
float fVertRingRadius = it->fRadius * valueVertRingRadius.GetValue();
if(!IS_ZERO(fOscillationAmplitude))
{
fDistToCenter += sinf(((it->fOscillationOffset + fEffectTime) * PI) * fOscillationFrequency) * fOscillationAmplitude;
}
CMatrix localMatrix = mtxAddLocal;
localMatrix.PreRotateY(it->fRotAngleStart + (fRotSpeed * 360.0f * fEffectTime));
localMatrix.Translate (0.0f, fDistToCenter, 0.0f);
// Compute Mesh
for(int i = 0; i < m_nSubdivisions + 1; i++)
{
float fRadius = it->eType == SRing::HORIZONTAL ? fHorRingRadius : fVertRingRadius;
float fWidth = it->eType == SRing::HORIZONTAL ? fHorRingWidth : fVertRingWidth;
m_pv3MeshVertices[i] = m_pv3Circle[i] * fRadius;
m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i];
if(it->eType == SRing::HORIZONTAL)
{
if(IS_ZERO(fRadius)) fRadius = 0.001f;
float fWidthRatio = fWidth / fRadius;
m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i + m_nSubdivisions + 1] * (1.0f - fWidthRatio);
}
if(it->eType == SRing::VERTICAL)
{
m_pv3MeshVertices[i + m_nSubdivisions + 1].SetY(m_pv3MeshVertices[i + m_nSubdivisions + 1].Y() + fWidth);
}
localMatrix.Transform(&m_pv3MeshVertices[i]);
localMatrix.Transform(&m_pv3MeshVertices[i + m_nSubdivisions + 1]);
}
// Draw
CVector4 v4Color(1.0f, 1.0f, 1.0f, it->fAlpha * valueAlpha.GetValue());
UtilGL::States::SetColor(v4Color);
glVertexPointer(3, GL_FLOAT, 0, m_pv3MeshVertices);
UtilGL::Texturing::CTexture2D* pTexture = it->eType == SRing::HORIZONTAL ? pHorTexture : pVertTexture;
if(pTexture)
{
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, m_pv2MeshMapping);
pTexture->SetActive();
pTexture->SetTiling(true);
}
else
{
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glDrawRangeElements(GL_QUADS, 0, (m_nSubdivisions * 2) + 1, m_nSubdivisions * 4, GL_UNSIGNED_INT, m_pnMeshFaceList);
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// States
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::ENABLED);
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BFCULLING, UtilGL::States::ENABLED);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE);
return true;
}
