1 files changed, 142 insertions, 0 deletions
diff --git a/src/tool/icon_tool.rs b/src/tool/icon_tool.rs
new file mode 100644
index 0000000..0ff1dc2
--- /dev/null
+++ b/src/tool/icon_tool.rs
@@ -0,0 +1,142 @@
+use crate::grid::snap_to_grid;
+use crate::map_data::MapData;
+use crate::math::Vec2;
+use crate::tool::Tool;
+use crate::transform::Transform;
+use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
+use raylib::core::texture::Texture2D;
+use raylib::ffi::{Color, KeyboardKey, MouseButton};
+use raylib::{RaylibHandle, RaylibThread};
+use ron::de::from_reader;
+use serde::Deserialize;
+use std::fs::{self, File};
+
+pub const ICON_DIR: &'static str = "assets/icons";
+
+#[derive(Deserialize)]
+struct IconInfo {
+    /// The position the icon should be anchored in pixels. This is the Vector it will be moved by
+    /// relative to the mouse pointer (to the left and up).
+    anchor: Vec2<f32>,
+    /// The scale of the icon as expressed in image pixels per real meter.
+    pixels_per_m: f32,
+}
+
+pub struct IconTool {
+    // TODO: support svg
+    /// The icon data, containing the image texture and the info for that image texture like the
+    /// scale the image actually has.
+    icon_data: Vec<(Texture2D, IconInfo)>,
+    /// The currently active icon, defined by its position in the Vec.
+    active_icon: usize,
+    current_icon_pos: Option<Vec2<f32>>,
+}
+
+impl IconTool {
+    pub fn new(rl: &mut RaylibHandle, rlt: &RaylibThread) -> Self {
+        /* Read all available icons from the icon directory. SVGs do not need any special scale
+         * file, but pixel-based file formats require a RON-file declaring what the scale of the
+         * picture is right beside them.
+         */
+        let mut image_files = Vec::new();
+        for entry in fs::read_dir(ICON_DIR).expect("Could not open icon directory") {
+            let entry = entry.expect("Failed to read file from icon directory");
+
+            // Ignore the RON-files for now and put the image files into the vec
+            if entry
+                .path()
+                .extension()
+                .expect("Entry does not have a file extension")
+                != "ron"
+            {
+                image_files.push(entry);
+            }
+        }
+
+        // Read the RON-files where it is necessary.
+        let mut icon_data = Vec::with_capacity(image_files.len());
+        for file in image_files {
+            // TODO: Handle svg
+
+            let texture = rl
+                .load_texture(
+                    rlt,
+                    file.path()
+                        .to_str()
+                        .expect("Unable to convert path to string."),
+                )
+                .expect("Could not read image file");
+
+            let mut file = file.path();
+            file.set_extension("ron");
+            let ron = File::open(file).expect("Could not read ron file for icon information.");
+            let icon_info: IconInfo =
+                from_reader(ron).expect("Could not parse icon info from reader.");
+
+            icon_data.push((texture, icon_info));
+        }
+
+        Self {
+            icon_data,
+            active_icon: 0,
+            current_icon_pos: None,
+        }
+    }
+}
+
+impl Tool for IconTool {
+    fn active_update(&mut self, map: &mut MapData, rl: &RaylibHandle, transform: &Transform) {
+        // Put the currently active icon to where it would be placed.
+        self.current_icon_pos = Some(snap_to_grid(
+            transform.point_px_to_m(rl.get_mouse_position().into()),
+            0.5,
+        ));
+
+        // Activate the next icon when pressing the icon tool key.
+        if rl.is_key_pressed(KeyboardKey::KEY_I) {
+            self.active_icon = (self.active_icon + 1) % self.icon_data.len();
+        }
+
+        // Handle placing the icon on the map
+        if rl.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
+            map.icons_mut()
+                .push((self.active_icon, self.current_icon_pos.unwrap()));
+        }
+    }
+
+    fn draw(&self, map: &MapData, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        // Draw all icons that have been placed on the map.
+        for (icon, pos) in map.icons() {
+            let (texture, info) = &self.icon_data[*icon];
+            rld.draw_texture_ex(
+                texture,
+                transform.point_m_to_px(*pos - (info.anchor / info.pixels_per_m)),
+                0.,
+                transform.pixels_per_m() / info.pixels_per_m,
+                Color {
+                    r: 255,
+                    g: 255,
+                    b: 255,
+                    a: 255,
+                },
+            );
+        }
+
+        // Draw the icon that would be placed
+        if let Some(current_icon_pos) = self.current_icon_pos {
+            let (texture, info) = &self.icon_data[self.active_icon];
+            rld.draw_texture_ex(
+                texture,
+                transform.point_m_to_px(current_icon_pos - (info.anchor / info.pixels_per_m)),
+                0.,
+                transform.pixels_per_m() / info.pixels_per_m,
+                Color {
+                    r: 120,
+                    g: 200,
+                    b: 120,
+                    a: 255,
+                },
+            );
+        }
+    }
+}