Beispiel #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="time"></param>
        /// <param name="quatA"></param>
        /// <param name="quatB"></param>
        /// <param name="useShortestPath"></param>
        /// <returns></returns>
        public static OpenTK.Quaternion Slerp(Real time, OpenTK.Quaternion quatA, OpenTK.Quaternion quatB, bool useShortestPath)
        {
            Real cos = quatA.Dot(quatB);

            Real angle = (Real)Utility.ACos(cos);

            if (Utility.Abs(angle) < EPSILON)
            {
                return(quatA);
            }

            Real sin        = Utility.Sin(angle);
            Real inverseSin = 1.0f / sin;
            Real coeff0     = Utility.Sin((1.0f - time) * angle) * inverseSin;
            Real coeff1     = Utility.Sin(time * angle) * inverseSin;

            OpenTK.Quaternion result;

            if (cos < 0.0f && useShortestPath)
            {
                coeff0 = -coeff0;
                // taking the complement requires renormalisation
                OpenTK.Quaternion t = coeff0 * quatA + coeff1 * quatB;
                t.Normalize();
                result = t;
            }
            else
            {
                result = (coeff0 * quatA + coeff1 * quatB);
            }

            return(result);
        }
Beispiel #2
0
        /// <param name="shortestPath"></param>
        public static OpenTK.Quaternion Nlerp(Real fT, OpenTK.Quaternion rkP, OpenTK.Quaternion rkQ, bool shortestPath)
        {
            OpenTK.Quaternion result;
            Real fCos = rkP.Dot(rkQ);

            if (fCos < 0.0f && shortestPath)
            {
                result = rkP + fT * ((OpenTK.Quaternion.Invert(rkQ)) - rkP);
            }
            else
            {
                result = rkP + fT * (rkQ - rkP);
            }
            result.Normalize();
            return(result);
        }