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

package/core/AccumulativeShadows.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),t=require("three"),r=require("react"),a=require("@react-three/fiber"),i=require("./shaderMaterial.cjs.js"),s=require("../materials/DiscardMaterial.cjs.js"),n=require("../helpers/constants.cjs.js");function o(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function l(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var a=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var h=o(e),c=l(t),u=l(r);const d=u.createContext(null),p=i.shaderMaterial({color:new c.Color,blend:2,alphaTest:.75,opacity:0,map:null},"varying vec2 vUv;\n   void main() {\n     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);\n     vUv = uv;\n   }",`varying vec2 vUv;\n   uniform sampler2D map;\n   uniform vec3 color;\n   uniform float opacity;\n   uniform float alphaTest;\n   uniform float blend;\n   void main() {\n     vec4 sampledDiffuseColor = texture2D(map, vUv);\n     gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);\n     #include <tonemapping_fragment>\n     #include <${n.version>=154?"colorspace_fragment":"encodings_fragment"}>\n   }`),f=u.forwardRef((({children:e,temporal:t,frames:r=40,limit:i=1/0,blend:s=20,scale:n=10,opacity:o=1,alphaTest:l=.75,color:h="black",colorBlend:c=2,resolution:f=1024,toneMapped:g=!0,...v},M)=>{a.extend({SoftShadowMaterial:p});const b=a.useThree((e=>e.gl)),w=a.useThree((e=>e.scene)),y=a.useThree((e=>e.camera)),x=a.useThree((e=>e.invalidate)),C=u.useRef(null),S=u.useRef(null),[j]=u.useState((()=>new m(b,w,f)));u.useLayoutEffect((()=>{j.configure(C.current)}),[]);const T=u.useMemo((()=>({lights:new Map,temporal:!!t,frames:Math.max(2,r),blend:Math.max(2,r===1/0?s:r),count:0,getMesh:()=>C.current,reset:()=>{j.clear();const e=C.current.material;e.opacity=0,e.alphaTest=0,T.count=0},update:(e=1)=>{const t=C.current.material;T.temporal?(t.opacity=Math.min(o,t.opacity+o/T.blend),t.alphaTest=Math.min(l,t.alphaTest+l/T.blend)):(t.opacity=o,t.alphaTest=l),S.current.visible=!0,j.prepare();for(let t=0;t<e;t++)T.lights.forEach((e=>e.update())),j.update(y,T.blend);S.current.visible=!1,j.finish()}})),[j,y,w,t,r,s,o,l]);return u.useLayoutEffect((()=>{T.reset(),T.temporal||T.frames===1/0||T.update(T.blend)})),u.useImperativeHandle(M,(()=>T),[T]),a.useFrame((()=>{(T.temporal||T.frames===1/0)&&T.count<T.frames&&T.count<i&&(x(),T.update(),T.count++)})),u.createElement("group",v,u.createElement("group",{traverse:()=>null,ref:S},u.createElement(d.Provider,{value:T},e)),u.createElement("mesh",{receiveShadow:!0,ref:C,scale:n,rotation:[-Math.PI/2,0,0]},u.createElement("planeGeometry",null),u.createElement("softShadowMaterial",{transparent:!0,depthWrite:!1,toneMapped:g,color:h,blend:c,map:j.progressiveLightMap2.texture})))})),g=u.forwardRef((({castShadow:e=!0,bias:t=.001,mapSize:r=512,size:a=5,near:i=.5,far:s=500,frames:o=1,position:l=[0,0,0],radius:p=1,amount:f=8,intensity:g=(n.version>=155?Math.PI:1),ambient:m=.5,...v},M)=>{const b=u.useRef(null),w=new c.Vector3(...l).length(),y=u.useContext(d),x=u.useCallback((()=>{let e;if(b.current)for(let t=0;t<b.current.children.length;t++)if(e=b.current.children[t],Math.random()>m)e.position.set(l[0]+c.MathUtils.randFloatSpread(p),l[1]+c.MathUtils.randFloatSpread(p),l[2]+c.MathUtils.randFloatSpread(p));else{let t=Math.acos(2*Math.random()-1)-Math.PI/2,r=2*Math.PI*Math.random();e.position.set(Math.cos(t)*Math.cos(r)*w,Math.abs(Math.cos(t)*Math.sin(r)*w),Math.sin(t)*w)}}),[p,m,w,...l]),C=u.useMemo((()=>({update:x})),[x]);return u.useImperativeHandle(M,(()=>C),[C]),u.useLayoutEffect((()=>{var e;const t=b.current;return y&&(null==(e=y.lights)||e.set(t.uuid,C)),()=>{var e;null==y||null==(e=y.lights)||e.delete(t.uuid)}}),[y,C]),u.createElement("group",h.default({ref:b},v),Array.from({length:f},((n,o)=>u.createElement("directionalLight",{key:o,castShadow:e,"shadow-bias":t,"shadow-mapSize":[r,r],intensity:g/f},u.createElement("orthographicCamera",{attach:"shadow-camera",args:[-a,a,a,-a,i,s]})))))}));class m{constructor(e,t,r=1024){this.renderer=e,this.res=r,this.scene=t,this.buffer1Active=!1,this.lights=[],this.meshes=[],this.object=null,this.clearColor=new c.Color,this.clearAlpha=0;const a={type:c.HalfFloatType,magFilter:c.NearestFilter,minFilter:c.NearestFilter};this.progressiveLightMap1=new c.WebGLRenderTarget(this.res,this.res,a),this.progressiveLightMap2=new c.WebGLRenderTarget(this.res,this.res,a),this.discardMat=new s.DiscardMaterial,this.targetMat=new c.MeshLambertMaterial({fog:!1}),this.previousShadowMap={value:this.progressiveLightMap1.texture},this.averagingWindow={value:100},this.targetMat.onBeforeCompile=e=>{e.vertexShader="varying vec2 vUv;\n"+e.vertexShader.slice(0,-1)+"vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }";const t=e.fragmentShader.indexOf("void main() {");e.fragmentShader="varying vec2 vUv;\n"+e.fragmentShader.slice(0,t)+"uniform sampler2D previousShadowMap;\n\tuniform float averagingWindow;\n"+e.fragmentShader.slice(t-1,-1)+"\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;\n        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);\n      }",e.uniforms.previousShadowMap=this.previousShadowMap,e.uniforms.averagingWindow=this.averagingWindow}}clear(){this.renderer.getClearColor(this.clearColor),this.clearAlpha=this.renderer.getClearAlpha(),this.renderer.setClearColor("black",1),this.renderer.setRenderTarget(this.progressiveLightMap1),this.renderer.clear(),this.renderer.setRenderTarget(this.progressiveLightMap2),this.renderer.clear(),this.renderer.setRenderTarget(null),this.renderer.setClearColor(this.clearColor,this.clearAlpha),this.lights=[],this.meshes=[],this.scene.traverse((e=>{!function(e){return!!e.geometry}(e)?function(e){return e.isLight}(e)&&this.lights.push({object:e,intensity:e.intensity}):this.meshes.push({object:e,material:e.material})}))}prepare(){this.lights.forEach((e=>e.object.intensity=0)),this.meshes.forEach((e=>e.object.material=this.discardMat))}finish(){this.lights.forEach((e=>e.object.intensity=e.intensity)),this.meshes.forEach((e=>e.object.material=e.material))}configure(e){this.object=e}update(e,t=100){if(!this.object)return;this.averagingWindow.value=t,this.object.material=this.targetMat;const r=this.buffer1Active?this.progressiveLightMap1:this.progressiveLightMap2,a=this.buffer1Active?this.progressiveLightMap2:this.progressiveLightMap1,i=this.scene.background;this.scene.background=null,this.renderer.setRenderTarget(r),this.previousShadowMap.value=a.texture,this.buffer1Active=!this.buffer1Active,this.renderer.render(this.scene,e),this.renderer.setRenderTarget(null),this.scene.background=i}}exports.AccumulativeShadows=f,exports.RandomizedLight=g,exports.accumulativeContext=d;

package/core/AccumulativeShadows.d.ts

@@ -0,0 +1,59 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { ReactThreeFiber, ThreeElements } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type AccumulativeShadowsProps = Omit<ThreeElements['group'], 'ref'> & {
+    frames?: number;
+    blend?: number;
+    limit?: number;
+    scale?: number;
+    temporal?: boolean;
+    opacity?: number;
+    alphaTest?: number;
+    color?: string;
+    colorBlend?: number;
+    resolution?: number;
+    toneMapped?: boolean;
+};
+interface AccumulativeContext {
+    lights: Map<any, any>;
+    temporal: boolean;
+    frames: number;
+    blend: number;
+    count: number;
+    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialProps & THREE.ShaderMaterial>;
+    reset: () => void;
+    update: (frames?: number) => void;
+}
+interface AccumulativeLightContext {
+    update: () => void;
+}
+type SoftShadowMaterialProps = {
+    map: THREE.Texture;
+    color?: ReactThreeFiber.Color;
+    alphaTest?: number;
+    blend?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+    }
+}
+export declare const accumulativeContext: React.Context<AccumulativeContext>;
+export declare const AccumulativeShadows: ForwardRefComponent<AccumulativeShadowsProps, AccumulativeContext>;
+export type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
+    frames?: number;
+    position?: [x: number, y: number, z: number];
+    radius?: number;
+    amount?: number;
+    intensity?: number;
+    ambient?: number;
+    castShadow?: boolean;
+    bias?: number;
+    mapSize?: number;
+    size?: number;
+    near?: number;
+    far?: number;
+};
+export declare const RandomizedLight: ForwardRefComponent<RandomizedLightProps, AccumulativeLightContext>;
+export {};

