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

package/index.d.ts

@@ -0,0 +1 @@
+export * from './web';

package/index.js

@@ -0,0 +1,139 @@
+export { Html } from './web/Html.js';
+export { CycleRaycast } from './web/CycleRaycast.js';
+export { useCursor } from './web/useCursor.js';
+export { Loader } from './web/Loader.js';
+export { DragControls } from './web/DragControls.js';
+export { Scroll, ScrollControls, useScroll } from './web/ScrollControls.js';
+export { PresentationControls } from './web/PresentationControls.js';
+export { KeyboardControls, useKeyboardControls } from './web/KeyboardControls.js';
+export { Select, useSelect } from './web/Select.js';
+export { Billboard } from './core/Billboard.js';
+export { ScreenSpace } from './core/ScreenSpace.js';
+export { ScreenSizer } from './core/ScreenSizer.js';
+export { QuadraticBezierLine } from './core/QuadraticBezierLine.js';
+export { CubicBezierLine } from './core/CubicBezierLine.js';
+export { CatmullRomLine } from './core/CatmullRomLine.js';
+export { Line } from './core/Line.js';
+export { PositionalAudio } from './core/PositionalAudio.js';
+export { Text } from './core/Text.js';
+export { Text3D } from './core/Text3D.js';
+export { Effects, isWebGL2Available } from './core/Effects.js';
+export { GradientTexture, GradientType } from './core/GradientTexture.js';
+export { Image } from './core/Image.js';
+export { Edges } from './core/Edges.js';
+export { Outlines } from './core/Outlines.js';
+export { Trail, useTrail } from './core/Trail.js';
+export { Sampler, useSurfaceSampler } from './core/Sampler.js';
+export { ComputedAttribute } from './core/ComputedAttribute.js';
+export { Clone } from './core/Clone.js';
+export { MarchingCube, MarchingCubes, MarchingPlane } from './core/MarchingCubes.js';
+export { Decal } from './core/Decal.js';
+export { Svg } from './core/Svg.js';
+export { Gltf, useGLTF } from './core/Gltf.js';
+export { AsciiRenderer } from './core/AsciiRenderer.js';
+export { Splat } from './core/Splat.js';
+export { OrthographicCamera } from './core/OrthographicCamera.js';
+export { PerspectiveCamera } from './core/PerspectiveCamera.js';
+export { CubeCamera, useCubeCamera } from './core/CubeCamera.js';
+export { DeviceOrientationControls } from './core/DeviceOrientationControls.js';
+export { FlyControls } from './core/FlyControls.js';
+export { MapControls } from './core/MapControls.js';
+export { OrbitControls } from './core/OrbitControls.js';
+export { TrackballControls } from './core/TrackballControls.js';
+export { ArcballControls } from './core/ArcballControls.js';
+export { TransformControls } from './core/TransformControls.js';
+export { PointerLockControls } from './core/PointerLockControls.js';
+export { FirstPersonControls } from './core/FirstPersonControls.js';
+export { CameraControls } from './core/CameraControls.js';
+export { default as CameraControlsImpl } from 'camera-controls';
+export { MotionPathControls, useMotion } from './core/MotionPathControls.js';
+export { GizmoHelper, useGizmoContext } from './core/GizmoHelper.js';
+export { GizmoViewcube } from './core/GizmoViewcube.js';
+export { GizmoViewport } from './core/GizmoViewport.js';
+export { Grid } from './core/Grid.js';
+export { CubeTexture, useCubeTexture } from './core/CubeTexture.js';
+export { Fbx, useFBX } from './core/Fbx.js';
+export { Ktx2, useKTX2 } from './core/Ktx2.js';
+export { Progress, useProgress } from './core/Progress.js';
+export { IsObject, Texture, useTexture } from './core/Texture.js';
+export { VideoTexture, useVideoTexture } from './core/VideoTexture.js';
+export { useFont } from './core/useFont.js';
+export { checkIfFrameIsEmpty, getFirstFrame, useSpriteLoader } from './core/useSpriteLoader.js';
+export { Helper, useHelper } from './core/Helper.js';
+export { Stats } from './core/Stats.js';
+export { StatsGl } from './core/StatsGl.js';
+export { useDepthBuffer } from './core/useDepthBuffer.js';
+export { useAspect } from './core/useAspect.js';
+export { useCamera } from './core/useCamera.js';
+export { DetectGPU, useDetectGPU } from './core/DetectGPU.js';
+export { Bvh, useBVH } from './core/Bvh.js';
+export { useContextBridge } from './core/useContextBridge.js';
+export { useAnimations } from './core/useAnimations.js';
+export { Fbo, useFBO } from './core/Fbo.js';
+export { useIntersect } from './core/useIntersect.js';
+export { useBoxProjectedEnv } from './core/useBoxProjectedEnv.js';
+export { BBAnchor } from './core/BBAnchor.js';
+export { TrailTexture, useTrailTexture } from './core/TrailTexture.js';
+export { Example } from './core/Example.js';
+export { SpriteAnimator, useSpriteAnimator } from './core/SpriteAnimator.js';
+export { CurveModifier } from './core/CurveModifier.js';
+export { MeshDistortMaterial } from './core/MeshDistortMaterial.js';
+export { MeshWobbleMaterial } from './core/MeshWobbleMaterial.js';
+export { MeshReflectorMaterial } from './core/MeshReflectorMaterial.js';
+export { MeshRefractionMaterial } from './core/MeshRefractionMaterial.js';
+export { MeshTransmissionMaterial } from './core/MeshTransmissionMaterial.js';
+export { MeshDiscardMaterial } from './core/MeshDiscardMaterial.js';
+export { MultiMaterial } from './core/MultiMaterial.js';
+export { PointMaterial, PointMaterialImpl } from './core/PointMaterial.js';
+export { shaderMaterial } from './core/shaderMaterial.js';
+export { SoftShadows } from './core/softShadows.js';
+export { Box, Capsule, Circle, Cone, Cylinder, Dodecahedron, Extrude, Icosahedron, Lathe, Octahedron, Plane, Polyhedron, Ring, Shape, Sphere, Tetrahedron, Torus, TorusKnot, Tube } from './core/shapes.js';
+export { RoundedBox, RoundedBoxGeometry } from './core/RoundedBox.js';
+export { ScreenQuad } from './core/ScreenQuad.js';
+export { Center } from './core/Center.js';
+export { Resize } from './core/Resize.js';
+export { Bounds, useBounds } from './core/Bounds.js';
+export { CameraShake } from './core/CameraShake.js';
+export { Float } from './core/Float.js';
+export { Stage } from './core/Stage.js';
+export { Backdrop } from './core/Backdrop.js';
+export { Shadow } from './core/Shadow.js';
+export { Caustics } from './core/Caustics.js';
+export { ContactShadows } from './core/ContactShadows.js';
+export { AccumulativeShadows, RandomizedLight, accumulativeContext } from './core/AccumulativeShadows.js';
+export { SpotLight, SpotLightShadow } from './core/SpotLight.js';
+export { Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal } from './core/Environment.js';
+export { Lightformer } from './core/Lightformer.js';
+export { Sky, calcPosFromAngles } from './core/Sky.js';
+export { Stars } from './core/Stars.js';
+export { Cloud, CloudInstance, Clouds } from './core/Cloud.js';
+export { Sparkles } from './core/Sparkles.js';
+export { useEnvironment } from './core/useEnvironment.js';
+export { MatcapTexture, useMatcapTexture } from './core/MatcapTexture.js';
+export { NormalTexture, useNormalTexture } from './core/NormalTexture.js';
+export { Wireframe } from './core/Wireframe.js';
+export { ShadowAlpha } from './core/ShadowAlpha.js';
+export { Point, Points, PointsBuffer, PositionPoint } from './core/Points.js';
+export { Instance, InstancedAttribute, Instances, Merged, PositionMesh, createInstances } from './core/Instances.js';
+export { Segment, SegmentObject, Segments } from './core/Segments.js';
+export { Detailed } from './core/Detailed.js';
+export { Preload } from './core/Preload.js';
+export { BakeShadows } from './core/BakeShadows.js';
+export { meshBounds } from './core/meshBounds.js';
+export { AdaptiveDpr } from './core/AdaptiveDpr.js';
+export { AdaptiveEvents } from './core/AdaptiveEvents.js';
+export { PerformanceMonitor, usePerformanceMonitor } from './core/PerformanceMonitor.js';
+export { RenderTexture } from './core/RenderTexture.js';
+export { RenderCubeTexture } from './core/RenderCubeTexture.js';
+export { Mask, useMask } from './core/Mask.js';
+export { Hud } from './core/Hud.js';
+export { Fisheye } from './core/Fisheye.js';
+export { MeshPortalMaterial } from './core/MeshPortalMaterial.js';
+export { calculateScaleFactor } from './core/calculateScaleFactor.js';
+export { View } from './web/View.js';
+export { PivotControls } from './web/pivotControls/index.js';
+export { ScreenVideoTexture } from './web/ScreenVideoTexture.js';
+export { WebcamVideoTexture } from './web/WebcamVideoTexture.js';
+export { FaceControls, useFaceControls } from './web/FaceControls.js';
+export { FaceLandmarker, FaceLandmarkerDefaults, useFaceLandmarker } from './web/FaceLandmarker.js';
+export { Facemesh, FacemeshDatas, FacemeshEye, FacemeshEyeDefaults } from './web/Facemesh.js';

