Struct Vector3D 

pub struct Vector3D<S = f32, U = ()> {
    pub x: S,
    pub y: S,
    pub z: S,
    /* private fields */
}

3D vector.

Fields

x: S

y: S

z: S

Implementations

impl<S, U> Vector3D<S, U>

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

Examples found in repository

examples/screenshot.rs (line 167)

    fn frame(&mut self) -> Result<(), T::Error> {
        let (width, height) = (self.width as f32, self.height as f32);
        let proj = Transform3D::perspective(60.0f32, width / height, 0.01, 30.0);
        let view = Transform3D::<f32>::look_at(
            Vector3D::new(0.0, 1.5, 9.0),
            Vector3D::new(0.0, 0.0, 0.0),
            Vector3D::new(0.0, 1.0, 0.0),
        );
        let view_proj = proj * view;

        self.rx += 0.01;
        self.ry += 0.03;

        let model = Transform3D::rotation(self.ry, Vector3D::new(0., 1.0, 0.))
            * Transform3D::<f32>::rotation(self.rx, Vector3D::new(1.0, 0., 0.));

        let vs_params = display_shader::Uniforms {
            mvp: view_proj * model,
        };
        let mut frame = self.backend.frame();

        frame.begin_pass(
            self.offscreen_pass,
            gfx::PassAction::clear(gfx::color::Rgba::BLACK),
        );
        frame.apply_pipeline(&self.offscreen_pipeline)?;
        frame.apply_bindings(&self.offscreen_bind)?;
        frame.apply_uniforms(&vs_params)?;
        frame.draw(0, 3, 1)?;
        frame.end_pass();

        frame.begin_default_pass(gfx::PassAction::clear(gfx::color::Rgba::BLACK));
        frame.apply_pipeline(&self.display_pipeline)?;
        frame.apply_bindings(&self.display_bind)?;
        frame.draw(0, 6, 1)?;
        frame.end_pass();
        frame.commit();

        Ok(())
    }

examples/offscreen.rs (line 32)

    fn frame(&mut self) -> Result<(), Self::Error> {
        let (width, height) = (self.width as f32, self.height as f32);
        let proj = Transform3D::perspective(60.0f32, width / height, 0.01, 100.);
        let view = Transform3D::<f32>::look_at(
            Vector3D::new(0.0, 1.5, 9.0),
            Vector3D::new(0.0, 0.0, 0.0),
            Vector3D::new(0.0, 1.0, 0.0),
        );
        let view_proj = proj * view;

        self.rx += 0.01;
        self.ry += 0.03;

        let model = Transform3D::rotation(self.ry, Vector3D::new(0., 1.0, 0.))
            * Transform3D::<f32>::rotation(self.rx, Vector3D::new(1.0, 0., 0.));
        let vs_params = display_shader::Uniforms {
            mvp: view_proj * model,
        };
        let mut frame = self.backend.frame();

        // Offscreen pass.
        frame.begin_pass(
            self.offscreen_pass,
            gfx::PassAction::clear(gfx::color::Rgba::WHITE),
        );
        frame.apply_pipeline(&self.offscreen_pipeline)?;
        frame.apply_bindings(&self.offscreen_bind)?;
        frame.apply_uniforms(&vs_params)?;
        frame.draw(0, 36, 1)?;
        frame.end_pass();

        // Display pass.
        frame.begin_default_pass(gfx::PassAction::clear(gfx::color::Rgba::new(
            0.0, 0., 0.45, 1.,
        )));
        frame.apply_pipeline(&self.display_pipeline)?;
        frame.apply_bindings(&self.display_bind)?;
        frame.apply_uniforms(&vs_params)?;
        frame.draw(0, 36, 1)?;
        frame.end_pass();
        frame.commit();

        Ok(())
    }

pub fn extend(self, w: S) -> Vector4D<S, U>

Extend vector to four dimensions.

pub fn dot(a: Self, b: Self) -> <S as Add>::Output

where S: Mul<Output = S> + Add<Output = S> + Copy,

Dot product of two vectors.

pub fn cross(a: Self, b: Self) -> Self

where S: Mul<Output = S> + Sub<Output = S> + Copy,

Vector cross product.

impl<S: Copy> Vector3D<S>

pub fn magnitude(self) -> S

where S: Float,

The distance from the tail to the tip of the vector.

pub fn normalize(self) -> Self

where S: One + Float + Div + Mul,

Returns a vector with the same direction and a given magnitude.

Trait Implementations

impl<S, U> Add for Vector3D<S, U>

where S: Add<Output = S> + Copy,

type Output = Vector3D<S, U>

The resulting type after applying the + operator.

fn add(self, other: Vector3D<S, U>) -> Self

Performs the + operation.

impl<S: Clone, U: Clone> Clone for Vector3D<S, U>

fn clone(&self) -> Vector3D<S, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug, U: Debug> Debug for Vector3D<S, U>

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

Formats the value using the given formatter.

impl<T: Copy> From<[T; 3]> for Vector3D<T>

fn from(array: [T; 3]) -> Self

Converts to this type from the input type.

impl<S: Zero, U: Copy> From<Vector2D<S, U>> for Vector3D<S, U>

fn from(other: Vector2D<S, U>) -> Self

Converts to this type from the input type.

impl<S, U: Copy> From<Vector3D<S, U>> for Vector2D<S, U>

fn from(other: Vector3D<S, U>) -> Self

Converts to this type from the input type.

impl From<Vector3D> for Vector4D<f32>

fn from(other: Vector3D<f32>) -> Self

Converts to this type from the input type.

impl<S: Hash, U: Hash> Hash for Vector3D<S, U>

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<S, U> Mul<S> for Vector3D<S, U>

where S: Mul<Output = S> + Copy,

type Output = Vector3D<S, U>

The resulting type after applying the * operator.

fn mul(self, s: S) -> Self

Performs the * operation.

impl Mul<Vector3D> for Transform3D<f32>

Transform a Vector3D with a Transform3D.

use ombre::math::*;
let m = Transform3D::from_translation(Vector3D::new(8., 8., 0.));
let v = Vector3D::new(1., 1., 0.);

assert_eq!(m * v, Vector3D::new(9., 9., 0.));

type Output = Vector3D

The resulting type after applying the * operator.

fn mul(self, vec: Vector3D<f32>) -> Vector3D<f32>

Performs the * operation.

impl<S: PartialEq, U: PartialEq> PartialEq for Vector3D<S, U>

fn eq(&self, other: &Vector3D<S, U>) -> 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<S, U> Sub for Vector3D<S, U>

where S: Sub<Output = S> + Copy,

type Output = Vector3D<S, U>

The resulting type after applying the - operator.

fn sub(self, other: Vector3D<S, U>) -> Self

Performs the - operation.

impl<S: Copy, U: Copy> Copy for Vector3D<S, U>

impl<S: Eq, U: Eq> Eq for Vector3D<S, U>

impl<S, U> StructuralPartialEq for Vector3D<S, U>