422 lines
16 KiB
Rust
422 lines
16 KiB
Rust
use std::cell::RefCell;
|
|
use std::collections::HashMap;
|
|
use std::io::{Cursor, Read, Seek, SeekFrom, Write};
|
|
|
|
use flate2::read::DeflateDecoder;
|
|
use sqpack::{DatBlockHeader, DatStdFileBlockInfos, FileKind, LodBlock, ModelBlock, SqPackFileInfo, SqPackFileInfoHeader};
|
|
use sqpack::binrw::{BinRead, BinWriterExt, VecArgs};
|
|
use zip::ZipArchive;
|
|
|
|
use crate::Error;
|
|
use crate::error::Result;
|
|
use crate::model::manifest_kind::ManifestKind;
|
|
use crate::model::SimpleMod;
|
|
use crate::tracking_reader::TrackingReader;
|
|
use crate::util::{MAX_MODEL_LODS, read_struct};
|
|
|
|
#[doc(hidden)]
|
|
pub trait WriteSeek: Write + Seek {}
|
|
|
|
impl<T> WriteSeek for T
|
|
where T: Write + Seek {}
|
|
|
|
pub struct TtmpExtractor<R> {
|
|
manifest: ManifestKind,
|
|
zip: RefCell<ZipArchive<R>>,
|
|
}
|
|
|
|
impl<R: Read + Seek> TtmpExtractor<R> {
|
|
pub fn new(reader: R) -> Result<Self> {
|
|
let (manifest, zip) = crate::from_reader(reader)?;
|
|
|
|
Ok(Self {
|
|
manifest,
|
|
zip: RefCell::new(zip),
|
|
})
|
|
}
|
|
|
|
pub fn manifest(&self) -> &ManifestKind {
|
|
&self.manifest
|
|
}
|
|
|
|
pub fn into_manifest(self) -> ManifestKind {
|
|
self.manifest
|
|
}
|
|
|
|
pub fn extract_all<F>(&mut self, writer_func: F) -> Result<()>
|
|
where F: Fn(&ModFile) -> Result<Box<dyn WriteSeek>, std::io::Error> + 'static,
|
|
{
|
|
let all_files = self.all_files_sorted();
|
|
|
|
let mut zip = self.zip.borrow_mut();
|
|
let mut data_file = TrackingReader::new(zip.by_name("TTMPD.mpd")
|
|
.map_err(Error::MissingDataFile)?);
|
|
|
|
let mut buf = [0; 4096];
|
|
for mod_file in all_files {
|
|
let file = mod_file.file;
|
|
data_file.read = 0;
|
|
|
|
// get the writer to write this file into
|
|
let mut writer = writer_func(&mod_file)
|
|
.map_err(Error::Io)?;
|
|
let expected = file.mod_size;
|
|
|
|
let info: SqPackFileInfoHeader = read_struct(&mut data_file, &mut buf)?;
|
|
match info.kind {
|
|
FileKind::Empty => todo!(),
|
|
FileKind::Standard => {
|
|
Self::extract_standard_file(&info, &mut data_file, &mut writer, &mut buf)?;
|
|
}
|
|
FileKind::Model => {
|
|
Self::extract_model_file(&info, &mut data_file, &mut writer, &mut buf)?;
|
|
}
|
|
FileKind::Texture => {
|
|
Self::extract_texture_file(&info, &mut data_file, &mut writer, &mut buf)?;
|
|
}
|
|
}
|
|
|
|
if data_file.read < expected {
|
|
let to_skip = expected - data_file.read;
|
|
Self::skip(&mut data_file, &mut buf, to_skip)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn zip(&self) -> &RefCell<ZipArchive<R>> {
|
|
&self.zip
|
|
}
|
|
|
|
pub fn all_files_sorted(&self) -> Vec<ModFile> {
|
|
let mut all_files = Vec::new();
|
|
|
|
let mut seen_groups: HashMap<&str, usize> = HashMap::new();
|
|
if let ManifestKind::V2(pack) = &self.manifest {
|
|
if let Some(pages) = &pack.mod_pack_pages {
|
|
for page in pages {
|
|
for group in &page.mod_groups {
|
|
let seen = seen_groups.entry(&group.group_name).or_default();
|
|
*seen += 1;
|
|
|
|
for option in &group.option_list {
|
|
for file in &option.mods_jsons {
|
|
all_files.push(ModFile {
|
|
group: Some(&*option.group_name),
|
|
group_occurence: *seen,
|
|
option: Some(&*option.name),
|
|
file,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
all_files.extend(self.manifest.simple_mods_list().iter().map(|file| ModFile {
|
|
group: None,
|
|
group_occurence: 0,
|
|
option: None,
|
|
file,
|
|
}));
|
|
|
|
all_files.sort_unstable_by_key(|file| file.file.mod_offset);
|
|
all_files
|
|
}
|
|
}
|
|
|
|
impl<R: Read> TtmpExtractor<R> {
|
|
pub fn extract_one_into<W: Write + Seek>(mod_file: &ModFile, mut reader: R, mut writer: W) -> Result<()> {
|
|
let mut reader = TrackingReader::new(&mut reader);
|
|
let mut buf = [0; 4096];
|
|
let file = mod_file.file;
|
|
let expected = file.mod_size;
|
|
|
|
let info: SqPackFileInfoHeader = read_struct(&mut reader, &mut buf)?;
|
|
match info.kind {
|
|
FileKind::Empty => todo!(),
|
|
FileKind::Standard => {
|
|
Self::extract_standard_file(&info, &mut reader, &mut writer, &mut buf)?;
|
|
}
|
|
FileKind::Model => {
|
|
Self::extract_model_file(&info, &mut reader, &mut writer, &mut buf)?;
|
|
}
|
|
FileKind::Texture => {
|
|
Self::extract_texture_file(&info, &mut reader, &mut writer, &mut buf)?;
|
|
}
|
|
}
|
|
|
|
if reader.read < expected {
|
|
let to_skip = expected - reader.read;
|
|
Self::skip(&mut reader, &mut buf, to_skip)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_standard_file<T: Read, W: Write>(info: &SqPackFileInfoHeader, mut data_file: T, mut writer: W, buf: &mut [u8]) -> Result<()> {
|
|
let std_info: SqPackFileInfo = read_struct(&mut data_file, buf)?;
|
|
let blocks: Vec<DatStdFileBlockInfos> = (0..std_info.number_of_blocks)
|
|
.map(|_| read_struct(&mut data_file, buf))
|
|
.collect::<Result<_>>()?;
|
|
|
|
let skip_amt = info.size as usize
|
|
- std::mem::size_of::<SqPackFileInfoHeader>()
|
|
- std::mem::size_of::<SqPackFileInfo>()
|
|
- std::mem::size_of::<DatStdFileBlockInfos>() * std_info.number_of_blocks as usize;
|
|
Self::skip(&mut data_file, buf, skip_amt)?;
|
|
|
|
for block in blocks {
|
|
Self::read_block_into(&mut data_file, &mut writer, buf, block.compressed_size as usize)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_model_file<T: Read, W: Write + Seek>(info: &SqPackFileInfoHeader, mut reader: T, mut writer: W, buf: &mut [u8]) -> Result<()> {
|
|
let model_info: ModelBlock = read_struct(&mut reader, buf)?;
|
|
|
|
let block_counts = &model_info.block_num;
|
|
let total_blocks = block_counts.stack
|
|
+ block_counts.runtime
|
|
+ block_counts.vertex_buffer.iter().sum::<u16>()
|
|
+ block_counts.edge_geometry_vertex_buffer.iter().sum::<u16>()
|
|
+ block_counts.index_buffer.iter().sum::<u16>();
|
|
let block_sizes: Vec<u16> = Self::read_vec(&mut reader, total_blocks as usize, buf)?;
|
|
|
|
let skip_amt = info.size as usize
|
|
- std::mem::size_of::<SqPackFileInfoHeader>()
|
|
- std::mem::size_of::<ModelBlock>()
|
|
- std::mem::size_of::<u16>() * total_blocks as usize;
|
|
Self::skip(&mut reader, buf, skip_amt)?;
|
|
|
|
writer.seek(SeekFrom::Start(0x44)).map_err(Error::Io)?;
|
|
|
|
let stack_size = Self::read_blocks_into(
|
|
model_info.block_num.stack,
|
|
model_info.block_index.stack,
|
|
model_info.offset.stack,
|
|
&block_sizes,
|
|
&mut reader,
|
|
&mut writer,
|
|
buf,
|
|
)?;
|
|
|
|
let runtime_size = Self::read_blocks_into(
|
|
model_info.block_num.runtime,
|
|
model_info.block_index.runtime,
|
|
model_info.offset.runtime,
|
|
&block_sizes,
|
|
&mut reader,
|
|
&mut writer,
|
|
buf,
|
|
)?;
|
|
|
|
let mut vertex_data_offsets = [0u32; MAX_MODEL_LODS];
|
|
let mut vertex_buffer_sizes = [0u32; MAX_MODEL_LODS];
|
|
|
|
let mut index_data_offsets = [0u32; MAX_MODEL_LODS];
|
|
let mut index_buffer_sizes = [0u32; MAX_MODEL_LODS];
|
|
|
|
for lod_index in 0..MAX_MODEL_LODS {
|
|
// Vertex buffer
|
|
let block_count = model_info.block_num.vertex_buffer[lod_index];
|
|
if block_count != 0 {
|
|
if lod_index == 0 || block_count > 0 {
|
|
vertex_data_offsets[lod_index] = writer.stream_position().map_err(Error::Io)? as u32;
|
|
}
|
|
|
|
vertex_buffer_sizes[lod_index] = Self::read_blocks_into(
|
|
block_count,
|
|
model_info.block_index.vertex_buffer[lod_index],
|
|
model_info.offset.vertex_buffer[lod_index],
|
|
&block_sizes,
|
|
&mut reader,
|
|
&mut writer,
|
|
buf,
|
|
)?;
|
|
}
|
|
|
|
// Edge geometry vertex buffer
|
|
let block_count = model_info.block_num.edge_geometry_vertex_buffer[lod_index];
|
|
if block_count != 0 {
|
|
Self::read_blocks_into(
|
|
block_count,
|
|
model_info.block_index.edge_geometry_vertex_buffer[lod_index],
|
|
model_info.offset.edge_geometry_vertex_buffer[lod_index],
|
|
&block_sizes,
|
|
&mut reader,
|
|
&mut writer,
|
|
buf,
|
|
)?;
|
|
}
|
|
|
|
// Index buffer
|
|
let block_count = model_info.block_num.index_buffer[lod_index];
|
|
if block_count != 0 {
|
|
if lod_index == 0 || block_count > 0 {
|
|
index_data_offsets[lod_index] = writer.stream_position().map_err(Error::Io)? as u32;
|
|
}
|
|
|
|
index_buffer_sizes[lod_index] = Self::read_blocks_into(
|
|
block_count,
|
|
model_info.block_index.index_buffer[lod_index],
|
|
model_info.offset.index_buffer[lod_index],
|
|
&block_sizes,
|
|
&mut reader,
|
|
&mut writer,
|
|
buf,
|
|
)?;
|
|
}
|
|
}
|
|
|
|
// Write out the header now we've collected the info for it.
|
|
writer.seek(SeekFrom::Start(0)).map_err(Error::Io)?;
|
|
writer.write_le(&model_info.version).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&stack_size).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&runtime_size).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&model_info.vertex_declaration_num).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&model_info.material_num).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&vertex_data_offsets).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&index_data_offsets).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&vertex_buffer_sizes).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&index_buffer_sizes).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&model_info.num_lods).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&model_info.index_buffer_streaming_enabled).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&model_info.edge_geometry_enabled).map_err(Error::BinRwWrite)?;
|
|
writer.write_le(&0u8).map_err(Error::BinRwWrite)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_texture_file<T: Read, W: Write>(info: &SqPackFileInfoHeader, mut reader: T, mut writer: W, buf: &mut [u8]) -> Result<()> {
|
|
let std_info: SqPackFileInfo = read_struct(&mut reader, buf)?;
|
|
let blocks: Vec<LodBlock> = (0..std_info.number_of_blocks)
|
|
.map(|_| read_struct(&mut reader, buf))
|
|
.collect::<Result<_>>()?;
|
|
|
|
let sub_block_count = blocks
|
|
.iter()
|
|
.fold(0, |acc, block| acc + block.block_count);
|
|
let sub_block_sizes: Vec<u16> = Self::read_vec(&mut reader, sub_block_count as usize, buf)?;
|
|
|
|
let skip_amt = info.size as usize
|
|
- std::mem::size_of::<SqPackFileInfoHeader>()
|
|
- std::mem::size_of::<SqPackFileInfo>()
|
|
- std::mem::size_of::<LodBlock>() * std_info.number_of_blocks as usize
|
|
- std::mem::size_of::<u16>() * sub_block_sizes.len();
|
|
Self::skip(&mut reader, buf, skip_amt)?;
|
|
|
|
let mip_map_size = blocks[0].compressed_offset;
|
|
if mip_map_size > 0 {
|
|
let mut reader = (&mut reader).take(mip_map_size as u64);
|
|
std::io::copy(&mut reader, &mut writer).map_err(Error::Io)?;
|
|
}
|
|
|
|
let mut sub_block = 0;
|
|
for block in blocks {
|
|
for _ in 0..block.block_count {
|
|
Self::read_block_into(&mut reader, &mut writer, buf, sub_block_sizes[sub_block] as usize)?;
|
|
sub_block += 1;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn read_block_into<T: Read, W: Write>(mut reader: T, mut writer: W, buf: &mut [u8], size: usize) -> Result<u64> {
|
|
let header: DatBlockHeader = read_struct(&mut reader, buf)?;
|
|
|
|
let (read, actual) = if header.compressed_size == 32_000 {
|
|
// uncompressed
|
|
let mut reader = (&mut reader).take(header.uncompressed_size as u64);
|
|
let read = std::io::copy(&mut reader, &mut writer).map_err(Error::Io)?;
|
|
(read, read)
|
|
} else if header.compressed_size == 0 {
|
|
// https://github.com/TexTools/xivModdingFramework/issues/51
|
|
let zeroes: Vec<u8> = std::iter::repeat(0)
|
|
.take(header.uncompressed_size as usize)
|
|
.collect();
|
|
std::io::copy(&mut Cursor::new(zeroes), &mut writer).map_err(Error::Io)?;
|
|
(0, 0)
|
|
} else {
|
|
// compressed
|
|
let reader = (&mut reader).take(header.compressed_size as u64);
|
|
let mut decoder = DeflateDecoder::new(reader);
|
|
let read = std::io::copy(&mut decoder, &mut writer).map_err(Error::Io)?;
|
|
(header.compressed_size as u64, read)
|
|
};
|
|
|
|
if (header.size as usize + read as usize) < size as usize {
|
|
let to_skip = size
|
|
- header.size as usize
|
|
- read as usize;
|
|
Self::skip(&mut reader, buf, to_skip)?;
|
|
}
|
|
|
|
Ok(actual)
|
|
}
|
|
|
|
fn read_blocks_into<T: Read, W: Write>(
|
|
block_count: u16,
|
|
block_index: u16,
|
|
_section_offset: u32,
|
|
block_sizes: &[u16],
|
|
mut reader: T,
|
|
mut writer: W,
|
|
buf: &mut [u8],
|
|
) -> Result<u32> {
|
|
let sizes = &block_sizes[block_index as usize..block_index as usize + block_count as usize];
|
|
sizes
|
|
.iter()
|
|
.try_fold(0, |acc, &size| {
|
|
let bytes_read = Self::read_block_into(&mut reader, &mut writer, buf, size as usize)?;
|
|
Ok(acc + bytes_read as u32)
|
|
})
|
|
}
|
|
|
|
fn read_vec<S: BinRead<Args=()>, T: Read>(mut reader: T, amount: usize, buf: &mut [u8]) -> Result<Vec<S>> {
|
|
let size_needed = amount * std::mem::size_of::<S>();
|
|
if size_needed <= buf.len() {
|
|
reader.read_exact(&mut buf[..size_needed]).map_err(Error::Io)?;
|
|
<Vec<S>>::read_le_args(
|
|
&mut Cursor::new(&buf[..size_needed]),
|
|
VecArgs {
|
|
count: amount,
|
|
inner: (),
|
|
},
|
|
).map_err(Error::SqPackError)
|
|
} else {
|
|
let mut buf = vec![0; size_needed];
|
|
reader.read_exact(&mut buf).map_err(Error::Io)?;
|
|
<Vec<S>>::read_le_args(
|
|
&mut Cursor::new(buf),
|
|
VecArgs {
|
|
count: amount,
|
|
inner: (),
|
|
},
|
|
).map_err(Error::SqPackError)
|
|
}
|
|
}
|
|
|
|
fn skip<T: Read>(mut reader: T, buf: &mut [u8], amt: usize) -> Result<()> {
|
|
let mut left = amt;
|
|
while left > 0 {
|
|
let to_read = std::cmp::min(left, buf.len());
|
|
left -= reader.read(&mut buf[..to_read]).map_err(Error::Io)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ModFile<'a> {
|
|
pub group: Option<&'a str>,
|
|
pub group_occurence: usize,
|
|
pub option: Option<&'a str>,
|
|
pub file: &'a SimpleMod,
|
|
}
|