Adds basic touch handling to sprites and optimizes transformations

sky/examples/game/lib/sprite_box.dart

 part of sprites;
 
 enum SpriteBoxTransformMode {
   nativePoints,
   letterbox,
   stretch,
   scaleToFit,
   fixedWidth,
   fixedHeight,
 }
@@ skipping 10 matching lines @@
   int _numFrames = 0;
   double _frameRate = 0.0;
 
   // Transformation mode
   SpriteBoxTransformMode transformMode;
   double _systemWidth;
   double _systemHeight;
 
   // Cached transformation matrix
   Matrix4 _transformMatrix;
-  bool _transformMatrixIsDirty;
+
+  List<Node> _eventTargets;
 
   // Setup
 
   SpriteBox(Node rootNode, [SpriteBoxTransformMode mode = SpriteBoxTransformMode.nativePoints, double width=1024.0, double height=1024.0]) {
     assert(rootNode != null);
     assert(rootNode._spriteBox == null);
 
     // Setup root node
     _rootNode = rootNode;
 
     // Assign SpriteBox reference to all the nodes
     _addSpriteBoxReference(_rootNode);
 
     // Setup transform mode
     transformMode = mode;
     _systemWidth = width;
     _systemHeight = height;
 
-    _transformMatrixIsDirty = true;
-
     _scheduleTick();
   }
 
   void _addSpriteBoxReference(Node node) {
     node._spriteBox = this;
     for (Node child in node._children) {
       _addSpriteBoxReference(child);
     }
   }
 
   // Properties
 
   double get systemWidth => _systemWidth;
   double get systemHeight => _systemHeight;
 
   Node get rootNode => _rootNode;
 
   void performLayout() {
     size = constraints.constrain(Size.infinite);
-    _transformMatrixIsDirty = true;
+    _invalidateTransformMatrix();
     _callSpriteBoxPerformedLayout(_rootNode);
   }
 
   // Event handling
 
-  void handleEvent(Event event, BoxHitTestEntry entry) {
+  void _addEventTargets(Node node, List<Node> eventTargets) {
+    if (node.userInteractionEnabled) {
+      eventTargets.add(node);
+    }
+    for (Node child in node.children) {
+      _addEventTargets(child, eventTargets);
+    }
+  }
+
+  void handleEvent(Event event, SpriteBoxHitTestEntry entry) {
+    if (event is PointerEvent) {
+
+      if (event.type == 'pointerdown') {
+        // Build list of event targets
+        if (_eventTargets == null) {
+          _eventTargets = [];
+          _addEventTargets(_rootNode, _eventTargets);
+        }
+
+        // Find the once that are hit by the pointer
+        List<Node> nodeTargets = [];
+        for (int i = _eventTargets.length - 1; i >= 0; i--) {
+          Node node = _eventTargets[i];
+
+          // Check if the node is ready to handle a pointer
+          if (node.handleMultiplePointers || node._handlingPointer == null) {
+            // Do the hit test
+            Point posInNodeSpace = node.convertPointToNodeSpace(entry.localPosition);
+            if (node.hitTest(posInNodeSpace)) {

[abarth-chromium, 2015/06/18 21:19:21]

Do you want to move this work into the |hitTest| function on this object?  It's
strange to perform hit testing during |handleEvent| instead of during |hitTest|.

+              nodeTargets.add(node);
+              node._handlingPointer = event.pointer;
+            }
+          }
+        }
+
+        entry.nodeTargets = nodeTargets;
+      }
+
+      // Pass the event down to nodes that were hit by the pointerdown
+      List<Node> targets = entry.nodeTargets;
+      for (Node node in targets) {
+        // Check if this event should be dispatched
+        if (node.handleMultiplePointers || event.pointer == node._handlingPointer) {
+          // Dispatch event
+          bool consumedEvent = node.handleEvent(new SpriteBoxEvent(new Point(event.x, event.y), event.type, event.pointer));
+          if (consumedEvent == null || consumedEvent) break;
+        }
+      }
+
+      // De-register pointer for nodes that doesn't handle multiple pointers
+      for (Node node in targets) {
+        if (event.type == 'pointerup' || event.type == 'pointercancel') {
+          node._handlingPointer = null;
+        }
+      }
+    }
+  }
+
+  bool hitTest(HitTestResult result, { Point position }) {
+    result.add(new SpriteBoxHitTestEntry(this, position));
+    return true;
   }
 
   // Rendering
 
   Matrix4 get transformMatrix {
     // Get cached matrix if available
-    if (!_transformMatrixIsDirty && _transformMatrix != null) {
+    if (_transformMatrix != null) {
       return _transformMatrix;
     }
 
     _transformMatrix = new Matrix4.identity();
 
     // Calculate matrix
     double scaleX = 1.0;
     double scaleY = 1.0;
     double offsetX = 0.0;
     double offsetY = 0.0;
@@ skipping 43 matching lines @@
         assert(false);
         break;
     }
 
     _transformMatrix.translate(offsetX, offsetY);
     _transformMatrix.scale(scaleX, scaleY);
 
     return _transformMatrix;
   }
 
+  void _invalidateTransformMatrix() {
+    _transformMatrix = null;
+    _rootNode._invalidateToBoxTransformMatrix();
+  }
+
   void paint(RenderObjectDisplayList canvas) {
     canvas.save();
 
     // Move to correct coordinate space before drawing
     canvas.concat(transformMatrix.storage);
 
     // Draw the sprite tree
     _rootNode.visit(canvas);
 
     canvas.restore();
@@ skipping 60 matching lines @@
     for (Node child in node.children) {
       _addNodesAtPosition(child, position, list);
     }
     // Do the hit test
     Point posInNodeSpace = node.convertPointToNodeSpace(position);
     if (node.hitTest(posInNodeSpace)) {
       list.add(node);
     }
   }
 }
+
+class SpriteBoxHitTestEntry extends BoxHitTestEntry {
+  List<Node> nodeTargets;
+  SpriteBoxHitTestEntry(RenderBox target, Point localPosition) : super(target, localPosition);
+}
+
+class SpriteBoxEvent {
+  Point boxPosition;
+  String type;
+  int pointer;
+
+  SpriteBoxEvent(this.boxPosition, this.type, this.pointer);
+}