Struct WgpuBlur 

pub struct WgpuBlur { /* private fields */ }

The wgpu implementation of BackdropBlur. Holds the fixed pipeline machinery (bind-group layout, sampler, Gaussian/downsample/upsample pipelines) and the per-(size) scratch (Gaussian ping-pong + dual-Kawase pyramid) + per-target-format composite caches, so repeated frosted surfaces reuse them.

Implementations

impl WgpuBlur

pub fn new(device: &Device) -> Self

Build the fixed pipeline machinery. The Gaussian pipeline (always writing the internal scratch format) is built now; composite pipelines are built lazily per target format.

Trait Implementations

impl BackdropBlur for WgpuBlur

type Device = Device

The GPU device (wgpu::Device; glow::Context).

type Queue = Queue

The upload queue (wgpu::Queue; () for glow, which uploads via the context).

type Encoder = CommandEncoder

The command sink (wgpu::CommandEncoder; glow::Context, the immediate-mode handle).

type SourceTexture = SourceView

A sampleable backdrop (wgpu::TextureView; glow::Texture). Own-loop backends receive it from the host; grab-pass backends produce it via GrabPass::grab_source.

type Target = TextureView

The composite destination (wgpu::TextureView; a glow framebuffer).

type TargetFormat = TextureFormat

The target’s color format (wgpu::TextureFormat; a GLES internal-format enum). Passed to prepare because wgpu bakes the fragment-target format into the composite pipeline at creation, so the pipeline is cached per format.

type Prepared = WgpuPrepared

An owned, opaque per-call handle carrying the resolved payload (kernel offsets, tint, ResolvedMask, target rect, and the resource keys) from prepare to record. Owned — it borrows nothing from the blurrer.

fn prepare( &mut self, device: &Self::Device, _queue: &Self::Queue, source: &Self::SourceTexture, target_format: Self::TargetFormat, request: &BlurRequest, ) -> Result<Option<Self::Prepared>, BlurError>

Phase 1 — holds the device + queue. Allocates and keys the ping-pong chain, lazily builds and caches pipelines (the fixed-scratch down/up pipelines once; the composite pipeline per target_format), and resolves the payload into an owned Prepared.

fn record( &self, encoder: &mut Self::Encoder, target: &Self::Target, prepared: &Self::Prepared, ) -> Result<(), BlurError>

Phase 2 — holds only the encoder + target. Records downsample → upsample → composite for a prepared produced earlier in the same frame.