Merge pull request #22 from LeagueToolkit/feat/modpkg-formaty

feat: add mod package format reading

Author: Crauzer

crates/io-ext/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "io-ext"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+thiserror = "1.0.60"
+league-primitives = { path = "../league-primitives" }
+byteorder = "1.5.0"
+glam = { version = "0.27.0", features = ["glam-assert"] }

crates/io-ext/src/lib.rs

@@ -0,0 +1,56 @@
+pub mod reader;
+pub mod writer;
+
+pub use reader::*;
+pub use writer::*;
+
+/// Measures the differnece in cursor position of an `io::Seek`, before and after calling `inner`
+/// **NOTE**: this function assumes the cursor position after calling `inner()` will always be >= the cursor after calling `inner()`. Negative position differences will clamp to 0.
+///
+/// The `inner` function's Err type **must** impl `From<std::io::Error>`, since
+/// `std::io::Seek::stream_position()` is fallable
+pub fn measure<S, T, E>(
+    seekable: &mut S,
+    mut inner: impl FnMut(&mut S) -> Result<T, E>,
+) -> Result<(u64, T), E>
+where
+    S: std::io::Seek + ?Sized,
+    E: std::error::Error + From<std::io::Error>,
+{
+    let start = seekable.stream_position()?;
+
+    let val = inner(seekable)?;
+    Ok((seekable.stream_position()?.saturating_sub(start), val))
+}
+
+/// Temporarily seeks an `io::Seek` to `SeekFrom::Start(at)`, for the duration of the `inner` call.
+/// Returns back to the seek position afterwards.
+///
+/// # Example
+/// ```rs
+/// let mut buf = Cursor::new(Vec::new());
+///
+/// let size_pos = buf.stream_position().unwrap();
+///
+/// // things happen....
+///
+/// window(&mut buf, size_pos, |buf| {
+///     let size = 10;
+///     buf.write_u32::<LE>(size)
+/// })
+/// ```
+pub fn window<S, T, E>(
+    seekable: &mut S,
+    at: u64,
+    mut inner: impl FnMut(&mut S) -> Result<T, E>,
+) -> Result<T, E>
+where
+    S: std::io::Seek + ?Sized,
+    E: std::error::Error + From<std::io::Error>,
+{
+    let original = seekable.stream_position()?;
+    seekable.seek(std::io::SeekFrom::Start(at))?;
+    let val = inner(seekable)?;
+    seekable.seek(std::io::SeekFrom::Start(original))?;
+    Ok(val)
+}

crates/league-toolkit/src/util/reader.rs crates/io-ext/src/reader.rscrates/league-toolkit/src/util/reader.rs renamed to crates/io-ext/src/reader.rs

@@ -2,8 +2,7 @@ use std::io::{self, Read};
 
 use byteorder::{ByteOrder, ReadBytesExt};
 use glam::{Mat4, Quat, Vec2, Vec3, Vec4};
