viral-viewer-2 6.2.1 → 6.2.4

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

@@ -1,72 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,71 +0,0 @@
-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

@@ -1,180 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1,41 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

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