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