phosphor-crt 0.1.0

use crate::autointensity::AutoIntensityResources;
use crate::gradient::{Gradient, RgbColor};
use crate::intermediate_texture::IntermediateTextureResources;
use crate::lut_texture::LutTextureResources;
use crate::pipeline::PipelineResources;
use crate::transform::AffineTransform;
use crate::types::UniformData;
use crate::uniform_buffer::UniformBufferResources;
use crate::waveform_resources::{WaveformMode, WaveformResources};
use cgmath::{Vector2, vec2};
use wgpu::{
    CommandBuffer, Device, Queue, RenderPass, ShaderModule, ShaderModuleDescriptor, TextureFormat,
};

#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialOrd, PartialEq, Ord, Eq)]
pub struct Size<T = u32> {
    pub width: T,
    pub height: T,
}

impl<T> From<(T, T)> for Size<T> {
    fn from((width, height): (T, T)) -> Size<T> {
        Size { width, height }
    }
}

impl<T> From<[T; 2]> for Size<T> {
    fn from([width, height]: [T; 2]) -> Size<T> {
        Size { width, height }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Viewport {
    pub size: Size<f32>,
    pub origin: Vector2<f32>,
}

#[derive(thiserror::Error, Debug)]
pub enum Error {
    #[error("width and height must both greater than zero, got ({0}, {1})")]
    ZeroSize(u32, u32),
    #[error("no waveform")]
    NoWaveform,
    #[error("`render_intermediate()` must be called before to allocate necessary resource ({0})")]
    MissingResources(&'static str),
}

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
struct RenderConfig {
    #[cfg(feature = "auto-intensity")]
    calc_auto_intensity: bool,
    gamma: f32,
    intensity: f32,
    beam_radius: f32,
    decay: Decay,
    viewport: Viewport,
}

/// Renderer context.
///
/// The `Renderer` is the main entry point. It uses a multi-pass rendering pipeline:
///
/// 1. **Intermediate rendering**: Waveform segments are rendered to a high-dynamic-range texture.
/// 2. (optional) **Auto-intensity**: The maximum value of the texture is determined for normalization.
/// 3. **Post-processing**: The intermediate texture is drawn into the scene while color mapping is applied using customizable gradient LUT.
///
/// # Example
///
/// ```rust
/// use phosphor::{Renderer, gradient::{Gradient, RgbColor}};
/// use wgpu::{Device, Queue, RenderPass, TextureFormat};
///
/// # fn example(device: &Device, queue: &Queue, render_pass: &mut RenderPass) -> Result<(), Box<dyn std::error::Error>> {
/// // Create a renderer for 800x600 output
/// let mut renderer = Renderer::new(device, &TextureFormat::Bgra8Unorm, (800, 600).into());
///
/// // Set waveform data (Vec<[f32; 2]> of (x, y) coordinates)
/// let waveform: Vec<[f32;2]> = vec![[0.0, 0.0], [1.0, 1.0], [2.0, 0.5]];
/// renderer.set_waveform_xy(&waveform);
///
/// // Configure appearance
/// renderer.set_intensity(2.0);
/// renderer.set_xlim(0.0, 2.0); // Set X-axis range
/// renderer.set_ylim(-1.0, 1.0); // Set Y-axis range
///
/// // Set color gradient (black to green)
/// let gradient = Gradient::new(vec![
///     (0.0, RgbColor { r: 0.0, g: 0.0, b: 0.0 }),
///     (1.0, RgbColor { r: 0.0, g: 1.0, b: 0.0 }),
/// ]);
/// renderer.set_lut(gradient);
///
/// // Render intermediate texture
/// let intermediate_cmd = renderer.render_intermediate(queue)?;
/// queue.submit([intermediate_cmd]);
/// // The final render pass just paints the previously computed texture into your scene.
/// // For performance, it is advisable to re-use the same `RenderPass` as you use for
/// // drawing the rest of your scene, so we expect you to provide your own render pass.
/// renderer.render(render_pass)?;
/// # Ok(())
/// # }
/// ```
#[derive(Debug)]
pub struct Renderer {
    size: Size,
    device: Device,
    texture_format: TextureFormat,

    uniform_resources: UniformBufferResources,
    intermediate_texture_resources: Option<IntermediateTextureResources>,
    lut_texture_resources: LutTextureResources,
    waveform_resources: Option<WaveformResources>,
    pipeline_resources: Option<PipelineResources>,
    auto_intensity_resources: Option<AutoIntensityResources>,

    render_shader: ShaderModule,
    post_fx_shader: ShaderModule,
    decay_shader: ShaderModule,
    #[cfg(feature = "auto-intensity")]
    auto_intensity_shader: ShaderModule,

    render_config: RenderConfig,
}

impl Renderer {
    /// Creates a new waveform renderer.
    ///
    /// # Arguments
    ///
    /// * `device` - WebGPU device for GPU resource creation
    /// * `texture_format` - Target texture format for final rendering (e.g., `TextureFormat::Bgra8Unorm`)
    /// * `size` - Initial render target dimensions in pixels.
    ///
    /// # Example
    ///
    /// ```rust
    /// use phosphor::Renderer;
    /// use wgpu::{Device, TextureFormat};
    ///
    /// # fn example(device: &Device) {
    /// let renderer = Renderer::new(device, &TextureFormat::Bgra8Unorm, (1920, 1080).into());
    /// # }
    /// ```
    pub fn new(device: &Device, texture_format: &TextureFormat, size: Size) -> Renderer {
        let uniform_data = UniformBufferResources::new(device);

        let render_shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Render Shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("render.wgsl").into()),
        });
        let post_fx_shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Post-processing Shader"),
            source: wgpu::ShaderSource::Wgsl(
                include_str!(concat!(env!("OUT_DIR"), "/postfx.wgsl")).into(),
            ),
        });
        let decay_shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Decay Shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("decay.wgsl").into()),
        });

        #[cfg(feature = "auto-intensity")]
        let auto_intensity_shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Auto Intensity Shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("auto_intensity.wgsl").into()),
        });

        let viewport = Viewport {
            origin: vec2(0., -1.),
            size: [1., 2.].into(),
        };

        Renderer {
            device: device.clone(),
            size,
            intermediate_texture_resources: None,
            lut_texture_resources: LutTextureResources::new(device),
            waveform_resources: None,
            auto_intensity_resources: None,
            uniform_resources: uniform_data,
            render_config: RenderConfig {
                viewport,
                beam_radius: 6.,
                intensity: 1.,
                gamma: 1.0,
                decay: Decay::instant_redraw(),
                #[cfg(feature = "auto-intensity")]
                calc_auto_intensity: false,
            },
            texture_format: *texture_format,
            pipeline_resources: None,
            render_shader,
            post_fx_shader,
            decay_shader,
            #[cfg(feature = "auto-intensity")]
            auto_intensity_shader,
        }
    }
}

