@woosh/meep-engine 3.16.0 → 3.17.0

package/src/core/model/node-graph/visual/layout/route_grid_build.d.ts

@@ -8,8 +8,9 @@
  * - **At every port**, a line at the height it sits at. This is what lets a wire arrive at a port
  *   horizontally instead of sloping into it, and it is most of the reason the grid is as tall as
  *   it is.
- * - **At every lane** the layout reserved. A wire crossing a column it does not stop at was
- *   promised empty space there; this is the line running through it.
+ * - **At every lane** the layout reserved, a line at its height and one at its x — the middle of
+ *   its column. A wire crossing a column it does not stop at was promised empty space there, and
+ *   it is routed through the point where the two meet.
  * - **Across every channel**, a few evenly spaced tracks. Without them the only places a wire can
  *   turn in a channel are the box edges either side of it, so every wire turning in that channel
  *   turns in the same place and they are drawn on top of each other.

package/src/core/model/node-graph/visual/layout/route_grid_build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route_grid_build.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_grid_build.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,2FALa,SAAS,CA6GrB;0BAlJyB,gBAAgB"}
+{"version":3,"file":"route_grid_build.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_grid_build.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,2FALa,SAAS,CA8GrB;0BA1I6C,gBAAgB"}

package/src/core/model/node-graph/visual/layout/route_grid_build.js

@@ -1,17 +1,7 @@
 import { LAYOUT_BOX_LANE } from "./LayoutBoxGraph.js";
 import { number_compare_ascending } from "../../../../primitives/numbers/number_compare_ascending.js";
 import { LAYOUT_SIDE_BOTTOM, LAYOUT_SIDE_TOP } from "./LayoutProblem.js";
