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

package/core/CubeTexture.js

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { CubeTextureLoader } from 'three';
+import { useLoader } from '@react-three/fiber';
+
+function useCubeTexture(files, {
+  path
+}) {
+  const [cubeTexture] = useLoader(CubeTextureLoader, [files], loader => loader.setPath(path));
+  return cubeTexture;
+}
+useCubeTexture.preload = (files, {
+  path
+}) => useLoader.preload(CubeTextureLoader, [files], loader => loader.setPath(path));
+function CubeTexture({
+  children,
+  files,
+  ...options
+}) {
+  const texture = useCubeTexture(files, {
+    ...options
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children == null ? void 0 : children(texture));
+}
+
+export { CubeTexture, useCubeTexture };

package/core/CubicBezierLine.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"),n=require("./Line.cjs.js");function c(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function i(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)}require("@react-three/fiber"),require("three-stdlib");var o=c(e),u=i(r);const s=u.forwardRef((function({start:e,end:r,midA:c,midB:i,segments:s=20,...f},a){const d=u.useMemo((()=>{const n=e instanceof t.Vector3?e:new t.Vector3(...e),o=r instanceof t.Vector3?r:new t.Vector3(...r),u=c instanceof t.Vector3?c:new t.Vector3(...c),f=i instanceof t.Vector3?i:new t.Vector3(...i);return new t.CubicBezierCurve3(n,u,f,o).getPoints(s)}),[e,r,c,i,s]);return u.createElement(n.Line,o.default({ref:a,points:d},f))}));exports.CubicBezierLine=s;

package/core/CubicBezierLine.d.ts

@@ -0,0 +1,12 @@
+import { Vector3 } from 'three';
+import { Line2 } from 'three-stdlib';
+import { LineProps } from './Line';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type CubicBezierLineProps = Omit<LineProps, 'points' | 'ref'> & {
+    start: Vector3 | [number, number, number];
+    end: Vector3 | [number, number, number];
+    midA: Vector3 | [number, number, number];
+    midB: Vector3 | [number, number, number];
+    segments?: number;
+};
+export declare const CubicBezierLine: ForwardRefComponent<CubicBezierLineProps, Line2>;

package/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/core/CurveModifier.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("three"),t=require("@react-three/fiber"),u=require("three-stdlib");function n(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)}var c=n(e),a=n(r);const i=c.forwardRef((({children:e,curve:r},n)=>{const[i]=c.useState((()=>new a.Scene)),[l,o]=c.useState(),f=c.useRef(null);return c.useLayoutEffect((()=>{f.current=new u.Flow(i.children[0]),o(f.current.object3D)}),[e]),c.useEffect((()=>{var e;r&&(null==(e=f.current)||e.updateCurve(0,r))}),[r]),c.useImperativeHandle(n,(()=>f.current)),c.createElement(c.Fragment,null,t.createPortal(e,i),l&&c.createElement("primitive",{object:l}))}));exports.CurveModifier=i;

package/core/CurveModifier.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { ThreeElements } from '@react-three/fiber';
+import { Flow } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export interface CurveModifierProps {
+    children: React.ReactElement<ThreeElements['mesh']>;
+    curve?: THREE.Curve<THREE.Vector3>;
+}
+export type CurveModifierRef = Flow;
+export declare const CurveModifier: ForwardRefComponent<CurveModifierProps, CurveModifierRef>;

package/core/CurveModifier.js

@@ -0,0 +1,27 @@
+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(null);
+  React.useLayoutEffect(() => {
+    modifier.current = new Flow(scene.children[0]);
+    set(modifier.current.object3D);
+  }, [children]);
+  React.useEffect(() => {
+    var _modifier$current;
+    if (curve) (_modifier$current = modifier.current) == null || _modifier$current.updateCurve(0, curve);
+  }, [curve]);
+  React.useImperativeHandle(ref, () => modifier.current);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, createPortal(children, scene), obj && /*#__PURE__*/React.createElement("primitive", {
+    object: obj
+  }));
+});
+
+export { CurveModifier };

