new proto

1 files changed, 15 insertions, 98 deletions

diff --git a/client/src/renderer.rs b/client/src/renderer.rs
index 35bc0ef..1cbc3cc 100644
--- a/client/src/renderer.rs
+++ b/client/src/renderer.rs
@@ -1,31 +1,22 @@
-use crate::part::{PartData, PartRenderer};
+use crate::{scene_prepare::ScenePreparer, scene_render::ScenePipeline};
 use anyhow::{Result, anyhow};
-use log::info;
+use log::{info, warn};
 use pollster::FutureExt;
-use std::collections::HashMap;
-use weareshared::{packets::Resource, tree::SceneTree};
+use weareshared::tree::SceneTree;
 use wgpu::{
-    Backends, BindGroup, BindGroupDescriptor, BindGroupLayoutDescriptor, BlendState, Color,
-    ColorTargetState, ColorWrites, CommandEncoderDescriptor, Device, DeviceDescriptor, Features,
-    FragmentState, FrontFace, Instance, InstanceDescriptor, Limits, LoadOp, MaintainBase,
-    MultisampleState, Operations, PipelineCompilationOptions, PipelineLayoutDescriptor,
-    PolygonMode, PowerPreference, PrimitiveState, PrimitiveTopology, Queue,
-    RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor,
-    RequestAdapterOptions, StoreOp, Surface, SurfaceConfiguration, TextureViewDescriptor,
-    VertexState, include_wgsl,
+    Backends, CommandEncoderDescriptor, Device, DeviceDescriptor, Features, Instance,
+    InstanceDescriptor, Limits, MaintainBase, PowerPreference, Queue, RequestAdapterOptions,
+    Surface, SurfaceConfiguration, TextureViewDescriptor,
 };
 use winit::window::Window;
 
 pub struct Renderer<'a> {
     surface: Surface<'a>,
-    pipeline: RenderPipeline,
-    bind_group: BindGroup,
     queue: Queue,
     device: Device,
     surface_configuration: SurfaceConfiguration,
-
-    prefabs_loading: HashMap<Resource, Vec<PartData>>,
-    prefabs: HashMap<Resource, Vec<PartRenderer>>,
+    scene_pipeline: ScenePipeline,
+    scene_prepare: ScenePreparer,
 }
 impl<'a> Renderer<'a> {
     pub fn new(window: &'a Window) -> Result<Self> {
@@ -60,65 +51,15 @@ impl<'a> Renderer<'a> {
             .get_default_config(&adapter, 256, 256)
             .ok_or(anyhow!("no default config"))?;
 
-        let module = device.create_shader_module(include_wgsl!("shader.wgsl"));
-
-        let bind_group_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[],
-            label: None,
-        });
-        let bind_group = device.create_bind_group(&BindGroupDescriptor {
-            label: None,
-            layout: &bind_group_layout,
-            entries: &[],
-        });
-        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
-            label: None,
-            bind_group_layouts: &[&bind_group_layout],
-            push_constant_ranges: &[],
-        });
-        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
-            label: None,
-            layout: Some(&pipeline_layout),
-            fragment: Some(FragmentState {
-                module: &module,
-                entry_point: Some("fs_main"),
-                targets: &[Some(ColorTargetState {
-                    blend: Some(BlendState::PREMULTIPLIED_ALPHA_BLENDING),
-                    format: surface_configuration.format,
-                    write_mask: ColorWrites::all(),
-                })],
-                compilation_options: PipelineCompilationOptions::default(),
-            }),
-            vertex: VertexState {
-                module: &module,
-                entry_point: Some("vs_main"),
-                buffers: &[],
-                compilation_options: PipelineCompilationOptions::default(),
-            },
-            primitive: PrimitiveState {
-                topology: PrimitiveTopology::TriangleList,
-                front_face: FrontFace::Ccw,
-                cull_mode: None, //Some(Face::Back),
-                polygon_mode: PolygonMode::Fill,
-                ..Default::default()
-            },
-            depth_stencil: Default::default(),
-            multisample: MultisampleState::default(),
-            multiview: None,
-            cache: None,
-        });
-
         surface.configure(&device, &surface_configuration);
 
         Ok(Self {
+            scene_pipeline: ScenePipeline::new(&device, surface_configuration.format),
+            scene_prepare: ScenePreparer::new(),
             surface,
-            pipeline,
-            bind_group,
             device,
             queue,
             surface_configuration,
-            prefabs: HashMap::new(),
-            prefabs_loading: HashMap::new(),
         })
     }
 
@@ -131,6 +72,9 @@ impl<'a> Renderer<'a> {
 
     pub fn draw(&mut self, scene: &SceneTree) -> Result<()> {
         let target = self.surface.get_current_texture()?;
+        if target.suboptimal {
+            warn!("suboptimal swapchain texture")
+        }
         let target_view = target
             .texture
             .create_view(&TextureViewDescriptor::default());
@@ -139,38 +83,11 @@ impl<'a> Renderer<'a> {
             .device
             .create_command_encoder(&CommandEncoderDescriptor { label: None });
 
-        {
-            let mut rpass = commands.begin_render_pass(&RenderPassDescriptor {
-                label: None,
-                color_attachments: &[Some(RenderPassColorAttachment {
-                    view: &target_view,
-                    resolve_target: None,
-                    ops: Operations {
-                        store: StoreOp::Store,
-                        load: LoadOp::Clear(Color::BLUE),
-                    },
-                })],
-                ..Default::default()
-            });
-
-            rpass.set_bind_group(0, &self.bind_group, &[]);
-            rpass.set_pipeline(&self.pipeline);
-            rpass.draw(0..3, 0..1);
-        }
-
-        for data in scene.objects.values() {
-            if let Some(ob) = self.prefabs.get(&data.res) {
-                for p in ob {
-                    p.draw(&mut commands, &target_view);
-                }
-            } else {
-                let loading = self.prefabs_loading.entry(data.res).or_default();
-                
-            }
-        }
+        self.scene_pipeline.draw(&mut commands, &target_view, scene);
 
         let i = self.queue.submit(Some(commands.finish()));
         self.device.poll(MaintainBase::WaitForSubmissionIndex(i));
+
         target.present();
 
         Ok(())