Generalized mutate

Author: Nercury

lesson-24-x/src/interface.rs

@@ -6,6 +6,8 @@ use render_gl::ColorBuffer;
 use render_gl::{DebugLines, RectMarker};
 use std::collections::HashMap;
 use std::collections::BTreeSet;
+use failure;
+use resources;
 
 struct ControlInfo {
     _id: Ix,
@@ -64,31 +66,34 @@ pub struct Interface {
     controls: HashMap<Ix, ControlInfo>,
     event_read_buffer: Vec<Effect>,
     flush_updates_set: BTreeSet<Ix>,
+
+    debug_lines: DebugLines,
 }
 
 impl Interface {
-    pub fn new(size: ElementSize) -> Interface {
+    pub fn new(gl: &gl::Gl, resources: &resources::Resources, size: ElementSize) -> Result<Interface, failure::Error> {
         let tree = Tree::new();
 
         let events = tree.events();
         let fill = tree.create_root(controls::Fill::new());
 
         fill.resize(size);
 
-        Interface {
+        Ok(Interface {
             fill,
             events,
             controls: HashMap::new(),
             event_read_buffer: Vec::new(),
             flush_updates_set: BTreeSet::new(),
-        }
+            debug_lines: DebugLines::new(gl, resources)?,
+        })
     }
 
     pub fn resize(&mut self, size: ElementSize) {
         self.fill.resize(size);
     }
 
-    fn process_events(&mut self, debug_lines: &DebugLines) {
+    fn process_events(&mut self) {
         self.events.drain_into(&mut self.event_read_buffer);
         self.flush_updates_set.clear();
 
@@ -113,12 +118,13 @@ impl Interface {
         }
 
         for id in &self.flush_updates_set {
+            let debug_lines = &self.debug_lines;
             self.controls.get_mut(id).map(|c| c.flush_updates(debug_lines));
         }
     }
 
-    pub fn update(&mut self, _delta: f32, debuglines: &DebugLines) {
-        self.process_events(debuglines)
+    pub fn update(&mut self, _delta: f32) {
+        self.process_events()
     }
 
     pub fn mouse_move(&mut self, _x: i32, _y: i32) {}
@@ -127,5 +133,7 @@ impl Interface {
 
     pub fn mouse_up(&mut self, _x: i32, _y: i32) {}
 
-    pub fn render(&mut self, _gl: &gl::Gl, _target: &ColorBuffer, _vp_matrix: &na::Matrix4<f32>) {}
+    pub fn render(&mut self, gl: &gl::Gl, target: &ColorBuffer, vp_matrix: &na::Matrix4<f32>) {
+        self.debug_lines.render(gl, target, vp_matrix);
+    }
 }

lesson-24-x/src/main.rs

@@ -78,10 +78,7 @@ fn run() -> Result<(), failure::Error> {
     viewport.set_used(&gl);
     color_buffer.set_clear_color(&gl, na::Vector3::new(0.3, 0.3, 0.5));
 
-    let mut debug_lines = render_gl::DebugLines::new(&gl, &resources)?;
-
-//    let mut iface = Interface::new(ui::ElementSize::Fixed { w: window_size.highdpi_width, h: window_size.highdpi_height });
-    let mut iface = Interface::new(ui::ElementSize::Fixed { w: viewport.w, h: viewport.h });
+    let mut iface = Interface::new(&gl, &resources, ui::ElementSize::Fixed { w: viewport.w, h: viewport.h })?;
 
     // main loop
 
@@ -104,31 +101,15 @@ fn run() -> Result<(), failure::Error> {
                     viewport.update_size(hdpi_w as i32, hdpi_h as i32);
                     viewport.set_used(&gl);
                     iface.resize(ui::ElementSize::Fixed { w: hdpi_w as i32, h: hdpi_h as i32 });
-//                    iface.resize(ui::ElementSize::Auto);
                 },
                 _ => (),
             };
-
-//            match event {
-//                sdl2::event::Event::KeyDown { scancode: Some(sdl2::keyboard::Scancode::C), .. } => {
-//                    side_cam = !side_cam;
-//                },
-//                sdl2::event::Event::KeyDown { scancode: Some(sdl2::keyboard::Scancode::I), .. } => {
-//                    debug_lines.toggle();
-//                },
-//                sdl2::event::Event::KeyDown { scancode: Some(sdl2::keyboard::Scancode::P), .. } => {
-//                    frame_profiler.toggle();
-//                    allocation_profiler.toggle();
-//                    gl_call_profiler.toggle();
-//                },
-//                _ => (),
-//            }
         }
 
         let delta = time.elapsed().as_fractional_secs() as f32;
         time = Instant::now();
 
-        iface.update(delta, &debug_lines);
+        iface.update(delta);
 
         unsafe {
             gl.Enable(gl::CULL_FACE);
@@ -146,7 +127,6 @@ fn run() -> Result<(), failure::Error> {
         let ui_matrix = na::Matrix4::new_nonuniform_scaling(&[1.0, -1.0, 1.0].into())
             * na::Matrix4::new_orthographic(left as f32, right as f32, bottom as f32, top as f32, -10.0, 10.0);
 
-        debug_lines.render(&gl, &color_buffer, &ui_matrix);
         iface.render(&gl, &color_buffer, &ui_matrix);
 
         while time.elapsed() < Duration::from_millis(12) {

lib/resources/src/backend/filesystem.rs

@@ -2,7 +2,6 @@ use std::path::{Path, PathBuf};
 use std::{io, fs};
 use backend::{Backend, BackendSyncPoint};
 use {ResourcePath, Error};
-use std::io::Read;
 
 pub struct FileSystem {
     root_path: PathBuf,

lib/ui/src/lib.rs

@@ -10,6 +10,10 @@ pub mod controls {
     pub struct Text;
 
     impl Element for Text {
+        fn inflate(&mut self, mut base: Base) {
+            base.enable_update(true);
+        }
+
         fn resize(&mut self, mut _base: Base, size: ElementSize) -> Option<ResolvedSize> {
             match size {
                 ElementSize::Auto => Some(ResolvedSize { w: 100, h: 60 }),
@@ -18,19 +22,7 @@ pub mod controls {
         }
     }
 
-    pub struct Button {
-        min_width: i32,
-        min_height: i32,
-    }
-
-    impl Button {
-        pub fn new() -> Button {
-            Button {
-                min_width: 50,
-                min_height: 30,
-            }
-        }
-    }
+    pub struct Button;
 
     impl Element for Button {
         fn inflate(&mut self, mut base: Base) {
@@ -57,12 +49,11 @@ pub mod controls {
 
     impl Element for Fill {
         fn inflate(&mut self, mut base: Base) {
-            base.add(Button::new());
-            base.add(Button::new());
+            base.add(Text);
+            base.add(Button);
         }
 
         fn resize(&mut self, mut base: Base, size: ElementSize) -> Option<ResolvedSize> {
-            println!("fill resize: size = {:?}", size);
             base.layout_vertical(size, 5)
         }
     }
@@ -87,14 +78,10 @@ pub enum Effect {
     Transform { id: Ix, absolute_transform: na::Projective3<f32> },
 }
 
-pub enum ResizeDecision {
-    AutoFromChildrenVertical,
-}
-
 pub trait Element {
 
-    fn inflate(&mut self, base: Base) {}
-    fn resize(&mut self, base: Base, size: ElementSize) -> Option<ResolvedSize>;
+    fn inflate(&mut self, _base: Base) {}
+    fn resize(&mut self, _base: Base, _size: ElementSize) -> Option<ResolvedSize>;
 
 }