@react-three/drei 11.0.0-alpha.4 → 11.0.0-alpha.5

package/core/index.mjs

@@ -2,9 +2,8 @@ import * as React from 'react';
 import { forwardRef, useImperativeHandle, useMemo, useEffect, useCallback, useRef, useLayoutEffect, useState, Fragment, createContext, useContext } from 'react';
 import { useThree, useFrame, extend, createPortal, useInstanceHandle, context as context$9, useLoader, applyProps, addEffect, addAfterEffect } from '@react-three/fiber';
 import * as THREE from 'three';
-import { REVISION, WebGLRenderTarget, Frustum, Matrix4, Vector3, Vector4, Vector2, Color, InstancedInterleavedBuffer, InterleavedBufferAttribute, WebGLCubeRenderTarget, HalfFloatType, CubeCamera as CubeCamera$1, MathUtils, TextureLoader, Texture as Texture$1, MeshLambertMaterial, Quaternion, DynamicDrawUsage, CatmullRomCurve3, CubicBezierCurve3, QuadraticBezierCurve3, Shape as Shape$1, Object3D, CanvasTexture, DoubleSide, PerspectiveCamera as PerspectiveCamera$1, OrthographicCamera as OrthographicCamera$1, AudioListener, AudioLoader, AnimationMixer, BufferAttribute, Box3, Sphere as Sphere$1, InstancedBufferAttribute, DepthTexture, DepthFormat, UnsignedShortType, CubeTextureLoader, DefaultLoadingManager, Ray, Raycaster, Camera, CubeReflectionMapping, EquirectangularReflectionMapping, Scene, RepeatWrapping } from 'three';
+import { REVISION, WebGLRenderTarget, Frustum, Matrix4, Vector3, Vector4, Vector2, Color, InstancedInterleavedBuffer, InterleavedBufferAttribute, WebGLCubeRenderTarget, HalfFloatType, CubeCamera as CubeCamera$1, EventDispatcher, Euler, Quaternion, MathUtils, TextureLoader, Texture as Texture$1, MeshLambertMaterial, DynamicDrawUsage, CatmullRomCurve3, CubicBezierCurve3, QuadraticBezierCurve3, Shape as Shape$1, Object3D, CanvasTexture, DoubleSide, PerspectiveCamera as PerspectiveCamera$1, OrthographicCamera as OrthographicCamera$1, AudioListener, AudioLoader, AnimationMixer, BufferAttribute, Box3, Sphere as Sphere$1, InstancedBufferAttribute, DepthTexture, DepthFormat, UnsignedShortType, CubeTextureLoader, DefaultLoadingManager, Ray, Raycaster, Camera, CubeReflectionMapping, EquirectangularReflectionMapping, Scene, RepeatWrapping } from 'three';
 import { ArcballControls as ArcballControls$1 } from 'three/examples/jsm/controls/ArcballControls.js';
-import { DeviceOrientationControls as DeviceOrientationControls$1 } from 'three-stdlib';
 import { useGesture } from '@use-gesture/react';
 import { FirstPersonControls as FirstPersonControls$1 } from 'three/examples/jsm/controls/FirstPersonControls.js';
 import { FlyControls as FlyControls$1 } from 'three/examples/jsm/controls/FlyControls.js';
@@ -180,6 +179,7 @@ function shaderMaterial(uniforms, vertexShader, fragmentShader, onInit) {
         });
       }
       this.uniforms = THREE.UniformsUtils.clone(this.uniforms);
+      Object.assign(this, parameters);
     }
   };
 }
@@ -196,7 +196,7 @@ const version = /* @__PURE__ */ getVersion();
 function isLight(object) {
   return object.isLight;
 }