-
-use crate::core::primitives::{Color, Sphere, AABB};
+use league_primitives::{Color, Sphere, AABB};
 
 #[derive(Debug, thiserror::Error)]
 pub enum ReaderError {

crates/league-toolkit/src/util/writer.rs crates/io-ext/src/writer.rscrates/league-toolkit/src/util/writer.rs renamed to crates/io-ext/src/writer.rs

@@ -1,9 +1,9 @@
 use std::io::{self, Write};
 
 use byteorder::{ByteOrder, WriteBytesExt};
-use glam::{Mat4, Quat, Vec2, Vec3, Vec4};
+use glam::{Mat4, Quat};
 
-use crate::core::primitives::{Color, Sphere, AABB};
+use league_primitives::{Color, Sphere, AABB};
 
 pub trait WriterExt: Write {
     fn write_padded_string<const N: usize>(&mut self, str: &str) -> io::Result<()> {

crates/league-modpkg/Cargo.toml

@@ -4,3 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+thiserror = "1.0.60"
+byteorder = "1.5.0"
+
+io-ext = { path = "../io-ext" }

crates/league-modpkg/src/chunk.rs

@@ -0,0 +1,58 @@
+use std::{
+    borrow::Cow,
+    io::{BufReader, Read},
+};
+
+use byteorder::{ReadBytesExt as _, LE};
+use io_ext::ReaderExt as _;
+
+use crate::error::ModpkgError;
+
+#[derive(Debug, PartialEq, PartialOrd)]
+pub struct ModpkgChunk {
+    path: Cow<'static, str>,
+    path_hash: u64,
+    compressed_size: usize,
+    uncompressed_size: usize,
+    data_offset: usize,
+    checksum: u64,
+}
+
+impl ModpkgChunk {
+    pub fn read(reader: &mut BufReader<impl Read>) -> Result<Self, ModpkgError> {
+        let path = reader.read_len_prefixed_string::<LE>()?;
+        let path_hash = reader.read_u64::<LE>()?;
+        let compressed_size = reader.read_u64::<LE>()?;
+        let uncompressed_size = reader.read_u64::<LE>()?;
+        let data_offset = reader.read_u64::<LE>()?;
+        let checksum = reader.read_u64::<LE>()?;
+
+        Ok(Self {
+            path: Cow::from(path),
+            path_hash,
+            compressed_size: compressed_size as usize,
+            uncompressed_size: uncompressed_size as usize,
+            data_offset: data_offset as usize,
+            checksum,
+        })
+    }
+
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+    pub fn path_hash(&self) -> u64 {
+        self.path_hash
+    }
+    pub fn compressed_size(&self) -> usize {
+        self.compressed_size
+    }
+    pub fn uncompressed_size(&self) -> usize {
+        self.uncompressed_size
+    }
+    pub fn data_offset(&self) -> usize {
+        self.data_offset
+    }
+    pub fn checksum(&self) -> u64 {
+        self.checksum
+    }
+}

crates/league-modpkg/src/error.rs

@@ -0,0 +1,20 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ModpkgError {
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("IO error: {0}")]
+    IoExtError(#[from] io_ext::ReaderError),
+
+    #[error("Invalid modpkg compression type: {0}")]
+    InvalidCompressionType(u8),
+    #[error("Invalid modpkg license type: {0}")]
+    InvalidLicenseType(u8),
+    #[error("Invalid modpkg magic: {0}")]
+    InvalidMagic(u64),
+    #[error("Invalid modpkg version: {0}")]
+    InvalidVersion(u32),
+    #[error("Duplicate chunk: {0}")]
+    DuplicateChunk(u64),
+}

crates/league-modpkg/src/lib.rs

@@ -1 +1,72 @@
+use chunk::ModpkgChunk;
+use license::ModpkgLicense;
+use std::collections::HashMap;
 
+mod chunk;
+mod error;
+mod license;
+mod read;
+
+#[derive(Debug, PartialEq)]
+pub struct Modpkg {
+    name: String,
+    display_name: String,
+    description: Option<String>,
+    version: String,
+    distributor: Option<String>,
+    authors: Vec<ModpkgAuthor>,
+    license: ModpkgLicense,
+
+    chunks: HashMap<u64, ModpkgChunk>,
+}
+
+impl Modpkg {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+    pub fn display_name(&self) -> &str {
+        &self.display_name
+    }
+    pub fn description(&self) -> Option<&str> {
+        self.description.as_deref()
+    }
+    pub fn version(&self) -> &str {
+        &self.version
+    }
+    pub fn distributor(&self) -> Option<&str> {
+        self.distributor.as_deref()
+    }
+    pub fn authors(&self) -> &[ModpkgAuthor] {
+        &self.authors
+    }
+    pub fn license(&self) -> &ModpkgLicense {
+        &self.license
+    }
+    pub fn chunks(&self) -> &HashMap<u64, ModpkgChunk> {
+        &self.chunks
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct ModpkgAuthor {
+    name: String,
+    role: Option<String>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ModpkgCompression {
+    None = 0,
+    Zstd = 1,
+}
+
+impl TryFrom<u8> for ModpkgCompression {
+    type Error = &'static str;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(match value {
+            0 => ModpkgCompression::None,
+            1 => ModpkgCompression::Zstd,
+            _ => return Err("Invalid modpkg compression value"),
+        })
+    }
+}

crates/league-modpkg/src/license.rs

@@ -0,0 +1,37 @@
+use std::io::{self, BufReader};
+
+use byteorder::{ReadBytesExt as _, LE};
+use io_ext::ReaderExt as _;
+
+use crate::error::ModpkgError;
+
+#[derive(Debug, PartialEq)]
+pub enum ModpkgLicense {
+    None,
+    Spdx { spdx_id: String },
+    Custom { name: String, url: String },
+}
+
+impl ModpkgLicense {
+    pub fn read(reader: &mut BufReader<impl io::Read>) -> Result<Self, ModpkgError> {
+        let license_type = reader.read_u8()?;
+
+        Ok(match license_type {
+            0 => Self::None,
+            1 => {
+                let spdx_id = reader.read_len_prefixed_string::<LE>()?;
+                Self::Spdx { spdx_id }
+            }
+            2 => {
+                let name = reader.read_len_prefixed_string::<LE>()?;
+                let url = reader.read_len_prefixed_string::<LE>()?;
+                Self::Custom { name, url }
+            }
+            _ => return Err(ModpkgError::InvalidLicenseType(license_type)),
+        })
+    }
+
+    pub fn write(&self, writer: &mut impl io::Write) -> Result<(), ModpkgError> {
+        unimplemented!("TODO: modpkg writing");
+    }
+}

crates/league-modpkg/src/read.rs

@@ -0,0 +1,89 @@
+use byteorder::{ReadBytesExt as _, LE};
+use io_ext::ReaderExt as _;
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    io::{BufReader, Read},
+};
+
+use crate::{error::ModpkgError, Modpkg, ModpkgAuthor, ModpkgChunk, ModpkgLicense};
+
+impl Modpkg {
+    pub const MAGIC: u64 = u64::from_le_bytes(*b"_modpkg_");
+
+    pub fn read(reader: &mut BufReader<impl Read>) -> Result<Self, ModpkgError> {
+        let magic = reader.read_u64::<LE>()?;
+        if magic != Self::MAGIC {
+            return Err(ModpkgError::InvalidMagic(magic));
+        }
+
+        let version = reader.read_u32::<LE>()?;
+        if version != 1 {
+            return Err(ModpkgError::InvalidVersion(version));
+        }
+
+        let name = reader.read_len_prefixed_string::<LE>()?;
+        let display_name = reader.read_len_prefixed_string::<LE>()?;
+        let description = reader.read_len_prefixed_string::<LE>()?;
+        let version = reader.read_len_prefixed_string::<LE>()?;
+        let distributor = reader.read_len_prefixed_string::<LE>()?;
+
+        let authors = Self::read_authors(reader)?;
+        let license = ModpkgLicense::read(reader)?;
+        let chunks = Self::read_chunks(reader)?;
+        Ok(Self {
+            name,
+            display_name,
+            description: match description.len() {
+                0 => None,
+                _ => Some(description),
+            },
+            version,
+            distributor: match distributor.len() {
+                0 => None,
+                _ => Some(distributor),
+            },
+            authors,
+            license,
+            chunks,
+        })
+    }
+
+    fn read_authors(reader: &mut BufReader<impl Read>) -> Result<Vec<ModpkgAuthor>, ModpkgError> {
+        let count = reader.read_u32::<LE>()?;
+        let mut authors = Vec::with_capacity(count as usize);
+        for _ in 0..count {
+            let name = reader.read_len_prefixed_string::<LE>()?;
+            let role = reader.read_len_prefixed_string::<LE>()?;
+
+            authors.push(ModpkgAuthor {
+                name,
+                role: match role.len() {
+                    0 => None,
+                    _ => Some(role),
+                },
+            });
+        }
+
+        Ok(authors)
+    }
+
+    fn read_chunks(
+        reader: &mut BufReader<impl Read>,
+    ) -> Result<HashMap<u64, ModpkgChunk>, ModpkgError> {
+        let chunk_count = reader.read_u32::<LE>()?;
+        let mut chunks = HashMap::with_capacity(chunk_count as usize);
+        for _ in 0..chunk_count {
+            let chunk = ModpkgChunk::read(reader)?;
+            match chunks.entry(chunk.path_hash()) {
+                Entry::Occupied(_) => {
+                    return Err(ModpkgError::DuplicateChunk(chunk.path_hash()));
+                }
+                Entry::Vacant(entry) => {
+                    entry.insert(chunk);
+                }
+            }
+        }
+
+        Ok(chunks)
+    }
+}