Trait FloatExt 

pub trait FloatExt {
    // Required methods
    fn lerp(self, rhs: Self, s: Self) -> Self;
    fn inverse_lerp(a: Self, b: Self, v: Self) -> Self;
    fn remap(
        self,
        in_start: Self,
        in_end: Self,
        out_start: Self,
        out_end: Self,
    ) -> Self;
    fn fract_gl(self) -> Self;
    fn step(self, value: Self) -> Self;
    fn saturate(self) -> Self;
}

A trait for extending f32 and f64 with extra methods.

Required Methods

fn lerp(self, rhs: Self, s: Self) -> Self

Performs a linear interpolation between self and rhs based on the value s.

When s is 0, the result will be self. When s is 1, the result will be rhs. When s is outside of the range [0, 1], the result is linearly extrapolated.

fn inverse_lerp(a: Self, b: Self, v: Self) -> Self

Returns v normalized to the range [a, b].

When v is equal to a the result will be 0. When v is equal to b will be 1.

When v is outside of the range [a, b], the result is linearly extrapolated.

a and b must not be equal, otherwise the result will be either infinite or NAN.

fn remap( self, in_start: Self, in_end: Self, out_start: Self, out_end: Self, ) -> Self

Remap self from the input range to the output range.

When self is equal to in_start this returns out_start. When self is equal to in_end this returns out_end.

When self is outside of the range [in_start, in_end], the result is linearly extrapolated.

in_start and in_end must not be equal, otherwise the result will be either infinite or NAN.

fn fract_gl(self) -> Self

Returns the fractional part of the input as self - self.floor().

Note that this differs from the Rust implementation of fract which returns self - self.trunc().

Note that this is fast but not precise for large numbers.

fn step(self, value: Self) -> Self

Returns 0.0 if value < self and 1.0 otherwise.

Similar to glsl’s step(edge, x), which translates into edge.step(x)

fn saturate(self) -> Self

Returns self clamped within the range [0.0, 1.0]

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl FloatExt for f32

fn lerp(self, rhs: Self, t: Self) -> Self

fn inverse_lerp(a: Self, b: Self, v: Self) -> Self

fn remap( self, in_start: Self, in_end: Self, out_start: Self, out_end: Self, ) -> Self

fn fract_gl(self) -> Self

fn step(self, value: Self) -> Self

fn saturate(self) -> Self

impl FloatExt for f64

fn lerp(self, rhs: Self, t: Self) -> Self

fn inverse_lerp(a: Self, b: Self, v: Self) -> Self

fn remap( self, in_start: Self, in_end: Self, out_start: Self, out_end: Self, ) -> Self

fn fract_gl(self) -> Self

fn step(self, value: Self) -> Self

fn saturate(self) -> Self

Implementors