-function isGeometry$1(object) {
+function isGeometry(object) {
   return !!object.geometry;
 }
 const accumulativeContext = /* @__PURE__ */ React.createContext(
@@ -441,7 +441,7 @@ vec3 texelOld = texture2D(previousShadowMap, vUv).rgb;
     this.lights = [];
     this.meshes = [];
     this.scene.traverse((object) => {
-      if (isGeometry$1(object)) {
+      if (isGeometry(object)) {
         this.meshes.push({ object, material: object.material });
       } else if (isLight(object)) {
         this.lights.push({ object, intensity: object.intensity });
@@ -1062,6 +1062,81 @@ const ArcballControls = /* @__PURE__ */ forwardRef(
   }
 );
 
+let DeviceOrientationControls$1 = class DeviceOrientationControls extends EventDispatcher {
+  object;
+  changeEvent = { type: "change" };
+  EPS = 1e-6;
+  enabled = true;
+  deviceOrientation = { alpha: 0, beta: 0, gamma: 0 };
+  screenOrientation = 0;
+  alphaOffset = 0;
+  // radians
+  constructor(object) {
+    super();
+    this.object = object;
+    this.object.rotation.reorder("YXZ");
+    this.connect();
+  }
+  onDeviceOrientationChangeEvent = (event) => {
+    this.deviceOrientation = event;
+  };
+  onScreenOrientationChangeEvent = () => {
+    this.screenOrientation = window.orientation || 0;
+  };
+  // The angles alpha, beta and gamma form a set of intrinsic Tait-Bryan angles of type Z-X'-Y''
+  zee = new Vector3(0, 0, 1);
+  euler = new Euler();
+  q0 = new Quaternion();
+  q1 = new Quaternion(-Math.sqrt(0.5), 0, 0, Math.sqrt(0.5));
+  // - PI/2 around the x-axis
+  setObjectQuaternion = (quaternion, alpha, beta, gamma, orient) => {
+    this.euler.set(beta, alpha, -gamma, "YXZ");
+    quaternion.setFromEuler(this.euler);
+    quaternion.multiply(this.q1);
+    quaternion.multiply(this.q0.setFromAxisAngle(this.zee, -orient));
+  };
+  connect = () => {
+    this.onScreenOrientationChangeEvent();
+    if (window.DeviceOrientationEvent !== void 0 && // @ts-ignore
+    typeof window.DeviceOrientationEvent.requestPermission === "function") {
+      window.DeviceOrientationEvent.requestPermission().then((response) => {
+        if (response == "granted") {
+          window.addEventListener("orientationchange", this.onScreenOrientationChangeEvent);
+          window.addEventListener("deviceorientation", this.onDeviceOrientationChangeEvent);
+        }
+      }).catch((error) => {
+        console.error("THREE.DeviceOrientationControls: Unable to use DeviceOrientation API:", error);
+      });
+    } else {
+      window.addEventListener("orientationchange", this.onScreenOrientationChangeEvent);
+      window.addEventListener("deviceorientation", this.onDeviceOrientationChangeEvent);
+    }
+    this.enabled = true;
+  };
+  disconnect = () => {
+    window.removeEventListener("orientationchange", this.onScreenOrientationChangeEvent);
+    window.removeEventListener("deviceorientation", this.onDeviceOrientationChangeEvent);
+    this.enabled = false;
+  };
+  lastQuaternion = new Quaternion();
+  update = () => {
+    if (this.enabled === false) return;
+    const device = this.deviceOrientation;
+    if (device) {
+      const alpha = device.alpha ? MathUtils.degToRad(device.alpha) + this.alphaOffset : 0;
+      const beta = device.beta ? MathUtils.degToRad(device.beta) : 0;
+      const gamma = device.gamma ? MathUtils.degToRad(device.gamma) : 0;
+      const orient = this.screenOrientation ? MathUtils.degToRad(this.screenOrientation) : 0;
+      this.setObjectQuaternion(this.object.quaternion, alpha, beta, gamma, orient);
+      if (8 * (1 - this.lastQuaternion.dot(this.object.quaternion)) > this.EPS) {
+        this.lastQuaternion.copy(this.object.quaternion);
+        this.dispatchEvent(this.changeEvent);
+      }
+    }
+  };
+  dispose = () => this.disconnect();
+};
+
 const DeviceOrientationControls = /* @__PURE__ */ React.forwardRef(
   (props, ref) => {
     const { camera, onChange, makeDefault, ...rest } = props;
@@ -1131,8 +1206,9 @@ const DragControls = React.forwardRef(
           onDragStart && onDragStart(initialModelPosition);
           invalidate();
         },
-        onDrag: ({ xy: [dragX, dragY], intentional }) => {
+        onDrag: ({ xy: [dragX, dragY], intentional, event }) => {
           if (!intentional) return;
+          if (dragConfig && dragConfig.preventOverlap) event.preventDefault();
           const normalizedMouseX = (dragX - size.left) / size.width * 2 - 1;
           const normalizedMouseY = -((dragY - size.top) / size.height) * 2 + 1;
           mousePosition2D.set(normalizedMouseX, normalizedMouseY);
@@ -1301,12 +1377,21 @@ function KeyboardControls({ map, children, onChange, domElement }) {
       obj.pressed = false;
       if (up) fn(false);
     };
+    const blurHandler = () => {
+      const resetState = map.reduce((prev, cur) => ({ ...prev, [cur.name]: false }), {});
+      set(resetState);
+      Object.values(keyMap).forEach((obj) => {
+        obj.pressed = false;
+      });
+    };
     const source = domElement || window;
     source.addEventListener("keydown", downHandler, { passive: true });
     source.addEventListener("keyup", upHandler, { passive: true });
+    window.addEventListener("blur", blurHandler);
     return () => {
       source.removeEventListener("keydown", downHandler);
       source.removeEventListener("keyup", upHandler);
+      window.removeEventListener("blur", blurHandler);
     };
   }, [domElement, key]);
   return /* @__PURE__ */ React.createElement(context$8.Provider, { value: api, children });
@@ -1657,7 +1742,13 @@ function PresentationControls({
   return /* @__PURE__ */ React.createElement("group", { ref, ...bind?.() }, children);
 }
 
+function roundToPixelRatio(value) {
+  const ratio = window.devicePixelRatio || 1;
+  return Math.round(value * ratio) / ratio;
+}
+
 const context$7 = /* @__PURE__ */ React.createContext(null);
+const rootCache = /* @__PURE__ */ new WeakMap();
 function useScroll() {
   return React.useContext(context$7);
 }
@@ -1671,6 +1762,7 @@ function ScrollControls({
   damping = 0.25,
   maxSpeed = Infinity,
   prepend = false,
+  pixelPerfect = true,
   style = {},
   children
 }) {
@@ -1692,6 +1784,7 @@ function ScrollControls({
       delta: 0,
       scroll,
       pages,
+      pixelPerfect,
       // 0-1 for a range between from -> from + distance
       range(from, distance2, margin = 0) {
         const start = from - margin;
@@ -1710,7 +1803,7 @@ function ScrollControls({
       }
     };
     return state2;
-  }, [eps, damping, horizontal, pages]);
+  }, [eps, damping, horizontal, pages, pixelPerfect]);
   React.useEffect(() => {
     el.style.position = "absolute";
     el.style.width = "100%";
@@ -1823,10 +1916,23 @@ const ScrollHtml = React.forwardRef(
     React.useImperativeHandle(ref, () => group.current, []);
     const { width, height } = useThree((state2) => state2.size);
     const fiberState = React.useContext(context$9);
-    const root = React.useMemo(() => ReactDOM.createRoot(state.fixed), [state.fixed]);
+    const root = React.useMemo(() => {
+      let root2 = rootCache.get(state.fixed);
+      if (!root2) {
+        root2 = ReactDOM.createRoot(state.fixed);
+        rootCache.set(state.fixed, root2);
+      }
+      return root2;
+    }, [state.fixed]);
     useFrame(() => {
       if (state.delta > state.eps) {
-        group.current.style.transform = `translate3d(${state.horizontal ? -width * (state.pages - 1) * state.offset : 0}px,${state.horizontal ? 0 : height * (state.pages - 1) * -state.offset}px,0)`;
+        let x = state.horizontal ? -width * (state.pages - 1) * state.offset : 0;
+        let y = state.horizontal ? 0 : height * (state.pages - 1) * -state.offset;
+        if (state.pixelPerfect) {
+          x = roundToPixelRatio(x);
+          y = roundToPixelRatio(y);
+        }
+        group.current.style.transform = `translate3d(${x}px,${y}px,0)`;
       }
     });
     root.render(
@@ -2755,377 +2861,6 @@ const Text3D = /* @__PURE__ */ React.forwardRef(
   }
 );
 
-const WireframeMaterialShaders = {
-  uniforms: {
-    strokeOpacity: 1,
-    fillOpacity: 0.25,
-    fillMix: 0,
-    thickness: 0.05,
-    colorBackfaces: false,
-    dashInvert: true,
-    dash: false,
-    dashRepeats: 4,
-    dashLength: 0.5,
-    squeeze: false,
-    squeezeMin: 0.2,
-    squeezeMax: 1,
-    stroke: /* @__PURE__ */ new THREE.Color("#ff0000"),
-    backfaceStroke: /* @__PURE__ */ new THREE.Color("#0000ff"),
-    fill: /* @__PURE__ */ new THREE.Color("#00ff00")
-  },
-  vertex: (
-    /* glsl */
-    `
-	  attribute vec3 barycentric;
-	
-		varying vec3 v_edges_Barycentric;
-		varying vec3 v_edges_Position;
-
-		void initWireframe() {
-			v_edges_Barycentric = barycentric;
-			v_edges_Position = position.xyz;
-		}
-	  `
-  ),
-  fragment: (
-    /* glsl */
-    `
-		#ifndef PI
-	  	#define PI 3.1415926535897932384626433832795
-		#endif
-  
-	  varying vec3 v_edges_Barycentric;
-	  varying vec3 v_edges_Position;
-  
-	  uniform float strokeOpacity;
-	  uniform float fillOpacity;
-	  uniform float fillMix;
-	  uniform float thickness;
-	  uniform bool colorBackfaces;
-  
-	  // Dash
-	  uniform bool dashInvert;
-	  uniform bool dash;
-	  uniform bool dashOnly;
-	  uniform float dashRepeats;
-	  uniform float dashLength;
-  
-	  // Squeeze
-	  uniform bool squeeze;
-	  uniform float squeezeMin;
-	  uniform float squeezeMax;
-  
-	  // Colors
-	  uniform vec3 stroke;
-	  uniform vec3 backfaceStroke;
-	  uniform vec3 fill;
-  
-	  // This is like
-	  float wireframe_aastep(float threshold, float dist) {
-		  float afwidth = fwidth(dist) * 0.5;
-		  return smoothstep(threshold - afwidth, threshold + afwidth, dist);
-	  }
-  
-	  float wireframe_map(float value, float min1, float max1, float min2, float max2) {
-		  return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
-	  }
-  
-	  float getWireframe() {
-			vec3 barycentric = v_edges_Barycentric;
-		
-			// Distance from center of each triangle to its edges.
-			float d = min(min(barycentric.x, barycentric.y), barycentric.z);
-
-			// for dashed rendering, we can use this to get the 0 .. 1 value of the line length
-			float positionAlong = max(barycentric.x, barycentric.y);
-			if (barycentric.y < barycentric.x && barycentric.y < barycentric.z) {
-				positionAlong = 1.0 - positionAlong;
-			}
-
-			// the thickness of the stroke
-			float computedThickness = wireframe_map(thickness, 0.0, 1.0, 0.0, 0.34);
-
-			// if we want to shrink the thickness toward the center of the line segment
-			if (squeeze) {
-				computedThickness *= mix(squeezeMin, squeezeMax, (1.0 - sin(positionAlong * PI)));
-			}
-
-			// Create dash pattern
-			if (dash) {
-				// here we offset the stroke position depending on whether it
-				// should overlap or not
-				float offset = 1.0 / dashRepeats * dashLength / 2.0;
-				if (!dashInvert) {
-					offset += 1.0 / dashRepeats / 2.0;
-				}
-
-				// if we should animate the dash or not
-				// if (dashAnimate) {
-				// 	offset += time * 0.22;
-				// }
-
-				// create the repeating dash pattern
-				float pattern = fract((positionAlong + offset) * dashRepeats);
-				computedThickness *= 1.0 - wireframe_aastep(dashLength, pattern);
-			}
-
-			// compute the anti-aliased stroke edge  
-			float edge = 1.0 - wireframe_aastep(computedThickness, d);
-
-			return edge;
-	  }
-	  `
-  )
-};
-const WireframeMaterial = /* @__PURE__ */ shaderMaterial(
-  WireframeMaterialShaders.uniforms,
-  WireframeMaterialShaders.vertex + /* glsl */
-  `
-  	void main() {
-		initWireframe();
-		gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-	}
-  `,
-  WireframeMaterialShaders.fragment + /* glsl */
-  `
-  void main () {
-		// Compute color
-
-		float edge = getWireframe();
-		vec4 colorStroke = vec4(stroke, edge);
-
-		#ifdef FLIP_SIDED
-			colorStroke.rgb = backfaceStroke;
-		#endif
-    
-		vec4 colorFill = vec4(fill, fillOpacity);
-		vec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);
-
-		gl_FragColor = outColor;
-	}
-  `
-);
-function setWireframeOverride(material, uniforms) {
-  material.onBeforeCompile = (shader) => {
-    shader.uniforms = {
-      ...shader.uniforms,
-      ...uniforms
-    };
-    shader.vertexShader = shader.vertexShader.replace(
-      "void main() {",
-      `
-		  ${WireframeMaterialShaders.vertex}
-		  void main() {
-			initWireframe();
-		`
-    );
-    shader.fragmentShader = shader.fragmentShader.replace(
-      "void main() {",
-      `
-		  ${WireframeMaterialShaders.fragment}
-		  void main() {
-		`
-    );
-    shader.fragmentShader = shader.fragmentShader.replace(
-      "#include <color_fragment>",
-      /* glsl */
-      `
-		  #include <color_fragment>
-			  float edge = getWireframe();
-		  vec4 colorStroke = vec4(stroke, edge);
-		  #ifdef FLIP_SIDED
-			colorStroke.rgb = backfaceStroke;
-		  #endif
-		  vec4 colorFill = vec4(mix(diffuseColor.rgb, fill, fillMix), mix(diffuseColor.a, fillOpacity, fillMix));
-		  vec4 outColor = mix(colorFill, colorStroke, edge * strokeOpacity);
-
-		  diffuseColor.rgb = outColor.rgb;
-		  diffuseColor.a *= outColor.a;
-		`
-    );
-  };
-  material.side = THREE.DoubleSide;
-  material.transparent = true;
-}
-function useWireframeUniforms(uniforms, props) {
-  React.useEffect(
-    () => void (uniforms.fillOpacity.value = props.fillOpacity ?? uniforms.fillOpacity.value),
-    [props.fillOpacity]
-  );
-  React.useEffect(() => void (uniforms.fillMix.value = props.fillMix ?? uniforms.fillMix.value), [props.fillMix]);
-  React.useEffect(
-    () => void (uniforms.strokeOpacity.value = props.strokeOpacity ?? uniforms.strokeOpacity.value),
-    [props.strokeOpacity]
-  );
-  React.useEffect(
-    () => void (uniforms.thickness.value = props.thickness ?? uniforms.thickness.value),
-    [props.thickness]
-  );
-  React.useEffect(() => void (uniforms.colorBackfaces.value = !!props.colorBackfaces), [props.colorBackfaces]);
-  React.useEffect(() => void (uniforms.dash.value = !!props.dash), [props.dash]);
-  React.useEffect(() => void (uniforms.dashInvert.value = !!props.dashInvert), [props.dashInvert]);
-  React.useEffect(
-    () => void (uniforms.dashRepeats.value = props.dashRepeats ?? uniforms.dashRepeats.value),
-    [props.dashRepeats]
-  );
-  React.useEffect(
-    () => void (uniforms.dashLength.value = props.dashLength ?? uniforms.dashLength.value),
-    [props.dashLength]
-  );
-  React.useEffect(() => void (uniforms.squeeze.value = !!props.squeeze), [props.squeeze]);
-  React.useEffect(
-    () => void (uniforms.squeezeMin.value = props.squeezeMin ?? uniforms.squeezeMin.value),
-    [props.squeezeMin]
-  );
-  React.useEffect(
-    () => void (uniforms.squeezeMax.value = props.squeezeMax ?? uniforms.squeezeMax.value),
-    [props.squeezeMax]
-  );
-  React.useEffect(
-    () => void (uniforms.stroke.value = props.stroke ? new THREE.Color(props.stroke) : uniforms.stroke.value),
-    [props.stroke]
-  );
-  React.useEffect(
-    () => void (uniforms.fill.value = props.fill ? new THREE.Color(props.fill) : uniforms.fill.value),
-    [props.fill]
-  );
-  React.useEffect(
-    () => void (uniforms.backfaceStroke.value = props.backfaceStroke ? new THREE.Color(props.backfaceStroke) : uniforms.backfaceStroke.value),
-    [props.backfaceStroke]
-  );
-}
-
-function isWithGeometry(object) {
-  return !!object?.geometry;
-}
-function isGeometry(object) {
-  return !!object?.isBufferGeometry;
-}
-function isRefObject$1(object) {
-  return !!object?.current;
-}
-function isRef$1(object) {
-  return object?.current !== void 0;
-}
-function isWireframeGeometry(geometry) {
-  return geometry.type === "WireframeGeometry";
-}
-function getUniforms() {
-  const u = {};
-  for (const key in WireframeMaterialShaders.uniforms) {
-    u[key] = { value: WireframeMaterialShaders.uniforms[key] };
-  }
-  return u;
-}
-function getBarycentricCoordinates(geometry, removeEdge) {
-  const position = geometry.getAttribute("position");
-  const count = position.count;
-  const barycentric = [];
-  for (let i = 0; i < count; i++) {
-    const even = i % 2 === 0;
-    const Q = removeEdge ? 1 : 0;
-    if (even) {
-      barycentric.push(0, 0, 1, 0, 1, 0, 1, 0, Q);
-    } else {
-      barycentric.push(0, 1, 0, 0, 0, 1, 1, 0, Q);
-    }
-  }
-  return new THREE.BufferAttribute(Float32Array.from(barycentric), 3);
-}
-function getInputGeometry(inputGeometry) {
-  const geo = isRefObject$1(inputGeometry) ? inputGeometry.current : inputGeometry;
-  if (!isGeometry(geo)) {
-    if (isWireframeGeometry(geo)) {
-      throw new Error("Wireframe: WireframeGeometry is not supported.");
-    }
-    const parent = geo.parent;
-    if (isWithGeometry(parent)) {
-      if (isWireframeGeometry(parent.geometry)) {
-        throw new Error("Wireframe: WireframeGeometry is not supported.");
-      }
-      return parent.geometry;
-    }
-  } else {
-    return geo;
-  }
-}
-function setBarycentricCoordinates(geometry, simplify) {
-  if (geometry.index) {
-    console.warn("Wireframe: Requires non-indexed geometry, converting to non-indexed geometry.");
-    const nonIndexedGeo = geometry.toNonIndexed();
-    geometry.copy(nonIndexedGeo);
-    geometry.setIndex(null);
-  }
-  const newBarycentric = getBarycentricCoordinates(geometry, simplify);
-  geometry.setAttribute("barycentric", newBarycentric);
-}
-function WireframeWithCustomGeo({
-  geometry: customGeometry,
-  simplify = false,
-  ...props
-}) {
-  extend({ MeshWireframeMaterial: WireframeMaterial });
-  const [geometry, setGeometry] = React.useState(null);
-  React.useLayoutEffect(() => {
-    const geom = getInputGeometry(customGeometry);
-    if (!geom) {
-      throw new Error("Wireframe: geometry prop must be a BufferGeometry or a ref to a BufferGeometry.");
-    }
-    setBarycentricCoordinates(geom, simplify);
-    if (isRef$1(customGeometry)) {
-      setGeometry(geom);
-    }
-  }, [simplify, customGeometry]);
-  const drawnGeo = isRef$1(customGeometry) ? geometry : customGeometry;
-  return /* @__PURE__ */ React.createElement(React.Fragment, null, drawnGeo && /* @__PURE__ */ React.createElement("mesh", { geometry: drawnGeo }, /* @__PURE__ */ React.createElement(
-    "meshWireframeMaterial",
-    {
-      attach: "material",
-      transparent: true,
-      side: THREE.DoubleSide,
-      polygonOffset: true,
-      polygonOffsetFactor: -4,
-      ...props
-    }
-  )));
-}
-function WireframeWithoutCustomGeo({
-  simplify = false,
-  ...props
-}) {
-  const objectRef = React.useRef(null);
-  const uniforms = React.useMemo(() => getUniforms(), [WireframeMaterialShaders.uniforms]);
-  useWireframeUniforms(uniforms, props);
-  React.useLayoutEffect(() => {
-    const geom = getInputGeometry(objectRef);
-    if (!geom) {
-      throw new Error("Wireframe: Must be a child of a Mesh, Line or Points object or specify a geometry prop.");
-    }
-    const og = geom.clone();
-    setBarycentricCoordinates(geom, simplify);
-    return () => {
-      geom.copy(og);
-      og.dispose();
-    };
-  }, [simplify]);
-  React.useLayoutEffect(() => {
-    const parentMesh = objectRef.current.parent;
-    const og = parentMesh.material.clone();
-    setWireframeOverride(parentMesh.material, uniforms);
-    return () => {
-      parentMesh.material.dispose();
-      parentMesh.material = og;
-    };
-  }, []);
-  return /* @__PURE__ */ React.createElement("object3D", { ref: objectRef });
-}
-function Wireframe({ geometry: customGeometry, ...props }) {
-  if (customGeometry) {
-    return /* @__PURE__ */ React.createElement(WireframeWithCustomGeo, { geometry: customGeometry, ...props });
-  }
-  return /* @__PURE__ */ React.createElement(WireframeWithoutCustomGeo, { ...props });
-}
-
 const Context = /* @__PURE__ */ React.createContext({});
 const useGizmoContext = () => {
   return React.useContext(Context);
@@ -3421,6 +3156,11 @@ const GizmoViewport = ({
   return /* @__PURE__ */ React.createElement("group", { scale: 40, ...props }, /* @__PURE__ */ React.createElement(Axis, { color: colorX, rotation: [0, 0, 0], scale: axisScale }), /* @__PURE__ */ React.createElement(Axis, { color: colorY, rotation: [0, 0, Math.PI / 2], scale: axisScale }), /* @__PURE__ */ React.createElement(Axis, { color: colorZ, rotation: [0, -Math.PI / 2, 0], scale: axisScale }), !hideAxisHeads && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorX, position: [1, 0, 0], label: labels[0], ...axisHeadProps }), /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorY, position: [0, 1, 0], label: labels[1], ...axisHeadProps }), /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorZ, position: [0, 0, 1], label: labels[2], ...axisHeadProps }), !hideNegativeAxes && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorX, position: [-1, 0, 0], ...axisHeadProps }), /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorY, position: [0, -1, 0], ...axisHeadProps }), /* @__PURE__ */ React.createElement(AxisHead, { arcStyle: colorZ, position: [0, 0, -1], ...axisHeadProps }))));
 };
 
+const roundEven = (n) => {
+  const rounded = Math.ceil(n);
+  return rounded % 2 === 0 ? rounded : rounded + 1;
+};
+
 const v1 = /* @__PURE__ */ new Vector3();
 const v2 = /* @__PURE__ */ new Vector3();
 const v3 = /* @__PURE__ */ new Vector3();
@@ -3519,9 +3259,11 @@ const Html = /* @__PURE__ */ React.forwardRef(
     as = "div",
     wrapperClass,
     pointerEvents = "auto",
+    pixelPerfect = true,
     ...props
   }, ref) => {
     const { gl, camera, scene, size, raycaster, events, viewport } = useThree();
+    const forceEven = useThree((state) => state.internal.forceEven);
     const [el] = React.useState(() => document.createElement(as));
     const root = React.useRef(null);
     const group = React.useRef(null);
@@ -3546,38 +3288,54 @@ const Html = /* @__PURE__ */ React.forwardRef(
         el2.style.position = null;
         el2.style.pointerEvents = null;
       }
-    }, [occlude]);
+    }, [occlude, zIndexRange, gl.domElement]);
     React.useLayoutEffect(() => {
       if (group.current) {
-        const currentRoot = root.current = ReactDOM.createRoot(el);
+        if (!root.current) {
+          root.current = ReactDOM.createRoot(el);
+        }
         scene.updateMatrixWorld();
         if (transform) {
           el.style.cssText = `position:absolute;top:0;left:0;pointer-events:none;overflow:hidden;`;
         } else {
-          const vec = calculatePosition(group.current, camera, size);
-          el.style.cssText = `position:absolute;top:0;left:0;transform:translate3d(${vec[0]}px,${vec[1]}px,0);transform-origin:0 0;`;
+          el.style.cssText = `position:absolute;top:0;left:0;transform:translate3d(0,-9999px,0);transform-origin:0 0;`;
         }
         if (target) {
           if (prepend) target.prepend(el);
           else target.appendChild(el);
         }
         return () => {
-          if (target) target.removeChild(el);
-          currentRoot.unmount();
+          if (root.current) {
+            root.current.unmount();
+            root.current = null;
+          }
+          if (target && target.contains(el)) {
+            target.removeChild(el);
+          }
         };
       }
-    }, [target, transform]);
+    }, [target, transform, el, prepend, scene]);
     React.useLayoutEffect(() => {
       if (wrapperClass) el.className = wrapperClass;
-    }, [wrapperClass]);
+    }, [wrapperClass, el]);
+    React.useLayoutEffect(() => {
+      return () => {
+        if (root.current) {
+          root.current.unmount();
+          root.current = null;
+        }
+      };
+    }, []);
     const styles = React.useMemo(() => {
+      const width = forceEven ? roundEven(size.width) : size.width;
+      const height = forceEven ? roundEven(size.height) : size.height;
       if (transform) {
         return {
           position: "absolute",
           top: 0,
           left: 0,
-          width: size.width,
-          height: size.height,
+          width,
+          height,
           transformStyle: "preserve-3d",
           pointerEvents: "none"
         };
@@ -3586,15 +3344,15 @@ const Html = /* @__PURE__ */ React.forwardRef(
           position: "absolute",
           transform: center ? "translate3d(-50%,-50%,0)" : "none",
           ...fullscreen && {
-            top: -size.height / 2,
-            left: -size.width / 2,
-            width: size.width,
-            height: size.height
+            top: forceEven ? roundEven(-size.height / 2) : -size.height / 2,
+            left: forceEven ? roundEven(-size.width / 2) : -size.width / 2,
+            width,
+            height
           },
           ...style
         };
       }
-    }, [style, center, fullscreen, size, transform]);
+    }, [style, center, fullscreen, size, transform, forceEven]);
     const transformInnerStyles = React.useMemo(
       () => ({ position: "absolute", pointerEvents }),
       [pointerEvents]
@@ -3608,7 +3366,7 @@ const Html = /* @__PURE__ */ React.forwardRef(
       } else {
         root.current?.render(/* @__PURE__ */ React.createElement("div", { ref, style: styles, className, children }));
       }
-    });
+    }, [transform, styles, transformInnerStyles, ref, className, style, children]);
     const visible = React.useRef(true);
     useFrame((gl2) => {
       if (group.current) {
@@ -3640,7 +3398,12 @@ const Html = /* @__PURE__ */ React.forwardRef(
           const zRange = occlude ? isRayCastOcclusion ? [zIndexRange[0], halfRange] : [halfRange - 1, 0] : zIndexRange;
           el.style.zIndex = `${objectZIndex(group.current, camera, zRange)}`;
           if (transform) {
-            const [widthHalf, heightHalf] = [size.width / 2, size.height / 2];
+            let widthHalf = forceEven ? roundEven(size.width / 2) : size.width / 2;
+            let heightHalf = forceEven ? roundEven(size.height / 2) : size.height / 2;
+            if (pixelPerfect) {
+              widthHalf = roundToPixelRatio(widthHalf);
+              heightHalf = roundToPixelRatio(heightHalf);
+            }
             const fov = camera.projectionMatrix.elements[5] * heightHalf;
             const { isOrthographicCamera, top, left, bottom, right } = camera;
             const cameraMatrix = getCameraCSSMatrix(camera.matrixWorldInverse);
@@ -3651,8 +3414,10 @@ const Html = /* @__PURE__ */ React.forwardRef(
               matrix.elements[3] = matrix.elements[7] = matrix.elements[11] = 0;
               matrix.elements[15] = 1;
             }
-            el.style.width = size.width + "px";
-            el.style.height = size.height + "px";
+            const elWidth = forceEven ? roundEven(size.width) : size.width;
+            const elHeight = forceEven ? roundEven(size.height) : size.height;
+            el.style.width = elWidth + "px";
+            el.style.height = elHeight + "px";
             el.style.perspective = isOrthographicCamera ? "" : `${fov}px`;
             if (transformOuterRef.current && transformInnerRef.current) {
               transformOuterRef.current.style.transform = `${cameraTransform}${cameraMatrix}translate(${widthHalf}px,${heightHalf}px)`;
@@ -3660,7 +3425,13 @@ const Html = /* @__PURE__ */ React.forwardRef(
             }
           } else {
             const scale = distanceFactor === void 0 ? 1 : objectScale(group.current, camera) * distanceFactor;
-            el.style.transform = `translate3d(${vec[0]}px,${vec[1]}px,0) scale(${scale})`;
+            let x = forceEven ? roundEven(vec[0]) : vec[0];
+            let y = forceEven ? roundEven(vec[1]) : vec[1];
+            if (pixelPerfect) {
+              x = roundToPixelRatio(x);
+              y = roundToPixelRatio(y);
+            }
+            el.style.transform = `translate3d(${x}px,${y}px,0) scale(${scale})`;
           }
           oldPosition.current = vec;
           oldZoom.current = camera.zoom;
@@ -3766,6 +3537,11 @@ const Html = /* @__PURE__ */ React.forwardRef(
 );
 
 const context$4 = /* @__PURE__ */ React.createContext(null);
+const resolveObject = (object, fallback) => {
+  if (!object) return fallback;
+  if ("current" in object) return object.current;
+  return object;
+};
 
 const vec1$1 = /* @__PURE__ */ new THREE.Vector3();
 const vec2$1 = /* @__PURE__ */ new THREE.Vector3();
@@ -3800,6 +3576,8 @@ const AxisArrow = ({ direction, axis }) => {
     onDragStart,
     onDrag,
     onDragEnd,
+    onHover,
+    dragState,
     userData,
     LineComponent: Line
   } = React.useContext(context$4);
@@ -3831,7 +3609,13 @@ const AxisArrow = ({ direction, axis }) => {
   const onPointerMove = React.useCallback(
     (e) => {
       e.stopPropagation();
-      if (!isHovered) setIsHovered(true);
+      if (!isHovered) {
+        const drag = dragState.current;
+        if (drag === null || drag.component === "Arrow" && drag.axis === axis) {
+          setIsHovered(true);
+          onHover({ component: "Arrow", axis, hovering: true });
+        }
+      }
       if (clickInfo.current) {
         const { clickPoint, dir } = clickInfo.current;
         const [min, max] = translationLimits?.[axis] || [void 0, void 0];
@@ -3850,7 +3634,7 @@ const AxisArrow = ({ direction, axis }) => {
         onDrag(offsetMatrix$1);
       }
     },
-    [annotations, onDrag, isHovered, translation, translationLimits, axis]
+    [annotations, onDrag, onHover, dragState, isHovered, translation, translationLimits, axis]
   );
   const onPointerUp = React.useCallback(
     (e) => {
@@ -3865,10 +3649,16 @@ const AxisArrow = ({ direction, axis }) => {
     },
     [annotations, camControls, onDragEnd]
   );
-  const onPointerOut = React.useCallback((e) => {
-    e.stopPropagation();
-    setIsHovered(false);
-  }, []);
+  const onPointerOut = React.useCallback(
+    (e) => {
+      e.stopPropagation();
+      if (isHovered) {
+        setIsHovered(false);
+        onHover({ component: "Arrow", axis, hovering: false });
+      }
+    },
+    [onHover, axis, isHovered]
+  );
   const { cylinderLength, coneWidth, coneLength, matrixL } = React.useMemo(() => {
     const coneWidth2 = fixed ? lineWidth / scale * 1.6 : scale / 20;
     const coneLength2 = fixed ? 0.2 : scale / 5;
@@ -3972,6 +3762,8 @@ const rotMatrix = /* @__PURE__ */ new THREE.Matrix4();
 const posNew = /* @__PURE__ */ new THREE.Vector3();
 const ray$1 = /* @__PURE__ */ new THREE.Ray();
 const intersection$1 = /* @__PURE__ */ new THREE.Vector3();
+const viewPlane = /* @__PURE__ */ new THREE.Plane();
+const viewIntersection = /* @__PURE__ */ new THREE.Vector3();
 const AxisRotator = ({
   dir1,
   dir2,
@@ -3992,6 +3784,8 @@ const AxisRotator = ({
     onDragStart,
     onDrag,
     onDragEnd,
+    onHover,
+    dragState,
     userData,
     LineComponent: Line
   } = React.useContext(context$4);
@@ -4025,14 +3819,29 @@ const AxisRotator = ({
   const onPointerMove = React.useCallback(
     (e) => {
       e.stopPropagation();
-      if (!isHovered) setIsHovered(true);
+      if (!isHovered) {
+        const drag = dragState.current;
+        if (drag === null || drag.component === "Rotator" && drag.axis === axis) {
+          setIsHovered(true);
+          onHover({ component: "Rotator", axis, hovering: true });
+        }
+      }
       if (clickInfo.current) {
         const { clickPoint, origin, e1, e2, normal, plane } = clickInfo.current;
         const [min, max] = rotationLimits?.[axis] || [void 0, void 0];
         ray$1.copy(e.ray);
-        ray$1.intersectPlane(plane, intersection$1);
-        ray$1.direction.negate();
-        ray$1.intersectPlane(plane, intersection$1);
+        const dotProduct = Math.abs(ray$1.direction.dot(normal));
+        if (dotProduct < 0.1) {
+          viewPlane.setFromNormalAndCoplanarPoint(ray$1.direction.clone().negate(), origin);
+          ray$1.intersectPlane(viewPlane, viewIntersection);
+          const toIntersection = viewIntersection.clone().sub(origin);
+          const projectedDist = toIntersection.dot(normal);
+          intersection$1.copy(viewIntersection).sub(normal.clone().multiplyScalar(projectedDist));
+        } else {
+          ray$1.intersectPlane(plane, intersection$1);
+          ray$1.direction.negate();
+          ray$1.intersectPlane(plane, intersection$1);
+        }
         let deltaAngle = calculateAngle(clickPoint, intersection$1, origin, e1, e2);
         let degrees = toDegrees(deltaAngle);
         if (e.shiftKey) {
@@ -4058,7 +3867,7 @@ const AxisRotator = ({
         onDrag(rotMatrix);
       }
     },
-    [annotations, onDrag, isHovered, rotationLimits, axis]
+    [annotations, onDrag, onHover, dragState, isHovered, rotationLimits, axis]
   );
   const onPointerUp = React.useCallback(
     (e) => {
@@ -4074,10 +3883,16 @@ const AxisRotator = ({
     },
     [annotations, camControls, onDragEnd]
   );
-  const onPointerOut = React.useCallback((e) => {
-    e.stopPropagation();
-    setIsHovered(false);
-  }, []);
+  const onPointerOut = React.useCallback(
+    (e) => {
+      e.stopPropagation();
+      if (isHovered) {
+        setIsHovered(false);
+        onHover({ component: "Rotator", axis, hovering: false });
+      }
+    },
+    [onHover, axis, isHovered]
+  );
   const matrixL = React.useMemo(() => {
     const dir1N = dir1.clone().normalize();
     const dir2N = dir2.clone().normalize();
@@ -4178,6 +3993,8 @@ const PlaneSlider = ({
     onDragStart,
     onDrag,
     onDragEnd,
+    onHover,
+    dragState,
     userData,
     LineComponent: Line
   } = React.useContext(context$4);
@@ -4213,7 +4030,13 @@ const PlaneSlider = ({
   const onPointerMove = React.useCallback(
     (e) => {
       e.stopPropagation();
-      if (!isHovered) setIsHovered(true);
+      if (!isHovered) {
+        const drag = dragState.current;
+        if (drag === null || drag.component === "Slider" && drag.axis === axis) {
+          setIsHovered(true);
+          onHover({ component: "Slider", axis, hovering: true });
+        }
+      }
       if (clickInfo.current) {
         const { clickPoint, e1, e2, plane } = clickInfo.current;
         const [minX, maxX] = translationLimits?.[(axis + 1) % 3] || [void 0, void 0];
@@ -4249,7 +4072,7 @@ const PlaneSlider = ({
         onDrag(offsetMatrix);
       }
     },
-    [annotations, onDrag, isHovered, translation, translationLimits, axis]
+    [annotations, onDrag, onHover, dragState, isHovered, translation, translationLimits, axis]
   );
   const onPointerUp = React.useCallback(
     (e) => {
@@ -4264,10 +4087,16 @@ const PlaneSlider = ({
     },
     [annotations, camControls, onDragEnd]
   );
-  const onPointerOut = React.useCallback((e) => {
-    e.stopPropagation();
-    setIsHovered(false);
-  }, []);
+  const onPointerOut = React.useCallback(
+    (e) => {
+      e.stopPropagation();
+      if (isHovered) {
+        setIsHovered(false);
+        onHover({ component: "Slider", axis, hovering: false });
+      }
+    },
+    [onHover, axis, isHovered]
+  );
   const matrixL = React.useMemo(() => {
     const dir1N = dir1.clone().normalize();
     const dir2N = dir2.clone().normalize();
@@ -4405,6 +4234,8 @@ const ScalingSphere = ({ direction, axis }) => {
     onDragStart,
     onDrag,
     onDragEnd,
+    onHover,
+    dragState,
     userData
   } = React.useContext(context$4);
   const size = useThree((state) => state.size);
@@ -4441,7 +4272,13 @@ const ScalingSphere = ({ direction, axis }) => {
   const onPointerMove = React.useCallback(
     (e) => {
       e.stopPropagation();
-      if (!isHovered) setIsHovered(true);
+      if (!isHovered) {
+        const drag = dragState.current;
+        if (drag === null || drag.component === "Sphere" && drag.axis === axis) {
+          setIsHovered(true);
+          onHover({ component: "Sphere", axis, hovering: true });
+        }
+      }
       if (clickInfo.current) {
         const { clickPoint, dir, mPLG, mPLGInv, offsetMultiplier } = clickInfo.current;
         const [min, max] = scaleLimits?.[axis] || [1e-5, void 0];
@@ -4467,7 +4304,7 @@ const ScalingSphere = ({ direction, axis }) => {
         onDrag(scaleMatrix);
       }
     },
-    [annotations, position, onDrag, isHovered, scaleLimits, axis]
+    [annotations, position, onDrag, onHover, dragState, isHovered, scaleLimits, axis]
   );
   const onPointerUp = React.useCallback(
     (e) => {
@@ -4484,10 +4321,16 @@ const ScalingSphere = ({ direction, axis }) => {
     },
     [annotations, camControls, onDragEnd, position]
   );
-  const onPointerOut = React.useCallback((e) => {
-    e.stopPropagation();
-    setIsHovered(false);
-  }, []);
+  const onPointerOut = React.useCallback(
+    (e) => {
+      e.stopPropagation();
+      if (isHovered) {
+        setIsHovered(false);
+        onHover({ component: "Sphere", axis, hovering: false });
+      }
+    },
+    [onHover, axis, isHovered]
+  );
   const { radius, matrixL } = React.useMemo(() => {
     const radius2 = fixed ? lineWidth / scale * 1.8 : scale / 22.5;
     const quaternion = new THREE.Quaternion().setFromUnitVectors(upV, direction.clone().normalize());
@@ -4557,9 +4400,11 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
   ({
     enabled = true,
     matrix,
+    object,
     onDragStart,
     onDrag,
     onDragEnd,
+    onHover,
     autoTransform = true,
     anchor,
     disableAxes = false,
@@ -4595,14 +4440,35 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
     const gizmoRef = React.useRef(null);
     const childrenRef = React.useRef(null);
     const translation = React.useRef([0, 0, 0]);
+    const dragState = React.useRef(null);
     const cameraScale = React.useRef(new THREE.Vector3(1, 1, 1));
     const gizmoScale = React.useRef(new THREE.Vector3(1, 1, 1));
+    React.useEffect(() => {
+      if (object) {
+        const target = resolveObject(object);
+        if (target) {
+          const pivot = ref.current;
+          const didAutoUpdate = target.matrixAutoUpdate;
+          target.updateWorldMatrix(true, true);
+          target.matrixAutoUpdate = false;
+          pivot.matrix.copy(target.matrix);
+          return () => {
+            if (didAutoUpdate) {
+              target.matrixAutoUpdate = true;
+              target.matrix.decompose(target.position, target.quaternion, target.scale);
+            }
+          };
+        }
+      }
+    }, [object]);
     React.useLayoutEffect(() => {
       if (!anchor) return;
-      childrenRef.current.updateWorldMatrix(true, true);
-      mPInv.copy(childrenRef.current.matrixWorld).invert();
+      const anchorTarget = resolveObject(object, childrenRef.current);
+      if (!anchorTarget) return;
+      anchorTarget.updateWorldMatrix(true, true);
+      mPInv.copy(anchorTarget.matrixWorld).invert();
       bb.makeEmpty();
-      childrenRef.current.traverse((obj) => {
+      anchorTarget.traverse((obj) => {
         if (!obj.geometry) return;
         if (!obj.geometry.boundingBox) obj.geometry.computeBoundingBox();
         mL.copy(obj.matrixWorld).premultiply(mPInv);
@@ -4617,9 +4483,17 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
       gizmoRef.current.position.copy(vPosition);
       invalidate();
     });
+    const mergedUserData = React.useMemo(
+      () => ({
+        ...userData,
+        ...depthTest === false && { interactivePriority: 1 }
+      }),
+      [userData, depthTest]
+    );
     const config = React.useMemo(
       () => ({
         onDragStart: (props2) => {
+          dragState.current = props2;
           mL0.copy(ref.current.matrix);
           mW0.copy(ref.current.matrixWorld);
           onDragStart && onDragStart(props2);
@@ -4635,13 +4509,20 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
           if (autoTransform) {
             ref.current.matrix.copy(mL);
           }
+          const target = resolveObject(object);
+          if (target) target.matrix.copy(mL);
           onDrag && onDrag(mL, mdL, mW, mdW);
           invalidate();
         },
         onDragEnd: () => {
+          dragState.current = null;
           if (onDragEnd) onDragEnd();
           invalidate();
         },
+        onHover: (props2) => {
+          if (onHover) onHover(props2);
+        },
+        dragState,
         translation,
         translationLimits,
         rotationLimits,
@@ -4653,7 +4534,7 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
         fixed,
         depthTest,
         renderOrder,
-        userData,
+        userData: mergedUserData,
         annotations,
         annotationsClass,
         LineComponent: LineComp
@@ -4662,6 +4543,7 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
         onDragStart,
         onDrag,
         onDragEnd,
+        onHover,
         translation,
         translationLimits,
         rotationLimits,
@@ -4673,11 +4555,12 @@ const PivotControls = /* @__PURE__ */ React.forwardRef(
         ...axisColors,
         hoveredColor,
         opacity,
-        userData,
+        mergedUserData,
         autoTransform,
         annotations,
         annotationsClass,
-        LineComp
+        LineComp,
+        object
       ]
     );
     const vec = new THREE.Vector3();
@@ -5039,7 +4922,7 @@ function createInstances() {
   ];
 }
 const InstancedAttribute = React.forwardRef(
-  ({ name, defaultValue, normalized, usage = THREE.DynamicDrawUsage }, fref) => {
+  ({ name, defaultValue, normalized, usage = THREE.DynamicDrawUsage, type = "float" }, fref) => {
     const ref = React.useRef(null);
     React.useImperativeHandle(fref, () => ref.current, []);
     React.useLayoutEffect(() => {
@@ -5047,7 +4930,26 @@ const InstancedAttribute = React.forwardRef(
       parent.geometry.attributes[name] = ref.current;
       const value = Array.isArray(defaultValue) ? defaultValue : [defaultValue];
       const array = Array.from({ length: parent.userData.limit }, () => value).flat();
-      ref.current.array = new Float32Array(array);
+      switch (type) {
+        case "float":
+          ref.current.array = new Float32Array(array);
+          break;
+        case "int":
+          ref.current.array = new Int32Array(array);
+          break;
+        case "uint":
+          ref.current.array = new Uint32Array(array);
+          break;
+        case "short":
+          ref.current.array = new Int16Array(array);
+          break;
+        case "ushort":
+          ref.current.array = new Uint16Array(array);
+          break;
+        case "byte":
+          ref.current.array = new Uint8Array(array);
+          break;
+      }
       ref.current.itemSize = value.length;
       ref.current.count = array.length / ref.current.itemSize;
       return () => {
@@ -6572,12 +6474,17 @@ const Gltf = /* @__PURE__ */ React.forwardRef(
   }
 );
 
-const cdn = "https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master";
-function useKTX2(input, basisPath = `${cdn}/basis/`) {
+let transcoderPath = "https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/basis/";
+function useKTX2(input, basisPath = true, extendLoader) {
   const renderer = useThree((state) => state.renderer);
   const textures = useLoader(KTX2Loader, IsObject(input) ? Object.values(input) : input, (loader) => {
+    if (extendLoader) {
+      extendLoader(loader);
+    }
+    if (basisPath) {
+      loader.setTranscoderPath(typeof basisPath === "string" ? basisPath : transcoderPath);
+    }
     loader.detectSupport(renderer);
-    loader.setTranscoderPath(basisPath);
   });
   useEffect(() => {
     const array = Array.isArray(textures) ? textures : [textures];
@@ -6592,16 +6499,20 @@ function useKTX2(input, basisPath = `${cdn}/basis/`) {
     return textures;
   }
 }
-useKTX2.preload = (url, basisPath = `${cdn}/basis/`) => useLoader.preload(KTX2Loader, url, (loader) => {
-  loader.setTranscoderPath(basisPath);
+useKTX2.preload = (url, basisPath = true, extendLoader) => useLoader.preload(KTX2Loader, url, (loader) => {
+  if (extendLoader) {
+    extendLoader(loader);
+  }
+  if (basisPath) {
+    loader.setTranscoderPath(typeof basisPath === "string" ? basisPath : transcoderPath);
+  }
 });
 useKTX2.clear = (input) => useLoader.clear(KTX2Loader, input);
-const Ktx2 = ({
-  children,
-  input,
-  basisPath
-}) => {
-  const texture = useKTX2(input, basisPath);
+useKTX2.setTranscoderPath = (path) => {
+  transcoderPath = path;
+};
+const Ktx2 = ({ children, input, basisPath, extendLoader }) => {
+  const texture = useKTX2(input, basisPath, extendLoader);
   return /* @__PURE__ */ React.createElement(React.Fragment, null, children?.(texture));
 };
 
@@ -7077,18 +6988,21 @@ function Fisheye({
   const normal = new THREE.Vector3();
   const sph = new THREE.Sphere(new THREE.Vector3(), radius);
   const normalMatrix = new THREE.Matrix3();
-  const compute = React.useCallback((event, state, prev) => {
-    state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
-    state.raycaster.setFromCamera(state.pointer, orthoC);
-    if (!state.raycaster.ray.intersectSphere(sph, normal)) return;
-    else normal.normalize();
-    normalMatrix.getNormalMatrix(cubeApi.current.camera.matrixWorld);
-    cubeApi.current.camera.getWorldPosition(state.raycaster.ray.origin);
-    state.raycaster.ray.direction.set(0, 0, 1).reflect(normal);
-    state.raycaster.ray.direction.x *= -1;
-    state.raycaster.ray.direction.applyNormalMatrix(normalMatrix).multiplyScalar(-1);
-    return void 0;
-  }, []);
+  const compute = React.useCallback(
+    (event, state, prev) => {
+      state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+      state.raycaster.setFromCamera(state.pointer, orthoC);
+      if (!state.raycaster.ray.intersectSphere(sph, normal)) return;
+      else normal.normalize();
+      normalMatrix.getNormalMatrix(cubeApi.current.camera.matrixWorld);
+      cubeApi.current.camera.getWorldPosition(state.raycaster.ray.origin);
+      state.raycaster.ray.direction.set(0, 0, 1).reflect(normal);
+      state.raycaster.ray.direction.x *= -1;
+      state.raycaster.ray.direction.applyNormalMatrix(normalMatrix).multiplyScalar(-1);
+      return void 0;
+    },
+    [width, height]
+  );
   useFrame(
     ({ gl }) => {
       if (renderPriority) gl.render(sphere.current, orthoC);
@@ -7223,14 +7137,22 @@ const isWebGPURenderer = (def) => !!def.isWebGPURenderer;
 const col = /* @__PURE__ */ new THREE.Color();
 const TUNNEL_KEY = "__drei_view_tunnel__";
 const tracked = globalThis[TUNNEL_KEY] || (globalThis[TUNNEL_KEY] = tunnel());
-function computeContainerPosition(canvasSize, trackRect) {
+function computeContainerPosition(canvasSize, trackRect, forceEven) {
   const { right, top: trackTop, left: trackLeft, bottom: trackBottom, width, height } = trackRect;
   const isOffscreen = trackRect.bottom < 0 || trackTop > canvasSize.height || right < 0 || trackRect.left > canvasSize.width;
   const canvasBottom = canvasSize.top + canvasSize.height;
-  const bottom = canvasBottom - trackBottom;
-  const left = trackLeft - canvasSize.left;
-  const top = trackTop - canvasSize.top;
-  return { position: { width, height, left, top, bottom, right }, isOffscreen };
+  const rawBottom = canvasBottom - trackBottom;
+  const rawLeft = trackLeft - canvasSize.left;
+  const rawTop = trackTop - canvasSize.top;
+  const position = forceEven ? {
+    width: roundEven(width),
+    height: roundEven(height),
+    left: roundEven(rawLeft),
+    top: roundEven(rawTop),
+    bottom: roundEven(rawBottom),
+    right: roundEven(right)
+  } : { width, height, left: rawLeft, top: rawTop, bottom: rawBottom, right };
+  return { position, isOffscreen };
 }
 function prepareSkissor(renderer, camera, {
   left,
@@ -7270,6 +7192,7 @@ function clear(renderer) {
 }
 function Container({ visible = true, canvasSize, scene, index, children, frames, rect, track }) {
   const { scene: portalScene, camera: portalCamera, renderer, get, setEvents } = useThree();
+  const forceEven = useThree((state) => state.internal.forceEven);
   const [isOffscreen, setOffscreen] = React.useState(false);
   const mountedRef = React.useRef(true);
   React.useEffect(() => {
@@ -7287,7 +7210,7 @@ function Container({ visible = true, canvasSize, scene, index, children, frames,
         frameCount++;
       }
       if (rect.current) {
-        const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, rect.current);
+        const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, rect.current, forceEven);
         if (isOffscreen !== _isOffscreen) setOffscreen(_isOffscreen);
         if (visible && !_isOffscreen && rect.current) {
           const targetScene = children ? portalScene : scene;
@@ -7309,14 +7232,14 @@ function Container({ visible = true, canvasSize, scene, index, children, frames,
   React.useLayoutEffect(() => {
     const curRect = rect.current;
     if (curRect && (!visible || !isOffscreen)) {
-      const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, curRect);
+      const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, curRect, forceEven);
       if (!_isOffscreen) {
         const autoClear = prepareSkissor(renderer, portalCamera, position);
         clear(renderer);
         finishSkissor(renderer, autoClear);
       }
     }
-  }, [visible, isOffscreen, renderer, portalCamera, canvasSize]);
+  }, [visible, isOffscreen, renderer, portalCamera, canvasSize, forceEven]);
   React.useEffect(() => {
     if (!track) return;
     const curRect = rect.current;
@@ -7324,7 +7247,7 @@ function Container({ visible = true, canvasSize, scene, index, children, frames,
     setEvents({ connected: track.current });
     return () => {
       if (curRect) {
-        const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, curRect);
+        const { position, isOffscreen: _isOffscreen } = computeContainerPosition(canvasSize, curRect, forceEven);
         if (!_isOffscreen) {
           const autoClear = prepareSkissor(renderer, portalCamera, position);
           clear(renderer);
@@ -7333,13 +7256,14 @@ function Container({ visible = true, canvasSize, scene, index, children, frames,
       }
       setEvents({ connected: old });
     };
-  }, [track, renderer, portalCamera, canvasSize, get, setEvents]);
+  }, [track, renderer, portalCamera, canvasSize, get, setEvents, forceEven]);
   return /* @__PURE__ */ React.createElement(React.Fragment, null, children, /* @__PURE__ */ React.createElement("group", { onPointerOver: () => null }));
 }
 const CanvasView = /* @__PURE__ */ React.forwardRef(
   ({ track, visible = true, index = 1, id, style, className, frames = Infinity, children, ...props }, fref) => {
     const rect = React.useRef(null);
     const { size, scene } = useThree();
+    const forceEven = useThree((state) => state.internal.forceEven);
     const [virtualScene] = React.useState(() => new THREE.Scene());
     const [ready, toggle] = React.useReducer(() => true, false);
     const compute = React.useCallback(
@@ -7376,12 +7300,12 @@ const CanvasView = /* @__PURE__ */ React.forwardRef(
       {
         events: { compute, priority: index },
         size: {
-          width: rect.current?.width,
-          height: rect.current?.height,
+          width: forceEven && rect.current?.width ? roundEven(rect.current.width) : rect.current?.width,
+          height: forceEven && rect.current?.height ? roundEven(rect.current.height) : rect.current?.height,
           // @ts-ignore
-          top: rect.current?.top,
+          top: forceEven && rect.current?.top ? roundEven(rect.current.top) : rect.current?.top,
           // @ts-ignore
-          left: rect.current?.left
+          left: forceEven && rect.current?.left ? roundEven(rect.current.left) : rect.current?.left
         }
       }
     ));
@@ -8556,4 +8480,4 @@ function useSelect() {
   return React.useContext(context);
 }
 
-export { AdaptiveDpr, AdaptiveEvents, ArcballControls, BBAnchor, Backdrop, Billboard, Bounds, Box, CameraShake, Capsule, CatmullRomLine, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, Dodecahedron, DragControls, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, Helper, Html, Hud, Icosahedron, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Loader, MapControls, Mask, MatcapTexture, Merged, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Select, Shadow, Shape, Sky, Sphere, SpriteAnimator, Stage, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, TrackballControls, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, useAnimations, useAspect, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useTexture, useTrailTexture, useVideoTexture };
+export { AdaptiveDpr, AdaptiveEvents, ArcballControls, BBAnchor, Backdrop, Billboard, Bounds, Box, CameraShake, Capsule, CatmullRomLine, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, Dodecahedron, DragControls, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, Helper, Html, Hud, Icosahedron, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Loader, MapControls, Mask, MatcapTexture, Merged, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Select, Shadow, Shape, Sky, Sphere, SpriteAnimator, Stage, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, TrackballControls, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, useAnimations, useAspect, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useTexture, useTrailTexture, useVideoTexture };