struct RenderOptions {
    gamma: f32,  
};
@group(2) @binding(0)
var<uniform> render_options: RenderOptions;

    result = vec4<f32>(sdr, hdr.a);

    // Map gamma while, we're at it
    result = vec4<f32>(pow(sdr, vec3<f32>(render_options.gamma)), hdr.a);

mod middleware;

    // TODO Extract most of the non-library stuff below into a middleware

    render_options_buffer: wgpu::Buffer,
    render_options_bind_group: wgpu::BindGroup,

/// Information sent to the shader to configuring rendering
#[derive(ShaderType)]
pub struct RenderOptions {
    pub gamma: f32,
}
impl Default for RenderOptions {
    fn default() -> Self {
        Self { gamma: 1.0 }
    }
}

    pub render_options: &'a RenderOptions,

        });
        let render_options = RenderOptions::default();
        let mut render_options_uniform_buffer = UniformBuffer::new(Vec::new());
        render_options_uniform_buffer
            .write(&render_options)
            .unwrap();
        let render_options_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("render options buffer"),
            contents: &render_options_uniform_buffer.into_inner(),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });
        let render_options_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                }],
                label: Some("render options bind group layout"),
            });
        let render_options_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("render options bind group"),
            layout: &render_options_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: render_options_buffer.as_entire_binding(),
            }],

                bind_group_layouts: &[&world_texture_bind_group_layout, &camera_bind_group_layout],

                bind_group_layouts: &[
                    &world_texture_bind_group_layout,
                    &camera_bind_group_layout,
                    &render_options_bind_group_layout,
                ],

            render_options_buffer,
            render_options_bind_group,

        // Update render options
        let mut uniform_buffer = UniformBuffer::new(Vec::new());
        uniform_buffer.write(input.render_options).unwrap();
        self.queue
            .write_buffer(&self.render_options_buffer, 0, &uniform_buffer.into_inner());

            final_render_pass.set_bind_group(2, &self.render_options_bind_group, &[]);

    screen::{Camera, RenderError, RenderInput, Screen},

    screen::{Camera, RenderError, RenderInput, RenderOptions, Screen},

    render_options: RenderOptions,

    pub render_options: &'a mut RenderOptions,
}
macro_rules! extract_view {
    ($game: expr) => {
        GameView {
            assets: &mut $game.assets,
            world: &mut $game.world,
            camera: &mut $game.camera,
            render_options: &mut $game.render_options,
        }
    };

        let mut render_options = RenderOptions::default();
        // The *only* time we need to manually do this, all others should use extract_view!

            render_options: &mut render_options,

            render_options,

            let mut view = GameView {
                assets: &mut self.assets,
                world: &mut self.world,
                camera: &mut self.camera,
            };

            let mut view = extract_view!(self);

        let mut view = GameView {
            assets: &mut self.assets,
            world: &mut self.world,
            camera: &mut self.camera,
        };

        let mut view = extract_view!(self);

        let mut view = GameView {
            assets: &mut self.assets,
            world: &mut self.world,
            camera: &mut self.camera,
        };

        let mut view = extract_view!(self);

            render_options: &self.render_options,

                ui.add(egui::Slider::new(&mut game.render_options.gamma, 0.0..=2.0).text("Gamma"));