package/materials/BlurPass.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("./ConvolutionMaterial.cjs.js");require("../helpers/constants.cjs.js");exports.BlurPass=class{constructor({gl:r,resolution:i,width:n=500,height:s=500,minDepthThreshold:o=0,maxDepthThreshold:a=1,depthScale:l=0,depthToBlurRatioBias:u=.25}){this.renderToScreen=!1,this.renderTargetA=new e.WebGLRenderTarget(i,i,{minFilter:e.LinearFilter,magFilter:e.LinearFilter,stencilBuffer:!1,depthBuffer:!1,type:e.HalfFloatType}),this.renderTargetB=this.renderTargetA.clone(),this.convolutionMaterial=new t.ConvolutionMaterial,this.convolutionMaterial.setTexelSize(1/n,1/s),this.convolutionMaterial.setResolution(new e.Vector2(n,s)),this.scene=new e.Scene,this.camera=new e.Camera,this.convolutionMaterial.uniforms.minDepthThreshold.value=o,this.convolutionMaterial.uniforms.maxDepthThreshold.value=a,this.convolutionMaterial.uniforms.depthScale.value=l,this.convolutionMaterial.uniforms.depthToBlurRatioBias.value=u,this.convolutionMaterial.defines.USE_DEPTH=l>0;const h=new Float32Array([-1,-1,0,3,-1,0,-1,3,0]),c=new Float32Array([0,0,2,0,0,2]),d=new e.BufferGeometry;d.setAttribute("position",new e.BufferAttribute(h,3)),d.setAttribute("uv",new e.BufferAttribute(c,2)),this.screen=new e.Mesh(d,this.convolutionMaterial),this.screen.frustumCulled=!1,this.scene.add(this.screen)}render(e,t,r){const i=this.scene,n=this.camera,s=this.renderTargetA,o=this.renderTargetB;let a=this.convolutionMaterial,l=a.uniforms;l.depthBuffer.value=t.depthTexture;const u=a.kernel;let h,c,d,f=t;for(c=0,d=u.length-1;c<d;++c)h=1&c?o:s,l.kernel.value=u[c],l.inputBuffer.value=f.texture,e.setRenderTarget(h),e.render(i,n),f=h;l.kernel.value=u[c],l.inputBuffer.value=f.texture,e.setRenderTarget(this.renderToScreen?null:r),e.render(i,n)}};