package/core/AccumulativeShadows.js

@@ -0,0 +1,310 @@
+import _extends from '@babel/runtime/helpers/esm/extends';
+import * as THREE from 'three';
+import * as React from 'react';
+import { extend, useThree, useFrame } from '@react-three/fiber';
+import { shaderMaterial } from './shaderMaterial.js';
+import { DiscardMaterial } from '../materials/DiscardMaterial.js';
+import { version } from '../helpers/constants.js';
+
+function isLight(object) {
+  return object.isLight;
+}
+function isGeometry(object) {
+  return !!object.geometry;
+}
+const accumulativeContext = /* @__PURE__ */React.createContext(null);
+const SoftShadowMaterial = /* @__PURE__ */shaderMaterial({
+  color: /* @__PURE__ */new THREE.Color(),
+  blend: 2.0,
+  alphaTest: 0.75,
+  opacity: 0,
+  map: null
+}, `varying vec2 vUv;
+   void main() {
+     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+     vUv = uv;
+   }`, `varying vec2 vUv;
+   uniform sampler2D map;
+   uniform vec3 color;
+   uniform float opacity;
+   uniform float alphaTest;
+   uniform float blend;
+   void main() {
+     vec4 sampledDiffuseColor = texture2D(map, vUv);
+     gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);
+     #include <tonemapping_fragment>
+     #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+   }`);
+const AccumulativeShadows = /* @__PURE__ */React.forwardRef(({
+  children,
+  temporal,
+  frames = 40,
+  limit = Infinity,
+  blend = 20,
+  scale = 10,
+  opacity = 1,
+  alphaTest = 0.75,
+  color = 'black',
+  colorBlend = 2,
+  resolution = 1024,
+  toneMapped = true,
+  ...props
+}, forwardRef) => {
+  extend({
+    SoftShadowMaterial
+  });
+  const gl = useThree(state => state.gl);
+  const scene = useThree(state => state.scene);
+  const camera = useThree(state => state.camera);
+  const invalidate = useThree(state => state.invalidate);
+  const gPlane = React.useRef(null);
+  const gLights = React.useRef(null);
+  const [plm] = React.useState(() => new ProgressiveLightMap(gl, scene, resolution));
+  React.useLayoutEffect(() => {
+    plm.configure(gPlane.current);
+  }, []);
+  const api = React.useMemo(() => ({
+    lights: new Map(),
+    temporal: !!temporal,
+    frames: Math.max(2, frames),
+    blend: Math.max(2, frames === Infinity ? blend : frames),
+    count: 0,
+    getMesh: () => gPlane.current,
+    reset: () => {
+      // Clear buffers, reset opacities, set frame count to 0
+      plm.clear();
+      const material = gPlane.current.material;
+      material.opacity = 0;
+      material.alphaTest = 0;
+      api.count = 0;
+    },
+    update: (frames = 1) => {
+      // Adapt the opacity-blend ratio to the number of frames
+      const material = gPlane.current.material;
+      if (!api.temporal) {
+        material.opacity = opacity;
+        material.alphaTest = alphaTest;
+      } else {
+        material.opacity = Math.min(opacity, material.opacity + opacity / api.blend);
+        material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / api.blend);
+      }
+
+      // Switch accumulative lights on
+      gLights.current.visible = true;
+      // Collect scene lights and meshes
+      plm.prepare();
+
+      // Update the lightmap and the accumulative lights
+      for (let i = 0; i < frames; i++) {
+        api.lights.forEach(light => light.update());
+        plm.update(camera, api.blend);
+      }
+      // Switch lights off
+      gLights.current.visible = false;
+      // Restore lights and meshes
+      plm.finish();
+    }
+  }), [plm, camera, scene, temporal, frames, blend, opacity, alphaTest]);
+  React.useLayoutEffect(() => {
+    // Reset internals, buffers, ...
+    api.reset();
+    // Update lightmap
+    if (!api.temporal && api.frames !== Infinity) api.update(api.blend);
+  });
+
+  // Expose api, allow children to set itself as the main light source
+  React.useImperativeHandle(forwardRef, () => api, [api]);
+  useFrame(() => {
+    if ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {
+      invalidate();
+      api.update();
+      api.count++;
+    }
+  });
+  return /*#__PURE__*/React.createElement("group", props, /*#__PURE__*/React.createElement("group", {
+    traverse: () => null,
+    ref: gLights
+  }, /*#__PURE__*/React.createElement(accumulativeContext.Provider, {
+    value: api
+  }, children)), /*#__PURE__*/React.createElement("mesh", {
+    receiveShadow: true,
+    ref: gPlane,
+    scale: scale,
+    rotation: [-Math.PI / 2, 0, 0]
+  }, /*#__PURE__*/React.createElement("planeGeometry", null), /*#__PURE__*/React.createElement("softShadowMaterial", {
+    transparent: true,
+    depthWrite: false,
+    toneMapped: toneMapped,
+    color: color,
+    blend: colorBlend,
+    map: plm.progressiveLightMap2.texture
+  })));
+});
+const RandomizedLight = /* @__PURE__ */React.forwardRef(({
+  castShadow = true,
+  bias = 0.001,
+  mapSize = 512,
+  size = 5,
+  near = 0.5,
+  far = 500,
+  frames = 1,
+  position = [0, 0, 0],
+  radius = 1,
+  amount = 8,
+  intensity = version >= 155 ? Math.PI : 1,
+  ambient = 0.5,
+  ...props
+}, forwardRef) => {
+  const gLights = React.useRef(null);
+  const length = new THREE.Vector3(...position).length();
+  const parent = React.useContext(accumulativeContext);
+  const update = React.useCallback(() => {
+    let light;
+    if (gLights.current) {
+      for (let l = 0; l < gLights.current.children.length; l++) {
+        light = gLights.current.children[l];
+        if (Math.random() > ambient) {
+          light.position.set(position[0] + THREE.MathUtils.randFloatSpread(radius), position[1] + THREE.MathUtils.randFloatSpread(radius), position[2] + THREE.MathUtils.randFloatSpread(radius));
+        } else {
+          let lambda = Math.acos(2 * Math.random() - 1) - Math.PI / 2.0;
+          let phi = 2 * Math.PI * Math.random();
+          light.position.set(Math.cos(lambda) * Math.cos(phi) * length, Math.abs(Math.cos(lambda) * Math.sin(phi) * length), Math.sin(lambda) * length);
+        }
+      }
+    }
+  }, [radius, ambient, length, ...position]);
+  const api = React.useMemo(() => ({
+    update
+  }), [update]);
+  React.useImperativeHandle(forwardRef, () => api, [api]);
+  React.useLayoutEffect(() => {
+    var _parent$lights;
+    const group = gLights.current;
+    if (parent) (_parent$lights = parent.lights) == null || _parent$lights.set(group.uuid, api);
+    return () => {
+      var _parent$lights2;
+      return void (parent == null || (_parent$lights2 = parent.lights) == null ? void 0 : _parent$lights2.delete(group.uuid));
+    };
+  }, [parent, api]);
+  return /*#__PURE__*/React.createElement("group", _extends({
+    ref: gLights
+  }, props), Array.from({
+    length: amount
+  }, (_, index) => /*#__PURE__*/React.createElement("directionalLight", {
+    key: index,
+    castShadow: castShadow,
+    "shadow-bias": bias,
+    "shadow-mapSize": [mapSize, mapSize],
+    intensity: intensity / amount
+  }, /*#__PURE__*/React.createElement("orthographicCamera", {
+    attach: "shadow-camera",
+    args: [-size, size, size, -size, near, far]
+  }))));
+});
+
+// Based on "Progressive Light Map Accumulator", by [zalo](https://github.com/zalo/)
+class ProgressiveLightMap {
+  constructor(renderer, scene, res = 1024) {
+    this.renderer = renderer;
+    this.res = res;
+    this.scene = scene;
+    this.buffer1Active = false;
+    this.lights = [];
+    this.meshes = [];
+    this.object = null;
+    this.clearColor = new THREE.Color();
+    this.clearAlpha = 0;
+
+    // Create the Progressive LightMap Texture
+    const textureParams = {
+      type: THREE.HalfFloatType,
+      magFilter: THREE.NearestFilter,
+      minFilter: THREE.NearestFilter
+    };
+    this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, textureParams);
+    this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, textureParams);
+
+    // Inject some spicy new logic into a standard phong material
+    this.discardMat = new DiscardMaterial();
+    this.targetMat = new THREE.MeshLambertMaterial({
+      fog: false
+    });
+    this.previousShadowMap = {
+      value: this.progressiveLightMap1.texture
+    };
+    this.averagingWindow = {
+      value: 100
+    };
+    this.targetMat.onBeforeCompile = shader => {
+      // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
+      shader.vertexShader = 'varying vec2 vUv;\n' + shader.vertexShader.slice(0, -1) + 'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';
+
+      // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
+      const bodyStart = shader.fragmentShader.indexOf('void main() {');
+      shader.fragmentShader = 'varying vec2 vUv;\n' + shader.fragmentShader.slice(0, bodyStart) + 'uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' + shader.fragmentShader.slice(bodyStart - 1, -1) + `\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;
+        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);
+      }`;
+
+      // Set the Previous Frame's Texture Buffer and Averaging Window
+      shader.uniforms.previousShadowMap = this.previousShadowMap;
+      shader.uniforms.averagingWindow = this.averagingWindow;
+    };
+  }
+  clear() {
+    this.renderer.getClearColor(this.clearColor);
+    this.clearAlpha = this.renderer.getClearAlpha();
+    this.renderer.setClearColor('black', 1);
+    this.renderer.setRenderTarget(this.progressiveLightMap1);
+    this.renderer.clear();
+    this.renderer.setRenderTarget(this.progressiveLightMap2);
+    this.renderer.clear();
+    this.renderer.setRenderTarget(null);
+    this.renderer.setClearColor(this.clearColor, this.clearAlpha);
+    this.lights = [];
+    this.meshes = [];
+    this.scene.traverse(object => {
+      if (isGeometry(object)) {
+        this.meshes.push({
+          object,
+          material: object.material
+        });
+      } else if (isLight(object)) {
+        this.lights.push({
+          object,
+          intensity: object.intensity
+        });
+      }
+    });
+  }
+  prepare() {
+    this.lights.forEach(light => light.object.intensity = 0);
+    this.meshes.forEach(mesh => mesh.object.material = this.discardMat);
+  }
+  finish() {
+    this.lights.forEach(light => light.object.intensity = light.intensity);
+    this.meshes.forEach(mesh => mesh.object.material = mesh.material);
+  }
+  configure(object) {
+    this.object = object;
+  }
+  update(camera, blendWindow = 100) {
+    if (!this.object) return;
+    // Set each object's material to the UV Unwrapped Surface Mapping Version
+    this.averagingWindow.value = blendWindow;
+    this.object.material = this.targetMat;
+    // Ping-pong two surface buffers for reading/writing
+    const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+    const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
+    // Render the object's surface maps
+    const oldBg = this.scene.background;
+    this.scene.background = null;
+    this.renderer.setRenderTarget(activeMap);
+    this.previousShadowMap.value = inactiveMap.texture;
+    this.buffer1Active = !this.buffer1Active;
+    this.renderer.render(this.scene, camera);
+    this.renderer.setRenderTarget(null);
+    this.scene.background = oldBg;
+  }
+}
+
+export { AccumulativeShadows, RandomizedLight, accumulativeContext };

