Struct bevy::asset::io::file::FileAssetReader

pub struct FileAssetReader { /* private fields */ }

Available on non-WebAssembly only.

I/O implementation for the local filesystem.

This asset I/O is fully featured but it’s not available on android and wasm targets.

Implementations

impl FileAssetReader

pub fn new<P>(path: P) -> FileAssetReader

where P: AsRef<Path>,

Creates a new FileAssetIo at a path relative to the executable’s directory, optionally watching for changes.

See get_base_path below.

pub fn get_base_path() -> PathBuf

Returns the base path of the assets directory, which is normally the executable’s parent directory.

If the CARGO_MANIFEST_DIR environment variable is set, then its value will be used instead. It’s set by cargo when running with cargo run.

Examples found in repository

examples/animation/animation_graph.rs (line 186)

fn setup_assets_programmatically(
    commands: &mut Commands,
    asset_server: &mut AssetServer,
    animation_graphs: &mut Assets<AnimationGraph>,
    _save: bool,
) {
    // Create the nodes.
    let mut animation_graph = AnimationGraph::new();
    let blend_node = animation_graph.add_blend(0.5, animation_graph.root);
    animation_graph.add_clip(
        asset_server.load("models/animated/Fox.glb#Animation0"),
        1.0,
        animation_graph.root,
    );
    animation_graph.add_clip(
        asset_server.load("models/animated/Fox.glb#Animation1"),
        1.0,
        blend_node,
    );
    animation_graph.add_clip(
        asset_server.load("models/animated/Fox.glb#Animation2"),
        1.0,
        blend_node,
    );

    // If asked to save, do so.
    #[cfg(not(target_arch = "wasm32"))]
    if _save {
        let animation_graph = animation_graph.clone();

        IoTaskPool::get()
            .spawn(async move {
                let mut animation_graph_writer = File::create(Path::join(
                    &FileAssetReader::get_base_path(),
                    Path::join(Path::new("assets"), Path::new(ANIMATION_GRAPH_PATH)),
                ))
                .expect("Failed to open the animation graph asset");
                ron::ser::to_writer_pretty(
                    &mut animation_graph_writer,
                    &animation_graph,
                    PrettyConfig::default(),
                )
                .expect("Failed to serialize the animation graph");
            })
            .detach();
    }

    // Add the graph.
    let handle = animation_graphs.add(animation_graph);

    // Save the assets in a resource.
    commands.insert_resource(ExampleAnimationGraph(handle));
}

pub fn root_path(&self) -> &PathBuf

Returns the root directory where assets are loaded from.

See get_base_path.

Trait Implementations

impl AssetReader for FileAssetReader

async fn read<'a>( &'a self, path: &'a Path ) -> Result<Box<dyn AsyncReadAndSeek + Unpin + Sync + Send + 'a>, AssetReaderError>

Returns a future to load the full file data at the provided path.

async fn read_meta<'a>( &'a self, path: &'a Path ) -> Result<Box<dyn AsyncReadAndSeek + Unpin + Sync + Send + 'a>, AssetReaderError>

Returns a future to load the full file data at the provided path.

async fn read_directory<'a>( &'a self, path: &'a Path ) -> Result<Box<dyn Stream<Item = PathBuf> + Unpin + Send>, AssetReaderError>

Returns an iterator of directory entry names at the provided path.

async fn is_directory<'a>( &'a self, path: &'a Path ) -> Result<bool, AssetReaderError>

Returns true if the provided path points to a directory.

fn read_meta_bytes<'a>(&'a self, path: &'a Path) -> impl ConditionalSendFuture

Reads asset metadata bytes at the given path into a Vec<u8>. This is a convenience function that wraps AssetReader::read_meta by default.