@react-three/drei 9.74.13 → 9.74.15

package/src/core/ContactShadows.js

@@ -1,114 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import * as THREE from 'three';
-import { useThree, useFrame } from '@react-three/fiber';
-import { HorizontalBlurShader, VerticalBlurShader } from 'three-stdlib';
-
-const ContactShadows = /*#__PURE__*/React.forwardRef(({
-  scale = 10,
-  frames = Infinity,
-  opacity = 1,
-  width = 1,
-  height = 1,
-  blur = 1,
-  far = 10,
-  resolution = 512,
-  smooth = true,
-  color = '#000000',
-  depthWrite = false,
-  renderOrder,
-  ...props
-}, fref) => {
-  const ref = React.useRef(null);
-  const scene = useThree(state => state.scene);
-  const gl = useThree(state => state.gl);
-  const shadowCamera = React.useRef(null);
-  width = width * (Array.isArray(scale) ? scale[0] : scale || 1);
-  height = height * (Array.isArray(scale) ? scale[1] : scale || 1);
-  const [renderTarget, planeGeometry, depthMaterial, blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur] = React.useMemo(() => {
-    const renderTarget = new THREE.WebGLRenderTarget(resolution, resolution);
-    const renderTargetBlur = new THREE.WebGLRenderTarget(resolution, resolution);
-    renderTargetBlur.texture.generateMipmaps = renderTarget.texture.generateMipmaps = false;
-    const planeGeometry = new THREE.PlaneGeometry(width, height).rotateX(Math.PI / 2);
-    const blurPlane = new THREE.Mesh(planeGeometry);
-    const depthMaterial = new THREE.MeshDepthMaterial();
-    depthMaterial.depthTest = depthMaterial.depthWrite = false;
-
-    depthMaterial.onBeforeCompile = shader => {
-      shader.uniforms = { ...shader.uniforms,
-        ucolor: {
-          value: new THREE.Color(color)
-        }
-      };
-      shader.fragmentShader = shader.fragmentShader.replace(`void main() {`, //
-      `uniform vec3 ucolor;
-           void main() {
-          `);
-      shader.fragmentShader = shader.fragmentShader.replace('vec4( vec3( 1.0 - fragCoordZ ), opacity );', // Colorize the shadow, multiply by the falloff so that the center can remain darker
-      'vec4( ucolor * fragCoordZ * 2.0, ( 1.0 - fragCoordZ ) * 1.0 );');
-    };
-
-    const horizontalBlurMaterial = new THREE.ShaderMaterial(HorizontalBlurShader);
-    const verticalBlurMaterial = new THREE.ShaderMaterial(VerticalBlurShader);
-    verticalBlurMaterial.depthTest = horizontalBlurMaterial.depthTest = false;
-    return [renderTarget, planeGeometry, depthMaterial, blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur];
-  }, [resolution, width, height, scale, color]);
-
-  const blurShadows = blur => {
-    blurPlane.visible = true;
-    blurPlane.material = horizontalBlurMaterial;
-    horizontalBlurMaterial.uniforms.tDiffuse.value = renderTarget.texture;
-    horizontalBlurMaterial.uniforms.h.value = blur * 1 / 256;
-    gl.setRenderTarget(renderTargetBlur);
-    gl.render(blurPlane, shadowCamera.current);
-    blurPlane.material = verticalBlurMaterial;
-    verticalBlurMaterial.uniforms.tDiffuse.value = renderTargetBlur.texture;
-    verticalBlurMaterial.uniforms.v.value = blur * 1 / 256;
-    gl.setRenderTarget(renderTarget);
-    gl.render(blurPlane, shadowCamera.current);
-    blurPlane.visible = false;
-  };
-
-  let count = 0;
-  let initialBackground;
-  let initialOverrideMaterial;
-  useFrame(() => {
-    if (shadowCamera.current && (frames === Infinity || count < frames)) {
-      count++;
-      initialBackground = scene.background;
-      initialOverrideMaterial = scene.overrideMaterial;
-      ref.current.visible = false;
-      scene.background = null;
-      scene.overrideMaterial = depthMaterial;
-      gl.setRenderTarget(renderTarget);
-      gl.render(scene, shadowCamera.current);
-      blurShadows(blur);
-      if (smooth) blurShadows(blur * 0.4);
-      gl.setRenderTarget(null);
-      ref.current.visible = true;
-      scene.overrideMaterial = initialOverrideMaterial;
-      scene.background = initialBackground;
-    }
-  });
-  React.useImperativeHandle(fref, () => ref.current, []);
-  return /*#__PURE__*/React.createElement("group", _extends({
-    "rotation-x": Math.PI / 2
-  }, props, {
-    ref: ref
-  }), /*#__PURE__*/React.createElement("mesh", {
-    renderOrder: renderOrder,
-    geometry: planeGeometry,
-    scale: [1, -1, 1],
-    rotation: [-Math.PI / 2, 0, 0]
-  }, /*#__PURE__*/React.createElement("meshBasicMaterial", {
-    transparent: true,
-    map: renderTarget.texture,
-    opacity: opacity,
-    depthWrite: depthWrite
-  })), /*#__PURE__*/React.createElement("orthographicCamera", {
-    ref: shadowCamera,
-    args: [-width / 2, width / 2, height / 2, -height / 2, 0, far]
-  }));
-});
-
-export { ContactShadows };