package/core/Decal.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),t=require("react"),r=require("three"),o=require("@react-three/fiber"),n=require("three-stdlib");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function i(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var o=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,o.get?o:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var c=a(e),s=i(t),u=i(r);function l(e=[0,0,0]){return function(e){return Array.isArray(e)}(e)?e:e instanceof u.Vector3||e instanceof u.Euler?[e.x,e.y,e.z]:[e,e,e]}const p=s.forwardRef((function({debug:e,depthTest:t=!1,polygonOffsetFactor:r=-10,map:a,mesh:i,children:p,position:f,rotation:m,scale:y,...d},b){const h=s.useRef(null);s.useImperativeHandle(b,(()=>h.current));const g=s.useRef(null),w=s.useRef({position:new u.Vector3,rotation:new u.Euler,scale:new u.Vector3(1,1,1)});return s.useLayoutEffect((()=>{const e=(null==i?void 0:i.current)||h.current.parent,t=h.current;if(!(e instanceof u.Mesh))throw new Error('Decal must have a Mesh as parent or specify its "mesh" prop');if(e){o.applyProps(w.current,{position:f,scale:y});const r=e.matrixWorld.clone();if(e.matrixWorld.identity(),m&&"number"!=typeof m)o.applyProps(w.current,{rotation:m});else{const t=new u.Object3D;t.position.copy(w.current.position);const r=e.geometry.attributes.position.array;void 0===e.geometry.attributes.normal&&e.geometry.computeVertexNormals();const n=e.geometry.attributes.normal.array;let a=1/0,i=new u.Vector3;const c=t.position.x,s=t.position.y,l=t.position.z,p=r.length;let f=-1;for(let e=0;e<p;e+=3){const t=r[e]-c,o=r[e+1]-s,n=r[e+2]-l,i=t*t+o*o+n*n;i<a&&(a=i,f=e)}i.fromArray(n,f),t.lookAt(t.position.clone().add(i)),t.rotateZ(Math.PI),t.rotateY(Math.PI),"number"==typeof m&&t.rotateZ(m),o.applyProps(w.current,{rotation:t.rotation})}return g.current&&o.applyProps(g.current,w.current),t.geometry=new n.DecalGeometry(e,w.current.position,w.current.rotation,w.current.scale),e.matrixWorld=r,()=>{t.geometry.dispose()}}}),[i,...l(f),...l(y),...l(m)]),s.useLayoutEffect((()=>{g.current&&g.current.traverse((e=>e.raycast=()=>null))}),[e]),s.createElement("mesh",c.default({ref:h,"material-transparent":!0,"material-polygonOffset":!0,"material-polygonOffsetFactor":r,"material-depthTest":t,"material-map":a},d),p,e&&s.createElement("mesh",{ref:g},s.createElement("boxGeometry",null),s.createElement("meshNormalMaterial",{wireframe:!0}),s.createElement("axesHelper",null)))}));exports.Decal=p;

package/core/Decal.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import * as FIBER from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type DecalProps = Omit<FIBER.ThreeElements['mesh'], 'ref' | 'children'> & {
+    debug?: boolean;
+    mesh?: React.RefObject<THREE.Mesh>;
+    position?: FIBER.Vector3;
+    rotation?: FIBER.Euler | number;
+    scale?: FIBER.Vector3;
+    map?: THREE.Texture;
+    children?: React.ReactNode;
+    polygonOffsetFactor?: number;
+    depthTest?: boolean;
+};
+export declare const Decal: ForwardRefComponent<DecalProps, THREE.Mesh>;

package/core/Decal.js

@@ -0,0 +1,128 @@
+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,
+  depthTest = false,
+  polygonOffsetFactor = -10,
+  map,
+  mesh,
+  children,
+  position,
+  rotation,
+  scale,
+  ...props
+}, forwardRef) {
+  const ref = React.useRef(null);
+  React.useImperativeHandle(forwardRef, () => ref.current);
+  const helper = React.useRef(null);
+  const state = React.useRef({
+    position: new THREE.Vector3(),
+    rotation: new THREE.Euler(),
+    scale: new THREE.Vector3(1, 1, 1)
+  });
+  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');
+    }
+    if (parent) {
+      applyProps(state.current, {
+        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.current.position);
+
+        // Thanks https://x.com/N8Programs !
+        const vertices = parent.geometry.attributes.position.array;
+        if (parent.geometry.attributes.normal === undefined) parent.geometry.computeVertexNormals();
+        const normal = parent.geometry.attributes.normal.array;
+        let distance = Infinity;
+        let closestNormal = new THREE.Vector3();
+        const ox = o.position.x;
+        const oy = o.position.y;
+        const oz = o.position.z;
+        const vLength = vertices.length;
+        let chosenIdx = -1;
+        for (let i = 0; i < vLength; i += 3) {
+          const x = vertices[i];
+          const y = vertices[i + 1];
+          const z = vertices[i + 2];
+          const xDiff = x - ox;
+          const yDiff = y - oy;
+          const zDiff = z - oz;
+          const distSquared = xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
+          if (distSquared < distance) {
+            distance = distSquared;
+            chosenIdx = i;
+          }
+        }
+        closestNormal.fromArray(normal, chosenIdx);
+
+        // Get vector tangent to normal
+        o.lookAt(o.position.clone().add(closestNormal));
+        o.rotateZ(Math.PI);
+        o.rotateY(Math.PI);
+        if (typeof rotation === 'number') o.rotateZ(rotation);
+        applyProps(state.current, {
+          rotation: o.rotation
+        });
+      } else {
+        applyProps(state.current, {
+          rotation
+        });
+      }
+      if (helper.current) {
+        applyProps(helper.current, state.current);
+      }
+      target.geometry = new DecalGeometry(parent, state.current.position, state.current.rotation, state.current.scale);
+      // Reset parents matix-world
+      parent.matrixWorld = matrixWorld;
+      return () => {
+        target.geometry.dispose();
+      };
+    }
+  }, [mesh, ...vecToArray(position), ...vecToArray(scale), ...vecToArray(rotation)]);
+  React.useLayoutEffect(() => {
+    if (helper.current) {
+      // Prevent the helpers from blocking rays
+      helper.current.traverse(child => child.raycast = () => null);
+    }
+  }, [debug]);
+  return /*#__PURE__*/React.createElement("mesh", _extends({
+    ref: ref,
+    "material-transparent": true,
+    "material-polygonOffset": true,
+    "material-polygonOffsetFactor": polygonOffsetFactor,
+    "material-depthTest": depthTest,
+    "material-map": map
+  }, props), children, 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/core/Detailed.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");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function u(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 c=n(e),a=u(r);const s=a.forwardRef((({children:e,hysteresis:r=0,distances:n,...u},s)=>{const l=a.useRef(null);return a.useImperativeHandle(s,(()=>l.current),[]),a.useLayoutEffect((()=>{const{current:e}=l;e.levels.length=0,e.children.forEach(((t,u)=>e.levels.push({object:t,hysteresis:r,distance:n[u]})))})),t.useFrame((e=>{var r;return null==(r=l.current)?void 0:r.update(e.camera)})),a.createElement("lOD",c.default({ref:l},u),e)}));exports.Detailed=s;

package/core/Detailed.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { LOD, Object3D } from 'three';
+import { ThreeElements } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type DetailedProps = Omit<ThreeElements['lOD'], 'ref'> & {
+    children: React.ReactElement<Object3D>[];
+    hysteresis?: number;
+    distances: number[];
+};
+export declare const Detailed: ForwardRefComponent<DetailedProps, LOD>;

package/core/Detailed.js

@@ -0,0 +1,33 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as React from 'react';
+import { useFrame } from '@react-three/fiber';
+
+const Detailed = /* @__PURE__ */React.forwardRef(({
+  children,
+  hysteresis = 0,
+  distances,
+  ...props
+}, ref) => {
+  const lodRef = React.useRef(null);
+  React.useImperativeHandle(ref, () => lodRef.current, []);
+  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: lodRef
+  }, props), children);
+});
+
+export { Detailed };

