Struct VertexBuffer 

pub struct VertexBuffer { /* private fields */ }

A VertexBuffer is a wrapper around an opengl VAO, VBO and EBO.

It is essentially a list of vertices (positions, colors, textures, etc.) and elements (which tell opengl which order to draw/join the vertices in).

You still need to create a [f32] slice of vertex data, which can store any information you would like to be passed to the shader, and a [u32] slice telling opengl the order to draw and connect the vertices in.

It shortens the 10+ opengl calls to create the buffers into a single call of new, as well as many add_component calls as you have components.

In short, this struct allows you to manage the shapes that are drawn to the screen.

Implementations

impl VertexBuffer

pub fn new(vertices: &[f32], elements: &[u32]) -> VertexBuffer

Create a realms::VertexBuffer with the specified vertices and elements. Once created, you need to call the add_component method for each component of the vertex array to tell the shader where to find each section of the vertex data (i.e. which parts are positions, colors, texture coords, etc.).

If you don’t know what opengl vertex buffers are, they are essentially arrays storing information about the triangles to draw to the screen.

Please read https://learnopengl.com/Getting-started/Hello-Triangle (specifically the start of the “Vertex input” section) for more info on opengl indices and buffers.

Example usage:

In your rust source file:

let vertices: [f32; 24] = [
//  POSITION:      COLOR:
    0.5,  -0.5,    1.0, 0.0, 0.0, 1.0,  // bottom right
    -0.5, -0.5,    0.0, 1.0, 0.0, 1.0,  // bottom left
    -0.5, 0.5,     0.0, 0.0, 1.0, 1.0,  // top left
    0.5,  0.5,     1.0, 1.0, 1.0, 1.0,  // top right
];
let elements: [u32; 6] = [
   0, 1, 2,
   0, 3, 2,
];
let vb: VertexBuffer = VertexBuffer::new(&vertices, &elements);
vb.add_attrib(0, 2, 6, 0);
vb.add_attrib(1, 4, 6, 2);

Then, remember to specify the layouts in the vertex shader:

layout (location = 0) in vec2 aPos;  
layout (location = 1) in vec4 aColor;

Panics

Although rare, it is technically possible for this function to PANIC if the size of the vertices passed in was too large to be converted from a u32 to an i32. You probably don’t need to worry about this, unless you have over 2.1 billion vertex components (in which case you’ve got bigger problems to deal with, such as your GPU being on fire).

Examples found in repository

examples/example_5_texture.rs (line 33)

fn main() {
    let mut window =
        Window::new(600, 600, "Rendering Pictures?!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex5.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment5.glsl")).unwrap(),
    ])
    .unwrap();

    let vertices: [f32; 16] = [
        // specify type `f32` with 16 elements: 4 vertices * 4 floats each.
        //        X     Y    texX texY
        -0.5, 0.5, 0.0, 1.0, // top left of triangle, top left of texture
        -0.5, -0.5, 0.0, 0.0, // bottom left of triangle, bottom left of texture
        0.5, -0.5, 1.0, 0.0, // bottom right of triangle, bottom right of texture
        0.5, 0.5, 1.0, 1.0, // top right of triangle, top right of texture
    ];

    let elements: [u32; 6] = [0, 1, 2, 2, 3, 0];

    let vb = VertexBuffer::new(&vertices, &elements);

    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        2, // each vertex has a texture position, made up of TWO float components (x, y)
    ]);

    let texture = Texture::load_file("examples/images/parrot.png").unwrap();
    texture.bind();

    while window.is_running() {
        window.new_frame();
        window.events();

        window.fill(Color::rgb(39, 85, 163));
        vb.draw(&shader_program);
    }
}

examples/example_3_colorful_triangle.rs (line 37)

fn main() {
    let mut window = Window::new(800, 600, "Hello Colors!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex3.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment3.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the shaders have changed slightly since example 2. Please update
    // `vertex2.glsl` and `fragment2.glsl` using the new versions of them in
    // this directory.

    let vertices: [f32; 15] = [
        // specify type `f32` with 15 elements: 3 vertices * 5 floats each.
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    // See https://learnopengl.com/Getting-started/Hello-Triangle for more info.
    // Scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // tell Realms how to split up our vertices array slice:
    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        3, // each vertex has a color, made up of THREE float components (r, g, b)
    ]);

    while window.is_running() {
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40));
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_4_2d_camera.rs (line 39)

