Struct Program

pub struct Program { /* private fields */ }

A combination of shaders linked together.

Implementations

impl Program

pub fn new<'a, F, I>( facade: &F, input: I, ) -> Result<Program, ProgramCreationError>

where I: Into<ProgramCreationInput<'a>>, F: Facade + ?Sized,

Builds a new program.

pub fn from_source<'a, F>( facade: &F, vertex_shader: &'a str, fragment_shader: &'a str, geometry_shader: Option<&'a str>, ) -> Result<Program, ProgramCreationError>

where F: Facade + ?Sized,

Builds a new program from GLSL source code.

A program is a group of shaders linked together.

Parameters

• vertex_shader: Source code of the vertex shader.
• fragment_shader: Source code of the fragment shader.
• geometry_shader: Source code of the geometry shader.

Example

let program = glium::Program::from_source(&display, vertex_source, fragment_source,
    Some(geometry_source));

Examples found in repository

examples/simple.rs (lines 56-67)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (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 )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);
        window.set_title("Walk Test");

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view and gravity
        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 += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

examples/simple-fxaa.rs (lines 71-88)

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
        );
        let (teapot_indices, teapot_vertices, teapot_uvs, teapot_normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &[] as &[TextureCoords; 0], &teapot::NORMALS
        );

        let program = Program::from_source(
            display, shaders::VERTEX,
            "#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, shaders::SCREEN_VERTEX, 
            "#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 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 view = Mat4::view_matrix_3d(size, 1.0, 1024.0, 0.1);

        // set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.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 view
        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 += move_dir.transform(&Mat3::from_rot(rx));

        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! {
                view: view,
                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 fn get_binary(&self) -> Result<Binary, GetBinaryError>

Returns the program’s compiled binary.

You can store the result in a file, then reload it later. This avoids having to compile the source code every time.

pub fn get_frag_data_location(&self, name: &str) -> Option<u32>

Returns the location of an output fragment, if it exists.

The location is low-level information that is used internally by glium. You probably don’t need to call this function.

You can declare output fragments in your shaders by writing:

out vec4 foo;

pub fn get_uniform(&self, name: &str) -> Option<&Uniform>

Returns informations about a uniform variable, if it exists.

pub fn uniforms(&self) -> Iter<'_, String, Uniform>

Returns an iterator to the list of uniforms.

Example

for (name, uniform) in program.uniforms() {
    println!("Name: {} - Type: {:?}", name, uniform.ty);
}

pub fn get_uniform_blocks( &self, ) -> &HashMap<String, UniformBlock, BuildHasherDefault<FnvHasher>>

Returns a list of uniform blocks.

Example

for (name, uniform) in program.get_uniform_blocks() {
    println!("Name: {}", name);
}

pub fn get_transform_feedback_buffers(&self) -> &[TransformFeedbackBuffer]

Returns the list of transform feedback varyings.

pub fn transform_feedback_matches( &self, format: &&'static [(Cow<'static, str>, usize, i32, AttributeType, bool)], stride: usize, ) -> bool

True if the transform feedback output of this program matches the specified VertexFormat and stride.

The stride is the number of bytes between two vertices.

pub fn get_output_primitives(&self) -> Option<OutputPrimitives>

Returns the type of geometry that transform feedback would generate, or None if it depends on the vertex/index data passed when drawing.

This corresponds to GL_GEOMETRY_OUTPUT_TYPE or GL_TESS_GEN_MODE. If the program doesn’t contain either a geometry shader or a tessellation evaluation shader, returns None.

pub fn has_tessellation_shaders(&self) -> bool

Returns true if the program contains a tessellation stage.

pub fn has_tessellation_control_shader(&self) -> bool

Returns true if the program contains a tessellation control stage.

pub fn has_tessellation_evaluation_shader(&self) -> bool

Returns true if the program contains a tessellation evaluation stage.

pub fn has_geometry_shader(&self) -> bool

Returns true if the program contains a geometry shader.

pub fn get_attribute(&self, name: &str) -> Option<&Attribute>

Returns informations about an attribute, if it exists.

pub fn attributes(&self) -> Iter<'_, String, Attribute>

Returns an iterator to the list of attributes.

Example

for (name, attribute) in program.attributes() {
    println!("Name: {} - Type: {:?}", name, attribute.ty);
}

pub fn has_srgb_output(&self) -> bool

Returns true if the program has been configured to output sRGB instead of RGB.

pub fn get_shader_storage_blocks( &self, ) -> &HashMap<String, UniformBlock, BuildHasherDefault<FnvHasher>>

Returns the list of shader storage blocks.

Example

for (name, uniform) in program.get_shader_storage_blocks() {
    println!("Name: {}", name);
}

pub fn get_atomic_counters( &self, ) -> &HashMap<String, UniformBlock, BuildHasherDefault<FnvHasher>>

Returns the list of shader storage blocks.

Example

for (name, uniform) in program.get_atomic_counters() {
    println!("Name: {}", name);
}

pub fn get_subroutine_uniforms( &self, ) -> &HashMap<(String, ShaderStage), SubroutineUniform, BuildHasherDefault<FnvHasher>>

Returns the subroutine uniforms of this program.

Since subroutine uniforms are unique per shader and not per program, the keys of the HashMap are in the format ("subroutine_name", ShaderStage).

Example

for (&(ref name, shader), uniform) in program.get_subroutine_uniforms() {
    println!("Name: {}", name);
}

pub fn uses_point_size(&self) -> bool

Returns true if the program has been configured to use the gl_PointSize variable.

If the program uses gl_PointSize without having been configured appropriately, then setting the value of gl_PointSize will have no effect.

Trait Implementations

impl Debug for Program

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

Formats the value using the given formatter.

impl GlObject for Program

type Id = Handle

The type of identifier for this object.

fn get_id(&self) -> Handle

Returns the id of the object.