@react-three/drei 9.74.13 → 9.74.14

package/src/core/Grid.js

@@ -1,112 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import * as THREE from 'three';
-import { extend } from '@react-three/fiber';
-import { shaderMaterial } from './shaderMaterial.js';
-
-const GridMaterial = shaderMaterial({
-  cellSize: 0.5,
-  sectionSize: 1,
-  fadeDistance: 100,
-  fadeStrength: 1,
-  cellThickness: 0.5,
-  sectionThickness: 1,
-  cellColor: new THREE.Color(),
-  sectionColor: new THREE.Color(),
-  infiniteGrid: false,
-  followCamera: false
-},
-/* glsl */
-`
-    varying vec3 worldPosition;
-    uniform float fadeDistance;
-    uniform bool infiniteGrid;
-    uniform bool followCamera;
-
-    void main() {
-      worldPosition = position.xzy;
-      if (infiniteGrid) worldPosition *= 1.0 + fadeDistance;
-      if (followCamera) worldPosition.xz +=cameraPosition.xz;
-
-      gl_Position = projectionMatrix * modelViewMatrix * vec4(worldPosition, 1.0);
-    }
-  `,
-/* glsl */
-`
-    varying vec3 worldPosition;
-    uniform float cellSize;
-    uniform float sectionSize;
-    uniform vec3 cellColor;
-    uniform vec3 sectionColor;
-    uniform float fadeDistance;
-    uniform float fadeStrength;
-    uniform float cellThickness;
-    uniform float sectionThickness;
-
-    float getGrid(float size, float thickness) {
-      vec2 r = worldPosition.xz / size;
-      vec2 grid = abs(fract(r - 0.5) - 0.5) / fwidth(r);
-      float line = min(grid.x, grid.y) + 1. - thickness;
-      return 1.0 - min(line, 1.);
-    }
-
-    void main() {
-      float g1 = getGrid(cellSize, cellThickness);
-      float g2 = getGrid(sectionSize, sectionThickness);
-
-      float d = 1.0 - min(distance(cameraPosition.xz, worldPosition.xz) / fadeDistance, 1.);
-      vec3 color = mix(cellColor, sectionColor, min(1.,sectionThickness * g2));
-
-      gl_FragColor = vec4(color, (g1 + g2) * pow(d,fadeStrength));
-      gl_FragColor.a = mix(0.75 * gl_FragColor.a, gl_FragColor.a, g2);
-      if (gl_FragColor.a <= 0.0) discard;
-
-      #include <tonemapping_fragment>
-      #include <encodings_fragment>
-    }
-  `);
-const Grid = /*#__PURE__*/React.forwardRef(({
-  args,
-  cellColor = '#000000',
-  sectionColor = '#2080ff',
-  cellSize = 0.5,
-  sectionSize = 1,
-  followCamera = false,
-  infiniteGrid = false,
-  fadeDistance = 100,
-  fadeStrength = 1,
-  cellThickness = 0.5,
-  sectionThickness = 1,
-  side = THREE.BackSide,
-  ...props
-}, fRef) => {
-  extend({
-    GridMaterial
-  });
-  const uniforms1 = {
-    cellSize,
-    sectionSize,
-    cellColor,
-    sectionColor,
-    cellThickness,
-    sectionThickness
-  };
-  const uniforms2 = {
-    fadeDistance,
-    fadeStrength,
-    infiniteGrid,
-    followCamera
-  };
-  return /*#__PURE__*/React.createElement("mesh", _extends({
-    ref: fRef,
-    frustumCulled: false
-  }, props), /*#__PURE__*/React.createElement("gridMaterial", _extends({
-    transparent: true,
-    "extensions-derivatives": true,
-    side: side
-  }, uniforms1, uniforms2)), /*#__PURE__*/React.createElement("planeGeometry", {
-    args: args
-  }));
-});
-
-export { Grid };

package/src/core/Hud.js

