@unikia/upe-renderer 0.186.110 → 0.187.11

package/examples/jsm/libs/surfaceNet.js

@@ -1,201 +0,0 @@
-/**
- * SurfaceNets in JavaScript
- *
- * Written by Mikola Lysenko (C) 2012
- *
- * MIT License
- *
- * Based on: S.F. Gibson, 'Constrained Elastic Surface Nets'. (1998) MERL Tech Report.
- * from https://github.com/mikolalysenko/isosurface/tree/master
- * 
- */
-
-let surfaceNet = ( dims, potential, bounds ) => {
-		
-	
-	//Precompute edge table, like Paul Bourke does.
-	// This saves a bit of time when computing the centroid of each boundary cell
-	var cube_edges = new Int32Array(24) , edge_table = new Int32Array(256);
-	(function() {
-
-		//Initialize the cube_edges table
-		// This is just the vertex number of each cube
-		var k = 0;
-		for(var i=0; i<8; ++i) {
-			for(var j=1; j<=4; j<<=1) {
-				var p = i^j;
-				if(i <= p) {
-					cube_edges[k++] = i;
-					cube_edges[k++] = p;
-				}
-			}
-		}
-
-		//Initialize the intersection table.
-		//  This is a 2^(cube configuration) ->  2^(edge configuration) map
-		//  There is one entry for each possible cube configuration, and the output is a 12-bit vector enumerating all edges crossing the 0-level.
-		for(var i=0; i<256; ++i) {
-			var em = 0;
-			for(var j=0; j<24; j+=2) {
-				var a = !!(i & (1<<cube_edges[j]))
-					, b = !!(i & (1<<cube_edges[j+1]));
-				em |= a !== b ? (1 << (j >> 1)) : 0;
-			}
-			edge_table[i] = em;
-		}
-	})();
-
-	//Internal buffer, this may get resized at run time
-	var buffer = new Array(4096);
-	(function() {
-		for(var i=0; i<buffer.length; ++i) {
-			buffer[i] = 0;
-		}
-	})();
-
-	if(!bounds) {
-		bounds = [[0,0,0],dims];
-	}
-	
-	var scale     = [0,0,0];
-	var shift     = [0,0,0];
-	for(var i=0; i<3; ++i) {
-		scale[i] = (bounds[1][i] - bounds[0][i]) / dims[i];
-		shift[i] = bounds[0][i];
-	}
-	
-	var vertices = []
-		, faces = []
-		, n = 0
-		, x = [0, 0, 0]
-		, R = [1, (dims[0]+1), (dims[0]+1)*(dims[1]+1)]
-		, grid = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-		, buf_no = 1;
-	
-		
-	//Resize buffer if necessary 
-	if(R[2] * 2 > buffer.length) {
-		var ol = buffer.length;
-		buffer.length = R[2] * 2;
-		while(ol < buffer.length) {
-			buffer[ol++] = 0;
-		}
-	}
-	
-	//March over the voxel grid
-	for(x[2]=0; x[2]<dims[2]-1; ++x[2], n+=dims[0], buf_no ^= 1, R[2]=-R[2]) {
-	
-		//m is the pointer into the buffer we are going to use.  
-		//This is slightly obtuse because javascript does not have good support for packed data structures, so we must use typed arrays :(
-		//The contents of the buffer will be the indices of the vertices on the previous x/y slice of the volume
-		var m = 1 + (dims[0]+1) * (1 + buf_no * (dims[1]+1));
-		
-		for(x[1]=0; x[1]<dims[1]-1; ++x[1], ++n, m+=2)
-		for(x[0]=0; x[0]<dims[0]-1; ++x[0], ++n, ++m) {
-		
-			//Read in 8 field values around this vertex and store them in an array
-			//Also calculate 8-bit mask, like in marching cubes, so we can speed up sign checks later
-			var mask = 0, g = 0;
-			for(var k=0; k<2; ++k)
-			for(var j=0; j<2; ++j)      
-			for(var i=0; i<2; ++i, ++g) {
-				var p = potential(
-					scale[0]*(x[0]+i)+shift[0],
-					scale[1]*(x[1]+j)+shift[1],
-					scale[2]*(x[2]+k)+shift[2]);
-				grid[g] = p;
-				mask |= (p < 0) ? (1<<g) : 0;
-			}
-			
-			//Check for early termination if cell does not intersect boundary
-			if(mask === 0 || mask === 0xff) {
-				continue;
-			}
-			
-			//Sum up edge intersections
-			var edge_mask = edge_table[mask]
-				, v = [0.0,0.0,0.0]
-				, e_count = 0;
-				
-			//For every edge of the cube...
-			for(var i=0; i<12; ++i) {
-			
-				//Use edge mask to check if it is crossed
-				if(!(edge_mask & (1<<i))) {
-					continue;
-				}
-				
-				//If it did, increment number of edge crossings
-				++e_count;
-				
-				//Now find the point of intersection
-				var e0 = cube_edges[ i<<1 ]       //Unpack vertices
-					, e1 = cube_edges[(i<<1)+1]
-					, g0 = grid[e0]                 //Unpack grid values
-					, g1 = grid[e1]
-					, t  = g0 - g1;                 //Compute point of intersection
-				if(Math.abs(t) > 1e-6) {
-					t = g0 / t;
-				} else {
-					continue;
-				}
-				
-				//Interpolate vertices and add up intersections (this can be done without multiplying)
-				for(var j=0, k=1; j<3; ++j, k<<=1) {
-					var a = e0 & k
-						, b = e1 & k;
-					if(a !== b) {
-						v[j] += a ? 1.0 - t : t;
-					} else {
-						v[j] += a ? 1.0 : 0;
-					}
-				}
-			}
-			
-			//Now we just average the edge intersections and add them to coordinate
-			var s = 1.0 / e_count;
-			for(var i=0; i<3; ++i) {
-				v[i] = scale[i] * (x[i] + s * v[i]) + shift[i];
-			}
-			
-			//Add vertex to buffer, store pointer to vertex index in buffer
-			buffer[m] = vertices.length;
-			vertices.push(v);
-			
-			//Now we need to add faces together, to do this we just loop over 3 basis components
-			for(var i=0; i<3; ++i) {
-				//The first three entries of the edge_mask count the crossings along the edge
-				if(!(edge_mask & (1<<i)) ) {
-					continue;
-				}
-				
-				// i = axes we are point along.  iu, iv = orthogonal axes
-				var iu = (i+1)%3
-					, iv = (i+2)%3;
-					
-				//If we are on a boundary, skip it
-				if(x[iu] === 0 || x[iv] === 0) {
-					continue;
-				}
-				
-				//Otherwise, look up adjacent edges in buffer
-				var du = R[iu]
-					, dv = R[iv];
-				
-				//Remember to flip orientation depending on the sign of the corner.
-				if(mask & 1) {
-					faces.push([buffer[m],    buffer[m-du],    buffer[m-dv]]);
-					faces.push([buffer[m-dv], buffer[m-du],    buffer[m-du-dv]]);
-				} else {
-					faces.push([buffer[m],    buffer[m-dv],    buffer[m-du]]);
-					faces.push([buffer[m-du], buffer[m-dv],    buffer[m-du-dv]]);
-				}
-			}
-		}
-	}
-	
-	//All done!  Return the result
-	return { positions: vertices, cells: faces };
-}
-
-export { surfaceNet }

