super-three 0.141.0 → 0.147.0

package/examples/js/modifiers/SimplifyModifier.js

@@ -10,13 +10,14 @@
 
 	const _cb = new THREE.Vector3(),
 		_ab = new THREE.Vector3();
-
 	class SimplifyModifier {
 
 		modify( geometry, count ) {
 
 			geometry = geometry.clone();
-			const attributes = geometry.attributes; // this modifier can only process indexed and non-indexed geomtries with a position attribute
+			const attributes = geometry.attributes;
+
+			// this modifier can only process indexed and non-indexed geomtries with a position attribute
 
 			for ( const name in attributes ) {
 
@@ -24,26 +25,29 @@
 
 			}
 
-			geometry = THREE.BufferGeometryUtils.mergeVertices( geometry ); //
+			geometry = THREE.BufferGeometryUtils.mergeVertices( geometry );
+
+			//
 			// put data of original geometry in different data structures
 			//
 
 			const vertices = [];
-			const faces = []; // add vertices
+			const faces = [];
 
-			const positionAttribute = geometry.getAttribute( 'position' );
+			// add vertices
 
+			const positionAttribute = geometry.getAttribute( 'position' );
 			for ( let i = 0; i < positionAttribute.count; i ++ ) {
 
 				const v = new THREE.Vector3().fromBufferAttribute( positionAttribute, i );
 				const vertex = new Vertex( v );
 				vertices.push( vertex );
 
-			} // add faces
+			}
 
+			// add faces
 
 			let index = geometry.getIndex();
-
 			if ( index !== null ) {
 
 				for ( let i = 0; i < index.count; i += 3 ) {
@@ -68,8 +72,9 @@
 
 				}
 
-			} // compute all edge collapse costs
+			}
 
+			// compute all edge collapse costs
 
 			for ( let i = 0, il = vertices.length; i < il; i ++ ) {
 
@@ -79,11 +84,9 @@
 
 			let nextVertex;
 			let z = count;
-
 			while ( z -- ) {
 
 				nextVertex = minimumCostEdge( vertices );
-
 				if ( ! nextVertex ) {
 
 					console.log( 'THREE.SimplifyModifier: No next vertex' );
@@ -93,30 +96,35 @@
 
 				collapse( vertices, faces, nextVertex, nextVertex.collapseNeighbor );
 
-			} //
+			}
 
+			//
 
 			const simplifiedGeometry = new THREE.BufferGeometry();
 			const position = [];
-			index = []; //
+			index = [];
+
+			//
 
 			for ( let i = 0; i < vertices.length; i ++ ) {
 
 				const vertex = vertices[ i ].position;
-				position.push( vertex.x, vertex.y, vertex.z ); // cache final index to GREATLY speed up faces reconstruction
-
+				position.push( vertex.x, vertex.y, vertex.z );
+				// cache final index to GREATLY speed up faces reconstruction
 				vertices[ i ].id = i;
 
-			} //
+			}
 
+			//
 
 			for ( let i = 0; i < faces.length; i ++ ) {
 
 				const face = faces[ i ];
 				index.push( face.v1.id, face.v2.id, face.v3.id );
 
-			} //
+			}
 
+			//
 
 			simplifiedGeometry.setAttribute( 'position', new THREE.Float32BufferAttribute( position, 3 ) );
 			simplifiedGeometry.setIndex( index );
@@ -125,7 +133,6 @@
 		}
 
 	}
-
 	function pushIfUnique( array, object ) {
 
 		if ( array.indexOf( object ) === - 1 ) array.push( object );
@@ -143,33 +150,33 @@
 
 		// if we collapse edge uv by moving u to v then how
 		// much different will the model change, i.e. the "error".
+
 		const edgelength = v.position.distanceTo( u.position );
 		let curvature = 0;
-		const sideFaces = []; // find the "sides" triangles that are on the edge uv
+		const sideFaces = [];
 
+		// find the "sides" triangles that are on the edge uv
 		for ( let i = 0, il = u.faces.length; i < il; i ++ ) {
 
 			const face = u.faces[ i ];
-
 			if ( face.hasVertex( v ) ) {
 
 				sideFaces.push( face );
 
 			}
 
-		} // use the triangle facing most away from the sides
-		// to determine our curvature term
-
+		}
 