package/src/core/CubeCamera.js

@@ -1,43 +0,0 @@
-import * as React from 'react';
-import { useFrame } from '@react-three/fiber';
-import { useCubeCamera } from './useCubeCamera.js';
-
-function CubeCamera({
-  children,
-  frames = Infinity,
-  resolution,
-  near,
-  far,
-  envMap,
-  fog,
-  ...props
-}) {
-  const ref = React.useRef();
-  const {
-    fbo,
-    camera,
-    update
-  } = useCubeCamera({
-    resolution,
-    near,
-    far,
-    envMap,
-    fog
-  });
-  let count = 0;
-  useFrame(() => {
-    if (ref.current && (frames === Infinity || count < frames)) {
-      ref.current.visible = false;
-      update();
-      ref.current.visible = true;
-      count++;
-    }
-  });
-  return /*#__PURE__*/React.createElement("group", props, /*#__PURE__*/React.createElement("primitive", {
-    object: camera
-  }), /*#__PURE__*/React.createElement("group", {
-    ref: ref
-  }, children(fbo.texture)));
-}
-
-export { CubeCamera };

package/src/core/CubicBezierLine.js

@@ -1,28 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import { Vector3, CubicBezierCurve3 } from 'three';
-import { Line } from './Line.js';
-
-const CubicBezierLine = /*#__PURE__*/React.forwardRef(function CubicBezierLine({
-  start,
-  end,
-  midA,
-  midB,
-  segments = 20,
-  ...rest
-}, ref) {
-  const points = React.useMemo(() => {
-    const startV = start instanceof Vector3 ? start : new Vector3(...start);
-    const endV = end instanceof Vector3 ? end : new Vector3(...end);
-    const midAV = midA instanceof Vector3 ? midA : new Vector3(...midA);
-    const midBV = midB instanceof Vector3 ? midB : new Vector3(...midB);
-    const interpolatedV = new CubicBezierCurve3(startV, midAV, midBV, endV).getPoints(segments);
-    return interpolatedV;
-  }, [start, end, midA, midB, segments]);
-  return /*#__PURE__*/React.createElement(Line, _extends({
-    ref: ref,
-    points: points
-  }, rest));
-});
-
-export { CubicBezierLine };

package/src/core/CurveModifier.js

