1 files changed, 91 insertions, 0 deletions
diff --git a/src/client/map/icon_texture_manager.rs b/src/client/map/icon_texture_manager.rs
new file mode 100644
index 0000000..c6b7fea
--- /dev/null
+++ b/src/client/map/icon_texture_manager.rs
@@ -0,0 +1,91 @@
+//! Since the same icon may be used very often on a map, it becomes impracticalto let every icon have
+//! it's own texture data saved, which is why a texture manager type of struct is used for it instead.
+
+use crate::math::Vec2;
+use raylib::core::texture::Texture2D;
+use raylib::{RaylibHandle, RaylibThread};
+use ron::de::from_reader;
+use serde::Deserialize;
+use std::fs::{self, File};
+
+/// The directory containing all files related to icons.
+pub const ICON_DIR: &str = "assets/icons";
+
+#[derive(Deserialize)]
+pub(super) struct IconFileInfo {
+    /// 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).
+    pub anchor: Vec2<f64>,
+    /// The scale of the icon as expressed in image pixels per real meter.
+    pub pixels_per_m: f64,
+}
+
+/// Manager for all icon texture or rendering data.
+pub struct IconTextureManager {
+    texture_data: Vec<(Texture2D, IconFileInfo)>,
+}
+
+impl IconTextureManager {
+    /// Create a new icon manager. This loads all textures and information for icons that is needed
+    /// to draw them to the screen. Usually, there should be only one IconTextureManager, or at least one
+    /// manager per directory and program instance.
+    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 texture_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: IconFileInfo =
+                from_reader(ron).expect("Could not parse icon info from reader.");
+
+            texture_data.push((texture, icon_info));
+        }
+
+        Self { texture_data }
+    }
+
+    /// Get the textures needed to render an icon of type `icon_id`.
+    ///
+    /// # Panics
+    /// If the `icon_id` does not describe a valid icon (is out of bounds), there is no data to be
+    /// accessed and the function panics.
+    pub(super) fn get(&self, icon_id: usize) -> &(Texture2D, IconFileInfo) {
+        &self.texture_data[icon_id]
+    }
+
+    /// The number of icons registered in this texture manager.
+    pub fn num_icons(&self) -> usize {
+        self.texture_data.len()
+    }
+}