@@ -1,58 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { useThree, createPortal, useFrame } from '@react-three/fiber';
-
-function RenderHud({
-  defaultScene,
-  defaultCamera,
-  renderPriority = 1
-}) {
-  const {
-    gl,
-    scene,
-    camera
-  } = useThree();
-  let oldCLear;
-  useFrame(() => {
-    oldCLear = gl.autoClear;
-
-    if (renderPriority === 1) {
-      // Clear scene and render the default scene
-      gl.autoClear = true;
-      gl.render(defaultScene, defaultCamera);
-    } // Disable cleaning and render the portal with its own camera
-
-
-    gl.autoClear = false;
-    gl.clearDepth();
-    gl.render(scene, camera); // Restore default
-
-    gl.autoClear = oldCLear;
-  }, renderPriority); // Without an element that receives pointer events state.pointer will always be 0/0
-
-  return /*#__PURE__*/React.createElement("group", {
-    onPointerOver: () => null
-  });
-}
-
-function Hud({
-  children,
-  renderPriority = 1
-}) {
-  const {
-    scene: defaultScene,
-    camera: defaultCamera
-  } = useThree();
-  const [hudScene] = React.useState(() => new THREE.Scene());
-  return /*#__PURE__*/React.createElement(React.Fragment, null, createPortal( /*#__PURE__*/React.createElement(React.Fragment, null, children, /*#__PURE__*/React.createElement(RenderHud, {
-    defaultScene: defaultScene,
-    defaultCamera: defaultCamera,
-    renderPriority: renderPriority
-  })), hudScene, {
-    events: {
-      priority: renderPriority + 1
-    }
-  }));
-}
-
-export { Hud };

package/src/core/Image.js

@@ -1,119 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import * as THREE from 'three';
-import { extend } from '@react-three/fiber';
-import { shaderMaterial } from './shaderMaterial.js';
-import { useTexture } from './useTexture.js';
-
-const ImageMaterialImpl = shaderMaterial({
-  color: new THREE.Color('white'),
-  scale: [1, 1],
-  imageBounds: [1, 1],
-  map: null,
-  zoom: 1,
-  grayscale: 0,
-  opacity: 1
-},
-/* glsl */
-`
-  varying vec2 vUv;
-  void main() {
-    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
-    vUv = uv;
-  }
-`,
-/* glsl */
-`
-  // mostly from https://gist.github.com/statico/df64c5d167362ecf7b34fca0b1459a44
-  varying vec2 vUv;
-  uniform vec2 scale;
-  uniform vec2 imageBounds;
-  uniform vec3 color;
-  uniform sampler2D map;
-  uniform float zoom;
-  uniform float grayscale;
-  uniform float opacity;
-  const vec3 luma = vec3(.299, 0.587, 0.114);
-  vec4 toGrayscale(vec4 color, float intensity) {
-    return vec4(mix(color.rgb, vec3(dot(color.rgb, luma)), intensity), color.a);
-  }
-  vec2 aspect(vec2 size) {
-    return size / min(size.x, size.y);
-  }
-  void main() {
-    vec2 s = aspect(scale);
-    vec2 i = aspect(imageBounds);
-    float rs = s.x / s.y;
-    float ri = i.x / i.y;
-    vec2 new = rs < ri ? vec2(i.x * s.y / i.y, s.y) : vec2(s.x, i.y * s.x / i.x);
-    vec2 offset = (rs < ri ? vec2((new.x - s.x) / 2.0, 0.0) : vec2(0.0, (new.y - s.y) / 2.0)) / new;
-    vec2 uv = vUv * s / new + offset;
-    vec2 zUv = (uv - vec2(0.5, 0.5)) / zoom + vec2(0.5, 0.5);
-    gl_FragColor = toGrayscale(texture2D(map, zUv) * vec4(color, opacity), grayscale);
-    
-    #include <tonemapping_fragment>
-    #include <encodings_fragment>
-  }
-`);
-const ImageBase = /*#__PURE__*/React.forwardRef(({
-  children,
-  color,
-  segments = 1,
-  scale = 1,
-  zoom = 1,
-  grayscale = 0,
-  opacity = 1,
-  texture,
-  toneMapped,
-  transparent,
-  ...props
-}, ref) => {
-  extend({
-    ImageMaterial: ImageMaterialImpl
-  });
-  const planeBounds = Array.isArray(scale) ? [scale[0], scale[1]] : [scale, scale];
-  const imageBounds = [texture.image.width, texture.image.height];
-  return /*#__PURE__*/React.createElement("mesh", _extends({
-    ref: ref,
-    scale: Array.isArray(scale) ? [...scale, 1] : scale
-  }, props), /*#__PURE__*/React.createElement("planeGeometry", {
-    args: [1, 1, segments, segments]
-  }), /*#__PURE__*/React.createElement("imageMaterial", {
-    color: color,
-    map: texture,
-    zoom: zoom,
-    grayscale: grayscale,
-    opacity: opacity,
-    scale: planeBounds,
-    imageBounds: imageBounds,
-    toneMapped: toneMapped,
-    transparent: transparent
-  }), children);
-});
-const ImageWithUrl = /*#__PURE__*/React.forwardRef(({
-  url,
-  ...props
-}, ref) => {
-  const texture = useTexture(url);
-  return /*#__PURE__*/React.createElement(ImageBase, _extends({}, props, {
-    texture: texture,
-    ref: ref
-  }));
-});
-const ImageWithTexture = /*#__PURE__*/React.forwardRef(({
-  url: _url,
-  ...props
-}, ref) => {
-  return /*#__PURE__*/React.createElement(ImageBase, _extends({}, props, {
-    ref: ref
-  }));
-});
-const Image = /*#__PURE__*/React.forwardRef((props, ref) => {
-  if (props.url) return /*#__PURE__*/React.createElement(ImageWithUrl, _extends({}, props, {
-    ref: ref
-  }));else if (props.texture) return /*#__PURE__*/React.createElement(ImageWithTexture, _extends({}, props, {
-    ref: ref
-  }));else throw new Error('<Image /> requires a url or texture');
-});
-
-export { Image };

