//----------------------------------------------------------------------------- // 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 ); } } } }
// 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 CDAViewModel::PauseAnimation() { m_bPaused = true; m_flPauseCycle = GetCycle(); m_nPauseSequence = GetSequence(); m_flPauseAnimTime = GetAnimTime(); }
void C_ServerRagdoll::AccumulateLayers( IBoneSetup &boneSetup, Vector pos[], Quaternion q[], float currentTime ) { BaseClass::AccumulateLayers( boneSetup, pos, q, currentTime ); if ( m_nOverlaySequence >= 0 && m_nOverlaySequence < boneSetup.GetStudioHdr()->GetNumSeq() ) { boneSetup.AccumulatePose( pos, q, m_nOverlaySequence, GetCycle(), m_flBlendWeightCurrent, currentTime, m_pIk ); } }
void C_ServerRagdoll::AccumulateLayers( CStudioHdr *hdr, Vector pos[], Quaternion q[], float poseparam[], float currentTime, int boneMask ) { BaseClass::AccumulateLayers( hdr, pos, q, poseparam, currentTime, boneMask ); if ( m_nOverlaySequence >= 0 && m_nOverlaySequence < hdr->GetNumSeq() ) { AccumulatePose( hdr, m_pIk, pos, q, m_nOverlaySequence, GetCycle(), poseparam, boneMask, m_flBlendWeightCurrent, currentTime ); } }
//========================================================= // Retire - stop being active //========================================================= void CNPC_BaseTurret::Retire(void) { // make the turret level m_vecGoalAngles.x = 0; m_vecGoalAngles.y = m_flStartYaw; SetNextThink( gpGlobals->curtime + 0.1 ); StudioFrameAdvance( ); EyeOff( ); if (!MoveTurret()) { if (m_iSpin) { SpinDownCall(); } else if (GetSequence() != TURRET_ANIM_RETIRE) { SetTurretAnim(TURRET_ANIM_RETIRE); CPASAttenuationFilter filter( this ); EmitSound( filter, entindex(), "Turret.Undeploy" ); m_OnDeactivate.FireOutput(this, this); } //else if (IsSequenceFinished()) else if( GetSequence() == TURRET_ANIM_RETIRE && GetCycle() <= 0.0 ) { m_iOn = 0; m_flLastSight = 0; //SetTurretAnim(TURRET_ANIM_NONE); Vector curmins, curmaxs; curmins = WorldAlignMins(); curmaxs = WorldAlignMaxs(); curmaxs.z = m_iRetractHeight; curmins.z = -m_iRetractHeight; SetCollisionBounds( curmins, curmaxs ); if (m_iAutoStart) { SetThink(&CNPC_BaseTurret::AutoSearchThink); SetNextThink( gpGlobals->curtime + 0.1 ); } else { SetThink( &CBaseEntity::SUB_DoNothing ); } } } else { SetTurretAnim(TURRET_ANIM_SPIN); } }
void CBaseAnimatingOverlay::GetSkeleton( CStudioHdr *pStudioHdr, Vector pos[], QuaternionAligned q[], int boneMask ) { if(!pStudioHdr) { Assert(!"CBaseAnimating::GetSkeleton() without a model"); return; } if (!pStudioHdr->SequencesAvailable()) { return; } IBoneSetup boneSetup( pStudioHdr, boneMask, GetPoseParameterArray() ); boneSetup.InitPose( pos, q ); boneSetup.AccumulatePose( pos, q, GetSequence(), GetCycle(), 1.0, gpGlobals->curtime, m_pIk ); // sort the layers int layer[MAX_OVERLAYS]; int i; for (i = 0; i < m_AnimOverlay.Count(); i++) { layer[i] = MAX_OVERLAYS; } for (i = 0; i < m_AnimOverlay.Count(); i++) { CAnimationLayer &pLayer = m_AnimOverlay[i]; if( (pLayer.m_flWeight > 0) && pLayer.IsActive() && pLayer.m_nOrder >= 0 && pLayer.m_nOrder < m_AnimOverlay.Count()) { layer[pLayer.m_nOrder] = i; } } for (i = 0; i < m_AnimOverlay.Count(); i++) { if (layer[i] >= 0 && layer[i] < m_AnimOverlay.Count()) { CAnimationLayer &pLayer = m_AnimOverlay[layer[i]]; // UNDONE: Is it correct to use overlay weight for IK too? boneSetup.AccumulatePose( pos, q, pLayer.m_nSequence, pLayer.m_flCycle, pLayer.m_flWeight, gpGlobals->curtime, m_pIk ); } } if ( m_pIk ) { CIKContext auto_ik; auto_ik.Init( pStudioHdr, GetAbsAngles(), GetAbsOrigin(), gpGlobals->curtime, 0, boneMask ); boneSetup.CalcAutoplaySequences( pos, q, gpGlobals->curtime, &auto_ik ); } else { boneSetup.CalcAutoplaySequences( pos, q, gpGlobals->curtime, NULL ); } boneSetup.CalcBoneAdj( pos, q, GetEncodedControllerArray() ); }
bool C_CFPlayer::GetIntervalMovement( float flIntervalUsed, bool &bMoveSeqFinished, Vector &newPosition, QAngle &newAngles ) { CStudioHdr *pstudiohdr = GetModelPtr( ); if (! pstudiohdr || !pstudiohdr->SequencesAvailable()) return false; float flComputedCycleRate = GetSequenceCycleRate( pstudiohdr, GetSequence() ); float flNextCycle = GetCycle() + flIntervalUsed * flComputedCycleRate * m_flPlaybackRate; if ((!SequenceLoops()) && flNextCycle > 1.0) { flIntervalUsed = GetCycle() / (flComputedCycleRate * m_flPlaybackRate); flNextCycle = 1.0; bMoveSeqFinished = true; } else { bMoveSeqFinished = false; } Vector deltaPos; QAngle deltaAngles; float poseParameters[MAXSTUDIOPOSEPARAM]; GetPoseParameters(pstudiohdr, poseParameters); if (Studio_SeqMovement( pstudiohdr, GetSequence(), GetCycle(), flNextCycle, poseParameters, deltaPos, deltaAngles )) { VectorYawRotate( deltaPos, GetLocalAngles().y, deltaPos ); newPosition = GetLocalOrigin() + deltaPos; newAngles.Init(); newAngles.y = GetLocalAngles().y + deltaAngles.y; return true; } else { newPosition = GetLocalOrigin(); newAngles = GetLocalAngles(); return false; } }
void CNPC_ControllerZapBall::AnimateThink( void ) { SetNextThink( gpGlobals->curtime + 0.1 ); SetCycle( ((int)GetCycle() + 1) % 11 ); if (gpGlobals->curtime - m_flSpawnTime > 5 || GetAbsVelocity().Length() < 10) { SetTouch( NULL ); Kill(); } }
void C_SkeletonPlayer::UpdateClientSideAnimation() { int curSeq = GetSequence(); Vector vel = GetLocalVelocity(); //EstimateAbsVelocity( vel ); int goalSeq = curSeq; if ( vel.LengthSqr() > 4 ) { QAngle velAng; VectorAngles( vel, velAng ); goalSeq = SelectWeightedSequence( ACT_RUN ); float speed = vel.Length2D(); float yaw = AngleNormalize( -(GetRenderAngles().y - velAng.y) ); float seqspeed = 150.0f; float rate = speed / seqspeed; SetPoseParameter( LookupPoseParameter( "move_x" ), cos( DEG2RAD( yaw ) ) * rate ); SetPoseParameter( LookupPoseParameter( "move_y" ), -sin( DEG2RAD( yaw ) ) * rate ); SetPlaybackRate( clamp( rate * 0.6f, 1, 1.5f ) ); } else goalSeq = SelectWeightedSequence( ACT_IDLE ); if ( curSeq != goalSeq ) { ResetSequence( goalSeq ); } //m_flAnimTime = gpGlobals->curtime; //StudioFrameAdvance(); if ( GetCycle() >= 1.0f ) SetCycle( GetCycle() - 1.0f ); }
//----------------------------------------------------------------------------- // Purpose: // Output : //----------------------------------------------------------------------------- float CAnimating::GetInstantaneousVelocity( float flInterval ) { CStudioHdr *pstudiohdr = GetModelPtr( ); if (! pstudiohdr) return 0; // FIXME: someone needs to check for last frame, etc. float flNextCycle = GetCycle() + flInterval * GetSequenceCycleRate( GetSequence() ) * m_flPlaybackRate; Vector vecVelocity; Studio_SeqVelocity( pstudiohdr, GetSequence(), flNextCycle, GetPoseParameterArray(), vecVelocity ); vecVelocity *= m_flPlaybackRate; return vecVelocity.Length(); }
/* ***************************************************************************** **函 数 名:void MakeMessage(void) **功能描述:数据处理 **输 入: 无 **输 出: 无 ***************************************************************************** */ void MakeMessage(void) { Uint8 xdata period = 0; Uint8 xdata statusWell; if(dataReady) { statusWell = JudgeWellStatus(GatDat->LoadBuff,TOTAL); //判断负载(载荷) if(!statusWell) { period = GetCycle(GatDat->LoadBuff,TOTAL); if(period<70||period>120) { if(ParDat.TimeUnit <= 15 && SysDat.NumRegather<5) { ReGather(period); } else { statusWell = 4; if(SysDat.NumRegather >= 5) statusWell = 5; SysDat.NumRegather = 0; MakeOldFormatMsg(); } } else { SysDat.NumRegather = 0; // if(timeUnit!=XBYTE[PERIOD_ADDR]) // SaveToFlash(PERIOD_ADDR,0,&timeUnit,1); if(GetDisplacement(GatDat->AccInt,period)) { MakeNewFormatMsg(period); } else { statusWell = 5; MakeOldFormatMsg(); } } } else { MakeOldFormatMsg(); } DISK_Write(DISK_OURDATA_ADDR,Msg.Head,sizeof(MESSAGE_DATA)); dataReady = 0; } }
void CBaseAnimatingOverlay::GetSkeleton( CStudioHdr *pStudioHdr, Vector pos[], Quaternion q[], int boneMask ) { if(!pStudioHdr) { Assert(!"CBaseAnimating::GetSkeleton() without a model"); return; } if (!pStudioHdr->SequencesAvailable()) { return; } InitPose( pStudioHdr, pos, q ); AccumulatePose( pStudioHdr, m_pIk, pos, q, GetSequence(), GetCycle(), GetPoseParameterArray(), boneMask, 1.0, gpGlobals->curtime ); // layers { for (int i = 0; i < m_AnimOverlay.Count(); i++) { CAnimationLayer &pLayer = m_AnimOverlay[i]; if( (pLayer.m_flWeight > 0) && pLayer.IsActive() ) { // UNDONE: Is it correct to use overlay weight for IK too? AccumulatePose( pStudioHdr, m_pIk, pos, q, pLayer.m_nSequence, pLayer.m_flCycle, GetPoseParameterArray(), boneMask, pLayer.m_flWeight, gpGlobals->curtime ); } } } if ( m_pIk ) { CIKContext auto_ik; auto_ik.Init( pStudioHdr, GetAbsAngles(), GetAbsOrigin(), gpGlobals->curtime, 0, boneMask ); CalcAutoplaySequences( pStudioHdr, &auto_ik, pos, q, GetPoseParameterArray(), boneMask, gpGlobals->curtime ); } else { CalcAutoplaySequences( pStudioHdr, NULL, pos, q, GetPoseParameterArray(), boneMask, gpGlobals->curtime ); } CalcBoneAdj( pStudioHdr, pos, q, GetEncodedControllerArray(), boneMask ); }
//----------------------------------------------------------------------------- // Purpose: Avoid aiming/drawing beams while opening and closing // Input : - //----------------------------------------------------------------------------- void CNPC_RocketTurret::OpeningThink() { StudioFrameAdvance(); // Require these poses for this animation QAngle vecNeutralAngles ( 0, 90, 0 ); m_vecGoalAngles = m_vecCurrentAngles = vecNeutralAngles; SyncPoseToAimAngles(); // Start following player after we're fully opened float flCurProgress = GetCycle(); if ( flCurProgress >= 0.99f ) { LaserOn(); SetThink( &CNPC_RocketTurret::FollowThink ); } SetNextThink( gpGlobals->curtime + 0.1f ); }
void CAI_BlendedMotor::MoveStart() { if (m_nPrimarySequence == -1) { m_nPrimarySequence = GetSequence(); m_flStartCycle = GetCycle(); m_flCurrRate = 0.4; // Assert( !GetOuter()->HasMovement( m_nStartSequence ) ); m_nSecondarySequence = -1; m_iPrimaryLayer = AddLayeredSequence( m_nPrimarySequence, 0 ); SetLayerWeight( m_iPrimaryLayer, 0.0 ); SetLayerPlaybackRate( m_iPrimaryLayer, 0.0 ); SetLayerNoRestore( m_iPrimaryLayer, true ); SetLayerCycle( m_iPrimaryLayer, m_flStartCycle, m_flStartCycle ); m_flSecondaryWeight = 0.0; } else { // suspect that MoveStop() wasn't called when the previous route finished // Assert( 0 ); } if (m_nGoalSequence == ACT_INVALID) { ResetGoalSequence(); } m_vecPrevOrigin2 = GetAbsOrigin(); m_vecPrevOrigin1 = GetAbsOrigin(); m_bDeceleratingToGoal = false; }
//----------------------------------------------------------------------------- // Purpose: Avoid aiming/drawing beams while opening and closing // Input : - //----------------------------------------------------------------------------- void CNPC_RocketTurret::ClosingThink() { LaserOff(); // Require these poses for this animation QAngle vecNeutralAngles ( 0, 90, 0 ); m_vecGoalAngles = vecNeutralAngles; // Once we're within 10 degrees of the neutral pose, start close animation. if ( UpdateFacing() <= 10.0f ) { StudioFrameAdvance(); } SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE ); // Start following player after we're fully opened float flCurProgress = GetCycle(); if ( flCurProgress >= 0.99f ) { SetThink( NULL ); SetNextThink( TICK_NEVER_THINK ); } }
void DecodedMux::MergeShadeWithConstantsInChannel(CombineChannel channel) { bool usedIn[2]; uint32 cycleVal; int cycleNum; usedIn[0] = isUsedInCycle(MUX_SHADE,channel); usedIn[1] = isUsedInCycle(MUX_SHADE,channel+2); if( usedIn[0] && usedIn[1] && GetCycle(channel)!=GetCycle(channel+2) ) { //Shade is used in more than 1 cycles, and the ways it is used are different //in cycles, so we can not merge shade with const factors return; } if( usedIn[0] ) { cycleVal = GetCycle(channel);cycleNum=0;} else {cycleVal = GetCycle(channel+2);cycleNum=1;} //Update to here, Shade is either used only in 1 cycle, or the way it is used are totally //the same in different cycles if( cycleVal == 0x06000000 || isUsedInCycle(MUX_COMBINED,channel+cycleNum*2) ) // (0-0)*0+Shade { return; } //Now we can merge shade with consts for( int i=0; i<2; i++ ) { if( usedIn[i] ) { N64CombinerType &m = m_n64Combiners[channel+i*2]; if( isUsedInCycle(MUX_TEXEL0,i*2+channel) || isUsedInCycle(MUX_TEXEL1,i*2+channel) ) { if( (m.a&MUX_MASK) == MUX_TEXEL0 || (m.a&MUX_MASK) == MUX_TEXEL1 ) { // m.a is texel, can not merge constant with shade return; } else if( (m.b&MUX_MASK) == MUX_TEXEL0 || (m.b&MUX_MASK) == MUX_TEXEL1 ) { // m.b is texel, can not merge constant with shade return; } else if(( (m.c&MUX_MASK) == MUX_TEXEL0 || (m.c&MUX_MASK) == MUX_TEXEL1 ) ) { if( (m.d&MUX_MASK) != MUX_SHADE ) { cycleVal &= 0x0000FFFF; // A-B } else if( (m.a&MUX_MASK) == MUX_SHADE || (m.b&MUX_MASK) == MUX_SHADE ) { return; } } else if( (m.d&MUX_MASK) == MUX_TEXEL0 || (m.d&MUX_MASK) == MUX_TEXEL1 ) { cycleVal &= 0x00FFFFFF; // (A-B)*C } } else { m.a = m.b = m.c = MUX_0; m.d = MUX_SHADE; splitType[i*2+channel] = CM_FMT_TYPE_D; } } } if( channel == COLOR_CHANNEL ) m_dwShadeColorChannelFlag = cycleVal; else m_dwShadeAlphaChannelFlag = cycleVal; }
//----------------------------------------------------------------------------- // Purpose: Render the weapon. Draw the Viewmodel if the weapon's being carried // by this player, otherwise draw the worldmodel. //----------------------------------------------------------------------------- int C_BaseViewModel::DrawModel( int flags, const RenderableInstance_t &instance ) { if ( !m_bReadyToDraw ) return 0; if ( flags & STUDIO_RENDER ) { // Determine blending amount and tell engine float blend = (float)( instance.m_nAlpha / 255.0f ); // Totally gone if ( blend <= 0.0f ) return 0; // Tell engine render->SetBlend( blend ); float color[3]; GetColorModulation( color ); render->SetColorModulation( color ); } CMatRenderContextPtr pRenderContext( materials ); if ( ShouldFlipViewModel() ) pRenderContext->CullMode( MATERIAL_CULLMODE_CW ); int ret = 0; C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); C_BaseCombatWeapon *pWeapon = GetOwningWeapon(); // If the local player's overriding the viewmodel rendering, let him do it if ( pPlayer && pPlayer->IsOverridingViewmodel() ) { ret = pPlayer->DrawOverriddenViewmodel( this, flags, instance ); } else if ( pWeapon && pWeapon->IsOverridingViewmodel() ) { ret = pWeapon->DrawOverriddenViewmodel( this, flags, instance ); } else { ret = BaseClass::DrawModel( flags, instance ); } pRenderContext->CullMode( MATERIAL_CULLMODE_CCW ); // Now that we've rendered, reset the animation restart flag if ( flags & STUDIO_RENDER ) { if ( m_nOldAnimationParity != m_nAnimationParity ) { m_nOldAnimationParity = m_nAnimationParity; } // Tell the weapon itself that we've rendered, in case it wants to do something if ( pWeapon ) { pWeapon->ViewModelDrawn( this ); } if ( vm_debug.GetBool() ) { MDLCACHE_CRITICAL_SECTION(); int line = 16; CStudioHdr *hdr = GetModelPtr(); engine->Con_NPrintf( line++, "%s: %s(%d), cycle: %.2f cyclerate: %.2f playbackrate: %.2f\n", (hdr)?hdr->pszName():"(null)", GetSequenceName( GetSequence() ), GetSequence(), GetCycle(), GetSequenceCycleRate( hdr, GetSequence() ), GetPlaybackRate() ); if ( hdr ) { for( int i=0; i < hdr->GetNumPoseParameters(); ++i ) { const mstudioposeparamdesc_t &Pose = hdr->pPoseParameter( i ); engine->Con_NPrintf( line++, "pose_param %s: %f", Pose.pszName(), GetPoseParameter( i ) ); } } // Determine blending amount and tell engine float blend = (float)( instance.m_nAlpha / 255.0f ); float color[3]; GetColorModulation( color ); engine->Con_NPrintf( line++, "blend=%f, color=%f,%f,%f", blend, color[0], color[1], color[2] ); engine->Con_NPrintf( line++, "GetRenderMode()=%d", GetRenderMode() ); engine->Con_NPrintf( line++, "m_nRenderFX=0x%8.8X", GetRenderFX() ); color24 c = GetRenderColor(); unsigned char a = GetRenderAlpha(); engine->Con_NPrintf( line++, "rendercolor=%d,%d,%d,%d", c.r, c.g, c.b, a ); engine->Con_NPrintf( line++, "origin=%f, %f, %f", GetRenderOrigin().x, GetRenderOrigin().y, GetRenderOrigin().z ); engine->Con_NPrintf( line++, "angles=%f, %f, %f", GetRenderAngles()[0], GetRenderAngles()[1], GetRenderAngles()[2] ); if ( IsEffectActive( EF_NODRAW ) ) { engine->Con_NPrintf( line++, "EF_NODRAW" ); } } } return ret; }