+		// use the triangle facing most away from the sides
+		// to determine our curvature term
 		for ( let i = 0, il = u.faces.length; i < il; i ++ ) {
 
 			let minCurvature = 1;
 			const face = u.faces[ i ];
-
 			for ( let j = 0; j < sideFaces.length; j ++ ) {
 
-				const sideFace = sideFaces[ j ]; // use dot product of face normals.
-
+				const sideFace = sideFaces[ j ];
+				// use dot product of face normals.
 				const dotProd = face.normal.dot( sideFace.normal );
 				minCurvature = Math.min( minCurvature, ( 1.001 - dotProd ) / 2 );
 
@@ -177,12 +184,11 @@
 
 			curvature = Math.max( curvature, minCurvature );
 
-		} // crude approach in attempt to preserve borders
-		// though it seems not to be totally correct
-
+		}
 
+		// crude approach in attempt to preserve borders
+		// though it seems not to be totally correct
 		const borders = 0;
-
 		if ( sideFaces.length < 2 ) {
 
 			// we add some arbitrary cost for borders,
@@ -204,6 +210,7 @@
 		// only cache the cost of the least cost edge at this vertex
 		// (in member variable collapse) as well as the value of the
 		// cost (in member variable collapseCost).
+
 		if ( v.neighbors.length === 0 ) {
 
 			// collapse if no neighbors.
@@ -214,12 +221,12 @@
 		}
 
 		v.collapseCost = 100000;
-		v.collapseNeighbor = null; // search all neighboring edges for "least cost" edge
+		v.collapseNeighbor = null;
 
+		// search all neighboring edges for "least cost" edge
 		for ( let i = 0; i < v.neighbors.length; i ++ ) {
 
 			const collapseCost = computeEdgeCollapseCost( v, v.neighbors[ i ] );
-
 			if ( ! v.collapseNeighbor ) {
 
 				v.collapseNeighbor = v.neighbors[ i ];
@@ -232,7 +239,6 @@
 
 			v.costCount ++;
 			v.totalCost += collapseCost;
-
 			if ( collapseCost < v.minCost ) {
 
 				v.collapseNeighbor = v.neighbors[ i ];
@@ -240,17 +246,17 @@
 
 			}
 
-		} // we average the cost of collapsing at this vertex
-
+		}
 
-		v.collapseCost = v.totalCost / v.costCount; // v.collapseCost = v.minCost;
+		// we average the cost of collapsing at this vertex
+		v.collapseCost = v.totalCost / v.costCount;
+		// v.collapseCost = v.minCost;
 
 	}
 
 	function removeVertex( v, vertices ) {
 
 		console.assert( v.faces.length === 0 );
-
 		while ( v.neighbors.length ) {
 
 			const n = v.neighbors.pop();
@@ -267,10 +273,10 @@
 		removeFromArray( faces, f );
 		if ( f.v1 ) removeFromArray( f.v1.faces, f );
 		if ( f.v2 ) removeFromArray( f.v2.faces, f );
-		if ( f.v3 ) removeFromArray( f.v3.faces, f ); // TODO optimize this!
+		if ( f.v3 ) removeFromArray( f.v3.faces, f );
 
+		// TODO optimize this!
 		const vs = [ f.v1, f.v2, f.v3 ];
-
 		for ( let i = 0; i < 3; i ++ ) {
 
 			const v1 = vs[ i ];
@@ -286,7 +292,9 @@
 	function collapse( vertices, faces, u, v ) {
 
 		// u and v are pointers to vertices of an edge
+
 		// Collapse the edge uv by moving vertex u onto v
+
 		if ( ! v ) {
 
 			// u is a vertex all by itself so just delete it..
@@ -296,33 +304,33 @@
 		}
 
 		const tmpVertices = [];
-
 		for ( let i = 0; i < u.neighbors.length; i ++ ) {
 
 			tmpVertices.push( u.neighbors[ i ] );
 
-		} // delete triangles on edge uv:
-
+		}
 
+		// delete triangles on edge uv:
 		for ( let i = u.faces.length - 1; i >= 0; i -- ) {
 
-			if ( u.faces[ i ].hasVertex( v ) ) {
+			if ( u.faces[ i ] && u.faces[ i ].hasVertex( v ) ) {
 
 				removeFace( u.faces[ i ], faces );
 
 			}
 
-		} // update remaining triangles to have v instead of u
-
+		}
 
+		// update remaining triangles to have v instead of u
 		for ( let i = u.faces.length - 1; i >= 0; i -- ) {
 
 			u.faces[ i ].replaceVertex( u, v );
 
 		}
 
-		removeVertex( u, vertices ); // recompute the edge collapse costs in neighborhood
+		removeVertex( u, vertices );
 
+		// recompute the edge collapse costs in neighborhood
 		for ( let i = 0; i < tmpVertices.length; i ++ ) {
 
 			computeEdgeCostAtVertex( tmpVertices[ i ] );
@@ -334,8 +342,8 @@
 	function minimumCostEdge( vertices ) {
 
 		// O(n * n) approach. TODO optimize this
-		let least = vertices[ 0 ];
 
+		let least = vertices[ 0 ];
 		for ( let i = 0; i < vertices.length; i ++ ) {
 
 			if ( vertices[ i ].collapseCost < least.collapseCost ) {
@@ -348,8 +356,9 @@
 
 		return least;
 
-	} // we use a triangle class to represent structure of face slightly differently
+	}
 
+	// we use a triangle class to represent structure of face slightly differently
 
 	class Triangle {
 
@@ -374,29 +383,22 @@
 			v3.addUniqueNeighbor( v2 );
 
 		}
-
 		computeNormal() {
 
 			const vA = this.v1.position;
 			const vB = this.v2.position;
 			const vC = this.v3.position;
-
 			_cb.subVectors( vC, vB );
-
 			_ab.subVectors( vA, vB );
-
 			_cb.cross( _ab ).normalize();
-
 			this.normal.copy( _cb );
 
 		}
-
 		hasVertex( v ) {
 
 			return v === this.v1 || v === this.v2 || v === this.v3;
 
 		}
-
 		replaceVertex( oldv, newv ) {
 
 			if ( oldv === this.v1 ) this.v1 = newv; else if ( oldv === this.v2 ) this.v2 = newv; else if ( oldv === this.v3 ) this.v3 = newv;
@@ -419,7 +421,6 @@
 		}
 
 	}
-
 	class Vertex {
 
 		constructor( v ) {
@@ -428,12 +429,10 @@
 			this.id = - 1; // external use position in vertices list (for e.g. face generation)
 
 			this.faces = []; // faces vertex is connected
-
 			this.neighbors = []; // neighbouring vertices aka "adjacentVertices"
-			// these will be computed in computeEdgeCostAtVertex()
 
+			// these will be computed in computeEdgeCostAtVertex()
 			this.collapseCost = 0; // cost of collapsing this vertex, the less the better. aka objdist
-
 			this.collapseNeighbor = null; // best candinate for collapsing
 
 		}
@@ -443,14 +442,12 @@
 			pushIfUnique( this.neighbors, vertex );
 
 		}
-
 		removeIfNonNeighbor( n ) {
 
 			const neighbors = this.neighbors;
 			const faces = this.faces;
 			const offset = neighbors.indexOf( n );
 			if ( offset === - 1 ) return;
-
 			for ( let i = 0; i < faces.length; i ++ ) {
 
 				if ( faces[ i ].hasVertex( n ) ) return;

package/examples/js/modifiers/TessellateModifier.js

@@ -12,15 +12,15 @@
 			this.maxIterations = maxIterations;
 
 		}
-
 		modify( geometry ) {
 
 			if ( geometry.index !== null ) {
 
 				geometry = geometry.toNonIndexed();
 
-			} //
+			}
 
+			//
 
 			const maxIterations = this.maxIterations;
 			const maxEdgeLengthSquared = this.maxEdgeLength * this.maxEdgeLength;
@@ -66,7 +66,6 @@
 			let uv2s2 = uv2s;
 			let iteration = 0;
 			let tessellating = true;
-
 			function addTriangle( a, b, c ) {
 
 				const v1 = vs[ a ];
@@ -75,7 +74,6 @@
 				positions2.push( v1.x, v1.y, v1.z );
 				positions2.push( v2.x, v2.y, v2.z );
 				positions2.push( v3.x, v3.y, v3.z );
-
 				if ( hasNormals ) {
 
 					const n1 = ns[ a ];
@@ -128,7 +126,6 @@
 				tessellating = false;
 				positions = positions2;
 				positions2 = [];
-
 				if ( hasNormals ) {
 
 					normals = normals2;
@@ -162,7 +159,6 @@
 					va.fromArray( positions, i + 0 );
 					vb.fromArray( positions, i + 3 );
 					vc.fromArray( positions, i + 6 );
-
 					if ( hasNormals ) {
 
 						na.fromArray( normals, i + 0 );
@@ -198,11 +194,9 @@
 					const dab = va.distanceToSquared( vb );
 					const dbc = vb.distanceToSquared( vc );
 					const dac = va.distanceToSquared( vc );
-
 					if ( dab > maxEdgeLengthSquared || dbc > maxEdgeLengthSquared || dac > maxEdgeLengthSquared ) {
 
 						tessellating = true;
-
 						if ( dab >= dbc && dab >= dac ) {
 
 							vm.lerpVectors( va, vb, 0.5 );
@@ -247,7 +241,6 @@
 
 			const geometry2 = new THREE.BufferGeometry();
 			geometry2.setAttribute( 'position', new THREE.Float32BufferAttribute( positions2, 3 ) );
-
 			if ( hasNormals ) {
 
 				geometry2.setAttribute( 'normal', new THREE.Float32BufferAttribute( normals2, 3 ) );

package/examples/js/objects/GroundProjectedEnv.js

@@ -0,0 +1,181 @@
+( function () {
+
+	/**
+ * Ground projected env map adapted from @react-three/drei.
+ * https://github.com/pmndrs/drei/blob/master/src/core/Environment.tsx
+ */
+	class GroundProjectedEnv extends THREE.Mesh {
+
+		constructor( texture, options ) {
+
+			const isCubeMap = texture.isCubeTexture;
+			const w = ( isCubeMap ? texture.image[ 0 ]?.width : texture.image.width ) ?? 1024;
+			const cubeSize = w / 4;
+			const _lodMax = Math.floor( Math.log2( cubeSize ) );
+			const _cubeSize = Math.pow( 2, _lodMax );
+			const width = 3 * Math.max( _cubeSize, 16 * 7 );
+			const height = 4 * _cubeSize;
+			const defines = [ isCubeMap ? '#define ENVMAP_TYPE_CUBE' : '', `#define CUBEUV_TEXEL_WIDTH ${1.0 / width}`, `#define CUBEUV_TEXEL_HEIGHT ${1.0 / height}`, `#define CUBEUV_MAX_MIP ${_lodMax}.0` ];
+			const vertexShader = /* glsl */`
+        varying vec3 vWorldPosition;
+
+        void main() 
+        {
+
+            vec4 worldPosition = ( modelMatrix * vec4( position, 1.0 ) );
+            vWorldPosition = worldPosition.xyz;
+            
+            gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+        }
+        `;
+			const fragmentShader = defines.join( '\n' ) + /* glsl */`
+        #define ENVMAP_TYPE_CUBE_UV
+
+        varying vec3 vWorldPosition;
+
+        uniform float radius;
+        uniform float height;
+        uniform float angle;
+
+        #ifdef ENVMAP_TYPE_CUBE
+
+            uniform samplerCube map;
+
+        #else
+
+            uniform sampler2D map;
+
+        #endif
+
+        // From: https://www.shadertoy.com/view/4tsBD7
+        float diskIntersectWithBackFaceCulling( vec3 ro, vec3 rd, vec3 c, vec3 n, float r ) 
+        {
+
+            float d = dot ( rd, n );
+            
+            if( d > 0.0 ) { return 1e6; }
+            
+            vec3  o = ro - c;
+            float t = - dot( n, o ) / d;
+            vec3  q = o + rd * t;
+            
+            return ( dot( q, q ) < r * r ) ? t : 1e6;
+
+        }
+
+        // From: https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
+        float sphereIntersect( vec3 ro, vec3 rd, vec3 ce, float ra ) 
+        {
+
+            vec3 oc = ro - ce;
+            float b = dot( oc, rd );
+            float c = dot( oc, oc ) - ra * ra;
+            float h = b * b - c;
+            
+            if( h < 0.0 ) { return -1.0; }
+            
+            h = sqrt( h );
+            
+            return - b + h;
+
+        }
+
+        vec3 project() 
+        {
+
+            vec3 p = normalize( vWorldPosition );
+            vec3 camPos = cameraPosition;
+            camPos.y -= height;
+
+            float intersection = sphereIntersect( camPos, p, vec3( 0.0 ), radius );
+            if( intersection > 0.0 ) {
+                
+                vec3 h = vec3( 0.0, - height, 0.0 );
+                float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );
+                p = ( camPos + min( intersection, intersection2 ) * p ) / radius;
+
+            } else {
+
+                p = vec3( 0.0, 1.0, 0.0 );
+
+            }
+
+            return p;
+
+        }
+
+        #include <common>
+        #include <cube_uv_reflection_fragment>
+
+        void main() 
+        {
+
+            vec3 projectedWorldPosition = project();
+            
+            #ifdef ENVMAP_TYPE_CUBE
+
+                vec3 outcolor = textureCube( map, projectedWorldPosition ).rgb;
+
+            #else
+
+                vec3 direction = normalize( projectedWorldPosition );
+                vec2 uv = equirectUv( direction );
+                vec3 outcolor = texture2D( map, uv ).rgb;
+
+            #endif
+
+            gl_FragColor = vec4( outcolor, 1.0 );
+
+            #include <tonemapping_fragment>
+            #include <encodings_fragment>
+
+        }
+        `;
+			const uniforms = {
+				map: {
+					value: texture
+				},
+				height: {
+					value: options?.height || 15
+				},
+				radius: {
+					value: options?.radius || 100
+				}
+			};
+			const geometry = new THREE.IcosahedronGeometry( 1, 16 );
+			const material = new THREE.ShaderMaterial( {
+				uniforms,
+				fragmentShader,
+				vertexShader,
+				side: THREE.DoubleSide
+			} );
+			super( geometry, material );
+
+		}
+		set radius( radius ) {
+
+			this.material.uniforms.radius.value = radius;
+
+		}
+		get radius() {
+
+			return this.material.uniforms.radius.value;
+
+		}
+		set height( height ) {
+
+			this.material.uniforms.height.value = height;
+
+		}
+		get height() {
+
+			return this.material.uniforms.height.value;
+
+		}
+
+	}
+
+	THREE.GroundProjectedEnv = GroundProjectedEnv;
+
+} )();