package/materials/BlurPass.d.ts

@@ -0,0 +1,23 @@
+import { Mesh, Scene, WebGLRenderTarget, WebGLRenderer, Camera } from 'three';
+import { ConvolutionMaterial } from './ConvolutionMaterial';
+export interface BlurPassProps {
+    gl: WebGLRenderer;
+    resolution: number;
+    width?: number;
+    height?: number;
+    minDepthThreshold?: number;
+    maxDepthThreshold?: number;
+    depthScale?: number;
+    depthToBlurRatioBias?: number;
+}
+export declare class BlurPass {
+    readonly renderTargetA: WebGLRenderTarget;
+    readonly renderTargetB: WebGLRenderTarget;
+    readonly convolutionMaterial: ConvolutionMaterial;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    readonly screen: Mesh;
+    renderToScreen: boolean;
+    constructor({ gl, resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
+    render(renderer: any, inputBuffer: any, outputBuffer: any): void;
+}

package/materials/BlurPass.js

@@ -0,0 +1,72 @@
+import { WebGLRenderTarget, LinearFilter, HalfFloatType, Vector2, Scene, Camera, BufferGeometry, BufferAttribute, Mesh } from 'three';
+import { ConvolutionMaterial } from './ConvolutionMaterial.js';
+
+class BlurPass {
+  constructor({
+    gl,
+    resolution,
+    width = 500,
+    height = 500,
+    minDepthThreshold = 0,
+    maxDepthThreshold = 1,
+    depthScale = 0,
+    depthToBlurRatioBias = 0.25
+  }) {
+    this.renderToScreen = false;
+    this.renderTargetA = new WebGLRenderTarget(resolution, resolution, {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter,
+      stencilBuffer: false,
+      depthBuffer: false,
+      type: HalfFloatType
+    });
+    this.renderTargetB = this.renderTargetA.clone();
+    this.convolutionMaterial = new ConvolutionMaterial();
+    this.convolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);
+    this.convolutionMaterial.setResolution(new Vector2(width, height));
+    this.scene = new Scene();
+    this.camera = new Camera();
+    this.convolutionMaterial.uniforms.minDepthThreshold.value = minDepthThreshold;
+    this.convolutionMaterial.uniforms.maxDepthThreshold.value = maxDepthThreshold;
+    this.convolutionMaterial.uniforms.depthScale.value = depthScale;
+    this.convolutionMaterial.uniforms.depthToBlurRatioBias.value = depthToBlurRatioBias;
+    this.convolutionMaterial.defines.USE_DEPTH = depthScale > 0;
+    const vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
+    const uvs = new Float32Array([0, 0, 2, 0, 0, 2]);
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new BufferAttribute(vertices, 3));
+    geometry.setAttribute('uv', new BufferAttribute(uvs, 2));
+    this.screen = new Mesh(geometry, this.convolutionMaterial);
+    this.screen.frustumCulled = false;
+    this.scene.add(this.screen);
+  }
+  render(renderer, inputBuffer, outputBuffer) {
+    const scene = this.scene;
+    const camera = this.camera;
+    const renderTargetA = this.renderTargetA;
+    const renderTargetB = this.renderTargetB;
+    let material = this.convolutionMaterial;
+    let uniforms = material.uniforms;
+    uniforms.depthBuffer.value = inputBuffer.depthTexture;
+    const kernel = material.kernel;
+    let lastRT = inputBuffer;
+    let destRT;
+    let i, l;
+    // Apply the multi-pass blur.
+    for (i = 0, l = kernel.length - 1; i < l; ++i) {
+      // Alternate between targets.
+      destRT = (i & 1) === 0 ? renderTargetA : renderTargetB;
+      uniforms.kernel.value = kernel[i];
+      uniforms.inputBuffer.value = lastRT.texture;
+      renderer.setRenderTarget(destRT);
+      renderer.render(scene, camera);
+      lastRT = destRT;
+    }
+    uniforms.kernel.value = kernel[i];
+    uniforms.inputBuffer.value = lastRT.texture;
+    renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);
+    renderer.render(scene, camera);
+  }
+}
+
+export { BlurPass };