-import { RouteGrid } from "./RouteGrid.js";
-
-/**
- * Coordinates nearer than this to one already collected are the same coordinate.
- *
- * Two lines a fraction of a unit apart are one line to anybody looking at the drawing, and keeping
- * both of them costs a whole row or column of the grid.
- *
- * @type {number}
- */
-const COORDINATE_EPSILON = 0.5;
+import { ROUTE_GRID_EPSILON, RouteGrid } from "./RouteGrid.js";
 
 /**
  * Work out which lines wires are allowed to travel along, and mark the boxes solid.
@@ -23,8 +13,9 @@ const COORDINATE_EPSILON = 0.5;
  * - **At every port**, a line at the height it sits at. This is what lets a wire arrive at a port
  *   horizontally instead of sloping into it, and it is most of the reason the grid is as tall as
  *   it is.
- * - **At every lane** the layout reserved. A wire crossing a column it does not stop at was
- *   promised empty space there; this is the line running through it.
+ * - **At every lane** the layout reserved, a line at its height and one at its x — the middle of
+ *   its column. A wire crossing a column it does not stop at was promised empty space there, and
+ *   it is routed through the point where the two meet.
  * - **Across every channel**, a few evenly spaced tracks. Without them the only places a wire can
  *   turn in a channel are the box edges either side of it, so every wire turning in that channel
  *   turns in the same place and they are drawn on top of each other.
@@ -80,7 +71,8 @@ export function route_grid_build(problem, options) {
 
         if (boxes.box_kind[box] === LAYOUT_BOX_LANE) {
             // A lane is a point, not an obstacle: it is the promise of empty space, so all it
-            // contributes is the line through it.
+            // contributes is the two lines through it.
+            xs.push(x0);
             ys.push(y0);
 
             continue;
@@ -225,7 +217,7 @@ function sorted_unique(values) {
     for (let i = 0; i < values.length; i++) {
         const value = values[i];
 
-        if (count > 0 && value - packed[count - 1] < COORDINATE_EPSILON) {
+        if (count > 0 && value - packed[count - 1] < ROUTE_GRID_EPSILON) {
             continue;
         }
 

package/src/core/model/node-graph/visual/layout/route_nudge.d.ts

@@ -12,6 +12,12 @@
  * swap and once to swap back. So a group is ordered by where its members come from and where they
  * go, and gets spread in that order.
  *
+ * **Wires of one net stay together.** The wires leaving one port are one signal, and where they
+ * run along the same line they are one line that forks — the router lets them share it for
+ * nothing for exactly that reason. Pulled apart they would be several lines, and the one that
+ * forks first would cross every one outside it. So a group is spread by net, every wire of a net
+ * moving by the same amount, and a group that is all one net does not move.
+ *
  * Only the middle of a wire moves. The two ends meet ports, and a port is where it is.
  *
  * @param {RouteSet} routes mutated in place

package/src/core/model/node-graph/visual/layout/route_nudge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route_nudge.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_nudge.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gFALa,MAAM,CAiElB"}
+{"version":3,"file":"route_nudge.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_nudge.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gFALa,MAAM,CA6DlB"}

package/src/core/model/node-graph/visual/layout/route_nudge.js

@@ -25,6 +25,12 @@ const SPREAD_LIMIT = 0.7;
  * swap and once to swap back. So a group is ordered by where its members come from and where they
  * go, and gets spread in that order.
  *
+ * **Wires of one net stay together.** The wires leaving one port are one signal, and where they
+ * run along the same line they are one line that forks — the router lets them share it for
+ * nothing for exactly that reason. Pulled apart they would be several lines, and the one that
+ * forks first would cross every one outside it. So a group is spread by net, every wire of a net
+ * moving by the same amount, and a group that is all one net does not move.
+ *
  * Only the middle of a wire moves. The two ends meet ports, and a port is where it is.
  *
  * @param {RouteSet} routes mutated in place
@@ -82,12 +88,8 @@ export function route_nudge(routes, options) {
             end++;
         }
 
-        const size = end - start;
-
-        if (size > 1) {
-            spread(routes, segments, order, start, end, separation, limit);
-
-            moved += size;
+        if (end - start > 1) {
+            moved += spread(routes, segments, order, start, end, separation, limit);
         }
 
         start = end;
@@ -97,7 +99,8 @@ export function route_nudge(routes, options) {
 }
 
 /**
- * Move one group of overlapping runs off their shared line, evenly either side of it.
+ * Move one group of overlapping runs off their shared line, evenly either side of it — one place
+ * per net, and every run of a net by the same amount.
  *
  * @param {RouteSet} routes
  * @param {object} segments
@@ -106,11 +109,9 @@ export function route_nudge(routes, options) {
  * @param {number} end exclusive
  * @param {number} separation
  * @param {number} limit largest distance any of them may be moved
- * @returns {void}
+ * @returns {number} how many runs were moved
  */
 function spread(routes, segments, order, start, end, separation, limit) {
-    const size = end - start;
-
     const group = order.subarray(start, end);
 
     // Where each wire comes into the run from and where it leaves it for, across the line rather
@@ -121,12 +122,31 @@ function spread(routes, segments, order, start, end, separation, limit) {
         || (segments.route[a] - segments.route[b])
     );
 
-    const step = Math.min(separation, size > 1 ? limit * 2 / (size - 1) : separation);
+    // each net takes the place its first run sorted to
+    const place = new Map();
+
+    for (let i = 0; i < group.length; i++) {
+        const net = segments.net[group[i]];
+
+        if (!place.has(net)) {
+            place.set(net, place.size);
+        }
+    }
+
+    const size = place.size;
 
-    for (let i = 0; i < size; i++) {
+    if (size < 2) {
+        return 0;
+    }
+
+    const step = Math.min(separation, limit * 2 / (size - 1));
+
+    let moved = 0;
+
+    for (let i = 0; i < group.length; i++) {
         const segment = group[i];
 
-        const shift = (i - (size - 1) / 2) * step;
+        const shift = (place.get(segments.net[segment]) - (size - 1) / 2) * step;
 
         if (shift === 0) {
             continue;
@@ -141,7 +161,11 @@ function spread(routes, segments, order, start, end, separation, limit) {
             routes.x[at] += shift;
             routes.x[at + 1] += shift;
         }
+
+        moved++;
     }
+
+    return moved;
 }
 
 /**
@@ -167,6 +191,7 @@ function collect(routes) {
     const segments = {
         count: 0,
         route: new Int32Array(capacity),
+        net: new Int32Array(capacity),
         point: new Int32Array(capacity),
         axis: new Uint8Array(capacity),
         fixed: new Float64Array(capacity),
@@ -180,6 +205,9 @@ function collect(routes) {
         const start = routes.offset[i];
         const end = routes.offset[i + 1];
 
+        // a route nobody has put in a net is a net of its own
+        const net = routes.net === null ? i : routes.net[i];
+
         for (let p = start + 1; p + 2 < end; p++) {
             const ax = routes.x[p];
             const ay = routes.y[p];
@@ -197,6 +225,7 @@ function collect(routes) {
             const at = segments.count++;
 
             segments.route[at] = i;
+            segments.net[at] = net;
             segments.point[at] = p;
             segments.axis[at] = horizontal ? 0 : 1;