@@ -1,34 +0,0 @@
-import * as React from 'react';
-import * as THREE from 'three';
-import { createPortal } from '@react-three/fiber';
-import { Flow } from 'three-stdlib';
-
-const CurveModifier = /*#__PURE__*/React.forwardRef(({
-  children,
-  curve
-}, ref) => {
-  const [scene] = React.useState(() => new THREE.Scene());
-  const [obj, set] = React.useState();
-  const modifier = React.useRef();
-  React.useEffect(() => {
-    modifier.current = new Flow(scene.children[0]);
-    set(modifier.current.object3D);
-  }, [children]);
-  React.useEffect(() => {
-    var _modifier$current;
-
-    if (curve) (_modifier$current = modifier.current) == null ? void 0 : _modifier$current.updateCurve(0, curve);
-  }, [curve]);
-  React.useImperativeHandle(ref, () => ({
-    moveAlongCurve: val => {
-      var _modifier$current2;
-
-      (_modifier$current2 = modifier.current) == null ? void 0 : _modifier$current2.moveAlongCurve(val);
-    }
-  }));
-  return /*#__PURE__*/React.createElement(React.Fragment, null, createPortal(children, scene), obj && /*#__PURE__*/React.createElement("primitive", {
-    object: obj
-  }));
-});
-
-export { CurveModifier };

package/src/core/Decal.js

@@ -1,92 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import * as THREE from 'three';
-import { applyProps } from '@react-three/fiber';
-import { DecalGeometry } from 'three-stdlib';
-
-function isArray(vec) {
-  return Array.isArray(vec);
-}
-
-function vecToArray(vec = [0, 0, 0]) {
-  if (isArray(vec)) {
-    return vec;
-  } else if (vec instanceof THREE.Vector3 || vec instanceof THREE.Euler) {
-    return [vec.x, vec.y, vec.z];
-  } else {
-    return [vec, vec, vec];
-  }
-}
-
-const Decal = /*#__PURE__*/React.forwardRef(function Decal({
-  debug,
-  mesh,
-  children,
-  position,
-  rotation,
-  scale,
-  ...props
-}, forwardRef) {
-  const ref = React.useRef(null);
-  React.useImperativeHandle(forwardRef, () => ref.current);
-  const helper = React.useRef(null);
-  React.useLayoutEffect(() => {
-    const parent = (mesh == null ? void 0 : mesh.current) || ref.current.parent;
-    const target = ref.current;
-
-    if (!(parent instanceof THREE.Mesh)) {
-      throw new Error('Decal must have a Mesh as parent or specify its "mesh" prop');
-    }
-
-    const state = {
-      position: new THREE.Vector3(),
-      rotation: new THREE.Euler(),
-      scale: new THREE.Vector3(1, 1, 1)
-    };
-
-    if (parent) {
-      applyProps(state, {
-        position,
-        scale
-      }); // Zero out the parents matrix world for this operation
-
-      const matrixWorld = parent.matrixWorld.clone();
-      parent.matrixWorld.identity();
-
-      if (!rotation || typeof rotation === 'number') {
-        const o = new THREE.Object3D();
-        o.position.copy(state.position);
-        o.lookAt(parent.position);
-        if (typeof rotation === 'number') o.rotateZ(rotation);
-        applyProps(state, {
-          rotation: o.rotation
-        });
-      } else {
-        applyProps(state, {
-          rotation
-        });
-      }
-
-      target.geometry = new DecalGeometry(parent, state.position, state.rotation, state.scale);
-      if (helper.current) applyProps(helper.current, state); // Reset parents matix-world
-
-      parent.matrixWorld = matrixWorld;
-      return () => {
-        target.geometry.dispose();
-      };
-    }
-  }, [mesh, ...vecToArray(position), ...vecToArray(scale), ...vecToArray(rotation)]);
-  return /*#__PURE__*/React.createElement("mesh", {
-    ref: ref
-  }, children || /*#__PURE__*/React.createElement("meshStandardMaterial", _extends({
-    transparent: true,
-    polygonOffset: true,
-    polygonOffsetFactor: -10
-  }, props)), debug && /*#__PURE__*/React.createElement("mesh", {
-    ref: helper
-  }, /*#__PURE__*/React.createElement("boxGeometry", null), /*#__PURE__*/React.createElement("meshNormalMaterial", {
-    wireframe: true
-  }), /*#__PURE__*/React.createElement("axesHelper", null)));
-});
-
-export { Decal };

package/src/core/Detailed.js

