Struct Quat

pub struct Quat {
    pub r: f32,
    pub i: f32,
    pub j: f32,
    pub k: f32,
}

a 4 part vector often used to represent rotations. note that multiplication of quaternions is applying transformations.

Fields

r: f32

i: f32

j: f32

k: f32

Implementations

impl Quat

pub const IDENTITY: Quat

pub fn from_x_rot(angle: f32) -> Quat

rotation around the x axis in radians

Examples found in repository

examples/simple.rs (line 87)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (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 )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

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

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view and gravity
        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 += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple-fxaa.rs (line 140)

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
        );
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        );

        let program = Program::from_source(
            display, shaders::VERTEX,
            "#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, shaders::SCREEN_VERTEX, 
            "#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 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 view = Mat4::view_matrix_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view
        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 += move_dir.transform(&Mat3::from_rot(rx));

        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! {
                view: view,
                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 from_y_rot(angle: f32) -> Quat

rotation around the y axis in radians

Examples found in repository

examples/simple.rs (line 86)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (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 )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

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

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view and gravity
        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 += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple-fxaa.rs (line 139)

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
        );
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        );

        let program = Program::from_source(
            display, shaders::VERTEX,
            "#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, shaders::SCREEN_VERTEX, 
            "#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 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 view = Mat4::view_matrix_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view
        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 += move_dir.transform(&Mat3::from_rot(rx));

        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! {
                view: view,
                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 from_z_rot(angle: f32) -> Quat

rotation around the z axis in radians

pub fn from_axis_rot(angle: f32, axis: Vec3) -> Quat

rotation around the inputed axis in radians

pub fn inverse(self) -> Quat

get innverse of a quaternion. panics if all quaternions values are 0

Trait Implementations

impl Add for Quat

type Output = Quat

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Quat

fn add_assign(&mut self, rhs: Quat)

Performs the += operation.

impl Clone for Quat

fn clone(&self) -> Quat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Quat

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

Formats the value using the given formatter.

impl From<DQuat> for Quat

fn from(value: DQuat) -> Quat

Converts to this type from the input type.

impl From<Quat> for Mat3

fn from(value: Quat) -> Mat3

Converts to this type from the input type.

impl From<Quat> for Mat4

fn from(value: Quat) -> Mat4

Converts to this type from the input type.

impl From<Vec4> for Quat

fn from(value: Vec4) -> Quat

Converts to this type from the input type.

impl Mul for Quat

type Output = Quat

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Quat

type Output = Quat

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl PartialEq for Quat

fn eq(&self, other: &Quat) -> bool

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

const 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 Sub for Quat

type Output = Quat

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Quat

fn sub_assign(&mut self, rhs: Quat)

Performs the -= operation.

impl Copy for Quat

impl StructuralPartialEq for Quat