@react-three/drei 9.19.5 → 9.20.0

package/README.md

@@ -73,6 +73,7 @@ The `native` route of the library **does not** export `Html` or `Loader`. The de
           <li><a href="#clone">Clone</a></li>
           <li><a href="#useanimations">useAnimations</a></li>
           <li><a href="#marchingcubes">MarchingCubes</a></li>
+          <li><a href="#decal">Decal</a></li>
         </ul>
         <li><a href="#shaders">Shaders</a></li>
         <ul>
@@ -108,6 +109,7 @@ The `native` route of the library **does not** export `Html` or `Loader`. The de
           <li><a href="#useintersect">useIntersect</a></li>
           <li><a href="#useboxprojectedenv">useBoxProjectedEnv</a></li>
           <li><a href="#useTrail">useTrail</a></li>
+          <li><a href="#useSurfaceSampler">useSurfaceSampler</a></li>
           <li><a href="#BBAnchor">BBAnchor</a></li>
         </ul>
         <li><a href="#loading">Loaders</a></li>
@@ -767,6 +769,7 @@ You can either pass a Mesh and InstancedMesh as children:
 <Sampler
   weight={"normal"} // the name of the attribute to be used as sampling weight
   transform={transformPoint} // a function that transforms each instance given a sample. See the examples for more.
+  count={16} // Number of samples
 >
   <mesh>
     <sphereGeometry args={[2]} />
