Initial flame_lua_runtime package

lib/runtime/rendering/render_tree_controller.dart

@@ -0,0 +1,489 @@
+import 'package:flame/components.dart';
+
+import '../models/game_diff.dart';
+import '../models/runtime_event.dart';
+import '../models/runtime_node.dart';
+import '../protocol/runtime_protocol.dart';
+import '../resources/game_resource_manager.dart';
+import 'runtime_component.dart';
+
+class RenderTreeController {
+  RenderTreeController({
+    required Component root,
+    required GameResourceManager resources,
+    required void Function(RuntimeEvent event) eventSink,
+    this.onScopeRemoved,
+  }) : _root = root,
+       _resources = resources,
+       _eventSink = eventSink;
+
+  final Component _root;
+  final GameResourceManager _resources;
+  final void Function(RuntimeEvent event) _eventSink;
+  final Map<String, RuntimeComponent> _components = {};
+  final Map<String, int> _epochs = {};
+  final Map<String, Vector2> _scrollVelocities = {};
+  void Function(String id)? onScopeRemoved;
+
+  RuntimeComponent? componentById(String id) => _components[id];
+
+  bool contains(String id) => _components.containsKey(id);
+
+  String? listViewAt(Vector2 canvasPosition) {
+    final hits =
+        _components.values
+            .where(
+              (component) =>
+                  component.node.type == RuntimeNodeType.listView &&
+                  component.containsVisualPoint(canvasPosition),
+            )
+            .toList(growable: false)
+          ..sort((a, b) => b.priority.compareTo(a.priority));
+    return hits.isEmpty ? null : hits.first.node.id;
+  }
+
+  bool scrollListViewAt(
+    Vector2 canvasPosition, {
+    double deltaX = 0,
+    double deltaY = 0,
+    String source = 'wheel',
+  }) {
+    final id = listViewAt(canvasPosition);
+    if (id == null) {
+      return false;
+    }
+    return scrollListView(id, deltaX: deltaX, deltaY: deltaY, source: source);
+  }
+
+  bool scrollListView(
+    String id, {
+    double deltaX = 0,
+    double deltaY = 0,
+    String source = 'program',
+  }) {
+    final component = _components[id];
+    if (component == null || component.node.type != RuntimeNodeType.listView) {
+      return false;
+    }
+    final node = component.node;
+    final viewport = _listViewContentViewport(node);
+    final nextScrollX = _clampScroll(
+      node.scrollX + deltaX,
+      viewportExtent: viewport.x,
+      contentExtent: node.contentWidth,
+    );
+    final nextScrollY = _clampScroll(
+      node.scrollY + deltaY,
+      viewportExtent: viewport.y,
+      contentExtent: node.contentHeight,
+    );
+    if (nextScrollX == node.scrollX && nextScrollY == node.scrollY) {
+      return false;
+    }
+    component.updateNode(
+      node.copyWithProps({'scrollX': nextScrollX, 'scrollY': nextScrollY}),
+    );
+    _reattachChildrenOf(id);
+    _emitScrollEvent(component, source: source);
+    return true;
+  }
+
+  void setListViewVelocity(String id, Vector2 velocity) {
+    final component = _components[id];
+    if (component == null || component.node.type != RuntimeNodeType.listView) {
+      return;
+    }
+    if (!component.node.inertia) {
+      _scrollVelocities.remove(id);
+      return;
+    }
+    if (velocity.length2 < 1) {
+      _scrollVelocities.remove(id);
+      return;
+    }
+    _scrollVelocities[id] = velocity;
+  }
+
+  void stopListViewVelocity(String id) {
+    _scrollVelocities.remove(id);
+  }
+
+  void updateListViewInertia(double dt) {
+    if (_scrollVelocities.isEmpty || dt <= 0) {
+      return;
+    }
+    for (final entry in _scrollVelocities.entries.toList(growable: false)) {
+      final id = entry.key;
+      final velocity = entry.value;
+      final consumed = scrollListView(
+        id,
+        deltaX: velocity.x * dt,
+        deltaY: velocity.y * dt,
+        source: 'inertia',
+      );
+      final next = velocity * 0.88;
+      if (!consumed || next.length2 < 25) {
+        _scrollVelocities.remove(id);
+      } else {
+        _scrollVelocities[id] = next;
+      }
+    }
+  }
+
+  int epochOf(String id) => _epochs[id] ?? 0;
+
+  bool isNodeEpochAlive(String id, int epoch) {
+    return _components.containsKey(id) && epochOf(id) == epoch;
+  }
+
+  void clear() {
+    final ids = _components.keys.toList(growable: false);
+    for (final component in _components.values) {
+      component.removeFromParent();
+    }
+    _components.clear();
+    for (final id in ids) {
+      _bumpEpoch(id);
+      onScopeRemoved?.call(id);
+    }
+  }
+
+  void removeById(String id) {
+    final removedIds = <String>[];
+    for (final childId in _descendantIdsOf(id)) {
+      final child = _components.remove(childId);
+      if (child != null) {
+        removedIds.add(childId);
+        _bumpEpoch(childId);
+        child.removeFromParent();
+      }
+    }
+
+    final component = _components.remove(id);
+    if (component != null) {
+      removedIds.add(id);
+      _bumpEpoch(id);
+      component.removeFromParent();
+    }
+
+    for (final removedId in removedIds) {
+      onScopeRemoved?.call(removedId);
+    }
+  }
+
+  void apply(NodeDiff diff) {
+    _validateDiff(diff);
+
+    for (final remove in diff.removes) {
+      removeById(remove.id);
+    }
+
+    for (final create in diff.creates) {
+      _createOrReplace(create);
+    }
+
+    for (final update in diff.updates) {
+      final component = _components[update.id];
+      if (component == null) {
+        continue;
+      }
+      final nextNode = component.node.copyWithProps(update.props);
+      component.updateNode(nextNode);
+      _attachToParent(component);
+      _reattachChildrenOf(component.node.id);
+    }
+  }
+
+  void _validateDiff(NodeDiff diff) {
+    final nodes = <String, RuntimeNode>{
+      for (final entry in _components.entries) entry.key: entry.value.node,
+    };
+
+    for (final remove in diff.removes) {
+      _removeNodeSnapshot(nodes, remove.id);
+    }
+
+    for (final create in diff.creates) {
+      nodes[create.id] = create;
+    }
+
+    for (final update in diff.updates) {
+      final current = nodes[update.id];
+      if (current == null) {
+        continue;
+      }
+      nodes[update.id] = current.copyWithProps(update.props);
+    }
+
+    _validateParentGraph(nodes);
+  }
+
+  void _removeNodeSnapshot(Map<String, RuntimeNode> nodes, String id) {
+    final descendants = _descendantIdsOfSnapshot(nodes, id);
+    for (final childId in descendants) {
+      nodes.remove(childId);
+    }
+    nodes.remove(id);
+  }
+
+  List<String> _descendantIdsOfSnapshot(
+    Map<String, RuntimeNode> nodes,
+    String parentId,
+  ) {
+    final descendants = <String>[];
+    for (final node in nodes.values) {
+      if (node.parent == parentId) {
+        descendants.add(node.id);
+        descendants.addAll(_descendantIdsOfSnapshot(nodes, node.id));
+      }
+    }
+    return descendants;
+  }
+
+  void _validateParentGraph(Map<String, RuntimeNode> nodes) {
+    for (final node in nodes.values) {
+      final parentId = node.parent;
+      if (parentId == null) {
+        continue;
+      }
+      if (parentId == node.id) {
+        throw const FormatException(
+          'RuntimeNode.parent cannot reference itself',
+        );
+      }
+
+      final seen = <String>{node.id};
+      var currentId = parentId;
+      while (true) {
+        if (!seen.add(currentId)) {
+          throw FormatException(
+            'RuntimeNode.parent would create a cycle: ${node.id} -> $parentId',
+          );
+        }
+        final parent = nodes[currentId];
+        final nextId = parent?.parent;
+        if (nextId == null) {
+          break;
+        }
+        currentId = nextId;
+      }
+    }
+  }
+
+  void _createOrReplace(RuntimeNode node) {
+    _validateParent(node);
+
+    final existing = _components.remove(node.id);
+    existing?.removeFromParent();
+    final epoch = _bumpEpoch(node.id);
+
+    late final RuntimeComponent component;
+    component = RuntimeComponent(
+      node: node,
+      resources: _resources,
+      onNodeTap: (tappedNode, localPosition) {
+        if (_components[tappedNode.id] != component) {
+          return;
+        }
+        _eventSink(
+          RuntimeEvent(
+            type: RuntimeEventType.tap,
+            target: tappedNode.id,
+            handler: tappedNode.onTap,
+            x: localPosition.x,
+            y: localPosition.y,
+            scope: tappedNode.id,
+            targetEpoch: epoch,
+            scopeEpoch: epoch,
+          ),
+        );
+      },
+    );
+    _components[node.id] = component;
+    _attachToParent(component);
+    _reattachChildrenOf(node.id);
+  }
+
+  int _bumpEpoch(String id) {
+    final next = (_epochs[id] ?? 0) + 1;
+    _epochs[id] = next;
+    return next;
+  }
+
+  void _attachToParent(RuntimeComponent component) {
+    final parentId = component.node.parent;
+    final parent = parentId == null ? null : _components[parentId];
+    final target = parent ?? _root;
+    final parentIsListView = parent?.node.type == RuntimeNodeType.listView;
+    final parentScrollX = parentIsListView ? parent!.node.scrollX : 0.0;
+    final parentScrollY = parentIsListView ? parent!.node.scrollY : 0.0;
+    final parentContentOffset = parentIsListView
+        ? parent!.listViewContentOffset()
+        : Vector2.zero();
+    component.setParentScroll(
+      x: parentScrollX,
+      y: parentScrollY,
+      contentOffsetX: parentContentOffset.x,
+      contentOffsetY: parentContentOffset.y,
+    );
+    component.setViewportCulled(_isCulledByParentListView(component, parent));
+    if (component.parent == target) {
+      return;
+    }
+
+    component.removeFromParent();
+    target.add(component);
+  }
+
+  void _validateParent(RuntimeNode node) {
+    final parentId = node.parent;
+    if (parentId != null && _wouldCreateCycle(node.id, parentId)) {
+      throw FormatException(
+        'RuntimeNode.parent would create a cycle: ${node.id} -> $parentId',
+      );
+    }
+  }
+
+  void _reattachChildrenOf(String parentId) {
+    for (final component in _components.values.toList(growable: false)) {
+      if (component.node.parent == parentId) {
+        _attachToParent(component);
+      }
+    }
+  }
+
+  List<String> _descendantIdsOf(String parentId) {
+    final descendants = <String>[];
+    for (final component in _components.values) {
+      if (component.node.parent == parentId) {
+        descendants.add(component.node.id);
+        descendants.addAll(_descendantIdsOf(component.node.id));
+      }
+    }
+    return descendants;
+  }
+
+  bool _isCulledByParentListView(
+    RuntimeComponent component,
+    RuntimeComponent? parent,
+  ) {
+    final parentNode = parent?.node;
+    if (parentNode == null ||
+        parentNode.type != RuntimeNodeType.listView ||
+        !parentNode.virtualized) {
+      return false;
+    }
+    final cache = parentNode.cacheExtent;
+    final viewportLeft = parentNode.scrollX - cache;
+    final viewportTop = parentNode.scrollY - cache;
+    final viewport = parent?.listViewContentViewport() ?? Vector2.zero();
+    final viewportRight = parentNode.scrollX + viewport.x + cache;
+    final viewportBottom = parentNode.scrollY + viewport.y + cache;
+    final node = component.node;
+    final childLeft = node.x;
+    final childTop = node.y;
+    final childRight = node.x + (node.width ?? 0);
+    final childBottom = node.y + (node.height ?? 0);
+    return childRight < viewportLeft ||
+        childLeft > viewportRight ||
+        childBottom < viewportTop ||
+        childTop > viewportBottom;
+  }
+
+  Vector2 _listViewContentViewport(RuntimeNode node) {
+    final width = node.width ?? 0;
+    final height = node.height ?? 0;
+    final left = node.paddingLeft.clamp(0.0, width).toDouble();
+    final top = node.paddingTop.clamp(0.0, height).toDouble();
+    if (!node.scrollbarVisible) {
+      return Vector2(
+        (width - left - node.paddingRight).clamp(0.0, width).toDouble(),
+        (height - top - node.paddingBottom).clamp(0.0, height).toDouble(),
+      );
+    }
+    final thickness = (node.scrollbarThickness ?? 5).clamp(1.0, 16.0);
+    final gutter = thickness + 8;
+    var vertical = (node.contentHeight ?? 0) > height && height > 0;
+    var horizontal = (node.contentWidth ?? 0) > width && width > 0;
+    for (var i = 0; i < 2; i += 1) {
+      final viewportWidth =
+          width - left - node.paddingRight - (vertical ? gutter : 0);
+      final viewportHeight =
+          height - top - node.paddingBottom - (horizontal ? gutter : 0);
+      vertical =
+          (node.contentHeight ?? 0) > viewportHeight && viewportHeight > 0;
+      horizontal =
+          (node.contentWidth ?? 0) > viewportWidth && viewportWidth > 0;
+    }
+    return Vector2(
+      (width - left - node.paddingRight - (vertical ? gutter : 0))
+          .clamp(0.0, width)
+          .toDouble(),
+      (height - top - node.paddingBottom - (horizontal ? gutter : 0))
+          .clamp(0.0, height)
+          .toDouble(),
+    );
+  }
+
+  double _clampScroll(
+    double value, {
+    required double? viewportExtent,
+    required double? contentExtent,
+  }) {
+    final maxScroll = (contentExtent ?? 0) - (viewportExtent ?? 0);
+    if (maxScroll <= 0) {
+      return 0;
+    }
+    return value.clamp(0, maxScroll).toDouble();
+  }
+
+  void _emitScrollEvent(RuntimeComponent component, {required String source}) {
+    final node = component.node;
+    final handler = node.onScroll;
+    if (handler == null || handler.isEmpty) {
+      return;
+    }
+    final id = node.id;
+    _eventSink(
+      RuntimeEvent(
+        type: RuntimeEventType.scroll,
+        target: id,
+        handler: handler,
+        scope: id,
+        targetEpoch: epochOf(id),
+        scopeEpoch: epochOf(id),
+        data: {
+          'scrollX': node.scrollX,
+          'scrollY': node.scrollY,
+          'maxScrollX': _clampScroll(
+            double.infinity,
+            viewportExtent: node.width,
+            contentExtent: node.contentWidth,
+          ),
+          'maxScrollY': _clampScroll(
+            double.infinity,
+            viewportExtent: node.height,
+            contentExtent: node.contentHeight,
+          ),
+          'source': source,
+        },
+      ),
+    );
+  }
+
+  bool _wouldCreateCycle(String nodeId, String parentId) {
+    var currentId = parentId;
+    while (true) {
+      if (currentId == nodeId) {
+        return true;
+      }
+
+      final parent = _components[currentId];
+      final nextId = parent?.node.parent;
+      if (nextId == null) {
+        return false;
+      }
+      currentId = nextId;
+    }
+  }
+}