Merge pull request #16510 from Mugen87/dev30

JSM: More modules and TS files for loaders.

docs/manual/en/introduction/Import-via-modules.html

@@ -116,6 +116,8 @@
 				</li>
 				<li>loaders
 					<ul>
+						<li>3MFLoader</li>
+						<li>AMFLoader</li>
 						<li>AssimpJSONLoader</li>
 						<li>AssimpLoader</li>
 						<li>BabylonLoader</li>
@@ -126,6 +128,8 @@
 						<li>FBXLoader</li>
 						<li>GCodeLoader</li>
 						<li>GLTFLoader</li>
+						<li>KMZLoader</li>
+						<li>KTXLoader</li>
 						<li>MTLLoader</li>
 						<li>OBJLoader</li>
 						<li>PCDLoader</li>

examples/js/loaders/KTXLoader.js

@@ -42,7 +42,7 @@ var KhronosTextureContainer = ( function () {
 	 * @param {boolean} threeDExpected- provision for indicating that data should be a 3D texture, not implemented
 	 * @param {boolean} textureArrayExpected- provision for indicating that data should be a texture array, not implemented
 	 */
-	function KhronosTextureContainer( arrayBuffer, facesExpected, threeDExpected, textureArrayExpected ) {
+	function KhronosTextureContainer( arrayBuffer, facesExpected /*, threeDExpected, textureArrayExpected */ ) {
 
 		this.arrayBuffer = arrayBuffer;
 
@@ -138,13 +138,13 @@ var KhronosTextureContainer = ( function () {
 
 			var imageSize = new Int32Array( this.arrayBuffer, dataOffset, 1 )[ 0 ]; // size per face, since not supporting array cubemaps
 			dataOffset += 4; // size of the image + 4 for the imageSize field
-			
+
 			for ( var face = 0; face < this.numberOfFaces; face ++ ) {
 
 				var byteArray = new Uint8Array( this.arrayBuffer, dataOffset, imageSize );
 
 				mipmaps.push( { "data": byteArray, "width": width, "height": height } );
-				
+
 				dataOffset += imageSize;
 				dataOffset += 3 - ( ( imageSize + 3 ) % 4 ); // add padding for odd sized image
 

examples/jsm/loaders/3MFLoader.d.ts

@@ -0,0 +1,16 @@
+import {
+  LoadingManager,
+  Group
+} from '../../../src/Three';
+
+export class ThreeMFLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+  availableExtensions: object[];
+
+  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+  setPath(value: string): this;
+  parse(data: ArrayBuffer): Group;
+  addExtension(extension: object):void
+}

examples/jsm/loaders/3MFLoader.js

@@ -0,0 +1,943 @@
+/**
+ * @author technohippy / https://github.com/technohippy
+ * @author Mugen87 / https://github.com/Mugen87
+ *
+ * 3D Manufacturing Format (3MF) specification: https://3mf.io/specification/
+ *
+ * The following features from the core specification are supported:
+ *
+ * - 3D Models
+ * - Object Resources (Meshes and Components)
+ * - Material Resources (Base Materials)
+ *
+ * 3MF Materials and Properties Extension (e.g. textures) are not yet supported.
+ *
+ */
+
+import {
+	BufferAttribute,
+	BufferGeometry,
+	DefaultLoadingManager,
+	FileLoader,
+	Group,
+	LoaderUtils,
+	Matrix4,
+	Mesh,
+	MeshPhongMaterial
+} from "../../../build/three.module.js";
+
+var ThreeMFLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+	this.availableExtensions = [];
+
+};
+
+ThreeMFLoader.prototype = {
+
+	constructor: ThreeMFLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+		var loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.load( url, function ( buffer ) {
+
+			onLoad( scope.parse( buffer ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+		return this;
+
+	},
+
+	parse: function ( data ) {
+
+		var scope = this;
+
+		function loadDocument( data ) {
+
+			var zip = null;
+			var file = null;
+
+			var relsName;
+			var modelPartNames = [];
+			var printTicketPartNames = [];
+			var texturesPartNames = [];
+			var otherPartNames = [];
+
+			var rels;
+			var modelParts = {};
+			var printTicketParts = {};
+			var texturesParts = {};
+			var otherParts = {};
+
+			try {
+
+				zip = new JSZip( data ); // eslint-disable-line no-undef
+
+			} catch ( e ) {
+
+				if ( e instanceof ReferenceError ) {
+
+					console.error( 'THREE.3MFLoader: jszip missing and file is compressed.' );
+					return null;
+
+				}
+
+			}
+
+			for ( file in zip.files ) {
+
+				if ( file.match( /\_rels\/.rels$/ ) ) {
+
+					relsName = file;
+
+				} else if ( file.match( /^3D\/.*\.model$/ ) ) {
+
+					modelPartNames.push( file );
+
+				} else if ( file.match( /^3D\/Metadata\/.*\.xml$/ ) ) {
+
+					printTicketPartNames.push( file );
+
+				} else if ( file.match( /^3D\/Textures\/.*/ ) ) {
+
+					texturesPartNames.push( file );
+
+				} else if ( file.match( /^3D\/Other\/.*/ ) ) {
+
+					otherPartNames.push( file );
+
+				}
+
+			}
+
+			var relsView = new Uint8Array( zip.file( relsName ).asArrayBuffer() );
+			var relsFileText = LoaderUtils.decodeText( relsView );
+			rels = parseRelsXml( relsFileText );
+
+			for ( var i = 0; i < modelPartNames.length; i ++ ) {
+
+				var modelPart = modelPartNames[ i ];
+				var view = new Uint8Array( zip.file( modelPart ).asArrayBuffer() );
+
+				var fileText = LoaderUtils.decodeText( view );
+				var xmlData = new DOMParser().parseFromString( fileText, 'application/xml' );
+
+				if ( xmlData.documentElement.nodeName.toLowerCase() !== 'model' ) {
+
+					console.error( 'THREE.3MFLoader: Error loading 3MF - no 3MF document found: ', modelPart );
+
+				}
+
+				var modelNode = xmlData.querySelector( 'model' );
+				var extensions = {};
+
+				for ( var i = 0; i < modelNode.attributes.length; i ++ ) {
+
+					var attr = modelNode.attributes[ i ];
+					if ( attr.name.match( /^xmlns:(.+)$/ ) ) {
+
+						extensions[ attr.value ] = RegExp.$1;
+
+					}
+
+				}
+
+				var modelData = parseModelNode( modelNode );
+				modelData[ 'xml' ] = modelNode;
+
+				if ( 0 < Object.keys( extensions ).length ) {
+
+					modelData[ 'extensions' ] = extensions;
+
+				}
+
+				modelParts[ modelPart ] = modelData;
+
+			}
+
+			for ( var i = 0; i < texturesPartNames.length; i ++ ) {
+
+				var texturesPartName = texturesPartNames[ i ];
+				texturesParts[ texturesPartName ] = zip.file( texturesPartName ).asBinary();
+
+			}
+
+			return {
+				rels: rels,
+				model: modelParts,
+				printTicket: printTicketParts,
+				texture: texturesParts,
+				other: otherParts
+			};
+
+		}
+
+		function parseRelsXml( relsFileText ) {
+
+			var relsXmlData = new DOMParser().parseFromString( relsFileText, 'application/xml' );
+			var relsNode = relsXmlData.querySelector( 'Relationship' );
+			var target = relsNode.getAttribute( 'Target' );
+			var id = relsNode.getAttribute( 'Id' );
+			var type = relsNode.getAttribute( 'Type' );
+
+			return {
+				target: target,
+				id: id,
+				type: type
+			};
+
+		}
+
+		function parseMetadataNodes( metadataNodes ) {
+
+			var metadataData = {};
+
+			for ( var i = 0; i < metadataNodes.length; i ++ ) {
+
+				var metadataNode = metadataNodes[ i ];
+				var name = metadataNode.getAttribute( 'name' );
+				var validNames = [
+					'Title',
+					'Designer',
+					'Description',
+					'Copyright',
+					'LicenseTerms',
+					'Rating',
+					'CreationDate',
+					'ModificationDate'
+				];
+
+				if ( 0 <= validNames.indexOf( name ) ) {
+
+					metadataData[ name ] = metadataNode.textContent;
+
+				}
+
+			}
+
+			return metadataData;
+
+		}
+
+		function parseBasematerialsNode( basematerialsNode ) {
+
+			var basematerialsData = {
+				id: basematerialsNode.getAttribute( 'id' ), // required
+				basematerials: []
+			};
+
+			var basematerialNodes = basematerialsNode.querySelectorAll( 'base' );
+
+			for ( var i = 0; i < basematerialNodes.length; i ++ ) {
+
+				var basematerialNode = basematerialNodes[ i ];
+				var basematerialData = parseBasematerialNode( basematerialNode );
+				basematerialsData.basematerials.push( basematerialData );
+
+			}
+
+			return basematerialsData;
+
+		}
+
+		function parseBasematerialNode( basematerialNode ) {
+
+			var basematerialData = {};
+
+			basematerialData[ 'name' ] = basematerialNode.getAttribute( 'name' ); // required
+			basematerialData[ 'displaycolor' ] = basematerialNode.getAttribute( 'displaycolor' ); // required
+
+			return basematerialData;
+
+		}
+
+		function parseMeshNode( meshNode ) {
+
+			var meshData = {};
+
+			var vertices = [];
+			var vertexNodes = meshNode.querySelectorAll( 'vertices vertex' );
+
+			for ( var i = 0; i < vertexNodes.length; i ++ ) {
+
+				var vertexNode = vertexNodes[ i ];
+				var x = vertexNode.getAttribute( 'x' );
+				var y = vertexNode.getAttribute( 'y' );
+				var z = vertexNode.getAttribute( 'z' );
+
+				vertices.push( parseFloat( x ), parseFloat( y ), parseFloat( z ) );
+
+			}
+
+			meshData[ 'vertices' ] = new Float32Array( vertices.length );
+
+			for ( var i = 0; i < vertices.length; i ++ ) {
+
+				meshData[ 'vertices' ][ i ] = vertices[ i ];
+
+			}
+
+			var triangleProperties = [];
+			var triangles = [];
+			var triangleNodes = meshNode.querySelectorAll( 'triangles triangle' );
+
+			for ( var i = 0; i < triangleNodes.length; i ++ ) {
+
+				var triangleNode = triangleNodes[ i ];
+				var v1 = triangleNode.getAttribute( 'v1' );
+				var v2 = triangleNode.getAttribute( 'v2' );
+				var v3 = triangleNode.getAttribute( 'v3' );
+				var p1 = triangleNode.getAttribute( 'p1' );
+				var p2 = triangleNode.getAttribute( 'p2' );
+				var p3 = triangleNode.getAttribute( 'p3' );
+				var pid = triangleNode.getAttribute( 'pid' );
+
+				triangles.push( parseInt( v1, 10 ), parseInt( v2, 10 ), parseInt( v3, 10 ) );
+
+				var triangleProperty = {};
+
+				if ( p1 ) {
+
+					triangleProperty[ 'p1' ] = parseInt( p1, 10 );
+
+				}
+
+				if ( p2 ) {
+
+					triangleProperty[ 'p2' ] = parseInt( p2, 10 );
+
+				}
+
+				if ( p3 ) {
+
+					triangleProperty[ 'p3' ] = parseInt( p3, 10 );
+
+				}
+
+				if ( pid ) {
+
+					triangleProperty[ 'pid' ] = pid;
+
+				}
+
+				if ( 0 < Object.keys( triangleProperty ).length ) {
+
+					triangleProperties.push( triangleProperty );
+
+				}
+
+			}
+
+			meshData[ 'triangleProperties' ] = triangleProperties;
+			meshData[ 'triangles' ] = new Uint32Array( triangles.length );
+
+			for ( var i = 0; i < triangles.length; i ++ ) {
+
+				meshData[ 'triangles' ][ i ] = triangles[ i ];
+
+			}
+
+			return meshData;
+
+		}
+
+		function parseComponentsNode( componentsNode ) {
+
+			var components = [];
+
+			var componentNodes = componentsNode.querySelectorAll( 'component' );
+
+			for ( var i = 0; i < componentNodes.length; i ++ ) {
+
+				var componentNode = componentNodes[ i ];
+				var componentData = parseComponentNode( componentNode );
+				components.push( componentData );
+
+			}
+
+			return components;
+
+		}
+
+		function parseComponentNode( componentNode ) {
+
+			var componentData = {};
+
+			componentData[ 'objectId' ] = componentNode.getAttribute( 'objectid' ); // required
+
+			var transform = componentNode.getAttribute( 'transform' );
+
+			if ( transform ) {
+
+				componentData[ 'transform' ] = parseTransform( transform );
+
+			}
+
+			return componentData;
+
+		}
+
+		function parseTransform( transform ) {
+
+			var t = [];
+			transform.split( ' ' ).forEach( function ( s ) {
+
+				t.push( parseFloat( s ) );
+
+			} );
+
+			var matrix = new Matrix4();
+			matrix.set(
+				t[ 0 ], t[ 3 ], t[ 6 ], t[ 9 ],
+				t[ 1 ], t[ 4 ], t[ 7 ], t[ 10 ],
+				t[ 2 ], t[ 5 ], t[ 8 ], t[ 11 ],
+				 0.0, 0.0, 0.0, 1.0
+			);
+
+			return matrix;
+
+		}
+
+		function parseObjectNode( objectNode ) {
+
+			var objectData = {
+				type: objectNode.getAttribute( 'type' )
+			};
+
+			var id = objectNode.getAttribute( 'id' );
+
+			if ( id ) {
+
+				objectData[ 'id' ] = id;
+
+			}
+
+			var pid = objectNode.getAttribute( 'pid' );
+
+			if ( pid ) {
+
+				objectData[ 'pid' ] = pid;
+
+			}
+
+			var pindex = objectNode.getAttribute( 'pindex' );
+
+			if ( pindex ) {
+
+				objectData[ 'pindex' ] = pindex;
+
+			}
+
+			var thumbnail = objectNode.getAttribute( 'thumbnail' );
+
+			if ( thumbnail ) {
+
+				objectData[ 'thumbnail' ] = thumbnail;
+
+			}
+
+			var partnumber = objectNode.getAttribute( 'partnumber' );
+
+			if ( partnumber ) {
+
+				objectData[ 'partnumber' ] = partnumber;
+
+			}
+
+			var name = objectNode.getAttribute( 'name' );
+
+			if ( name ) {
+
+				objectData[ 'name' ] = name;
+
+			}
+
+			var meshNode = objectNode.querySelector( 'mesh' );
+
+			if ( meshNode ) {
+
+				objectData[ 'mesh' ] = parseMeshNode( meshNode );
+
+			}
+
+			var componentsNode = objectNode.querySelector( 'components' );
+
+			if ( componentsNode ) {
+
+				objectData[ 'components' ] = parseComponentsNode( componentsNode );
+
+			}
+
+			return objectData;
+
+		}
+
+		function parseResourcesNode( resourcesNode ) {
+
+			var resourcesData = {};
+			var basematerialsNode = resourcesNode.querySelector( 'basematerials' );
+
+			if ( basematerialsNode ) {
+
+				resourcesData[ 'basematerials' ] = parseBasematerialsNode( basematerialsNode );
+
+			}
+
+			resourcesData[ 'object' ] = {};
+			var objectNodes = resourcesNode.querySelectorAll( 'object' );
+
+			for ( var i = 0; i < objectNodes.length; i ++ ) {
+
+				var objectNode = objectNodes[ i ];
+				var objectData = parseObjectNode( objectNode );
+				resourcesData[ 'object' ][ objectData[ 'id' ] ] = objectData;
+
+			}
+
+			return resourcesData;
+
+		}
+
+		function parseBuildNode( buildNode ) {
+
+			var buildData = [];
+			var itemNodes = buildNode.querySelectorAll( 'item' );
+
+			for ( var i = 0; i < itemNodes.length; i ++ ) {
+
+				var itemNode = itemNodes[ i ];
+				var buildItem = {
+					objectId: itemNode.getAttribute( 'objectid' )
+				};
+				var transform = itemNode.getAttribute( 'transform' );
+
+				if ( transform ) {
+
+					buildItem[ 'transform' ] = parseTransform( transform );
+
+				}
+
+				buildData.push( buildItem );
+
+			}
+
+			return buildData;
+
+		}
+
+		function parseModelNode( modelNode ) {
+
+			var modelData = { unit: modelNode.getAttribute( 'unit' ) || 'millimeter' };
+			var metadataNodes = modelNode.querySelectorAll( 'metadata' );
+
+			if ( metadataNodes ) {
+
+				modelData[ 'metadata' ] = parseMetadataNodes( metadataNodes );
+
+			}
+
+			var resourcesNode = modelNode.querySelector( 'resources' );
+
+			if ( resourcesNode ) {
+
+				modelData[ 'resources' ] = parseResourcesNode( resourcesNode );
+
+			}
+
+			var buildNode = modelNode.querySelector( 'build' );
+
+			if ( buildNode ) {
+
+				modelData[ 'build' ] = parseBuildNode( buildNode );
+
+			}
+
+			return modelData;
+
+		}
+
+		function buildMesh( meshData, objects, modelData, objectData ) {
+
+			// geometry
+
+			var geometry = new BufferGeometry();
+			geometry.setIndex( new BufferAttribute( meshData[ 'triangles' ], 1 ) );
+			geometry.addAttribute( 'position', new BufferAttribute( meshData[ 'vertices' ], 3 ) );
+
+			// groups
+
+			var basematerialsData = modelData[ 'resources' ][ 'basematerials' ];
+			var triangleProperties = meshData[ 'triangleProperties' ];
+
+			var start = 0;
+			var count = 0;
+			var currentMaterialIndex = - 1;
+
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
+
+				var triangleProperty = triangleProperties[ i ];
+				var pid = triangleProperty.pid;
+
+				// only proceed if the triangle refers to a basematerials definition
+
+				if ( basematerialsData && ( basematerialsData.id === pid ) ) {
+
+					if ( currentMaterialIndex === - 1 ) currentMaterialIndex = triangleProperty.p1;
+
+					if ( currentMaterialIndex === triangleProperty.p1 ) {
+
+						count += 3; // primitves per triangle
+
+					} else {
+
+						geometry.addGroup( start, count, currentMaterialIndex );
+
+						start += count;
+						count = 3;
+						currentMaterialIndex = triangleProperty.p1;
+
+					}
+
+				}
+
+			}
+
+			if ( geometry.groups.length > 0 ) mergeGroups( geometry );
+
+			geometry.computeBoundingSphere();
+
+			// material
+
+			var material;
+
+			// add material if an object-level definition is present
+
+			if ( basematerialsData && ( basematerialsData.id === objectData.pid ) ) {
+
+				var materialIndex = objectData.pindex;
+				var basematerialData = basematerialsData.basematerials[ materialIndex ];
+
+				material = getBuild( basematerialData, objects, modelData, objectData, buildBasematerial );
+
+			}
+
+			// add/overwrite material if definitions on triangles are present
+
+			if ( geometry.groups.length > 0 ) {
+
+				var groups = geometry.groups;
+				material = [];
+
+				for ( var i = 0, l = groups.length; i < l; i ++ ) {
+
+					var group = groups[ i ];
+					var basematerialData = basematerialsData.basematerials[ group.materialIndex ];
+
+					material.push( getBuild( basematerialData, objects, modelData, objectData, buildBasematerial ) );
+
+				}
+
+			}
+
+			// default material
+
+			if ( material === undefined ) material = new MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
+
+			return new Mesh( geometry, material );
+
+		}
+
+		function mergeGroups( geometry ) {
+
+			// sort by material index
+
+			var groups = geometry.groups.sort( function ( a, b ) {
+
+				if ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex;
+
+				return a.start - b.start;
+
+			} );
+
+			// reorganize index buffer
+
+			var index = geometry.index;
+
+			var itemSize = index.itemSize;
+			var srcArray = index.array;
+
+			var targetOffset = 0;
+
+			var targetArray = new srcArray.constructor( srcArray.length );
+
+			for ( var i = 0; i < groups.length; i ++ ) {
+
+				var group = groups[ i ];
+
+				var groupLength = group.count * itemSize;
+				var groupStart = group.start * itemSize;
+
+				var sub = srcArray.subarray( groupStart, groupStart + groupLength );
+
+				targetArray.set( sub, targetOffset );
+
+				targetOffset += groupLength;
+
+			}
+
+			srcArray.set( targetArray );
+
+			// update groups
+
+			var start = 0;
+
+			for ( i = 0; i < groups.length; i ++ ) {
+
+				group = groups[ i ];
+
+				group.start = start;
+				start += group.count;
+
+			}
+
+			// merge groups
+
+			var lastGroup = groups[ 0 ];
+
+			geometry.groups = [ lastGroup ];
+
+			for ( i = 1; i < groups.length; i ++ ) {
+
+				group = groups[ i ];
+
+				if ( lastGroup.materialIndex === group.materialIndex ) {
+
+					lastGroup.count += group.count;
+
+				} else {
+
+					lastGroup = group;
+					geometry.groups.push( lastGroup );
+
+				}
+
+			}
+
+		}
+
+		function applyExtensions( extensions, meshData, modelXml ) {
+
+			if ( ! extensions ) {
+
+				return;
+
+			}
+
+			var availableExtensions = [];
+			var keys = Object.keys( extensions );
+
+			for ( var i = 0; i < keys.length; i ++ ) {
+
+				var ns = keys[ i ];
+
+				for ( var j = 0; j < scope.availableExtensions.length; j ++ ) {
+
+					var extension = scope.availableExtensions[ j ];
+
+					if ( extension.ns === ns ) {
+
+						availableExtensions.push( extension );
+
+					}
+
+				}
+
+			}
+
+			for ( var i = 0; i < availableExtensions.length; i ++ ) {
+
+				var extension = availableExtensions[ i ];
+				extension.apply( modelXml, extensions[ extension[ 'ns' ] ], meshData );
+
+			}
+
+		}
+
+		function getBuild( data, objects, modelData, objectData, builder ) {
+
+			if ( data.build !== undefined ) return data.build;
+
+			data.build = builder( data, objects, modelData, objectData );
+
+			return data.build;
+
+		}
+
+		function buildBasematerial( materialData ) {
+
+			var material = new MeshPhongMaterial( { flatShading: true } );
+
+			material.name = materialData.name;
+
+			// displaycolor MUST be specified with a value of a 6 or 8 digit hexadecimal number, e.g. "#RRGGBB" or "#RRGGBBAA"
+
+			var displaycolor = materialData.displaycolor;
+
+			var color = displaycolor.substring( 0, 7 );
+			material.color.setStyle( color );
+			material.color.convertSRGBToLinear(); // displaycolor is in sRGB
+
+			// process alpha if set
+
+			if ( displaycolor.length === 9 ) {
+
+				material.opacity = parseInt( displaycolor.charAt( 7 ) + displaycolor.charAt( 8 ), 16 ) / 255;
+
+			}
+
+			return material;
+
+		}
+
+		function buildComposite( compositeData, objects, modelData ) {
+
+			var composite = new Group();
+
+			for ( var j = 0; j < compositeData.length; j ++ ) {
+
+				var component = compositeData[ j ];
+				var build = objects[ component.objectId ];
+
+				if ( build === undefined ) {
+
+					buildObject( component.objectId, objects, modelData );
+					build = objects[ component.objectId ];
+
+				}
+
+				var object3D = build.clone();
+
+				// apply component transfrom
+
+				var transform = component.transform;
+
+				if ( transform ) {
+
+					object3D.applyMatrix( transform );
+
+				}
+
+				composite.add( object3D );
+
+			}
+
+			return composite;
+
+		}
+
+		function buildObject( objectId, objects, modelData ) {
+
+			var objectData = modelData[ 'resources' ][ 'object' ][ objectId ];
+
+			if ( objectData[ 'mesh' ] ) {
+
+				var meshData = objectData[ 'mesh' ];
+
+				var extensions = modelData[ 'extensions' ];
+				var modelXml = modelData[ 'xml' ];
+
+				applyExtensions( extensions, meshData, modelXml );
+
+				objects[ objectData.id ] = getBuild( meshData, objects, modelData, objectData, buildMesh );
+
+			} else {
+
+				var compositeData = objectData[ 'components' ];
+
+				objects[ objectData.id ] = getBuild( compositeData, objects, modelData, objectData, buildComposite );
+
+			}
+
+		}
+
+		function buildObjects( data3mf ) {
+
+			var modelsData = data3mf.model;
+			var objects = {};
+			var modelsKeys = Object.keys( modelsData );
+
+			for ( var i = 0; i < modelsKeys.length; i ++ ) {
+
+				var modelsKey = modelsKeys[ i ];
+				var modelData = modelsData[ modelsKey ];
+
+				var objectIds = Object.keys( modelData[ 'resources' ][ 'object' ] );
+
+				for ( var j = 0; j < objectIds.length; j ++ ) {
+
+					var objectId = objectIds[ j ];
+
+					buildObject( objectId, objects, modelData );
+
+				}
+
+			}
+
+			return objects;
+
+		}
+
+		function build( objects, refs, data3mf ) {
+
+			var group = new Group();
+			var buildData = data3mf.model[ refs[ 'target' ].substring( 1 ) ][ 'build' ];
+
+			for ( var i = 0; i < buildData.length; i ++ ) {
+
+				var buildItem = buildData[ i ];
+				var object3D = objects[ buildItem[ 'objectId' ] ];
+
+				// apply transform
+
+				var transform = buildItem[ 'transform' ];
+
+				if ( transform ) {
+
+					object3D.applyMatrix( transform );
+
+				}
+
+				group.add( object3D );
+
+			}
+
+			return group;
+
+		}
+
+		var data3mf = loadDocument( data );
+		var objects = buildObjects( data3mf );
+
+		return build( objects, data3mf[ 'rels' ], data3mf );
+
+	},
+
+	addExtension: function ( extension ) {
+
+		this.availableExtensions.push( extension );
+
+	}
+
+};
+
+export { ThreeMFLoader };

examples/jsm/loaders/AMFLoader.d.ts

@@ -0,0 +1,14 @@
+import {
+  LoadingManager,
+  Group
+} from '../../../src/Three';
+
+export class AMFLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+
+  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+  setPath(value: string): this;
+  parse(data: ArrayBuffer): Group;
+}

examples/jsm/loaders/AMFLoader.js

@@ -0,0 +1,509 @@
+/*
+ * @author tamarintech / https://tamarintech.com
+ *
+ * Description: Early release of an AMF Loader following the pattern of the
+ * example loaders in the three.js project.
+ *
+ * More information about the AMF format: http://amf.wikispaces.com
+ *
+ * Usage:
+ *	var loader = new AMFLoader();
+ *	loader.load('/path/to/project.amf', function(objecttree) {
+ *		scene.add(objecttree);
+ *	});
+ *
+ * Materials now supported, material colors supported
+ * Zip support, requires jszip
+ * No constellation support (yet)!
+ *
+ */
+
+import {
+	BufferGeometry,
+	Color,
+	DefaultLoadingManager,
+	FileLoader,
+	Float32BufferAttribute,
+	Group,
+	LoaderUtils,
+	Mesh,
+	MeshPhongMaterial
+} from "../../../build/three.module.js";
+
+var AMFLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+};
+
+AMFLoader.prototype = {
+
+	constructor: AMFLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( text ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+		return this;
+
+	},
+
+	parse: function ( data ) {
+
+		function loadDocument( data ) {
+
+			var view = new DataView( data );
+			var magic = String.fromCharCode( view.getUint8( 0 ), view.getUint8( 1 ) );
+
+			if ( magic === 'PK' ) {
+
+				var zip = null;
+				var file = null;
+
+				console.log( 'THREE.AMFLoader: Loading Zip' );
+
+				try {
+
+					zip = new JSZip( data ); // eslint-disable-line no-undef
+
+				} catch ( e ) {
+
+					if ( e instanceof ReferenceError ) {
+
+						console.log( 'THREE.AMFLoader: jszip missing and file is compressed.' );
+						return null;
+
+					}
+
+				}
+
+				for ( file in zip.files ) {
+
+					if ( file.toLowerCase().substr( - 4 ) === '.amf' ) {
+
+						break;
+
+					}
+
+				}
+
+				console.log( 'THREE.AMFLoader: Trying to load file asset: ' + file );
+				view = new DataView( zip.file( file ).asArrayBuffer() );
+
+			}
+
+			var fileText = LoaderUtils.decodeText( view );
+			var xmlData = new DOMParser().parseFromString( fileText, 'application/xml' );
+
+			if ( xmlData.documentElement.nodeName.toLowerCase() !== 'amf' ) {
+
+				console.log( 'THREE.AMFLoader: Error loading AMF - no AMF document found.' );
+				return null;
+
+			}
+
+			return xmlData;
+
+		}
+
+		function loadDocumentScale( node ) {
+
+			var scale = 1.0;
+			var unit = 'millimeter';
+
+			if ( node.documentElement.attributes.unit !== undefined ) {
+
+				unit = node.documentElement.attributes.unit.value.toLowerCase();
+
+			}
+
+			var scaleUnits = {
+				millimeter: 1.0,
+				inch: 25.4,
+				feet: 304.8,
+				meter: 1000.0,
+				micron: 0.001
+			};
+
+			if ( scaleUnits[ unit ] !== undefined ) {
+
+				scale = scaleUnits[ unit ];
+
+			}
+
+			console.log( 'THREE.AMFLoader: Unit scale: ' + scale );
+			return scale;
+
+		}
+
+		function loadMaterials( node ) {
+
+			var matName = 'AMF Material';
+			var matId = node.attributes.id.textContent;
+			var color = { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
+
+			var loadedMaterial = null;
+
+			for ( var i = 0; i < node.childNodes.length; i ++ ) {
+
+				var matChildEl = node.childNodes[ i ];
+
+				if ( matChildEl.nodeName === 'metadata' && matChildEl.attributes.type !== undefined ) {
+
+					if ( matChildEl.attributes.type.value === 'name' ) {
+
+						matName = matChildEl.textContent;
+
+					}
+
+				} else if ( matChildEl.nodeName === 'color' ) {
+
+					color = loadColor( matChildEl );
+
+				}
+
+			}
+
+			loadedMaterial = new MeshPhongMaterial( {
+				flatShading: true,
+				color: new Color( color.r, color.g, color.b ),
+				name: matName
+			} );
+
+			if ( color.a !== 1.0 ) {
+
+				loadedMaterial.transparent = true;
+				loadedMaterial.opacity = color.a;
+
+			}
+
+			return { id: matId, material: loadedMaterial };
+
+		}
+
+		function loadColor( node ) {
+
+			var color = { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
+
+			for ( var i = 0; i < node.childNodes.length; i ++ ) {
+
+				var matColor = node.childNodes[ i ];
+
+				if ( matColor.nodeName === 'r' ) {
+
+					color.r = matColor.textContent;
+
+				} else if ( matColor.nodeName === 'g' ) {
+
+					color.g = matColor.textContent;
+
+				} else if ( matColor.nodeName === 'b' ) {
+
+					color.b = matColor.textContent;
+
+				} else if ( matColor.nodeName === 'a' ) {
+
+					color.a = matColor.textContent;
+
+				}
+
+			}
+
+			return color;
+
+		}
+
+		function loadMeshVolume( node ) {
+
+			var volume = { name: '', triangles: [], materialid: null };
+
+			var currVolumeNode = node.firstElementChild;
+
+			if ( node.attributes.materialid !== undefined ) {
+
+				volume.materialId = node.attributes.materialid.nodeValue;
+
+			}
+
+			while ( currVolumeNode ) {
+
+				if ( currVolumeNode.nodeName === 'metadata' ) {
+
+					if ( currVolumeNode.attributes.type !== undefined ) {
+
+						if ( currVolumeNode.attributes.type.value === 'name' ) {
+
+							volume.name = currVolumeNode.textContent;
+
+						}
+
+					}
+
+				} else if ( currVolumeNode.nodeName === 'triangle' ) {
+
+					var v1 = currVolumeNode.getElementsByTagName( 'v1' )[ 0 ].textContent;
+					var v2 = currVolumeNode.getElementsByTagName( 'v2' )[ 0 ].textContent;
+					var v3 = currVolumeNode.getElementsByTagName( 'v3' )[ 0 ].textContent;
+
+					volume.triangles.push( v1, v2, v3 );
+
+				}
+
+				currVolumeNode = currVolumeNode.nextElementSibling;
+
+			}
+
+			return volume;
+
+		}
+
+		function loadMeshVertices( node ) {
+
+			var vertArray = [];
+			var normalArray = [];
+			var currVerticesNode = node.firstElementChild;
+
+			while ( currVerticesNode ) {
+
+				if ( currVerticesNode.nodeName === 'vertex' ) {
+
+					var vNode = currVerticesNode.firstElementChild;
+
+					while ( vNode ) {
+
+						if ( vNode.nodeName === 'coordinates' ) {
+
+							var x = vNode.getElementsByTagName( 'x' )[ 0 ].textContent;
+							var y = vNode.getElementsByTagName( 'y' )[ 0 ].textContent;
+							var z = vNode.getElementsByTagName( 'z' )[ 0 ].textContent;
+
+							vertArray.push( x, y, z );
+
+						} else if ( vNode.nodeName === 'normal' ) {
+
+							var nx = vNode.getElementsByTagName( 'nx' )[ 0 ].textContent;
+							var ny = vNode.getElementsByTagName( 'ny' )[ 0 ].textContent;
+							var nz = vNode.getElementsByTagName( 'nz' )[ 0 ].textContent;
+
+							normalArray.push( nx, ny, nz );
+
+						}
+
+						vNode = vNode.nextElementSibling;
+
+					}
+
+				}
+				currVerticesNode = currVerticesNode.nextElementSibling;
+
+			}
+
+			return { 'vertices': vertArray, 'normals': normalArray };
+
+		}
+
+		function loadObject( node ) {
+
+			var objId = node.attributes.id.textContent;
+			var loadedObject = { name: 'amfobject', meshes: [] };
+			var currColor = null;
+			var currObjNode = node.firstElementChild;
+
+			while ( currObjNode ) {
+
+				if ( currObjNode.nodeName === 'metadata' ) {
+
+					if ( currObjNode.attributes.type !== undefined ) {
+
+						if ( currObjNode.attributes.type.value === 'name' ) {
+
+							loadedObject.name = currObjNode.textContent;
+
+						}
+
+					}
+
+				} else if ( currObjNode.nodeName === 'color' ) {
+
+					currColor = loadColor( currObjNode );
+
+				} else if ( currObjNode.nodeName === 'mesh' ) {
+
+					var currMeshNode = currObjNode.firstElementChild;
+					var mesh = { vertices: [], normals: [], volumes: [], color: currColor };
+
+					while ( currMeshNode ) {
+
+						if ( currMeshNode.nodeName === 'vertices' ) {
+
+							var loadedVertices = loadMeshVertices( currMeshNode );
+
+							mesh.normals = mesh.normals.concat( loadedVertices.normals );
+							mesh.vertices = mesh.vertices.concat( loadedVertices.vertices );
+
+						} else if ( currMeshNode.nodeName === 'volume' ) {
+
+							mesh.volumes.push( loadMeshVolume( currMeshNode ) );
+
+						}
+
+						currMeshNode = currMeshNode.nextElementSibling;
+
+					}
+
+					loadedObject.meshes.push( mesh );
+
+				}
+
+				currObjNode = currObjNode.nextElementSibling;
+
+			}
+
+			return { 'id': objId, 'obj': loadedObject };
+
+		}
+
+		var xmlData = loadDocument( data );
+		var amfName = '';
+		var amfAuthor = '';
+		var amfScale = loadDocumentScale( xmlData );
+		var amfMaterials = {};
+		var amfObjects = {};
+		var childNodes = xmlData.documentElement.childNodes;
+
+		var i, j;
+
+		for ( i = 0; i < childNodes.length; i ++ ) {
+
+			var child = childNodes[ i ];
+
+			if ( child.nodeName === 'metadata' ) {
+
+				if ( child.attributes.type !== undefined ) {
+
+					if ( child.attributes.type.value === 'name' ) {
+
+						amfName = child.textContent;
+
+					} else if ( child.attributes.type.value === 'author' ) {
+
+						amfAuthor = child.textContent;
+
+					}
+
+				}
+
+			} else if ( child.nodeName === 'material' ) {
+
+				var loadedMaterial = loadMaterials( child );
+
+				amfMaterials[ loadedMaterial.id ] = loadedMaterial.material;
+
+			} else if ( child.nodeName === 'object' ) {
+
+				var loadedObject = loadObject( child );
+
+				amfObjects[ loadedObject.id ] = loadedObject.obj;
+
+			}
+
+		}
+
+		var sceneObject = new Group();
+		var defaultMaterial = new MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
+
+		sceneObject.name = amfName;
+		sceneObject.userData.author = amfAuthor;
+		sceneObject.userData.loader = 'AMF';
+
+		for ( var id in amfObjects ) {
+
+			var part = amfObjects[ id ];
+			var meshes = part.meshes;
+			var newObject = new Group();
+			newObject.name = part.name || '';
+
+			for ( i = 0; i < meshes.length; i ++ ) {
+
+				var objDefaultMaterial = defaultMaterial;
+				var mesh = meshes[ i ];
+				var vertices = new Float32BufferAttribute( mesh.vertices, 3 );
+				var normals = null;
+
+				if ( mesh.normals.length ) {
+
+					normals = new Float32BufferAttribute( mesh.normals, 3 );
+
+				}
+
+				if ( mesh.color ) {
+
+					var color = mesh.color;
+
+					objDefaultMaterial = defaultMaterial.clone();
+					objDefaultMaterial.color = new Color( color.r, color.g, color.b );
+
+					if ( color.a !== 1.0 ) {
+
+						objDefaultMaterial.transparent = true;
+						objDefaultMaterial.opacity = color.a;
+
+					}
+
+				}
+
+				var volumes = mesh.volumes;
+
+				for ( j = 0; j < volumes.length; j ++ ) {
+
+					var volume = volumes[ j ];
+					var newGeometry = new BufferGeometry();
+					var material = objDefaultMaterial;
+
+					newGeometry.setIndex( volume.triangles );
+					newGeometry.addAttribute( 'position', vertices.clone() );
+
+					if ( normals ) {
+
+						newGeometry.addAttribute( 'normal', normals.clone() );
+
+					}
+
+					if ( amfMaterials[ volume.materialId ] !== undefined ) {
+
+						material = amfMaterials[ volume.materialId ];
+
+					}
+
+					newGeometry.scale( amfScale, amfScale, amfScale );
+					newObject.add( new Mesh( newGeometry, material.clone() ) );
+
+				}
+
+			}
+
+			sceneObject.add( newObject );
+
+		}
+
+		return sceneObject;
+
+	}
+
+};
+
+export { AMFLoader };

examples/jsm/loaders/DDSLoader.d.ts

@@ -11,7 +11,7 @@ export interface DDS {
   height: number;
   format: PixelFormat | CompressedPixelFormat;
   mipmapCount: number;
-	isCubemap: boolean;
+  isCubemap: boolean;
 }
 
 export class DDSLoader extends CompressedTextureLoader {

examples/jsm/loaders/KMZLoader.d.ts

@@ -0,0 +1,15 @@
+import {
+  LoadingManager
+} from '../../../src/Three';
+
+import { Collada } from './ColladaLoader';
+
+export class KMZLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+
+  load(url: string, onLoad: (kmz: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+  setPath(value: string): this;
+  parse(data: ArrayBuffer): Collada;
+}

examples/jsm/loaders/KMZLoader.js

@@ -0,0 +1,122 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+import {
+	DefaultLoadingManager,
+	FileLoader,
+	Group,
+	LoadingManager
+} from "../../../build/three.module.js";
+import { ColladaLoader } from "../loaders/ColladaLoader.js";
+
+var KMZLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+};
+
+KMZLoader.prototype = {
+
+	constructor: KMZLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( text ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+		return this;
+
+	},
+
+	parse: function ( data ) {
+
+		function findFile( url ) {
+
+			for ( var path in zip.files ) {
+
+				if ( path.substr( - url.length ) === url ) {
+
+					return zip.files[ path ];
+
+				}
+
+			}
+
+		}
+
+		var manager = new LoadingManager();
+		manager.setURLModifier( function ( url ) {
+
+			var image = findFile( url );
+
+			if ( image ) {
+
+				console.log( 'Loading', url );
+
+				var blob = new Blob( [ image.asArrayBuffer() ], { type: 'application/octet-stream' } );
+				return URL.createObjectURL( blob );
+
+			}
+
+			return url;
+
+		} );
+
+		//
+
+		var zip = new JSZip( data ); // eslint-disable-line no-undef
+
+		if ( zip.files[ 'doc.kml' ] ) {
+
+			var xml = new DOMParser().parseFromString( zip.files[ 'doc.kml' ].asText(), 'application/xml' );
+
+			var model = xml.querySelector( 'Placemark Model Link href' );
+
+			if ( model ) {
+
+				var loader = new ColladaLoader( manager );
+				return loader.parse( zip.files[ model.textContent ].asText() );
+
+			}
+
+		} else {
+
+			console.warn( 'KMZLoader: Missing doc.kml file.' );
+
+			for ( var path in zip.files ) {
+
+				var extension = path.split( '.' ).pop().toLowerCase();
+
+				if ( extension === 'dae' ) {
+
+					var loader = new ColladaLoader( manager );
+					return loader.parse( zip.files[ path ].asText() );
+
+				}
+
+			}
+
+		}
+
+		console.error( 'KMZLoader: Couldn\'t find .dae file.' );
+		return { scene: new Group() };
+
+	}
+
+};
+
+export { KMZLoader };

examples/jsm/loaders/KTXLoader.d.ts

@@ -0,0 +1,22 @@
+import {
+  LoadingManager,
+  CompressedTextureLoader,
+  PixelFormat,
+  CompressedPixelFormat
+} from '../../../src/Three';
+
+export interface KTX {
+  mipmaps: object[];
+  width: number;
+  height: number;
+  format: PixelFormat | CompressedPixelFormat;
+  mipmapCount: number;
+  isCubemap: boolean;
+}
+
+export class KTXLoader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager);
+
+  parse(buffer: ArrayBuffer, loadMipmaps: boolean) : KTX;
+  _parser(buffer: ArrayBuffer, loadMipmaps: boolean) : KTX;
+}

examples/jsm/loaders/KTXLoader.js

@@ -0,0 +1,176 @@
+/**
+ * @author amakaseev / https://github.com/amakaseev
+ *
+ * for description see https://www.khronos.org/opengles/sdk/tools/KTX/
+ * for file layout see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
+ *
+ * ported from https://github.com/BabylonJS/Babylon.js/blob/master/src/Tools/babylon.khronosTextureContainer.ts
+ */
+
+import {
+	CompressedTextureLoader
+} from "../../../build/three.module.js";
+
+
+var KTXLoader = function ( manager ) {
+
+	CompressedTextureLoader.call( this, manager );
+
+	this._parser = KTXLoader.parse;
+
+};
+
+KTXLoader.prototype = Object.create( CompressedTextureLoader.prototype );
+KTXLoader.prototype.constructor = KTXLoader;
+
+KTXLoader.parse = function ( buffer, loadMipmaps ) {
+
+	var ktx = new KhronosTextureContainer( buffer, 1 );
+
+	return {
+		mipmaps: ktx.mipmaps( loadMipmaps ),
+		width: ktx.pixelWidth,
+		height: ktx.pixelHeight,
+		format: ktx.glInternalFormat,
+		isCubemap: ktx.numberOfFaces === 6,
+		mipmapCount: ktx.numberOfMipmapLevels
+	};
+
+};
+
+var KhronosTextureContainer = ( function () {
+
+	/**
+	 * @param {ArrayBuffer} arrayBuffer- contents of the KTX container file
+	 * @param {number} facesExpected- should be either 1 or 6, based whether a cube texture or or
+	 * @param {boolean} threeDExpected- provision for indicating that data should be a 3D texture, not implemented
+	 * @param {boolean} textureArrayExpected- provision for indicating that data should be a texture array, not implemented
+	 */
+	function KhronosTextureContainer( arrayBuffer, facesExpected /*, threeDExpected, textureArrayExpected */ ) {
+
+		this.arrayBuffer = arrayBuffer;
+
+		// Test that it is a ktx formatted file, based on the first 12 bytes, character representation is:
+		// '´', 'K', 'T', 'X', ' ', '1', '1', 'ª', '\r', '\n', '\x1A', '\n'
+		// 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
+		var identifier = new Uint8Array( this.arrayBuffer, 0, 12 );
+		if ( identifier[ 0 ] !== 0xAB ||
+			identifier[ 1 ] !== 0x4B ||
+			identifier[ 2 ] !== 0x54 ||
+			identifier[ 3 ] !== 0x58 ||
+			identifier[ 4 ] !== 0x20 ||
+			identifier[ 5 ] !== 0x31 ||
+			identifier[ 6 ] !== 0x31 ||
+			identifier[ 7 ] !== 0xBB ||
+			identifier[ 8 ] !== 0x0D ||
+			identifier[ 9 ] !== 0x0A ||
+			identifier[ 10 ] !== 0x1A ||
+			identifier[ 11 ] !== 0x0A ) {
+
+			console.error( 'texture missing KTX identifier' );
+			return;
+
+		}
+
+		// load the reset of the header in native 32 bit uint
+		var dataSize = Uint32Array.BYTES_PER_ELEMENT;
+		var headerDataView = new DataView( this.arrayBuffer, 12, 13 * dataSize );
+		var endianness = headerDataView.getUint32( 0, true );
+		var littleEndian = endianness === 0x04030201;
+
+		this.glType = headerDataView.getUint32( 1 * dataSize, littleEndian ); // must be 0 for compressed textures
+		this.glTypeSize = headerDataView.getUint32( 2 * dataSize, littleEndian ); // must be 1 for compressed textures
+		this.glFormat = headerDataView.getUint32( 3 * dataSize, littleEndian ); // must be 0 for compressed textures
+		this.glInternalFormat = headerDataView.getUint32( 4 * dataSize, littleEndian ); // the value of arg passed to gl.compressedTexImage2D(,,x,,,,)
+		this.glBaseInternalFormat = headerDataView.getUint32( 5 * dataSize, littleEndian ); // specify GL_RGB, GL_RGBA, GL_ALPHA, etc (un-compressed only)
+		this.pixelWidth = headerDataView.getUint32( 6 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage2D(,,,x,,,)
+		this.pixelHeight = headerDataView.getUint32( 7 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage2D(,,,,x,,)
+		this.pixelDepth = headerDataView.getUint32( 8 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage3D(,,,,,x,,)
+		this.numberOfArrayElements = headerDataView.getUint32( 9 * dataSize, littleEndian ); // used for texture arrays
+		this.numberOfFaces = headerDataView.getUint32( 10 * dataSize, littleEndian ); // used for cubemap textures, should either be 1 or 6
+		this.numberOfMipmapLevels = headerDataView.getUint32( 11 * dataSize, littleEndian ); // number of levels; disregard possibility of 0 for compressed textures
+		this.bytesOfKeyValueData = headerDataView.getUint32( 12 * dataSize, littleEndian ); // the amount of space after the header for meta-data
+
+		// Make sure we have a compressed type.  Not only reduces work, but probably better to let dev know they are not compressing.
+		if ( this.glType !== 0 ) {
+
+			console.warn( 'only compressed formats currently supported' );
+			return;
+
+		} else {
+
+			// value of zero is an indication to generate mipmaps @ runtime.  Not usually allowed for compressed, so disregard.
+			this.numberOfMipmapLevels = Math.max( 1, this.numberOfMipmapLevels );
+
+		}
+		if ( this.pixelHeight === 0 || this.pixelDepth !== 0 ) {
+
+			console.warn( 'only 2D textures currently supported' );
+			return;
+
+		}
+		if ( this.numberOfArrayElements !== 0 ) {
+
+			console.warn( 'texture arrays not currently supported' );
+			return;
+
+		}
+		if ( this.numberOfFaces !== facesExpected ) {
+
+			console.warn( 'number of faces expected' + facesExpected + ', but found ' + this.numberOfFaces );
+			return;
+
+		}
+		// we now have a completely validated file, so could use existence of loadType as success
+		// would need to make this more elaborate & adjust checks above to support more than one load type
+		this.loadType = KhronosTextureContainer.COMPRESSED_2D;
+
+	}
+
+	// return mipmaps for js
+	KhronosTextureContainer.prototype.mipmaps = function ( loadMipmaps ) {
+
+		var mipmaps = [];
+
+		// initialize width & height for level 1
+		var dataOffset = KhronosTextureContainer.HEADER_LEN + this.bytesOfKeyValueData;
+		var width = this.pixelWidth;
+		var height = this.pixelHeight;
+		var mipmapCount = loadMipmaps ? this.numberOfMipmapLevels : 1;
+
+		for ( var level = 0; level < mipmapCount; level ++ ) {
+
+			var imageSize = new Int32Array( this.arrayBuffer, dataOffset, 1 )[ 0 ]; // size per face, since not supporting array cubemaps
+			dataOffset += 4; // size of the image + 4 for the imageSize field
+
+			for ( var face = 0; face < this.numberOfFaces; face ++ ) {
+
+				var byteArray = new Uint8Array( this.arrayBuffer, dataOffset, imageSize );
+
+				mipmaps.push( { "data": byteArray, "width": width, "height": height } );
+
+				dataOffset += imageSize;
+				dataOffset += 3 - ( ( imageSize + 3 ) % 4 ); // add padding for odd sized image
+
+			}
+			width = Math.max( 1.0, width * 0.5 );
+			height = Math.max( 1.0, height * 0.5 );
+
+		}
+
+		return mipmaps;
+
+	};
+
+	KhronosTextureContainer.HEADER_LEN = 12 + ( 13 * 4 ); // identifier + header elements (not including key value meta-data pairs)
+	// load types
+	KhronosTextureContainer.COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
+	KhronosTextureContainer.COMPRESSED_3D = 1; // uses a gl.compressedTexImage3D()
+	KhronosTextureContainer.TEX_2D = 2; // uses a gl.texImage2D()
+	KhronosTextureContainer.TEX_3D = 3; // uses a gl.texImage3D()
+
+	return KhronosTextureContainer;
+
+}() );
+
+export { KTXLoader };

utils/modularize.js

@@ -34,6 +34,8 @@ var files = [
 	{ path: 'exporters/STLExporter.js', dependencies: [], ignoreList: [] },
 	{ path: 'exporters/TypedGeometryExporter.js', dependencies: [], ignoreList: [] },
 
+	{ path: 'loaders/3MFLoader.js', dependencies: [], ignoreList: [] },
+	{ path: 'loaders/AMFLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/AssimpJSONLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/AssimpLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/BabylonLoader.js', dependencies: [], ignoreList: [] },
@@ -44,6 +46,8 @@ var files = [
 	{ path: 'loaders/FBXLoader.js', dependencies: [ { name: 'TGALoader', path: 'loaders/TGALoader.js' }, { name: 'NURBSCurve', path: 'curves/NURBSCurve.js' } ], ignoreList: [] },
 	{ path: 'loaders/GCodeLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/GLTFLoader.js', dependencies: [], ignoreList: [ 'NoSide', 'Matrix2', 'DDSLoader' ] },
+	{ path: 'loaders/KMZLoader.js', dependencies: [ { name: 'ColladaLoader', path: 'loaders/ColladaLoader.js' } ], ignoreList: [] },
+	{ path: 'loaders/KTXLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/MTLLoader.js', dependencies: [], ignoreList: [ 'BackSide', 'DoubleSide', 'ClampToEdgeWrapping', 'MirroredRepeatWrapping' ] },
 	{ path: 'loaders/OBJLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/PCDLoader.js', dependencies: [], ignoreList: [] },