package/src/renderers/shaders/ShaderChunk/cube_uv_reflection_fragment.glsl.js

@@ -1,186 +0,0 @@
-export default /* glsl */`
-#ifdef ENVMAP_TYPE_CUBE_UV
-
-	#define cubeUV_minMipLevel 4.0
-	#define cubeUV_minTileSize 16.0
-
-	// These shader functions convert between the UV coordinates of a single face of
-	// a cubemap, the 0-5 integer index of a cube face, and the direction vector for
-	// sampling a textureCube (not generally normalized ).
-
-	float getFace( vec3 direction ) {
-
-		vec3 absDirection = abs( direction );
-
-		float face = - 1.0;
-
-		if ( absDirection.x > absDirection.z ) {
-
-			if ( absDirection.x > absDirection.y )
-
-				face = direction.x > 0.0 ? 0.0 : 3.0;
-
-			else
-
-				face = direction.y > 0.0 ? 1.0 : 4.0;
-
-		} else {
-
-			if ( absDirection.z > absDirection.y )
-
-				face = direction.z > 0.0 ? 2.0 : 5.0;
-
-			else
-
-				face = direction.y > 0.0 ? 1.0 : 4.0;
-
-		}
-
-		return face;
-
-	}
-
-	// RH coordinate system; PMREM face-indexing convention
-	vec2 getUV( vec3 direction, float face ) {
-
-		vec2 uv;
-
-		if ( face == 0.0 ) {
-
-			uv = vec2( direction.z, direction.y ) / abs( direction.x ); // pos x
-
-		} else if ( face == 1.0 ) {
-
-			uv = vec2( - direction.x, - direction.z ) / abs( direction.y ); // pos y
-
-		} else if ( face == 2.0 ) {
-
-			uv = vec2( - direction.x, direction.y ) / abs( direction.z ); // pos z
-
-		} else if ( face == 3.0 ) {
-
-			uv = vec2( - direction.z, direction.y ) / abs( direction.x ); // neg x
-
-		} else if ( face == 4.0 ) {
-
-			uv = vec2( - direction.x, direction.z ) / abs( direction.y ); // neg y
-
-		} else {
-
-			uv = vec2( direction.x, direction.y ) / abs( direction.z ); // neg z
-
-		}
-
-		return 0.5 * ( uv + 1.0 );
-
-	}
-
-	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
-
-		float face = getFace( direction );
-
-		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
-
-		mipInt = max( mipInt, cubeUV_minMipLevel );
-
-		float faceSize = exp2( mipInt );
-
-		highp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0; // #25071
-
-		if ( face > 2.0 ) {
-
-			uv.y += faceSize;
-
-			face -= 3.0;
-
-		}
-
-		uv.x += face * faceSize;
-
-		uv.x += filterInt * 3.0 * cubeUV_minTileSize;
-
-		uv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );
-
-		uv.x *= CUBEUV_TEXEL_WIDTH;
-		uv.y *= CUBEUV_TEXEL_HEIGHT;
-
-		#ifdef texture2DGradEXT
-
-			return texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb; // disable anisotropic filtering
-
-		#else
-
-			return texture2D( envMap, uv ).rgb;
-
-		#endif
-
-	}
-
-	// These defines must match with PMREMGenerator
-
-	#define cubeUV_r0 1.0
-	#define cubeUV_m0 - 2.0
-	#define cubeUV_r1 0.8
-	#define cubeUV_m1 - 1.0
-	#define cubeUV_r4 0.4
-	#define cubeUV_m4 2.0
-	#define cubeUV_r5 0.305
-	#define cubeUV_m5 3.0
-	#define cubeUV_r6 0.21
-	#define cubeUV_m6 4.0
-
-	float roughnessToMip( float roughness ) {
-
-		float mip = 0.0;
-
-		if ( roughness >= cubeUV_r1 ) {
-
-			mip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;
-
-		} else if ( roughness >= cubeUV_r4 ) {
-
-			mip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;
-
-		} else if ( roughness >= cubeUV_r5 ) {
-
-			mip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;
-
-		} else if ( roughness >= cubeUV_r6 ) {
-
-			mip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;
-
-		} else {
-
-			mip = - 2.0 * log2( 1.16 * roughness ); // 1.16 = 1.79^0.25
-		}
-
-		return mip;
-
-	}
-
-	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
-
-		float mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );
-
-		float mipF = fract( mip );
-
-		float mipInt = floor( mip );
-
-		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
-
-		if ( mipF == 0.0 ) {
-
-			return vec4( color0, 1.0 );
-
-		} else {
-
-			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
-
-			return vec4( mix( color0, color1, mipF ), 1.0 );
-
-		}
-
-	}
-
-#endif
-`;