@anov/3d 0.0.3 → 0.0.4-alpha12

package/examples/jsm/utils/GeometryUtils.js

@@ -1,221 +0,0 @@
-import { Vector3 } from 'three';
-
-
-/**
- * Generates 2D-Coordinates in a very fast way.
- *
- * Based on work by:
- * @link http://www.openprocessing.org/sketch/15493
- *
- * @param center     Center of Hilbert curve.
- * @param size       Total width of Hilbert curve.
- * @param iterations Number of subdivisions.
- * @param v0         Corner index -X, -Z.
- * @param v1         Corner index -X, +Z.
- * @param v2         Corner index +X, +Z.
- * @param v3         Corner index +X, -Z.
- */
-function hilbert2D( center = new Vector3( 0, 0, 0 ), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3 ) {
-
-	const half = size / 2;
-
-	const vec_s = [
-		new Vector3( center.x - half, center.y, center.z - half ),
-		new Vector3( center.x - half, center.y, center.z + half ),
-		new Vector3( center.x + half, center.y, center.z + half ),
-		new Vector3( center.x + half, center.y, center.z - half )
-	];
-
-	const vec = [
-		vec_s[ v0 ],
-		vec_s[ v1 ],
-		vec_s[ v2 ],
-		vec_s[ v3 ]
-	];
-
-	// Recurse iterations
-	if ( 0 <= -- iterations ) {
-
-		return [
-			...hilbert2D( vec[ 0 ], half, iterations, v0, v3, v2, v1 ),
-			...hilbert2D( vec[ 1 ], half, iterations, v0, v1, v2, v3 ),
-			...hilbert2D( vec[ 2 ], half, iterations, v0, v1, v2, v3 ),
-			...hilbert2D( vec[ 3 ], half, iterations, v2, v1, v0, v3 )
-		];
-
-	}
-
-	// Return complete Hilbert Curve.
-	return vec;
-
-}
-
-/**
- * Generates 3D-Coordinates in a very fast way.
- *
- * Based on work by:
- * @link https://openprocessing.org/user/5654
- *
- * @param center     Center of Hilbert curve.
- * @param size       Total width of Hilbert curve.
- * @param iterations Number of subdivisions.
- * @param v0         Corner index -X, +Y, -Z.
- * @param v1         Corner index -X, +Y, +Z.
- * @param v2         Corner index -X, -Y, +Z.
- * @param v3         Corner index -X, -Y, -Z.
- * @param v4         Corner index +X, -Y, -Z.
- * @param v5         Corner index +X, -Y, +Z.
- * @param v6         Corner index +X, +Y, +Z.
- * @param v7         Corner index +X, +Y, -Z.
- */
-function hilbert3D( center = new Vector3( 0, 0, 0 ), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7 ) {
-
-	// Default Vars
-	const half = size / 2;
-
-	const vec_s = [
-		new Vector3( center.x - half, center.y + half, center.z - half ),
-		new Vector3( center.x - half, center.y + half, center.z + half ),
-		new Vector3( center.x - half, center.y - half, center.z + half ),
-		new Vector3( center.x - half, center.y - half, center.z - half ),
-		new Vector3( center.x + half, center.y - half, center.z - half ),
-		new Vector3( center.x + half, center.y - half, center.z + half ),
-		new Vector3( center.x + half, center.y + half, center.z + half ),
-		new Vector3( center.x + half, center.y + half, center.z - half )
-	];
-
-	const vec = [
-		vec_s[ v0 ],
-		vec_s[ v1 ],
-		vec_s[ v2 ],
-		vec_s[ v3 ],
-		vec_s[ v4 ],
-		vec_s[ v5 ],
-		vec_s[ v6 ],
-		vec_s[ v7 ]
-	];
-
-	// Recurse iterations
-	if ( -- iterations >= 0 ) {
-
-		return [
-			...hilbert3D( vec[ 0 ], half, iterations, v0, v3, v4, v7, v6, v5, v2, v1 ),
-			...hilbert3D( vec[ 1 ], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3 ),
-			...hilbert3D( vec[ 2 ], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3 ),
-			...hilbert3D( vec[ 3 ], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5 ),
-			...hilbert3D( vec[ 4 ], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5 ),
-			...hilbert3D( vec[ 5 ], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7 ),
-			...hilbert3D( vec[ 6 ], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7 ),
-			...hilbert3D( vec[ 7 ], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7 )
-		];
-
-	}
-
-	// Return complete Hilbert Curve.
-	return vec;
-
-}
-
-/**
- * Generates a Gosper curve (lying in the XY plane)
- *
- * https://gist.github.com/nitaku/6521802
- *
- * @param size The size of a single gosper island.
- */
-function gosper( size = 1 ) {
-
-	function fractalize( config ) {
-
-		let output;
-		let input = config.axiom;
-
-		for ( let i = 0, il = config.steps; 0 <= il ? i < il : i > il; 0 <= il ? i ++ : i -- ) {
-
-			output = '';
-
-			for ( let j = 0, jl = input.length; j < jl; j ++ ) {
-
-				const char = input[ j ];
-
-				if ( char in config.rules ) {
-
-					output += config.rules[ char ];
-
-				} else {
-
-					output += char;
-
-				}
-
-			}
-
-			input = output;
-
-		}
-
-		return output;
-
-	}
-
-	function toPoints( config ) {
-
-		let currX = 0, currY = 0;
-		let angle = 0;
-		const path = [ 0, 0, 0 ];
-		const fractal = config.fractal;
-
-		for ( let i = 0, l = fractal.length; i < l; i ++ ) {
-
-			const char = fractal[ i ];
-
-			if ( char === '+' ) {
-
-				angle += config.angle;
-
-			} else if ( char === '-' ) {
-
-				angle -= config.angle;
-
-			} else if ( char === 'F' ) {
-
-				currX += config.size * Math.cos( angle );
-				currY += - config.size * Math.sin( angle );
-				path.push( currX, currY, 0 );
-
-			}
-
-		}
-
-		return path;
-
-	}
-
-	//
-
-	const gosper = fractalize( {
-		axiom: 'A',
-		steps: 4,
-		rules: {
-			A: 'A+BF++BF-FA--FAFA-BF+',
-			B: '-FA+BFBF++BF+FA--FA-B'
-		}
-	} );
-
-	const points = toPoints( {
-		fractal: gosper,
-		size: size,
-		angle: Math.PI / 3 // 60 degrees
-	} );
-
-	return points;
-
-}
-
-
-
-export {
-	hilbert2D,
-	hilbert3D,
-	gosper,
-};

