opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/3MFLoader.js

@@ -0,0 +1,1123 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../libs/fflate.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../libs/fflate.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.fflateModule);
+    global.MFLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, fflate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ThreeMFLoader = void 0;
+  fflate = _interopRequireWildcard(fflate);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   *
+   * 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 are only partially supported.
+   *
+   * - Texture 2D
+   * - Texture 2D Groups
+   * - Color Groups (Vertex Colors)
+   * - Metallic Display Properties (PBR)
+   */
+  var ThreeMFLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(ThreeMFLoader, _Loader);
+
+    var _super = _createSuper(ThreeMFLoader);
+
+    function ThreeMFLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, ThreeMFLoader);
+
+      _this = _super.call(this, manager);
+      _this.availableExtensions = [];
+      return _this;
+    }
+
+    _createClass(ThreeMFLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setResponseType('arraybuffer');
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (buffer) {
+          try {
+            onLoad(scope.parse(buffer));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(data) {
+        var scope = this;
+        var textureLoader = new _three.TextureLoader(this.manager);
+
+        function loadDocument(data) {
+          var zip = null;
+          var file = null;
+          var relsName;
+          var modelRelsName;
+          var modelPartNames = [];
+          var printTicketPartNames = [];
+          var texturesPartNames = [];
+          var otherPartNames = [];
+          var modelRels;
+          var modelParts = {};
+          var printTicketParts = {};
+          var texturesParts = {};
+          var otherParts = {};
+
+          try {
+            zip = fflate.unzipSync(new Uint8Array(data)); // eslint-disable-line no-undef
+          } catch (e) {
+            if (e instanceof ReferenceError) {
+              console.error('THREE.3MFLoader: fflate missing and file is compressed.');
+              return null;
+            }
+          }
+
+          for (file in zip) {
+            if (file.match(/\_rels\/.rels$/)) {
+              relsName = file;
+            } else if (file.match(/3D\/_rels\/.*\.model\.rels$/)) {
+              modelRelsName = 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 = zip[relsName];
+
+          var relsFileText = _three.LoaderUtils.decodeText(relsView);
+
+          var rels = parseRelsXml(relsFileText); //
+
+          if (modelRelsName) {
+            var _relsView = zip[modelRelsName];
+
+            var _relsFileText = _three.LoaderUtils.decodeText(_relsView);
+
+            modelRels = parseRelsXml(_relsFileText);
+          } //
+
+
+          for (var i = 0; i < modelPartNames.length; i++) {
+            var modelPart = modelPartNames[i];
+            var view = zip[modelPart];
+
+            var fileText = _three.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 _i2 = 0; _i2 < texturesPartNames.length; _i2++) {
+            var texturesPartName = texturesPartNames[_i2];
+            texturesParts[texturesPartName] = zip[texturesPartName].buffer;
+          }
+
+          return {
+            rels: rels,
+            modelRels: modelRels,
+            model: modelParts,
+            printTicket: printTicketParts,
+            texture: texturesParts,
+            other: otherParts
+          };
+        }
+
+        function parseRelsXml(relsFileText) {
+          var relationships = [];
+          var relsXmlData = new DOMParser().parseFromString(relsFileText, 'application/xml');
+          var relsNodes = relsXmlData.querySelectorAll('Relationship');
+
+          for (var i = 0; i < relsNodes.length; i++) {
+            var relsNode = relsNodes[i];
+            var relationship = {
+              target: relsNode.getAttribute('Target'),
+              //required
+              id: relsNode.getAttribute('Id'),
+              //required
+              type: relsNode.getAttribute('Type') //required
+
+            };
+            relationships.push(relationship);
+          }
+
+          return relationships;
+        }
+
+        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);
+            basematerialData.index = i; // the order and count of the material nodes form an implicit 0-based index
+
+            basematerialsData.basematerials.push(basematerialData);
+          }
+
+          return basematerialsData;
+        }
+
+        function parseTexture2DNode(texture2DNode) {
+          var texture2dData = {
+            id: texture2DNode.getAttribute('id'),
+            // required
+            path: texture2DNode.getAttribute('path'),
+            // required
+            contenttype: texture2DNode.getAttribute('contenttype'),
+            // required
+            tilestyleu: texture2DNode.getAttribute('tilestyleu'),
+            tilestylev: texture2DNode.getAttribute('tilestylev'),
+            filter: texture2DNode.getAttribute('filter')
+          };
+          return texture2dData;
+        }
+
+        function parseTextures2DGroupNode(texture2DGroupNode) {
+          var texture2DGroupData = {
+            id: texture2DGroupNode.getAttribute('id'),
+            // required
+            texid: texture2DGroupNode.getAttribute('texid'),
+            // required
+            displaypropertiesid: texture2DGroupNode.getAttribute('displaypropertiesid')
+          };
+          var tex2coordNodes = texture2DGroupNode.querySelectorAll('tex2coord');
+          var uvs = [];
+
+          for (var i = 0; i < tex2coordNodes.length; i++) {
+            var tex2coordNode = tex2coordNodes[i];
+            var u = tex2coordNode.getAttribute('u');
+            var v = tex2coordNode.getAttribute('v');
+            uvs.push(parseFloat(u), parseFloat(v));
+          }
+
+          texture2DGroupData['uvs'] = new Float32Array(uvs);
+          return texture2DGroupData;
+        }
+
+        function parseColorGroupNode(colorGroupNode) {
+          var colorGroupData = {
+            id: colorGroupNode.getAttribute('id'),
+            // required
+            displaypropertiesid: colorGroupNode.getAttribute('displaypropertiesid')
+          };
+          var colorNodes = colorGroupNode.querySelectorAll('color');
+          var colors = [];
+          var colorObject = new _three.Color();
+
+          for (var i = 0; i < colorNodes.length; i++) {
+            var colorNode = colorNodes[i];
+            var color = colorNode.getAttribute('color');
+            colorObject.setStyle(color.substring(0, 7));
+            colorObject.convertSRGBToLinear(); // color is in sRGB
+
+            colors.push(colorObject.r, colorObject.g, colorObject.b);
+          }
+
+          colorGroupData['colors'] = new Float32Array(colors);
+          return colorGroupData;
+        }
+
+        function parseMetallicDisplaypropertiesNode(metallicDisplaypropetiesNode) {
+          var metallicDisplaypropertiesData = {
+            id: metallicDisplaypropetiesNode.getAttribute('id') // required
+
+          };
+          var metallicNodes = metallicDisplaypropetiesNode.querySelectorAll('pbmetallic');
+          var metallicData = [];
+
+          for (var i = 0; i < metallicNodes.length; i++) {
+            var metallicNode = metallicNodes[i];
+            metallicData.push({
+              name: metallicNode.getAttribute('name'),
+              // required
+              metallicness: parseFloat(metallicNode.getAttribute('metallicness')),
+              // required
+              roughness: parseFloat(metallicNode.getAttribute('roughness')) // required
+
+            });
+          }
+
+          metallicDisplaypropertiesData.data = metallicData;
+          return metallicDisplaypropertiesData;
+        }
+
+        function parseBasematerialNode(basematerialNode) {
+          var basematerialData = {};
+          basematerialData['name'] = basematerialNode.getAttribute('name'); // required
+
+          basematerialData['displaycolor'] = basematerialNode.getAttribute('displaycolor'); // required
+
+          basematerialData['displaypropertiesid'] = basematerialNode.getAttribute('displaypropertiesid');
+          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);
+          var triangleProperties = [];
+          var triangles = [];
+          var triangleNodes = meshNode.querySelectorAll('triangles triangle');
+
+          for (var _i3 = 0; _i3 < triangleNodes.length; _i3++) {
+            var triangleNode = triangleNodes[_i3];
+            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');
+            var triangleProperty = {};
+            triangleProperty['v1'] = parseInt(v1, 10);
+            triangleProperty['v2'] = parseInt(v2, 10);
+            triangleProperty['v3'] = parseInt(v3, 10);
+            triangles.push(triangleProperty['v1'], triangleProperty['v2'], triangleProperty['v3']); // optional
+
+            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);
+          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 _three.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 = {};
+          resourcesData['basematerials'] = {};
+          var basematerialsNodes = resourcesNode.querySelectorAll('basematerials');
+
+          for (var i = 0; i < basematerialsNodes.length; i++) {
+            var basematerialsNode = basematerialsNodes[i];
+            var basematerialsData = parseBasematerialsNode(basematerialsNode);
+            resourcesData['basematerials'][basematerialsData['id']] = basematerialsData;
+          } //
+
+
+          resourcesData['texture2d'] = {};
+          var textures2DNodes = resourcesNode.querySelectorAll('texture2d');
+
+          for (var _i4 = 0; _i4 < textures2DNodes.length; _i4++) {
+            var textures2DNode = textures2DNodes[_i4];
+            var texture2DData = parseTexture2DNode(textures2DNode);
+            resourcesData['texture2d'][texture2DData['id']] = texture2DData;
+          } //
+
+
+          resourcesData['colorgroup'] = {};
+          var colorGroupNodes = resourcesNode.querySelectorAll('colorgroup');
+
+          for (var _i5 = 0; _i5 < colorGroupNodes.length; _i5++) {
+            var colorGroupNode = colorGroupNodes[_i5];
+            var colorGroupData = parseColorGroupNode(colorGroupNode);
+            resourcesData['colorgroup'][colorGroupData['id']] = colorGroupData;
+          } //
+
+
+          resourcesData['pbmetallicdisplayproperties'] = {};
+          var pbmetallicdisplaypropertiesNodes = resourcesNode.querySelectorAll('pbmetallicdisplayproperties');
+
+          for (var _i6 = 0; _i6 < pbmetallicdisplaypropertiesNodes.length; _i6++) {
+            var pbmetallicdisplaypropertiesNode = pbmetallicdisplaypropertiesNodes[_i6];
+            var pbmetallicdisplaypropertiesData = parseMetallicDisplaypropertiesNode(pbmetallicdisplaypropertiesNode);
+            resourcesData['pbmetallicdisplayproperties'][pbmetallicdisplaypropertiesData['id']] = pbmetallicdisplaypropertiesData;
+          } //
+
+
+          resourcesData['texture2dgroup'] = {};
+          var textures2DGroupNodes = resourcesNode.querySelectorAll('texture2dgroup');
+
+          for (var _i7 = 0; _i7 < textures2DGroupNodes.length; _i7++) {
+            var textures2DGroupNode = textures2DGroupNodes[_i7];
+            var textures2DGroupData = parseTextures2DGroupNode(textures2DGroupNode);
+            resourcesData['texture2dgroup'][textures2DGroupData['id']] = textures2DGroupData;
+          } //
+
+
+          resourcesData['object'] = {};
+          var objectNodes = resourcesNode.querySelectorAll('object');
+
+          for (var _i8 = 0; _i8 < objectNodes.length; _i8++) {
+            var objectNode = objectNodes[_i8];
+            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 buildTexture(texture2dgroup, objects, modelData, textureData) {
+          var texid = texture2dgroup.texid;
+          var texture2ds = modelData.resources.texture2d;
+          var texture2d = texture2ds[texid];
+
+          if (texture2d) {
+            var _data = textureData[texture2d.path];
+            var type = texture2d.contenttype;
+            var blob = new Blob([_data], {
+              type: type
+            });
+            var sourceURI = URL.createObjectURL(blob);
+            var texture = textureLoader.load(sourceURI, function () {
+              URL.revokeObjectURL(sourceURI);
+            });
+            texture.encoding = _three.sRGBEncoding; // texture parameters
+
+            switch (texture2d.tilestyleu) {
+              case 'wrap':
+                texture.wrapS = _three.RepeatWrapping;
+                break;
+
+              case 'mirror':
+                texture.wrapS = _three.MirroredRepeatWrapping;
+                break;
+
+              case 'none':
+              case 'clamp':
+                texture.wrapS = _three.ClampToEdgeWrapping;
+                break;
+
+              default:
+                texture.wrapS = _three.RepeatWrapping;
+            }
+
+            switch (texture2d.tilestylev) {
+              case 'wrap':
+                texture.wrapT = _three.RepeatWrapping;
+                break;
+
+              case 'mirror':
+                texture.wrapT = _three.MirroredRepeatWrapping;
+                break;
+
+              case 'none':
+              case 'clamp':
+                texture.wrapT = _three.ClampToEdgeWrapping;
+                break;
+
+              default:
+                texture.wrapT = _three.RepeatWrapping;
+            }
+
+            switch (texture2d.filter) {
+              case 'auto':
+                texture.magFilter = _three.LinearFilter;
+                texture.minFilter = _three.LinearMipmapLinearFilter;
+                break;
+
+              case 'linear':
+                texture.magFilter = _three.LinearFilter;
+                texture.minFilter = _three.LinearFilter;
+                break;
+
+              case 'nearest':
+                texture.magFilter = _three.NearestFilter;
+                texture.minFilter = _three.NearestFilter;
+                break;
+
+              default:
+                texture.magFilter = _three.LinearFilter;
+                texture.minFilter = _three.LinearMipmapLinearFilter;
+            }
+
+            return texture;
+          } else {
+            return null;
+          }
+        }
+
+        function buildBasematerialsMeshes(basematerials, triangleProperties, meshData, objects, modelData, textureData, objectData) {
+          var objectPindex = objectData.pindex;
+          var materialMap = {};
+
+          for (var i = 0, l = triangleProperties.length; i < l; i++) {
+            var triangleProperty = triangleProperties[i];
+            var pindex = triangleProperty.p1 !== undefined ? triangleProperty.p1 : objectPindex;
+            if (materialMap[pindex] === undefined) materialMap[pindex] = [];
+            materialMap[pindex].push(triangleProperty);
+          } //
+
+
+          var keys = Object.keys(materialMap);
+          var meshes = [];
+
+          for (var _i9 = 0, _l = keys.length; _i9 < _l; _i9++) {
+            var materialIndex = keys[_i9];
+            var trianglePropertiesProps = materialMap[materialIndex];
+            var basematerialData = basematerials.basematerials[materialIndex];
+            var material = getBuild(basematerialData, objects, modelData, textureData, objectData, buildBasematerial); //
+
+            var geometry = new _three.BufferGeometry();
+            var positionData = [];
+            var vertices = meshData.vertices;
+
+            for (var j = 0, jl = trianglePropertiesProps.length; j < jl; j++) {
+              var _triangleProperty = trianglePropertiesProps[j];
+              positionData.push(vertices[_triangleProperty.v1 * 3 + 0]);
+              positionData.push(vertices[_triangleProperty.v1 * 3 + 1]);
+              positionData.push(vertices[_triangleProperty.v1 * 3 + 2]);
+              positionData.push(vertices[_triangleProperty.v2 * 3 + 0]);
+              positionData.push(vertices[_triangleProperty.v2 * 3 + 1]);
+              positionData.push(vertices[_triangleProperty.v2 * 3 + 2]);
+              positionData.push(vertices[_triangleProperty.v3 * 3 + 0]);
+              positionData.push(vertices[_triangleProperty.v3 * 3 + 1]);
+              positionData.push(vertices[_triangleProperty.v3 * 3 + 2]);
+            }
+
+            geometry.setAttribute('position', new _three.Float32BufferAttribute(positionData, 3)); //
+
+            var mesh = new _three.Mesh(geometry, material);
+            meshes.push(mesh);
+          }
+
+          return meshes;
+        }
+
+        function buildTexturedMesh(texture2dgroup, triangleProperties, meshData, objects, modelData, textureData, objectData) {
+          // geometry
+          var geometry = new _three.BufferGeometry();
+          var positionData = [];
+          var uvData = [];
+          var vertices = meshData.vertices;
+          var uvs = texture2dgroup.uvs;
+
+          for (var i = 0, l = triangleProperties.length; i < l; i++) {
+            var triangleProperty = triangleProperties[i];
+            positionData.push(vertices[triangleProperty.v1 * 3 + 0]);
+            positionData.push(vertices[triangleProperty.v1 * 3 + 1]);
+            positionData.push(vertices[triangleProperty.v1 * 3 + 2]);
+            positionData.push(vertices[triangleProperty.v2 * 3 + 0]);
+            positionData.push(vertices[triangleProperty.v2 * 3 + 1]);
+            positionData.push(vertices[triangleProperty.v2 * 3 + 2]);
+            positionData.push(vertices[triangleProperty.v3 * 3 + 0]);
+            positionData.push(vertices[triangleProperty.v3 * 3 + 1]);
+            positionData.push(vertices[triangleProperty.v3 * 3 + 2]); //
+
+            uvData.push(uvs[triangleProperty.p1 * 2 + 0]);
+            uvData.push(uvs[triangleProperty.p1 * 2 + 1]);
+            uvData.push(uvs[triangleProperty.p2 * 2 + 0]);
+            uvData.push(uvs[triangleProperty.p2 * 2 + 1]);
+            uvData.push(uvs[triangleProperty.p3 * 2 + 0]);
+            uvData.push(uvs[triangleProperty.p3 * 2 + 1]);
+          }
+
+          geometry.setAttribute('position', new _three.Float32BufferAttribute(positionData, 3));
+          geometry.setAttribute('uv', new _three.Float32BufferAttribute(uvData, 2)); // material
+
+          var texture = getBuild(texture2dgroup, objects, modelData, textureData, objectData, buildTexture);
+          var material = new _three.MeshPhongMaterial({
+            map: texture,
+            flatShading: true
+          }); // mesh
+
+          var mesh = new _three.Mesh(geometry, material);
+          return mesh;
+        }
+
+        function buildVertexColorMesh(colorgroup, triangleProperties, meshData, objects, modelData, objectData) {
+          // geometry
+          var geometry = new _three.BufferGeometry();
+          var positionData = [];
+          var colorData = [];
+          var vertices = meshData.vertices;
+          var colors = colorgroup.colors;
+
+          for (var i = 0, l = triangleProperties.length; i < l; i++) {
+            var triangleProperty = triangleProperties[i];
+            var v1 = triangleProperty.v1;
+            var v2 = triangleProperty.v2;
+            var v3 = triangleProperty.v3;
+            positionData.push(vertices[v1 * 3 + 0]);
+            positionData.push(vertices[v1 * 3 + 1]);
+            positionData.push(vertices[v1 * 3 + 2]);
+            positionData.push(vertices[v2 * 3 + 0]);
+            positionData.push(vertices[v2 * 3 + 1]);
+            positionData.push(vertices[v2 * 3 + 2]);
+            positionData.push(vertices[v3 * 3 + 0]);
+            positionData.push(vertices[v3 * 3 + 1]);
+            positionData.push(vertices[v3 * 3 + 2]); //
+
+            var p1 = triangleProperty.p1 !== undefined ? triangleProperty.p1 : objectData.pindex;
+            var p2 = triangleProperty.p2 !== undefined ? triangleProperty.p2 : p1;
+            var p3 = triangleProperty.p3 !== undefined ? triangleProperty.p3 : p1;
+            colorData.push(colors[p1 * 3 + 0]);
+            colorData.push(colors[p1 * 3 + 1]);
+            colorData.push(colors[p1 * 3 + 2]);
+            colorData.push(colors[p2 * 3 + 0]);
+            colorData.push(colors[p2 * 3 + 1]);
+            colorData.push(colors[p2 * 3 + 2]);
+            colorData.push(colors[p3 * 3 + 0]);
+            colorData.push(colors[p3 * 3 + 1]);
+            colorData.push(colors[p3 * 3 + 2]);
+          }
+
+          geometry.setAttribute('position', new _three.Float32BufferAttribute(positionData, 3));
+          geometry.setAttribute('color', new _three.Float32BufferAttribute(colorData, 3)); // material
+
+          var material = new _three.MeshPhongMaterial({
+            vertexColors: true,
+            flatShading: true
+          }); // mesh
+
+          var mesh = new _three.Mesh(geometry, material);
+          return mesh;
+        }
+
+        function buildDefaultMesh(meshData) {
+          var geometry = new _three.BufferGeometry();
+          geometry.setIndex(new _three.BufferAttribute(meshData['triangles'], 1));
+          geometry.setAttribute('position', new _three.BufferAttribute(meshData['vertices'], 3));
+          var material = new _three.MeshPhongMaterial({
+            color: 0xffffff,
+            flatShading: true
+          });
+          var mesh = new _three.Mesh(geometry, material);
+          return mesh;
+        }
+
+        function buildMeshes(resourceMap, meshData, objects, modelData, textureData, objectData) {
+          var keys = Object.keys(resourceMap);
+          var meshes = [];
+
+          for (var i = 0, il = keys.length; i < il; i++) {
+            var resourceId = keys[i];
+            var triangleProperties = resourceMap[resourceId];
+            var resourceType = getResourceType(resourceId, modelData);
+
+            switch (resourceType) {
+              case 'material':
+                var basematerials = modelData.resources.basematerials[resourceId];
+                var newMeshes = buildBasematerialsMeshes(basematerials, triangleProperties, meshData, objects, modelData, textureData, objectData);
+
+                for (var j = 0, jl = newMeshes.length; j < jl; j++) {
+                  meshes.push(newMeshes[j]);
+                }
+
+                break;
+
+              case 'texture':
+                var texture2dgroup = modelData.resources.texture2dgroup[resourceId];
+                meshes.push(buildTexturedMesh(texture2dgroup, triangleProperties, meshData, objects, modelData, textureData, objectData));
+                break;
+
+              case 'vertexColors':
+                var colorgroup = modelData.resources.colorgroup[resourceId];
+                meshes.push(buildVertexColorMesh(colorgroup, triangleProperties, meshData, objects, modelData, objectData));
+                break;
+
+              case 'default':
+                meshes.push(buildDefaultMesh(meshData));
+                break;
+
+              default:
+                console.error('THREE.3MFLoader: Unsupported resource type.');
+            }
+          }
+
+          return meshes;
+        }
+
+        function getResourceType(pid, modelData) {
+          if (modelData.resources.texture2dgroup[pid] !== undefined) {
+            return 'texture';
+          } else if (modelData.resources.basematerials[pid] !== undefined) {
+            return 'material';
+          } else if (modelData.resources.colorgroup[pid] !== undefined) {
+            return 'vertexColors';
+          } else if (pid === 'default') {
+            return 'default';
+          } else {
+            return undefined;
+          }
+        }
+
+        function analyzeObject(modelData, meshData, objectData) {
+          var resourceMap = {};
+          var triangleProperties = meshData['triangleProperties'];
+          var objectPid = objectData.pid;
+
+          for (var i = 0, l = triangleProperties.length; i < l; i++) {
+            var triangleProperty = triangleProperties[i];
+            var pid = triangleProperty.pid !== undefined ? triangleProperty.pid : objectPid;
+            if (pid === undefined) pid = 'default';
+            if (resourceMap[pid] === undefined) resourceMap[pid] = [];
+            resourceMap[pid].push(triangleProperty);
+          }
+
+          return resourceMap;
+        }
+
+        function buildGroup(meshData, objects, modelData, textureData, objectData) {
+          var group = new _three.Group();
+          var resourceMap = analyzeObject(modelData, meshData, objectData);
+          var meshes = buildMeshes(resourceMap, meshData, objects, modelData, textureData, objectData);
+
+          for (var i = 0, l = meshes.length; i < l; i++) {
+            group.add(meshes[i]);
+          }
+
+          return group;
+        }
+
+        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 _i10 = 0; _i10 < availableExtensions.length; _i10++) {
+            var _extension = availableExtensions[_i10];
+
+            _extension.apply(modelXml, extensions[_extension['ns']], meshData);
+          }
+        }
+
+        function getBuild(data, objects, modelData, textureData, objectData, builder) {
+          if (data.build !== undefined) return data.build;
+          data.build = builder(data, objects, modelData, textureData, objectData);
+          return data.build;
+        }
+
+        function buildBasematerial(materialData, objects, modelData) {
+          var material;
+          var displaypropertiesid = materialData.displaypropertiesid;
+          var pbmetallicdisplayproperties = modelData.resources.pbmetallicdisplayproperties;
+
+          if (displaypropertiesid !== null && pbmetallicdisplayproperties[displaypropertiesid] !== undefined) {
+            // metallic display property, use StandardMaterial
+            var pbmetallicdisplayproperty = pbmetallicdisplayproperties[displaypropertiesid];
+            var metallicData = pbmetallicdisplayproperty.data[materialData.index];
+            material = new _three.MeshStandardMaterial({
+              flatShading: true,
+              roughness: metallicData.roughness,
+              metalness: metallicData.metallicness
+            });
+          } else {
+            // otherwise use PhongMaterial
+            material = new _three.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, textureData) {
+          var composite = new _three.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, textureData);
+              _build = objects[component.objectId];
+            }
+
+            var object3D = _build.clone(); // apply component transform
+
+
+            var transform = component.transform;
+
+            if (transform) {
+              object3D.applyMatrix4(transform);
+            }
+
+            composite.add(object3D);
+          }
+
+          return composite;
+        }
+
+        function buildObject(objectId, objects, modelData, textureData) {
+          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, textureData, objectData, buildGroup);
+          } else {
+            var compositeData = objectData['components'];
+            objects[objectData.id] = getBuild(compositeData, objects, modelData, textureData, objectData, buildComposite);
+          }
+        }
+
+        function buildObjects(data3mf) {
+          var modelsData = data3mf.model;
+          var modelRels = data3mf.modelRels;
+          var objects = {};
+          var modelsKeys = Object.keys(modelsData);
+          var textureData = {}; // evaluate model relationships to textures
+
+          if (modelRels) {
+            for (var i = 0, l = modelRels.length; i < l; i++) {
+              var modelRel = modelRels[i];
+              var textureKey = modelRel.target.substring(1);
+
+              if (data3mf.texture[textureKey]) {
+                textureData[modelRel.target] = data3mf.texture[textureKey];
+              }
+            }
+          } // start build
+
+
+          for (var _i11 = 0; _i11 < modelsKeys.length; _i11++) {
+            var modelsKey = modelsKeys[_i11];
+            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, textureData);
+            }
+          }
+
+          return objects;
+        }
+
+        function fetch3DModelPart(rels) {
+          for (var i = 0; i < rels.length; i++) {
+            var rel = rels[i];
+            var extension = rel.target.split('.').pop();
+            if (extension.toLowerCase() === 'model') return rel;
+          }
+        }
+
+        function build(objects, data3mf) {
+          var group = new _three.Group();
+          var relationship = fetch3DModelPart(data3mf['rels']);
+          var buildData = data3mf.model[relationship['target'].substring(1)]['build'];
+
+          for (var i = 0; i < buildData.length; i++) {
+            var buildItem = buildData[i];
+            var object3D = objects[buildItem['objectId']].clone(); // apply transform
+
+            var transform = buildItem['transform'];
+
+            if (transform) {
+              object3D.applyMatrix4(transform);
+            }
+
+            group.add(object3D);
+          }
+
+          return group;
+        }
+
+        var data3mf = loadDocument(data);
+        var objects = buildObjects(data3mf);
+        return build(objects, data3mf);
+      }
+    }, {
+      key: "addExtension",
+      value: function addExtension(extension) {
+        this.availableExtensions.push(extension);
+      }
+    }]);
+
+    return ThreeMFLoader;
+  }(_three.Loader);
+
+  _exports.ThreeMFLoader = ThreeMFLoader;
+});