package/materials/ConvolutionMaterial.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),n=require("../helpers/constants.cjs.js");function r(e){if(e&&e.__esModule)return e;var n=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var t=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(n,r,t.get?t:{enumerable:!0,get:function(){return e[r]}})}})),n.default=e,Object.freeze(n)}var t=r(e);class i extends t.ShaderMaterial{constructor(e=new t.Vector2){super({uniforms:{inputBuffer:new t.Uniform(null),depthBuffer:new t.Uniform(null),resolution:new t.Uniform(new t.Vector2),texelSize:new t.Uniform(new t.Vector2),halfTexelSize:new t.Uniform(new t.Vector2),kernel:new t.Uniform(0),scale:new t.Uniform(1),cameraNear:new t.Uniform(0),cameraFar:new t.Uniform(1),minDepthThreshold:new t.Uniform(0),maxDepthThreshold:new t.Uniform(1),depthScale:new t.Uniform(0),depthToBlurRatioBias:new t.Uniform(.25)},fragmentShader:`#include <common>\n        #include <dithering_pars_fragment>      \n        uniform sampler2D inputBuffer;\n        uniform sampler2D depthBuffer;\n        uniform float cameraNear;\n        uniform float cameraFar;\n        uniform float minDepthThreshold;\n        uniform float maxDepthThreshold;\n        uniform float depthScale;\n        uniform float depthToBlurRatioBias;\n        varying vec2 vUv;\n        varying vec2 vUv0;\n        varying vec2 vUv1;\n        varying vec2 vUv2;\n        varying vec2 vUv3;\n\n        void main() {\n          float depthFactor = 0.0;\n          \n          #ifdef USE_DEPTH\n            vec4 depth = texture2D(depthBuffer, vUv);\n            depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));\n            depthFactor *= depthScale;\n            depthFactor = max(0.0, min(1.0, depthFactor + 0.25));\n          #endif\n          \n          vec4 sum = texture2D(inputBuffer, mix(vUv0, vUv, depthFactor));\n          sum += texture2D(inputBuffer, mix(vUv1, vUv, depthFactor));\n          sum += texture2D(inputBuffer, mix(vUv2, vUv, depthFactor));\n          sum += texture2D(inputBuffer, mix(vUv3, vUv, depthFactor));\n          gl_FragColor = sum * 0.25 ;\n\n          #include <dithering_fragment>\n          #include <tonemapping_fragment>\n          #include <${n.version>=154?"colorspace_fragment":"encodings_fragment"}>\n        }`,vertexShader:"uniform vec2 texelSize;\n        uniform vec2 halfTexelSize;\n        uniform float kernel;\n        uniform float scale;\n        varying vec2 vUv;\n        varying vec2 vUv0;\n        varying vec2 vUv1;\n        varying vec2 vUv2;\n        varying vec2 vUv3;\n\n        void main() {\n          vec2 uv = position.xy * 0.5 + 0.5;\n          vUv = uv;\n\n          vec2 dUv = (texelSize * vec2(kernel) + halfTexelSize) * scale;\n          vUv0 = vec2(uv.x - dUv.x, uv.y + dUv.y);\n          vUv1 = vec2(uv.x + dUv.x, uv.y + dUv.y);\n          vUv2 = vec2(uv.x + dUv.x, uv.y - dUv.y);\n          vUv3 = vec2(uv.x - dUv.x, uv.y - dUv.y);\n\n          gl_Position = vec4(position.xy, 1.0, 1.0);\n        }",blending:t.NoBlending,depthWrite:!1,depthTest:!1}),this.toneMapped=!1,this.setTexelSize(e.x,e.y),this.kernel=new Float32Array([0,1,2,2,3])}setTexelSize(e,n){this.uniforms.texelSize.value.set(e,n),this.uniforms.halfTexelSize.value.set(e,n).multiplyScalar(.5)}setResolution(e){this.uniforms.resolution.value.copy(e)}}exports.ConvolutionMaterial=i;

