alpha.3 fixes

Author: tychedelia

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "processing"
-version = "0.0.9-alpha.3"
+version = "0.0.9-alpha.4"
 edition = "2024"
 autoexamples = false
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "processing_pyo3"
-version = "0.0.9-alpha.3"
+version = "0.0.9-alpha.4"
 edition = "2024"
 
 [lints]

crates/processing_pyo3/Cargo.toml

@@ -2,7 +2,7 @@ use bevy::prelude::Entity;
 use processing::prelude::*;
 use pyo3::{exceptions::PyRuntimeError, prelude::*};
 
-use crate::graphics::{Geometry, Light};
+use crate::graphics::{Geometry, Image, Light};
 use crate::material::Material;
 
 #[pyclass(unsendable)]
@@ -35,6 +35,13 @@ impl Gltf {
         Ok(Material { entity })
     }
 
+    /// The texture on the named mesh, e.g. for `LOOKUP`.
+    pub fn texture(&self, name: &str) -> PyResult<Image> {
+        let entity = gltf_texture(self.entity, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Image::wrap(entity))
+    }
+
     pub fn mesh_names(&self) -> PyResult<Vec<String>> {
         gltf_mesh_names(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }

crates/processing_pyo3/src/gltf.rs

@@ -8,7 +8,7 @@ use bevy::{
     },
     camera::visibility::RenderLayers,
     ecs::system::RunSystemOnce,
-    gltf::{Gltf, GltfMaterial, GltfMeshName},
+    gltf::{Gltf, GltfMaterial, GltfMaterialName, GltfMeshName},
     pbr::ExtendedMaterial,
     prelude::*,
     world_serialization::WorldInstanceSpawner,
@@ -138,21 +138,7 @@ pub fn geometry(
     let instance_id = gltf_handle.instance_id;
 
     let (mesh_handle, global_transform) = {
-        let spawner = world.resource::<WorldInstanceSpawner>();
-
-        // find the mesh with the given name component that bevy added post-spawn
-        // name is derived from gltf node or computed
-        let mesh_entity = spawner
-            .iter_instance_entities(instance_id)
-            .find(|&e| {
-                world
-                    .get::<GltfMeshName>(e)
-                    .map(|n| n.0 == name)
-                    .unwrap_or(false)
-            })
-            .ok_or_else(|| {
-                ProcessingError::GltfLoadError(format!("Mesh '{}' not found in GLTF scene", name))
-            })?;
+        let mesh_entity = find_mesh_entity(world, instance_id, &name)?;
 
         let mesh3d = world.get::<Mesh3d>(mesh_entity).ok_or_else(|| {
             ProcessingError::GltfLoadError(format!(
@@ -182,6 +168,64 @@ pub fn geometry(
     Ok(entity)
 }
 
+/// The scene entity bevy spawned for a mesh, by the name it gave that mesh (from the
+/// glTF node, or computed).
+fn find_mesh_entity(
+    world: &World,
+    instance_id: bevy::world_serialization::InstanceId,
+    name: &str,
+) -> Result<Entity> {
+    world
+        .resource::<WorldInstanceSpawner>()
+        .iter_instance_entities(instance_id)
+        .find(|&e| world.get::<GltfMeshName>(e).is_some_and(|n| n.0 == name))
+        .ok_or_else(|| {
+            ProcessingError::GltfLoadError(format!("Mesh '{}' not found in GLTF scene", name))
+        })
+}
+
+/// The base color texture of a mesh's material, as an [`Image`](crate::image::Image).
+pub fn texture(In((gltf_entity, name)): In<(Entity, String)>, world: &mut World) -> Result<Entity> {
+    let gltf_handle = world
+        .get::<GltfHandle>(gltf_entity)
+        .ok_or(ProcessingError::InvalidEntity)?;
+    let (instance_id, handle) = (gltf_handle.instance_id, gltf_handle.handle.clone());
+
+    let mesh_entity = find_mesh_entity(world, instance_id, &name)?;
+    let material_name = world
+        .get::<GltfMaterialName>(mesh_entity)
+        .ok_or_else(|| {
+            ProcessingError::GltfLoadError(format!("Mesh '{}' has no material", name))
+        })?
+        .0
+        .clone();
+
+    let texture = {
+        let gltf = world
+            .resource::<Assets<Gltf>>()
+            .get(&handle)
+            .ok_or_else(|| ProcessingError::GltfLoadError("GLTF asset not found".into()))?;
+        let material = gltf
+            .named_materials
+            .get(material_name.as_str())
+            .and_then(|h| world.resource::<Assets<GltfMaterial>>().get(h))
+            .ok_or_else(|| {
+                ProcessingError::GltfLoadError(format!(
+                    "Material '{}' not found in GLTF",
+                    material_name
+                ))
+            })?;
+        material.base_color_texture.clone().ok_or_else(|| {
+            ProcessingError::GltfLoadError(format!("Mesh '{}' has no texture", name))
+        })?
+    };
+
+    block_on_load(world, |w| w.get_asset_server().load_state(&texture))?;
+    world
+        .run_system_once_with(crate::image::from_handle, texture)
+        .unwrap()
+}
+
 /// Translate a bevy [`GltfMaterial`] into the [`StandardMaterial`] base of a
 /// [`ProcessingExtendedMaterial`]. `GltfMaterial` mirrors `StandardMaterial`'s
 /// fields, so we copy across the ones that drive shading and let the rest fall

crates/processing_render/src/gltf.rs

@@ -2290,6 +2290,15 @@ pub fn gltf_material(gltf_entity: Entity, name: &str) -> error::Result<Entity> {
     })
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub fn gltf_texture(gltf_entity: Entity, name: &str) -> error::Result<Entity> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(gltf::texture, (gltf_entity, name.to_string()))
+            .unwrap()
+    })
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn gltf_mesh_names(gltf_entity: Entity) -> error::Result<Vec<String>> {
     app_mut(|app| {

crates/processing_render/src/lib.rs

@@ -23,6 +23,17 @@ pub fn particles_emit_gpu(
         return Ok(());
     }
 
+    let required: Vec<Entity> = app_mut(|app| {
+        Ok(app
+            .world()
+            .get::<KernelRequires>(compute_entity)
+            .map(|r| r.0.clone())
+            .unwrap_or_default())
+    })?;
+    for attr_entity in required {
+        particles_ensure_attribute(particles_entity, attr_entity)?;
+    }
+
     let (capacity, head, buffers) = app_mut(|app| {
         let world = app.world();
         let field = world

crates/processing_render/src/particles/emit.rs

@@ -15,7 +15,7 @@ use crate::{compute_create, compute_set, shader_load};
 #[derive(Component, Default, Clone)]
 pub struct KernelRequires(pub Vec<Entity>);
 
-fn set_requires(compute: Entity, names: &[&str]) -> error::Result<()> {
+pub(crate) fn set_requires(compute: Entity, names: &[&str]) -> error::Result<()> {
     app_mut(|app| {
         let world = app.world_mut();
         let attrs: Vec<Entity> = {

crates/processing_render/src/particles/kernels/mod.rs

@@ -21,6 +21,8 @@ struct EmitRange {
 @group(0) @binding(6) var<storage, read_write> life:            array<f32>;
 @group(0) @binding(7) var<uniform>             params:          Params;
 @group(0) @binding(8) var<uniform>             emit_range:      EmitRange;
+@group(0) @binding(9) var<storage, read>       source_uv:       array<f32>;
+@group(0) @binding(10) var<storage, read_write> uv:             array<f32>;
 
 fn hash(n: u32) -> u32 {
     var x = n;
@@ -91,6 +93,13 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     position[slot * 3u + 0u] = p.x;
     position[slot * 3u + 1u] = p.y;
     position[slot * 3u + 2u] = p.z;
+    // texture coordinate at the same spot, for LOOKUP
+    let t0 = vec2<f32>(source_uv[i0 * 2u], source_uv[i0 * 2u + 1u]);
+    let t1 = vec2<f32>(source_uv[i1 * 2u], source_uv[i1 * 2u + 1u]);
+    let t2 = vec2<f32>(source_uv[i2 * 2u], source_uv[i2 * 2u + 1u]);
+    let t = (1.0 - u - v) * t0 + u * t1 + v * t2;
+    uv[slot * 2u + 0u] = t.x;
+    uv[slot * 2u + 1u] = t.y;
     scale[slot * 3u + 0u] = 1.0;
     scale[slot * 3u + 1u] = 1.0;
     scale[slot * 3u + 2u] = 1.0;

crates/processing_render/src/particles/kernels/scatter_surface.wgsl

@@ -5,24 +5,27 @@ use processing_core::app_mut;
 use processing_core::error::{self, ProcessingError, Result};
 
 use crate::geometry::Geometry;
+use crate::particles::kernels::set_requires;
 use crate::shader_value::ShaderValue;
 use crate::{
     buffer_create_with_data, compute_create, compute_set, geometry_attribute_position, shader_load,
 };
 
 pub fn particles_scatter_create(source_geometry: Entity) -> error::Result<Entity> {
-    let (cdf_bytes, indices_bytes, face_count) = app_mut(|app| {
+    let (cdf_bytes, indices_bytes, uv_bytes, face_count) = app_mut(|app| {
         app.world_mut()
             .run_system_cached_with(prepare_scatter_source, source_geometry)
             .unwrap()
     })?;
 
     let cdf_buf = buffer_create_with_data(cdf_bytes)?;
     let idx_buf = buffer_create_with_data(indices_bytes)?;
+    let uv_buf = buffer_create_with_data(uv_bytes)?;
 
     let shader =
         shader_load("embedded://processing_render/particles/kernels/scatter_surface.wgsl")?;
     let scatter = compute_create(shader)?;
+    set_requires(scatter, &["position", "scale", "age", "life", "uv"])?;
 
     let position_attr = geometry_attribute_position();
     compute_set(
@@ -32,6 +35,7 @@ pub fn particles_scatter_create(source_geometry: Entity) -> error::Result<Entity
     )?;
     compute_set(scatter, "source_indices", ShaderValue::Buffer(idx_buf))?;
     compute_set(scatter, "cdf", ShaderValue::Buffer(cdf_buf))?;
+    compute_set(scatter, "source_uv", ShaderValue::Buffer(uv_buf))?;
     compute_set(scatter, "face_count", ShaderValue::UInt(face_count))?;
     compute_set(scatter, "seed", ShaderValue::UInt(0xc0ffeeu32))?;
 
@@ -119,7 +123,7 @@ pub fn prepare_scatter_source(
     In(geom_entity): In<Entity>,
     geometries: Query<&Geometry>,
     mut meshes: ResMut<Assets<Mesh>>,
-) -> Result<(Vec<u8>, Vec<u8>, u32)> {
+) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>, u32)> {
     let geom = geometries
         .get(geom_entity)
         .map_err(|_| ProcessingError::GeometryNotFound)?;
@@ -130,6 +134,11 @@ pub fn prepare_scatter_source(
 
     let (positions, dense_indices) = extract_scatter_geometry(mesh)?;
     let face_count = (dense_indices.len() / 3) as u32;
+    // a mesh without UVs scatters with uv (0, 0)
+    let uvs = match mesh.attribute(Mesh::ATTRIBUTE_UV_0) {
+        Some(VertexAttributeValues::Float32x2(uv)) => uv.clone(),
+        _ => vec![[0.0, 0.0]; positions.len()],
+    };
 
     let mut cum = Vec::with_capacity(face_count as usize);
     let mut total = 0.0_f32;
@@ -156,7 +165,8 @@ pub fn prepare_scatter_source(
 
     let cdf_bytes: Vec<u8> = cum.iter().flat_map(|f| f.to_le_bytes()).collect();
     let indices_bytes: Vec<u8> = dense_indices.iter().flat_map(|i| i.to_le_bytes()).collect();
-    Ok((cdf_bytes, indices_bytes, face_count))
+    let uv_bytes: Vec<u8> = uvs.iter().flatten().flat_map(|f| f.to_le_bytes()).collect();
+    Ok((cdf_bytes, indices_bytes, uv_bytes, face_count))
 }
 
 pub fn prepare_scatter_volume_source(