angular-three-soba 1.7.0 → 1.8.1

package/esm2020/shaders/lib/blur-pass/blur-pass.mjs

@@ -0,0 +1,61 @@
+import { BufferAttribute, BufferGeometry, Camera, LinearFilter, Mesh, Scene, Vector2, WebGLRenderTarget, } from 'three';
+import { ConvolutionMaterial } from '../convolution-material/convolution-material';
+export 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,
+            encoding: gl.outputEncoding,
+        });
+        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;
+        const material = this.convolutionMaterial;
+        const 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blur-pass.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/shaders/src/lib/blur-pass/blur-pass.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    BufferAttribute,\n    BufferGeometry,\n    Camera,\n    LinearFilter,\n    Mesh,\n    Scene,\n    Vector2,\n    WebGLRenderer,\n    WebGLRenderTarget,\n} from 'three';\n\nimport { ConvolutionMaterial } from '../convolution-material/convolution-material';\n\nexport interface BlurPassProps {\n    gl: WebGLRenderer;\n    resolution: number;\n    width?: number;\n    height?: number;\n    minDepthThreshold?: number;\n    maxDepthThreshold?: number;\n    depthScale?: number;\n    depthToBlurRatioBias?: number;\n}\n\nexport class BlurPass {\n    readonly renderTargetA: WebGLRenderTarget;\n    readonly renderTargetB: WebGLRenderTarget;\n    readonly convolutionMaterial: ConvolutionMaterial;\n    readonly scene: Scene;\n    readonly camera: Camera;\n    readonly screen: Mesh;\n    renderToScreen = false;\n\n    constructor({\n        gl,\n        resolution,\n        width = 500,\n        height = 500,\n        minDepthThreshold = 0,\n        maxDepthThreshold = 1,\n        depthScale = 0,\n        depthToBlurRatioBias = 0.25,\n    }: BlurPassProps) {\n        this.renderTargetA = new WebGLRenderTarget(resolution, resolution, {\n            minFilter: LinearFilter,\n            magFilter: LinearFilter,\n            stencilBuffer: false,\n            depthBuffer: false,\n            encoding: gl.outputEncoding,\n        });\n        this.renderTargetB = this.renderTargetA.clone();\n        this.convolutionMaterial = new ConvolutionMaterial();\n        this.convolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);\n        this.convolutionMaterial.setResolution(new Vector2(width, height));\n        this.scene = new Scene();\n        this.camera = new Camera();\n        this.convolutionMaterial.uniforms['minDepthThreshold'].value = minDepthThreshold;\n        this.convolutionMaterial.uniforms['maxDepthThreshold'].value = maxDepthThreshold;\n        this.convolutionMaterial.uniforms['depthScale'].value = depthScale;\n        this.convolutionMaterial.uniforms['depthToBlurRatioBias'].value = depthToBlurRatioBias;\n        this.convolutionMaterial.defines['USE_DEPTH'] = depthScale > 0;\n        const vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);\n        const uvs = new Float32Array([0, 0, 2, 0, 0, 2]);\n        const geometry = new BufferGeometry();\n        geometry.setAttribute('position', new BufferAttribute(vertices, 3));\n        geometry.setAttribute('uv', new BufferAttribute(uvs, 2));\n        this.screen = new Mesh(geometry, this.convolutionMaterial);\n        this.screen.frustumCulled = false;\n        this.scene.add(this.screen);\n    }\n\n    render(renderer: WebGLRenderer, inputBuffer: any, outputBuffer: any) {\n        const scene = this.scene;\n        const camera = this.camera;\n        const renderTargetA = this.renderTargetA;\n        const renderTargetB = this.renderTargetB;\n        const material = this.convolutionMaterial;\n        const uniforms = material.uniforms;\n        uniforms['depthBuffer'].value = inputBuffer.depthTexture;\n        const kernel = material.kernel;\n        let lastRT = inputBuffer;\n        let destRT;\n        let i, l;\n        // Apply the multi-pass blur.\n        for (i = 0, l = kernel.length - 1; i < l; ++i) {\n            // Alternate between targets.\n            destRT = (i & 1) === 0 ? renderTargetA : renderTargetB;\n            uniforms['kernel'].value = kernel[i];\n            uniforms['inputBuffer'].value = lastRT.texture;\n            renderer.setRenderTarget(destRT);\n            renderer.render(scene, camera);\n            lastRT = destRT;\n        }\n        uniforms['kernel'].value = kernel[i];\n        uniforms['inputBuffer'].value = lastRT.texture;\n        renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);\n        renderer.render(scene, camera);\n    }\n}\n"]}

package/esm2020/shaders/lib/convolution-material/convolution-material.mjs

@@ -0,0 +1,94 @@
+import { NoBlending, ShaderMaterial, Uniform, Vector2 } from 'three';
+export class ConvolutionMaterial extends ShaderMaterial {
+    constructor(texelSize = new Vector2()) {
+        super({
+            uniforms: {
+                inputBuffer: new Uniform(null),
+                depthBuffer: new Uniform(null),
+                resolution: new Uniform(new Vector2()),
+                texelSize: new Uniform(new Vector2()),
+                halfTexelSize: new Uniform(new Vector2()),
+                kernel: new Uniform(0.0),
+                scale: new Uniform(1.0),
+                cameraNear: new Uniform(0.0),
+                cameraFar: new Uniform(1.0),
+                minDepthThreshold: new Uniform(0.0),
+                maxDepthThreshold: new Uniform(1.0),
+                depthScale: new Uniform(0.0),
+                depthToBlurRatioBias: new 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 <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: 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shaders/lib/mesh-distort-material/mesh-distort-material.mjs

@@ -0,0 +1,55 @@
+import { InjectionToken } from '@angular/core';
+import * as THREE from 'three';
+export const NGTS_DISTORT_MATERIAL_SHADER = new InjectionToken('DistortMaterialShader');
+export function provideDistortMaterialShader(distortShader) {
+    return {
+        provide: NGTS_DISTORT_MATERIAL_SHADER,
+        useFactory: () => {
+            return class MeshDistortMaterial extends THREE.MeshPhysicalMaterial {
+                constructor(parameters = {}) {
+                    super(parameters);
+                    this.setValues(parameters);
+                    this._time = { value: 0 };
+                    this._distort = { value: 0.4 };
+                    this._radius = { value: 1 };
+                }
+                onBeforeCompile(shader) {
+                    shader.uniforms['time'] = this._time;
+                    shader.uniforms['radius'] = this._radius;
+                    shader.uniforms['distort'] = this._distort;
+                    shader.vertexShader = `
+									    uniform float time;
+									    uniform float radius;
+									    uniform float distort;
+									    ${distortShader}
+									    ${shader.vertexShader}
+									  `;
+                    shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `
+									      float updateTime = time / 50.0;
+									      float noise = snoise(vec3(position / 2.0 + updateTime * 5.0));
+									      vec3 transformed = vec3(position * (noise * pow(distort, 2.0) + radius));
+									      `);
+                }
+                get time() {
+                    return this._time.value;
+                }
+                set time(v) {
+                    this._time.value = v;
+                }
+                get distort() {
+                    return this._distort.value;
+                }
+                set distort(v) {
+                    this._distort.value = v;
+                }
+                get radius() {
+                    return this._radius.value;
+                }
+                set radius(v) {
+                    this._radius.value = v;
+                }
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shaders/lib/mesh-reflector-material/mesh-reflector-material.mjs

@@ -0,0 +1,223 @@
+import { MeshStandardMaterial } from 'three';
+export class MeshReflectorMaterial extends MeshStandardMaterial {
+    constructor(parameters = {}) {
+        super(parameters);
+        this._tDepth = { value: null };
+        this._distortionMap = { value: null };
+        this._tDiffuse = { value: null };
+        this._tDiffuseBlur = { value: null };
+        this._textureMatrix = { value: null };
+        this._hasBlur = { value: false };
+        this._mirror = { value: 0.0 };
+        this._mixBlur = { value: 0.0 };
+        this._blurStrength = { value: 0.5 };
+        this._minDepthThreshold = { value: 0.9 };
+        this._maxDepthThreshold = { value: 1 };
+        this._depthScale = { value: 0 };
+        this._depthToBlurRatioBias = { value: 0.25 };
+        this._distortion = { value: 1 };
+        this._mixContrast = { value: 1.0 };
+        this.setValues(parameters);
+    }
+    onBeforeCompile(shader) {
+        if (!shader.defines?.USE_UV) {
+            shader.defines.USE_UV = '';
+        }
+        shader.uniforms.hasBlur = this._hasBlur;
+        shader.uniforms.tDiffuse = this._tDiffuse;
+        shader.uniforms.tDepth = this._tDepth;
+        shader.uniforms.distortionMap = this._distortionMap;
+        shader.uniforms.tDiffuseBlur = this._tDiffuseBlur;
+        shader.uniforms.textureMatrix = this._textureMatrix;
+        shader.uniforms.mirror = this._mirror;
+        shader.uniforms.mixBlur = this._mixBlur;
+        shader.uniforms.mixStrength = this._blurStrength;
+        shader.uniforms.minDepthThreshold = this._minDepthThreshold;
+        shader.uniforms.maxDepthThreshold = this._maxDepthThreshold;
+        shader.uniforms.depthScale = this._depthScale;
+        shader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;
+        shader.uniforms.distortion = this._distortion;
+        shader.uniforms.mixContrast = this._mixContrast;
+        shader.vertexShader = `
+        uniform mat4 textureMatrix;
+        varying vec4 my_vUv;
+      ${shader.vertexShader}`;
+        shader.vertexShader = shader.vertexShader.replace('#include <project_vertex>', `#include <project_vertex>
+        my_vUv = textureMatrix * vec4( position, 1.0 );
+        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`);
+        shader.fragmentShader = `
+        uniform sampler2D tDiffuse;
+        uniform sampler2D tDiffuseBlur;
+        uniform sampler2D tDepth;
+        uniform sampler2D distortionMap;
+        uniform float distortion;
+        uniform float cameraNear;
+			  uniform float cameraFar;
+        uniform bool hasBlur;
+        uniform float mixBlur;
+        uniform float mirror;
+        uniform float mixStrength;
+        uniform float minDepthThreshold;
+        uniform float maxDepthThreshold;
+        uniform float mixContrast;
+        uniform float depthScale;
+        uniform float depthToBlurRatioBias;
+        varying vec4 my_vUv;
+        ${shader.fragmentShader}`;
+        shader.fragmentShader = shader.fragmentShader.replace('#include <emissivemap_fragment>', `#include <emissivemap_fragment>
+
+      float distortionFactor = 0.0;
+      #ifdef USE_DISTORTION
+        distortionFactor = texture2D(distortionMap, vUv).r * distortion;
+      #endif
+
+      vec4 new_vUv = my_vUv;
+      new_vUv.x += distortionFactor;
+      new_vUv.y += distortionFactor;
+
+      vec4 base = texture2DProj(tDiffuse, new_vUv);
+      vec4 blur = texture2DProj(tDiffuseBlur, new_vUv);
+
+      vec4 merge = base;
+
+      #ifdef USE_NORMALMAP
+        vec2 normal_uv = vec2(0.0);
+        vec4 normalColor = texture2D(normalMap, vUv * normalScale);
+        vec3 my_normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );
+        vec3 coord = new_vUv.xyz / new_vUv.w;
+        normal_uv = coord.xy + coord.z * my_normal.xz * 0.05;
+        vec4 base_normal = texture2D(tDiffuse, normal_uv);
+        vec4 blur_normal = texture2D(tDiffuseBlur, normal_uv);
+        merge = base_normal;
+        blur = blur_normal;
+      #endif
+
+      float depthFactor = 0.0001;
+      float blurFactor = 0.0;
+
+      #ifdef USE_DEPTH
+        vec4 depth = texture2DProj(tDepth, new_vUv);
+        depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
+        depthFactor *= depthScale;
+        depthFactor = max(0.0001, min(1.0, depthFactor));
+
+        #ifdef USE_BLUR
+          blur = blur * min(1.0, depthFactor + depthToBlurRatioBias);
+          merge = merge * min(1.0, depthFactor + 0.5);
+        #else
+          merge = merge * depthFactor;
+        #endif
+
+      #endif
+
+      float reflectorRoughnessFactor = roughness;
+      #ifdef USE_ROUGHNESSMAP
+        vec4 reflectorTexelRoughness = texture2D( roughnessMap, vUv );
+        reflectorRoughnessFactor *= reflectorTexelRoughness.g;
+      #endif
+
+      #ifdef USE_BLUR
+        blurFactor = min(1.0, mixBlur * reflectorRoughnessFactor);
+        merge = mix(merge, blur, blurFactor);
+      #endif
+
+      vec4 newMerge = vec4(0.0, 0.0, 0.0, 1.0);
+      newMerge.r = (merge.r - 0.5) * mixContrast + 0.5;
+      newMerge.g = (merge.g - 0.5) * mixContrast + 0.5;
+      newMerge.b = (merge.b - 0.5) * mixContrast + 0.5;
+
+      diffuseColor.rgb = diffuseColor.rgb * ((1.0 - min(1.0, mirror)) + newMerge.rgb * mixStrength);
+      `);
+    }
+    get tDiffuse() {
+        return this._tDiffuse.value;
+    }
+    set tDiffuse(v) {
+        this._tDiffuse.value = v;
+    }
+    get tDepth() {
+        return this._tDepth.value;
+    }
+    set tDepth(v) {
+        this._tDepth.value = v;
+    }
+    get distortionMap() {
+        return this._distortionMap.value;
+    }
+    set distortionMap(v) {
+        this._distortionMap.value = v;
+    }
+    get tDiffuseBlur() {
+        return this._tDiffuseBlur.value;
+    }
+    set tDiffuseBlur(v) {
+        this._tDiffuseBlur.value = v;
+    }
+    get textureMatrix() {
+        return this._textureMatrix.value;
+    }
+    set textureMatrix(v) {
+        this._textureMatrix.value = v;
+    }
+    get hasBlur() {
+        return this._hasBlur.value;
+    }
+    set hasBlur(v) {
+        this._hasBlur.value = v;
+    }
+    get mirror() {
+        return this._mirror.value;
+    }
+    set mirror(v) {
+        this._mirror.value = v;
+    }
+    get mixBlur() {
+        return this._mixBlur.value;
+    }
+    set mixBlur(v) {
+        this._mixBlur.value = v;
+    }
+    get mixStrength() {
+        return this._blurStrength.value;
+    }
+    set mixStrength(v) {
+        this._blurStrength.value = v;
+    }
+    get minDepthThreshold() {
+        return this._minDepthThreshold.value;
+    }
+    set minDepthThreshold(v) {
+        this._minDepthThreshold.value = v;
+    }
+    get maxDepthThreshold() {
+        return this._maxDepthThreshold.value;
+    }
+    set maxDepthThreshold(v) {
+        this._maxDepthThreshold.value = v;
+    }
+    get depthScale() {
+        return this._depthScale.value;
+    }
+    set depthScale(v) {
+        this._depthScale.value = v;
+    }
+    get depthToBlurRatioBias() {
+        return this._depthToBlurRatioBias.value;
+    }
+    set depthToBlurRatioBias(v) {
+        this._depthToBlurRatioBias.value = v;
+    }
+    get distortion() {
+        return this._distortion.value;
+    }
+    set distortion(v) {
+        this._distortion.value = v;
+    }
+    get mixContrast() {
+        return this._mixContrast.value;
+    }
+    set mixContrast(v) {
+        this._mixContrast.value = v;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mesh-reflector-material.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/shaders/src/lib/mesh-reflector-material/mesh-reflector-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,oBAAoB,EAAW,MAAM,OAAO,CAAC;AAI/D,MAAM,OAAO,qBAAsB,SAAQ,oBAAoB;IAiB3D,YAAY,UAAU,GAAG,EAAE;QACvB,KAAK,CAAC,UAAU,CAAC,CAAC;QAjBd,YAAO,GAAkC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACzD,mBAAc,GAAkC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAChE,cAAS,GAAkC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAC3D,kBAAa,GAAkC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAC/D,mBAAc,GAAkC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAChE,aAAQ,GAAuB,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAChD,YAAO,GAAsB,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAC5C,aAAQ,GAAsB,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAC7C,kBAAa,GAAsB,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAClD,uBAAkB,GAAsB,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QACvD,uBAAkB,GAAsB,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QACrD,gBAAW,GAAsB,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAC9C,0BAAqB,GAAsB,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAC3D,gBAAW,GAAsB,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAC9C,iBAAY,GAAsB,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAIrD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC;IAEQ,eAAe,CAAC,MAAW;QAChC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE;YACzB,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;SAC9B;QACD,MAAM,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QACxC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;QAC1C,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;QACtC,MAAM,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC;QACpD,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC;QAClD,MAAM,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC;QACpD,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;QACtC,MAAM,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QACxC,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC;QACjD,MAAM,CAAC,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAC5D,MAAM,CAAC,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAC5D,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QAC9C,MAAM,CAAC,QAAQ,CAAC,oBAAoB,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAClE,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QAC9C,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC;QAChD,MAAM,CAAC,YAAY,GAAG;;;QAGtB,MAAM,CAAC,YAAY,EAAE,CAAC;QACtB,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAC7C,2BAA2B,EAC3B;;kFAEsE,CACzE,CAAC;QACF,MAAM,CAAC,cAAc,GAAG;;;;;;;;;;;;;;;;;;UAkBtB,MAAM,CAAC,cAAc,EAAE,CAAC;QAC1B,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CACjD,iCAAiC,EACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DL,CACE,CAAC;IACN,CAAC;IACD,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAChC,CAAC;IACD,IAAI,QAAQ,CAAC,CAAiB;QAC1B,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC;IAC7B,CAAC;IACD,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IAC9B,CAAC;IACD,IAAI,MAAM,CAAC,CAAiB;QACxB,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;IAC3B,CAAC;IACD,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;IACrC,CAAC;IACD,IAAI,aAAa,CAAC,CAAiB;QAC/B,IAAI,CAAC,cAAc,CAAC,KAAK,GAAG,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;IACpC,CAAC;IACD,IAAI,YAAY,CAAC,CAAiB;QAC9B,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;IACrC,CAAC;IACD,IAAI,aAAa,CAAC,CAAiB;QAC/B,IAAI,CAAC,cAAc,CAAC,KAAK,GAAG,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,OAAO,CAAC,CAAU;QAClB,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IAC9B,CAAC;IACD,IAAI,MAAM,CAAC,CAAS;QAChB,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;IAC3B,CAAC;IACD,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,OAAO,CAAC,CAAS;QACjB,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,WAAW;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;IACpC,CAAC;IACD,IAAI,WAAW,CAAC,CAAS;QACrB,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;IACzC,CAAC;IACD,IAAI,iBAAiB,CAAC,CAAS;QAC3B,IAAI,CAAC,kBAAkB,CAAC,KAAK,GAAG,CAAC,CAAC;IACtC,CAAC;IACD,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;IACzC,CAAC;IACD,IAAI,iBAAiB,CAAC,CAAS;QAC3B,IAAI,CAAC,kBAAkB,CAAC,KAAK,GAAG,CAAC,CAAC;IACtC,CAAC;IACD,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,UAAU,CAAC,CAAS;QACpB,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;IAC/B,CAAC;IACD,IAAI,oBAAoB;QACpB,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;IAC5C,CAAC;IACD,IAAI,oBAAoB,CAAC,CAAS;QAC9B,IAAI,CAAC,qBAAqB,CAAC,KAAK,GAAG,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,UAAU,CAAC,CAAS;QACpB,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;IAC/B,CAAC;IACD,IAAI,WAAW;QACX,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,WAAW,CAAC,CAAS;QACrB,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,CAAC,CAAC;IAChC,CAAC;CACJ","sourcesContent":["import { Matrix4, MeshStandardMaterial, Texture } from 'three';\n\ntype UninitializedUniform<Value> = { value: Value | null };\n\nexport class MeshReflectorMaterial extends MeshStandardMaterial {\n    private _tDepth: UninitializedUniform<Texture> = { value: null };\n    private _distortionMap: UninitializedUniform<Texture> = { value: null };\n    private _tDiffuse: UninitializedUniform<Texture> = { value: null };\n    private _tDiffuseBlur: UninitializedUniform<Texture> = { value: null };\n    private _textureMatrix: UninitializedUniform<Matrix4> = { value: null };\n    private _hasBlur: { value: boolean } = { value: false };\n    private _mirror: { value: number } = { value: 0.0 };\n    private _mixBlur: { value: number } = { value: 0.0 };\n    private _blurStrength: { value: number } = { value: 0.5 };\n    private _minDepthThreshold: { value: number } = { value: 0.9 };\n    private _maxDepthThreshold: { value: number } = { value: 1 };\n    private _depthScale: { value: number } = { value: 0 };\n    private _depthToBlurRatioBias: { value: number } = { value: 0.25 };\n    private _distortion: { value: number } = { value: 1 };\n    private _mixContrast: { value: number } = { value: 1.0 };\n\n    constructor(parameters = {}) {\n        super(parameters);\n        this.setValues(parameters);\n    }\n\n    override onBeforeCompile(shader: any) {\n        if (!shader.defines?.USE_UV) {\n            shader.defines.USE_UV = '';\n        }\n        shader.uniforms.hasBlur = this._hasBlur;\n        shader.uniforms.tDiffuse = this._tDiffuse;\n        shader.uniforms.tDepth = this._tDepth;\n        shader.uniforms.distortionMap = this._distortionMap;\n        shader.uniforms.tDiffuseBlur = this._tDiffuseBlur;\n        shader.uniforms.textureMatrix = this._textureMatrix;\n        shader.uniforms.mirror = this._mirror;\n        shader.uniforms.mixBlur = this._mixBlur;\n        shader.uniforms.mixStrength = this._blurStrength;\n        shader.uniforms.minDepthThreshold = this._minDepthThreshold;\n        shader.uniforms.maxDepthThreshold = this._maxDepthThreshold;\n        shader.uniforms.depthScale = this._depthScale;\n        shader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;\n        shader.uniforms.distortion = this._distortion;\n        shader.uniforms.mixContrast = this._mixContrast;\n        shader.vertexShader = `\n        uniform mat4 textureMatrix;\n        varying vec4 my_vUv;\n      ${shader.vertexShader}`;\n        shader.vertexShader = shader.vertexShader.replace(\n            '#include <project_vertex>',\n            `#include <project_vertex>\n        my_vUv = textureMatrix * vec4( position, 1.0 );\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`\n        );\n        shader.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        ${shader.fragmentShader}`;\n        shader.fragmentShader = shader.fragmentShader.replace(\n            '#include <emissivemap_fragment>',\n            `#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      `\n        );\n    }\n    get tDiffuse(): Texture | null {\n        return this._tDiffuse.value;\n    }\n    set tDiffuse(v: Texture | null) {\n        this._tDiffuse.value = v;\n    }\n    get tDepth(): Texture | null {\n        return this._tDepth.value;\n    }\n    set tDepth(v: Texture | null) {\n        this._tDepth.value = v;\n    }\n    get distortionMap(): Texture | null {\n        return this._distortionMap.value;\n    }\n    set distortionMap(v: Texture | null) {\n        this._distortionMap.value = v;\n    }\n    get tDiffuseBlur(): Texture | null {\n        return this._tDiffuseBlur.value;\n    }\n    set tDiffuseBlur(v: Texture | null) {\n        this._tDiffuseBlur.value = v;\n    }\n    get textureMatrix(): Matrix4 | null {\n        return this._textureMatrix.value;\n    }\n    set textureMatrix(v: Matrix4 | null) {\n        this._textureMatrix.value = v;\n    }\n    get hasBlur(): boolean {\n        return this._hasBlur.value;\n    }\n    set hasBlur(v: boolean) {\n        this._hasBlur.value = v;\n    }\n    get mirror(): number {\n        return this._mirror.value;\n    }\n    set mirror(v: number) {\n        this._mirror.value = v;\n    }\n    get mixBlur(): number {\n        return this._mixBlur.value;\n    }\n    set mixBlur(v: number) {\n        this._mixBlur.value = v;\n    }\n    get mixStrength(): number {\n        return this._blurStrength.value;\n    }\n    set mixStrength(v: number) {\n        this._blurStrength.value = v;\n    }\n    get minDepthThreshold(): number {\n        return this._minDepthThreshold.value;\n    }\n    set minDepthThreshold(v: number) {\n        this._minDepthThreshold.value = v;\n    }\n    get maxDepthThreshold(): number {\n        return this._maxDepthThreshold.value;\n    }\n    set maxDepthThreshold(v: number) {\n        this._maxDepthThreshold.value = v;\n    }\n    get depthScale(): number {\n        return this._depthScale.value;\n    }\n    set depthScale(v: number) {\n        this._depthScale.value = v;\n    }\n    get depthToBlurRatioBias(): number {\n        return this._depthToBlurRatioBias.value;\n    }\n    set depthToBlurRatioBias(v: number) {\n        this._depthToBlurRatioBias.value = v;\n    }\n    get distortion(): number {\n        return this._distortion.value;\n    }\n    set distortion(v: number) {\n        this._distortion.value = v;\n    }\n    get mixContrast(): number {\n        return this._mixContrast.value;\n    }\n    set mixContrast(v: number) {\n        this._mixContrast.value = v;\n    }\n}\n"]}

package/esm2020/shaders/lib/mesh-wobble-material/mesh-wobble-material.mjs

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+export class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.setValues(parameters);
+        this._time = { value: 0 };
+        this._factor = { value: 1 };
+    }
+    onBeforeCompile(shader) {
+        shader.uniforms['time'] = this._time;
+        shader.uniforms['factor'] = this._factor;
+        shader.vertexShader = `
+      uniform float time;
+      uniform float factor;
+      ${shader.vertexShader}
+    `;
+        shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', `float theta = sin( time + position.y ) / 2.0 * factor;
+        float c = cos( theta );
+        float s = sin( theta );
+        mat3 m = mat3( c, 0, s, 0, 1, 0, -s, 0, c );
+        vec3 transformed = vec3( position ) * m;
+        vNormal = vNormal * m;`);
+    }
+    get time() {
+        return this._time.value;
+    }
+    set time(v) {
+        this._time.value = v;
+    }
+    get factor() {
+        return this._factor.value;
+    }
+    set factor(v) {
+        this._factor.value = v;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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