viral-viewer-2 6.2.6 → 6.2.8

package/dist/threejs-addon/shaders/output-shader.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputShader = void 0;
+const three_1 = require("three");
+const OutputShader = {
+    uniforms: {
+        'tDiffuse': { value: null },
+        'toneMappingExposure': { value: 1 }
+    },
+    vertexShader: /* glsl */ `
+		precision highp float;
+
+		uniform mat4 modelViewMatrix;
+		uniform mat4 projectionMatrix;
+
+		attribute vec3 position;
+		attribute vec2 uv;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+    fragmentShader: /* glsl */ `
+	
+		precision highp float;
+
+		uniform sampler2D tDiffuse;
+
+		` + three_1.ShaderChunk['tonemapping_pars_fragment'] + three_1.ShaderChunk['colorspace_pars_fragment'] + `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+
+			// tone mapping
+
+			#ifdef LINEAR_TONE_MAPPING
+
+				gl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );
+
+			#elif defined( REINHARD_TONE_MAPPING )
+
+				gl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );
+
+			#elif defined( CINEON_TONE_MAPPING )
+
+				gl_FragColor.rgb = OptimizedCineonToneMapping( gl_FragColor.rgb );
+
+			#elif defined( ACES_FILMIC_TONE_MAPPING )
+
+				gl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );
+
+			#endif
+
+			// color space
+
+			#ifdef SRGB_COLOR_SPACE
+
+				gl_FragColor = LinearTosRGB( gl_FragColor );
+
+			#endif
+
+		}`
+};
+exports.OutputShader = OutputShader;
+//# sourceMappingURL=output-shader.js.map

package/dist/threejs-addon/shaders/output-shader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-shader.js","sourceRoot":"","sources":["../../../src/threejs-addon/shaders/output-shader.js"],"names":[],"mappings":";;;AAAA,iCAEe;AAEf,MAAM,YAAY,GAAG;IAEjB,QAAQ,EAAE;QAEN,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QAC3B,qBAAqB,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;KAEtC;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;IAgBzB;IAEA,cAAc,EAAE,UAAU,CAAC;;;;;;GAM5B,GAAG,mBAAW,CAAC,2BAA2B,CAAC,GAAG,mBAAW,CAAC,0BAA0B,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoCvF;CAEH,CAAC;AAEO,oCAAY"}

package/dist/threejs-addon/shaders/sao-shader.d.ts

@@ -0,0 +1,71 @@
+export namespace SAOShader {
+    namespace defines {
+        const NUM_SAMPLES: number;
+        const NUM_RINGS: number;
+        const NORMAL_TEXTURE: number;
+        const DIFFUSE_TEXTURE: number;
+        const DEPTH_PACKING: number;
+        const PERSPECTIVE_CAMERA: number;
+    }
+    namespace uniforms {
+        namespace tDepth {
+            const value: null;
+        }
+        namespace tDiffuse {
+            const value_1: null;
+            export { value_1 as value };
+        }
+        namespace tNormal {
+            const value_2: null;
+            export { value_2 as value };
+        }
+        namespace size {
+            const value_3: Vector2;
+            export { value_3 as value };
+        }
+        namespace cameraNear {
+            const value_4: number;
+            export { value_4 as value };
+        }
+        namespace cameraFar {
+            const value_5: number;
+            export { value_5 as value };
+        }
+        namespace cameraProjectionMatrix {
+            const value_6: Matrix4;
+            export { value_6 as value };
+        }
+        namespace cameraInverseProjectionMatrix {
+            const value_7: Matrix4;
+            export { value_7 as value };
+        }
+        namespace scale {
+            const value_8: number;
+            export { value_8 as value };
+        }
+        namespace intensity {
+            const value_9: number;
+            export { value_9 as value };
+        }
+        namespace bias {
+            const value_10: number;
+            export { value_10 as value };
+        }
+        namespace minResolution {
+            const value_11: number;
+            export { value_11 as value };
+        }
+        namespace kernelRadius {
+            const value_12: number;
+            export { value_12 as value };
+        }
+        namespace randomSeed {
+            const value_13: number;
+            export { value_13 as value };
+        }
+    }
+    const vertexShader: string;
+    const fragmentShader: string;
+}
+import { Vector2 } from 'three';
+import { Matrix4 } from 'three';

package/dist/threejs-addon/shaders/sao-shader.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAOShader = void 0;
+const three_1 = require("three");
+/**
+ * TODO
+ */
+const SAOShader = {
+    defines: {
+        'NUM_SAMPLES': 7,
+        'NUM_RINGS': 4,
+        'NORMAL_TEXTURE': 0,
+        'DIFFUSE_TEXTURE': 0,
+        'DEPTH_PACKING': 1,
+        'PERSPECTIVE_CAMERA': 1
+    },
+    uniforms: {
+        'tDepth': { value: null },
+        'tDiffuse': { value: null },
+        'tNormal': { value: null },
+        'size': { value: new three_1.Vector2(512, 512) },
+        'cameraNear': { value: 1 },
+        'cameraFar': { value: 100 },
+        'cameraProjectionMatrix': { value: new three_1.Matrix4() },
+        'cameraInverseProjectionMatrix': { value: new three_1.Matrix4() },
+        'scale': { value: 1.0 },
+        'intensity': { value: 0.1 },
+        'bias': { value: 0.5 },
+        'minResolution': { value: 0.0 },
+        'kernelRadius': { value: 100.0 },
+        'randomSeed': { value: 0.0 }
+    },
+    vertexShader: /* glsl */ `
+
+		varying vec2 vUv;
+
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+		}`,
+    fragmentShader: /* glsl */ `
+
+		#include <common>
+
+		varying vec2 vUv;
+
+		#if DIFFUSE_TEXTURE == 1
+		uniform sampler2D tDiffuse;
+		#endif
+
+		uniform sampler2D tDepth;
+
+		#if NORMAL_TEXTURE == 1
+		uniform sampler2D tNormal;
+		#endif
+
+		uniform float cameraNear;
+		uniform float cameraFar;
+		uniform mat4 cameraProjectionMatrix;
+		uniform mat4 cameraInverseProjectionMatrix;
+
+		uniform float scale;
+		uniform float intensity;
+		uniform float bias;
+		uniform float kernelRadius;
+		uniform float minResolution;
+		uniform vec2 size;
+		uniform float randomSeed;
+
+		// RGBA depth
+
+		#include <packing>
+
+		vec4 getDefaultColor( const in vec2 screenPosition ) {
+			#if DIFFUSE_TEXTURE == 1
+			return texture2D( tDiffuse, vUv );
+			#else
+			return vec4( 1.0 );
+			#endif
+		}
+
+		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
+		}
+
+		vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
+			float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
+			vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
+			clipPosition *= clipW; // unprojection.
+
+			return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
+		}
+
+		vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
+			#if NORMAL_TEXTURE == 1
+			return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
+			#else
+			return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
+			#endif
+		}
+
+		float scaleDividedByCameraFar;
+		float minResolutionMultipliedByCameraFar;
+
+		float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
+			vec3 viewDelta = sampleViewPosition - centerViewPosition;
+			float viewDistance = length( viewDelta );
+			float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;
+
+			return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );
+		}
+
+		// moving costly divides into consts
+		const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+		const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+
+		float getAmbientOcclusion( const in vec3 centerViewPosition ) {
+			// precompute some variables require in getOcclusion.
+			scaleDividedByCameraFar = scale / cameraFar;
+			minResolutionMultipliedByCameraFar = minResolution * cameraFar;
+			vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
+
+			// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+			float angle = rand( vUv + randomSeed ) * PI2;
+			vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
+			vec2 radiusStep = radius;
+
+			float occlusionSum = 0.0;
+			float weightSum = 0.0;
+
+			for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+				vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;
+				radius += radiusStep;
+				angle += ANGLE_STEP;
+
+				float sampleDepth = getDepth( sampleUv );
+				if( sampleDepth >= ( 1.0 - EPSILON ) ) {
+					continue;
+				}
+
+				float sampleViewZ = getViewZ( sampleDepth );
+				vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );
+				occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );
+				weightSum += 1.0;
+			}
+
+			if( weightSum == 0.0 ) discard;
+
+			return occlusionSum * ( intensity / weightSum );
+		}
+
+		void main() {
+			float centerDepth = getDepth( vUv );
+			if( centerDepth >= ( 1.0 - EPSILON ) ) {
+				discard;
+			}
+
+			float centerViewZ = getViewZ( centerDepth );
+			vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
+
+			float ambientOcclusion = getAmbientOcclusion( viewPosition );
+
+			gl_FragColor = getDefaultColor( vUv );
+			gl_FragColor.xyz *=  1.0 - ambientOcclusion;
+		}`
+};
+exports.SAOShader = SAOShader;
+//# sourceMappingURL=sao-shader.js.map

package/dist/threejs-addon/shaders/sao-shader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sao-shader.js","sourceRoot":"","sources":["../../../src/threejs-addon/shaders/sao-shader.js"],"names":[],"mappings":";;;AAAA,iCAGe;AAEf;;GAEG;AAEH,MAAM,SAAS,GAAG;IACd,OAAO,EAAE;QACL,aAAa,EAAE,CAAC;QAChB,WAAW,EAAE,CAAC;QACd,gBAAgB,EAAE,CAAC;QACnB,iBAAiB,EAAE,CAAC;QACpB,eAAe,EAAE,CAAC;QAClB,oBAAoB,EAAE,CAAC;KAC1B;IACD,QAAQ,EAAE;QAEN,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QACzB,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QAC3B,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QAC1B,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,eAAO,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;QAExC,YAAY,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;QAC1B,WAAW,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QAC3B,wBAAwB,EAAE,EAAE,KAAK,EAAE,IAAI,eAAO,EAAE,EAAE;QAClD,+BAA+B,EAAE,EAAE,KAAK,EAAE,IAAI,eAAO,EAAE,EAAE;QAEzD,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QACvB,WAAW,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QAC3B,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QAEtB,eAAe,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;QAC/B,cAAc,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QAChC,YAAY,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;KAC/B;IACD,YAAY,EAAE,UAAU,CAAC;;;;;;;IAOzB;IAEA,cAAc,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwI3B;CAEH,CAAC;AAEO,8BAAS"}

package/dist/threejs-addon/shaders/unpack-depth-rgba-shader.d.ts

@@ -0,0 +1,13 @@
+export namespace UnpackDepthRGBAShader {
+    namespace uniforms {
+        namespace tDiffuse {
+            const value: null;
+        }
+        namespace opacity {
+            const value_1: number;
+            export { value_1 as value };
+        }
+    }
+    const vertexShader: string;
+    const fragmentShader: string;
+}

package/dist/threejs-addon/shaders/unpack-depth-rgba-shader.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Unpack RGBA depth shader
+ * - show RGBA encoded depth as monochrome color
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpackDepthRGBAShader = void 0;
+const UnpackDepthRGBAShader = {
+    uniforms: {
+        'tDiffuse': { value: null },
+        'opacity': { value: 1.0 }
+    },
+    vertexShader: /* glsl */ `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+    fragmentShader: /* glsl */ `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		#include <packing>
+
+		void main() {
+
+			float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );
+			gl_FragColor = vec4( vec3( depth ), opacity );
+
+		}`
+};
+exports.UnpackDepthRGBAShader = UnpackDepthRGBAShader;
+//# sourceMappingURL=unpack-depth-rgba-shader.js.map

package/dist/threejs-addon/shaders/unpack-depth-rgba-shader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpack-depth-rgba-shader.js","sourceRoot":"","sources":["../../../src/threejs-addon/shaders/unpack-depth-rgba-shader.js"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,MAAM,qBAAqB,GAAG;IAE1B,QAAQ,EAAE;QAEN,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QAC3B,SAAS,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;KAE5B;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;;;IASzB;IAEA,cAAc,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;IAe3B;CAEH,CAAC;AAEO,sDAAqB"}

package/dist/threejs-addon/simplify-modifier.d.ts

@@ -0,0 +1,4 @@
+export class SimplifyModifier {
+    modify(geometry: any, count: any): BufferGeometry<import("three").NormalBufferAttributes>;
+}
+import { BufferGeometry } from 'three';