impl Renderer {
    /// Returns the current render target size in pixels.
    pub fn size(&self) -> Size {
        self.size
    }

    /// Resizes the render target and recreates internal resources.
    ///
    /// This updates the intermediate texture size and affects the apparent beam width.
    /// Must be called when the target texture dimensions change. If it mismatches the
    /// size of the final render target, then artifacts (distorted aspect ratio, ...)
    /// might be visible.
    ///
    /// # Arguments
    ///
    /// * `new_size` - New render target dimensions in pixels
    ///
    /// # Errors
    ///
    /// Returns `Error::ZeroSize` if either width or height is zero.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use phosphor::Renderer;
    /// # use wgpu::{Device, TextureFormat};
    /// # fn example(device: &Device) -> Result<(), phosphor::renderer::Error> {
    /// let mut renderer = Renderer::new(device, &TextureFormat::Bgra8Unorm, (800, 600).into());
    /// renderer.resize((1920, 1080).into())?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn resize(&mut self, new_size: Size) -> Result<()> {
        if new_size.width == 0 || new_size.height == 0 {
            return Err(Error::ZeroSize(new_size.width, new_size.height));
        }
        if self.size != new_size {
            log::info!("Setting new size: {new_size:?}");
            self.size = new_size;
            self.intermediate_texture_resources = None;
        }
        Ok(())
    }

    /// Sets the horizontal axis range (X-axis limits).
    ///
    /// Defines the range of X coordinates that will be visible in the rendered output.
    /// Values outside this range will be clipped.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use phosphor::Renderer;
    /// # use wgpu::{Device, TextureFormat};
    /// # fn example(device: &Device) {
    /// let mut renderer = Renderer::new(device, &TextureFormat::Bgra8Unorm, (800, 600).into());
    /// renderer.set_xlim(-10.0, 10.0); // Show X range from -10 to +10
    /// # }
    /// ```
    pub fn set_xlim(&mut self, left: f32, right: f32) {
        self.render_config.viewport.origin.x = f32::min(left, right);
        self.render_config.viewport.size.width = (right - left).abs();
    }

    /// Sets the vertical axis range (Y-axis limits).
    ///
    /// Defines the range of Y coordinates that will be visible in the rendered output.
    /// Values outside this range will be clipped.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use phosphor::Renderer;
    /// # use wgpu::{Device, TextureFormat};
    /// # fn example(device: &Device) {
    /// let mut renderer = Renderer::new(device, &TextureFormat::Bgra8Unorm, (800, 600).into());
    /// renderer.set_ylim(-1.0, 1.0); // Show Y range from -1 to +1
    /// # }
    /// ```
    pub fn set_ylim(&mut self, lower: f32, upper: f32) {
        self.render_config.viewport.origin.y = f32::min(lower, upper);
        self.render_config.viewport.size.height = (upper - lower).abs();
    }

    /// Sets the intensity (brightness multiplier) for the rendered waveform.
    ///
    /// Controls the overall brightness of the rendered trace. When auto-intensity is enabled
    /// (see [`Renderer::enable_auto_intensity`]), this value is multiplied with the
    /// automatically calculated intensity.
    pub fn set_intensity(&mut self, value: f32) {
        self.render_config.intensity = value;
    }

    /// Set the gamma correction value for the waveform rendering.
    pub fn set_gamma(&mut self, value: f32) {
        self.render_config.gamma = value;
    }

    /// Set the beam width (in pixels) for the waveform rendering.
    pub fn set_beam_width(&mut self, width: f32) {
        self.render_config.beam_radius = width / 2.;
    }

    /// Load the samples to draw in the next call to [`Renderer::render_intermediate()`]
    ///
    /// The x-coordinates of the samples are not given; instead they are implicitly assumed
    /// to be 0, 1, 2, ..., N-1, where N is the number of samples. This is useful for drawing
    /// a waveform where the beam sweeps uniformly from the left to the right of the screen.
    /// Use [`Renderer::set_waveform_xy()`] if you need to specify arbitrary x and y coordinates.
    ///
    /// Loading a new waveform invalidates the GPU buffer that holds the waveform data.
    pub fn set_waveform_yt(&mut self, waveform: &[f32]) {
        log::info!("Setting new YT waveform ({} samples)", waveform.len());
        if self.waveform_resources.as_ref().map(|wf| wf.mode()) != Some(WaveformMode::YT) {
            // switching the waveform mode requires switching the shader
            self.pipeline_resources = None;
        }
        // todo: reuse existing buffer
        self.waveform_resources = Some(WaveformResources::new(
            waveform,
            &self.device,
            WaveformMode::YT,
        ))
    }

    /// Load the samples to draw in the next call to [`Renderer::render_intermediate()`]
    ///
    /// Each individual sample is specified via its x and y coordinates, in a `[f32; 2]`.
    /// If the samples are uniformly spaced along the x-axis, strongly consider using
    /// [`Renderer::set_waveform_yt`] instead. It implicitly assigns x coordinates to the samples.
    /// Not only does this save some memory, it may also significantly faster because it can efficiently
    /// cull those samples with an x position outside the viewport.
    ///
    /// Loading a new waveform invalidates the GPU buffer that holds the waveform data.
    pub fn set_waveform_xy(&mut self, waveform: &[[f32; 2]]) {
        log::info!("Setting new XY waveform ({} samples)", waveform.len());
        if self.waveform_resources.as_ref().map(|wf| wf.mode()) != Some(WaveformMode::XY) {
            // switching the waveform mode requires switching the shader
            self.pipeline_resources = None;
        }
        // todo: reuse existing buffer
        self.waveform_resources = Some(WaveformResources::new(
            bytemuck::cast_slice(waveform),
            &self.device,
            WaveformMode::XY,
        ))
    }

    pub fn set_lut(&mut self, lut: impl IntoIterator<Item = (f32, RgbColor<f32>)>) {
        self.lut_texture_resources.update_lut(Gradient::new(lut));
    }
}