package/core/DetectGPU.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("detect-gpu"),r=require("suspend-react");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);const c=e=>r.suspend((()=>t.getGPUTier(e)),["useDetectGPU"]);exports.DetectGPU=function({children:e,...t}){const r=c(t);return u.createElement(u.Fragment,null,null==e?void 0:e(r))},exports.useDetectGPU=c;

package/core/DetectGPU.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { GetGPUTier } from 'detect-gpu';
+export declare const useDetectGPU: (props?: GetGPUTier) => import("detect-gpu").TierResult;
+export type DetectGPUProps = {
+    children?: (result: ReturnType<typeof useDetectGPU>) => React.ReactNode;
+} & Parameters<typeof useDetectGPU>[0];
+export declare function DetectGPU({ children, ...options }: DetectGPUProps): React.JSX.Element;

package/core/DetectGPU.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { getGPUTier } from 'detect-gpu';
+import { suspend } from 'suspend-react';
+
+const useDetectGPU = props => suspend(() => getGPUTier(props), ['useDetectGPU']);
+function DetectGPU({
+  children,
+  ...options
+}) {
+  const result = useDetectGPU(options);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children == null ? void 0 : children(result));
+}
+
+export { DetectGPU, useDetectGPU };

package/core/DeviceOrientationControls.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 c=u(e),i=o(r);const l=i.forwardRef(((e,r)=>{const{camera:u,onChange:o,makeDefault:l,...s}=e,a=t.useThree((e=>e.camera)),f=t.useThree((e=>e.invalidate)),d=t.useThree((e=>e.get)),v=t.useThree((e=>e.set)),b=u||a,h=i.useMemo((()=>new n.DeviceOrientationControls(b)),[b]);return i.useEffect((()=>{const e=e=>{f(),o&&o(e)};return null==h||null==h.addEventListener||h.addEventListener("change",e),()=>null==h||null==h.removeEventListener?void 0:h.removeEventListener("change",e)}),[o,h,f]),t.useFrame((()=>null==h?void 0:h.update()),-1),i.useEffect((()=>{const e=h;return null==e||e.connect(),()=>null==e?void 0:e.dispose()}),[h]),i.useEffect((()=>{if(l){const e=d().controls;return v({controls:h}),()=>v({controls:e})}}),[l,h]),h?i.createElement("primitive",c.default({ref:r,object:h},s)):null}));exports.DeviceOrientationControls=l;

