chore: merge 22

Author: mbienkowsk

src/app.rs

@@ -59,6 +59,7 @@ impl ApplicationHandler for App {
             load_floor(),
             self.base_models[0].clone(),
             Vec::new(),
+            3.0,
             [10.0, 10.0, 10.0],
         ));
 
@@ -250,7 +251,7 @@ impl App {
 
     fn calculate_transformations(&mut self) {
         let lsystem_config = self.get_current_lsystem_config();
-
+        let target_height = lsystem_config.fractal_height;
         let production_rules: HashMap<char, String> =
             lsystem_config.production_rules.iter().cloned().collect();
         let lsystem = LSystem::new(&lsystem_config.axiom, production_rules);
@@ -272,7 +273,7 @@ impl App {
         self.scene
             .as_mut()
             .unwrap()
-            .update_transformations(final_transformations);
+            .update_transformations(final_transformations, target_height);
         self.renderer
             .as_mut()
             .unwrap()

src/gui.rs

@@ -1,4 +1,4 @@
-use egui::Context;
+use egui::Ui;
 use egui_glium::EguiGlium;
 use egui_glium::egui_winit::egui::ViewportId;
 use glium::glutin::surface::WindowSurface;
@@ -24,15 +24,17 @@ pub struct LSystemConfig {
     pub production_rules: Vec<(char, String)>,
     pub n_iterations: u32,
     pub angle: f32,
+    pub fractal_height: f32, // TODO move elsewhere, now leaving here for convenience with App update logic
 }
 
 impl Default for LSystemConfig {
     fn default() -> Self {
         Self {
             axiom: "F".to_string(),
-            production_rules: vec![('F', "F[+F]F[-F]F".to_string())],
+            production_rules: vec![('F', "F[+F][&F][\\F]F[-F][^F][/F]F".to_string())],
             n_iterations: 3,
             angle: 25.0,
+            fractal_height: 3.0,
         }
     }
 }
@@ -148,101 +150,97 @@ impl GuiController {
     fn ui_control_panel(
         model_selection: &mut ModelSelection,
         shading_mode: &mut ShadingMode,
-        ctx: &Context,
+        ui: &mut Ui,
     ) {
-        egui::Window::new("Control panel").show(ctx, |ui| {
-            egui::ComboBox::from_label("Selected Model")
-                .selected_text(format!("{model_selection:?}"))
-                .show_ui(ui, |ui| {
-                    ui.selectable_value(model_selection, ModelSelection::Monkey, "Monkey");
-                    ui.selectable_value(model_selection, ModelSelection::Cylinder, "Cylinder");
-                });
+        egui::ComboBox::from_label("Selected Model")
+            .selected_text(format!("{model_selection:?}"))
+            .show_ui(ui, |ui| {
+                ui.selectable_value(model_selection, ModelSelection::Monkey, "Monkey");
+                ui.selectable_value(model_selection, ModelSelection::Cylinder, "Cylinder");
+            });
 
-            ui.separator();
-            ui.label("Shading Mode:");
-            ui.radio_value(shading_mode, ShadingMode::Flat, "Flat");
-            ui.radio_value(shading_mode, ShadingMode::Gouraud, "Gouraud");
-            ui.radio_value(shading_mode, ShadingMode::Phong, "Phong");
-            ui.separator();
-        });
+        ui.label("Shading Mode:");
+        ui.radio_value(shading_mode, ShadingMode::Flat, "Flat");
+        ui.radio_value(shading_mode, ShadingMode::Gouraud, "Gouraud");
+        ui.radio_value(shading_mode, ShadingMode::Phong, "Phong");
+    }
+
+    fn ui_fractal_height(fractal_height: &mut f32, ui: &mut Ui) {
+        ui.label("Fractal Height:");
+        ui.add(egui::Slider::new(fractal_height, 0.1..=5.0).text("Fractal Height"));
     }
 
     fn ui_tree_generation_config(
         tree_generation_config: &mut TreeGenerationConfig,
         requires_redraw: &mut bool,
-        ctx: &Context,
+        ui: &mut Ui,
     ) {
-        egui::Window::new("Tree Generation").show(ctx, |ui| {
-            ui.label("Number of trees");
-            ui.add(egui::Slider::new(
-                &mut tree_generation_config.num_trees,
-                1..=128,
-            ));
-            ui.label("X Bounds:");
-            ui.add(
-                egui::Slider::new(
-                    &mut tree_generation_config.xmin,
-                    -50..=tree_generation_config.xmax - 1,
-                )
-                .text("X Min"),
-            );
-            ui.add(
-                egui::Slider::new(
-                    &mut tree_generation_config.xmax,
-                    (tree_generation_config.xmin + 1)..=50,
-                )
-                .text("X Max"),
-            );
-            ui.label("Z Bounds:");
-            ui.add(
-                egui::Slider::new(
-                    &mut tree_generation_config.zmin,
-                    -50..=tree_generation_config.zmax - 1,
-                )
-                .text("Z Min"),
-            );
-            ui.add(
-                egui::Slider::new(
-                    &mut tree_generation_config.zmax,
-                    (tree_generation_config.zmin + 1)..=50,
-                )
-                .text("Z Max"),
-            );
-            if ui.add(egui::Button::new("Regenerate trees")).clicked() {
-                *requires_redraw = true;
-            }
-        });
+        ui.label("Number of trees");
+        ui.add(egui::Slider::new(
+            &mut tree_generation_config.num_trees,
+            1..=128,
+        ));
+        ui.label("X Bounds:");
+        ui.add(
+            egui::Slider::new(
+                &mut tree_generation_config.xmin,
+                -50..=tree_generation_config.xmax - 1,
+            )
+            .text("X Min"),
+        );
+        ui.add(
+            egui::Slider::new(
+                &mut tree_generation_config.xmax,
+                (tree_generation_config.xmin + 1)..=50,
+            )
+            .text("X Max"),
+        );
+        ui.label("Z Bounds:");
+        ui.add(
+            egui::Slider::new(
+                &mut tree_generation_config.zmin,
+                -50..=tree_generation_config.zmax - 1,
+            )
+            .text("Z Min"),
+        );
+        ui.add(
+            egui::Slider::new(
+                &mut tree_generation_config.zmax,
+                (tree_generation_config.zmin + 1)..=50,
+            )
+            .text("Z Max"),
+        );
+        if ui.add(egui::Button::new("Regenerate trees")).clicked() {
+            *requires_redraw = true;
+        }
     }
 
     // TODO make editable
-    fn ui_lsystem_config(lsystem_config: &mut LSystemConfig, ctx: &Context) {
-        egui::Window::new("LSystem Configuration").show(ctx, |ui| {
-            ui.add(
-                egui::Slider::new(&mut lsystem_config.n_iterations, 0..=6)
-                    .text("Number of Iterations"),
-            );
-            ui.add(egui::Slider::new(&mut lsystem_config.angle, 0.0..=45.0).text("Angle"));
-            ui.label(format!("{:?}", lsystem_config.axiom));
-            ui.label("Production Rules:");
-            for (i, (symbol, replacement)) in lsystem_config.production_rules.iter().enumerate() {
-                ui.horizontal(|ui| {
-                    ui.label(format!("{i}: {symbol} -> {replacement}"));
-                });
-            }
-        });
+    fn ui_lsystem_config(lsystem_config: &mut LSystemConfig, ui: &mut Ui) {
+        ui.label("LSystem Config:");
+        ui.add(
+            egui::Slider::new(&mut lsystem_config.n_iterations, 0..=6).text("Number of Iterations"),
+        );
+        ui.add(egui::Slider::new(&mut lsystem_config.angle, 0.0..=45.0).text("Angle"));
+        ui.label(format!("{:?}", lsystem_config.axiom));
+        ui.label("Production Rules:");
+        for (i, (symbol, replacement)) in lsystem_config.production_rules.iter().enumerate() {
+            ui.horizontal(|ui| {
+                ui.label(format!("{i}: {symbol} -> {replacement}"));
+            });
+        }
     }
 
     fn ui_color_panel(
         interpolation_color_low: &mut [f32; 3],
         interpolation_color_high: &mut [f32; 3],
-        ctx: &Context,
+        ui: &mut Ui,
     ) {
-        egui::Window::new("Color Configuration").show(ctx, |ui| {
-            ui.label("Color - low");
-            ui.color_edit_button_rgb(interpolation_color_low);
-            ui.label("Color - high");
-            ui.color_edit_button_rgb(interpolation_color_high);
-        });
+        ui.label("Color Interpolation:");
+        ui.label("Color - low");
+        ui.color_edit_button_rgb(interpolation_color_low);
+        ui.label("Color - high");
+        ui.color_edit_button_rgb(interpolation_color_high);
     }
 
     pub fn draw(&mut self, window: &Window, display: &Display<WindowSurface>, frame: &mut Frame) {
@@ -253,14 +251,20 @@ impl GuiController {
         let color_high = &mut self.interpolation_color_high;
 
         self.egui_glium.run(window, |ctx| {
-            GuiController::ui_control_panel(model_selection, shading_mode, ctx);
-            GuiController::ui_lsystem_config(lsystem_config, ctx);
-            GuiController::ui_color_panel(color_low, color_high, ctx);
-            GuiController::ui_tree_generation_config(
-                &mut self.tree_generation_config,
-                &mut self.requires_tree_regeneration,
-                ctx,
-            );
+            egui::Window::new("Control panel").show(ctx, |ui| {
+                GuiController::ui_control_panel(model_selection, shading_mode, ui);
+                GuiController::ui_fractal_height(&mut lsystem_config.fractal_height, ui);
+                ui.separator();
+                GuiController::ui_lsystem_config(lsystem_config, ui);
+                ui.separator();
+                GuiController::ui_color_panel(color_low, color_high, ui);
+                ui.separator();
+                GuiController::ui_tree_generation_config(
+                    &mut self.tree_generation_config,
+                    &mut self.requires_tree_regeneration,
+                    ui,
+                );
+            });
         });
         self.egui_glium.paint(display, frame);
     }

src/lsystem.rs

@@ -6,7 +6,6 @@ pub struct LSystem {
 }
 
 impl LSystem {
-    // TODO: restrict input to a predefined alphabet?
     pub fn new(axiom: &str, production_rules: HashMap<char, String>) -> Self {
         Self {
             axiom: axiom.to_string(),

src/model_loader.rs

@@ -25,10 +25,10 @@ fn load_obj_file(path: &str) -> Model3D {
         "Expected exactly one material in material file for {path}"
     );
 
-    let model = models.first().expect("Expected model").clone();
+    let geometry = models.first().expect("Expected model").clone();
     let material = materials.first().expect("Expected material").clone();
 
-    Model3D { geometry: model, material }
+    Model3D { geometry, material }
 }
 
 pub fn load_monkey() -> Model3D {

src/renderer.rs

@@ -91,8 +91,6 @@ impl Renderer {
         let (interpolation_color_low, interpolation_color_high) =
             self.gui.get_interpolation_colors();
 
-        let fractal_total_height = scene.fractal_total_height();
-
         if !scene.transformations().is_empty() {
             let instance_data: Vec<InstanceData> = scene
                 .transformations()
@@ -111,7 +109,7 @@ impl Renderer {
                 view_parameters,
                 *scene.light_position(),
                 shading_mode,
-                fractal_total_height,
+                scene.target_height(),
                 interpolation_color_low,
                 interpolation_color_high,
                 ColorMode::Interpolated,

src/scene.rs

@@ -6,6 +6,7 @@ pub struct Scene {
     floor: Model3D,
     fractal_base: Model3D,
     transformations: Vec<Vec<Mat4>>,
+    target_height: f32,
     light_position: [f32; 3],
 }
 
@@ -14,12 +15,14 @@ impl Scene {
         floor: Model3D,
         fractal_base: Model3D,
         transformations: Vec<Vec<Mat4>>,
+        target_height: f32,
         light_position: [f32; 3],
     ) -> Self {
         Self {
             floor,
             fractal_base,
             transformations,
+            target_height,
             light_position,
         }
     }
@@ -36,12 +39,22 @@ impl Scene {
         &self.transformations
     }
 
+    pub fn target_height(&self) -> f32 {
+        self.target_height
+    }
+
     pub fn light_position(&self) -> &[f32; 3] {
         &self.light_position
     }
 
-    pub fn update_transformations(&mut self, transformations: Vec<Vec<Mat4>>) {
-        self.transformations = transformations;
+    pub fn update_transformations(&mut self, transformations: Vec<Vec<Mat4>>, target_height: f32) {
+        let scaled_transformations = Self::scale_transformations_to_height(
+            transformations,
+            target_height,
+            &self.fractal_base.geometry,
+        );
+        self.transformations = scaled_transformations;
+        self.target_height = target_height;
     }
 
     pub fn set_fractal_base(&mut self, model: Model3D) {
@@ -58,19 +71,38 @@ impl Scene {
             .fold(f32::NEG_INFINITY, f32::max)
     }
 
-    pub fn fractal_total_height(&self) -> f32 {
-        if self.transformations.is_empty() {
+    fn fractal_total_height(base: &Model, transformations: &[Vec<Mat4>]) -> f32 {
+        if transformations.is_empty() {
             return 0.0;
         }
 
-        let model_height = Self::model_max_local_y(&self.fractal_base.geometry);
+        let model_height = Self::model_max_local_y(base);
         let up_vector = Vec4::new(0.0, model_height, 0.0, 1.0);
 
-        self.transformations
-            .first()
-            .expect("Empty case was handled above")
+        transformations
             .iter()
-            .map(|mat| (mat * up_vector)[1])
+            .flat_map(|mat_list| mat_list.iter().map(|mat| (mat * up_vector)[1]))
             .fold(f32::NEG_INFINITY, f32::max)
     }
+
+    fn scale_transformations_to_height(
+        transformations: Vec<Vec<Mat4>>,
+        target_height: f32,
+        base_model: &Model,
+    ) -> Vec<Vec<Mat4>> {
+        let current_height = Self::fractal_total_height(base_model, &transformations);
+        if current_height == 0.0 {
+            return transformations;
+        }
+        let scale_factor = target_height / current_height;
+        let scale_matrix = glm::scale(
+            &Mat4::identity(),
+            &glm::vec3(scale_factor, scale_factor, scale_factor),
+        );
+
+        transformations
+            .into_iter()
+            .map(|mat_list| mat_list.into_iter().map(|mat| scale_matrix * mat).collect())
+            .collect()
+    }
 }