viral-viewer-2 3.1.8 → 3.2.0

package/dist/components/worker-script/threejs.types.js

@@ -8485,42 +8485,42 @@ function workerFunction() {
                 uniforms: {
                     tEquirect: { value: null },
                 },
-                vertexShader: /* glsl */ `
-
-				varying vec3 vWorldDirection;
-
-				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
-
-					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
-
-				}
-
-				void main() {
-
-					vWorldDirection = transformDirection( position, modelMatrix );
-
-					#include <begin_vertex>
-					#include <project_vertex>
-
-				}
+                vertexShader: /* glsl */ `
+
+				varying vec3 vWorldDirection;
+
+				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
+
+					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
+
+				}
+
+				void main() {
+
+					vWorldDirection = transformDirection( position, modelMatrix );
+
+					#include <begin_vertex>
+					#include <project_vertex>
+
+				}
 			`,
-                fragmentShader: /* glsl */ `
-
-				uniform sampler2D tEquirect;
-
-				varying vec3 vWorldDirection;
-
-				#include <common>
-
-				void main() {
-
-					vec3 direction = normalize( vWorldDirection );
-
-					vec2 sampleUV = equirectUv( direction );
-
-					gl_FragColor = texture2D( tEquirect, sampleUV );
-
-				}
+                fragmentShader: /* glsl */ `
+
+				uniform sampler2D tEquirect;
+
+				varying vec3 vWorldDirection;
+
+				#include <common>
+
+				void main() {
+
+					vec3 direction = normalize( vWorldDirection );
+
+					vec2 sampleUV = equirectUv( direction );
+
+					gl_FragColor = texture2D( tEquirect, sampleUV );
+
+				}
 			`,
             };
             const geometry = new BoxGeometry(5, 5, 5);
@@ -11055,66 +11055,66 @@ function workerFunction() {
                 poleAxis: { value: poleAxis },
             },
             vertexShader: _getCommonVertexShader(),
-            fragmentShader: /* glsl */ `
-
-			precision mediump float;
-			precision mediump int;
-
-			varying vec3 vOutputDirection;
-
-			uniform sampler2D envMap;
-			uniform int samples;
-			uniform float weights[ n ];
-			uniform bool latitudinal;
-			uniform float dTheta;
-			uniform float mipInt;
-			uniform vec3 poleAxis;
-
-			#define ENVMAP_TYPE_CUBE_UV
-			#include <cube_uv_reflection_fragment>
-
-			vec3 getSample( float theta, vec3 axis ) {
-
-				float cosTheta = cos( theta );
-				// Rodrigues' axis-angle rotation
-				vec3 sampleDirection = vOutputDirection * cosTheta
-					+ cross( axis, vOutputDirection ) * sin( theta )
-					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );
-
-				return bilinearCubeUV( envMap, sampleDirection, mipInt );
-
-			}
-
-			void main() {
-
-				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );
-
-				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {
-
-					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );
-
-				}
-
-				axis = normalize( axis );
-
-				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
-				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );
-
-				for ( int i = 1; i < n; i++ ) {
-
-					if ( i >= samples ) {
-
-						break;
-
-					}
-
-					float theta = dTheta * float( i );
-					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
-					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );
-
-				}
-
-			}
+            fragmentShader: /* glsl */ `
+
+			precision mediump float;
+			precision mediump int;
+
+			varying vec3 vOutputDirection;
+
+			uniform sampler2D envMap;
+			uniform int samples;
+			uniform float weights[ n ];
+			uniform bool latitudinal;
+			uniform float dTheta;
+			uniform float mipInt;
+			uniform vec3 poleAxis;
+
+			#define ENVMAP_TYPE_CUBE_UV
+			#include <cube_uv_reflection_fragment>
+
+			vec3 getSample( float theta, vec3 axis ) {
+
+				float cosTheta = cos( theta );
+				// Rodrigues' axis-angle rotation
+				vec3 sampleDirection = vOutputDirection * cosTheta
+					+ cross( axis, vOutputDirection ) * sin( theta )
+					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );
+
+				return bilinearCubeUV( envMap, sampleDirection, mipInt );
+
+			}
+
+			void main() {
+
+				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );
+
+				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {
+
+					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );
+
+				}
+
+				axis = normalize( axis );
+
+				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
+				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );
+
+				for ( int i = 1; i < n; i++ ) {
+
+					if ( i >= samples ) {
+
+						break;
+
+					}
+
+					float theta = dTheta * float( i );
+					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
+					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );
+
+				}
+
+			}
 		`,
             blending: NoBlending,
             depthTest: false,
@@ -11129,25 +11129,25 @@ function workerFunction() {
                 envMap: { value: null },
             },
             vertexShader: _getCommonVertexShader(),
-            fragmentShader: /* glsl */ `
-
-			precision mediump float;
-			precision mediump int;
-
-			varying vec3 vOutputDirection;
-
-			uniform sampler2D envMap;
-
-			#include <common>
-
-			void main() {
-
-				vec3 outputDirection = normalize( vOutputDirection );
-				vec2 uv = equirectUv( outputDirection );
-
-				gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );
-
-			}
+            fragmentShader: /* glsl */ `
+
+			precision mediump float;
+			precision mediump int;
+
+			varying vec3 vOutputDirection;
+
+			uniform sampler2D envMap;
+
+			#include <common>
+
+			void main() {
+
+				vec3 outputDirection = normalize( vOutputDirection );
+				vec2 uv = equirectUv( outputDirection );
+
+				gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );
+
+			}
 		`,
             blending: NoBlending,
             depthTest: false,