package/core/DeviceOrientationControls.d.ts

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

package/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.useMemo(() => new DeviceOrientationControls$1(explCamera), [explCamera]);
+  React.useEffect(() => {
+    const callback = e => {
+      invalidate();
+      if (onChange) onChange(e);
+    };
+    controls == null || controls.addEventListener == null || controls.addEventListener('change', callback);
+    return () => controls == null || 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 || current.connect();
+    return () => current == null ? void 0 : current.dispose();
+  }, [controls]);
+  React.useEffect(() => {
+    if (makeDefault) {
+      const old = get().controls;
+      // @ts-ignore https://github.com/three-types/three-ts-types/pull/1398
+      set({
+        controls
+      });
+      return () => set({
+        controls: old
+      });
+    }
+  }, [makeDefault, controls]);
+  return controls ? /*#__PURE__*/React.createElement("primitive", _extends({
+    ref: ref,
+    object: controls
+  }, rest)) : null;
+});
+
+export { DeviceOrientationControls };

package/core/Edges.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),t=require("react"),r=require("three"),n=require("./Line.cjs.js");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function s(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)}require("@react-three/fiber"),require("three-stdlib");var c=u(e),i=s(t),o=s(r);const a=i.forwardRef((({threshold:e=15,geometry:t,...r},u)=>{const s=i.useRef(null);i.useImperativeHandle(u,(()=>s.current),[]);const a=i.useMemo((()=>[0,0,0,1,0,0]),[]),l=i.useRef(null),f=i.useRef(null);return i.useLayoutEffect((()=>{const r=s.current.parent,n=null!=t?t:null==r?void 0:r.geometry;if(!n)return;if(l.current===n&&f.current===e)return;l.current=n,f.current=e;const u=new o.EdgesGeometry(n,e).attributes.position.array;s.current.geometry.setPositions(u),s.current.geometry.attributes.instanceStart.needsUpdate=!0,s.current.geometry.attributes.instanceEnd.needsUpdate=!0,s.current.computeLineDistances()})),i.createElement(n.Line,c.default({segments:!0,points:a,ref:s,raycast:()=>null},r))}));exports.Edges=a;

