Upgrade glTF loader + three-axis model scales

editor/Cargo.toml

@@ -8,7 +8,8 @@ bytemuck = "^1.0"
 crossbeam-channel = "^0.5"
 cyborg = { path = "../", features = ["legion"] }
 egui = "0.18"
-egui-winit = "0.18.0"
+egui-gizmo = "0.7"
+egui-winit = "0.18"
 egui_wgpu_backend = "0.18.0"
 glam = { version = "0.20", features = ["serde"] }
 gltf = { version = "1.0", features = ["utils"] }

editor/src/import.rs

@@ -36,33 +36,36 @@ pub fn load_stl(path: std::path::PathBuf) -> model::Model {
 }
 
 pub fn load_gltf(path: std::path::PathBuf) -> model::Model {
-    use gltf::*;
-
     let name = path.file_name().map(|v| v.to_string_lossy().to_string());
-    let mut file = std::fs::File::open(path).unwrap();
-    let model = Gltf::from_reader(&mut file).unwrap();
+    let (document, buffers, _images) = gltf::import(path).unwrap();
 
-    GltfLoader::load(name, &model)
+    let buffers = buffers.into_iter().map(|v| v.to_vec()).collect();
+
+    let loader = GltfLoader {
+        name,
+        document,
+        buffers,
+    };
+
+    loader.load()
 }
 
-pub struct GltfLoader<'a> {
-    pub model: &'a gltf::Gltf,
+pub struct GltfLoader {
+    pub name: Option<String>,
+    pub document: gltf::Document,
     pub buffers: Vec<Vec<u8>>,
 }
 
