From 6af8b165fe8cbab35721a8797ca85cda454a5ff4 Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Mon, 6 Jan 2025 18:54:00 +0100
Subject: new network

---
 client/src/download.rs      |  4 +--
 client/src/scene_prepare.rs | 64 ++++++++++++++++++++++++++++++++++++---------
 client/src/scene_render.rs  | 10 ++++---
 3 files changed, 59 insertions(+), 19 deletions(-)

(limited to 'client')

diff --git a/client/src/download.rs b/client/src/download.rs
index dfd7ff0..8e1686a 100644
--- a/client/src/download.rs
+++ b/client/src/download.rs
@@ -34,8 +34,8 @@ impl Downloader {
     pub fn packet(&mut self, p: &Packet) -> Result<()> {
         match p {
             Packet::RespondResource(d) => {
-                let key = Resource(sha256(&d));
-                self.store.set(&d)?;
+                let key = Resource(sha256(&d.0));
+                self.store.set(&d.0)?;
                 self.need.remove(&key);
                 self.pending.remove(&key);
                 if self.have.insert(key) {
diff --git a/client/src/scene_prepare.rs b/client/src/scene_prepare.rs
index 30c1742..5376145 100644
--- a/client/src/scene_prepare.rs
+++ b/client/src/scene_prepare.rs
@@ -1,28 +1,28 @@
+use crate::download::Downloader;
 use anyhow::Result;
 use std::{
     collections::{HashMap, HashSet},
     sync::Arc,
 };
 use weareshared::{
+    Affine3A,
     packets::{ReadWrite, Resource},
-    resources::Prefab,
-    tree::SceneTree,
+    resources::{Attribute, Part, Prefab},
 };
 use wgpu::Buffer;
 
-use crate::download::Downloader;
-
 pub struct ScenePreparer {
     index_buffers: HashMap<Resource, Arc<Buffer>>,
-    vertex_buffers_x3: HashMap<[Resource; 1], Arc<Buffer>>,
-    vertex_buffers_x2: HashMap<[Resource; 2], Arc<Buffer>>,
-    vertex_buffers_x1: HashMap<[Resource; 3], Arc<Buffer>>,
+    index_buffers_needed: HashSet<Resource>,
+    vertex_buffers: HashMap<Resource, Arc<Buffer>>,
+    vertex_buffers_needed: HashSet<Resource>,
     parts: HashMap<Resource, Arc<RPart>>,
+    parts_needed: HashSet<Resource>,
     prefabs: HashMap<Resource, RPrefab>,
     prefabs_needed: HashSet<Resource>,
 }
 
-pub struct RPrefab(pub Vec<Arc<RPart>>);
+pub struct RPrefab(pub Vec<(Affine3A, Arc<RPart>)>);
 pub struct RPart {
     pub index_count: u32,
     pub index: Arc<Buffer>,
@@ -34,19 +34,57 @@ impl ScenePreparer {
     pub fn new() -> Self {
         Self {
             index_buffers: HashMap::new(),
-            vertex_buffers_x3: HashMap::new(),
-            vertex_buffers_x2: HashMap::new(),
-            vertex_buffers_x1: HashMap::new(),
+            vertex_buffers: HashMap::new(),
+            vertex_buffers_needed: HashSet::new(),
             parts: HashMap::new(),
+            parts_needed: HashSet::new(),
             prefabs: HashMap::new(),
             prefabs_needed: HashSet::new(),
+            index_buffers_needed: HashSet::new(),
         }
     }
-    fn update(&mut self, dls: &mut Downloader) -> Result<()> {
+    pub fn update(&mut self, dls: &mut Downloader) -> Result<()> {
+        let mut done = Vec::new();
         for pres in &self.prefabs_needed {
             if let Some(buf) = dls.try_get(*pres)? {
                 let prefab = Prefab::read(&mut buf.as_slice())?;
-                
+                let mut rprefab = RPrefab(Vec::new());
+                for (aff, partres) in &prefab.0 {
+                    if let Some(part) = self.parts.get(partres) {
+                        rprefab.0.push((*aff, part.clone()));
+                    } else {
+                        self.parts_needed.insert(*partres);
+                    }
+                }
+                if rprefab.0.len() == prefab.0.len() {
+                    self.prefabs.insert(*pres, rprefab);
+                    done.push(*pres);
+                }
+            }
+        }
+        for pres in &self.parts_needed {
+            if let Some(buf) = dls.try_get(*pres)? {
+                let part = Part::read(&mut buf.as_slice())?;
+                if let Some(indexres) = part.index {
+                    if let Some(vertexres) = part.va_position {
+                        let Some(index) = self.index_buffers.get(&indexres) else {
+                            self.index_buffers_needed.insert(indexres);
+                            continue;
+                        };
+                        for vr in vertexres {
+                            match vr {
+                                Attribute::Constant(_) => todo!(),
+                                Attribute::Vertex(resource) => {
+                                    let Some(vertex) = self.index_buffers.get(&resource) else {
+                                        self.index_buffers_needed.insert(indexres);
+                                        continue;
+                                    };
+                                }
+                                Attribute::Texture(resource) => todo!(),
+                            }
+                        }
+                    }
+                }
             }
         }
         Ok(())
diff --git a/client/src/scene_render.rs b/client/src/scene_render.rs
index f80f6c2..68d0c49 100644
--- a/client/src/scene_render.rs
+++ b/client/src/scene_render.rs
@@ -5,9 +5,9 @@ use wgpu::{
     ColorWrites, CommandEncoder, Device, FragmentState, FrontFace, IndexFormat, LoadOp,
     MultisampleState, Operations, PipelineCompilationOptions, PipelineLayoutDescriptor,
     PolygonMode, PrimitiveState, PrimitiveTopology, RenderPassColorAttachment,
-    RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, StoreOp, TextureFormat,
-    TextureView, VertexAttribute, VertexBufferLayout, VertexFormat, VertexState, VertexStepMode,
-    include_wgsl,
+    RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, ShaderStages, StoreOp,
+    TextureFormat, TextureView, VertexAttribute, VertexBufferLayout, VertexFormat, VertexState,
+    VertexStepMode, include_wgsl,
 };
 
 use crate::scene_prepare::RPrefab;
@@ -113,7 +113,9 @@ impl ScenePipeline {
 
         for ob in scene.objects.values() {
             if let Some(prefab) = self.prefabs.get(&ob.res) {
-                for part in &prefab.0 {
+                for (affine, part) in &prefab.0 {
+                    let affine = affine.to_cols_array().map(|v| v.to_le_bytes());
+                    rpass.set_push_constants(ShaderStages::VERTEX, 0, affine.as_flattened());
                     rpass.set_index_buffer(part.index.slice(..), IndexFormat::Uint16);
                     rpass.set_vertex_buffer(0, part.positions.slice(..));
                     rpass.set_vertex_buffer(1, part.normals.slice(..));
-- 
cgit v1.2.3-70-g09d2