public void CalculateFromNormTracking(ArmMovements leftArm, ArmMovements rightArm, Transform leftHandTarget, Transform rightHandTarget)
{
if (leftArm != null)
{
leftArm.CalculateFromNormTracking(leftHandTarget);
}
if (rightArm != null)
{
rightArm.CalculateFromNormTracking(rightHandTarget);
}
fromNormCalculated = true;
}
public void CalculateFromNormTPose(ArmMovements leftArm, ArmMovements rightArm)
{
if (leftArm != null)
{
leftArm.CalculateFromNormTPose();
}
if (rightArm != null)
{
rightArm.CalculateFromNormTPose();
}
fromNormCalculated = true;
}
public float BendAngle(Vector3 torsoTarget, ArmMovements arm)
{
float baseAngle = Vector3.Angle(spineStartOrientation, torsoTarget - spine.position);
float dSpine2Target = Vector3.Distance(spine.position, torsoTarget);
float spineAngle = Mathf.Acos((dSpine2Target * dSpine2Target + length * length - arm.length * arm.length) / (2 * dSpine2Target * length)) * Mathf.Rad2Deg;
if (float.IsNaN(spineAngle))
{
spineAngle = 0;
}
return(Mathf.Min(baseAngle - spineAngle, IVR_BodyMovements.maxHipAngle));
}
public bool IsInTPose(ArmMovements leftArm, ArmMovements rightArm)
{
float d;
Ray hand2hand = new Ray(leftArm.hand.position, rightArm.hand.position - leftArm.hand.position);
// All lined up?
d = DistanceToRay(hand2hand, leftArm.forearm.position);
if (d > 0.1f)
{
return(false);
}
d = DistanceToRay(hand2hand, leftArm.upperArm.position);
if (d > 0.1f)
{
return(false);
}
d = DistanceToRay(hand2hand, rightArm.upperArm.position);
if (d > 0.1f)
{
return(false);
}
d = DistanceToRay(hand2hand, rightArm.forearm.position);
if (d > 0.1f)
{
return(false);
}
// Arms stretched?
d = Vector3.Distance(leftArm.upperArm.position, leftArm.hand.position);
if (d < leftArm.length - 0.1f)
{
return(false);
}
d = Vector3.Distance(rightArm.upperArm.position, rightArm.hand.position);
if (d < rightArm.length - 0.1f)
{
return(false);
}
Debug.Log("Arms are in T-pose");
return(true);
}
public void StartMovements()
{
ivr = this.GetComponent <InstantVR>();
headTarget = ivr.headTarget;
leftHandTarget = ivr.leftHandTarget;
rightHandTarget = ivr.rightHandTarget;
hipTarget = ivr.hipTarget;
leftFootTarget = ivr.leftFootTarget;
rightFootTarget = ivr.rightFootTarget;
animator = ivr.transform.GetComponentInChildren <Animator>();
if (animator == null)
{
StopMovements();
}
else
{
characterRigidbody = animator.GetComponent <Rigidbody>();
if (characterRigidbody != null)
{
characterTransform = characterRigidbody.GetComponent <Transform>();
}
if (leftArm == null)
{
leftArm = new ArmMovements(ivr, ArmMovements.BodySide.Left, this);
}
leftArm.Initialize(ivr, ArmMovements.BodySide.Left, this);
if (rightArm == null)
{
rightArm = new ArmMovements(ivr, ArmMovements.BodySide.Right, this);
}
rightArm.Initialize(ivr, ArmMovements.BodySide.Right, this);
Transform neck, spine, hips;
neck = animator.GetBoneTransform(HumanBodyBones.Neck);
if (neck == null)
{
neck = animator.GetBoneTransform(HumanBodyBones.Head);
if (neck == null)
{
StopMovements();
return;
}
}
spine = animator.GetBoneTransform(HumanBodyBones.Spine);
hips = animator.GetBoneTransform(HumanBodyBones.Hips);
torso = new Torso(neck, spine, hips, hipTarget, headTarget, rightArm);
leftLeg = new LegMovements(ArmMovements.BodySide.Left, animator, hipTarget);
rightLeg = new LegMovements(ArmMovements.BodySide.Right, animator, hipTarget);
if (rightHandTarget != null)
{
rightHandOTarget = rightHandTarget;
}
if (leftHandTarget != null)
{
leftHandOTarget = leftHandTarget;
}
if (headTarget == null && enableTorso)
{
GameObject neckTargetGO = new GameObject("Neck_Target");
headTarget = neckTargetGO.transform;
headTarget.parent = characterTransform;
headTarget.position = torso.neck.position;
headTarget.rotation = characterTransform.rotation;
}
if (enableLegs)
{
if (rightFootTarget == null)
{
GameObject rightFootTargetGO = new GameObject("Foot_R_Target");
rightFootTarget = rightFootTargetGO.transform;
rightFootTarget.parent = characterTransform;
rightFootTarget.position = rightLeg.foot.position;
rightFootTarget.rotation = characterTransform.rotation;
}
if (leftFootTarget == null)
{
GameObject leftFootTargetGO = new GameObject("Foot_L_Target");
leftFootTarget = leftFootTargetGO.transform;
leftFootTarget.parent = characterTransform;
leftFootTarget.position = leftLeg.foot.position;
leftFootTarget.rotation = characterTransform.rotation;
}
}
if (IsInTPose(leftArm, rightArm))
{
CalculateFromNormTPose(leftArm, rightArm);
}
else
{
CalculateFromNormTracking(leftArm, rightArm, leftHandTarget, rightHandTarget);
}
if (leftLeg.IsInTPose())
{
leftLeg.FromNormTPose();
}
else
{
leftLeg.FromNormTracking(leftFootTarget);
}
if (rightLeg.IsInTPose())
{
rightLeg.FromNormTPose();
}
else
{
rightLeg.FromNormTracking(rightFootTarget);
}
}
}
public bool AutoVertical(Transform rightHandOTarget, Transform rightHandTarget, ArmMovements rightArm, Transform leftHandOTarget, Transform leftHandTarget, ArmMovements leftArm, Transform neckTarget)
{
Vector3 neckDelta = Vector3.zero;
Vector3 leftToTarget = leftHandOTarget.position - leftArm.upperArmStartPosition;
Vector3 rightToTarget = rightHandOTarget.position - rightArm.upperArmStartPosition;
float leftOver = leftToTarget.magnitude - leftArm.length;
float rightOver = rightToTarget.magnitude - rightArm.length;
if (leftOver > 0)
{
if (rightOver > leftOver)
{
neckDelta = rightToTarget.normalized * rightOver;
}
else
{
neckDelta = leftToTarget.normalized * leftOver;
}
}
else if (rightOver > 0)
{
neckDelta = rightToTarget.normalized * rightOver;
}
neckTarget.position = neckStartPosition + new Vector3(0, neckDelta.y, 0);
float dY = neckTarget.transform.position.y - neck.position.y;
if (hips.position.y + dY < hipStartPosition.y)
{
hips.Translate(0, dY, 0, Space.World);
}
else if (hips.position.y + dY > hipStartPosition.y)
{
hips.position = new Vector3(hips.position.x, hipStartPosition.y, hips.position.z);
}
rightArm.Calculate(rightHandTarget);
leftArm.Calculate(leftHandTarget);
return(hips.position.y < hipStartPosition.y);
}
public float AutoHorizontal(Transform rightHandOTarget, Transform rightHandTarget, ArmMovements rightArm, Transform leftHandOTarget, Transform leftHandTarget, ArmMovements leftArm, Transform neckTarget)
{
float bendAngle = 0;
Vector3 torsoTarget = Vector3.zero;
Vector3 dShoulderNeck = (leftArm.upperArm.position - rightArm.upperArm.position) / 2;
Vector3 leftToTarget = leftHandOTarget.position - leftArm.upperArmStartPosition;
Vector3 rightToTarget = rightHandOTarget.position - rightArm.upperArmStartPosition;
float leftOver = leftToTarget.magnitude - leftArm.length;
float rightOver = rightToTarget.magnitude - rightArm.length;
if (leftOver > 0)
{
if (rightOver > 0)
{
Vector3 torsoTargetR = rightHandOTarget.position + dShoulderNeck;
Vector3 torsoTargetL = leftHandOTarget.position - dShoulderNeck;
float bendAngleR = BendAngle(torsoTargetR, rightArm);
float bendAngleL = BendAngle(torsoTargetL, leftArm);
if (bendAngleR > bendAngleL)
{
torsoTarget = torsoTargetR;
}
else
{
torsoTarget = torsoTargetL;
}
}
else
{
torsoTarget = leftHandOTarget.position - dShoulderNeck;
}
}
else if (rightOver > 0)
{
torsoTarget = rightHandOTarget.position + dShoulderNeck;
}
if (rightOver > 0 || leftOver > 0)
{
bendAngle = BendAngle(torsoTarget, rightArm); // arm should be left or right
spine.rotation = spineStartRotation * Quaternion.AngleAxis(bendAngle, spineAxis);
}
else
{
spine.rotation = spineStartRotation;
}
rightArm.Calculate(rightHandTarget);
leftArm.Calculate(leftHandTarget);
return(bendAngle);
}
public Torso(Transform neck, Transform spine, Transform hips, Transform hipTarget, Transform neckTarget, ArmMovements arm)
{
this.hipTarget = hipTarget;
this.neck = neck;
neckStartPosition = neck.position;
this.spine = spine;
spineStartRotation = spine.rotation;
spineStartOrientation = neck.position - spine.position;
this.hips = hips;
hipStartPosition = hips.position;
Vector3 neckAtUpperArm = new Vector3(neck.position.x, arm.upperArm.position.y, neck.position.z);
length = Vector3.Distance(spine.position, neckAtUpperArm);
if (neckTarget != null)
{
fromNormNeck = Quaternion.Inverse(Quaternion.LookRotation(neckTarget.forward)) * neck.rotation;
fromNormTorso = Quaternion.Inverse(Quaternion.LookRotation(neck.position - spine.position, hipTarget.forward)) * spine.rotation;
fromNormHips = Quaternion.Inverse(Quaternion.LookRotation(hipTarget.forward)) * hips.rotation;
}
userNeckTarget = (neckTarget != null);
spineAxis = spine.InverseTransformDirection(hipTarget.right);
}
