finish state and cache refactor for core library, still pending editor

Author: mbrea-c

crates/bevy_animation_graph/src/core/animation_graph/core.rs

@@ -12,7 +12,8 @@ use crate::{
     },
     nodes::FSMNode,
     prelude::{
-        DataSpec, DataValue, DeferredGizmos, OptDataSpec, PassContext, SpecContext, SystemResources,
+        DataSpec, DataValue, DeferredGizmos, OptDataSpec, PassContext, SpecContext,
+        SystemResources, graph_context::QueryOutputTime,
     },
 };
 use bevy::{
@@ -767,7 +768,7 @@ impl AnimationGraph {
             TargetPin::NodeTime(target_node, target_pin) => ctx
                 .node_caches()
                 .get_input_time_update(target_node.clone(), key, target_pin.clone()),
-            TargetPin::OutputTime => match ctx.context().query_output_time.clone() {
+            TargetPin::OutputTime => match ctx.context().query_output_time.get(key) {
                 Some(update) => Ok(update),
                 None => ctx.parent_time_update_fwd(),
             },
@@ -815,7 +816,7 @@ impl AnimationGraph {
             entity_map,
             deferred_gizmos,
         );
-        ctx.context_mut().query_output_time = Some(time_update);
+        ctx.context_mut().query_output_time = QueryOutputTime::Forced(time_update);
         let mut outputs = HashMap::new();
         for k in self.output_parameters.keys() {
             let out = self.get_data(TargetPin::OutputData(k.clone()), ctx.clone())?;

crates/bevy_animation_graph/src/core/context/graph_context.rs

@@ -1,212 +1,17 @@
 use crate::{
-    core::{
-        animation_graph::{NodeId, SourcePin, TargetPin, TimeUpdate},
-        duration_data::DurationData,
-        prelude::AnimationGraph,
-        state_machine::low_level::FSMState,
+    core::{animation_graph::TimeUpdate, prelude::AnimationGraph},
+    prelude::{
+        node_caches::NodeCaches,
+        node_states::{NodeStates, StateKey},
     },
-    prelude::{DataValue, node_caches::NodeCaches, node_states::NodeStates},
 };
-use bevy::{
-    asset::AssetId,
-    platform::collections::{HashMap, HashSet},
-    reflect::prelude::*,
-};
-
-#[derive(Reflect, Debug, Default, Clone)]
-pub struct CacheReadFilter {
-    pub allow_primary: bool,
-    pub allow_temp: bool,
-}
-
-#[derive(Clone, Copy, Debug, Reflect, PartialEq, Eq, Hash)]
-pub enum CacheWriteFilter {
-    Primary,
-    Temp,
-}
-
-impl CacheReadFilter {
-    pub const TEMP: Self = Self {
-        allow_primary: false,
-        allow_temp: true,
-    };
-    pub const PRIMARY: Self = Self {
-        allow_primary: true,
-        allow_temp: false,
-    };
-    pub const FULL: Self = Self {
-        allow_primary: true,
-        allow_temp: true,
-    };
-
-    pub fn for_temp(is_temp: bool) -> Self {
-        if is_temp { Self::TEMP } else { Self::PRIMARY }
-    }
-}
-
-impl CacheWriteFilter {
-    pub fn for_temp(is_temp: bool) -> Self {
-        if is_temp { Self::Temp } else { Self::Primary }
-    }
-}
-
-#[derive(Reflect, Debug, Default, Clone)]
-pub struct TimeCache {
-    current: HashMap<SourcePin, f32>,
-    previous: HashMap<SourcePin, f32>,
-}
-
-impl TimeCache {
-    pub fn next_frame(&mut self) {
-        self.previous.clone_from(&self.current);
-    }
-
-    pub fn get(&self, source_pin: &SourcePin) -> Option<f32> {
-        self.current.get(source_pin).copied()
-    }
-
-    pub fn get_prev(&self, source_pin: &SourcePin) -> Option<f32> {
-        self.previous.get(source_pin).copied()
-    }
-
-    pub fn save(&mut self, source_pin: SourcePin, time: f32) -> Option<f32> {
-        self.current.insert(source_pin, time)
-    }
-}
-
-#[derive(Reflect, Debug, Default)]
-pub struct GraphState {
-    pub data: HashMap<SourcePin, DataValue>,
-    pub durations: HashMap<SourcePin, DurationData>,
-    pub time_updates: HashMap<SourcePin, TimeUpdate>,
-    pub time_updates_back: HashMap<TargetPin, TimeUpdate>,
-    pub times: TimeCache,
-    pub updated: HashSet<NodeId>,
-    pub fsm_state: HashMap<NodeId, FSMState>,
-}
-
-impl GraphState {
-    pub fn next_frame(&mut self) {
-        self.times.next_frame();
-
-        self.data.clear();
-        self.durations.clear();
-        self.time_updates.clear();
-        self.time_updates_back.clear();
-        self.updated.clear();
-    }
-
-    pub fn get_data(&self, source_pin: &SourcePin) -> Option<&DataValue> {
-        self.data.get(source_pin)
-    }
-
-    pub fn set_data(&mut self, source_pin: SourcePin, value: DataValue) -> Option<DataValue> {
-        self.data.insert(source_pin, value)
-    }
-
-    pub fn get_duration(&self, source_pin: &SourcePin) -> Option<DurationData> {
-        self.durations.get(source_pin).cloned()
-    }
-
-    pub fn set_duration(
-        &mut self,
-        source_pin: SourcePin,
-        value: DurationData,
-    ) -> Option<DurationData> {
-        self.durations.insert(source_pin, value)
-    }
-
-    pub fn get_time_update(&self, source_pin: &SourcePin) -> Option<&TimeUpdate> {
-        self.time_updates.get(source_pin)
-    }
-
-    pub fn set_time_update(
-        &mut self,
-        source_pin: SourcePin,
-        value: TimeUpdate,
-    ) -> Option<TimeUpdate> {
-        self.time_updates.insert(source_pin, value)
-    }
-
-    pub fn get_time_update_back(&self, target_pin: &TargetPin) -> Option<&TimeUpdate> {
-        self.time_updates_back.get(target_pin)
-    }
-
-    pub fn set_time_update_back(
-        &mut self,
-        target_pin: TargetPin,
-        value: TimeUpdate,
-    ) -> Option<TimeUpdate> {
-        self.time_updates_back.insert(target_pin, value)
-    }
-
-    pub fn get_time(&self, source_pin: &SourcePin) -> Option<f32> {
-        self.times.get(source_pin)
-    }
-
-    pub fn get_prev_time(&self, source_pin: &SourcePin) -> Option<f32> {
-        self.times.get_prev(source_pin)
-    }
-
-    pub fn set_time(&mut self, source_pin: SourcePin, value: f32) -> Option<f32> {
-        self.times.save(source_pin, value)
-    }
-
-    pub fn is_updated(&self, node_id: &NodeId) -> bool {
-        self.updated.contains(node_id)
-    }
-
-    pub fn set_updated(&mut self, node_id: NodeId) {
-        self.updated.insert(node_id);
-    }
-
-    pub fn get_fsm_state(&self, node_id: &NodeId) -> Option<&FSMState> {
-        self.fsm_state.get(node_id)
-    }
-
-    pub fn set_fsm_state(&mut self, node_id: NodeId, state: FSMState) -> Option<FSMState> {
-        self.fsm_state.insert(node_id, state)
-    }
-}
-
-// TODO: Maybe we should consider the multiple caches to be a stack of overlays?
-// Might reduce the amount of cloning between frames.
-#[derive(Reflect, Debug, Default)]
-pub struct GraphStateStack {
-    primary_cache: GraphState,
-    temp_cache: GraphState,
-}
-
-impl GraphStateStack {
-    pub fn next_frame(&mut self) {
-        self.primary_cache.next_frame();
-        self.temp_cache = GraphState::default();
-    }
-
-    pub fn get<T>(&self, f: impl Fn(&GraphState) -> Option<T>, opts: CacheReadFilter) -> Option<T> {
-        opts.allow_temp
-            .then(|| f(&self.temp_cache))
-            .flatten()
-            .or_else(|| opts.allow_primary.then(|| f(&self.primary_cache)).flatten())
-    }
-
-    pub fn get_primary<T>(&self, f: impl Fn(&GraphState) -> Option<T>) -> Option<T> {
-        self.get(f, CacheReadFilter::PRIMARY)
-    }
-
-    pub fn set<T>(&mut self, f: impl FnOnce(&mut GraphState) -> T, opts: CacheWriteFilter) -> T {
-        match opts {
-            CacheWriteFilter::Primary => f(&mut self.primary_cache),
-            CacheWriteFilter::Temp => f(&mut self.temp_cache),
-        }
-    }
-}
+use bevy::{asset::AssetId, platform::collections::HashMap, reflect::prelude::*};
 
 #[derive(Debug, Reflect)]
 pub struct GraphContext {
     pub node_states: NodeStates,
     pub node_caches: NodeCaches,
-    pub query_output_time: Option<TimeUpdate>,
+    pub query_output_time: QueryOutputTime,
     graph_id: AssetId<AnimationGraph>,
 }
 
@@ -216,7 +21,7 @@ impl GraphContext {
             graph_id,
             node_states: NodeStates::default(),
             node_caches: NodeCaches::default(),
-            query_output_time: None,
+            query_output_time: QueryOutputTime::None,
         }
     }
 
@@ -229,3 +34,24 @@ impl GraphContext {
         self.graph_id
     }
 }
+
+#[derive(Debug, Reflect)]
+pub enum QueryOutputTime {
+    None,
+    Forced(TimeUpdate),
+    ByKey(HashMap<StateKey, TimeUpdate>),
+}
+
+impl QueryOutputTime {
+    pub fn from_key(key: StateKey, update: TimeUpdate) -> Self {
+        Self::ByKey([(key, update)].into())
+    }
+
+    pub fn get(&self, key: StateKey) -> Option<TimeUpdate> {
+        match self {
+            QueryOutputTime::None => None,
+            QueryOutputTime::Forced(time_update) => Some(time_update.clone()),
+            QueryOutputTime::ByKey(hash_map) => hash_map.get(&key).cloned(),
+        }
+    }
+}

crates/bevy_animation_graph/src/core/context/graph_context_arena.rs

@@ -1,6 +1,8 @@
-use super::GraphContext;
-use crate::core::{
-    animation_graph::NodeId, prelude::AnimationGraph, state_machine::low_level::LowLevelStateId,
+use crate::{
+    core::{
+        animation_graph::NodeId, prelude::AnimationGraph, state_machine::low_level::LowLevelStateId,
+    },
+    prelude::graph_context::GraphContext,
 };
 use bevy::{asset::AssetId, platform::collections::HashMap, reflect::Reflect};
 

crates/bevy_animation_graph/src/core/context/mod.rs

@@ -1,5 +1,5 @@
 mod deferred_gizmos;
-mod graph_context;
+pub mod graph_context;
 mod graph_context_arena;
 pub mod node_caches;
 pub mod node_state_box;
@@ -13,7 +13,6 @@ pub use deferred_gizmos::{
     CustomRelativeDrawCommand, CustomRelativeDrawCommandReference, DeferredGizmos,
     DeferredGizmosContext,
 };
-pub use graph_context::{CacheReadFilter, CacheWriteFilter, GraphContext};
 pub use graph_context_arena::{GraphContextArena, GraphContextId};
 pub use pass_context::{FsmContext, PassContext, StateRole, StateStack};
 pub use pose_fallback::{PoseFallbackContext, RootOffsetResult};

crates/bevy_animation_graph/src/core/context/node_states.rs

@@ -56,6 +56,17 @@ impl NodeState {
         self.upcoming_time.clear();
     }
 
+    pub fn get_state<T: GraphStateType>(&self, key: StateKey) -> Result<&T, GraphError> {
+        self.upcoming_state
+            .get(&key)
+            .or(self.last_state.as_ref())
+            .ok_or(GraphError::MissingStateValue)
+            .and_then(|v| {
+                let v: &dyn Any = v.value.as_ref();
+                v.downcast_ref::<T>().ok_or(GraphError::MismatchedStateType)
+            })
+    }
+
     pub fn get_mut_or_insert_with<T: GraphStateType>(
         &mut self,
         key: StateKey,
@@ -102,7 +113,7 @@ impl NodeState {
 
 #[derive(Debug, Reflect, Default)]
 pub struct NodeStates {
-    pub states: HashMap<NodeId, NodeState>,
+    states: HashMap<NodeId, NodeState>,
 }
 
 impl NodeStates {
@@ -112,6 +123,13 @@ impl NodeStates {
         }
     }
 
+    pub fn get<T: GraphStateType>(&self, node_id: NodeId, key: StateKey) -> Result<&T, GraphError> {
+        self.states
+            .get(&node_id)
+            .ok_or(GraphError::MissingStateValue)
+            .and_then(|n| n.get_state(key))
+    }
+
     pub fn get_mut_or_insert_with<T: GraphStateType>(
         &mut self,
         node_id: NodeId,