[−][src]Trait ultraviolet::interp::Slerp
Spherical-linear interpolation.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
Required methods
fn slerp(&self, end: Self, t: T) -> Self
Implementors
impl Slerp<f32> for Bivec2[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Bivec3[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Rotor2[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Rotor3[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Vec2[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Vec3[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32> for Vec4[src]
fn slerp(&self, end: Self, t: f32) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Bivec2x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Bivec3x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Rotor2x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Rotor3x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Vec2x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Vec3x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x4> for Vec4x4[src]
fn slerp(&self, end: Self, t: f32x4) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Bivec2x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Bivec3x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Rotor2x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Rotor3x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Vec2x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Vec3x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!
impl Slerp<f32x8> for Vec4x8[src]
fn slerp(&self, end: Self, t: f32x8) -> Self[src]
Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.
self and end should both be normalized or something bad will happen!
The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.
Basically, interpolation that maintains a constant angular velocity
from one orientation on a unit hypersphere to another. This is sorta the "high quality" interpolation
for Rotors, and it can also be used to interpolate other things, one example being interpolation of
3d normal vectors.
Note that you should often normalize the result returned by this operation, when working with Rotors, etc!