mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-20 06:20:50 +01:00
2038 lines
96 KiB
Rust
2038 lines
96 KiB
Rust
//! 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<bool>,
|
||
}
|
||
|
||
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<Tex>,
|
||
bind_group: wgpu::BindGroup,
|
||
mips_dirty: Vec<bool>,
|
||
/// 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<bool>,
|
||
/// 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<Option<PendingTex>>,
|
||
}
|
||
|
||
/// 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<std::sync::mpsc::Receiver<Option<String>>>,
|
||
}
|
||
|
||
/// 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<Tex>,
|
||
ctx: (&wgpu::Device, &wgpu::BindGroupLayout, &wgpu::Sampler),
|
||
failures: &mut Vec<usize>,
|
||
) -> 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<Vertex>, Vec<u32>)>,
|
||
/// The subdivided copy displacement draws (built on first use; None: the mesh is dense).
|
||
dense: Option<Geometry>,
|
||
/// 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<wgpu::TextureView>,
|
||
/// Per level: reads the level above (the HDR scene for level 0).
|
||
down: Vec<wgpu::BindGroup>,
|
||
/// Per level but the last: reads the level below, added onto this one.
|
||
up: Vec<wgpu::BindGroup>,
|
||
}
|
||
|
||
/// 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<wgpu::BindGroup>,
|
||
post_buf: wgpu::Buffer,
|
||
post_bg: wgpu::BindGroup,
|
||
bloom: Option<Bloom>,
|
||
fx: Option<Fx>,
|
||
behind: Option<Behind>,
|
||
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<bool>,
|
||
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<wgpu::TextureFormat, wgpu::RenderPipeline>,
|
||
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<Vec<u8>>,
|
||
/// Texture sets whose display textures could not be allocated (out of GPU memory) since
|
||
/// [`Renderer::take_memory_failures`].
|
||
memory_failures: Vec<usize>,
|
||
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<MeshGpu>,
|
||
sets: Vec<SetGpu>,
|
||
/// 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<Option<usize>>,
|
||
views: HashMap<u64, ViewTargets>,
|
||
}
|
||
|
||
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<usize>, 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<wgpu::BindGroupEntry> =
|
||
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<wgpu::BlendState>);
|
||
|
||
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<wgpu::VertexBufferLayout>],
|
||
color: Option<ColorOut<'_>>,
|
||
samples: u32,
|
||
depth: Option<wgpu::DepthStencilState>,
|
||
) -> 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<wgpu::Color>,
|
||
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<wgpu::Color>,
|
||
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::Color> = 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::<Vertex>() 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<Vec<&wgpu::Texture>> {
|
||
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<u8> = 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::<u32, u8>(&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<u32> = 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<usize> {
|
||
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<Tex> =
|
||
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<u8>;
|
||
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<usize> {
|
||
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<u32> {
|
||
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::<PostRaw>());
|
||
let blit_buf = uniform("tc_blit", std::mem::size_of::<BlitRaw>());
|
||
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::<GlobalsRaw>()),
|
||
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<wgpu::TextureView> =
|
||
(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::<Vec<_>>(), &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<usize>,
|
||
) -> impl Iterator<Item = (std::ops::Range<u32>, &'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<Mat4> {
|
||
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<u8>)> {
|
||
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<Option<String>>)> {
|
||
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]);
|
||
}
|
||
}
|