/// Natural decay behaviour of the simulated phosphor screen.
///
/// We provide two tuning knobs:
/// - the decay between consecutive samples in the same trace
/// - the decay between consecutive traces
///
/// The former models the finite time it takes for the scope to trace a single sweep across the screen.
/// The latter models the time between two shots.
///
/// # `screen_decay`
/// The decay factor applied to the entire phosphor screen, applied the next time when
/// [`Renderer::render_intermediate()`] is called. Each pixel is faded according to a factor
/// of `exp(-screen_decay)`. A value of either exactly 0.0 (no decay, waveforms are drawn on
/// top of each other) or `+INFINITY` (new waveforms completely erase previous ones) bypass the
/// blending logic and are slightly more efficient. A value below 0 is clamped.
///
/// # `sample_decay`
/// The decay factor applied between consecutive samples in the same trace. The very last sample
/// is painted with full nominal intensity, and the N-th sample before the last has its intensity
/// scaled by a factor `(1 - sample_decay).pow(N)`. Setting `sample_decay` to 0.0 will render all
/// samples at full intensity. A value outside the [0, 1] range is clamped.
#[derive(Debug, Copy, Clone)]
pub struct Decay {
    screen_decay: f32,
    sample_decay: f32,
}

impl Decay {
    pub fn new(mut screen_decay: f32, mut sample_decay: f32) -> Decay {
        screen_decay = screen_decay.max(0.);
        sample_decay = sample_decay.clamp(0., 1.);
        Decay {
            screen_decay,
            sample_decay,
        }
    }

