cleanup. bringing in ncollider

src/main.rs

@@ -24,7 +24,6 @@ mod framework;
 mod geometry;
 mod light;
 mod render;
-mod runtime;
 
 /*
 
@@ -78,17 +77,6 @@ pub enum ShaderStage {
     Compute,
 }
 
-/*
-   window: winit::window::Window,
-   event_loop: EventLoop<()>,
-   instance: wgpu::Instance,
-   size: winit::dpi::PhysicalSize<u32>,
-   surface: wgpu::Surface,
-   adapter: wgpu::Adapter,
-   device: wgpu::Device,
-   queue: wgpu::Queue,
-*/
-
 // a component is any type that is 'static, sized, send and sync
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Position {
@@ -217,76 +205,9 @@ fn main() {
     // Load up the renderer (and the resources)
     let mut renderer = render::Renderer::init(window);
 
-    let untitled_mesh =
+    entity_loading(&mut world, &mut renderer);
-        renderer.load_mesh_to_buffer("./resources/monkey.obj");
-
-    // This could be used for relationships between entities...???
-    let light_entity: Entity = world.push((
-        cgmath::Point3 {
-            x: 7.0 as f32,
-            y: -5.0 as f32,
-            z: 10.0 as f32,
-        },
-        renderer.create_light(),
-    ));
-
-    let light_entity: Entity = world.push((
-        cgmath::Point3 {
-            x: -5.0 as f32,
-            y: 7.0 as f32,
-            z: 10.0 as f32,
-        },
-        renderer.create_light(),
-    ));
-
-    let offset = cgmath::vec3(2.0, 2.0, 2.0);
-    let transform = Decomposed {
-        disp: offset.clone(),
-        rot: Quaternion::from_axis_angle(offset.normalize(), Deg(50.0)),
-        scale: 1.0,
-    };
-
-    let mesh_entity: Entity = world.push((
-        Position {
-            x: 17.0,
-            y: 15.0,
-            z: 10.0,
-            mx: cgmath::Matrix4::from(transform),
-        },
-        untitled_mesh,
-        Color {
-            r: 1.0,
-            g: 0.5,
-            b: 0.5,
-            a: 1.0,
-        },
-    ));
-
-    let plane_mesh =
-        renderer.create_plane(7.0);
-
-    // let plane_entity: Entity = world.push((
-    //     Position {
-    //         x: 0.0,
-    //         y: 0.0,
-    //         z: 0.0,
-    //         mx:  cgmath::Matrix4::identity(),
-    //     },
-    //     plane_mesh,
-    //     Color {
-    //         r: 1.0,
-    //         g: 0.5,
-    //         b: 0.5,
-    //         a: 1.0,
-    //     },
-    // ));
-
-
-    // Init, this wants the references to the buffers...
-    let mut runtime = runtime::Runtime::init();
 
     let mut resources = Resources::default();
-    resources.insert(runtime);
     resources.insert(renderer);
 
     // This is just an winit event loop
@@ -372,3 +293,72 @@ fn main() {
         }
     });
 }
+
+
+pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
+
+    let untitled_mesh =
+        renderer.load_mesh_to_buffer("./resources/monkey.obj");
+
+    // This could be used for relationships between entities...???
+    let light_entity: Entity = world.push((
+        cgmath::Point3 {
+            x: 7.0 as f32,
+            y: -5.0 as f32,
+            z: 10.0 as f32,
+        },
+        renderer.create_light(),
+    ));
+
+    let light_entity: Entity = world.push((
+        cgmath::Point3 {
+            x: -5.0 as f32,
+            y: 7.0 as f32,
+            z: 10.0 as f32,
+        },
+        renderer.create_light(),
+    ));
+
+    let offset = cgmath::vec3(2.0, 2.0, 2.0);
+    let transform = Decomposed {
+        disp: offset.clone(),
+        rot: Quaternion::from_axis_angle(offset.normalize(), Deg(50.0)),
+        scale: 1.0,
+    };
+
+    let mesh_entity: Entity = world.push((
+        Position {
+            x: 17.0,
+            y: 15.0,
+            z: 10.0,
+            mx: cgmath::Matrix4::from(transform),
+        },
+        untitled_mesh,
+        Color {
+            r: 1.0,
+            g: 0.5,
+            b: 0.5,
+            a: 1.0,
+        },
+    ));
+
+    let plane_mesh =
+        renderer.create_plane(7.0);
+
+    let plane_entity: Entity = world.push((
+        Position {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+            mx:  cgmath::Matrix4::identity(),
+        },
+        plane_mesh,
+        Color {
+            r: 1.0,
+            g: 0.5,
+            b: 0.5,
+            a: 1.0,
+        },
+    ));
+
+}