package/examples/jsm/utils/LDrawUtils.js

@@ -1,202 +0,0 @@
-import {
-	BufferAttribute,
-	BufferGeometry,
-	Group,
-	LineSegments,
-	Matrix3,
-	Mesh
-} from 'three';
-
-import { mergeGeometries } from './BufferGeometryUtils.js';
-
-class LDrawUtils {
-
-	static mergeObject( object ) {
-
-		// Merges geometries in object by materials and returns new object. Use on not indexed geometries.
-		// The object buffers reference the old object ones.
-		// Special treatment is done to the conditional lines generated by LDrawLoader.
-
-		function extractGroup( geometry, group, elementSize, isConditionalLine ) {
-
-			// Extracts a group from a geometry as a new geometry (with attribute buffers referencing original buffers)
-
-			const newGeometry = new BufferGeometry();
-
-			const originalPositions = geometry.getAttribute( 'position' ).array;
-			const originalNormals = elementSize === 3 ? geometry.getAttribute( 'normal' ).array : null;
-
-			const numVertsGroup = Math.min( group.count, Math.floor( originalPositions.length / 3 ) - group.start );
-			const vertStart = group.start * 3;
-			const vertEnd = ( group.start + numVertsGroup ) * 3;
-
-			const positions = originalPositions.subarray( vertStart, vertEnd );
-			const normals = originalNormals !== null ? originalNormals.subarray( vertStart, vertEnd ) : null;
-
-			newGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
-			if ( normals !== null ) newGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
-
-			if ( isConditionalLine ) {
-
-				const controlArray0 = geometry.getAttribute( 'control0' ).array.subarray( vertStart, vertEnd );
-				const controlArray1 = geometry.getAttribute( 'control1' ).array.subarray( vertStart, vertEnd );
-				const directionArray = geometry.getAttribute( 'direction' ).array.subarray( vertStart, vertEnd );
-
-				newGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
-				newGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
-				newGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
-
-			}
-
-			return newGeometry;
-
-		}
-
-		function addGeometry( mat, geometry, geometries ) {
-
-			const geoms = geometries[ mat.uuid ];
-			if ( ! geoms ) {
-
-				geometries[ mat.uuid ] = {
-					mat: mat,
-					arr: [ geometry ]
-				};
-
-			} else {
-
-				geoms.arr.push( geometry );
-
-			}
-
-		}
-
-		function permuteAttribute( attribute, elemSize ) {
-
-			// Permutes first two vertices of each attribute element
-
-			if ( ! attribute ) return;
-
-			const verts = attribute.array;
-			const numVerts = Math.floor( verts.length / 3 );
-			let offset = 0;
-			for ( let i = 0; i < numVerts; i ++ ) {
-
-				const x = verts[ offset ];
-				const y = verts[ offset + 1 ];
-				const z = verts[ offset + 2 ];
-
-				verts[ offset ] = verts[ offset + 3 ];
-				verts[ offset + 1 ] = verts[ offset + 4 ];
-				verts[ offset + 2 ] = verts[ offset + 5 ];
-
-				verts[ offset + 3 ] = x;
-				verts[ offset + 4 ] = y;
-				verts[ offset + 5 ] = z;
-
-				offset += elemSize * 3;
-
-			}
-
-		}
-
-		// Traverse the object hierarchy collecting geometries and transforming them to world space
-
-		const meshGeometries = {};
-		const linesGeometries = {};
-		const condLinesGeometries = {};
-
-		object.updateMatrixWorld( true );
-		const normalMatrix = new Matrix3();
-
-		object.traverse( c => {
-
-			if ( c.isMesh | c.isLineSegments ) {
-
-				const elemSize = c.isMesh ? 3 : 2;
-
-				const geometry = c.geometry.clone();
-				const matrixIsInverted = c.matrixWorld.determinant() < 0;
-				if ( matrixIsInverted ) {
-
-					permuteAttribute( geometry.attributes.position, elemSize );
-					permuteAttribute( geometry.attributes.normal, elemSize );
-
-				}
-
-				geometry.applyMatrix4( c.matrixWorld );
-
-				if ( c.isConditionalLine ) {
-
-					geometry.attributes.control0.applyMatrix4( c.matrixWorld );
-					geometry.attributes.control1.applyMatrix4( c.matrixWorld );
-					normalMatrix.getNormalMatrix( c.matrixWorld );
-					geometry.attributes.direction.applyNormalMatrix( normalMatrix );
-
-				}
-
-				const geometries = c.isMesh ? meshGeometries : ( c.isConditionalLine ? condLinesGeometries : linesGeometries );
-
-				if ( Array.isArray( c.material ) ) {
-
-					for ( const groupIndex in geometry.groups ) {
-
-						const group = geometry.groups[ groupIndex ];
-						const mat = c.material[ group.materialIndex ];
-						const newGeometry = extractGroup( geometry, group, elemSize, c.isConditionalLine );
-						addGeometry( mat, newGeometry, geometries );
-
-					}
-
-				} else {
-
-					addGeometry( c.material, geometry, geometries );
-
-				}
-
-			}
-
-		} );
-
-		// Create object with merged geometries
-
-		const mergedObject = new Group();
-
-		const meshMaterialsIds = Object.keys( meshGeometries );
-		for ( const meshMaterialsId of meshMaterialsIds ) {
-
-			const meshGeometry = meshGeometries[ meshMaterialsId ];
-			const mergedGeometry = mergeGeometries( meshGeometry.arr );
-			mergedObject.add( new Mesh( mergedGeometry, meshGeometry.mat ) );
-
-		}
-
-		const linesMaterialsIds = Object.keys( linesGeometries );
-		for ( const linesMaterialsId of linesMaterialsIds ) {
-
-			const lineGeometry = linesGeometries[ linesMaterialsId ];
-			const mergedGeometry = mergeGeometries( lineGeometry.arr );
-			mergedObject.add( new LineSegments( mergedGeometry, lineGeometry.mat ) );
-
-		}
-
-		const condLinesMaterialsIds = Object.keys( condLinesGeometries );
-		for ( const condLinesMaterialsId of condLinesMaterialsIds ) {
-
-			const condLineGeometry = condLinesGeometries[ condLinesMaterialsId ];
-			const mergedGeometry = mergeGeometries( condLineGeometry.arr );
-			const condLines = new LineSegments( mergedGeometry, condLineGeometry.mat );
-			condLines.isConditionalLine = true;
-			mergedObject.add( condLines );
-
-		}
-
-		mergedObject.userData.constructionStep = 0;
-		mergedObject.userData.numConstructionSteps = 1;
-
-		return mergedObject;
-
-	}
-
-}
-
-export { LDrawUtils };

