自学教程：C++ GetModelPtr函数代码示例

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

//-----------------------------------------------------------------------------// 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 framesvoid 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 modelvoid 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);	}}

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