@react-three/drei 9.74.11 → 9.74.13

package/src/core/ContactShadows.js

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,132 @@
+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 };