//! The wgpu viewport renderer. Independent of any UI toolkit: the shell calls [`Renderer::prepare`] //! with an encoder (offscreen render into per-view targets) and [`Renderer::blit`] inside its //! own render pass. //! //! Per view and frame: the scene pass (MSAA, linear HDR premultiplied by scene coverage, resolved) //! → the scene effects (only when on: a G-buffer pass, the screen-space subsurface blur and the //! depth of field, see fx.wgsl) → the bloom pyramid (only when bloom is on) → the post pass (flat //! studio backdrop, exposure, //! tone mapping, effects, sRGB) into the view's RGBA8 target that [`Renderer::blit`] and //! [`Renderer::read_view`] use. The key-light shadow map is re-rendered only when the mesh, the //! light direction or the visible texture sets change. //! //! Temporal anti-aliasing (idle accumulation): while a 3D view's frame and the scene content stay //! the same, each new frame renders with a sub-pixel jitter and is averaged into the view's //! accumulation target, up to [`TAA_SAMPLES`] frames (4× MSAA each); then the view stops //! rendering until something changes. [`Renderer::accumulating`] tells the shell to keep redrawing. //! //! Screen-space refraction (sets with a Transmission channel): the scene pass first renders //! without the transmissive surfaces into the view's `behind` target (with mips for rough //! glass), then transmissive surfaces refract that image, falling back to the environment where //! the refracted ray leaves the view or shows nothing. Displacement draws a dense copy of the //! mesh ([`crate::subdivide`]) moved along its normals by the height channel in the vertex shader. use std::collections::HashMap; use bytemuck::{Pod, Zeroable}; use texturecraft_compose::{DisplayKind, ImageRes}; use texturecraft_core::{Channel, DisplaySettings, Project, ToneMapping}; use texturecraft_geom::glam::{Mat4, Vec3}; use texturecraft_geom::{Mesh, OrbitCamera}; use texturecraft_texel::TILE; use crate::gpu_trace::{Checked, checked}; use crate::ibl; use crate::subdivide::{self, Vertex}; pub const MSAA: u32 = 4; pub const COLOR_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm; pub const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float; /// Scene (pre tone mapping) format where float targets are renderable. pub const HDR_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float; /// Prefiltered environment levels (roughness 0..1). pub const ENV_LEVELS: u32 = 6; const SHADOW_SIZE: u32 = 2048; /// Bloom pyramid levels (1/2 .. 1/32 resolution). const BLOOM_LEVELS: u32 = 5; /// Bright-pass threshold on the exposed scene value, and the glow gain at strength 1. const BLOOM_THRESHOLD: f32 = 1.0; const BLOOM_GAIN: f32 = 0.15; /// Frames averaged by idle accumulation (temporal anti-aliasing). pub const TAA_SAMPLES: u32 = 16; /// Largest depth of field blur radius, as a fraction of the view height. const MAX_COC: f32 = 0.03; /// Mip levels of the refraction source (the roughest glass reads 1/64 resolution). const BEHIND_LEVELS: u32 = 7; /// How far refracted rays travel before they look up the scene behind, as a fraction of the /// mesh's bounding radius (no thickness channel: a constant, like a thin shell). const REFRACTION_DEPTH: f32 = 0.2; #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] struct GlobalsRaw { view_proj: [[f32; 4]; 4], inv_view_proj: [[f32; 4]; 4], eye: [f32; 4], env: [f32; 4], sh: [[f32; 4]; 9], mode: [f32; 4], bg: [f32; 4], uv_xform: [f32; 4], light: [f32; 4], light_vp: [[f32; 4]; 4], shadow: [f32; 4], material: [f32; 4], scatter: [f32; 4], fwd: [f32; 4], disp: [f32; 4], refr: [f32; 4], } /// The post pass uniform (see `Post` in post.wgsl). #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] struct PostRaw { a: [f32; 4], b: [f32; 4], c: [f32; 4], d: [f32; 4], e: [f32; 4], } #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] struct BlitRaw { rect: [f32; 4], dst: [f32; 4], } /// How the material is shaded (from the project's display settings and the view mode). #[derive(Clone, Copy, Debug, PartialEq)] pub struct Shade { /// Exposure in EV, applied in the post pass (not to data views). pub exposure_ev: f32, /// ACES filmic tone mapping (else linear, clipped). pub aces: bool, pub env_rotation_deg: f32, /// 0..1 → background blur level. pub env_blur: f32, pub env_opacity: f32, pub ao_intensity: f32, pub height_strength: f32, /// -1 for DirectX normal maps in the normal channel, 1 for OpenGL. pub normal_y: f32, /// 0 material, 1 channel, 2 mesh map (aux texture), 3 UV checker. pub view_mode: u32, /// Channel index for view mode 1 (channel order, see the shader). pub channel: u32, /// Direction to an optional key light and its intensity (0 = off). The direction is in /// environment space: it turns with `env_rotation_deg` like the lights painted into the /// environment, so rotating the environment sweeps the key light and its shadows too. pub light: [f32; 4], /// Draw the UV wireframe in the 2D view. pub wireframe: bool, /// Key-light shadow map (needs `light[3] > 0`; 3D material view only). Shadows dim the key /// light, not the image-based lighting. pub shadows: bool, /// Master switch of the effects below ("Post effects"); off costs no extra pass. /// Effects never apply to data views (channels, mesh maps, UV checker, 2D view). pub post_effects: bool, /// Effect strengths, 0..1. pub bloom: f32, pub vignette: f32, pub sharpen: f32, pub grain: f32, /// Draw the mesh edges over the shaded 3D view (depth tested). pub wireframe_3d: bool, /// Specular/glossiness shading: base color is the diffuse color and the Specular channel the /// F0 color (roughness arrives as 1 - glossiness from the display conversion). pub spec_gloss: bool, /// Parallax occlusion mapping from the height channel (3D view). pub parallax: bool, /// Idle accumulation of jittered frames in the 3D view. pub taa: bool, /// Per-channel diffuse wrap where the scattering weight is 1 (0 = plain Lambert), see /// [`scatter_wrap`]. pub scatter: [f32; 3], /// Index of refraction of the Transmission channel. pub ior: f32, /// Depth of field (3D material view): focus depth along the view axis (0: the orbit /// target) and lens radius as a fraction of the mesh's bounding radius. pub dof: Option<[f32; 2]>, /// Screen-space subsurface blur of the scattering diffuse light (3D material view): mean /// free path per color channel as a fraction of the mesh's bounding radius. Set by /// [`Shade::from_project`] for projects with a Scattering weight channel. pub sss_blur: Option<[f32; 3]>, /// Transmissive surfaces refract the scene behind them (3D material view; an extra pass). /// Set by [`Shade::from_project`] for projects with a Transmission channel. pub refraction: bool, /// Move the surface by the height channel (3D view): a dense copy of the mesh, displaced in /// the vertex shader at the height-to-normal strength. pub displacement: bool, } /// The viewport's subsurface scattering approximation: the diffuse lighting wraps around the /// terminator by `min(1, 4 × radius × color)` per channel (radius as a fraction of the mesh /// size, about the softening angle on mesh-scale curvature; the path tracer walks the real /// distance). pub fn scatter_wrap(d: &DisplaySettings) -> [f32; 3] { d.scatter_color.map(|c| (4.0 * d.scatter_radius.max(0.0) * c.max(0.0)).min(1.0)) } impl Shade { /// The project-level shading (display and shader settings); the caller adds the view mode, /// channel, height strength and wireframe toggles. pub fn from_display(d: &DisplaySettings) -> Shade { Shade { exposure_ev: d.env_exposure, aces: d.tone_mapping == ToneMapping::AcesFilmic, env_rotation_deg: d.env_rotation, env_blur: d.env_blur, env_opacity: d.env_opacity, ao_intensity: d.ao_intensity, // The key light (on with shadows), in environment space. light: if d.shadows { [0.5, 0.8, 0.4, 2.5] } else { [0.0; 4] }, shadows: d.shadows, post_effects: d.post_effects, bloom: d.bloom, vignette: d.vignette, sharpen: d.sharpen, grain: d.grain, spec_gloss: d.spec_gloss, parallax: d.parallax, taa: d.taa, scatter: scatter_wrap(d), ior: d.ior, dof: d.dof.enabled.then_some([d.dof.focus_distance, d.dof.aperture]), displacement: d.displacement, ..Shade::default() } } /// [`Shade::from_display`] of the project's settings, plus the subsurface blur where a /// texture set has the Scattering weight channel and refraction where one has Transmission. pub fn from_project(p: &Project) -> Shade { let d = &p.display; let has = |c: Channel| p.texture_sets.iter().any(|t| t.has_channel(c)); let scatters = d.scatter_radius > 0.0 && has(Channel::ScatterWeight); Shade { sss_blur: scatters.then(|| d.scatter_color.map(|c| c.max(0.0) * d.scatter_radius)), refraction: has(Channel::Transmission), ..Shade::from_display(d) } } } impl Default for Shade { fn default() -> Self { Shade { exposure_ev: 0.0, aces: true, env_rotation_deg: 0.0, env_blur: 0.35, env_opacity: 0.0, ao_intensity: 0.75, height_strength: 1.0, normal_y: 1.0, view_mode: 0, channel: 0, light: [0.0; 4], wireframe: false, shadows: false, post_effects: false, bloom: 0.0, vignette: 0.0, sharpen: 0.0, grain: 0.0, wireframe_3d: false, spec_gloss: false, parallax: false, taa: false, scatter: scatter_wrap(&DisplaySettings::default()), ior: 1.5, dof: None, sss_blur: None, refraction: false, displacement: false, } } } #[derive(Clone, Copy, Debug, PartialEq)] pub enum ViewKind { /// The 3D viewport. Scene, /// The 2D UV view of texture set `ts`: zoom (1 = fit) and pan (clip-space offset). Uv { ts: usize, zoom: f32, pan: [f32; 2] }, } /// One view to render this frame. #[derive(Clone, Debug, PartialEq)] pub struct Frame { pub view_id: u64, /// Target size in physical pixels. pub size: [u32; 2], pub kind: ViewKind, pub camera: OrbitCamera, pub shade: Shade, /// Visibility per texture set. pub visible: Vec, } struct Tex { texture: wgpu::Texture, view: wgpu::TextureView, format: wgpu::TextureFormat, mips: u32, } fn mip_count(size: u32) -> u32 { 32 - size.max(1).leading_zeros() } /// Clip-space half extents of the 2D view's UV square in a view of `aspect` (width / height) /// at `zoom`: fit into the view and stretched to the set's `size` (a UV tile atlas is wider or /// taller), keeping texels square. pub fn uv_view_scale(aspect: f32, zoom: f32, size: (u32, u32)) -> [f32; 2] { let z = zoom.clamp(0.05, 64.0) * 0.92; let (sx, sy) = if aspect >= 1.0 { (z / aspect, z) } else { (z, z * aspect) }; let a = size.0.max(1) as f32 / size.1.max(1) as f32; if a >= 1.0 { [sx, sy / a] } else { [sx * a, sy] } } /// Display texture size of a set of `size` texels halved `shift` times. fn display_dims(size: (u32, u32), shift: u32) -> (u32, u32) { ((size.0 >> shift).max(1), (size.1 >> shift).max(1)) } /// Side of the square aux (mesh map / mask / quick mask) texture of a set of `size` texels; it /// stretches over the set like its other textures. pub fn aux_size(size: (u32, u32)) -> u32 { size.0.max(size.1).clamp(1, 2048) } impl Tex { fn new(device: &wgpu::Device, label: &str, w: u32, h: u32, format: wgpu::TextureFormat, mips: u32) -> Tex { let texture = device.create_texture(&wgpu::TextureDescriptor { label: Some(label), size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 }, mip_level_count: mips, sample_count: 1, dimension: wgpu::TextureDimension::D2, format, // COPY_SRC: the GPU path tracer copies the display textures into its arrays. usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, view_formats: &[], }); let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); Tex { texture, view, format, mips } } } struct SetGpu { /// Texels across and down (a UV-tiled set's whole atlas). size: (u32, u32), /// Display textures hold the set at `size >> shift`: halved until they fit the device. shift: u32, /// The display textures in [`DisplayKind::ALL`] order, then the aux (mesh map) texture. /// Each starts as a 1×1 neutral placeholder and gets its full size with the first tile (or /// aux image) that holds something else, so a mesh with many materials costs no GPU memory /// until its sets are painted. tex: Vec, bind_group: wgpu::BindGroup, mips_dirty: Vec, /// Textures whose full-size allocation failed (out of GPU memory): they keep their /// placeholder until the set is re-created, instead of retrying on every tile. failed: Vec, /// Full-size textures the browser's WebGPU has not yet confirmed: tiles go into them while /// the placeholder stays bound (see [`Renderer::resolve_pending`]). pending: Vec>, } /// A full-size texture waiting for WebGPU's verdict on its allocation. struct PendingTex { tex: Tex, /// `None` for success, else what went wrong. (A mutex: the renderer is shared with the /// paint callback, so it must be `Sync`.) answer: std::sync::Mutex>>, } /// Swap `tex` in for slot `slot` of `set` (bound at once; its mips are rebuilt). fn install(set: &mut SetGpu, slot: usize, tex: Tex, device: &wgpu::Device, layout: &wgpu::BindGroupLayout, sampler: &wgpu::Sampler) { if let Some(s) = set.tex.get_mut(slot) { *s = tex; } set.bind_group = set_bind_group(device, layout, sampler, &set.tex); if let Some(d) = set.mips_dirty.get_mut(slot) { *d = true; } } /// Give slot `slot` of `set` (texture set `ts`) the full-size texture `checked` allocated: /// installed when wgpu accepted it, kept pending while WebGPU has not answered, or (out of GPU /// memory) left as the placeholder with the failure recorded. False when there is nothing to /// write into. fn grow( set: &mut SetGpu, ts: usize, slot: usize, checked: Checked, ctx: (&wgpu::Device, &wgpu::BindGroupLayout, &wgpu::Sampler), failures: &mut Vec, ) -> bool { match checked { Checked::Done(Ok(full)) => install(set, slot, full, ctx.0, ctx.1, ctx.2), Checked::Done(Err(e)) => { if let Some(f) = set.failed.get_mut(slot) { *f = true; } memory_failed(failures, ts, &e); return false; } Checked::Later(tex, answer) => { if let Some(p) = set.pending.get_mut(slot) { *p = Some(PendingTex { tex, answer: std::sync::Mutex::new(answer) }); } } } true } /// Vertex and index buffers with their draws (first index, count, material). struct Geometry { vb: wgpu::Buffer, ib: wgpu::Buffer, draws: Vec<(u32, u32, usize)>, triangles: usize, } struct MeshGpu { id: u64, geo: Geometry, /// The vertices and indices of a mesh coarse enough to subdivide for displacement, until /// its dense copy is built. coarse: Option<(Vec, Vec)>, /// The subdivided copy displacement draws (built on first use; None: the mesh is dense). dense: Option, /// World length per UV unit (displacement scale). world_per_uv: f32, /// Unique UV edges as a line list, per material: (first index, count, material). lines: wgpu::Buffer, line_draws: Vec<(u32, u32, usize)>, /// Bounding sphere (center, radius) for fitting the shadow map. center: Vec3, radius: f32, } /// The scene effect targets of a view (full resolution unless noted), created the first time /// depth of field or the subsurface blur is used. struct Fx { /// G-buffer: scattering diffuse light, view depth (see `fs_gbuf`), and its depth buffer. gbuf: wgpu::TextureView, gbuf_depth: wgpu::TextureView, /// The horizontal subsurface pass, then the depth of field result. a: wgpu::TextureView, /// The scene with the subsurface blur. b: wgpu::TextureView, /// Half resolution: the gathered blur and the near-field coverage. half: wgpu::TextureView, near: wgpu::TextureView, } /// The bloom pyramid of a view, created the first time bloom is used. struct Bloom { /// 1/2, 1/4, ... resolution targets. levels: Vec, /// Per level: reads the level above (the HDR scene for level 0). down: Vec, /// Per level but the last: reads the level below, added onto this one. up: Vec, } /// What a view's transmissive surfaces refract: the scene without them, with mips. struct Behind { /// Mip 0 (the scene pass resolves into it), the whole chain (`refr_bg`). level0: wgpu::TextureView, bg: wgpu::BindGroup, /// Per mip from 1: its view and the bind group reading the level above. mips: Vec<(wgpu::TextureView, wgpu::BindGroup)>, } struct ViewTargets { size: [u32; 2], msaa: wgpu::TextureView, depth: wgpu::TextureView, /// The resolved HDR scene of a jittered accumulation frame. hdr: wgpu::TextureView, /// The HDR scene the post pass reads: resolved directly, or the running average of jittered /// frames (see [`TAA_SAMPLES`]). accum: wgpu::TextureView, /// Reads `hdr` for the accumulation blend. accum_bg: wgpu::BindGroup, /// What `accum` holds: the frame and content revision, and the sample count. history: Option<(Frame, u64)>, samples: u32, /// The display image (RGBA8, sRGB-encoded): post pass output, blit and read-back source. resolve: wgpu::Texture, resolve_view: wgpu::TextureView, globals: wgpu::Buffer, globals_bg: Option, post_buf: wgpu::Buffer, post_bg: wgpu::BindGroup, bloom: Option, fx: Option, behind: Option, blit_buf: wgpu::Buffer, blit_bg: wgpu::BindGroup, /// Set by [`Renderer::prepare`]: the view has content to blit. ready: bool, } /// Key-light shadow map, shared by all views (1×1 until shadows are first used). struct ShadowMap { view: wgpu::TextureView, size: u32, /// What the map was rendered for: mesh id, light direction bits, displacement (its /// parameters' bits and, when on, the content revision), visible sets. key: Option<(u64, [u32; 3], [u32; 4], u64)>, visible: Vec, vp: Mat4, buf: wgpu::Buffer, bg: wgpu::BindGroup, } pub struct Renderer { target_format: wgpu::TextureFormat, /// [`HDR_FORMAT`], or [`COLOR_FORMAT`] where float targets are not renderable (WebGL2 /// without float color buffers). hdr_format: wgpu::TextureFormat, globals_bgl: wgpu::BindGroupLayout, set_bgl: wgpu::BindGroupLayout, blit_bgl: wgpu::BindGroupLayout, mip_bgl: wgpu::BindGroupLayout, fx_bgl: wgpu::BindGroupLayout, /// The refraction source of the mesh pipelines (group 2), and that bind group reading black. refr_bgl: wgpu::BindGroupLayout, refr_black: wgpu::BindGroup, mesh_pipeline: wgpu::RenderPipeline, /// The scene behind transmissive surfaces: `fs_mesh` without them. opaque_pipeline: wgpu::RenderPipeline, uv_pipeline: wgpu::RenderPipeline, wire_pipeline: wgpu::RenderPipeline, wire3d_pipeline: wgpu::RenderPipeline, bg_pipeline: wgpu::RenderPipeline, blit_pipeline: wgpu::RenderPipeline, post_pipeline: wgpu::RenderPipeline, /// Bright pass + first downsample, downsample, additive upsample. bloom_pipelines: [wgpu::RenderPipeline; 3], /// The G-buffer of the scene effects (`fs_gbuf`). gbuf_pipeline: wgpu::RenderPipeline, /// Subsurface blur (horizontal, vertical), depth of field gather and composite (fx.wgsl). sss_pipelines: [wgpu::RenderPipeline; 2], dof_gather_pipeline: wgpu::RenderPipeline, dof_pipeline: wgpu::RenderPipeline, shadow_pipeline: wgpu::RenderPipeline, mip_pipelines: HashMap, util_module: wgpu::ShaderModule, sampler: wgpu::Sampler, env_sampler: wgpu::Sampler, shadow_sampler: wgpu::Sampler, shadow: ShadowMap, /// 1×1 black texture for unused effect inputs. black: wgpu::TextureView, /// [`DisplayKind::default_texel`] in [`DisplayKind::ALL`] order. default_texels: Vec>, /// Texture sets whose display textures could not be allocated (out of GPU memory) since /// [`Renderer::take_memory_failures`]. memory_failures: Vec, accum_pipeline: wgpu::RenderPipeline, env: Tex, env_name: String, sh: [[f32; 4]; 9], /// Bumped by every change of what the views show (uploads, mesh, environment): restarts /// accumulation. content_rev: u64, mesh: Option, sets: Vec, /// Viewport texture resolution: display textures at 1/2^shift of each set's size (at least /// as reduced as the device's texture limit needs). display_shift: u32, /// Texture set index per mesh material. material_sets: Vec>, views: HashMap, } fn fragment_entry(binding: u32, ty: wgpu::BindingType) -> wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry { binding, visibility: wgpu::ShaderStages::FRAGMENT, ty, count: None } } fn tex_entry(binding: u32) -> wgpu::BindGroupLayoutEntry { fragment_entry( binding, wgpu::BindingType::Texture { multisampled: false, sample_type: wgpu::TextureSampleType::Float { filterable: true }, view_dimension: wgpu::TextureViewDimension::D2, }, ) } fn sampler_entry(binding: u32) -> wgpu::BindGroupLayoutEntry { fragment_entry(binding, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering)) } fn uniform_entry(binding: u32) -> wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry { binding, visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT, ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None }, count: None, } } pub(crate) fn display_format(k: DisplayKind) -> wgpu::TextureFormat { match k { DisplayKind::BaseColor | DisplayKind::Emissive | DisplayKind::Sheen => wgpu::TextureFormat::Rgba8UnormSrgb, DisplayKind::Orm | DisplayKind::Normal | DisplayKind::Lobes | DisplayKind::Extra => wgpu::TextureFormat::Rgba8Unorm, DisplayKind::Height => wgpu::TextureFormat::Rgba16Float, } } /// Texel of the aux texture before a mesh map or mask is shown. const AUX_NEUTRAL: [u8; 4] = [128, 128, 128, 255]; /// A `w × h` texture filled with `texel`. fn neutral_tex(device: &wgpu::Device, queue: &wgpu::Queue, (w, h): (u32, u32), format: wgpu::TextureFormat, mips: u32, texel: &[u8]) -> Tex { let t = Tex::new(device, "tc_set", w, h, format, mips); let row = texel.repeat(w as usize); // Fill in bands of rows: an 8K texture's bytes at once would be hundreds of megabytes. let band = (NEUTRAL_BAND_BYTES / row.len().max(1)).clamp(1, h.max(1) as usize) as u32; let data = row.repeat(band as usize); let mut y = 0; while y < h { let rows = band.min(h - y); queue.write_texture( wgpu::TexelCopyTextureInfo { texture: &t.texture, mip_level: 0, origin: wgpu::Origin3d { x: 0, y, z: 0 }, aspect: wgpu::TextureAspect::All }, data.get(..row.len() * rows as usize).unwrap_or_default(), wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(row.len() as u32), rows_per_image: Some(rows) }, wgpu::Extent3d { width: w, height: rows, depth_or_array_layers: 1 }, ); y += rows; } t } /// Record that texture set `ts` could not get a display texture (`error` says which). fn memory_failed(failures: &mut Vec, ts: usize, error: &str) { log::warn!("cannot allocate the display texture of {error}"); if !failures.contains(&ts) { failures.push(ts); } } /// Bytes per write when filling a texture with one texel. const NEUTRAL_BAND_BYTES: usize = 8 << 20; /// The bind group of a set's textures (`set_bgl`): textures, then the sampler. fn set_bind_group(device: &wgpu::Device, layout: &wgpu::BindGroupLayout, sampler: &wgpu::Sampler, tex: &[Tex]) -> wgpu::BindGroup { let mut entries: Vec = tex.iter().enumerate().map(|(i, t)| wgpu::BindGroupEntry { binding: i as u32, resource: wgpu::BindingResource::TextureView(&t.view) }).collect(); entries.push(wgpu::BindGroupEntry { binding: tex.len() as u32, resource: wgpu::BindingResource::Sampler(sampler) }); device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_set"), layout, entries: &entries }) } /// The color output of a pipeline: fragment entry point, format, blending. `fs_wire*` entry /// points draw line lists. type ColorOut<'a> = (&'a str, wgpu::TextureFormat, Option); const ADD: wgpu::BlendComponent = wgpu::BlendComponent { src_factor: wgpu::BlendFactor::One, dst_factor: wgpu::BlendFactor::One, operation: wgpu::BlendOperation::Add }; const ADDITIVE: wgpu::BlendState = wgpu::BlendState { color: ADD, alpha: ADD }; #[allow(clippy::too_many_arguments)] fn pipeline( device: &wgpu::Device, label: &str, layout: &wgpu::PipelineLayout, module: &wgpu::ShaderModule, vs: &str, buffers: &[Option], color: Option>, samples: u32, depth: Option, ) -> wgpu::RenderPipeline { let lines = color.is_some_and(|(fs, ..)| fs.starts_with("fs_wire")); let topology = if lines { wgpu::PrimitiveTopology::LineList } else { wgpu::PrimitiveTopology::TriangleList }; let targets = color.map(|(_, format, blend)| [Some(wgpu::ColorTargetState { format, blend, write_mask: wgpu::ColorWrites::ALL })]); device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some(label), layout: Some(layout), vertex: wgpu::VertexState { module, entry_point: Some(vs), buffers, compilation_options: Default::default() }, primitive: wgpu::PrimitiveState { topology, cull_mode: None, ..Default::default() }, depth_stencil: depth, multisample: wgpu::MultisampleState { count: samples, mask: !0, alpha_to_coverage_enabled: false }, fragment: color.zip(targets.as_ref()).map(|((fs, ..), targets)| wgpu::FragmentState { module, entry_point: Some(fs), targets, compilation_options: Default::default(), }), multiview_mask: None, cache: None, }) } fn depth_state(write: bool, compare: wgpu::CompareFunction) -> wgpu::DepthStencilState { wgpu::DepthStencilState { format: DEPTH_FORMAT, depth_write_enabled: Some(write), depth_compare: Some(compare), stencil: wgpu::StencilState::default(), bias: wgpu::DepthBiasState::default(), } } /// Whether [`HDR_FORMAT`] works as an MSAA render target. Guaranteed on WebGPU and the native /// backends; WebGL2/GLES need float color buffer extensions, so probe there (wgpu-core reports the /// validation error synchronously, so the future is ready at once). fn hdr_renderable(device: &wgpu::Device) -> bool { if device.adapter_info().backend != wgpu::Backend::Gl { return true; } let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); let _probe = texture(device, "tc_probe", [1, 1], HDR_FORMAT, MSAA, wgpu::TextureUsages::RENDER_ATTACHMENT); let mut error = std::pin::pin!(scope.pop()); matches!(error.as_mut().poll(&mut std::task::Context::from_waker(std::task::Waker::noop())), std::task::Poll::Ready(None)) } fn texture(device: &wgpu::Device, label: &str, size: [u32; 2], format: wgpu::TextureFormat, samples: u32, usage: wgpu::TextureUsages) -> wgpu::Texture { device.create_texture(&wgpu::TextureDescriptor { label: Some(label), size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 }, mip_level_count: 1, sample_count: samples, dimension: wgpu::TextureDimension::D2, format, usage, view_formats: &[], }) } fn target_view(device: &wgpu::Device, label: &str, size: [u32; 2], format: wgpu::TextureFormat, samples: u32) -> wgpu::TextureView { let usage = if samples > 1 || format == DEPTH_FORMAT { wgpu::TextureUsages::RENDER_ATTACHMENT } else { wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING }; texture(device, label, size, format, samples, usage).create_view(&Default::default()) } fn shadow_view(device: &wgpu::Device, size: u32) -> wgpu::TextureView { texture(device, "tc_shadow", [size, size], DEPTH_FORMAT, 1, wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING) .create_view(&Default::default()) } /// A buffer of `usage` holding `data`. fn upload_buffer(device: &wgpu::Device, queue: &wgpu::Queue, label: &str, data: &[u8], usage: wgpu::BufferUsages) -> wgpu::Buffer { let buf = device.create_buffer(&wgpu::BufferDescriptor { label: Some(label), size: (data.len() as u64).max(4).next_multiple_of(4), usage: usage | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); queue.write_buffer(&buf, 0, data); buf } /// One fullscreen-triangle pass into `target`. fn fullscreen( encoder: &mut wgpu::CommandEncoder, label: &str, target: &wgpu::TextureView, load: wgpu::LoadOp, pipe: &wgpu::RenderPipeline, bg: &wgpu::BindGroup, ) { fullscreen_blend(encoder, label, target, load, pipe, bg, 1.0); } /// [`fullscreen`] with a blend constant (for pipelines that blend by it). fn fullscreen_blend( encoder: &mut wgpu::CommandEncoder, label: &str, target: &wgpu::TextureView, load: wgpu::LoadOp, pipe: &wgpu::RenderPipeline, bg: &wgpu::BindGroup, constant: f64, ) { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some(label), color_attachments: &[Some(wgpu::RenderPassColorAttachment { view: target, resolve_target: None, depth_slice: None, ops: wgpu::Operations { load, store: wgpu::StoreOp::Store }, })], depth_stencil_attachment: None, timestamp_writes: None, occlusion_query_set: None, multiview_mask: None, }); pass.set_pipeline(pipe); pass.set_bind_group(0, bg, &[]); pass.set_blend_constant(wgpu::Color { r: constant, g: constant, b: constant, a: constant }); pass.draw(0..3, 0..1); } /// Halton low-discrepancy value of `i` in `base` (0..1). fn halton(mut i: u32, base: u32) -> f32 { let (mut f, mut r) = (1.0, 0.0); while i > 0 { f /= base as f32; r += f * (i % base) as f32; i /= base; } r } const CLEAR: wgpu::LoadOp = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT); impl Renderer { /// `target_format`: the format of the pass [`Renderer::blit`] draws into. pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, target_format: wgpu::TextureFormat) -> Renderer { let shader = |label: &str, source: &str| { device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some(label), source: wgpu::ShaderSource::Wgsl(source.into()) }) }; let module = shader("tc_mesh", concat!(include_str!("shaders/displace.wgsl"), include_str!("shaders/mesh.wgsl"))); let util_module = shader("tc_util", include_str!("shaders/util.wgsl")); let post_module = shader("tc_post", concat!(include_str!("shaders/util.wgsl"), include_str!("shaders/post.wgsl"), include_str!("shaders/fx.wgsl"))); let shadow_module = shader("tc_shadow", concat!(include_str!("shaders/displace.wgsl"), include_str!("shaders/shadow.wgsl"))); let bgl = |label: &str, entries: &[wgpu::BindGroupLayoutEntry]| { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some(label), entries }) }; let globals_bgl = bgl( "tc_globals", &[ uniform_entry(0), tex_entry(1), sampler_entry(2), fragment_entry( 3, wgpu::BindingType::Texture { multisampled: false, sample_type: wgpu::TextureSampleType::Depth, view_dimension: wgpu::TextureViewDimension::D2, }, ), fragment_entry(4, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison)), ], ); // The display textures, the aux texture, the sampler. let textures = DisplayKind::ALL.len() as u32 + 1; // Displacement reads the height (and the sampler) in the vertex shader. let height = DisplayKind::ALL.iter().position(|k| *k == DisplayKind::Height).unwrap_or(0) as u32; let set_entries: Vec<_> = (0..textures) .map(tex_entry) .chain(std::iter::once(sampler_entry(textures))) .map(|mut e| { if e.binding == height || e.binding == textures { e.visibility |= wgpu::ShaderStages::VERTEX; } e }) .collect(); let set_bgl = bgl("tc_set", &set_entries); let refr_bgl = bgl("tc_refr", &[tex_entry(0)]); let blit_bgl = bgl("tc_blit", &[tex_entry(0), sampler_entry(1), uniform_entry(2)]); let mip_bgl = bgl("tc_mip", &[tex_entry(0), sampler_entry(1)]); let fx_bgl = bgl("tc_fx", &[tex_entry(0), sampler_entry(1), uniform_entry(3), tex_entry(4), tex_entry(5), tex_entry(6)]); let shadow_bgl = bgl("tc_shadow", &[uniform_entry(0)]); let pl = |label: &str, groups: &[Option<&wgpu::BindGroupLayout>]| { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some(label), bind_group_layouts: groups, immediate_size: 0 }) }; let layout = pl("tc_uv", &[Some(&globals_bgl), Some(&set_bgl)]); let mesh_layout = pl("tc_mesh", &[Some(&globals_bgl), Some(&set_bgl), Some(&refr_bgl)]); let bg_layout = pl("tc_bg", &[Some(&globals_bgl)]); let blit_layout = pl("tc_blit", &[Some(&blit_bgl)]); let fx_layout = pl("tc_fx", &[Some(&fx_bgl)]); let shadow_layout = pl("tc_shadow", &[Some(&shadow_bgl), Some(&set_bgl)]); let vb = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Float32x4, 3 => Float32x2], })]; // shortcut: the RGBA8 fallback clips highlights above 1 and bands in the darks; encode // (e.g. RGBM) if WebGL2 without float color buffers turns out to matter. let hdr_format = if hdr_renderable(device) { HDR_FORMAT } else { COLOR_FORMAT }; let hdr = |fs, blend| Some((fs, hdr_format, blend)); let always = || Some(depth_state(false, wgpu::CompareFunction::Always)); let mesh_pipeline = pipeline( device, "tc_mesh", &mesh_layout, &module, "vs_mesh", &vb, hdr("fs_mesh", None), MSAA, Some(depth_state(true, wgpu::CompareFunction::Less)), ); let opaque_pipeline = pipeline( device, "tc_opaque", &mesh_layout, &module, "vs_mesh", &vb, hdr("fs_opaque", None), MSAA, Some(depth_state(true, wgpu::CompareFunction::Less)), ); let uv_pipeline = pipeline(device, "tc_uv", &layout, &module, "vs_uv", &vb, hdr("fs_uv", None), MSAA, always()); let blend = Some(wgpu::BlendState::ALPHA_BLENDING); let wire_pipeline = pipeline(device, "tc_wire", &layout, &module, "vs_uv", &vb, hdr("fs_wire", blend), MSAA, always()); let wire3d_depth = Some(depth_state(false, wgpu::CompareFunction::LessEqual)); let wire3d_pipeline = pipeline(device, "tc_wire3d", &layout, &module, "vs_wire3d", &vb, hdr("fs_wire3d", blend), MSAA, wire3d_depth); let bg_pipeline = pipeline(device, "tc_bg", &bg_layout, &module, "vs_bg", &[], hdr("fs_bg", None), MSAA, always()); let blit_pipeline = pipeline(device, "tc_blit", &blit_layout, &util_module, "vs_blit", &[], Some(("fs_blit", target_format, None)), 1, None); let post_pipeline = pipeline(device, "tc_post", &fx_layout, &post_module, "vs_full", &[], Some(("fs_post", COLOR_FORMAT, None)), 1, None); let bloom_pipelines = [("fs_bloom_pre", None), ("fs_bloom_down", None), ("fs_bloom_up", Some(ADDITIVE))] .map(|(fs, blend)| pipeline(device, "tc_bloom", &fx_layout, &post_module, "vs_full", &[], hdr(fs, blend), 1, None)); let gbuf_pipeline = pipeline(device, "tc_gbuf", &mesh_layout, &module, "vs_mesh", &vb, hdr("fs_gbuf", None), 1, Some(depth_state(true, wgpu::CompareFunction::Less))); let sss_pipelines = ["fs_sss_h", "fs_sss_v"].map(|fs| pipeline(device, "tc_sss", &fx_layout, &post_module, "vs_full", &[], hdr(fs, None), 1, None)); let dof_pipeline = pipeline(device, "tc_dof", &fx_layout, &post_module, "vs_full", &[], hdr("fs_dof", None), 1, None); let dof_target = Some(wgpu::ColorTargetState { format: hdr_format, blend: None, write_mask: wgpu::ColorWrites::ALL }); let dof_gather_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("tc_dof_gather"), layout: Some(&fx_layout), vertex: wgpu::VertexState { module: &post_module, entry_point: Some("vs_full"), buffers: &[], compilation_options: Default::default() }, primitive: wgpu::PrimitiveState::default(), depth_stencil: None, multisample: wgpu::MultisampleState::default(), fragment: Some(wgpu::FragmentState { module: &post_module, entry_point: Some("fs_dof_gather"), targets: &[dof_target.clone(), dof_target], compilation_options: Default::default(), }), multiview_mask: None, cache: None, }); let shadow_depth = wgpu::DepthStencilState { bias: wgpu::DepthBiasState { constant: 0, slope_scale: 1.5, clamp: 0.0 }, ..depth_state(true, wgpu::CompareFunction::Less) }; let shadow_pipeline = pipeline(device, "tc_shadow", &shadow_layout, &shadow_module, "vs_shadow", &vb, None, 1, Some(shadow_depth)); // accum = hdr * k + accum * (1 - k) with k = 1 / (sample + 1): a running average. let average = wgpu::BlendComponent { src_factor: wgpu::BlendFactor::Constant, dst_factor: wgpu::BlendFactor::OneMinusConstant, operation: wgpu::BlendOperation::Add, }; let accum_layout = pl("tc_accum", &[Some(&mip_bgl)]); let accum_blend = Some(wgpu::BlendState { color: average, alpha: average }); let accum_pipeline = pipeline(device, "tc_accum", &accum_layout, &util_module, "vs_full", &[], hdr("fs_copy", accum_blend), 1, None); let sampler = device.create_sampler(&wgpu::SamplerDescriptor { label: Some("tc_tex"), address_mode_u: wgpu::AddressMode::ClampToEdge, address_mode_v: wgpu::AddressMode::ClampToEdge, mag_filter: wgpu::FilterMode::Linear, min_filter: wgpu::FilterMode::Linear, mipmap_filter: wgpu::MipmapFilterMode::Linear, anisotropy_clamp: 8, ..Default::default() }); let env_sampler = device.create_sampler(&wgpu::SamplerDescriptor { label: Some("tc_env"), address_mode_u: wgpu::AddressMode::Repeat, address_mode_v: wgpu::AddressMode::ClampToEdge, mag_filter: wgpu::FilterMode::Linear, min_filter: wgpu::FilterMode::Linear, mipmap_filter: wgpu::MipmapFilterMode::Linear, ..Default::default() }); let shadow_sampler = device.create_sampler(&wgpu::SamplerDescriptor { label: Some("tc_shadow"), mag_filter: wgpu::FilterMode::Linear, min_filter: wgpu::FilterMode::Linear, compare: Some(wgpu::CompareFunction::LessEqual), ..Default::default() }); let shadow_buf = device.create_buffer(&wgpu::BufferDescriptor { label: Some("tc_shadow"), size: std::mem::size_of::<[[f32; 4]; 5]>() as u64, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); let shadow = ShadowMap { view: shadow_view(device, 1), size: 1, key: None, visible: Vec::new(), vp: Mat4::IDENTITY, bg: device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_shadow"), layout: &shadow_bgl, entries: &[wgpu::BindGroupEntry { binding: 0, resource: shadow_buf.as_entire_binding() }], }), buf: shadow_buf, }; let black = Tex::new(device, "tc_black", 1, 1, COLOR_FORMAT, 1).view; let refr_black = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_refr_black"), layout: &refr_bgl, entries: &[wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&black) }], }); let env = Tex::new(device, "tc_env", 512, 256, wgpu::TextureFormat::Rgba16Float, ENV_LEVELS); let mut r = Renderer { target_format, hdr_format, globals_bgl, set_bgl, blit_bgl, mip_bgl, fx_bgl, refr_bgl, refr_black, mesh_pipeline, opaque_pipeline, uv_pipeline, wire_pipeline, wire3d_pipeline, bg_pipeline, blit_pipeline, post_pipeline, bloom_pipelines, gbuf_pipeline, sss_pipelines, dof_gather_pipeline, dof_pipeline, shadow_pipeline, accum_pipeline, mip_pipelines: HashMap::new(), util_module, sampler, env_sampler, shadow_sampler, shadow, black, default_texels: DisplayKind::ALL.map(DisplayKind::default_texel).to_vec(), memory_failures: Vec::new(), env, env_name: String::new(), sh: [[0.0; 4]; 9], content_rev: 0, mesh: None, sets: Vec::new(), display_shift: 0, material_sets: Vec::new(), views: HashMap::new(), }; r.set_environment(device, queue, "Studio Soft", None); r } pub fn environment_name(&self) -> &str { &self.env_name } /// Each texture set's display textures in [`DisplayKind::ALL`] order (lazy kinds may still be /// 1×1 placeholders), for the GPU path tracer. pub fn display_textures(&self) -> Vec> { self.sets.iter().map(|s| s.tex.iter().take(DisplayKind::ALL.len()).map(|t| &t.texture).collect()).collect() } /// Changes whenever what the views show changes (uploads, mesh, environment). pub fn content_rev(&self) -> u64 { self.content_rev } /// Use environment `name`: with `image`, that equirect image (an imported `.hdr`/`.exr`, or /// any image, linearized), prefiltered on the CPU (rayon); otherwise the built-in of that /// name (no-op when already current; unknown names give the default studio). pub fn set_environment(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, name: &str, image: Option<&ImageRes>) { let img = match image.and_then(|i| ibl::EnvImage::from_rgba(i.width, i.height, &i.rgba, i.srgb)) { Some(img) => img, None if self.env_name == name => return, None => ibl::environment(name, 512), }; let levels = ibl::prefilter(&img, ENV_LEVELS); if self.env.texture.width() != img.width || self.env.texture.height() != img.height { self.env = Tex::new(device, "tc_env", img.width, img.height, wgpu::TextureFormat::Rgba16Float, ENV_LEVELS); } for (l, lv) in levels.iter().enumerate() { let bytes: Vec = lv.data.iter().flat_map(|c| [c[0], c[1], c[2], 1.0]).flat_map(|v| half::f16::from_f32(v).to_le_bytes()).collect(); queue.write_texture( wgpu::TexelCopyTextureInfo { texture: &self.env.texture, mip_level: l as u32, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All }, &bytes, wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(lv.width * 8), rows_per_image: Some(lv.height) }, wgpu::Extent3d { width: lv.width, height: lv.height, depth_or_array_layers: 1 }, ); } let sh = ibl::sh9(&img); self.sh = sh.map(|c| [c[0], c[1], c[2], 0.0]); self.env_name = name.to_string(); self.content_rev += 1; for v in self.views.values_mut() { v.globals_bg = None; } } /// Upload the mesh when `id` changed. pub fn set_mesh(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, mesh: &Mesh, id: u64) { if self.mesh.as_ref().is_some_and(|m| m.id == id) { return; } let verts = subdivide::vertices(mesh); let mk = |label: &str, data: &[u8], usage: wgpu::BufferUsages| upload_buffer(device, queue, label, data, usage); let mut idx_bytes = bytemuck::cast_slice::(&mesh.indices).to_vec(); idx_bytes.resize(idx_bytes.len().next_multiple_of(4), 0); let vb = mk("tc_vb", bytemuck::cast_slice(&verts), wgpu::BufferUsages::VERTEX); let ib = mk("tc_ib", &idx_bytes, wgpu::BufferUsages::INDEX); let draws: Vec<(u32, u32, usize)> = mesh.submeshes.iter().map(|s| (s.start, s.count, s.material)).collect(); // Mesh edges per material (polygons, not their triangles), for the wireframes. let mut line_idx: Vec = Vec::new(); let mut line_draws = Vec::new(); for (m, edges) in mesh.wire_edges().into_iter().enumerate() { let start = line_idx.len() as u32; line_idx.extend(edges.into_iter().flat_map(|(a, b)| [a, b])); line_draws.push((start, line_idx.len() as u32 - start, m)); } let lines = mk("tc_lines", bytemuck::cast_slice(&line_idx), wgpu::BufferUsages::INDEX); let (lo, hi) = mesh.bounds(); let (center, radius) = ((lo + hi) * 0.5, ((hi - lo).length() * 0.5).max(1e-3)); let triangles = mesh.indices.len() / 3; let world_per_uv = subdivide::world_per_uv(&verts, &mesh.indices).unwrap_or(radius); let coarse = (subdivide::level_for(triangles) > 0).then(|| (verts, mesh.indices.clone())); let geo = Geometry { vb, ib, draws, triangles }; self.mesh = Some(MeshGpu { id, geo, coarse, dense: None, world_per_uv, lines, line_draws, center, radius }); self.content_rev += 1; } /// Build the mesh's dense copy for displacement (once per mesh). fn ensure_dense(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) { let Some(m) = self.mesh.as_mut() else { return }; let Some((verts, indices)) = m.coarse.take() else { return }; let (v, i, draws) = subdivide::subdivide(&verts, &indices, &m.geo.draws, subdivide::level_for(m.geo.triangles)); let vb = upload_buffer(device, queue, "tc_dense_vb", bytemuck::cast_slice(&v), wgpu::BufferUsages::VERTEX); let ib = upload_buffer(device, queue, "tc_dense_ib", bytemuck::cast_slice(&i), wgpu::BufferUsages::INDEX); m.dense = Some(Geometry { vb, ib, draws, triangles: i.len() / 3 }); } /// Show texture sets at 1/2^`shift` of their size (0 = full, 1 = half, 2 = quarter…) from the /// next [`Renderer::set_texture_sets`], which re-creates the sets that change. pub fn set_display_shift(&mut self, shift: u32) { self.display_shift = shift.min(6); } /// Make the per-texture-set textures match `sets` (texels across and down per set: a /// UV-tiled set's atlas) and map mesh materials to sets. Re-created textures start neutral; /// returns the sets that were reset (the caller must upload all their tiles). pub fn set_texture_sets(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, sets: &[((u32, u32), usize)], material_count: usize) -> Vec { let mut reset = Vec::new(); self.content_rev += 1; self.sets.truncate(sets.len()); let max = device.limits().max_texture_dimension_2d.max(1); for (i, &(size, _)) in sets.iter().enumerate() { // shortcut: a set larger than the device's textures shows every 2^shift-th texel; // a texture array per UV tile would keep full detail on such devices. let shift = (0..31).find(|s| size.0.max(size.1) >> s <= max).unwrap_or(0).max(self.display_shift); if self.sets.get(i).is_some_and(|s| s.size == size && s.shift == shift) { continue; } // Placeholders only: full-size textures come with the first non-neutral upload. let mut tex: Vec = DisplayKind::ALL.iter().zip(&self.default_texels).map(|(k, texel)| neutral_tex(device, queue, (1, 1), display_format(*k), 1, texel)).collect(); tex.push(neutral_tex(device, queue, (1, 1), wgpu::TextureFormat::Rgba8Unorm, 1, &AUX_NEUTRAL)); let bind_group = set_bind_group(device, &self.set_bgl, &self.sampler, &tex); let n = tex.len(); let gpu = SetGpu { size, shift, tex, bind_group, mips_dirty: vec![true; n], failed: vec![false; n], pending: (0..n).map(|_| None).collect() }; if i < self.sets.len() { self.sets[i] = gpu; } else { self.sets.push(gpu); } reset.push(i); } self.material_sets = vec![None; material_count]; for (i, &(_, m)) in sets.iter().enumerate() { if let Some(slot) = self.material_sets.get_mut(m) { *slot = Some(i); } } reset } /// Upload one 64×64 tile of a display texture (bytes from `compose::tile_bytes`). #[allow(clippy::too_many_arguments)] pub fn upload_tile(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, ts: usize, kind: DisplayKind, tx: u32, ty: u32, bytes: &[u8]) { let Some(set) = self.sets.get_mut(ts) else { return }; let Some(ki) = DisplayKind::ALL.iter().position(|k| *k == kind) else { return }; let (Some(t), Some(texel)) = (set.tex.get(ki), self.default_texels.get(ki)) else { return }; let bpt = kind.bytes_per_texel() as u32; let (x, y) = (tx * TILE, ty * TILE); if x >= set.size.0 || y >= set.size.1 || bytes.len() < (TILE * TILE * bpt) as usize { return; } let dims = display_dims(set.size, set.shift); let awaiting = set.pending.get(ki).is_some_and(Option::is_some); if !awaiting && (t.texture.width() < dims.0 || t.texture.height() < dims.1) { // A placeholder: neutral tiles change nothing, the first real one allocates it. if set.failed.get(ki).copied().unwrap_or(true) || bytes.chunks_exact(texel.len()).all(|px| px == texel.as_slice()) { return; } let what = format!("texture set {} ({kind:?}, {}×{})", ts + 1, dims.0, dims.1); let full = checked(device, &what, || neutral_tex(device, queue, dims, display_format(kind), mip_count(dims.0.max(dims.1)), texel)); if !grow(set, ts, ki, full, (device, &self.set_bgl, &self.sampler), &mut self.memory_failures) { return; } } // While WebGPU has not confirmed the full-size texture, tiles go into it (its errors, if // it is invalid, are dropped with these scopes) and the placeholder stays bound. let pending = set.pending.get(ki).and_then(Option::as_ref).map(|p| &p.tex); let Some(t) = pending.or(set.tex.get(ki)) else { return }; let oom = pending.is_some().then(|| device.push_error_scope(wgpu::ErrorFilter::OutOfMemory)); let invalid = pending.is_some().then(|| device.push_error_scope(wgpu::ErrorFilter::Validation)); // Downscaled sets take every `step`-th texel of the tile. let (step, n) = (1usize << set.shift.min(6), TILE >> set.shift.min(6)); let small: Vec; let data = if step == 1 { bytes } else { let texel = |r: usize, c: usize| bytes.get((r * TILE as usize + c) * bpt as usize..).unwrap_or_default().iter().take(bpt as usize); small = (0..n as usize).flat_map(|r| (0..n as usize).flat_map(move |c| texel(r * step, c * step))).copied().collect(); &small }; let (ox, oy) = (x >> set.shift, y >> set.shift); let (w, h) = (n.min(dims.0.saturating_sub(ox)), n.min(dims.1.saturating_sub(oy))); if w == 0 || h == 0 { return; } queue.write_texture( wgpu::TexelCopyTextureInfo { texture: &t.texture, mip_level: 0, origin: wgpu::Origin3d { x: ox, y: oy, z: 0 }, aspect: wgpu::TextureAspect::All }, data, wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(n * bpt), rows_per_image: Some(n) }, wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 }, ); // Innermost scope first. drop(invalid); drop(oom); self.content_rev += 1; if let Some(d) = set.mips_dirty.get_mut(ki) { *d = true; } } /// Upload the aux (mesh map / debug) texture of a set: RGBA8, `size × size` with `size` from /// [`aux_size`]. The first upload allocates it. pub fn upload_aux(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, ts: usize, size: u32, rgba: &[u8]) { let Some(set) = self.sets.get_mut(ts) else { return }; let want = aux_size(set.size); let ai = set.tex.len().saturating_sub(1); let Some(t) = set.tex.last() else { return }; if size != want || rgba.len() < (size as usize) * (size as usize) * 4 { return; } let awaiting = set.pending.get(ai).is_some_and(Option::is_some); if !awaiting && t.texture.width() != size { if set.failed.get(ai).copied().unwrap_or(true) { return; } let what = format!("texture set {} (mesh map view, {size}×{size})", ts + 1); let full = checked(device, &what, || neutral_tex(device, queue, (size, size), wgpu::TextureFormat::Rgba8Unorm, mip_count(size), &AUX_NEUTRAL)); if !grow(set, ts, ai, full, (device, &self.set_bgl, &self.sampler), &mut self.memory_failures) { return; } } let pending = set.pending.get(ai).and_then(Option::as_ref).map(|p| &p.tex); let Some(t) = pending.or(set.tex.last()) else { return }; let (w, h) = (t.texture.width(), t.texture.height()); let oom = pending.is_some().then(|| device.push_error_scope(wgpu::ErrorFilter::OutOfMemory)); let invalid = pending.is_some().then(|| device.push_error_scope(wgpu::ErrorFilter::Validation)); queue.write_texture( wgpu::TexelCopyTextureInfo { texture: &t.texture, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All }, rgba, wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(w * 4), rows_per_image: Some(h) }, wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 }, ); drop(invalid); drop(oom); self.content_rev += 1; if let Some(d) = set.mips_dirty.last_mut() { *d = true; } } /// Texture sets whose display textures could not be allocated since the last call (out of /// GPU memory: they show neutral values where they could not be allocated). pub fn take_memory_failures(&mut self) -> Vec { std::mem::take(&mut self.memory_failures) } /// Whether a full-size texture still waits for WebGPU's verdict: keep drawing frames, since /// [`Renderer::prepare`] installs it (or reports the failure) once the answer is in. pub fn awaiting_gpu(&self) -> bool { self.sets.iter().any(|s| s.pending.iter().any(Option::is_some)) } /// Install the pending full-size textures WebGPU accepted; drop the ones it rejected (their /// placeholder stays and the failure is reported). fn resolve_pending(&mut self, device: &wgpu::Device) { for (ts, set) in self.sets.iter_mut().enumerate() { for slot in 0..set.pending.len() { let poll = |p: &PendingTex| p.answer.lock().unwrap_or_else(std::sync::PoisonError::into_inner).try_recv(); let verdict = match set.pending.get(slot).and_then(Option::as_ref).map(poll) { None | Some(Err(std::sync::mpsc::TryRecvError::Empty)) => continue, Some(Ok(v)) => v, Some(Err(std::sync::mpsc::TryRecvError::Disconnected)) => Some(format!("texture set {}: the GPU never answered", ts + 1)), }; let Some(p) = set.pending.get_mut(slot).and_then(Option::take) else { continue }; match verdict { None => { install(set, slot, p.tex, device, &self.set_bgl, &self.sampler); self.content_rev += 1; } Some(e) => { if let Some(f) = set.failed.get_mut(slot) { *f = true; } memory_failed(&mut self.memory_failures, ts, &e); } } } } } /// Size of the aux texture of a set (1 until a mesh map or mask was shown). pub fn aux_size(&self, ts: usize) -> Option { self.sets.get(ts).and_then(|s| s.tex.last()).map(|t| t.texture.width()) } fn generate_mips(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder) { for si in 0..self.sets.len() { for ti in 0..self.sets[si].tex.len() { if !self.sets[si].mips_dirty.get(ti).copied().unwrap_or(false) { continue; } let format = self.sets[si].tex[ti].format; self.ensure_mip_pipeline(device, format); let Some(pipe) = self.mip_pipelines.get(&format) else { continue }; let t = &self.sets[si].tex[ti]; for level in 1..t.mips { let src = t.texture.create_view(&wgpu::TextureViewDescriptor { base_mip_level: level - 1, mip_level_count: Some(1), ..Default::default() }); let dst = t.texture.create_view(&wgpu::TextureViewDescriptor { base_mip_level: level, mip_level_count: Some(1), ..Default::default() }); let bg = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_mip"), layout: &self.mip_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&src) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, ], }); fullscreen(encoder, "tc_mip", &dst, CLEAR, pipe, &bg); } if let Some(d) = self.sets[si].mips_dirty.get_mut(ti) { *d = false; } } } } /// The pipeline that downsamples one mip level of `format` into the next. fn ensure_mip_pipeline(&mut self, device: &wgpu::Device, format: wgpu::TextureFormat) { if !self.mip_pipelines.contains_key(&format) { let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("tc_mip"), bind_group_layouts: &[Some(&self.mip_bgl)], immediate_size: 0, }); let p = pipeline(device, "tc_mip", &layout, &self.util_module, "vs_full", &[], Some(("fs_mip", format, None)), 1, None); self.mip_pipelines.insert(format, p); } } /// The refraction source of a view of `size`: the scene without transmissive surfaces, with /// a short mip chain (rough glass reads blurrier levels). fn create_behind(&self, device: &wgpu::Device, size: [u32; 2]) -> Behind { let levels = mip_count(size[0].max(size[1])).min(BEHIND_LEVELS); let texture = device.create_texture(&wgpu::TextureDescriptor { label: Some("tc_behind"), size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 }, mip_level_count: levels, sample_count: 1, dimension: wgpu::TextureDimension::D2, format: self.hdr_format, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, view_formats: &[], }); let level = |l: u32| texture.create_view(&wgpu::TextureViewDescriptor { base_mip_level: l, mip_level_count: Some(1), ..Default::default() }); let mip_bg = |src: &wgpu::TextureView| { device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_behind_mip"), layout: &self.mip_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(src) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, ], }) }; let mips = (1..levels).map(|l| (level(l), mip_bg(&level(l - 1)))).collect(); let all = texture.create_view(&Default::default()); let bg = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_refr"), layout: &self.refr_bgl, entries: &[wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&all) }], }); Behind { level0: level(0), bg, mips } } /// Effect bind group (`fx_bgl`): source texture, the post uniform, up to three extra /// textures (`fx_a`, `fx_b`, `fx_c`; missing ones read black). fn fx_bind_group(&self, device: &wgpu::Device, src: &wgpu::TextureView, extra: &[&wgpu::TextureView], post: &wgpu::Buffer) -> wgpu::BindGroup { let tex = |i: usize| wgpu::BindingResource::TextureView(extra.get(i).copied().unwrap_or(&self.black)); device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_fx"), layout: &self.fx_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(src) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, wgpu::BindGroupEntry { binding: 3, resource: post.as_entire_binding() }, wgpu::BindGroupEntry { binding: 4, resource: tex(0) }, wgpu::BindGroupEntry { binding: 5, resource: tex(1) }, wgpu::BindGroupEntry { binding: 6, resource: tex(2) }, ], }) } fn create_targets(&self, device: &wgpu::Device, size: [u32; 2]) -> ViewTargets { let hdr = target_view(device, "tc_hdr", size, self.hdr_format, 1); let accum = target_view(device, "tc_accum", size, self.hdr_format, 1); let accum_bg = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_accum"), layout: &self.mip_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&hdr) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, ], }); let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC; let resolve = texture(device, "tc_resolve", size, COLOR_FORMAT, 1, usage); let resolve_view = resolve.create_view(&Default::default()); let uniform = |label: &str, size: usize| { device.create_buffer(&wgpu::BufferDescriptor { label: Some(label), size: size as u64, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }) }; let post_buf = uniform("tc_post", std::mem::size_of::()); let blit_buf = uniform("tc_blit", std::mem::size_of::()); let blit_bg = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_blit"), layout: &self.blit_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&resolve_view) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, wgpu::BindGroupEntry { binding: 2, resource: blit_buf.as_entire_binding() }, ], }); ViewTargets { size, msaa: target_view(device, "tc_msaa", size, self.hdr_format, MSAA), depth: target_view(device, "tc_depth", size, DEPTH_FORMAT, MSAA), post_bg: self.fx_bind_group(device, &accum, &[], &post_buf), hdr, accum, accum_bg, history: None, samples: 0, resolve, resolve_view, globals: uniform("tc_globals", std::mem::size_of::()), globals_bg: None, post_buf, bloom: None, fx: None, behind: None, blit_buf, blit_bg, ready: false, } } /// The bloom pyramid of `v`, and the post bind group that reads it. fn create_bloom(&self, device: &wgpu::Device, v: &ViewTargets) -> (Bloom, wgpu::BindGroup) { let levels: Vec = (1..=BLOOM_LEVELS).map(|i| target_view(device, "tc_bloom", [(v.size[0] >> i).max(1), (v.size[1] >> i).max(1)], self.hdr_format, 1)).collect(); let fx = |src: &wgpu::TextureView| self.fx_bind_group(device, src, &[], &v.post_buf); let down = std::iter::once(&v.accum).chain(&levels).take(levels.len()).map(fx).collect(); let up = levels.iter().skip(1).map(fx).collect(); let post_bg = self.fx_bind_group(device, &v.accum, &levels.iter().take(1).collect::>(), &v.post_buf); (Bloom { levels, down, up }, post_bg) } fn create_fx(&self, device: &wgpu::Device, size: [u32; 2]) -> Fx { let full = |label| target_view(device, label, size, self.hdr_format, 1); let half_size = [(size[0] / 2).max(1), (size[1] / 2).max(1)]; Fx { gbuf: full("tc_gbuf"), gbuf_depth: target_view(device, "tc_gbuf_depth", size, DEPTH_FORMAT, 1), a: full("tc_fx_a"), b: full("tc_fx_b"), half: target_view(device, "tc_dof_half", half_size, self.hdr_format, 1), near: target_view(device, "tc_dof_near", half_size, self.hdr_format, 1), } } fn targets(&mut self, device: &wgpu::Device, id: u64, size: [u32; 2], bloom: bool, fx: bool, refraction: bool) -> Option<&mut ViewTargets> { let size = [size[0].clamp(1, 8192), size[1].clamp(1, 8192)]; if self.views.get(&id).is_none_or(|v| v.size != size) { let v = self.create_targets(device, size); self.views.insert(id, v); } if refraction && self.views.get(&id).is_some_and(|v| v.behind.is_none()) { self.ensure_mip_pipeline(device, self.hdr_format); let b = self.create_behind(device, size); self.views.get_mut(&id)?.behind = Some(b); } if fx && self.views.get(&id).is_some_and(|v| v.fx.is_none()) { let f = self.create_fx(device, size); self.views.get_mut(&id)?.fx = Some(f); } if bloom && let Some(v) = self.views.get(&id) && v.bloom.is_none() { let (b, post_bg) = self.create_bloom(device, v); let v = self.views.get_mut(&id)?; v.bloom = Some(b); v.post_bg = post_bg; } let (env_view, shadow_view) = (&self.env.view, &self.shadow.view); let (bgl, env_sampler, shadow_sampler) = (&self.globals_bgl, &self.env_sampler, &self.shadow_sampler); let v = self.views.get_mut(&id)?; if v.globals_bg.is_none() { v.globals_bg = Some(device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_globals"), layout: bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: v.globals.as_entire_binding() }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(env_view) }, wgpu::BindGroupEntry { binding: 2, resource: wgpu::BindingResource::Sampler(env_sampler) }, wgpu::BindGroupEntry { binding: 3, resource: wgpu::BindingResource::TextureView(shadow_view) }, wgpu::BindGroupEntry { binding: 4, resource: wgpu::BindingResource::Sampler(shadow_sampler) }, ], })); } Some(v) } /// Index ranges of `ranges` (first, count, material) whose texture set is visible (and is /// `only`, when given), with that set. fn drawable<'a>( &'a self, ranges: &'a [(u32, u32, usize)], visible: &'a [bool], only: Option, ) -> impl Iterator, &'a SetGpu)> + 'a { ranges.iter().filter_map(move |&(start, count, material)| { let ts = self.material_sets.get(material).copied().flatten()?; if only.is_some_and(|o| o != ts) || !visible.get(ts).copied().unwrap_or(true) { return None; } Some((start..start + count, self.sets.get(ts)?)) }) } /// Keep the key-light shadow map current; returns its view-projection. `light` points to /// the light (world space), `disp` is the shadow pass's displacement (see shadow.wgsl). /// Re-renders only when the mesh, light, displacement or visible sets changed (and, when it /// displaces, the set textures). /// shortcut: casters are fully opaque (the dithered opacity cut-out is ignored) and the map is /// one shared buffer, so two 3D views with different lights in one frame would share the last /// light; upgrade to a per-view map if split 3D views get their own lights. #[allow(clippy::too_many_arguments)] fn update_shadow( &mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, light: Vec3, disp: [f32; 4], visible: &[bool], ) -> Option { let l = light.try_normalize()?; let (id, center, radius) = self.mesh.as_ref().map(|m| (m.id, m.center, m.radius))?; if self.shadow.size != SHADOW_SIZE { self.shadow.view = shadow_view(device, SHADOW_SIZE); self.shadow.size = SHADOW_SIZE; self.shadow.key = None; for v in self.views.values_mut() { v.globals_bg = None; } } let displacing = disp[0] > 0.5; let key = (id, l.to_array().map(f32::to_bits), disp.map(f32::to_bits), if displacing { self.content_rev } else { 0 }); if self.shadow.key == Some(key) && self.shadow.visible == visible { return Some(self.shadow.vp); } // An orthographic light frustum around the mesh's bounding sphere. let up = if l.y.abs() > 0.99 { Vec3::Z } else { Vec3::Y }; let vp = Mat4::orthographic_rh(-radius, radius, -radius, radius, radius * 0.5, radius * 3.5) * Mat4::look_at_rh(center + l * radius * 2.0, center, up); let mut raw = [[0.0f32; 4]; 5]; raw[..4].copy_from_slice(&vp.to_cols_array_2d()); raw[4] = disp; queue.write_buffer(&self.shadow.buf, 0, bytemuck::bytes_of(&raw)); let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("tc_shadow"), color_attachments: &[], depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { view: &self.shadow.view, depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: wgpu::StoreOp::Store }), stencil_ops: None, }), timestamp_writes: None, occlusion_query_set: None, multiview_mask: None, }); pass.set_pipeline(&self.shadow_pipeline); pass.set_bind_group(0, &self.shadow.bg, &[]); if let Some(m) = &self.mesh { let geo = m.dense.as_ref().filter(|_| displacing).unwrap_or(&m.geo); pass.set_vertex_buffer(0, geo.vb.slice(..)); pass.set_index_buffer(geo.ib.slice(..), wgpu::IndexFormat::Uint32); for (range, set) in self.drawable(&geo.draws, visible, None) { pass.set_bind_group(1, &set.bind_group, &[]); pass.draw_indexed(range, 0, 0..1); } } drop(pass); self.shadow.key = Some(key); self.shadow.visible = visible.to_vec(); self.shadow.vp = vp; Some(vp) } /// Whether view `id` is still accumulating anti-aliasing samples: the shell should draw it /// again even though nothing changed. pub fn accumulating(&self, id: u64) -> bool { self.views.get(&id).is_some_and(|v| v.history.as_ref().is_some_and(|(f, _)| f.shade.taa && f.kind == ViewKind::Scene) && v.samples + 1 < TAA_SAMPLES) } /// Render `frame` into its offscreen target (and regenerate dirty mips). A 3D frame with /// `shade.taa` that repeats the previous one adds a jittered sample to the average instead, /// and renders nothing once [`TAA_SAMPLES`] are in. pub fn prepare(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, frame: &Frame) { self.resolve_pending(device); self.generate_mips(device, encoder); let rev = self.content_rev; let sample = match self.views.get(&frame.view_id) { Some(v) if frame.shade.taa && frame.kind == ViewKind::Scene && v.history.as_ref().is_some_and(|(f, r)| *r == rev && f == frame) => v.samples + 1, _ => 0, }; if sample >= TAA_SAMPLES { return; } let aspect = frame.size[0].max(1) as f32 / frame.size[1].max(1) as f32; let mut vp = frame.camera.view_proj(aspect); if sample > 0 { // Sub-pixel jitter in clip space: a box filter over the pixel once averaged. let (jx, jy) = (halton(sample, 2) - 0.5, halton(sample, 3) - 0.5); vp = Mat4::from_translation(Vec3::new(2.0 * jx / frame.size[0].max(1) as f32, 2.0 * jy / frame.size[1].max(1) as f32, 0.0)) * vp; } let s = &frame.shade; let (uv_view, uv_xform) = match frame.kind { ViewKind::Scene => (0.0, [1.0, 1.0, 0.0, 0.0]), ViewKind::Uv { ts, zoom, pan } => { let [sx, sy] = uv_view_scale(aspect, zoom, self.sets.get(ts).map_or((1, 1), |s| s.size)); (1.0, [sx, sy, pan[0], pan[1]]) } }; // Data views (channels, mesh maps, UV checker, the 2D view) show values as they are: no // exposure, tone mapping, effects or shadows. let data = uv_view > 0.5 || s.view_mode != 0; let fx = |v: f32| if s.post_effects && !data { v.clamp(0.0, 1.0) } else { 0.0 }; let bloom = fx(s.bloom) > 0.0; // The key light lives in the environment: turn it with it (the inverse of env_rotate in // mesh.wgsl maps environment directions to world directions). let (sin, cos) = s.env_rotation_deg.to_radians().sin_cos(); let [lx, ly, lz, lw] = s.light; let light = Vec3::new(cos * lx + sin * lz, ly, cos * lz - sin * lx); let displace = s.displacement && frame.kind == ViewKind::Scene; if displace { self.ensure_dense(device, queue); } let disp = match self.mesh.as_ref().filter(|_| displace) { // Height-to-normal's slope: strength 1 tilts 45° for a height change of 1 over 1/16 of // the UV square; the vertex shader samples the mip whose texels match the vertex spacing. Some(m) => [1.0, m.world_per_uv / 16.0, 1.0 / (m.dense.as_ref().unwrap_or(&m.geo).triangles.max(1) as f32 * 0.5).sqrt(), 0.0], None => [0.0; 4], }; let shadow_disp = [disp[0], disp[1] * s.height_strength, disp[2], 0.0]; let shadow_vp = if !data && s.shadows && lw > 0.0 { self.update_shadow(device, queue, encoder, light, shadow_disp, &frame.visible) } else { None }; let radius = self.mesh.as_ref().map_or(1.0, |m| m.radius); // Background rays come from a perspective camera even in orthographic views (an ortho // ray grid would show a single flat environment color). let bg_vp = OrbitCamera { ortho: false, ..frame.camera }.view_proj(aspect); let e = frame.camera.eye(); // Scene effects (3D material view; they need float targets for depths and signed light). let scene_fx = !data && frame.kind == ViewKind::Scene && self.hdr_format == HDR_FORMAT && self.mesh.is_some(); let dof = s.dof.filter(|_| scene_fx); let sss = s.sss_blur.filter(|m| scene_fx && m.iter().any(|v| *v > 0.0)); let fx_on = dof.is_some() || sss.is_some(); let refraction = s.refraction && !data && frame.kind == ViewKind::Scene && self.mesh.is_some(); let cam = &frame.camera; let half_h = (cam.fov.clamp(5.0, 150.0).to_radians() * 0.5).tan(); let height = frame.size[1].max(1) as f32; // Pixels per world unit at view depth z: k / z in perspective, k in orthographic views. let k = if cam.ortho { height / (2.0 * cam.distance.max(1e-6) * half_h) } else { height / (2.0 * half_h) }; let ppw = |z: f32| if cam.ortho { k } else { k / z.max(1e-6) }; let dof_c = dof.map_or([0.0; 4], |[focus, aperture]| { let f = if focus > 0.0 { focus } else { cam.distance }; [aperture.max(0.0) * radius * ppw(f), f, MAX_COC * height, sample as f32] }); let sss_d = sss.map_or([0.0; 4], |m| [m[0] * radius, m[1] * radius, m[2] * radius, k]); let fwd = cam.forward(); let raw = GlobalsRaw { view_proj: vp.to_cols_array_2d(), inv_view_proj: bg_vp.inverse().to_cols_array_2d(), eye: [e.x, e.y, e.z, 0.0], env: [s.env_rotation_deg.to_radians(), (ENV_LEVELS - 1) as f32, s.ao_intensity, 0.0], sh: self.sh, mode: [s.view_mode as f32, s.channel as f32, s.height_strength, s.normal_y], bg: [s.env_opacity, s.env_blur * (ENV_LEVELS - 1) as f32, uv_view, 0.0], uv_xform, light: [light.x, light.y, light.z, lw], light_vp: shadow_vp.unwrap_or(Mat4::IDENTITY).to_cols_array_2d(), // Normal offset: 1.5 shadow texels of the light frustum (2 × radius wide). shadow: [if shadow_vp.is_some() { 1.0 } else { 0.0 }, 1.0 / SHADOW_SIZE as f32, radius * 3.0 / SHADOW_SIZE as f32, 0.0], material: [if s.spec_gloss { 1.0 } else { 0.0 }, if s.parallax { 1.0 } else { 0.0 }, sample as f32, s.ior], scatter: [s.scatter[0], s.scatter[1], s.scatter[2], if sss.is_some() { 1.0 } else { 0.0 }], fwd: [fwd.x, fwd.y, fwd.z, 0.0], disp, refr: [if refraction { 1.0 } else { 0.0 }, (BEHIND_LEVELS - 1) as f32, REFRACTION_DEPTH * radius, 0.0], }; let flag = |b: bool| if b { 1.0 } else { 0.0 }; let post = PostRaw { a: [2f32.powf(s.exposure_ev), flag(s.aces), flag(data), fx(s.bloom) * BLOOM_GAIN], b: [fx(s.vignette), fx(s.sharpen), fx(s.grain), BLOOM_THRESHOLD], c: dof_c, d: sss_d, e: [flag(cam.ortho), sample as f32, 0.0, 0.0], }; let Some(v) = self.targets(device, frame.view_id, frame.size, bloom, fx_on, refraction) else { return }; queue.write_buffer(&v.globals, 0, bytemuck::bytes_of(&raw)); queue.write_buffer(&v.post_buf, 0, bytemuck::bytes_of(&post)); v.ready = true; v.history = Some((frame.clone(), rev)); v.samples = sample; let Some(v) = self.views.get(&frame.view_id) else { return }; let Some(globals_bg) = v.globals_bg.as_ref() else { return }; if refraction && let Some(b) = &v.behind { self.behind_pass(encoder, v, b, globals_bg, frame); } let weight = 1.0 / f64::from(sample + 1); match v.fx.as_ref().filter(|_| fx_on) { // The effects run on every frame before it joins the average, so idle accumulation // also smooths the depth of field's sampling pattern (turned each frame). Their // G-buffer (unjittered) stays valid while the view accumulates. Some(f) => { self.scene_pass(encoder, v, &v.hdr, globals_bg, frame); if sample == 0 { self.gbuf_pass(encoder, f, globals_bg, frame); } let out = self.scene_fx(device, encoder, v, f, sss.is_some(), dof.is_some()); let bg = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_accum_fx"), layout: &self.mip_bgl, entries: &[ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(out) }, wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) }, ], }); fullscreen_blend(encoder, "tc_accum", &v.accum, wgpu::LoadOp::Load, &self.accum_pipeline, &bg, weight); } None if sample == 0 => self.scene_pass(encoder, v, &v.accum, globals_bg, frame), None => { self.scene_pass(encoder, v, &v.hdr, globals_bg, frame); fullscreen_blend(encoder, "tc_accum", &v.accum, wgpu::LoadOp::Load, &self.accum_pipeline, &v.accum_bg, weight); } } if bloom && let Some(b) = &v.bloom { let [pre, down, up] = &self.bloom_pipelines; for (i, (level, bg)) in b.levels.iter().zip(&b.down).enumerate() { fullscreen(encoder, "tc_bloom_down", level, CLEAR, if i == 0 { pre } else { down }, bg); } for (level, bg) in b.levels.iter().zip(&b.up).rev() { fullscreen(encoder, "tc_bloom_up", level, wgpu::LoadOp::Load, up, bg); } } fullscreen(encoder, "tc_post", &v.resolve_view, CLEAR, &self.post_pipeline, &v.post_bg); } /// The scene effects' G-buffer: the mesh again, single-sampled, into `f.gbuf`. fn gbuf_pass(&self, encoder: &mut wgpu::CommandEncoder, f: &Fx, globals_bg: &wgpu::BindGroup, frame: &Frame) { let Some(m) = &self.mesh else { return }; let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("tc_gbuf"), color_attachments: &[Some(wgpu::RenderPassColorAttachment { view: &f.gbuf, resolve_target: None, depth_slice: None, ops: wgpu::Operations { load: CLEAR, store: wgpu::StoreOp::Store }, })], depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { view: &f.gbuf_depth, depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: wgpu::StoreOp::Discard }), stencil_ops: None, }), timestamp_writes: None, occlusion_query_set: None, multiview_mask: None, }); pass.set_pipeline(&self.gbuf_pipeline); pass.set_bind_group(0, globals_bg, &[]); pass.set_bind_group(2, &self.refr_black, &[]); let geo = self.geometry(m, frame); pass.set_vertex_buffer(0, geo.vb.slice(..)); pass.set_index_buffer(geo.ib.slice(..), wgpu::IndexFormat::Uint32); for (range, set) in self.drawable(&geo.draws, &frame.visible, None) { pass.set_bind_group(1, &set.bind_group, &[]); pass.draw_indexed(range, 0, 0..1); } } /// The triangles a frame draws: the dense copy when it displaces. fn geometry<'a>(&self, m: &'a MeshGpu, frame: &Frame) -> &'a Geometry { m.dense.as_ref().filter(|_| frame.shade.displacement && frame.kind == ViewKind::Scene).unwrap_or(&m.geo) } /// The scene without transmissive surfaces into `b` (MSAA resolved into mip 0), then its mips. fn behind_pass(&self, encoder: &mut wgpu::CommandEncoder, v: &ViewTargets, b: &Behind, globals_bg: &wgpu::BindGroup, frame: &Frame) { self.draw_scene(encoder, v, &b.level0, globals_bg, frame, &self.opaque_pipeline, None, &self.refr_black); let Some(pipe) = self.mip_pipelines.get(&self.hdr_format) else { return }; for (dst, bg) in &b.mips { fullscreen(encoder, "tc_behind_mip", dst, CLEAR, pipe, bg); } } /// Subsurface blur and depth of field over this frame's scene (`v.hdr`); returns the result. fn scene_fx<'a>( &self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, v: &'a ViewTargets, f: &'a Fx, sss: bool, dof: bool, ) -> &'a wgpu::TextureView { let bg = |src: &wgpu::TextureView, extra: &[&wgpu::TextureView]| self.fx_bind_group(device, src, extra, &v.post_buf); let mut scene = &v.hdr; if sss { let [h, vert] = &self.sss_pipelines; fullscreen(encoder, "tc_sss_h", &f.a, CLEAR, h, &bg(&f.gbuf, &[])); fullscreen(encoder, "tc_sss_v", &f.b, CLEAR, vert, &bg(&f.a, &[&v.hdr])); scene = &f.b; } if dof { let target = |view| { Some(wgpu::RenderPassColorAttachment { view, resolve_target: None, depth_slice: None, ops: wgpu::Operations { load: CLEAR, store: wgpu::StoreOp::Store }, }) }; let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("tc_dof_gather"), color_attachments: &[target(&f.half), target(&f.near)], depth_stencil_attachment: None, timestamp_writes: None, occlusion_query_set: None, multiview_mask: None, }); pass.set_pipeline(&self.dof_gather_pipeline); pass.set_bind_group(0, &bg(scene, &[&f.gbuf]), &[]); pass.draw(0..3, 0..1); drop(pass); fullscreen(encoder, "tc_dof", &f.a, CLEAR, &self.dof_pipeline, &bg(scene, &[&f.half, &f.gbuf, &f.near])); scene = &f.a; } scene } /// Background, mesh and wireframe into the view's MSAA HDR target, resolved to `resolve`. fn scene_pass(&self, encoder: &mut wgpu::CommandEncoder, v: &ViewTargets, resolve: &wgpu::TextureView, globals_bg: &wgpu::BindGroup, frame: &Frame) { let uv_ts = match frame.kind { ViewKind::Scene => None, ViewKind::Uv { ts, .. } => Some(ts), }; let (pipe, wire) = match uv_ts { None => (&self.mesh_pipeline, frame.shade.wireframe_3d.then_some(&self.wire3d_pipeline)), Some(_) => (&self.uv_pipeline, frame.shade.wireframe.then_some(&self.wire_pipeline)), }; // Transmissive surfaces refract what the behind pass rendered this frame. let refr = v.behind.as_ref().filter(|_| frame.shade.refraction).map_or(&self.refr_black, |b| &b.bg); self.draw_scene(encoder, v, resolve, globals_bg, frame, pipe, wire, refr); } /// One scene pass: background, then the mesh with `pipe` and the wireframe with `wire`. #[allow(clippy::too_many_arguments)] fn draw_scene( &self, encoder: &mut wgpu::CommandEncoder, v: &ViewTargets, resolve: &wgpu::TextureView, globals_bg: &wgpu::BindGroup, frame: &Frame, pipe: &wgpu::RenderPipeline, wire: Option<&wgpu::RenderPipeline>, refr: &wgpu::BindGroup, ) { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("tc_view"), color_attachments: &[Some(wgpu::RenderPassColorAttachment { view: &v.msaa, resolve_target: Some(resolve), depth_slice: None, ops: wgpu::Operations { load: CLEAR, store: wgpu::StoreOp::Discard }, })], depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { view: &v.depth, depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: wgpu::StoreOp::Discard }), stencil_ops: None, }), timestamp_writes: None, occlusion_query_set: None, multiview_mask: None, }); pass.set_bind_group(0, globals_bg, &[]); pass.set_pipeline(&self.bg_pipeline); pass.draw(0..3, 0..1); let Some(m) = &self.mesh else { return }; let uv_ts = match frame.kind { ViewKind::Scene => None, ViewKind::Uv { ts, .. } => Some(ts), }; pass.set_bind_group(2, refr, &[]); let geo = self.geometry(m, frame); // The wireframe draws the mesh's own edges (displaced in the vertex shader too). for (pipe, vb, ib, ranges) in [(Some(pipe), &geo.vb, &geo.ib, &geo.draws), (wire, &m.geo.vb, &m.lines, &m.line_draws)] { let Some(pipe) = pipe else { continue }; pass.set_pipeline(pipe); pass.set_vertex_buffer(0, vb.slice(..)); pass.set_index_buffer(ib.slice(..), wgpu::IndexFormat::Uint32); for (range, set) in self.drawable(ranges, &frame.visible, uv_ts) { pass.set_bind_group(1, &set.bind_group, &[]); pass.draw_indexed(range, 0, 0..1); } } } /// Draw view `id` into the current pass at `rect` (target pixels: x, y, w, h). pub fn blit(&self, queue: &wgpu::Queue, pass: &mut wgpu::RenderPass<'_>, id: u64, rect: [f32; 4], target_size: [u32; 2]) { let Some(v) = self.views.get(&id).filter(|v| v.ready) else { return }; let raw = BlitRaw { rect, dst: [target_size[0] as f32, target_size[1] as f32, if self.target_format.is_srgb() { 1.0 } else { 0.0 }, 0.0] }; queue.write_buffer(&v.blit_buf, 0, bytemuck::bytes_of(&raw)); pass.set_pipeline(&self.blit_pipeline); pass.set_bind_group(0, &v.blit_bg, &[]); pass.draw(0..6, 0..1); } /// Write the blit rectangle for view `id` (call from `prepare` when the pass can't write /// buffers itself). pub fn set_blit_rect(&self, queue: &wgpu::Queue, id: u64, rect: [f32; 4], target_size: [u32; 2]) { if let Some(v) = self.views.get(&id) { let raw = BlitRaw { rect, dst: [target_size[0] as f32, target_size[1] as f32, if self.target_format.is_srgb() { 1.0 } else { 0.0 }, 0.0] }; queue.write_buffer(&v.blit_buf, 0, bytemuck::bytes_of(&raw)); } } /// Draw view `id` with the rectangle set by [`Renderer::set_blit_rect`]. pub fn blit_prepared(&self, pass: &mut wgpu::RenderPass<'_>, id: u64) { let Some(v) = self.views.get(&id).filter(|v| v.ready) else { return }; pass.set_pipeline(&self.blit_pipeline); pass.set_bind_group(0, &v.blit_bg, &[]); pass.draw(0..6, 0..1); } /// Read back the rendered view as tightly packed RGBA8 (sRGB-encoded), blocking. pub fn read_view(&self, device: &wgpu::Device, queue: &wgpu::Queue, id: u64) -> Option<(u32, u32, Vec)> { crate::readback::Readback::blocking(device, queue, &self.views.get(&id)?.resolve) } /// Forget a view's targets (e.g. a closed panel). pub fn drop_view(&mut self, id: u64) { self.views.remove(&id); } } #[cfg(test)] mod tests { use super::*; use crate::headless::Headless; /// A headless renderer with one 256² texture set, and the base color slot's full-size /// texture handed over as WebGPU would: allocated, with its verdict still to come. fn awaiting() -> Option<(Headless, std::sync::mpsc::Sender>)> { let Ok(mut h) = Headless::new() else { eprintln!("skipping: no GPU adapter"); return None; }; h.renderer.set_texture_sets(&h.device, &h.queue, &[((256, 256), 0)], 1); let (tx, rx) = std::sync::mpsc::channel(); let full = neutral_tex(&h.device, &h.queue, (256, 256), display_format(DisplayKind::BaseColor), mip_count(256), &[0, 0, 0, 255]); let r = &mut h.renderer; let set = r.sets.get_mut(0).unwrap(); assert!(grow(set, 0, 0, Checked::Later(full, rx), (&h.device, &r.set_bgl, &r.sampler), &mut r.memory_failures)); Some((h, tx)) } fn base_width(h: &Headless) -> u32 { h.renderer.display_textures()[0][0].width() } fn prepare(h: &mut Headless) { let mut enc = h.device.create_command_encoder(&Default::default()); h.renderer.resolve_pending(&h.device); h.renderer.generate_mips(&h.device, &mut enc); h.queue.submit([enc.finish()]); } #[test] fn a_late_texture_stays_unbound_until_accepted() { let Some((mut h, tx)) = awaiting() else { return }; assert!(h.renderer.awaiting_gpu()); // Tiles go into the pending texture; the placeholder stays bound and nothing is retried. h.renderer.upload_tile(&h.device, &h.queue, 0, DisplayKind::BaseColor, 0, 0, &[200, 30, 30, 255].repeat(64 * 64)); prepare(&mut h); assert_eq!(base_width(&h), 1, "no verdict yet: the placeholder stays bound"); assert!(h.renderer.awaiting_gpu()); tx.send(None).unwrap(); prepare(&mut h); assert_eq!(base_width(&h), 256, "accepted: installed"); assert!(!h.renderer.awaiting_gpu()); assert!(h.renderer.take_memory_failures().is_empty()); } #[test] fn a_late_rejection_keeps_the_placeholder_and_is_reported() { let Some((mut h, tx)) = awaiting() else { return }; tx.send(Some("texture set 1 (BaseColor, 256×256): Out of Memory".into())).unwrap(); prepare(&mut h); assert_eq!(base_width(&h), 1); assert!(!h.renderer.awaiting_gpu()); assert_eq!(h.renderer.take_memory_failures(), vec![0]); // The failed kind is not allocated again by later tiles. h.renderer.upload_tile(&h.device, &h.queue, 0, DisplayKind::BaseColor, 1, 0, &[200, 30, 30, 255].repeat(64 * 64)); prepare(&mut h); assert_eq!(base_width(&h), 1); assert!(!h.renderer.awaiting_gpu()); } #[test] fn a_verdict_that_never_comes_counts_as_a_failure() { let Some((mut h, tx)) = awaiting() else { return }; drop(tx); prepare(&mut h); assert_eq!(base_width(&h), 1); assert_eq!(h.renderer.take_memory_failures(), vec![0]); } }