@@ -11162,22 +11162,22 @@ function workerFunction() {
                 flipEnvMap: { value: -1 },
             },
             vertexShader: _getCommonVertexShader(),
-            fragmentShader: /* glsl */ `
-
-			precision mediump float;
-			precision mediump int;
-
-			uniform float flipEnvMap;
-
-			varying vec3 vOutputDirection;
-
-			uniform samplerCube envMap;
-
-			void main() {
-
-				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );
-
-			}
+            fragmentShader: /* glsl */ `
+
+			precision mediump float;
+			precision mediump int;
+
+			uniform float flipEnvMap;
+
+			varying vec3 vOutputDirection;
+
+			uniform samplerCube envMap;
+
+			void main() {
+
+				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );
+
+			}
 		`,
             blending: NoBlending,
             depthTest: false,
@@ -11185,61 +11185,61 @@ function workerFunction() {
         });
     }
     function _getCommonVertexShader() {
-        return /* glsl */ `
-
-		precision mediump float;
-		precision mediump int;
-
-		attribute float faceIndex;
-
-		varying vec3 vOutputDirection;
-
-		// RH coordinate system; PMREM face-indexing convention
-		vec3 getDirection( vec2 uv, float face ) {
-
-			uv = 2.0 * uv - 1.0;
-
-			vec3 direction = vec3( uv, 1.0 );
-
-			if ( face == 0.0 ) {
-
-				direction = direction.zyx; // ( 1, v, u ) pos x
-
-			} else if ( face == 1.0 ) {
-
-				direction = direction.xzy;
-				direction.xz *= -1.0; // ( -u, 1, -v ) pos y
-
-			} else if ( face == 2.0 ) {
-
-				direction.x *= -1.0; // ( -u, v, 1 ) pos z
-
-			} else if ( face == 3.0 ) {
-
-				direction = direction.zyx;
-				direction.xz *= -1.0; // ( -1, v, -u ) neg x
-
-			} else if ( face == 4.0 ) {
-
-				direction = direction.xzy;
-				direction.xy *= -1.0; // ( -u, -1, v ) neg y
-
-			} else if ( face == 5.0 ) {
-
-				direction.z *= -1.0; // ( u, v, -1 ) neg z
-
-			}
-
-			return direction;
-
-		}
-
-		void main() {
-
-			vOutputDirection = getDirection( uv, faceIndex );
-			gl_Position = vec4( position, 1.0 );
-
-		}
+        return /* glsl */ `
+
+		precision mediump float;
+		precision mediump int;
+
+		attribute float faceIndex;
+
+		varying vec3 vOutputDirection;
+
+		// RH coordinate system; PMREM face-indexing convention
+		vec3 getDirection( vec2 uv, float face ) {
+
+			uv = 2.0 * uv - 1.0;
+
+			vec3 direction = vec3( uv, 1.0 );
+
+			if ( face == 0.0 ) {
+
+				direction = direction.zyx; // ( 1, v, u ) pos x
+
+			} else if ( face == 1.0 ) {
+
+				direction = direction.xzy;
+				direction.xz *= -1.0; // ( -u, 1, -v ) pos y
+
+			} else if ( face == 2.0 ) {
+
+				direction.x *= -1.0; // ( -u, v, 1 ) pos z
+
+			} else if ( face == 3.0 ) {
+
+				direction = direction.zyx;
+				direction.xz *= -1.0; // ( -1, v, -u ) neg x
+
+			} else if ( face == 4.0 ) {
+
+				direction = direction.xzy;
+				direction.xy *= -1.0; // ( -u, -1, v ) neg y
+
+			} else if ( face == 5.0 ) {
+
+				direction.z *= -1.0; // ( u, v, -1 ) neg z
+
+			}
+
+			return direction;
+
+		}
+
+		void main() {
+
+			vOutputDirection = getDirection( uv, faceIndex );
+			gl_Position = vec4( position, 1.0 );
+
+		}
 	`;
     }
     function WebGLCubeUVMaps(renderer) {
@@ -34103,17 +34103,15 @@ function workerFunction() {
         dummyGeometry.setAttribute("position", new BufferAttribute(buffer, 3));
         if (event.data.Instances.length > 0) {
             let geometry = new BufferGeometry();
-            // // In case number of polygon larger than expect, merge them to reduce polygon first, for optimize purpose
-            // if (dummyGeometry.attributes.position.count > maxPolygonPerObject) {
-            //   let modifier = new SimplifyModifier();
-            //   // const ratio = maxPolygonPerObject / dummyGeometry.attributes.position.count;
-            //   // const count = Math.floor(dummyGeometry.attributes.position.count * ratio); // number of polygon to remove
-            // } else {
-            //   geometry = dummyGeometry;
-            // }
-            let modifier = new SimplifyModifier();
-            geometry = modifier.modify(dummyGeometry, maxPolygonPerObject);
-            console.log(dummyGeometry.attributes.position.count, geometry.attributes.position.count);
+            // In case number of polygon larger than expect, merge them to reduce polygon first, for optimize purpose
+            if (dummyGeometry.attributes.position.count > maxPolygonPerObject) {
+                let modifier = new SimplifyModifier();
+                geometry = modifier.modify(dummyGeometry, maxPolygonPerObject);
+                console.log(dummyGeometry.attributes.position.count, geometry.attributes.position.count);
+            }
+            else {
+                geometry = dummyGeometry;
+            }
             geometry.computeVertexNormals();
             const childMesh = new InstancedMesh(geometry, new MeshBasicMaterial(), event.data.Instances.length);
             childMesh.castShadow = true;
@@ -34143,40 +34141,27 @@ function workerFunction() {
                 matrix4.fromArray(numbers);
                 childMesh.setMatrixAt(index, matrix4);
                 //if number of polygon smaller than expect, generate edges
-                // if (geometry.attributes.position.count < maxPolygonForEdge) {
-                //   const edges = new EdgesGeometry(geometry, 90);
-                //   const positions = edges.attributes.position.array;
-                //   const indices = [];
-                //   for (let i = 0; i < positions.length / 3; i += 2) {
-                //     indices.push(i, i + 1);
-                //   }
-                //   const bufferGeometry = new BufferGeometry();
-                //   // Set the position attribute
-                //   bufferGeometry.setAttribute(
-                //     "position",
-                //     new BufferAttribute(new Float32Array(positions), 3)
-                //   );
-                //   // Set the index attribute
-                //   bufferGeometry.setIndex(indices);
-                //   const line = new LineSegments(
-                //     bufferGeometry,
-                //     new LineBasicMaterial({ color: "#666", linewidth: 0.5 })
-                //   );
-                //   line.applyMatrix4(matrix4);
-                //   line.updateMatrix();
-                //   childMesh.add(line);
-                // }
+                if (geometry.attributes.position.count < maxPolygonForEdge) {
+                    const edges = new EdgesGeometry(geometry, 90);
+                    const positions = edges.attributes.position.array;
+                    const indices = [];
+                    for (let i = 0; i < positions.length / 3; i += 2) {
+                        indices.push(i, i + 1);
+                    }
+                    const bufferGeometry = new BufferGeometry();
+                    // Set the position attribute
+                    bufferGeometry.setAttribute("position", new BufferAttribute(new Float32Array(positions), 3));
+                    // Set the index attribute
+                    bufferGeometry.setIndex(indices);
+                    const line = new LineSegments(bufferGeometry, new LineBasicMaterial({ color: "#666", linewidth: 0.5 }));
+                    line.applyMatrix4(matrix4);
+                    line.updateMatrix();
+                    childMesh.add(line);
+                }
             }
             // childMesh.instanceMatrix.needsUpdate = true;
             childMesh.updateMatrix();
-            childMesh.uuid;
             let jsonData = childMesh.toJSON();
-            // jsonData.object.type = "InstancedMesh";
-            // jsonData.object.count = childMesh.count;
-            // jsonData.object.instanceMatrix = childMesh.instanceMatrix.toJSON();
-            // if (this.instanceColor !== null)
-            // jsonData.object.instanceColor = childMesh.instanceColor.toJSON();
-            console.log(jsonData);
             self.postMessage(jsonData);
         }
         else {