package/core/Edges.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import { ThreeElement, type ThreeElements } from '@react-three/fiber';
+import { LineSegmentsGeometry, LineMaterial, LineMaterialParameters, Line2 } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type EdgesRef = THREE.Mesh<LineSegmentsGeometry, LineMaterial>;
+export type EdgesProps = Partial<ThreeElements['mesh']> & {
+    threshold?: number;
+    lineWidth?: number;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ThreeElement<typeof Line2>, 'args' | 'geometry'> & Omit<ThreeElement<typeof LineMaterial>, 'color' | 'vertexColors' | 'args'> & {
+    geometry?: THREE.BufferGeometry;
+    color?: THREE.ColorRepresentation;
+};
+export declare const Edges: ForwardRefComponent<EdgesProps, EdgesRef>;

package/core/Edges.js

@@ -0,0 +1,38 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as React from 'react';
+import * as THREE from 'three';
+import { Line } from './Line.js';
+
+const Edges = /* @__PURE__ */React.forwardRef(({
+  threshold = 15,
+  geometry: explicitGeometry,
+  ...props
+}, fref) => {
+  const ref = React.useRef(null);
+  React.useImperativeHandle(fref, () => ref.current, []);
+  const tmpPoints = React.useMemo(() => [0, 0, 0, 1, 0, 0], []);
+  const memoizedGeometry = React.useRef(null);
+  const memoizedThreshold = React.useRef(null);
+  React.useLayoutEffect(() => {
+    const parent = ref.current.parent;
+    const geometry = explicitGeometry !== null && explicitGeometry !== void 0 ? explicitGeometry : parent == null ? void 0 : parent.geometry;
+    if (!geometry) return;
+    const cached = memoizedGeometry.current === geometry && memoizedThreshold.current === threshold;
+    if (cached) return;
+    memoizedGeometry.current = geometry;
+    memoizedThreshold.current = threshold;
+    const points = new THREE.EdgesGeometry(geometry, threshold).attributes.position.array;
+    ref.current.geometry.setPositions(points);
+    ref.current.geometry.attributes.instanceStart.needsUpdate = true;
+    ref.current.geometry.attributes.instanceEnd.needsUpdate = true;
+    ref.current.computeLineDistances();
+  });
+  return /*#__PURE__*/React.createElement(Line, _extends({
+    segments: true,
+    points: tmpPoints,
+    ref: ref,
+    raycast: () => null
+  }, props));
+});
+
+export { Edges };

package/core/Effects.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"),a=require("@react-three/fiber"),n=require("three-stdlib");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function u(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=s(e),l=u(r);const o=l.forwardRef((({children:e,multisamping:r=8,renderIndex:s=1,disableRender:u,disableGamma:o,disableRenderPass:i,depthBuffer:d=!0,stencilBuffer:f=!1,anisotropy:p=1,colorSpace:h,type:m,...b},g)=>{l.useMemo((()=>a.extend({EffectComposer:n.EffectComposer,RenderPass:n.RenderPass,ShaderPass:n.ShaderPass})),[]);const y=l.useRef(null);l.useImperativeHandle(g,(()=>y.current),[]);const{scene:v,camera:E,gl:P,size:x,viewport:R}=a.useThree(),[w]=l.useState((()=>{const e=new t.WebGLRenderTarget(x.width,x.height,{type:m||t.HalfFloatType,format:t.RGBAFormat,depthBuffer:d,stencilBuffer:f,anisotropy:p});return m===t.UnsignedByteType&&null!=h&&(e.texture.colorSpace=h),e.samples=r,e}));l.useEffect((()=>{var e,r;null==(e=y.current)||e.setSize(x.width,x.height),null==(r=y.current)||r.setPixelRatio(R.dpr)}),[P,x,R.dpr]),a.useFrame((()=>{var e;u||null==(e=y.current)||e.render()}),s);const j=[];return i||j.push(l.createElement("renderPass",{key:"renderpass",attach:`passes-${j.length}`,args:[v,E]})),o||j.push(l.createElement("shaderPass",{attach:`passes-${j.length}`,key:"gammapass",args:[n.GammaCorrectionShader]})),l.Children.forEach(e,(e=>{e&&j.push(l.cloneElement(e,{key:j.length,attach:`passes-${j.length}`}))})),l.createElement("effectComposer",c.default({ref:y,args:[P,w]},b),j)}));exports.Effects=o,exports.isWebGL2Available=()=>{try{var e=document.createElement("canvas");return!(!window.WebGL2RenderingContext||!e.getContext("webgl2"))}catch(e){return!1}};

package/core/Effects.d.ts

@@ -0,0 +1,25 @@
+import { TextureDataType, ColorSpace } from 'three';
+import { ThreeElement, ThreeElements } from '@react-three/fiber';
+import { EffectComposer, RenderPass, ShaderPass } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type EffectsProps = Omit<ThreeElements['effectComposer'], 'ref' | 'args'> & {
+    multisamping?: number;
+    colorSpace?: ColorSpace;
+    type?: TextureDataType;
+    renderIndex?: number;
+    disableGamma?: boolean;
+    disableRenderPass?: boolean;
+    disableRender?: boolean;
+    depthBuffer?: boolean;
+    stencilBuffer?: boolean;
+    anisotropy?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        effectComposer: ThreeElement<typeof EffectComposer>;
+        renderPass: ThreeElement<typeof RenderPass>;
+        shaderPass: ThreeElement<typeof ShaderPass>;
+    }
+}
+export declare const isWebGL2Available: () => boolean;
+export declare const Effects: ForwardRefComponent<EffectsProps, EffectComposer>;

