Struct Vec2 

pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

a vector made from a x and y coordinate.

Fields

x: f32

y: f32

Implementations

impl Vec2

pub const ZERO: Vec2

a zero vector

pub const ONE: Vec2

a vector full of ones

pub const X: Vec2

the x axis

pub const Y: Vec2

the y axis

pub const fn new(x: f32, y: f32) -> Vec2

pub const fn extend(self, z: f32) -> Vec3

pub const fn truncate(self) -> f32

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

create a vector where x and y equals value.

pub fn length_squared(self) -> f32

the length of the vector before being square rooted.

pub fn length(self) -> f32

length of the vector.

pub fn distance_squared(self, other: Vec2) -> f32

distance between two vectors before being square rooted.

pub fn distance(self, other: Vec2) -> f32

distance between two vectors.

pub fn dot(self, other: Vec2) -> f32

get the dot product of 2 vectors. equal to the cosign of the angle between vectors.

pub fn scale(self, scalar: f32) -> Vec2

multiplies each value by the scalar.

Examples found in repository

examples/simple-fxaa.rs (line 160)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);

    let mut colour = ResizableTexture2d::default();
    let mut depth = ResizableDepthTexture2d::default();

    let input = { use base_input_codes::*; input_map!(
        (Left,    ArrowLeft,  KeyA, LeftStickLeft ),
        (Right,   ArrowRight, KeyD, LeftStickRight),
        (Forward, ArrowUp,    KeyW, LeftStickUp   ),
        (Back,    ArrowDown,  KeyS, LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown ),
        (FXAA,      KeyF,       GamepadInput::North)
    ) };
    struct Graphics {
        screen_indices: IndexBuffer<u32>,
        screen_vertices: VertexBuffer<Vertex>,
        screen_uvs: VertexBuffer<TextureCoords>,

        teapot_indices: IndexBuffer<u16>,
        teapot_vertices: VertexBuffer<Vertex>,
        teapot_uvs: VertexBuffer<TextureCoords>,
        teapot_normals: VertexBuffer<Normal>,

        fxaa: Program, normal: Program, program: Program
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::default();
    let graphics_setup = graphics.clone();

    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };
    let mut fxaa_on = true;
    
    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    
    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        window.set_title("FXAA Test");
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);

        let (screen_indices, screen_vertices, screen_uvs) = mesh!(
            display, &screen::INDICES, &screen::VERTICES, &screen::UVS
        ).unwrap();
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        ).unwrap();

        let program = Program::from_source(
            display,
            "#version 140
            in vec3 position;
            in vec3 normal;
            
            out vec3 v_normal;

            uniform mat4 model;
            uniform mat4 perspective;
            uniform mat4 camera;

            void main() {
                mat3 norm_mat = transpose(inverse(mat3(camera * model)));
                v_normal = normalize(norm_mat * normal);
                gl_Position = perspective * camera * model * vec4(position, 1);
            }",
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            uniform mat4 camera;
            uniform vec3 ambient;
            uniform vec3 albedo;
            uniform float shine;
            void main() {
                vec3 camera_dir = inverse(mat3(camera)) * vec3(0, 0, -1);
                vec3 half_dir = normalize(camera_dir + light);
                float specular = pow(max(dot(half_dir, v_normal), 0.0), shine);
                float light_level = max(dot(light, v_normal), 0.0);
                colour = vec4(albedo * light_level + ambient + vec3(specular), 1.0);
            }", None
        ).unwrap();
        let fxaa = shaders::fxaa_shader(display).unwrap();
        let normal = Program::from_source(
            display,
            "#version 140
            in vec2 texture_coords;
            out vec2 uv;
            in vec3 position;
            void main() {
                uv = texture_coords;
                gl_Position = vec4(position, 1);
            }", 
            "#version 140
            in vec2 uv;
            uniform sampler2D tex;
            out vec4 colour;
            void main() {
                colour = texture(tex, uv);
            }", None
        ).unwrap();
        graphics_setup.replace(Some(Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        }));
    }).with_update(|input, display, _, _, _| {
        let graphics = graphics.borrow();
        let Graphics {
            screen_indices, screen_vertices, screen_uvs,
            teapot_indices, teapot_vertices, teapot_uvs, teapot_normals,
            program, normal, fxaa
        } = graphics.as_ref().unwrap();
        let teapot_mesh = (teapot_vertices, teapot_normals, teapot_uvs);
        let screen_mesh = (screen_vertices, screen_uvs);

        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        // using a small resolution to better show the effect of fxaa.
        let size = (380, 216);
        display.resize(size);
        depth.resize_to_display(&display);
        colour.resize_to_display(&display);

        // press f or gamepad north to toggle FXAA
        if input.pressed(FXAA) { fxaa_on = !fxaa_on }

        let colour = colour.texture();
        let depth = depth.texture();
        let mut frame = SimpleFrameBuffer::with_depth_buffer(
            display, colour, depth
        ).unwrap();

        let perspective = Mat4::perspective_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookRight, LookLeft, LookUp, LookDown);
        rot += look_move.scale(delta_time * 15.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(-rot.y);
        let rot = rx * ry;

        // move player based on camera
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += Mat3::from_rot(rx) * move_dir;

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        // draw teapot
        frame.draw(
            teapot_mesh, teapot_indices,
            program, &uniform! {
                perspective: perspective,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light:   vec3(0.1, 0.25, -1.0).normalise(),
                albedo:  vec3(0.5, 0.1,   0.4),
                ambient: vec3(0.0, 0.05,  0.1),
                shine: 50.0f32,
            },
            &draw_parameters,
        ).unwrap();

        let mut frame = display.draw();
        frame.draw(
            screen_mesh, screen_indices, if fxaa_on { fxaa } else { normal },
            &shaders::fxaa_uniforms(colour), &DrawParameters::default()
        ).unwrap();
        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

pub fn normalise(self) -> Vec2

makes the length of the vector equal to 1. on fail returns vec2 of zeros

pub fn transform(self, matrix: Mat2) -> Vec2

transforms vector by the matrix

pub fn eq(self, rhs: Vec2) -> BVec2

returns whether the 2 components are equal

pub fn less(self, rhs: Vec2) -> BVec2

returns whether the 1st components are less than the 2nd

pub fn more(self, rhs: Vec2) -> BVec2

returns whether the 1st components are more than the 2nd

pub fn less_or_eq(self, rhs: Vec2) -> BVec2

returns whether the 1st components are less than or equal to the 2nd

pub fn more_or_eq(self, rhs: Vec2) -> BVec2

returns whether the 1st components are more than or equal to the 2nd

Trait Implementations

impl Add for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, rhs: Vec2) -> <Vec2 as Add>::Output

Performs the + operation.

impl AddAssign for Vec2

fn add_assign(&mut self, rhs: Vec2)

Performs the += operation.

impl AsUniformValue for Vec2

fn as_uniform_value(&self) -> UniformValue<'_>

Builds a UniformValue.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vec2

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

Formats the value using the given formatter.

impl Div<f32> for Vec2

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <Vec2 as Div<f32>>::Output

Performs the / operation.

impl Div for Vec2

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: Vec2) -> <Vec2 as Div>::Output