package/examples/jsm/utils/PackedPhongMaterial.js

@@ -1,178 +0,0 @@
-
-/**
- * `PackedPhongMaterial` inherited from THREE.MeshPhongMaterial
- *
- * @param {Object} parameters
- */
-import {
-	MeshPhongMaterial,
-	ShaderChunk,
-	ShaderLib,
-	UniformsUtils,
-} from 'three';
-
-class PackedPhongMaterial extends MeshPhongMaterial {
-
-	constructor( parameters ) {
-
-		super();
-
-		this.defines = {};
-		this.type = 'PackedPhongMaterial';
-		this.uniforms = UniformsUtils.merge( [
-
-			ShaderLib.phong.uniforms,
-
-			{
-				quantizeMatPos: { value: null },
-				quantizeMatUV: { value: null }
-			}
-
-		] );
-
-		this.vertexShader = [
-			'#define PHONG',
-
-			'varying vec3 vViewPosition;',
-
-			ShaderChunk.common,
-			ShaderChunk.uv_pars_vertex,
-			ShaderChunk.displacementmap_pars_vertex,
-			ShaderChunk.envmap_pars_vertex,
-			ShaderChunk.color_pars_vertex,
-			ShaderChunk.fog_pars_vertex,
-			ShaderChunk.normal_pars_vertex,
-			ShaderChunk.morphtarget_pars_vertex,
-			ShaderChunk.skinning_pars_vertex,
-			ShaderChunk.shadowmap_pars_vertex,
-			ShaderChunk.logdepthbuf_pars_vertex,
-			ShaderChunk.clipping_planes_pars_vertex,
-
-			`#ifdef USE_PACKED_NORMAL
-					#if USE_PACKED_NORMAL == 0
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							float x = packedNormal.x * 2.0 - 1.0;
-							float y = packedNormal.y * 2.0 - 1.0;
-							vec2 scth = vec2(sin(x * PI), cos(x * PI));
-							vec2 scphi = vec2(sqrt(1.0 - y * y), y);
-							return normalize( vec3(scth.y * scphi.x, scth.x * scphi.x, scphi.y) );
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 1
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = vec3(packedNormal.xy, 1.0 - abs(packedNormal.x) - abs(packedNormal.y));
-							if (v.z < 0.0)
-							{
-								v.xy = (1.0 - abs(v.yx)) * vec2((v.x >= 0.0) ? +1.0 : -1.0, (v.y >= 0.0) ? +1.0 : -1.0);
-							}
-							return normalize(v);
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 2
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = (packedNormal * 2.0) - 1.0;
-							return normalize(v);
-						}
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						uniform mat4 quantizeMatPos;
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 1
-						uniform mat3 quantizeMatUV;
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 0
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = (packedUV * 2.0) - 1.0;
-							return uv;
-						}
-					#endif
-
-					#if USE_PACKED_UV == 1
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = ( vec3(packedUV, 1.0) * quantizeMatUV ).xy;
-							return uv;
-						}
-					#endif
-				#endif`,
-
-			'void main() {',
-
-			ShaderChunk.uv_vertex,
-
-			`#ifdef USE_MAP
-					#ifdef USE_PACKED_UV
-						vMapUv = decodeUV(vMapUv);
-					#endif
-				#endif`,
-
-			ShaderChunk.color_vertex,
-			ShaderChunk.morphcolor_vertex,
-
-			ShaderChunk.beginnormal_vertex,
-
-			`#ifdef USE_PACKED_NORMAL
-					objectNormal = decodeNormal(objectNormal);
-				#endif
-
-				#ifdef USE_TANGENT
-					vec3 objectTangent = vec3( tangent.xyz );
-				#endif
-				`,
-
-			ShaderChunk.morphnormal_vertex,
-			ShaderChunk.skinbase_vertex,
-			ShaderChunk.skinnormal_vertex,
-			ShaderChunk.defaultnormal_vertex,
-			ShaderChunk.normal_vertex,
-
-			ShaderChunk.begin_vertex,
-
-			`#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						transformed = ( vec4(transformed, 1.0) * quantizeMatPos ).xyz;
-					#endif
-				#endif`,
-
-			ShaderChunk.morphtarget_vertex,
-			ShaderChunk.skinning_vertex,
-			ShaderChunk.displacementmap_vertex,
-			ShaderChunk.project_vertex,
-			ShaderChunk.logdepthbuf_vertex,
-			ShaderChunk.clipping_planes_vertex,
-
-			'vViewPosition = - mvPosition.xyz;',
-
-			ShaderChunk.worldpos_vertex,
-			ShaderChunk.envmap_vertex,
-			ShaderChunk.shadowmap_vertex,
-			ShaderChunk.fog_vertex,
-
-			'}',
-		].join( '\n' );
-
-		// Use the original MeshPhongMaterial's fragmentShader.
-		this.fragmentShader = ShaderLib.phong.fragmentShader;
-
-		this.setValues( parameters );
-
-	}
-
-}
-
-export { PackedPhongMaterial };