From b584b329fea119fd4e9462776fb51f4d0ccb7595 Mon Sep 17 00:00:00 2001 From: Orual Date: Sun, 28 Jun 2026 21:59:26 -0400 Subject: [PATCH] bugfixes to rewritten renderer --- crates/polymodel-mesh/src/parser.rs | 23 +++-- .../polymodel-renderer-worker/src/worker.rs | 86 ++++++++++++++++--- 2 files changed, 93 insertions(+), 16 deletions(-) diff --git a/crates/polymodel-mesh/src/parser.rs b/crates/polymodel-mesh/src/parser.rs index ec7a397..22abd00 100644 --- a/crates/polymodel-mesh/src/parser.rs +++ b/crates/polymodel-mesh/src/parser.rs @@ -26,10 +26,6 @@ where F: FnMut(String) -> Fut, Fut: Future, MeshLoadError>>, { - if format == MeshFormat::Threemf { - return Err(MeshLoadError::UnsupportedFormat); - } - let primary = fetch(primary_url.to_string()).await?; let companions = if format == MeshFormat::Gltf { let base = primary_url.rsplit_once('/').map(|(base, _)| base); @@ -266,7 +262,22 @@ mod tests { .expect("3MF parses locally"); assert_eq!(mesh.format, MeshFormat::Threemf); assert_eq!(mesh.triangle_count(), 25692); - assert_eq!(mesh.format, MeshFormat::Gltf); - assert_eq!(mesh.triangle_count(), 12); + } + + #[tokio::test] + async fn load_mesh_with_companions_parses_threemf_locally() { + let threemf = fixture("cube_gears.3mf"); + let mesh = load_mesh_with_companions("cube_gears.3mf", MeshFormat::Threemf, |url| { + let threemf = threemf.clone(); + async move { + assert_eq!(url, "cube_gears.3mf"); + Ok(threemf) + } + }) + .await + .expect("3MF parses through the async worker helper"); + + assert_eq!(mesh.format, MeshFormat::Threemf); + assert_eq!(mesh.triangle_count(), 25692); } } diff --git a/crates/polymodel-renderer-worker/src/worker.rs b/crates/polymodel-renderer-worker/src/worker.rs index 3e36a1e..37ee024 100644 --- a/crates/polymodel-renderer-worker/src/worker.rs +++ b/crates/polymodel-renderer-worker/src/worker.rs @@ -99,6 +99,7 @@ impl WorkerState { } fn init_renderer(&mut self, canvas: web_sys::OffscreenCanvas) { + tracing::info!("renderer worker: initializing WebGL2 renderer"); let opts = js_sys::Object::new(); let _ = js_sys::Reflect::set(&opts, &"desynchronized".into(), &JsValue::from_bool(true)); @@ -162,6 +163,7 @@ impl WorkerState { }); self.post_event(&RendererEvent::ContextAcquired); self.post_event(&RendererEvent::RendererReady); + tracing::info!("renderer worker: renderer ready"); } } @@ -184,6 +186,16 @@ fn build_scene( > { let fit = model.camera_fit(); let cpu_model = model_with_default_materials(model); + tracing::info!( + format = ?model.format, + parts = cpu_model.geometries.len(), + materials = cpu_model.materials.len(), + vertices = model.vertex_count(), + triangles = model.triangle_count(), + center = ?fit.center, + radius = fit.radius, + "renderer worker: building scene" + ); let render_model = three_d::Model::::new(context, &cpu_model) .map_err(|e| format!("renderer model: {e}"))?; if render_model.iter().next().is_none() { @@ -336,17 +348,17 @@ fn standard_lights( three_d::DirectionalLight, ) { let ambient_light = - three_d::AmbientLight::new(context, 0.45, three_d::Srgba::new_opaque(255, 255, 255)); + three_d::AmbientLight::new(context, 1.15, three_d::Srgba::new_opaque(255, 255, 255)); let key_light = three_d::DirectionalLight::new( context, - 2.6, + 3.4, three_d::Srgba::new_opaque(255, 255, 255), three_d::vec3(-0.45, -0.55, -0.70), ); let fill_light = three_d::DirectionalLight::new( context, - 0.9, - three_d::Srgba::new_opaque(170, 205, 255), + 1.7, + three_d::Srgba::new_opaque(215, 230, 255), three_d::vec3(0.55, 0.35, -0.35), ); (ambient_light, key_light, fill_light) @@ -475,7 +487,7 @@ fn consume_input_and_render(st: &mut WorkerState) { let screen = three_d::RenderTarget::screen(&renderer.context, st.pixel_width, st.pixel_height); let screen = screen.clear(three_d::ClearState::color_and_depth( - 0.035, 0.043, 0.067, 1.0, 1.0, + 0.78, 0.80, 0.84, 1.0, 1.0, )); if let Some(model) = &renderer.model { @@ -502,6 +514,13 @@ fn handle_load_mesh( expected_size: Option, expected_digest: Option>, ) { + tracing::info!( + ?format, + primary_url, + expected_size, + has_expected_digest = expected_digest.is_some(), + "renderer worker: starting mesh load" + ); let epoch = { let mut st = state.borrow_mut(); if st.disposed { @@ -514,6 +533,19 @@ fn handle_load_mesh( let state_clone = state.clone(); spawn_local(async move { let result = load_mesh_async(&primary_url, format, expected_size, expected_digest).await; + match &result { + Ok(_) => tracing::info!( + ?format, + success = true, + "renderer worker: mesh load future completed" + ), + Err(message) => tracing::error!( + ?format, + success = false, + %message, + "renderer worker: mesh load future completed" + ), + } let mut st = match state_clone.try_borrow_mut() { Ok(st) => st, @@ -563,15 +595,34 @@ async fn load_mesh_async( expected_size: Option, expected_digest: Option>, ) -> Result { - load_mesh_with_companions(primary_url, format, |url| { + tracing::info!( + ?format, + primary_url, + "renderer worker: load_mesh_async begin" + ); + let model = load_mesh_with_companions(primary_url, format, |url| { let verify_primary = url == primary_url; let expected_digest = expected_digest.clone(); async move { + tracing::debug!(%url, verify_primary, "renderer worker: fetching mesh resource"); let bytes = fetch_bytes(&url).await.map_err(|e| { polymodel_mesh::contract::MeshLoadError::Decode(format!("fetch {url}: {e}")) })?; + tracing::debug!( + %url, + verify_primary, + bytes = bytes.len(), + "renderer worker: fetched mesh resource" + ); if verify_primary && (expected_size.is_some() || expected_digest.is_some()) { let size = expected_size.unwrap_or(bytes.len() as i64); + tracing::debug!( + %url, + expected_size = size, + bytes = bytes.len(), + has_expected_digest = expected_digest.is_some(), + "renderer worker: verifying primary part file" + ); polymodel_renderer_protocol::verify_part_file( &bytes, size, @@ -582,12 +633,21 @@ async fn load_mesh_async( "part file verification failed: {e}" )) })?; + tracing::debug!(%url, "renderer worker: primary part file verified"); } Ok(bytes) } }) .await - .map_err(|e| e.to_string()) + .map_err(|e| e.to_string())?; + tracing::info!( + ?format, + parts = model.part_count(), + vertices = model.vertex_count(), + triangles = model.triangle_count(), + "renderer worker: mesh parsed" + ); + Ok(model) } // --------------------------------------------------------------------------- @@ -652,7 +712,7 @@ async fn render_preview_png(model: &ModelMesh, width: u32, height: u32) -> Resul let screen = three_d::RenderTarget::screen(&context, width, height); let _ = screen .clear(three_d::ClearState::color_and_depth( - 0.035, 0.043, 0.067, 1.0, 1.0, + 0.78, 0.80, 0.84, 1.0, 1.0, )) .render( &camera, @@ -836,7 +896,10 @@ fn handle_canvas_transfer(state: &Rc>, value: &JsValue) { pub fn entry() { console_error_panic_hook::set_once(); - tracing_wasm::set_as_global_default(); + let mut wasm_log_config = tracing_wasm::WASMLayerConfigBuilder::new(); + wasm_log_config.set_max_level(tracing::Level::DEBUG); + tracing_wasm::set_as_global_default_with_config(wasm_log_config.build()); + tracing::info!("renderer worker: tracing initialized"); let scope: DedicatedWorkerGlobalScope = js_sys::global().unchecked_into(); let state = Rc::new(RefCell::new(WorkerState::new(scope.clone()))); @@ -869,7 +932,10 @@ pub fn entry() { if let Ok(array) = data.dyn_into::() { let bytes = array.to_vec(); match deserialize_command(&bytes) { - Ok(cmd) => handle_command(&state_for_msg, cmd), + Ok(cmd) => { + tracing::debug!(command = ?cmd, "renderer worker: command received"); + handle_command(&state_for_msg, cmd); + } Err(e) => { tracing::error!("failed to deserialize command: {e}"); } -- knotmirror 0.0.1