Performs the / operation.

impl DivAssign<f32> for Vec2

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign for Vec2

fn div_assign(&mut self, rhs: Vec2)

Performs the /= operation.

impl From<[f32; 2]> for Vec2

fn from(value: [f32; 2]) -> Vec2

Converts to this type from the input type.

impl From<(f32, f32)> for Vec2

fn from(value: (f32, f32)) -> Vec2

Converts to this type from the input type.

impl From<Vec2> for DIVec2

fn from(value: Vec2) -> DIVec2

Converts to this type from the input type.

impl From<Vec2> for DUVec2

fn from(value: Vec2) -> DUVec2

Converts to this type from the input type.

impl From<Vec2> for DVec2

fn from(value: Vec2) -> DVec2

Converts to this type from the input type.

impl From<Vec2> for IVec2

fn from(value: Vec2) -> IVec2

Converts to this type from the input type.

impl From<Vec2> for TextureCoords

fn from(value: Vec2) -> TextureCoords

Converts to this type from the input type.

impl From<Vec2> for UVec2

fn from(value: Vec2) -> UVec2

Converts to this type from the input type.

impl Mul<Vec2> for Mat2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> <Mat2 as Mul<Vec2>>::Output

Performs the * operation.

impl Mul<f32> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <Vec2 as Mul<f32>>::Output

Performs the * operation.

impl Mul for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> <Vec2 as Mul>::Output

Performs the * operation.

impl MulAssign<f32> for Vec2

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign for Vec2

fn mul_assign(&mut self, rhs: Vec2)

Performs the *= operation.

impl Neg for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn neg(self) -> <Vec2 as Neg>::Output

Performs the unary - operation.

impl PartialEq for Vec2

fn eq(&self, other: &Vec2) -> 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 PartialOrd for Vec2

fn partial_cmp(&self, other: &Vec2) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<f32> for Vec2

type Output = Vec2

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> <Vec2 as Rem<f32>>::Output

Performs the % operation.

impl Rem for Vec2

type Output = Vec2

The resulting type after applying the % operator.

fn rem(self, rhs: Vec2) -> <Vec2 as Rem>::Output

Performs the % operation.

impl RemAssign<f32> for Vec2

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl RemAssign for Vec2

fn rem_assign(&mut self, rhs: Vec2)

Performs the %= operation.

impl Sub for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2) -> <Vec2 as Sub>::Output

Performs the - operation.

impl SubAssign for Vec2

fn sub_assign(&mut self, rhs: Vec2)

Performs the -= operation.

impl Copy for Vec2

impl StructuralPartialEq for Vec2