mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 05:50:43 +01:00
Revert "Show a whole material at once: coarse first look, then the exact result"
This commit is contained in:
1 parent
783cbdcb27
commit
d664dc239c
10 files changed
+31
-510
No files matched your search
+7
-152
@@ -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() {
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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]
|
||||
}
|
||||
|
||||
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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() {
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user