Playable demo game and bug fixes in sprites

sky/examples/game/lib/sprite_box.dart

 part of sprites;
 
 enum SpriteBoxTransformMode {
   nativePoints,
   letterbox,
   stretch,
   scaleToFit,
   fixedWidth,
   fixedHeight,
 }
 
 class SpriteBox extends RenderBox {
 
   // Member variables
 
   // Root node for drawing
   Node _rootNode;
 
   // Tracking of frame rate and updates
   double _lastTimeStamp;
   int _numFrames = 0;
+  double _frameRate = 0.0;
 
+  // Transformation mode
   SpriteBoxTransformMode transformMode;
   double _systemWidth;
   double _systemHeight;
 
+  // Cached transformation matrix
+  Matrix4 _transformMatrix;
+  bool _transformMatrixIsDirty;
+
   // 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;
+    _callSpriteBoxPerformedLayout(_rootNode);
   }
 
   // Event handling
 
   void handleEvent(Event event, BoxHitTestEntry entry) {
   }
 
   // Rendering
 
-  void paint(RenderObjectDisplayList canvas) {
-    // Move to correct coordinate space before drawing
+  Matrix4 get transformMatrix {
+    // Get cached matrix if available
+    if (!_transformMatrixIsDirty && _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;
 
     switch(transformMode) {
       case SpriteBoxTransformMode.stretch:
         scaleX = size.width/_systemWidth;
         scaleY = size.height/_systemHeight;
         break;
@@ skipping 31 matching lines @@
         scaleX = scaleY;
         _systemWidth = size.width/scaleY;
         break;
       case SpriteBoxTransformMode.nativePoints:
         break;
       default:
         assert(false);
         break;
     }
 
+    _transformMatrix.translate(offsetX, offsetY);
+    _transformMatrix.scale(scaleX, scaleY);
+
+    return _transformMatrix;
+  }
+
+  void paint(RenderObjectDisplayList canvas) {
     canvas.save();
 
-    canvas.translate(offsetX, offsetY);
-    canvas.scale(scaleX, scaleY);
+    // Move to correct coordinate space before drawing
+    canvas.concat(transformMatrix.storage);
 
     // Draw the sprite tree
     _rootNode.visit(canvas);
 
     canvas.restore();
   }
 
   // Updates
 
   int _animationId = 0;
 
   void _scheduleTick() {
     _animationId = scheduler.requestAnimationFrame(_tick);
   }
 
   void _tick(double timeStamp) {
 
       // Calculate the time between frames in seconds
     if (_lastTimeStamp == null) _lastTimeStamp = timeStamp;
     double delta = (timeStamp - _lastTimeStamp) / 1000;
     _lastTimeStamp = timeStamp;
 
     // Count the number of frames we've been running
     _numFrames += 1;
 
+    _frameRate = 1.0/delta;
+
     // Print frame rate
-    if (_numFrames % 60 == 0) print("delta: ${delta} fps: ${1.0/delta}");
+    if (_numFrames % 60 == 0) print("delta: $delta fps: $_frameRate");
 
-    _rootNode.update(delta);
+    _callUpdate(_rootNode, delta);
     _scheduleTick();
   }
 
+  void _callUpdate(Node node, double dt) {
+    node.update(dt);
+    for (Node child in node.children) {
+      if (!child.paused) {
+        _callUpdate(child, dt);
+      }
+    }
+  }
+
+  void _callSpriteBoxPerformedLayout(Node node) {
+    node.spriteBoxPerformedLayout();
+    for (Node child in node.children) {
+      _callSpriteBoxPerformedLayout(child);
+    }
+  }
+
   // Hit tests
 
   List<Node> findNodesAtPosition(Point position) {
     assert(position != null);
 
     List<Node> nodes = [];
 
     // Traverse the render tree and find objects at the position
     _addNodesAtPosition(_rootNode, position, nodes);
 
     return nodes;
   }
 
   _addNodesAtPosition(Node node, Point position, List<Node> list) {
     // Visit children first
     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);
     }
   }
 }