Evaluating ExpressionNodes

[arcadiogarcia]

I use ExpressionNodes heavily to create composition animations, and in many cases I find myself wishing I was able to evaluate the current value of an expression node. This would be useful in the following situations:

• Whenever the UI thread needs to know the current value of a property that is driven by a composition animation (for doing manual hit testing/using them as a trigger once they meet a certain threshold/animating one element to the position of another...). While some animations are running (e.g. when the position of an element is attached to an interaction tracker), simply reading the property of the visual often returns a stale value.
• In some cases, the expression animation is a rewrite of some computations that also needs to exist somewhere else in the view code. The developer currently has to keep two methods with the same logic, written using the regular C# math API and the expression nodes API. In situations where perf is not critical, being able to simply evaluate the node would reduce the code that needs to be written, but more importantly eliminate the chance of introducing any bugs where the two implementations behave differently.
• Expression animations are not particularly easy to debug, since the expression is evaluated by the compositor and the user can't step through the immediate results. While this wouldn't fix that, being able to evaluate the root expression node and each of the subtrees would be handy to find mistakes faster.

My proposal:

ExpressionNodes should have an Evaluate method that returns the current value of that expression (using the appropriate data type for each class: boolean for BooleanNode, Quaternion for QuaternionNode, etc...). The value would be calculated by recursively iterating through the nodes and evaluating them, computing the operation indicated by NodeType, all the way down to the constant values and reference properties. This wouldn't create any significant overhead for people that don't need this feature, while allowing users to evaluate any expression node at any point in time (before, during, and after it has been used to animate a property).

E.g. this is what a partial implementation for QuaternionNode would look like:

        /// <summary>
        /// Evaluates the current value of the expression
        /// </summary>
        /// <returns>The current value of the expression</returns>
        public Quaternion Evaluate()
        {
            switch (NodeType)
            {
                case ExpressionNodeType.ConstantValue:
                    return _value;
                case ExpressionNodeType.QuaternionFromAxisAngle:
                    return Quaternion.CreateFromAxisAngle((Children[0] as Vector3Node).Evaluate(), (Children[1] as ScalarNode).Evaluate());
                case ExpressionNodeType.Multiply:
                    return (Children[0] as QuaternionNode).Evaluate() * (Children[1] as QuaternionNode).Evaluate();
                case ExpressionNodeType.Conditional:
                    return
                        (Children[0] as BooleanNode).Evaluate() ?
                        (Children[1] as QuaternionNode).Evaluate() :
                        (Children[2] as QuaternionNode).Evaluate();
                default:
                    throw new System.NotImplementedException();
            }
        }

I have an incomplete implementation locally and have been using it successfully to do things like using the value of ongoing expression animations to trigger actions, and automatically create animations that interpolate between two existing expression animations.

I'd be happy to send a PR request with the full implementation, but before I start writing a comprehensive implementation (there's a lot of ExpressionNodeType/valuetype combinations!) I wanted to check if this is something other people would be interested in / opposed to / have thoughts about.

[michael-hawker]

FYI @Sergio0694 @JustinXinLiu who are more familiar with this space.