package/src/core/Instances.js

@@ -1,215 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as THREE from 'three';
-import * as React from 'react';
-import { extend, useFrame } from '@react-three/fiber';
-import mergeRefs from 'react-merge-refs';
-import Composer from 'react-composer';
-
-const _instanceLocalMatrix = /*@__PURE__*/new THREE.Matrix4();
-
-const _instanceWorldMatrix = /*@__PURE__*/new THREE.Matrix4();
-
-const _instanceIntersects = [];
-
-const _mesh = /*@__PURE__*/new THREE.Mesh();
-
-class PositionMesh extends THREE.Group {
-  constructor() {
-    super();
-    this.color = new THREE.Color('white');
-    this.instance = {
-      current: undefined
-    };
-    this.instanceKey = {
-      current: undefined
-    };
-  } // This will allow the virtual instance have bounds
-
-
-  get geometry() {
-    var _this$instance$curren;
-
-    return (_this$instance$curren = this.instance.current) == null ? void 0 : _this$instance$curren.geometry;
-  } // And this will allow the virtual instance to receive events
-
-
-  raycast(raycaster, intersects) {
-    const parent = this.instance.current;
-    if (!parent) return;
-    if (!parent.geometry || !parent.material) return;
-    _mesh.geometry = parent.geometry;
-    const matrixWorld = parent.matrixWorld;
-    const instanceId = parent.userData.instances.indexOf(this.instanceKey); // If the instance wasn't found or exceeds the parents draw range, bail out
-
-    if (instanceId === -1 || instanceId > parent.count) return; // calculate the world matrix for each instance
-
-    parent.getMatrixAt(instanceId, _instanceLocalMatrix);
-
-    _instanceWorldMatrix.multiplyMatrices(matrixWorld, _instanceLocalMatrix); // the mesh represents this single instance
-
-
-    _mesh.matrixWorld = _instanceWorldMatrix; // raycast side according to instance material
-
-    if (parent.material instanceof THREE.Material) _mesh.material.side = parent.material.side;else _mesh.material.side = parent.material[0].side;
-
-    _mesh.raycast(raycaster, _instanceIntersects); // process the result of raycast
-
-
-    for (let i = 0, l = _instanceIntersects.length; i < l; i++) {
-      const intersect = _instanceIntersects[i];
-      intersect.instanceId = instanceId;
-      intersect.object = this;
-      intersects.push(intersect);
-    }
-
-    _instanceIntersects.length = 0;
-  }
-
-}
-
-const globalContext = /*@__PURE__*/React.createContext(null);
-const parentMatrix = /*@__PURE__*/new THREE.Matrix4();
-const instanceMatrix = /*@__PURE__*/new THREE.Matrix4();
-const tempMatrix = /*@__PURE__*/new THREE.Matrix4();
-const translation = /*@__PURE__*/new THREE.Vector3();
-const rotation = /*@__PURE__*/new THREE.Quaternion();
-const scale = /*@__PURE__*/new THREE.Vector3();
-const Instance = /*#__PURE__*/React.forwardRef(({
-  context,
-  children,
-  ...props
-}, ref) => {
-  React.useMemo(() => extend({
-    PositionMesh
-  }), []);
-  const group = React.useRef();
-  const {
-    subscribe,
-    getParent
-  } = React.useContext(context || globalContext);
-  React.useLayoutEffect(() => subscribe(group), []);
-  return /*#__PURE__*/React.createElement("positionMesh", _extends({
-    instance: getParent(),
-    instanceKey: group,
-    ref: mergeRefs([ref, group])
-  }, props), children);
-});
-const Instances = /*#__PURE__*/React.forwardRef(({
-  children,
-  range,
-  limit = 1000,
-  frames = Infinity,
-  ...props
-}, ref) => {
-  const [{
-    context,
-    instance
-  }] = React.useState(() => {
-    const context = /*#__PURE__*/React.createContext(null);
-    return {
-      context,
-      instance: /*#__PURE__*/React.forwardRef((props, ref) => /*#__PURE__*/React.createElement(Instance, _extends({
-        context: context
-      }, props, {
-        ref: ref
-      })))
-    };
-  });
-  const parentRef = React.useRef(null);
-  const [instances, setInstances] = React.useState([]);
-  const [[matrices, colors]] = React.useState(() => {
-    const mArray = new Float32Array(limit * 16);
-
-    for (let i = 0; i < limit; i++) tempMatrix.identity().toArray(mArray, i * 16);
-
-    return [mArray, new Float32Array([...new Array(limit * 3)].map(() => 1))];
-  });
-  React.useEffect(() => {
-    // We might be a frame too late? 🤷‍♂️
-    parentRef.current.instanceMatrix.needsUpdate = true;
-  });
-  let count = 0;
-  let updateRange = 0;
-  useFrame(() => {
-    if (frames === Infinity || count < frames) {
-      parentRef.current.updateMatrix();
-      parentRef.current.updateMatrixWorld();
-      parentMatrix.copy(parentRef.current.matrixWorld).invert();
-      updateRange = Math.min(limit, range !== undefined ? range : limit, instances.length);
-      parentRef.current.count = updateRange;
-      parentRef.current.instanceMatrix.updateRange.count = updateRange * 16;
-      parentRef.current.instanceColor.updateRange.count = updateRange * 3;
-
-      for (let i = 0; i < instances.length; i++) {
-        const instance = instances[i].current; // Multiply the inverse of the InstancedMesh world matrix or else
-        // Instances will be double-transformed if <Instances> isn't at identity
-
-        instance.matrixWorld.decompose(translation, rotation, scale);
-        instanceMatrix.compose(translation, rotation, scale).premultiply(parentMatrix);
-        instanceMatrix.toArray(matrices, i * 16);
-        parentRef.current.instanceMatrix.needsUpdate = true;
-        instance.color.toArray(colors, i * 3);
-        parentRef.current.instanceColor.needsUpdate = true;
-      }
-
-      count++;
-    }
-  });
-  const api = React.useMemo(() => ({
-    getParent: () => parentRef,
-    subscribe: ref => {
-      setInstances(instances => [...instances, ref]);
-      return () => setInstances(instances => instances.filter(item => item.current !== ref.current));
-    }
-  }), []);
-  return /*#__PURE__*/React.createElement("instancedMesh", _extends({
-    userData: {
-      instances
-    },
-    matrixAutoUpdate: false,
-    ref: mergeRefs([ref, parentRef]),
-    args: [null, null, 0],
-    raycast: () => null
-  }, props), /*#__PURE__*/React.createElement("instancedBufferAttribute", {
-    attach: "instanceMatrix",
-    count: matrices.length / 16,
-    array: matrices,
-    itemSize: 16,
-    usage: THREE.DynamicDrawUsage
-  }), /*#__PURE__*/React.createElement("instancedBufferAttribute", {
-    attach: "instanceColor",
-    count: colors.length / 3,
-    array: colors,
-    itemSize: 3,
-    usage: THREE.DynamicDrawUsage
-  }), typeof children === 'function' ? /*#__PURE__*/React.createElement(context.Provider, {
-    value: api
-  }, children(instance)) : /*#__PURE__*/React.createElement(globalContext.Provider, {
-    value: api
-  }, children));
-});
-const Merged = /*#__PURE__*/React.forwardRef(function Merged({
-  meshes,
-  children,
-  ...props
-}, ref) {
-  const isArray = Array.isArray(meshes); // Filter out meshes from collections, which may contain non-meshes
-
-  if (!isArray) for (const key of Object.keys(meshes)) if (!meshes[key].isMesh) delete meshes[key];
-  return /*#__PURE__*/React.createElement("group", {
-    ref: ref
-  }, /*#__PURE__*/React.createElement(Composer, {
-    components: (isArray ? meshes : Object.values(meshes)).map(({
-      geometry,
-      material
-    }) => /*#__PURE__*/React.createElement(Instances, _extends({
-      key: geometry.uuid,
-      geometry: geometry,
-      material: material
-    }, props)))
-  }, args => isArray ? children(...args) : children(Object.keys(meshes).filter(key => meshes[key].isMesh).reduce((acc, key, i) => ({ ...acc,
-    [key]: args[i]
-  }), {}))));
-});
-
-export { Instance, Instances, Merged };

