Struct pixel_engine_draw::vector2::Vec2d

pub struct Vec2d<T> {
    pub x: T,
    pub y: T,
}

Basicly a glorified tuple

Fields

x: T

x

y: T

y

Implementations

impl<T> Vec2d<T>

pub fn cast<U: From<T>>(self) -> Vec2d<U>

Cast the Vec2d to an other Vec2d with a differant inner type

impl<T> Vec2d<T>where
    T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Neg<Output = T> + Into<f32> + From<f32> + Copy,

pub fn mag_f64(&self) -> f32

Return the magnitude (hypotenus) of the given Vec2d as f64

Examples found in repository

src/vector2.rs (line 61)

    pub fn norm(&self) -> Self {
        let r: T = self.mag_f64().recip().into();
        Vec2d {
            x: self.x * r,
            y: self.y * r,
        }
    }

pub fn mag(&self) -> T

Return the magnitude (hypotenus) of the given Vec2d as T

pub fn mag2(&self) -> T

Return the magnitude (hypotenus) of the given Vec2d as T without doing the square root

Examples found in repository

src/vector2.rs (line 44)

    pub fn mag_f64(&self) -> f32 {
        let mag2: f32 = self.mag2().into();
        mag2.sqrt()
    }
    /// Return the magnitude (hypotenus) of the given Vec2d as T
    pub fn mag(&self) -> T {
        let mag2: f32 = self.mag2().into();
        mag2.sqrt().into()
    }

pub fn norm(&self) -> Self

Return a normalized version of the Vec2d

pub fn perp(&self) -> Self

Return the normal of the given Vec2d

pub fn dot(&self, rhs: &Self) -> T

Perform the dot product on the Vec2ds

pub fn cross(&self, rhs: &Self) -> T

Perform the cross product on the Vec2ds

impl Vec2d<u32>

pub fn cast_f32(self) -> Vec2d<f32>

impl Vec2d<i32>

pub fn cast_f32(self) -> Vec2d<f32>

impl Vec2d<f32>

pub fn cast_u32(self) -> Vec2d<u32>

impl Vec2d<i32>

pub fn cast_u32(self) -> Vec2d<u32>

Examples found in repository

src/graphics.rs (line 547)

    fn draw<P: Into<Vi2d>>(&mut self, pos: P, col: Color) {
        let pixel_mode = self.get_pixel_mode();
        let blend_factor = self.get_blend_factor();
        let pos @ Vi2d { x, y } = pos.into();
        if x >= self.sprite.size().x.try_into().unwrap()
            || y >= self.sprite.size().y.try_into().unwrap()
            || x < 0
            || y < 0
        {
            return;
        }
        match pixel_mode {
            PixelMode::Normal => unsafe {
                self.sprite.set_pixel_unchecked(pos.cast_u32(), col);
            },
            PixelMode::Mask => {
                if col.a == 255 {
                    unsafe {
                        self.sprite.set_pixel_unchecked(pos.cast_u32(), col);
                    }
                }
            }
            PixelMode::Alpha => {
                let current_color: Color =
                    unsafe { self.sprite.get_pixel_unchecked(pos.cast_u32()) };
                let alpha: f32 = (f32::from(col.a) / 255.0f32) * blend_factor;
                let inverse_alpha: f32 = 1.0 - alpha;
                let red: f32 =
                    alpha * f32::from(col.r) + inverse_alpha * f32::from(current_color.r);
                let green: f32 =
                    alpha * f32::from(col.g) + inverse_alpha * f32::from(current_color.g);
                let blue: f32 =
                    alpha * f32::from(col.b) + inverse_alpha * f32::from(current_color.b);
                unsafe {
                    self.sprite
                        .set_pixel_unchecked(pos.cast_u32(), [red, green, blue].into());
                }
            }
        }
    }

    fn get_textsheet(&self) -> &'static Sprite {
        create_text()
    }

    fn clear(&mut self, col: Color) {
        let size = self.sprite.size();
        for y in 0..size.y {
            for x in 0..size.x {
                unsafe {
                    self.sprite.set_pixel_unchecked(Vu2d { x, y }, col);
                }
            }
        }
    }

    fn get_pixel_mode(&self) -> PixelMode {
        self.draw_data.pixel_mode
    }
    fn get_blend_factor(&self) -> f32 {
        self.draw_data.blend_factor
    }

    fn set_pixel_mode(&mut self, mode: PixelMode) {
        self.draw_data.pixel_mode = mode;
    }
    fn set_blend_factor(&mut self, f: f32) {
        self.draw_data.blend_factor = f;
    }
}

pub trait DrawSpriteTrait {
    fn get_pixel(&self, pos: Vi2d) -> Option<Color>;
    fn set_pixel(&mut self, pos: Vi2d, col: Color);
    fn size(&self) -> Vu2d;
    /// Get the pixel at the given location, but bypassing any bounds check
    ///
    /// # Safety
    ///     You must ensure that the pos in bounds
    unsafe fn get_pixel_unchecked(&self, pos: Vu2d) -> Color;
    /// Set the pixel at the given location, but bypassing any bounds check
    ///
    /// # Safety
    ///     You must ensure that the pos in bounds
    unsafe fn set_pixel_unchecked(&mut self, pos: Vu2d, col: Color);
}

