diff --git a/bench/layer-atlas/check.sh b/bench/layer-atlas/check.sh
new file mode 100755
index 00000000..78fa4191
--- /dev/null
+++ b/bench/layer-atlas/check.sh
@@ -0,0 +1,43 @@
+#!/bin/bash
+# A page of many layers the size of the frame draws every one of them in every frame, and a page of more than Vello's
+# image atlas holds fails its render. A layer with a perspective transform (or a filter) is an image the size of its
+# box in that atlas, new in each frame; the atlas kept the last two frames' images, so with ten such layers or more
+# the frame's last ones found no room and were left out, with no error: fit.tsx's 18 drew 10 from its second frame
+# on. The atlas now lets go of what the frame doesn't use and packs the frame's images again before it leaves one
+# out, and a frame with an image left out fails the render naming it (over.tsx's 40 rendered, 12 of them missing).
+# Each layer holds one white 160x100 tile on black, so a frame's mean luma counts its tiles. Exits 1 on a failure.
+# bench/layer-atlas/check.sh (RAEA_BIN: the raea to run, default target/release/raea)
+cd "$(dirname "$0")/../.." || exit 2
+BIN=${RAEA_BIN:-$PWD/target/release/raea}
+export RAEA_SIGN=0 RAEA_MARK=0 RAEA_EXPORT_CACHE=0
+OUT=$(mktemp -d "${TMPDIR:-/tmp}/raea-layer-atlas.XXXXXX")
+trap 'rm -rf "$OUT"' EXIT
+status=0
+# a video's frames short of N tiles, from each frame's mean luma (limited range: black 16, white 235)
+short() { # MP4 N
+ ffmpeg -loglevel error -i "$1" -vf "signalstats,metadata=print:key=lavfi.signalstats.YAVG:file=-" -f null - |
+ awk -F= -v n="$2" '/YAVG/ { f++; if (($2 - 16) / 219 * 1920 * 1080 / 16000 < n - 0.5) bad++ } END { print bad + 0, f + 0 }'
+}
+
+"$BIN" render bench/layer-atlas/fit.tsx -o "$OUT/fit.mp4" > "$OUT/fit.log" 2>&1 || { echo "FAIL: the video of 18 layers failed"; tail -3 "$OUT/fit.log"; exit 1; }
+read -r bad frames < <(short "$OUT/fit.mp4" 18)
+if [ "$frames" = 48 ] && [ "$bad" = 0 ]; then echo "ok a video of 18 layers: 18 tiles in each of its 48 frames"
+else echo "FAIL a video of 18 layers: $bad of $frames frames are short of 18 tiles"; status=1; fi
+
+mkdir -p "$OUT/stills"
+"$BIN" render bench/layer-atlas/fit.tsx --at 0,1,2,3,4,5 -o "$OUT/stills" > "$OUT/stills.log" 2>&1 || { echo "FAIL: the stills of 18 layers failed"; tail -3 "$OUT/stills.log"; exit 1; }
+bad=0
+for f in "$OUT"/stills/frame-*.png; do
+ tiles=$(magick "$f" -alpha off -colorspace gray -format "%[fx:int(mean*1920*1080/16000+0.5)]" info:)
+ [ "$tiles" = 18 ] || { echo "FAIL $(basename "$f"): $tiles tiles of 18"; bad=1; status=1; }
+done
+[ $bad = 0 ] && echo "ok six stills of 18 layers in one call: 18 tiles in each"
+
+if "$BIN" render bench/layer-atlas/over.tsx -o "$OUT/over.mp4" > "$OUT/over.log" 2>&1; then
+ read -r bad frames < <(short "$OUT/over.mp4" 40)
+ echo "FAIL a video of 40 layers rendered, $bad of its $frames frames short of 40 tiles"; status=1
+elif grep -q "frame 0: .*image atlas" "$OUT/over.log"; then echo "ok a video of 40 layers fails, naming the frame and the atlas"
+else echo "FAIL a video of 40 layers failed without naming the frame and the atlas:"; tail -3 "$OUT/over.log"; status=1; fi
+
+[ $status = 0 ] && echo "PASS a page's layers are all drawn, or its render fails"
+exit $status
diff --git a/bench/layer-atlas/fit.tsx b/bench/layer-atlas/fit.tsx
new file mode 100644
index 00000000..688a4b7f
--- /dev/null
+++ b/bench/layer-atlas/fit.tsx
@@ -0,0 +1,5 @@
+// 18 layers the size of the frame: Vello's image atlas has room for 28 (bench/layer-atlas/check.sh)
+import { registerRoot } from "raea";
+import { planes } from "./planes";
+
+registerRoot(planes(18));
diff --git a/bench/layer-atlas/over.tsx b/bench/layer-atlas/over.tsx
new file mode 100644
index 00000000..3e03450d
--- /dev/null
+++ b/bench/layer-atlas/over.tsx
@@ -0,0 +1,5 @@
+// 40 layers the size of the frame: more than Vello's image atlas holds at once (bench/layer-atlas/check.sh)
+import { registerRoot } from "raea";
+import { planes } from "./planes";
+
+registerRoot(planes(40));
diff --git a/bench/layer-atlas/planes.tsx b/bench/layer-atlas/planes.tsx
new file mode 100644
index 00000000..873665a9
--- /dev/null
+++ b/bench/layer-atlas/planes.tsx
@@ -0,0 +1,27 @@
+// N layers the size of the frame, each holding one white tile in a cell of its own, on black: a frame's mean luma
+// counts the tiles drawn. An element with a perspective transform is drawn apart and placed as an image the size of
+// its box, new in every frame, in Vello's image atlas. The perspective here is slight (the far corner moves under
+// 3 px) and changes with the frame, so each frame is painted anew, the layers land a pixel or two apart in size, and
+// no tile leaves its cell. bench/layer-atlas/check.sh
+import { AbsoluteFill, Composition, useCurrentFrame } from "raea";
+
+const W = 1920, H = 1080, COLS = 8;
+
+function Planes({ n }: { n: number }) {
+ const f = useCurrentFrame();
+ return (
+
+ {Array.from({ length: n }, (_, i) => {
+ // matrix3d's m14 and m24: w = 1 + a x + b y
+ const a = (1e-7 * (1 + ((i + f) % 5))).toFixed(9), b = (1e-7 * (1 + ((2 * i + f) % 3))).toFixed(9);
+ return (
+
+ );
+ })}
+
+ );
+}
+
+export const planes = (n: number) => () => } width={W} height={H} fps={24} durationInFrames={48} />;
diff --git a/gpu/device/src/check.rs b/gpu/device/src/check.rs
index 07185d9f..69cc0b52 100644
--- a/gpu/device/src/check.rs
+++ b/gpu/device/src/check.rs
@@ -162,6 +162,10 @@ pub fn on_settle(settle: fn()) {
/// skipped too (#23).
pub fn fed_checked(f: i64, first: T, wait: fn(), redraw_full: fn(bool), paint: impl FnOnce() -> Result) -> Result {
wait();
+ // a frame raea-page refused (`refuse`) fails the render naming it, as a still's does (`black_checked`): the fed
+ // render had no one to read the refusal, encoded the frame as it came and went on
+ let unrefused = || refused().map_or(Ok(()), |why| Err(format!("frame {f}: {why}")));
+ unrefused()?;
if take_skipped().is_none() {
return Ok(first);
}
@@ -170,6 +174,7 @@ pub fn fed_checked(f: i64, first: T, wait: fn(), redraw_full: fn(bool), paint
redraw_full(false);
let again = again?;
wait();
+ unrefused()?;
match take_skipped() {
Some(why) => Err(format!("frame {f}: {why}")),
None => Ok(again),
@@ -293,6 +298,14 @@ mod tests {
})
.unwrap_err();
assert_eq!(e, "frame 7: a page (1920x1080) wasn't drawn");
+ // the fed render's frame, which no read back checks: a refused one fails the render by its number too, and
+ // the frame after it isn't refused with it
+ fn drawn() {}
+ assert_eq!(fed_checked(8, 1, drawn, full, || panic!("no draw skipped")).unwrap(), 1);
+ refuse("a page (1920x1080) was drawn without 2 of its images".into());
+ let e = fed_checked(9, 1, drawn, full, || panic!("no draw skipped")).unwrap_err();
+ assert_eq!(e, "frame 9: a page (1920x1080) was drawn without 2 of its images");
+ assert_eq!(fed_checked(10, 1, drawn, full, || panic!("no draw skipped")).unwrap(), 1);
}
#[test]
diff --git a/systems/page/src/skipped.rs b/systems/page/src/skipped.rs
index 561f5d28..d346c780 100644
--- a/systems/page/src/skipped.rs
+++ b/systems/page/src/skipped.rs
@@ -8,6 +8,10 @@
//! counted (raea_gpu_device::check::skipped_draw), and the frame's check (`skip_checked`) draws the frames since again
//! at those sizes, or refuses one skipped at them too, so the render fails naming it.
//! RAEA_PAGE_DRAWN_CHECK=0 draws without the check (for measuring what it costs; a skipped draw goes unseen again).
+//! And whether it drew every image: one that finds no room in Vello's image atlas is drawn at no size, again with no
+//! error. A layer with a filter or a perspective transform is such an image, the size of its box, so a page of many
+//! lost its nearest ones. The resolve counts them (vendor/vello_encoding `take_images_left_out`) and the frame is
+//! refused (raea_gpu_device::check::refuse), so the render fails naming it.
use std::sync::atomic::{AtomicBool, Ordering};
@@ -52,7 +56,15 @@ pub fn render(renderer: &mut vello::Renderer, device: &wgpu::Device, queue: &wgp
if check {
queue.write_texture(texel, &SENTINEL, layout, one);
}
+ // (the count is this draw's: a resolve that only measures the scene, RAEA_VELLO_BUMP_USE's, counts its own before it)
+ vello::low_level::vello_encoding::take_images_left_out();
renderer.render_to_texture(device, queue, scene, &target.create_view(&Default::default()), params).map_err(|e| format!("vello, {what}: {e}"))?;
+ let left_out = vello::low_level::vello_encoding::take_images_left_out();
+ if left_out > 0 {
+ let why = format!("{what} ({}x{}) was drawn without {left_out} of its images: Vello's image atlas (8192 px a side) has no room for them. Each element with a filter or a perspective transform is an image the size of its box, so fewer of them, or smaller boxes, draw it", params.width, params.height);
+ bevy::log::error!("raea-page: {why}");
+ raea_gpu_device::check::refuse(why);
+ }
if !check {
return Ok(());
}
diff --git a/vendor/vello_encoding/src/image_cache.rs b/vendor/vello_encoding/src/image_cache.rs
index e5431031..a9f6591d 100644
--- a/vendor/vello_encoding/src/image_cache.rs
+++ b/vendor/vello_encoding/src/image_cache.rs
@@ -49,6 +49,8 @@ pub(crate) struct ImageCache {
map: HashMap,
/// Images that must be uploaded in the current resolve pass, with atlas locations.
images: Vec<(ImageData, u32, u32)>,
+ /// raea: whether the current resolve has packed the atlas again (`repack_with`: once a resolve)
+ repacked_in_resolve: bool,
}
impl Default for ImageCache {
@@ -70,6 +72,7 @@ impl ImageCache {
evicted_in_resolve: 0,
map: HashMap::default(),
images: Vec::default(),
+ repacked_in_resolve: false,
}
}
@@ -77,6 +80,7 @@ impl ImageCache {
self.generation = self.generation.wrapping_add(1);
self.evicted_in_resolve = 0;
self.images.clear();
+ self.repacked_in_resolve = false;
}
pub(crate) fn restart_resolve_pass(&mut self) {
@@ -187,6 +191,54 @@ impl ImageCache {
self.evicted_in_resolve != 0
}
+ /// raea: with the atlas at its largest and no room for an image, the resident images the current resolve hasn't
+ /// used are let go, the ones unused longest first (one generation a call; false when none is left). Upstream stops
+ /// at `evict_stale_entries`, which keeps what the last two resolves used: an embedder whose images are new in
+ /// every frame (raea-page's layers, each a placeholder the size of its box) fills the atlas with the last two
+ /// frames' and draws the frame without its last images.
+ pub(crate) fn evict_unused(&mut self) -> bool {
+ // once packed again (`repack_with`), what's resident is the resolve's own images, the ones its pass hasn't
+ // reached yet among them
+ if self.repacked_in_resolve {
+ return false;
+ }
+ let generation = self.generation;
+ let Some(oldest) = self.map.values().map(|resident| resident.last_used_generation).filter(|used| *used != generation).min() else {
+ return false;
+ };
+ for (_id, resident) in self.map.extract_if(|_, resident| resident.last_used_generation == oldest) {
+ self.atlas.deallocate(resident.alloc_id);
+ self.evicted_in_resolve += 1;
+ }
+ true
+ }
+
+ /// raea: the atlas emptied and packed with `wanted` alone (the current resolve's images), the tallest first, once
+ /// a resolve (false after that). What `evict_unused` leaves lies where the images it let go had put it, and
+ /// images met in paint order cut the room up: 18 images near a 1080p frame's size, a few px apart, didn't all
+ /// find a place in an atlas with the area for 28. Tallest first, a guillotine packs them in rows. The caller
+ /// starts its pass again, as after `bump_size`: every image is uploaded again.
+ pub(crate) fn repack_with<'a>(&mut self, wanted: impl Iterator- ) -> bool {
+ if std::mem::replace(&mut self.repacked_in_resolve, true) {
+ return false;
+ }
+ let mut wanted: Vec<&ImageData> = wanted.collect();
+ wanted.sort_by_key(|image| (std::cmp::Reverse(image.height), std::cmp::Reverse(image.width), image.data.id()));
+ wanted.dedup_by_key(|image| image.data.id());
+ self.evicted_in_resolve += self.map.keys().filter(|id| !wanted.iter().any(|image| image.data.id() == **id)).count();
+ self.atlas = AtlasAllocator::new(self.atlas.size());
+ self.map.clear();
+ // not yet used by this pass: `get_or_insert` uploads each as it meets it
+ let unused = self.generation.wrapping_sub(1);
+ for image in wanted {
+ let Some(alloc) = self.atlas.allocate(size2(image.width as _, image.height as _)) else { continue };
+ let (x, y) = (alloc.rectangle.min.x as u32, alloc.rectangle.min.y as u32);
+ self.map.insert(image.data.id(), ResidentImage { image: image.clone(), alloc_id: alloc.id, x, y, dirty: true, last_used_generation: unused });
+ }
+ self.images.clear();
+ true
+ }
+
fn repack_to_size(&mut self, size: i32) -> bool {
let mut atlas = AtlasAllocator::new(size2(size, size));
let mut entries: Vec<_> = self.map.iter().collect();
@@ -348,6 +400,50 @@ mod tests {
assert!(!cache.evict_stale_entries());
}
+ /// raea: at the atlas's largest size, what the resolve hasn't used goes the longest unused first, and what it has
+ /// used stays
+ #[test]
+ fn unused_entries_are_let_go_longest_unused_first() {
+ let mut cache = ImageCache::new_with_sizes(32, 32);
+ let (old, last, this) = (image(1, 8, 8), image(2, 8, 8), image(3, 8, 8));
+ for image in [&old, &last, &this] {
+ cache.begin_resolve();
+ assert!(cache.get_or_insert(image).is_some());
+ }
+ let resident = |cache: &ImageCache| [&old, &last, &this].map(|image| cache.map.contains_key(&image.data.id()));
+ assert!(cache.evict_unused());
+ assert_eq!(resident(&cache), [false, true, true]);
+ assert!(cache.evict_unused());
+ assert_eq!(resident(&cache), [false, false, true]);
+ assert!(!cache.evict_unused());
+ assert_eq!((resident(&cache), cache.evicted_in_resolve), ([false, false, true], 2));
+ }
+
+ /// raea: a crowded atlas packed again holds the wanted images alone, each to be uploaded as the pass meets it, and
+ /// is packed once a resolve
+ #[test]
+ fn a_crowded_atlas_is_packed_again_with_the_wanted_images() {
+ let mut cache = ImageCache::new_with_sizes(16, 16);
+ let (before, a, b) = (image(1, 10, 10), image(2, 16, 6), image(3, 16, 10));
+ cache.begin_resolve();
+ assert!(cache.get_or_insert(&before).is_some());
+ cache.finish_resolve();
+ cache.begin_resolve();
+ // twice wanted: one place
+ assert!(cache.repack_with([&a, &b, &a].into_iter()));
+ assert!(!cache.map.contains_key(&before.data.id()));
+ assert_eq!((cache.map.len(), cache.evicted_in_resolve, cache.images.len()), (2, 1, 0));
+ // what it packed is the resolve's own, though the pass hasn't met it yet: none of it is let go
+ assert!(!cache.evict_unused());
+ assert_eq!(cache.map.len(), 2);
+ // the taller first, at the top
+ assert_eq!((cache.get_or_insert(&b), cache.get_or_insert(&a)), (Some((0, 0)), Some((0, 10))));
+ assert_eq!(cache.images.len(), 2);
+ assert!(!cache.repack_with([&a, &b].into_iter()));
+ cache.begin_resolve();
+ assert!(cache.repack_with([&a].into_iter()));
+ }
+
#[test]
fn failed_repack_leaves_existing_residency_unchanged() {
let mut cache = ImageCache::new_with_sizes(16, 16);
diff --git a/vendor/vello_encoding/src/lib.rs b/vendor/vello_encoding/src/lib.rs
index ab18a556..0d43f4c6 100644
--- a/vendor/vello_encoding/src/lib.rs
+++ b/vendor/vello_encoding/src/lib.rs
@@ -68,7 +68,7 @@ pub use path::{
PathTag, SegmentCount, Style, Tile,
};
pub use ramp_cache::Ramps;
-pub use resolve::{Layout, Patch, Resolver, resolve_solid_paths_only};
+pub use resolve::{Layout, Patch, Resolver, resolve_solid_paths_only, take_images_left_out};
#[cfg(feature = "bump_estimate")]
pub use estimate::BumpEstimator;
diff --git a/vendor/vello_encoding/src/resolve.rs b/vendor/vello_encoding/src/resolve.rs
index a3a398ae..249a232f 100644
--- a/vendor/vello_encoding/src/resolve.rs
+++ b/vendor/vello_encoding/src/resolve.rs
@@ -512,8 +512,15 @@ impl Resolver {
fn resolve_pending_images(&mut self) {
'outer: loop {
self.image_cache.restart_resolve_pass();
+ // raea: an image the atlas could hold found no room in it at its largest
+ let mut crowded = false;
// Loop over the images, attempting to allocate them all into the atlas.
for pending_image in &mut self.pending_images {
+ // raea: an empty image has no place to find (the allocator gives none, and the atlas grew to its
+ // largest looking): it's drawn at no size as it is, and isn't one left out
+ if pending_image.image.width == 0 || pending_image.image.height == 0 {
+ continue;
+ }
pending_image.xy = loop {
if let Some(xy) = self.image_cache.get_or_insert(&pending_image.image) {
break Some(xy);
@@ -527,7 +534,12 @@ impl Resolver {
if self.image_cache.bump_size() {
// We were able to increase the atlas size. Restart the outer loop.
continue 'outer;
+ } else if self.image_cache.can_fit_image(&pending_image.image) && self.image_cache.evict_unused() {
+ // raea: the atlas is at its largest: what this resolve hasn't used goes before an image
+ // is left out, the longest unused first
+ continue;
} else {
+ crowded |= self.image_cache.can_fit_image(&pending_image.image);
// If the atlas is already maximum size, there's nothing we can do. Set
// the xy field to None so this image isn't rendered and then carry on--
// other images might still fit.
@@ -535,13 +547,30 @@ impl Resolver {
}
};
}
+ // raea: an image left out for want of room, with nothing unused left to let go: the atlas is packed again
+ // with this resolve's images alone, in an order that packs, and the pass run again (once)
+ if crowded && self.image_cache.repack_with(self.pending_images.iter().map(|pending| &pending.image)) {
+ continue;
+ }
// If we made it here, we've either successfully allocated all images or we reached
// the maximum atlas size.
break;
}
+ // raea: an image with no place is drawn at no size and nothing says so: counted, for the embedder to refuse
+ // the frame with (`take_images_left_out`)
+ let left_out = self.pending_images.iter().filter(|pending| pending.xy.is_none() && pending.image.width > 0 && pending.image.height > 0).count();
+ IMAGES_LEFT_OUT.fetch_add(left_out as u32, std::sync::atomic::Ordering::Relaxed);
}
}
+static IMAGES_LEFT_OUT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+
+/// raea: how many images the resolves since the last call left out, the atlas having no room for them at its largest
+/// size (or an image being larger than it): each is drawn at no size, and neither the resolve nor the render says so.
+pub fn take_images_left_out() -> u32 {
+ IMAGES_LEFT_OUT.swap(0, std::sync::atomic::Ordering::Relaxed)
+}
+
/// Patch for a late bound resource.
#[derive(Clone)]
pub enum Patch {
@@ -653,3 +682,53 @@ fn size_to_words(byte_size: usize) -> u32 {
fn align_up(len: usize, alignment: u32) -> usize {
len + (len.wrapping_neg() & (alignment as usize - 1))
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use peniko::{Blob, ImageAlphaType, ImageFormat};
+
+ /// raea: frame `f`'s `n` images, each new (a blob of its own) and near a 1080p frame's size, a few px apart and
+ /// differently in each frame: raea-page's layers under a moving camera, each a placeholder the size of its box
+ fn frame(n: u32, f: u32) -> Encoding {
+ let mut encoding = Encoding::new();
+ for i in 0..n {
+ encoding.encode_image(&image(1920 - (i * 37 + f * 11) % 23, 1080 - (i * 17 + f * 7) % 13), 1.0);
+ }
+ encoding
+ }
+
+ fn image(width: u32, height: u32) -> ImageData {
+ ImageData { data: Blob::new(Arc::new([0_u8; 0])), format: ImageFormat::Rgba8, alpha_type: ImageAlphaType::Alpha, width, height }
+ }
+
+ fn placed(resolver: &Resolver) -> usize {
+ resolver.pending_images.iter().filter(|pending| pending.xy.is_some()).count()
+ }
+
+ /// raea: every image of a frame gets a place while the frames before it held as many of their own. The atlas has
+ /// the area for 28 this size and kept the last two frames' (36 of them), so the second frame drew 10 of its 18;
+ /// with those let go but nothing packed again, 13 frames of 40 still drew 17.
+ #[test]
+ fn images_new_in_each_frame_all_get_a_place() {
+ let (mut resolver, mut packed) = (Resolver::new(), Vec::new());
+ for f in 0..40 {
+ resolver.resolve(&frame(18, f), &mut packed);
+ assert_eq!(placed(&resolver), 18, "frame {f}");
+ }
+ assert_eq!(take_images_left_out(), 0);
+ // more than the atlas holds at once: the ones left out are counted, once
+ resolver.resolve(&frame(40, 40), &mut packed);
+ let left_out = 40 - placed(&resolver);
+ assert!((12..40).contains(&left_out), "{left_out} of 40 left out");
+ assert_eq!(take_images_left_out() as usize, left_out);
+ assert_eq!(take_images_left_out(), 0);
+ // an empty image has no place and isn't one left out, and the atlas doesn't grow looking for one
+ let (mut resolver, mut empty) = (Resolver::new(), Encoding::new());
+ empty.encode_image(&image(0, 16), 1.0);
+ empty.encode_image(&image(16, 16), 1.0);
+ let (_, _, images) = resolver.resolve(&empty, &mut packed);
+ assert_eq!((images.width, images.images.len()), (1024, 1));
+ assert_eq!((placed(&resolver), take_images_left_out()), (1, 0));
+ }
+}
diff --git a/vendor/vendor.toml b/vendor/vendor.toml
index ac84fa75..5bb2fad9 100644
--- a/vendor/vendor.toml
+++ b/vendor/vendor.toml
@@ -112,7 +112,7 @@ exit = "anyrender_svg drawing these"
path = "vendor/vello_encoding"
upstream = "crates.io:0.11.0"
kind = "patch"
-reason = "bump buffer sizes set by the embedder (vello#1861's BumpAllocationSizes), not 165 MiB of defaults, grown with the target past 1080p (bump_sizes_for: ptcl holds every tile's initial allocation, which alone filled 99% of a fixed 2M at 4K), and back at the defaults while set_bump_full is on (a frame that came out all black drawn again); glyph tops for the CoreGraphics y-map (RAEA_PAGE_CG_YMAP); a resolve with no images keeps the image atlas (resolve.rs: a solid-only scene reported 0x0, the renderer swapped in a 1x1 atlas and every cached image then drew blank)"
+reason = "bump buffer sizes set by the embedder (vello#1861's BumpAllocationSizes), not 165 MiB of defaults, grown with the target past 1080p (bump_sizes_for: ptcl holds every tile's initial allocation, which alone filled 99% of a fixed 2M at 4K), and back at the defaults while set_bump_full is on (a frame that came out all black drawn again); glyph tops for the CoreGraphics y-map (RAEA_PAGE_CG_YMAP); a resolve with no images keeps the image atlas (resolve.rs: a solid-only scene reported 0x0, the renderer swapped in a 1x1 atlas and every cached image then drew blank); a full image atlas lets go of what the resolve hasn't used, the longest unused first, and is then packed again with the resolve's images alone, before an image is left out, and the images left out are counted (take_images_left_out: raea-page's layers are new images in every frame, the atlas kept the last two frames' and a page of ten frame-sized layers drew without its nearest)"
exit = "vello#1861 in a release; the y-map hook stays ours"
# checked 2026-10-26 for firewheel and its graph, macros and nodes: crates.io 0.14.0 (latest) and Firewheel main 34b35cad stop at glam-32 and bevy_reflect 0.19; bevy_seedling 0.8.0 and its main ab4a88b4 need firewheel 0.12 and Bevy 0.19