package/src/core/Lightformer.js

@@ -1,51 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import { applyProps } from '@react-three/fiber';
-import * as React from 'react';
-import * as THREE from 'three';
-import mergeRefs from 'react-merge-refs';
-
-const Lightformer = /*#__PURE__*/React.forwardRef(({
-  args,
-  map,
-  toneMapped = false,
-  color = 'white',
-  form: Form = 'rect',
-  intensity = 1,
-  scale = 1,
-  target,
-  children,
-  ...props
-}, forwardRef) => {
-  // Apply emissive power
-  const ref = React.useRef(null);
-  React.useLayoutEffect(() => {
-    if (!children && !props.material) {
-      applyProps(ref.current.material, {
-        color
-      });
-      ref.current.material.color.multiplyScalar(intensity);
-    }
-  }, [color, intensity, children, props.material]); // Target light
-
-  React.useLayoutEffect(() => {
-    if (target) ref.current.lookAt(Array.isArray(target) ? new THREE.Vector3(...target) : target);
-  }, [target]); // Fix 2-dimensional scale
-
-  scale = Array.isArray(scale) && scale.length === 2 ? [scale[0], scale[1], 1] : scale;
-  return /*#__PURE__*/React.createElement("mesh", _extends({
-    ref: mergeRefs([ref, forwardRef]),
-    scale: scale
-  }, props), Form === 'circle' ? /*#__PURE__*/React.createElement("ringGeometry", {
-    args: [0, 1, 64]
-  }) : Form === 'ring' ? /*#__PURE__*/React.createElement("ringGeometry", {
-    args: [0.5, 1, 64]
-  }) : Form === 'rect' ? /*#__PURE__*/React.createElement("planeGeometry", null) : /*#__PURE__*/React.createElement(Form, {
-    args: args
-  }), children ? children : !props.material ? /*#__PURE__*/React.createElement("meshBasicMaterial", {
-    toneMapped: toneMapped,
-    map: map,
-    side: THREE.DoubleSide
-  }) : null);
-});
-
-export { Lightformer };

