WIP

Cargo.toml

@@ -28,7 +28,7 @@ members = [
     "crates/formats",
     "crates/cli",
     "crates/viewer",
-    "crates/dvdbnd",
+    "crates/dvdbnd", "crates/asset-server",
 ]
 
 [workspace.package]
@@ -51,4 +51,4 @@ fstools_formats = { path = "crates/formats", version = "0.1.0" }
 fstools_dvdbnd = { path = "crates/dvdbnd", version = "0.1.0" }
 memmap2 = "0.7"
 rayon = "1"
-thiserror = "1"
+thiserror = "1"

crates/asset-server/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "fstools_asset_server"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+
+[dependencies]
+bevy_app = "0.13"
+bevy_asset = { version = "0.13", features = ["multi-threaded", "asset_processor", "file_watcher"] }
+fstools_dvdbnd.workspace = true
+fstools_formats.workspace = true
+futures-lite = "2"
+
+[lints]
+workspace = true

crates/asset-server/src/archive.rs

@@ -0,0 +1,75 @@
+mod bnd4;
+
+use std::{
+    collections::{HashMap, HashSet},
+    path::Path,
+};
+
+use bevy_asset::{
+    io::{AssetReader, AssetReaderError, PathStream, Reader}, BoxedFuture, UntypedHandle,
+};
+use futures_lite::io::Cursor;
+
+pub struct ArchiveEntry {
+    data: Vec<u8>,
+}
+
+pub struct ArchiveAssetSource {
+    mounted_archives: HashSet<UntypedHandle>,
+    entries: HashMap<String, ArchiveEntry>,
+}
+
+pub trait IntoArchive {
+    fn files(&self) -> impl Iterator<Item = (String, Vec<u8>)>;
+}
+
+impl ArchiveAssetSource {
+    pub fn mount<A: IntoArchive>(&mut self, archive: A) {
+        self.entries.extend(archive.files().map(|(name, data)| {
+            (
+                name,
+                ArchiveEntry {
+                    data,
+                },
+            )
+        }));
+    }
+}
+
+impl AssetReader for ArchiveAssetSource {
+    fn read<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
+        Box::pin(async move {
+            let data = self
+                .entries
+                .get(&path.to_string_lossy().to_string())
+                .map(|entry| Box::new(Cursor::new(&entry.data   )) as Box<Reader<'a>>)
+                .ok_or_else(|| AssetReaderError::NotFound(path.to_path_buf()))?;
+
+            Ok(data)
+        })
+    }
+
+    fn read_meta<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
+        todo!()
+    }
+
+    fn read_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> BoxedFuture<'a, Result<Box<PathStream>, AssetReaderError>> {
+        todo!()
+    }
+
+    fn is_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> BoxedFuture<'a, Result<bool, AssetReaderError>> {
+        todo!()
+    }
+}

crates/asset-server/src/archive/bnd4.rs

@@ -0,0 +1,14 @@
+use fstools_formats::bnd4::BND4;
+
+use crate::archive::IntoArchive;
+
+impl IntoArchive for BND4 {
+    fn files(&self) -> impl Iterator<Item = (String, Vec<u8>)> {
+        self.files.iter().map(|file| {
+            let start = file.data_offset as usize;
+            let size = file.compressed_size as usize;
+
+            (file.path.clone(), self.data[start..start + size].to_vec())
+        })
+    }
+}

crates/viewer/src/vfs/reader.rs → crates/asset-server/src/dvdbnd.rs

@@ -1,39 +1,27 @@
-use std::{
-    io::{self, Read},
-    path::Path,
-    pin::Pin,
-    sync::Arc,
-    task::Poll,
-};
+use std::{io, io::Read, path::Path, pin::Pin, sync::Arc, task::Poll};
 
-use bevy::{
-    asset::{
-        io::{AssetReader, AssetReaderError, PathStream, Reader},
-        BoxedFuture,
-    },
-    prelude::{Deref, DerefMut, Resource},
-    tasks::futures_lite::{io::Cursor, AsyncRead},
+use bevy_asset::{
+    io::{AssetReader, AssetReaderError, PathStream, Reader},
+    BoxedFuture,
 };
-use fstools_dvdbnd::{DvdBnd, DvdBndEntryError, DvdBndEntryReader as VfsEntryReaderImpl};
+use fstools_dvdbnd::{DvdBnd, DvdBndEntryError, DvdBndEntryReader};
+use futures_lite::AsyncRead;
 
-#[derive(Clone, Deref, DerefMut, Resource)]
-pub struct VfsAssetRepository(pub(crate) Arc<DvdBnd>);
+#[derive(Clone)]
+pub struct DvdBndAssetSource(pub(crate) Arc<DvdBnd>);
 
-impl AssetReader for VfsAssetRepository {
+impl AssetReader for DvdBndAssetSource {
     fn read<'a>(
         &'a self,
         path: &'a Path,
     ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
         Box::pin(async move {
             let path_str = path.to_string_lossy();
+            let dvd_bnd = &self.0;
 
-            self.open(&*path_str)
-                .map(|r| Box::new(VfsEntryReader(r)) as Box<Reader>)
-                .or_else(|_| {
-                    Ok(self
-                        .open_from_mounts(&path_str)
-                        .map(|r| Box::new(Cursor::new(r)))?)
-                })
+            dvd_bnd
+                .open(&*path_str)
+                .map(|r| Box::new(AsyncDvdBndEntryReader(r)) as Box<Reader>)
                 .map_err(|e| match e {
                     DvdBndEntryError::NotFound => AssetReaderError::NotFound(path.to_path_buf()),
                     _ => AssetReaderError::Io(Arc::new(io::Error::other(
@@ -65,9 +53,9 @@ impl AssetReader for VfsAssetRepository {
     }
 }
 
-struct VfsEntryReader(VfsEntryReaderImpl);
+struct AsyncDvdBndEntryReader(DvdBndEntryReader);
 
-impl AsyncRead for VfsEntryReader {
+impl AsyncRead for AsyncDvdBndEntryReader {
     fn poll_read(
         mut self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,