@@ -1,34 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import { useFrame } from '@react-three/fiber';
-import mergeRefs from 'react-merge-refs';
-
-const Detailed = /*#__PURE__*/React.forwardRef(({
-  children,
-  hysteresis = 0,
-  distances,
-  ...props
-}, ref) => {
-  const lodRef = React.useRef(null);
-  React.useLayoutEffect(() => {
-    const {
-      current: lod
-    } = lodRef;
-    lod.levels.length = 0;
-    lod.children.forEach((object, index) => lod.levels.push({
-      object,
-      hysteresis,
-      distance: distances[index]
-    }));
-  });
-  useFrame(state => {
-    var _lodRef$current;
-
-    return (_lodRef$current = lodRef.current) == null ? void 0 : _lodRef$current.update(state.camera);
-  });
-  return /*#__PURE__*/React.createElement("lOD", _extends({
-    ref: mergeRefs([lodRef, ref])
-  }, props), children);
-});
-
-export { Detailed };

package/src/core/DeviceOrientationControls.js

@@ -1,51 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import { useThree, useFrame } from '@react-three/fiber';
-import * as React from 'react';
-import { DeviceOrientationControls as DeviceOrientationControls$1 } from 'three-stdlib';
-
-const DeviceOrientationControls = /*#__PURE__*/React.forwardRef((props, ref) => {
-  const {
-    camera,
-    onChange,
-    makeDefault,
-    ...rest
-  } = props;
-  const defaultCamera = useThree(state => state.camera);
-  const invalidate = useThree(state => state.invalidate);
-  const get = useThree(state => state.get);
-  const set = useThree(state => state.set);
-  const explCamera = camera || defaultCamera;
-  const [controls] = React.useState(() => new DeviceOrientationControls$1(explCamera));
-  React.useEffect(() => {
-    const callback = e => {
-      invalidate();
-      if (onChange) onChange(e);
-    };
-
-    controls == null ? void 0 : controls.addEventListener == null ? void 0 : controls.addEventListener('change', callback);
-    return () => controls == null ? void 0 : controls.removeEventListener == null ? void 0 : controls.removeEventListener('change', callback);
-  }, [onChange, controls, invalidate]);
-  useFrame(() => controls == null ? void 0 : controls.update(), -1);
-  React.useEffect(() => {
-    const current = controls;
-    current == null ? void 0 : current.connect();
-    return () => current == null ? void 0 : current.dispose();
-  }, [controls]);
-  React.useEffect(() => {
-    if (makeDefault) {
-      const old = get().controls;
-      set({
-        controls
-      });
-      return () => set({
-        controls: old
-      });
-    }
-  }, [makeDefault, controls]);
-  return controls ? /*#__PURE__*/React.createElement("primitive", _extends({
-    ref: ref,
-    object: controls
-  }, rest)) : null;
-});
-
-export { DeviceOrientationControls };

package/src/core/Edges.js

@@ -1,36 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import * as THREE from 'three';
-
-const Edges = /*#__PURE__*/React.forwardRef(({
-  userData,
-  children,
-  geometry,
-  threshold = 15,
-  color = 'black',
-  ...props
-}, fref) => {
-  const ref = React.useRef(null);
-  React.useLayoutEffect(() => {
-    const parent = ref.current.parent;
-
-    if (parent) {
-      const geom = geometry || parent.geometry;
-
-      if (geom !== ref.current.userData.currentGeom || threshold !== ref.current.userData.currentThreshold) {
-        ref.current.userData.currentGeom = geom;
-        ref.current.userData.currentThreshold = threshold;
-        ref.current.geometry = new THREE.EdgesGeometry(geom, threshold);
-      }
-    }
-  });
-  React.useImperativeHandle(fref, () => ref.current);
-  return /*#__PURE__*/React.createElement("lineSegments", _extends({
-    ref: ref,
-    raycast: () => null
-  }, props), children ? children : /*#__PURE__*/React.createElement("lineBasicMaterial", {
-    color: color
-  }));
-});
-
-export { Edges };

package/src/core/Effects.js

