Add support for nodes as functions

Example/test/index.js

@@ -21,8 +21,64 @@ const {
   Value,
   Clock,
   event,
+  proc,
 } = Animated;
 
+const betterSpring = proc(
+  (
+    finished,
+    velocity,
+    position,
+    time,
+    prevPosition,
+    toValue,
+    damping,
+    mass,
+    stiffness,
+    overshootClamping,
+    restSpeedThreshold,
+    restDisplacementThreshold,
+    clock
+  ) =>
+    spring(
+      clock,
+      {
+        finished,
+        velocity,
+        position,
+        time,
+        prevPosition,
+      },
+      {
+        toValue,
+        damping,
+        mass,
+        stiffness,
+        overshootClamping,
+        restDisplacementThreshold,
+        restSpeedThreshold,
+      }
+    )
+);
+
+function springFill(clock, state, config) {
+  return betterSpring(
+    state.finished,
+    state.velocity,
+    state.position,
+    state.time,
+    new Value(0),
+    config.toValue,
+    config.damping,
+    config.mass,
+    config.stiffness,
+    config.overshootClamping,
+    config.restSpeedThreshold,
+    config.restDisplacementThreshold,
+    clock
+  );
+}
+
 function runSpring(clock, value, dest) {
   const state = {
     finished: new Value(0),
@@ -34,7 +90,7 @@ function runSpring(clock, value, dest) {
   const config = {
     toValue: new Value(0),
     damping: 7,
-    mass: 1,
+    mass: 5,
     stiffness: 121.6,
     overshootClamping: false,
     restSpeedThreshold: 0.001,
@@ -50,7 +106,7 @@ function runSpring(clock, value, dest) {
       set(config.toValue, dest),
       startClock(clock),
     ]),
-    spring(clock, state, config),
+    springFill(clock, state, config),
     cond(state.finished, debug('stop clock', stopClock(clock))),
     state.position,
   ]);
@@ -92,29 +148,34 @@ export default class Example extends Component {
     // const transX = new Value(0);
     const clock = new Clock();
     // const twenty = new Value(20);
-    // const thirty = new Value(30);
-    // this._transX = cond(new Value(0), twenty, multiply(3, thirty));
-    this._transX = runTiming(clock, -120, 120);
+    this.t = Array.from(Array(40)).map(() =>
+      runSpring(new Clock(), Math.random() * -200, Math.random() * 200)
+    );
   }
+
   componentDidMount() {
     // Animated.spring(this._transX, {
     //   duration: 300,
     //   velocity: -300,
     //   toValue: 150,
     // }).start();
   }
+
   render() {
     return (
-      <View style={styles.container}>
-        <Animated.View
-          style={[styles.box, { transform: [{ translateX: this._transX }] }]}
-        />
+      <View style={styles.container}>        
+        {Array.from(Array(40)).map((_, i) => (
+          <Animated.View
+            key={i}
+            style={[styles.box, { transform: [{ translateX: this.t[i] }] }]}
+          />
+        ))}
       </View>
     );
   }
 }
 