@@ -912,6 +915,37 @@ An abstraction for threes [MarchingCubes](https://threejs.org/examples/#webgl_ma
 </MarchingCubes>
 ```
 
+#### Decal
+
+[![](https://img.shields.io/badge/-storybook-%23ff69b4)](https://drei.pmnd.rs/?path=/story/misc-decal--decal-st)
+
+Abstraction around Three's `DecalGeometry`. It will use the its parent `mesh` as the decal surface by default.
+
+```js
+<mesh>
+  <sphereGeometry />
+  <meshBasicMaterial />
+
+  <Decal
+    debug={undefined} // Makes "bounding box" of the decal visible
+    position={[0, 0, 0]} // Position of the decal
+    rotation={[0, 0, 0]} // Rotation of the decal
+    scale={[1, 1, 1]} // Scale of the decal
+  >
+    // Include your decal material here
+    <meshBasicMaterial alpaMap={map} />
+  </Decal>
+</mesh>
+```
+
+If declarative composition is not possible, use the `mesh` prop to define the surface the decal must attach to.
+
+```js
+<Decal mesh={ref}>
+  <meshBasicMaterial alpaMap={map} />
+</Decal>
+```
+
 # Shaders
 
 #### MeshReflectorMaterial
@@ -1423,6 +1457,22 @@ useFrame(() => {
 })
 ```
 
+#### useSurfaceSampler
+
+[![](https://img.shields.io/badge/-storybook-%23ff69b4)](https://drei.vercel.app/?path=/story/misc-decal--decal-st)
+
+A hook to obtain the result of the [`<Sampler />`](#sampler) as a buffer. Useful for driving anything other than `InstancedMesh` via the Sampler.
+
+```js
+const buffer = useSurfaceSampler(
+  mesh, // Mesh to sample
+  count, // [Optional] Number of samples (default: 16)
+  transform, // [Optional] Transformation function. Same as in `<Sampler />`
+  weight, // [Optional] Same as in `<Sampler />`
+  instancedMesh // [Optional] Instanced mesh to scatter
+)
+```
+
 #### BBAnchor
 
 [![](https://img.shields.io/badge/-storybook-%23ff69b4)](https://drei.vercel.app/?path=/story/misc-bbanchor--bb-anchor-with-html)
@@ -2177,7 +2227,11 @@ type RandomizedLightProps = JSX.IntrinsicElements['group'] & {
 }
 ```
 
-It exposes its api via reference, where `update` will jiggle the lights.
+```jsx
+<RandomizedLight castShadow amount={8} frames={100} position={[5, 5, -10]} />
+```
+
+#### Refernce api
 
 ```jsx
 interface AccumulativeLightContext {
@@ -2186,17 +2240,13 @@ interface AccumulativeLightContext {
 }
 ```
 
-```jsx
-<RandomizedLight castShadow amount={8} frames={100} position={[5, 5, -10]} />
-```
-
 ###  AccumulativeShadows
 
 <p>
   <a href="https://codesandbox.io/s/hxcc1x"><img width="20%" src="https://codesandbox.io/api/v1/sandboxes/hxcc1x/screenshot.png" alt="Demo"/></a>
 </p>
 
-A planar, Y-up oriented shadow-catcher that can accumulate into soft shadows and has zero performance impact after all frames have accumulated. It can be temporal, it will accumulate over time, or instantaneous, which might expensive depending on how many frames you render.
+A planar, Y-up oriented shadow-catcher that can accumulate into soft shadows and has zero performance impact after all frames have accumulated. It can be temporal, it will accumulate over time, or instantaneous, which might be expensive depending on how many frames you render.
 
 You must pair it with lightsources (and scene objects!) that cast shadows, which go into the children slot. Best use it with the `RandomizedLight` component, which jiggles a set of lights around, creating realistic raycast-like shadows and ambient occlusion.
 
@@ -2223,7 +2273,13 @@ type AccumulativeShadowsProps = JSX.IntrinsicElements['group'] & {
 }
 ```
 
-It exposes its api via reference. Mostly `setLights` is interesting for internal
+```jsx
+<AccumulativeShadows temporal frames={100} scale={10}>
+  <RandomizedLight amount={8} position={[5, 5, -10]} />
+</AccumulativeShadows>
+```
+
+##### Reference api
 
 ```tsx
 interface AccumulativeContext {
@@ -2236,12 +2292,6 @@ interface AccumulativeContext {
 }
 ```
 
-```jsx
-<AccumulativeShadows temporal frames={100} scale={10}>
-  <RandomizedLight castShadow amount={8} position={[5, 5, -10]} />
-</AccumulativeShadows>
-```
-
 #### SpotLight
 
 <p>

package/core/AccumulativeShadows.cjs.js

@@ -1 +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");function i(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}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 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 s=i(e),o=n(t),u=n(r);const l=u.createContext(null),c=u.forwardRef((({children:e,blend:t,frames:r=40,scale:i=10,temporal:n=!1,opacity:s=1,alphaTest:c=.65,color:h="black",resolution:f=1024,...g},p)=>{const m=a.useThree((e=>e.gl)),v=a.useThree((e=>e.scene)),M=a.useThree((e=>e.camera)),b=u.useRef(null),y=u.useRef(null),S=u.useRef(0),[w]=u.useState((()=>new d(m,v,f)));u.useLayoutEffect((()=>{w.configureObject(b.current)}),[]),r<=1&&(r=2);let L=void 0===t&&r===1/0?100:r;const _=u.useMemo((()=>{const e=Object.assign(new o.MeshBasicMaterial({opacity:0,transparent:!0,dithering:!0,depthWrite:!1,map:w.progressiveLightMap2.texture}),{uniforms:{ucolor:{value:new o.Color(h)},alphaTest:{value:0}}});return e.onBeforeCompile=t=>{e.uniforms=t.uniforms={...t.uniforms,...e.uniforms},t.fragmentShader=t.fragmentShader.replace("void main() {","uniform vec3 ucolor;\n           uniform float alphaTest;\n           void main() {"),t.fragmentShader=t.fragmentShader.replace("#include <dithering_fragment>","#include <dithering_fragment>\n           gl_FragColor = vec4(ucolor * gl_FragColor.r * 2.0, max(0.0, (1.0 - gl_FragColor.r / alphaTest)) * opacity);")},e}),[h]),[T,x]=u.useState([]);function E(e=1){n?(_.opacity=Math.min(s,_.opacity+s/L),_.uniforms.alphaTest.value=Math.min(c,_.uniforms.alphaTest.value+c/L)):(_.opacity=s,_.uniforms.alphaTest.value=c),y.current.visible=!0;const t=[];v.traverse((e=>{(function(e){return e.isLight})(e)&&(t.push({object:e,intensity:e.intensity}),e.intensity=0)}));for(let t=0;t<e;t++)w.update(M,L),T&&T.forEach((e=>e.update()));y.current.visible=!1,t.forEach((({object:e,intensity:t})=>e.intensity=t))}function C(){r!==1/0&&(w.clear(),_.opacity=0,_.uniforms.alphaTest.value=0,S.current=0,E())}const A=u.useMemo((()=>({reset:C,update:E,setLights:x})),[]);return u.useImperativeHandle(p,(()=>A),[A]),a.useFrame((()=>{n&&S.current<r&&(E(),S.current++)})),u.useLayoutEffect((()=>{C(),n||E(L)})),u.createElement("group",g,u.createElement("group",{traverse:()=>null,ref:y},u.createElement(l.Provider,{value:A},e)),u.createElement("mesh",{receiveShadow:!0,ref:b,material:_,scale:i,rotation:[-Math.PI/2,0,0]},u.createElement("planeGeometry",null)))})),h=u.forwardRef((({castShadow:e=!0,bias:t=0,mapSize:r=512,size:a=5,near:i=.5,far:n=500,frames:c=1,position:h=[0,0,0],radius:d=1,amount:f=8,intensity:g=1,ambient:p=.5,...m},v)=>{const M=u.useRef(null),b=new o.Vector3(...h).length(),y=u.useContext(l),S=u.useCallback((()=>{let e;if(M.current)for(let t=0;t<M.current.children.length;t++)if(e=M.current.children[t],Math.random()>p)e.position.set(h[0]+o.MathUtils.randFloatSpread(d),h[1]+o.MathUtils.randFloatSpread(d),h[2]+o.MathUtils.randFloatSpread(d));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)*b,Math.abs(Math.cos(t)*Math.sin(r)*b),Math.sin(t)*b)}}),[d,p,b,...h]),w=u.useMemo((()=>({update:S})),[S]);return u.useImperativeHandle(v,(()=>w),[w]),u.useLayoutEffect((()=>(y&&y.setLights((e=>[...e,w])),()=>y.setLights((e=>e.filter((e=>e!==w)))))),[y,w]),u.createElement("group",s.default({ref:M},m),Array.from({length:f},((s,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,n]})))))}));class d{constructor(e,t,r=1024){this.renderer=e,this.res=r,this.scene=t,this.scene.background=null,this.buffer1Active=!1;const a=/(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent)?o.HalfFloatType:o.FloatType;this.progressiveLightMap1=new o.WebGLRenderTarget(this.res,this.res,{type:a}),this.progressiveLightMap2=new o.WebGLRenderTarget(this.res,this.res,{type:a}),this.uvMat=new o.MeshPhongMaterial({shininess:0,specular:new o.Color("black")}),this.uniforms={},this.uvMat.onBeforeCompile=e=>{e.vertexShader="#define USE_LIGHTMAP\n"+e.vertexShader.slice(0,-1)+"\tgl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }";const t=e.fragmentShader.indexOf("void main() {");e.fragmentShader=e.fragmentShader.replace("#include <clipping_planes_pars_fragment>","#include <clipping_planes_pars_fragment>\n#include <shadowmask_pars_fragment>\n"),e.fragmentShader="varying vec2 vUv2;\n"+e.fragmentShader.slice(0,t)+"\tuniform sampler2D previousShadowMap;\n\tuniform float averagingWindow;\n"+e.fragmentShader.slice(t-1,-1)+"\nvec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;\n        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);\n      }",e.uniforms.previousShadowMap={value:this.progressiveLightMap1.texture},e.uniforms.averagingWindow={value:100},this.uniforms=e.uniforms}}clear(){this.renderer.setRenderTarget(this.progressiveLightMap1),this.renderer.clear(),this.renderer.setRenderTarget(this.progressiveLightMap2),this.renderer.clear()}configureObject(e){const t=e.geometry.getAttribute("uv").clone();e.geometry.setAttribute("uv2",t),e.geometry.getAttribute("uv2").needsUpdate=!0}update(e,t=100){this.uniforms.averagingWindow={value:t},this.scene.overrideMaterial=this.uvMat;const r=this.buffer1Active?this.progressiveLightMap1:this.progressiveLightMap2,a=this.buffer1Active?this.progressiveLightMap2:this.progressiveLightMap1;this.renderer.setRenderTarget(r),this.uniforms.previousShadowMap={value:a.texture},this.buffer1Active=!this.buffer1Active,this.renderer.render(this.scene,e),this.scene.overrideMaterial=null,this.renderer.setRenderTarget(null)}}exports.AccumulativeShadows=c,exports.RandomizedLight=h,exports.accumulativeContext=l;
+"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");function i(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 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 n=i(e),o=s(t),h=s(r);const l=h.createContext(null),u=h.forwardRef((({children:e,temporal:t,frames:r=40,blend:i=20,scale:s=10,opacity:n=1,alphaTest:u=.65,color:c="black",resolution:d=1024,...g},f)=>{const m=a.useThree((e=>e.gl)),v=a.useThree((e=>e.scene)),M=a.useThree((e=>e.camera)),b=h.useRef(null),w=h.useRef(null),[y]=h.useState((()=>new p(m,v,d)));h.useLayoutEffect((()=>{y.configure(b.current)}),[]);const S=h.useMemo((()=>{const e=Object.assign(new o.MeshBasicMaterial({opacity:0,transparent:!0,dithering:!0,depthWrite:!1,map:y.progressiveLightMap2.texture}),{uniforms:{ucolor:{value:new o.Color(c)},alphaTest:{value:0}}});return e.onBeforeCompile=t=>{e.uniforms=t.uniforms={...t.uniforms,...e.uniforms},t.fragmentShader=t.fragmentShader.replace("void main() {","uniform vec3 ucolor;\n           uniform float alphaTest;\n           void main() {"),t.fragmentShader=t.fragmentShader.replace("#include <dithering_fragment>","#include <dithering_fragment>\n           gl_FragColor = vec4(ucolor * gl_FragColor.r * 2.0, max(0.0, (1.0 - gl_FragColor.r / alphaTest)) * opacity);")},e}),[c]),x=h.useMemo((()=>({lights:new Map,temporal:!!t,frames:Math.max(2,r),blend:Math.max(2,r===1/0?i:r),count:0,reset:()=>{y.clear(),S.opacity=0,S.uniforms.alphaTest.value=0,x.count=0},update:(e=1)=>{x.temporal?(S.opacity=Math.min(n,S.opacity+n/x.blend),S.uniforms.alphaTest.value=Math.min(u,S.uniforms.alphaTest.value+u/x.blend)):(S.opacity=n,S.uniforms.alphaTest.value=u),w.current.visible=!0,y.prepare();for(let t=0;t<e;t++)x.lights.forEach((e=>e.update())),y.update(M,x.blend);w.current.visible=!1,y.finish()}})),[y,S,M,v,t,r,i,n,u]);return h.useLayoutEffect((()=>{x.reset(),x.temporal||x.frames===1/0||x.update(x.blend)})),h.useImperativeHandle(f,(()=>x),[]),a.useFrame((()=>{(x.temporal||x.frames===1/0)&&x.count<x.frames&&(x.update(),x.count++)})),h.createElement("group",g,h.createElement("group",{traverse:()=>null,ref:w},h.createElement(l.Provider,{value:x},e)),h.createElement("mesh",{receiveShadow:!0,ref:b,material:S,scale:s,rotation:[-Math.PI/2,0,0]},h.createElement("planeGeometry",null)))})),c=h.forwardRef((({castShadow:e=!0,bias:t=0,mapSize:r=512,size:a=5,near:i=.5,far:s=500,frames:u=1,position:c=[0,0,0],radius:d=1,amount:p=8,intensity:g=1,ambient:f=.5,...m},v)=>{const M=h.useRef(null),b=new o.Vector3(...c).length(),w=h.useContext(l),y=h.useCallback((()=>{let e;if(M.current)for(let t=0;t<M.current.children.length;t++)if(e=M.current.children[t],Math.random()>f)e.position.set(c[0]+o.MathUtils.randFloatSpread(d),c[1]+o.MathUtils.randFloatSpread(d),c[2]+o.MathUtils.randFloatSpread(d));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)*b,Math.abs(Math.cos(t)*Math.sin(r)*b),Math.sin(t)*b)}}),[d,f,b,...c]),S=h.useMemo((()=>({update:y})),[y]);return h.useImperativeHandle(v,(()=>S),[S]),h.useLayoutEffect((()=>{const e=M.current;return w&&w.lights.set(e.uuid,S),()=>{w.lights.delete(e.uuid)}}),[w,S]),h.createElement("group",n.default({ref:M},m),Array.from({length:p},((n,o)=>h.createElement("directionalLight",{key:o,castShadow:e,"shadow-bias":t,"shadow-mapSize":[r,r],intensity:g/p},h.createElement("orthographicCamera",{attach:"shadow-camera",args:[-a,a,a,-a,i,s]})))))}));class d extends o.ShaderMaterial{constructor(){super({vertexShader:"void main() { gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }",fragmentShader:"void main() { discard; }"})}}class p{constructor(e,t,r=1024){this.renderer=e,this.res=r,this.scene=t,this.scene.background=null,this.buffer1Active=!1,this.lights=[],this.meshes=[],this.object=null;const a=/(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent)?o.HalfFloatType:o.FloatType;this.progressiveLightMap1=new o.WebGLRenderTarget(this.res,this.res,{type:a}),this.progressiveLightMap2=new o.WebGLRenderTarget(this.res,this.res,{type:a}),this.uvMat=new d,this.targetMat=new o.MeshPhongMaterial({shininess:0}),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=e.fragmentShader.replace("#include <clipping_planes_pars_fragment>","#include <clipping_planes_pars_fragment>\n#include <shadowmask_pars_fragment>\n"),e.fragmentShader="varying vec2 vUv;\n"+e.fragmentShader.slice(0,t)+"\tuniform 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.setRenderTarget(this.progressiveLightMap1),this.renderer.clear(),this.renderer.setRenderTarget(this.progressiveLightMap2),this.renderer.clear(),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.uvMat))}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;this.renderer.setRenderTarget(r),this.previousShadowMap.value=a.texture,this.buffer1Active=!this.buffer1Active,this.renderer.render(this.scene,e),this.renderer.setRenderTarget(null)}}exports.AccumulativeShadows=u,exports.RandomizedLight=c,exports.accumulativeContext=l;

package/core/AccumulativeShadows.d.ts

@@ -1,9 +1,13 @@
 import * as THREE from 'three';
 import * as React from 'react';
 interface AccumulativeContext {
+    lights: Map<any, any>;
+    temporal: boolean;
+    frames: number;
+    blend: number;
+    count: number;
     reset: () => void;
     update: (frames?: number) => void;
-    setLights: React.Dispatch<React.SetStateAction<AccumulativeLightContext[]>>;
 }
 interface AccumulativeLightContext {
     update: () => void;
@@ -36,7 +40,7 @@ export declare const AccumulativeShadows: React.ForwardRefExoticComponent<Pick<O
     alphaTest?: number | undefined;
     color?: string | undefined;
     resolution?: number | undefined;
-}, "visible" | "attach" | "args" | "children" | "key" | "onUpdate" | "position" | "up" | "scale" | "rotation" | "matrix" | "quaternion" | "layers" | "dispose" | "type" | "isGroup" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | "color" | keyof import("@react-three/fiber/dist/declarations/src/core/events").EventHandlers | "opacity" | "alphaTest" | "resolution" | "frames" | "blend" | "temporal"> & React.RefAttributes<AccumulativeContext>>;
+}, "visible" | "attach" | "args" | "children" | "key" | "onUpdate" | "position" | "up" | "scale" | "rotation" | "matrix" | "quaternion" | "layers" | "dispose" | "type" | "isGroup" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | "color" | keyof import("@react-three/fiber/dist/declarations/src/core/events").EventHandlers | "opacity" | "alphaTest" | "resolution" | "frames" | "temporal" | "blend"> & React.RefAttributes<AccumulativeContext>>;
 export declare const RandomizedLight: React.ForwardRefExoticComponent<Pick<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<THREE.Group>, import("@react-three/fiber").NodeProps<THREE.Group, typeof THREE.Group>>>, import("@react-three/fiber").NonFunctionKeys<{
     position?: import("@react-three/fiber").Vector3 | undefined;
     up?: import("@react-three/fiber").Vector3 | undefined;

package/core/AccumulativeShadows.js

@@ -7,13 +7,17 @@ function isLight(object) {
   return object.isLight;
 }
 
+function isGeometry(object) {
+  return !!object.geometry;
+}
+
 const accumulativeContext = /*#__PURE__*/React.createContext(null);
 const AccumulativeShadows = /*#__PURE__*/React.forwardRef(({
   children,
-  blend,
+  temporal,
   frames = 40,
+  blend = 20,
   scale = 10,
-  temporal = false,
   opacity = 1,
   alphaTest = 0.65,
   color = 'black',
@@ -22,17 +26,14 @@ const AccumulativeShadows = /*#__PURE__*/React.forwardRef(({
 }, forwardRef) => {
   const gl = useThree(state => state.gl);
   const scene = useThree(state => state.scene);
-  const defaultCamera = useThree(state => state.camera);
+  const camera = useThree(state => state.camera);
   const gPlane = React.useRef(null);
   const gLights = React.useRef(null);
-  const count = React.useRef(0);
   const [plm] = React.useState(() => new ProgressiveLightMap(gl, scene, resolution));
   React.useLayoutEffect(() => {
-    plm.configureObject(gPlane.current);
-  }, []); // Actual number of frames to render, it must be at least 2 due to the ping/ponging in the lightmap
+    plm.configure(gPlane.current);
+  }, []); //const [lights, setLights] = React.useState<AccumulativeLightContext[]>([])
 
-  if (frames <= 1) frames = 2;
-  let blendFrames = blend === undefined ? frames === Infinity ? 100 : frames : frames;
   const material = React.useMemo(() => {
     const mat = Object.assign(new THREE.MeshBasicMaterial({
       opacity: 0,
@@ -64,73 +65,59 @@ const AccumulativeShadows = /*#__PURE__*/React.forwardRef(({
 
     return mat;
   }, [color]);
-  const [lights, setLights] = React.useState([]);
-
-  function update(frames = 1) {
-    // Adapt the opacity-blend ratio to the number of frames
-    if (!temporal) {
-      material.opacity = opacity;
-      material.uniforms.alphaTest.value = alphaTest;
-    } else {
-      material.opacity = Math.min(opacity, material.opacity + opacity / blendFrames);
-      material.uniforms.alphaTest.value = Math.min(alphaTest, material.uniforms.alphaTest.value + alphaTest / blendFrames);
-    } // Switch accumulative lights on
+  const api = React.useMemo(() => ({
+    lights: new Map(),
+    temporal: !!temporal,
+    frames: Math.max(2, frames),
+    blend: Math.max(2, frames === Infinity ? blend : frames),
+    count: 0,
+    reset: () => {
+      // Clear buffers, reset opacities, set frame count to 0
+      plm.clear();
+      material.opacity = 0;
+      material.uniforms.alphaTest.value = 0;
+      api.count = 0;
+    },
+    update: (frames = 1) => {
+      // Adapt the opacity-blend ratio to the number of frames
+      if (!api.temporal) {
+        material.opacity = opacity;
+        material.uniforms.alphaTest.value = alphaTest;
+      } else {
+        material.opacity = Math.min(opacity, material.opacity + opacity / api.blend);
+        material.uniforms.alphaTest.value = Math.min(alphaTest, material.uniforms.alphaTest.value + alphaTest / api.blend);
+      } // Switch accumulative lights on
 
 
-    gLights.current.visible = true; // Switch off all other scene lights off, collect their intensities
+      gLights.current.visible = true; // Collect scene lights and meshes
 
-    const intensities = [];
-    scene.traverse(object => {
-      if (isLight(object)) {
-        intensities.push({
-          object,
-          intensity: object.intensity
-        });
-        object.intensity = 0;
-      }
-    }); // Update the lightmap and the accumulative lights
+      plm.prepare(); // Update the lightmap and the accumulative lights
 
-    for (let i = 0; i < frames; i++) {
-      plm.update(defaultCamera, blendFrames);
-      if (lights) lights.forEach(light => light.update());
-    } // Switch lights off
+      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; // Switch scene lights on and restore their intensities
+      gLights.current.visible = false; // Restore lights and meshes
 
-    intensities.forEach(({
-      object,
-      intensity
-    }) => object.intensity = intensity);
-  }
-
-  function reset() {
-    if (frames !== Infinity) {
-      plm.clear();
-      material.opacity = 0;
-      material.uniforms.alphaTest.value = 0;
-      count.current = 0;
-      update();
+      plm.finish();
     }
-  } // Expose api, allow children to set itself as the main light source
+  }), [plm, material, 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
 
-  const api = React.useMemo(() => ({
-    reset,
-    update,
-    setLights
-  }), []);
-  React.useImperativeHandle(forwardRef, () => api, [api]);
+  React.useImperativeHandle(forwardRef, () => api, []);
   useFrame(() => {
-    if (temporal && count.current < frames) {
-      update();
-      count.current++;
+    if ((api.temporal || api.frames === Infinity) && api.count < api.frames) {
+      api.update();
+      api.count++;
     }
   });
-  React.useLayoutEffect(() => {
-    reset();
-    if (!temporal) update(blendFrames);
-  });
   return /*#__PURE__*/React.createElement("group", props, /*#__PURE__*/React.createElement("group", {
     traverse: () => null,
     ref: gLights
@@ -184,8 +171,9 @@ const RandomizedLight = /*#__PURE__*/React.forwardRef(({
   }), [update]);
   React.useImperativeHandle(forwardRef, () => api, [api]);
   React.useLayoutEffect(() => {
-    if (parent) parent.setLights(state => [...state, api]);
-    return () => parent.setLights(state => state.filter(a => a !== api));
+    const group = gLights.current;
+    if (parent) parent.lights.set(group.uuid, api);
+    return () => void parent.lights.delete(group.uuid);
   }, [parent, api]);
   return /*#__PURE__*/React.createElement("group", _extends({
     ref: gLights
@@ -201,7 +189,18 @@ const RandomizedLight = /*#__PURE__*/React.forwardRef(({
     attach: "shadow-camera",
     args: [-size, size, size, -size, near, far]
   }))));
-}); // Based on "Progressive Light Map Accumulator", by [zalo](https://github.com/zalo/)
+});
+
+class UVMaterial extends THREE.ShaderMaterial {
+  constructor() {
+    super({
+      vertexShader: 'void main() { gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }',
+      fragmentShader: 'void main() { discard; }'
+    });
+  }
+
+} // Based on "Progressive Light Map Accumulator", by [zalo](https://github.com/zalo/)
+
 
 class ProgressiveLightMap {
   constructor(renderer, scene, res = 1024) {
@@ -209,7 +208,10 @@ class ProgressiveLightMap {
     this.res = res;
     this.scene = scene;
     this.scene.background = null;
-    this.buffer1Active = false; // Create the Progressive LightMap Texture
+    this.buffer1Active = false;
+    this.lights = [];
+    this.meshes = [];
+    this.object = null; // Create the Progressive LightMap Texture
 
     const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;
     this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {
@@ -219,29 +221,29 @@ class ProgressiveLightMap {
       type: format
     }); // Inject some spicy new logic into a standard phong material
 
-    this.uvMat = new THREE.MeshPhongMaterial({
-      shininess: 0,
-      specular: new THREE.Color('black')
+    this.uvMat = new UVMaterial();
+    this.targetMat = new THREE.MeshPhongMaterial({
+      shininess: 0
     });
-    this.uniforms = {};
+    this.previousShadowMap = {
+      value: this.progressiveLightMap1.texture
+    };
+    this.averagingWindow = {
+      value: 100
+    };
 
-    this.uvMat.onBeforeCompile = shader => {
+    this.targetMat.onBeforeCompile = shader => {
       // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
-      shader.vertexShader = '#define USE_LIGHTMAP\n' + shader.vertexShader.slice(0, -1) + '	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }'; // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
+      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 = shader.fragmentShader.replace('#include <clipping_planes_pars_fragment>', '#include <clipping_planes_pars_fragment>\n#include <shadowmask_pars_fragment>\n');
-      shader.fragmentShader = 'varying vec2 vUv2;\n' + shader.fragmentShader.slice(0, bodyStart) + '	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' + shader.fragmentShader.slice(bodyStart - 1, -1) + `\nvec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;
+      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 = {
-        value: this.progressiveLightMap1.texture
-      };
-      shader.uniforms.averagingWindow = {
-        value: 100
-      };
-      this.uniforms = shader.uniforms;
+      shader.uniforms.previousShadowMap = this.previousShadowMap;
+      shader.uniforms.averagingWindow = this.averagingWindow;
     };
   }
 
@@ -250,31 +252,50 @@ class ProgressiveLightMap {
     this.renderer.clear();
     this.renderer.setRenderTarget(this.progressiveLightMap2);
     this.renderer.clear();
+    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.uvMat);
   }
 
-  configureObject(object) {
-    const uv2 = object.geometry.getAttribute('uv').clone();
-    object.geometry.setAttribute('uv2', uv2);
-    object.geometry.getAttribute('uv2').needsUpdate = true;
+  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) {
-    // Set each object's material to the UV Unwrapped Surface Mapping Version
-    this.uniforms.averagingWindow = {
-      value: blendWindow
-    };
-    this.scene.overrideMaterial = this.uvMat; // Ping-pong two surface buffers for reading/writing
+    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
 
     this.renderer.setRenderTarget(activeMap);
-    this.uniforms.previousShadowMap = {
-      value: inactiveMap.texture
-    };
+    this.previousShadowMap.value = inactiveMap.texture;
     this.buffer1Active = !this.buffer1Active;
     this.renderer.render(this.scene, camera);
-    this.scene.overrideMaterial = null;
     this.renderer.setRenderTarget(null);
   }
 

package/core/Decal.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("three"),t=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 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=n(e),o=n(r);function c(e,r){Array.isArray(e)?r.fromArray?r.fromArray(e):r.set(...e):r.copy(e)}exports.Decal=function({debug:e,mesh:r,children:n,position:s,rotation:l,scale:u}){const i=a.useRef(null),[[f,m,p]]=a.useState((()=>[new o.Vector3,new o.Euler,new o.Vector3(1,1,1)]));return a.useLayoutEffect((()=>{const e=(null==r?void 0:r.current)||i.current.parent;if(!(e instanceof o.Mesh))throw new Error('Decal must have a Mesh as parent or specify its "mesh" prop');e&&(c(s,f),c(l,m),c(u,p),i.current.geometry=new t.DecalGeometry(e,f,m,p))}),[r,s,u,l,f,m,p]),a.createElement("mesh",{ref:i},n||a.createElement("meshNormalMaterial",{transparent:!0,depthTest:!0,depthWrite:!1,polygonOffset:!0,polygonOffsetFactor:-4}),e&&a.createElement("mesh",{position:s,rotation:l,scale:u},a.createElement("boxGeometry",null),a.createElement("meshNormalMaterial",{wireframe:!0}),a.createElement("axesHelper",null)))};

package/core/Decal.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import * as FIBER from '@react-three/fiber';
+interface DecalProps {
+    debug: boolean;
+    mesh: React.MutableRefObject<THREE.Mesh>;
+    position: FIBER.Vector3;
+    rotation: FIBER.Euler;
+    scale: FIBER.Vector3;
+}
+export declare function Decal({ debug, mesh, children, position, rotation, scale, }: React.PropsWithChildren<Partial<DecalProps>>): JSX.Element;
+export {};

package/core/Decal.js

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { DecalGeometry } from 'three-stdlib';
+
+function setProp(value, targetProp) {
+  if (Array.isArray(value)) {
+    if (targetProp.fromArray) targetProp.fromArray(value);else targetProp.set(...value);
+  } else {
+    targetProp.copy(value);
+  }
+}
+
+function Decal({
+  debug,
+  mesh,
+  children,
+  position,
+  rotation,
+  scale
+}) {
+  const ref = React.useRef(null);
+  const [[p, r, s]] = React.useState(() => {
+    return [new THREE.Vector3(), new THREE.Euler(), new THREE.Vector3(1, 1, 1)];
+  });
+  React.useLayoutEffect(() => {
+    const parent = (mesh == null ? void 0 : mesh.current) || ref.current.parent;
+
+    if (!(parent instanceof THREE.Mesh)) {
+      throw new Error('Decal must have a Mesh as parent or specify its "mesh" prop');
+    }
+
+    if (parent) {
+      setProp(position, p);
+      setProp(rotation, r);
+      setProp(scale, s);
+      ref.current.geometry = new DecalGeometry(parent, p, r, s);
+    }
+  }, [mesh, position, scale, rotation, p, r, s]);
+  return /*#__PURE__*/React.createElement("mesh", {
+    ref: ref
+  }, children || /*#__PURE__*/React.createElement("meshNormalMaterial", {
+    transparent: true,
+    depthTest: true,
+    depthWrite: false,
+    polygonOffset: true,
+    polygonOffsetFactor: -4
+  }), debug && /*#__PURE__*/React.createElement("mesh", {
+    position: position,
+    rotation: rotation,
+    scale: scale
+  }, /*#__PURE__*/React.createElement("boxGeometry", null), /*#__PURE__*/React.createElement("meshNormalMaterial", {
+    wireframe: true
+  }), /*#__PURE__*/React.createElement("axesHelper", null)));
+}
+
+export { Decal };

package/core/Reflector.d.ts

@@ -26,4 +26,4 @@ declare global {
         }
     }
 }
-export declare const Reflector: React.ForwardRefExoticComponent<Pick<ReflectorProps, "visible" | "attach" | "args" | "children" | "key" | "onUpdate" | "position" | "up" | "scale" | "rotation" | "matrix" | "quaternion" | "layers" | "dispose" | "type" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | keyof import("@react-three/fiber/dist/declarations/src/core/events").EventHandlers | "material" | "blur" | "resolution" | "geometry" | "morphTargetInfluences" | "morphTargetDictionary" | "isMesh" | "updateMorphTargets" | "minDepthThreshold" | "maxDepthThreshold" | "depthScale" | "depthToBlurRatioBias" | "mixBlur" | "mixStrength" | "mirror" | "distortion" | "mixContrast" | "distortionMap" | "debug"> & React.RefAttributes<Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>>>;
+export declare const Reflector: React.ForwardRefExoticComponent<Pick<ReflectorProps, "visible" | "attach" | "args" | "children" | "key" | "onUpdate" | "position" | "up" | "scale" | "rotation" | "matrix" | "quaternion" | "layers" | "dispose" | "type" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | keyof import("@react-three/fiber/dist/declarations/src/core/events").EventHandlers | "material" | "blur" | "resolution" | "geometry" | "morphTargetInfluences" | "morphTargetDictionary" | "isMesh" | "updateMorphTargets" | "debug" | "minDepthThreshold" | "maxDepthThreshold" | "depthScale" | "depthToBlurRatioBias" | "mixBlur" | "mixStrength" | "mirror" | "distortion" | "mixContrast" | "distortionMap"> & React.RefAttributes<Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>>>;

package/core/Sampler.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("three-stdlib"),n=require("three");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 i=u(e),l=c(r);exports.Sampler=({children:e,weight:r,transform:u,instances:c,mesh:o,...a})=>{const s=l.useRef(null),d=l.useRef(null),f=l.useRef(null);return l.useEffect((()=>{var e,r;d.current=null!==(e=null==c?void 0:c.current)&&void 0!==e?e:s.current.children.find((e=>e.hasOwnProperty("instanceMatrix"))),f.current=null!==(r=null==o?void 0:o.current)&&void 0!==r?r:s.current.children.find((e=>"Mesh"===e.type))}),[e,null==o?void 0:o.current,null==c?void 0:c.current]),l.useEffect((()=>{if(void 0===f.current)return;if(void 0===d.current)return;const e=new t.MeshSurfaceSampler(f.current);r&&e.setWeightAttribute(r),e.build();const c=new n.Vector3,i=new n.Vector3,l=new n.Color,o=new n.Object3D;f.current.updateMatrixWorld(!0);for(let r=0;r<d.current.count;r++)e.sample(c,i,l),"function"==typeof u?u({dummy:o,sampledMesh:f.current,position:c,normal:i,color:l},r):o.position.copy(c),o.updateMatrix(),d.current.setMatrixAt(r,o.matrix);d.current.instanceMatrix.needsUpdate=!0}),[e,null==o?void 0:o.current,null==c?void 0:c.current]),l.createElement("group",i.default({ref:s},a),e)};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("three-stdlib"),n=require("three");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 l=u(e),o=c(r);function i(e,r=16,u,c,l){const[i,a]=o.useState((()=>{const e=Array.from({length:r},(()=>[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1])).flat();return new n.InstancedBufferAttribute(Float32Array.from(e),16)}));return o.useEffect((()=>{if(void 0===e.current)return;const o=new t.MeshSurfaceSampler(e.current);c&&o.setWeightAttribute(c),o.build();const s=new n.Vector3,f=new n.Vector3,d=new n.Color,p=new n.Object3D;e.current.updateMatrixWorld(!0);for(let t=0;t<r;t++)o.sample(s,f,d),"function"==typeof u?u({dummy:p,sampledMesh:e.current,position:s,normal:f,color:d},t):p.position.copy(s),p.updateMatrix(),null!=l&&l.current&&l.current.setMatrixAt(t,p.matrix),p.matrix.toArray(i.array,16*t);null!=l&&l.current&&(l.current.instanceMatrix.needsUpdate=!0),i.needsUpdate=!0,a(i.clone())}),[e,l,c,r,u]),i}exports.Sampler=function({children:e,weight:r,transform:t,instances:n,mesh:u,count:c=16,...a}){const s=o.useRef(null),f=o.useRef(null),d=o.useRef(null);return o.useEffect((()=>{var e,r;f.current=null!==(e=null==n?void 0:n.current)&&void 0!==e?e:s.current.children.find((e=>e.hasOwnProperty("instanceMatrix"))),d.current=null!==(r=null==u?void 0:u.current)&&void 0!==r?r:s.current.children.find((e=>"Mesh"===e.type))}),[e,null==u?void 0:u.current,null==n?void 0:n.current]),i(d,c,t,r,f),o.createElement("group",l.default({ref:s},a),e)},exports.useSurfaceSampler=i;