    pub fn with_sample_decay(mut self, sample_decay: f32) -> Decay {
        self.sample_decay = sample_decay.clamp(0., 1.);
        self
    }

    pub fn with_screen_decay(mut self, screen_decay: f32) -> Decay {
        self.screen_decay = screen_decay.max(0.);
        self
    }
}

/// Ready-made configurations for common use cases.
impl Decay {
    /// No decay. All render commands draw on top of each other.
    pub fn no_decay() -> Decay {
        Decay {
            sample_decay: 0.,
            screen_decay: 0.,
        }
    }

    /// No sample-to-sample decay, and no persistence between traces.
    ///
    /// Useful for 'single-shot digital storage oscilloscope' applications, where e.g. a full trace
    /// is acquired once, and then frozen. The user can pan and zoom the viewport for inspecting
    /// the waveform, without the trace fading.
    ///
    /// This is what the [`Default::default()`] implementation returns.
    pub fn instant_redraw() -> Decay {
        Decay {
            screen_decay: f32::INFINITY,
            sample_decay: 0.,
        }
    }

    /// Decay simulating a continuously updated waveform with no dead-time between shots.
    ///
    /// Think of a free-running oscilloscope in XY mode.
    ///
    /// # Arguments
    ///
    /// * `time_since_last_frame` - Time (e.g. in seconds) since the last frame was drawn to the screen
    /// * `persistence` - Time (same units) for the phosphor screen to decay to 37% (1/_e_) of its original
    ///   brightness.
    /// * `trace_length` - The number of samples in the waveform about to be drawn.
    pub fn continuous_update(
        time_since_last_trace: f32,
        persistence: f32,
        trace_length: usize,
    ) -> Decay {
        Decay::new(
            time_since_last_trace / persistence,
            time_since_last_trace / persistence / (trace_length as f32),
        )
    }
}

impl Default for Decay {
    fn default() -> Self {
        Decay::instant_redraw()
    }
}

/// Methods for configuring decay behaviour.
impl Renderer {
    pub fn set_decay(&mut self, decay: Decay) {
        self.render_config.decay = decay
    }
}

/// Methods for rendering workflow.
impl Renderer {
    fn prepare(&mut self, queue: &Queue) -> Result<()> {
        self.lut_texture_resources.prepare(queue);
        if self.intermediate_texture_resources.is_none() {
            self.intermediate_texture_resources =
                Some(IntermediateTextureResources::new(self.size, &self.device));
            self.pipeline_resources = None;
        }
        let intermediate_texture_resources = self.intermediate_texture_resources.as_ref().unwrap();

        if self.auto_intensity_resources.is_none() {
            let auto_intensity_data = AutoIntensityResources::new(&self.device);
            self.auto_intensity_resources = Some(auto_intensity_data);
            #[cfg(feature = "auto-intensity")]
            self.reset_auto_intensity(queue)?;
        }

        let Some(waveform_resources) = self.waveform_resources.as_ref() else {
            return Err(Error::NoWaveform);
        };

        let auto_intensity_data = self.auto_intensity_resources.as_ref().unwrap();
        if self.pipeline_resources.is_none() {
            self.pipeline_resources = Some(PipelineResources::new(
                &self.render_shader,
                &self.decay_shader,
                &self.post_fx_shader,
                #[cfg(feature = "auto-intensity")]
                &self.auto_intensity_shader,
                &self.device,
                &self.texture_format,
                intermediate_texture_resources,
                &self.lut_texture_resources,
                &self.uniform_resources,
                waveform_resources,
                auto_intensity_data,
            ));
        }

        self.update_uniform_buffer(queue);

        #[cfg(feature = "auto-intensity")]
        if self.render_config.calc_auto_intensity {
            // reset the auto-intensity value to its minimum. The shader performs atomic
            // max operations, and thus can only increase it.
            self.set_auto_intensity_value(queue, 1)?;
        }

        Ok(())
    }

