Struct gemini_engine::elements::view::vec2d::Vector2

pub struct Vector2<T: Clone> {
    pub x: T,
    pub y: T,
}

Raw Vector2 type

Fields

x: T

y: T

Implementations

impl<T: Clone> Vector2<T>

pub const fn new(x: T, y: T) -> Self

Examples found in repository

examples/multi-movement.rs (line 14)

const BLOCK_SIZE: Vec2D = Vec2D::new(4, 2);
const FILL_CHAR: ColChar = ColChar::SOLID;

fn main() {
    let mut view = View::new(50, 12, ColChar::BACKGROUND);

    let mut blocks = vec![
        Rect::new(Vec2D::new(0, 0), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 2), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 4), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 6), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 8), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 10), BLOCK_SIZE, FILL_CHAR),
    ];

    let mut i = 0;
    fps_gameloop!(
        {
            i += 1;
            for j in 0..blocks.len() {
                if i % 2_u32.pow(j as u32) == 0 {
                    blocks[j].pos.x += 1;
                }
            }
        },
        {
            view.clear();
            for block in &blocks {
                view.blit(block, Wrapping::Wrap);
            }
            view.display_render().unwrap();

            if blocks.iter().all(|b| b.pos.x % view.width as isize == 0) {
                thread::sleep(Duration::from_secs(2));
            };
        },
        200.0
    );
}

pub fn as_tuple(&self) -> (T, T)

impl Vector2<isize>

pub const ZERO: Vec2D = _

A Vec2D of (0,0)

Trait Implementations

impl<T: Clone + Add<Output = T>> Add<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone + AddAssign> AddAssign<Vector2<T>> for Vector2<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Clone> Clone for Vector2<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone> Debug for Vector2<T>

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

Formats the value using the given formatter.

impl<T: Clone + Div<Output = T>> Div<T> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Clone + DivAssign> DivAssign<T> for Vector2<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Clone> From<(T, T)> for Vector2<T>

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

Converts to this type from the input type.

impl<T: PartialEq + Clone> PartialEq<Vector2<T>> for Vector2<T>

fn eq(&self, other: &Vector2<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 Rem<Vector2<isize>> for Vec2D

type Output = Vector2<isize>

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<Vector2<isize>> for Vec2D

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T: Clone + Sub<Output = T>> Sub<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Clone + SubAssign> SubAssign<Vector2<T>> for Vector2<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy + Clone> Copy for Vector2<T>

impl<T: Clone> StructuralPartialEq for Vector2<T>