It would be great if there was added support for CSV files, the csv crate already has support for serde!

The code examples already use level.json instead of json.level. Do the same in the readme.

I'm trying to app.register_asset_processor::<LoadTransformAndSave<RonAssetLoader<MyAsset>, _, _>>(LoadTransformAndSave::new(..., ...), but I cannot, bc RonAssetLoader is private

Use https://doc.rust-lang.org/beta/unstable-book/language-features/doc-cfg.html to have notes on docs.rs for required crate features.

I'm trying to optimize my cargo build times for my project, and a major slow down I've noticed for recompiles is bevy_sprite. I'm making a 3d project, and I'd like to be able to remove bevy_sprite, since I don't need it, but this crate makes it a hard dependency.

A '2d' feature flag would let people who use this crate and bevy_asset_loader to remove bevy_sprite, and speed up re-compiles for 3d projects.

This would allow for all xml file types (custom, html, etc.) to be used as assets.

I would be happy to code it up myself with a little guidance if needed!

Just trying to use the JsonAssetPlugin:

use bevy_common_assets::json::JsonAssetPlugin;

But this won't compile. Here's the error I get:

Am I doing something wrong? Btw I'm fairly new to Rust.

Bevy now has AssetSaver. This allows a cross-platform way of saving assets by:

1. Getting an AssetWriter from an AssetSource (from AssetServer)
2. Calling AssetWriter::write to get an AsyncWrite object.
3. Calling AssetSaver::save with that AsyncWrite object.

In the future this will likely be streamlined but for now we should support AssetSaver to support this "canonical" workflow.

bevy 1.12.1
Currently figuring out how to use this crate, i added the plugin like so:

        .add_plugins((
            DefaultPlugins, 
            YamlAssetPlugin::<World>::new(&["world.yml"])
        ))

#[derive(Deserialize, Asset, TypePath, Debug)]
struct World {
    name: String,
    width: u8,
    height: u8,
}


fn load_world(
    server: Res<AssetServer>,
    mut images: ResMut<Assets<Image>>,
    mut worlds: ResMut<Assets<World>>,
    mut commands: Commands
) {
    let handle: Handle<World> = server.load("world.yaml");
    
    if let Some(x) = worlds.get_mut(handle.id()) {
        println!("{:?}", x);
    } else {
        println!("Did not find!")
    }
}

This comes up with "did not find!" and the error found in the title: ERROR bevy_asset::server: no 'AssetLoader' found for the following extension: yaml This error also occurs when changing everything to 'yml'.
The yaml file is very simple and as far as i know, this should work?

name: Cloob
width: 64
height: 32

What is going wrong?
Thanks in advance!

Edit: The example contains wrong code, worlds.get_mut(handle.id()) should be in a Update script. It still gives the error regardless.

I have structs SpritesData and SoundsData, and I want to parse them from sprites.data.ron and sounds.data.ron respectively.
A new example would be nice.

Could you please add an example of how to read a struct in addition to the vector?

See e.g. https://github.com/3Hren/msgpack-rust/tree/master/rmp-serde

So I'm trying to replicate something similar to this

struct Projectile {
    sprite: Handle<Image>
}

Where an Asset called Projectile has a reference to another asset inside.

I could not get it to work with bevy_asset_loader

Is there some example code I can look at to be sure I'm using it correctly?
error:

thread 'main' panicked at 'Requested resource bevy_asset::asset_server::AssetServer does not exist in the `World`. 
                Did you forget to add it using `app.insert_resource` / `app.init_resource`? 
                Resources are also implicitly added via `app.add_event`,
                and can be added by plugins.', /home/pinkponk/.cargo/registry/src/github.com-1ecc6299db9ec823/bevy_asset-0.8.1/src/assets.rs:324:43

Usage:

...
.with_collection::<WorldAssets>()
...
.add_plugin(JsonAssetPlugin::<WorldConfigJson>::new(&["json.world"]))

#[derive(serde::Deserialize, bevy::reflect::TypeUuid)]
#[uuid = "413be529-bfeb-41b3-9db0-4b8b38022c46"]
pub struct WorldConfigJson {
    plants: Vec<String>,
    spawns: Vec<SpawnsJson>,
}

#[derive(serde::Deserialize)]
pub struct SpawnsJson {
    species: String,
    nr_creatures: u32,
    radius: f32,
    age_factor: f32,
    world_pos_factor: [f32; 2],
}

pub fn configure_world(
    mut commands: Commands,
    world_assets: Res<WorldAssets>,
    mut world_config_jsons: ResMut<Assets<WorldConfigJson>>,
) {
...}

file:

{
    "plants": [
        "mushroom",
        "grass",
        "tree",
        "bush",
        "carrot"
    ],
    "spawns": [
        {
            "species": "fox",
            "nr_creatures": 3,
            "radius": 10.0,
            "age_factor": 0.5,
            "world_pos_factor": [
                0.1,
                0.1
            ]
        }
    ]
}

TL;DR

Could this repository include a common asset type and loader for loading generic serde_json::Value, toml_edit::Document, etc. types from files with the generic format extension like .json/.toml rather than a specific extension?

Background

I built something closely related to this for loading plugin settings from specific configuration files: https://github.com/devnev/bevy_settings_loader

But in my plugin, the settings are resource singletons and not identified by file extensions but by the full path to the file. So I add a generic .json / .toml loader and then deserialise from the loaded value into the destination type for the asset matching the settings path.

For that I've added generic JsonAsset and TomlAsset types that wrap serde_json::Value and toml_edit::Document loaded from arbitrary files with the corresponding extension. However, my repository/package/plugin is too specific for something that generic, whereas this repository seems more suitable and has most of the code for it already.

The main missing pieces is a wrapper implementing Asset for serde_json::Value etc, which would allow other plugins to avoid duplicate registration of loaders for the corresponding extension.