/// <summary> /// Setup binding between character joints and animator stream, that will be written by Kinematica job /// </summary> /// <param name="animator">Unity animator associated with the animation job</param> /// <param name="transforms">Character joint transforms</param> /// <param name="synthesizer">Reference to motion synthesizer</param> /// <param name="deltaTimePropertyHandle">Property handle for the deltaTime</param> /// <returns></returns> public bool Setup(Animator animator, Transform[] transforms, ref MotionSynthesizer synthesizer, PropertySceneHandle deltaTimePropertyHandle) { this.synthesizer = MemoryRef <MotionSynthesizer> .Create(ref synthesizer); int numJoints = synthesizer.Binary.numJoints; this.transforms = new NativeArray <TransformStreamHandle>(numJoints, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); boundJoints = new NativeArray <bool>(numJoints, Allocator.Persistent, NativeArrayOptions.ClearMemory); // Root joint is always first transform, and names don't need to match contrary to other joints this.transforms[0] = animator.BindStreamTransform(transforms[0]); boundJoints[0] = true; for (int i = 1; i < transforms.Length; i++) { int jointNameIndex = synthesizer.Binary.GetStringIndex(transforms[i].name); int jointIndex = (jointNameIndex >= 0) ? synthesizer.Binary.animationRig.GetJointIndexForNameIndex(jointNameIndex) : -1; if (jointIndex >= 0) { this.transforms[jointIndex] = animator.BindStreamTransform(transforms[i]); boundJoints[jointIndex] = true; } } deltaTime = deltaTimePropertyHandle; return(true); }
public void Setup(Animator animator, RotationConstraint[] constraints) { int count = constraints.Length; referenceTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); currentTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); minMaxSpeeds = new NativeArray <Vector2>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); minMaxAngles = new NativeArray <Vector2>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); lastPositions = new NativeArray <Vector3>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); initialRotations = new NativeArray <Quaternion>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); lastAngles = new NativeArray <float>(count, Allocator.Persistent); for (int i = 0; i < count; ++i) { Assert.IsTrue(constraints[i].referenceTransform != null); Assert.IsTrue(constraints[i].transform != null); referenceTransforms[i] = animator.BindStreamTransform(constraints[i].referenceTransform); currentTransforms[i] = animator.BindStreamTransform(constraints[i].transform); minMaxSpeeds[i] = new Vector2(constraints[i].minimumSpeed, constraints[i].maximumSpeed); minMaxAngles[i] = new Vector2(constraints[i].minimumAngle, constraints[i].maximumAngle); lastPositions[i] = constraints[i].referenceTransform.position; initialRotations[i] = constraints[i].transform.localRotation; } deltaTime = animator.BindSceneProperty(animator.gameObject.transform, typeof(Unit), "m_deltaTime"); }
/************************************************************************************************************************/ public static NativeArray <TransformStreamHandle> GetDefaultHumanoidLeanBones(Animator animator) { var leanBones = new NativeArray <TransformStreamHandle>(2, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); leanBones[0] = animator.BindStreamTransform(animator.GetBoneTransform(HumanBodyBones.Spine)); leanBones[1] = animator.BindStreamTransform(animator.GetBoneTransform(HumanBodyBones.Chest)); return(leanBones); }
// public bool Setup(Animator animator, EditorSettings editorSettings) { jobSettings = editorSettings.jobSettings; m_CameraHandle = animator.BindStreamTransform(editorSettings.cameraBone); m_CharacterRoot = animator.BindStreamTransform(editorSettings.characterRootBone); return(true); }
public void Setup(Animator animator, Transform topX, Transform midX, Transform lowX, Transform effectorX) { top = animator.BindStreamTransform(topX); mid = animator.BindStreamTransform(midX); low = animator.BindStreamTransform(lowX); effector = animator.BindSceneTransform(effectorX); }
public bool Setup(Animator animator, IkChain chain, Type componentType, string weightProperty, string weightOffsetProperty, string targetOffsetProperty) { if (!chain.HasValidData()) { return(false); } // Target m_TargetOffset = chain.target.offset; if (chain.target.readFrom == TargetType.Stream) { m_EffectorStreamHandle = animator.BindStreamTransform(chain.target.target); m_UseStreamEffector = true; } else { m_EffectorSceneHandle = animator.BindSceneTransform(chain.target.target); m_UseStreamEffector = false; } // Weight if (chain.weight.useAnimatorProperty && chain.weight.propertyName != "") { m_AnimatorWeight = animator.BindStreamProperty(animator.transform, typeof(Animator), chain.weight.propertyName); m_UseAnimatorProperty = true; } m_WeightHandle = animator.BindSceneProperty(animator.transform, componentType, weightProperty); m_AnimatorWeightOffset = animator.BindSceneProperty(animator.transform, componentType, weightOffsetProperty); // Driven m_IkType = chain.driven.type; if (m_IkType == IkType.Generic) { var end = chain.driven.genericEndJoint; var mid = end.parent; var start = mid.parent; m_StartHandle = animator.BindStreamTransform(start); m_MidHandle = animator.BindStreamTransform(mid); m_EndHandle = animator.BindStreamTransform(end); } else { m_HumanLimb = chain.driven.humanoidLimb; } return(true); }
public bool Setup(Animator animator, EditorSettings editorSettings, float deltaTime, NativeQueue <Quaternion> dragHistory) { if (!editorSettings.HasValidData()) { return(false); } settings = editorSettings.settings; m_Effectorhandle = animator.BindStreamTransform(editorSettings.weaponHandBone); m_WeaponPivot = animator.BindStreamTransform(editorSettings.weaponBone); m_WeaponHandResult = animator.BindSceneTransform(editorSettings.applyResultOn); m_DragHistory = dragHistory; return(true); }
public void Setup(Animator animator, Transform[] bones, Transform target) { this.bones = new NativeArray <UnityEngine.Animations.TransformStreamHandle>(bones.Length, Allocator.Persistent); this.boneWeights = new NativeArray <UnityEngine.Animations.PropertySceneHandle>(bones.Length - 1, Allocator.Persistent); this.boneSqrMags = new NativeArray <float>(bones.Length - 1, Allocator.Persistent); for (int i = 0; i < this.bones.Length; i++) { this.bones[i] = animator.BindStreamTransform(bones[i]); } for (int i = 0; i < this.bones.Length - 1; i++) { var boneParams = bones[i].gameObject.GetComponent <IKJBoneParams>(); if (boneParams == null) { boneParams = bones[i].gameObject.AddComponent <IKJBoneParams>(); } this.boneWeights[i] = animator.BindSceneProperty(bones[i].transform, typeof(IKJBoneParams), "weight"); } // Rotation Limits SetUpRotationLimits(animator, bones); _target = animator.BindSceneTransform(target); _IKPositionWeight = animator.BindSceneProperty(animator.transform, typeof(CCDIKJ), "weight"); _maxIterations = animator.BindSceneProperty(animator.transform, typeof(CCDIKJ), "maxIterations"); _tolerance = animator.BindSceneProperty(animator.transform, typeof(CCDIKJ), "tolerance"); _XY = animator.BindSceneProperty(animator.transform, typeof(CCDIKJ), "XY"); _useRotationLimits = animator.BindSceneProperty(animator.transform, typeof(CCDIKJ), "useRotationLimits"); }
public void Setup(Animator animator, Transform[] bones, Transform target, Transform poleTarget, Transform aimTransform) { this.bones = new NativeArray <UnityEngine.Animations.TransformStreamHandle>(bones.Length, Allocator.Persistent); this.boneWeights = new NativeArray <UnityEngine.Animations.PropertySceneHandle>(bones.Length, Allocator.Persistent); for (int i = 0; i < this.bones.Length; i++) { this.bones[i] = animator.BindStreamTransform(bones[i]); } for (int i = 0; i < this.bones.Length; i++) { var boneParams = bones[i].gameObject.GetComponent <IKJBoneParams>(); if (boneParams == null) { boneParams = bones[i].gameObject.AddComponent <IKJBoneParams>(); } this.boneWeights[i] = animator.BindSceneProperty(bones[i].transform, typeof(IKJBoneParams), "weight"); } // Rotation Limits SetUpRotationLimits(animator, bones); _target = animator.BindSceneTransform(target); _poleTarget = animator.BindSceneTransform(poleTarget); _transform = animator.BindStreamTransform(aimTransform); _IKPositionWeight = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "weight"); _poleWeight = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "poleWeight"); _axisX = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "axisX"); _axisY = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "axisY"); _axisZ = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "axisZ"); _poleAxisX = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "poleAxisX"); _poleAxisY = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "poleAxisY"); _poleAxisZ = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "poleAxisZ"); _clampWeight = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "clampWeight"); _clampSmoothing = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "clampSmoothing"); _maxIterations = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "maxIterations"); _tolerance = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "tolerance"); _XY = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "XY"); _useRotationLimits = animator.BindSceneProperty(animator.transform, typeof(AimIKJ), "useRotationLimits"); step = 1f / (float)bones.Length; }
//============================================================================================ /** * @brief Initializes the rigging integration. This is called automatically by MxM * * This function sets up native arrays of TransformStreamHandles so that the transforms * of the rig can be accessed from an animation job * * @param [PlayableGraph] a_playableGraph - the playable graph to use for the integration * @param [Animator] a_animator - a reference to the animator component * *********************************************************************************************/ public void Initialize(PlayableGraph a_playableGraph, Animator a_animator) { m_rigBuilder = GetComponentInChildren <RigBuilder>(); m_fixRigTransforms = false; m_lastTimeCached = Time.time; if (m_rigBuilder != null) { var rigLayers = m_rigBuilder.layers; m_rigs = new Rig[rigLayers.Count]; for (int i = 0; i < rigLayers.Count; ++i) { Rig rig = rigLayers[i].rig; m_rigs[i] = rig; } } m_rigStreamHandles = new NativeArray <TransformStreamHandle>(m_rigControls.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_rigTransformCache = new NativeArray <TransformData>(m_rigControls.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_rigWeightHandles = new NativeArray <PropertyStreamHandle>(m_rigs.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_rigWeightCache = new NativeArray <float>(m_rigs.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (int i = 0; i < m_rigControls.Length; ++i) { Transform controlTransform = m_rigControls[i]; m_rigStreamHandles[i] = a_animator.BindStreamTransform(controlTransform); m_rigTransformCache[i] = new TransformData() { Position = controlTransform.localPosition, Rotation = controlTransform.localRotation }; } for (int i = 0; i < m_rigs.Length; ++i) { m_rigWeightHandles[i] = a_animator.BindStreamProperty(m_rigs[i].transform, typeof(Rig), "m_Weight"); m_rigWeightCache[i] = m_rigs[i].weight; } var rigIntegrationJob = new RiggingIntegrationJob() { FixRigTransforms = m_fixRigTransforms, RigStreamHandles = m_rigStreamHandles, RigTransformCache = m_rigTransformCache, RigWeightHandles = m_rigWeightHandles, RigWeightCache = m_rigWeightCache, }; m_riggingScriptPlayable = AnimationScriptPlayable.Create(a_playableGraph, rigIntegrationJob); var output = AnimationPlayableOutput.Create(a_playableGraph, "RigIntegrationOutput", a_animator); output.SetSourcePlayable(m_riggingScriptPlayable); }
public void Setup(Animator animator, AverageConstraint[] constraints) { int count = constraints.Length; startTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); endTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); currentTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (int i = 0; i < count; ++i) { Assert.IsTrue(constraints[i].startTransform != null); Assert.IsTrue(constraints[i].endTransform != null); Assert.IsTrue(constraints[i].transform != null); startTransforms[i] = animator.BindStreamTransform(constraints[i].startTransform); endTransforms[i] = animator.BindStreamTransform(constraints[i].endTransform); currentTransforms[i] = animator.BindStreamTransform(constraints[i].transform); } }
/// <summary> /// Create a ReadWriteTransformHandle representing the new binding between the Animator and a Transform already bound to the Animator. /// </summary> /// <param name="animator">The Animator on which to bind the new handle.</param> /// <param name="transform">The Transform to bind.</param> /// <returns>Returns the ReadWriteTransformHandle that represents the new binding.</returns> public static ReadWriteTransformHandle Bind(Animator animator, Transform transform) { ReadWriteTransformHandle handle = new ReadWriteTransformHandle(); if (transform == null || !transform.IsChildOf(animator.transform)) { return(handle); } handle.m_Handle = animator.BindStreamTransform(transform); return(handle); }
protected Transform[] InitHandle(Animator animator) { // Get all the transforms in the hierarchy. Transform[] boneList = animator.transform.GetComponentsInChildren <Transform>(); var numTransforms = boneList.Length - 1; // Fill native arrays (all the bones have a weight of 1.0). m_Handles = new NativeArray <TransformStreamHandle>(numTransforms, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (var i = 0; i < numTransforms; ++i) { m_Handles[i] = animator.BindStreamTransform(boneList[i + 1]); } return(boneList); }
public void Setup(Animator animator, LookAtConstraint[] constraints) { int count = constraints.Length; targetTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); upAxisTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); currentTransforms = new NativeArray <TransformStreamHandle>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); lookAtAxes = new NativeArray <Vector3>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); upAxes = new NativeArray <Vector3>(count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (int i = 0; i < count; ++i) { Assert.IsTrue(constraints[i].targetTransform != null); Assert.IsTrue(constraints[i].upAxisTransform != null); Assert.IsTrue(constraints[i].transform != null); targetTransforms[i] = animator.BindStreamTransform(constraints[i].targetTransform); upAxisTransforms[i] = animator.BindStreamTransform(constraints[i].upAxisTransform); currentTransforms[i] = animator.BindStreamTransform(constraints[i].transform); lookAtAxes[i] = Convert(constraints[i].lookAtAxis); upAxes[i] = Convert(constraints[i].upAxis); } }
private void CollectAndBindAnimationTransforms() { List <Transform> transforms = new List <Transform>(60); if (m_animator.isHuman) { for (int i = 0; i < (int)HumanBodyBones.LastBone; ++i) { var boneTransform = m_animator.GetBoneTransform((HumanBodyBones)i); if (boneTransform != null) { transforms.Add(boneTransform); } } } if (m_avatarMask != null) { //All non human bones for (int i = 0; i < m_avatarMask.transformCount; ++i) { var jointTransformPath = m_avatarMask.GetTransformPath(i); var jointTransform = m_animator.transform.Find(jointTransformPath); if (jointTransform != null) { transforms.Add(jointTransform); } } } m_transforms = transforms.ToArray(); m_targetAnimationTransforms = new NativeArray <TransformStreamHandle>(m_transforms.Length, Allocator.Persistent); m_currentAnimationTransforms = new NativeArray <TransformSceneHandle>(m_transforms.Length, Allocator.Persistent); m_previousAnimationTransforms = new NativeArray <TransformData>(m_transforms.Length, Allocator.Persistent); for (int i = 0; i < m_transforms.Length; ++i) { Transform tform = m_transforms[i]; m_targetAnimationTransforms[i] = m_animator.BindStreamTransform(tform); m_currentAnimationTransforms[i] = m_animator.BindSceneTransform(tform); m_previousAnimationTransforms[i] = new TransformData(tform.position, tform.rotation); } }
public override SyncSceneToStreamJob Create(Animator animator, ref T data) { var job = new SyncSceneToStreamJob(); var objects = data.objects; var sync = data.sync; job.sceneHandles = new NativeArray<TransformSceneHandle>(objects.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); job.streamHandles = new NativeArray<TransformStreamHandle>(objects.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); job.syncSceneToStream = new BitArray(data.sync); for (int i = 0; i < objects.Length; ++i) { job.sceneHandles[i] = animator.BindSceneTransform(objects[i]); job.streamHandles[i] = animator.BindStreamTransform(objects[i]); } return job; }
void Initialize(Animator animator) { // Create arrays (without the root which has its own handle). var numJoints = joints.Length; m_Handles = new NativeArray <TransformStreamHandle>(numJoints, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_LocalPositions = new NativeArray <Vector3>(numJoints, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_LocalRotations = new NativeArray <Quaternion>(numJoints, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); m_Positions = new NativeArray <Vector3>(numJoints, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (var i = 0; i < numJoints; ++i) { m_Handles[i] = animator.BindStreamTransform(joints[i]); m_LocalPositions[i] = joints[i].localPosition; m_LocalRotations[i] = joints[i].localRotation; m_Positions[i] = joints[i].position; } m_Velocities = new NativeArray <Vector3>(numJoints, Allocator.Persistent); }
/// <summary> /// Create a ReadOnlyTransformHandle representing the new binding between the Animator and a Transform already bound to the Animator. /// </summary> /// <param name="animator">The Animator on which to bind the new handle.</param> /// <param name="transform">The Transform to bind.</param> /// <returns>Returns the ReadOnlyTransformHandle that represents the new binding.</returns> public static ReadOnlyTransformHandle Bind(Animator animator, Transform transform) { ReadOnlyTransformHandle handle = new ReadOnlyTransformHandle(); if (transform == null) { return(handle); } handle.m_InStream = (byte)(transform.IsChildOf(animator.transform) ? 1 : 0); if (handle.m_InStream == 1) { handle.m_StreamHandle = animator.BindStreamTransform(transform); } else { handle.m_SceneHandle = animator.BindSceneTransform(transform); } return(handle); }
public SharedAnimationData( Animator animator, PlayableGraph playableGraph) { Animator = animator; PlayableGraph = playableGraph; // Get all the transforms in the hierarchy. AllAnimatorTransforms = animator.transform.GetComponentsInChildren <Transform>(); var numTransforms = AllAnimatorTransforms.Length - 1; // Fill native arrays (all the bones have a weight of 0.0). boneHandles = new NativeArray <TransformStreamHandle>(numTransforms, Allocator.Persistent, NativeArrayOptions.ClearMemory); boneWeights = new NativeArray <float>(numTransforms, Allocator.Persistent, NativeArrayOptions.ClearMemory); for (var i = 0; i < numTransforms; ++i) { boneHandles[i] = animator.BindStreamTransform(AllAnimatorTransforms[i + 1]); boneWeights[i] = 1; } bonesLastFrame = new NativeArray <BoneLocation>(numTransforms, Allocator.Persistent, NativeArrayOptions.ClearMemory); }
public bool Setup(Animator animator, EditorSettings editorSettings, float deltaTime, NativeArray <MuscleHandle> headMuscles, NativeArray <MuscleHandle> spineMuscles) { if (!editorSettings.HasValidData()) { return(false); } m_SkeletonHandle = animator.BindStreamTransform(editorSettings.bankTransform); m_HeadLeftRightMuscles = headMuscles; m_SpineLeftRightMuscles = spineMuscles; m_HeadLeftRightMuscles[0] = new MuscleHandle(HeadDof.NeckLeftRight); m_HeadLeftRightMuscles[1] = new MuscleHandle(HeadDof.HeadLeftRight); m_SpineLeftRightMuscles[0] = new MuscleHandle(BodyDof.SpineLeftRight); m_SpineLeftRightMuscles[1] = new MuscleHandle(BodyDof.ChestLeftRight); m_SpineLeftRightMuscles[2] = new MuscleHandle(BodyDof.UpperChestLeftRight); return(true); }
public void Setup(Animator animator, Transform boneToFollow, Transform slavedTransform) { m_BoneToFollow = animator.BindStreamTransform(boneToFollow); m_SlavedTransform = animator.BindSceneTransform(slavedTransform); }
private void SetupIKLimbHandle(ref FullBodyIKJob.IKLimbHandle handle, HumanBodyBones top, HumanBodyBones middle, HumanBodyBones end) { handle.top = m_Animator.BindStreamTransform(m_Animator.GetBoneTransform(top)); handle.middle = m_Animator.BindStreamTransform(m_Animator.GetBoneTransform(middle)); handle.end = m_Animator.BindStreamTransform(m_Animator.GetBoneTransform(end)); }
public void Setup(Animator animator, Skeleton skeleton, AvatarMask boneMask) { int numBones; var activeBones = new List <Transform>(); if (boneMask != null) { for (var i = 0; i < boneMask.transformCount; i++) { if (boneMask.GetTransformActive(i)) { var tokens = boneMask.GetTransformPath(i).Split('/'); var name = tokens[tokens.Length - 1]; var skeletonIndex = skeleton.GetBoneIndex(name.GetHashCode()); if (skeletonIndex != -1) { activeBones.Add(skeleton.bones[skeletonIndex]); } } } numBones = activeBones.Count; } else { numBones = skeleton.bones.Length; } m_CurrentBufferIndex = -1; m_Bones = new NativeArray <TransformStreamHandle>(numBones, Allocator.Persistent); m_OutputPositions = new NativeArray <float3>(numBones * k_OutputBufferCount, Allocator.Persistent); m_OutputRotations = new NativeArray <quaternion>(numBones * k_OutputBufferCount, Allocator.Persistent); m_OutputScales = new NativeArray <float3>(numBones * k_OutputBufferCount, Allocator.Persistent); m_OutputIkPositions = new NativeArray <float3>(k_NumIkHandles * k_OutputBufferCount, Allocator.Persistent); m_OutputIkRotations = new NativeArray <quaternion>(k_NumIkHandles * k_OutputBufferCount, Allocator.Persistent); m_PosDirArray = new NativeArray <float3>(numBones, Allocator.Persistent); m_PosDeltaArray = new NativeArray <float>(numBones, Allocator.Persistent); m_PosDeltaVelArray = new NativeArray <float>(numBones, Allocator.Persistent); m_RotAxisArray = new NativeArray <float3>(numBones, Allocator.Persistent); m_RotDeltaArray = new NativeArray <float>(numBones, Allocator.Persistent); m_RotDeltaVelArray = new NativeArray <float>(numBones, Allocator.Persistent); m_StarteScaleArray = new NativeArray <float3>(numBones, Allocator.Persistent); m_FromIkPositions = new NativeArray <float3>(k_NumIkHandles, Allocator.Persistent); m_FromIkRotations = new NativeArray <quaternion>(k_NumIkHandles, Allocator.Persistent); for (var i = 0; i < numBones; i++) { if (boneMask != null) { m_Bones[i] = animator.BindStreamTransform(activeBones[i]); } else { m_Bones[i] = animator.BindStreamTransform(skeleton.bones[i]); } } }
public void BindAt(int index, Animator animator, Transform transform) { sceneHandles[index] = animator.BindSceneTransform(transform); streamHandles[index] = animator.BindStreamTransform(transform); }