Struct kas_core::geom::Vec2

#[repr(C)]
pub struct Vec2(pub f32, pub f32);

2D vector

Usually used as either a coordinate or a difference of coordinates, but may have some other uses.

Vectors are partially ordered and support component-wise comparison via methods like lhs.lt(rhs). The PartialOrd trait is not implemented since it implements lhs ≤ rhs as lhs < rhs || lhs == rhs which is wrong for vectors (consider for lhs = (0, 1), rhs = (1, 0)).

Tuple Fields

0: f32

1: f32

Implementations

impl Vec2

pub const ZERO: Vec2 = _

Zero

pub const ONE: Vec2 = _

One

pub const NEG_INFINITY: Vec2 = _

Negative infinity

pub const INFINITY: Vec2 = _

Positive infinity

pub const NAN: Vec2 = _

Not a Number (NaN)

pub const fn splat(value: f32) -> Self

Constructs a new instance with each element initialized to value.

Examples found in repository

src/event/components.rs (line 83)

    fn step(&mut self, (decay_mul, decay_sub): (f32, f32)) -> Option<Offset> {
        if let Glide::Glide(start, v, rest) = self {
            let now = Instant::now();
            let dur = (now - *start).as_secs_f32();
            let d = *v * dur + *rest;
            let delta = Offset::conv_approx(d);
            let rest = d - Vec2::conv(delta);

            if v.abs().max_comp() >= 1.0 {
                let mut v = *v * decay_mul.powf(dur);
                v = v - v.abs().min(Vec2::splat(decay_sub * dur)) * v.sign();
                *self = Glide::Glide(now, v, rest);
                Some(delta)
            } else {
                *self = Glide::None;
                None
            }
        } else {
            None
        }
    }

pub fn min_comp(self) -> f32

Take the minimum component

pub fn max_comp(self) -> f32

Take the maximum component

Examples found in repository

src/event/manager/mgr_pub.rs (line 149)

    pub fn config_test_pan_thresh(&self, dist: Offset) -> bool {
        Vec2::conv(dist).abs().max_comp() >= self.config.pan_dist_thresh()
    }

src/event/components.rs (line 81)

    fn step(&mut self, (decay_mul, decay_sub): (f32, f32)) -> Option<Offset> {
        if let Glide::Glide(start, v, rest) = self {
            let now = Instant::now();
            let dur = (now - *start).as_secs_f32();
            let d = *v * dur + *rest;
            let delta = Offset::conv_approx(d);
            let rest = d - Vec2::conv(delta);

            if v.abs().max_comp() >= 1.0 {
                let mut v = *v * decay_mul.powf(dur);
                v = v - v.abs().min(Vec2::splat(decay_sub * dur)) * v.sign();
                *self = Glide::Glide(now, v, rest);
                Some(delta)
            } else {
                *self = Glide::None;
                None
            }
        } else {
            None
        }
    }

pub fn min(self, other: Self) -> Self

Return the minimum, componentwise

Examples found in repository

src/event/components.rs (line 83)

    fn step(&mut self, (decay_mul, decay_sub): (f32, f32)) -> Option<Offset> {
        if let Glide::Glide(start, v, rest) = self {
            let now = Instant::now();
            let dur = (now - *start).as_secs_f32();
            let d = *v * dur + *rest;
            let delta = Offset::conv_approx(d);
            let rest = d - Vec2::conv(delta);

            if v.abs().max_comp() >= 1.0 {
                let mut v = *v * decay_mul.powf(dur);
                v = v - v.abs().min(Vec2::splat(decay_sub * dur)) * v.sign();
                *self = Glide::Glide(now, v, rest);
                Some(delta)
            } else {
                *self = Glide::None;
                None
            }
        } else {
            None
        }
    }

pub fn max(self, other: Self) -> Self

Return the maximum, componentwise

pub fn abs(self) -> Self

Take the absolute value of each component

Examples found in repository

src/event/manager/mgr_pub.rs (line 149)

    pub fn config_test_pan_thresh(&self, dist: Offset) -> bool {
        Vec2::conv(dist).abs().max_comp() >= self.config.pan_dist_thresh()
    }

src/event/components.rs (line 81)

    fn step(&mut self, (decay_mul, decay_sub): (f32, f32)) -> Option<Offset> {
        if let Glide::Glide(start, v, rest) = self {
            let now = Instant::now();
            let dur = (now - *start).as_secs_f32();
            let d = *v * dur + *rest;
            let delta = Offset::conv_approx(d);
            let rest = d - Vec2::conv(delta);

            if v.abs().max_comp() >= 1.0 {
                let mut v = *v * decay_mul.powf(dur);
                v = v - v.abs().min(Vec2::splat(decay_sub * dur)) * v.sign();
                *self = Glide::Glide(now, v, rest);
                Some(delta)
            } else {
                *self = Glide::None;
                None
            }
        } else {
            None
        }
    }

pub fn floor(self) -> Self

Take the floor of each component

pub fn ceil(self) -> Self

Take the ceiling of each component