impl DrawSpriteTrait for Sprite {
    fn get_pixel(&self, pos: Vi2d) -> Option<Color> {
        if pos.x < 0 || pos.y < 0 || pos.x as u32 >= self.size().x || pos.y as u32 >= self.size().y
        {
            return None;
        }
        let (raw, lock) = self.get_read_lock();
        let mut col = Color::BLANK;
        let pos = pos.cast_u32();

        col.r = raw[(pos.y * self.width() + pos.x) as usize * 4];
        col.g = raw[(pos.y * self.width() + pos.x) as usize * 4 + 1];
        col.b = raw[(pos.y * self.width() + pos.x) as usize * 4 + 2];
        col.a = raw[(pos.y * self.width() + pos.x) as usize * 4 + 3];
        drop(lock);
        Some(col)
    }

    fn set_pixel(&mut self, pos: Vi2d, col: Color) {
        if pos.x < 0 || pos.y < 0 {
            return;
        };
        self.set_pixel(pos.x as u32, pos.y as u32, col);
    }
    fn size(&self) -> Vu2d {
        *self.size()
    }

    /// # Safety
    /// its up to the caller to make sure that the given position is in bounds
    unsafe fn get_pixel_unchecked(&self, pos: Vu2d) -> Color {
        let (raw, _lock) = self.get_read_lock();
        let mut col = Color::BLANK;
        col.r = *raw.get_unchecked((pos.y * self.width() + pos.x) as usize * 4);
        col.g = *raw.get_unchecked((pos.y * self.width() + pos.x) as usize * 4 + 1);
        col.b = *raw.get_unchecked((pos.y * self.width() + pos.x) as usize * 4 + 2);
        col.a = *raw.get_unchecked((pos.y * self.width() + pos.x) as usize * 4 + 3);
        col
    }

    /// # Safety
    /// its up to the caller to make sure that the given position is in bounds
    unsafe fn set_pixel_unchecked(&mut self, pos: Vu2d, col: Color) {
        let Vu2d { x, y } = pos;
        let width = self.width();
        // SAFETY: Its up to the caller to make sure that the bounds are correct to not write oob
        *self
            .raw
            .get_mut()
            .get_unchecked_mut((y * width + x) as usize * 4) = col.r;
        *self
            .raw
            .get_mut()
            .get_unchecked_mut((y * width + x) as usize * 4 + 1) = col.g;
        *self
            .raw
            .get_mut()
            .get_unchecked_mut((y * width + x) as usize * 4 + 2) = col.b;
        *self
            .raw
            .get_mut()
            .get_unchecked_mut((y * width + x) as usize * 4 + 3) = col.a;
    }
}
impl<'spr> DrawSpriteTrait for SpriteMutRef<'spr> {
    fn get_pixel(&self, pos: Vi2d) -> Option<Color> {
        if pos.x < 0 || pos.y < 0 {
            return None;
        };
        self.get_pixel(pos.cast_u32())
    }

    fn set_pixel(&mut self, pos: Vi2d, col: Color) {
        if pos.x < 0 || pos.y < 0 {
            return;
        };
        self.set_pixel(pos.cast_u32(), col);
    }

impl Vec2d<f32>

pub fn cast_i32(self) -> Vec2d<i32>

impl Vec2d<u32>

pub fn cast_i32(self) -> Vec2d<i32>

Trait Implementations

impl<T> Add<Vec2d<T>> for Vec2d<T>where
    T: Add<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<Vec2d<T>> for Vec2d<T>where
    T: AddAssign<T> + Copy,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for Vec2d<T>

fn clone(&self) -> Vec2d<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vec2d<T>

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

Formats the value using the given formatter.

impl<T> Div<T> for Vec2d<T>where
    T: Div<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Vec2d<T>> for Vec2d<T>where
    T: Div<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for Vec2d<T>where
    T: DivAssign<T> + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Copy> From<[T; 2]> for Vec2d<T>

fn from(t: [T; 2]) -> Self

Converts to this type from the input type.

impl<T: Copy> From<(T, T)> for Vec2d<T>

fn from(t: (T, T)) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Vec2d<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Mul<T> for Vec2d<T>where
    T: Mul<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Vec2d<T>> for Vec2d<T>where
    T: Mul<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for Vec2d<T>where
    T: MulAssign<T> + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: PartialEq> PartialEq<Vec2d<T>> for Vec2d<T>

fn eq(&self, other: &Vec2d<T>) -> 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<T> Sub<Vec2d<T>> for Vec2d<T>where
    T: Sub<Output = T> + Copy,

type Output = Vec2d<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<Vec2d<T>> for Vec2d<T>where
    T: SubAssign<T> + Copy,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy> Copy for Vec2d<T>

impl<T: Eq> Eq for Vec2d<T>

impl<T> StructuralEq for Vec2d<T>

impl<T> StructuralPartialEq for Vec2d<T>