@@ -1,93 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import { WebGLRenderTarget, HalfFloatType, RGBAFormat, UnsignedByteType } from 'three';
-import { extend, useThree, useFrame } from '@react-three/fiber';
-import { EffectComposer, RenderPass, ShaderPass, GammaCorrectionShader } from 'three-stdlib';
-import mergeRefs from 'react-merge-refs';
-
-const isWebGL2Available = () => {
-  try {
-    var canvas = document.createElement('canvas');
-    return !!(window.WebGL2RenderingContext && canvas.getContext('webgl2'));
-  } catch (e) {
-    return false;
-  }
-};
-const Effects = /*#__PURE__*/React.forwardRef(({
-  children,
-  multisamping = 8,
-  renderIndex = 1,
-  disableRender,
-  disableGamma,
-  disableRenderPass,
-  depthBuffer = true,
-  stencilBuffer = false,
-  anisotropy = 1,
-  encoding,
-  type,
-  ...props
-}, ref) => {
-  React.useMemo(() => extend({
-    EffectComposer,
-    RenderPass,
-    ShaderPass
-  }), []);
-  const composer = React.useRef();
-  const {
-    scene,
-    camera,
-    gl,
-    size,
-    viewport
-  } = useThree();
-  const [target] = React.useState(() => {
-    const t = new WebGLRenderTarget(size.width, size.height, {
-      type: type || HalfFloatType,
-      format: RGBAFormat,
-      depthBuffer,
-      stencilBuffer,
-      anisotropy
-    }); // sRGB textures must be RGBA8 since r137 https://github.com/mrdoob/three.js/pull/23129
-
-    if (type === UnsignedByteType && encoding != null) {
-      if ('colorSpace' in t) t.texture.colorSpace = encoding;else t.texture.encoding = encoding;
-    }
-
-    t.samples = multisamping;
-    return t;
-  });
-  React.useEffect(() => {
-    var _composer$current, _composer$current2;
-
-    (_composer$current = composer.current) == null ? void 0 : _composer$current.setSize(size.width, size.height);
-    (_composer$current2 = composer.current) == null ? void 0 : _composer$current2.setPixelRatio(viewport.dpr);
-  }, [gl, size, viewport.dpr]);
-  useFrame(() => {
-    var _composer$current3;
-
-    if (!disableRender) (_composer$current3 = composer.current) == null ? void 0 : _composer$current3.render();
-  }, renderIndex);
-  const passes = [];
-  if (!disableRenderPass) passes.push( /*#__PURE__*/React.createElement("renderPass", {
-    key: "renderpass",
-    attach: `passes-${passes.length}`,
-    args: [scene, camera]
-  }));
-  if (!disableGamma) passes.push( /*#__PURE__*/React.createElement("shaderPass", {
-    attach: `passes-${passes.length}`,
-    key: "gammapass",
-    args: [GammaCorrectionShader]
-  }));
-  React.Children.forEach(children, el => {
-    el && passes.push( /*#__PURE__*/React.cloneElement(el, {
-      key: passes.length,
-      attach: `passes-${passes.length}`
-    }));
-  });
-  return /*#__PURE__*/React.createElement("effectComposer", _extends({
-    ref: mergeRefs([ref, composer]),
-    args: [gl, target]
-  }, props), passes);
-});
-
-export { Effects, isWebGL2Available };

package/src/core/Environment.js

