Fix loading.

Author: tychedelia

crates/processing_pyo3/assets

@@ -0,0 +1 @@
+/Users/char/src/github.com/processing/libprocessing/assets/

crates/processing_pyo3/examples/custom_material.py

@@ -7,7 +7,7 @@ def setup():
     size(800, 600)
     mode_3d()
 
-    frag = Shader.load("assets/shaders/custom_material.wesl")
+    frag = Shader.load("shaders/custom_material.wesl")
     mat = Material(fragment=frag, color=[1.0, 0.2, 0.4, 1.0])
 
 def draw():

crates/processing_render/src/lib.rs

@@ -1317,10 +1317,12 @@ pub fn shader_create(source: &str) -> error::Result<Entity> {
 
 /// Load a shader from a file path.
 pub fn shader_load(path: &str) -> error::Result<Entity> {
-    let source = std::fs::read_to_string(path).map_err(|e| {
-        error::ProcessingError::ShaderCompilationError(format!("Failed to read {path}: {e}"))
-    })?;
-    shader_create(&source)
+    let path = std::path::PathBuf::from(path);
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(material::custom::load_shader, path)
+            .unwrap()
+    })
 }
 
 pub fn shader_destroy(entity: Entity) -> error::Result<()> {

crates/processing_render/src/material/custom.rs

@@ -42,6 +42,7 @@ use bevy_naga_reflect::dynamic_shader::DynamicShader;
 
 use bevy::shader::Shader as ShaderAsset;
 
+use crate::config::{Config, ConfigKey};
 use crate::error::{ProcessingError, Result};
 use crate::material::MaterialValue;
 use crate::render::material::UntypedMaterial;
@@ -140,6 +141,56 @@ pub fn create_shader(
         .id())
 }
 
+pub fn load_shader(In(path): In<std::path::PathBuf>, world: &mut World) -> Result<Entity> {
+    use bevy::asset::{
+        AssetPath, LoadState, handle_internal_asset_events,
+        io::{AssetSourceId, embedded::GetAssetServer},
+    };
+    use bevy::ecs::system::RunSystemOnce;
+
+    let config = world.resource::<Config>();
+    let asset_path: AssetPath = match config.get(ConfigKey::AssetRootPath) {
+        Some(_) => {
+            AssetPath::from_path_buf(path).with_source(AssetSourceId::from("assets_directory"))
+        }
+        None => AssetPath::from_path_buf(path),
+    };
+
+    let handle: Handle<ShaderAsset> = world.get_asset_server().load(asset_path);
+
+    while let LoadState::Loading = world.get_asset_server().load_state(&handle) {
+        world.run_system_once(handle_internal_asset_events).unwrap();
+    }
+
+    let source = {
+        let shader_assets = world.resource::<Assets<ShaderAsset>>();
+        let shader = shader_assets
+            .get(&handle)
+            .ok_or(ProcessingError::ShaderNotFound)?;
+        match &shader.source {
+            bevy::shader::Source::Wesl(s) | bevy::shader::Source::Wgsl(s) => s.to_string(),
+            _ => {
+                return Err(ProcessingError::ShaderCompilationError(
+                    "Unsupported shader source format".to_string(),
+                ));
+            }
+        }
+    };
+
+    let (compiled_wgsl, module) = compile_shader(&source)?;
+
+    let shader_handle = world
+        .resource_mut::<Assets<ShaderAsset>>()
+        .add(ShaderAsset::from_wgsl(compiled_wgsl, "custom_material"));
+
+    Ok(world
+        .spawn(Shader {
+            module,
+            shader_handle,
+        })
+        .id())
+}
+
 pub fn destroy_shader(In(entity): In<Entity>, mut commands: Commands) -> Result<()> {
     commands.entity(entity).despawn();
     Ok(())

examples/custom_material.rs

@@ -31,9 +31,7 @@ fn sketch() -> error::Result<()> {
     transform_set_position(graphics, 100.0, 100.0, 300.0)?;
     transform_look_at(graphics, 0.0, 0.0, 0.0)?;
 
-    let frag_source = std::fs::read_to_string("assets/shaders/custom_material.wesl")
-        .map_err(|e| error::ProcessingError::ShaderCompilationError(e.to_string()))?;
-    let frag = shader_create(&frag_source)?;
+    let frag = shader_load("shaders/custom_material.wesl")?;
     let mat = material_create_custom(None, Some(frag))?;
     material_set(
         mat,