// 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; }