@woosh/meep-engine 3.16.0 → 3.17.1

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

@@ -13,7 +13,8 @@ import { NodeInstancePortReference } from "../../../src/core/model/node-graph/no
 import { ActionProcessor } from "../../../src/core/process/undo/ActionProcessor.js";
 import { NodeGraphCamera } from "./NodeGraphCamera.js";
 import { NodeGraphSelection } from "./NodeGraphSelection.js";
-import { ConnectionCreateAction } from "./actions/ConnectionCreateAction.js";
+import { connection_bind_actions } from "./actions/connection_bind_actions.js";
+import { ConnectionDeleteAction } from "./actions/ConnectionDeleteAction.js";
 import { NodeParameterSetAction } from "./actions/NodeParameterSetAction.js";
 import { NodesMoveAction } from "./actions/NodesMoveAction.js";
 import { SelectionSetAction } from "./actions/SelectionSetAction.js";
@@ -299,7 +300,20 @@ export class NodeGraphView extends View {
              *
              * @type {boolean}
              */
-            consumed: false
+            consumed: false,
+
+            /**
+             * The wire this gesture picked up, when it began on an input that already had one.
+             *
+             * Dragging out of a bound input is that wire being moved rather than a second one being
+             * made, so the gesture continues from the source it came from and this is what is on
+             * the end of it. It is not taken off the graph until the drop says where it is going —
+             * a gesture that ends on a port that refuses it, or on the port it started from, has to
+             * leave the graph as it found it — so while the drag runs it is only hidden.
+             *
+             * @type {Connection|null}
+             */
+            detached: null
         };
 
         const vBlockCanvas = new ListView(graph.nodes, {
@@ -340,12 +354,25 @@ export class NodeGraphView extends View {
                                     return;
                                 }
 
+                                // An input holds one wire, so a drag out of a bound one is that
+                                // wire being taken hold of: what is on the end of the gesture is
+                                // its source, and where it is let go decides what it feeds — or
+                                // whether it feeds anything, which is how one is pulled off.
+                                const held = port.direction === PortDirection.In
+                                    ? node.getEndpoint(port.id).inConnections[0] ?? null
+                                    : null;
+
                                 const endpoint = new NodeInstancePortReference();
 
-                                endpoint.set(node, port);
+                                if (held === null) {
+                                    endpoint.set(node, port);
+                                } else {
+                                    endpoint.set(held.source.instance, held.source.port);
+                                }
 
                                 tempConnection.enabled = true;
                                 tempConnection.consumed = false;
+                                tempConnection.detached = held;
                                 tempConnection.endpoint = endpoint;
 
                                 // The wire is drawn from here to the anchor, and a gesture that ends
@@ -362,8 +389,10 @@ export class NodeGraphView extends View {
 
                                 const endpoint = tempConnection.endpoint;
                                 const consumed = tempConnection.consumed;
+                                const detached = tempConnection.detached;
 
                                 tempConnection.enabled = false;
+                                tempConnection.detached = null;
 
                                 requestRedraw();
 
@@ -373,6 +402,15 @@ export class NodeGraphView extends View {
                                     return;
                                 }
 
+                                if (detached !== null) {
+                                    // A wire taken off an input and let go over nothing is a wire
+                                    // removed. Its own step: what the host makes of the drop below
+                                    // — a menu that may be dismissed — is a separate decision, and
+                                    // the removal stands whichever way that goes.
+                                    actionProcessor.mark('disconnect');
+                                    actionProcessor.do(new ConnectionDeleteAction(graph, detached, visual));
+                                }
+
                                 const anchor = tempConnection.anchor;
 
                                 self.transformPointGraph2Canvas(anchor, v2_pointer);
@@ -443,19 +481,46 @@ export class NodeGraphView extends View {
                                     const source_ref = graph.getConnectionEndpoint(source_node, source_port);
                                     const target_ref = graph.getConnectionEndpoint(target_node, target_port);
 
+                                    const detached = tempConnection.detached;
+
+                                    if (
+                                        detached !== null
+                                        && detached.source === source_ref
+                                        && detached.target === target_ref
+                                    ) {
+                                        // a wire picked up and put back where it came from: the
+                                        // gesture did nothing, and leaving it alone is what makes
+                                        // that true — nothing reaches the timeline
+                                        return;
+                                    }
+
                                     const duplicate = source_ref.connections.some(
                                         c => c.source === source_ref && c.target === target_ref
                                     );
 
-                                    if (!duplicate) {
-                                        actionProcessor.mark('create connection');
-                                        actionProcessor.do(new ConnectionCreateAction(
+                                    const actions = duplicate
+                                        ? []
+                                        : connection_bind_actions(
                                             graph,
                                             source_node, source_port,
-                                            target_node, target_port
-                                        ));
+                                            target_node, target_port,
+                                            visual
+                                        );
+
+                                    if (detached !== null) {
+                                        // the wire this gesture is holding now feeds somewhere
+                                        // else, so it comes off where it was — one step, because
+                                        // it was one gesture
+                                        actions.unshift(new ConnectionDeleteAction(graph, detached, visual));
                                     }
 
+                                    if (actions.length > 0) {
+                                        actionProcessor.mark(detached === null
+                                            ? 'create connection'
+                                            : 'move connection');
+
+                                        actionProcessor.doMany(actions);
+                                    }
                                 }
                             }
                         });
@@ -598,6 +663,13 @@ export class NodeGraphView extends View {
             //draw connections: a wire carries what comes out of its source
             graph.connections.forEach(connection => {
 
+                if (connection === tempConnection.detached) {
+                    // in hand rather than on the graph: it is drawn below, running to the cursor.
+                    // Still on the graph because where it ends up is the drop's to decide, and one
+                    // that lands back where it started has to leave no trace.
+                    return;
+                }
+
                 this.drawConnection(
                     ctx,
                     this.resolveConnectionPath(connection),
@@ -690,6 +762,10 @@ export class NodeGraphView extends View {
         this.bindSignal(graph.on.connectionAdded, requestRedraw);
         this.bindSignal(graph.on.connectionRemoved, requestRedraw);
 
+        // connection ids are pooled the way node ids are, so a wire that is gone must not leave its
+        // selection behind for an unrelated future one to be handed
+        this.bindSignal(graph.on.connectionRemoved, connection => selection.connections.removeOneOf(connection.id));
+
         // selected wires are drawn highlighted
         this.bindSignal(selection.connections.on.added, requestRedraw);
         this.bindSignal(selection.connections.on.removed, requestRedraw);

package/editor/view/node-graph/actions/connection_bind_actions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bind an input to a source, taking off whatever that input was already holding.
+ *
+ * An input takes one wire. A second one dropped on it is an author saying what should feed it,
+ * not asking for a merge the graph has no rule for — so the wire that was there comes off in the
+ * same gesture, and on the same step of the timeline. That an editor can never leave an input with
+ * two sources is the point: a graph loaded from a file may be in that state and is reported for it,
+ * but no gesture on the canvas can put one there.
+ *
+ * Returned rather than performed, so a caller in the middle of a larger step — a node and its first
+ * wire, say — can fold them into it. {@link ActionProcessor#doMany} applies them in order.
+ *
+ * @param {NodeGraph} graph
+ * @param {number} sourceNode
+ * @param {number} sourcePort
+ * @param {number} targetNode
+ * @param {number} targetPort input port; what is already bound to it is unbound first
+ * @param {NodeGraphVisualData} [visual] source of the removed wires' paths; without it the paths are
+ *        left alone, which is what a caller with no visual data wants
+ * @returns {Action[]}
+ */
+export function connection_bind_actions(graph: NodeGraph, sourceNode: number, sourcePort: number, targetNode: number, targetPort: number, visual?: NodeGraphVisualData): Action[];
+//# sourceMappingURL=connection_bind_actions.d.ts.map

package/editor/view/node-graph/actions/connection_bind_actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection_bind_actions.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/connection_bind_actions.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sEARW,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,iCAGJ,QAAQ,CAgBpB"}

package/editor/view/node-graph/actions/connection_bind_actions.js

@@ -0,0 +1,39 @@
+import { ConnectionCreateAction } from "./ConnectionCreateAction.js";
+import { ConnectionDeleteAction } from "./ConnectionDeleteAction.js";
+
+/**
+ * Bind an input to a source, taking off whatever that input was already holding.
+ *
+ * An input takes one wire. A second one dropped on it is an author saying what should feed it,
+ * not asking for a merge the graph has no rule for — so the wire that was there comes off in the
+ * same gesture, and on the same step of the timeline. That an editor can never leave an input with
+ * two sources is the point: a graph loaded from a file may be in that state and is reported for it,
+ * but no gesture on the canvas can put one there.
+ *
+ * Returned rather than performed, so a caller in the middle of a larger step — a node and its first
+ * wire, say — can fold them into it. {@link ActionProcessor#doMany} applies them in order.
+ *
+ * @param {NodeGraph} graph
+ * @param {number} sourceNode
+ * @param {number} sourcePort
+ * @param {number} targetNode
+ * @param {number} targetPort input port; what is already bound to it is unbound first
+ * @param {NodeGraphVisualData} [visual] source of the removed wires' paths; without it the paths are
+ *        left alone, which is what a caller with no visual data wants
+ * @returns {Action[]}
+ */
+export function connection_bind_actions(graph, sourceNode, sourcePort, targetNode, targetPort, visual = undefined) {
+    const target = graph.getConnectionEndpoint(targetNode, targetPort);
+
+    const actions = [];
+
+    // off before on, so the graph is never holding an input with two sources — not even between two
+    // actions of one step, where anything watching it would see one
+    for (const connection of target === undefined ? [] : target.inConnections) {
+        actions.push(new ConnectionDeleteAction(graph, connection, visual));
+    }
+
+    actions.push(new ConnectionCreateAction(graph, sourceNode, sourcePort, targetNode, targetPort));
+
+    return actions;
+}

package/editor/view/particles/effect/ParticleCodeEditorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleCodeEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleCodeEditorView.js"],"names":[],"mappings":"AAgDA;IA2DI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OA6G9F;IAxGG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAmGxB;;OAEG;IACH,wBAYC;IAED;;;;OAIG;IACH,gBAsCC;IAwGD;;;OAGG;IACH,iBAFW,MAAM,QAahB;IAsBD;;OAEG;IACH,eAyBC;IAcD,eAcC;;CACJ;iBA5dgB,8BAA8B"}
+{"version":3,"file":"ParticleCodeEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleCodeEditorView.js"],"names":[],"mappings":"AAgDA;IA2DI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OA6G9F;IAxGG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAmGxB;;OAEG;IACH,wBAYC;IAED;;;;OAIG;IACH,gBAsCC;IAyGD;;;OAGG;IACH,iBAFW,MAAM,QAahB;IAsBD;;OAEG;IACH,eAyBC;IAcD,eAcC;;CACJ;iBA7dgB,8BAA8B"}

package/editor/view/particles/effect/ParticleCodeEditorView.js

@@ -283,9 +283,10 @@ export class ParticleCodeEditorView extends View {
     /**
      * What the optimizer did, in the two numbers that decide whether it was worth it.
      *
-     * Instructions are what the VM steps through and registers are what limits how much of an effect
-     * fits at all (see `PARTICLE_VM_REGISTER_SLOTS`), so those are the pair. Blank when the box is
-     * not ticked: there is nothing to compare a program against itself with.
+     * Instructions are what the VM steps through and registers are what decides which interpreter
+     * runs it: past `PARTICLE_VM_FAST_REGISTER_SLOTS` the whole system falls back to the wide VM,
+     * which works and is far slower. So those are the pair. Blank when the box is not ticked: there
+     * is nothing to compare a program against itself with.
      *
      * @param {import("../../../particles/effect/ParticleEffectDocument.js").ParticleEffectCompilation} compilation
      */

package/editor/view/particles/effect/ParticleCurveEditorView.d.ts

@@ -0,0 +1,20 @@
+export class ParticleCurveEditorView extends View {
+    /**
+     * @param {object} options
+     * @param {function():object} options.read the parameter's current value
+     * @param {function(object):void} options.write commit a new value
+     */
+    constructor({ read, write }: {
+        read: () => object;
+        write: (arg0: object) => void;
+    });
+    el: HTMLDivElement;
+    /**
+     * Re-read the parameter and redraw.
+     */
+    refresh(): void;
+    render(): void;
+    #private;
+}
+import View from "../../../../src/view/View.js";
+//# sourceMappingURL=ParticleCurveEditorView.d.ts.map

package/editor/view/particles/effect/ParticleCurveEditorView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleCurveEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleCurveEditorView.js"],"names":[],"mappings":"AAgEA;IA6CI;;;;OAIG;IACH;QAHsC,IAAI,QAApB,MAAM;QACc,KAAK,SAA3B,MAAM,KAAE,IAAI;OAiF/B;IAzEG,mBAAuC;IA2E3C;;OAEG;IACH,gBAcC;IAgRD,eAiEC;;CACJ;iBA/hBgB,8BAA8B"}