setup asset load states

src/app.rs

@@ -1,9 +1,11 @@
+use std::default;
+
 use bevy::{
 	asset::RenderAssetUsages,
-	math::VectorSpace,
+	image::ImageSamplerDescriptor,
 	prelude::*,
 	render::{
-		render_resource::{Extent3d, TextureDimension, TextureFormat, TextureUsages},
+		render_resource::{Extent3d, SamplerDescriptor, TextureDimension, TextureFormat, TextureUsages},
 		view::RenderLayers,
 	},
 	window::PrimaryWindow,
@@ -17,11 +19,24 @@ use crate::{
 
 pub struct Blackhole;
 
+#[derive(States, Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub enum AssetLoad {
+	#[default]
+	Pending,
+	Loading,
+	Init,
+	Ready,
+}
+
 impl Plugin for Blackhole {
 	fn build(&self, app: &mut App) {
 		app.register_type::<TracerRenderTextures>();
 
-		app.add_systems(Startup, setup);
+		app.init_state::<AssetLoad>();
+		app.add_systems(Startup, setup)
+			.add_systems(Update, asset_load_check.run_if(in_state(AssetLoad::Loading)))
+			.add_systems(Update, prepare_skybox.run_if(in_state(AssetLoad::Init)))
+			.add_systems(Last, asset_init.run_if(in_state(AssetLoad::Init)));
 		app.add_plugins(TracerPipelinePlugin);
 		app.insert_resource(TracerUniforms {
 			sky_color: LinearRgba::rgb(0.1, 0.0, 0.01),
@@ -41,6 +56,7 @@ fn setup(
 	mut images: ResMut<Assets<Image>>,
 	window: Single<&Window, With<PrimaryWindow>>,
 	asset_server: Res<AssetServer>,
+	mut load_state: ResMut<NextState<AssetLoad>>,
 ) {
 	commands.spawn((
 		PerfUiRoot::default(),
@@ -108,4 +124,27 @@ fn setup(
 		secondary: img1,
 		skybox,
 	});
+
+	load_state.set(AssetLoad::Loading);
+}
+
+fn asset_load_check(
+	mut load_state: ResMut<NextState<AssetLoad>>,
+	tracer_textures: Res<TracerRenderTextures>,
+	asset_server: Res<AssetServer>,
+) {
+	let skybox_load_state = asset_server.load_state(tracer_textures.skybox.id());
+	if skybox_load_state.is_loaded() {
+		load_state.set(AssetLoad::Init);
+		info!("Assets Loaded");
+	}
+}
+
+fn prepare_skybox(tracer_textures: Res<TracerRenderTextures>, image_assets: Res<Assets<Image>>) {
+	let sb = image_assets.get(tracer_textures.skybox.id()).unwrap();
+}
+
+fn asset_init(mut load_state: ResMut<NextState<AssetLoad>>) {
+	load_state.set(AssetLoad::Ready);
+	info!("Assets Initialized");
 }

src/render/node.rs

@@ -75,7 +75,11 @@ impl render_graph::Node for TracerNode {
 		render_context: &mut RenderContext,
 		world: &World,
 	) -> Result<(), render_graph::NodeRunError> {
-		let bind_groups = &world.resource::<TracerImageBindGroups>().0;
+		let bind_groups_res = world.get_resource::<TracerImageBindGroups>();
+		if bind_groups_res.is_none() {
+			return Ok(());
+		}
+		let bind_groups = &bind_groups_res.unwrap().0;
 		let pipeline_cache = world.resource::<PipelineCache>();
 		let pipeline = world.resource::<TracerPipeline>();
 

src/render/pipeline.rs

@@ -18,7 +18,7 @@ use bevy::{
 	},
 };
 
-use crate::{SHADER_ASSET_PATH, components::rt::RTCamera, render::node::TracerNode};
+use crate::{SHADER_ASSET_PATH, app::AssetLoad, components::rt::RTCamera, render::node::TracerNode};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
 pub struct TracerLabel;
@@ -47,9 +47,9 @@ impl Plugin for TracerPipelinePlugin {
 			ExtractResourcePlugin::<TracerUniforms>::default(),
 		));
 		app.init_resource::<TracerUniforms>()
-			.add_systems(Update, switch_textures);
+			.add_systems(Update, switch_textures.run_if(in_state(AssetLoad::Ready)));
 
-		app.add_systems(First, update_tracer_uniforms);
+		app.add_systems(First, update_tracer_uniforms.run_if(in_state(AssetLoad::Ready)));
 		let render_app = app.sub_app_mut(RenderApp);
 
 		// render_app.add_systems(Startup, init_pipeline);
@@ -203,7 +203,12 @@ fn prepare_bind_groups(
 ) {
 	let view_a = gpu_images.get(&tracer_images.main).unwrap();
 	let view_b = gpu_images.get(&tracer_images.secondary).unwrap();
-	let skybox = gpu_images.get(&tracer_images.skybox).unwrap();
+	let skybox_image = gpu_images.get(&tracer_images.skybox);
+	if skybox_image.is_none() {
+		error!("skybox image is not yet loaded");
+		return;
+	}
+	let skybox = skybox_image.unwrap();
 
 	// Uniform buffer is used here to demonstrate how to set up a uniform in a compute shader
 	// Alternatives such as storage buffers or push constants may be more suitable for your use case