package/materials/ConvolutionMaterial.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+export declare class ConvolutionMaterial extends THREE.ShaderMaterial {
+    readonly kernel: Float32Array;
+    constructor(texelSize?: THREE.Vector2);
+    setTexelSize(x: number, y: number): void;
+    setResolution(resolution: THREE.Vector2): void;
+}

package/materials/ConvolutionMaterial.js

@@ -0,0 +1,97 @@
+import * as THREE from 'three';
+import { version } from '../helpers/constants.js';
+
+class ConvolutionMaterial extends THREE.ShaderMaterial {
+  constructor(texelSize = new THREE.Vector2()) {
+    super({
+      uniforms: {
+        inputBuffer: new THREE.Uniform(null),
+        depthBuffer: new THREE.Uniform(null),
+        resolution: new THREE.Uniform(new THREE.Vector2()),
+        texelSize: new THREE.Uniform(new THREE.Vector2()),
+        halfTexelSize: new THREE.Uniform(new THREE.Vector2()),
+        kernel: new THREE.Uniform(0.0),
+        scale: new THREE.Uniform(1.0),
+        cameraNear: new THREE.Uniform(0.0),
+        cameraFar: new THREE.Uniform(1.0),
+        minDepthThreshold: new THREE.Uniform(0.0),
+        maxDepthThreshold: new THREE.Uniform(1.0),
+        depthScale: new THREE.Uniform(0.0),
+        depthToBlurRatioBias: new THREE.Uniform(0.25)
+      },
+      fragmentShader: `#include <common>
+        #include <dithering_pars_fragment>      
+        uniform sampler2D inputBuffer;
+        uniform sampler2D depthBuffer;
+        uniform float cameraNear;
+        uniform float cameraFar;
+        uniform float minDepthThreshold;
+        uniform float maxDepthThreshold;
+        uniform float depthScale;
+        uniform float depthToBlurRatioBias;
+        varying vec2 vUv;
+        varying vec2 vUv0;
+        varying vec2 vUv1;
+        varying vec2 vUv2;
+        varying vec2 vUv3;
+
+        void main() {
+          float depthFactor = 0.0;
+          
+          #ifdef USE_DEPTH
+            vec4 depth = texture2D(depthBuffer, vUv);
+            depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
+            depthFactor *= depthScale;
+            depthFactor = max(0.0, min(1.0, depthFactor + 0.25));
+          #endif
+          
+          vec4 sum = texture2D(inputBuffer, mix(vUv0, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv1, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv2, vUv, depthFactor));
+          sum += texture2D(inputBuffer, mix(vUv3, vUv, depthFactor));
+          gl_FragColor = sum * 0.25 ;
+
+          #include <dithering_fragment>
+          #include <tonemapping_fragment>
+          #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+        }`,
+      vertexShader: `uniform vec2 texelSize;
+        uniform vec2 halfTexelSize;
+        uniform float kernel;
+        uniform float scale;
+        varying vec2 vUv;
+        varying vec2 vUv0;
+        varying vec2 vUv1;
+        varying vec2 vUv2;
+        varying vec2 vUv3;
+
+        void main() {
+          vec2 uv = position.xy * 0.5 + 0.5;
+          vUv = uv;
+
+          vec2 dUv = (texelSize * vec2(kernel) + halfTexelSize) * scale;
+          vUv0 = vec2(uv.x - dUv.x, uv.y + dUv.y);
+          vUv1 = vec2(uv.x + dUv.x, uv.y + dUv.y);
+          vUv2 = vec2(uv.x + dUv.x, uv.y - dUv.y);
+          vUv3 = vec2(uv.x - dUv.x, uv.y - dUv.y);
+
+          gl_Position = vec4(position.xy, 1.0, 1.0);
+        }`,
+      blending: THREE.NoBlending,
+      depthWrite: false,
+      depthTest: false
+    });
+    this.toneMapped = false;
+    this.setTexelSize(texelSize.x, texelSize.y);
+    this.kernel = new Float32Array([0.0, 1.0, 2.0, 2.0, 3.0]);
+  }
+  setTexelSize(x, y) {
+    this.uniforms.texelSize.value.set(x, y);
+    this.uniforms.halfTexelSize.value.set(x, y).multiplyScalar(0.5);
+  }
+  setResolution(resolution) {
+    this.uniforms.resolution.value.copy(resolution);
+  }
+}
+
+export { ConvolutionMaterial };

