Struct Vec2

pub struct Vec2<R: Real = f32> {
    pub x: R,
    pub y: R,
}

Fields

x: R

y: R

Implementations

impl<R: Real> Vec2<R>

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

Examples found in repository

examples/example-pong.rs (line 48)

    fn new(state: &mut onyx::State<Action>, center: Vec2, size: Vec2, velocity: Vec2) -> Rect {
        let transform = state.graph().add(center, Vec2::new(1.0, 1.0));
        let child = state.graph().add_child(transform, -0.5 * size, size);
        state.renderer().add(child);
        Self { center, size, velocity, transform }
    }

    fn min(&self) -> Vec2 {
        self.center - 0.5 * self.size
    }

    fn max(&self) -> Vec2 {
        self.center + 0.5 * self.size
    }
}

impl onyx::Scene for Scene {
    type Action = Action;

    fn new(state: &mut onyx::State<Action>) -> Self {
        let size = state.context().size();
        let plank_size = Vec2::new(10.0, 100.0);
        let left_plank = Rect::new(state, 0.5 * Vec2::new(plank_size.x, size.y), plank_size, Vec2::zero());
        let right_plank = Rect::new(state, Vec2::new(size.x - 0.5 * plank_size.x, 0.5 * size.y), plank_size, Vec2::zero());
        let ball_size = Vec2::new(20.0, 20.0);
        let ball = Rect::new(state, 0.5 * size, ball_size, Vec2::new(100.0, 100.0));
        state.ui().build(onyx::ui::panel()
            .layout(onyx::ui::Layout::Horizontal)
            .alignment(onyx::ui::Alignment::Center, onyx::ui::Alignment::Min)
            .child(onyx::ui::label("0").id("left"))
            .child(onyx::ui::label(":"))
            .child(onyx::ui::label("0").id("right"))
        );
        let mut keys = HashMap::new();
        keys.insert(onyx::Key::W, (Direction::Up, Plank::Left));
        keys.insert(onyx::Key::S, (Direction::Down, Plank::Left));
        keys.insert(onyx::Key::Up, (Direction::Up, Plank::Right));
        keys.insert(onyx::Key::Down, (Direction::Down, Plank::Right));
        Scene { 
            left_plank,
            right_plank,
            ball,
            left_score: 0,
            right_score: 0,
            keys,
        }
    }

    fn event(&mut self, event: onyx::Event) -> Option<Action> {
        match event {
            onyx::Event::KeyPressed(key) => {
                if let Some(&(direction, plank)) = self.keys.get(&key) {
                    Some(Action { direction, plank, kind: Kind::Start })
                } else {
                    None
                }
            },
            onyx::Event::KeyReleased(key) => {
                if let Some(&(direction, plank)) = self.keys.get(&key) {
                    Some(Action { direction, plank, kind: Kind::Stop })
                } else {
                    None
                }
            },
            _ => None,
        }
    }

    fn action(&mut self, action: Self::Action, state: &mut onyx::State<Action>) -> onyx::Transition {
        let plank = match action.plank {
            Plank::Left => &mut self.left_plank,
            Plank::Right => &mut self.right_plank,
        };
        let velocity = match action.direction {
            Direction::Down => Vec2::new(0.0, 100.0),
            Direction::Up => Vec2::new(0.0, -100.0),
        };
        match action.kind {
            Kind::Start => plank.velocity += velocity,
            Kind::Stop => plank.velocity -= velocity,
        }
        state.none()
    }

impl<R: Real> Vec2<R>

pub fn zero() -> Self

Examples found in repository

examples/example-pong.rs (line 69)

    fn new(state: &mut onyx::State<Action>) -> Self {
        let size = state.context().size();
        let plank_size = Vec2::new(10.0, 100.0);
        let left_plank = Rect::new(state, 0.5 * Vec2::new(plank_size.x, size.y), plank_size, Vec2::zero());
        let right_plank = Rect::new(state, Vec2::new(size.x - 0.5 * plank_size.x, 0.5 * size.y), plank_size, Vec2::zero());
        let ball_size = Vec2::new(20.0, 20.0);
        let ball = Rect::new(state, 0.5 * size, ball_size, Vec2::new(100.0, 100.0));
        state.ui().build(onyx::ui::panel()
            .layout(onyx::ui::Layout::Horizontal)
            .alignment(onyx::ui::Alignment::Center, onyx::ui::Alignment::Min)
            .child(onyx::ui::label("0").id("left"))
            .child(onyx::ui::label(":"))
            .child(onyx::ui::label("0").id("right"))
        );
        let mut keys = HashMap::new();
        keys.insert(onyx::Key::W, (Direction::Up, Plank::Left));
        keys.insert(onyx::Key::S, (Direction::Down, Plank::Left));
        keys.insert(onyx::Key::Up, (Direction::Up, Plank::Right));
        keys.insert(onyx::Key::Down, (Direction::Down, Plank::Right));
        Scene { 
            left_plank,
            right_plank,
            ball,
            left_score: 0,
            right_score: 0,
            keys,
        }
    }