fn main() {
    let mut window = Window::new(800, 600, "We Have A Camera?").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex4.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment4.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the vertex shader has  changed since example 3. Please update
    // `vertex2.glsl` using the new versions of it in this directory.
    // The fragment shader has stayed the same.

    // all vertices are the same as in the last example
    let vertices: [f32; 15] = [
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // same attribute layout as in the last example:
    vb.set_layout(&[2, 3]);

    let (mut camera_x, mut camera_y) = (0.0, 0.0); // --NEW-- //

    while window.is_running() {
        window.new_frame();
        window.fill(Color::rgb(20, 34, 40));

        // --- NEW --- //
        for event in window.events() {
            match event {
                // here, we don't store the current state of the key, so we
                // need to move the camera by repeatedly pressing WASD.
                Event::KeyDown(Key::W) => camera_y += 0.1, // move camera up
                Event::KeyDown(Key::S) => camera_y -= 0.1, // move camera down
                Event::KeyDown(Key::A) => camera_x -= 0.1, // move camera left
                Event::KeyDown(Key::D) => camera_x += 0.1, // move camera right
                _ => {}
            }
        }
        // upload the camera position to the vertex shader using a *uniform*:
        // learn more: https://thebookofshaders.com/03/
        shader_program.uniform_2f("cameraPos", (camera_x, camera_y));
        // --- END NEW --- //

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_2_triangle.rs (line 41)

fn main() {
    // create the window and unwrap the result:
    let mut window = Window::new(800, 600, "Hello Triangle!").expect("Failed to create window");

    // create the shader program from the shaders `vertex2.glsl` and `fragment2.glsl`:
    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex2.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment2.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: you need to code the `vertex2.glsl` and `fragment2.glsl` files. Some
    // default shaders are provided for you, in the same directory as this file
    // in the files `vertex2.glsl` and `fragment2.glsl`. You can copy and paste
    // these into the SAME DIRECTORY as your example3_colorful_triangle file.

    // create an [f32] slice of vertex data:
    let vertices: [f32; 6] = [
        // specify type `f32` with 6 elements.
        //   X     Y
        0.0, 0.5, // top of triangle
        -0.5, -0.5, // bottom left of triangle
        0.5, -0.5, // bottom right of triangle
    ];

    // Create a [u32] slice listing the indices of the `vertices` array to draw.
    // Although in this case we only have one triangle, in scenes with many
    // triangles this drastically reduces the size of data sent to the GPU.
    // Read more at https://learnopengl.com/Getting-started/Hello-Triangle,
    // scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    // create a VertexBuffer using references to the `vertices` and `elements`:
    let vb = VertexBuffer::new(&vertices, &elements);

    // Tell Realms how each vertex is structured. Each vertex has a single
    // component (a position) made up of TWO float components (x and y):
    vb.set_layout(&[2]);

    // loop until the user closes the window
    while window.is_running() {
        // swap the buffers (draw to the screen) and bind our shader program:
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40)); // fill the screen dark blue
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

pub fn add_attrib( &self, layout: u32, component_count: i32, stride: i32, offset: usize, )

As the vertices array reference passed to the new function was just a slice of floats, we need to tell opengl how to split it up. For each ‘attribute’ of the vertex, call this function. For example, if you have a vertices array with 4 vertices, and each vertex was made up of a position (using two floats) and a color (using 4 floats), you would call the function twice (for each attribute):

let vb = VertexBuffer::new(...);
vb.add_attrib( // position attribute
    0, // first attrib, so layout index is 0
    2, // the position is made up of 2 floats, so 2 position components
    6, // each vertex has 6 floats (2 pos + 4 color) so stride is 6
    0, // first attrib, so no offset
)
vb.add_attrib( // color attribute
    0, // second attrib, so layout index is 1
    4, // the color is made up of 4 floats, so 4 position components
    6, // each vertex has 6 floats (2 pos + 4 color) so stride is 6
    2, // second attrib. first had 2 components, so offset is 2
)

Panics

It’s likely impossible to occur, but if the value returned by mem::size_of for the size of a GLfloat cannot be converted into a GLsizei, the program will PANIC with an expect error.

pub fn set_layout(&self, component_counts: &[i32])

Adding the vertex attributes through the add_attrib method requires a lot of boilerplate and leads to messy code. Realms can infer all of that information just from a slice of component counts.

A component count is just a number reflecting the number of floats a component is made up of. A component is some information about the vertex that your vertex shader takes in as a layout parameter.

For example, if each vertex has a position and a color, your component counts may be:

• 3 components for position (X, Y and Z)
• 4 components for color (R, G, B and A)
• Therefore your component_counts slice would be [3, 4].

Example usage

let vb = VertexBuffer::new(...);
vb.set_layout(&[
    3, // if our vertex position is made up of 3 floats (x, y, z)
    4, // if our vertex color is made up of 4 floats (r, g, b, a)
]);

Panics

If the layout could not be converted from a usize into a u32 (this could only happen if there are over 4.2 billion components) the program will PANIC. This will likely never happen.

If the sum of the components are larger than the max usize value, the program will PANIC. But you will never need that many components. Also, on 8-bit or 16-bit systems, the max value for a usize is much lower, so casting each component i32 to a usize may fail and cause a PANIC.

It’s likely impossible to occur, but if the value returned by mem::size_of for the size of a GLfloat cannot be converted into a GLsizei, the program will PANIC with an expect error. This panic is raised by the add_attrib method.

Examples found in repository

examples/example_5_texture.rs (lines 35-38)

fn main() {
    let mut window =
        Window::new(600, 600, "Rendering Pictures?!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex5.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment5.glsl")).unwrap(),
    ])
    .unwrap();

    let vertices: [f32; 16] = [
        // specify type `f32` with 16 elements: 4 vertices * 4 floats each.
        //        X     Y    texX texY
        -0.5, 0.5, 0.0, 1.0, // top left of triangle, top left of texture
        -0.5, -0.5, 0.0, 0.0, // bottom left of triangle, bottom left of texture
        0.5, -0.5, 1.0, 0.0, // bottom right of triangle, bottom right of texture
        0.5, 0.5, 1.0, 1.0, // top right of triangle, top right of texture
    ];

    let elements: [u32; 6] = [0, 1, 2, 2, 3, 0];

    let vb = VertexBuffer::new(&vertices, &elements);

    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        2, // each vertex has a texture position, made up of TWO float components (x, y)
    ]);

    let texture = Texture::load_file("examples/images/parrot.png").unwrap();
    texture.bind();

    while window.is_running() {
        window.new_frame();
        window.events();

        window.fill(Color::rgb(39, 85, 163));
        vb.draw(&shader_program);
    }
}