src/render.rs

@@ -118,8 +118,8 @@ pub fn render_test(world: &mut SubWorld, #[resource] renderer: &mut Renderer) {
 
     // Update the entity uniforms
     for (pos, mesh, color) in query.iter_mut(world) {
-        let rotation = cgmath::Matrix4::from_angle_x(cgmath::Deg(2.0));
+        // let rotation = cgmath::Matrix4::from_angle_x(cgmath::Deg(2.0));
-        pos.mx = pos.mx * rotation;
+        // pos.mx = pos.mx * rotation;
 
         let data = EntityUniforms {
             model: pos.mx.into(),
@@ -138,7 +138,7 @@ pub fn render_test(world: &mut SubWorld, #[resource] renderer: &mut Renderer) {
     }
 
     if renderer.lights_are_dirty {
-        //renderer.lights_are_dirty = false;
+        renderer.lights_are_dirty = false;
         let mut query = <(&mut DirectionalLight, &mut Point3<f32>)>::query();
         for (i, (light, pos)) in query.iter_mut(world).enumerate() {
             renderer.queue.write_buffer(

src/runtime.rs

@@ -1,199 +0,0 @@
-use std::rc::Rc;
-
-use bytemuck::__core::mem;
-use bytemuck::__core::num::NonZeroU32;
-use cgmath::{Decomposed, Deg, InnerSpace, Quaternion, Rotation3, SquareMatrix};
-
-use crate::render::EntityUniforms;
-use crate::DirectionalLight;
-
-/*
-
-This will eventually be within an ECS...
-
-So I will probably take the same approach that I did for tracer and have meta-data for rendering
-held by the ECS, and a render system which will cycle through them and render
-
- */
-
-struct Entity {
-    mx_world: cgmath::Matrix4<f32>,
-    rotation_speed: f32,
-    color: wgpu::Color,
-
-    index_count: usize,
-    bind_group: wgpu::BindGroup,
-    // This is a little weird to have in the entity isn't it?
-
-    // uniform buf is tough...
-    uniform_buf: wgpu::Buffer,
-    vertex_buf: Rc<wgpu::Buffer>,
-    index_buf: Rc<wgpu::Buffer>,
-}
-
-pub struct Runtime {
-    entities: Vec<Entity>,
-    // This is going to be ECS'd
-    lights: Vec<DirectionalLight>, // ECS
-}
-
-impl Runtime {
-    pub fn init(
-       // sc_desc: &wgpu::SwapChainDescriptor,
-    //    device: &wgpu::Device,
-    //    _queue: &wgpu::Queue,
-    ) -> Self
-    {
-
-        // https://sotrh.github.io/learn-wgpu/beginner/tutorial5-textures/#the-bindgroup
-        // It appears like bindgroups are the shader input definitions
-        /*
-            But it is defined in multiples places...
-
-            ` `
-
-            one of these in each pass
-            let bind_group_layout =
-                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                    entries: &[
-                        wgpu::BindGroupLayoutEntry {
-
-
-
-            The entities have one
-
-            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                layout: &local_bind_group_layout,
-                entries: &[wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::Buffer(plane_uniform_buf.slice(..)),
-                }],
-                label: None,
-            });
-        */
-
-        // Defines the Uniform buffer for the Vertex and Fragment shaders
-        // let local_bind_group_layout =
-        //     device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-        //         entries: &[wgpu::BindGroupLayoutEntry {
-        //             binding: 0,
-        //             visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
-        //             ty: wgpu::BindingType::UniformBuffer {
-        //                 dynamic: false,
-        //                 min_binding_size: wgpu::BufferSize::new(
-        //                     mem::size_of::<EntityUniforms>() as _
-        //                 ),
-        //             },
-        //             count: None,
-        //         }],
-        //         label: None,
-        //     });
-
-
-        let mut entities = Vec::default();
-
-        // entities.push(Entity {
-        //     mx_world: cgmath::Matrix4::identity(),
-        //     rotation_speed: 0.0,
-        //     color: wgpu::Color::WHITE,
-        //     vertex_buf: Rc::new(plane_vertex_buf),
-        //     index_buf: Rc::new(plane_index_buf),
-        //     index_count: plane_index_data.len(),
-        //     bind_group: device.create_bind_group(&wgpu::BindGroupDescriptor {
-        //         layout: &local_bind_group_layout,
-        //         entries: &[wgpu::BindGroupEntry {
-        //             binding: 0,
-        //             resource: wgpu::BindingResource::Buffer(plane_uniform_buf.slice(..)),
-        //         }],
-        //         label: None,
-        //     }),
-        //     uniform_buf: plane_uniform_buf,
-        // });
-
-
-        struct CubeDesc {
-            offset: cgmath::Vector3<f32>,
-            angle: f32,
-            scale: f32,
-            rotation: f32,
-        }
-
-        let cube_descs = [
-            CubeDesc {
-                offset: cgmath::vec3(-2.0, -2.0, 2.0),
-                angle: 10.0,
-                scale: 0.7,
-                rotation: 1.5,
-            },
-        ];
-
-
-        // for cube in &cube_descs {
-        //     let transform = Decomposed {
-        //         disp: cube.offset.clone(),
-        //         rot: Quaternion::from_axis_angle(cube.offset.normalize(), Deg(cube.angle)),
-        //         scale: cube.scale,
-        //     };
-        //     let uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
-        //         label: None,
-        //         size: entity_uniform_size,
-        //         usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
-        //         mapped_at_creation: false,
-        //     });
-        //     entities.push(Entity {
-        //         mx_world: cgmath::Matrix4::from(transform),
-        //         rotation_speed: cube.rotation,
-        //         color: wgpu::Color::GREEN,
-        //         vertex_buf: Rc::clone(&cube_vertex_buf),
-        //         index_buf: Rc::clone(&cube_index_buf),
-        //         index_count: cube_index_data.len(),
-        //         bind_group: device.create_bind_group(&wgpu::BindGroupDescriptor {
-        //             layout: &local_bind_group_layout,
-        //             entries: &[wgpu::BindGroupEntry {
-        //                 binding: 0,
-        //                 resource: wgpu::BindingResource::Buffer(uniform_buf.slice(..)),
-        //             }],
-        //             label: None,
-        //         }),
-        //         uniform_buf,
-        //     });
-        //}
-
-// Create other resources
-
-// This is just metadata we hold for the lights. We can hold onto this
-        let lights = vec![
-            // Light {
-            //     pos: cgmath::Point3::new(7.0, -5.0, 10.0),
-            //     color: wgpu::Color {
-            //         r: 0.5,
-            //         g: 1.0,
-            //         b: 0.5,
-            //         a: 1.0,
-            //     },
-            //     fov: 60.0,
-            //     depth: 1.0..20.0,
-            // },
-            // Light {
-            //     pos: cgmath::Point3::new(-5.0, 7.0, 10.0),
-            //     color: wgpu::Color {
-            //         r: 1.0,
-            //         g: 0.5,
-            //         b: 0.5,
-            //         a: 1.0,
-            //     },
-            //     fov: 45.0,
-            //     depth: 1.0..20.0,
-            // },
-        ];
-
-        Runtime {
-            entities,
-            lights,
-        }
-    }
-
-    pub fn update(&mut self, _event: winit::event::WindowEvent) {
-        //empty
-    }
-}