Audio: WAV + tinyaudio, Ambient-Emitter mit Distance ramps; artist.md

engine/wav.rs (Decoder) und render/audio.rs (Mixer, 8 SFX-Voices +
Loop-Voice je Emitter) aus irl3d eingebettet; Emitter-Logik headless in
engine/audio.rs. Empties mit sound/radius-Property senden positional,
play_sound-Signale laufen als SFX über Session::take_sounds.
Platzhalter-Sounds + Emitter in der Testszene; artist.md fasst die
Content-Regeln für die Autorin zusammen.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/engine/audio.rs

@@ -0,0 +1,125 @@
+//! Ambient-Emitter aus Blender-Modellen: Empties mit `sound`-Custom-Property
+//! sind positionale Dauerschleifen — `sound = <name>` löst zu
+//! `assets/sounds/{name}.wav` auf (macht der Frontend-Treiber), `radius`
+//! (Meter, optional) bestimmt die Distance ramp.
+//!
+//! Headless wie `trigger`: hier lebt nur die *Logik* — wer sendet wo, und
+//! wie laut ist das gerade für den Hörer ([`Emitters::gains`], lineare
+//! Rampe [`distance_gain`]). Gerätezugriff und Mixing sind Sache des
+//! Frontend-Treibers (render::audio), der die Gains jeden Frame zieht und
+//! auf seine Voices legt — die Engine ruft nie ins Frontend.
+//!
+//! Einmal-SFX laufen nicht hier, sondern über den Signal-Dispatcher
+//! (`play_sound <name>` → `Action::PlaySound` → `Session::take_sounds`).
+
+use crate::engine::model::Model;
+
+/// Custom-Property-Schlüssel, der ein Empty zum Ambient-Emitter macht
+/// (Wert = Sound-Name). Emitter loopen immer; „an/aus" macht die Autorin
+/// über Distanz/Radius oder (später) per Signal.
+pub const SOUND_PROP: &str = "sound";
+/// Optionaler Hörradius in Metern (Custom Property am selben Empty).
+pub const RADIUS_PROP: &str = "radius";
+const DEFAULT_RADIUS: f32 = 8.0;
+
+pub struct Emitter {
+    pub sound: String,
+    pos:    [f32; 3],
+    radius: f32,
+}
+
+#[derive(Default)]
+pub struct Emitters {
+    list: Vec<Emitter>,
+}
+
+impl Emitters {
+    pub fn new() -> Self { Self::default() }
+
+    /// Emitter eines Modells übernehmen: alle Empties mit `sound`-Property.
+    pub fn add_model(&mut self, model: &Model) {
+        for e in &model.empties {
+            let Some(sound) = e.props.get(SOUND_PROP) else { continue; };
+            let radius = e.props.get(RADIUS_PROP)
+                .and_then(|r| r.parse::<f32>().ok())
+                .filter(|r| *r > 0.0)
+                .unwrap_or(DEFAULT_RADIUS);
+            self.list.push(Emitter { sound: sound.clone(), pos: e.pos, radius });
+        }
+    }
+
+    /// Die Emitter in fester Reihenfolge (Voice-Zuordnung des Treibers).
+    pub fn list(&self) -> &[Emitter] { &self.list }
+
+    /// Aktueller Gain je Emitter (parallel zu [`Emitters::list`]) für einen
+    /// Hörer bei `listener` — jeden Frame ziehen, auf die Voices legen.
+    pub fn gains(&self, listener: [f32; 3]) -> Vec<f32> {
+        self.list.iter().map(|e| {
+            let d = [
+                e.pos[0] - listener[0],
+                e.pos[1] - listener[1],
+                e.pos[2] - listener[2],
+            ];
+            let dist = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
+            distance_gain(dist, e.radius)
+        }).collect()
+    }
+}
+
+/// Lineare Distance ramp: volle Lautstärke am Emitter, Stille ab `radius`.
+/// Bewusst linear statt 1/d² — bei Zimmer-Skalen klingt die gerade Rampe
+/// kontrollierbarer, und die Autorin kann per `radius` direkt denken.
+pub fn distance_gain(dist: f32, radius: f32) -> f32 {
+    (1.0 - dist / radius).clamp(0.0, 1.0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::engine::model::{Empty, Props};
+
+    fn model(empties: Vec<Empty>) -> Model {
+        Model { objects: Vec::new(), empties, materials: Vec::new() }
+    }
+
+    fn empty(name: &str, pos: [f32; 3], props: &[(&str, &str)]) -> Empty {
+        let mut p = Props::new();
+        for (k, v) in props { p.insert((*k).into(), (*v).into()); }
+        Empty { name: name.into(), pos, props: p }
+    }
+
+    #[test]
+    fn collects_sound_empties_with_radius() {
+        let mut em = Emitters::new();
+        em.add_model(&model(vec![
+            empty("Radio", [5.0, 0.0, 0.0], &[("sound", "hum"), ("radius", "4")]),
+            empty("spawn", [0.0, 0.0, 0.0], &[("role", "spawn")]),
+            empty("Bach",  [9.0, 0.0, 0.0], &[("sound", "wasser")]),
+        ]));
+        assert_eq!(em.list().len(), 2, "nur Empties mit sound-Property");
+        assert_eq!(em.list()[0].sound, "hum");
+        assert_eq!(em.list()[1].radius, DEFAULT_RADIUS);
+    }
+
+    #[test]
+    fn gains_ramp_linearly_to_radius() {
+        let mut em = Emitters::new();
+        em.add_model(&model(vec![
+            empty("Radio", [0.0, 0.0, 0.0], &[("sound", "hum"), ("radius", "4")]),
+        ]));
+        assert_eq!(em.gains([0.0, 0.0, 0.0]), vec![1.0]);
+        assert_eq!(em.gains([2.0, 0.0, 0.0]), vec![0.5]);
+        assert_eq!(em.gains([4.0, 0.0, 0.0]), vec![0.0]);
+        assert_eq!(em.gains([9.0, 0.0, 0.0]), vec![0.0], "hinter dem Radius still");
+    }
+
+    #[test]
+    fn broken_radius_falls_back_to_default() {
+        let mut em = Emitters::new();
+        em.add_model(&model(vec![
+            empty("A", [0.0; 3], &[("sound", "x"), ("radius", "kaputt")]),
+            empty("B", [0.0; 3], &[("sound", "y"), ("radius", "-2")]),
+        ]));
+        assert!(em.list().iter().all(|e| e.radius == DEFAULT_RADIUS));
+    }
+}