vim-web 0.6.0-dev.1 → 0.6.0-dev.3

package/dist/vim-web.js

@@ -894,7 +894,7 @@ function requireDist$2() {
   return dist$3;
 }
 var distExports$2 = requireDist$2();
-const MAX_VIMS = 256;
+const MAX_VIMS = 255;
 let VimCollection$1 = class VimCollection {
   constructor() {
     // Sparse storage indexed by stable ID
@@ -48649,6 +48649,266 @@ class SimpleInstanceSubmesh {
     return this.mesh;
   }
 }
+const MARKER_VIM_INDEX = 255;
+function packPickingId(vimIndex, elementIndex) {
+  return (vimIndex & 255) << 24 | elementIndex & 16777215;
+}
+function unpackPickingId(packedId) {
+  return {
+    vimIndex: packedId >>> 24,
+    elementIndex: packedId & 16777215
+  };
+}
+class GpuPickResult {
+  constructor(elementIndex, vimIndex, worldPosition, worldNormal, vim, marker) {
+    /** The element index in the vim (or marker index if vimIndex === MARKER_VIM_INDEX) */
+    __publicField(this, "elementIndex");
+    /** The vim index identifying which vim the element belongs to (255 = marker) */
+    __publicField(this, "vimIndex");
+    /** The world position of the hit */
+    __publicField(this, "worldPosition");
+    /** The world normal at the hit point */
+    __publicField(this, "worldNormal");
+    /** Reference to the vim containing the element */
+    __publicField(this, "_vim");
+    /** Reference to the marker if this is a marker hit */
+    __publicField(this, "_marker");
+    this.elementIndex = elementIndex;
+    this.vimIndex = vimIndex;
+    this.worldPosition = worldPosition;
+    this.worldNormal = worldNormal;
+    this._vim = vim;
+    this._marker = marker;
+  }
+  /**
+   * The object property for IRaycastResult interface.
+   * Returns the Element3D or Marker for the picked object.
+   */
+  get object() {
+    return this._marker ?? this.getElement();
+  }
+  /**
+   * Gets the Element3D object for the picked element.
+   * @returns The Element3D object, or undefined if not found or if this is a marker hit
+   */
+  getElement() {
+    var _a3;
+    return (_a3 = this._vim) == null ? void 0 : _a3.getElementFromIndex(this.elementIndex);
+  }
+  /**
+   * Gets the Marker object if this is a marker hit.
+   * @returns The Marker object, or undefined if this is an element hit
+   */
+  getMarker() {
+    return this._marker;
+  }
+}
+class GpuPicker {
+  constructor(renderer, camera2, scene, vims, section, width, height) {
+    __publicField(this, "_renderer");
+    __publicField(this, "_camera");
+    __publicField(this, "_scene");
+    __publicField(this, "_vims");
+    __publicField(this, "_markers");
+    __publicField(this, "_section");
+    __publicField(this, "_renderTarget");
+    __publicField(this, "_pickingMaterial");
+    __publicField(this, "_readBuffer");
+    // Debug visualization
+    __publicField(this, "debug", true);
+    __publicField(this, "_debugSphere");
+    __publicField(this, "_debugLine");
+    this._renderer = renderer;
+    this._camera = camera2;
+    this._scene = scene;
+    this._vims = vims;
+    this._section = section;
+    this._renderTarget = new WebGLRenderTarget(width, height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      format: RGBAFormat,
+      type: FloatType,
+      depthBuffer: true
+    });
+    this._pickingMaterial = new PickingMaterial();
+    this._readBuffer = new Float32Array(4);
+  }
+  /**
+   * Sets the GizmoMarkers reference for marker picking.
+   * Must be called after gizmos are initialized.
+   */
+  setMarkers(markers) {
+    this._markers = markers;
+  }
+  /**
+   * Updates the render target size to match viewport.
+   */
+  setSize(width, height) {
+    this._renderTarget.setSize(width, height);
+  }
+  /**
+   * Performs GPU picking at the given screen coordinates.
+   * Returns a result object with element index, world position, and getElement() method.
+   *
+   * @param screenPos Screen position in 0-1 range (0,0 is top-left)
+   * @returns Pick result with element index, world position, and getElement(), or undefined if no hit
+   */
+  pick(screenPos) {
+    var _a3;
+    const camera2 = this._camera.three;
+    camera2.updateMatrixWorld(true);
+    const currentRenderTarget = this._renderer.getRenderTarget();
+    const currentOverrideMaterial = this._scene.threeScene.overrideMaterial;
+    const currentBackground = this._scene.threeScene.background;
+    this._pickingMaterial.updateCamera(camera2);
+    if (this._section.active) {
+      this._pickingMaterial.clippingPlanes = this._section.clippingPlanes;
+    } else {
+      this._pickingMaterial.clippingPlanes = [];
+    }
+    this._scene.threeScene.background = null;
+    this._scene.threeScene.overrideMaterial = this._pickingMaterial.material;
+    camera2.layers.disable(1);
+    this._renderer.setRenderTarget(this._renderTarget);
+    this._renderer.setClearColor(0, 0);
+    this._renderer.clear();
+    this._renderer.render(this._scene.threeScene, camera2);
+    this._renderer.setRenderTarget(currentRenderTarget);
+    camera2.layers.enable(1);
+    this._scene.threeScene.overrideMaterial = currentOverrideMaterial;
+    this._scene.threeScene.background = currentBackground;
+    const pixelX = Math.floor(screenPos.x * this._renderTarget.width);
+    const pixelY = Math.floor((1 - screenPos.y) * this._renderTarget.height);
+    this._renderer.readRenderTargetPixels(
+      this._renderTarget,
+      pixelX,
+      pixelY,
+      1,
+      1,
+      this._readBuffer
+    );
+    const depth = this._readBuffer[1];
+    const normalX = this._readBuffer[2];
+    const normalY = this._readBuffer[3];
+    if (depth <= 0) {
+      return void 0;
+    }
+    const dataView = new DataView(this._readBuffer.buffer);
+    const packedId = dataView.getUint32(0, true);
+    const { vimIndex, elementIndex } = unpackPickingId(packedId);
+    const normalZ = Math.sqrt(Math.max(0, 1 - normalX * normalX - normalY * normalY));
+    const worldNormal = new Vector3(normalX, normalY, normalZ).normalize();
+    const worldPosition = this.reconstructWorldPosition(screenPos, depth, camera2);
+    if (vimIndex === MARKER_VIM_INDEX) {
+      const marker = (_a3 = this._markers) == null ? void 0 : _a3.getMarkerFromIndex(elementIndex);
+      const result2 = new GpuPickResult(elementIndex, vimIndex, worldPosition, worldNormal, void 0, marker);
+      if (this.debug) {
+        this.showDebugVisuals(result2);
+      }
+      return result2;
+    }
+    const vim = this._vims.getFromId(vimIndex);
+    const result = new GpuPickResult(elementIndex, vimIndex, worldPosition, worldNormal, vim);
+    if (this.debug) {
+      this.showDebugVisuals(result);
+    }
+    return result;
+  }
+  /**
+   * Shows debug visuals (sphere at hit point, line showing normal direction).
+   */
+  showDebugVisuals(result) {
+    this.clearDebugVisuals();
+    const sphereGeometry = new SphereGeometry(0.5, 16, 16);
+    const sphereMaterial = new MeshBasicMaterial({ color: 16711680 });
+    this._debugSphere = new Mesh(sphereGeometry, sphereMaterial);
+    this._debugSphere.position.copy(result.worldPosition);
+    this._debugSphere.layers.set(1);
+    this._scene.threeScene.add(this._debugSphere);
+    const lineLength = 2;
+    const lineStart = result.worldPosition.clone();
+    const lineEnd = result.worldPosition.clone().add(result.worldNormal.clone().multiplyScalar(lineLength));
+    const lineGeometry = new BufferGeometry().setFromPoints([lineStart, lineEnd]);
+    const lineMaterial = new LineBasicMaterial({ color: 65280, linewidth: 2 });
+    this._debugLine = new Line(lineGeometry, lineMaterial);
+    this._debugLine.layers.set(1);
+    this._scene.threeScene.add(this._debugLine);
+    this._renderer.domElement.dispatchEvent(new Event("needsUpdate"));
+  }
+  /**
+   * Reconstructs world position from screen coordinates and depth value.
+   */
+  reconstructWorldPosition(screenPos, depth, camera2) {
+    const ndcX = screenPos.x * 2 - 1;
+    const ndcY = (1 - screenPos.y) * 2 - 1;
+    const rayEnd = new Vector3(ndcX, ndcY, 1).unproject(camera2);
+    const rayDir = rayEnd.sub(camera2.position).normalize();
+    const cameraDir = new Vector3();
+    camera2.getWorldDirection(cameraDir);
+    const t = depth / rayDir.dot(cameraDir);
+    const worldPos = camera2.position.clone().add(rayDir.clone().multiplyScalar(t));
+    return worldPos;
+  }
+  /**
+   * Removes debug visuals (sphere and normal line) from the scene.
+   */
+  clearDebugVisuals() {
+    if (this._debugSphere) {
+      this._scene.threeScene.remove(this._debugSphere);
+      this._debugSphere.geometry.dispose();
+      this._debugSphere.material.dispose();
+      this._debugSphere = void 0;
+    }
+    if (this._debugLine) {
+      this._scene.threeScene.remove(this._debugLine);
+      this._debugLine.geometry.dispose();
+      this._debugLine.material.dispose();
+      this._debugLine = void 0;
+    }
+  }
+  /**
+   * Raycasts from camera to the screen position to find the first object hit.
+   * Implements IRaycaster interface.
+   * @param position - Screen position in 0-1 range (0,0 is top-left)
+   * @returns A promise that resolves to the raycast result, or undefined if no hit
+   */
+  raycastFromScreen(position) {
+    return Promise.resolve(this.pick(position));
+  }
+  /**
+   * Raycasts from camera towards a world position to find the first object hit.
+   * Implements IRaycaster interface.
+   * @param position - The world position to raycast towards
+   * @returns A promise that resolves to the raycast result, or undefined if no hit
+   */
+  raycastFromWorld(position) {
+    const screenPos = this.worldToScreen(position);
+    if (!screenPos) return Promise.resolve(void 0);
+    return Promise.resolve(this.pick(screenPos));
+  }
+  /**
+   * Converts a world position to screen coordinates (0-1 range).
+   * @param worldPos - The world position to convert
+   * @returns Screen position in 0-1 range, or undefined if behind camera
+   */
+  worldToScreen(worldPos) {
+    const camera2 = this._camera.three;
+    camera2.updateMatrixWorld(true);
+    const ndc = worldPos.clone().project(camera2);
+    if (ndc.z > 1) return void 0;
+    const screenX = (ndc.x + 1) / 2;
+    const screenY = (1 - ndc.y) / 2;
+    return new Vector2(screenX, screenY);
+  }
+  /**
+   * Disposes of all resources.
+   */
+  dispose() {
+    this.clearDebugVisuals();
+    this._renderTarget.dispose();
+    this._pickingMaterial.dispose();
+  }
+}
 class GizmoMarkers {
   /**
    * Constructs the marker manager and sets up an initial instanced mesh.
@@ -48692,6 +48952,12 @@ class GizmoMarkers {
     mesh.count = 0;
     mesh.frustumCulled = false;
     mesh.layers.enableAll();
+    const packedIdArray = new Uint32Array(capacity);
+    const packedIdAttr = new InstancedBufferAttribute(packedIdArray, 1);
+    mesh.geometry.setAttribute("packedId", packedIdAttr);
+    const ignoreArray = new Float32Array(capacity);
+    const ignoreAttr = new InstancedBufferAttribute(ignoreArray, 1);
+    mesh.geometry.setAttribute("ignore", ignoreAttr);
     this._viewer.renderer.add(mesh);
     return mesh;
   }
@@ -48701,12 +48967,20 @@ class GizmoMarkers {
   resizeMesh() {
     const larger = this.createMesh(this._mesh, this._mesh.count * 2);
     larger.count = this._mesh.count;
+    const oldPackedId = this._mesh.geometry.getAttribute("packedId");
+    const oldIgnore = this._mesh.geometry.getAttribute("ignore");
+    const newPackedId = larger.geometry.getAttribute("packedId");
+    const newIgnore = larger.geometry.getAttribute("ignore");
     for (let i = 0; i < this._mesh.count; i++) {
       this._mesh.getMatrixAt(i, this._reusableMatrix);
       larger.setMatrixAt(i, this._reusableMatrix);
+      newPackedId.setX(i, oldPackedId.getX(i));
+      newIgnore.setX(i, oldIgnore.getX(i));
       const sub = new SimpleInstanceSubmesh(larger, i);
       this._markers[i].updateMesh(sub);
     }
+    newPackedId.needsUpdate = true;
+    newIgnore.needsUpdate = true;
     this._viewer.renderer.remove(this._mesh);
     this._mesh = larger;
   }
@@ -48720,8 +48994,12 @@ class GizmoMarkers {
     if (this._mesh.count === this._mesh.instanceMatrix.count) {
       this.resizeMesh();
     }
+    const markerIndex = this._mesh.count;
     this._mesh.count += 1;
-    const sub = new SimpleInstanceSubmesh(this._mesh, this._mesh.count - 1);
+    const packedIdAttr = this._mesh.geometry.getAttribute("packedId");
+    packedIdAttr.setX(markerIndex, packPickingId(MARKER_VIM_INDEX, markerIndex));
+    packedIdAttr.needsUpdate = true;
+    const sub = new SimpleInstanceSubmesh(this._mesh, markerIndex);
     const marker = new Marker(this._viewer, sub);
     marker.position = position;
     this._markers.push(marker);
@@ -48742,7 +49020,10 @@ class GizmoMarkers {
       this._mesh.getMatrixAt(fromIndex, this._reusableMatrix);
       this._mesh.setMatrixAt(destIndex, this._reusableMatrix);
       this._mesh.instanceMatrix.needsUpdate = true;
-      const sub = new SimpleInstanceSubmesh(this._mesh, marker.index);
+      const packedIdAttr = this._mesh.geometry.getAttribute("packedId");
+      packedIdAttr.setX(destIndex, packPickingId(MARKER_VIM_INDEX, destIndex));
+      packedIdAttr.needsUpdate = true;
+      const sub = new SimpleInstanceSubmesh(this._mesh, destIndex);
       lastMarker.updateMesh(sub);
     }
     this._markers.length -= 1;
@@ -53643,238 +53924,6 @@ class Gizmos {
     this.axes.dispose();
   }
 }
-function packPickingId(vimIndex, elementIndex) {
-  return (vimIndex & 255) << 24 | elementIndex & 16777215;
-}
-function unpackPickingId(packedId) {
-  return {
-    vimIndex: packedId >>> 24,
-    elementIndex: packedId & 16777215
-  };
-}
-class GpuPickResult {
-  constructor(elementIndex, vimIndex, worldPosition, worldNormal, vim) {
-    /** The element index in the vim */
-    __publicField(this, "elementIndex");
-    /** The vim index identifying which vim the element belongs to */
-    __publicField(this, "vimIndex");
-    /** The world position of the hit */
-    __publicField(this, "worldPosition");
-    /** The world normal at the hit point */
-    __publicField(this, "worldNormal");
-    /** Reference to the vim containing the element */
-    __publicField(this, "_vim");
-    this.elementIndex = elementIndex;
-    this.vimIndex = vimIndex;
-    this.worldPosition = worldPosition;
-    this.worldNormal = worldNormal;
-    this._vim = vim;
-  }
-  /**
-   * The object property for IRaycastResult interface.
-   * Returns the Element3D for the picked element.
-   */
-  get object() {
-    return this.getElement();
-  }
-  /**
-   * Gets the Element3D object for the picked element.
-   * @returns The Element3D object, or undefined if not found
-   */
-  getElement() {
-    var _a3;
-    return (_a3 = this._vim) == null ? void 0 : _a3.getElementFromIndex(this.elementIndex);
-  }
-}
-class GpuPicker {
-  constructor(renderer, camera2, scene, vims, section, width, height) {
-    __publicField(this, "_renderer");
-    __publicField(this, "_camera");
-    __publicField(this, "_scene");
-    __publicField(this, "_vims");
-    __publicField(this, "_section");
-    __publicField(this, "_renderTarget");
-    __publicField(this, "_pickingMaterial");
-    __publicField(this, "_readBuffer");
-    // Debug visualization
-    __publicField(this, "debug", true);
-    __publicField(this, "_debugSphere");
-    __publicField(this, "_debugLine");
-    this._renderer = renderer;
-    this._camera = camera2;
-    this._scene = scene;
-    this._vims = vims;
-    this._section = section;
-    this._renderTarget = new WebGLRenderTarget(width, height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      format: RGBAFormat,
-      type: FloatType,
-      depthBuffer: true
-    });
-    this._pickingMaterial = new PickingMaterial();
-    this._readBuffer = new Float32Array(4);
-  }
-  /**
-   * Updates the render target size to match viewport.
-   */
-  setSize(width, height) {
-    this._renderTarget.setSize(width, height);
-  }
-  /**
-   * Performs GPU picking at the given screen coordinates.
-   * Returns a result object with element index, world position, and getElement() method.
-   *
-   * @param screenPos Screen position in 0-1 range (0,0 is top-left)
-   * @returns Pick result with element index, world position, and getElement(), or undefined if no hit
-   */
-  pick(screenPos) {
-    const camera2 = this._camera.three;
-    camera2.updateMatrixWorld(true);
-    const currentRenderTarget = this._renderer.getRenderTarget();
-    const currentOverrideMaterial = this._scene.threeScene.overrideMaterial;
-    const currentBackground = this._scene.threeScene.background;
-    this._pickingMaterial.updateCamera(camera2);
-    if (this._section.active) {
-      this._pickingMaterial.clippingPlanes = this._section.clippingPlanes;
-    } else {
-      this._pickingMaterial.clippingPlanes = [];
-    }
-    this._scene.threeScene.background = null;
-    this._scene.threeScene.overrideMaterial = this._pickingMaterial.material;
-    camera2.layers.disable(1);
-    this._renderer.setRenderTarget(this._renderTarget);
-    this._renderer.setClearColor(0, 0);
-    this._renderer.clear();
-    this._renderer.render(this._scene.threeScene, camera2);
-    this._renderer.setRenderTarget(currentRenderTarget);
-    camera2.layers.enable(1);
-    this._scene.threeScene.overrideMaterial = currentOverrideMaterial;
-    this._scene.threeScene.background = currentBackground;
-    const pixelX = Math.floor(screenPos.x * this._renderTarget.width);
-    const pixelY = Math.floor((1 - screenPos.y) * this._renderTarget.height);
-    this._renderer.readRenderTargetPixels(
-      this._renderTarget,
-      pixelX,
-      pixelY,
-      1,
-      1,
-      this._readBuffer
-    );
-    const depth = this._readBuffer[1];
-    const normalX = this._readBuffer[2];
-    const normalY = this._readBuffer[3];
-    if (depth <= 0) {
-      return void 0;
-    }
-    const dataView = new DataView(this._readBuffer.buffer);
-    const packedId = dataView.getUint32(0, true);
-    const { vimIndex, elementIndex } = unpackPickingId(packedId);
-    const normalZ = Math.sqrt(Math.max(0, 1 - normalX * normalX - normalY * normalY));
-    const worldNormal = new Vector3(normalX, normalY, normalZ).normalize();
-    const worldPosition = this.reconstructWorldPosition(screenPos, depth, camera2);
-    const vim = this._vims.getFromId(vimIndex);
-    const result = new GpuPickResult(elementIndex, vimIndex, worldPosition, worldNormal, vim);
-    if (this.debug) {
-      this.showDebugVisuals(result);
-    }
-    return result;
-  }
-  /**
-   * Shows debug visuals (sphere at hit point, line showing normal direction).
-   */
-  showDebugVisuals(result) {
-    this.clearDebugVisuals();
-    const sphereGeometry = new SphereGeometry(0.5, 16, 16);
-    const sphereMaterial = new MeshBasicMaterial({ color: 16711680 });
-    this._debugSphere = new Mesh(sphereGeometry, sphereMaterial);
-    this._debugSphere.position.copy(result.worldPosition);
-    this._debugSphere.layers.set(1);
-    this._scene.threeScene.add(this._debugSphere);
-    const lineLength = 2;
-    const lineStart = result.worldPosition.clone();
-    const lineEnd = result.worldPosition.clone().add(result.worldNormal.clone().multiplyScalar(lineLength));
-    const lineGeometry = new BufferGeometry().setFromPoints([lineStart, lineEnd]);
-    const lineMaterial = new LineBasicMaterial({ color: 65280, linewidth: 2 });
-    this._debugLine = new Line(lineGeometry, lineMaterial);
-    this._debugLine.layers.set(1);
-    this._scene.threeScene.add(this._debugLine);
-    this._renderer.domElement.dispatchEvent(new Event("needsUpdate"));
-  }
-  /**
-   * Reconstructs world position from screen coordinates and depth value.
-   */
-  reconstructWorldPosition(screenPos, depth, camera2) {
-    const ndcX = screenPos.x * 2 - 1;
-    const ndcY = (1 - screenPos.y) * 2 - 1;
-    const rayEnd = new Vector3(ndcX, ndcY, 1).unproject(camera2);
-    const rayDir = rayEnd.sub(camera2.position).normalize();
-    const cameraDir = new Vector3();
-    camera2.getWorldDirection(cameraDir);
-    const t = depth / rayDir.dot(cameraDir);
-    const worldPos = camera2.position.clone().add(rayDir.clone().multiplyScalar(t));
-    return worldPos;
-  }
-  /**
-   * Removes debug visuals (sphere and normal line) from the scene.
-   */
-  clearDebugVisuals() {
-    if (this._debugSphere) {
-      this._scene.threeScene.remove(this._debugSphere);
-      this._debugSphere.geometry.dispose();
-      this._debugSphere.material.dispose();
-      this._debugSphere = void 0;
-    }
-    if (this._debugLine) {
-      this._scene.threeScene.remove(this._debugLine);
-      this._debugLine.geometry.dispose();
-      this._debugLine.material.dispose();
-      this._debugLine = void 0;
-    }
-  }
-  /**
-   * Raycasts from camera to the screen position to find the first object hit.
-   * Implements IRaycaster interface.
-   * @param position - Screen position in 0-1 range (0,0 is top-left)
-   * @returns A promise that resolves to the raycast result, or undefined if no hit
-   */
-  raycastFromScreen(position) {
-    return Promise.resolve(this.pick(position));
-  }
-  /**
-   * Raycasts from camera towards a world position to find the first object hit.
-   * Implements IRaycaster interface.
-   * @param position - The world position to raycast towards
-   * @returns A promise that resolves to the raycast result, or undefined if no hit
-   */
-  raycastFromWorld(position) {
-    const screenPos = this.worldToScreen(position);
-    if (!screenPos) return Promise.resolve(void 0);
-    return Promise.resolve(this.pick(screenPos));
-  }
-  /**
-   * Converts a world position to screen coordinates (0-1 range).
-   * @param worldPos - The world position to convert
-   * @returns Screen position in 0-1 range, or undefined if behind camera
-   */
-  worldToScreen(worldPos) {
-    const camera2 = this._camera.three;
-    camera2.updateMatrixWorld(true);
-    const ndc = worldPos.clone().project(camera2);
-    if (ndc.z > 1) return void 0;
-    const screenX = (ndc.x + 1) / 2;
-    const screenY = (1 - ndc.y) / 2;
-    return new Vector2(screenX, screenY);
-  }
-  /**
-   * Disposes of all resources.
-   */
-  dispose() {
-    this.clearDebugVisuals();
-    this._renderTarget.dispose();
-    this._pickingMaterial.dispose();
-  }
-}
 function getAverageBoundingBox(positions, thresholdSpan = 1e3, framingDistanceMultiplier = 2) {
   if (positions.length === 0) {
     return new Box3();
@@ -55023,14 +55072,14 @@ function createAdapter$2(viewer) {
     selectAtPointer: async (pos, add) => {
       const result = await viewer.raycaster.raycastFromScreen(pos);
       if (add) {
-        viewer.selection.add(result.object);
+        viewer.selection.add(result == null ? void 0 : result.object);
       } else {
-        viewer.selection.select(result.object);
+        viewer.selection.select(result == null ? void 0 : result.object);
       }
     },
     frameAtPointer: async (pos) => {
       const result = await viewer.raycaster.raycastFromScreen(pos);
-      viewer.camera.lerp(0.75).frame(result.object ?? "all");
+      viewer.camera.lerp(0.75).frame((result == null ? void 0 : result.object) ?? "all");
     },
     zoom: async (value, pos) => {
       if (pos) {
@@ -56333,7 +56382,7 @@ let Viewer$3 = class Viewer {
     this.environment = new Environment(this.camera, this.renderer, this.materials, this.settings);
     this.selection = createSelection$1();
     const size = this.renderer.renderer.getSize(new Vector2());
-    this.raycaster = new GpuPicker(
+    const gpuPicker = new GpuPicker(
       this.renderer.renderer,
       this._camera,
       scene,
@@ -56342,6 +56391,8 @@ let Viewer$3 = class Viewer {
       size.x || 1,
       size.y || 1
     );
+    gpuPicker.setMarkers(this.gizmos.markers);
+    this.raycaster = gpuPicker;
     this.viewport.onResize.sub(() => {
       const size2 = this.viewport.getParentSize();
       this.raycaster.setSize(size2.x, size2.y);