Merge pull request #86 from LeagueToolkit/feat/ltk_mapgeo

feat(ltk_mapgeo): implement mapgeo parsing

Author: Crauzer

crates/ltk_io_ext/src/reader.rs

@@ -24,13 +24,20 @@ pub trait ReaderExt: Read {
         Ok(std::str::from_utf8(&buf[..i])?.to_string())
     }
 
-    fn read_len_prefixed_string<T: ByteOrder>(&mut self) -> ReaderResult<String> {
+    fn read_sized_string_u16<T: ByteOrder>(&mut self) -> ReaderResult<String> {
         let len = self.read_u16::<T>()?;
         let mut buf = vec![0; len as _];
         self.read_exact(&mut buf)?;
         Ok(String::from_utf8(buf)?)
     }
 
+    fn read_sized_string_u32<T: ByteOrder>(&mut self) -> ReaderResult<String> {
+        let len = self.read_u32::<T>()?;
+        let mut buf = vec![0; len as _];
+        self.read_exact(&mut buf)?;
+        Ok(String::from_utf8(buf)?)
+    }
+
     fn read_str_until_nul(&mut self) -> io::Result<String> {
         let mut s = String::new();
         loop {

crates/ltk_mapgeo/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "ltk_mapgeo"
+version = "0.1.0"
+edition = "2021"
+description = "Map Geometry (.mapgeo) parsing for League Toolkit"
+license = "MIT OR Apache-2.0"
+readme = "../../README.md"
+
+[dependencies]
+byteorder = { workspace = true }
+bitflags = { workspace = true }
+thiserror = { workspace = true }
+glam = { workspace = true }
+
+ltk_io_ext = { version = "0.3.4", path = "../ltk_io_ext" }
+ltk_primitives = { version = "0.3.0", path = "../ltk_primitives" }
+ltk_mesh = { version = "0.3.0", path = "../ltk_mesh" }
+
+[dev-dependencies]

crates/ltk_mapgeo/src/asset.rs

@@ -0,0 +1,206 @@
+//! Environment asset definition
+
+use ltk_mesh::mem::{IndexBuffer, VertexBuffer};
+
+use crate::{BucketedGeometry, EnvironmentMesh, PlanarReflector, ShaderTextureOverride};
+
+/// An environment asset contains all geometry data for a League of Legends map.
+///
+/// This is the primary type for working with `.mapgeo` files. It contains:
+/// - Environment meshes (renderable geometry)
+/// - Shared vertex and index buffers
+/// - Bucketed geometry for spatial queries
+/// - Planar reflectors for reflection rendering
+///
+/// # Buffer Sharing
+///
+/// Multiple meshes can reference the same vertex/index buffers. The asset owns
+/// all buffers, and meshes store indices into these buffer arrays.
+///
+/// # Example
+///
+/// ```ignore
+/// use ltk_mapgeo::EnvironmentAsset;
+/// use std::fs::File;
+///
+/// let mut file = File::open("base.mapgeo")?;
+/// let asset = EnvironmentAsset::from_reader(&mut file)?;
+///
+/// for mesh in asset.meshes() {
+///     println!("Mesh: {} (material: {})", mesh.name(), mesh.material_name());
+///     
+///     // Access the mesh's vertex buffer
+///     let vb_id = mesh.vertex_buffer_ids()[0];
+///     let vertex_buffer = &asset.vertex_buffers()[vb_id];
+///     println!("  Vertices: {}", vertex_buffer.count());
+/// }
+/// ```
+#[derive(Debug)]
+pub struct EnvironmentAsset {
+    /// Shader texture overrides (global sampler replacements)
+    shader_texture_overrides: Vec<ShaderTextureOverride>,
+
+    /// Environment meshes (renderable geometry)
+    meshes: Vec<EnvironmentMesh>,
+
+    /// Bucketed geometry scene graphs (spatial acceleration)
+    scene_graphs: Vec<BucketedGeometry>,
+
+    /// Planar reflectors
+    planar_reflectors: Vec<PlanarReflector>,
+
+    /// Shared vertex buffers (meshes reference by index)
+    vertex_buffers: Vec<VertexBuffer>,
+
+    /// Shared index buffers (meshes reference by index)
+    index_buffers: Vec<IndexBuffer<u16>>,
+}
+
+impl EnvironmentAsset {
+    /// Creates a new environment asset builder
+    pub(crate) fn builder() -> EnvironmentAssetBuilder {
+        EnvironmentAssetBuilder::default()
+    }
+
+    /// The shader texture overrides
+    #[inline]
+    pub fn shader_texture_overrides(&self) -> &[ShaderTextureOverride] {
+        &self.shader_texture_overrides
+    }
+
+    /// The environment meshes
+    #[inline]
+    pub fn meshes(&self) -> &[EnvironmentMesh] {
+        &self.meshes
+    }
+
+    /// The bucketed geometry scene graphs
+    #[inline]
+    pub fn scene_graphs(&self) -> &[BucketedGeometry] {
+        &self.scene_graphs
+    }
+
+    /// The planar reflectors
+    #[inline]
+    pub fn planar_reflectors(&self) -> &[PlanarReflector] {
+        &self.planar_reflectors
+    }
+
+    /// The shared vertex buffers
+    #[inline]
+    pub fn vertex_buffers(&self) -> &[VertexBuffer] {
+        &self.vertex_buffers
+    }
+
+    /// The shared index buffers
+    #[inline]
+    pub fn index_buffers(&self) -> &[IndexBuffer<u16>] {
+        &self.index_buffers
+    }
+
+    /// Gets a vertex buffer by index
+    #[inline]
+    pub fn vertex_buffer(&self, index: usize) -> Option<&VertexBuffer> {
+        self.vertex_buffers.get(index)
+    }
+
+    /// Gets an index buffer by index
+    #[inline]
+    pub fn index_buffer(&self, index: usize) -> Option<&IndexBuffer<u16>> {
+        self.index_buffers.get(index)
+    }
+
+    /// Returns the total number of meshes
+    #[inline]
+    pub fn mesh_count(&self) -> usize {
+        self.meshes.len()
+    }
+
+    /// Returns the total number of vertex buffers
+    #[inline]
+    pub fn vertex_buffer_count(&self) -> usize {
+        self.vertex_buffers.len()
+    }
+
+    /// Returns the total number of index buffers
+    #[inline]
+    pub fn index_buffer_count(&self) -> usize {
+        self.index_buffers.len()
+    }
+
+    /// Finds a mesh by name
+    pub fn find_mesh(&self, name: &str) -> Option<&EnvironmentMesh> {
+        self.meshes.iter().find(|m| m.name() == name)
+    }
+
+    /// Iterates over meshes with their vertex and index buffers
+    pub fn meshes_with_buffers(
+        &self,
+    ) -> impl Iterator<Item = (&EnvironmentMesh, Vec<&VertexBuffer>, &IndexBuffer<u16>)> {
+        self.meshes.iter().filter_map(|mesh| {
+            let vertex_buffers: Vec<_> = mesh
+                .vertex_buffer_ids()
+                .iter()
+                .filter_map(|&id| self.vertex_buffers.get(id))
+                .collect();
+
+            let index_buffer = self.index_buffers.get(mesh.index_buffer_id())?;
+
+            Some((mesh, vertex_buffers, index_buffer))
+        })
+    }
+}
+
+/// Builder for constructing [`EnvironmentAsset`] instances
+#[derive(Default)]
+pub(crate) struct EnvironmentAssetBuilder {
+    shader_texture_overrides: Vec<ShaderTextureOverride>,
+    meshes: Vec<EnvironmentMesh>,
+    scene_graphs: Vec<BucketedGeometry>,
+    planar_reflectors: Vec<PlanarReflector>,
+    vertex_buffers: Vec<VertexBuffer>,
+    index_buffers: Vec<IndexBuffer<u16>>,
+}
+
+impl EnvironmentAssetBuilder {
+    pub fn shader_texture_overrides(mut self, overrides: Vec<ShaderTextureOverride>) -> Self {
+        self.shader_texture_overrides = overrides;
+        self
+    }
+
+    pub fn meshes(mut self, meshes: Vec<EnvironmentMesh>) -> Self {
+        self.meshes = meshes;
+        self
+    }
+
+    pub fn scene_graphs(mut self, scene_graphs: Vec<BucketedGeometry>) -> Self {
+        self.scene_graphs = scene_graphs;
+        self
+    }
+
+    pub fn planar_reflectors(mut self, reflectors: Vec<PlanarReflector>) -> Self {
+        self.planar_reflectors = reflectors;
+        self
+    }
+
+    pub fn vertex_buffers(mut self, buffers: Vec<VertexBuffer>) -> Self {
+        self.vertex_buffers = buffers;
+        self
+    }
+
+    pub fn index_buffers(mut self, buffers: Vec<IndexBuffer<u16>>) -> Self {
+        self.index_buffers = buffers;
+        self
+    }
+
+    pub fn build(self) -> EnvironmentAsset {
+        EnvironmentAsset {
+            shader_texture_overrides: self.shader_texture_overrides,
+            meshes: self.meshes,
+            scene_graphs: self.scene_graphs,
+            planar_reflectors: self.planar_reflectors,
+            vertex_buffers: self.vertex_buffers,
+            index_buffers: self.index_buffers,
+        }
+    }
+}

crates/ltk_mapgeo/src/channel.rs

@@ -0,0 +1,89 @@
+//! Environment asset channel definitions
+//!
+//! Channels represent texture samplers with associated UV parameters.
+
+use glam::Vec2;
+
+/// An environment asset channel represents a texture sampler binding.
+///
+/// Used for lighting textures like "STATIONARY_LIGHT" and "BAKED_LIGHT".
+#[derive(Debug, Clone, PartialEq)]
+pub struct EnvironmentAssetChannel {
+    /// Texture path (if known)
+    texture: String,
+    /// UV scale applied to this channel
+    scale: Vec2,
+    /// UV offset applied to this channel
+    offset: Vec2,
+}
+
+impl EnvironmentAssetChannel {
+    /// Creates a new channel
+    pub fn new(texture: String, scale: Vec2, offset: Vec2) -> Self {
+        Self {
+            texture,
+            scale,
+            offset,
+        }
+    }
+
+    /// Creates an empty/default channel
+    pub fn empty() -> Self {
+        Self {
+            texture: String::new(),
+            scale: Vec2::ONE,
+            offset: Vec2::ZERO,
+        }
+    }
+
+    /// The texture path
+    #[inline]
+    pub fn texture(&self) -> &str {
+        &self.texture
+    }
+
+    /// UV scale for this channel
+    #[inline]
+    pub fn scale(&self) -> Vec2 {
+        self.scale
+    }
+
+    /// UV offset for this channel
+    #[inline]
+    pub fn offset(&self) -> Vec2 {
+        self.offset
+    }
+}
+
+/// A per-mesh texture override.
+///
+/// Allows overriding specific sampler slots on individual meshes.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MeshTextureOverride {
+    /// Sampler index to override
+    sampler_index: u32,
+    /// Texture path
+    texture: String,
+}
+
+impl MeshTextureOverride {
+    /// Creates a new texture override
+    pub fn new(sampler_index: u32, texture: String) -> Self {
+        Self {
+            sampler_index,
+            texture,
+        }
+    }
+
+    /// The sampler index this override applies to
+    #[inline]
+    pub fn sampler_index(&self) -> u32 {
+        self.sampler_index
+    }
+
+    /// The texture path
+    #[inline]
+    pub fn texture(&self) -> &str {
+        &self.texture
+    }
+}