CWreckage* CDigitanksEntity::CreateWreckage() { // Figure out what to do about structures later. if (dynamic_cast<CDigitank*>(this) == NULL) return NULL; CWreckage* pWreckage = GameServer()->Create<CWreckage>("CWreckage"); pWreckage->SetGlobalOrigin(GetRenderOrigin()); pWreckage->SetGlobalAngles(GetRenderAngles()); pWreckage->SetModel(GetModelID()); pWreckage->SetGlobalGravity(Vector(0, 0, DigitanksGame()->GetGravity())); pWreckage->SetOldPlayer(GetDigitanksPlayer()); pWreckage->CalculateVisibility(); CDigitank* pTank = dynamic_cast<CDigitank*>(this); if (pTank) pWreckage->SetTurretModel(pTank->GetTurretModel()); bool bColorSwap = GetPlayerOwner() && (dynamic_cast<CDigitank*>(this)); if (bColorSwap) pWreckage->SetColorSwap(GetPlayerOwner()->GetColor()); return pWreckage; }
void CDeferredLight::ApplyDataToLight() { Assert( m_pLight != NULL ); ABS_QUERY_GUARD( true ); m_pLight->ang = GetRenderAngles(); m_pLight->pos = GetRenderOrigin(); m_pLight->col_diffuse = GetColor_Diffuse(); m_pLight->col_ambient = GetColor_Ambient(); m_pLight->flRadius = GetRadius(); m_pLight->flFalloffPower = GetFalloffPower(); m_pLight->flSpotCone_Inner = SPOT_DEGREE_TO_RAD( GetSpotCone_Inner() ); m_pLight->flSpotCone_Outer = SPOT_DEGREE_TO_RAD( GetSpotCone_Outer() ); m_pLight->iVisible_Dist = GetVisible_Distance(); m_pLight->iVisible_Range = GetVisible_FadeRange(); m_pLight->iShadow_Dist = GetShadow_Distance(); m_pLight->iShadow_Range = GetShadow_FadeRange(); m_pLight->iStyleSeed = GetStyle_Seed(); m_pLight->flStyle_Amount = GetStyle_Amount(); m_pLight->flStyle_Random = GetStyle_Random(); m_pLight->flStyle_Smooth = GetStyle_Smooth(); m_pLight->flStyle_Speed = GetStyle_Speed(); m_pLight->iLighttype = GetLight_Type(); m_pLight->iFlags >>= DEFLIGHTGLOBAL_FLAGS_MAX_SHARED_BITS; m_pLight->iFlags <<= DEFLIGHTGLOBAL_FLAGS_MAX_SHARED_BITS; m_pLight->iFlags |= GetLight_Flags(); m_pLight->iCookieIndex = GetCookieIndex(); #if DEFCFG_ADAPTIVE_VOLUMETRIC_LOD GetVolumeLODDistances( m_pLight->flVolumeLOD0Dist, m_pLight->flVolumeLOD1Dist, m_pLight->flVolumeLOD2Dist, m_pLight->flVolumeLOD3Dist ); #endif #if DEFCFG_CONFIGURABLE_VOLUMETRIC_LOD m_pLight->iVolumeSamples = GetVolumeSamples(); #endif }
void CDeferredLight::ClientThink() { if ( m_pLight == NULL ) return; Vector curOrig = GetRenderOrigin(); QAngle curAng = GetRenderAngles(); if ( VectorCompare( curOrig.Base(), m_pLight->pos.Base() ) == 0 || VectorCompare( curAng.Base(), m_pLight->ang.Base() ) == 0 ) { ApplyDataToLight(); if ( m_pLight->flSpotCone_Outer != GetSpotCone_Outer() ) m_pLight->MakeDirtyAll(); else m_pLight->MakeDirtyXForms(); } }
int C_PortalGhostRenderable::DrawModel( int flags ) { if( m_bSourceIsBaseAnimating ) { if( m_bLocalPlayer ) { C_Portal_Player *pPlayer = C_Portal_Player::GetLocalPlayer(); if ( !pPlayer->IsAlive() ) { // Dead player uses a ragdoll to draw, so don't ghost the dead entity return 0; } else if( g_pPortalRender->GetViewRecursionLevel() == 0 ) { if( pPlayer->m_bEyePositionIsTransformedByPortal ) return 0; } else if( g_pPortalRender->GetViewRecursionLevel() == 1 ) { if( !pPlayer->m_bEyePositionIsTransformedByPortal ) return 0; } } return C_BaseAnimating::DrawModel( flags ); } else { render->DrawBrushModel( m_pGhostedRenderable, (model_t *)m_pGhostedRenderable->GetModel(), GetRenderOrigin(), GetRenderAngles(), flags & STUDIO_TRANSPARENCY ? true : false ); return 1; } return 0; }
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: Get the rendered extents of the sprite //----------------------------------------------------------------------------- void CSprite::GetRenderBounds( Vector &vecMins, Vector &vecMaxs ) { float flScale = GetRenderScale() * 0.5f; // If our scale is normalized we need to convert that to actual world units if ( m_bWorldSpaceScale == false ) { CEngineSprite *psprite = (CEngineSprite *) modelinfo->GetModelExtraData( GetModel() ); if ( psprite ) { float flSize = MAX( psprite->GetWidth(), psprite->GetHeight() ); flScale *= flSize; } } vecMins.Init( -flScale, -flScale, -flScale ); vecMaxs.Init( flScale, flScale, flScale ); #if 0 // Visualize the bounds debugoverlay->AddBoxOverlay( GetRenderOrigin(), vecMins, vecMaxs, GetRenderAngles(), 255, 255, 255, 0, 0.01f ); #endif }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_HL2MP_Player::CalculateIKLocks( float currentTime ) { if (!m_pIk) return; int targetCount = m_pIk->m_target.Count(); if ( targetCount == 0 ) return; // In TF, we might be attaching a player's view to a walking model that's using IK. If we are, it can // get in here during the view setup code, and it's not normally supposed to be able to access the spatial // partition that early in the rendering loop. So we allow access right here for that special case. SpatialPartitionListMask_t curSuppressed = partition->GetSuppressedLists(); partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false ); CBaseEntity::PushEnableAbsRecomputations( false ); for (int i = 0; i < targetCount; i++) { trace_t trace; CIKTarget *pTarget = &m_pIk->m_target[i]; if (!pTarget->IsActive()) continue; switch( pTarget->type) { case IK_GROUND: { pTarget->SetPos( Vector( pTarget->est.pos.x, pTarget->est.pos.y, GetRenderOrigin().z )); pTarget->SetAngles( GetRenderAngles() ); } break; case IK_ATTACHMENT: { C_BaseEntity *pEntity = NULL; float flDist = pTarget->est.radius; // FIXME: make entity finding sticky! // FIXME: what should the radius check be? for ( CEntitySphereQuery sphere( pTarget->est.pos, 64 ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() ) { C_BaseAnimating *pAnim = pEntity->GetBaseAnimating( ); if (!pAnim) continue; int iAttachment = pAnim->LookupAttachment( pTarget->offset.pAttachmentName ); if (iAttachment <= 0) continue; Vector origin; QAngle angles; pAnim->GetAttachment( iAttachment, origin, angles ); // debugoverlay->AddBoxOverlay( origin, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), QAngle( 0, 0, 0 ), 255, 0, 0, 0, 0 ); float d = (pTarget->est.pos - origin).Length(); if ( d >= flDist) continue; flDist = d; pTarget->SetPos( origin ); pTarget->SetAngles( angles ); // debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 255, 0, 0, 0 ); } if (flDist >= pTarget->est.radius) { // debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 0, 255, 0, 0 ); // no solution, disable ik rule pTarget->IKFailed( ); } } break; } } CBaseEntity::PopEnableAbsRecomputations(); partition->SuppressLists( curSuppressed, true ); }
//----------------------------------------------------------------------------- // 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; }
/** * Orient head and eyes towards m_lookAt. */ void C_CHostage::UpdateLookAt( CStudioHdr *pStudioHdr ) { if (!m_isInit) { m_isInit = true; Initialize( ); } // head yaw if (m_headYawPoseParam < 0 || m_bodyYawPoseParam < 0 || m_headPitchPoseParam < 0) return; if (GetLeader()) { m_lookAt = GetLeader()->EyePosition(); } // orient eyes m_viewtarget = m_lookAt; // blinking if (m_blinkTimer.IsElapsed()) { m_blinktoggle = !m_blinktoggle; m_blinkTimer.Start( RandomFloat( 1.5f, 4.0f ) ); } // Figure out where we want to look in world space. QAngle desiredAngles; Vector to = m_lookAt - EyePosition(); VectorAngles( to, desiredAngles ); // Figure out where our body is facing in world space. float poseParams[MAXSTUDIOPOSEPARAM]; GetPoseParameters( pStudioHdr, poseParams ); QAngle bodyAngles( 0, 0, 0 ); bodyAngles[YAW] = GetRenderAngles()[YAW] + RemapVal( poseParams[m_bodyYawPoseParam], 0, 1, m_bodyYawMin, m_bodyYawMax ); float flBodyYawDiff = bodyAngles[YAW] - m_flLastBodyYaw; m_flLastBodyYaw = bodyAngles[YAW]; // Set the head's yaw. float desired = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] ); desired = clamp( desired, m_headYawMin, m_headYawMax ); m_flCurrentHeadYaw = ApproachAngle( desired, m_flCurrentHeadYaw, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime ); // Counterrotate the head from the body rotation so it doesn't rotate past its target. m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw - flBodyYawDiff ); desired = clamp( desired, m_headYawMin, m_headYawMax ); SetPoseParameter( pStudioHdr, m_headYawPoseParam, m_flCurrentHeadYaw ); // Set the head's yaw. desired = AngleNormalize( desiredAngles[PITCH] ); desired = clamp( desired, m_headPitchMin, m_headPitchMax ); m_flCurrentHeadPitch = ApproachAngle( desired, m_flCurrentHeadPitch, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime ); m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch ); SetPoseParameter( pStudioHdr, m_headPitchPoseParam, m_flCurrentHeadPitch ); SetPoseParameter( pStudioHdr, "head_roll", 0.0f ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_AI_BaseHumanoid::StandardBlendingRules( Vector pos[], Quaternion q[], float currentTime, int boneMask ) { VPROF( "C_AI_BaseHumanoid::StandardBlendingRules" ); BaseClass::StandardBlendingRules( pos, q, currentTime, boneMask ); studiohdr_t *hdr = InitModel(); if ( !hdr ) { return; } #if 0 float poseparam[MAXSTUDIOPOSEPARAM]; if (m_nSequence >= hdr->numseq) { m_nSequence = 0; } // interpolate pose parameters for (int i = 0; i < hdr->numposeparameters; i++) { poseparam[ i ] = m_flPoseParameter[i]; } // build root animation float fCycle = m_flCycle; CalcPose( hdr, NULL, pos, q, m_nSequence, fCycle, poseparam ); // debugoverlay->AddTextOverlay( GetAbsOrigin() + Vector( 0, 0, 64 ), 0, 0, "%30s %6.2f : %6.2f", hdr->pSeqdesc( m_nSequence )->pszLabel( ), fCycle, 1.0 ); MaintainSequenceTransitions( fCycle, poseparam, pos, q, boneMask ); #if 1 for (i = 0; i < 4; i++) { if (m_Layer[i][2].nSequence != m_Layer[i][1].nSequence) { if (m_Layer[i][2].flWeight > 0.5) m_Layer[i][1].flWeight = 1.0; else m_Layer[i][1].flWeight = 0; } } #endif #if 1 for (i = 0; i < 4; i++) { Vector pos2[MAXSTUDIOBONES]; Quaternion q2[MAXSTUDIOBONES]; float fWeight = m_Layer[i][1].flWeight * (1 - dadt) + m_Layer[i][2].flWeight * dadt; /* debugoverlay->AddTextOverlay( GetAbsOrigin() + Vector( 0, 0, 64 ), -i - 1, 0, "%2d %6.2f %6.2f : %2d %6.2f %6.2f : %2d %6.2f %6.2f", m_Layer[i][0].nSequence, m_Layer[i][0].flCycle, m_Layer[i][0].flWeight, m_Layer[i][1].nSequence, m_Layer[i][1].flCycle, m_Layer[i][1].flWeight, m_Layer[i][2].nSequence, m_Layer[i][2].flCycle, m_Layer[i][2].flWeight ); */ if (fWeight > 0) { mstudioseqdesc_t *pseqdesc = hdr->pSeqdesc( m_Layer[i][2].nSequence ); float fCycle = m_Layer[i][2].flCycle; // UNDONE: Do IK here. CalcPose( hdr, NULL, pos2, q2, m_Layer[i][2].nSequence, fCycle, poseparam ); if (fWeight > 1) fWeight = 1; SlerpBones( hdr, q, pos, pseqdesc, q2, pos2, fWeight ); engine->Con_NPrintf( 10 + i, "%30s %6.2f : %6.2f", pseqdesc->pszLabel(), fCycle, fWeight ); } else { engine->Con_NPrintf( 10 + i, "%30s %6.2f : %6.2f", " ", 0, 0 ); } } #endif CIKContext auto_ik; auto_ik.Init( hdr, GetRenderAngles(), GetRenderOrigin(), gpGlobals->curtime ); CalcAutoplaySequences( hdr, &auto_ik, pos, q, poseparam, boneMask, currentTime ); float controllers[MAXSTUDIOBONECTRLS]; GetBoneControllers(controllers); CalcBoneAdj( hdr, pos, q, controllers ); #endif }