Struct ggez::graphics::Shader

pub struct Shader { /* private fields */ }

A custom shader that can be used to render with shader effects.

The shader may have a user specified vertex module, fragment module, both, or neither. The fragment module entry point must be named fs_main. The vertex module entry point must be named vs_main. The vertex module must have an output of type

struct VertexOutput {
    @builtin(position) position: vec4<f32>,
    @location(0) uv: vec2<f32>,
    @location(1) color: vec4<f32>,
}

if the fragment module is left unspecified (default).

Produce a Shader using ShaderBuilder.

Adapted from the shader.rs example:

use ggez::*;
use ggez::graphics::*;
use crevice::std140::AsStd140;

#[derive(AsStd140)]
struct Dim {
    rate: f32,
}

struct MainState {}

impl event::EventHandler for MainState {
    fn draw(&mut self, ctx: &mut Context) -> GameResult {
        let mut canvas = graphics::Canvas::from_frame(ctx, Color::BLACK);
        let dim = Dim { rate: 0.5 };
        // NOTE: This is for simplicity; do not recreate your shader every frame like this!
        //       For more info look at the full example.
        let shader = ShaderBuilder::new()
            .fragment_code(include_str!("../../resources/dimmer.wgsl"))
            .build(&mut ctx.gfx)?;
        let mut params = ShaderParamsBuilder::new(&dim).build(ctx);
        params.set_uniforms(ctx, &dim);

        canvas.set_shader(&shader);
        canvas.set_shader_params(&params);
        // draw something...
        canvas.finish(ctx)
    }

    /* ... */
}

Trait Implementations

impl Clone for Shader

fn clone(&self) -> Shader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Shader

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

Formats the value using the given formatter.

impl Hash for Shader

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Shader> for Shader

fn eq(&self, other: &Shader) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Shader

impl StructuralEq for Shader

impl StructuralPartialEq for Shader