Revert "Show a whole material at once: coarse first look, then the exact result"

This commit is contained in:
Chris Hassebrook authored and GitHub committed 2026-11-10 16:08:27 -05:00
1 parent 783cbdcb27
commit d664dc239c
10 files changed
+31 -510

No files matched your search

+7 -152
View File
@@ -803,22 +803,6 @@ fn fields_of(inp: &Inputs, channels: &[Channel], list: &[LayerId], tiles: &[(u32
out
}
/// Whether texture set `ts` has a layer with a neighbourhood filter (blur, sharpen, warp…) in
/// its mask or content: a composite then precomputes [`neighbourhood_fields`] at full
/// resolution, so even a [`composite_tiles_coarse`] is not much cheaper than the exact one.
/// The same layers as `neighbourhood_fields` looks at (it may count a hidden one).
pub fn has_neighbourhood_filters(project: &Project, ts: usize) -> bool {
let Ok(set) = project.texture_set(ts) else { return false };
let mut order = Vec::new();
draw_order(project, &set.stack, 0, &mut order);
let res = set.resolution;
order.iter().any(|id| {
let mask = layer_mask(project, *id).is_some_and(|m| m.enabled && neighbourhood(&m.effects, res).is_some());
let content = project.content_layer(*id).is_some_and(|l| !l.is_group() && neighbourhood(&l.content_effects, res).is_some());
mask || content
})
}
/// Build the curvature detail sizes every visible generator of `layers` reads, once, before tiles composite in parallel.
fn prepare_curvature_sizes(inp: &Inputs, layers: &[LayerId]) {
let visible = layers.iter().filter(|id| inp.project.layers.get(id).is_some_and(|layer| layer.visible));
@@ -915,89 +899,10 @@ fn mask_plan<'a>(inp: &Inputs<'a>, id: LayerId, mask: &'a Mask, tx: u32, ty: u32
}
fn plan<'a>(inp: &Inputs<'a>, list: &[LayerId], channels: &[Channel], tx: u32, ty: u32, depth: usize, fields: Option<&'a Fields>) -> Vec<Node<'a>> {
plan_with(inp, list, channels, tx, ty, depth, fields, false)
}
/// [`plan`], leaving out what an opaque layer above hides when `cull` (see [`cull_hidden`]).
/// Only for lists that are evaluated whole and not looked into (no anchor or stop layer reads).
#[allow(clippy::too_many_arguments)]
fn plan_with<'a>(
inp: &Inputs<'a>,
list: &[LayerId],
channels: &[Channel],
tx: u32,
ty: u32,
depth: usize,
fields: Option<&'a Fields>,
cull: bool,
) -> Vec<Node<'a>> {
if depth > texturecraft_core::project::MAX_DEPTH {
return Vec::new();
}
let mut nodes: Vec<Node<'a>> = list.iter().filter_map(|id| plan_node(inp, *id, channels, tx, ty, depth, fields, true, cull)).collect();
if cull {
cull_hidden(&mut nodes, channels);
}
nodes
}
/// Whether node `n` hides everything below it in channel `ch`: it replaces the stack there at
/// every texel (full opacity, normal blend, no mask or geometry or height mask, a fill that
/// covers the whole surface with no content effects), or is a folder at full opacity holding
/// such a layer.
fn occludes(n: &Node, ch: usize) -> bool {
if n.mask.is_some() || n.parts.is_some() || n.height_mask.enabled {
return false;
}
let Some(c) = n.chans.iter().find(|c| c.ch == ch) else { return false };
if c.opacity < 1.0 {
return false;
}
match &n.content {
Content::Fill(f) => c.blend == BlendMode::Normal && !matches!(f.projection, Projection::Decal(_)) && c.effects.is_empty() && c.start.is_none(),
Content::Group(kids) => kids.iter().any(|k| occludes(k, ch)),
Content::Paint { .. } => false,
}
}
/// Whether `n` or a layer in it masks with its height.
fn uses_height_mask(n: &Node) -> bool {
n.height_mask.enabled || matches!(&n.content, Content::Group(kids) if kids.iter().any(uses_height_mask))
}
/// Take channel `ch` out of `n` (and what it holds), dropping what then draws nothing.
fn strip_channel(n: &mut Node, ch: usize) {
n.chans.retain(|c| c.ch != ch);
if let Content::Group(kids) = &mut n.content {
for k in kids.iter_mut() {
strip_channel(k, ch);
}
kids.retain(|k| !k.chans.is_empty());
}
}
/// Leave out the layers (per channel) that a layer above them hides completely: a stack that
/// grows by applying material after material would otherwise evaluate every one of them. The
/// result is identical. Channels with anchor points or height masks below the hiding layer
/// are left alone (they read other layers' values), and so are those under a hiding folder
/// that records an anchor point: its inner stack starts from what lies below it, so an anchor
/// under the hiding layer inside it holds the layers it hides.
fn cull_hidden(nodes: &mut Vec<Node>, channels: &[Channel]) {
for c in channels {
let ch = c.index();
let Some(k) = nodes.iter().rposition(|n| occludes(n, ch)) else { continue };
if nodes.get(k).is_some_and(|n| n.has_anchor) {
continue;
}
let Some(below) = nodes.get_mut(..k) else { continue };
if below.iter().any(|n| n.has_anchor || (*c == Channel::Height && uses_height_mask(n))) {
continue;
}
for n in below.iter_mut() {
strip_channel(n, ch);
}
}
nodes.retain(|n| !n.chans.is_empty() || n.has_anchor);
list.iter().filter_map(|id| plan_node(inp, *id, channels, tx, ty, depth, fields, true)).collect()
}
/// The plan of layer `id` at `depth` (None where it draws nothing); a folder's children are
@@ -1012,7 +917,6 @@ fn plan_node<'a>(
depth: usize,
fields: Option<&'a Fields>,
kids: bool,
cull: bool,
) -> Option<Node<'a>> {
let own: &'a Layer = inp.project.layers.get(&id)?;
// Instances draw their source's content (a missing source draws nothing).
@@ -1039,9 +943,7 @@ fn plan_node<'a>(
let content = match &layer.kind {
LayerKind::Paint => Content::Paint { preview: previews(inp, PaintTarget::Layer(layer.id)) },
LayerKind::Fill(f) => Content::Fill(f),
LayerKind::Group { children, .. } => {
Content::Group(if kids { plan_with(inp, children, channels, tx, ty, depth + 1, fields, cull) } else { Vec::new() })
}
LayerKind::Group { children, .. } => Content::Group(if kids { plan(inp, children, channels, tx, ty, depth + 1, fields) } else { Vec::new() }),
// `content_layer` already followed instance links.
LayerKind::Instance { .. } => return None,
};
@@ -1088,8 +990,8 @@ fn plan_levels<'a>(inp: &Inputs<'a>, levels: &[Level], channels: &[Channel], tx:
.iter()
.enumerate()
.map(|(d, l)| LevelPlan {
below: if warm { Vec::new() } else { plan_with(inp, &l.below, channels, tx, ty, d, Some(fields), true) },
at: plan_node(inp, l.at, channels, tx, ty, d, Some(fields), d == last, false),
below: if warm { Vec::new() } else { plan(inp, &l.below, channels, tx, ty, d, Some(fields)) },
at: plan_node(inp, l.at, channels, tx, ty, d, Some(fields), d == last),
above: plan(inp, &l.above, channels, tx, ty, d, Some(fields)),
})
.collect()
@@ -1758,35 +1660,6 @@ pub fn composite_tiles(inp: &Inputs, out: &mut Composite, tiles: &[(u32, u32)])
composite_tiles_cached(inp, out, tiles, None);
}
/// The strides a coarse composite ([`composite_tiles_coarse`]) takes, coarsest first: texels
/// per block side, one evaluated per block. Each divides the rows of a band and a tile, so a
/// block never crosses bands or tiles. A big recomposite shows them in this order before the
/// exact composite. One level: a coarse pass costs about the same at any stride (writing,
/// padding and uploading the full-resolution tiles dominate once one texel in 64 is
/// evaluated; measured 4096², 3217 tiles: 139 ms at 16, 150 at 8, 254 at 4, 2.1 s exact), so
/// a second level would only add that cost again before the exact composite.
pub const COARSE_STRIDES: [u32; 1] = [8];
/// A quick look at `tiles`: [`composite_tiles`] evaluating one texel in every `stride` by `stride`
/// block (its first covered texel) and repeating it over the block's covered texels (a texel only
/// depends on its own position, so the evaluated ones are exact; the rest are as blocky as a
/// lower resolution), about `stride`² times fewer evaluations. A `stride` that does not divide a band and a tile composites exactly. A later
/// [`composite_tiles`] of the same tiles gives the exact result.
pub fn composite_tiles_coarse(inp: &Inputs, out: &mut Composite, tiles: &[(u32, u32)], stride: u32) {
let Ok(set) = inp.project.texture_set(inp.ts) else { return };
if (inp.gbuf.width, inp.gbuf.height) != (out.resolution, out.height) {
return;
}
let step = if stride > 0 && BAND.is_multiple_of(stride) && TILE.is_multiple_of(stride) { stride } else { 1 };
let mut blocks: BTreeMap<(u32, u32), Vec<(u32, u32)>> = BTreeMap::new();
for t in tiles {
blocks.entry((t.1 / BLOCK, t.0 / BLOCK)).or_default().push(*t);
}
for block in blocks.values() {
composite_block(inp, &set.stack, out, block, None, 0, step);
}
}
/// Tiles per side of the blocks a composite works through (bounds neighbourhood-filter memory).
const BLOCK: u32 = 16;
@@ -1815,7 +1688,7 @@ pub fn composite_tiles_cached(inp: &Inputs, out: &mut Composite, tiles: &[(u32,
None => 0,
};
let cached = below.as_deref().zip(split.as_deref());
let records = composite_block(inp, &set.stack, out, block, cached, quota, 1);
let records = composite_block(inp, &set.stack, out, block, cached, quota);
if let Some(b) = below.as_deref_mut() {
for t in block {
b.touch(*t);
@@ -1846,7 +1719,6 @@ fn composite_block(
tiles: &[(u32, u32)],
below: Option<(&BelowCache, &[Level])>,
quota: usize,
step: u32,
) -> Vec<((u32, u32), Vec<Band>)> {
let channels: Vec<Channel> = inp.project.texture_set(inp.ts).map(|s| s.channel_list()).unwrap_or_default();
let (w, h) = (out.resolution, out.height);
@@ -1876,7 +1748,7 @@ fn composite_block(
let warm = cached((tx, ty)).and_then(|b| b.get(band as usize));
let record = warm.is_none() && recorded.contains(&(tx, ty));
let levels = split.map(|l| plan_levels(inp, l, &channels, tx, ty, &fields, warm.is_some()));
let nodes = if levels.is_none() { plan_with(inp, stack, &channels, tx, ty, 0, Some(&fields), true) } else { Vec::new() };
let nodes = if levels.is_none() { plan(inp, stack, &channels, tx, ty, 0, Some(&fields)) } else { Vec::new() };
let rows = (BAND * TILE) as usize;
let mut accs = vec![defaults; nlev];
let mut masks = vec![0.0f32; nlev];
@@ -1900,17 +1772,11 @@ fn composite_block(
let mut bufs: Vec<Vec<u16>> = channels.iter().map(|c| vec![0u16; rows * c.components()]).collect();
let mut anchors = Vec::new();
let mut any = false;
// Coarse: per `step`-wide block of the current block row, the value of its first
// covered texel (evaluated), repeated over the block's other covered texels.
let mut sampled: Vec<Option<Acc>> = vec![None; if step > 1 { (TILE / step) as usize } else { 0 }];
for ly in band * BAND..(band + 1) * BAND {
let y = ty * TILE + ly;
if y >= h {
break;
}
if step > 1 && ly % step == 0 {
sampled.fill(None);
}
for lx in 0..TILE {
let x = tx * TILE + lx;
if x >= w {
@@ -1922,12 +1788,7 @@ fn composite_block(
let ob = ((ly - band * BAND) * TILE + lx) as usize;
let covered = inp.gbuf.tri.get(gi).is_some_and(|t| *t != NO_TRI);
let mut acc = defaults;
let block = if step > 1 { sampled.get_mut((lx / step) as usize) } else { None };
let repeated = block.as_ref().and_then(|b| **b);
if covered && let Some(a) = repeated {
any = true;
acc = a;
} else if covered {
if covered {
any = true;
let mut tex = Texel::new(inp, x, y, o, stroke_at(preview_tile, o));
// Reuse one anchor buffer per band.
@@ -1959,12 +1820,6 @@ fn composite_block(
anchors = tex.anchors;
anchors.clear();
}
if covered
&& repeated.is_none()
&& let Some(slot) = block
{
*slot = Some(acc);
}
for (l, buf) in lanes.iter().zip(&mut bufs) {
let v = acc.get(l.ch).copied().unwrap_or([0.0; 3]);
for (k, x) in v.iter().take(l.n).enumerate() {
+2 -2
View File
@@ -20,8 +20,8 @@ pub mod thumb;
pub use below::{BelowCache, StackKey};
pub use display::{DisplayKind, tile_bytes};
pub use eval::{
COARSE_STRIDES, Composite, Inputs, PaintTarget, Stencil, StrokePreview, all_tiles, composite_tiles, composite_tiles_cached, composite_tiles_coarse,
covered_tiles, effect_histogram, flatten_layer, has_neighbourhood_filters, mask_at, mask_image, pad_tiles,
Composite, Inputs, PaintTarget, Stencil, StrokePreview, all_tiles, composite_tiles, composite_tiles_cached, covered_tiles, effect_histogram, flatten_layer,
mask_at, mask_image, pad_tiles,
};
pub use store::{BakedMaps, ImageRes, ImageStore, PixelStore};
pub use thumb::{THUMB_TEXELS, ThumbImage, ThumbTarget};
@@ -573,35 +573,3 @@ fn gathering_filters_composite_identically_in_any_grouping_and_cached() {
assert!(!check_cached(&f, 0, hot).is_empty());
}
}
/// A folder that hides the layers below it but records an anchor point inside (under its own
/// hiding layer) keeps them: its inner stack starts from them, so the anchor holds them.
#[test]
fn layers_under_a_hiding_folder_with_an_anchor_are_not_culled() {
let mut f = fixture();
let only = |f: &mut Fixture, id: LayerId, c: Channel| f.project.layer_mut(id).unwrap().channels.retain(|x, _| *x == c);
let low = add(&mut f, 0, fill(&[(Channel::BaseColor, Source::Uniform([0.9; 3]))]), None);
only(&mut f, low, Channel::BaseColor);
let group = add(&mut f, 0, LayerKind::Group { children: vec![], collapsed: false }, None);
// Inside: a half-opacity fill recording anchor A, then an opaque fill hiding everything.
let anchored = put(&mut f, 0, Some(group), fill(&[(Channel::BaseColor, Source::Uniform([0.5; 3]))]), None);
only(&mut f, anchored, Channel::BaseColor);
blend(&mut f, anchored, BlendMode::Normal, 0.5);
let anchor = effect(&mut f, EffectKind::Anchor);
let anchor_id = anchor.id;
f.project.layer_mut(anchored).unwrap().content_effects.push(anchor);
let hiding = put(&mut f, 0, Some(group), fill(&[(Channel::BaseColor, Source::Uniform([0.1; 3]))]), None);
only(&mut f, hiding, Channel::BaseColor);
// Above the folder, roughness reads the base color held by A.
let reader = add(&mut f, 0, fill(&[(Channel::Roughness, Source::Anchor { anchor: anchor_id, channel: Channel::BaseColor })]), None);
only(&mut f, reader, Channel::Roughness);
let out = reference(&f, 0);
let rough = out.value(Channel::Roughness, 128, 128)[0];
// A = 0.5 at half opacity over the low layer's 0.9.
assert!((rough - 0.7).abs() < 2e-3, "the anchor holds the layer under the folder: {rough}");
assert!((out.value(Channel::BaseColor, 128, 128)[0] - 0.1).abs() < 2e-3);
// The same stack with an (unread) anchor on the low layer is never culled: identical.
let keep = effect(&mut f, EffectKind::Anchor);
f.project.layer_mut(low).unwrap().content_effects.push(keep);
assert!(reference(&f, 0) == out, "culling changed the composite");
}
-5
View File
@@ -350,11 +350,6 @@ pub fn blend3(mode: BlendMode, a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
/// Mix `blended` over `a` by weight `w` (coverage × opacity × mask).
pub fn mix3(a: [f32; 3], blended: [f32; 3], w: f32) -> [f32; 3] {
// A full-weight blend is exactly the blended value (`a + (b - a)` can be an ulp off it): what
// lies under it does not leak in, so skipping the layers it hides changes nothing at all.
if w >= 1.0 {
return blended;
}
[a[0] + (blended[0] - a[0]) * w, a[1] + (blended[1] - a[1]) * w, a[2] + (blended[2] - a[2]) * w]
}
-5
View File
@@ -193,10 +193,5 @@ pub fn session(s: &Session) -> Value {
"history": { "undo": s.undo_label(), "redo": s.redo_label(), "depth": s.history_labels().len() },
"memoryBytes": s.memory().total(),
"pendingTiles": s.pending_tiles(),
// Tiles with no look of the current composite yet, tiles shown from a coarse pass only
// (their exact composite pending), and the coarsest stride shown (0: none).
"dirtyTiles": s.caches.iter().map(|c| c.dirty.len()).sum::<usize>(),
"coarseTiles": s.caches.iter().map(|c| c.refine.len()).sum::<usize>(),
"coarsestStride": s.caches.iter().flat_map(|c| c.refine.values().copied()).max().unwrap_or(0),
})
}
+15 -77
View File
@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
use serde::{Deserialize, Serialize};
use texturecraft_compose::{BakedMaps, BelowCache, COARSE_STRIDES, Composite, PaintTarget, PixelStore, StackKey, StrokePreview, covered_tiles, pad_tiles};
use texturecraft_compose::{BakedMaps, BelowCache, Composite, PaintTarget, PixelStore, StackKey, StrokePreview, covered_tiles, pad_tiles};
use texturecraft_core::{Channel, Layer, LayerId, LayerKind, Project, TextureSet};
use texturecraft_geom::glam::Vec2;
use texturecraft_geom::{Bvh, Mesh, OrbitCamera, UvGBuffer};
@@ -43,24 +43,14 @@ pub struct SetCache {
/// Tiles to recomposite at low priority: what they show is already right (a committed
/// stroke's live preview), but it was composited from the stroke, not the layer pixels.
pub settle: BTreeSet<(u32, u32)>,
/// Tiles shown from a coarse pass ([`texturecraft_compose::composite_tiles_coarse`]) with
/// the stride they were composited at; they still need the finer ones and the exact one. A
/// big recomposite (a material applied) first looks right everywhere at a small part of the
/// cost, then sharpens level by level ([`texturecraft_compose::COARSE_STRIDES`]), each level
/// over every tile before the next, so the surface is always at one consistent level.
pub refine: BTreeMap<(u32, u32), u32>,
/// The dirty tiles go through a coarse pass: decided when a big recomposite starts and
/// kept until `dirty` drains, so its last few tiles do not go exact at the full price.
pub coarse_pass: bool,
/// Tiles whose display textures must be re-uploaded.
pub upload: BTreeSet<(u32, u32)>,
/// Bumps on every composite change (thumbnails, exports, caches).
pub revision: u64,
/// Everything but the layer being edited, per tile (repaints evaluate only that layer).
pub below: BelowCache,
/// Wall-clock milliseconds per tile of the last exact composite chunk (0: not measured
/// yet): the first chunk of a budgeted update is sized from it and that update's budget.
pub tile_ms: f64,
/// Tiles per composite chunk that fit the last frame's budget (0: not measured yet).
pub chunk: usize,
}
impl SetCache {
@@ -79,12 +69,10 @@ impl SetCache {
composite: Composite { block_scales: ts.block_scales(), ..Composite::with_size(&ts.channel_list(), w, h) },
dirty: all.clone(),
settle: BTreeSet::new(),
refine: BTreeMap::new(),
coarse_pass: false,
upload: all,
revision: 0,
below: BelowCache::default(),
tile_ms: 0.0,
chunk: 0,
}
}
@@ -727,60 +715,23 @@ impl Session {
carried: s.canvas.pickup.as_ref().map(|p| p.values.clone()).unwrap_or_default(),
})
});
// A coarse look first only when there is a frame budget to spread a big change over, and
// never under a live stroke (it keeps the exact, cached repaint of the hot layer).
let coarse_allowed = budget_ms.is_finite() && self.stroke.is_none();
let active = self.ts();
let order = std::iter::once(active).chain((0..self.caches.len()).filter(|ts| *ts != active));
let mut changed = false;
for ts in order {
let Some(cache) = self.caches.get_mut(ts) else { continue };
cache.below.set_hot(hot);
cache.below.pass = cache.dirty.len() + cache.settle.len() + cache.refine.len();
cache.below.pass = cache.dirty.len() + cache.settle.len();
// Instances in sets of the stroke's size show the live stroke too.
let preview = preview.as_ref().filter(|_| Some(cache.size) == stroke_size);
// Start at the size this budget fits at the last measured pace: with a heavy stack
// (smart materials at 8K) one tile per thread alone would take several frames'
// budget. Never above one tile per thread: work can turn heavy from one frame to the
// next.
let exact_chunk =
|cache: &SetCache| if budget_ms.is_finite() && cache.tile_ms > 0.0 { ((budget_ms / cache.tile_ms) as usize).clamp(1, first) } else { first };
let mut chunk = exact_chunk(cache);
// A stack with neighbourhood filters computes them at full resolution even for a
// coarse composite, so it gains little from one: straight to the exact composite.
let may_coarse = coarse_allowed && !cache.dirty.is_empty() && !texturecraft_compose::has_neighbourhood_filters(&self.doc.project, ts);
// The stride of the previous chunk (1: exact), to restart the chunk size on a change.
let mut last_stride = 1;
// Start at the size that fit the budget last time: with a heavy stack (smart
// materials at 8K) one tile per thread alone would take several frames' budget.
let mut chunk = if budget_ms.is_finite() && cache.chunk > 0 { cache.chunk } else { first };
loop {
if cache.dirty.is_empty() {
cache.coarse_pass = false;
}
// The work of this chunk: fresh dirty tiles (coarsest look or exact), the next
// level of the coarsest refining tiles, or settling tiles.
let (stride, refining, settling): (u32, Option<u32>, bool) = if !cache.dirty.is_empty() {
// A big change gets a coarse look first, for the whole of it.
if may_coarse && cache.dirty.len() > COARSE_MIN_TILES {
cache.coarse_pass = true;
if cache.settle.is_empty() || clock() - start >= budget_ms.min(SETTLE_BUDGET_MS) {
break;
}
let coarse = may_coarse && cache.coarse_pass;
(if coarse { COARSE_STRIDES[0] } else { 1 }, None, false)
} else if let Some(at) = cache.refine.values().copied().max() {
(finer_stride(at), Some(at), false)
} else if !cache.settle.is_empty() && clock() - start < budget_ms.min(SETTLE_BUDGET_MS) {
(1, None, true)
} else {
break;
};
// A level costs about its stride² less per texel than the exact composite: a
// new level starts at the exact pace, and the chunks grow from what it measures.
if stride != last_stride {
chunk = exact_chunk(cache);
last_stride = stride;
}
if let Some(at) = refining {
let mut level: BTreeSet<(u32, u32)> = cache.refine.iter().filter(|(_, s)| **s == at).map(|(t, _)| *t).collect();
cache.dirty.extend(next_chunk(&mut level, chunk));
} else if settling {
// Small chunks: the settle slice of the budget is short.
cache.dirty.extend(next_chunk(&mut cache.settle, chunk.min(first)));
}
@@ -788,7 +739,6 @@ impl Session {
let tiles = next_chunk(&mut cache.dirty, chunk);
for t in &tiles {
cache.settle.remove(t);
cache.refine.remove(t);
}
let empty = BakedMaps::default();
let inputs = texturecraft_compose::Inputs {
@@ -803,12 +753,7 @@ impl Session {
images: &self.images,
bounds: self.mesh.bounds(),
};
if stride > 1 {
texturecraft_compose::composite_tiles_coarse(&inputs, &mut cache.composite, &tiles, stride);
cache.refine.extend(tiles.iter().map(|t| (*t, stride)));
} else {
texturecraft_compose::composite_tiles_cached(&inputs, &mut cache.composite, &tiles, Some(&mut cache.below));
}
texturecraft_compose::composite_tiles_cached(&inputs, &mut cache.composite, &tiles, Some(&mut cache.below));
// The composited tiles and the neighbours their padding reached change.
let padded = pad_tiles(&mut cache.composite, &cache.dilation, &tiles);
cache.upload.extend(tiles.iter().copied().chain(padded));
@@ -818,8 +763,9 @@ impl Session {
let left = budget_ms - (now - start);
// As many tiles as fit in what is left, at the pace of this chunk.
let per_tile = (now - t0) / tiles.len().max(1) as f64;
if budget_ms.is_finite() && per_tile > 0.0 && stride == 1 {
cache.tile_ms = per_tile;
if budget_ms.is_finite() && per_tile > 0.0 {
// Never above one tile per thread: work can turn heavy from one frame to the next.
cache.chunk = ((budget_ms / per_tile) as usize).clamp(1, first);
}
if left <= 0.0 {
return changed;
@@ -836,7 +782,7 @@ impl Session {
/// Tiles still waiting to be composited, over every texture set (settling ones included).
pub fn pending_tiles(&self) -> usize {
self.caches.iter().map(|c| c.dirty.len() + c.settle.len() + c.refine.len()).sum()
self.caches.iter().map(|c| c.dirty.len() + c.settle.len()).sum()
}
/// The layer a stroke target belongs to (an effect's owner).
@@ -948,9 +894,6 @@ impl Memory {
/// Most tiles per composite chunk (a 1024² region).
const CHUNK: usize = 256;
/// A recomposite of more tiles than this (a material applied, not a brush stroke) is shown from
/// a coarse pass first when it is spread over frames.
const COARSE_MIN_TILES: usize = 64;
/// The most a budgeted update spends on settling tiles (what they show is already right).
pub const SETTLE_BUDGET_MS: f64 = 6.0;
@@ -969,11 +912,6 @@ fn next_chunk(dirty: &mut BTreeSet<(u32, u32)>, n: usize) -> Vec<(u32, u32)> {
tiles
}
/// The stride of the level after `stride` in [`COARSE_STRIDES`] (1: the exact composite).
fn finer_stride(stride: u32) -> u32 {
COARSE_STRIDES.iter().copied().find(|s| *s < stride).unwrap_or(1)
}
/// Valid texture set resolutions: powers of two from 128 to 8192.
pub fn check_resolution(r: u32) -> Result<u32> {
if (128..=8192).contains(&r) && r.is_power_of_two() {
+2 -4
View File
@@ -220,12 +220,10 @@ fn budgeted_updates_spread_work_and_end_identical() {
s.caches[0].invalidate_all();
// A clock that is always over budget: one chunk per call.
let mut calls = 0;
// Progress: a tile is two steps from done while dirty (coarse look, then exact), one when refining.
let steps = |s: &texturecraft_engine::Session| 2 * s.caches[0].dirty.len() + s.caches[0].refine.len() + s.caches[0].settle.len();
while s.pending_tiles() > 0 {
let before = steps(&s);
let before = s.pending_tiles();
s.update_for(0.0, || 1.0);
assert!(steps(&s) < before);
assert!(s.pending_tiles() < before);
calls += 1;
}
assert!(calls > 1, "the work was spread over calls");
-163
View File
@@ -446,166 +446,3 @@ fn curvature_generators_take_a_mode_and_detail_sizes() {
assert!(dirt.is_err(), "only curvature generators have a mode");
assert_eq!(execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string(), inspect, "failed commands leave the project unchanged");
}
/// A material applied over frames first looks right everywhere from a coarse pass (the sampled
/// texels are exact, the rest repeat them), then the tiles fill in to the exact composite.
#[test]
fn a_big_recomposite_shows_a_coarse_look_first_then_the_exact_one() {
let make = || {
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 2048).unwrap();
s.viewport = texturecraft_engine::geom::glam::Vec2::new(400.0, 400.0);
s.update();
execute(&mut s, "material.apply", &json!({"material": "steel_painted_worn"})).unwrap();
s
};
let mut exact = make();
exact.update();
assert_eq!(exact.pending_tiles(), 0, "an unbudgeted update goes straight to the exact composite");
let exact = exact.caches[0].composite.clone();
let mut s = make();
let t = std::cell::Cell::new(0.0);
let clock = || {
t.set(t.get() + 2.0);
t.get()
};
let covered = s.caches[0].covered_tiles.len();
assert!(covered > 100, "a big change: {covered} tiles");
while !s.caches[0].dirty.is_empty() {
s.update_for(30.0, clock);
}
assert!(s.caches[0].refine.len() > 100 && s.pending_tiles() > 0, "everything has a coarse look, the exact one is pending");
let coarse = s.caches[0].composite.clone();
assert_ne!(coarse, exact, "the coarse look is not the exact one");
// Where the coarse pass sampled (a block's first covered texel, its corner where covered), it
// is exact; the others repeat the sample of their block.
let c = Channel::BaseColor;
let stride = texturecraft_engine::compose::COARSE_STRIDES[0];
let (mut sampled, mut repeated, mut checked) = (0, 0, 0);
for y in (0..2048).step_by(7) {
for x in (0..2048).step_by(5) {
let (ax, ay) = (x - x % stride, y - y % stride);
if x == ax && y == ay {
if coarse.value(c, x, y) == exact.value(c, x, y) {
sampled += 1;
}
checked += 1;
} else if coarse.value(c, x, y) == coarse.value(c, ax, ay) {
repeated += 1;
}
}
}
assert!(checked > 100 && sampled * 10 >= checked * 9, "sampled texels are exact: {sampled} of {checked}");
assert!(repeated > 1000, "the others repeat their sample: {repeated}");
while s.pending_tiles() > 0 {
s.update_for(30.0, clock);
}
assert_eq!(s.caches[0].composite, exact, "the refined composite is the exact one");
}
/// Layers an opaque layer above hides are not evaluated: a material applied over others
/// composites exactly like the same material applied alone, in the channels it sets.
#[test]
fn layers_hidden_by_an_opaque_material_are_left_out_without_changing_the_result() {
let make = |materials: &[&str]| {
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 512).unwrap();
s.viewport = texturecraft_engine::geom::glam::Vec2::new(400.0, 400.0);
for m in materials {
execute(&mut s, "material.apply", &json!({"material": m})).unwrap();
}
s.update();
s.caches[0].composite.clone()
};
let alone = make(&["gold_polished"]);
let stacked = make(&["steel_painted_worn", "copper", "gold_polished"]);
let underneath = make(&["steel_painted_worn", "copper"]);
assert_ne!(alone, underneath, "the materials differ");
for c in [Channel::BaseColor, Channel::Roughness, Channel::Metallic] {
let (mut compared, mut differing) = (0, 0);
for y in (0..512).step_by(3) {
for x in (0..512).step_by(3) {
compared += 1;
if alone.value(c, x, y) != stacked.value(c, x, y) {
differing += 1;
}
}
}
assert!(compared > 1000 && differing == 0, "{c:?}: {differing} of {compared} texels differ");
}
}
/// A clock that advances 2 ms per reading, for budgeted updates.
fn ticking() -> impl Fn() -> f64 {
let t = std::cell::Cell::new(0.0);
move || {
t.set(t.get() + 2.0);
t.get()
}
}
/// A big change goes through the coarse pass to its last tile (the decision is kept for the
/// whole pass): its tail does not go exact at the full price while the rest waits for detail.
#[test]
fn the_coarse_pass_covers_every_tile_of_a_big_change() {
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 1024).unwrap();
s.update();
execute(&mut s, "material.apply", &json!({"material": "steel_painted_worn"})).unwrap();
let dirty = s.caches[0].dirty.len();
assert!(dirty > 100, "a big change: {dirty} tiles");
// A clock always over budget: one chunk per call.
let mut calls = 0;
while !s.caches[0].dirty.is_empty() {
s.update_for(0.0, || 1.0);
let c = &s.caches[0];
assert_eq!(c.refine.len() + c.dirty.len(), dirty, "no tile went exact during the coarse pass");
calls += 1;
}
assert!(calls > 1, "the pass was spread over calls");
s.update_for(0.0, || 1.0);
assert!(!s.caches[0].coarse_pass, "the pass ended with its tiles");
let clock = ticking();
// A small change after it goes straight to the exact composite.
let some: Vec<(u32, u32)> = s.caches[0].covered_tiles.iter().copied().take(10).collect();
s.update();
s.caches[0].dirty.extend(some);
s.update_for(30.0, &clock);
assert!(s.caches[0].refine.is_empty() && s.caches[0].dirty.is_empty(), "a few tiles are composited exactly");
}
/// Under a live stroke the compositor keeps the exact (cached) repaint: no coarse pass.
#[test]
fn no_coarse_pass_while_a_stroke_is_live() {
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 1024).unwrap();
s.update();
s.begin_stroke_uv(texturecraft_engine::geom::glam::Vec2::new(0.5, 0.5), 1.0).unwrap();
s.caches[0].invalidate_all();
assert!(s.caches[0].dirty.len() > 100);
let clock = ticking();
while !s.caches[0].dirty.is_empty() {
s.update_for(30.0, &clock);
assert!(s.caches[0].refine.is_empty(), "nothing went coarse under the stroke");
}
s.end_stroke().unwrap();
}
/// A stack with a neighbourhood filter (blur) computes it at full resolution even for a coarse
/// look, which then saves little: such a stack goes straight to the exact composite.
#[test]
fn stacks_with_neighbourhood_filters_skip_the_coarse_pass() {
use texturecraft_engine::core::{Effect, EffectKind, Filter};
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 1024).unwrap();
s.update();
execute(&mut s, "material.apply", &json!({"material": "copper"})).unwrap();
s.update();
assert!(!texturecraft_engine::compose::has_neighbourhood_filters(&s.doc.project, 0));
let top = *s.doc.project.texture_sets[0].stack.last().unwrap();
let id = s.doc.project.alloc_id();
s.doc.project.layer_mut(top).unwrap().content_effects.push(Effect::new(id, EffectKind::Filter(Filter::Blur { radius: 8.0 })));
assert!(texturecraft_engine::compose::has_neighbourhood_filters(&s.doc.project, 0));
s.caches[0].invalidate_all();
let clock = ticking();
while !s.caches[0].dirty.is_empty() {
s.update_for(30.0, &clock);
assert!(s.caches[0].refine.is_empty(), "nothing went coarse");
}
}
+4 -65
View File
@@ -93,29 +93,11 @@ pub struct GpuLink {
pub adapter: String,
/// Most tiles waiting to be composited since compositing last caught up (progress).
composite_total: usize,
/// Consecutive frames without user input (see [`frame_budgets`]).
idle_frames: u32,
bake_scene: BakeSceneLink,
}
/// The compositing and whole-frame budgets in milliseconds after `idle_frames` frames without
/// user input: the responsive pair while the user works, the longer pair once they have stopped.
fn frame_budgets(idle_frames: u32) -> (f64, f64) {
if idle_frames >= IDLE_FRAMES_BEFORE_BOOST { (IDLE_COMPOSITE_BUDGET_MS, IDLE_FRAME_BUDGET_MS) } else { (COMPOSITE_BUDGET_MS, FRAME_BUDGET_MS) }
}
/// Compositing time per frame while the user is working: a full recomposite of a large texture
/// set spreads over frames.
/// Compositing time per frame: a full recomposite of a large texture set spreads over frames.
const COMPOSITE_BUDGET_MS: f64 = 30.0;
/// Compositing time per frame once the user has stopped touching the app: the compositor scales
/// with the machine's cores, so a longer slice finishes sooner on a fast PC (a frame then takes
/// longer, but nothing is being dragged or painted that would feel it).
const IDLE_COMPOSITE_BUDGET_MS: f64 = 100.0;
/// [`FRAME_BUDGET_MS`] while idle: the idle compositing slice plus the usual rest of the frame.
const IDLE_FRAME_BUDGET_MS: f64 = IDLE_COMPOSITE_BUDGET_MS + (FRAME_BUDGET_MS - COMPOSITE_BUDGET_MS);
/// Frames without input (about 0.2 s at 60 fps) before the longer idle slices start, so a short
/// pause between strokes or drags keeps the responsive budget.
const IDLE_FRAMES_BEFORE_BOOST: u32 = 12;
/// The most a frame spends on the scene (with the work already done this frame, such as a
/// stroke's commit): compositing and display conversion leave the rest for the next frames, so
/// a large (8K) texture set never stalls one frame.
@@ -127,10 +109,6 @@ const UPLOAD_CHUNK: usize = 64;
/// Estimated GPU upload cost of one display tile (write_texture of one 64×64 tile of one
/// display kind, measured at ~5.5 µs on a desktop GPU), counted against the frame budget.
const UPLOAD_MS_PER_TILE: f64 = 0.006;
/// CPU cost of converting one display tile of one kind for upload ([`tile_bytes`], measured at
/// ~6 µs: 8192 in 50 ms on a 24-thread desktop): with [`UPLOAD_MS_PER_TILE`], what a tile still
/// waiting for upload will cost this frame.
const CONVERT_MS_PER_TILE: f64 = 0.006;
pub fn init(rs: &egui_wgpu::RenderState, ctx: &egui::Context) -> GpuLink {
let reset = Arc::new(AtomicBool::new(false));
@@ -162,7 +140,6 @@ pub fn init(rs: &egui_wgpu::RenderState, ctx: &egui::Context) -> GpuLink {
aux: BTreeMap::new(),
adapter: format!("{} ({:?})", info.name, info.backend),
composite_total: 0,
idle_frames: 0,
bake_scene: BakeSceneLink::default(),
}
}
@@ -185,28 +162,13 @@ impl GpuLink {
}
/// Collect everything the GPU needs this frame, running the compositor first: `bake` is what bake mode's 3D view draws besides the low poly, `spent_ms` the time this frame already took
pub fn sync(
&mut self,
session: &mut Session,
aux_map: Option<AuxView>,
bake: Option<BakeVisualization>,
shift: u32,
spent_ms: f64,
user_active: bool,
) -> SceneSync {
pub fn sync(&mut self, session: &mut Session, aux_map: Option<AuxView>, bake: Option<BakeVisualization>, shift: u32, spent_ms: f64) -> SceneSync {
let start_ms = crate::now_ms();
let mut queued = 0usize;
self.idle_frames = if user_active { 0 } else { self.idle_frames.saturating_add(1) };
let (composite_budget_ms, frame_budget_ms) = frame_budgets(self.idle_frames);
let time_left_ms = |queued: usize| frame_budget_ms - spent_ms - (crate::now_ms() - start_ms) - queued as f64 * UPLOAD_MS_PER_TILE;
let time_left_ms = |queued: usize| FRAME_BUDGET_MS - spent_ms - (crate::now_ms() - start_ms) - queued as f64 * UPLOAD_MS_PER_TILE;
let pending = session.pending_tiles();
self.composite_total = if pending == 0 { 0 } else { self.composite_total.max(pending) };
// Tiles composited earlier and still waiting to be uploaded go first: a big change's
// coarse look is composited in a frame or two, and showing it whole matters more than
// compositing on (otherwise it appears a chunk of tiles per frame).
let backlog = session.caches.iter().map(|c| c.upload.len()).sum::<usize>() * DisplayKind::ALL.len();
let backlog_ms = backlog as f64 * (UPLOAD_MS_PER_TILE + CONVERT_MS_PER_TILE);
session.update_for(composite_budget_ms.min(time_left_ms(0) - backlog_ms).max(MIN_SLICE_MS), crate::now_ms);
session.update_for(COMPOSITE_BUDGET_MS.min(time_left_ms(0)).max(MIN_SLICE_MS), crate::now_ms);
let mut out = SceneSync::default();
if self.lost.swap(false, Ordering::AcqRel) {
@@ -448,26 +410,3 @@ impl CallbackTrait for ViewCallback {
gpu.renderer.blit_prepared(pass, self.frame.view_id);
}
}
#[cfg(test)]
mod tests {
use super::*;
/// While the user is working (or just stopped) a frame keeps the responsive budgets.
#[test]
fn budgets_stay_short_while_the_user_is_active() {
assert_eq!(frame_budgets(0), (COMPOSITE_BUDGET_MS, FRAME_BUDGET_MS));
assert_eq!(frame_budgets(IDLE_FRAMES_BEFORE_BOOST - 1), (COMPOSITE_BUDGET_MS, FRAME_BUDGET_MS));
}
/// After a pause the compositor gets the longer slice, and the frame budget grows with it so the
/// display uploads keep their usual share.
#[test]
fn budgets_grow_once_the_user_is_idle() {
let (composite, frame) = frame_budgets(IDLE_FRAMES_BEFORE_BOOST);
assert_eq!(composite, IDLE_COMPOSITE_BUDGET_MS);
assert!(composite > COMPOSITE_BUDGET_MS);
assert_eq!(frame - composite, FRAME_BUDGET_MS - COMPOSITE_BUDGET_MS, "the non-compositing share of a frame is unchanged");
assert_eq!(frame_budgets(u32::MAX), (composite, frame), "stays boosted");
}
}
+1 -5
View File
@@ -317,11 +317,7 @@ fn add_callback(app: &mut TextureCraftApp, ui: &Ui, rect: Rect, mut frame: Frame
let scene = match (sync.0.take(), app.gpu.as_mut()) {
(Some(aux), Some(gpu_link)) => {
let sync_start_ms = crate::now_ms();
// Pointer, key and scroll input all count: the compositor then keeps frames short.
let user_active =
ui.ctx().input(|i| i.pointer.is_moving() || i.pointer.any_down() || !i.events.is_empty() || i.smooth_scroll_delta != egui::Vec2::ZERO);
let scene =
gpu_link.sync(&mut app.session, aux, bake, u32::from(app.ui.prefs.viewport_texture.min(2)), f64::from(app.profiler.logic_ms), user_active);
let scene = gpu_link.sync(&mut app.session, aux, bake, u32::from(app.ui.prefs.viewport_texture.min(2)), f64::from(app.profiler.logic_ms));
let reports = gpu_link.take_reports();
app.profiler.sync_ms += (crate::now_ms() - sync_start_ms) as f32;
gpu_report_toasts(app, reports);