Files
endorphin-tessera-gui/src/snapshot.rs
T
codex-bot 6c42e5dde4
Verify Tessera GUI / verify (push) Successful in 9m53s
feat: construct native visual subclasses from Endor source
2026-10-21 02:06:25 +08:00

241 lines
8.2 KiB
Rust

//! Object-to-visual dependencies. Cached results never own VM references.
use crate::{
block::{self, Kind},
ui_bridge::{UiKind, UiNode},
};
use endor_core::{ChangeBatch, ChangeKey, ObjectRef, ObjectStore, Value, VmError};
use std::{
collections::{HashMap, HashSet, VecDeque},
sync::Arc,
};
#[derive(Debug)]
struct Cached {
node: Arc<UiNode>,
dependencies: Vec<Dependency>,
children: Vec<ObjectRef>,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct Dependency {
object: ObjectRef,
property: Option<String>,
}
#[derive(Debug, Default)]
pub struct RenderCache {
entries: HashMap<ObjectRef, Cached>,
dependents: HashMap<Dependency, HashSet<ObjectRef>>,
parents: HashMap<ObjectRef, HashSet<ObjectRef>>,
dirty: HashSet<ObjectRef>,
pub visited: usize,
pub reused: usize,
}
impl RenderCache {
pub fn invalidate(&mut self, batch: ChangeBatch) {
let mut queue = VecDeque::new();
if batch.rescan_required {
queue.extend(self.entries.keys().copied());
} else {
for change in batch.changes {
let key = Dependency {
object: change.object,
property: match change.key {
ChangeKey::Attribute(name) => Some(name),
ChangeKey::Contents => None,
},
};
if let Some(owners) = self.dependents.get(&key) {
queue.extend(owners);
}
}
}
while let Some(block) = queue.pop_front() {
if self.dirty.insert(block)
&& let Some(parents) = self.parents.get(&block)
{
queue.extend(parents);
}
}
}
fn remove(&mut self, block: ObjectRef) -> Option<Cached> {
let old = self.entries.remove(&block)?;
for source in &old.dependencies {
if let Some(owners) = self.dependents.get_mut(source) {
owners.remove(&block);
if owners.is_empty() {
self.dependents.remove(source);
}
}
}
for child in &old.children {
if let Some(parents) = self.parents.get_mut(child) {
parents.remove(&block);
if parents.is_empty() {
self.parents.remove(child);
}
}
}
Some(old)
}
pub fn prune(&mut self, store: &ObjectStore) {
let dead: Vec<_> = self
.entries
.keys()
.filter(|v| store.object(**v).is_err())
.copied()
.collect();
for block in dead {
self.remove(block);
self.dirty.remove(&block);
}
}
pub fn snapshot(
&mut self,
store: &ObjectStore,
root: ObjectRef,
) -> Result<Arc<UiNode>, VmError> {
self.visited = 0;
self.reused = 0;
let mut work = vec![(root, false)];
let mut path = HashSet::new();
let mut values = Vec::<Arc<UiNode>>::new();
while let Some((block, finish)) = work.pop() {
if !finish {
if !self.dirty.contains(&block)
&& let Some(cached) = self.entries.get(&block)
{
self.reused += 1;
values.push(cached.node.clone());
continue;
}
self.visited += 1;
if self.visited > 10_000 {
return Err(VmError::ExecutionLimit("expanded Block graph"));
}
}
let (data_ref, data, raw_dependencies) = block::resolve_tracked(store, block)?;
let mut dependencies: Vec<_> = raw_dependencies
.into_iter()
.map(|object| Dependency {
object,
property: None,
})
.collect();
if !finish {
if !path.insert(data_ref) {
return Err(VmError::InvalidArgument("cyclic Block composition"));
}
work.push((block, true));
for child in data.children.iter().rev() {
work.push((child.block, false));
}
continue;
}
path.remove(&data_ref);
let children = values.split_off(values.len() - data.children.len());
let kind = match &data.kind {
Kind::Text { value, size, color } => {
let value = if let Some((source, field)) = &data.text_binding {
let storage = store.attribute_path(*source)?;
for (index, object) in storage.iter().enumerate() {
dependencies.push(Dependency {
object: *object,
property: (index + 1 == storage.len()).then(|| field.clone()),
});
}
match store.get_attr(*source, field)? {
Value::Nil => "nil".into(),
Value::Bool(v) => v.to_string(),
Value::Number(v) => v.to_string(),
Value::Text(v) => v,
Value::Object(v) => {
dependencies.push(Dependency {
object: v,
property: None,
});
store.str(v)?
}
}
} else {
value.clone()
};
UiKind::Text {
value,
size: *size,
color: color.clone(),
}
}
Kind::Rect {
width,
height,
radius,
color,
} => UiKind::Rect {
width: *width,
height: *height,
radius: *radius,
color: color.clone(),
},
Kind::Spacer(size) => UiKind::Spacer(*size),
Kind::Row => UiKind::Row {
padding: data.padding,
gap: data.gap,
children,
},
Kind::Column | Kind::Page => UiKind::Column {
padding: data.padding,
gap: data.gap,
children,
},
Kind::Button => UiKind::Button {
padding: data.padding,
gap: data.gap,
children,
},
};
let next = UiNode {
block_id: block.to_string(),
slots: data.children.iter().map(|c| c.slot).collect(),
interactive: matches!(&data.kind, Kind::Button) || data.click.is_some(),
kind,
};
let old = self.remove(block);
let node = if let Some(old) = old.as_ref().filter(|old| old.node.shallow_eq(&next)) {
old.node.clone()
} else {
Arc::new(next)
};
dependencies.sort_unstable();
dependencies.dedup();
let child_refs: Vec<_> = data.children.iter().map(|child| child.block).collect();
for source in &dependencies {
self.dependents
.entry(source.clone())
.or_default()
.insert(block);
}
for child in &child_refs {
self.parents.entry(*child).or_default().insert(block);
}
self.entries.insert(
block,
Cached {
node: node.clone(),
dependencies,
children: child_refs,
},
);
self.dirty.remove(&block);
values.push(node);
}
values
.pop()
.ok_or(VmError::InvalidArgument("empty Block snapshot"))
}
}