onedrop_renderer/

chain_textures.rs

//! Per-chain feedback textures.
//!
//! Each rendering chain owns its own warp output, previous-frame copy,
//! final comp output, and three-level blur pyramid (plus a scratch
//! horizontal-pass target). Sharing these between chains would cross the
//! feedback streams during preset transitions — the old preset's accumulated
//! warp output must keep evolving on the secondary chain while the new
//! preset fills the primary chain. Procedural noise stays shared in
//! `GpuContext` because it is constant for the program lifetime.
//!
//! Sizes track `RenderConfig::{width, height}`; [`Self::resize`] rebuilds
//! every texture when the host window resizes.

use crate::config::RenderConfig;

/// All resolution-dependent textures consumed and produced by one
/// rendering chain.
pub struct ChainTextures {
    /// Warp pass output. Fed back into next frame's warp pass via
    /// [`Self::prev_texture`], and read by the comp pass for the current
    /// frame's display output. Display-only filters never write here so they
    /// don't leak into the feedback loop.
    pub render_texture: wgpu::Texture,
    pub render_texture_view: wgpu::TextureView,

    /// Last frame's warp output. Sampled by the warp pass on the next
    /// frame's feedback step. `copy_to_prev` swaps the current frame's
    /// `render_texture` into this slot at the end of each render.
    pub prev_texture: wgpu::Texture,
    pub prev_texture_view: wgpu::TextureView,

    /// Comp pass output for this chain. The user-visible image (after
    /// gamma + echo + anaglyph + user comp shader) — but **not** the
    /// display: secondary chains during transitions render here too, and
    /// the final-blend pipeline composites the chain's `final_texture`
    /// into the renderer's display target.
    pub final_texture: wgpu::Texture,
    pub final_texture_view: wgpu::TextureView,

    // Blur pyramid: three cumulative Gaussian-blur levels of
    // `render_texture` exposed to user comp shaders via
    // `GetBlur1/2/3`. Each level downsamples by 2× from the previous,
    // so Blur1 is ½ render, Blur2 is ¼, Blur3 is ⅛ — drops GPU cost
    // ~8× total vs. running all three at full resolution, with
    // negligible visual difference because the Gaussian kernel
    // already spreads each level far beyond a single texel. Sampling
    // is normalised UV-space, so user shaders' `GetBlur1/2/3(uv)`
    // doesn't care that the underlying texture shrank — the
    // hardware bilinear sampler handles the upscale at sample time.
    //
    // Each level needs its own horizontal-pass scratch because the
    // shared scratch idea would have forced the scratch to the
    // largest level's resolution, which defeats the savings.
    pub blur1_texture: wgpu::Texture,
    pub blur1_texture_view: wgpu::TextureView,
    pub blur1_scratch_texture: wgpu::Texture,
    pub blur1_scratch_texture_view: wgpu::TextureView,
    pub blur2_texture: wgpu::Texture,
    pub blur2_texture_view: wgpu::TextureView,
    pub blur2_scratch_texture: wgpu::Texture,
    pub blur2_scratch_texture_view: wgpu::TextureView,
    pub blur3_texture: wgpu::Texture,
    pub blur3_texture_view: wgpu::TextureView,
    pub blur3_scratch_texture: wgpu::Texture,
    pub blur3_scratch_texture_view: wgpu::TextureView,

    /// One-frame-delayed copy of the blur pyramid. Populated at the
    /// end of each frame (after the blur pipeline writes the current
    /// frame's pyramid); read by the next frame's warp pass — where
    /// a user warp shader's `GetBlur1/2/3(uv)` sample the *previous*
    /// frame's blur, mirroring how `prev_texture` mirrors the
    /// previous warp output. Required because the warp pass runs
    /// before this frame's blur pipeline; sampling this-frame's
    /// blur would be a self-dependency.
    pub prev_blur1_texture: wgpu::Texture,
    pub prev_blur1_texture_view: wgpu::TextureView,
    pub prev_blur2_texture: wgpu::Texture,
    pub prev_blur2_texture_view: wgpu::TextureView,
    pub prev_blur3_texture: wgpu::Texture,
    pub prev_blur3_texture_view: wgpu::TextureView,
}