package/materials/DiscardMaterial.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../core/shaderMaterial.cjs.js");require("three");const r=e.shaderMaterial({},"void main() { }","void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }");exports.DiscardMaterial=r;

package/materials/DiscardMaterial.d.ts

@@ -0,0 +1,3 @@
+export declare const DiscardMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial> & {
+    key: string;
+};

package/materials/DiscardMaterial.js

@@ -0,0 +1,5 @@
+import { shaderMaterial } from '../core/shaderMaterial.js';
+
+const DiscardMaterial = /* @__PURE__ */shaderMaterial({}, 'void main() { }', 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }');
+
+export { DiscardMaterial };

package/materials/MeshReflectorMaterial.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");class t extends e.MeshStandardMaterial{constructor(e={}){super(e),this._tDepth={value:null},this._distortionMap={value:null},this._tDiffuse={value:null},this._tDiffuseBlur={value:null},this._textureMatrix={value:null},this._hasBlur={value:!1},this._mirror={value:0},this._mixBlur={value:0},this._blurStrength={value:.5},this._minDepthThreshold={value:.9},this._maxDepthThreshold={value:1},this._depthScale={value:0},this._depthToBlurRatioBias={value:.25},this._distortion={value:1},this._mixContrast={value:1},this.setValues(e)}onBeforeCompile(e){var t;null!=(t=e.defines)&&t.USE_UV||(e.defines.USE_UV=""),e.uniforms.hasBlur=this._hasBlur,e.uniforms.tDiffuse=this._tDiffuse,e.uniforms.tDepth=this._tDepth,e.uniforms.distortionMap=this._distortionMap,e.uniforms.tDiffuseBlur=this._tDiffuseBlur,e.uniforms.textureMatrix=this._textureMatrix,e.uniforms.mirror=this._mirror,e.uniforms.mixBlur=this._mixBlur,e.uniforms.mixStrength=this._blurStrength,e.uniforms.minDepthThreshold=this._minDepthThreshold,e.uniforms.maxDepthThreshold=this._maxDepthThreshold,e.uniforms.depthScale=this._depthScale,e.uniforms.depthToBlurRatioBias=this._depthToBlurRatioBias,e.uniforms.distortion=this._distortion,e.uniforms.mixContrast=this._mixContrast,e.vertexShader=`\n        uniform mat4 textureMatrix;\n        varying vec4 my_vUv;\n      ${e.vertexShader}`,e.vertexShader=e.vertexShader.replace("#include <project_vertex>","#include <project_vertex>\n        my_vUv = textureMatrix * vec4( position, 1.0 );\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );"),e.fragmentShader=`\n        uniform sampler2D tDiffuse;\n        uniform sampler2D tDiffuseBlur;\n        uniform sampler2D tDepth;\n        uniform sampler2D distortionMap;\n        uniform float distortion;\n        uniform float cameraNear;\n\t\t\t  uniform float cameraFar;\n        uniform bool hasBlur;\n        uniform float mixBlur;\n        uniform float mirror;\n        uniform float mixStrength;\n        uniform float minDepthThreshold;\n        uniform float maxDepthThreshold;\n        uniform float mixContrast;\n        uniform float depthScale;\n        uniform float depthToBlurRatioBias;\n        varying vec4 my_vUv;\n        ${e.fragmentShader}`,e.fragmentShader=e.fragmentShader.replace("#include <emissivemap_fragment>","#include <emissivemap_fragment>\n\n      float distortionFactor = 0.0;\n      #ifdef USE_DISTORTION\n        distortionFactor = texture2D(distortionMap, vUv).r * distortion;\n      #endif\n\n      vec4 new_vUv = my_vUv;\n      new_vUv.x += distortionFactor;\n      new_vUv.y += distortionFactor;\n\n      vec4 base = texture2DProj(tDiffuse, new_vUv);\n      vec4 blur = texture2DProj(tDiffuseBlur, new_vUv);\n\n      vec4 merge = base;\n\n      #ifdef USE_NORMALMAP\n        vec2 normal_uv = vec2(0.0);\n        vec4 normalColor = texture2D(normalMap, vUv * normalScale);\n        vec3 my_normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );\n        vec3 coord = new_vUv.xyz / new_vUv.w;\n        normal_uv = coord.xy + coord.z * my_normal.xz * 0.05;\n        vec4 base_normal = texture2D(tDiffuse, normal_uv);\n        vec4 blur_normal = texture2D(tDiffuseBlur, normal_uv);\n        merge = base_normal;\n        blur = blur_normal;\n      #endif\n\n      float depthFactor = 0.0001;\n      float blurFactor = 0.0;\n\n      #ifdef USE_DEPTH\n        vec4 depth = texture2DProj(tDepth, new_vUv);\n        depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));\n        depthFactor *= depthScale;\n        depthFactor = max(0.0001, min(1.0, depthFactor));\n\n        #ifdef USE_BLUR\n          blur = blur * min(1.0, depthFactor + depthToBlurRatioBias);\n          merge = merge * min(1.0, depthFactor + 0.5);\n        #else\n          merge = merge * depthFactor;\n        #endif\n\n      #endif\n\n      float reflectorRoughnessFactor = roughness;\n      #ifdef USE_ROUGHNESSMAP\n        vec4 reflectorTexelRoughness = texture2D( roughnessMap, vUv );\n        reflectorRoughnessFactor *= reflectorTexelRoughness.g;\n      #endif\n\n      #ifdef USE_BLUR\n        blurFactor = min(1.0, mixBlur * reflectorRoughnessFactor);\n        merge = mix(merge, blur, blurFactor);\n      #endif\n\n      vec4 newMerge = vec4(0.0, 0.0, 0.0, 1.0);\n      newMerge.r = (merge.r - 0.5) * mixContrast + 0.5;\n      newMerge.g = (merge.g - 0.5) * mixContrast + 0.5;\n      newMerge.b = (merge.b - 0.5) * mixContrast + 0.5;\n\n      diffuseColor.rgb = diffuseColor.rgb * ((1.0 - min(1.0, mirror)) + newMerge.rgb * mixStrength);\n      ")}get tDiffuse(){return this._tDiffuse.value}set tDiffuse(e){this._tDiffuse.value=e}get tDepth(){return this._tDepth.value}set tDepth(e){this._tDepth.value=e}get distortionMap(){return this._distortionMap.value}set distortionMap(e){this._distortionMap.value=e}get tDiffuseBlur(){return this._tDiffuseBlur.value}set tDiffuseBlur(e){this._tDiffuseBlur.value=e}get textureMatrix(){return this._textureMatrix.value}set textureMatrix(e){this._textureMatrix.value=e}get hasBlur(){return this._hasBlur.value}set hasBlur(e){this._hasBlur.value=e}get mirror(){return this._mirror.value}set mirror(e){this._mirror.value=e}get mixBlur(){return this._mixBlur.value}set mixBlur(e){this._mixBlur.value=e}get mixStrength(){return this._blurStrength.value}set mixStrength(e){this._blurStrength.value=e}get minDepthThreshold(){return this._minDepthThreshold.value}set minDepthThreshold(e){this._minDepthThreshold.value=e}get maxDepthThreshold(){return this._maxDepthThreshold.value}set maxDepthThreshold(e){this._maxDepthThreshold.value=e}get depthScale(){return this._depthScale.value}set depthScale(e){this._depthScale.value=e}get depthToBlurRatioBias(){return this._depthToBlurRatioBias.value}set depthToBlurRatioBias(e){this._depthToBlurRatioBias.value=e}get distortion(){return this._distortion.value}set distortion(e){this._distortion.value=e}get mixContrast(){return this._mixContrast.value}set mixContrast(e){this._mixContrast.value=e}}exports.MeshReflectorMaterial=t;

