Loading assets is ambiguous between the source asset and the processed asset.

[andriyDev]

Imagine an asset in your assets directory at path my_thingy.sphere.

struct SphereAsset {
    radius: f32
}

We also create an asset processor to convert this SphereAsset into a Mesh. Now consider we have two assets that want to load this asset:

struct BooleanOperator {
    sphere1: Handle<SphereAsset>,
    sphere2: Handle<SphereAsset>,
}

struct Collider {
    mesh: Handle<Mesh>,
}

Inside the loader of these, they will both try to load "my_thingy.sphere", except with different types! One of these is not valid, and will fail when loading (even during processing).

This is even worse with one-to-many asset processing, where the original path may no longer even exist (since the one asset may have been broken into several pieces).

[andriyDev]

Maybe the answer here is to annotate every AssetLoader nested load with the desired "state". So you'd say load_context.load("some/path.txt", AssetMode::Unprocessed). This is incredibly cumbersome though and forces asset loaders to pick per asset whether they expect to be loading processed or unprocessed assets.

Alternatively, maybe we can specify for the entire loader that it expects to load unprocessed or processed assets. So something like a GltfLoader would expect to load unprocessed assets, whereas something like BSN would expect to load processed assets. Basically we'd be partitioning our loaders based on whether we expect their assets to be created "outside" bevy vs "inside" bevy.

[andriyDev]

Oh one more option. The meta file could have a flag to decide whether to load processed or unprocessed assets. This would effectively declare whether you authored the asset before or after importing other assets.

[andriyDev]

I had a longer think. First of course, if you're in Unprocessed or Processed mode this whole issue doesn't matter. Both of these cases should only be loading wholly source assets or wholly processed assets respectively. Only during processing is this a problem.

Which led me to a straight forward solution: when you call ProcessContext::load_source_asset you should specify whether you expect processed or unprocessed nested asset loads. I don't think we need anything fine-grained. Either an asset is authored without Bevy in mind (like a GLTF) so it should load source assets, or it was authored with Bevy in mind and so should use the processed assets.