public Quaternion CalculateChestRotation(HipsTarget hipsTarget, Quaternion baseRotation, Quaternion hipsRotation, Quaternion neckRotation) { float factor = hipsTarget.bendingFactor * 0.3F; Quaternion chestRotation = Quaternion.Slerp(neckRotation, hipsRotation, factor) * baseRotation; return(chestRotation); }
//float bendingFactor = 1; private void NewIK(HipsTarget hipsTarget, Vector3 neckBonePosition, Quaternion neckBoneTargetRotation) { Quaternion hipsTargetRotation = CalculateHipsRotation(hipsTarget, neckBonePosition); hipsTarget.hips.SetBoneRotation(hipsTargetRotation); hipsTargetRotation *= Quaternion.Inverse(hipsTarget.hips.bone.baseRotation); Quaternion spineTargetRotation = CalculateSpineRotation(hipsTarget, hipsTarget.spine.bone.baseRotation, hipsTargetRotation, neckBoneTargetRotation); hipsTarget.spine.SetBoneRotation(spineTargetRotation); Quaternion chestTargetRotation = CalculateChestRotation(hipsTarget, hipsTarget.chest.bone.baseRotation, hipsTargetRotation, neckBoneTargetRotation); hipsTarget.chest.SetBoneRotation(chestTargetRotation); if (hipsTarget.chest.bone.transform != null) { Vector3 chestTopPosition = hipsTarget.chest.bone.transform.position + hipsTarget.chest.bone.targetRotation * Vector3.up * hipsTarget.chest.bone.length; Vector3 spineVector = chestTopPosition - hipsTarget.hips.bone.transform.position; hipsTarget.hips.SetBonePosition(neckBonePosition - spineVector); } else if (hipsTarget.spine.bone.transform != null) { Vector3 spineTopPosition = hipsTarget.spine.bone.transform.position + hipsTarget.spine.bone.targetRotation * Vector3.up * hipsTarget.spine.bone.length; Vector3 spineVector = spineTopPosition - hipsTarget.hips.bone.transform.position; hipsTarget.hips.SetBonePosition(neckBonePosition - spineVector); } }
public void CharacterNoIK(HipsTarget hipsTarget, Vector3 neckBonePosition) { hipsTarget.hips.SetBoneRotation(hipsTarget.hips.target.transform.rotation); hipsTarget.spine.SetBoneRotation(hipsTarget.spine.target.transform.rotation); hipsTarget.chest.SetBoneRotation(hipsTarget.chest.target.transform.rotation); if (hipsTarget.humanoid.headTarget.head.target.confidence.position > 0) { if (hipsTarget.chest.bone.transform != null) { Vector3 chestTopPosition = hipsTarget.chest.bone.transform.position + hipsTarget.chest.bone.targetRotation * Vector3.up * hipsTarget.chest.bone.length; Vector3 spineVector = chestTopPosition - hipsTarget.hips.bone.transform.position; hipsTarget.hips.SetBonePosition(neckBonePosition - spineVector); } else if (hipsTarget.spine.bone.transform != null) { Vector3 spineTopPosition = hipsTarget.spine.bone.transform.position + hipsTarget.spine.bone.targetRotation * Vector3.up * hipsTarget.spine.bone.length; Vector3 spineVector = spineTopPosition - hipsTarget.hips.bone.transform.position; hipsTarget.hips.SetBonePosition(neckBonePosition - spineVector); } } else { Vector3 hipsPosition = hipsTarget.hips.target.transform.position + hipsTarget.hipsBaseHeight * Vector3.up; hipsTarget.hips.SetBonePosition(hipsPosition); } }
// Do not remove this, this is dynamically called from Target_Editor! // Changes the target transform used for this head target // Generates a new headtarget component, so parameters will be lost if transform is changed public static HipsTarget SetTarget(HumanoidControl humanoid, Transform targetTransform, bool isLeft) { HipsTarget currentHipsTarget = humanoid.hipsTarget; if (targetTransform == currentHipsTarget.transform) { return(currentHipsTarget); } GetDefaultBone(humanoid.targetsRig, ref targetTransform, HumanBodyBones.Hips); if (targetTransform == null) { return(currentHipsTarget); } HipsTarget hipsTarget = targetTransform.GetComponent <HipsTarget>(); if (hipsTarget == null) { hipsTarget = targetTransform.gameObject.AddComponent <HipsTarget>(); } hipsTarget.NewComponent(humanoid); hipsTarget.InitComponent(); return(hipsTarget); }
/// <summary>Animates the arm swing based on foot movements</summary> /// <returns>boolean indicating is the arms are swinging</returns> protected bool ArmSwingAnimation() { HumanoidControl humanoid = handTarget.humanoid; HipsTarget hipsTarget = humanoid.hipsTarget; Vector3 newPosition; float localFootZ; if (handTarget.isLeft) { localFootZ = hipsTarget.transform.InverseTransformPoint(humanoid.rightFootTarget.transform.position).z; Vector3 localFootPosition = Quaternion.Inverse(hipsTarget.hips.bone.targetRotation) * (humanoid.rightFootTarget.transform.position - humanoid.transform.position); newPosition = localFootPosition + foot2hand; handTarget.hand.target.transform.rotation = handTarget.forearm.bone.targetRotation; handTarget.hand.target.confidence.rotation = 0.2F; } else { localFootZ = hipsTarget.transform.InverseTransformPoint(humanoid.leftFootTarget.transform.position).z; Vector3 localFootPosition = Quaternion.Inverse(hipsTarget.hips.bone.targetRotation) * (humanoid.leftFootTarget.transform.position - humanoid.transform.position); newPosition = localFootPosition + foot2hand; handTarget.hand.target.transform.rotation = handTarget.forearm.bone.targetRotation; handTarget.hand.target.confidence.rotation = 0.2F; } float newY = Mathf.Abs(localFootZ / 4 + 0.02f) - humanoid.transform.position.y; handTarget.hand.target.transform.position = hipsTarget.transform.TransformPoint(new Vector3(newPosition.x, newY, newPosition.z)); handTarget.hand.target.confidence.position = 0.2F; return(true); }
private void SimpleIK(HipsTarget hipsTarget) { // This implementation ignores the spine and chest bones // Which results in a stiff spine Vector3 neckTargetPosition = hipsTarget.humanoid.headTarget.neck.target.transform.position; Quaternion neckRotation = hipsTarget.humanoid.headTarget.neck.bone.transform.rotation; Vector3 hipsTargetPosition = hipsTarget.hips.target.transform.position; Quaternion hipsTargetRotation = hipsTarget.hips.target.transform.rotation; Vector3 hipsBack = hipsTargetRotation * Vector3.back; Vector3 hipsUp = neckTargetPosition - hipsTargetPosition; if (hipsUp.sqrMagnitude <= 0.0001F) { hipsUp = hipsTarget.humanoid.up; } Quaternion spineRotation = Quaternion.LookRotation(hipsUp, hipsBack) * Quaternion.Euler(90, 0, 0); Quaternion hipsRotation = spineRotation; /** hipsTarget.spine2HipsRotation;*/ hipsTarget.hips.SetBoneRotation(hipsRotation); Vector3 spineVector = spineRotation * Vector3.up * hipsTarget.torsoLength; hipsTarget.hips.SetBonePosition(hipsTarget.humanoid.headTarget.neck.target.transform.position - spineVector); hipsTarget.humanoid.headTarget.neck.bone.transform.rotation = neckRotation; }
public void InitController(SerializedProperty sensorProp, HipsTarget hipsTarget) { if (sensorProp == null) { return; } Init(hipsTarget); SerializedProperty sensorTransformProp = sensorProp.FindPropertyRelative("sensorTransform"); sensorTransformProp.objectReferenceValue = sensorTransform; SerializedProperty targetProp = sensorProp.FindPropertyRelative("target"); targetProp.objectReferenceValue = target; if (!tracker.enabled || !enabled) { return; } CheckSensorTransform(); sensorTransformProp.objectReferenceValue = sensorTransform; ShowSensor(hipsTarget.humanoid.showRealObjects && hipsTarget.showRealObjects); SerializedProperty sensor2TargetPositionProp = sensorProp.FindPropertyRelative("sensor2TargetPosition"); sensor2TargetPositionProp.vector3Value = sensor2TargetPosition; SerializedProperty sensor2TargetRotationProp = sensorProp.FindPropertyRelative("sensor2TargetRotation"); sensor2TargetRotationProp.quaternionValue = sensor2TargetRotation; }
public override void Init(HipsTarget _hipsTarget) { base.Init(_hipsTarget); #if hSTEAMVR tracker = hipsTarget.humanoid.steam; #elif hOPENVR tracker = hipsTarget.humanoid.openVR; #endif }
public void Start(HumanoidControl _humanoid, HipsTarget _target) { hipsTarget = _target; if (hipsTarget.hips.bone.transform == null) { return; } }
public Quaternion CalculateSpineRotation(HipsTarget hipsTarget, Quaternion baseRotation, Quaternion hipsRotation, Quaternion neckRotation) { float factor = hipsTarget.chest.bone.transform != null ? 0.4F : 0.3F; factor *= hipsTarget.bendingFactor; Quaternion spineRotation = Quaternion.Slerp(neckRotation, hipsRotation, factor) * baseRotation; return(spineRotation); }
private void InitConfiguration(HipsTarget target) { if (target.humanoid.avatarRig == null) { return; } InitChestConfiguration(target.chest); InitSpineConfiguration(target.spine); InitHipsConfiguration(target.hips); }
private void FeetOffGround() { HipsTarget hipsTarget = footTarget.humanoid.hipsTarget; footTarget.foot.target.transform.rotation = Quaternion.AngleAxis(hipsTarget.hips.target.transform.eulerAngles.y, footTarget.humanoid.up) * Quaternion.AngleAxis(30, Vector3.right); float legLength = footTarget.upperLeg.bone.length + footTarget.lowerLeg.bone.length; Vector3 localFootPosition = new Vector3(footTarget.isLeft ? -footSeparation : footSeparation, -legLength, 0); footTarget.foot.target.transform.position = hipsTarget.hips.target.transform.position + hipsTarget.hips.target.transform.rotation * localFootPosition; }
private void UpdateBones(HipsTarget target) { if (target.humanoid.avatarRig == null) { return; } UpdateHipsBones(target.hips); UpdateSpineBones(target.spine); UpdateChestBones(target.chest); }
public TargetProps(SerializedObject serializedObject, UnityTorsoSensor _sensor, HipsTarget _hipsTarget, string unitySensorName) { enabledProp = serializedObject.FindProperty(unitySensorName + ".enabled"); sensorTransformProp = serializedObject.FindProperty(unitySensorName + ".sensorTransform"); sensor2TargetPositionProp = serializedObject.FindProperty(unitySensorName + ".sensor2TargetPosition"); sensor2TargetRotationProp = serializedObject.FindProperty(unitySensorName + ".sensor2TargetRotation"); hipsTarget = _hipsTarget; sensor = _sensor; sensor.Init(hipsTarget); }
private static void CheckSensorComponent(HipsTarget hipsTarget) { if (hipsTarget.viveTracker.sensorTransform == null) { return; } ViveTrackerComponent sensorComponent = hipsTarget.viveTracker.sensorTransform.GetComponent <ViveTrackerComponent>(); if (sensorComponent == null) { sensorComponent = hipsTarget.viveTracker.sensorTransform.gameObject.AddComponent <ViveTrackerComponent>(); } }
protected static void CheckRigidbodyComponent(HipsTarget hipsTarget) { if (hipsTarget.optitrack.sensorTransform == null) { return; } OptitrackRigidbodyComponent sensorComponent = hipsTarget.optitrack.sensorTransform.GetComponent <OptitrackRigidbodyComponent>(); if (sensorComponent == null) { hipsTarget.optitrack.sensorTransform.gameObject.AddComponent <OptitrackRigidbodyComponent>(); } }
private static Quaternion NaturalShoulderOrientation(HandTarget handTarget, ref Quaternion lastLocalShoulderRotation) { if (handTarget.shoulder.target.confidence.rotation > 0.5F) { return(handTarget.shoulder.target.transform.rotation); } HipsTarget hipsTarget = handTarget.humanoid.hipsTarget; Quaternion torsoRotation; if (hipsTarget.chest.bone.transform != null) { torsoRotation = hipsTarget.chest.bone.targetRotation; } else { torsoRotation = Quaternion.LookRotation(hipsTarget.hips.bone.targetRotation * Vector3.forward, handTarget.humanoid.up); } Vector3 upperArmBasePosition = handTarget.shoulder.bone.transform.position + torsoRotation * handTarget.shoulder.target.baseRotation * handTarget.outward * handTarget.shoulder.bone.length; float upperArm2HandDistance = Vector3.Distance(upperArmBasePosition, handTarget.hand.target.transform.position); float armLength = handTarget.upperArm.bone.length + handTarget.forearm.bone.length; float distanceToTarget = upperArm2HandDistance - armLength - 0.03F; Quaternion shoulderRotation = handTarget.shoulder.bone.targetRotation; if (distanceToTarget > 0) { // we need to use the shoulder now to get closer to the target Vector3 targetDirection = handTarget.hand.bone.transform.position - handTarget.shoulder.bone.transform.position; Quaternion toTargetRotation = Quaternion.LookRotation(targetDirection) * Quaternion.AngleAxis(handTarget.isLeft ? 90 : -90, Vector3.up); shoulderRotation = Quaternion.Slerp(torsoRotation * handTarget.shoulder.bone.baseRotation, toTargetRotation, distanceToTarget * 4); } else if (distanceToTarget < 0) { shoulderRotation = Quaternion.Slerp(shoulderRotation, torsoRotation * handTarget.shoulder.bone.baseRotation, -distanceToTarget * 10); } if (handTarget.shoulder.bone.jointLimitations) { shoulderRotation = LimitAngle(handTarget.shoulder, ref lastLocalShoulderRotation, shoulderRotation); } return(shoulderRotation); }
private Quaternion CalculateHipsRotation(HipsTarget hipsTarget, Vector3 neckBonePosition) { // hips target has only effect on the Y rotation (via hipsForward) // the effect of the other movements and rotations of hips on the movements of the spine is very limited // for now, we will not take these movements into account Vector3 torsoUp = neckBonePosition - hipsTarget.hips.target.transform.position; Quaternion spine2HipsRotation = Rotations.Rotate(hipsTarget.spine2HipsRotation, hipsTarget.hips.target.transform.rotation); Vector3 hipsUp = spine2HipsRotation * torsoUp; Vector3 hipsForward = hipsTarget.hips.target.transform.forward; Quaternion hipsRotation = Quaternion.LookRotation(hipsUp, -hipsForward) * Quaternion.AngleAxis(90, Vector3.right); return(hipsRotation); }
private void ConfigurationInspector(HipsTarget hipsTarget) { hipsTarget.RetrieveBones(); showConfiguration = EditorGUILayout.Foldout(showConfiguration, "Configuration", true); if (showConfiguration) { EditorGUI.indentLevel++; ChestConfigurationInspector(ref hipsTarget.chest); SpineConfigurationInspector(ref hipsTarget.spine); HipsConfigurationInspector(ref hipsTarget.hips); EditorGUI.indentLevel--; } }
public Vector3 CalculateElbowAxis(HandTarget handTarget, Vector3 handPosition, Quaternion handRotation) { HipsTarget hipsTarget = handTarget.humanoid.hipsTarget; Quaternion hipsOrientation = Quaternion.LookRotation(hipsTarget.hips.target.transform.forward, handTarget.humanoid.up); Vector3 elbowAxis = Quaternion.Inverse(hipsOrientation) * handRotation * Vector3.up; if (handTarget.isLeft) { elbowAxis = (elbowAxis + (Vector3.left + Vector3.up).normalized) / 2; } else { elbowAxis = (elbowAxis + (Vector3.right + Vector3.up).normalized) / 2; } float elbowAxisY = elbowAxis.y; float elbowAxisZ = elbowAxis.z; Vector3 dHandUpper = Quaternion.Inverse(hipsOrientation) * (handPosition - handTarget.upperArm.bone.transform.position); if (!handTarget.isLeft) { if (dHandUpper.x < 0) { elbowAxisZ -= dHandUpper.x * 10; } } else { if (dHandUpper.x > 0) { elbowAxisZ += dHandUpper.x * 10; } } if (dHandUpper.y > 0) { elbowAxisY += dHandUpper.y * 10; } elbowAxisY = Mathf.Clamp(elbowAxisY, 0.01F, 1); elbowAxisZ = Mathf.Clamp(elbowAxisZ, -0.1F, 0.1F); elbowAxis = hipsOrientation * new Vector3(elbowAxis.x, elbowAxisY, elbowAxisZ); return(elbowAxis); }
public static void Update(HipsTarget hipsTarget) { if (hipsTarget.hips.bone.transform == null || !hipsTarget.humanoid.calculateBodyPose) { return; } //if (Mathf.Abs(hipsTarget.hipsBaseHeight) < 0.00001F) // hipsTarget.hipsBaseHeight = hipsTarget.hips.bone.transform.position.y - hipsTarget.hips.target.transform.position.y; HeadTarget headTarget = hipsTarget.humanoid.headTarget; HumanoidTarget.BoneTransform neckBone = (headTarget.neck.bone.transform != null) ? headTarget.neck.bone : headTarget.head.bone; Vector3 neckPosition = neckBone.transform.position; Quaternion neckRotation = neckBone.transform.rotation; Quaternion neckTargetRotation = neckRotation * neckBone.toTargetRotation * Quaternion.Inverse(headTarget.neck.bone.baseRotation); if (hipsTarget.humanoid.targetsRig.runtimeAnimatorController != null && hipsTarget.hips.target.confidence.position == 0) { hipsTarget.torsoMovements.CharacterNoIK(hipsTarget, neckPosition); } else { if (hipsTarget.hips.target.confidence.rotation > 0.5F && hipsTarget.spine.target.confidence.rotation > 0.5F && hipsTarget.chest.target.confidence.rotation > 0.5F) { hipsTarget.torsoMovements.CharacterNoIK(hipsTarget, neckPosition); } else if (!hipsTarget.newSpineIK) { hipsTarget.torsoMovements.NewIK(hipsTarget, neckPosition, neckTargetRotation); } else { hipsTarget.torsoMovements.SimpleIK(hipsTarget); } if (Application.isPlaying) { hipsTarget.torsoMovements.breathing.Update(); } neckBone.transform.position = neckPosition; neckBone.transform.rotation = neckRotation; } }
private void SensorInspectors(HipsTarget hipsTarget) { showSensors = EditorGUILayout.Foldout(showSensors, "Controllers", true); if (showSensors) { EditorGUI.indentLevel++; foreach (TargetProps props in allProps) { props.Inspector(); } if (humanoid.animatorEnabled) { hipsTarget.animator.enabled = EditorGUILayout.ToggleLeft("Procedural Animation", hipsTarget.animator.enabled, GUILayout.MinWidth(80)); } EditorGUI.indentLevel--; } }
public void OnEnable() { hipsTarget = (HipsTarget)target; if (hipsTarget.humanoid == null) { hipsTarget.humanoid = GetHumanoid(hipsTarget); } humanoid = hipsTarget.humanoid; if (humanoid == null) { return; } InitEditors(); hipsTarget.InitSensors(); InitConfiguration(hipsTarget); InitSettings(); }
/// <summary> /// Checks whether the humanoid has an HipsTarget /// and adds one if none has been found /// </summary> /// <param name="humanoid">The humanoid to check</param> public static void DetermineTarget(HumanoidControl humanoid) { HipsTarget hipsTarget = humanoid.hipsTarget; if (hipsTarget == null) { Transform hipsTargetTransform = humanoid.targetsRig.GetBoneTransform(HumanBodyBones.Hips); if (hipsTargetTransform == null) { Debug.LogError("Could not find hips bone in targets rig"); return; } hipsTarget = hipsTargetTransform.GetComponent <HipsTarget>(); if (hipsTarget == null) { hipsTarget = hipsTargetTransform.gameObject.AddComponent <HipsTarget>(); hipsTarget.humanoid = humanoid; } } humanoid.hipsTarget = hipsTarget; }
// Do not remove this, this is dynamically called from Target_Editor! public static HipsTarget CreateTarget(HumanoidTarget oldTarget) { GameObject targetObject = new GameObject("Hips Target"); Transform targetTransform = targetObject.transform; HumanoidControl humanoid = oldTarget.humanoid; targetTransform.parent = oldTarget.humanoid.transform; targetTransform.position = oldTarget.transform.position; targetTransform.rotation = oldTarget.transform.rotation; HipsTarget hipsTarget = targetTransform.gameObject.AddComponent <HipsTarget>(); hipsTarget.humanoid = humanoid; humanoid.hipsTarget = hipsTarget; hipsTarget.RetrieveBones(); hipsTarget.InitAvatar(); hipsTarget.MatchTargetsToAvatar(); //hipsTarget.NewComponent(oldTarget.humanoid); //hipsTarget.InitComponent(); return(hipsTarget); }
public TargetedHipsBone(HipsTarget hipsTarget) { this.hipsTarget = hipsTarget; boneId = Bone.Hips; }
public TargetedSpineBone(HipsTarget hipsTarget) { this.hipsTarget = hipsTarget; boneId = Bone.Spine; }
public TargetedChestBone(HipsTarget hipsTarget) { this.hipsTarget = hipsTarget; boneId = Bone.Chest; }
public override void Init(HipsTarget _hipsTarget) { base.Init(_hipsTarget); optitrackTracker = hipsTarget.humanoid.optitrack; tracker = optitrackTracker; }
public HipsTargetProps(SerializedObject serializedObject, HipsTarget hipsTarget) : base(serializedObject, hipsTarget.kinect, hipsTarget, "kinect") { }