examples/example_3_colorful_triangle.rs (lines 40-43)

fn main() {
    let mut window = Window::new(800, 600, "Hello Colors!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex3.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment3.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the shaders have changed slightly since example 2. Please update
    // `vertex2.glsl` and `fragment2.glsl` using the new versions of them in
    // this directory.

    let vertices: [f32; 15] = [
        // specify type `f32` with 15 elements: 3 vertices * 5 floats each.
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    // See https://learnopengl.com/Getting-started/Hello-Triangle for more info.
    // Scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // tell Realms how to split up our vertices array slice:
    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        3, // each vertex has a color, made up of THREE float components (r, g, b)
    ]);

    while window.is_running() {
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40));
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_4_2d_camera.rs (line 42)

fn main() {
    let mut window = Window::new(800, 600, "We Have A Camera?").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex4.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment4.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the vertex shader has  changed since example 3. Please update
    // `vertex2.glsl` using the new versions of it in this directory.
    // The fragment shader has stayed the same.

    // all vertices are the same as in the last example
    let vertices: [f32; 15] = [
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // same attribute layout as in the last example:
    vb.set_layout(&[2, 3]);

    let (mut camera_x, mut camera_y) = (0.0, 0.0); // --NEW-- //

    while window.is_running() {
        window.new_frame();
        window.fill(Color::rgb(20, 34, 40));

        // --- NEW --- //
        for event in window.events() {
            match event {
                // here, we don't store the current state of the key, so we
                // need to move the camera by repeatedly pressing WASD.
                Event::KeyDown(Key::W) => camera_y += 0.1, // move camera up
                Event::KeyDown(Key::S) => camera_y -= 0.1, // move camera down
                Event::KeyDown(Key::A) => camera_x -= 0.1, // move camera left
                Event::KeyDown(Key::D) => camera_x += 0.1, // move camera right
                _ => {}
            }
        }
        // upload the camera position to the vertex shader using a *uniform*:
        // learn more: https://thebookofshaders.com/03/
        shader_program.uniform_2f("cameraPos", (camera_x, camera_y));
        // --- END NEW --- //

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_2_triangle.rs (line 45)

fn main() {
    // create the window and unwrap the result:
    let mut window = Window::new(800, 600, "Hello Triangle!").expect("Failed to create window");

    // create the shader program from the shaders `vertex2.glsl` and `fragment2.glsl`:
    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex2.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment2.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: you need to code the `vertex2.glsl` and `fragment2.glsl` files. Some
    // default shaders are provided for you, in the same directory as this file
    // in the files `vertex2.glsl` and `fragment2.glsl`. You can copy and paste
    // these into the SAME DIRECTORY as your example3_colorful_triangle file.

    // create an [f32] slice of vertex data:
    let vertices: [f32; 6] = [
        // specify type `f32` with 6 elements.
        //   X     Y
        0.0, 0.5, // top of triangle
        -0.5, -0.5, // bottom left of triangle
        0.5, -0.5, // bottom right of triangle
    ];

    // Create a [u32] slice listing the indices of the `vertices` array to draw.
    // Although in this case we only have one triangle, in scenes with many
    // triangles this drastically reduces the size of data sent to the GPU.
    // Read more at https://learnopengl.com/Getting-started/Hello-Triangle,
    // scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    // create a VertexBuffer using references to the `vertices` and `elements`:
    let vb = VertexBuffer::new(&vertices, &elements);

    // Tell Realms how each vertex is structured. Each vertex has a single
    // component (a position) made up of TWO float components (x and y):
    vb.set_layout(&[2]);

    // loop until the user closes the window
    while window.is_running() {
        // swap the buffers (draw to the screen) and bind our shader program:
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40)); // fill the screen dark blue
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

pub fn draw(&self, shader_program: &ShaderProgram)

Draw the vertex buffer as a series of triangles. Note that if you change the elements of the array of vertices or elements, they will not be updated in the VertexBuffer. If changing the elements, you should create a new VertexBuffer and call draw on that instead.

WARNING: This binds the VAO, VBO and EBO. It does not unbind them afterwards.

Example usage

while w.is_running() {
    w.new_frame();
    vertex_buffer.draw(&shader_program);
}

Migrating from 2.3.4 to 3.3.4

The Window::new_frame method no longer takes in a shader program reference, but the VertexBuffer::draw method now does. You should bind the shader program when calling this draw method, NOT when calling Window::new_frame.

In short, instead of doing this (pre-3.3.4):

while w.is_running() {
    w.new_frame(&shader_program);
    vertex_buffer.draw();
}

You should do this (3.3.4+):

while w.is_running() {
    w.new_frame();
    vertex_buffer.draw(&shader_program);
}

Examples found in repository

examples/example_5_texture.rs (line 48)

fn main() {
    let mut window =
        Window::new(600, 600, "Rendering Pictures?!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex5.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment5.glsl")).unwrap(),
    ])
    .unwrap();

    let vertices: [f32; 16] = [
        // specify type `f32` with 16 elements: 4 vertices * 4 floats each.
        //        X     Y    texX texY
        -0.5, 0.5, 0.0, 1.0, // top left of triangle, top left of texture
        -0.5, -0.5, 0.0, 0.0, // bottom left of triangle, bottom left of texture
        0.5, -0.5, 1.0, 0.0, // bottom right of triangle, bottom right of texture
        0.5, 0.5, 1.0, 1.0, // top right of triangle, top right of texture
    ];

    let elements: [u32; 6] = [0, 1, 2, 2, 3, 0];

    let vb = VertexBuffer::new(&vertices, &elements);

    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        2, // each vertex has a texture position, made up of TWO float components (x, y)
    ]);

    let texture = Texture::load_file("examples/images/parrot.png").unwrap();
    texture.bind();

    while window.is_running() {
        window.new_frame();
        window.events();

        window.fill(Color::rgb(39, 85, 163));
        vb.draw(&shader_program);
    }
}

examples/example_3_colorful_triangle.rs (line 51)

fn main() {
    let mut window = Window::new(800, 600, "Hello Colors!").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex3.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment3.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the shaders have changed slightly since example 2. Please update
    // `vertex2.glsl` and `fragment2.glsl` using the new versions of them in
    // this directory.

    let vertices: [f32; 15] = [
        // specify type `f32` with 15 elements: 3 vertices * 5 floats each.
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    // See https://learnopengl.com/Getting-started/Hello-Triangle for more info.
    // Scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // tell Realms how to split up our vertices array slice:
    vb.set_layout(&[
        2, // each vertex has a position, made up of TWO float components (x, y)
        3, // each vertex has a color, made up of THREE float components (r, g, b)
    ]);

    while window.is_running() {
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40));
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_4_2d_camera.rs (line 67)

fn main() {
    let mut window = Window::new(800, 600, "We Have A Camera?").expect("Failed to create window");

    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex4.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment4.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: the vertex shader has  changed since example 3. Please update
    // `vertex2.glsl` using the new versions of it in this directory.
    // The fragment shader has stayed the same.

    // all vertices are the same as in the last example
    let vertices: [f32; 15] = [
        //   X     Y     red green blue
        0.0, 0.5, 0.0, 1.0, 0.0, // top of triangle, green
        -0.5, -0.5, 1.0, 0.0, 0.0, // bottom left of triangle, red
        0.5, -0.5, 0.0, 0.0, 1.0, // bottom right of triangle, blue
    ];

    let elements: [u32; 3] = [0, 1, 2];

    let vb = VertexBuffer::new(&vertices, &elements);

    // same attribute layout as in the last example:
    vb.set_layout(&[2, 3]);

    let (mut camera_x, mut camera_y) = (0.0, 0.0); // --NEW-- //

    while window.is_running() {
        window.new_frame();
        window.fill(Color::rgb(20, 34, 40));

        // --- NEW --- //
        for event in window.events() {
            match event {
                // here, we don't store the current state of the key, so we
                // need to move the camera by repeatedly pressing WASD.
                Event::KeyDown(Key::W) => camera_y += 0.1, // move camera up
                Event::KeyDown(Key::S) => camera_y -= 0.1, // move camera down
                Event::KeyDown(Key::A) => camera_x -= 0.1, // move camera left
                Event::KeyDown(Key::D) => camera_x += 0.1, // move camera right
                _ => {}
            }
        }
        // upload the camera position to the vertex shader using a *uniform*:
        // learn more: https://thebookofshaders.com/03/
        shader_program.uniform_2f("cameraPos", (camera_x, camera_y));
        // --- END NEW --- //

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}

examples/example_2_triangle.rs (line 55)

fn main() {
    // create the window and unwrap the result:
    let mut window = Window::new(800, 600, "Hello Triangle!").expect("Failed to create window");

    // create the shader program from the shaders `vertex2.glsl` and `fragment2.glsl`:
    let shader_program = ShaderProgram::new(vec![
        Shader::load_str(ShaderType::Vertex, include_str!("shaders/vertex2.glsl")).unwrap(),
        Shader::load_str(ShaderType::Fragment, include_str!("shaders/fragment2.glsl")).unwrap(),
    ])
    .unwrap();
    // NOTE: you need to code the `vertex2.glsl` and `fragment2.glsl` files. Some
    // default shaders are provided for you, in the same directory as this file
    // in the files `vertex2.glsl` and `fragment2.glsl`. You can copy and paste
    // these into the SAME DIRECTORY as your example3_colorful_triangle file.

    // create an [f32] slice of vertex data:
    let vertices: [f32; 6] = [
        // specify type `f32` with 6 elements.
        //   X     Y
        0.0, 0.5, // top of triangle
        -0.5, -0.5, // bottom left of triangle
        0.5, -0.5, // bottom right of triangle
    ];

    // Create a [u32] slice listing the indices of the `vertices` array to draw.
    // Although in this case we only have one triangle, in scenes with many
    // triangles this drastically reduces the size of data sent to the GPU.
    // Read more at https://learnopengl.com/Getting-started/Hello-Triangle,
    // scroll to the section on Element Buffer Objects.
    let elements: [u32; 3] = [0, 1, 2];

    // create a VertexBuffer using references to the `vertices` and `elements`:
    let vb = VertexBuffer::new(&vertices, &elements);

    // Tell Realms how each vertex is structured. Each vertex has a single
    // component (a position) made up of TWO float components (x and y):
    vb.set_layout(&[2]);

    // loop until the user closes the window
    while window.is_running() {
        // swap the buffers (draw to the screen) and bind our shader program:
        window.new_frame();

        window.fill(Color::rgb(20, 34, 40)); // fill the screen dark blue
        window.events(); // we don't handle any events, but we need to poll for them anyway.

        vb.draw(&shader_program); // draw the data in our vertex buffer
    }
}