package/materials/MeshReflectorMaterial.d.ts

@@ -0,0 +1,50 @@
+import { Matrix4, MeshStandardMaterial, Texture } from 'three';
+export declare class MeshReflectorMaterial extends MeshStandardMaterial {
+    private _tDepth;
+    private _distortionMap;
+    private _tDiffuse;
+    private _tDiffuseBlur;
+    private _textureMatrix;
+    private _hasBlur;
+    private _mirror;
+    private _mixBlur;
+    private _blurStrength;
+    private _minDepthThreshold;
+    private _maxDepthThreshold;
+    private _depthScale;
+    private _depthToBlurRatioBias;
+    private _distortion;
+    private _mixContrast;
+    constructor(parameters?: {});
+    onBeforeCompile(shader: any): void;
+    get tDiffuse(): Texture | null;
+    set tDiffuse(v: Texture | null);
+    get tDepth(): Texture | null;
+    set tDepth(v: Texture | null);
+    get distortionMap(): Texture | null;
+    set distortionMap(v: Texture | null);
+    get tDiffuseBlur(): Texture | null;
+    set tDiffuseBlur(v: Texture | null);
+    get textureMatrix(): Matrix4 | null;
+    set textureMatrix(v: Matrix4 | null);
+    get hasBlur(): boolean;
+    set hasBlur(v: boolean);
+    get mirror(): number;
+    set mirror(v: number);
+    get mixBlur(): number;
+    set mixBlur(v: number);
+    get mixStrength(): number;
+    set mixStrength(v: number);
+    get minDepthThreshold(): number;
+    set minDepthThreshold(v: number);
+    get maxDepthThreshold(): number;
+    set maxDepthThreshold(v: number);
+    get depthScale(): number;
+    set depthScale(v: number);
+    get depthToBlurRatioBias(): number;
+    set depthToBlurRatioBias(v: number);
+    get distortion(): number;
+    set distortion(v: number);
+    get mixContrast(): number;
+    set mixContrast(v: number);
+}