impl ChainTextures {
    /// Allocate a fresh set of per-chain textures at the resolution + format
    /// declared by `config`. Initial contents are undefined; the first warp
    /// pass clears `render_texture` and the first `copy_to_prev` populates
    /// `prev_texture`.
    pub fn new(device: &wgpu::Device, config: &RenderConfig) -> Self {
        let render_texture = make_color_texture(device, config, "Render Texture");
        let render_texture_view =
            render_texture.create_view(&wgpu::TextureViewDescriptor::default());

        let prev_texture = make_color_texture(device, config, "Previous Frame Texture");
        let prev_texture_view = prev_texture.create_view(&wgpu::TextureViewDescriptor::default());

        let final_texture = make_color_texture(device, config, "Final Texture");
        let final_texture_view = final_texture.create_view(&wgpu::TextureViewDescriptor::default());

        // Downsampled blur dimensions. `max(1, …)` defends against
        // pathologically small render targets (e.g. headless tests at
        // 1×1) that would otherwise produce zero-area textures and
        // trip wgpu validation.
        let (b1_w, b1_h) = (config.width.max(2) / 2, config.height.max(2) / 2);
        let (b2_w, b2_h) = (config.width.max(4) / 4, config.height.max(4) / 4);
        let (b3_w, b3_h) = (config.width.max(8) / 8, config.height.max(8) / 8);

        let (blur1_texture, blur1_texture_view) =
            make_blur_texture_at(device, config, b1_w, b1_h, "Blur1 Texture");
        let (blur1_scratch_texture, blur1_scratch_texture_view) =
            make_blur_texture_at(device, config, b1_w, b1_h, "Blur1 Scratch Texture");
        let (blur2_texture, blur2_texture_view) =
            make_blur_texture_at(device, config, b2_w, b2_h, "Blur2 Texture");
        let (blur2_scratch_texture, blur2_scratch_texture_view) =
            make_blur_texture_at(device, config, b2_w, b2_h, "Blur2 Scratch Texture");
        let (blur3_texture, blur3_texture_view) =
            make_blur_texture_at(device, config, b3_w, b3_h, "Blur3 Texture");
        let (blur3_scratch_texture, blur3_scratch_texture_view) =
            make_blur_texture_at(device, config, b3_w, b3_h, "Blur3 Scratch Texture");
        let (prev_blur1_texture, prev_blur1_texture_view) =
            make_blur_texture_at(device, config, b1_w, b1_h, "Prev Blur1 Texture");
        let (prev_blur2_texture, prev_blur2_texture_view) =
            make_blur_texture_at(device, config, b2_w, b2_h, "Prev Blur2 Texture");
        let (prev_blur3_texture, prev_blur3_texture_view) =
            make_blur_texture_at(device, config, b3_w, b3_h, "Prev Blur3 Texture");

        Self {
            render_texture,
            render_texture_view,
            prev_texture,
            prev_texture_view,
            final_texture,
            final_texture_view,
            blur1_texture,
            blur1_texture_view,
            blur1_scratch_texture,
            blur1_scratch_texture_view,
            blur2_texture,
            blur2_texture_view,
            blur2_scratch_texture,
            blur2_scratch_texture_view,
            blur3_texture,
            blur3_texture_view,
            blur3_scratch_texture,
            blur3_scratch_texture_view,
            prev_blur1_texture,
            prev_blur1_texture_view,
            prev_blur2_texture,
            prev_blur2_texture_view,
            prev_blur3_texture,
            prev_blur3_texture_view,
        }
    }

    /// Re-allocate every texture at the new resolution. All `TextureView`s
    /// become invalid after this call; downstream pipelines (warp, comp,
    /// blur, custom_shape) must be rebound — see
    /// [`crate::render_chain::RenderChain::rebind_after_resize`].
    pub fn resize(&mut self, device: &wgpu::Device, config: &RenderConfig) {
        *self = Self::new(device, config);
    }