package/core/Effects.js

@@ -0,0 +1,91 @@
+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';
+
+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,
+  colorSpace,
+  type,
+  ...props
+}, ref) => {
+  React.useMemo(() => extend({
+    EffectComposer,
+    RenderPass,
+    ShaderPass
+  }), []);
+  const composer = React.useRef(null);
+  React.useImperativeHandle(ref, () => composer.current, []);
+  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 && colorSpace != null) {
+      t.texture.colorSpace = colorSpace;
+    }
+    t.samples = multisamping;
+    return t;
+  });
+  React.useEffect(() => {
+    var _composer$current, _composer$current2;
+    (_composer$current = composer.current) == null || _composer$current.setSize(size.width, size.height);
+    (_composer$current2 = composer.current) == null || _composer$current2.setPixelRatio(viewport.dpr);
+  }, [gl, size, viewport.dpr]);
+  useFrame(() => {
+    var _composer$current3;
+    if (!disableRender) (_composer$current3 = composer.current) == null || _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: composer,
+    args: [gl, target]
+  }, props), passes);
+});
+
+export { Effects, isWebGL2Available };

package/core/Environment.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),n=require("react"),t=require("@react-three/fiber"),r=require("three"),o=require("three-stdlib"),u=require("./useEnvironment.cjs.js");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function i(e){if(e&&e.__esModule)return e;var n=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var r=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(n,t,r.get?r:{enumerable:!0,get:function(){return e[t]}})}})),n.default=e,Object.freeze(n)}require("@monogrid/gainmap-js"),require("../helpers/environment-assets.cjs.js");var s=a(e),c=i(n);function l(e,n,r,o,u={}){var a,i,s,c;u={backgroundBlurriness:0,backgroundIntensity:1,backgroundRotation:[0,0,0],environmentIntensity:1,environmentRotation:[0,0,0],...u};const l=(e=>{return(n=e).current&&n.current.isScene?e.current:e;var n})(n||r),d=l.background,m=l.environment,g={backgroundBlurriness:l.backgroundBlurriness,backgroundIntensity:l.backgroundIntensity,backgroundRotation:null!==(a=null==(i=l.backgroundRotation)||null==i.clone?void 0:i.clone())&&void 0!==a?a:[0,0,0],environmentIntensity:l.environmentIntensity,environmentRotation:null!==(s=null==(c=l.environmentRotation)||null==c.clone?void 0:c.clone())&&void 0!==s?s:[0,0,0]};return"only"!==e&&(l.environment=o),e&&(l.background=o),t.applyProps(l,u),()=>{"only"!==e&&(l.environment=m),e&&(l.background=d),t.applyProps(l,g)}}function d({scene:e,background:n=!1,map:r,...o}){const u=t.useThree((e=>e.scene));return c.useLayoutEffect((()=>{if(r)return l(n,e,u,r,o)})),null}function m({background:e=!1,scene:n,blur:r,backgroundBlurriness:o,backgroundIntensity:a,backgroundRotation:i,environmentIntensity:s,environmentRotation:d,...m}){const g=u.useEnvironment(m),b=t.useThree((e=>e.scene));return c.useLayoutEffect((()=>l(e,n,b,g,{backgroundBlurriness:null!=r?r:o,backgroundIntensity:a,backgroundRotation:i,environmentIntensity:s,environmentRotation:d}))),c.useEffect((()=>()=>{g.dispose()}),[g]),null}function g({children:e,near:n=.1,far:o=1e3,resolution:u=256,frames:a=1,map:i,background:s=!1,blur:g,backgroundBlurriness:b,backgroundIntensity:f,backgroundRotation:v,environmentIntensity:p,environmentRotation:k,scene:E,files:y,path:h,preset:I,extensions:R}){const j=t.useThree((e=>e.gl)),x=t.useThree((e=>e.scene)),P=c.useRef(null),[C]=c.useState((()=>new r.Scene)),q=c.useMemo((()=>{const e=new r.WebGLCubeRenderTarget(u);return e.texture.type=r.HalfFloatType,e}),[u]);c.useEffect((()=>()=>{q.dispose()}),[q]),c.useLayoutEffect((()=>{if(1===a){const e=j.autoClear;j.autoClear=!0,P.current.update(j,C),j.autoClear=e}return l(s,E,x,q.texture,{backgroundBlurriness:null!=g?g:b,backgroundIntensity:f,backgroundRotation:v,environmentIntensity:p,environmentRotation:k})}),[e,C,q.texture,E,x,s,a,j]);let B=1;return t.useFrame((()=>{if(a===1/0||B<a){const e=j.autoClear;j.autoClear=!0,P.current.update(j,C),j.autoClear=e,B++}})),c.createElement(c.Fragment,null,t.createPortal(c.createElement(c.Fragment,null,e,c.createElement("cubeCamera",{ref:P,args:[n,o,q]}),y||I?c.createElement(m,{background:!0,files:y,preset:I,path:h,extensions:R}):i?c.createElement(d,{background:!0,map:i,extensions:R}):null),C))}function b(e){var n,r,a,i;const l=u.useEnvironment(e),m=e.map||l;c.useMemo((()=>t.extend({GroundProjectedEnvImpl:o.GroundProjectedEnv})),[]),c.useEffect((()=>()=>{l.dispose()}),[l]);const g=c.useMemo((()=>[m]),[m]),b=null==(n=e.ground)?void 0:n.height,f=null==(r=e.ground)?void 0:r.radius,v=null!==(a=null==(i=e.ground)?void 0:i.scale)&&void 0!==a?a:1e3;return c.createElement(c.Fragment,null,c.createElement(d,s.default({},e,{map:m})),c.createElement("groundProjectedEnvImpl",{args:g,scale:v,height:b,radius:f}))}exports.Environment=function(e){return e.ground?c.createElement(b,e):e.map?c.createElement(d,e):e.children?c.createElement(g,e):c.createElement(m,e)},exports.EnvironmentCube=m,exports.EnvironmentMap=d,exports.EnvironmentPortal=g;

package/core/Environment.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { Euler, ThreeElement } from '@react-three/fiber';
+import { Texture, Scene } from 'three';
+import { GroundProjectedEnv as GroundProjectedEnvImpl } from 'three-stdlib';
+import { PresetsType } from '../helpers/environment-assets';
+import { EnvironmentLoaderProps } from './useEnvironment';
+export type EnvironmentProps = {
+    children?: React.ReactNode;
+    frames?: number;
+    near?: number;
+    far?: number;
+    resolution?: number;
+    background?: boolean | 'only';
+    blur?: number;
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    backgroundRotation?: Euler;
+    environmentIntensity?: number;
+    environmentRotation?: Euler;
+    map?: Texture;
+    preset?: PresetsType;
+    scene?: Scene | React.RefObject<Scene>;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    };
+} & EnvironmentLoaderProps;
+export declare function EnvironmentMap({ scene, background, map, ...config }: EnvironmentProps): null;
+export declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, ...rest }: EnvironmentProps): null;
+export declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): React.JSX.Element;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        groundProjectedEnvImpl: ThreeElement<typeof GroundProjectedEnvImpl>;
+    }
+}
+export declare function Environment(props: EnvironmentProps): React.JSX.Element;