Struct Mat3 

pub struct Mat3 { /* private fields */ }

a matrix often used for transformations in glium

Implementations

impl Mat3

pub const IDENTITY: Mat3

pub const fn from_colum_major_array(array: [[f32; 3]; 3]) -> Mat3

pub const fn into_column_major_array(self) -> [[f32; 3]; 3]

pub const fn from_row_major_array(array: [[f32; 3]; 3]) -> Mat3

pub const fn into_row_major_array(self) -> [[f32; 3]; 3]

pub const fn from_scale(scale: Vec3) -> Mat3

pub fn from_2d_transform(pos: Vec2, scale: Vec2, rot: f32) -> Mat3

pub fn from_transform(scale: Vec3, rot: Quat) -> Mat3

pub fn from_rot(rot: Quat) -> Mat3

Examples found in repository

examples/simple-fxaa.rs (line 169)

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 const fn from_values( a: f32, b: f32, c: f32, d: f32, e: f32, f: f32, g: f32, h: f32, i: f32, ) -> Mat3

creates a matrix with the following values.

use glium_types::matrices::Mat3;
let new_matrix = Mat3::from_values(
    1.0, 0.0, 0.0,
    0.0, 1.0, 0.0,
    0.0, 0.0, 1.0
);
assert!(new_matrix == Mat3::IDENTITY);

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

pub fn determinant(&self) -> f32

pub fn inverse(&self) -> Mat3

pub const fn transpose(self) -> Mat3

pub const fn column(&self, pos: usize) -> [f32; 3]

pub const fn row(&self, pos: usize) -> [f32; 3]

Trait Implementations

impl Add for Mat3

type Output = Mat3

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Mat3

fn add_assign(&mut self, rhs: Mat3)

Performs the += operation.

impl AsUniformValue for Mat3

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

Builds a UniformValue.

impl Clone for Mat3

fn clone(&self) -> Mat3

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mat3

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

Formats the value using the given formatter.

impl Default for Mat3

fn default() -> Mat3

Returns the “default value” for a type.

impl Div<f32> for Mat3

type Output = Mat3

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Mat3

type Output = Mat3

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<f32> for Mat3

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign for Mat3

fn div_assign(&mut self, rhs: Mat3)

Performs the /= operation.

impl From<Mat2> for Mat3

fn from(value: Mat2) -> Mat3

Converts to this type from the input type.

impl From<Mat3> for Mat2

fn from(value: Mat3) -> Mat2

Converts to this type from the input type.

impl From<Mat3> for Mat4

fn from(value: Mat3) -> Mat4

Converts to this type from the input type.

impl From<Mat4> for Mat3

fn from(value: Mat4) -> Mat3

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 Index<usize> for Mat3

type Output = [f32; 3]

The returned type after indexing.

fn index(&self, index: usize) -> &<Mat3 as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Mat3

fn index_mut(&mut self, index: usize) -> &mut <Mat3 as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl Mul<Vec3> for Mat3

type Output = Vec3

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Mat3

type Output = Mat3

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Mat3

type Output = Mat3

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f32> for Mat3

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign for Mat3

fn mul_assign(&mut self, rhs: Mat3)

Performs the *= operation.

impl PartialEq for Mat3

fn eq(&self, other: &Mat3) -> 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 Rem<f32> for Mat3

type Output = Mat3

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<f32> for Mat3

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl Sub for Mat3

type Output = Mat3

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Mat3

fn sub_assign(&mut self, rhs: Mat3)

Performs the -= operation.

impl Copy for Mat3

impl StructuralPartialEq for Mat3