fix deadlock and client counters

2 files changed, 21 insertions, 11 deletions

diff --git a/src/client.rs b/src/client.rs
index 9281bce..9c1b29a 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -14,7 +14,8 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio::sync::Semaphore;
 
 pub struct GeClient {
-    counter: AtomicUsize,
+    download_counter: AtomicUsize,
+    cache_counter: AtomicUsize,
     client: Client,
     cache: Cache,
     par_limit: Semaphore,
@@ -23,7 +24,8 @@ pub struct GeClient {
 impl GeClient {
     pub async fn new(par_limit: usize, cache: Cache) -> Result<Self> {
         Ok(Self {
-            counter: AtomicUsize::new(0),
+            download_counter: AtomicUsize::new(0),
+            cache_counter: AtomicUsize::new(0),
             par_limit: Semaphore::new(par_limit),cache,
             client: Client::builder().default_headers(HeaderMap::from_iter([
                 (HeaderName::from_static("user-agent"), HeaderValue::from_static("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36")),
@@ -34,10 +36,11 @@ impl GeClient {
     pub async fn download(&self, path: &str) -> Result<Bytes> {
         let _permit = self.par_limit.acquire().await?;
         if let Some(d) = self.cache.get(path).await? {
-            debug!("cached {path:?}");
+            let n = self.cache_counter.fetch_add(1, Ordering::Relaxed);
+            debug!("cached #{n} {path:?}");
             Ok(d.into())
         } else {
-            let n = self.counter.fetch_add(1, Ordering::Relaxed);
+            let n = self.download_counter.fetch_add(1, Ordering::Relaxed);
             info!("download #{n} {path:?}");
             let res = self
                 .client
diff --git a/src/main.rs b/src/main.rs
index e9ae4c2..4a395ad 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,7 +8,7 @@ use cache::Cache;
 use clap::Parser;
 use client::GeClient;
 use futures_util::{StreamExt, stream::FuturesUnordered};
-use glam::{DMat4, Vec3};
+use glam::{DMat4, DVec3};
 use mesh::{convert_mesh, decode_normal_table};
 use std::{f32::consts::PI, path::PathBuf, pin::Pin, sync::Arc};
 use tokio::sync::Semaphore;
@@ -107,15 +107,19 @@ fn do_node(
             let (cpath, flags) = unpack_path_and_id(node_meta.path_and_flags());
             // eprintln!("{path}+{cpath} {flags:?}");
             let abspath = format!("{path}{cpath}");
-            if flags.has_node {
+            if flags.has_node && cpath.len() == 4 {
                 let node = c.node_data(&abspath, flags, &bulk, node_meta).await?;
                 let transform = DMat4::from_cols_slice(&node.matrix_globe_from_mesh);
                 let for_normals = decode_normal_table(node.for_normals());
+                eprintln!(
+                    "{:?} {:?}",
+                    node_meta.oriented_bounding_box, bulk.head_node_center
+                );
                 for m in node.meshes {
                     let mesh = convert_mesh(m, &store, &for_normals)?;
                     meshes.push((
                         Affine3A::from_rotation_x(-PI / 2.)
-                            * Affine3A::from_mat4((transform / 500_000.).as_mat4()),
+                            * Affine3A::from_mat4((transform / 3_000_000.).as_mat4()),
                         mesh,
                     ))
                 }
@@ -129,10 +133,13 @@ fn do_node(
             children.push(res?);
         }
 
+        let center = DVec3::from_slice(&bulk.head_node_center).as_vec3();
+        let size = 10_000_0000. / (1 << path.len()) as f32;
         let bounds = AABB {
-            min: Vec3::ZERO,
-            max: Vec3::MAX,
+            min: center - size,
+            max: center + size,
         };
+
         let prefab = store.set(&Prefab {
             mesh: meshes,
             ..Default::default()
@@ -164,18 +171,18 @@ fn cache_all(
         for node_meta in &bulk.node_metadata {
             let (cpath, flags) = unpack_path_and_id(node_meta.path_and_flags());
             let abspath = format!("{path}{cpath}");
-            if flags.has_node {
+            if flags.has_node && abspath.len() < level {
                 c.node_data(&abspath, flags, &bulk, node_meta).await?;
             }
             if cpath.len() == 4 && flags.has_metadata && abspath.len() < level {
                 fu.push(cache_all(c.clone(), par.clone(), abspath, epoch, level));
             }
         }
+        drop(_permit);
 
         while let Some(res) = fu.next().await {
             res?;
         }
-        drop(_permit);
         Ok(())
     })
 }