angular-three-soba 1.13.0 → 2.0.0-beta.2

package/esm2022/shaders/blur-pass/blur-pass.mjs

@@ -0,0 +1,61 @@
+import { BufferAttribute, BufferGeometry, HalfFloatType, LinearFilter, Mesh, PerspectiveCamera, 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,
+            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 PerspectiveCamera();
+        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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blur-pass.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/blur-pass/blur-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,eAAe,EACf,cAAc,EAEd,aAAa,EACb,YAAY,EACZ,IAAI,EACJ,iBAAiB,EACjB,KAAK,EACL,OAAO,EACP,iBAAiB,GAEpB,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAanF,MAAM,OAAO,QAAQ;IASjB,YAAY,EACR,EAAE,EACF,UAAU,EACV,KAAK,GAAG,GAAG,EACX,MAAM,GAAG,GAAG,EACZ,iBAAiB,GAAG,CAAC,EACrB,iBAAiB,GAAG,CAAC,EACrB,UAAU,GAAG,CAAC,EACd,oBAAoB,GAAG,IAAI,GACf;QAXhB,mBAAc,GAAY,KAAK,CAAC;QAY5B,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE;YAC/D,SAAS,EAAE,YAAY;YACvB,SAAS,EAAE,YAAY;YACvB,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,KAAK;YAClB,IAAI,EAAE,aAAa;SACtB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAChD,IAAI,CAAC,mBAAmB,GAAG,IAAI,mBAAmB,EAAE,CAAC;QACrD,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,GAAG,GAAG,KAAK,EAAE,GAAG,GAAG,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;QACtC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,KAAK,GAAG,iBAAiB,CAAC;QACjF,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,KAAK,GAAG,iBAAiB,CAAC;QACjF,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,KAAK,GAAG,UAAU,CAAC;QACnE,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC,KAAK,GAAG,oBAAoB,CAAC;QACvF,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACnE,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACjD,MAAM,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC;QACtC,QAAQ,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,eAAe,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;QACpE,QAAQ,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,KAAK,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,MAAM,CAAC,QAAuB,EAAE,WAA8B,EAAE,YAA+B;QAC3F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,IAAI,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACxC,IAAI,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QACjC,QAAQ,CAAC,aAAa,CAAC,CAAC,KAAK,GAAG,WAAW,CAAC,YAAY,CAAC;QACzD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC/B,IAAI,MAAM,GAAG,WAAW,CAAC;QACzB,IAAI,MAAM,CAAC;QACX,IAAI,CAAC,EAAE,CAAC,CAAC;QACT,6BAA6B;QAC7B,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE;YAC3C,6BAA6B;YAC7B,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC;YACvD,QAAQ,CAAC,QAAQ,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACrC,QAAQ,CAAC,aAAa,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC;YAC/C,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YACjC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC/B,MAAM,GAAG,MAAM,CAAC;SACnB;QACD,QAAQ,CAAC,QAAQ,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACrC,QAAQ,CAAC,aAAa,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/C,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QACpE,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;CACJ","sourcesContent":["import {\n    BufferAttribute,\n    BufferGeometry,\n    Camera,\n    HalfFloatType,\n    LinearFilter,\n    Mesh,\n    PerspectiveCamera,\n    Scene,\n    Vector2,\n    WebGLRenderTarget,\n    WebGLRenderer,\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: boolean = 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            type: HalfFloatType,\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 PerspectiveCamera();\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: WebGLRenderTarget, outputBuffer: WebGLRenderTarget) {\n        const scene = this.scene;\n        const camera = this.camera;\n        const renderTargetA = this.renderTargetA;\n        const renderTargetB = this.renderTargetB;\n        let material = this.convolutionMaterial;\n        let 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/esm2022/shaders/caustics-material/caustics-material.mjs

@@ -0,0 +1,128 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export const CausticsMaterial = shaderMaterial({
+    cameraMatrixWorld: new THREE.Matrix4(),
+    cameraProjectionMatrixInv: new THREE.Matrix4(),
+    normalTexture: null,
+    depthTexture: null,
+    lightDir: new THREE.Vector3(0, 1, 0),
+    lightPlaneNormal: new THREE.Vector3(0, 1, 0),
+    lightPlaneConstant: 0,
+    near: 0.1,
+    far: 100,
+    modelMatrix: new THREE.Matrix4(),
+    worldRadius: 1 / 40,
+    ior: 1.1,
+    bounces: 0,
+    resolution: 1024,
+    size: 10,
+    intensity: 0.5,
+}, 
+/* glsl */ `varying vec2 vUv;
+void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`, 
+/* glsl */ `uniform mat4 cameraMatrixWorld;
+uniform mat4 cameraProjectionMatrixInv;
+uniform vec3 lightDir;
+uniform vec3 lightPlaneNormal;
+uniform float lightPlaneConstant;
+uniform float near;
+uniform float far;
+uniform float time;
+uniform float worldRadius;
+uniform float resolution;
+uniform float size;
+uniform float intensity;
+uniform float ior;
+precision highp isampler2D;
+precision highp usampler2D;
+uniform sampler2D normalTexture;
+uniform sampler2D depthTexture;
+uniform float bounces;
+varying vec2 vUv;
+vec3 WorldPosFromDepth(float depth, vec2 coord) {
+  float z = depth * 2.0 - 1.0;
+  vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);
+  vec4 viewSpacePosition = cameraProjectionMatrixInv * clipSpacePosition;
+  // Perspective division
+  viewSpacePosition /= viewSpacePosition.w;
+  vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;
+  return worldSpacePosition.xyz;
+}
+float sdPlane( vec3 p, vec3 n, float h ) {
+  // n must be normalized
+  return dot(p,n) + h;
+}
+float planeIntersect( vec3 ro, vec3 rd, vec4 p ) {
+  return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz);
+}
+vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 pos, vec3 normal, float ior, out vec3 rayOrigin, out vec3 rayDirection) {
+  rayOrigin = ro;
+  rayDirection = rd;
+  rayDirection = refract(rayDirection, normal, 1.0 / ior);
+  rayOrigin = pos + rayDirection * 0.1;
+  return rayDirection;
+}
+void main() {
+  // Each sample consists of random offset in the x and y direction
+  float caustic = 0.0;
+  float causticTexelSize = (1.0 / resolution) * size * 2.0;
+  float texelsNeeded = worldRadius / causticTexelSize;
+  float sampleRadius = texelsNeeded / resolution;
+  float sum = 0.0;
+  if (texture2D(depthTexture, vUv).x == 1.0) {
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    return;
+  }
+  vec2 offset1 = vec2(-0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);
+  vec2 offset2 = vec2(-0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
+  vec2 offset3 = vec2(0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
+  vec2 offset4 = vec2(0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);
+  vec2 uv1 = vUv + offset1 * sampleRadius;
+  vec2 uv2 = vUv + offset2 * sampleRadius;
+  vec2 uv3 = vUv + offset3 * sampleRadius;
+  vec2 uv4 = vUv + offset4 * sampleRadius;
+  vec3 normal1 = texture2D(normalTexture, uv1, -10.0).rgb * 2.0 - 1.0;
+  vec3 normal2 = texture2D(normalTexture, uv2, -10.0).rgb * 2.0 - 1.0;
+  vec3 normal3 = texture2D(normalTexture, uv3, -10.0).rgb * 2.0 - 1.0;
+  vec3 normal4 = texture2D(normalTexture, uv4, -10.0).rgb * 2.0 - 1.0;
+  float depth1 = texture2D(depthTexture, uv1, -10.0).x;
+  float depth2 = texture2D(depthTexture, uv2, -10.0).x;
+  float depth3 = texture2D(depthTexture, uv3, -10.0).x;
+  float depth4 = texture2D(depthTexture, uv4, -10.0).x;
+  // Sanity check the depths
+  if (depth1 == 1.0 || depth2 == 1.0 || depth3 == 1.0 || depth4 == 1.0) {
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    return;
+  }
+  vec3 pos1 = WorldPosFromDepth(depth1, uv1);
+  vec3 pos2 = WorldPosFromDepth(depth2, uv2);
+  vec3 pos3 = WorldPosFromDepth(depth3, uv3);
+  vec3 pos4 = WorldPosFromDepth(depth4, uv4);
+  vec3 originPos1 = WorldPosFromDepth(0.0, uv1);
+  vec3 originPos2 = WorldPosFromDepth(0.0, uv2);
+  vec3 originPos3 = WorldPosFromDepth(0.0, uv3);
+  vec3 originPos4 = WorldPosFromDepth(0.0, uv4);
+  vec3 endPos1, endPos2, endPos3, endPos4;
+  vec3 endDir1, endDir2, endDir3, endDir4;
+  totalInternalReflection(originPos1, lightDir, pos1, normal1, ior, endPos1, endDir1);
+  totalInternalReflection(originPos2, lightDir, pos2, normal2, ior, endPos2, endDir2);
+  totalInternalReflection(originPos3, lightDir, pos3, normal3, ior, endPos3, endDir3);
+  totalInternalReflection(originPos4, lightDir, pos4, normal4, ior, endPos4, endDir4);
+  float lightPosArea = length(cross(originPos2 - originPos1, originPos3 - originPos1)) + length(cross(originPos3 - originPos1, originPos4 - originPos1));
+  float t1 = planeIntersect(endPos1, endDir1, vec4(lightPlaneNormal, lightPlaneConstant));
+  float t2 = planeIntersect(endPos2, endDir2, vec4(lightPlaneNormal, lightPlaneConstant));
+  float t3 = planeIntersect(endPos3, endDir3, vec4(lightPlaneNormal, lightPlaneConstant));
+  float t4 = planeIntersect(endPos4, endDir4, vec4(lightPlaneNormal, lightPlaneConstant));
+  vec3 finalPos1 = endPos1 + endDir1 * t1;
+  vec3 finalPos2 = endPos2 + endDir2 * t2;
+  vec3 finalPos3 = endPos3 + endDir3 * t3;
+  vec3 finalPos4 = endPos4 + endDir4 * t4;
+  float finalArea = length(cross(finalPos2 - finalPos1, finalPos3 - finalPos1)) + length(cross(finalPos3 - finalPos1, finalPos4 - finalPos1));
+  caustic += intensity * (lightPosArea / finalArea);
+  // Calculate the area of the triangle in light spaces
+  gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);
+}`);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caustics-material.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/caustics-material/caustics-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAC1C;IACI,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IACtC,yBAAyB,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IAC9C,aAAa,EAAE,IAAI;IACnB,YAAY,EAAE,IAAI;IAClB,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACpC,gBAAgB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC5C,kBAAkB,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG;IACT,GAAG,EAAE,GAAG;IACR,WAAW,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IAChC,WAAW,EAAE,CAAC,GAAG,EAAE;IACnB,GAAG,EAAE,GAAG;IACR,OAAO,EAAE,CAAC;IACV,UAAU,EAAE,IAAI;IAChB,IAAI,EAAE,EAAE;IACR,SAAS,EAAE,GAAG;CACjB;AACD,UAAU,CAAC;;;;EAIb;AACE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGb,CACD,CAAC","sourcesContent":["import * as THREE from 'three';\nimport { shaderMaterial } from '../shader-material/shader-material';\n\nexport const CausticsMaterial = shaderMaterial(\n    {\n        cameraMatrixWorld: new THREE.Matrix4(),\n        cameraProjectionMatrixInv: new THREE.Matrix4(),\n        normalTexture: null,\n        depthTexture: null,\n        lightDir: new THREE.Vector3(0, 1, 0),\n        lightPlaneNormal: new THREE.Vector3(0, 1, 0),\n        lightPlaneConstant: 0,\n        near: 0.1,\n        far: 100,\n        modelMatrix: new THREE.Matrix4(),\n        worldRadius: 1 / 40,\n        ior: 1.1,\n        bounces: 0,\n        resolution: 1024,\n        size: 10,\n        intensity: 0.5,\n    },\n    /* glsl */ `varying vec2 vUv;\nvoid main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n}`,\n    /* glsl */ `uniform mat4 cameraMatrixWorld;\nuniform mat4 cameraProjectionMatrixInv;\nuniform vec3 lightDir;\nuniform vec3 lightPlaneNormal;\nuniform float lightPlaneConstant;\nuniform float near;\nuniform float far;\nuniform float time;\nuniform float worldRadius;\nuniform float resolution;\nuniform float size;\nuniform float intensity;\nuniform float ior;\nprecision highp isampler2D;\nprecision highp usampler2D;\nuniform sampler2D normalTexture;\nuniform sampler2D depthTexture;\nuniform float bounces;\nvarying vec2 vUv;\nvec3 WorldPosFromDepth(float depth, vec2 coord) {\n  float z = depth * 2.0 - 1.0;\n  vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);\n  vec4 viewSpacePosition = cameraProjectionMatrixInv * clipSpacePosition;\n  // Perspective division\n  viewSpacePosition /= viewSpacePosition.w;\n  vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;\n  return worldSpacePosition.xyz;\n}\nfloat sdPlane( vec3 p, vec3 n, float h ) {\n  // n must be normalized\n  return dot(p,n) + h;\n}\nfloat planeIntersect( vec3 ro, vec3 rd, vec4 p ) {\n  return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz);\n}\nvec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 pos, vec3 normal, float ior, out vec3 rayOrigin, out vec3 rayDirection) {\n  rayOrigin = ro;\n  rayDirection = rd;\n  rayDirection = refract(rayDirection, normal, 1.0 / ior);\n  rayOrigin = pos + rayDirection * 0.1;\n  return rayDirection;\n}\nvoid main() {\n  // Each sample consists of random offset in the x and y direction\n  float caustic = 0.0;\n  float causticTexelSize = (1.0 / resolution) * size * 2.0;\n  float texelsNeeded = worldRadius / causticTexelSize;\n  float sampleRadius = texelsNeeded / resolution;\n  float sum = 0.0;\n  if (texture2D(depthTexture, vUv).x == 1.0) {\n    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);\n    return;\n  }\n  vec2 offset1 = vec2(-0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);\n  vec2 offset2 = vec2(-0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);\n  vec2 offset3 = vec2(0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);\n  vec2 offset4 = vec2(0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);\n  vec2 uv1 = vUv + offset1 * sampleRadius;\n  vec2 uv2 = vUv + offset2 * sampleRadius;\n  vec2 uv3 = vUv + offset3 * sampleRadius;\n  vec2 uv4 = vUv + offset4 * sampleRadius;\n  vec3 normal1 = texture2D(normalTexture, uv1, -10.0).rgb * 2.0 - 1.0;\n  vec3 normal2 = texture2D(normalTexture, uv2, -10.0).rgb * 2.0 - 1.0;\n  vec3 normal3 = texture2D(normalTexture, uv3, -10.0).rgb * 2.0 - 1.0;\n  vec3 normal4 = texture2D(normalTexture, uv4, -10.0).rgb * 2.0 - 1.0;\n  float depth1 = texture2D(depthTexture, uv1, -10.0).x;\n  float depth2 = texture2D(depthTexture, uv2, -10.0).x;\n  float depth3 = texture2D(depthTexture, uv3, -10.0).x;\n  float depth4 = texture2D(depthTexture, uv4, -10.0).x;\n  // Sanity check the depths\n  if (depth1 == 1.0 || depth2 == 1.0 || depth3 == 1.0 || depth4 == 1.0) {\n    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);\n    return;\n  }\n  vec3 pos1 = WorldPosFromDepth(depth1, uv1);\n  vec3 pos2 = WorldPosFromDepth(depth2, uv2);\n  vec3 pos3 = WorldPosFromDepth(depth3, uv3);\n  vec3 pos4 = WorldPosFromDepth(depth4, uv4);\n  vec3 originPos1 = WorldPosFromDepth(0.0, uv1);\n  vec3 originPos2 = WorldPosFromDepth(0.0, uv2);\n  vec3 originPos3 = WorldPosFromDepth(0.0, uv3);\n  vec3 originPos4 = WorldPosFromDepth(0.0, uv4);\n  vec3 endPos1, endPos2, endPos3, endPos4;\n  vec3 endDir1, endDir2, endDir3, endDir4;\n  totalInternalReflection(originPos1, lightDir, pos1, normal1, ior, endPos1, endDir1);\n  totalInternalReflection(originPos2, lightDir, pos2, normal2, ior, endPos2, endDir2);\n  totalInternalReflection(originPos3, lightDir, pos3, normal3, ior, endPos3, endDir3);\n  totalInternalReflection(originPos4, lightDir, pos4, normal4, ior, endPos4, endDir4);\n  float lightPosArea = length(cross(originPos2 - originPos1, originPos3 - originPos1)) + length(cross(originPos3 - originPos1, originPos4 - originPos1));\n  float t1 = planeIntersect(endPos1, endDir1, vec4(lightPlaneNormal, lightPlaneConstant));\n  float t2 = planeIntersect(endPos2, endDir2, vec4(lightPlaneNormal, lightPlaneConstant));\n  float t3 = planeIntersect(endPos3, endDir3, vec4(lightPlaneNormal, lightPlaneConstant));\n  float t4 = planeIntersect(endPos4, endDir4, vec4(lightPlaneNormal, lightPlaneConstant));\n  vec3 finalPos1 = endPos1 + endDir1 * t1;\n  vec3 finalPos2 = endPos2 + endDir2 * t2;\n  vec3 finalPos3 = endPos3 + endDir3 * t3;\n  vec3 finalPos4 = endPos4 + endDir4 * t4;\n  float finalArea = length(cross(finalPos2 - finalPos1, finalPos3 - finalPos1)) + length(cross(finalPos3 - finalPos1, finalPos4 - finalPos1));\n  caustic += intensity * (lightPosArea / finalArea);\n  // Calculate the area of the triangle in light spaces\n  gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);\n}`\n);\n"]}

package/esm2022/shaders/caustics-material/caustics-projection-material.mjs

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+export const CausticsProjectionMaterial = shaderMaterial({
+    causticsTexture: null,
+    causticsTextureB: null,
+    color: new THREE.Color(),
+    lightProjMatrix: new THREE.Matrix4(),
+    lightViewMatrix: new THREE.Matrix4(),
+}, 
+/* glsl */ `varying vec3 vWorldPosition;
+void main() {
+  gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+  vec4 worldPosition = modelMatrix * vec4(position, 1.);
+  vWorldPosition = worldPosition.xyz;
+}`, 
+/* glsl */ `varying vec3 vWorldPosition;
+uniform vec3 color;
+uniform sampler2D causticsTexture;
+uniform sampler2D causticsTextureB;
+uniform mat4 lightProjMatrix;
+uniform mat4 lightViewMatrix;
+ void main() {
+  // Apply caustics
+  vec4 lightSpacePos = lightProjMatrix * lightViewMatrix * vec4(vWorldPosition, 1.0);
+  lightSpacePos.xyz /= lightSpacePos.w;
+  lightSpacePos.xyz = lightSpacePos.xyz * 0.5 + 0.5;
+  vec3 front = texture2D(causticsTexture, lightSpacePos.xy).rgb;
+  vec3 back = texture2D(causticsTextureB, lightSpacePos.xy).rgb;
+  gl_FragColor = vec4((front + back) * color, 1.0);
+  #include <tonemapping_fragment>
+  #include <encodings_fragment>
+}`);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/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/esm2022/shaders/discard-material/discard-material.mjs

@@ -0,0 +1,3 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const DiscardMaterial = shaderMaterial({}, 'void main() { }', 'void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); discard;  }');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY2FyZC1tYXRlcmlhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zaGFkZXJzL3NyYy9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRXBFLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxjQUFjLENBQ3pDLEVBQUUsRUFDRixpQkFBaUIsRUFDakIsb0VBQW9FLENBQ3ZFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaGFkZXJNYXRlcmlhbCB9IGZyb20gJy4uL3NoYWRlci1tYXRlcmlhbC9zaGFkZXItbWF0ZXJpYWwnO1xuXG5leHBvcnQgY29uc3QgRGlzY2FyZE1hdGVyaWFsID0gc2hhZGVyTWF0ZXJpYWwoXG4gICAge30sXG4gICAgJ3ZvaWQgbWFpbigpIHsgfScsXG4gICAgJ3ZvaWQgbWFpbigpIHsgZ2xfRnJhZ0NvbG9yID0gdmVjNCgwLjAsIDAuMCwgMC4wLCAwLjApOyBkaXNjYXJkOyAgfSdcbik7XG4iXX0=

package/esm2022/shaders/index.mjs

@@ -0,0 +1,15 @@
+export * from './blur-pass/blur-pass';
+export * from './caustics-material/caustics-material';
+export * from './caustics-material/caustics-projection-material';
+export * from './convolution-material/convolution-material';
+export * from './discard-material/discard-material';
+export * from './mesh-distort-material/mesh-distort-material';
+export * from './mesh-reflector-material/mesh-reflector-material';
+export * from './mesh-refraction-material/mesh-refraction-material';
+export * from './mesh-transmission-material/mesh-transmission-material';
+export * from './mesh-wobble-material/mesh-wobble-material';
+export * from './soft-shadow-material/soft-shadow-material';
+export * from './sparkles-material/sparkles-material';
+export * from './spot-light-material/spot-light-material';
+export * from './star-field-material/star-field-material';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc2hhZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsa0RBQWtELENBQUM7QUFDakUsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLDJDQUEyQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ibHVyLXBhc3MvYmx1ci1wYXNzJztcbmV4cG9ydCAqIGZyb20gJy4vY2F1c3RpY3MtbWF0ZXJpYWwvY2F1c3RpY3MtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9jYXVzdGljcy1tYXRlcmlhbC9jYXVzdGljcy1wcm9qZWN0aW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vY29udm9sdXRpb24tbWF0ZXJpYWwvY29udm9sdXRpb24tbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNjYXJkLW1hdGVyaWFsL2Rpc2NhcmQtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLWRpc3RvcnQtbWF0ZXJpYWwvbWVzaC1kaXN0b3J0LW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzaC1yZWZsZWN0b3ItbWF0ZXJpYWwvbWVzaC1yZWZsZWN0b3ItbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLXJlZnJhY3Rpb24tbWF0ZXJpYWwvbWVzaC1yZWZyYWN0aW9uLW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzaC10cmFuc21pc3Npb24tbWF0ZXJpYWwvbWVzaC10cmFuc21pc3Npb24tbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNoLXdvYmJsZS1tYXRlcmlhbC9tZXNoLXdvYmJsZS1tYXRlcmlhbCc7XG5leHBvcnQgKiBmcm9tICcuL3NvZnQtc2hhZG93LW1hdGVyaWFsL3NvZnQtc2hhZG93LW1hdGVyaWFsJztcbmV4cG9ydCAqIGZyb20gJy4vc3BhcmtsZXMtbWF0ZXJpYWwvc3BhcmtsZXMtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zcG90LWxpZ2h0LW1hdGVyaWFsL3Nwb3QtbGlnaHQtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFyLWZpZWxkLW1hdGVyaWFsL3N0YXItZmllbGQtbWF0ZXJpYWwnO1xuIl19

package/esm2022/shaders/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 provideNgtsMeshDistortMaterialShader(distortShader) {
+    return {
+        provide: NGTS_DISTORT_MATERIAL_SHADER,
+        useFactory: () => {
+            return class 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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