    /// Copy `blur{1,2,3}_texture` → `prev_blur{1,2,3}_texture` so the
    /// next frame's warp pass (which runs before that frame's blur
    /// pipeline) can sample a one-frame-delayed pyramid through a
    /// user-translated warp shader's `GetBlur1/2/3(uv)`. Cheap — three
    /// GPU `copy_texture_to_texture` calls on already-resident
    /// memory. Must run AFTER the blur pipeline has written this
    /// frame's `blur1/2/3` (otherwise we'd snapshot stale data).
    pub fn copy_blur_to_prev(&self, encoder: &mut wgpu::CommandEncoder, _config: &RenderConfig) {
        let zero = wgpu::Origin3d::ZERO;
        let aspect = wgpu::TextureAspect::All;
        // Each pyramid level lives at its own resolution post-
        // downsampling (½ / ¼ / ⅛), so we can't share one `Extent3d`
        // across the three copies — read it back from each source.
        for (src, dst) in [
            (&self.blur1_texture, &self.prev_blur1_texture),
            (&self.blur2_texture, &self.prev_blur2_texture),
            (&self.blur3_texture, &self.prev_blur3_texture),
        ] {
            let extent = wgpu::Extent3d {
                width: src.width(),
                height: src.height(),
                depth_or_array_layers: 1,
            };
            encoder.copy_texture_to_texture(
                wgpu::TexelCopyTextureInfo {
                    texture: src,
                    mip_level: 0,
                    origin: zero,
                    aspect,
                },
                wgpu::TexelCopyTextureInfo {
                    texture: dst,
                    mip_level: 0,
                    origin: zero,
                    aspect,
                },
                extent,
            );
        }
    }

    /// Copy `render_texture` → `prev_texture` to close the feedback loop
    /// for next frame. Must run AFTER the comp pass for the current frame
    /// has consumed `prev_texture` (the echo blend reads frame N-1's
    /// warp output via `prev_texture`).
    pub fn copy_to_prev(&self, encoder: &mut wgpu::CommandEncoder, config: &RenderConfig) {
        encoder.copy_texture_to_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &self.render_texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::TexelCopyTextureInfo {
                texture: &self.prev_texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::Extent3d {
                width: config.width,
                height: config.height,
                depth_or_array_layers: 1,
            },
        );
    }
}

fn make_color_texture(device: &wgpu::Device, config: &RenderConfig, label: &str) -> wgpu::Texture {
    device.create_texture(&wgpu::TextureDescriptor {
        label: Some(label),
        size: wgpu::Extent3d {
            width: config.width,
            height: config.height,
            depth_or_array_layers: 1,
        },
        mip_level_count: 1,
        sample_count: 1,
        dimension: wgpu::TextureDimension::D2,
        format: config.texture_format.to_wgpu(),
        usage: wgpu::TextureUsages::RENDER_ATTACHMENT
            | wgpu::TextureUsages::TEXTURE_BINDING
            | wgpu::TextureUsages::COPY_SRC
            | wgpu::TextureUsages::COPY_DST,
        view_formats: &[],
    })
}

/// Allocate a blur-stage texture at an explicit `(width, height)` —
/// the downsampled pyramid wants each level smaller than the last,
/// so the helper takes the dimensions directly rather than deriving
/// them from `config`. Texture format follows `config.texture_format`
/// so the blur output composes cleanly with `render_texture` /
/// `final_texture` in the comp pass.
fn make_blur_texture_at(
    device: &wgpu::Device,
    config: &RenderConfig,
    width: u32,
    height: u32,
    label: &str,
) -> (wgpu::Texture, wgpu::TextureView) {
    let tex = device.create_texture(&wgpu::TextureDescriptor {
        label: Some(label),
        size: wgpu::Extent3d {
            width,
            height,
            depth_or_array_layers: 1,
        },
        mip_level_count: 1,
        sample_count: 1,
        dimension: wgpu::TextureDimension::D2,
        format: config.texture_format.to_wgpu(),
        usage: wgpu::TextureUsages::RENDER_ATTACHMENT
            | wgpu::TextureUsages::TEXTURE_BINDING
            | wgpu::TextureUsages::COPY_SRC
            | wgpu::TextureUsages::COPY_DST,
        view_formats: &[],
    });
    let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
    (tex, view)
}