//----------------------------------------------------------------------------- // Purpose: clear out any face/eye values stored in the material system //----------------------------------------------------------------------------- void C_HL2MPRagdoll::SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights ) { BaseClass::SetupWeights( pBoneToWorld, nFlexWeightCount, pFlexWeights, pFlexDelayedWeights ); static float destweight[128]; static bool bIsInited = false; CStudioHdr *hdr = GetModelPtr(); if ( !hdr ) return; int nFlexDescCount = hdr->numflexdesc(); if ( nFlexDescCount ) { Assert( !pFlexDelayedWeights ); memset( pFlexWeights, 0, nFlexWeightCount * sizeof(float) ); } if ( m_iEyeAttachment > 0 ) { matrix3x4_t attToWorld; if (GetAttachment( m_iEyeAttachment, attToWorld )) { Vector local, tmp; local.Init( 1000.0f, 0.0f, 0.0f ); VectorTransform( local, attToWorld, tmp ); modelrender->SetViewTarget( GetModelPtr(), GetBody(), tmp ); } } }
//========================================================= // SetEyePosition // // queries the units's model for $eyeposition and copies // that vector to the npc's m_vDefaultEyeOffset and m_vecViewOffset // //========================================================= void CUnitBase::SetDefaultEyeOffset( Vector *pCustomOfset ) { if( pCustomOfset ) { m_vDefaultEyeOffset = *pCustomOfset; } else if ( GetModelPtr() ) { GetEyePosition( GetModelPtr(), m_vDefaultEyeOffset ); if ( m_vDefaultEyeOffset == vec3_origin ) { //if ( Classify() != CLASS_NONE ) { DevMsg( "WARNING: %s(%s) has no eye offset in .qc!\n", GetClassname(), STRING(GetModelName()) ); } VectorAdd( WorldAlignMins(), WorldAlignMaxs(), m_vDefaultEyeOffset ); m_vDefaultEyeOffset *= 0.75; } } else m_vDefaultEyeOffset = vec3_origin; // Clamp to values in dt m_vDefaultEyeOffset.x = Max<float>( Min<float>( m_vDefaultEyeOffset.x, 256.0f ), -256.0 ); m_vDefaultEyeOffset.y = Max<float>( Min<float>( m_vDefaultEyeOffset.y, 256.0f ), -256.0 ); m_vDefaultEyeOffset.z = Max<float>( Min<float>( m_vDefaultEyeOffset.z, 1024.0f ), -1.0f ); #ifndef CLIENT_DLL SetViewOffset( m_vDefaultEyeOffset ); #endif // CLIENT_DLL }
//----------------------------------------------------------------------------- // Purpose: find the anim events that may have started sounds, and stop them. //----------------------------------------------------------------------------- void C_BaseObject::StopAnimGeneratedSounds( void ) { MDLCACHE_CRITICAL_SECTION(); CStudioHdr *pStudioHdr = GetModelPtr(); if ( !pStudioHdr ) return; mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( GetSequence() ); float flCurrentCycle = GetCycle(); mstudioevent_t *pevent = GetEventIndexForSequence( seqdesc ); for (int i = 0; i < (int)seqdesc.numevents; i++) { if ( pevent[i].cycle < flCurrentCycle ) { if ( pevent[i].event == CL_EVENT_SOUND || pevent[i].event == AE_CL_PLAYSOUND ) { StopSound( entindex(), pevent[i].options ); } } } }
//----------------------------------------------------------------------------- // Purpose: Do not test against hit boxes, but against the bounding box. // Much cheaper and we don't really need hitboxes for hl2wars. //----------------------------------------------------------------------------- bool CUnitBase::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ) { #if 1 if( unit_cheaphitboxtest.GetBool() == false ) return BaseClass::TestHitboxes( ray, fContentsMask, tr ); CStudioHdr *pStudioHdr = GetModelPtr( ); if (!pStudioHdr) return false; Ray_t ray2 = ray; Vector start = GetAbsOrigin() - ray.m_Start; ray2.Init(start, start+ray.m_Delta); IntersectRayWithBox(ray2, WorldAlignMins(), WorldAlignMaxs(), 0.0f, &tr); if ( tr.DidHit() ) { tr.surface.name = "**studio**"; tr.surface.flags = SURF_HITBOX; tr.surface.surfaceProps = VPhysicsGetObject() ? VPhysicsGetObject()->GetMaterialIndex() : 0; //NDebugOverlay::SweptBox(ray.m_Start, tr.endpos, -Vector(32, 32, 32), Vector(32, 32, 32), GetAbsAngles(), 255, 0, 0, 255, 1.0f); return true; } return false; #else return BaseClass::TestHitboxes( ray, fContentsMask, tr ); #endif // 0 }
// asw - test always advancing the frames void C_ASW_Alien::ASWUpdateClientSideAnimation() { if ( GetSequence() != -1 ) { // latch old values //OnLatchInterpolatedVariables( LATCH_ANIMATION_VAR ); // move frame forward //FrameAdvance( 0.0f ); // 0 means to use the time we last advanced instead of a constant CStudioHdr *hdr = GetModelPtr(); float cyclerate = hdr ? GetSequenceCycleRate( hdr, GetSequence() ) : 1.0f; float addcycle = gpGlobals->frametime * cyclerate * m_flPlaybackRate; float flNewCycle = GetCycle() + addcycle; m_flAnimTime = gpGlobals->curtime; if ( (flNewCycle < 0.0f) || (flNewCycle >= 1.0f) ) { if (flNewCycle >= 1.0f) // asw ReachedEndOfSequence(); // asw if ( IsSequenceLooping( hdr, GetSequence() ) ) { flNewCycle -= (int)(flNewCycle); } else { flNewCycle = (flNewCycle < 0.0f) ? 0.0f : 1.0f; } } SetCycle( flNewCycle ); } }
void C_BaseAnimatingOverlay::GetRenderBounds( Vector& theMins, Vector& theMaxs ) { BaseClass::GetRenderBounds( theMins, theMaxs ); if ( !IsRagdoll() ) { CStudioHdr *pStudioHdr = GetModelPtr(); if ( !pStudioHdr || !pStudioHdr->SequencesAvailable() ) return; int nSequences = pStudioHdr->GetNumSeq(); int i; for (i = 0; i < m_AnimOverlay.Count(); i++) { if (m_AnimOverlay[i].m_flWeight > 0.0) { if ( m_AnimOverlay[i].m_nSequence >= nSequences ) { continue; } mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( m_AnimOverlay[i].m_nSequence ); VectorMin( seqdesc.bbmin, theMins, theMins ); VectorMax( seqdesc.bbmax, theMaxs, theMaxs ); } } } }
//----------------------------------------------------------------------------- void C_CHostage::UpdateClientSideAnimation() { if (IsDormant()) { return; } m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] ); // initialize pose parameters char *setToZero[] = { "spine_yaw", "head_roll" }; CStudioHdr *pStudioHdr = GetModelPtr(); for ( int i=0; i < ARRAYSIZE( setToZero ); i++ ) { int index = LookupPoseParameter( pStudioHdr, setToZero[i] ); if ( index >= 0 ) SetPoseParameter( pStudioHdr, index, 0 ); } // orient head and eyes LookAround(); UpdateLookAt( pStudioHdr ); BaseClass::UpdateClientSideAnimation(); }
// If the local player is visible (thirdperson mode, tf2 taunts, etc., then make sure that we are using the // w_ (world) model not the v_ (view) model or else the model can flicker, etc. // Otherwise, if we're not the local player, always use the world model void C_BaseCombatWeapon::EnsureCorrectRenderingModel() { C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer(); if ( localplayer && localplayer == GetOwner() && !localplayer->ShouldDrawLocalPlayer() ) { return; } MDLCACHE_CRITICAL_SECTION(); // BRJ 10/14/02 // FIXME: Remove when Yahn's client-side prediction is done // It's a hacky workaround for the model indices fighting // (GetRenderBounds uses the model index, which is for the view model) SetModelIndex( GetWorldModelIndex() ); // Validate our current sequence just in case ( in theory the view and weapon models should have the same sequences for sequences that overlap at least ) CStudioHdr *pStudioHdr = GetModelPtr(); if ( pStudioHdr && GetSequence() >= pStudioHdr->GetNumSeq() ) { SetSequence( 0 ); } }
//----------------------------------------------------------------------------- // Purpose: zero's out all non-restore safe fields // Output : //----------------------------------------------------------------------------- void CBaseAnimatingOverlay::OnRestore( ) { int i; // force order of unused layers to current MAX_OVERLAYS // and Tracker 48843 (Alyx skating after restore) restore the owner entity ptr (otherwise the network layer won't get NetworkStateChanged signals until the layer is re-Init()'ed for (i = 0; i < m_AnimOverlay.Count(); i++) { m_AnimOverlay[i].m_pOwnerEntity = this; if ( !m_AnimOverlay[i].IsActive()) { m_AnimOverlay[i].m_nOrder.Set( MAX_OVERLAYS ); } } // get rid of all layers that shouldn't be restored for (i = 0; i < m_AnimOverlay.Count(); i++) { if ( ( m_AnimOverlay[i].IsActive() && (m_AnimOverlay[i].m_fFlags & ANIM_LAYER_DONTRESTORE) ) || ( GetModelPtr() && !IsValidSequence(m_AnimOverlay[i].m_nSequence) ) ) { FastRemoveLayer( i ); } } BaseClass::OnRestore(); }
void CASW_Parasite::InfestThink( void ) { SetNextThink( gpGlobals->curtime + 0.1f ); if ( !GetModelPtr() ) return; StudioFrameAdvance(); DispatchAnimEvents( this ); CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>(GetParent()); CASW_Colonist *pColonist = dynamic_cast<CASW_Colonist*>(GetParent()); if (!pColonist) { if ( !pMarine || !pMarine->IsInfested() || pMarine->IsEffectActive( EF_NODRAW ) ) { FinishedInfesting(); } } if (!pMarine) { if ( !pColonist || !pColonist->IsInfested() || pColonist->IsEffectActive( EF_NODRAW ) ) { FinishedInfesting(); } } }
//----------------------------------------------------------------------------- // Purpose: // Output : int //----------------------------------------------------------------------------- int CBaseAnimatingOverlay::AddLayeredSequence( int sequence, int iPriority ) { int i = AllocateLayer( iPriority ); // No room? if ( IsValidLayer( i ) ) { m_AnimOverlay[i].m_flCycle = 0; m_AnimOverlay[i].m_flPrevCycle = 0; m_AnimOverlay[i].m_flPlaybackRate = 1.0; m_AnimOverlay[i].m_nActivity = ACT_INVALID; m_AnimOverlay[i].m_nSequence = sequence; m_AnimOverlay[i].m_flWeight = 1.0f; m_AnimOverlay[i].m_flBlendIn = 0.0f; m_AnimOverlay[i].m_flBlendOut = 0.0f; m_AnimOverlay[i].m_bSequenceFinished = false; m_AnimOverlay[i].m_flLastEventCheck = 0; m_AnimOverlay[i].m_bLooping = ((GetSequenceFlags( GetModelPtr(), sequence ) & STUDIO_LOOPING) != 0); if (ai_sequence_debug.GetBool() == true && m_debugOverlays & OVERLAY_NPC_SELECTED_BIT) { Msg("%5.3f : adding %d (%d): %s : %5.3f (%.3f)\n", gpGlobals->curtime, i, m_AnimOverlay[ i ].m_nOrder.Get(), GetSequenceName( m_AnimOverlay[ i ].m_nSequence ), m_AnimOverlay[ i ].m_flCycle.Get(), m_AnimOverlay[ i ].m_flWeight.Get() ); } } return i; }
void CEnvParticleScript::PrecacheAnimationEventMaterials() { CStudioHdr *hdr = GetModelPtr(); if ( hdr ) { int numseq = hdr->GetNumSeq(); for ( int i = 0; i < numseq; ++i ) { mstudioseqdesc_t& seqdesc = hdr->pSeqdesc( i ); int ecount = seqdesc.numevents; for ( int j = 0 ; j < ecount; ++j ) { const mstudioevent_t* event = (const mstudioevent_for_client_server_t*)seqdesc.pEvent( j ); if ( event->Event() == CL_EVENT_SPRITEGROUP_CREATE ) { char pAttachmentName[256]; char pSpriteName[256]; int nArgs = sscanf( event->pszOptions(), "%255s %255s", pAttachmentName, pSpriteName ); if ( nArgs == 2 ) { PrecacheMaterial( pSpriteName ); } } } } } }
void CRagdollProp::SetupBones( matrix3x4_t *pBoneToWorld, int boneMask ) { studiohdr_t *pStudioHdr = GetModelPtr( ); bool sim[MAXSTUDIOBONES]; memset( sim, 0, pStudioHdr->numbones ); int i; for ( i = 0; i < m_ragdoll.listCount; i++ ) { if ( RagdollGetBoneMatrix( m_ragdoll, pBoneToWorld, i ) ) { sim[m_ragdoll.boneIndex[i]] = true; } } mstudiobone_t *pbones = pStudioHdr->pBone( 0 ); for ( i = 0; i < pStudioHdr->numbones; i++ ) { if ( sim[i] ) continue; MatrixCopy( pBoneToWorld[pbones[i].parent], pBoneToWorld[ i ] ); } }
void CHL2MP_Player::PickDefaultSpawnTeam( void ) { if (GetModelPtr() == NULL) { ChangeTeam(TEAM_UNASSIGNED); } }
void CRagdollPropAttached::InitRagdollAttached( IPhysicsObject *pAttached, const Vector &forceVector, int forceBone, matrix3x4_t *pPrevBones, matrix3x4_t *pBoneToWorld, float dt, int collisionGroup, CBaseAnimating *pFollow, int boneIndexRoot, const Vector &boneLocalOrigin, int parentBoneAttach, const Vector &worldAttachOrigin ) { int ragdollAttachedIndex = 0; if ( parentBoneAttach > 0 ) { studiohdr_t *pStudioHdr = GetModelPtr(); mstudiobone_t *pBone = pStudioHdr->pBone( parentBoneAttach ); ragdollAttachedIndex = pBone->physicsbone; } InitRagdoll( forceVector, forceBone, vec3_origin, pPrevBones, pBoneToWorld, dt, collisionGroup, false ); IPhysicsObject *pRefObject = m_ragdoll.list[ragdollAttachedIndex].pObject; Vector attachmentPointRagdollSpace; pRefObject->WorldToLocal( attachmentPointRagdollSpace, worldAttachOrigin ); constraint_ragdollparams_t constraint; constraint.Defaults(); matrix3x4_t tmp, worldToAttached, worldToReference, constraintToWorld; Vector offsetWS; pAttached->LocalToWorld( offsetWS, boneLocalOrigin ); AngleMatrix( QAngle(0, pFollow->GetAbsAngles().y, 0 ), offsetWS, constraintToWorld ); constraint.axes[0].SetAxisFriction( -2, 2, 20 ); constraint.axes[1].SetAxisFriction( 0, 0, 0 ); constraint.axes[2].SetAxisFriction( -15, 15, 20 ); pAttached->GetPositionMatrix( tmp ); MatrixInvert( tmp, worldToAttached ); pRefObject->GetPositionMatrix( tmp ); MatrixInvert( tmp, worldToReference ); ConcatTransforms( worldToReference, constraintToWorld, constraint.constraintToReference ); ConcatTransforms( worldToAttached, constraintToWorld, constraint.constraintToAttached ); // for now, just slam this to be the passed in value MatrixSetColumn( attachmentPointRagdollSpace, 3, constraint.constraintToReference ); DisableCollisions( pAttached ); m_pAttachConstraint = physenv->CreateRagdollConstraint( pRefObject, pAttached, m_ragdoll.pGroup, constraint ); FollowEntity( pFollow ); SetOwnerEntity( pFollow ); RagdollActivate( m_ragdoll ); Relink(); m_boneIndexAttached = boneIndexRoot; m_ragdollAttachedObjectIndex = ragdollAttachedIndex; m_attachmentPointBoneSpace = boneLocalOrigin; Vector vTemp; MatrixGetColumn( constraint.constraintToReference, 3, vTemp ); m_attachmentPointRagdollSpace = vTemp; }
//----------------------------------------------------------------------------- // Should this object cast render-to-texture shadows? //----------------------------------------------------------------------------- ShadowType_t C_PropVehicleDriveable::ShadowCastType() { CStudioHdr *pStudioHdr = GetModelPtr(); if ( !pStudioHdr ) return SHADOWS_NONE; if ( IsEffectActive(EF_NODRAW | EF_NOSHADOW) ) return SHADOWS_NONE; // Always use render-to-texture. We'll always the dirty bits in our think function return SHADOWS_RENDER_TO_TEXTURE; }
//----------------------------------------------------------------------------- // Purpose: // Input : act - //----------------------------------------------------------------------------- void CBaseObject::SetActivity( Activity act ) { // Hrm, it's not actually a studio model... if ( !GetModelPtr() ) return; int sequence = SelectWeightedSequence( act ); if ( sequence != ACTIVITY_NOT_AVAILABLE ) { m_Activity = act; SetObjectSequence( sequence ); } }
void CBaseCombatWeapon::Operator_FrameUpdate( CBaseCombatCharacter *pOperator ) { StudioFrameAdvance( ); // animate if ( IsSequenceFinished() ) { if ( SequenceLoops() ) { // animation does loop, which means we're playing subtle idle. Might need to fidget. int iSequence = SelectWeightedSequence( GetActivity() ); if ( iSequence != ACTIVITY_NOT_AVAILABLE ) { ResetSequence( iSequence ); // Set to new anim (if it's there) } } #if 0 else { // animation that just ended doesn't loop! That means we just finished a fidget // and should return to our heaviest weighted idle (the subtle one) SelectHeaviestSequence( GetActivity() ); } #endif } CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); if ( pOwner == NULL ) return; CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex ); if ( vm == NULL ) return; // HACK: Player weapon and view model often use the same mdl, which results // in duplicate anim events. For now, let the view model handle the events // if they're the same, which is the preferred behavior in general. CStudioHdr *w_hdr = GetModelPtr(); CStudioHdr *v_hdr = vm->GetModelPtr(); if ( w_hdr->GetRenderHdr() != v_hdr->GetRenderHdr() ) { // Animation events are passed back to the weapon's owner/operator DispatchAnimEvents( pOperator ); } // Update and dispatch the viewmodel events if ( vm != NULL ) { vm->StudioFrameAdvance(); vm->DispatchAnimEvents( this ); } }
//----------------------------------------------------------------------------- bool C_LowViolenceHostageDeathModel::SetupLowViolenceModel( C_CHostage *pHostage ) { const model_t *model = pHostage->GetModel(); const char *pModelName = modelinfo->GetModelName( model ); if ( InitializeAsClientEntity( pModelName, RENDER_GROUP_OPAQUE_ENTITY ) == false ) { Release(); return false; } // Play the low-violence death anim if ( LookupSequence( "death1" ) == -1 ) { Release(); return false; } m_flFadeOutStart = gpGlobals->curtime + 5.0f; SetNextClientThink( CLIENT_THINK_ALWAYS ); SetSequence( LookupSequence( "death1" ) ); ForceClientSideAnimationOn(); if ( pHostage && !pHostage->IsDormant() ) { SetNetworkOrigin( pHostage->GetAbsOrigin() ); SetAbsOrigin( pHostage->GetAbsOrigin() ); SetAbsVelocity( pHostage->GetAbsVelocity() ); // move my current model instance to the ragdoll's so decals are preserved. pHostage->SnatchModelInstance( this ); SetAbsAngles( pHostage->GetRenderAngles() ); SetNetworkAngles( pHostage->GetRenderAngles() ); CStudioHdr *pStudioHdr = GetModelPtr(); // update pose parameters float poseParameter[MAXSTUDIOPOSEPARAM]; GetPoseParameters( pStudioHdr, poseParameter ); for ( int i=0; i<NumInterestingPoseParameters; ++i ) { int poseParameterIndex = LookupPoseParameter( pStudioHdr, InterestingPoseParameters[i] ); SetPoseParameter( pStudioHdr, poseParameterIndex, poseParameter[poseParameterIndex] ); } } Interp_Reset( GetVarMapping() ); return true; }
void CHL2MP_Player::PickDefaultSpawnTeam( void ) { if ( GetTeamNumber() == 0 ) { if ( HL2MPRules()->IsTeamplay() == false ) { if ( GetModelPtr() == NULL ) { const char *szModelName = NULL; szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" ); if ( ValidatePlayerModel( szModelName ) == false ) { char szReturnString[512]; //DHL - Skillet - Changed from combine soldier Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel DHL_DEFAULTMODEL\n" ); engine->ClientCommand ( edict(), szReturnString ); } ChangeTeam( TEAM_UNASSIGNED ); } } else { CTeam *pCombine = g_Teams[TEAM_COMBINE]; CTeam *pRebels = g_Teams[TEAM_REBELS]; if ( pCombine == NULL || pRebels == NULL ) { ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) ); } else { if ( pCombine->GetNumPlayers() > pRebels->GetNumPlayers() ) { ChangeTeam( TEAM_REBELS ); } else if ( pCombine->GetNumPlayers() < pRebels->GetNumPlayers() ) { ChangeTeam( TEAM_COMBINE ); } else { ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) ); } } } } }
unsigned int C_DynamicProp::ComputeClientSideAnimationFlags() { if ( GetSequence() != -1 ) { CStudioHdr *pStudioHdr = GetModelPtr(); if ( GetSequenceCycleRate(pStudioHdr, GetSequence()) != 0.0f ) { return BaseClass::ComputeClientSideAnimationFlags(); } } // no sequence or no cycle rate, don't do any per-frame calcs return 0; }
void CDAViewModel::UnpauseAnimation(float flRewind) { m_bPaused = false; SetSequence(m_nPauseSequence); SetCycle(m_flPauseCycle - flRewind * BaseClass::GetSequenceCycleRate(GetModelPtr(), m_nPauseSequence)); SetAnimTime(m_flPauseAnimTime - flRewind); #ifdef CLIENT_DLL // Remember this so that when the message comes in from the server // we can set it back to this. m_flResumeCycle = m_flPauseCycle; m_flResumeAnimTime = m_flPauseAnimTime; #endif }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseObject::OnGoInactive( void ) { #ifndef CLIENT_DLL if ( GetModelPtr() ) { // Switch to the off state int index = FindBodygroupByName( "powertoggle" ); if ( index >= 0 ) { SetBodygroup( index, 0 ); } } #endif }
//----------------------------------------------------------------------------- // Purpose: Clear all pose parameters //----------------------------------------------------------------------------- void C_HL2MP_Player::InitializePoseParams( void ) { m_headYawPoseParam = LookupPoseParameter( "head_yaw" ); GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax ); m_headPitchPoseParam = LookupPoseParameter( "head_pitch" ); GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax ); CStudioHdr *hdr = GetModelPtr(); for ( int i = 0; i < hdr->GetNumPoseParameters() ; i++ ) { SetPoseParameter( hdr, i, 0.0 ); } }
void CASW_Dummy_Vehicle::SetNormalizedPoseParameter(int iParam, float fValue) { CStudioHdr *pStudioHdr = GetModelPtr(); if (!pStudioHdr) return; if (iParam < 0 || iParam >= pStudioHdr->GetNumPoseParameters()) return; const mstudioposeparamdesc_t &Pose = pStudioHdr->pPoseParameter( iParam ); float diff = Pose.end - Pose.start; SetPoseParameter(iParam, Pose.start + diff * fValue); }
KeyValues *C_CFPlayer::GetSequenceKeyValues( int iSequence ) { const char *szText = Studio_GetKeyValueText( GetModelPtr(), iSequence ); if (szText) { KeyValues *seqKeyValues = new KeyValues(""); if ( seqKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), szText ) ) { return seqKeyValues; } seqKeyValues->deleteThis(); } return NULL; }
void CHL2MP_Player::PickDefaultSpawnTeam( void ) { if ( GetTeamNumber() == 0 ) { if ( HL2MPRules()->IsTeamplay() ) { if(g_Teams[TEAM_GREEN]->GetNumPlayers() < g_Teams[TEAM_PINK]->GetNumPlayers()) ChangeTeam(TEAM_GREEN); else ChangeTeam(TEAM_PINK); } if ( GetModelPtr() == NULL ) ChangeTeam( TEAM_UNASSIGNED ); } }
bool SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime ) { if ( GetMoveParent() ) { // HACKHACK: Force the attached bone to be set up int index = m_boneIndex[m_ragdollAttachedObjectIndex]; int boneFlags = GetModelPtr()->boneFlags(index); if ( !(boneFlags & boneMask) ) { // BUGBUG: The attached bone is required and this call is going to skip it, so force it // HACKHACK: Assume the highest bit numbered bone flag is the minimum bone set boneMask |= GetHighestBit( boneFlags ); } } return BaseClass::SetupBones( pBoneToWorldOut, nMaxBones, boneMask, currentTime ); }
bool CRagdollProp::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace ) { #if 0 // PERFORMANCE: Use hitboxes for rays instead of vcollides if this is a performance problem if ( ray.m_IsRay ) { return BaseClass::TestCollision( ray, mask, trace ); } #endif CStudioHdr *pStudioHdr = GetModelPtr( ); if (!pStudioHdr) return false; // Just iterate all of the elements and trace the box against each one. // NOTE: This is pretty expensive for small/dense characters trace_t tr; for ( int i = 0; i < m_ragdoll.listCount; i++ ) { Vector position; QAngle angles; if( m_ragdoll.list[i].pObject ) { m_ragdoll.list[i].pObject->GetPosition( &position, &angles ); physcollision->TraceBox( ray, m_ragdoll.list[i].pObject->GetCollide(), position, angles, &tr ); if ( tr.fraction < trace.fraction ) { tr.physicsbone = i; tr.surface.surfaceProps = m_ragdoll.list[i].pObject->GetMaterialIndex(); trace = tr; } } else { DevWarning("Bogus object in Ragdoll Prop's ragdoll list!\n"); } } if ( trace.fraction >= 1 ) { return false; } return true; }
bool C_BaseViewModel::Interpolate( float currentTime ) { CStudioHdr *pStudioHdr = GetModelPtr(); // Make sure we reset our animation information if we've switch sequences UpdateAnimationParity(); bool bret = BaseClass::Interpolate( currentTime ); // Hack to extrapolate cycle counter for view model float elapsed_time = currentTime - m_flAnimTime; C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); // Predicted viewmodels have fixed up interval if ( GetPredictable() || IsClientCreated() ) { Assert( pPlayer ); float curtime = pPlayer ? pPlayer->GetFinalPredictedTime() : gpGlobals->curtime; elapsed_time = curtime - m_flAnimTime; // Adjust for interpolated partial frame if ( !engine->IsPaused() ) { elapsed_time += ( gpGlobals->interpolation_amount * TICK_INTERVAL ); } } // Prediction errors? if ( elapsed_time < 0 ) { elapsed_time = 0; } float dt = elapsed_time * GetSequenceCycleRate( pStudioHdr, GetSequence() ) * GetPlaybackRate(); if ( dt >= 1.0f ) { if ( !IsSequenceLooping( GetSequence() ) ) { dt = 0.999f; } else { dt = fmod( dt, 1.0f ); } } SetCycle( dt ); return bret; }