Initial project import

node_modules/three-stdlib/shaders/DepthLimitedBlurShader.cjs

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const DepthLimitedBlurShader = {
+  defines: {
+    KERNEL_RADIUS: 4,
+    DEPTH_PACKING: 1,
+    PERSPECTIVE_CAMERA: 1
+  },
+  uniforms: {
+    tDiffuse: { value: null },
+    size: { value: /* @__PURE__ */ new THREE.Vector2(512, 512) },
+    sampleUvOffsets: { value: [/* @__PURE__ */ new THREE.Vector2(0, 0)] },
+    sampleWeights: { value: [1] },
+    tDepth: { value: null },
+    cameraNear: { value: 10 },
+    cameraFar: { value: 1e3 },
+    depthCutoff: { value: 10 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+    #include <common>
+
+    uniform vec2 size;
+
+    varying vec2 vUv;
+    varying vec2 vInvSize;
+
+    void main() {
+    	vUv = uv;
+    	vInvSize = 1.0 / size;
+
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    }
+  `
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+    #include <common>
+    #include <packing>
+
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tDepth;
+
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform float depthCutoff;
+
+    uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];
+    uniform float sampleWeights[ KERNEL_RADIUS + 1 ];
+
+    varying vec2 vUv;
+    varying vec2 vInvSize;
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
+
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    	#else
+    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    	#endif
+    }
+
+    void main() {
+    	float depth = getDepth( vUv );
+    	if( depth >= ( 1.0 - EPSILON ) ) {
+    		discard;
+    	}
+
+    	float centerViewZ = -getViewZ( depth );
+    	bool rBreak = false, lBreak = false;
+
+    	float weightSum = sampleWeights[0];
+    	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;
+
+    	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {
+
+    		float sampleWeight = sampleWeights[i];
+    		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;
+
+    		vec2 sampleUv = vUv + sampleUvOffset;
+    		float viewZ = -getViewZ( getDepth( sampleUv ) );
+
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;
+
+    		if( ! rBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
+
+    		sampleUv = vUv - sampleUvOffset;
+    		viewZ = -getViewZ( getDepth( sampleUv ) );
+
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;
+
+    		if( ! lBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
+
+    	}
+
+    	gl_FragColor = diffuseSum / weightSum;
+    }
+  `
+  )
+};
+const BlurShaderUtils = {
+  createSampleWeights: (kernelRadius, stdDev) => {
+    const gaussian = (x, stdDev2) => {
+      return Math.exp(-(x * x) / (2 * (stdDev2 * stdDev2))) / (Math.sqrt(2 * Math.PI) * stdDev2);
+    };
+    const weights = [];
+    for (let i = 0; i <= kernelRadius; i++) {
+      weights.push(gaussian(i, stdDev));
+    }
+    return weights;
+  },
+  createSampleOffsets: (kernelRadius, uvIncrement) => {
+    const offsets = [];
+    for (let i = 0; i <= kernelRadius; i++) {
+      offsets.push(uvIncrement.clone().multiplyScalar(i));
+    }
+    return offsets;
+  },
+  configure: (shader, kernelRadius, stdDev, uvIncrement) => {
+    shader.defines["KERNEL_RADIUS"] = kernelRadius;
+    shader.uniforms["sampleUvOffsets"].value = BlurShaderUtils.createSampleOffsets(kernelRadius, uvIncrement);
+    shader.uniforms["sampleWeights"].value = BlurShaderUtils.createSampleWeights(kernelRadius, stdDev);
+    shader.needsUpdate = true;
+  }
+};
+exports.BlurShaderUtils = BlurShaderUtils;
+exports.DepthLimitedBlurShader = DepthLimitedBlurShader;
+//# sourceMappingURL=DepthLimitedBlurShader.cjs.map