bevy_common_assets

To load custom asset types from RON (Rusty Object Notation) files, use the RonAssetPlugin<A>. This plugin registers a RonAssetLoader for your type A. Your type must implement serde::Deserialize, bevy_asset::Asset, and bevy_reflect::TypePath.

use bevy::prelude::*;
use bevy_common_assets::ron::RonAssetPlugin;
use serde::Deserialize;
use bevy_reflect::TypePath;

#[derive(Deserialize, Asset, TypePath)]
struct Level {
    value: Option<f32>,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(RonAssetPlugin::<Level>::new(&["level.ron"]))
        .run();
}

To load a custom asset type A from TOML files, use the TomlAssetPlugin<A>. Your asset type must implement bevy::asset::Asset and serde::Deserialize. You must specify the file extensions (e.g., ["toml"]) that the plugin should associate with this asset type.

Note: The asset type must be compatible with serde for deserialization.

use bevy::prelude::*;
use bevy_common_assets::toml::TomlAssetPlugin;
use serde::Deserialize;

#[derive(Asset, TypePath, Deserialize, Debug)]
struct MyConfig {
    value: u32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(TomlAssetPlugin::<MyConfig>::new(&["toml"]))
        .run();
}

To load custom asset types from MessagePack files, use the MsgPackAssetPlugin<A> plugin. The asset type A must implement bevy::asset::Asset and serde::Deserialize.

When initializing the plugin, you must provide a slice of file extensions (e.g., &["msgpack"]) that the loader should respond to.

use bevy::prelude::*;
use bevy_common_assets::msgpack::MsgPackAssetPlugin;

#[derive(Asset, TypePath, serde::Deserialize, serde::Serialize)]
struct MyData {
    value: u32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(MsgPackAssetPlugin::<MyData>::new(&["msgpack"]))
        .run();
}

To load a custom asset type A from YAML files, use the YamlAssetPlugin<A>. The asset type A must implement bevy::asset::Asset and serde::Deserialize.

You can specify which file extensions the plugin should respond to (e.g., ["yaml", "yml"]) when initializing the plugin.

use bevy::prelude::*;
use bevy_common_assets::yaml::YamlAssetPlugin;
use serde::Deserialize;

#[derive(Asset, TypePath, Deserialize, Debug)]
struct MyAsset {
    value: String,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(YamlAssetPlugin::<MyAsset>::new(&["yaml", "yml"]))
        .run();
}

To load a custom asset type A from CSV files, use the CsvAssetPlugin<A>. Your asset type A must implement serde::Deserialize, bevy_asset::Asset, and bevy_reflect::TypePath.

When you add this plugin, it registers a LoadedCsv<A> asset type and a CsvAssetLoader<A> that handles the file extensions you specify.

use bevy::prelude::*;
use bevy_common_assets::csv::CsvAssetPlugin;
use bevy_reflect::TypePath;

#[derive(serde::Deserialize, Asset, TypePath, Debug)]
struct TreePosition {
    x: f32,
    y: f32,
    z: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // Register the plugin for TreePosition with .csv extension
        .add_plugins(CsvAssetPlugin::<TreePosition>::new(&["csv"]))
        .run();
}

To load a custom asset type A from XML files, use the XmlAssetPlugin<A>. The asset type A must implement bevy::asset::Asset and serde::Deserialize.

When initializing the plugin, you must provide a slice of file extensions (e.g., &["xml"]) that the loader should respond to. The plugin handles both registering the asset type and registering the XmlAssetLoader with Bevy.

use bevy::prelude::*;
use bevy_common_assets::xml::XmlAssetPlugin;
use serde::Deserialize;

#[derive(Asset, TypePath, Deserialize, Debug)]
struct MyXmlAsset {
    // your fields here
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(XmlAssetPlugin::<MyXmlAsset>::new(&["xml"]))
        .run();
}

The CborAssetPlugin<A> allows you to load custom asset types A from files using the Concise Binary Object Representation (CBOR) format. To use it, your asset type must implement bevy_asset::Asset and serde::Deserialize. You must specify the file extensions that the plugin should associate with this asset type.

use bevy::prelude::*;
use bevy_common_assets::cbor::CborAssetPlugin;
use serde::{Deserialize, Serialize};

#[derive(Asset, TypePath, Serialize, Deserialize, Debug)]
struct MyCborAsset {
    value: u32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // Register the plugin with specific extensions (e.g., "cbor")
        .add_plugins(CborAssetPlugin::<MyCborAsset>::new(&["cbor"]))
        .run();
}

To load custom asset types using the postcard serialization format, use the PostcardAssetPlugin<A> plugin. You must provide a list of file extensions that the plugin should associate with your asset type A.

Your asset type A must implement bevy_asset::Asset and serde::Deserialize.

use bevy::prelude::*;
use bevy_common_assets::postcard::PostcardAssetPlugin;

#[derive(Asset, serde::Deserialize, serde::Serialize, TypePath, Debug)]
struct MyData {
    value: u32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // Register the plugin for MyData with .postcard extensions
        .add_plugins(PostcardAssetPlugin::<MyData>::new(&["postcard"]))
        .run();
}

The library supports the following formats: