Wire post-process passes, audio, animation, and AI behavior trees

Four previously unconnected subsystems now execute at runtime in the
MOBA demo:

1. Post-process: DoF and Motion Blur passes instantiated on Renderer,
   executed between TAA and the PostProcessStack. TAA enabled in
   dota_client. High quality preset already enables motion blur + DoF.

2. Audio: AudioEngine (Kira 0.12) initialized with bus settings.
   audio_update_system_mut() called each frame for spatial positioning,
   bus volume sync, and playback lifecycle management.

3. Animation: euca-animation added to euca-game. AnimationLibrary and
   AnimationEventLibrary resources inserted. animation_evaluate_system()
   called each frame for state machine transitions, pose blending,
   montage playback, and IK solving.

4. AI Behavior Trees: euca-ai added to euca-gameplay. New bt_perception
   system populates blackboards with self_position, nearest_enemy,
   enemy_distance. behavior_tree_system ticks all BT executors.
   bt_moveto_system bridges MoveTo actions to ECS velocity. Runs
   alongside existing ai_system (both coexist — AiGoal vs BT entities).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stainlu

Cargo.lock

@@ -20,8 +20,10 @@ euca-net = { path = "../euca-net" }
 euca-input = { path = "../euca-input" }
 euca-core = { path = "../euca-core" }
 euca-gameplay = { path = "../euca-gameplay" }
+euca-ai = { path = "../euca-ai" }
 euca-agent = { path = "../euca-agent" }
 euca-audio = { path = "../euca-audio" }
+euca-animation = { path = "../euca-animation" }
 euca-nav = { path = "../euca-nav" }
 euca-asset = { path = "../euca-asset" }
 euca-terrain = { path = "../euca-terrain", features = ["level-render"] }

crates/euca-game/Cargo.toml

@@ -14,6 +14,7 @@ euca-math = { path = "../euca-math" }
 euca-physics = { path = "../euca-physics" }
 euca-render = { path = "../euca-render" }
 euca-scene = { path = "../euca-scene" }