-const BOX_SIZE = 100;
+const BOX_SIZE = 10;
 
 const styles = StyleSheet.create({
   container: {
@@ -129,6 +190,6 @@ const styles = StyleSheet.create({
     borderColor: '#F5FCFF',
     alignSelf: 'center',
     backgroundColor: 'plum',
-    margin: BOX_SIZE / 2,
+    margin: 2,
   },
 });

README.md

@@ -658,6 +658,24 @@ Returns an accumulated value of the given node. This node stores a sum of all ev
 
 Works the same way as with the original `Animated` library.
 
+---
+### `proc`
+
+Returns a callable function node that can be used to define expressions that can be called from other nodes. 
+
+Example:
+´´´js
+// Global constant
+const myProc = proc((a, b) => multiply(a,b));
+
+// In your component
+const style = { width: proc(10, 10 )};
+´´´
+
+A proc node should be declared as a global constant in your code and not recreated from inside components.
+
+It is not possible to reference nodes that are not passed as parameters.
+
 ---
 ### `interpolate`
 ```js

android/src/main/java/com/swmansion/reanimated/NodesManager.java

@@ -37,6 +37,9 @@
 import com.swmansion.reanimated.nodes.StyleNode;
 import com.swmansion.reanimated.nodes.TransformNode;
 import com.swmansion.reanimated.nodes.ValueNode;
+import com.swmansion.reanimated.nodes.ParamNode;
+import com.swmansion.reanimated.nodes.FunctionNode;
+import com.swmansion.reanimated.nodes.CallFuncNode;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -264,6 +267,12 @@ public void createNode(int nodeID, ReadableMap config) {
       node = new AlwaysNode(nodeID, config, this);
     } else if ("concat".equals(type)) {
       node = new ConcatNode(nodeID, config, this);
+    } else if ("param".equals(type)) {
+      node = new ParamNode(nodeID, config, this);
+    } else if ("func".equals(type)) {
+      node = new FunctionNode(nodeID, config, this);
+    } else if ("callfunc".equals(type)) {
+      node = new CallFuncNode(nodeID, config, this);
     } else {
       throw new JSApplicationIllegalArgumentException("Unsupported node type: " + type);
     }

android/src/main/java/com/swmansion/reanimated/UpdateContext.java

@@ -7,6 +7,7 @@
 public class UpdateContext {
 
   public long updateLoopID = 0;
+  public String callID = "";
   public final ArrayList<Node> updatedNodes = new ArrayList<>();
 
 }

android/src/main/java/com/swmansion/reanimated/nodes/CallFuncNode.java

@@ -0,0 +1,48 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+
+public class CallFuncNode extends Node {
+
+  private String mPreviousCallID;
+  private final int mWhatNodeID;
+  private final int[] mArgs;
+  private final int[] mParams;
+
+  public CallFuncNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mWhatNodeID = config.getInt("what");
+    mParams = Utils.processIntArray(config.getArray("params"));
+    mArgs = Utils.processIntArray(config.getArray("args"));
+  }
+
+  private void beginContext() {
+    mPreviousCallID = mNodesManager.updateContext.callID;
+    mNodesManager.updateContext.callID = mNodesManager.updateContext.callID + '/' + String.valueOf(mNodeID);
+    for (int i = 0; i < mParams.length; i++) {
+      int paramId = mParams[i];
+      ParamNode paramNode = mNodesManager.findNodeById(paramId, ParamNode.class);
+      paramNode.beginContext(mArgs[i], mPreviousCallID);
+    }
+  }
+
+  private void endContext() {
+    for (int i = 0; i < mParams.length; i++) {
+      int paramId = mParams[i];
+      ParamNode paramNode = mNodesManager.findNodeById(paramId, ParamNode.class);
+      paramNode.endContext();
+    }
+    mNodesManager.updateContext.callID = mPreviousCallID;
+  }
+
+  @Override
+  protected Object evaluate() {
+    beginContext();
+    Node whatNode = mNodesManager.findNodeById(mWhatNodeID, Node.class);
+    Object retVal = whatNode.value();
+    endContext();
+    return retVal;
+  }
+}

android/src/main/java/com/swmansion/reanimated/nodes/FunctionNode.java

@@ -0,0 +1,20 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+public class FunctionNode extends Node {
+
+  private final int mWhatNodeID;
+
+  public FunctionNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mWhatNodeID = config.getInt("what");
+  }
+
+  @Override
+  protected Object evaluate() {
+    Node what = mNodesManager.findNodeById(mWhatNodeID, Node.class);
+    return what.value();
+  }
+}

android/src/main/java/com/swmansion/reanimated/nodes/Node.java

@@ -1,13 +1,17 @@
 package com.swmansion.reanimated.nodes;
 
+import android.util.SparseArray;
+
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.swmansion.reanimated.NodesManager;
 import com.swmansion.reanimated.UpdateContext;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.Stack;
 
@@ -21,13 +25,14 @@ public abstract class Node {
   protected final int mNodeID;
   protected final NodesManager mNodesManager;
 
-  private final UpdateContext mUpdateContext;
+  protected final UpdateContext mUpdateContext;
 
-  private long mLastLoopID = -1;
-  private @Nullable Object mMemoizedValue;
+  private final Map<String, Long> mLastLoopID = new HashMap<>();
+  private final Map<String, Object> mMemoizedValue = new HashMap<>();
   private @Nullable List<Node> mChildren; /* lazy-initialized when a child is added */
 
   public Node(int nodeID, @Nullable ReadableMap config, NodesManager nodesManager) {
+    mLastLoopID.put("", 1L);
     mNodeID = nodeID;
     mNodesManager = nodesManager;
     mUpdateContext = nodesManager.updateContext;
@@ -36,11 +41,14 @@ public Node(int nodeID, @Nullable ReadableMap config, NodesManager nodesManager)
   protected abstract @Nullable Object evaluate();
 
   public final @Nullable Object value() {
-    if (mLastLoopID < mUpdateContext.updateLoopID) {
-      mLastLoopID = mUpdateContext.updateLoopID;
-      return (mMemoizedValue = evaluate());
+    if (!mLastLoopID.containsKey(mUpdateContext.callID) || mLastLoopID.get(mUpdateContext.callID) < mUpdateContext.updateLoopID) {
+      mLastLoopID.put(mUpdateContext.callID, mUpdateContext.updateLoopID);
+      Object result = evaluate();
+      mMemoizedValue.put(mUpdateContext.callID, result);
+
+      return result;
     }
-    return mMemoizedValue;
+    return mMemoizedValue.get(mUpdateContext.callID);
   }
 
   /**
@@ -83,12 +91,12 @@ protected void markUpdated() {
   }
 
   protected final void dangerouslyRescheduleEvaluate() {
-    mLastLoopID = -1;
+    mLastLoopID.put(mUpdateContext.callID, -1L);
     markUpdated();
   }
 
   protected final void forceUpdateMemoizedValue(Object value) {
-    mMemoizedValue = value;
+    mMemoizedValue.put(mUpdateContext.callID, value);
     markUpdated();
   }
 

android/src/main/java/com/swmansion/reanimated/nodes/ParamNode.java

@@ -0,0 +1,47 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+import java.util.Stack;
+
+public class ParamNode extends ValueNode {
+
+  private final Stack<Integer> mArgsStack;
+  private String mPrevCallID;
+
+  public ParamNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mArgsStack = new Stack<>();
+  }
+
+  @Override
+  public void setValue(Object value) {
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    String callID = mUpdateContext.callID;
+    mUpdateContext.callID = mPrevCallID;
+    ((ValueNode) node).setValue(value);
+    mUpdateContext.callID = callID;
+  }
+
+  public void beginContext(Integer ref, String prevCallID) {
+    mPrevCallID = prevCallID;
+    mArgsStack.push(ref);
+  }
+
+
+  public void endContext() {
+    mArgsStack.pop();
+  }
+
+
+  @Override
+  protected Object evaluate() {
+    String callID = mUpdateContext.callID;
+    mUpdateContext.callID = mPrevCallID;
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    Object val = node.value();
+    mUpdateContext.callID = callID;
+    return val;
+  }
+}

ios/Nodes/REACallFuncNode.h

@@ -0,0 +1,7 @@
+
+#import "REANode.h"
+
+@interface REACallFuncNode : REANode
+
+@end
+