vim-web 0.3.44-dev.18 → 0.3.44-dev.19

package/dist/vim-web.iife.js

@@ -50664,7 +50664,7 @@ void main() {
     }
     init(duration) {
       this.cancel();
-      this._duration = duration;
+      this._duration = Math.max(duration, 0.01);
       this._clock.start();
     }
     cancel() {
@@ -50985,6 +50985,7 @@ void main() {
      * @returns {CameraMovement} The camera movement api.
      */
     lerp(duration = 1, force = false) {
+      if (duration <= 0) return this.snap(force);
       this.stop();
       this._force = force;
       this._lerp.init(duration);
@@ -51886,10 +51887,10 @@ void main() {
       });
       __publicField(this, "onMouseUp", (event) => {
         event.stopImmediatePropagation();
+        event.preventDefault();
         const btn = this.getButton(event);
         if (btn === this._buttonDown) return;
         this._viewer.gizmos.rectangle.visible = false;
-        event.preventDefault();
         if (!this._buttonDown) return;
         if (this.inputs.pointerActive === "rect" && this._hasMouseMoved && !this._hasCameraMoved) {
           this.onRectEnd();
@@ -51906,6 +51907,7 @@ void main() {
         this.inputs.pointerOverride = void 0;
       });
       __publicField(this, "onDoubleClick", (event) => {
+        console.log("Double click");
         event.stopImmediatePropagation();
         this.onMouseClick(
           new Vector2(event.offsetX, event.offsetY),
@@ -55469,6 +55471,7 @@ void main() {
       __publicField(this, "_color");
       __publicField(this, "_highlightColor");
       __publicField(this, "_materials");
+      __publicField(this, "_camera");
       __publicField(this, "_camSub");
       this._materials = [matAlways, matBehind];
       this._forward = new Vector3();
@@ -55481,15 +55484,18 @@ void main() {
       this.quaternion.setFromUnitVectors(new Vector3(0, -1, 0), this._forward);
     }
     trackCamera(camera2) {
-      const rescale = () => {
-        const size = camera2.frustrumSizeAt(this.position);
-        this.scale.set(size.x * 3e-3, size.x * 3e-3, size.x * 3e-3);
-      };
-      this._camSub = camera2.onMoved.subscribe(() => rescale());
-      rescale();
+      this._camera = camera2;
+      this.update();
+      this._camSub = camera2.onMoved.subscribe(() => this.update());
+    }
+    update() {
+      if (!this._camera) return;
+      const size = this._camera.frustrumSizeAt(this.position);
+      this.scale.set(size.x * 3e-3, size.x * 3e-3, size.x * 3e-3);
     }
     setPosition(position) {
       this.position.copy(position);
+      this.update();
     }
     get forward() {
       return this._forward;
@@ -57627,6 +57633,36 @@ void main() {
     }
     return Math.min(Math.max(value, min2), max2);
   }
+  class CaptureStateMachine {
+    constructor(canvas) {
+      __publicField(this, "_canvas");
+      __publicField(this, "state");
+      __publicField(this, "id");
+      this._canvas = canvas;
+      this.state = "none";
+      this.id = -1;
+    }
+    onPointerDown(event) {
+      if (this.state === "captured") {
+        this._canvas.releasePointerCapture(this.id);
+      }
+      this.id = event.pointerId;
+      this.state = "captured";
+    }
+    onPointerMove(event) {
+      if (this.state === "capture") {
+        this._canvas.setPointerCapture(this.id);
+        this.state = "captured";
+      }
+    }
+    onPointerUp(event) {
+      if (this.state === "captured") {
+        this._canvas.releasePointerCapture(this.id);
+        this.state = "none";
+        this.id = -1;
+      }
+    }
+  }
   class InputMouse extends InputHandler {
     constructor(canvas, rpc, selection, camera2) {
       super();
@@ -57635,45 +57671,47 @@ void main() {
       __publicField(this, "_lastMouseDownPosition", new Vector2(0, 0));
       __publicField(this, "_selection");
       __publicField(this, "_camera");
+      __publicField(this, "_capture");
       this._canvas = canvas;
       this._rpc = rpc;
       this._selection = selection;
       this._camera = camera2;
+      this._capture = new CaptureStateMachine(canvas);
     }
     register() {
       this.reg(this._canvas, "pointerdown", (e) => {
-        this.handlePointerDown(e);
+        this.onPointerDown(e);
       });
       this.reg(this._canvas, "pointerup", (e) => {
-        this.handlePointerUp(e);
+        this.onPointerUp(e);
       });
       this.reg(this._canvas, "pointermove", (e) => {
-        this.handlePointerMove(e);
+        this.onPointerMove(e);
       });
       this.reg(this._canvas, "wheel", (e) => {
-        this.handleMouseScroll(e);
+        this.onMouseScroll(e);
       });
       this.reg(this._canvas, "dblclick", (e) => {
-        this.handleDoubleClick(e);
+        this.onDoubleClick(e);
       });
     }
     dispose() {
       this.unregister();
     }
-    handlePointerDown(event) {
+    onPointerDown(event) {
       if (event.pointerType !== "mouse") return;
       const pos = this.relativePosition(event);
       this._rpc.RPCMouseButtonEvent(pos, event.button, true);
       this._lastMouseDownPosition = pos;
-      this._canvas.setPointerCapture(event.pointerId);
+      this._capture.onPointerDown(event);
       event.preventDefault();
     }
-    handlePointerUp(event) {
+    onPointerUp(event) {
       if (event.pointerType !== "mouse") return;
       const pos = this.relativePosition(event);
       this._rpc.RPCMouseButtonEvent(pos, event.button, false);
       this.handleMouseClick(event);
-      this._canvas.releasePointerCapture(event.pointerId);
+      this._capture.onPointerUp(event);
       event.preventDefault();
     }
     async handleMouseClick(event) {
@@ -57693,21 +57731,24 @@ void main() {
         this._selection.select(hit.vim, hit.nodeIndex);
       }
     }
-    handlePointerMove(event) {
+    onPointerMove(event) {
       if (event.pointerType !== "mouse") return;
       this._canvas.focus();
+      this._capture.onPointerMove(event);
       const pos = this.relativePosition(event);
       this._rpc.RPCMouseMoveEvent(pos);
     }
-    async handleDoubleClick(event) {
+    async onDoubleClick(event) {
       const pos = this.relativePosition(event);
       const hit = await this._selection.hitTest(pos);
       if (hit) {
         this._camera.frameVim(hit.vim, [hit.nodeIndex], 1);
+      } else {
+        this._camera.frameAll(1);
       }
       event.preventDefault();
     }
-    handleMouseScroll(event) {
+    onMouseScroll(event) {
       this._rpc.RPCMouseScrollEvent(Math.sign(event.deltaY));
       event.preventDefault();
     }
@@ -59687,15 +59728,19 @@ void main() {
       switch (event.key) {
         case "Escape":
           this._selection.clear();
+          event.preventDefault();
           break;
         case "f":
           this.frameContext();
+          event.preventDefault();
           break;
         case "Home":
           this._camera.restoreSavedPosition();
+          event.preventDefault();
           break;
         case " ":
           this._inputs.mode = this._inputs.mode === InputMode.Orbit ? InputMode.Free : InputMode.Orbit;
+          event.preventDefault();
           break;
       }
     }
@@ -61235,11 +61280,15 @@ Averrage Date/Second ${avgDataRatePS} kb
      * Handles camera initialization when connection is established
      */
     onConnect() {
+      this.set(new Vector3(-1e3, 1e3, 1e3), new Vector3(0, 0, 0), 0);
       this.restoreLastPosition();
     }
     onCameraPose(pose) {
       this._lastPosition = pose;
     }
+    set(position, target, blendTime = this._defaultBlendTime) {
+      this._rpc.RPCSetCameraPosition(new Segment(position, target), blendTime);
+    }
     /**
      * Pauses or resumes rendering
      * @param value - True to pause rendering, false to resume
@@ -61253,6 +61302,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @returns Promise that resolves when the framing animation is complete
      */
     async frameAll(blendTime = this._defaultBlendTime) {
+      console.log("Camera.frameAll");
       const segment = await this._rpc.RPCFrameAll(blendTime);
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
@@ -61263,6 +61313,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      */
     async frameBox(box, blendTime = this._defaultBlendTime) {
+      console.log("Camera.frameAll");
       const segment = await this._rpc.RPCFrameBox(box, blendTime);
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
@@ -74959,7 +75010,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       if (!this._settings.isolation.enable) return;
       this._isolation = objects ?? [];
       this._apply(source);
-      this._camera.frameVisibleObjects.call();
+      this._camera.frameScene.call();
     }
     /**
      * Toggles isolation by using the current selection.
@@ -74974,7 +75025,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       if (!this._settings.isolation.enable) return;
       this._isolation = [...this._viewer.selection.objects].filter((o) => o.type === "Object3D");
       this._apply(source);
-      this._camera.frameVisibleObjects.call();
+      this._camera.frameScene.call();
       this._viewer.selection.clear();
     }
     /**
@@ -75074,140 +75125,6 @@ Averrage Date/Second ${avgDataRatePS} kb
       return objects;
     }
   }
-  function useStateRef(initialValue) {
-    const [value, setValue] = React2.useState(initialValue);
-    const ref = React2.useRef(initialValue);
-    const event = React2.useRef(new distExports.SimpleEventDispatcher());
-    const validate = React2.useRef((value2) => value2);
-    const confirm = React2.useRef((value2) => value2);
-    const set2 = (value2) => {
-      const finalValue = validate.current(value2) ?? value2;
-      if (finalValue === void 0) return;
-      if (finalValue === ref.current) return;
-      ref.current = finalValue;
-      setValue(finalValue);
-      event.current.dispatch(finalValue);
-    };
-    return {
-      get() {
-        return ref.current;
-      },
-      set: set2,
-      confirm() {
-        set2(confirm.current(ref.current));
-      },
-      useOnChange(on) {
-        React2.useEffect(() => {
-          return event.current.subscribe(on);
-        }, []);
-      },
-      useMemo(on, deps) {
-        return React2.useMemo(() => on(value), [...deps || [], value]);
-      },
-      useValidate(on) {
-        React2.useEffect(() => {
-          validate.current = on;
-        }, []);
-      },
-      useConfirm(on) {
-        React2.useEffect(() => {
-          confirm.current = on;
-        }, []);
-      }
-    };
-  }
-  function useActionRef(action) {
-    const ref = React2.useRef(action);
-    return {
-      call() {
-        ref == null ? void 0 : ref.current();
-      },
-      set(func) {
-        ref.current = func;
-      }
-    };
-  }
-  function useArgActionRef(action) {
-    const ref = React2.useRef(action);
-    return {
-      call(arg) {
-        ref == null ? void 0 : ref.current(arg);
-      },
-      set(func) {
-        ref.current = func;
-      }
-    };
-  }
-  function useFuncRef(func) {
-    const ref = React2.useRef(func);
-    return {
-      call() {
-        return ref == null ? void 0 : ref.current();
-      },
-      set(func2) {
-        ref.current = func2;
-      }
-    };
-  }
-  function useCamera(viewer) {
-    const autoCamera2 = useStateRef(false);
-    autoCamera2.useOnChange((v) => {
-      if (v) {
-        frameSelection2.call();
-      }
-    });
-    React2.useEffect(() => {
-      viewer.selection.onValueChanged.sub(() => {
-        if (autoCamera2.get()) {
-          frameSelection2.call();
-        }
-      });
-    }, []);
-    const reset = useActionRef(() => viewer.camera.lerp(1).reset());
-    const frameSelection2 = useActionRef(() => {
-      if (viewer.selection.count === 0) {
-        frameVisibleObjects.call();
-        return;
-      }
-      const box = viewer.selection.getBoundingBox();
-      if (!box) {
-        return;
-      }
-      box.intersect(viewer.gizmos.sectionBox.box);
-      if (box.isEmpty()) {
-        return;
-      }
-      viewer.camera.lerp(1).frame(box);
-    });
-    const frameVisibleObjects = useActionRef(() => {
-      const movement = viewer.camera.lerp(1);
-      const box = getVisibleBoundingBox(viewer);
-      movement.frame(box);
-    });
-    return {
-      autoCamera: autoCamera2,
-      reset,
-      frameSelection: frameSelection2,
-      frameVisibleObjects
-    };
-  }
-  function getVisibleBoundingBox(viewer, source) {
-    let box;
-    const vimBoxUnion = (vim) => {
-      for (const obj of vim.getObjects()) {
-        if (!obj.visible) continue;
-        const b = obj.getBoundingBox();
-        if (!b) continue;
-        box = box ? box.union(b) : b == null ? void 0 : b.clone();
-      }
-    };
-    {
-      for (const vim of viewer.vims) {
-        vimBoxUnion(vim);
-      }
-    }
-    return box;
-  }
   function createContainer(element) {
     let root = element;
     if (root === void 0) {
@@ -75919,6 +75836,92 @@ Averrage Date/Second ${avgDataRatePS} kb
     r.max.z += b2.max.z;
     return r;
   }
+  function useStateRef(initialValue) {
+    const [value, setValue] = React2.useState(initialValue);
+    const ref = React2.useRef(initialValue);
+    const event = React2.useRef(new distExports.SimpleEventDispatcher());
+    const validate = React2.useRef((value2) => value2);
+    const confirm = React2.useRef((value2) => value2);
+    const set2 = (value2) => {
+      const finalValue = validate.current(value2) ?? value2;
+      if (finalValue === void 0) return;
+      if (finalValue === ref.current) return;
+      ref.current = finalValue;
+      setValue(finalValue);
+      event.current.dispatch(finalValue);
+    };
+    return {
+      get() {
+        return ref.current;
+      },
+      set: set2,
+      confirm() {
+        set2(confirm.current(ref.current));
+      },
+      useOnChange(on) {
+        React2.useEffect(() => {
+          return event.current.subscribe(on);
+        }, []);
+      },
+      useMemo(on, deps) {
+        return React2.useMemo(() => on(value), [...deps || [], value]);
+      },
+      useValidate(on) {
+        React2.useEffect(() => {
+          validate.current = on;
+        }, []);
+      },
+      useConfirm(on) {
+        React2.useEffect(() => {
+          confirm.current = on;
+        }, []);
+      }
+    };
+  }
+  function useActionRef(action) {
+    const ref = React2.useRef(action);
+    return {
+      call() {
+        ref == null ? void 0 : ref.current();
+      },
+      set(func) {
+        ref.current = func;
+      }
+    };
+  }
+  function useArgActionRef(action) {
+    const ref = React2.useRef(action);
+    return {
+      call(arg) {
+        ref == null ? void 0 : ref.current(arg);
+      },
+      set(func) {
+        ref.current = func;
+      }
+    };
+  }
+  function useFuncRef(func) {
+    const ref = React2.useRef(func);
+    return {
+      call() {
+        return ref == null ? void 0 : ref.current();
+      },
+      set(func2) {
+        ref.current = func2;
+      }
+    };
+  }
+  function useAsyncFuncRef(func) {
+    const ref = React2.useRef(func);
+    return {
+      async call() {
+        return ref == null ? void 0 : ref.current();
+      },
+      set(func2) {
+        ref.current = func2;
+      }
+    };
+  }
   function useSectionBox(adapter) {
     const enable = useStateRef(false);
     const visible2 = useStateRef(false);
@@ -75950,6 +75953,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     });
     visible2.useOnChange((v) => adapter.setVisible(v));
     React2.useEffect(() => {
+      adapter.setVisible(false);
       return adapter.onSelectionChanged.sub(() => {
         if (auto.get() && enable.get()) sectionSelection.call();
       });
@@ -76014,12 +76018,61 @@ Averrage Date/Second ${avgDataRatePS} kb
       fitBox: (box) => viewer.gizmos.sectionBox.fitBox(box),
       getSelectionBox: () => Promise.resolve(viewer.selection.getBoundingBox()),
       getRendererBox: () => Promise.resolve(viewer.renderer.getBoundingBox()),
-      onSceneChanged: viewer.renderer.onBoxUpdated,
       onSelectionChanged: viewer.selection.onValueChanged
     };
     viewer.gizmos.sectionBox.clip = true;
     return useSectionBox(vimAdapter);
   }
+  function useCamera(adapter) {
+    const autoCamera2 = useStateRef(false);
+    autoCamera2.useOnChange((v) => {
+      if (v) {
+        frameSelection2.call();
+      }
+    });
+    React2.useEffect(() => {
+      adapter.onSelectionChanged.sub(() => {
+        if (autoCamera2.get()) {
+          frameSelection2.call();
+        }
+      });
+    }, []);
+    const reset = useActionRef(() => adapter.resetCamera(1));
+    const frameSelection2 = useAsyncFuncRef(async () => {
+      console.log("frameSelection");
+      if (!adapter.hasSelection()) {
+        frameScene.call();
+        return;
+      }
+      const box = await adapter.getSelectionBox();
+      if (!box) {
+        return;
+      }
+      adapter.frameCamera(box, 1);
+    });
+    const frameScene = useAsyncFuncRef(async () => {
+      adapter.frameAll(1);
+    });
+    return {
+      autoCamera: autoCamera2,
+      reset,
+      frameSelection: frameSelection2,
+      frameScene
+    };
+  }
+  function useWebglCamera(viewer) {
+    return useCamera({
+      onSelectionChanged: viewer.selection.onValueChanged,
+      frameCamera: (box, duration) => viewer.camera.lerp(duration).frame(box),
+      resetCamera: (duration) => viewer.camera.lerp(duration).reset(),
+      frameAll: (duration) => {
+        const box = viewer.renderer.getBoundingBox();
+        viewer.camera.lerp(duration).frame(box);
+      },
+      hasSelection: () => viewer.selection.count > 0,
+      getSelectionBox: () => Promise.resolve(viewer.selection.getBoundingBox())
+    });
+  }
   function createWebglComponent(container, componentSettings = {}, viewerSettings = {}) {
     const promise2 = new DeferredPromise();
     const cmpContainer = container instanceof HTMLElement ? createContainer(container) : container ?? createContainer();
@@ -76051,7 +76104,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     var _a2;
     const settings2 = useSettings(props.viewer, props.settings ?? {});
     const modal = useModal(settings2.value.capacity.canFollowUrl);
-    const camera2 = useCamera(props.viewer);
+    const camera2 = useWebglCamera(props.viewer);
     const cursor = React2.useMemo(() => new CursorManager(props.viewer), []);
     const loader = React2.useRef(new ComponentLoader(props.viewer, modal));
     const [isolation] = React2.useState(() => new Isolation(props.viewer, camera2, settings2.value));
@@ -76507,6 +76560,7 @@ Averrage Date/Second ${avgDataRatePS} kb
   function useUltraSectionBox(viewer) {
     const ultraAdapter = {
       setVisible: (b) => {
+        console.log("SetVisible!", b);
         viewer.sectionBox.visible = b;
         viewer.sectionBox.interactive = b;
       },
@@ -76514,15 +76568,26 @@ Averrage Date/Second ${avgDataRatePS} kb
       fitBox: (box) => viewer.sectionBox.fitBox(box),
       getSelectionBox: () => viewer.selection.getBoundingBox(),
       getRendererBox: () => viewer.renderer.getBoundingBox(),
-      onSelectionChanged: viewer.selection.onValueChanged,
-      onSceneChanged: viewer.vims.onChanged
+      onSelectionChanged: viewer.selection.onValueChanged
     };
     return useSectionBox(ultraAdapter);
   }
-  function useUltraControlBar(viewer, section, customization) {
-    let controlBar2 = [controlBarSectionBox(section, viewer.selection.count > 0)];
-    controlBar2 = (customization == null ? void 0 : customization(controlBar2)) ?? controlBar2;
-    return controlBar2;
+  function useUltraControlBar(viewer, section, camera2, customization) {
+    const sectionSectionBox = controlBarSectionBox(section, viewer.selection.count > 0);
+    const sectionCamera = controlBarCamera(camera2);
+    let bar = [sectionCamera, sectionSectionBox];
+    bar = (customization == null ? void 0 : customization(bar)) ?? bar;
+    return bar;
+  }
+  function useUltraCamera(viewer) {
+    return useCamera({
+      onSelectionChanged: viewer.selection.onValueChanged,
+      frameCamera: (box, duration) => void viewer.camera.frameBox(box, duration),
+      frameAll: (duration) => viewer.camera.frameAll(duration),
+      resetCamera: (duration) => viewer.camera.restoreSavedPosition(duration),
+      hasSelection: () => viewer.selection.count > 0,
+      getSelectionBox: () => viewer.selection.getBoundingBox()
+    });
   }
   function createUltraComponent(container) {
     const promise2 = new DeferredPromise();
@@ -76552,10 +76617,11 @@ Averrage Date/Second ${avgDataRatePS} kb
   function UltraComponent(props) {
     const modal = useModal(true);
     const sectionBox2 = useUltraSectionBox(props.viewer);
+    const camera2 = useUltraCamera(props.viewer);
     const side = useSideState(true, 400);
     const [_, setSelectState] = React2.useState(0);
     const [controlBarCustom, setControlBarCustom] = React2.useState(() => (c) => c);
-    const controlBar2 = useUltraControlBar(props.viewer, sectionBox2, (_2) => _2);
+    const controlBar2 = useUltraControlBar(props.viewer, sectionBox2, camera2, (_2) => _2);
     React2.useEffect(() => {
       props.viewer.onStateChanged.subscribe((state) => updateModal(modal, state));
       props.viewer.selection.onValueChanged.subscribe(() => {