    fn update_uniform_buffer(&mut self, queue: &Queue) {
        let transform = AffineTransform::new()
            .translate(
                -self.render_config.viewport.origin.x,
                -self.render_config.viewport.origin.y,
            )
            .scale(
                1. / self.render_config.viewport.size.width,
                1. / self.render_config.viewport.size.height,
            )
            .scale(self.size.width as f32, self.size.height as f32)
            .wgpu_mat3x3();

        let uniform_data = UniformData {
            resolution: [self.size.width, self.size.height],
            transform,
            beam_radius: self.render_config.beam_radius,
            intensity: self.render_config.intensity,
            gamma: self.render_config.gamma,
            decay_per_sample: self.render_config.decay.sample_decay,
            num_samples: self
                .waveform_resources
                .as_ref()
                .map(|wf| wf.num_samples())
                .unwrap_or(0) as u32,
            screen_decay: self.render_config.decay.screen_decay,
        };
        self.uniform_resources.update_data(queue, uniform_data);
    }

    /// Render the waveform into intermediate texture.
    ///
    /// Enqueue the resulting command buffer before `render()`, to update the intermediate
    /// waveform texture. For large waveforms especially, this is the more expensive pass.
    ///
    /// This method automatically prepares resources as needed before rendering.
    pub fn render_intermediate(&mut self, queue: &Queue) -> Result<CommandBuffer> {
        self.prepare(queue)?;
        let texture_data = self
            .intermediate_texture_resources
            .as_ref()
            .expect("texture_data is missing");
        let pipelines = self
            .pipeline_resources
            .as_ref()
            .expect("pipeline_data is missing");

        let Some(waveform_resources) = &self.waveform_resources else {
            return Err(Error::NoWaveform);
        };

        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("Encoder"),
            });
        {
            // Determine load operation based on screen decay and initialization state
            let load_op = if self.render_config.decay.screen_decay == f32::INFINITY
                || !texture_data.is_texture_initialized()
            {
                texture_data.assume_texture_initialized();
                wgpu::LoadOp::Clear(wgpu::Color::BLACK)
            } else {
                wgpu::LoadOp::Load
            };

            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Render Pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: texture_data.texture_view(),
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: load_op,
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
                occlusion_query_set: None,
                timestamp_writes: None,
            });

            // Apply screen decay if needed
            if self.render_config.decay.screen_decay > 0.0
                && self.render_config.decay.screen_decay != f32::INFINITY
            {
                render_pass.set_pipeline(pipelines.decay_pipeline());
                render_pass.set_bind_group(0, self.uniform_resources.bind_group(), &[]);
                render_pass.draw(0..3, 0..1); // Draw full-screen triangle
            }

            // Render waveform
            render_pass.set_pipeline(pipelines.render_pipeline());
            render_pass.set_bind_group(0, self.uniform_resources.bind_group(), &[]);
            // We need at least 2 samples to draw a segment.
            if waveform_resources.num_samples() >= 2 {
                // In YT mode, we can cull a significant chunk of the waveform just based on the horizontal
                // extent of the viewport. In XY mode, this is not possible.
                let (start_index, end_index) = match waveform_resources.mode() {
                    WaveformMode::YT => {
                        // valid (!) indices into the waveform array that (maybe) are just outside the viewport
                        let start_index: u32 =
                            (self.render_config.viewport.origin.x.floor().max(0.) as i32)
                                .min(waveform_resources.num_samples() as i32 - 1)
                                .try_into()
                                .unwrap();
                        let end_index: u32 = ((self.render_config.viewport.origin.x
                            + self.render_config.viewport.size.width)
                            .ceil()
                            .max(0.) as i32)
                            .min(waveform_resources.num_samples() as i32 - 1)
                            .try_into()
                            .unwrap();
                        (start_index, end_index)
                    }
                    WaveformMode::XY => (0, waveform_resources.num_samples() as u32 - 1),
                };

                // Draw even numbered line segments...
                let span = end_index - start_index;
                render_pass.set_vertex_buffer(0, waveform_resources.buffer().slice(..));
                render_pass.draw(0..4, (start_index / 2)..(start_index + span).div_ceil(2));

                // ... and the odd numbered ones.
                let stride = waveform_resources.samples_size_bytes() as u64;
                render_pass.set_vertex_buffer(0, waveform_resources.buffer().slice(stride..));
                render_pass.draw(4..8, (start_index / 2)..(start_index + span) / 2);
            }
        }
        #[cfg(feature = "auto-intensity")]
        if self.render_config.calc_auto_intensity {
            let auto_intensity_data = self
                .auto_intensity_resources
                .as_ref()
                .expect("auto_intensity_data is missing");
            let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
                label: Some("Auto Intensity Compute Pass"),
                timestamp_writes: None,
            });
            compute_pass.set_pipeline(pipelines.auto_intensity_pipeline());
            compute_pass.set_bind_group(0, texture_data.bind_group(), &[]);
            compute_pass.set_bind_group(1, auto_intensity_data.bind_group_compute(), &[]);
            compute_pass.dispatch_workgroups(
                self.size.width.div_ceil(16),
                self.size.height.div_ceil(16),
                1,
            );
        }

        Ok(encoder.finish())
    }

    /// Render final output using caller-provided render pass.
    ///
    /// This just composites a texture into the output buffer, so it is a fairly inexpensive
    /// operation.
    pub fn render(&self, render_pass: &mut RenderPass) -> Result<()> {
        let Some(ref intermediate_texture_data) = self.intermediate_texture_resources else {
            return Err(Error::MissingResources("intermediate_texture_data"));
        };
        let Some(auto_intensity_data) = &self.auto_intensity_resources else {
            return Err(Error::MissingResources("auto_intensity_data"));
        };
        let Some(ref pipelines) = self.pipeline_resources else {
            return Err(Error::MissingResources("pipeline_data"));
        };
        render_pass.set_pipeline(pipelines.post_fx_pipeline());
        render_pass.set_bind_group(0, intermediate_texture_data.bind_group(), &[]);
        render_pass.set_bind_group(1, self.lut_texture_resources.bind_group(), &[]);
        render_pass.set_bind_group(2, auto_intensity_data.bind_group_fragment(), &[]);
        render_pass.set_bind_group(3, self.uniform_resources.bind_group(), &[]);
        render_pass.draw(0..3, 0..1);
        Ok(())
    }
}

