.

Author: tychedelia

Cargo.lock

@@ -197,6 +197,18 @@ path = "examples/field_lifecycle.rs"
 name = "field_from_mesh"
 path = "examples/field_from_mesh.rs"
 
+[[example]]
+name = "field_noise"
+path = "examples/field_noise.rs"
+
+[[example]]
+name = "field_emit_gpu"
+path = "examples/field_emit_gpu.rs"
+
+[[example]]
+name = "field_stress"
+path = "examples/field_stress.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

Cargo.toml

@@ -14,16 +14,22 @@ thread_local! {
 }
 
 pub fn app_mut<T>(cb: impl FnOnce(&mut App) -> error::Result<T>) -> error::Result<T> {
-    let res = APP.with(|app_cell| {
+    // `try_with` rather than `with` so callers (especially `Drop`s running
+    // during pyo3 module teardown) get a graceful error instead of a panic
+    // when the thread-local has already been destroyed.
+    let res = APP.try_with(|app_cell| {
         let mut app_borrow = app_cell
             .try_borrow_mut()
             .map_err(|_| error::ProcessingError::AppAccess)?;
         let app = app_borrow
             .as_mut()
             .ok_or(error::ProcessingError::AppAccess)?;
         cb(app)
-    })?;
-    Ok(res)
+    });
+    match res {
+        Ok(inner) => inner,
+        Err(_) => Err(error::ProcessingError::AppAccess),
+    }
 }
 
 pub fn is_already_init() -> error::Result<bool> {

crates/processing_core/src/lib.rs

@@ -21,6 +21,7 @@ cuda = ["dep:processing_cuda", "processing_cuda/cuda", "processing/cuda"]
 [dependencies]
 pyo3 = { workspace = true, features = ["experimental-inspect", "multiple-pymethods"] }
 processing = { workspace = true }
+processing_render = { workspace = true }
 processing_webcam = { workspace = true, optional = true }
 processing_glfw = { workspace = true }
 bevy = { workspace = true, features = ["file_watcher"] }

crates/processing_pyo3/Cargo.toml

@@ -0,0 +1,71 @@
+from mewnala import *
+
+field_obj = None
+sphere = None
+mat = None
+spin = None
+
+SPIN_SHADER = """
+struct Params {
+    dt: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> position: array<f32>;
+@group(0) @binding(1) var<uniform> params: Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let count = arrayLength(&position) / 3u;
+    if i >= count {
+        return;
+    }
+    let cs = cos(params.dt);
+    let sn = sin(params.dt);
+    let x = position[i * 3u + 0u];
+    let z = position[i * 3u + 2u];
+    position[i * 3u + 0u] = x * cs - z * sn;
+    position[i * 3u + 2u] = x * sn + z * cs;
+}
+"""
+
+
+def setup():
+    global field_obj, sphere, mat, spin
+
+    size(900, 700)
+    mode_3d()
+
+    create_directional_light((0.9, 0.85, 0.8), 300.0)
+
+    sphere = Geometry.sphere(0.25, 12, 8)
+
+    capacity = 1000
+    positions = []
+    for x in range(10):
+        for y in range(10):
+            for z in range(10):
+                positions.extend([x - 4.5, y - 4.5, z - 4.5])
+
+    field_obj = Field(capacity=capacity, attributes=[Attribute.position()])
+    pos_buf = field_obj.pbuffer(Attribute.position())
+    pos_buf.write(positions)
+
+    mat = Material(roughness=0.4)
+    spin = Compute(Shader(SPIN_SHADER))
+
+
+def draw():
+    camera_position(0.0, 8.0, 25.0)
+    camera_look_at(0.0, 0.0, 0.0)
+    background(15, 15, 20)
+    fill(230, 128, 75)
+
+    use_material(mat)
+    draw_field(field_obj, sphere)
+
+    spin.set(dt=0.01)
+    field_obj.apply(spin)
+
+
+run()

crates/processing_pyo3/examples/field_animated.py

@@ -0,0 +1,59 @@
+from mewnala import *
+
+field_obj = None
+particle = None
+mat = None
+
+
+def setup():
+    global field_obj, particle, mat
+
+    size(900, 700)
+    mode_3d()
+
+    create_directional_light((0.95, 0.9, 0.85), 600.0)
+
+    # Source mesh whose vertices become particle positions; uvs come along for
+    # free and we use them to color each particle.
+    source = Geometry.sphere(5.0, 32, 24)
+    field_obj = Field(
+        geometry=source,
+        attributes=[Attribute.position(), Attribute.uv(), Attribute.color()],
+    )
+
+    # Read uvs back, build per-particle colors, write to color PBuffer.
+    color_buf = field_obj.pbuffer(Attribute.color())
+    uv_buf = field_obj.pbuffer(Attribute.uv())
+    colors = []
+    for uv in uv_buf.read():
+        u = uv[0]
+        h = u * 6.0
+        c = h - int(h)
+        if h < 1:
+            colors.append([1.0, c, 0.0, 1.0])
+        elif h < 2:
+            colors.append([1.0 - c, 1.0, 0.0, 1.0])
+        elif h < 3:
+            colors.append([0.0, 1.0, c, 1.0])
+        elif h < 4:
+            colors.append([0.0, 1.0 - c, 1.0, 1.0])
+        elif h < 5:
+            colors.append([c, 0.0, 1.0, 1.0])
+        else:
+            colors.append([1.0, 0.0, 1.0 - c, 1.0])
+    color_buf.write(colors)
+
+    particle = Geometry.sphere(0.18, 10, 8)
+    mat = Material.field_pbr(color_buf)
+
+
+def draw():
+    camera_position(0.0, 4.0, 18.0)
+    camera_look_at(0.0, 0.0, 0.0)
+    background(15, 15, 20)
+
+    use_material(mat)
+    draw_field(field_obj, particle)
+
+
+run()

crates/processing_pyo3/examples/field_basic.py

@@ -18,6 +18,20 @@ pub struct Buffer {
     size: u64,
 }
 
+impl Buffer {
+    /// Wrap an existing buffer entity (e.g., one owned by a Field's PBuffer).
+    /// `size` is queried from the buffer; `element_type` is supplied so typed
+    /// reads / `__getitem__` work correctly.
+    pub(crate) fn from_entity(entity: Entity, element_type: Option<ShaderValue>) -> Self {
+        let size = buffer_size(entity).unwrap_or(0);
+        Self {
+            entity,
+            element_type,
+            size,
+        }
+    }
+}
+
 #[pymethods]
 impl Buffer {
     #[new]
@@ -245,6 +259,14 @@ pub struct Compute {
     pub(crate) entity: Entity,
 }
 
+impl Compute {
+    /// Wrap an existing compute entity (e.g., one created by a Rust-side
+    /// factory like `field_kernel_noise`). Not exposed to Python directly.
+    pub(crate) fn from_entity(entity: Entity) -> Self {
+        Self { entity }
+    }
+}
+
 #[pymethods]
 impl Compute {
     #[new]