-impl<'a> GltfLoader<'a> {
-    pub fn load(name: Option<String>, model: &'a gltf::Gltf) -> model::Model {
-        let buffers = Self::load_buffers(model);
-        let mut loader = Self { model, buffers };
-
+impl GltfLoader {
+    pub fn load(mut self) -> model::Model {
         let mut model = model::Model {
-            name,
+            name: self.name.clone(),
             objects: vec![],
         };
 
-        for scene in loader.model.scenes() {
+        for scene in self.document.scenes() {
             for node in scene.nodes() {
-                model.objects.push(loader.load_node(node));
+                model.objects.push(self.load_node(node, glam::Vec3::ONE));
             }
         }
 
@@ -82,8 +85,20 @@ impl<'a> GltfLoader<'a> {
         buffer_data
     }
 
-    pub fn load_node(&mut self, node: gltf::Node) -> model::Object {
-        let transform = model::Transform::default();
+    pub fn load_node(&self, node: gltf::Node, parent_scale: glam::Vec3) -> model::Object {
+        let (translation, orientation, scale) = node.transform().decomposed();
+
+        let orientation = glam::Quat::from_array(orientation);
+        let rotation = orientation.to_euler(glam::EulerRot::XYZ);
+
+        let scale: glam::Vec3 = scale.into();
+        let scale = scale * parent_scale;
+
+        let transform = model::Transform {
+            position: translation.into(),
+            rotation: rotation.into(),
+            scale,
+        };
 
         let mut object = model::Object {
             name: node.name().map(str::to_string),
@@ -99,13 +114,13 @@ impl<'a> GltfLoader<'a> {
         }
 
         for child in node.children() {
-            object.children.push(self.load_node(child));
+            object.children.push(self.load_node(child, scale));
         }
 
         object
     }
 
-    pub fn load_primitive_mesh(&mut self, primitive: gltf::Primitive) -> model::Mesh {
+    pub fn load_primitive_mesh(&self, primitive: gltf::Primitive) -> model::Mesh {
         use gltf::mesh::util::{ReadIndices, ReadTexCoords};
         if primitive.mode() != gltf::mesh::Mode::Triangles {
             panic!("glTF primitive must be triangle list");

editor/src/main.rs

@@ -7,7 +7,6 @@ use egui_winit::winit::{
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder,
 };
-use legion::EntityStore;
 use parking_lot::RwLock;
 use std::sync::Arc;
 
@@ -16,6 +15,7 @@ mod model;
 mod render;
 mod script;
 mod ui;
+mod world;
 
 struct Application {
     window: winit::window::Window,
@@ -29,9 +29,9 @@ struct Application {
     egui_rp: EguiRenderPass,
     ui: ui::UserInterface,
     viewport: ui::ViewportWidget,
-    render_state: Arc<RwLock<render::RenderState>>,
+    world: Arc<RwLock<world::World>>,
+    render_state: render::RenderState,
     file_receiver: crossbeam_channel::Receiver<ui::FileEvent>,
-    objects: Vec<ui::ObjectWidget>,
 }
 
 impl Application {
@@ -73,9 +73,18 @@ impl Application {
         let egui_state = egui_winit::State::new(4096, &window);
         let egui_ctx = egui::Context::default();
         let mut egui_rp = egui_wgpu_backend::RenderPass::new(&device, config.format, 1);
-        let render_state =
-            render::RenderState::new(device.clone(), queue.clone(), config.format, &mut egui_rp);
-        let viewport_texture = render_state
+
+        let mut world = world::World::new();
+
+        let render_state = render::RenderState::new(
+            &mut world,
+            device.clone(),
+            queue.clone(),
+            config.format,
+            &mut egui_rp,
+        );
+
+        let viewport_texture = world
             .resources
             .get::<render::ViewportStore>()
             .unwrap()
@@ -94,11 +103,11 @@ impl Application {
             egui_state,
             egui_ctx,
             egui_rp,
+            world: Arc::new(RwLock::new(world)),
             ui: ui::UserInterface::new(file_sender),
             viewport: ui::ViewportWidget::new(viewport_texture),
-            render_state: Arc::new(RwLock::new(render_state)),
+            render_state,
             file_receiver,
-            objects: vec![],
         }
     }
 
@@ -115,14 +124,13 @@ impl Application {
                         ui::ImportKind::Gltf => import::load_gltf(path),
                     };
 
-                    let mut render_state = self.render_state.write();
-                    let loaded = render_state.load_model(&model);
+                    let mut world = self.world.write();
+                    let loaded = world.load_model(&model);
                     let transform = glam::Mat4::IDENTITY;
-                    let widgets = render_state.spawn_model(&loaded, &transform);
-                    self.objects.extend(widgets.into_iter());
-                },
+                    world.spawn_model(&loaded, &transform);
+                }
                 Ok(ui::FileEvent::LoadScript(path)) => {
-                    script::Script::new(&path, self.render_state.to_owned());
+                    script::Script::new(&path, self.world.to_owned());
                 }
                 Err(crossbeam_channel::TryRecvError::Empty) => break,
                 Err(crossbeam_channel::TryRecvError::Disconnected) => {
@@ -130,22 +138,9 @@ impl Application {
                 }
             }
         }
-
-        let mut render_state = self.render_state.write();
-        for object in self.objects.iter_mut() {
-            object.flush_dirty(|object| {
-                let transform = object.transform.to_mat4();
-                for entity in object.entities.iter() {
-                    render_state
-                        .world
-                        .entry_mut(*entity)
-                        .unwrap()
-                        .get_component_mut::<cyborg::scene::Transform>()
-                        .unwrap()
-                        .transform = transform;
-                }
-            });
-        }
+        
+        let mut world = self.world.write();
+        world.flush_dirty_objects();
     }
 
     pub fn on_resize(&mut self, new_size: PhysicalSize<u32>) {
@@ -168,15 +163,22 @@ impl Application {
                     puffin::profile_scope!("Draw egui");
                     let raw_input = self.egui_state.take_egui_input(&self.window);
                     self.egui_ctx.run(raw_input, |ctx| {
-                        self.ui.run(ctx, &mut self.viewport, &mut self.objects)
+                        let mut world = self.world.write();
+
+                        let mut resources = ui::UiResources {
+                            world: &mut world,
+                            viewport: &mut self.viewport,
+                        };
+
+                        self.ui.run(ctx, &mut resources);
                     })
                 };
 
                 {
                     puffin::profile_scope!("Main render");
-                    let mut render_state = self.render_state.write();
-                    render_state.update_viewport(&mut self.egui_rp, &mut self.viewport);
-                    render_state.render();
+                    let mut world = self.world.write();
+                    world.update_viewport(&mut self.egui_rp, &mut self.viewport);
+                    world.execute(&mut self.render_state.render_schedule);
                 }
 
                 puffin::profile_scope!("Render egui");

editor/src/model.rs

@@ -43,7 +43,7 @@ pub struct LoadedObject {
 pub struct Transform {
     pub position: glam::Vec3,
     pub rotation: glam::Vec3, // TODO support glam::Quat too
-    pub scale: f32,
+    pub scale: glam::Vec3,
 }
 
 impl Transform {
@@ -55,7 +55,7 @@ impl Transform {
             self.rotation[1],
             self.rotation[2],
         );
-        let scale = glam::Vec3::splat(self.scale);
+        let scale = self.scale;
         glam::Mat4::from_scale_rotation_translation(scale, rotation, translation)
     }
 }
@@ -65,7 +65,7 @@ impl Default for Transform {
         Self {
             position: glam::Vec3::ZERO,
             rotation: glam::Vec3::ZERO,
-            scale: 1.0,
+            scale: glam::Vec3::ONE,
         }
     }
 }

editor/src/render.rs

@@ -1,6 +1,7 @@
 use crate::model;
-use crate::ui::{ObjectWidget, ViewportWidget};
+use crate::ui::ViewportWidget;
 use crate::wgpu;
+use crate::world::World;
 use cyborg::camera::Camera;
 use cyborg::storage::mesh::MeshHandle;
 use cyborg::viewport::{Viewport, ViewportInfo, ViewportViews};
@@ -154,13 +155,12 @@ impl cyborg::legion::RenderCallbacks for ViewportStore {
 }
 
 pub struct RenderState {
-    pub world: legion::World,
-    pub resources: legion::Resources,
     pub render_schedule: legion::Schedule,
 }
 
 impl RenderState {
     pub fn new(
+        world: &mut World,
         device: Arc<wgpu::Device>,
         queue: Arc<wgpu::Queue>,
         output_format: wgpu::TextureFormat,
@@ -169,8 +169,8 @@ impl RenderState {
         use cyborg::scene::{DebugDrawList, DebugVertex};
         use cyborg::shader::{ShaderStore, ShaderWatcher};
 
-        let mut world = legion::World::default();
-        let mut resources = legion::Resources::default();
+        let resources = &mut world.resources;
+
         let viewport_store =
             ViewportStore::new(device.clone(), queue.clone(), output_format, render_pass);
 
@@ -200,7 +200,7 @@ impl RenderState {
         resources.insert(mesh_shaders);
 
         let mut render_schedule = legion::Schedule::builder();
-        cyborg::legion::build_renderer(viewport_store, &mut resources, &mut render_schedule);
+        cyborg::legion::build_renderer(viewport_store, resources, &mut render_schedule);
         let render_schedule = render_schedule.build();
 
         // make debug draw grid
@@ -242,13 +242,11 @@ impl RenderState {
             },
         ));
 
-        Self {
-            world,
-            resources,
-            render_schedule,
-        }
+        Self { render_schedule }
     }
+}
 
+impl World {
     pub fn update_viewport(
         &mut self,
         egui_rp: &mut egui_wgpu_backend::RenderPass,
@@ -277,11 +275,6 @@ impl RenderState {
         }
     }
 
-    pub fn render(&mut self) {
-        self.render_schedule
-            .execute(&mut self.world, &mut self.resources);
-    }
-
     pub fn load_model(&mut self, model: &model::Model) -> model::LoadedModel {
         model::LoadedModel {
             name: model.name.clone(),
@@ -339,49 +332,4 @@ impl RenderState {
 
         mesh_pass.get_mesh_pool().load(mesh).unwrap()
     }
-
-    pub fn spawn_model(
-        &mut self,
-        model: &model::LoadedModel,
-        transform: &glam::Mat4,
-    ) -> Vec<ObjectWidget> {
-        // TODO use model name?
-        let mut objects = Vec::new();
-        for object in model.objects.iter() {
-            objects.push(self.spawn_object(object, transform));
-        }
-
-        objects
-    }
-
-    pub fn spawn_object(
-        &mut self,
-        object: &model::LoadedObject,
-        root_transform: &glam::Mat4,
-    ) -> ObjectWidget {
-        let transform = cyborg::scene::Transform {
-            transform: *root_transform * object.transform.to_mat4(),
-        };
-
-        let mut entities = Vec::new();
-        for mesh in object.meshes.iter() {
-            let mesh = cyborg::scene::Mesh { mesh: *mesh };
-            let entity = self.world.push((mesh, transform.clone()));
-            entities.push(entity);
-        }
-
-        let mut children = Vec::new();
-        for child in object.children.iter() {
-            children.push(self.spawn_object(child, root_transform));
-        }
-
-        ObjectWidget {
-            name: object.name.clone(),
-            transform: object.transform.clone(),
-            entities,
-            children,
-            dirty: false,
-            children_dirty: false,
-        }
-    }
 }

editor/src/script.rs

@@ -1,5 +1,5 @@
 use crate::model::LoadedModel;
-use crate::render::RenderState;
+use crate::world::World;
 use mlua::{Lua, LuaSerdeExt, Result, Value};
 use parking_lot::RwLock;
 use serde::{Deserialize, Serialize};
@@ -10,7 +10,7 @@ impl mlua::UserData for LoadedModel {}
 
 pub struct ScriptData {
     root_path: PathBuf,
-    render_state: Arc<RwLock<RenderState>>,
+    world: Arc<RwLock<World>>,
 }
 
 #[derive(Copy, Clone, Debug, Deserialize, Serialize)]
@@ -31,7 +31,7 @@ impl Transform {
 fn load_gltf(lua: &Lua, filename: String) -> Result<LoadedModel> {
     let data = lua.app_data_ref::<ScriptData>().unwrap();
     let model = crate::import::load_gltf(data.root_path.join(filename).into());
-    let loaded = data.render_state.write().load_model(&model);
+    let loaded = data.world.write().load_model(&model);
     Ok(loaded)
 }
 
@@ -39,7 +39,7 @@ fn spawn_model(lua: &Lua, model: (LoadedModel, Value)) -> Result<()> {
     let data = lua.app_data_ref::<ScriptData>().unwrap();
     let transform: Transform = lua.from_value(model.1)?;
     let transform = transform.to_mat4();
-    data.render_state.write().spawn_model(&model.0, &transform);
+    data.world.write().spawn_model(&model.0, &transform);
     Ok(())
 }
 
@@ -48,12 +48,12 @@ pub struct Script {
 }
 
 impl Script {
-    pub fn new(file: &Path, render_state: Arc<RwLock<RenderState>>) -> Self {
+    pub fn new(file: &Path, world: Arc<RwLock<World>>) -> Self {
         let lua = Lua::new();
 
         let data = ScriptData {
             root_path: file.parent().unwrap().into(),
-            render_state,
+            world,
         };
 
         lua.set_app_data(data);

editor/src/ui.rs

@@ -1,8 +1,11 @@
-use crate::winit;
 use crossbeam_channel::Sender;
 use cyborg::camera::Flycam;
+use legion::Entity;
 use std::path::PathBuf;
 
+use crate::winit;
+use crate::world::{Object, World};
+
 #[derive(Clone, Debug)]
 pub enum FileEvent {
     Save,
@@ -23,6 +26,11 @@ pub enum Workspace {
     NodeEditor,
 }
 
+pub struct UiResources<'a> {
+    pub world: &'a mut World,
+    pub viewport: &'a mut ViewportWidget,
+}
+
 pub struct UserInterface {
     file_sender: Sender<FileEvent>,
     developer_mode: bool,
@@ -52,12 +60,7 @@ impl UserInterface {
         self.quit
     }
 
-    pub fn run(
-        &mut self,
-        ctx: &egui::Context,
-        viewport: &mut ViewportWidget,
-        objects: &mut [ObjectWidget],
-    ) {
+    pub fn run(&mut self, ctx: &egui::Context, resources: &mut UiResources) {
         egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
             egui::menu::bar(ui, |ui| self.ui_menu_bar(ui));
         });
@@ -98,7 +101,7 @@ impl UserInterface {
         }
 
         match self.workspace {
-            Workspace::Scene => self.ui_scene(ctx, viewport, objects),
+            Workspace::Scene => self.ui_scene(ctx, resources),
             Workspace::NodeEditor => {
                 egui::CentralPanel::default().show(ctx, |ui| self.ui_node_editor(ui));
             }
@@ -194,28 +197,65 @@ impl UserInterface {
         ui.selectable_value(&mut self.workspace, Workspace::NodeEditor, "Node Editor");
     }
 
-    pub fn ui_scene(
-        &mut self,
-        ctx: &egui::Context,
-        viewport: &mut ViewportWidget,
-        objects: &mut [ObjectWidget],
-    ) {
+    pub fn ui_scene(&mut self, ctx: &egui::Context, resources: &mut UiResources) {
         egui::SidePanel::left("objects_panel")
             .resizable(true)
-            .show(ctx, |ui| {
-                egui::ScrollArea::vertical().show(ui, |ui| {
-                    for (index, object) in objects.iter_mut().enumerate() {
-                        object.ui(index, ui);
-                    }
-                });
-            });
+            .show(ctx, |ui| self.ui_objects(ui, resources));
 
         egui::CentralPanel::default().show(ctx, |ui| {
-            ui.add(viewport);
+            resources.viewport.show(ui);
             ui.heading("Viewport");
         });
     }
 
+    pub fn ui_objects(&mut self, ui: &mut egui::Ui, resources: &mut UiResources) {
+        egui::ScrollArea::vertical().show(ui, |ui| {
+            let roots = resources.world.root_objects.to_owned();
+            for object in roots.into_iter() {
+                self.ui_object(ui, resources, object);
+            }
+        });
+    }
+
+    pub fn ui_object(
+        &mut self,
+        ui: &mut egui::Ui,
+        resources: &mut UiResources,
+        id: Entity,
+    ) -> bool {
+        let object: &mut Object = resources.world.get_component_mut(id);
+        let name = object
+            .name
+            .as_ref()
+            .unwrap_or(&"<unnamed>".into())
+            .to_owned();
+
+        let children = object.children.to_owned();
+        let mut any_dirty = false;
+
+        egui::CollapsingHeader::new(name)
+            .id_source(format!("child_{:?}", id))
+            .default_open(true)
+            .show(ui, |ui| {
+                let object: &mut Object = resources.world.get_component_mut(id);
+                object.ui(ui);
+
+                for child in children.into_iter() {
+                    if self.ui_object(ui, resources, child) {
+                        any_dirty = true;
+                    }
+                }
+            });
+
+        let object: &mut Object = resources.world.get_component_mut(id);
+
+        if any_dirty {
+            object.children_dirty = true;
+        }
+
+        object.dirty || any_dirty
+    }
+
     pub fn ui_node_editor(&mut self, ui: &mut egui::Ui) {
         ui.label("Node editor goes here!");
     }
@@ -260,6 +300,7 @@ pub struct ViewportWidget {
     pub flycam: Flycam,
     pub width: u32,
     pub height: u32,
+    pub dragging: bool,
 }
 
 impl ViewportWidget {
@@ -269,21 +310,39 @@ impl ViewportWidget {
             flycam: Flycam::new(0.002, 10.0, 0.25),
             width: 640,
             height: 480,
+            dragging: false,
         }
     }
-}
 
-impl egui::Widget for &mut ViewportWidget {
-    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
+    fn should_drag(
+        &self,
+        viewport: egui::Rect,
+        gizmo_active: bool,
+        pointer: &egui::PointerState,
+    ) -> bool {
+        if gizmo_active {
+            false
+        } else if !pointer.primary_down() {
+            false
+        } else if self.dragging {
+            true
+        } else if let Some(pos) = pointer.interact_pos() {
+            viewport.contains(pos)
+        } else {
+            false
+        }
+    }
+
+    fn show(&mut self, ui: &mut egui::Ui) {
         ui.style_mut().spacing.window_margin = egui::style::Margin::same(0.0);
         let rect = ui.max_rect();
-        let id = egui::Id::new("viewport_widget");
-        let sense = egui::Sense::click_and_drag();
-        let response = ui.interact(rect, id, sense);
 
         self.width = rect.width().round() as u32;
         self.height = rect.height().round() as u32;
 
+        self.flycam.resize(self.width, self.height);
+        self.flycam.update();
+
         use egui::{pos2, Color32, Mesh, Rect, Shape};
         let mut mesh = Mesh::with_texture(self.texture);
         let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
@@ -291,11 +350,22 @@ impl egui::Widget for &mut ViewportWidget {
         mesh.add_rect_with_uv(rect, uv, tint);
         ui.painter().add(Shape::mesh(mesh));
 
-        if response.dragged() {
-            let delta = response.drag_delta();
+        let gizmo = egui_gizmo::Gizmo::new("My gizmo")
+            .viewport(rect)
+            .view_matrix(self.flycam.get_view().to_cols_array_2d())
+            .projection_matrix(self.flycam.get_projection().to_cols_array_2d());
+
+        let gizmo = gizmo.interact(ui);
+
+        let input = ui.input();
+
+        self.dragging = self.should_drag(rect, gizmo.is_some(), &input.pointer);
+
+        if self.dragging {
+            let delta = input.pointer.delta();
             self.flycam.process_mouse(delta.x as f64, delta.y as f64);
 
-            for event in ui.input().events.iter() {
+            for event in input.events.iter() {
                 match event {
                     egui::Event::Key { key, pressed, .. } => {
                         use winit::event::{ElementState, VirtualKeyCode};
@@ -324,126 +394,8 @@ impl egui::Widget for &mut ViewportWidget {
                     _ => {}
                 }
             }
-        } else if response.drag_released() {
+        } else {
             self.flycam.defocus();
         }
-
-        self.flycam.resize(self.width, self.height);
-        self.flycam.update();
-
-        response
-    }
-}
-
-pub struct ObjectWidget {
-    pub name: Option<String>,
-    pub transform: crate::model::Transform,
-    pub entities: Vec<legion::Entity>,
-    pub children: Vec<ObjectWidget>,
-    pub dirty: bool,
-    pub children_dirty: bool,
-}
-
-impl ObjectWidget {
-    pub fn ui(&mut self, index: usize, ui: &mut egui::Ui) {
-        egui::CollapsingHeader::new(self.name.as_ref().unwrap_or(&"<unnamed>".into()))
-            .id_source(format!("child_{}", index))
-            .default_open(true)
-            .show(ui, |ui| {
-                self.ui_self(ui);
-
-                for (index, child) in self.children.iter_mut().enumerate() {
-                    child.ui(index, ui);
-                    if child.dirty || child.children_dirty {
-                        self.children_dirty = true;
-                    }
-                }
-            });
-    }
-
-    pub fn ui_self(&mut self, ui: &mut egui::Ui) {
-        egui::Grid::new("root_object")
-            .num_columns(4)
-            .striped(true)
-            .show(ui, |ui| {
-                ui.label("Position: ");
-                self.ui_position(ui);
-                ui.end_row();
-
-                ui.label("Rotation: ");
-                self.ui_rotation(ui);
-                ui.end_row();
-
-                ui.label("Scale: ");
-                self.ui_scale(ui);
-                ui.end_row();
-            });
-    }
-
-    pub fn ui_position(&mut self, ui: &mut egui::Ui) {
-        let speed = 0.1 * self.transform.scale;
-        if Self::ui_vec3(ui, speed, &mut self.transform.position) {
-            self.dirty = true;
-        }
-    }
-
-    pub fn ui_rotation(&mut self, ui: &mut egui::Ui) {
-        let axes = &mut self.transform.rotation;
-
-        if ui.drag_angle(&mut axes.x).changed() {
-            self.dirty = true;
-        }
-
-        if ui.drag_angle(&mut axes.y).changed() {
-            self.dirty = true;
-        }
-
-        if ui.drag_angle(&mut axes.z).changed() {
-            self.dirty = true;
-        }
-    }
-
-    pub fn ui_vec3(ui: &mut egui::Ui, speed: f32, vec3: &mut glam::Vec3) -> bool {
-        let x_drag = egui::DragValue::new(&mut vec3.x).speed(speed);
-        let dirty = ui.add(x_drag).changed();
-
-        let dirty = dirty || {
-            // For some reason, Rust complains if this isn't in a block
-            let y_drag = egui::DragValue::new(&mut vec3.y).speed(speed);
-            ui.add(y_drag).changed()
-        };
-
-        let z_drag = egui::DragValue::new(&mut vec3.z).speed(speed);
-        let dirty = dirty || ui.add(z_drag).changed();
-
-        dirty
-    }
-
-    pub fn ui_scale(&mut self, ui: &mut egui::Ui) {
-        let scale_speed = self.transform.scale * 0.01;
-        let drag = egui::DragValue::new(&mut self.transform.scale)
-            .clamp_range(0.0..=f32::INFINITY)
-            .speed(scale_speed);
-        if ui.add(drag).changed() {
-            self.dirty = true;
-        }
-    }
-
-    pub fn flush_dirty(&mut self, mut f: impl FnMut(&mut Self)) {
-        let mut stack = vec![self];
-        while let Some(parent) = stack.pop() {
-            if parent.dirty {
-                parent.dirty = false;
-                f(parent);
-            }
-
-            if parent.children_dirty {
-                parent.children_dirty = false;
-
-                for child in parent.children.iter_mut() {
-                    stack.push(child);
-                }
-            }
-        }
     }
 }

editor/src/world.rs

@@ -0,0 +1,191 @@
+use legion::Entity;
+
+use crate::model;
+
+use std::ops::{Deref, DerefMut};
+
+pub struct World {
+    pub world: legion::World,
+    pub resources: legion::Resources,
+    pub root_objects: Vec<Entity>,
+}
+
+impl Deref for World {
+    type Target = legion::World;
+
+    fn deref(&self) -> &legion::World {
+        &self.world
+    }
+}
+
+impl DerefMut for World {
+    fn deref_mut(&mut self) -> &mut legion::World {
+        &mut self.world
+    }
+}
+
+impl World {
+    pub fn new() -> Self {
+        Self {
+            world: Default::default(),
+            resources: Default::default(),
+            root_objects: vec![],
+        }
+    }
+
+    pub fn execute(&mut self, schedule: &mut legion::Schedule) {
+        schedule.execute(&mut self.world, &mut self.resources);
+    }
+
+    pub fn get_component_mut<T: 'static + Send + Sync>(&mut self, entity: Entity) -> &mut T {
+        self.entry(entity).unwrap().into_component_mut().unwrap()
+    }
+
+    pub fn spawn_model(&mut self, model: &model::LoadedModel, transform: &glam::Mat4) -> Entity {
+        let mut children = Vec::new();
+        for object in model.objects.iter() {
+            children.push(self.spawn_object(object, transform));
+        }
+
+        let root = self.world.push((Object {
+            name: model.name.to_owned(),
+            transform: model::Transform::default(),
+            entities: Default::default(),
+            children,
+            dirty: false,
+            children_dirty: false,
+        },));
+
+        self.root_objects.push(root);
+        root
+    }
+
+    pub fn spawn_object(
+        &mut self,
+        object: &model::LoadedObject,
+        root_transform: &glam::Mat4,
+    ) -> Entity {
+        let transform = cyborg::scene::Transform {
+            transform: *root_transform * object.transform.to_mat4(),
+        };
+
+        let mut entities = Vec::new();
+        for mesh in object.meshes.iter() {
+            let mesh = cyborg::scene::Mesh { mesh: *mesh };
+            let entity = self.world.push((mesh, transform.clone()));
+            entities.push(entity);
+        }
+
+        let mut children = Vec::new();
+        for child in object.children.iter() {
+            children.push(self.spawn_object(child, root_transform));
+        }
+
+        self.world.push((Object {
+            name: object.name.clone(),
+            transform: object.transform.clone(),
+            entities,
+            children,
+            dirty: false,
+            children_dirty: false,
+        },))
+    }
+
+    pub fn flush_dirty_objects(&mut self) {
+        let mut stack = self.root_objects.to_owned();
+        while let Some(parent) = stack.pop() {
+            let parent: &mut Object = self.get_component_mut(parent);
+
+            if parent.children_dirty {
+                parent.children_dirty = false;
+                stack.extend_from_slice(&parent.children);
+            }
+
+            if parent.dirty {
+                parent.dirty = false;
+
+                let mat4 = parent.transform.to_mat4();
+                for entity in parent.entities.to_owned().into_iter() {
+                    let transform: &mut cyborg::scene::Transform = self.get_component_mut(entity);
+                    transform.transform = mat4;
+                }
+            }
+        }
+    }
+}
+
+pub struct Object {
+    pub name: Option<String>,
+    pub transform: model::Transform,
+    pub entities: Vec<Entity>,
+    pub children: Vec<Entity>,
+    pub dirty: bool,
+    pub children_dirty: bool,
+}
+
+impl Object {
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        egui::Grid::new("root_object")
+            .num_columns(4)
+            .striped(true)
+            .show(ui, |ui| {
+                ui.label("Position: ");
+                self.ui_position(ui);
+                ui.end_row();
+
+                ui.label("Rotation: ");
+                self.ui_rotation(ui);
+                ui.end_row();
+
+                ui.label("Scale: ");
+                self.ui_scale(ui);
+                ui.end_row();
+            });
+    }
+
+    pub fn ui_position(&mut self, ui: &mut egui::Ui) {
+        let speed = 0.1 * self.transform.scale.min_element();
+        if Self::ui_vec3(ui, speed, &mut self.transform.position) {
+            self.dirty = true;
+        }
+    }
+
+    pub fn ui_rotation(&mut self, ui: &mut egui::Ui) {
+        let axes = &mut self.transform.rotation;
+
+        if ui.drag_angle(&mut axes.x).changed() {
+            self.dirty = true;
+        }
+
+        if ui.drag_angle(&mut axes.y).changed() {
+            self.dirty = true;
+        }
+
+        if ui.drag_angle(&mut axes.z).changed() {
+            self.dirty = true;
+        }
+    }
+
+    pub fn ui_vec3(ui: &mut egui::Ui, speed: f32, vec3: &mut glam::Vec3) -> bool {
+        let x_drag = egui::DragValue::new(&mut vec3.x).speed(speed);
+        let dirty = ui.add(x_drag).changed();
+
+        let dirty = dirty || {
+            // For some reason, Rust complains if this isn't in a block
+            let y_drag = egui::DragValue::new(&mut vec3.y).speed(speed);
+            ui.add(y_drag).changed()
+        };
+
+        let z_drag = egui::DragValue::new(&mut vec3.z).speed(speed);
+        let dirty = dirty || ui.add(z_drag).changed();
+
+        dirty
+    }
+
+    pub fn ui_scale(&mut self, ui: &mut egui::Ui) {
+        let speed = self.transform.scale.min_element() * 0.01;
+        if Self::ui_vec3(ui, speed, &mut self.transform.scale) {
+            self.dirty = true;
+        }
+    }
+}

src/camera.rs

@@ -233,16 +233,21 @@ impl Flycam {
     pub fn get_eye(&self) -> [f32; 4] {
         self.position.extend(0.0).to_array()
     }
-
-    pub fn get_vp(&self) -> [[f32; 4]; 4] {
+    
+    pub fn get_view(&self) -> glam::Mat4 {
         // view matrix is inverted camera pose (world space to camera space)
         let rotation = Mat4::from_quat(self.get_orientation().inverse());
         let translation = Mat4::from_translation(-self.position);
-        let view = rotation * translation;
-
-        // perspective projection
-        let proj = Mat4::perspective_rh_gl(self.fovy, self.aspect, self.znear, self.zfar);
+        rotation * translation
+    }
+    
+    pub fn get_projection(&self) -> glam::Mat4 {
+        Mat4::perspective_rh_gl(self.fovy, self.aspect, self.znear, self.zfar)
+    }
 
+    pub fn get_vp(&self) -> [[f32; 4]; 4] {
+        let view = self.get_view();
+        let proj = self.get_projection();
         let vp = proj * view;
         vp.to_cols_array_2d()
     }