pub fn nlerp(&mut self, a: &Quaternion, b: &Quaternion, t: f32) {
        unsafe {
            ffi::cogl_quaternion_nlerp(
                self.to_glib_none_mut().0,
                a.to_glib_none().0,
                b.to_glib_none().0,
                t,
            );
        }
    }
/// Performs a normalized linear interpolation between two quaternions.
/// That is it does a linear interpolation of the quaternion components
/// and then normalizes the result. This will follow the shortest arc
/// between the two orientations (just like the `slerp` function) but
/// will not progress at a constant speed. Unlike `slerp` nlerp is
/// commutative which is useful if you are blending animations
/// together. (I.e. nlerp (tmp, a, b) followed by nlerp (result, tmp,
/// d) is the same as nlerp (tmp, a, d) followed by nlerp (result, tmp,
/// b)). Finally nlerp is cheaper than slerp so it can be a good choice
/// if you don't need the constant speed property of the `slerp` function.
///
/// Notable properties:
/// `<itemizedlist>`
/// `<listitem>`
/// commutative: Yes
/// `</listitem>`
/// `<listitem>`
/// constant velocity: No
/// `</listitem>`
/// `<listitem>`
/// torque minimal (travels along the surface of the 4-sphere): Yes
/// `</listitem>`
/// `<listitem>`
/// faster than `Quaternion::slerp`
/// `</listitem>`
/// `</itemizedlist>`
/// ## `a`
/// The first `Quaternion`
/// ## `b`
/// The second `Quaternion`
/// ## `t`
/// The factor in the range [0,1] used to interpolate between
/// quaterion `a` and `b`.
Performs a normalized linear interpolation between two quaternions.
That is it does a linear interpolation of the quaternion components
and then normalizes the result. This will follow the shortest arc
between the two orientations (just like the `slerp` function) but
will not progress at a constant speed. Unlike `slerp` nlerp is
commutative which is useful if you are blending animations
together.  followed by nlerp (result, tmp,
d) is the same as nlerp (tmp, a, d) followed by nlerp (result, tmp,
b)). Finally nlerp is cheaper than slerp so it can be a good choice
if you don't need the constant speed property of the `slerp` function.


Performs a normalized linear interpolation between two quaternions . That is it does a linear interpolation of the quaternion components and then normalizes the result . This will follow the shortest arc between the two orientations ( just like the ` slerp ` function ) but will not progress at a constant speed . Unlike ` slerp ` nlerp is commutative which is useful if you are blending animations together . followed by nlerp ( result tmp d ) is the same as nlerp ( tmp a d ) followed by nlerp ( result tmp b )) . Finally nlerp is cheaper than slerp so it can be a good choice if you don ' t need the constant speed property of the ` slerp ` function .
pub fn nlerp(&mut self, a: &Quaternion, b: &Quaternion, t: f32) {
        unsafe {
            ffi::cogl_quaternion_nlerp(
                self.to_glib_none_mut().0,
                a.to_glib_none().0,
                b.to_glib_none().0,
                t,
            );
        }
    }
pub fn nlerp ( & mut self , a : & Quaternion , b : & Quaternion , t : f32 ) { unsafe { ffi :: cogl_quaternion_nlerp ( self . to_glib_none_mut ( ) . 0 , a . to_glib_none ( ) . 0 , b . to_glib_none ( ) . 0 , t , ) ; } }
Performs a normalized linear interpolation between two quaternions.
Performs a normalized linear interpolation between two quaternions .
&mut self
a
&Quaternion
b
&Quaternion
t
f32
&mut self
a
&Quaternion
b
&Quaternion
t
f32
`a`
The first `Quaternion`
The first ` Quaternion `
`b`
The second `Quaternion`
The second ` Quaternion `
`t`
The factor in the range [0,1] used to interpolate between
quaterion `a` and `b`.
The factor in the range [ 0 1 ] used to interpolate between quaterion ` a ` and ` b ` .