Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Viewport: keep the model scene in blocks and upload only what changed (#1147) (#1154)

bherbruck39bc87a8cc2d
diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs
index c561da6f4f..37e928cc9d 100644
--- a/crates/ui-egui/src/browser.rs
+++ b/crates/ui-egui/src/browser.rs
@@ -1374,9 +1374,15 @@ fn folder_rows_at(app: &mut SolveApp, ui: &mut egui::Ui, comp: u64, path: Option
let prefix = path.map(occurrence_key).unwrap_or_else(|| format!("c{comp}"));
if let Some(path) = path {
let Ok(placement) = app.session.occurrence_placement(path) else { return };
+ // Each row's placed body by its definition's name (a search per row was quadratic in a
+ // component's bodies, every frame).
+ let mut placed: std::collections::HashMap<&str, &_> = std::collections::HashMap::with_capacity(placement.bodies.len());
+ for b in &placement.bodies {
+ placed.entry(b.source.as_str()).or_insert(b);
+ }
for e in &mut all {
if folder == "bodies" {
- let Some(body) = placement.bodies.iter().find(|b| b.source == e.key) else { continue };
+ let Some(body) = placed.get(e.key.as_str()) else { continue };
e.sel = Some(Sel::Body { name: body.world.clone() });
e.target = Some(Target::Body { name: body.world.clone() });
e.bodies = vec![body.world.clone()];
diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rs
index eb8b5ec67d..85ed67366a 100644
--- a/crates/ui-egui/src/gpu.rs
+++ b/crates/ui-egui/src/gpu.rs
@@ -51,6 +51,49 @@ pub struct GpuScene {
pub under: Vec<u8>,
/// Opaque bodies drawn from their plans on the GPU, like `tris`.
pub planned: Vec<PlannedBody>,
+ /// The model's bodies, a few at a time, drawn before the loose geometry above (`tris`,
+ /// `trans`, `lines` and `hidden` of each block, in order, then the scene's own). A block
+ /// that comes back unchanged keeps its buffers: a design changing one body at a time (an
+ /// agent adding bodies over MCP) uploads only the blocks that changed, not the whole model.
+ pub blocks: Vec<SceneBlock>,
+}
+
+#[cfg(test)]
+impl GpuScene {
+ /// The blocks' geometry moved into the scene's own lists, in drawing order (for tests that
+ /// count what the scene holds).
+ pub fn merged(mut self) -> GpuScene {
+ let mut out = GpuScene { glass: std::mem::take(&mut self.glass), ..Default::default() };
+ for block in std::mem::take(&mut self.blocks) {
+ out.tris.extend_from_slice(&block.bytes.tris);
+ out.trans.extend_from_slice(&block.bytes.trans);
+ out.lines.extend_from_slice(&block.bytes.lines);
+ out.hidden.extend_from_slice(&block.bytes.hidden);
+ }
+ out.tris.append(&mut self.tris);
+ out.trans.append(&mut self.trans);
+ out.lines.append(&mut self.lines);
+ out.hidden.append(&mut self.hidden);
+ GpuScene { tris: out.tris, trans: out.trans, glass: out.glass, lines: out.lines, hidden: out.hidden, ..self }
+ }
+}
+
+/// A run of the model's bodies in the scene: their triangles and edges, and a key that names
+/// exactly this content (the viewport keeps the bytes while the key comes back).
+#[derive(Clone)]
+pub struct SceneBlock {
+ pub key: u64,
+ pub bytes: Arc<BlockBytes>,
+}
+
+/// A block's geometry, laid out as in [`GpuScene`].
+#[derive(Default)]
+pub struct BlockBytes {
+ pub tris: Vec<u8>,
+ pub trans: Vec<u8>,
+ pub glass: Vec<u8>,
+ pub lines: Vec<u8>,
+ pub hidden: Vec<u8>,
}
impl GpuScene {
@@ -194,8 +237,28 @@ struct PlannedDraw {
colors: wgpu::Buffer,
}
+/// A scene block on the GPU, with the bytes it was uploaded from.
+struct BlockGpu {
+ bytes: Arc<BlockBytes>,
+ tris: Option<Batch>,
+ trans: Option<Batch>,
+ lines: Option<Batch>,
+ hidden: Option<Batch>,
+}
+
+/// The blocks' buffers, then the scene's own, as one batch (the blocks' buffers are shared,
+/// not copied).
+fn joined<'a>(blocks: impl Iterator<Item = &'a Option<Batch>>, own: Option<Batch>) -> Option<Batch> {
+ let mut parts: Vec<(wgpu::Buffer, u32)> = blocks.flatten().flat_map(|b| b.parts.iter().cloned()).collect();
+ let chunk = own.as_ref().map(|b| b.chunk).unwrap_or(0);
+ parts.extend(own.into_iter().flat_map(|b| b.parts));
+ (!parts.is_empty()).then_some(Batch { parts, chunk })
+}
+
#[derive(Default)]
struct Batches {
+ /// The scene blocks on the GPU, by key.
+ blocks: std::collections::HashMap<u64, BlockGpu>,
key: Option<u64>,
tris: Option<Batch>,
trans: Option<Batch>,
@@ -227,13 +290,33 @@ impl Batches {
Some((tess, encoder)) => self.planned(device, tess, encoder, &sc.planned),
None => Vec::new(),
};
- self.tris = upload(device, "sc_tris", &sc.tris, TRI_SIZE);
- self.trans = upload(device, "sc_trans", &sc.trans, TRI_SIZE);
+ let mut kept = std::mem::take(&mut self.blocks);
+ let mut blocks: Vec<&BlockGpu> = Vec::with_capacity(sc.blocks.len());
+ for block in &sc.blocks {
+ let gpu = match kept.remove(&block.key).filter(|g| Arc::ptr_eq(&g.bytes, &block.bytes)) {
+ Some(g) => g,
+ None => BlockGpu {
+ bytes: block.bytes.clone(),
+ tris: upload(device, "sc_tris", &block.bytes.tris, TRI_SIZE),
+ trans: upload(device, "sc_trans", &block.bytes.trans, TRI_SIZE),
+ lines: upload(device, "sc_lines", &block.bytes.lines, LINE_SIZE),
+ hidden: upload(device, "sc_hidden", &block.bytes.hidden, LINE_SIZE),
+ },
+ };
+ self.blocks.insert(block.key, gpu);
+ }
+ for block in &sc.blocks {
+ if let Some(g) = self.blocks.get(&block.key) {
+ blocks.push(g);
+ }
+ }
+ self.tris = joined(blocks.iter().map(|b| &b.tris), upload(device, "sc_tris", &sc.tris, TRI_SIZE));
+ self.trans = joined(blocks.iter().map(|b| &b.trans), upload(device, "sc_trans", &sc.trans, TRI_SIZE));
self.glass = upload_with(device, "sc_glass", &sc.glass, TRI_SIZE, wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST);
self.glass_cpu = sc.glass;
self.glass_sorted_for = None;
- self.lines = upload(device, "sc_lines", &sc.lines, LINE_SIZE);
- self.hidden = upload(device, "sc_hidden", &sc.hidden, LINE_SIZE);
+ self.lines = joined(blocks.iter().map(|b| &b.lines), upload(device, "sc_lines", &sc.lines, LINE_SIZE));
+ self.hidden = joined(blocks.iter().map(|b| &b.hidden), upload(device, "sc_hidden", &sc.hidden, LINE_SIZE));
self.overlays = upload(device, "sc_overlay", &sc.overlay, LINE_SIZE);
self.ghost = upload(device, "sc_ghost", &sc.ghost, TRI_SIZE);
self.xray = upload(device, "sc_xray", &sc.xray, TRI_SIZE);
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index aa76c98e3c..88760e99fb 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -38,6 +38,10 @@ pub struct ViewportState {
/// Per-body boxes of one world state, held (not just its address, which a later state can
/// reuse once the old one is freed, so stale boxes would come back).
pick_bounds: std::sync::Mutex<Option<BodyBounds>>,
+ /// The model scene's blocks of bodies by key, from the last scene built.
+ pub(crate) blocks: std::sync::Mutex<std::collections::HashMap<u64, CachedBlock>>,
+ /// Each body mesh's box (the mesh held, so its address stays its own), from the last state.
+ mesh_bounds: std::sync::Mutex<std::collections::HashMap<usize, (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::geom::Aabb3)>>,
/// The last click in the view was the middle button's (for the middle double-click).
middle_clicked: bool,
/// The last pick (its key and hits): reused while nothing it depends on changed.
@@ -350,6 +354,110 @@ fn shown_mesh(
.unwrap_or_else(|| b.mesh())
}
+/// A model scene block kept by the viewport: its bytes and the meshes they were built from
+/// (held, so no other mesh can take their addresses while the block is kept).
+pub(crate) struct CachedBlock {
+ bytes: std::sync::Arc<crate::gpu::BlockBytes>,
+ meshes: Vec<std::sync::Arc<solidcraft_engine::geom::Mesh>>,
+}
+
+/// One body as the model scene draws it.
+struct BodyDraw {
+ mesh: std::sync::Arc<solidcraft_engine::geom::Mesh>,
+ col: [u8; 4],
+ faded: bool,
+ opacity: f64,
+ face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look>,
+ /// Its faces are drawn from its plan on the GPU (only its edges are built here).
+ on_gpu: bool,
+}
+
+impl BodyDraw {
+ /// Everything [`BodyDraw::build`] reads.
+ fn key(&self, shaded: bool, edges: bool, hidden_edges: bool, edge_col: [u8; 4], hidden_col: [u8; 4]) -> u64 {
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ (std::sync::Arc::as_ptr(&self.mesh) as usize).hash(&mut h);
+ (self.col, self.faded, self.opacity.to_bits(), self.on_gpu, shaded, edges, hidden_edges, edge_col, hidden_col).hash(&mut h);
+ let mut looks: Vec<_> = self.face_looks.iter().map(|(f, l)| (*f, l.color, l.opacity.to_bits())).collect();
+ looks.sort_unstable();
+ looks.hash(&mut h);
+ h.finish()
+ }
+
+ fn build(&self, sc: &mut crate::gpu::BlockBytes, shaded: bool, edges: bool, hidden_edges: bool, edge_col: [u8; 4], hidden_col: [u8; 4]) {
+ let m = &self.mesh;
+ let mut out = GpuScene::default();
+ for (ti, t) in m.triangles.iter().enumerate().filter(|_| shaded && !self.on_gpu) {
+ let (mut col, a) = match m.tri_face.get(ti).and_then(|f| self.face_looks.get(&(*f as usize))) {
+ Some(l) => {
+ let c = Color32::from_rgb(l.color[0], l.color[1], l.color[2]);
+ (if self.faded { c4(c.gamma_multiply(0.35)) } else { c4(c) }, l.opacity)
+ }
+ None => (self.col, self.opacity),
+ };
+ let glass = !self.faded && a < 0.999;
+ if glass {
+ col[3] = (a.clamp(0.05, 1.0) * 255.0).round() as u8;
+ }
+ for k in t {
+ let i = *k as usize;
+ if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
+ if self.faded {
+ out.trans_tri(p.to_f32(), n.to_f32(), col);
+ } else if glass {
+ out.glass_tri(p.to_f32(), n.to_f32(), col);
+ } else {
+ out.tri(p.to_f32(), n.to_f32(), col);
+ }
+ }
+ }
+ }
+ for (ei, e) in m.edges.iter().enumerate().filter(|_| edges) {
+ if !m.edge_pickable(ei) || (shaded && !m.shaded_edge_visible(ei)) {
+ continue;
+ }
+ for w in e.windows(2) {
+ out.line(w[0].to_f32(), w[1].to_f32(), edge_col, 1.3, false);
+ if hidden_edges {
+ out.hidden_line(w[0].to_f32(), w[1].to_f32(), hidden_col, 1.0);
+ }
+ }
+ }
+ sc.tris.extend_from_slice(&out.tris);
+ sc.trans.extend_from_slice(&out.trans);
+ sc.glass.extend_from_slice(&out.glass);
+ sc.lines.extend_from_slice(&out.lines);
+ sc.hidden.extend_from_slice(&out.hidden);
+ }
+}
+
+/// Add a block of bodies to the scene: the bytes built for the same bodies last time when
+/// there were any, else built now.
+fn push_block(
+ sc: &mut GpuScene,
+ kept: &mut std::collections::HashMap<u64, CachedBlock>,
+ made: &mut std::collections::HashMap<u64, CachedBlock>,
+ key: u64,
+ draws: Vec<BodyDraw>,
+ build: impl Fn(&BodyDraw, &mut crate::gpu::BlockBytes),
+) {
+ let same = |c: &CachedBlock| c.meshes.len() == draws.len() && c.meshes.iter().zip(&draws).all(|(m, d)| std::sync::Arc::ptr_eq(m, &d.mesh));
+ let block = match kept.remove(&key).or_else(|| made.remove(&key)).filter(same) {
+ Some(c) => c,
+ None => {
+ let mut bytes = crate::gpu::BlockBytes::default();
+ for d in &draws {
+ build(d, &mut bytes);
+ }
+ CachedBlock { bytes: std::sync::Arc::new(bytes), meshes: draws.iter().map(|d| d.mesh.clone()).collect() }
+ }
+ };
+ // See-through triangles are sorted with the rest of the glass, every view.
+ sc.glass.extend_from_slice(&block.bytes.glass);
+ sc.blocks.push(crate::gpu::SceneBlock { key, bytes: block.bytes.clone() });
+ made.insert(key, block);
+}
+
fn build_scene(app: &SolveApp) -> GpuScene {
let tk = Tokens::get();
let mut sc = GpuScene::default();
@@ -357,6 +465,20 @@ fn build_scene(app: &SolveApp) -> GpuScene {
// Bodies where their occurrences place them.
let st = s.world_state();
let active_bodies = s.active_occurrence_path.as_ref().and_then(|p| s.occurrence_bodies(p, true).ok());
+ let (shaded, edges) = match app.ui.visual_style {
+ 1 => (true, false),
+ 2 => (false, true),
+ _ => (true, true),
+ };
+ let edge_col = if shaded { c4(tk.body_edge) } else { c4(tk.text) };
+ // Shaded with hidden edges: edges behind the model show faintly.
+ let hidden_edges = app.ui.visual_style == 3;
+ let hidden_col = c4(tk.text.gamma_multiply(0.35));
+ // The blocks the last scene built, reused when their bodies come back as they were.
+ let mut kept = app.viewport.blocks.lock().map(|mut b| std::mem::take(&mut *b)).unwrap_or_default();
+ let mut made: std::collections::HashMap<u64, CachedBlock> = std::collections::HashMap::new();
+ let mut run: Vec<BodyDraw> = Vec::new();
+ let mut run_key = std::collections::hash_map::DefaultHasher::new();
for b in &st.bodies {
if !app.session.body_visible(&b.name) || app.preview.replaced.contains(&b.name) {
continue;
@@ -364,16 +486,6 @@ fn build_scene(app: &SolveApp) -> GpuScene {
let faded = body_faded(app, b, &active_bodies);
let base = body_color(&s.doc, b).unwrap_or(tk.body);
let col = if faded { c4(base.gamma_multiply(0.35)) } else { c4(base) };
- let m = b.mesh();
- let (shaded, edges) = match app.ui.visual_style {
- 1 => (true, false),
- 2 => (false, true),
- _ => (true, true),
- };
- let edge_col = if shaded { c4(tk.body_edge) } else { c4(tk.text) };
- // Shaded with hidden edges: edges behind the model show faintly.
- let hidden_edges = app.ui.visual_style == 3;
- let hidden_col = c4(tk.text.gamma_multiply(0.35));
// Appearances: the body's opacity, and faces with looks of their own.
let opacity = s.doc.model_body_opacity(b);
let face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look> =
@@ -390,43 +502,24 @@ fn build_scene(app: &SolveApp) -> GpuScene {
.collect();
sc.planned.push(crate::gpu::PlannedBody { plan, face_colors });
}
- for (ti, t) in m.triangles.iter().enumerate().filter(|_| shaded && !on_gpu) {
- let (mut col, a) = match m.tri_face.get(ti).and_then(|f| face_looks.get(&(*f as usize))) {
- Some(l) => {
- let c = Color32::from_rgb(l.color[0], l.color[1], l.color[2]);
- (if faded { c4(c.gamma_multiply(0.35)) } else { c4(c) }, l.opacity)
- }
- None => (col, opacity),
- };
- let glass = !faded && a < 0.999;
- if glass {
- col[3] = (a.clamp(0.05, 1.0) * 255.0).round() as u8;
- }
- for k in t {
- let i = *k as usize;
- if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
- if faded {
- sc.trans_tri(p.to_f32(), n.to_f32(), col);
- } else if glass {
- sc.glass_tri(p.to_f32(), n.to_f32(), col);
- } else {
- sc.tri(p.to_f32(), n.to_f32(), col);
- }
- }
- }
- }
- for (ei, e) in m.edges.iter().enumerate().filter(|_| edges) {
- if !m.edge_pickable(ei) || (shaded && !m.shaded_edge_visible(ei)) {
- continue;
- }
- for w in e.windows(2) {
- sc.line(w[0].to_f32(), w[1].to_f32(), edge_col, 1.3, false);
- if hidden_edges {
- sc.hidden_line(w[0].to_f32(), w[1].to_f32(), hidden_col, 1.0);
- }
- }
+ let body = BodyDraw { mesh: b.mesh(), col, faded, opacity, face_looks, on_gpu };
+ let key = body.key(shaded, edges, hidden_edges, edge_col, hidden_col);
+ key.hash(&mut run_key);
+ run.push(body);
+ // Blocks end where a body's own key says, so a body added or removed changes only its
+ // own block, not every block after it.
+ if key.is_multiple_of(16) || run.len() >= 64 {
+ let draws = std::mem::take(&mut run);
+ let block_key = std::mem::replace(&mut run_key, std::collections::hash_map::DefaultHasher::new()).finish();
+ push_block(&mut sc, &mut kept, &mut made, block_key, draws, |d, out| d.build(out, shaded, edges, hidden_edges, edge_col, hidden_col));
}
}
+ if !run.is_empty() {
+ push_block(&mut sc, &mut kept, &mut made, run_key.finish(), run, |d, out| d.build(out, shaded, edges, hidden_edges, edge_col, hidden_col));
+ }
+ if let Ok(mut b) = app.viewport.blocks.lock() {
+ *b = made;
+ }
if app.ui.ground_shadow && app.ui.visual_style != 2 && app.cam.pitch > 0.0 {
ground_shadow(&mut sc, app, &st);
}
@@ -511,12 +604,12 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {
sc
}
-fn ground_shadow(sc: &mut GpuScene, app: &SolveApp, st: &solidcraft_engine::doc::ModelState) {
+fn ground_shadow(sc: &mut GpuScene, app: &SolveApp, st: &std::sync::Arc<solidcraft_engine::doc::ModelState>) {
// The bodies' box in the camera's Z-up frame (the ground is its XY plane).
let mut b = solidcraft_engine::geom::Aabb3::EMPTY;
- for x in st.bodies.iter().filter(|x| app.session.body_visible(&x.name)) {
- let bb = x.mesh().bounds();
- if bb.is_empty() {
+ let boxes = body_bounds(app, st);
+ for (x, (_, bb)) in st.bodies.iter().zip(boxes.iter()) {
+ if bb.is_empty() || !app.session.body_visible(&x.name) {
continue;
}
for i in 0..8 {
@@ -705,7 +798,27 @@ fn body_bounds(
{
return b.clone();
}
- let b = std::sync::Arc::new(st.bodies.iter().map(|b| (b.name.clone(), b.mesh().bounds())).collect::<Vec<_>>());
+ // Boxes of meshes the last state had too are kept (each body's box walks its mesh).
+ let mut known = app.viewport.mesh_bounds.lock().map(|mut k| std::mem::take(&mut *k)).unwrap_or_default();
+ let mut now = std::collections::HashMap::with_capacity(st.bodies.len());
+ let b = std::sync::Arc::new(
+ st.bodies
+ .iter()
+ .map(|b| {
+ let mesh = b.mesh();
+ let ptr = std::sync::Arc::as_ptr(&mesh) as usize;
+ let bounds = match known.remove(&ptr).or_else(|| now.remove(&ptr)) {
+ Some((_, bounds)) => bounds,
+ None => mesh.bounds(),
+ };
+ now.insert(ptr, (mesh, bounds));
+ (b.name.clone(), bounds)
+ })
+ .collect::<Vec<_>>(),
+ );
+ if let Ok(mut k) = app.viewport.mesh_bounds.lock() {
+ *k = now;
+ }
*g = Some((st.clone(), b.clone()));
return b;
}
@@ -3344,7 +3457,7 @@ mod tests {
let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));
let mut render = |tess: bool| {
app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });
- let scene = build_scene(&app);
+ let scene = build_scene(&app).merged();
let proj = projection(&app, rect);
let e = proj.cam.eye().to_f32();
let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];
@@ -3392,7 +3505,7 @@ mod tests {
app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });
const SIZE: u32 = 256;
let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));
- let scene = build_scene(&app);
+ let scene = build_scene(&app).merged();
assert!(scene.planned.is_empty(), "no body waits for the GPU evaluation");
assert!(!scene.tris.is_empty(), "the bodies are meshed on the CPU");
let proj = projection(&app, rect);
@@ -3978,11 +4091,11 @@ mod tests {
assert_eq!(mesh.smooth_edges.iter().filter(|f| **f).count(), 512);
let smooth = mesh.smooth_edges.iter().position(|f| *f).unwrap();
let expected = mesh.edges.iter().enumerate().filter(|(i, _)| mesh.shaded_edge_visible(*i)).map(|(_, e)| e.len() - 1).sum::<usize>();
- let shaded = build_scene(&app);
+ let shaded = build_scene(&app).merged();
assert_eq!(shaded.lines.len() / crate::gpu::LINE_SIZE, expected);
assert!(!shaded.tris.is_empty());
app.ui.visual_style = 2;
- let wire = build_scene(&app);
+ let wire = build_scene(&app).merged();
let expected_wire =
mesh.edges.iter().enumerate().filter(|(i, _)| !mesh.seams.get(*i).copied().unwrap_or(false)).map(|(_, e)| e.len() - 1).sum::<usize>();
assert_eq!(wire.lines.len() / crate::gpu::LINE_SIZE, expected_wire);
diff --git a/crates/ui-egui/src/viewport_appearance_tests.rs b/crates/ui-egui/src/viewport_appearance_tests.rs
index b7f2fffb03..ef5498c1ee 100644
--- a/crates/ui-egui/src/viewport_appearance_tests.rs
+++ b/crates/ui-egui/src/viewport_appearance_tests.rs
@@ -31,7 +31,7 @@ fn placed_step_body_uses_imported_opacity_until_a_design_look_overrides_it() {
assert!((appearance.opacity - 0.4).abs() < 1e-6);
assert_eq!(appearance.color, [51, 153, 204]);
crate::dialogs::cancel(&mut app);
- let scene = build_scene(&app);
+ let scene = build_scene(&app).merged();
assert!(!scene.glass.is_empty());
assert!(
scene.tris.is_empty(),
diff --git a/docs/perf.md b/docs/perf.md
index 8ee6e0c305..42b39092d3 100644
--- a/docs/perf.md
+++ b/docs/perf.md
@@ -71,6 +71,22 @@ once per command), but slowly. `solidcraft-cli eval` output for the design corpu
the regression scripts, the generated bicycle and a 3,300-feature agent-built design is
unchanged apart from the timings.
+The viewport rebuilt its whole model scene after every change and uploaded all of it again
+(every body's triangles and edges, 60 MB for the bicycle where bodies are built on the CPU). It
+now builds the scene in blocks of a few bodies, cut where a body's own key says so that adding
+or removing a body changes only its block, and keeps each block's bytes and GPU buffers while
+the block comes back unchanged. The bodies' boxes (fit, picking, the ground shadow) are kept per
+mesh the same way. Built command by command over the control channel (`engine.execute`, then
+`ui.inspect`) in the desktop app under Xvfb with software GL:
+
+| desktop, bicycle built over the control channel | main | with #1148 and this |
+|---|---:|---:|
+| UI work per change at ~1,000 bodies (`frame_ms`) | 1,374 ms | 18 ms |
+| model scene build at ~1,000 bodies (`build_ms`) | 41 ms | 1.4 ms |
+| whole build | 1,409 s | 210 s |
+
+Most of what is left there is software rendering of 770k triangles per frame.
+
## STEP import: shells and item solids without copies (2026-10-13)
A file that lists one product definition many times (a bolt used 70 times, a panel in several