void vHavokBehaviorComponent::UpdateAnimationAndBoneIndexList() { // Set up the animation config VDynamicMesh* mesh = m_entityOwner->GetMesh(); if( mesh != HK_NULL && mesh->GetSkeleton() != HK_NULL ) { // create an anim config, if one is not present VisAnimConfig_cl* pConfig = m_entityOwner->GetAnimConfig(); if ( pConfig == HK_NULL ) { pConfig = VisAnimConfig_cl::CreateSkeletalConfig(mesh); m_entityOwner->SetAnimConfig( pConfig ); } pConfig->SetFlags(pConfig->GetFlags() | MULTITHREADED_ANIMATION); // Create mapping VisSkeleton_cl* visionSkeleton = mesh->GetSkeleton(); const hkaSkeleton* havokSkeleton = m_character->getSetup()->m_animationSkeleton; for( int i = 0; i < havokSkeleton->m_bones.getSize(); i++ ) { const VHashString &boneName = havokSkeleton->m_bones[i].m_name.cString(); int visionBoneIndex = visionSkeleton->GetBoneIndexByName( boneName ); m_boneIndexList.pushBack( visionBoneIndex ); } } }
void SimpleSkeletalAnimatedObject_cl::LayerTwoAnimations() { // Layer two animations (using a LayerMixer node). We use this to fade-in an upper body animation // on top of a full body animation. The mixer gets the two animation controls as input and generates // the layered result. The animation tree looks as follows: // // - FinalSkeletalResult // - LayerMixerNode // - SkeletalAnimControl (WalkDagger Animation; influences full body) // - SkeletalAnimControl (RunDagger Animation: influences upper body only) // // The weight of the layered upper body animation is set on the mixer instance. // // Create a new AnimConfig instance VDynamicMesh *pMesh = GetMesh(); VisSkeleton_cl *pSkeleton = pMesh->GetSkeleton(); VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult; VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); // get skeletal animation sequence VisSkeletalAnimSequence_cl* pAnimSequenceWalkDagger = static_cast<VisSkeletalAnimSequence_cl*>( pMesh->GetSequence("Walk_Dagger", VIS_MODELANIM_SKELETAL)); VisSkeletalAnimSequence_cl* pAnimSequenceDrawDagger = static_cast<VisSkeletalAnimSequence_cl*>( pMesh->GetSequence("Draw_Dagger", VIS_MODELANIM_SKELETAL)); if (pAnimSequenceWalkDagger == NULL || pAnimSequenceDrawDagger == NULL) return; // Create the two animation controls: WalkDagger: full body animation; DrawDagger: upper body animation. // Use a helper function to create the animation controls. VSmartPtr<VisSkeletalAnimControl_cl> spWalkDaggerAnimControl = VisSkeletalAnimControl_cl::Create( pMesh->GetSkeleton(), pAnimSequenceWalkDagger, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); VSmartPtr<VisSkeletalAnimControl_cl> spDrawDaggerAnimControl = VisSkeletalAnimControl_cl::Create( pMesh->GetSkeleton(), pAnimSequenceDrawDagger, VSKELANIMCTRL_DEFAULTS, 1.0f, true); // create the layer node which layers the two animations m_spLayerMixerNode = new VisAnimLayerMixerNode_cl(pMesh->GetSkeleton()); m_spLayerMixerNode->AddMixerInput(spWalkDaggerAnimControl, 1.0f); int iMixerInputDrawDagger = m_spLayerMixerNode->AddMixerInput(spDrawDaggerAnimControl, 0.0f); // set a per bone weighting list for the DrawDagger (upper body) slot in the mixer. It shall overlay the // upper body of the character and thus only influence the upper body bones. int iBoneCount = pSkeleton->GetBoneCount(); VASSERT(iBoneCount < 256); float fPerBoneWeightingList[256]; memset(fPerBoneWeightingList, 0, sizeof(float)*iBoneCount); pSkeleton->SetBoneWeightRecursive(1.f, pSkeleton->GetBoneIndexByName("skeleton1:Spine"), fPerBoneWeightingList); m_spLayerMixerNode->ApplyPerBoneWeightingMask(iMixerInputDrawDagger, iBoneCount, fPerBoneWeightingList); // finally set the mixer as the root animation node pFinalSkeletalResult->SetSkeletalAnimInput(m_spLayerMixerNode); SetAnimConfig(pConfig); // fade-in the upper body animation //m_spLayerMixerNode->EaseIn(iMixerInputDrawDagger, 0.4f, true); }
void VAnimationEventEffectTrigger::MessageFunction( int iID, INT_PTR iParamA, INT_PTR iParamB ) { IVTransitionEventTrigger::MessageFunction(iID, iParamA, iParamB); #ifdef WIN32 if (iID == VIS_MSG_EDITOR_GETSTANDARDVALUES) { // Get bone names const char *szKey = (const char *)iParamA; if (!strcmp(szKey,"Bone")) { // Check for model and skeleton VisBaseEntity_cl* pEntity = (VisBaseEntity_cl *)m_pOwner; if (pEntity == NULL) return; VDynamicMesh* pMesh = pEntity->GetMesh(); if (pMesh == NULL) return; VisSkeleton_cl *pSkeleton = pMesh->GetSkeleton(); if (pSkeleton == NULL) return; // Fill list with bone names (first entry is empty) VStrList *pDestList = (VStrList*) iParamB; pDestList->AddString(" "); for (int i = 0; i < pSkeleton->GetBoneCount(); i++) pDestList->AddString(pSkeleton->GetBone(i)->m_sBoneName.AsChar()); } } #endif }
// ---------------------------------------------------------------------------- void vHavokChainAnimation::CommonInit() { CommonDeinit(); if (!m_pOwner || !m_pOwner->IsOfType(V_RUNTIME_CLASS(VisBaseEntity_cl))) return; Vision::Callbacks.OnUpdateSceneFinished += this; m_pOwnerEntity = static_cast<VisBaseEntity_cl*>(m_pOwner); VisAnimConfig_cl *pAnimConfig = m_pOwnerEntity->GetAnimConfig(); // If there is no AnimConfig, but we can get a skeleton, create the AnimConfig. if (!pAnimConfig) { VDynamicMesh *pMesh = m_pOwnerEntity->GetMesh(); VisSkeleton_cl *pSkeleton = pMesh ? pMesh->GetSkeleton() : NULL; if (pSkeleton) { VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult; pAnimConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); m_pOwnerEntity->SetAnimConfig(pAnimConfig); } } }
void SimpleSkeletalAnimatedObject_cl::LookAt() { // start a single animation StartSingleAnimation(true); // start a simple skeletal animation bool bLooped = true; int iFlags = VSKELANIMCTRL_DEFAULTS; if (bLooped) iFlags |= VANIMCTRL_LOOP; m_spSingleAnimControl = VisAnimConfig_cl::StartSkeletalAnimation(this, "Run", iFlags); // find the head bone index VDynamicMesh *pMesh = GetMesh(); m_iHeadBoneIndex = pMesh->GetSkeleton()->GetBoneIndexByName("skeleton1:Head"); // create a rotation matrix that defines the actual orientation of the head. This is model specific and can // only be found out by trial and error (typically 0, 90 or 180 deg). In our case the head is rotated by 180 degrees; Without this additional // orientation that model would follow the target with the backside of the head. m_RelativeHeadOrientation.setFromEulerAngles (90, 0, 270); // create an entity that rotates around the model m_pLookAtTarget = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3::ZeroVector(), "Models/MagicBall.model"); m_fLookAtRotationPhase = 0.f; }
void SimpleSkeletalAnimatedObject_cl::ForwardKinematics() { // Apply forward kinematics to the head "Neck" bone, using a bone modifier node. The bone modifier // gets a skeletal animation as input, modifies the translation of the neck bone and generates the // combined result. The animation tree looks as follows: // // - FinalSkeletalResult // - BoneModifierNode (modifies the neck bone) // - SkeletalAnimControl (Walk Animation) // // The translation of the neck bone is set on the bone modifier node. // // Create a new AnimConfig instance VDynamicMesh *pMesh = GetMesh(); VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult; VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); // Get skeletal animation sequence. VisSkeletalAnimSequence_cl* pAnimSequenceWalk = static_cast<VisSkeletalAnimSequence_cl*>(pMesh->GetSequence("Walk", VIS_MODELANIM_SKELETAL)); if (pAnimSequenceWalk == NULL) return; // Create the animation control to play the walk animation (via a helper function). VSmartPtr<VisSkeletalAnimControl_cl> spWalkAnimControl = VisSkeletalAnimControl_cl::Create( pMesh->GetSkeleton(), pAnimSequenceWalk, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); // Create the bone modifier node that translates the head bone. Set the animation control instance // as the input for this node. m_spBoneModifierNode = new VisAnimBoneModifierNode_cl(pMesh->GetSkeleton()); m_spBoneModifierNode->SetModifierInput(spWalkAnimControl); hkvQuat customBoneRotation; // set the neck bone translation on the bone modifier node m_iNeckBoneIndex = pMesh->GetSkeleton()->GetBoneIndexByName("skeleton1:Neck"); customBoneRotation.setFromEulerAngles (0, -45, 0); m_spBoneModifierNode->SetCustomBoneRotation(m_iNeckBoneIndex, customBoneRotation, VIS_MODIFY_BONE); // finally set the bone modifier as the root animation node pFinalSkeletalResult->SetSkeletalAnimInput(m_spBoneModifierNode); SetAnimConfig(pConfig); // The bone modifier node is now part of the animation tree. You can at any time update the translation // on the bone modifier. The animation system will take care of generating the proper final result. }
void SimpleSkeletalAnimatedObject_cl::BlendTwoAnimations() { // Blend two animations using a NormalizeMixer node. The mixer gets the two animations as input // and generates the blended result. The animation tree looks as follows: // // - FinalSkeletalResult // - NormalizeMixerNode // - SkeletalAnimControl (Walk Animation) // - SkeletalAnimControl (Run Animation) // // The weights of the two animations are set on the mixer instance. // // create a new AnimConfig instance VDynamicMesh *pMesh = GetMesh(); VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult; VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); // get skeletal animation sequence VisSkeletalAnimSequence_cl* pAnimSequenceWalk = static_cast<VisSkeletalAnimSequence_cl*>( pMesh->GetSequence("Walk", VIS_MODELANIM_SKELETAL)); VisSkeletalAnimSequence_cl* pAnimSequenceRun = static_cast<VisSkeletalAnimSequence_cl*>( pMesh->GetSequence("Run", VIS_MODELANIM_SKELETAL)); if(pAnimSequenceWalk == NULL || pAnimSequenceRun == NULL) return; // create two animation controls: walk and run (use a helper function for creating them) VSmartPtr<VisSkeletalAnimControl_cl> spWalkAnimControl = VisSkeletalAnimControl_cl::Create( pMesh->GetSkeleton(), pAnimSequenceWalk, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); VSmartPtr<VisSkeletalAnimControl_cl> spRunAnimControl = VisSkeletalAnimControl_cl::Create( pMesh->GetSkeleton(), pAnimSequenceRun, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); // create the mixer node that blends the two animations // (set initial weight to show walk animation only) m_spNormalizeMixerNode = new VisAnimNormalizeMixerNode_cl(pMesh->GetSkeleton()); m_iMixerInputWalk = m_spNormalizeMixerNode->AddMixerInput(spWalkAnimControl, 1.0f); m_iMixerInputRun = m_spNormalizeMixerNode->AddMixerInput(spRunAnimControl, 0.0f); // finally set the mixer as the root animation node pFinalSkeletalResult->SetSkeletalAnimInput(m_spNormalizeMixerNode); SetAnimConfig(pConfig); // blend from walk to run SetBlendWalkToRun(true); }
bool VAnimationEventEffectTrigger::CommonInit() { // Initialize base component if (!IVTransitionEventTrigger::CommonInit()) return false; // Get owner entity VisBaseEntity_cl *pEntity = (VisBaseEntity_cl *)m_pOwner; if (pEntity == NULL) return false; // Fill the event trigger info if (m_iEventTriggerInfoCount <= 0) { VEventEffectTriggerInfo_t* info = NULL; if(m_pActiveTriggerInfo == NULL) //make sure it does not get created more than once { // Create new list with only one entry and set properties info = new VEventEffectTriggerInfo_t(); } else { info = (VEventEffectTriggerInfo_t*)m_pActiveTriggerInfo; } info->m_vPositionOffset = PositionOffset; info->m_vOrientationOffset= OrientationOffset; // Get effect file info->m_spEffectFile = VisParticleGroupManager_cl::GlobalManager().LoadFromFile(EffectFilename); if (info->m_spEffectFile == NULL || !GetEventTriggerInfoBaseData(info)) { V_SAFE_DELETE(info); m_pActiveTriggerInfo = NULL; return false; } // Get Bone Index if specified if (!AttachToBone.IsEmpty()) { VDynamicMesh* pMesh = pEntity->GetMesh(); if (pMesh == NULL) return false; VisSkeleton_cl *pSkeleton = pMesh->GetSkeleton(); if (pSkeleton == NULL) return false; info->m_iAttachToBone = pSkeleton->GetBoneIndexByName(AttachToBone); } // Set it as the active event trigger info m_pActiveTriggerInfo = info; } return true; }
void MergedModelFactory_cl::PreviewModel() { DeleteModels(); m_pPreviewModelEntities = new VisBaseEntity_cl*[BARBARIAN_MAX]; m_pPreviewModelEntities[BARBARIAN_BODY] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Body.model"); m_pPreviewModelEntities[BARBARIAN_ARM] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Arm.model"); m_pPreviewModelEntities[BARBARIAN_SHOULDER] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Shoulder.model"); m_pPreviewModelEntities[BARBARIAN_LEGS] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Legs.model"); m_pPreviewModelEntities[BARBARIAN_KNEE] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Knee.model"); m_pPreviewModelEntities[BARBARIAN_ACCESSOIRE] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Accessoire.model"); m_pPreviewModelEntities[BARBARIAN_BELT] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Belt.model"); m_pPreviewModelEntities[BARBARIAN_CLOTH] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Cloth.model"); m_pPreviewModelEntities[BARBARIAN_BEARD] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Beard.model"); m_pPreviewModelEntities[BARBARIAN_AXE] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Axe.model"); m_pPreviewModelEntities[BARBARIAN_SWORD] = Vision::Game.CreateEntity("VisBaseEntity_cl", hkvVec3(0.f, 0.f, 0.f), "Barbarian_Sword.model"); // Setup animation system VDynamicMesh* pBodyMesh = m_pPreviewModelEntities[BARBARIAN_BODY]->GetMesh(); VisSkeletalAnimSequence_cl* pSequence = static_cast<VisSkeletalAnimSequence_cl*>(pBodyMesh->GetSequence("Idle", VIS_MODELANIM_SKELETAL)); // Create shared skeletal anim control to animate all models in sync VisSkeletalAnimControl_cl* pSkeletalAnimControl = VisSkeletalAnimControl_cl::Create(pBodyMesh->GetSkeleton(), pSequence, VSKELANIMCTRL_DEFAULTS | VANIMCTRL_LOOP); for (int i = 0; i < BARBARIAN_MAX; i++) { // Create anim config per entity VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult = NULL; VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateSkeletalConfig(m_pPreviewModelEntities[i]->GetMesh(), &pFinalSkeletalResult); pConfig->SetFlags(pConfig->GetFlags() | APPLY_MOTION_DELTA); // Anim config uses shared skeletal anim control as input pFinalSkeletalResult->SetSkeletalAnimInput(pSkeletalAnimControl); m_pPreviewModelEntities[i]->SetAnimConfig(pConfig); m_pPreviewModelEntities[i]->SetPosition(m_vPos); m_pPreviewModelEntities[i]->SetOrientation(m_vOri); #ifndef _VISION_PSP2 m_pPreviewModelEntities[i]->SetCastShadows(TRUE); #endif } m_pCameraEntity->AttachToParent(m_pPreviewModelEntities[BARBARIAN_BODY]); m_pPlayerCamera->ResetOldPosition(); m_pPlayerCamera->Follow = true; m_pPlayerCamera->Zoom = false; m_pPlayerCamera->InitialYaw = -90.f; UpdatePreview(); }
BOOL VLineFollowerComponent::StartAnimation(const char *szAnimName) { VisBaseEntity_cl* pOwner = (VisBaseEntity_cl *)GetOwner(); if (!pOwner) return false; m_bPlayingAnim = false; // Check for animation sequences VDynamicMesh *pMesh = pOwner->GetMesh(); if (!pMesh || !pMesh->GetSequenceSetCollection() || !pMesh->GetSequenceSetCollection()->GetSequenceSetCount()) return false; VisAnimFinalSkeletalResult_cl* pFinalSkeletalResult = NULL; VisVertexAnimDeformer_cl* pVertexAnimDeformer = NULL; // Get the sequence(s) for vertex and skeletal animation VisSkeletalAnimSequence_cl* pAnimSequenceSkeletal = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence(szAnimName, VIS_MODELANIM_SKELETAL); VisVertexAnimSequence_cl* pAnimSequenceVertex = (VisVertexAnimSequence_cl*)pMesh->GetSequence(szAnimName, VIS_MODELANIM_VERTEX); // If no sequence with the given name is present if ((!pAnimSequenceSkeletal) && (!pAnimSequenceVertex)) { VisAnimSequenceSet_cl * pSequenceSet = pMesh->GetSequenceSetCollection()->GetSequenceSet(0); // Find the first skeletal or vertex animation and use it for (int i=0; i< pSequenceSet->GetSequenceCount(); ++i) { VisAnimSequence_cl* pTempAnimSequence = pSequenceSet->GetSequence(i); if (pTempAnimSequence->GetType() == VIS_MODELANIM_SKELETAL) { // If it is a skeletal animation, create a config for it VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); VisSkeletalAnimControl_cl* pSkeletalAnimControl = VisSkeletalAnimControl_cl::Create(pMesh->GetSkeleton(), (VisSkeletalAnimSequence_cl*)pTempAnimSequence, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); pFinalSkeletalResult->SetSkeletalAnimInput(pSkeletalAnimControl); pOwner->SetAnimConfig(pConfig); m_bPlayingAnim = true; return true; } else if (pTempAnimSequence->GetType() == VIS_MODELANIM_VERTEX) { // If it is a vertex animation, create a config for it VisAnimConfig_cl* pConfig = VisAnimConfig_cl::CreateVertexConfig(pMesh, &pVertexAnimDeformer); VisVertexAnimControl_cl* pVertexAnimControl = VisVertexAnimControl_cl::Create((VisVertexAnimSequence_cl*)pTempAnimSequence, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); pVertexAnimDeformer->AddVertexAnimControl(pVertexAnimControl, 1.0f); pOwner->SetAnimConfig(pConfig); m_bPlayingAnim = true; return true; } } // If neither a skeletal nor a vertex animation has been found, report failure return false; } // If both a vertex and a skeletal animation with the given name has been found // create a combined config for skeletal and vertex animation. VisAnimConfig_cl* pConfig = NULL; if ((pAnimSequenceSkeletal) && (pAnimSequenceVertex)) pConfig = VisAnimConfig_cl::CreateSkeletalVertexConfig(pMesh, &pFinalSkeletalResult, &pVertexAnimDeformer); // If it is just a skeletal animation, create a config for it if (pAnimSequenceSkeletal) { if (!pConfig) pConfig = VisAnimConfig_cl::CreateSkeletalConfig(pMesh, &pFinalSkeletalResult); // If a skeletal animation has been found create a control for it VisSkeletalAnimControl_cl* pSkeletalAnimControl = VisSkeletalAnimControl_cl::Create(pMesh->GetSkeleton(), pAnimSequenceSkeletal, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); // And set it as the input for the final skeletal result pFinalSkeletalResult->SetSkeletalAnimInput(pSkeletalAnimControl); } // If it is just a vertex animation, create a config for it if (pAnimSequenceVertex) { if (!pConfig) pConfig = VisAnimConfig_cl::CreateVertexConfig(pMesh, &pVertexAnimDeformer); // If a vertex animation has been found create a control for it VisVertexAnimControl_cl* pVertexAnimControl = VisVertexAnimControl_cl::Create(pAnimSequenceVertex, VANIMCTRL_LOOP|VSKELANIMCTRL_DEFAULTS, 1.0f, true); // And set add it to the vertex anim deformer pVertexAnimDeformer->AddVertexAnimControl(pVertexAnimControl, 1.0f); } // Set the current config pOwner->SetAnimConfig(pConfig); // Make sure we get the motion delta from the animation pOwner->GetAnimConfig()->SetFlags(pOwner->GetAnimConfig()->GetFlags() | APPLY_MOTION_DELTA | MULTITHREADED_ANIMATION); // And report success m_bPlayingAnim = true; return true; }
void AnimatedWarrior_cl::InitFunction() { SetCastShadows(TRUE); SetupAnimations(); if (!m_bModelValid) return; m_pCharacterController = new vHavokCharacterController(); m_pCharacterController->Initialize(); hkvAlignedBBox bbox; GetMesh()->GetCollisionBoundingBox(bbox); float r = bbox.getSizeX() * 0.5f; m_pCharacterController->Capsule_Radius = r; m_pCharacterController->Character_Top.set(0,0,bbox.m_vMax.z - r); m_pCharacterController->Character_Bottom.set(0,0,bbox.m_vMin.z + r); m_pCharacterController->Max_Slope = 75.0f; if (!m_bEnabled) m_pCharacterController->SetEnabled(FALSE); AddComponent(m_pCharacterController); //// setup animation system // create config VDynamicMesh* pMesh = GetMesh(); VASSERT(pMesh); VisSkeleton_cl* pSkeleton = pMesh->GetSkeleton(); VASSERT(pSkeleton); // create mixer structure, we keep pointers on the mixers to add and remove inputs m_spLayerMixer = new VisAnimLayerMixerNode_cl(pSkeleton); m_pNormalizeMixer = new VisAnimNormalizeMixerNode_cl(pSkeleton); m_spLayerMixer->AddMixerInput(m_pNormalizeMixer, 1.f); //// create per bone weighting list for upper body int iBoneCount = pSkeleton->GetBoneCount(); float* fPerBoneWeightingList = new float[iBoneCount]; memset(fPerBoneWeightingList, 0, sizeof(float)*iBoneCount); // set all bone weights above the spine to 1 pSkeleton->SetBoneWeightRecursive(1.f, pSkeleton->GetBoneIndexByName("skeleton1:Spine"), fPerBoneWeightingList); int iMixerInputIndex = -1; for(int i=0; i<UPPERBODY_CONTROLCOUNT; i++) { m_spUpperBodyControls[i] = new VisSkeletalAnimControl_cl(pSkeleton, VSKELANIMCTRL_DEFAULTS); m_spUpperBodyControls[i]->AddEventListener(this); // we want to receive all events from sequence and control iMixerInputIndex = m_spLayerMixer->AddMixerInput(m_spUpperBodyControls[i], 0.f); m_spLayerMixer->ApplyPerBoneWeightingMask(iMixerInputIndex, iBoneCount, fPerBoneWeightingList); } V_SAFE_DELETE_ARRAY(fPerBoneWeightingList); // set the start animation BlendOverFullBodyAnimation(0.f, ANIMID_IDLE, 1.f, 0.f); SetFullBodyState(m_pFullBodyIdleState[FBSTATETYPE_NORMAL]); SetUpperBodyState(m_pUpperBodyIdleState); // initialize variables for upperbody fadein/fadeout m_eUpperBodyFadeState = FADESTATE_NONE; // setup neck bone for head rotation m_iHeadBoneIndex = pSkeleton->GetBoneIndexByName("skeleton1:Neck"); m_fHeadRotationAngles[0] = 0.f; m_fHeadRotationAngles[1] = 0.f; m_fHeadRotationAngles[2] = 0.f; m_bHeadInMovement = false; // setup the torch hkvVec3 vDummyOrigin; m_pTorch = (AttachedTorch_cl *) Vision::Game.CreateEntity( "AttachedTorch_cl", vDummyOrigin ); HideTorch(); // attach the torch to the bone //hkvVec3 localTranslation(-11.f, -4.5f, 25.f); hkvVec3 localTranslation(-11.f, 5.5f, 0.f); float euler[3] = {90, 0, 185}; hkvQuat localRotation; localRotation.setFromEulerAngles (euler[2], euler[1], euler[0]); // pass as roll, pitch, yaw m_pTorch->Attach(this, "skeleton1:RightHand", localRotation, localTranslation); SetEnabled(true); }