package/src/core/Line.js

@@ -1,68 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import { Vector3, Vector2, Color } from 'three';
-import { useThree } from '@react-three/fiber';
-import { LineSegments2, Line2, LineMaterial, LineSegmentsGeometry, LineGeometry } from 'three-stdlib';
-
-const Line = /*#__PURE__*/React.forwardRef(function Line({
-  points,
-  color = 'black',
-  vertexColors,
-  linewidth,
-  lineWidth,
-  segments,
-  dashed,
-  ...rest
-}, ref) {
-  const size = useThree(state => state.size);
-  const line2 = React.useMemo(() => segments ? new LineSegments2() : new Line2(), [segments]);
-  const [lineMaterial] = React.useState(() => new LineMaterial());
-  const lineGeom = React.useMemo(() => {
-    const geom = segments ? new LineSegmentsGeometry() : new LineGeometry();
-    const pValues = points.map(p => {
-      const isArray = Array.isArray(p);
-      return p instanceof Vector3 ? [p.x, p.y, p.z] : p instanceof Vector2 ? [p.x, p.y, 0] : isArray && p.length === 3 ? [p[0], p[1], p[2]] : isArray && p.length === 2 ? [p[0], p[1], 0] : p;
-    });
-    geom.setPositions(pValues.flat());
-
-    if (vertexColors) {
-      const cValues = vertexColors.map(c => c instanceof Color ? c.toArray() : c);
-      geom.setColors(cValues.flat());
-    }
-
-    return geom;
-  }, [points, segments, vertexColors]);
-  React.useLayoutEffect(() => {
-    line2.computeLineDistances();
-  }, [points, line2]);
-  React.useLayoutEffect(() => {
-    if (dashed) {
-      lineMaterial.defines.USE_DASH = '';
-    } else {
-      // Setting lineMaterial.defines.USE_DASH to undefined is apparently not sufficient.
-      delete lineMaterial.defines.USE_DASH;
-    }
-
-    lineMaterial.needsUpdate = true;
-  }, [dashed, lineMaterial]);
-  React.useEffect(() => {
-    return () => lineGeom.dispose();
-  }, [lineGeom]);
-  return /*#__PURE__*/React.createElement("primitive", _extends({
-    object: line2,
-    ref: ref
-  }, rest), /*#__PURE__*/React.createElement("primitive", {
-    object: lineGeom,
-    attach: "geometry"
-  }), /*#__PURE__*/React.createElement("primitive", _extends({
-    object: lineMaterial,
-    attach: "material",
-    color: color,
-    vertexColors: Boolean(vertexColors),
-    resolution: [size.width, size.height],
-    linewidth: linewidth !== null && linewidth !== void 0 ? linewidth : lineWidth,
-    dashed: dashed
-  }, rest)));
-});
-
-export { Line };