package/core/AdaptiveDpr.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("@react-three/fiber");function t(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 n=t(e);exports.AdaptiveDpr=function({pixelated:e}){const t=r.useThree((e=>e.gl)),u=r.useThree((e=>e.internal.active)),i=r.useThree((e=>e.performance.current)),a=r.useThree((e=>e.viewport.initialDpr)),c=r.useThree((e=>e.setDpr));return n.useEffect((()=>{const r=t.domElement;return()=>{u&&c(a),e&&r&&(r.style.imageRendering="auto")}}),[]),n.useEffect((()=>{c(i*a),e&&t.domElement&&(t.domElement.style.imageRendering=1===i?"auto":"pixelated")}),[i]),null};

package/core/AdaptiveDpr.d.ts

@@ -0,0 +1,3 @@
+export declare function AdaptiveDpr({ pixelated }: {
+    pixelated?: boolean;
+}): null;

package/core/AdaptiveDpr.js

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { useThree } from '@react-three/fiber';
+
+function AdaptiveDpr({
+  pixelated
+}) {
+  const gl = useThree(state => state.gl);
+  const active = useThree(state => state.internal.active);
+  const current = useThree(state => state.performance.current);
+  const initialDpr = useThree(state => state.viewport.initialDpr);
+  const setDpr = useThree(state => state.setDpr);
+  // Restore initial pixelratio on unmount
+  React.useEffect(() => {
+    const domElement = gl.domElement;
+    return () => {
+      if (active) setDpr(initialDpr);
+      if (pixelated && domElement) domElement.style.imageRendering = 'auto';
+    };
+  }, []);
+  // Set adaptive pixelratio
+  React.useEffect(() => {
+    setDpr(current * initialDpr);
+    if (pixelated && gl.domElement) gl.domElement.style.imageRendering = current === 1 ? 'auto' : 'pixelated';
+  }, [current]);
+  return null;
+}
+
+export { AdaptiveDpr };

package/core/AdaptiveEvents.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("@react-three/fiber");function t(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 n=t(e);exports.AdaptiveEvents=function(){const e=r.useThree((e=>e.get)),t=r.useThree((e=>e.setEvents)),u=r.useThree((e=>e.performance.current));return n.useEffect((()=>{const r=e().events.enabled;return()=>t({enabled:r})}),[]),n.useEffect((()=>t({enabled:1===u})),[u]),null};

package/core/AdaptiveEvents.d.ts

@@ -0,0 +1 @@
+export declare function AdaptiveEvents(): null;

package/core/AdaptiveEvents.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { useThree } from '@react-three/fiber';
+
+function AdaptiveEvents() {
+  const get = useThree(state => state.get);
+  const setEvents = useThree(state => state.setEvents);
+  const current = useThree(state => state.performance.current);
+  React.useEffect(() => {
+    const enabled = get().events.enabled;
+    return () => setEvents({
+      enabled
+    });
+  }, []);
+  React.useEffect(() => setEvents({
+    enabled: current === 1
+  }), [current]);
+  return null;
+}
+
+export { AdaptiveEvents };

package/core/ArcballControls.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("@react-three/fiber"),t=require("react"),n=require("three-stdlib");function s(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 a=s(e),u=o(t);const c=t.forwardRef((({camera:e,makeDefault:s,regress:o,domElement:c,onChange:i,onStart:l,onEnd:f,...d},m)=>{const v=r.useThree((e=>e.invalidate)),b=r.useThree((e=>e.camera)),h=r.useThree((e=>e.gl)),E=r.useThree((e=>e.events)),p=r.useThree((e=>e.set)),g=r.useThree((e=>e.get)),j=r.useThree((e=>e.performance)),O=e||b,T=c||E.connected||h.domElement,L=t.useMemo((()=>new n.ArcballControls(O)),[O]);return r.useFrame((()=>{L.enabled&&L.update()}),-1),t.useEffect((()=>(L.connect(T),()=>{L.dispose()})),[T,o,L,v]),t.useEffect((()=>{const e=e=>{v(),o&&j.regress(),i&&i(e)};return L.addEventListener("change",e),l&&L.addEventListener("start",l),f&&L.addEventListener("end",f),()=>{L.removeEventListener("change",e),l&&L.removeEventListener("start",l),f&&L.removeEventListener("end",f)}}),[i,l,f]),t.useEffect((()=>{if(s){const e=g().controls;return p({controls:L}),()=>p({controls:e})}}),[s,L]),u.createElement("primitive",a.default({ref:m,object:L},d))}));exports.ArcballControls=c;

package/core/ArcballControls.d.ts

@@ -0,0 +1,15 @@
+import { ReactThreeFiber, ThreeElement } from '@react-three/fiber';
+import { ArcballControls as ArcballControlsImpl } from 'three-stdlib';
+import type { Event, OrthographicCamera, PerspectiveCamera } from 'three';
+import { ForwardRefComponent, Overwrite } from '../helpers/ts-utils';
+export type ArcballControlsProps = Omit<Overwrite<ThreeElement<typeof ArcballControlsImpl>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: OrthographicCamera | PerspectiveCamera;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: Event) => void;
+    onStart?: (e?: Event) => void;
+    onEnd?: (e?: Event) => void;
+}>, 'ref' | 'args'>;
+export declare const ArcballControls: ForwardRefComponent<ArcballControlsProps, ArcballControlsImpl>;

package/core/ArcballControls.js

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

package/core/AsciiRenderer.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-stdlib");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 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 n=o(e);exports.AsciiRenderer=function({renderIndex:e=1,bgColor:o="black",fgColor:l="white",characters:c=" .:-+*=%@#",invert:s=!0,color:i=!1,resolution:u=.15}){const{size:m,gl:d,scene:a,camera:f}=t.useThree(),E=n.useMemo((()=>{const e=new r.AsciiEffect(d,c,{invert:s,color:i,resolution:u});return e.domElement.style.position="absolute",e.domElement.style.top="0px",e.domElement.style.left="0px",e.domElement.style.pointerEvents="none",e}),[c,s,i,u]);return n.useLayoutEffect((()=>{E.domElement.style.color=l,E.domElement.style.backgroundColor=o}),[l,o]),n.useEffect((()=>(d.domElement.style.opacity="0",d.domElement.parentNode.appendChild(E.domElement),()=>{d.domElement.style.opacity="1",d.domElement.parentNode.removeChild(E.domElement)})),[E]),n.useEffect((()=>{E.setSize(m.width,m.height)}),[E,m]),t.useFrame((e=>{E.render(a,f)}),e),n.createElement(n.Fragment,null)};

package/core/AsciiRenderer.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export type AsciiRendererProps = {
+    renderIndex?: number;
+    bgColor?: string;
+    fgColor?: string;
+    characters?: string;
+    invert?: boolean;
+    color?: boolean;
+    resolution?: number;
+};
+export declare function AsciiRenderer({ renderIndex, bgColor, fgColor, characters, invert, color, resolution, }: AsciiRendererProps): React.JSX.Element;

package/core/AsciiRenderer.js

@@ -0,0 +1,66 @@
+import * as React from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import { AsciiEffect } from 'three-stdlib';
+
+function AsciiRenderer({
+  renderIndex = 1,
+  bgColor = 'black',
+  fgColor = 'white',
+  characters = ' .:-+*=%@#',
+  invert = true,
+  color = false,
+  resolution = 0.15
+}) {
+  // Reactive state
+  const {
+    size,
+    gl,
+    scene,
+    camera
+  } = useThree();
+
+  // Create effect
+  const effect = React.useMemo(() => {
+    const effect = new AsciiEffect(gl, characters, {
+      invert,
+      color,
+      resolution
+    });
+    effect.domElement.style.position = 'absolute';
+    effect.domElement.style.top = '0px';
+    effect.domElement.style.left = '0px';
+    effect.domElement.style.pointerEvents = 'none';
+    return effect;
+  }, [characters, invert, color, resolution]);
+
+  // Styling
+  React.useLayoutEffect(() => {
+    effect.domElement.style.color = fgColor;
+    effect.domElement.style.backgroundColor = bgColor;
+  }, [fgColor, bgColor]);
+
+  // Append on mount, remove on unmount
+  React.useEffect(() => {
+    gl.domElement.style.opacity = '0';
+    gl.domElement.parentNode.appendChild(effect.domElement);
+    return () => {
+      gl.domElement.style.opacity = '1';
+      gl.domElement.parentNode.removeChild(effect.domElement);
+    };
+  }, [effect]);
+
+  // Set size
+  React.useEffect(() => {
+    effect.setSize(size.width, size.height);
+  }, [effect, size]);
+
+  // Take over render-loop (that is what the index is for)
+  useFrame(state => {
+    effect.render(scene, camera);
+  }, renderIndex);
+
+  // return something to not break type signatures
+  return /*#__PURE__*/React.createElement(React.Fragment, null);
+}
+
+export { AsciiRenderer };

package/core/BBAnchor.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("@react-three/fiber");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function c(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 a=u(e),o=c(r),i=c(t);const s=new i.Box3,f=new i.Vector3;exports.BBAnchor=({anchor:e,...r})=>{const t=o.useRef(null),u=o.useRef(null);return o.useEffect((()=>{var e;null!=(e=t.current)&&null!=(e=e.parent)&&e.parent&&(u.current=t.current.parent,t.current.parent.parent.add(t.current))}),[]),n.useFrame((()=>{u.current&&(s.setFromObject(u.current),s.getSize(f),t.current.position.set(u.current.position.x+f.x*(Array.isArray(e)?e[0]:e.x)/2,u.current.position.y+f.y*(Array.isArray(e)?e[1]:e.y)/2,u.current.position.z+f.z*(Array.isArray(e)?e[2]:e.z)/2))})),o.createElement("group",a.default({ref:t},r))};

package/core/BBAnchor.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { ThreeElements } from '@react-three/fiber';
+export type BBAnchorProps = ThreeElements['group'] & {
+    anchor: THREE.Vector3 | [number, number, number];
+};
+export declare const BBAnchor: ({ anchor, ...props }: BBAnchorProps) => React.JSX.Element;