shaders.rs

extern crate raylib;
use raylib::prelude::*;

const SHADER: &str = include_str!("res/shader.fs");

pub fn main() {
    let (w, h) = (1440, 900);
    let (mut rl, thread) = raylib::init()
        .size(w, h)
        .title("raylib [shaders] example - raymarching shader")
        .build();

    let mut target = rl
        .load_render_texture(&thread, w as u32, h as u32)
        .expect("Failed to load render texture");

    let mut shader = rl.load_shader_from_memory(&thread, None, Some(SHADER));

    rl.set_target_fps(120);

    // Get shader locations for required uniforms
    let time_loc = shader.get_shader_location("iTime");
    let resolution_loc = shader.get_shader_location("iResolution");

    let resolution: [f32; 2] = [w as f32, h as f32];
    shader.set_shader_value(resolution_loc, resolution);

    let mut run_time = 0.0;

    while !rl.window_should_close() {
        let delta_time = rl.get_frame_time();
        run_time += delta_time;

        shader.set_shader_value(time_loc, run_time);

        let mut d = rl.begin_drawing(&thread);

        {
            let mut d = d.begin_texture_mode(&thread, &mut target);
            d.clear_background(Color::WHITE);
            d.draw_rectangle(
                0,
                0,
                d.get_screen_width(),
                d.get_screen_height(),
                Color::WHITE,
            );
        }

        d.clear_background(Color::RAYWHITE);

        {
            let mut d = d.begin_shader_mode(&shader);
            d.draw_texture_rec(
                &target,
                Rectangle::new(
                    0.0,
                    0.0,
                    d.get_screen_width() as f32,
                    -d.get_screen_height() as f32,
                ),
                Vector2::new(0.0, 0.0),
                Color::WHITE,
            );
        }

        d.draw_fps(10, 10);
    }
}