@@ -1,132 +0,0 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import * as React from 'react';
-import { useThree, useFrame, createPortal, extend } from '@react-three/fiber';
-import { Scene, WebGLCubeRenderTarget, HalfFloatType } from 'three';
-import { GroundProjectedEnv } from 'three-stdlib';
-import { useEnvironment } from './useEnvironment.js';
-
-const isRef = obj => obj.current && obj.current.isScene;
-
-const resolveScene = scene => isRef(scene) ? scene.current : scene;
-
-function setEnvProps(background, scene, defaultScene, texture, blur = 0) {
-  const target = resolveScene(scene || defaultScene);
-  const oldbg = target.background;
-  const oldenv = target.environment; // @ts-ignore
-
-  const oldBlur = target.backgroundBlurriness || 0;
-  if (background !== 'only') target.environment = texture;
-  if (background) target.background = texture; // @ts-ignore
-
-  if (background && target.backgroundBlurriness !== undefined) target.backgroundBlurriness = blur;
-  return () => {
-    if (background !== 'only') target.environment = oldenv;
-    if (background) target.background = oldbg; // @ts-ignore
-
-    if (background && target.backgroundBlurriness !== undefined) target.backgroundBlurriness = oldBlur;
-  };
-}
-
-function EnvironmentMap({
-  scene,
-  background = false,
-  blur,
-  map
-}) {
-  const defaultScene = useThree(state => state.scene);
-  React.useLayoutEffect(() => {
-    if (map) return setEnvProps(background, scene, defaultScene, map, blur);
-  }, [defaultScene, scene, map, background, blur]);
-  return null;
-}
-function EnvironmentCube({
-  background = false,
-  scene,
-  blur,
-  ...rest
-}) {
-  const texture = useEnvironment(rest);
-  const defaultScene = useThree(state => state.scene);
-  React.useLayoutEffect(() => {
-    return setEnvProps(background, scene, defaultScene, texture, blur);
-  }, [texture, background, scene, defaultScene, blur]);
-  return null;
-}
-function EnvironmentPortal({
-  children,
-  near = 1,
-  far = 1000,
-  resolution = 256,
-  frames = 1,
-  map,
-  background = false,
-  blur,
-  scene,
-  files,
-  path,
-  preset = undefined,
-  extensions
-}) {
-  const gl = useThree(state => state.gl);
-  const defaultScene = useThree(state => state.scene);
-  const camera = React.useRef(null);
-  const [virtualScene] = React.useState(() => new Scene());
-  const fbo = React.useMemo(() => {
-    const fbo = new WebGLCubeRenderTarget(resolution);
-    fbo.texture.type = HalfFloatType;
-    return fbo;
-  }, [resolution]);
-  React.useLayoutEffect(() => {
-    if (frames === 1) camera.current.update(gl, virtualScene);
-    return setEnvProps(background, scene, defaultScene, fbo.texture, blur);
-  }, [children, virtualScene, fbo.texture, scene, defaultScene, background, frames, gl]);
-  let count = 1;
-  useFrame(() => {
-    if (frames === Infinity || count < frames) {
-      camera.current.update(gl, virtualScene);
-      count++;
-    }
-  });
-  return /*#__PURE__*/React.createElement(React.Fragment, null, createPortal( /*#__PURE__*/React.createElement(React.Fragment, null, children, /*#__PURE__*/React.createElement("cubeCamera", {
-    ref: camera,
-    args: [near, far, fbo]
-  }), files || preset ? /*#__PURE__*/React.createElement(EnvironmentCube, {
-    background: true,
-    files: files,
-    preset: preset,
-    path: path,
-    extensions: extensions
-  }) : map ? /*#__PURE__*/React.createElement(EnvironmentMap, {
-    background: true,
-    map: map,
-    extensions: extensions
-  }) : null), virtualScene));
-}
-
-function EnvironmentGround(props) {
-  var _props$ground, _props$ground2, _scale, _props$ground3;
-
-  const textureDefault = useEnvironment(props);
-  const texture = props.map || textureDefault;
-  React.useMemo(() => extend({
-    GroundProjectedEnvImpl: GroundProjectedEnv
-  }), []);
-  const args = React.useMemo(() => [texture], [texture]);
-  const height = (_props$ground = props.ground) == null ? void 0 : _props$ground.height;
-  const radius = (_props$ground2 = props.ground) == null ? void 0 : _props$ground2.radius;
-  const scale = (_scale = (_props$ground3 = props.ground) == null ? void 0 : _props$ground3.scale) !== null && _scale !== void 0 ? _scale : 1000;
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(EnvironmentMap, _extends({}, props, {
-    map: texture
-  })), /*#__PURE__*/React.createElement("groundProjectedEnvImpl", {
-    args: args,
-    scale: scale,
-    height: height,
-    radius: radius
-  }));
-}
-
-function Environment(props) {
-  return props.ground ? /*#__PURE__*/React.createElement(EnvironmentGround, props) : props.map ? /*#__PURE__*/React.createElement(EnvironmentMap, props) : props.children ? /*#__PURE__*/React.createElement(EnvironmentPortal, props) : /*#__PURE__*/React.createElement(EnvironmentCube, props);
-}
-
-export { Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal };