Struct VertexBuffer 

pub struct VertexBuffer { /* private fields */ }

Vertex Buffer structure A vertexbuffer is an buffer object in OpenGl. Here it’s linked with VertexArray for data. The VertexBuffer is the ‘low levelest’ object that is drawable. You can create it from Vertice slice or VertexArray

use gust::window::Window;
use gust::vertex::{VertexArray, Vertex};
use gust::Drawable;

fn main() {
    let win = Window::default();
    let vertice = &[
    Vertex::new(Vector::new(0.0, 0.0), Vector::new(0.0, 0.0), Color::new(1.0, 0.0, 0.0)),
    Vertex::new(Vector::new(1.0, 0.0), Vector::new(0.0, 0.0), Color::new(1.0, 0.0, 0.0)),
    Vertex::new(Vector::new(0.0, 1.0), Vector::new(0.0, 0.0), Color::new(1.0, 0.0, 0.0)),
    ];
    let triangle = VertexBuffer::from(vertice);
    while window.is_open() {
        window.clear();
        window.draw(&triangle);
        window.display();
    }
}

Implementations

impl VertexBuffer

pub fn clear(&mut self)

Clear all data from VertexArray

pub fn new(t: Primitive, vertice: VertexArray) -> VertexBuffer

Create new Vertex Buffer from vertices

Examples found in repository

examples/shape.rs (line 74)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let vert_arr = VertexArray::from(
        vec![
            Vertex::new(
                Vector::new(800.0, 400.0),
                Vector::new(200.0, 0.0),
                Color::new(0.0, 1.0, 0.0),
            ),
            Vertex::new(
                Vector::new(1200.0, 700.0),
                Vector::new(20.0, 10.0),
                Color::new(0.0, 1.0, 1.0),
            ),
            Vertex::new(
                Vector::new(1000.0, 300.0),
                Vector::new(0.0, 0.0),
                Color::new(0.0, 0.2, 1.0),
            ),
            Vertex::new(
                Vector::new(800.0, 100.0),
                Vector::new(0.0, 0.0),
                Color::new(1.0, 1.0, 0.5),
            ),
            Vertex::new(
                Vector::new(600.0, 300.0),
                Vector::new(0.0, 0.0),
                Color::new(0.5, 0.2, 0.1),
            ),
            Vertex::new(
                Vector::new(400.0, 700.0),
                Vector::new(0.0, 0.0),
                Color::new(1.0, 0.0, 0.0),
            ),
        ]
        .as_slice(),
    );

    let vert_arr_2 = VertexArray::from(
        vec![
            Vertex::new(Vector::new(0.0, 0.0), Vector::new(0.0, 0.0), Color::blue()),
            Vertex::new(
                Vector::new(0.0, 100.0),
                Vector::new(0.0, 0.0),
                Color::blue(),
            ),
            Vertex::new(
                Vector::new(100.0, 100.0),
                Vector::new(0.0, 0.0),
                Color::blue(),
            ),
            Vertex::new(Vector::new(0.0, 0.0), Vector::new(0.0, 0.0), Color::green()),
            Vertex::new(
                Vector::new(100.0, 100.0),
                Vector::new(0.0, 0.0),
                Color::green(),
            ),
            Vertex::new(
                Vector::new(100.0, 0.0),
                Vector::new(0.0, 0.0),
                Color::green(),
            ),
        ]
        .as_slice(),
    );

    let vert_buf = VertexBuffer::new(Primitive::TriangleFan, vert_arr);
    let vert_buf2 = VertexBuffer::new(Primitive::Triangles, vert_arr_2);

    let event_handler = EventHandler::new(&window);

    window.set_clear_color(Color::red());
    window.poll(EventType::Key);
    while window.is_open() {
        window.poll_events();

        for event in event_handler.fetch() {
            match event.1 {
                Events::Key(Key::Escape, _, Action::Press, _) => {
                    window.close();
                }
                _ => {}
            }
        }

        window.clear();
        window.draw(&vert_buf);
        window.draw(&vert_buf2);
        window.display();
    }
}

pub fn append(&mut self, vertices: &[Vertex])

Append data to the actual VertexArray while be updated internaly.

pub fn get_primitive(&self) -> Primitive

pub fn set_geometry(&mut self, vertice: &[Vertex])

pub fn bind(&self)

pub fn unbind(&self)

Trait Implementations

impl Clone for VertexBuffer

fn clone(&self) -> VertexBuffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VertexBuffer

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

Formats the value using the given formatter.

impl Default for VertexBuffer

fn default() -> Self

Returns the “default value” for a type.

impl Drawable for VertexBuffer

fn draw<T: Drawer>(&self, target: &mut T)

Draw the drawable structure, you need a Drawer(Where the struct will be draw)

fn draw_with_context(&self, context: &mut Context<'_>)

Draw with a particular context

fn update(&mut self)

Update the openGL state of the drawable entity Should be call often so be carefull when implementing.

fn setup_draw(&self, context: &mut Context<'_>)

Setup the draw for the final system you don’t have to implement it in a normal drawable

impl DrawableMut for VertexBuffer

fn draw_mut<T: Drawer>(&mut self, target: &mut T)

Mutable version of draw function.

fn draw_with_context_mut(&mut self, context: &mut Context<'_>)

Mutable draw context function.

impl Drop for VertexBuffer

fn drop(&mut self)

Executes the destructor for this type.

impl Index<usize> for VertexBuffer

type Output = Vertex

The returned type after indexing.

fn index(&self, vertex_index: usize) -> &Vertex

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for VertexBuffer

fn index_mut(&mut self, index: usize) -> &mut Vertex

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

impl PartialEq for VertexBuffer

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