+euca-ai = { path = "../euca-ai" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 bincode = "1"

crates/euca-gameplay/Cargo.toml

@@ -0,0 +1,52 @@
+//! Behavior tree action handlers — bridge BT intent to ECS mutations.
+//!
+//! The [`euca_ai::BtAction::MoveTo`] action signals intent without moving the
+//! entity. This system reads the blackboard target and applies velocity,
+//! mirroring the logic in [`crate::ai::ai_system`].
+
+use euca_ai::BehaviorTreeExecutor;
+use euca_ecs::{Entity, Query, World};
+use euca_math::{Quat, Vec3};
+use euca_physics::Velocity;
+use euca_scene::LocalTransform;
+
+/// Default movement speed for BT-controlled entities.
+const BT_MOVE_SPEED: f32 = 4.0;
+
+/// Apply movement for entities whose behavior tree has a `MoveTo` action running.
+///
+/// Reads `"enemy_position"` or `"patrol_target"` from the blackboard (whichever
+/// the active MoveTo references) and steers the entity toward it.
+pub fn bt_moveto_system(world: &mut World) {
+    let updates: Vec<(Entity, Vec3)> = {
+        let query = Query::<(Entity, &BehaviorTreeExecutor, &LocalTransform)>::new(world);
+        query
+            .iter()
+            .filter_map(|(e, exec, lt)| {
+                // Check common target keys in priority order.
+                let target_pos = exec
+                    .blackboard
+                    .get_vec3("enemy_position")
+                    .or_else(|| exec.blackboard.get_vec3("patrol_target"))?;
+                let self_pos = lt.0.translation;
+                let delta = target_pos - self_pos;
+                let horizontal = Vec3::new(delta.x, 0.0, delta.z);
+                if horizontal.length() < 0.3 {
+                    return None; // Close enough
+                }
+                Some((e, horizontal.normalize()))
+            })
+            .collect()
+    };
+
+    for (entity, dir) in updates {
+        if let Some(vel) = world.get_mut::<Velocity>(entity) {
+            vel.linear.x = dir.x * BT_MOVE_SPEED;
+            vel.linear.z = dir.z * BT_MOVE_SPEED;
+        }
+        if let Some(lt) = world.get_mut::<LocalTransform>(entity) {
+            let target_angle = dir.x.atan2(dir.z);
+            lt.0.rotation = Quat::from_axis_angle(Vec3::Y, target_angle);
+        }
+    }
+}

crates/euca-gameplay/src/bt_actions.rs

@@ -0,0 +1,87 @@
+//! Perception system for behavior tree AI entities.
+//!
+//! Runs before [`euca_ai::behavior_tree_system`] to populate each entity's
+//! blackboard with sensory data: own position, nearest enemy, distance, etc.
+
+use euca_ai::{BehaviorTreeExecutor, BlackboardValue};
+use euca_ecs::{Entity, Query, World};
+use euca_math::Vec3;
+use euca_scene::GlobalTransform;
+
+use crate::health::{Dead, Health};
+use crate::teams::Team;
+
+/// Populate behavior tree blackboards with perception data.
+///
+/// For each entity with a [`BehaviorTreeExecutor`], writes:
+/// - `"self_position"` — own world position (Vec3)
+/// - `"alive"` — whether the entity is alive (Bool)
+/// - `"nearest_enemy"` — entity ID of closest living enemy (Entity)
+/// - `"enemy_position"` — world position of nearest enemy (Vec3)
+/// - `"enemy_distance"` — distance to nearest enemy (Float)
+pub fn bt_perception_system(world: &mut World) {
+    // Collect all living combatants for enemy scanning.
+    let combatants: Vec<(Entity, Vec3, u8)> = {
+        let query = Query::<(Entity, &GlobalTransform, &Team)>::new(world);
+        query
+            .iter()
+            .filter(|(e, _, _)| world.get::<Dead>(*e).is_none())
+            .filter(|(e, _, _)| world.get::<Health>(*e).is_some())
+            .map(|(e, gt, t)| (e, gt.0.translation, t.0))
+            .collect()
+    };
+
+    // Collect BT entities to update.
+    let bt_entities: Vec<Entity> = {
+        let query = Query::<(Entity, &BehaviorTreeExecutor)>::new(world);
+        query.iter().map(|(e, _)| e).collect()
+    };
+
+    for entity in bt_entities {
+        let (self_pos, self_team, is_alive) = {
+            let pos = world
+                .get::<GlobalTransform>(entity)
+                .map(|gt| gt.0.translation)
+                .unwrap_or(Vec3::ZERO);
+            let team = world.get::<Team>(entity).map(|t| t.0).unwrap_or(0);
+            let alive = world.get::<Dead>(entity).is_none();
+            (pos, team, alive)
+        };
+
+        let executor = match world.get_mut::<BehaviorTreeExecutor>(entity) {
+            Some(exec) => exec,
+            None => continue,
+        };
+
+        let bb = &mut executor.blackboard;
+        bb.set("self_position", BlackboardValue::Vec3(self_pos));
+        bb.set("alive", BlackboardValue::Bool(is_alive));
+
+        // Find nearest living enemy.
+        let mut nearest_dist = f32::MAX;
+        let mut nearest_entity = None;
+        let mut nearest_pos = Vec3::ZERO;
+
+        for &(other, other_pos, other_team) in &combatants {
+            if other == entity || other_team == self_team {
+                continue;
+            }
+            let dist = (other_pos - self_pos).length();
+            if dist < nearest_dist {
+                nearest_dist = dist;
+                nearest_entity = Some(other);
+                nearest_pos = other_pos;
+            }
+        }
+
+        if let Some(enemy) = nearest_entity {
+            bb.set("nearest_enemy", BlackboardValue::Entity(enemy));
+            bb.set("enemy_position", BlackboardValue::Vec3(nearest_pos));
+            bb.set("enemy_distance", BlackboardValue::Float(nearest_dist));
+        } else {
+            bb.remove("nearest_enemy");
+            bb.remove("enemy_position");
+            bb.remove("enemy_distance");
+        }
+    }
+}

crates/euca-gameplay/src/bt_perception.rs

@@ -18,6 +18,10 @@ pub mod ai;
 pub mod assertions;
 /// Dota 2 hero attribute system — STR/AGI/INT with per-level growth and stat conversions.
 pub mod attributes;
+/// Behavior tree action handlers (MoveTo → velocity).
+pub mod bt_actions;
+/// Perception system for behavior tree AI entities.
+pub mod bt_perception;
 /// Dota 2 tower and building system — types, backdoor, fortification, aggro, bounties.
 pub mod building;
 /// ECS systems for buildings — backdoor protection, fortification, barracks death.
@@ -91,6 +95,8 @@ pub use assertions::{
     AssertCondition, AssertResult, Assertion, CompareOp, EntityFilter, EvaluationReport, Severity,
     evaluate_assertions, parse_entity_filter,
 };
+pub use bt_actions::bt_moveto_system;
+pub use bt_perception::bt_perception_system;
 pub use combat::{
     AttackStyle, AutoCombat, CurrentTarget, EntityRole, MarchDirection, Projectile,
     auto_combat_system, projectile_system,

crates/euca-gameplay/src/lib.rs

@@ -372,6 +372,10 @@ pub struct Renderer<D: euca_rhi::RenderDevice = euca_rhi::wgpu_backend::WgpuDevi
     prev_depth_dims: (u32, u32),
     /// TAA resolve pass (temporal anti-aliasing).
     taa_pass: crate::taa::TaaPass<D>,
+    /// Depth-of-field pass (CoC computation + gather blur).
+    dof_pass: crate::dof::DofPass<D>,
+    /// Motion blur pass (tile max velocity + directional blur).
+    motion_blur_pass: crate::motion_blur::MotionBlurPass<D>,
     /// Frame counter for TAA jitter sequence.
     frame_count: u32,
     /// Interpolated SH probe coefficients for indirect lighting (set by caller).
@@ -1107,6 +1111,8 @@ impl<D: RenderDevice> Renderer<D> {
             prev_depth_buffer: Vec::new(),
             prev_depth_dims: (0, 0),
             taa_pass: crate::taa::TaaPass::new(rhi, surface_w, surface_h),
+            dof_pass: crate::dof::DofPass::new(rhi, surface_w, surface_h),
+            motion_blur_pass: crate::motion_blur::MotionBlurPass::new(rhi, surface_w, surface_h),
             frame_count: 0,
             probe_sh: [[0.0; 4]; 9],
             probe_enabled: false,
@@ -1458,6 +1464,8 @@ impl<D: RenderDevice> Renderer<D> {
             fog_pass.resize(&**gpu, fw, fh);
         }
         self.taa_pass.resize(rhi, w, h);
+        self.dof_pass.resize(rhi, w, h);
+        self.motion_blur_pass.resize(rhi, w, h);
         self.velocity_textures.resize(rhi, w, h);
     }
 
@@ -2458,6 +2466,70 @@ impl<D: RenderDevice> Renderer<D> {
             }
         }
 
+        // Motion blur: per-pixel directional blur from velocity buffer.
+        if self.post_process_settings.motion_blur.enabled {
+            self.motion_blur_pass.execute(
+                rhi,
+                encoder,
+                self.post_process_stack.ping_view(),
+                &self.velocity_textures.velocity_view,
+                &self.post_process_settings.motion_blur,
+            );
+            let (copy_w, copy_h) = rhi.surface_size();
+            rhi.copy_texture_to_texture(
+                encoder,
+                &euca_rhi::TexelCopyTextureInfo {
+                    texture: self.motion_blur_pass.output_texture(),
+                    mip_level: 0,
+                    origin: euca_rhi::Origin3d { x: 0, y: 0, z: 0 },
+                    aspect: euca_rhi::TextureAspect::All,
+                },
+                &euca_rhi::TexelCopyTextureInfo {
+                    texture: self.post_process_stack.ping_texture(),
+                    mip_level: 0,
+                    origin: euca_rhi::Origin3d { x: 0, y: 0, z: 0 },
+                    aspect: euca_rhi::TextureAspect::All,
+                },
+                euca_rhi::Extent3d {
+                    width: copy_w,
+                    height: copy_h,
+                    depth_or_array_layers: 1,
+                },
+            );
+        }
+
+        // Depth of field: CoC computation + variable-radius gather blur.
+        if self.post_process_settings.dof.enabled {
+            self.dof_pass.execute(
+                rhi,
+                encoder,
+                self.post_process_stack.ping_view(),
+                &self.post_process_stack.depth_resolve_view,
+                &self.post_process_settings.dof,
+            );
+            let (copy_w, copy_h) = rhi.surface_size();
+            rhi.copy_texture_to_texture(
+                encoder,
+                &euca_rhi::TexelCopyTextureInfo {
+                    texture: self.dof_pass.output_texture(),
+                    mip_level: 0,
+                    origin: euca_rhi::Origin3d { x: 0, y: 0, z: 0 },
+                    aspect: euca_rhi::TextureAspect::All,
+                },
+                &euca_rhi::TexelCopyTextureInfo {
+                    texture: self.post_process_stack.ping_texture(),
+                    mip_level: 0,
+                    origin: euca_rhi::Origin3d { x: 0, y: 0, z: 0 },
+                    aspect: euca_rhi::TextureAspect::All,
+                },
+                euca_rhi::Extent3d {
+                    width: copy_w,
+                    height: copy_h,
+                    depth_or_array_layers: 1,
+                },
+            );
+        }
+
         self.frame_count = self.frame_count.wrapping_add(1);
 
         // Post-processing via the modular stack.

crates/euca-render/src/renderer.rs

@@ -1155,10 +1155,31 @@ impl DotaClientApp {
         let mut pps = euca_render::RenderQuality::High.to_settings();
         pps.ssao_enabled = false;
         pps.ssr_enabled = true;
+        pps.taa_enabled = true;
         // Focal distance matches the MOBA camera height (~40 world units).
         pps.dof.focus_distance = 40.0;
         world.insert_resource(pps);
 
+        // Audio engine: spatial audio, bus mixing, reverb zones.
+        match euca_audio::AudioEngine::new() {
+            Ok(engine) => {
+                world.insert_resource(engine);
+                world.insert_resource(euca_audio::AudioBusSettings::default());
+                world.insert_resource(euca_audio::AudioSettings::default());
+                log::info!("Audio engine initialized");
+            }
+            Err(e) => {
+                log::warn!("Audio engine failed to initialize: {e}");
+            }
+        }
+
+        // Animation: state machines, blending, montages, IK, root motion.
+        world.insert_resource(euca_asset::AnimationLibrary {
+            clips: Vec::new(),
+            skeletons: Vec::new(),
+        });
+        world.insert_resource(euca_animation::AnimationEventLibrary::new());
+
         // Register items and heroes
         world.insert_resource(define_items());
         world.insert_resource(define_heroes());
@@ -1572,6 +1593,10 @@ impl DotaClientApp {
         euca_gameplay::projectile_system(&mut self.world, dt);
         euca_gameplay::trigger_system(&mut self.world);
         euca_gameplay::ai_system(&mut self.world, dt);
+        // Behavior tree AI: perception → tick → action execution.
+        euca_gameplay::bt_perception_system(&mut self.world);
+        euca_ai::behavior_tree_system(&mut self.world, dt);
+        euca_gameplay::bt_moveto_system(&mut self.world);
         euca_gameplay::tower_aggro_system(&mut self.world);
         euca_gameplay::auto_combat_system(&mut self.world, dt);
         euca_gameplay::neutral_camp_system(&mut self.world, dt);
@@ -1715,6 +1740,12 @@ impl DotaClientApp {
             euca_agent::routes::drain_pending_mesh_uploads(&mut self.world, renderer, gpu);
         }
 
+        // Animation: evaluate state machines, blend poses, sample clips.
+        euca_animation::animation_evaluate_system(&mut self.world, dt);
+
+        // Audio: update spatial positioning, bus volumes, and playback state.
+        euca_audio::audio_update_system_mut(&mut self.world, dt);
+
         // ── Render ──────────────────────────────────────────────────────
 
         let gpu = self.gpu.as_ref().unwrap();