@ohos-ports/react-three-drei 10.7.7-beta.0

package/core/Environment.js

@@ -0,0 +1,189 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as React from 'react';
+import { useThree, useFrame, createPortal, applyProps, 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, sceneProps = {}) {
+  var _target$backgroundRot, _target$backgroundRot2, _target$environmentRo, _target$environmentRo2;
+  // defaults
+  sceneProps = {
+    backgroundBlurriness: 0,
+    backgroundIntensity: 1,
+    backgroundRotation: [0, 0, 0],
+    environmentIntensity: 1,
+    environmentRotation: [0, 0, 0],
+    ...sceneProps
+  };
+  const target = resolveScene(scene || defaultScene);
+  const oldbg = target.background;
+  const oldenv = target.environment;
+  const oldSceneProps = {
+    // @ts-ignore
+    backgroundBlurriness: target.backgroundBlurriness,
+    // @ts-ignore
+    backgroundIntensity: target.backgroundIntensity,
+    // @ts-ignore
+    backgroundRotation: (_target$backgroundRot = (_target$backgroundRot2 = target.backgroundRotation) == null || _target$backgroundRot2.clone == null ? void 0 : _target$backgroundRot2.clone()) !== null && _target$backgroundRot !== void 0 ? _target$backgroundRot : [0, 0, 0],
+    // @ts-ignore
+    environmentIntensity: target.environmentIntensity,
+    // @ts-ignore
+    environmentRotation: (_target$environmentRo = (_target$environmentRo2 = target.environmentRotation) == null || _target$environmentRo2.clone == null ? void 0 : _target$environmentRo2.clone()) !== null && _target$environmentRo !== void 0 ? _target$environmentRo : [0, 0, 0]
+  };
+  if (background !== 'only') target.environment = texture;
+  if (background) target.background = texture;
+  applyProps(target, sceneProps);
+  return () => {
+    if (background !== 'only') target.environment = oldenv;
+    if (background) target.background = oldbg;
+    applyProps(target, oldSceneProps);
+  };
+}
+function EnvironmentMap({
+  scene,
+  background = false,
+  map,
+  ...config
+}) {
+  const defaultScene = useThree(state => state.scene);
+  React.useLayoutEffect(() => {
+    if (map) return setEnvProps(background, scene, defaultScene, map, config);
+  });
+  return null;
+}
+function EnvironmentCube({
+  background = false,
+  scene,
+  blur,
+  backgroundBlurriness,
+  backgroundIntensity,
+  backgroundRotation,
+  environmentIntensity,
+  environmentRotation,
+  ...rest
+}) {
+  const texture = useEnvironment(rest);
+  const defaultScene = useThree(state => state.scene);
+  React.useLayoutEffect(() => {
+    return setEnvProps(background, scene, defaultScene, texture, {
+      backgroundBlurriness: blur !== null && blur !== void 0 ? blur : backgroundBlurriness,
+      backgroundIntensity,
+      backgroundRotation,
+      environmentIntensity,
+      environmentRotation
+    });
+  });
+  React.useEffect(() => {
+    return () => {
+      texture.dispose();
+    };
+  }, [texture]);
+  return null;
+}
+function EnvironmentPortal({
+  children,
+  near = 0.1,
+  far = 1000,
+  resolution = 256,
+  frames = 1,
+  map,
+  background = false,
+  blur,
+  backgroundBlurriness,
+  backgroundIntensity,
+  backgroundRotation,
+  environmentIntensity,
+  environmentRotation,
+  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.useEffect(() => {
+    return () => {
+      fbo.dispose();
+    };
+  }, [fbo]);
+  React.useLayoutEffect(() => {
+    if (frames === 1) {
+      const autoClear = gl.autoClear;
+      gl.autoClear = true;
+      camera.current.update(gl, virtualScene);
+      gl.autoClear = autoClear;
+    }
+    return setEnvProps(background, scene, defaultScene, fbo.texture, {
+      backgroundBlurriness: blur !== null && blur !== void 0 ? blur : backgroundBlurriness,
+      backgroundIntensity,
+      backgroundRotation,
+      environmentIntensity,
+      environmentRotation
+    });
+  }, [children, virtualScene, fbo.texture, scene, defaultScene, background, frames, gl]);
+  let count = 1;
+  useFrame(() => {
+    if (frames === Infinity || count < frames) {
+      const autoClear = gl.autoClear;
+      gl.autoClear = true;
+      camera.current.update(gl, virtualScene);
+      gl.autoClear = autoClear;
+      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
+  }), []);
+  React.useEffect(() => {
+    return () => {
+      textureDefault.dispose();
+    };
+  }, [textureDefault]);
+  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 };

package/core/Example.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("./Text3D.cjs.js"),t=require("./Center.cjs.js");function a(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var a=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,a.get?a:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}require("@babel/runtime/helpers/extends"),require("@react-three/fiber"),require("three-stdlib"),require("./useFont.cjs.js"),require("suspend-react"),require("three");var c=a(e);const n=c.forwardRef((({font:e,color:a="#cbcbcb",bevelSize:n=.04,debug:l=!1,children:u,...s},i)=>{const[o,b]=c.useState(0),f=c.useCallback(((e=1)=>b(o+e)),[o]),d=c.useCallback(((e=1)=>b(o-e)),[o]),m=c.useMemo((()=>({incr:f,decr:d})),[f,d]);return c.useImperativeHandle(i,(()=>m),[m]),c.createElement("group",s,c.createElement(c.Suspense,{fallback:null},c.createElement(t.Center,{top:!0,cacheKey:JSON.stringify({counter:o,font:e})},c.createElement(r.Text3D,{bevelEnabled:!0,bevelSize:n,font:e},l?c.createElement("meshNormalMaterial",{wireframe:!0}):c.createElement("meshStandardMaterial",{color:a}),o))),u)}));exports.Example=n;

package/core/Example.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { Color } from '@react-three/fiber';
+export type ExampleProps = {
+    font: string;
+    color?: Color;
+    debug?: boolean;
+    bevelSize?: number;
+} & React.ComponentProps<'group'>;
+export type ExampleApi = {
+    incr: (x?: number) => void;
+    decr: (x?: number) => void;
+};
+export declare const Example: React.ForwardRefExoticComponent<Omit<ExampleProps, "ref"> & React.RefAttributes<ExampleApi>>;

package/core/Example.js

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { Text3D } from './Text3D.js';
+import { Center } from './Center.js';
+
+/* eslint react-hooks/exhaustive-deps: 1 */
+/**
+ * A simple counter example component. Click to increment, meta-click to decrement.
+ */
+const Example = /* @__PURE__ */React.forwardRef(({
+  font,
+  color = '#cbcbcb',
+  bevelSize = 0.04,
+  debug = false,
+  children,
+  ...props
+}, fref) => {
+  const [counter, setCounter] = React.useState(0);
+  const incr = React.useCallback((x = 1) => setCounter(counter + x), [counter]);
+  const decr = React.useCallback((x = 1) => setCounter(counter - x), [counter]);
+
+  // ref-API
+  const api = React.useMemo(() => ({
+    incr,
+    decr
+  }), [incr, decr]);
+  React.useImperativeHandle(fref, () => api, [api]);
+  return /*#__PURE__*/React.createElement("group", props, /*#__PURE__*/React.createElement(React.Suspense, {
+    fallback: null
+  }, /*#__PURE__*/React.createElement(Center, {
+    top: true,
+    cacheKey: JSON.stringify({
+      counter,
+      font
+    })
+  }, /*#__PURE__*/React.createElement(Text3D, {
+    bevelEnabled: true,
+    bevelSize: bevelSize,
+    font: font
+  }, debug ? /*#__PURE__*/React.createElement("meshNormalMaterial", {
+    wireframe: true
+  }) : /*#__PURE__*/React.createElement("meshStandardMaterial", {
+    color: color
+  }), counter))), children);
+});
+
+export { Example };

package/core/Fbo.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("three"),r=require("@react-three/fiber");function n(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var u=n(e),i=n(t);function o(e,t,n){const o=r.useThree((e=>e.size)),s=r.useThree((e=>e.viewport)),a="number"==typeof e?e:o.width*s.dpr,l="number"==typeof t?t:o.height*s.dpr,f=("number"==typeof e?n:e)||{},{samples:p=0,depth:c,...d}=f,h=null!=c?c:f.depthBuffer,b=u.useMemo((()=>{const e=new i.WebGLRenderTarget(a,l,{minFilter:i.LinearFilter,magFilter:i.LinearFilter,type:i.HalfFloatType,...d});return h&&(e.depthTexture=new i.DepthTexture(a,l,i.FloatType)),e.samples=p,e}),[]);return u.useLayoutEffect((()=>{b.setSize(a,l),p&&(b.samples=p)}),[p,b,a,l]),u.useEffect((()=>()=>b.dispose()),[]),b}const s=e.forwardRef((({children:t,width:r,height:n,...i},s)=>{const a=o(r,n,i);return e.useImperativeHandle(s,(()=>a),[a]),u.createElement(u.Fragment,null,null==t?void 0:t(a))}));exports.Fbo=s,exports.useFBO=o;

package/core/Fbo.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { type RenderTargetOptions } from 'three';
+type FBOSettings = {
+    depth?: boolean;
+} & RenderTargetOptions;
+export declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE.WebGLRenderTarget<THREE.Texture>;
+type UseFBOParams = Parameters<typeof useFBO>;
+type Fbo = ReturnType<typeof useFBO>;
+export type FboProps = {
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
+} & FBOSettings;
+export declare const Fbo: React.ForwardRefExoticComponent<{
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
+} & {
+    depth?: boolean;
+} & THREE.RenderTargetOptions & React.RefAttributes<THREE.WebGLRenderTarget<THREE.Texture>>>;
+export {};

package/core/Fbo.js

@@ -0,0 +1,63 @@
+import * as React from 'react';
+import { forwardRef, useImperativeHandle } from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+
+// 👇 uncomment when TS version supports function overloads
+// export function useFBO(settings?: FBOSettings)
+function useFBO(/** Width in pixels, or settings (will render fullscreen by default) */
+width, /** Height in pixels */
+height, /**Settings */
+settings) {
+  const size = useThree(state => state.size);
+  const viewport = useThree(state => state.viewport);
+  const _width = typeof width === 'number' ? width : size.width * viewport.dpr;
+  const _height = typeof height === 'number' ? height : size.height * viewport.dpr;
+  const _settings = (typeof width === 'number' ? settings : width) || {};
+  const {
+    samples = 0,
+    depth,
+    ...targetSettings
+  } = _settings;
+  const depthBuffer = depth !== null && depth !== void 0 ? depth : _settings.depthBuffer; // backwards compatibility for deprecated `depth` prop
+
+  const target = React.useMemo(() => {
+    const target = new THREE.WebGLRenderTarget(_width, _height, {
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.LinearFilter,
+      type: THREE.HalfFloatType,
+      ...targetSettings
+    });
+    if (depthBuffer) {
+      target.depthTexture = new THREE.DepthTexture(_width, _height, THREE.FloatType);
+    }
+    target.samples = samples;
+    return target;
+  }, []);
+  React.useLayoutEffect(() => {
+    target.setSize(_width, _height);
+    if (samples) target.samples = samples;
+  }, [samples, target, _width, _height]);
+  React.useEffect(() => {
+    return () => target.dispose();
+  }, []);
+  return target;
+}
+
+//
+// Fbo component
+//
+
+const Fbo = /* @__PURE__ */forwardRef(({
+  children,
+  width,
+  height,
+  ...settings
+}, fref) => {
+  const target = useFBO(width, height, settings);
+  useImperativeHandle(fref, () => target, [target]); // expose target through ref
+
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children == null ? void 0 : children(target));
+});
+
+export { Fbo, useFBO };

package/core/Fbx.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("three-stdlib"),u=require("@react-three/fiber"),n=require("./Clone.cjs.js");function o(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function a(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var u=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,u.get?u:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}require("three");var c=o(e),i=a(r);function l(e){return u.useLoader(t.FBXLoader,e)}l.preload=e=>u.useLoader.preload(t.FBXLoader,e),l.clear=e=>u.useLoader.clear(t.FBXLoader,e),exports.Fbx=function({path:e,...r}){const t=l(e).children[0];return i.createElement(n.Clone,c.default({},r,{object:t}))},exports.useFBX=l;

package/core/Fbx.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Group } from 'three';
+import { Clone } from './Clone';
+export declare function useFBX(path: string): Group;
+export declare namespace useFBX {
+    var preload: (path: string) => void;
+    var clear: (input: string | string[]) => void;
+}
+export declare function Fbx({ path, ...props }: {
+    path: Parameters<typeof useFBX>[0];
+} & Omit<React.ComponentProps<typeof Clone>, 'object'>): React.JSX.Element;

package/core/Fbx.js

@@ -0,0 +1,23 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as React from 'react';
+import { FBXLoader } from 'three-stdlib';
+import { useLoader } from '@react-three/fiber';
+import { Clone } from './Clone.js';
+
+function useFBX(path) {
+  return useLoader(FBXLoader, path);
+}
+useFBX.preload = path => useLoader.preload(FBXLoader, path);
+useFBX.clear = input => useLoader.clear(FBXLoader, input);
+function Fbx({
+  path,
+  ...props
+}) {
+  const fbx = useFBX(path);
+  const object = fbx.children[0];
+  return /*#__PURE__*/React.createElement(Clone, _extends({}, props, {
+    object: object
+  }));
+}
+
+export { Fbx, useFBX };

package/core/FirstPersonControls.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("@react-three/fiber"),n=require("three-stdlib");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function o(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var s=u(e),c=o(r);const l=c.forwardRef((({domElement:e,makeDefault:r,...u},o)=>{const l=t.useThree((e=>e.camera)),a=t.useThree((e=>e.gl)),f=t.useThree((e=>e.events)),i=t.useThree((e=>e.get)),d=t.useThree((e=>e.set)),b=e||f.connected||a.domElement,[m]=c.useState((()=>new n.FirstPersonControls(l,b)));return c.useEffect((()=>{if(r){const e=i().controls;return d({controls:m}),()=>d({controls:e})}}),[r,m]),t.useFrame(((e,r)=>{m.update(r)}),-1),m?c.createElement("primitive",s.default({ref:o,object:m},u)):null}));exports.FirstPersonControls=l;

package/core/FirstPersonControls.d.ts

@@ -0,0 +1,8 @@
+import { ThreeElement } from '@react-three/fiber';
+import { FirstPersonControls as FirstPersonControlImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FirstPersonControlsProps = Omit<ThreeElement<typeof FirstPersonControlImpl>, 'ref' | 'args'> & {
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+export declare const FirstPersonControls: ForwardRefComponent<FirstPersonControlsProps, FirstPersonControlImpl>;

package/core/FirstPersonControls.js

@@ -0,0 +1,38 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as React from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import { FirstPersonControls as FirstPersonControls$1 } from 'three-stdlib';
+
+const FirstPersonControls = /* @__PURE__ */React.forwardRef(({
+  domElement,
+  makeDefault,
+  ...props
+}, ref) => {
+  const camera = useThree(state => state.camera);
+  const gl = useThree(state => state.gl);
+  const events = useThree(state => state.events);
+  const get = useThree(state => state.get);
+  const set = useThree(state => state.set);
+  const explDomElement = domElement || events.connected || gl.domElement;
+  const [controls] = React.useState(() => new FirstPersonControls$1(camera, explDomElement));
+  React.useEffect(() => {
+    if (makeDefault) {
+      const old = get().controls;
+      set({
+        controls
+      });
+      return () => set({
+        controls: old
+      });
+    }
+  }, [makeDefault, controls]);
+  useFrame((_, delta) => {
+    controls.update(delta);
+  }, -1);
+  return controls ? /*#__PURE__*/React.createElement("primitive", _extends({
+    ref: ref,
+    object: controls
+  }, props)) : null;
+});
+
+export { FirstPersonControls };

package/core/Fisheye.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("three"),t=require("react"),a=require("@react-three/fiber"),n=require("./RenderCubeTexture.cjs.js");function i(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function o(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var a=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,a.get?a:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var c=i(e),u=o(r),s=o(t);function l({api:e}){const r=new u.Vector3,t=new u.Quaternion,n=new u.Vector3,i=new u.Euler(0,Math.PI,0);return a.useFrame((a=>{a.camera.matrixWorld.decompose(r,t,n),e.current.camera.position.copy(r),e.current.camera.quaternion.setFromEuler(i).premultiply(t)})),null}exports.Fisheye=function({renderPriority:e=1,zoom:r=0,segments:t=64,children:i,resolution:o=896,...m}){const f=s.useRef(null),p=s.useRef(null),{width:d,height:h}=a.useThree((e=>e.size)),[y]=s.useState((()=>new u.OrthographicCamera));s.useLayoutEffect((()=>{y.position.set(0,0,100),y.zoom=100,y.left=d/-2,y.right=d/2,y.top=h/2,y.bottom=h/-2,y.updateProjectionMatrix()}),[d,h]);const b=Math.sqrt(d*d+h*h)/100*(.5+r/2),g=new u.Vector3,w=new u.Sphere(new u.Vector3,b),x=new u.Matrix3,j=s.useCallback(((e,r,t)=>{r.pointer.set(e.offsetX/r.size.width*2-1,-e.offsetY/r.size.height*2+1),r.raycaster.setFromCamera(r.pointer,y),r.raycaster.ray.intersectSphere(w,g)&&(g.normalize(),x.getNormalMatrix(p.current.camera.matrixWorld),p.current.camera.getWorldPosition(r.raycaster.ray.origin),r.raycaster.ray.direction.set(0,0,1).reflect(g),r.raycaster.ray.direction.x*=-1,r.raycaster.ray.direction.applyNormalMatrix(x).multiplyScalar(-1))}),[]);return a.useFrame((r=>{e&&r.gl.render(f.current,y)}),e),s.createElement(s.Fragment,null,s.createElement("mesh",c.default({ref:f},m,{scale:b}),s.createElement("sphereGeometry",{args:[1,t,t]}),s.createElement("meshBasicMaterial",null,s.createElement(n.RenderCubeTexture,{compute:j,attach:"envMap",flip:!0,resolution:o,ref:p},i,s.createElement(l,{api:p})))))};

package/core/Fisheye.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { ThreeElements } from '@react-three/fiber';
+export type FisheyeProps = ThreeElements['mesh'] & {
+    zoom?: number;
+    segments?: number;
+    resolution?: number;
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+export declare function Fisheye({ renderPriority, zoom, segments, children, resolution, ...props }: FisheyeProps): React.JSX.Element;

package/core/Fisheye.js

@@ -0,0 +1,95 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as THREE from 'three';
+import * as React from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import { RenderCubeTexture } from './RenderCubeTexture.js';
+
+function Fisheye({
+  renderPriority = 1,
+  zoom = 0,
+  segments = 64,
+  children,
+  resolution = 896,
+  ...props
+}) {
+  const sphere = React.useRef(null);
+  const cubeApi = React.useRef(null);
+
+  // This isn't more than a simple sphere and a fixed orthographc camera
+  // pointing at it. A virtual scene is portalled into the environment map
+  // of its material. The cube-camera filming that scene is being synced to
+  // the portals default camera with the <UpdateCubeCamera> component.
+
+  const {
+    width,
+    height
+  } = useThree(state => state.size);
+  const [orthoC] = React.useState(() => new THREE.OrthographicCamera());
+  React.useLayoutEffect(() => {
+    orthoC.position.set(0, 0, 100);
+    orthoC.zoom = 100;
+    orthoC.left = width / -2;
+    orthoC.right = width / 2;
+    orthoC.top = height / 2;
+    orthoC.bottom = height / -2;
+    orthoC.updateProjectionMatrix();
+  }, [width, height]);
+  const radius = Math.sqrt(width * width + height * height) / 100 * (0.5 + zoom / 2);
+  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) => {
+    // Raycast from the render camera to the sphere and get the surface normal
+    // of the point hit in world space of the sphere scene
+    // We have to set the raycaster using the orthocam and pointer
+    // to perform sphere interscetions.
+    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();
+    // Get the matrix for transforming normals into world space
+    normalMatrix.getNormalMatrix(cubeApi.current.camera.matrixWorld);
+    // Get the ray
+    cubeApi.current.camera.getWorldPosition(state.raycaster.ray.origin);
+    state.raycaster.ray.direction.set(0, 0, 1).reflect(normal);
+    state.raycaster.ray.direction.x *= -1; // flip across X to accommodate the "flip" of the env map
+    state.raycaster.ray.direction.applyNormalMatrix(normalMatrix).multiplyScalar(-1);
+    return undefined;
+  }, []);
+  useFrame(state => {
+    // Take over rendering
+    if (renderPriority) state.gl.render(sphere.current, orthoC);
+  }, renderPriority);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("mesh", _extends({
+    ref: sphere
+  }, props, {
+    scale: radius
+  }), /*#__PURE__*/React.createElement("sphereGeometry", {
+    args: [1, segments, segments]
+  }), /*#__PURE__*/React.createElement("meshBasicMaterial", null, /*#__PURE__*/React.createElement(RenderCubeTexture, {
+    compute: compute,
+    attach: "envMap",
+    flip: true,
+    resolution: resolution,
+    ref: cubeApi
+  }, children, /*#__PURE__*/React.createElement(UpdateCubeCamera, {
+    api: cubeApi
+  })))));
+}
+function UpdateCubeCamera({
+  api
+}) {
+  const t = new THREE.Vector3();
+  const r = new THREE.Quaternion();
+  const s = new THREE.Vector3();
+  const e = new THREE.Euler(0, Math.PI, 0);
+  useFrame(state => {
+    // Read out the cameras whereabouts, state.camera is the one *within* the portal
+    state.camera.matrixWorld.decompose(t, r, s);
+    // Apply its position and rotation, flip the Y axis
+    api.current.camera.position.copy(t);
+    api.current.camera.quaternion.setFromEuler(e).premultiply(r);
+  });
+  return null;
+}
+
+export { Fisheye };

package/core/Float.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("@react-three/fiber"),r=require("three");function n(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var a=n(e),o=n(r);const i=a.forwardRef((({children:e,enabled:r=!0,speed:n=1,rotationIntensity:i=1,floatIntensity:u=1,floatingRange:c=[-.1,.1],autoInvalidate:l=!1,...s},d)=>{const f=a.useRef(null);a.useImperativeHandle(d,(()=>f.current),[]);const p=a.useRef(1e4*Math.random());return t.useFrame((e=>{var t,a;if(!r||0===n)return;l&&e.invalidate();const s=p.current+e.clock.elapsedTime;f.current.rotation.x=Math.cos(s/4*n)/8*i,f.current.rotation.y=Math.sin(s/4*n)/8*i,f.current.rotation.z=Math.sin(s/4*n)/20*i;let d=Math.sin(s/4*n)/10;d=o.MathUtils.mapLinear(d,-.1,.1,null!==(t=null==c?void 0:c[0])&&void 0!==t?t:-.1,null!==(a=null==c?void 0:c[1])&&void 0!==a?a:.1),f.current.position.y=d*u,f.current.updateMatrix()})),a.createElement("group",s,a.createElement("group",{ref:f,matrixAutoUpdate:!1},e))}));exports.Float=i;

package/core/Float.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { ThreeElements } from '@react-three/fiber';
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FloatProps = Omit<ThreeElements['group'], 'ref'> & {
+    enabled?: boolean;
+    speed?: number;
+    rotationIntensity?: number;
+    floatIntensity?: number;
+    children?: React.ReactNode;
+    floatingRange?: [number?, number?];
+    autoInvalidate?: boolean;
+};
+export declare const Float: ForwardRefComponent<FloatProps, THREE.Group>;

package/core/Float.js

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+
+const Float = /* @__PURE__ */React.forwardRef(({
+  children,
+  enabled = true,
+  speed = 1,
+  rotationIntensity = 1,
+  floatIntensity = 1,
+  floatingRange = [-0.1, 0.1],
+  autoInvalidate = false,
+  ...props
+}, forwardRef) => {
+  const ref = React.useRef(null);
+  React.useImperativeHandle(forwardRef, () => ref.current, []);
+  const offset = React.useRef(Math.random() * 10000);
+  useFrame(state => {
+    var _floatingRange$, _floatingRange$2;
+    if (!enabled || speed === 0) return;
+    if (autoInvalidate) state.invalidate();
+    const t = offset.current + state.clock.elapsedTime;
+    ref.current.rotation.x = Math.cos(t / 4 * speed) / 8 * rotationIntensity;
+    ref.current.rotation.y = Math.sin(t / 4 * speed) / 8 * rotationIntensity;
+    ref.current.rotation.z = Math.sin(t / 4 * speed) / 20 * rotationIntensity;
+    let yPosition = Math.sin(t / 4 * speed) / 10;
+    yPosition = THREE.MathUtils.mapLinear(yPosition, -0.1, 0.1, (_floatingRange$ = floatingRange == null ? void 0 : floatingRange[0]) !== null && _floatingRange$ !== void 0 ? _floatingRange$ : -0.1, (_floatingRange$2 = floatingRange == null ? void 0 : floatingRange[1]) !== null && _floatingRange$2 !== void 0 ? _floatingRange$2 : 0.1);
+    ref.current.position.y = yPosition * floatIntensity;
+    ref.current.updateMatrix();
+  });
+  return /*#__PURE__*/React.createElement("group", props, /*#__PURE__*/React.createElement("group", {
+    ref: ref,
+    matrixAutoUpdate: false
+  }, children));
+});
+
+export { Float };

package/core/FlyControls.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),t=require("@react-three/fiber"),r=require("react"),n=require("three-stdlib");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function o(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var s=u(e),c=o(r);const a=c.forwardRef((({domElement:e,...r},u)=>{const{onChange:o,makeDefault:a,...l}=r,i=t.useThree((e=>e.invalidate)),f=t.useThree((e=>e.camera)),d=t.useThree((e=>e.gl)),v=t.useThree((e=>e.events)),m=t.useThree((e=>e.get)),b=t.useThree((e=>e.set)),h=e||v.connected||d.domElement,p=c.useMemo((()=>new n.FlyControls(f)),[f]);return c.useEffect((()=>(p.connect(h),()=>{p.dispose()})),[h,p,i]),c.useEffect((()=>{const e=e=>{i(),o&&o(e)};return null==p.addEventListener||p.addEventListener("change",e),()=>null==p.removeEventListener?void 0:p.removeEventListener("change",e)}),[o,i]),c.useEffect((()=>{if(a){const e=m().controls;return b({controls:p}),()=>b({controls:e})}}),[a,p]),t.useFrame(((e,t)=>p.update(t))),c.createElement("primitive",s.default({ref:u,object:p,args:[f,h]},l))}));exports.FlyControls=a;

package/core/FlyControls.d.ts

@@ -0,0 +1,10 @@
+import { ThreeElement } from '@react-three/fiber';
+import * as THREE from 'three';
+import { FlyControls as FlyControlsImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FlyControlsProps = Omit<ThreeElement<typeof FlyControlsImpl>, 'ref' | 'args'> & {
+    onChange?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+export declare const FlyControls: ForwardRefComponent<FlyControlsProps, FlyControlsImpl>;