Struct Shader 

pub struct Shader { /* private fields */ }

Implementations

impl Shader

pub fn compile( vertex_src: &str, fragment_src: &str, geometry_src: Option<&str>, ) -> Result<Self, String>

Examples found in repository

examples/transforms.rs (line 41)

fn main() {
    let vertices: Vec<GLfloat> = vec![
        -10.0, 0.0,  // bottom-left
        10.0, 0.0,  // bottom-right
        0.0,  10.0, // top-center
    ];
    let values_per_vertex = 2;

    let window = Window::new("Transform", 800, 600);
    let mut geometry = Geometry::new(GL_TRIANGLES);
    geometry.add_buffer(&vertices, values_per_vertex);
    geometry.add_vertex_attribute(Attribute::new(0, 2, 2, 0));

    let vertex_shader_source = include_str!("shaders/transform.vert");
    let fragment_shader_source = include_str!("shaders/transform.frag");

    let shader = Shader::compile(vertex_shader_source, fragment_shader_source, None)
        .expect("Failed to compile shader");

    let mut mesh = Mesh::new(Rc::new(shader), geometry);
    let renderer = Renderer::new(window.handle());
    let mut app = App::new(window);

    app.on_render(move || {
        // Get current viewport size in case window was resized
        let (width, height) = renderer.viewport_size();

        let transform = build_transform(width as f32, height as f32, renderer.get_time());
        mesh.set_transform(transform);

        renderer.draw_mesh(&mesh)
    });

    app.run();
}

examples/triangle.rs (line 41)

fn main() {
    let window = Window::new("Hello Window", 800, 600);


    let vertex_shader_source = include_str!("shaders/geometry.vert");
    let fragment_shader_source = include_str!("shaders/geometry.frag");

    /* 5 values per vertex: x,y,r,g,b */
    let vertices: Vec<GLfloat> = vec![
        /* bottom right */ 0.5, -0.5, /*color */ 1.0, 0.0, 0.0,
        /* bottom left */ -0.5, -0.5, /*color */ 0.0, 1.0, 0.0,
        /* top */ 0.0, 0.5, /*color */ 0.0, 0.0, 1.0,
    ];

    let position_values_per_vertex = 2;
    let color_values_per_vertex = 3;
    let values_per_vertex = 5;


    let mut geometry = Geometry::new(GL_TRIANGLES);
    geometry.add_buffer(&vertices, values_per_vertex);

    let position_attribute =
        Attribute::new(0, position_values_per_vertex, values_per_vertex as usize, 0);
    geometry.add_vertex_attribute(position_attribute);

    let color_attribute = Attribute::new(
        1,
        color_values_per_vertex,
        values_per_vertex as usize,
        position_values_per_vertex as usize,
    );
    geometry.add_vertex_attribute(color_attribute);

    let shader = Shader::compile(vertex_shader_source, fragment_shader_source, None)
        .expect("Failed to compile shader");

    let mesh = Mesh::new(Rc::new(shader), geometry);

    let renderer = Renderer::new(window.handle());
    let mut app = App::new(window);

    app.on_render(move || {
        renderer.draw_mesh(&mesh)
    });
    app.run();
}

examples/waypoints.rs (lines 45-49)

fn main() {
    let wgs84_coordinates = vec![
        6.1432, 46.2044, // Geneva
        6.6323, 46.5197, // Lausanne
        7.4474, 46.9480, // Bern
        8.2457, 46.8959, // Sarnen
        8.5417, 47.3769, // Zurich
        9.8355, 46.4908, // St-Moritz
    ];

    let mut  window = Window::new("Hello, Switzerland", 800, 600);

    window.on_scroll(move |_, y_offset| {
        MAP_BOUNDS.with(|bounds| {
            let mut b = bounds.borrow_mut();

            let center_long = (b[0] + b[2]) / 2.0;
            let center_lat = (b[1] + b[3]) / 2.0;
            let zoom_factor = if y_offset > 0.0 { 0.95 } else { 1.05 };

            b[0] = center_long + (b[0] - center_long) * zoom_factor;
            b[1] = center_lat + (b[1] - center_lat) * zoom_factor;
            b[2] = center_long + (b[2] - center_long) * zoom_factor;
            b[3] = center_lat + (b[3] - center_lat) * zoom_factor;
        });
    });

    let vertex_shader_source = include_str!("shaders/waypoints.vert");
    let fragment_shader_source = include_str!("shaders/waypoints.frag");
    let geometry_shader_source = include_str!("shaders/waypoints.geom");

    let shader = Shader::compile(
        vertex_shader_source,
        fragment_shader_source,
        Some(geometry_shader_source),
    )
    .expect("Failed to compile shader");

    let mut geometry = Geometry::new(GL_POINTS);

    geometry.add_buffer(&wgs84_coordinates, 2);
    geometry.add_vertex_attribute(Attribute::new(0, 2, 2usize, 0));

    let mesh = Mesh::new(Rc::new(shader), geometry);

    let renderer = Renderer::new(window.handle());
    renderer.set_point_size(5.0);

    let mut app = App::new(window);


    app.on_render(move || {
        MAP_BOUNDS.with(|bounds| {
            mesh.set_uniform_4f("map_bounds", &bounds.borrow());
        });
        renderer.draw_mesh(&mesh);
    });
    app.run();
}

pub fn use_program(&self)

pub fn program(&self) -> GLuint

Trait Implementations

impl Drop for Shader

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.