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

package/dist/vim-web.iife.js

@@ -910,7 +910,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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
@@ -48665,6 +48665,266 @@ void main() {
       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.
@@ -48708,6 +48968,12 @@ void main() {
       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;
     }
@@ -48717,12 +48983,20 @@ void main() {
     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 i2 = 0; i2 < this._mesh.count; i2++) {
         this._mesh.getMatrixAt(i2, this._reusableMatrix);
         larger.setMatrixAt(i2, this._reusableMatrix);
+        newPackedId.setX(i2, oldPackedId.getX(i2));
+        newIgnore.setX(i2, oldIgnore.getX(i2));
         const sub = new SimpleInstanceSubmesh(larger, i2);
         this._markers[i2].updateMesh(sub);
       }
+      newPackedId.needsUpdate = true;
+      newIgnore.needsUpdate = true;
       this._viewer.renderer.remove(this._mesh);
       this._mesh = larger;
     }
@@ -48736,8 +49010,12 @@ void main() {
       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);
@@ -48758,7 +49036,10 @@ void main() {
         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;
@@ -53659,238 +53940,6 @@ void main() {
       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();
@@ -55039,14 +55088,14 @@ void main() {
       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) {
@@ -56349,7 +56398,7 @@ void main() {
       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,
@@ -56358,6 +56407,8 @@ void main() {
         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);