Struct Vertex 

pub struct Vertex {
    pub pos: Vector2<f32>,
    pub tex: Vector2<f32>,
    pub color: Color,
}

Vertex structure defined by texture coord, space coors and color

Fields

pos: Vector2<f32>

tex: Vector2<f32>

color: Color

Implementations

impl Vertex

pub fn new(pos: Vector2<f32>, tex: Vector2<f32>, color: Color) -> Vertex

Create a vertex containing position, texCoord and Color

Examples found in repository

examples/shape.rs (lines 12-16)

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();
    }
}

Trait Implementations

impl Clone for Vertex

fn clone(&self) -> Vertex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vertex

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

Formats the value using the given formatter.

impl Default for Vertex

fn default() -> Vertex

Default vertex

impl From<(Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2>>::Buffer>, Color)> for Vertex

fn from(datas: (Vector2<f32>, Color)) -> Vertex

datas.0 = pos datas.1 = color

impl From<(Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2>>::Buffer>, Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2>>::Buffer>)> for Vertex

fn from(datas: (Vector2<f32>, Vector2<f32>)) -> Vertex

datas.0 = position datas.1 = texCoord

impl From<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2>>::Buffer>> for Vertex

fn from(pos: Vector2<f32>) -> Vertex

create a vertex with just a position in 2D space

impl PartialEq for Vertex

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

impl StructuralPartialEq for Vertex