@woosh/meep-engine 3.14.6 → 3.16.0

package/editor/view/node-graph/connection_wire_geometry.js

@@ -4,9 +4,14 @@ import { spline3_hermite_bounds } from "../../../src/core/math/spline/spline3_he
 import { spline3_hermite_to_bezier } from "../../../src/core/math/spline/spline3_hermite_to_bezier.js";
 
 /*
- * A connection wire is a cubic hermite spline in graph space: it leaves the source port
- * horizontally, arrives at the target port horizontally, and is level vertically at both ends.
- * This module is the single definition of that shape, shared by drawing, culling and hit-testing.
+ * The shape of a wire that has not been routed: a single cubic hermite spline in graph space,
+ * leaving the source port horizontally, arriving at the target port horizontally, and level
+ * vertically at both ends.
+ *
+ * A wire the layout has routed is not this shape — it is a chain of curves following a path found
+ * around the nodes, and it is held on the connection's own {@link ConnectionVisualData}. This is
+ * what a wire looks like before that has happened, and what one being dragged out of a port looks
+ * like: there is nothing to route to yet.
  */
 
 /**
@@ -105,3 +110,74 @@ export function wire_distance_to_point(px, py, x0, y0, x1, y1) {
 
     return Math.sqrt(best_sqr);
 }
+
+/**
+ * Fill in the path of a wire that has not been routed.
+ *
+ * Everything that draws or hit-tests a wire works from a {@link ConnectionVisualData}, so that
+ * routed and unrouted wires are one case rather than two. This is how an unrouted one becomes one
+ * of those.
+ *
+ * @param {ConnectionVisualData} result
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ * @returns {void}
+ */
+export function wire_build_direct(result, x0, y0, x1, y1) {
+    result.allocate(2);
+
+    result.set_knot(0, x0, y0, WIRE_TANGENT_X, 0);
+    result.set_knot(1, x1, y1, WIRE_TANGENT_X, 0);
+}
+
+/**
+ * How far a routed wire's end may sit from the port it belongs to before the route is out of date.
+ *
+ * Half a unit: routes are written from grid lines and port positions that are themselves exact, so
+ * a route that still belongs to its ports matches them to the bit. Anything further apart is a node
+ * that has been moved.
+ *
+ * @type {number}
+ */
+const ROUTE_STALE_DISTANCE = 0.5;
+
+/**
+ * The path a wire should be drawn along.
+ *
+ * A wire has a route only while its nodes have not moved since it was found. Dragging a node takes
+ * its ports with it and leaves the route behind, and re-routing on every frame of a drag is not
+ * affordable — so a route that no longer meets its own ports is set aside and the wire is drawn the
+ * way an unrouted one is, until the graph is routed again.
+ *
+ * The fallback is written into `scratch`, so the result is only good until the next call.
+ *
+ * @param {ConnectionVisualData|undefined} route what the layout found, if anything
+ * @param {number} x0 where the wire leaves, now
+ * @param {number} y0
+ * @param {number} x1 where it arrives, now
+ * @param {number} y1
+ * @param {ConnectionVisualData} scratch
+ * @returns {ConnectionVisualData}
+ */
+export function wire_resolve_path(route, x0, y0, x1, y1, scratch) {
+    if (route !== undefined && route.knot_count >= 2) {
+        const knots = route.knots;
+
+        const last = (route.knot_count - 1) * 4;
+
+        if (
+            Math.abs(knots[0] - x0) <= ROUTE_STALE_DISTANCE
+            && Math.abs(knots[1] - y0) <= ROUTE_STALE_DISTANCE
+            && Math.abs(knots[last] - x1) <= ROUTE_STALE_DISTANCE
+            && Math.abs(knots[last + 1] - y1) <= ROUTE_STALE_DISTANCE
+        ) {
+            return route;
+        }
+    }
+
+    wire_build_direct(scratch, x0, y0, x1, y1);
+
+    return scratch;
+}