/// The following methods require feature flag `auto-intensity`.
#[cfg(feature = "auto-intensity")]
impl Renderer {
    /// Enable automatic intensity calculation during subsequent calls to [`Renderer::render_intermediate()`].
    ///
    /// When drawing the trace, it will be normalized to the brightest pixel. A manually specified
    /// intensity ([`Renderer::set_intensity()`]) will be applied to the normalized value.
    /// The auto-intensity calculation will remain enabled for subsequent frames until disabled again.
    /// Once disabled, the last normalization factor will stay in use until
    /// [`Renderer::reset_auto_intensity()`] is called.
    pub fn enable_auto_intensity(&mut self, value: bool) {
        if value != self.render_config.calc_auto_intensity {
            log::info!("Auto-intensity enabled: {value:?}");
            self.render_config.calc_auto_intensity = value
        }
    }

    /// Reset the previously computed auto-intensity to the default value.
    ///
    /// Note: this will not disable re-computation of the auto-intensity in the next frame.
    /// Call [`Renderer::enable_auto_intensity`]`(false)` instead.
    pub fn reset_auto_intensity(&self, queue: &Queue) -> Result<()> {
        log::info!("Resetting auto-intensity value to default");
        self.set_auto_intensity_value(queue, 1 << 16)
    }

    fn set_auto_intensity_value(&self, queue: &Queue, value: u32) -> Result<()> {
        let Some(ref auto_intensity_data) = self.auto_intensity_resources else {
            return Err(Error::MissingResources("auto_intensity_data"));
        };
        log::debug!("Setting auto-intensity value to {value}");
        queue.write_buffer(
            auto_intensity_data.max_value_buffer(),
            0,
            bytemuck::cast_slice(&[value]),
        );

        Ok(())
    }
}