Struct ModuleFile

pub struct ModuleFile {
    header: ModuleHeader,
    pub files: Vec<ModuleFileEntry>,
    resource_indices: Vec<u32>,
    blocks: Vec<ModuleBlockEntry>,
    file_data_offset: u64,
    module_file: Option<BufReader<File>>,
    hd1_file: Option<BufReader<File>>,
}

Module structure which contains the layout of the entire module file.

Fields

header: ModuleHeader

Information relating to how the other fields should be read.

files: Vec<ModuleFileEntry>

Metadata regarding compression and layout of files (tags).

resource_indices: Vec<u32>

Indices of resource files present in the module.

blocks: Vec<ModuleBlockEntry>

Uncompressed/compressed blocks making up a file.

file_data_offset: u64

Offset in BufReader where file data starts.

module_file: Option<BufReader<File>>

Reference to the module file buffer.

hd1_file: Option<BufReader<File>>

Reference to HD1 buffer if it exists.

Implementations

impl ModuleFile

pub fn new() -> Self

Instantiates a default ModuleFile object.

pub fn from_path<T: AsRef<Path>>(file_path: T) -> Result<Self>

Examples found in repository

examples/load_all_modules.rs (line 18)

fn load_modules(deploy_path: String) -> infinite_rs::Result<Vec<ModuleFile>> {
    let mut modules = Vec::new();
    for entry in walkdir::WalkDir::new(deploy_path)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        if entry.file_type().is_file() {
            let file_path = entry.path().to_str().unwrap();
            if file_path.ends_with(".module") {
                let module = ModuleFile::from_path(file_path);
                match module {
                    Ok(_) => {
                        modules.push(module?);
                        println!("Read module: {}", file_path);
                    }
                    Err(err) => {
                        println!("Failed on file: {}", file_path);
                        return Err(err);
                    }
                };
            }
        }
    }
    Ok(modules)
}

pub fn read<T: AsRef<Path>>(&mut self, file_path: T) -> Result<()>

Reads the module file from the given file path. This function reads the entire structure of the module file. It also calculates and stores important offsets within the file.

Arguments

• file_path - A reference to a type that implements Path that holds the path to the module file.

Returns

Returns Ok(()) if the read operation is successful, or an Error containing the I/O error if any reading operation fails.

fn open_hd1<T: AsRef<Path>>(&mut self, file_path: T) -> Result<()>

pub fn read_tag(&mut self, index: u32) -> Result<()>

Reads a specific tag from the module file.

This function reads a specific tag from the module file based on the provided index. It checks if the tag is not a resource tag (indicated by a tag_id of -1) and then reads the tag data from the module file. It also utilizes the HD1 stream if the file entry has the flag set for it and the stream is loaded.

Arguments

• index - The index of the file entry to read the tag from. This index corresponds to the position of the file entry in the files vector.

Returns

Returns Ok(()) if the read operation is successful, or an Error containing the I/O error if any reading operation fails.

Examples found in repository

examples/load_all_modules.rs (line 167)

fn main() -> infinite_rs::Result<()> {
    let mut pc_modules =
        load_modules(String::from("C:/XboxGames/Halo Infinite/Content/deploy/pc"))?;

    let mut any_modules = load_modules(String::from(
        "C:/XboxGames/Halo Infinite/Content/deploy/any",
    ))?;

    let mut modules = pc_modules.iter_mut().chain(any_modules.iter_mut());

    for module in &mut modules {
        for index in 0..module.files.len() {
            module.read_tag(index as u32)?;
            let tag = &mut module.files[index];
            if tag.tag_group == "mat " {
                let mut mat = MaterialTag::default();
                tag.read_metadata(&mut mat)?;
                println!("{:#?}", mat.style_info);
            }
        }
    }
    Ok(())
}

pub fn read_tag_from_id(&mut self, global_id: i32) -> Result<Option<usize>>

Searches for the index of the tag given the global_id.

This function searches for the index of a tag in the files vector using the provided global_id. If the tag is found, it reads the tag using the read_tag function and stores it in the index.

Arguments

• global_id - The global tag ID of the file to find. This ID is used to identify the specific tag within the module file.

Returns

Returns the index of the file if successful, wrapped in Some(usize). If the tag is not found, it returns None. Any I/O error encountered during the operation is also returned if it occurs.

pub fn read_resources(&mut self, index: u32) -> Result<Vec<&ModuleFileEntry>>

Reads the resources referenced by a module entry.

This function reads the resources referenced by a specific module entry. It retrieves the resources based on the provided index and returns them as a vector of references to ModuleFileEntry.

Arguments

• index - Index of the file to read the resources of. This index corresponds to the position of the file entry in the files vector.

Returns

Returns Ok(Vec<&ModuleFileEntry>) if the read operation is successful, containing a vector of references to ModuleFileEntry. If the requested resource wasn’t found in the module, an Error is returned.

Trait Implementations

impl Debug for ModuleFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ModuleFile

fn default() -> ModuleFile

Returns the “default value” for a type.