pub fn round(self) -> Self

Round each component to the nearest integer

pub fn trunc(self) -> Self

Take the trunc of each component

pub fn fract(self) -> Self

Take the fract of each component

pub fn sign(self) -> Self

For each component, return ±1 with the same sign as self.

Examples found in repository

src/event/components.rs (line 83)

    fn step(&mut self, (decay_mul, decay_sub): (f32, f32)) -> Option<Offset> {
        if let Glide::Glide(start, v, rest) = self {
            let now = Instant::now();
            let dur = (now - *start).as_secs_f32();
            let d = *v * dur + *rest;
            let delta = Offset::conv_approx(d);
            let rest = d - Vec2::conv(delta);

            if v.abs().max_comp() >= 1.0 {
                let mut v = *v * decay_mul.powf(dur);
                v = v - v.abs().min(Vec2::splat(decay_sub * dur)) * v.sign();
                *self = Glide::Glide(now, v, rest);
                Some(delta)
            } else {
                *self = Glide::None;
                None
            }
        } else {
            None
        }
    }

pub fn lt(self, rhs: Self) -> bool

True when for all components, lhs < rhs

pub fn le(self, rhs: Self) -> bool

True when for all components, lhs ≤ rhs

pub fn ge(self, rhs: Self) -> bool

True when for all components, lhs ≥ rhs

pub fn gt(self, rhs: Self) -> bool

True when for all components, lhs > rhs

pub fn complex_mul(self, rhs: Self) -> Self

Multiply two vectors as if they are complex numbers

pub fn complex_div(self, rhs: Self) -> Self

Divide by a second vector as if they are complex numbers

pub fn complex_inv(self) -> Self

Take the complex reciprocal

pub fn sum(self) -> f32

Return the sum of the terms

pub fn sum_square(self) -> f32

Return the sum of the square of the terms

pub fn extract<D: Directional>(self, dir: D) -> f32

Extract one component, based on a direction

This merely extracts the horizontal or vertical component. It never negates it, even if the axis is reversed.

Trait Implementations

impl Add<Vec2> for Quad

type Output = Quad

The resulting type after applying the + operator.

fn add(self, rhs: Vec2) -> Self::Output

Performs the + operation.

impl Add<Vec2> for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, rhs: Vec2) -> Self::Output

Performs the + operation.

impl Add<f32> for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl AddAssign<Vec2> for Quad

fn add_assign(&mut self, rhs: Vec2)

Performs the += operation.

impl AddAssign<Vec2> for Vec2

fn add_assign(&mut self, rhs: Vec2)

Performs the += operation.

impl AddAssign<f32> for Vec2

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Conv<(f32, f32)> for Vec2

fn conv(arg: (f32, f32)) -> Self

Convert from T to Self

fn try_conv(v: (f32, f32)) -> Result<Self>

Try converting from T to Self

impl Conv<Coord> for Vec2

fn try_conv(arg: Coord) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Offset> for Vec2

fn try_conv(arg: Offset) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

fn try_conv(arg: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Vec2> for (f32, f32)

fn conv(v: Vec2) -> Self

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl Conv<Vec2> for Vec2

fn conv(size: Vec2) -> Self

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl Conv<Vec2> for Vec2

fn conv(size: Vec2) -> Vec2

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl ConvApprox<DVec2> for Vec2

fn try_conv_approx(size: DVec2) -> Result<Vec2>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Coord

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Offset

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Size

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvFloat<Vec2> for Coord

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Offset

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Size

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl Debug for Vec2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Vec2

fn default() -> Vec2

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Vec2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<Vec2> for Vec2

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: Vec2) -> Self::Output

Performs the / operation.

impl Div<Vec2> for f32

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: Vec2) -> Self::Output

Performs the / operation.

impl Div<f32> for Vec2

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl From<(f32, f32)> for Vec2

fn from(arg: (f32, f32)) -> Self

Converts to this type from the input type.

impl From<LogicalSize> for Vec2

fn from(LogicalSize: LogicalSize) -> Self

Converts to this type from the input type.

impl From<Vec2> for (f32, f32)

fn from(v: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for LogicalSize

fn from(Vec2: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for Vec2

fn from(size: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for Vec2

fn from(size: Vec2) -> Vec2

Converts to this type from the input type.

impl Mul<Vec2> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> Self::Output

Performs the * operation.

impl Mul<f32> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Neg for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<Vec2> for Vec2

fn eq(&self, other: &Vec2) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Vec2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Vec2> for Quad

type Output = Quad

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2) -> Self::Output

Performs the - operation.

impl Sub<Vec2> for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2) -> Self::Output

Performs the - operation.

impl Sub<f32> for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl SubAssign<Vec2> for Quad

fn sub_assign(&mut self, rhs: Vec2)

Performs the -= operation.

impl SubAssign<Vec2> for Vec2

fn sub_assign(&mut self, rhs: Vec2)

Performs the -= operation.

impl SubAssign<f32> for Vec2

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl Copy for Vec2

impl StructuralPartialEq for Vec2