package/src/core/MapControls.js

@@ -1,64 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import { useThree, useFrame } from '@react-three/fiber';
-import * as React from 'react';
-import { MapControls as MapControls$1 } from 'three-stdlib';
-
-const MapControls = /*#__PURE__*/React.forwardRef((props = {
-  enableDamping: true
-}, ref) => {
-  const {
-    domElement,
-    camera,
-    makeDefault,
-    onChange,
-    onStart,
-    onEnd,
-    ...rest
-  } = props;
-  const invalidate = useThree(state => state.invalidate);
-  const defaultCamera = useThree(state => state.camera);
-  const gl = useThree(state => state.gl);
-  const events = useThree(state => state.events);
-  const set = useThree(state => state.set);
-  const get = useThree(state => state.get);
-  const explDomElement = domElement || events.connected || gl.domElement;
-  const explCamera = camera || defaultCamera;
-  const controls = React.useMemo(() => new MapControls$1(explCamera), [explCamera]);
-  React.useEffect(() => {
-    controls.connect(explDomElement);
-
-    const callback = e => {
-      invalidate();
-      if (onChange) onChange(e);
-    };
-
-    controls.addEventListener('change', callback);
-    if (onStart) controls.addEventListener('start', onStart);
-    if (onEnd) controls.addEventListener('end', onEnd);
-    return () => {
-      controls.dispose();
-      controls.removeEventListener('change', callback);
-      if (onStart) controls.removeEventListener('start', onStart);
-      if (onEnd) controls.removeEventListener('end', onEnd);
-    };
-  }, [onChange, onStart, onEnd, controls, invalidate, explDomElement]);
-  React.useEffect(() => {
-    if (makeDefault) {
-      const old = get().controls;
-      set({
-        controls
-      });
-      return () => set({
-        controls: old
-      });
-    }
-  }, [makeDefault, controls]);
-  useFrame(() => controls.update(), -1);
-  return /*#__PURE__*/React.createElement("primitive", _extends({
-    ref: ref,
-    object: controls,
-    enableDamping: true
-  }, rest));
-});
-
-export { MapControls };