Something went wrong. Try again.
atproto Thingiverse but good
Something went wrong. Try again.
20 kB · 532 lines
Rust
at commit 08e9e382
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533//! Leaf protocol crate for the Polymodel renderer worker split.//!//! Owns the types shared between the Dioxus main thread and the renderer Web Worker://! [`MeshFormat`] / [`LengthUnit`] / [`Units`] (relocated from the mesh contract so the//! app never depends on `three-d-asset`), the postcard message envelope//! ([`RendererCommand`] / [`RendererEvent`]), and [`MeshStats`].//!//! The app depends on this crate (and only this crate); the worker and mesh crates depend//! on it too. Heavy deps (`three-d-asset`, `stl_io`, `tobj`, `gltf`) live in the mesh and//! worker crates, never here.
use serde::{Deserialize, Serialize};use sha2::Digest;
mod load_state;
pub use load_state::{ LoadError, LoadErrorCode, LoadEvent, LoadIdentity, LoadReducer, LoadState, RendererNamespace, ResourceToken, TransitionOutcome, TransitionResult,};
// ---------------------------------------------------------------------------// Shared mesh-format types (relocated from polymodel-mesh::contract)// ---------------------------------------------------------------------------
/// Source format of a loaded mesh.////// STL, OBJ, glTF (GLB, embedded, or multi-file `.gltf` with external buffers), and 3MF/// are all parsed client-side in the worker via `three-d-asset`. There is no/// binary/ASCII sub-label for STL — reliably telling them apart is hard, and both yield/// the same mesh.#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]pub enum MeshFormat { /// Stereolithography (binary or ASCII). Stl, /// Wavefront OBJ (convex polygons fan-triangulated; lines/points dropped). Obj, /// glTF 2.0 — GLB, embedded-base64 `.gltf`, or multi-file `.gltf` + companions. Gltf, /// 3D Manufacturing Format. Parsed client-side in the worker via `three-d-asset`'s /// `3mf` feature (`lib3mf`, pure Rust). Threemf,}
impl MeshFormat { /// Detect a mesh format from a filename extension. /// /// The extension is taken from the final `.`-delimited segment, lower-cased, and /// matched with no leading dot. Returns `None` for empty or unknown extensions. pub fn from_extension(path: impl AsRef<str>) -> Option<Self> { let path = path.as_ref(); let ext = path.rsplit('.').next()?.to_ascii_lowercase(); if ext.len() >= path.len() { return None; } match ext.as_str() { "stl" => Some(Self::Stl), "obj" => Some(Self::Obj), "gltf" | "glb" => Some(Self::Gltf), "3mf" => Some(Self::Threemf), _ => None, } }}
/// A length unit.#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]pub enum LengthUnit { Millimeter, Centimeter, Meter, Inch, /// A thousandth of an inch — "thou" in machining, "mil" in PCB/electronics. Thou, Foot, Unknown,}
/// Unit handling for a loaded model.////// `source` is the unit declared by the file; STL/OBJ declare none, so they report/// [`LengthUnit::Unknown`] and rely on [`Units::unitless_assumed_mm`]. glTF's base unit is/// the metre, so a loaded glTF reports [`LengthUnit::Meter`] with no assumption.#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]pub struct Units { /// The unit declared by the file (STL/OBJ: [`LengthUnit::Unknown`]; glTF: [`LengthUnit::Meter`]). pub source: LengthUnit, /// The convention assumed when `source` is unknown. pub assumed: Option<LengthUnit>,}
impl Units { /// Unit handling for a unitless format (STL, OBJ): source unknown, assume millimetres. pub fn unitless_assumed_mm() -> Self { Self { source: LengthUnit::Unknown, assumed: Some(LengthUnit::Millimeter), } }
/// Unit handling for a format that declares its own unit (e.g. glTF → metres), /// so no assumption is applied. pub fn declared(source: LengthUnit) -> Self { Self { source, assumed: None, } }}
// ---------------------------------------------------------------------------// Mesh stats (the only mesh data crossing back from the worker)// ---------------------------------------------------------------------------
/// Lightweight mesh statistics returned to the main thread after a successful load.////// The full model geometry stays in the worker; only aggregate counts cross back for/// display.#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]pub struct MeshStats { /// Sum of part-local vertex positions across renderable geometry. pub vertices: u32, /// Number of triangles. pub triangles: u32,}
// ---------------------------------------------------------------------------// Part-file verification (client-side digest + size check)// ---------------------------------------------------------------------------
/// Errors from [`verify_part_file`].#[derive(Debug, thiserror::Error)]pub enum VerifyError { #[error("part file size mismatch: expected {expected}, got {actual}")] Size { expected: i64, actual: usize }, #[error("part file digest mismatch")] Digest,}
/// Verify a reassembled part file's size and (optional) sha256 digest.////// Called on every consumer path (viewer mesh-load, direct download) after the/// streamed bytes are collected. Per-chunk CID verifies each piece on the PDS/// side; this full-file check catches assembly errors (reordering, swaps,/// drops) that per-chunk CID cannot.pub fn verify_part_file(bytes: &[u8], size: i64, digest: Option<&[u8]>) -> Result<(), VerifyError> { if bytes.len() as i64 != size { return Err(VerifyError::Size { expected: size, actual: bytes.len(), }); } if let Some(expected) = digest { let actual = sha2::Sha256::digest(bytes); if actual[..] != *expected { return Err(VerifyError::Digest); } } Ok(())}
// ---------------------------------------------------------------------------// Renderer command (main → worker)// ---------------------------------------------------------------------------
/// A command sent from the main thread to the renderer worker.////// Serialized with postcard and posted as a `Uint8Array`. The worker deserializes and/// dispatches. Input commands (`SetPointerState`, `PointerDown`, `PointerUp`) only update/// worker-side accumulators — the worker's `requestAnimationFrame` loop consumes them/// per-frame, never rendering from a single message.#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]pub enum RendererCommand { /// Begin an interactive load. The main thread allocates the identity and the worker /// must not allocate or infer one. The worker discovers and fetches glTF companions. StartLoad { namespace: RendererNamespace, identity: LoadIdentity, format: MeshFormat, primary_url: String, expected_size: Option<i64>, expected_digest: Option<Vec<u8>>, }, /// Cancel the current identity. Late results are rejected by the reducer. Cancel { namespace: RendererNamespace, identity: LoadIdentity, }, /// Render a mesh URL to a PNG preview image. This is intentionally handled by /// the worker so the Dioxus app does not depend on mesh parsing or `three-d`. RenderPreviewImage { request_id: u32, format: MeshFormat, primary_url: String, width: u32, height: u32, }, /// Resize the worker's `OffscreenCanvas` and viewport. `css_w`/`css_h` are CSS pixels, /// `dpr` is `window.devicePixelRatio`. The worker sets canvas pixel dimensions to /// `css_w * dpr` × `css_h * dpr`. Resize { css_w: f32, css_h: f32, dpr: f32 }, /// Coalesced latest pointer state (producer-side throttled to display rate). /// `x`/`y` are canvas-relative CSS pixels; `buttons` is a bitmask matching /// `PointerEvent.buttons`; `wheel_delta` is the accumulated deltaY since the last post. SetPointerState { x: f32, y: f32, buttons: u16, modifiers: KeyModifiers, wheel_delta: f32, }, /// Discrete pointer-down event (infrequent; posted as events). PointerDown { x: f32, y: f32 }, /// Discrete pointer-up event (infrequent; posted as events). PointerUp { x: f32, y: f32 }, /// Tear down the renderer and stop the frame loop. The worker closes itself. Dispose, /// Deliberately panic — used by e2e tests to verify crash surfacing. DebugCrash,}
/// Keyboard modifier flags accompanying a pointer state.#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]pub struct KeyModifiers { pub shift: bool, pub ctrl: bool, pub alt: bool, pub meta: bool,}
// ---------------------------------------------------------------------------// Renderer event (worker → main)// ---------------------------------------------------------------------------
/// An event sent from the renderer worker to the main thread.////// Serialized with postcard and posted as a `Uint8Array`. The main thread deserializes and/// maps to [`crate::viewer::ViewerStatus`] / `context_acquisitions`.////// The `"__worker_ready"` string handshake is posted as a bare JS string (not postcard)/// before the first `RendererEvent` — see the worker `main.rs`.#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]pub enum RendererEvent { /// The WebGL2 context was created on the `OffscreenCanvas`. Emitted once per worker /// lifetime (retained across model switches). ContextAcquired, /// Context and initial viewport readiness only; mesh readiness is `InstallSucceeded`. RendererContextReady, /// Fetch/parse completed and a candidate is ready for installation. LoadSucceeded { namespace: RendererNamespace, identity: LoadIdentity, }, /// The candidate scene was installed; this is the only mesh-readiness publication point. InstallSucceeded { namespace: RendererNamespace, identity: LoadIdentity, stats: MeshStats, }, /// A load or install failed for the exact identity. LoadFailed { namespace: RendererNamespace, identity: LoadIdentity, code: LoadErrorCode, detail: String, }, /// Cancellation/supersession/disposal status publication for the exact identity. LoadCancelled { namespace: RendererNamespace, identity: LoadIdentity, }, /// A preview render completed successfully. `png` is raw PNG bytes. PreviewImageRendered { request_id: u32, png: Vec<u8> }, /// A preview render failed. Preview failures are non-fatal and do not affect /// the interactive viewer scene. PreviewImageError { request_id: u32, message: String }, /// A renderer error. `fatal: true` means the worker is unusable (context loss, /// unhandled panic) — the main thread surfaces `ViewerStatus::RendererError`. Error { fatal: bool, message: String },}
// ---------------------------------------------------------------------------// Postcard ser/deser helpers// ---------------------------------------------------------------------------
/// Serialize a [`RendererCommand`] to postcard bytes.pub fn serialize_command(cmd: &RendererCommand) -> Result<Vec<u8>, postcard::Error> { postcard::to_allocvec(cmd)}
/// Serialize a [`RendererEvent`] to postcard bytes.pub fn serialize_event(evt: &RendererEvent) -> Result<Vec<u8>, postcard::Error> { postcard::to_allocvec(evt)}
/// Deserialize a [`RendererCommand`] from postcard bytes.pub fn deserialize_command(bytes: &[u8]) -> Result<RendererCommand, postcard::Error> { postcard::from_bytes(bytes)}
/// Deserialize a [`RendererEvent`] from postcard bytes.pub fn deserialize_event(bytes: &[u8]) -> Result<RendererEvent, postcard::Error> { postcard::from_bytes(bytes)}
// ---------------------------------------------------------------------------// Tests// ---------------------------------------------------------------------------
#[cfg(test)]mod tests { use super::*;
#[test] fn verify_part_file_matching_size_and_digest_is_ok() { let data = b"hello world"; let digest = sha2::Sha256::digest(data); assert!(verify_part_file(data, data.len() as i64, Some(&digest)).is_ok()); }
#[test] fn verify_part_file_size_mismatch_is_err() { let data = b"hello world"; let digest = sha2::Sha256::digest(data); let err = verify_part_file(data, 999, Some(&digest)).unwrap_err(); assert!(matches!( err, VerifyError::Size { expected: 999, actual: 11 } )); }
#[test] fn verify_part_file_digest_mismatch_is_err() { let data = b"hello world"; let wrong_digest = [0u8; 32]; let err = verify_part_file(data, data.len() as i64, Some(&wrong_digest)).unwrap_err(); assert!(matches!(err, VerifyError::Digest)); }
#[test] fn verify_part_file_no_digest_checks_size_only() { let data = b"hello world"; assert!(verify_part_file(data, data.len() as i64, None).is_ok()); assert!(verify_part_file(data, 999, None).is_err()); }
#[test] fn from_extension_maps_known_formats() { assert_eq!( MeshFormat::from_extension("cube.stl"), Some(MeshFormat::Stl) ); assert_eq!( MeshFormat::from_extension("cube.obj"), Some(MeshFormat::Obj) ); assert_eq!( MeshFormat::from_extension("cube.gltf"), Some(MeshFormat::Gltf) ); assert_eq!( MeshFormat::from_extension("cube.glb"), Some(MeshFormat::Gltf) ); assert_eq!( MeshFormat::from_extension("cube.3mf"), Some(MeshFormat::Threemf) ); }
#[test] fn from_extension_case_insensitive() { assert_eq!( MeshFormat::from_extension("CUBE.GLB"), Some(MeshFormat::Gltf) ); assert_eq!(MeshFormat::from_extension(".OBJ"), Some(MeshFormat::Obj)); assert_eq!( MeshFormat::from_extension("/models/Body_F_Chest-v4.STL"), Some(MeshFormat::Stl) ); }
#[test] fn from_extension_rejects_unknown_and_extensionless() { assert_eq!(MeshFormat::from_extension("cube.ply"), None); assert_eq!(MeshFormat::from_extension("cube"), None); assert_eq!(MeshFormat::from_extension(""), None); assert_eq!(MeshFormat::from_extension("cube."), None); assert_eq!(MeshFormat::from_extension("."), None); assert_eq!(MeshFormat::from_extension("archive.tar.gz"), None); }
fn roundtrip_command(cmd: &RendererCommand) -> RendererCommand { deserialize_command(&serialize_command(cmd).unwrap()).unwrap() }
fn roundtrip_event(evt: &RendererEvent) -> RendererEvent { deserialize_event(&serialize_event(evt).unwrap()).unwrap() }
#[test] fn all_commands_roundtrip() { let commands = vec![ RendererCommand::StartLoad { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 1), format: MeshFormat::Stl, primary_url: "/models/cube.stl".into(), expected_size: Some(4096), expected_digest: Some(vec![0u8; 32]), }, RendererCommand::StartLoad { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 2), format: MeshFormat::Obj, primary_url: "/models/cube.obj".into(), expected_size: None, expected_digest: None, }, RendererCommand::StartLoad { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(2, 1), format: MeshFormat::Gltf, primary_url: "/models/cube.glb".into(), expected_size: Some(2048), expected_digest: None, }, RendererCommand::StartLoad { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(2, 2), format: MeshFormat::Threemf, primary_url: "/models/cube.3mf".into(), expected_size: None, expected_digest: Some(vec![1u8; 32]), }, RendererCommand::Cancel { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(2, 2), }, RendererCommand::RenderPreviewImage { request_id: 7, format: MeshFormat::Stl, primary_url: "blob:http://localhost/preview".into(), width: 1024, height: 1024, }, RendererCommand::Resize { css_w: 800.0, css_h: 600.0, dpr: 2.0, }, RendererCommand::SetPointerState { x: 100.0, y: 200.0, buttons: 1, modifiers: KeyModifiers { shift: true, ..Default::default() }, wheel_delta: 42.0, }, RendererCommand::PointerDown { x: 10.0, y: 20.0 }, RendererCommand::PointerUp { x: 15.0, y: 25.0 }, RendererCommand::Dispose, RendererCommand::DebugCrash, ]; for cmd in &commands { assert_eq!(&roundtrip_command(cmd), cmd, "failed on {cmd:?}"); } }
#[test] fn all_events_roundtrip() { let events = vec![ RendererEvent::ContextAcquired, RendererEvent::RendererContextReady, RendererEvent::LoadSucceeded { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 1), }, RendererEvent::InstallSucceeded { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 1), stats: MeshStats { vertices: 1234, triangles: 4321, }, }, RendererEvent::LoadFailed { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 2), code: LoadErrorCode::Parse, detail: "failed to parse: bad bytes".into(), }, RendererEvent::LoadCancelled { namespace: RendererNamespace::Interactive, identity: LoadIdentity::new(1, 2), }, RendererEvent::PreviewImageRendered { request_id: 7, png: vec![137, 80, 78, 71], }, RendererEvent::PreviewImageError { request_id: 7, message: "preview failed".into(), }, RendererEvent::Error { fatal: true, message: "context lost".into(), }, RendererEvent::Error { fatal: false, message: "non-fatal warning".into(), }, ]; for evt in &events { assert_eq!(&roundtrip_event(evt), evt, "failed on {evt:?}"); } }
#[test] fn deserialize_garbage_returns_error() { assert!(deserialize_command(&[0xFF, 0xFE, 0xFD]).is_err()); assert!(deserialize_event(&[0xFF, 0xFE, 0xFD]).is_err()); assert!(deserialize_command(&[]).is_err()); assert!(deserialize_event(&[]).is_err()); }}