public Quaternion LimitSwing(Quaternion rotation)
        {
            if (this.axis == Vector3.zero)
            {
                return(rotation);
            }
            if (rotation == Quaternion.identity)
            {
                return(rotation);
            }
            Vector3 vector = rotation * this.axis;
            float   num    = RotationLimit.GetOrthogonalAngle(vector, base.secondaryAxis, this.axis);
            float   num2   = Vector3.Dot(vector, base.crossAxis);

            if (num2 < 0f)
            {
                num = 180f + (180f - num);
            }
            float      maxDegreesDelta = this.spline.Evaluate(num);
            Quaternion to        = Quaternion.FromToRotation(this.axis, vector);
            Quaternion rotation2 = Quaternion.RotateTowards(Quaternion.identity, to, maxDegreesDelta);
            Quaternion lhs       = Quaternion.FromToRotation(vector, rotation2 * this.axis);

            return(lhs * rotation);
        }
Exemple #2
0
 protected override Quaternion LimitRotation(Quaternion rotation)
 {
     if (this.reachCones.Length == 0)
     {
         this.Start();
     }
     return(RotationLimit.LimitTwist(this.LimitSwing(rotation), this.axis, base.secondaryAxis, this.twistLimit));
 }
Exemple #3
0
			private RotationLimit rotationLimit; // The Rotation Limit component

			// Aim this part at the target
			public void AimAt(Transform target) {
				transform.LookAt(target.position, transform.up);

				// Finding the Rotation Limit
				if (rotationLimit == null) {
					rotationLimit = transform.GetComponent<RotationLimit>();
					rotationLimit.Disable();
				}

				// Apply rotation limits
				rotationLimit.Apply();
			}
Exemple #4
0
        private Quaternion LimitHinge(Quaternion rotation)
        {
            if (this.min == 0f && this.max == 0f && this.useLimits)
            {
                return(Quaternion.AngleAxis(0f, this.axis));
            }
            Quaternion quaternion = RotationLimit.Limit1DOF(rotation, this.axis);

            if (!this.useLimits)
            {
                return(quaternion);
            }
            Quaternion quaternion2 = quaternion * Quaternion.Inverse(this.lastRotation);
            float      num         = Quaternion.Angle(Quaternion.identity, quaternion2);
            Vector3    vector      = new Vector3(this.axis.z, this.axis.x, this.axis.y);
            Vector3    rhs         = Vector3.Cross(vector, this.axis);

            if (Vector3.Dot(quaternion2 * vector, rhs) > 0f)
            {
                num = -num;
            }
            this.lastAngle = Mathf.Clamp(this.lastAngle + num, this.min, this.max);
            return(Quaternion.AngleAxis(this.lastAngle, this.axis));
        }
        protected override Quaternion LimitRotation(Quaternion rotation)
        {
            Quaternion rotation2 = this.LimitSwing(rotation);

            return(RotationLimit.LimitTwist(rotation2, this.axis, base.secondaryAxis, this.twistLimit));
        }
        protected override void OnUpdate()
        {
            if (this.axis == Vector3.zero)
            {
                if (!Warning.logged)
                {
                    base.LogWarning("IKSolverAim axis is Vector3.zero.");
                }
                return;
            }
            if (this.poleAxis == Vector3.zero && this.poleWeight > 0f)
            {
                if (!Warning.logged)
                {
                    base.LogWarning("IKSolverAim poleAxis is Vector3.zero.");
                }
                return;
            }
            if (this.target != null)
            {
                this.IKPosition = this.target.position;
            }
            if (this.poleTarget != null)
            {
                this.polePosition = this.poleTarget.position;
            }
            if (this.IKPositionWeight <= 0f)
            {
                return;
            }
            this.IKPositionWeight = Mathf.Clamp(this.IKPositionWeight, 0f, 1f);
            if (this.transform != this.lastTransform)
            {
                this.transformLimit = this.transform.GetComponent <RotationLimit>();
                if (this.transformLimit != null)
                {
                    this.transformLimit.enabled = false;
                }
                this.lastTransform = this.transform;
            }
            if (this.transformLimit != null)
            {
                this.transformLimit.Apply();
            }
            if (this.transform == null)
            {
                if (!Warning.logged)
                {
                    base.LogWarning("Aim Transform unassigned in Aim IK solver. Please Assign a Transform (lineal descendant to the last bone in the spine) that you want to be aimed at IKPosition");
                }
                return;
            }
            this.clampWeight       = Mathf.Clamp(this.clampWeight, 0f, 1f);
            this.clampedIKPosition = this.GetClampedIKPosition();
            Vector3 b = this.clampedIKPosition - this.transform.position;

            b = Vector3.Slerp(this.transformAxis * b.magnitude, b, this.IKPositionWeight);
            this.clampedIKPosition = this.transform.position + b;
            for (int i = 0; i < this.maxIterations; i++)
            {
                if (i >= 1 && this.tolerance > 0f && this.GetAngle() < this.tolerance)
                {
                    break;
                }
                this.lastLocalDirection = this.localDirection;
                if (this.OnPreIteration != null)
                {
                    this.OnPreIteration(i);
                }
                this.Solve();
            }
            this.lastLocalDirection = this.localDirection;
        }
        protected override void OnUpdate()
        {
            if (axis == Vector3.zero) {
                if (!Warning.logged) LogWarning("IKSolverAim axis is Vector3.zero.");
                return;
            }

            // Clamping weights
            if (IKPositionWeight <= 0) return;
            IKPositionWeight = Mathf.Clamp(IKPositionWeight, 0f, 1f);

            // Rotation Limit on the Aim Transform
            if (transform != lastTransform) {
                transformLimit = transform.GetComponent<RotationLimit>();
                if (transformLimit != null) transformLimit.enabled = false;
                lastTransform = transform;
            }

            if (transformLimit != null) transformLimit.Apply();

            // In case transform becomes unassigned in runtime
            if (transform == null) {
                if (!Warning.logged) LogWarning("Aim Transform unassigned in Aim IK solver. Please Assign a Transform (lineal descendant to the last bone in the spine) that you want to be aimed at IKPosition");
                return;
            }

            clampWeight = Mathf.Clamp(clampWeight, 0f, 1f);
            clampedIKPosition = GetClampedIKPosition();

            Vector3 dir = clampedIKPosition - transform.position;
            dir = Vector3.Slerp(transformAxis * dir.magnitude, dir, IKPositionWeight);
            clampedIKPosition = transform.position + dir;

            // Iterating the solver
            for (int i = 0; i < maxIterations; i++) {

                // Optimizations
                if (i >= 1 && tolerance > 0 && GetAngle() < tolerance) break;

                lastLocalDirection = localDirection;

                Solve();
            }

            lastLocalDirection = localDirection;
        }
 protected override Quaternion LimitRotation(Quaternion rotation)
 {
     return RotationLimit.LimitTwist(this.LimitSwing(rotation), this.axis, base.secondaryAxis, this.twistLimit);
 }