    fn event(&mut self, event: onyx::Event) -> Option<Action> {
        match event {
            onyx::Event::KeyPressed(key) => {
                if let Some(&(direction, plank)) = self.keys.get(&key) {
                    Some(Action { direction, plank, kind: Kind::Start })
                } else {
                    None
                }
            },
            onyx::Event::KeyReleased(key) => {
                if let Some(&(direction, plank)) = self.keys.get(&key) {
                    Some(Action { direction, plank, kind: Kind::Stop })
                } else {
                    None
                }
            },
            _ => None,
        }
    }

    fn action(&mut self, action: Self::Action, state: &mut onyx::State<Action>) -> onyx::Transition {
        let plank = match action.plank {
            Plank::Left => &mut self.left_plank,
            Plank::Right => &mut self.right_plank,
        };
        let velocity = match action.direction {
            Direction::Down => Vec2::new(0.0, 100.0),
            Direction::Up => Vec2::new(0.0, -100.0),
        };
        match action.kind {
            Kind::Start => plank.velocity += velocity,
            Kind::Stop => plank.velocity -= velocity,
        }
        state.none()
    }

    fn update(&mut self, state: &mut onyx::State<Action>) -> onyx::Transition {
        let min = Vec2::zero();
        let max = state.context().size();
        self.ball.center += self.ball.velocity * state.context().dt();
        self.left_plank.center += self.left_plank.velocity * state.context().dt();
        self.right_plank.center += self.right_plank.velocity * state.context().dt();
        if self.ball.max().x > max.x - self.right_plank.size.x && self.ball.max().x < max.x {
            if self.ball.min().y < self.right_plank.max().y && self.ball.max().y > self.right_plank.min().y {
                self.ball.center.x = max.x - self.right_plank.size.x - 0.5 * self.ball.size.x;
                self.ball.velocity.x = -self.ball.velocity.x;
            }
        }
        if self.ball.min().x > max.x {
            self.ball.center.x = 0.5 * (max.x - min.x);
            self.left_score += 1;
            state.ui().set_text("left", &self.left_score.to_string());
        }
        if self.ball.min().x < min.x + self.left_plank.size.x && self.ball.max().x > min.x {
            if self.ball.min().y < self.left_plank.max().y && self.ball.max().y > self.left_plank.min().y {
                self.ball.center.x = min.x + self.left_plank.size.x + 0.5 * self.ball.size.x;
                self.ball.velocity.x = -self.ball.velocity.x;
            }
        }
        if self.ball.max().x < min.x {
            self.ball.center.x = 0.5 * (max.x - min.x);
            self.right_score += 1;
            state.ui().set_text("right", &self.right_score.to_string());
        }
        if self.ball.min().y < min.y {
            self.ball.center.y = min.y + 0.5 * self.ball.size.y;
            self.ball.velocity.y = -self.ball.velocity.y;
        }
        if self.ball.max().y > max.y {
            self.ball.center.y = max.y - 0.5 * self.ball.size.y;
            self.ball.velocity.y = -self.ball.velocity.y;
        }
        state.graph().set_position(self.ball.transform, self.ball.center);
        state.graph().set_position(self.left_plank.transform, self.left_plank.center);
        state.graph().set_position(self.right_plank.transform, self.right_plank.center);
        state.none()
    }

Trait Implementations

impl<R: Real> Add for Vec2<R>

type Output = Vec2<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Real> AddAssign for Vec2<R>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<R: Clone + Real> Clone for Vec2<R>

fn clone(&self) -> Vec2<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Real> Debug for Vec2<R>

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

Formats the value using the given formatter.

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

where R: Deserialize<'de> + Real,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: Real> From<Vec2<R>> for Vec3<R>

fn from(vec2: Vec2<R>) -> Self

Converts to this type from the input type.

impl<R: Real> Into<[R; 2]> for Vec2<R>

fn into(self) -> [R; 2]

Converts this type into the (usually inferred) input type.

impl<R: Real> Mul<R> for Vec2<R>

type Output = Vec2<R>

The resulting type after applying the * operator.

fn mul(self, other: R) -> Self::Output

Performs the * operation.

impl Mul<Vec2<f64>> for f64

type Output = Vec2<f64>

The resulting type after applying the * operator.

fn mul(self, other: Vec2<f64>) -> Self::Output

Performs the * operation.

impl Mul<Vec2> for f32

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, other: Vec2<f32>) -> Self::Output

Performs the * operation.

impl<R: PartialEq + Real> PartialEq for Vec2<R>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<R> Serialize for Vec2<R>

where R: Serialize + Real,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Real> Sub for Vec2<R>

type Output = Vec2<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Real> SubAssign for Vec2<R>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<R: Copy + Real> Copy for Vec2<R>

impl<R: Real> StructuralPartialEq for Vec2<R>