@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/cjs/node_modules/three/examples/jsm/exporters/STLExporter.js

@@ -1 +1,218 @@
-"use strict";Object.defineProperty(exports,"t",{value:!0});var e=require("three");exports.STLExporter=class{parse(t,n={}){const o=(n=Object.assign({binary:!1},n)).binary,r=[];let l,s=0;t.traverse(function(e){if(e.isMesh){const t=e.geometry,n=t.index,o=t.getAttribute("position");s+=null!==n?n.count/3:o.count/3,r.push({object3d:e,geometry:t})}});let i=80;if(!0===o){const e=new ArrayBuffer(2*s+3*s*4*4+80+4);l=new DataView(e),l.setUint32(i,s,!0),i+=4}else l="",l+="solid exported\n";const c=new e.Vector3,f=new e.Vector3,u=new e.Vector3,a=new e.Vector3,d=new e.Vector3,p=new e.Vector3;for(let e=0,t=r.length;e<t;e++){const t=r[e].object3d,n=r[e].geometry,o=n.index,l=n.getAttribute("position");if(null!==o)for(let e=0;e<o.count;e+=3){w(o.getX(e+0),o.getX(e+1),o.getX(e+2),l,t)}else for(let e=0;e<l.count;e+=3){w(e+0,e+1,e+2,l,t)}}return!1===o&&(l+="endsolid exported\n"),l;function w(e,t,n,r,s){c.fromBufferAttribute(r,e),f.fromBufferAttribute(r,t),u.fromBufferAttribute(r,n),!0===s.isSkinnedMesh&&(s.applyBoneTransform(e,c),s.applyBoneTransform(t,f),s.applyBoneTransform(n,u)),c.applyMatrix4(s.matrixWorld),f.applyMatrix4(s.matrixWorld),u.applyMatrix4(s.matrixWorld),function(e,t,n){a.subVectors(n,t),d.subVectors(e,t),a.cross(d).normalize(),p.copy(a).normalize(),!0===o?(l.setFloat32(i,p.x,!0),i+=4,l.setFloat32(i,p.y,!0),i+=4,l.setFloat32(i,p.z,!0),i+=4):(l+="\tfacet normal "+p.x+" "+p.y+" "+p.z+"\n",l+="\t\touter loop\n")}(c,f,u),x(c),x(f),x(u),!0===o?(l.setUint16(i,0,!0),i+=2):(l+="\t\tendloop\n",l+="\tendfacet\n")}function x(e){!0===o?(l.setFloat32(i,e.x,!0),i+=4,l.setFloat32(i,e.y,!0),i+=4,l.setFloat32(i,e.z,!0),i+=4):l+="\t\t\tvertex "+e.x+" "+e.y+" "+e.z+"\n"}}};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var THREE = require('three');
+
+/**
+ * An exporter for STL.
+ *
+ * STL files describe only the surface geometry of a three-dimensional object without
+ * any representation of color, texture or other common model attributes. The STL format
+ * specifies both ASCII and binary representations, with binary being more compact.
+ * STL files contain no scale information or indexes, and the units are arbitrary.
+ *
+ * ```js
+ * const exporter = new STLExporter();
+ * const data = exporter.parse( mesh, { binary: true } );
+ * ```
+ *
+ * @three_import import { STLExporter } from 'three/addons/exporters/STLExporter.js';
+ */
+class STLExporter {
+
+	/**
+	 * Parses the given 3D object and generates the STL output.
+	 *
+	 * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+	 *
+	 * @param {Object3D} scene - A scene, mesh or any other 3D object containing meshes to encode.
+	 * @param {STLExporter~Options} options - The export options.
+	 * @return {string|ArrayBuffer} The exported STL.
+	 */
+	parse( scene, options = {} ) {
+
+		options = Object.assign( {
+			binary: false
+		}, options );
+
+		const binary = options.binary;
+
+		//
+
+		const objects = [];
+		let triangles = 0;
+
+		scene.traverse( function ( object ) {
+
+			if ( object.isMesh ) {
+
+				const geometry = object.geometry;
+
+				const index = geometry.index;
+				const positionAttribute = geometry.getAttribute( 'position' );
+
+				triangles += ( index !== null ) ? ( index.count / 3 ) : ( positionAttribute.count / 3 );
+
+				objects.push( {
+					object3d: object,
+					geometry: geometry
+				} );
+
+			}
+
+		} );
+
+		let output;
+		let offset = 80; // skip header
+
+		if ( binary === true ) {
+
+			const bufferLength = triangles * 2 + triangles * 3 * 4 * 4 + 80 + 4;
+			const arrayBuffer = new ArrayBuffer( bufferLength );
+			output = new DataView( arrayBuffer );
+			output.setUint32( offset, triangles, true ); offset += 4;
+
+		} else {
+
+			output = '';
+			output += 'solid exported\n';
+
+		}
+
+		const vA = new THREE.Vector3();
+		const vB = new THREE.Vector3();
+		const vC = new THREE.Vector3();
+		const cb = new THREE.Vector3();
+		const ab = new THREE.Vector3();
+		const normal = new THREE.Vector3();
+
+		for ( let i = 0, il = objects.length; i < il; i ++ ) {
+
+			const object = objects[ i ].object3d;
+			const geometry = objects[ i ].geometry;
+
+			const index = geometry.index;
+			const positionAttribute = geometry.getAttribute( 'position' );
+
+			if ( index !== null ) {
+
+				// indexed geometry
+
+				for ( let j = 0; j < index.count; j += 3 ) {
+
+					const a = index.getX( j + 0 );
+					const b = index.getX( j + 1 );
+					const c = index.getX( j + 2 );
+
+					writeFace( a, b, c, positionAttribute, object );
+
+				}
+
+			} else {
+
+				// non-indexed geometry
+
+				for ( let j = 0; j < positionAttribute.count; j += 3 ) {
+
+					const a = j + 0;
+					const b = j + 1;
+					const c = j + 2;
+
+					writeFace( a, b, c, positionAttribute, object );
+
+				}
+
+			}
+
+		}
+
+		if ( binary === false ) {
+
+			output += 'endsolid exported\n';
+
+		}
+
+		return output;
+
+		function writeFace( a, b, c, positionAttribute, object ) {
+
+			vA.fromBufferAttribute( positionAttribute, a );
+			vB.fromBufferAttribute( positionAttribute, b );
+			vC.fromBufferAttribute( positionAttribute, c );
+
+			if ( object.isSkinnedMesh === true ) {
+
+				object.applyBoneTransform( a, vA );
+				object.applyBoneTransform( b, vB );
+				object.applyBoneTransform( c, vC );
+
+			}
+
+			vA.applyMatrix4( object.matrixWorld );
+			vB.applyMatrix4( object.matrixWorld );
+			vC.applyMatrix4( object.matrixWorld );
+
+			writeNormal( vA, vB, vC );
+
+			writeVertex( vA );
+			writeVertex( vB );
+			writeVertex( vC );
+
+			if ( binary === true ) {
+
+				output.setUint16( offset, 0, true ); offset += 2;
+
+			} else {
+
+				output += '\t\tendloop\n';
+				output += '\tendfacet\n';
+
+			}
+
+		}
+
+		function writeNormal( vA, vB, vC ) {
+
+			cb.subVectors( vC, vB );
+			ab.subVectors( vA, vB );
+			cb.cross( ab ).normalize();
+
+			normal.copy( cb ).normalize();
+
+			if ( binary === true ) {
+
+				output.setFloat32( offset, normal.x, true ); offset += 4;
+				output.setFloat32( offset, normal.y, true ); offset += 4;
+				output.setFloat32( offset, normal.z, true ); offset += 4;
+
+			} else {
+
+				output += '\tfacet normal ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
+				output += '\t\touter loop\n';
+
+			}
+
+		}
+
+		function writeVertex( vertex ) {
+
+			if ( binary === true ) {
+
+				output.setFloat32( offset, vertex.x, true ); offset += 4;
+				output.setFloat32( offset, vertex.y, true ); offset += 4;
+				output.setFloat32( offset, vertex.z, true ); offset += 4;
+
+			} else {
+
+				output += '\t\t\tvertex ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+
+			}
+
+		}
+
+	}
+
+}
+
+exports.STLExporter = STLExporter;