|
|
@@ -0,0 +1,4121 @@
|
|
|
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+require('./src/loaders');
|
|
|
+
|
|
|
+},{"./src/loaders":8}],2:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
+
|
|
|
+var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
|
|
|
+ return typeof obj === "undefined" ? "undefined" : _typeof2(obj);
|
|
|
+} : function (obj) {
|
|
|
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof2(obj);
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * @author Kyle-Larson https://github.com/Kyle-Larson
|
|
|
+ * @author Takahiro https://github.com/takahirox
|
|
|
+ * @author Lewy Blue https://github.com/looeee
|
|
|
+ *
|
|
|
+ * Loader loads FBX file and generates Group representing FBX scene.
|
|
|
+ * Requires FBX file to be >= 7.0 and in ASCII or to be any version in Binary format.
|
|
|
+ *
|
|
|
+ * Supports:
|
|
|
+ * Mesh Generation (Positional Data)
|
|
|
+ * Normal Data (Per Vertex Drawing Instance)
|
|
|
+ * UV Data (Per Vertex Drawing Instance)
|
|
|
+ * Skinning
|
|
|
+ * Animation
|
|
|
+ * - Separated Animations based on stacks.
|
|
|
+ * - Skeletal & Non-Skeletal Animations
|
|
|
+ * NURBS (Open, Closed and Periodic forms)
|
|
|
+ *
|
|
|
+ * Needs Support:
|
|
|
+ * Euler rotation order
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * FBX format references:
|
|
|
+ * https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure
|
|
|
+ *
|
|
|
+ * Binary format specification:
|
|
|
+ * https://code.blender.org/2013/08/fbx-binary-file-format-specification/
|
|
|
+ * https://wiki.rogiken.org/specifications/file-format/fbx/ (more detail but Japanese)
|
|
|
+ */
|
|
|
+
|
|
|
+// Monkeypatch for <r89
|
|
|
+THREE.LoaderUtils = {
|
|
|
+ extractUrlBase: THREE.Loader.prototype.extractUrlBase,
|
|
|
+ decodeText: function decodeText(array) {
|
|
|
+ return new TextDecoder().decode(array);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+(function () {
|
|
|
+
|
|
|
+ module.exports = THREE.FBXLoader = function (manager) {
|
|
|
+
|
|
|
+ this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager;
|
|
|
+ };
|
|
|
+
|
|
|
+ Object.assign(THREE.FBXLoader.prototype, {
|
|
|
+
|
|
|
+ load: function load(url, onLoad, onProgress, onError) {
|
|
|
+
|
|
|
+ var self = this;
|
|
|
+
|
|
|
+ var resourceDirectory = THREE.LoaderUtils.extractUrlBase(url);
|
|
|
+
|
|
|
+ var loader = new THREE.FileLoader(this.manager);
|
|
|
+ loader.setResponseType('arraybuffer');
|
|
|
+ loader.load(url, function (buffer) {
|
|
|
+
|
|
|
+ try {
|
|
|
+
|
|
|
+ var scene = self.parse(buffer, resourceDirectory);
|
|
|
+ onLoad(scene);
|
|
|
+ } catch (error) {
|
|
|
+
|
|
|
+ window.setTimeout(function () {
|
|
|
+
|
|
|
+ if (onError) onError(error);
|
|
|
+
|
|
|
+ self.manager.itemError(url);
|
|
|
+ }, 0);
|
|
|
+ }
|
|
|
+ }, onProgress, onError);
|
|
|
+ },
|
|
|
+
|
|
|
+ parse: function parse(FBXBuffer, resourceDirectory) {
|
|
|
+
|
|
|
+ var FBXTree;
|
|
|
+
|
|
|
+ if (isFbxFormatBinary(FBXBuffer)) {
|
|
|
+
|
|
|
+ FBXTree = new BinaryParser().parse(FBXBuffer);
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var FBXText = convertArrayBufferToString(FBXBuffer);
|
|
|
+
|
|
|
+ if (!isFbxFormatASCII(FBXText)) {
|
|
|
+
|
|
|
+ throw new Error('THREE.FBXLoader: Unknown format.');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getFbxVersion(FBXText) < 7000) {
|
|
|
+
|
|
|
+ throw new Error('THREE.FBXLoader: FBX version not supported, FileVersion: ' + getFbxVersion(FBXText));
|
|
|
+ }
|
|
|
+
|
|
|
+ FBXTree = new TextParser().parse(FBXText);
|
|
|
+ }
|
|
|
+
|
|
|
+ // console.log( FBXTree );
|
|
|
+
|
|
|
+ var connections = parseConnections(FBXTree);
|
|
|
+ var images = parseImages(FBXTree);
|
|
|
+ var textures = parseTextures(FBXTree, new THREE.TextureLoader(this.manager).setPath(resourceDirectory), images, connections);
|
|
|
+ var materials = parseMaterials(FBXTree, textures, connections);
|
|
|
+ var skeletons = parseDeformers(FBXTree, connections);
|
|
|
+ var geometryMap = parseGeometries(FBXTree, connections, skeletons);
|
|
|
+ var sceneGraph = parseScene(FBXTree, connections, skeletons, geometryMap, materials);
|
|
|
+
|
|
|
+ return sceneGraph;
|
|
|
+ }
|
|
|
+
|
|
|
+ });
|
|
|
+
|
|
|
+ // Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )
|
|
|
+ // and details the connection type
|
|
|
+ function parseConnections(FBXTree) {
|
|
|
+
|
|
|
+ var connectionMap = new Map();
|
|
|
+
|
|
|
+ if ('Connections' in FBXTree) {
|
|
|
+
|
|
|
+ var rawConnections = FBXTree.Connections.connections;
|
|
|
+
|
|
|
+ rawConnections.forEach(function (rawConnection) {
|
|
|
+
|
|
|
+ var fromID = rawConnection[0];
|
|
|
+ var toID = rawConnection[1];
|
|
|
+ var relationship = rawConnection[2];
|
|
|
+
|
|
|
+ if (!connectionMap.has(fromID)) {
|
|
|
+
|
|
|
+ connectionMap.set(fromID, {
|
|
|
+ parents: [],
|
|
|
+ children: []
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var parentRelationship = { ID: toID, relationship: relationship };
|
|
|
+ connectionMap.get(fromID).parents.push(parentRelationship);
|
|
|
+
|
|
|
+ if (!connectionMap.has(toID)) {
|
|
|
+
|
|
|
+ connectionMap.set(toID, {
|
|
|
+ parents: [],
|
|
|
+ children: []
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var childRelationship = { ID: fromID, relationship: relationship };
|
|
|
+ connectionMap.get(toID).children.push(childRelationship);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ return connectionMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse FBXTree.Objects.Video for embedded image data
|
|
|
+ // These images are connected to textures in FBXTree.Objects.Textures
|
|
|
+ // via FBXTree.Connections.
|
|
|
+ function parseImages(FBXTree) {
|
|
|
+
|
|
|
+ var images = {};
|
|
|
+ var blobs = {};
|
|
|
+
|
|
|
+ if ('Video' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var videoNodes = FBXTree.Objects.Video;
|
|
|
+
|
|
|
+ for (var nodeID in videoNodes) {
|
|
|
+
|
|
|
+ var videoNode = videoNodes[nodeID];
|
|
|
+
|
|
|
+ var id = parseInt(nodeID);
|
|
|
+
|
|
|
+ images[id] = videoNode.Filename;
|
|
|
+
|
|
|
+ // raw image data is in videoNode.Content
|
|
|
+ if ('Content' in videoNode) {
|
|
|
+
|
|
|
+ var arrayBufferContent = videoNode.Content instanceof ArrayBuffer && videoNode.Content.byteLength > 0;
|
|
|
+ var base64Content = typeof videoNode.Content === 'string' && videoNode.Content !== '';
|
|
|
+
|
|
|
+ if (arrayBufferContent || base64Content) {
|
|
|
+
|
|
|
+ var image = parseImage(videoNodes[nodeID]);
|
|
|
+
|
|
|
+ blobs[videoNode.Filename] = image;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var id in images) {
|
|
|
+
|
|
|
+ var filename = images[id];
|
|
|
+
|
|
|
+ if (blobs[filename] !== undefined) images[id] = blobs[filename];else images[id] = images[id].split('\\').pop();
|
|
|
+ }
|
|
|
+
|
|
|
+ return images;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse embedded image data in FBXTree.Video.Content
|
|
|
+ function parseImage(videoNode) {
|
|
|
+
|
|
|
+ var content = videoNode.Content;
|
|
|
+ var fileName = videoNode.RelativeFilename || videoNode.Filename;
|
|
|
+ var extension = fileName.slice(fileName.lastIndexOf('.') + 1).toLowerCase();
|
|
|
+
|
|
|
+ var type;
|
|
|
+
|
|
|
+ switch (extension) {
|
|
|
+
|
|
|
+ case 'bmp':
|
|
|
+
|
|
|
+ type = 'image/bmp';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'jpg':
|
|
|
+ case 'jpeg':
|
|
|
+
|
|
|
+ type = 'image/jpeg';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'png':
|
|
|
+
|
|
|
+ type = 'image/png';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'tif':
|
|
|
+
|
|
|
+ type = 'image/tiff';
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+
|
|
|
+ console.warn('FBXLoader: Image type "' + extension + '" is not supported.');
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof content === 'string') {
|
|
|
+ // ASCII format
|
|
|
+
|
|
|
+ return 'data:' + type + ';base64,' + content;
|
|
|
+ } else {
|
|
|
+ // Binary Format
|
|
|
+
|
|
|
+ var array = new Uint8Array(content);
|
|
|
+ return window.URL.createObjectURL(new Blob([array], { type: type }));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse nodes in FBXTree.Objects.Texture
|
|
|
+ // These contain details such as UV scaling, cropping, rotation etc and are connected
|
|
|
+ // to images in FBXTree.Objects.Video
|
|
|
+ function parseTextures(FBXTree, loader, images, connections) {
|
|
|
+
|
|
|
+ var textureMap = new Map();
|
|
|
+
|
|
|
+ if ('Texture' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var textureNodes = FBXTree.Objects.Texture;
|
|
|
+ for (var nodeID in textureNodes) {
|
|
|
+
|
|
|
+ var texture = parseTexture(textureNodes[nodeID], loader, images, connections);
|
|
|
+ textureMap.set(parseInt(nodeID), texture);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return textureMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse individual node in FBXTree.Objects.Texture
|
|
|
+ function parseTexture(textureNode, loader, images, connections) {
|
|
|
+
|
|
|
+ var texture = loadTexture(textureNode, loader, images, connections);
|
|
|
+
|
|
|
+ texture.ID = textureNode.id;
|
|
|
+
|
|
|
+ texture.name = textureNode.attrName;
|
|
|
+
|
|
|
+ var wrapModeU = textureNode.WrapModeU;
|
|
|
+ var wrapModeV = textureNode.WrapModeV;
|
|
|
+
|
|
|
+ var valueU = wrapModeU !== undefined ? wrapModeU.value : 0;
|
|
|
+ var valueV = wrapModeV !== undefined ? wrapModeV.value : 0;
|
|
|
+
|
|
|
+ // http://download.autodesk.com/us/fbx/SDKdocs/FBX_SDK_Help/files/fbxsdkref/class_k_fbx_texture.html#889640e63e2e681259ea81061b85143a
|
|
|
+ // 0: repeat(default), 1: clamp
|
|
|
+
|
|
|
+ texture.wrapS = valueU === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
|
|
|
+ texture.wrapT = valueV === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
|
|
|
+
|
|
|
+ if ('Scaling' in textureNode) {
|
|
|
+
|
|
|
+ var values = textureNode.Scaling.value;
|
|
|
+
|
|
|
+ texture.repeat.x = values[0];
|
|
|
+ texture.repeat.y = values[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ return texture;
|
|
|
+ }
|
|
|
+
|
|
|
+ // load a texture specified as a blob or data URI, or via an external URL using THREE.TextureLoader
|
|
|
+ function loadTexture(textureNode, loader, images, connections) {
|
|
|
+
|
|
|
+ var fileName;
|
|
|
+
|
|
|
+ var currentPath = loader.path;
|
|
|
+
|
|
|
+ var children = connections.get(textureNode.id).children;
|
|
|
+
|
|
|
+ if (children !== undefined && children.length > 0 && images[children[0].ID] !== undefined) {
|
|
|
+
|
|
|
+ fileName = images[children[0].ID];
|
|
|
+
|
|
|
+ if (fileName.indexOf('blob:') === 0 || fileName.indexOf('data:') === 0) {
|
|
|
+
|
|
|
+ loader.setPath(undefined);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var texture = loader.load(fileName);
|
|
|
+
|
|
|
+ loader.setPath(currentPath);
|
|
|
+
|
|
|
+ return texture;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse nodes in FBXTree.Objects.Material
|
|
|
+ function parseMaterials(FBXTree, textureMap, connections) {
|
|
|
+
|
|
|
+ var materialMap = new Map();
|
|
|
+
|
|
|
+ if ('Material' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var materialNodes = FBXTree.Objects.Material;
|
|
|
+
|
|
|
+ for (var nodeID in materialNodes) {
|
|
|
+
|
|
|
+ var material = parseMaterial(FBXTree, materialNodes[nodeID], textureMap, connections);
|
|
|
+
|
|
|
+ if (material !== null) materialMap.set(parseInt(nodeID), material);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return materialMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse single node in FBXTree.Objects.Material
|
|
|
+ // Materials are connected to texture maps in FBXTree.Objects.Textures
|
|
|
+ // FBX format currently only supports Lambert and Phong shading models
|
|
|
+ function parseMaterial(FBXTree, materialNode, textureMap, connections) {
|
|
|
+
|
|
|
+ var ID = materialNode.id;
|
|
|
+ var name = materialNode.attrName;
|
|
|
+ var type = materialNode.ShadingModel;
|
|
|
+
|
|
|
+ //Case where FBX wraps shading model in property object.
|
|
|
+ if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object') {
|
|
|
+
|
|
|
+ type = type.value;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Ignore unused materials which don't have any connections.
|
|
|
+ if (!connections.has(ID)) return null;
|
|
|
+
|
|
|
+ var parameters = parseParameters(FBXTree, materialNode, textureMap, ID, connections);
|
|
|
+
|
|
|
+ var material;
|
|
|
+
|
|
|
+ switch (type.toLowerCase()) {
|
|
|
+
|
|
|
+ case 'phong':
|
|
|
+ material = new THREE.MeshPhongMaterial();
|
|
|
+ break;
|
|
|
+ case 'lambert':
|
|
|
+ material = new THREE.MeshLambertMaterial();
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ console.warn('THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type);
|
|
|
+ material = new THREE.MeshPhongMaterial({ color: 0x3300ff });
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ material.setValues(parameters);
|
|
|
+ material.name = name;
|
|
|
+
|
|
|
+ return material;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse FBX material and return parameters suitable for a three.js material
|
|
|
+ // Also parse the texture map and return any textures associated with the material
|
|
|
+ function parseParameters(FBXTree, properties, textureMap, ID, connections) {
|
|
|
+
|
|
|
+ var parameters = {};
|
|
|
+
|
|
|
+ if (properties.BumpFactor) {
|
|
|
+
|
|
|
+ parameters.bumpScale = properties.BumpFactor.value;
|
|
|
+ }
|
|
|
+ if (properties.Diffuse) {
|
|
|
+
|
|
|
+ parameters.color = new THREE.Color().fromArray(properties.Diffuse.value);
|
|
|
+ }
|
|
|
+ if (properties.DisplacementFactor) {
|
|
|
+
|
|
|
+ parameters.displacementScale = properties.DisplacementFactor.value;
|
|
|
+ }
|
|
|
+ if (properties.ReflectionFactor) {
|
|
|
+
|
|
|
+ parameters.reflectivity = properties.ReflectionFactor.value;
|
|
|
+ }
|
|
|
+ if (properties.Specular) {
|
|
|
+
|
|
|
+ parameters.specular = new THREE.Color().fromArray(properties.Specular.value);
|
|
|
+ }
|
|
|
+ if (properties.Shininess) {
|
|
|
+
|
|
|
+ parameters.shininess = properties.Shininess.value;
|
|
|
+ }
|
|
|
+ if (properties.Emissive) {
|
|
|
+
|
|
|
+ parameters.emissive = new THREE.Color().fromArray(properties.Emissive.value);
|
|
|
+ }
|
|
|
+ if (properties.EmissiveFactor) {
|
|
|
+
|
|
|
+ parameters.emissiveIntensity = parseFloat(properties.EmissiveFactor.value);
|
|
|
+ }
|
|
|
+ if (properties.Opacity) {
|
|
|
+
|
|
|
+ parameters.opacity = parseFloat(properties.Opacity.value);
|
|
|
+ }
|
|
|
+ if (parameters.opacity < 1.0) {
|
|
|
+
|
|
|
+ parameters.transparent = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ connections.get(ID).children.forEach(function (child) {
|
|
|
+
|
|
|
+ var type = child.relationship;
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 'Bump':
|
|
|
+ parameters.bumpMap = textureMap.get(child.ID);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'DiffuseColor':
|
|
|
+ parameters.map = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'DisplacementColor':
|
|
|
+ parameters.displacementMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'EmissiveColor':
|
|
|
+ parameters.emissiveMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NormalMap':
|
|
|
+ parameters.normalMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'ReflectionColor':
|
|
|
+ parameters.envMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ parameters.envMap.mapping = THREE.EquirectangularReflectionMapping;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'SpecularColor':
|
|
|
+ parameters.specularMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'TransparentColor':
|
|
|
+ parameters.alphaMap = getTexture(FBXTree, textureMap, child.ID, connections);
|
|
|
+ parameters.transparent = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'AmbientColor':
|
|
|
+ case 'ShininessExponent': // AKA glossiness map
|
|
|
+ case 'SpecularFactor': // AKA specularLevel
|
|
|
+ case 'VectorDisplacementColor': // NOTE: Seems to be a copy of DisplacementColor
|
|
|
+ default:
|
|
|
+ console.warn('THREE.FBXLoader: %s map is not supported in three.js, skipping texture.', type);
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ return parameters;
|
|
|
+ }
|
|
|
+
|
|
|
+ // get a texture from the textureMap for use by a material.
|
|
|
+ function getTexture(FBXTree, textureMap, id, connections) {
|
|
|
+
|
|
|
+ // if the texture is a layered texture, just use the first layer and issue a warning
|
|
|
+ if ('LayeredTexture' in FBXTree.Objects && id in FBXTree.Objects.LayeredTexture) {
|
|
|
+
|
|
|
+ console.warn('THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.');
|
|
|
+ id = connections.get(id).children[0].ID;
|
|
|
+ }
|
|
|
+
|
|
|
+ return textureMap.get(id);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse nodes in FBXTree.Objects.Deformer
|
|
|
+ // Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here
|
|
|
+ // Generates map of Skeleton-like objects for use later when generating and binding skeletons.
|
|
|
+ function parseDeformers(FBXTree, connections) {
|
|
|
+
|
|
|
+ var skeletons = {};
|
|
|
+
|
|
|
+ if ('Deformer' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var DeformerNodes = FBXTree.Objects.Deformer;
|
|
|
+
|
|
|
+ for (var nodeID in DeformerNodes) {
|
|
|
+
|
|
|
+ var deformerNode = DeformerNodes[nodeID];
|
|
|
+
|
|
|
+ if (deformerNode.attrType === 'Skin') {
|
|
|
+
|
|
|
+ var relationships = connections.get(parseInt(nodeID));
|
|
|
+
|
|
|
+ var skeleton = parseSkeleton(relationships, DeformerNodes);
|
|
|
+ skeleton.ID = nodeID;
|
|
|
+
|
|
|
+ if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
|
|
|
+ skeleton.geometryID = relationships.parents[0].ID;
|
|
|
+
|
|
|
+ skeletons[nodeID] = skeleton;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return skeletons;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse single nodes in FBXTree.Objects.Deformer
|
|
|
+ // The top level deformer nodes have type 'Skin' and subDeformer nodes have type 'Cluster'
|
|
|
+ // Each skin node represents a skeleton and each cluster node represents a bone
|
|
|
+ function parseSkeleton(connections, deformerNodes) {
|
|
|
+
|
|
|
+ var rawBones = [];
|
|
|
+
|
|
|
+ connections.children.forEach(function (child) {
|
|
|
+
|
|
|
+ var subDeformerNode = deformerNodes[child.ID];
|
|
|
+
|
|
|
+ if (subDeformerNode.attrType !== 'Cluster') return;
|
|
|
+
|
|
|
+ var rawBone = {
|
|
|
+
|
|
|
+ ID: child.ID,
|
|
|
+ indices: [],
|
|
|
+ weights: [],
|
|
|
+ transform: new THREE.Matrix4().fromArray(subDeformerNode.Transform.a),
|
|
|
+ transformLink: new THREE.Matrix4().fromArray(subDeformerNode.TransformLink.a),
|
|
|
+ linkMode: subDeformerNode.Mode
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ if ('Indexes' in subDeformerNode) {
|
|
|
+
|
|
|
+ rawBone.indices = subDeformerNode.Indexes.a;
|
|
|
+ rawBone.weights = subDeformerNode.Weights.a;
|
|
|
+ }
|
|
|
+
|
|
|
+ rawBones.push(rawBone);
|
|
|
+ });
|
|
|
+
|
|
|
+ return {
|
|
|
+
|
|
|
+ rawBones: rawBones,
|
|
|
+ bones: []
|
|
|
+
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse nodes in FBXTree.Objects.Geometry
|
|
|
+ function parseGeometries(FBXTree, connections, skeletons) {
|
|
|
+
|
|
|
+ var geometryMap = new Map();
|
|
|
+
|
|
|
+ if ('Geometry' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var geometryNodes = FBXTree.Objects.Geometry;
|
|
|
+
|
|
|
+ for (var nodeID in geometryNodes) {
|
|
|
+
|
|
|
+ var relationships = connections.get(parseInt(nodeID));
|
|
|
+ var geo = parseGeometry(FBXTree, relationships, geometryNodes[nodeID], skeletons);
|
|
|
+
|
|
|
+ geometryMap.set(parseInt(nodeID), geo);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return geometryMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse single node in FBXTree.Objects.Geometry
|
|
|
+ function parseGeometry(FBXTree, relationships, geometryNode, skeletons) {
|
|
|
+
|
|
|
+ switch (geometryNode.attrType) {
|
|
|
+
|
|
|
+ case 'Mesh':
|
|
|
+ return parseMeshGeometry(FBXTree, relationships, geometryNode, skeletons);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NurbsCurve':
|
|
|
+ return parseNurbsGeometry(geometryNode);
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse single node mesh geometry in FBXTree.Objects.Geometry
|
|
|
+ function parseMeshGeometry(FBXTree, relationships, geometryNode, skeletons) {
|
|
|
+
|
|
|
+ var modelNodes = relationships.parents.map(function (parent) {
|
|
|
+
|
|
|
+ return FBXTree.Objects.Model[parent.ID];
|
|
|
+ });
|
|
|
+
|
|
|
+ // don't create geometry if it is not associated with any models
|
|
|
+ if (modelNodes.length === 0) return;
|
|
|
+
|
|
|
+ var skeleton = relationships.children.reduce(function (skeleton, child) {
|
|
|
+
|
|
|
+ if (skeletons[child.ID] !== undefined) skeleton = skeletons[child.ID];
|
|
|
+
|
|
|
+ return skeleton;
|
|
|
+ }, null);
|
|
|
+
|
|
|
+ var preTransform = new THREE.Matrix4();
|
|
|
+
|
|
|
+ // TODO: if there is more than one model associated with the geometry, AND the models have
|
|
|
+ // different geometric transforms, then this will cause problems
|
|
|
+ // if ( modelNodes.length > 1 ) { }
|
|
|
+
|
|
|
+ // For now just assume one model and get the preRotations from that
|
|
|
+ var modelNode = modelNodes[0];
|
|
|
+
|
|
|
+ if ('GeometricRotation' in modelNode) {
|
|
|
+
|
|
|
+ var array = modelNode.GeometricRotation.value.map(THREE.Math.degToRad);
|
|
|
+ array[3] = 'ZYX';
|
|
|
+
|
|
|
+ preTransform.makeRotationFromEuler(new THREE.Euler().fromArray(array));
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('GeometricTranslation' in modelNode) {
|
|
|
+
|
|
|
+ preTransform.setPosition(new THREE.Vector3().fromArray(modelNode.GeometricTranslation.value));
|
|
|
+ }
|
|
|
+
|
|
|
+ return genGeometry(FBXTree, relationships, geometryNode, skeleton, preTransform);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Generate a THREE.BufferGeometry from a node in FBXTree.Objects.Geometry
|
|
|
+ function genGeometry(FBXTree, relationships, geometryNode, skeleton, preTransform) {
|
|
|
+
|
|
|
+ var vertexPositions = geometryNode.Vertices.a;
|
|
|
+ var vertexIndices = geometryNode.PolygonVertexIndex.a;
|
|
|
+
|
|
|
+ // create arrays to hold the final data used to build the buffergeometry
|
|
|
+ var vertexBuffer = [];
|
|
|
+ var normalBuffer = [];
|
|
|
+ var colorsBuffer = [];
|
|
|
+ var uvsBuffer = [];
|
|
|
+ var materialIndexBuffer = [];
|
|
|
+ var vertexWeightsBuffer = [];
|
|
|
+ var weightsIndicesBuffer = [];
|
|
|
+
|
|
|
+ if (geometryNode.LayerElementColor) {
|
|
|
+
|
|
|
+ var colorInfo = getColors(geometryNode.LayerElementColor[0]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (geometryNode.LayerElementMaterial) {
|
|
|
+
|
|
|
+ var materialInfo = getMaterials(geometryNode.LayerElementMaterial[0]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (geometryNode.LayerElementNormal) {
|
|
|
+
|
|
|
+ var normalInfo = getNormals(geometryNode.LayerElementNormal[0]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (geometryNode.LayerElementUV) {
|
|
|
+
|
|
|
+ var uvInfo = [];
|
|
|
+ var i = 0;
|
|
|
+ while (geometryNode.LayerElementUV[i]) {
|
|
|
+
|
|
|
+ uvInfo.push(getUVs(geometryNode.LayerElementUV[i]));
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var weightTable = {};
|
|
|
+
|
|
|
+ if (skeleton !== null) {
|
|
|
+
|
|
|
+ skeleton.rawBones.forEach(function (rawBone, i) {
|
|
|
+
|
|
|
+ // loop over the bone's vertex indices and weights
|
|
|
+ rawBone.indices.forEach(function (index, j) {
|
|
|
+
|
|
|
+ if (weightTable[index] === undefined) weightTable[index] = [];
|
|
|
+
|
|
|
+ weightTable[index].push({
|
|
|
+
|
|
|
+ id: i,
|
|
|
+ weight: rawBone.weights[j]
|
|
|
+
|
|
|
+ });
|
|
|
+ });
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var polygonIndex = 0;
|
|
|
+ var faceLength = 0;
|
|
|
+ var displayedWeightsWarning = false;
|
|
|
+
|
|
|
+ // these will hold data for a single face
|
|
|
+ var vertexPositionIndexes = [];
|
|
|
+ var faceNormals = [];
|
|
|
+ var faceColors = [];
|
|
|
+ var faceUVs = [];
|
|
|
+ var faceWeights = [];
|
|
|
+ var faceWeightIndices = [];
|
|
|
+
|
|
|
+ vertexIndices.forEach(function (vertexIndex, polygonVertexIndex) {
|
|
|
+
|
|
|
+ var endOfFace = false;
|
|
|
+
|
|
|
+ // Face index and vertex index arrays are combined in a single array
|
|
|
+ // A cube with quad faces looks like this:
|
|
|
+ // PolygonVertexIndex: *24 {
|
|
|
+ // a: 0, 1, 3, -3, 2, 3, 5, -5, 4, 5, 7, -7, 6, 7, 1, -1, 1, 7, 5, -4, 6, 0, 2, -5
|
|
|
+ // }
|
|
|
+ // Negative numbers mark the end of a face - first face here is 0, 1, 3, -3
|
|
|
+ // to find index of last vertex multiply by -1 and subtract 1: -3 * - 1 - 1 = 2
|
|
|
+ if (vertexIndex < 0) {
|
|
|
+
|
|
|
+ vertexIndex = vertexIndex ^ -1; // equivalent to ( x * -1 ) - 1
|
|
|
+ vertexIndices[polygonVertexIndex] = vertexIndex;
|
|
|
+ endOfFace = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ var weightIndices = [];
|
|
|
+ var weights = [];
|
|
|
+
|
|
|
+ vertexPositionIndexes.push(vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2);
|
|
|
+
|
|
|
+ if (colorInfo) {
|
|
|
+
|
|
|
+ var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, colorInfo);
|
|
|
+
|
|
|
+ faceColors.push(data[0], data[1], data[2]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (skeleton) {
|
|
|
+
|
|
|
+ if (weightTable[vertexIndex] !== undefined) {
|
|
|
+
|
|
|
+ weightTable[vertexIndex].forEach(function (wt) {
|
|
|
+
|
|
|
+ weights.push(wt.weight);
|
|
|
+ weightIndices.push(wt.id);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (weights.length > 4) {
|
|
|
+
|
|
|
+ if (!displayedWeightsWarning) {
|
|
|
+
|
|
|
+ console.warn('THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.');
|
|
|
+ displayedWeightsWarning = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ var wIndex = [0, 0, 0, 0];
|
|
|
+ var Weight = [0, 0, 0, 0];
|
|
|
+
|
|
|
+ weights.forEach(function (weight, weightIndex) {
|
|
|
+
|
|
|
+ var currentWeight = weight;
|
|
|
+ var currentIndex = weightIndices[weightIndex];
|
|
|
+
|
|
|
+ Weight.forEach(function (comparedWeight, comparedWeightIndex, comparedWeightArray) {
|
|
|
+
|
|
|
+ if (currentWeight > comparedWeight) {
|
|
|
+
|
|
|
+ comparedWeightArray[comparedWeightIndex] = currentWeight;
|
|
|
+ currentWeight = comparedWeight;
|
|
|
+
|
|
|
+ var tmp = wIndex[comparedWeightIndex];
|
|
|
+ wIndex[comparedWeightIndex] = currentIndex;
|
|
|
+ currentIndex = tmp;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ weightIndices = wIndex;
|
|
|
+ weights = Weight;
|
|
|
+ }
|
|
|
+
|
|
|
+ // if the weight array is shorter than 4 pad with 0s
|
|
|
+ while (weights.length < 4) {
|
|
|
+
|
|
|
+ weights.push(0);
|
|
|
+ weightIndices.push(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var i = 0; i < 4; ++i) {
|
|
|
+
|
|
|
+ faceWeights.push(weights[i]);
|
|
|
+ faceWeightIndices.push(weightIndices[i]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (normalInfo) {
|
|
|
+
|
|
|
+ var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, normalInfo);
|
|
|
+
|
|
|
+ faceNormals.push(data[0], data[1], data[2]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (materialInfo && materialInfo.mappingType !== 'AllSame') {
|
|
|
+
|
|
|
+ var materialIndex = getData(polygonVertexIndex, polygonIndex, vertexIndex, materialInfo)[0];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (uvInfo) {
|
|
|
+
|
|
|
+ uvInfo.forEach(function (uv, i) {
|
|
|
+
|
|
|
+ var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, uv);
|
|
|
+
|
|
|
+ if (faceUVs[i] === undefined) {
|
|
|
+
|
|
|
+ faceUVs[i] = [];
|
|
|
+ }
|
|
|
+
|
|
|
+ faceUVs[i].push(data[0]);
|
|
|
+ faceUVs[i].push(data[1]);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ faceLength++;
|
|
|
+
|
|
|
+ // we have reached the end of a face - it may have 4 sides though
|
|
|
+ // in which case the data is split to represent two 3 sided faces
|
|
|
+ if (endOfFace) {
|
|
|
+
|
|
|
+ for (var i = 2; i < faceLength; i++) {
|
|
|
+
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[0]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[1]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[2]]);
|
|
|
+
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3 + 1]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3 + 2]]);
|
|
|
+
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3 + 1]]);
|
|
|
+ vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3 + 2]]);
|
|
|
+
|
|
|
+ if (skeleton) {
|
|
|
+
|
|
|
+ vertexWeightsBuffer.push(faceWeights[0]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[1]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[2]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[3]);
|
|
|
+
|
|
|
+ vertexWeightsBuffer.push(faceWeights[(i - 1) * 4]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 1]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 2]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 3]);
|
|
|
+
|
|
|
+ vertexWeightsBuffer.push(faceWeights[i * 4]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[i * 4 + 1]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[i * 4 + 2]);
|
|
|
+ vertexWeightsBuffer.push(faceWeights[i * 4 + 3]);
|
|
|
+
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[0]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[1]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[2]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[3]);
|
|
|
+
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 1]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 2]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 3]);
|
|
|
+
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[i * 4]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 1]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 2]);
|
|
|
+ weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 3]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (colorInfo) {
|
|
|
+
|
|
|
+ colorsBuffer.push(faceColors[0]);
|
|
|
+ colorsBuffer.push(faceColors[1]);
|
|
|
+ colorsBuffer.push(faceColors[2]);
|
|
|
+
|
|
|
+ colorsBuffer.push(faceColors[(i - 1) * 3]);
|
|
|
+ colorsBuffer.push(faceColors[(i - 1) * 3 + 1]);
|
|
|
+ colorsBuffer.push(faceColors[(i - 1) * 3 + 2]);
|
|
|
+
|
|
|
+ colorsBuffer.push(faceColors[i * 3]);
|
|
|
+ colorsBuffer.push(faceColors[i * 3 + 1]);
|
|
|
+ colorsBuffer.push(faceColors[i * 3 + 2]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (materialInfo && materialInfo.mappingType !== 'AllSame') {
|
|
|
+
|
|
|
+ materialIndexBuffer.push(materialIndex);
|
|
|
+ materialIndexBuffer.push(materialIndex);
|
|
|
+ materialIndexBuffer.push(materialIndex);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (normalInfo) {
|
|
|
+
|
|
|
+ normalBuffer.push(faceNormals[0]);
|
|
|
+ normalBuffer.push(faceNormals[1]);
|
|
|
+ normalBuffer.push(faceNormals[2]);
|
|
|
+
|
|
|
+ normalBuffer.push(faceNormals[(i - 1) * 3]);
|
|
|
+ normalBuffer.push(faceNormals[(i - 1) * 3 + 1]);
|
|
|
+ normalBuffer.push(faceNormals[(i - 1) * 3 + 2]);
|
|
|
+
|
|
|
+ normalBuffer.push(faceNormals[i * 3]);
|
|
|
+ normalBuffer.push(faceNormals[i * 3 + 1]);
|
|
|
+ normalBuffer.push(faceNormals[i * 3 + 2]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (uvInfo) {
|
|
|
+
|
|
|
+ uvInfo.forEach(function (uv, j) {
|
|
|
+
|
|
|
+ if (uvsBuffer[j] === undefined) uvsBuffer[j] = [];
|
|
|
+
|
|
|
+ uvsBuffer[j].push(faceUVs[j][0]);
|
|
|
+ uvsBuffer[j].push(faceUVs[j][1]);
|
|
|
+
|
|
|
+ uvsBuffer[j].push(faceUVs[j][(i - 1) * 2]);
|
|
|
+ uvsBuffer[j].push(faceUVs[j][(i - 1) * 2 + 1]);
|
|
|
+
|
|
|
+ uvsBuffer[j].push(faceUVs[j][i * 2]);
|
|
|
+ uvsBuffer[j].push(faceUVs[j][i * 2 + 1]);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ polygonIndex++;
|
|
|
+ faceLength = 0;
|
|
|
+
|
|
|
+ // reset arrays for the next face
|
|
|
+ vertexPositionIndexes = [];
|
|
|
+ faceNormals = [];
|
|
|
+ faceColors = [];
|
|
|
+ faceUVs = [];
|
|
|
+ faceWeights = [];
|
|
|
+ faceWeightIndices = [];
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ var geo = new THREE.BufferGeometry();
|
|
|
+ geo.name = geometryNode.name;
|
|
|
+
|
|
|
+ var positionAttribute = new THREE.Float32BufferAttribute(vertexBuffer, 3);
|
|
|
+
|
|
|
+ preTransform.applyToBufferAttribute(positionAttribute);
|
|
|
+
|
|
|
+ geo.addAttribute('position', positionAttribute);
|
|
|
+
|
|
|
+ if (colorsBuffer.length > 0) {
|
|
|
+
|
|
|
+ geo.addAttribute('color', new THREE.Float32BufferAttribute(colorsBuffer, 3));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (skeleton) {
|
|
|
+
|
|
|
+ geo.addAttribute('skinIndex', new THREE.Float32BufferAttribute(weightsIndicesBuffer, 4));
|
|
|
+
|
|
|
+ geo.addAttribute('skinWeight', new THREE.Float32BufferAttribute(vertexWeightsBuffer, 4));
|
|
|
+
|
|
|
+ // used later to bind the skeleton to the model
|
|
|
+ geo.FBX_Deformer = skeleton;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (normalBuffer.length > 0) {
|
|
|
+
|
|
|
+ var normalAttribute = new THREE.Float32BufferAttribute(normalBuffer, 3);
|
|
|
+
|
|
|
+ var normalMatrix = new THREE.Matrix3().getNormalMatrix(preTransform);
|
|
|
+ normalMatrix.applyToBufferAttribute(normalAttribute);
|
|
|
+
|
|
|
+ geo.addAttribute('normal', normalAttribute);
|
|
|
+ }
|
|
|
+
|
|
|
+ uvsBuffer.forEach(function (uvBuffer, i) {
|
|
|
+
|
|
|
+ // subsequent uv buffers are called 'uv1', 'uv2', ...
|
|
|
+ var name = 'uv' + (i + 1).toString();
|
|
|
+
|
|
|
+ // the first uv buffer is just called 'uv'
|
|
|
+ if (i === 0) {
|
|
|
+
|
|
|
+ name = 'uv';
|
|
|
+ }
|
|
|
+
|
|
|
+ geo.addAttribute(name, new THREE.Float32BufferAttribute(uvsBuffer[i], 2));
|
|
|
+ });
|
|
|
+
|
|
|
+ if (materialInfo && materialInfo.mappingType !== 'AllSame') {
|
|
|
+
|
|
|
+ // Convert the material indices of each vertex into rendering groups on the geometry.
|
|
|
+ var prevMaterialIndex = materialIndexBuffer[0];
|
|
|
+ var startIndex = 0;
|
|
|
+
|
|
|
+ materialIndexBuffer.forEach(function (currentIndex, i) {
|
|
|
+
|
|
|
+ if (currentIndex !== prevMaterialIndex) {
|
|
|
+
|
|
|
+ geo.addGroup(startIndex, i - startIndex, prevMaterialIndex);
|
|
|
+
|
|
|
+ prevMaterialIndex = currentIndex;
|
|
|
+ startIndex = i;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ // the loop above doesn't add the last group, do that here.
|
|
|
+ if (geo.groups.length > 0) {
|
|
|
+
|
|
|
+ var lastGroup = geo.groups[geo.groups.length - 1];
|
|
|
+ var lastIndex = lastGroup.start + lastGroup.count;
|
|
|
+
|
|
|
+ if (lastIndex !== materialIndexBuffer.length) {
|
|
|
+
|
|
|
+ geo.addGroup(lastIndex, materialIndexBuffer.length - lastIndex, prevMaterialIndex);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // case where there are multiple materials but the whole geometry is only
|
|
|
+ // using one of them
|
|
|
+ if (geo.groups.length === 0) {
|
|
|
+
|
|
|
+ geo.addGroup(0, materialIndexBuffer.length, materialIndexBuffer[0]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return geo;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists
|
|
|
+ function getNormals(NormalNode) {
|
|
|
+
|
|
|
+ var mappingType = NormalNode.MappingInformationType;
|
|
|
+ var referenceType = NormalNode.ReferenceInformationType;
|
|
|
+ var buffer = NormalNode.Normals.a;
|
|
|
+ var indexBuffer = [];
|
|
|
+ if (referenceType === 'IndexToDirect') {
|
|
|
+
|
|
|
+ if ('NormalIndex' in NormalNode) {
|
|
|
+
|
|
|
+ indexBuffer = NormalNode.NormalIndex.a;
|
|
|
+ } else if ('NormalsIndex' in NormalNode) {
|
|
|
+
|
|
|
+ indexBuffer = NormalNode.NormalsIndex.a;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 3,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists
|
|
|
+ function getUVs(UVNode) {
|
|
|
+
|
|
|
+ var mappingType = UVNode.MappingInformationType;
|
|
|
+ var referenceType = UVNode.ReferenceInformationType;
|
|
|
+ var buffer = UVNode.UV.a;
|
|
|
+ var indexBuffer = [];
|
|
|
+ if (referenceType === 'IndexToDirect') {
|
|
|
+
|
|
|
+ indexBuffer = UVNode.UVIndex.a;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 2,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists
|
|
|
+ function getColors(ColorNode) {
|
|
|
+
|
|
|
+ var mappingType = ColorNode.MappingInformationType;
|
|
|
+ var referenceType = ColorNode.ReferenceInformationType;
|
|
|
+ var buffer = ColorNode.Colors.a;
|
|
|
+ var indexBuffer = [];
|
|
|
+ if (referenceType === 'IndexToDirect') {
|
|
|
+
|
|
|
+ indexBuffer = ColorNode.ColorIndex.a;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 4,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists
|
|
|
+ function getMaterials(MaterialNode) {
|
|
|
+
|
|
|
+ var mappingType = MaterialNode.MappingInformationType;
|
|
|
+ var referenceType = MaterialNode.ReferenceInformationType;
|
|
|
+
|
|
|
+ if (mappingType === 'NoMappingInformation') {
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 1,
|
|
|
+ buffer: [0],
|
|
|
+ indices: [0],
|
|
|
+ mappingType: 'AllSame',
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ var materialIndexBuffer = MaterialNode.Materials.a;
|
|
|
+
|
|
|
+ // Since materials are stored as indices, there's a bit of a mismatch between FBX and what
|
|
|
+ // we expect.So we create an intermediate buffer that points to the index in the buffer,
|
|
|
+ // for conforming with the other functions we've written for other data.
|
|
|
+ var materialIndices = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < materialIndexBuffer.length; ++i) {
|
|
|
+
|
|
|
+ materialIndices.push(i);
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 1,
|
|
|
+ buffer: materialIndexBuffer,
|
|
|
+ indices: materialIndices,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ // Functions use the infoObject and given indices to return value array of geometry.
|
|
|
+ // Parameters:
|
|
|
+ // - polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ // - polygonIndex - Index of polygon in geometry.
|
|
|
+ // - vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ // - infoObject: can be materialInfo, normalInfo, UVInfo or colorInfo
|
|
|
+ // Index type:
|
|
|
+ // - Direct: index is same as polygonVertexIndex
|
|
|
+ // - IndexToDirect: infoObject has it's own set of indices
|
|
|
+ var dataArray = [];
|
|
|
+
|
|
|
+ var GetData = {
|
|
|
+
|
|
|
+ ByPolygonVertex: {
|
|
|
+
|
|
|
+ Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var from = polygonVertexIndex * infoObject.dataSize;
|
|
|
+ var to = polygonVertexIndex * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ },
|
|
|
+
|
|
|
+ IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var index = infoObject.indices[polygonVertexIndex];
|
|
|
+ var from = index * infoObject.dataSize;
|
|
|
+ var to = index * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ ByPolygon: {
|
|
|
+
|
|
|
+ Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var from = polygonIndex * infoObject.dataSize;
|
|
|
+ var to = polygonIndex * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ },
|
|
|
+
|
|
|
+ IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var index = infoObject.indices[polygonIndex];
|
|
|
+ var from = index * infoObject.dataSize;
|
|
|
+ var to = index * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ ByVertice: {
|
|
|
+
|
|
|
+ Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var from = vertexIndex * infoObject.dataSize;
|
|
|
+ var to = vertexIndex * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ AllSame: {
|
|
|
+
|
|
|
+ IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ var from = infoObject.indices[0] * infoObject.dataSize;
|
|
|
+ var to = infoObject.indices[0] * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ return slice(dataArray, infoObject.buffer, from, to);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
|
|
|
+
|
|
|
+ return GetData[infoObject.mappingType][infoObject.referenceType](polygonVertexIndex, polygonIndex, vertexIndex, infoObject);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Generate a NurbGeometry from a node in FBXTree.Objects.Geometry
|
|
|
+ function parseNurbsGeometry(geometryNode) {
|
|
|
+
|
|
|
+ if (THREE.NURBSCurve === undefined) {
|
|
|
+
|
|
|
+ console.error('THREE.FBXLoader: The loader relies on THREE.NURBSCurve for any nurbs present in the model. Nurbs will show up as empty geometry.');
|
|
|
+ return new THREE.BufferGeometry();
|
|
|
+ }
|
|
|
+
|
|
|
+ var order = parseInt(geometryNode.Order);
|
|
|
+
|
|
|
+ if (isNaN(order)) {
|
|
|
+
|
|
|
+ console.error('THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geometryNode.Order, geometryNode.id);
|
|
|
+ return new THREE.BufferGeometry();
|
|
|
+ }
|
|
|
+
|
|
|
+ var degree = order - 1;
|
|
|
+
|
|
|
+ var knots = geometryNode.KnotVector.a;
|
|
|
+ var controlPoints = [];
|
|
|
+ var pointsValues = geometryNode.Points.a;
|
|
|
+
|
|
|
+ for (var i = 0, l = pointsValues.length; i < l; i += 4) {
|
|
|
+
|
|
|
+ controlPoints.push(new THREE.Vector4().fromArray(pointsValues, i));
|
|
|
+ }
|
|
|
+
|
|
|
+ var startKnot, endKnot;
|
|
|
+
|
|
|
+ if (geometryNode.Form === 'Closed') {
|
|
|
+
|
|
|
+ controlPoints.push(controlPoints[0]);
|
|
|
+ } else if (geometryNode.Form === 'Periodic') {
|
|
|
+
|
|
|
+ startKnot = degree;
|
|
|
+ endKnot = knots.length - 1 - startKnot;
|
|
|
+
|
|
|
+ for (var i = 0; i < degree; ++i) {
|
|
|
+
|
|
|
+ controlPoints.push(controlPoints[i]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var curve = new THREE.NURBSCurve(degree, knots, controlPoints, startKnot, endKnot);
|
|
|
+ var vertices = curve.getPoints(controlPoints.length * 7);
|
|
|
+
|
|
|
+ var positions = new Float32Array(vertices.length * 3);
|
|
|
+
|
|
|
+ vertices.forEach(function (vertex, i) {
|
|
|
+
|
|
|
+ vertex.toArray(positions, i * 3);
|
|
|
+ });
|
|
|
+
|
|
|
+ var geometry = new THREE.BufferGeometry();
|
|
|
+ geometry.addAttribute('position', new THREE.BufferAttribute(positions, 3));
|
|
|
+
|
|
|
+ return geometry;
|
|
|
+ }
|
|
|
+
|
|
|
+ // create the main THREE.Group() to be returned by the loader
|
|
|
+ function parseScene(FBXTree, connections, skeletons, geometryMap, materialMap) {
|
|
|
+
|
|
|
+ var sceneGraph = new THREE.Group();
|
|
|
+
|
|
|
+ var modelMap = parseModels(FBXTree, skeletons, geometryMap, materialMap, connections);
|
|
|
+
|
|
|
+ var modelNodes = FBXTree.Objects.Model;
|
|
|
+
|
|
|
+ modelMap.forEach(function (model) {
|
|
|
+
|
|
|
+ var modelNode = modelNodes[model.ID];
|
|
|
+ setLookAtProperties(FBXTree, model, modelNode, connections, sceneGraph);
|
|
|
+
|
|
|
+ var parentConnections = connections.get(model.ID).parents;
|
|
|
+
|
|
|
+ parentConnections.forEach(function (connection) {
|
|
|
+
|
|
|
+ var parent = modelMap.get(connection.ID);
|
|
|
+ if (parent !== undefined) parent.add(model);
|
|
|
+ });
|
|
|
+
|
|
|
+ if (model.parent === null) {
|
|
|
+
|
|
|
+ sceneGraph.add(model);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ bindSkeleton(FBXTree, skeletons, geometryMap, modelMap, connections);
|
|
|
+
|
|
|
+ addAnimations(FBXTree, connections, sceneGraph);
|
|
|
+
|
|
|
+ createAmbientLight(FBXTree, sceneGraph);
|
|
|
+
|
|
|
+ return sceneGraph;
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse nodes in FBXTree.Objects.Model
|
|
|
+ function parseModels(FBXTree, skeletons, geometryMap, materialMap, connections) {
|
|
|
+
|
|
|
+ var modelMap = new Map();
|
|
|
+ var modelNodes = FBXTree.Objects.Model;
|
|
|
+
|
|
|
+ for (var nodeID in modelNodes) {
|
|
|
+
|
|
|
+ var id = parseInt(nodeID);
|
|
|
+ var node = modelNodes[nodeID];
|
|
|
+ var relationships = connections.get(id);
|
|
|
+
|
|
|
+ var model = buildSkeleton(relationships, skeletons, id, node.attrName);
|
|
|
+
|
|
|
+ if (!model) {
|
|
|
+
|
|
|
+ switch (node.attrType) {
|
|
|
+
|
|
|
+ case 'Camera':
|
|
|
+ model = createCamera(FBXTree, relationships);
|
|
|
+ break;
|
|
|
+ case 'Light':
|
|
|
+ model = createLight(FBXTree, relationships);
|
|
|
+ break;
|
|
|
+ case 'Mesh':
|
|
|
+ model = createMesh(FBXTree, relationships, geometryMap, materialMap);
|
|
|
+ break;
|
|
|
+ case 'NurbsCurve':
|
|
|
+ model = createCurve(relationships, geometryMap);
|
|
|
+ break;
|
|
|
+ case 'LimbNode': // usually associated with a Bone, however if a Bone was not created we'll make a Group instead
|
|
|
+ case 'Null':
|
|
|
+ default:
|
|
|
+ model = new THREE.Group();
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ model.name = THREE.PropertyBinding.sanitizeNodeName(node.attrName);
|
|
|
+ model.ID = id;
|
|
|
+ }
|
|
|
+
|
|
|
+ setModelTransforms(FBXTree, model, node);
|
|
|
+ modelMap.set(id, model);
|
|
|
+ }
|
|
|
+
|
|
|
+ return modelMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ function buildSkeleton(relationships, skeletons, id, name) {
|
|
|
+
|
|
|
+ var bone = null;
|
|
|
+
|
|
|
+ relationships.parents.forEach(function (parent) {
|
|
|
+
|
|
|
+ for (var ID in skeletons) {
|
|
|
+
|
|
|
+ var skeleton = skeletons[ID];
|
|
|
+
|
|
|
+ skeleton.rawBones.forEach(function (rawBone, i) {
|
|
|
+
|
|
|
+ if (rawBone.ID === parent.ID) {
|
|
|
+
|
|
|
+ var subBone = bone;
|
|
|
+ bone = new THREE.Bone();
|
|
|
+ bone.matrixWorld.copy(rawBone.transformLink);
|
|
|
+
|
|
|
+ // set name and id here - otherwise in cases where "subBone" is created it will not have a name / id
|
|
|
+ bone.name = THREE.PropertyBinding.sanitizeNodeName(name);
|
|
|
+ bone.ID = id;
|
|
|
+
|
|
|
+ skeleton.bones[i] = bone;
|
|
|
+
|
|
|
+ // In cases where a bone is shared between multiple meshes
|
|
|
+ // duplicate the bone here and and it as a child of the first bone
|
|
|
+ if (subBone !== null) {
|
|
|
+
|
|
|
+ bone.add(subBone);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ return bone;
|
|
|
+ }
|
|
|
+
|
|
|
+ // create a THREE.PerspectiveCamera or THREE.OrthographicCamera
|
|
|
+ function createCamera(FBXTree, relationships) {
|
|
|
+
|
|
|
+ var model;
|
|
|
+ var cameraAttribute;
|
|
|
+
|
|
|
+ relationships.children.forEach(function (child) {
|
|
|
+
|
|
|
+ var attr = FBXTree.Objects.NodeAttribute[child.ID];
|
|
|
+
|
|
|
+ if (attr !== undefined) {
|
|
|
+
|
|
|
+ cameraAttribute = attr;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ if (cameraAttribute === undefined) {
|
|
|
+
|
|
|
+ model = new THREE.Object3D();
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var type = 0;
|
|
|
+ if (cameraAttribute.CameraProjectionType !== undefined && cameraAttribute.CameraProjectionType.value === 1) {
|
|
|
+
|
|
|
+ type = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ var nearClippingPlane = 1;
|
|
|
+ if (cameraAttribute.NearPlane !== undefined) {
|
|
|
+
|
|
|
+ nearClippingPlane = cameraAttribute.NearPlane.value / 1000;
|
|
|
+ }
|
|
|
+
|
|
|
+ var farClippingPlane = 1000;
|
|
|
+ if (cameraAttribute.FarPlane !== undefined) {
|
|
|
+
|
|
|
+ farClippingPlane = cameraAttribute.FarPlane.value / 1000;
|
|
|
+ }
|
|
|
+
|
|
|
+ var width = window.innerWidth;
|
|
|
+ var height = window.innerHeight;
|
|
|
+
|
|
|
+ if (cameraAttribute.AspectWidth !== undefined && cameraAttribute.AspectHeight !== undefined) {
|
|
|
+
|
|
|
+ width = cameraAttribute.AspectWidth.value;
|
|
|
+ height = cameraAttribute.AspectHeight.value;
|
|
|
+ }
|
|
|
+
|
|
|
+ var aspect = width / height;
|
|
|
+
|
|
|
+ var fov = 45;
|
|
|
+ if (cameraAttribute.FieldOfView !== undefined) {
|
|
|
+
|
|
|
+ fov = cameraAttribute.FieldOfView.value;
|
|
|
+ }
|
|
|
+
|
|
|
+ var focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 0:
|
|
|
+ // Perspective
|
|
|
+ model = new THREE.PerspectiveCamera(fov, aspect, nearClippingPlane, farClippingPlane);
|
|
|
+ if (focalLength !== null) model.setFocalLength(focalLength);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 1:
|
|
|
+ // Orthographic
|
|
|
+ model = new THREE.OrthographicCamera(-width / 2, width / 2, height / 2, -height / 2, nearClippingPlane, farClippingPlane);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ console.warn('THREE.FBXLoader: Unknown camera type ' + type + '.');
|
|
|
+ model = new THREE.Object3D();
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return model;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Create a THREE.DirectionalLight, THREE.PointLight or THREE.SpotLight
|
|
|
+ function createLight(FBXTree, relationships) {
|
|
|
+
|
|
|
+ var model;
|
|
|
+ var lightAttribute;
|
|
|
+
|
|
|
+ relationships.children.forEach(function (child) {
|
|
|
+
|
|
|
+ var attr = FBXTree.Objects.NodeAttribute[child.ID];
|
|
|
+
|
|
|
+ if (attr !== undefined) {
|
|
|
+
|
|
|
+ lightAttribute = attr;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ if (lightAttribute === undefined) {
|
|
|
+
|
|
|
+ model = new THREE.Object3D();
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var type;
|
|
|
+
|
|
|
+ // LightType can be undefined for Point lights
|
|
|
+ if (lightAttribute.LightType === undefined) {
|
|
|
+
|
|
|
+ type = 0;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ type = lightAttribute.LightType.value;
|
|
|
+ }
|
|
|
+
|
|
|
+ var color = 0xffffff;
|
|
|
+
|
|
|
+ if (lightAttribute.Color !== undefined) {
|
|
|
+
|
|
|
+ color = new THREE.Color().fromArray(lightAttribute.Color.value);
|
|
|
+ }
|
|
|
+
|
|
|
+ var intensity = lightAttribute.Intensity === undefined ? 1 : lightAttribute.Intensity.value / 100;
|
|
|
+
|
|
|
+ // light disabled
|
|
|
+ if (lightAttribute.CastLightOnObject !== undefined && lightAttribute.CastLightOnObject.value === 0) {
|
|
|
+
|
|
|
+ intensity = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ var distance = 0;
|
|
|
+ if (lightAttribute.FarAttenuationEnd !== undefined) {
|
|
|
+
|
|
|
+ if (lightAttribute.EnableFarAttenuation !== undefined && lightAttribute.EnableFarAttenuation.value === 0) {
|
|
|
+
|
|
|
+ distance = 0;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ distance = lightAttribute.FarAttenuationEnd.value / 1000;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO: could this be calculated linearly from FarAttenuationStart to FarAttenuationEnd?
|
|
|
+ var decay = 1;
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 0:
|
|
|
+ // Point
|
|
|
+ model = new THREE.PointLight(color, intensity, distance, decay);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 1:
|
|
|
+ // Directional
|
|
|
+ model = new THREE.DirectionalLight(color, intensity);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 2:
|
|
|
+ // Spot
|
|
|
+ var angle = Math.PI / 3;
|
|
|
+
|
|
|
+ if (lightAttribute.InnerAngle !== undefined) {
|
|
|
+
|
|
|
+ angle = THREE.Math.degToRad(lightAttribute.InnerAngle.value);
|
|
|
+ }
|
|
|
+
|
|
|
+ var penumbra = 0;
|
|
|
+ if (lightAttribute.OuterAngle !== undefined) {
|
|
|
+
|
|
|
+ // TODO: this is not correct - FBX calculates outer and inner angle in degrees
|
|
|
+ // with OuterAngle > InnerAngle && OuterAngle <= Math.PI
|
|
|
+ // while three.js uses a penumbra between (0, 1) to attenuate the inner angle
|
|
|
+ penumbra = THREE.Math.degToRad(lightAttribute.OuterAngle.value);
|
|
|
+ penumbra = Math.max(penumbra, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ model = new THREE.SpotLight(color, intensity, distance, angle, penumbra, decay);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ console.warn('THREE.FBXLoader: Unknown light type ' + lightAttribute.LightType.value + ', defaulting to a THREE.PointLight.');
|
|
|
+ model = new THREE.PointLight(color, intensity);
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if (lightAttribute.CastShadows !== undefined && lightAttribute.CastShadows.value === 1) {
|
|
|
+
|
|
|
+ model.castShadow = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return model;
|
|
|
+ }
|
|
|
+
|
|
|
+ function createMesh(FBXTree, relationships, geometryMap, materialMap) {
|
|
|
+
|
|
|
+ var model;
|
|
|
+ var geometry = null;
|
|
|
+ var material = null;
|
|
|
+ var materials = [];
|
|
|
+
|
|
|
+ // get geometry and materials(s) from connections
|
|
|
+ relationships.children.forEach(function (child) {
|
|
|
+
|
|
|
+ if (geometryMap.has(child.ID)) {
|
|
|
+
|
|
|
+ geometry = geometryMap.get(child.ID);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (materialMap.has(child.ID)) {
|
|
|
+
|
|
|
+ materials.push(materialMap.get(child.ID));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ if (materials.length > 1) {
|
|
|
+
|
|
|
+ material = materials;
|
|
|
+ } else if (materials.length > 0) {
|
|
|
+
|
|
|
+ material = materials[0];
|
|
|
+ } else {
|
|
|
+
|
|
|
+ material = new THREE.MeshPhongMaterial({ color: 0xcccccc });
|
|
|
+ materials.push(material);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('color' in geometry.attributes) {
|
|
|
+
|
|
|
+ materials.forEach(function (material) {
|
|
|
+
|
|
|
+ material.vertexColors = THREE.VertexColors;
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (geometry.FBX_Deformer) {
|
|
|
+
|
|
|
+ materials.forEach(function (material) {
|
|
|
+
|
|
|
+ material.skinning = true;
|
|
|
+ });
|
|
|
+
|
|
|
+ model = new THREE.SkinnedMesh(geometry, material);
|
|
|
+ } else {
|
|
|
+
|
|
|
+ model = new THREE.Mesh(geometry, material);
|
|
|
+ }
|
|
|
+
|
|
|
+ return model;
|
|
|
+ }
|
|
|
+
|
|
|
+ function createCurve(relationships, geometryMap) {
|
|
|
+
|
|
|
+ var geometry = relationships.children.reduce(function (geo, child) {
|
|
|
+
|
|
|
+ if (geometryMap.has(child.ID)) geo = geometryMap.get(child.ID);
|
|
|
+
|
|
|
+ return geo;
|
|
|
+ }, null);
|
|
|
+
|
|
|
+ // FBX does not list materials for Nurbs lines, so we'll just put our own in here.
|
|
|
+ var material = new THREE.LineBasicMaterial({ color: 0x3300ff, linewidth: 1 });
|
|
|
+ return new THREE.Line(geometry, material);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse ambient color in FBXTree.GlobalSettings - if it's not set to black (default), create an ambient light
|
|
|
+ function createAmbientLight(FBXTree, sceneGraph) {
|
|
|
+
|
|
|
+ if ('GlobalSettings' in FBXTree && 'AmbientColor' in FBXTree.GlobalSettings) {
|
|
|
+
|
|
|
+ var ambientColor = FBXTree.GlobalSettings.AmbientColor.value;
|
|
|
+ var r = ambientColor[0];
|
|
|
+ var g = ambientColor[1];
|
|
|
+ var b = ambientColor[2];
|
|
|
+
|
|
|
+ if (r !== 0 || g !== 0 || b !== 0) {
|
|
|
+
|
|
|
+ var color = new THREE.Color(r, g, b);
|
|
|
+ sceneGraph.add(new THREE.AmbientLight(color, 1));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function setLookAtProperties(FBXTree, model, modelNode, connections, sceneGraph) {
|
|
|
+
|
|
|
+ if ('LookAtProperty' in modelNode) {
|
|
|
+
|
|
|
+ var children = connections.get(model.ID).children;
|
|
|
+
|
|
|
+ children.forEach(function (child) {
|
|
|
+
|
|
|
+ if (child.relationship === 'LookAtProperty') {
|
|
|
+
|
|
|
+ var lookAtTarget = FBXTree.Objects.Model[child.ID];
|
|
|
+
|
|
|
+ if ('Lcl_Translation' in lookAtTarget) {
|
|
|
+
|
|
|
+ var pos = lookAtTarget.Lcl_Translation.value;
|
|
|
+
|
|
|
+ // DirectionalLight, SpotLight
|
|
|
+ if (model.target !== undefined) {
|
|
|
+
|
|
|
+ model.target.position.fromArray(pos);
|
|
|
+ sceneGraph.add(model.target);
|
|
|
+ } else {
|
|
|
+ // Cameras and other Object3Ds
|
|
|
+
|
|
|
+ model.lookAt(new THREE.Vector3().fromArray(pos));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse the model node for transform details and apply them to the model
|
|
|
+ function setModelTransforms(FBXTree, model, modelNode) {
|
|
|
+
|
|
|
+ // http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_class_fbx_euler_html
|
|
|
+ if ('RotationOrder' in modelNode) {
|
|
|
+
|
|
|
+ var enums = ['XYZ', // default
|
|
|
+ 'XZY', 'YZX', 'ZXY', 'YXZ', 'ZYX', 'SphericXYZ'];
|
|
|
+
|
|
|
+ var value = parseInt(modelNode.RotationOrder.value, 10);
|
|
|
+
|
|
|
+ if (value > 0 && value < 6) {
|
|
|
+
|
|
|
+ // model.rotation.order = enums[ value ];
|
|
|
+
|
|
|
+ // Note: Euler order other than XYZ is currently not supported, so just display a warning for now
|
|
|
+ console.warn('THREE.FBXLoader: unsupported Euler Order: %s. Currently only XYZ order is supported. Animations and rotations may be incorrect.', enums[value]);
|
|
|
+ } else if (value === 6) {
|
|
|
+
|
|
|
+ console.warn('THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect.');
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('Lcl_Translation' in modelNode) {
|
|
|
+
|
|
|
+ model.position.fromArray(modelNode.Lcl_Translation.value);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('Lcl_Rotation' in modelNode) {
|
|
|
+
|
|
|
+ var rotation = modelNode.Lcl_Rotation.value.map(THREE.Math.degToRad);
|
|
|
+ rotation.push('ZYX');
|
|
|
+ model.rotation.fromArray(rotation);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('Lcl_Scaling' in modelNode) {
|
|
|
+
|
|
|
+ model.scale.fromArray(modelNode.Lcl_Scaling.value);
|
|
|
+ }
|
|
|
+
|
|
|
+ if ('PreRotation' in modelNode) {
|
|
|
+
|
|
|
+ var array = modelNode.PreRotation.value.map(THREE.Math.degToRad);
|
|
|
+ array[3] = 'ZYX';
|
|
|
+
|
|
|
+ var preRotations = new THREE.Euler().fromArray(array);
|
|
|
+
|
|
|
+ preRotations = new THREE.Quaternion().setFromEuler(preRotations);
|
|
|
+ var currentRotation = new THREE.Quaternion().setFromEuler(model.rotation);
|
|
|
+ preRotations.multiply(currentRotation);
|
|
|
+ model.rotation.setFromQuaternion(preRotations, 'ZYX');
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function bindSkeleton(FBXTree, skeletons, geometryMap, modelMap, connections) {
|
|
|
+
|
|
|
+ var bindMatrices = parsePoseNodes(FBXTree);
|
|
|
+
|
|
|
+ for (var ID in skeletons) {
|
|
|
+
|
|
|
+ var skeleton = skeletons[ID];
|
|
|
+
|
|
|
+ var parents = connections.get(parseInt(skeleton.ID)).parents;
|
|
|
+
|
|
|
+ parents.forEach(function (parent) {
|
|
|
+
|
|
|
+ if (geometryMap.has(parent.ID)) {
|
|
|
+
|
|
|
+ var geoID = parent.ID;
|
|
|
+ var geoRelationships = connections.get(geoID);
|
|
|
+
|
|
|
+ geoRelationships.parents.forEach(function (geoConnParent) {
|
|
|
+
|
|
|
+ if (modelMap.has(geoConnParent.ID)) {
|
|
|
+
|
|
|
+ var model = modelMap.get(geoConnParent.ID);
|
|
|
+
|
|
|
+ model.bind(new THREE.Skeleton(skeleton.bones), bindMatrices[geoConnParent.ID]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function parsePoseNodes(FBXTree) {
|
|
|
+
|
|
|
+ var bindMatrices = {};
|
|
|
+
|
|
|
+ if ('Pose' in FBXTree.Objects) {
|
|
|
+
|
|
|
+ var BindPoseNode = FBXTree.Objects.Pose;
|
|
|
+
|
|
|
+ for (var nodeID in BindPoseNode) {
|
|
|
+
|
|
|
+ if (BindPoseNode[nodeID].attrType === 'BindPose') {
|
|
|
+
|
|
|
+ var poseNodes = BindPoseNode[nodeID].PoseNode;
|
|
|
+
|
|
|
+ if (Array.isArray(poseNodes)) {
|
|
|
+
|
|
|
+ poseNodes.forEach(function (poseNode) {
|
|
|
+
|
|
|
+ bindMatrices[poseNode.Node] = new THREE.Matrix4().fromArray(poseNode.Matrix.a);
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+
|
|
|
+ bindMatrices[poseNodes.Node] = new THREE.Matrix4().fromArray(poseNodes.Matrix.a);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return bindMatrices;
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseAnimations(FBXTree, connections) {
|
|
|
+
|
|
|
+ // since the actual transformation data is stored in FBXTree.Objects.AnimationCurve,
|
|
|
+ // if this is undefined we can safely assume there are no animations
|
|
|
+ if (FBXTree.Objects.AnimationCurve === undefined) return undefined;
|
|
|
+
|
|
|
+ var curveNodesMap = parseAnimationCurveNodes(FBXTree);
|
|
|
+
|
|
|
+ parseAnimationCurves(FBXTree, connections, curveNodesMap);
|
|
|
+
|
|
|
+ var layersMap = parseAnimationLayers(FBXTree, connections, curveNodesMap);
|
|
|
+ var rawClips = parseAnimStacks(FBXTree, connections, layersMap);
|
|
|
+
|
|
|
+ return rawClips;
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse nodes in FBXTree.Objects.AnimationCurveNode
|
|
|
+ // each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation )
|
|
|
+ // and is referenced by an AnimationLayer
|
|
|
+ function parseAnimationCurveNodes(FBXTree) {
|
|
|
+
|
|
|
+ var rawCurveNodes = FBXTree.Objects.AnimationCurveNode;
|
|
|
+
|
|
|
+ var curveNodesMap = new Map();
|
|
|
+
|
|
|
+ for (var nodeID in rawCurveNodes) {
|
|
|
+
|
|
|
+ var rawCurveNode = rawCurveNodes[nodeID];
|
|
|
+
|
|
|
+ if (rawCurveNode.attrName.match(/S|R|T/) !== null) {
|
|
|
+
|
|
|
+ var curveNode = {
|
|
|
+
|
|
|
+ id: rawCurveNode.id,
|
|
|
+ attr: rawCurveNode.attrName,
|
|
|
+ curves: {}
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ curveNodesMap.set(curveNode.id, curveNode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return curveNodesMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse nodes in FBXTree.Objects.AnimationCurve and connect them up to
|
|
|
+ // previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated
|
|
|
+ // axis ( e.g. times and values of x rotation)
|
|
|
+ function parseAnimationCurves(FBXTree, connections, curveNodesMap) {
|
|
|
+
|
|
|
+ var rawCurves = FBXTree.Objects.AnimationCurve;
|
|
|
+
|
|
|
+ for (var nodeID in rawCurves) {
|
|
|
+
|
|
|
+ var animationCurve = {
|
|
|
+
|
|
|
+ id: rawCurves[nodeID].id,
|
|
|
+ times: rawCurves[nodeID].KeyTime.a.map(convertFBXTimeToSeconds),
|
|
|
+ values: rawCurves[nodeID].KeyValueFloat.a
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ var relationships = connections.get(animationCurve.id);
|
|
|
+
|
|
|
+ if (relationships !== undefined) {
|
|
|
+
|
|
|
+ var animationCurveID = relationships.parents[0].ID;
|
|
|
+ var animationCurveRelationship = relationships.parents[0].relationship;
|
|
|
+ var axis = '';
|
|
|
+
|
|
|
+ if (animationCurveRelationship.match(/X/)) {
|
|
|
+
|
|
|
+ axis = 'x';
|
|
|
+ } else if (animationCurveRelationship.match(/Y/)) {
|
|
|
+
|
|
|
+ axis = 'y';
|
|
|
+ } else if (animationCurveRelationship.match(/Z/)) {
|
|
|
+
|
|
|
+ axis = 'z';
|
|
|
+ } else {
|
|
|
+
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ curveNodesMap.get(animationCurveID).curves[axis] = animationCurve;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references
|
|
|
+ // to various AnimationCurveNodes and is referenced by an AnimationStack node
|
|
|
+ // note: theoretically a stack can multiple layers, however in practice there always seems to be one per stack
|
|
|
+ function parseAnimationLayers(FBXTree, connections, curveNodesMap) {
|
|
|
+
|
|
|
+ var rawLayers = FBXTree.Objects.AnimationLayer;
|
|
|
+
|
|
|
+ var layersMap = new Map();
|
|
|
+
|
|
|
+ for (var nodeID in rawLayers) {
|
|
|
+
|
|
|
+ var layerCurveNodes = [];
|
|
|
+
|
|
|
+ var connection = connections.get(parseInt(nodeID));
|
|
|
+
|
|
|
+ if (connection !== undefined) {
|
|
|
+
|
|
|
+ // all the animationCurveNodes used in the layer
|
|
|
+ var children = connection.children;
|
|
|
+
|
|
|
+ children.forEach(function (child, i) {
|
|
|
+
|
|
|
+ if (curveNodesMap.has(child.ID)) {
|
|
|
+
|
|
|
+ var curveNode = curveNodesMap.get(child.ID);
|
|
|
+
|
|
|
+ // check that the curves are defined for at least one axis, otherwise ignore the curveNode
|
|
|
+ if (curveNode.curves.x !== undefined || curveNode.curves.y !== undefined || curveNode.curves.z !== undefined) {
|
|
|
+
|
|
|
+ if (layerCurveNodes[i] === undefined) {
|
|
|
+
|
|
|
+ var modelID;
|
|
|
+
|
|
|
+ connections.get(child.ID).parents.forEach(function (parent) {
|
|
|
+
|
|
|
+ if (parent.relationship !== undefined) modelID = parent.ID;
|
|
|
+ });
|
|
|
+
|
|
|
+ var rawModel = FBXTree.Objects.Model[modelID.toString()];
|
|
|
+
|
|
|
+ var node = {
|
|
|
+
|
|
|
+ modelName: THREE.PropertyBinding.sanitizeNodeName(rawModel.attrName),
|
|
|
+ initialPosition: [0, 0, 0],
|
|
|
+ initialRotation: [0, 0, 0],
|
|
|
+ initialScale: [1, 1, 1]
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ if ('Lcl_Translation' in rawModel) node.initialPosition = rawModel.Lcl_Translation.value;
|
|
|
+
|
|
|
+ if ('Lcl_Rotation' in rawModel) node.initialRotation = rawModel.Lcl_Rotation.value;
|
|
|
+
|
|
|
+ if ('Lcl_Scaling' in rawModel) node.initialScale = rawModel.Lcl_Scaling.value;
|
|
|
+
|
|
|
+ // if the animated model is pre rotated, we'll have to apply the pre rotations to every
|
|
|
+ // animation value as well
|
|
|
+ if ('PreRotation' in rawModel) node.preRotations = rawModel.PreRotation.value;
|
|
|
+
|
|
|
+ layerCurveNodes[i] = node;
|
|
|
+ }
|
|
|
+
|
|
|
+ layerCurveNodes[i][curveNode.attr] = curveNode;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ layersMap.set(parseInt(nodeID), layerCurveNodes);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return layersMap;
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation
|
|
|
+ // hierarchy. Each Stack node will be used to create a THREE.AnimationClip
|
|
|
+ function parseAnimStacks(FBXTree, connections, layersMap) {
|
|
|
+
|
|
|
+ var rawStacks = FBXTree.Objects.AnimationStack;
|
|
|
+
|
|
|
+ // connect the stacks (clips) up to the layers
|
|
|
+ var rawClips = {};
|
|
|
+
|
|
|
+ for (var nodeID in rawStacks) {
|
|
|
+
|
|
|
+ var children = connections.get(parseInt(nodeID)).children;
|
|
|
+
|
|
|
+ if (children.length > 1) {
|
|
|
+
|
|
|
+ // it seems like stacks will always be associated with a single layer. But just in case there are files
|
|
|
+ // where there are multiple layers per stack, we'll display a warning
|
|
|
+ console.warn('THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers.');
|
|
|
+ }
|
|
|
+
|
|
|
+ var layer = layersMap.get(children[0].ID);
|
|
|
+
|
|
|
+ rawClips[nodeID] = {
|
|
|
+
|
|
|
+ name: rawStacks[nodeID].attrName,
|
|
|
+ layer: layer
|
|
|
+
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ return rawClips;
|
|
|
+ }
|
|
|
+
|
|
|
+ // take raw animation data from parseAnimations and connect it up to the loaded models
|
|
|
+ function addAnimations(FBXTree, connections, sceneGraph) {
|
|
|
+
|
|
|
+ sceneGraph.animations = [];
|
|
|
+
|
|
|
+ var rawClips = parseAnimations(FBXTree, connections);
|
|
|
+
|
|
|
+ if (rawClips === undefined) return;
|
|
|
+
|
|
|
+ for (var key in rawClips) {
|
|
|
+
|
|
|
+ var rawClip = rawClips[key];
|
|
|
+
|
|
|
+ var clip = addClip(rawClip);
|
|
|
+
|
|
|
+ sceneGraph.animations.push(clip);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function addClip(rawClip) {
|
|
|
+
|
|
|
+ var tracks = [];
|
|
|
+
|
|
|
+ rawClip.layer.forEach(function (rawTracks) {
|
|
|
+
|
|
|
+ tracks = tracks.concat(generateTracks(rawTracks));
|
|
|
+ });
|
|
|
+
|
|
|
+ return new THREE.AnimationClip(rawClip.name, -1, tracks);
|
|
|
+ }
|
|
|
+
|
|
|
+ function generateTracks(rawTracks) {
|
|
|
+
|
|
|
+ var tracks = [];
|
|
|
+
|
|
|
+ if (rawTracks.T !== undefined && Object.keys(rawTracks.T.curves).length > 0) {
|
|
|
+
|
|
|
+ var positionTrack = generateVectorTrack(rawTracks.modelName, rawTracks.T.curves, rawTracks.initialPosition, 'position');
|
|
|
+ if (positionTrack !== undefined) tracks.push(positionTrack);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (rawTracks.R !== undefined && Object.keys(rawTracks.R.curves).length > 0) {
|
|
|
+
|
|
|
+ var rotationTrack = generateRotationTrack(rawTracks.modelName, rawTracks.R.curves, rawTracks.initialRotation, rawTracks.preRotations);
|
|
|
+ if (rotationTrack !== undefined) tracks.push(rotationTrack);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (rawTracks.S !== undefined && Object.keys(rawTracks.S.curves).length > 0) {
|
|
|
+
|
|
|
+ var scaleTrack = generateVectorTrack(rawTracks.modelName, rawTracks.S.curves, rawTracks.initialScale, 'scale');
|
|
|
+ if (scaleTrack !== undefined) tracks.push(scaleTrack);
|
|
|
+ }
|
|
|
+
|
|
|
+ return tracks;
|
|
|
+ }
|
|
|
+
|
|
|
+ function generateVectorTrack(modelName, curves, initialValue, type) {
|
|
|
+
|
|
|
+ var times = getTimesForAllAxes(curves);
|
|
|
+ var values = getKeyframeTrackValues(times, curves, initialValue);
|
|
|
+
|
|
|
+ return new THREE.VectorKeyframeTrack(modelName + '.' + type, times, values);
|
|
|
+ }
|
|
|
+
|
|
|
+ function generateRotationTrack(modelName, curves, initialValue, preRotations) {
|
|
|
+
|
|
|
+ if (curves.x !== undefined) curves.x.values = curves.x.values.map(THREE.Math.degToRad);
|
|
|
+ if (curves.y !== undefined) curves.y.values = curves.y.values.map(THREE.Math.degToRad);
|
|
|
+ if (curves.z !== undefined) curves.z.values = curves.z.values.map(THREE.Math.degToRad);
|
|
|
+
|
|
|
+ var times = getTimesForAllAxes(curves);
|
|
|
+ var values = getKeyframeTrackValues(times, curves, initialValue);
|
|
|
+
|
|
|
+ if (preRotations !== undefined) {
|
|
|
+
|
|
|
+ preRotations = preRotations.map(THREE.Math.degToRad);
|
|
|
+ preRotations.push('ZYX');
|
|
|
+
|
|
|
+ preRotations = new THREE.Euler().fromArray(preRotations);
|
|
|
+ preRotations = new THREE.Quaternion().setFromEuler(preRotations);
|
|
|
+ }
|
|
|
+
|
|
|
+ var quaternion = new THREE.Quaternion();
|
|
|
+ var euler = new THREE.Euler();
|
|
|
+
|
|
|
+ var quaternionValues = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < values.length; i += 3) {
|
|
|
+
|
|
|
+ euler.set(values[i], values[i + 1], values[i + 2], 'ZYX');
|
|
|
+
|
|
|
+ quaternion.setFromEuler(euler);
|
|
|
+
|
|
|
+ if (preRotations !== undefined) quaternion.premultiply(preRotations);
|
|
|
+
|
|
|
+ quaternion.toArray(quaternionValues, i / 3 * 4);
|
|
|
+ }
|
|
|
+
|
|
|
+ return new THREE.QuaternionKeyframeTrack(modelName + '.quaternion', times, quaternionValues);
|
|
|
+ }
|
|
|
+
|
|
|
+ function getKeyframeTrackValues(times, curves, initialValue) {
|
|
|
+
|
|
|
+ var prevValue = initialValue;
|
|
|
+
|
|
|
+ var values = [];
|
|
|
+
|
|
|
+ var xIndex = -1;
|
|
|
+ var yIndex = -1;
|
|
|
+ var zIndex = -1;
|
|
|
+
|
|
|
+ times.forEach(function (time) {
|
|
|
+
|
|
|
+ if (curves.x) xIndex = curves.x.times.indexOf(time);
|
|
|
+ if (curves.y) yIndex = curves.y.times.indexOf(time);
|
|
|
+ if (curves.z) zIndex = curves.z.times.indexOf(time);
|
|
|
+
|
|
|
+ // if there is an x value defined for this frame, use that
|
|
|
+ if (xIndex !== -1) {
|
|
|
+
|
|
|
+ var xValue = curves.x.values[xIndex];
|
|
|
+ values.push(xValue);
|
|
|
+ prevValue[0] = xValue;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // otherwise use the x value from the previous frame
|
|
|
+ values.push(prevValue[0]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (yIndex !== -1) {
|
|
|
+
|
|
|
+ var yValue = curves.y.values[yIndex];
|
|
|
+ values.push(yValue);
|
|
|
+ prevValue[1] = yValue;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ values.push(prevValue[1]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (zIndex !== -1) {
|
|
|
+
|
|
|
+ var zValue = curves.z.values[zIndex];
|
|
|
+ values.push(zValue);
|
|
|
+ prevValue[2] = zValue;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ values.push(prevValue[2]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ return values;
|
|
|
+ }
|
|
|
+
|
|
|
+ // For all animated objects, times are defined separately for each axis
|
|
|
+ // Here we'll combine the times into one sorted array without duplicates
|
|
|
+ function getTimesForAllAxes(curves) {
|
|
|
+
|
|
|
+ var times = [];
|
|
|
+
|
|
|
+ // first join together the times for each axis, if defined
|
|
|
+ if (curves.x !== undefined) times = times.concat(curves.x.times);
|
|
|
+ if (curves.y !== undefined) times = times.concat(curves.y.times);
|
|
|
+ if (curves.z !== undefined) times = times.concat(curves.z.times);
|
|
|
+
|
|
|
+ // then sort them and remove duplicates
|
|
|
+ times = times.sort(function (a, b) {
|
|
|
+
|
|
|
+ return a - b;
|
|
|
+ }).filter(function (elem, index, array) {
|
|
|
+
|
|
|
+ return array.indexOf(elem) == index;
|
|
|
+ });
|
|
|
+
|
|
|
+ return times;
|
|
|
+ }
|
|
|
+
|
|
|
+ // parse an FBX file in ASCII format
|
|
|
+ function TextParser() {}
|
|
|
+
|
|
|
+ Object.assign(TextParser.prototype, {
|
|
|
+
|
|
|
+ getPrevNode: function getPrevNode() {
|
|
|
+
|
|
|
+ return this.nodeStack[this.currentIndent - 2];
|
|
|
+ },
|
|
|
+
|
|
|
+ getCurrentNode: function getCurrentNode() {
|
|
|
+
|
|
|
+ return this.nodeStack[this.currentIndent - 1];
|
|
|
+ },
|
|
|
+
|
|
|
+ getCurrentProp: function getCurrentProp() {
|
|
|
+
|
|
|
+ return this.currentProp;
|
|
|
+ },
|
|
|
+
|
|
|
+ pushStack: function pushStack(node) {
|
|
|
+
|
|
|
+ this.nodeStack.push(node);
|
|
|
+ this.currentIndent += 1;
|
|
|
+ },
|
|
|
+
|
|
|
+ popStack: function popStack() {
|
|
|
+
|
|
|
+ this.nodeStack.pop();
|
|
|
+ this.currentIndent -= 1;
|
|
|
+ },
|
|
|
+
|
|
|
+ setCurrentProp: function setCurrentProp(val, name) {
|
|
|
+
|
|
|
+ this.currentProp = val;
|
|
|
+ this.currentPropName = name;
|
|
|
+ },
|
|
|
+
|
|
|
+ parse: function parse(text) {
|
|
|
+
|
|
|
+ this.currentIndent = 0;
|
|
|
+ this.allNodes = new FBXTree();
|
|
|
+ this.nodeStack = [];
|
|
|
+ this.currentProp = [];
|
|
|
+ this.currentPropName = '';
|
|
|
+
|
|
|
+ var self = this;
|
|
|
+
|
|
|
+ var split = text.split('\n');
|
|
|
+
|
|
|
+ split.forEach(function (line, i) {
|
|
|
+
|
|
|
+ var matchComment = line.match(/^[\s\t]*;/);
|
|
|
+ var matchEmpty = line.match(/^[\s\t]*$/);
|
|
|
+
|
|
|
+ if (matchComment || matchEmpty) return;
|
|
|
+
|
|
|
+ var matchBeginning = line.match('^\\t{' + self.currentIndent + '}(\\w+):(.*){', '');
|
|
|
+ var matchProperty = line.match('^\\t{' + self.currentIndent + '}(\\w+):[\\s\\t\\r\\n](.*)');
|
|
|
+ var matchEnd = line.match('^\\t{' + (self.currentIndent - 1) + '}}');
|
|
|
+
|
|
|
+ if (matchBeginning) {
|
|
|
+
|
|
|
+ self.parseNodeBegin(line, matchBeginning);
|
|
|
+ } else if (matchProperty) {
|
|
|
+
|
|
|
+ self.parseNodeProperty(line, matchProperty, split[++i]);
|
|
|
+ } else if (matchEnd) {
|
|
|
+
|
|
|
+ self.popStack();
|
|
|
+ } else if (line.match(/^[^\s\t}]/)) {
|
|
|
+
|
|
|
+ // large arrays are split over multiple lines terminated with a ',' character
|
|
|
+ // if this is encountered the line needs to be joined to the previous line
|
|
|
+ self.parseNodePropertyContinued(line);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ return this.allNodes;
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeBegin: function parseNodeBegin(line, property) {
|
|
|
+
|
|
|
+ var nodeName = property[1].trim().replace(/^"/, '').replace(/"$/, '');
|
|
|
+
|
|
|
+ var nodeAttrs = property[2].split(',').map(function (attr) {
|
|
|
+
|
|
|
+ return attr.trim().replace(/^"/, '').replace(/"$/, '');
|
|
|
+ });
|
|
|
+
|
|
|
+ var node = { name: nodeName };
|
|
|
+ var attrs = this.parseNodeAttr(nodeAttrs);
|
|
|
+
|
|
|
+ var currentNode = this.getCurrentNode();
|
|
|
+
|
|
|
+ // a top node
|
|
|
+ if (this.currentIndent === 0) {
|
|
|
+
|
|
|
+ this.allNodes.add(nodeName, node);
|
|
|
+ } else {
|
|
|
+ // a subnode
|
|
|
+
|
|
|
+ // if the subnode already exists, append it
|
|
|
+ if (nodeName in currentNode) {
|
|
|
+
|
|
|
+ // special case Pose needs PoseNodes as an array
|
|
|
+ if (nodeName === 'PoseNode') {
|
|
|
+
|
|
|
+ currentNode.PoseNode.push(node);
|
|
|
+ } else if (currentNode[nodeName].id !== undefined) {
|
|
|
+
|
|
|
+ currentNode[nodeName] = {};
|
|
|
+ currentNode[nodeName][currentNode[nodeName].id] = currentNode[nodeName];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (attrs.id !== '') currentNode[nodeName][attrs.id] = node;
|
|
|
+ } else if (typeof attrs.id === 'number') {
|
|
|
+
|
|
|
+ currentNode[nodeName] = {};
|
|
|
+ currentNode[nodeName][attrs.id] = node;
|
|
|
+ } else if (nodeName !== 'Properties70') {
|
|
|
+
|
|
|
+ if (nodeName === 'PoseNode') currentNode[nodeName] = [node];else currentNode[nodeName] = node;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof attrs.id === 'number') node.id = attrs.id;
|
|
|
+ if (attrs.name !== '') node.attrName = attrs.name;
|
|
|
+ if (attrs.type !== '') node.attrType = attrs.type;
|
|
|
+
|
|
|
+ this.pushStack(node);
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeAttr: function parseNodeAttr(attrs) {
|
|
|
+
|
|
|
+ var id = attrs[0];
|
|
|
+
|
|
|
+ if (attrs[0] !== '') {
|
|
|
+
|
|
|
+ id = parseInt(attrs[0]);
|
|
|
+
|
|
|
+ if (isNaN(id)) {
|
|
|
+
|
|
|
+ id = attrs[0];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var name = '',
|
|
|
+ type = '';
|
|
|
+
|
|
|
+ if (attrs.length > 1) {
|
|
|
+
|
|
|
+ name = attrs[1].replace(/^(\w+)::/, '');
|
|
|
+ type = attrs[2];
|
|
|
+ }
|
|
|
+
|
|
|
+ return { id: id, name: name, type: type };
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeProperty: function parseNodeProperty(line, property, contentLine) {
|
|
|
+
|
|
|
+ var propName = property[1].replace(/^"/, '').replace(/"$/, '').trim();
|
|
|
+ var propValue = property[2].replace(/^"/, '').replace(/"$/, '').trim();
|
|
|
+
|
|
|
+ // for special case: base64 image data follows "Content: ," line
|
|
|
+ // Content: ,
|
|
|
+ // "/9j/4RDaRXhpZgAATU0A..."
|
|
|
+ if (propName === 'Content' && propValue === ',') {
|
|
|
+
|
|
|
+ propValue = contentLine.replace(/"/g, '').replace(/,$/, '').trim();
|
|
|
+ }
|
|
|
+
|
|
|
+ var currentNode = this.getCurrentNode();
|
|
|
+ var parentName = currentNode.name;
|
|
|
+
|
|
|
+ if (parentName === 'Properties70') {
|
|
|
+
|
|
|
+ this.parseNodeSpecialProperty(line, propName, propValue);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Connections
|
|
|
+ if (propName === 'C') {
|
|
|
+
|
|
|
+ var connProps = propValue.split(',').slice(1);
|
|
|
+ var from = parseInt(connProps[0]);
|
|
|
+ var to = parseInt(connProps[1]);
|
|
|
+
|
|
|
+ var rest = propValue.split(',').slice(3);
|
|
|
+
|
|
|
+ rest = rest.map(function (elem) {
|
|
|
+
|
|
|
+ return elem.trim().replace(/^"/, '');
|
|
|
+ });
|
|
|
+
|
|
|
+ propName = 'connections';
|
|
|
+ propValue = [from, to];
|
|
|
+ append(propValue, rest);
|
|
|
+
|
|
|
+ if (currentNode[propName] === undefined) {
|
|
|
+
|
|
|
+ currentNode[propName] = [];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Node
|
|
|
+ if (propName === 'Node') currentNode.id = propValue;
|
|
|
+
|
|
|
+ // connections
|
|
|
+ if (propName in currentNode && Array.isArray(currentNode[propName])) {
|
|
|
+
|
|
|
+ currentNode[propName].push(propValue);
|
|
|
+ } else {
|
|
|
+
|
|
|
+ if (propName !== 'a') currentNode[propName] = propValue;else currentNode.a = propValue;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.setCurrentProp(currentNode, propName);
|
|
|
+
|
|
|
+ // convert string to array, unless it ends in ',' in which case more will be added to it
|
|
|
+ if (propName === 'a' && propValue.slice(-1) !== ',') {
|
|
|
+
|
|
|
+ currentNode.a = parseNumberArray(propValue);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodePropertyContinued: function parseNodePropertyContinued(line) {
|
|
|
+
|
|
|
+ var currentNode = this.getCurrentNode();
|
|
|
+
|
|
|
+ currentNode.a += line;
|
|
|
+
|
|
|
+ // if the line doesn't end in ',' we have reached the end of the property value
|
|
|
+ // so convert the string to an array
|
|
|
+ if (line.slice(-1) !== ',') {
|
|
|
+
|
|
|
+ currentNode.a = parseNumberArray(currentNode.a);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ // parse "Property70"
|
|
|
+ parseNodeSpecialProperty: function parseNodeSpecialProperty(line, propName, propValue) {
|
|
|
+
|
|
|
+ // split this
|
|
|
+ // P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1
|
|
|
+ // into array like below
|
|
|
+ // ["Lcl Scaling", "Lcl Scaling", "", "A", "1,1,1" ]
|
|
|
+ var props = propValue.split('",').map(function (prop) {
|
|
|
+
|
|
|
+ return prop.trim().replace(/^\"/, '').replace(/\s/, '_');
|
|
|
+ });
|
|
|
+
|
|
|
+ var innerPropName = props[0];
|
|
|
+ var innerPropType1 = props[1];
|
|
|
+ var innerPropType2 = props[2];
|
|
|
+ var innerPropFlag = props[3];
|
|
|
+ var innerPropValue = props[4];
|
|
|
+
|
|
|
+ // cast values where needed, otherwise leave as strings
|
|
|
+ switch (innerPropType1) {
|
|
|
+
|
|
|
+ case 'int':
|
|
|
+ case 'enum':
|
|
|
+ case 'bool':
|
|
|
+ case 'ULongLong':
|
|
|
+ case 'double':
|
|
|
+ case 'Number':
|
|
|
+ case 'FieldOfView':
|
|
|
+ innerPropValue = parseFloat(innerPropValue);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'Color':
|
|
|
+ case 'ColorRGB':
|
|
|
+ case 'Vector3D':
|
|
|
+ case 'Lcl_Translation':
|
|
|
+ case 'Lcl_Rotation':
|
|
|
+ case 'Lcl_Scaling':
|
|
|
+ innerPropValue = parseNumberArray(innerPropValue);
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // CAUTION: these props must append to parent's parent
|
|
|
+ this.getPrevNode()[innerPropName] = {
|
|
|
+
|
|
|
+ 'type': innerPropType1,
|
|
|
+ 'type2': innerPropType2,
|
|
|
+ 'flag': innerPropFlag,
|
|
|
+ 'value': innerPropValue
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ this.setCurrentProp(this.getPrevNode(), innerPropName);
|
|
|
+ }
|
|
|
+
|
|
|
+ });
|
|
|
+
|
|
|
+ // Parse an FBX file in Binary format
|
|
|
+ function BinaryParser() {}
|
|
|
+
|
|
|
+ Object.assign(BinaryParser.prototype, {
|
|
|
+
|
|
|
+ parse: function parse(buffer) {
|
|
|
+
|
|
|
+ var reader = new BinaryReader(buffer);
|
|
|
+ reader.skip(23); // skip magic 23 bytes
|
|
|
+
|
|
|
+ var version = reader.getUint32();
|
|
|
+
|
|
|
+ console.log('THREE.FBXLoader: FBX binary version: ' + version);
|
|
|
+
|
|
|
+ var allNodes = new FBXTree();
|
|
|
+
|
|
|
+ while (!this.endOfContent(reader)) {
|
|
|
+
|
|
|
+ var node = this.parseNode(reader, version);
|
|
|
+ if (node !== null) allNodes.add(node.name, node);
|
|
|
+ }
|
|
|
+
|
|
|
+ return allNodes;
|
|
|
+ },
|
|
|
+
|
|
|
+ // Check if reader has reached the end of content.
|
|
|
+ endOfContent: function endOfContent(reader) {
|
|
|
+
|
|
|
+ // footer size: 160bytes + 16-byte alignment padding
|
|
|
+ // - 16bytes: magic
|
|
|
+ // - padding til 16-byte alignment (at least 1byte?)
|
|
|
+ // (seems like some exporters embed fixed 15 or 16bytes?)
|
|
|
+ // - 4bytes: magic
|
|
|
+ // - 4bytes: version
|
|
|
+ // - 120bytes: zero
|
|
|
+ // - 16bytes: magic
|
|
|
+ if (reader.size() % 16 === 0) {
|
|
|
+
|
|
|
+ return (reader.getOffset() + 160 + 16 & ~0xf) >= reader.size();
|
|
|
+ } else {
|
|
|
+
|
|
|
+ return reader.getOffset() + 160 + 16 >= reader.size();
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ // recursively parse nodes until the end of the file is reached
|
|
|
+ parseNode: function parseNode(reader, version) {
|
|
|
+
|
|
|
+ var node = {};
|
|
|
+
|
|
|
+ // The first three data sizes depends on version.
|
|
|
+ var endOffset = version >= 7500 ? reader.getUint64() : reader.getUint32();
|
|
|
+ var numProperties = version >= 7500 ? reader.getUint64() : reader.getUint32();
|
|
|
+
|
|
|
+ // note: do not remove this even if you get a linter warning as it moves the buffer forward
|
|
|
+ var propertyListLen = version >= 7500 ? reader.getUint64() : reader.getUint32();
|
|
|
+
|
|
|
+ var nameLen = reader.getUint8();
|
|
|
+ var name = reader.getString(nameLen);
|
|
|
+
|
|
|
+ // Regards this node as NULL-record if endOffset is zero
|
|
|
+ if (endOffset === 0) return null;
|
|
|
+
|
|
|
+ var propertyList = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < numProperties; i++) {
|
|
|
+
|
|
|
+ propertyList.push(this.parseProperty(reader));
|
|
|
+ }
|
|
|
+
|
|
|
+ // Regards the first three elements in propertyList as id, attrName, and attrType
|
|
|
+ var id = propertyList.length > 0 ? propertyList[0] : '';
|
|
|
+ var attrName = propertyList.length > 1 ? propertyList[1] : '';
|
|
|
+ var attrType = propertyList.length > 2 ? propertyList[2] : '';
|
|
|
+
|
|
|
+ // check if this node represents just a single property
|
|
|
+ // like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}
|
|
|
+ node.singleProperty = numProperties === 1 && reader.getOffset() === endOffset ? true : false;
|
|
|
+
|
|
|
+ while (endOffset > reader.getOffset()) {
|
|
|
+
|
|
|
+ var subNode = this.parseNode(reader, version);
|
|
|
+
|
|
|
+ if (subNode !== null) this.parseSubNode(name, node, subNode);
|
|
|
+ }
|
|
|
+
|
|
|
+ node.propertyList = propertyList; // raw property list used by parent
|
|
|
+
|
|
|
+ if (typeof id === 'number') node.id = id;
|
|
|
+ if (attrName !== '') node.attrName = attrName;
|
|
|
+ if (attrType !== '') node.attrType = attrType;
|
|
|
+ if (name !== '') node.name = name;
|
|
|
+
|
|
|
+ return node;
|
|
|
+ },
|
|
|
+
|
|
|
+ parseSubNode: function parseSubNode(name, node, subNode) {
|
|
|
+
|
|
|
+ // special case: child node is single property
|
|
|
+ if (subNode.singleProperty === true) {
|
|
|
+
|
|
|
+ var value = subNode.propertyList[0];
|
|
|
+
|
|
|
+ if (Array.isArray(value)) {
|
|
|
+
|
|
|
+ node[subNode.name] = subNode;
|
|
|
+
|
|
|
+ subNode.a = value;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ node[subNode.name] = value;
|
|
|
+ }
|
|
|
+ } else if (name === 'Connections' && subNode.name === 'C') {
|
|
|
+
|
|
|
+ var array = [];
|
|
|
+
|
|
|
+ subNode.propertyList.forEach(function (property, i) {
|
|
|
+
|
|
|
+ // first Connection is FBX type (OO, OP, etc.). We'll discard these
|
|
|
+ if (i !== 0) array.push(property);
|
|
|
+ });
|
|
|
+
|
|
|
+ if (node.connections === undefined) {
|
|
|
+
|
|
|
+ node.connections = [];
|
|
|
+ }
|
|
|
+
|
|
|
+ node.connections.push(array);
|
|
|
+ } else if (subNode.name === 'Properties70') {
|
|
|
+
|
|
|
+ var keys = Object.keys(subNode);
|
|
|
+
|
|
|
+ keys.forEach(function (key) {
|
|
|
+
|
|
|
+ node[key] = subNode[key];
|
|
|
+ });
|
|
|
+ } else if (name === 'Properties70' && subNode.name === 'P') {
|
|
|
+
|
|
|
+ var innerPropName = subNode.propertyList[0];
|
|
|
+ var innerPropType1 = subNode.propertyList[1];
|
|
|
+ var innerPropType2 = subNode.propertyList[2];
|
|
|
+ var innerPropFlag = subNode.propertyList[3];
|
|
|
+ var innerPropValue;
|
|
|
+
|
|
|
+ if (innerPropName.indexOf('Lcl ') === 0) innerPropName = innerPropName.replace('Lcl ', 'Lcl_');
|
|
|
+ if (innerPropType1.indexOf('Lcl ') === 0) innerPropType1 = innerPropType1.replace('Lcl ', 'Lcl_');
|
|
|
+
|
|
|
+ if (innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf('Lcl_') === 0) {
|
|
|
+
|
|
|
+ innerPropValue = [subNode.propertyList[4], subNode.propertyList[5], subNode.propertyList[6]];
|
|
|
+ } else {
|
|
|
+
|
|
|
+ innerPropValue = subNode.propertyList[4];
|
|
|
+ }
|
|
|
+
|
|
|
+ // this will be copied to parent, see above
|
|
|
+ node[innerPropName] = {
|
|
|
+
|
|
|
+ 'type': innerPropType1,
|
|
|
+ 'type2': innerPropType2,
|
|
|
+ 'flag': innerPropFlag,
|
|
|
+ 'value': innerPropValue
|
|
|
+
|
|
|
+ };
|
|
|
+ } else if (node[subNode.name] === undefined) {
|
|
|
+
|
|
|
+ if (typeof subNode.id === 'number') {
|
|
|
+
|
|
|
+ node[subNode.name] = {};
|
|
|
+ node[subNode.name][subNode.id] = subNode;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ node[subNode.name] = subNode;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+
|
|
|
+ if (subNode.name === 'PoseNode') {
|
|
|
+
|
|
|
+ if (!Array.isArray(node[subNode.name])) {
|
|
|
+
|
|
|
+ node[subNode.name] = [node[subNode.name]];
|
|
|
+ }
|
|
|
+
|
|
|
+ node[subNode.name].push(subNode);
|
|
|
+ } else if (node[subNode.name][subNode.id] === undefined) {
|
|
|
+
|
|
|
+ node[subNode.name][subNode.id] = subNode;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ parseProperty: function parseProperty(reader) {
|
|
|
+
|
|
|
+ var type = reader.getString(1);
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 'C':
|
|
|
+ return reader.getBoolean();
|
|
|
+
|
|
|
+ case 'D':
|
|
|
+ return reader.getFloat64();
|
|
|
+
|
|
|
+ case 'F':
|
|
|
+ return reader.getFloat32();
|
|
|
+
|
|
|
+ case 'I':
|
|
|
+ return reader.getInt32();
|
|
|
+
|
|
|
+ case 'L':
|
|
|
+ return reader.getInt64();
|
|
|
+
|
|
|
+ case 'R':
|
|
|
+ var length = reader.getUint32();
|
|
|
+ return reader.getArrayBuffer(length);
|
|
|
+
|
|
|
+ case 'S':
|
|
|
+ var length = reader.getUint32();
|
|
|
+ return reader.getString(length);
|
|
|
+
|
|
|
+ case 'Y':
|
|
|
+ return reader.getInt16();
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ case 'c':
|
|
|
+ case 'd':
|
|
|
+ case 'f':
|
|
|
+ case 'i':
|
|
|
+ case 'l':
|
|
|
+
|
|
|
+ var arrayLength = reader.getUint32();
|
|
|
+ var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
|
|
|
+ var compressedLength = reader.getUint32();
|
|
|
+
|
|
|
+ if (encoding === 0) {
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ case 'c':
|
|
|
+ return reader.getBooleanArray(arrayLength);
|
|
|
+
|
|
|
+ case 'd':
|
|
|
+ return reader.getFloat64Array(arrayLength);
|
|
|
+
|
|
|
+ case 'f':
|
|
|
+ return reader.getFloat32Array(arrayLength);
|
|
|
+
|
|
|
+ case 'i':
|
|
|
+ return reader.getInt32Array(arrayLength);
|
|
|
+
|
|
|
+ case 'l':
|
|
|
+ return reader.getInt64Array(arrayLength);
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (window.Zlib === undefined) {
|
|
|
+
|
|
|
+ console.error('THREE.FBXLoader: External library Inflate.min.js required, obtain or import from https://github.com/imaya/zlib.js');
|
|
|
+ }
|
|
|
+
|
|
|
+ var inflate = new Zlib.Inflate(new Uint8Array(reader.getArrayBuffer(compressedLength))); // eslint-disable-line no-undef
|
|
|
+ var reader2 = new BinaryReader(inflate.decompress().buffer);
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ case 'c':
|
|
|
+ return reader2.getBooleanArray(arrayLength);
|
|
|
+
|
|
|
+ case 'd':
|
|
|
+ return reader2.getFloat64Array(arrayLength);
|
|
|
+
|
|
|
+ case 'f':
|
|
|
+ return reader2.getFloat32Array(arrayLength);
|
|
|
+
|
|
|
+ case 'i':
|
|
|
+ return reader2.getInt32Array(arrayLength);
|
|
|
+
|
|
|
+ case 'l':
|
|
|
+ return reader2.getInt64Array(arrayLength);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ default:
|
|
|
+ throw new Error('THREE.FBXLoader: Unknown property type ' + type);
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ });
|
|
|
+
|
|
|
+ function BinaryReader(buffer, littleEndian) {
|
|
|
+
|
|
|
+ this.dv = new DataView(buffer);
|
|
|
+ this.offset = 0;
|
|
|
+ this.littleEndian = littleEndian !== undefined ? littleEndian : true;
|
|
|
+ }
|
|
|
+
|
|
|
+ Object.assign(BinaryReader.prototype, {
|
|
|
+
|
|
|
+ getOffset: function getOffset() {
|
|
|
+
|
|
|
+ return this.offset;
|
|
|
+ },
|
|
|
+
|
|
|
+ size: function size() {
|
|
|
+
|
|
|
+ return this.dv.buffer.byteLength;
|
|
|
+ },
|
|
|
+
|
|
|
+ skip: function skip(length) {
|
|
|
+
|
|
|
+ this.offset += length;
|
|
|
+ },
|
|
|
+
|
|
|
+ // seems like true/false representation depends on exporter.
|
|
|
+ // true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)
|
|
|
+ // then sees LSB.
|
|
|
+ getBoolean: function getBoolean() {
|
|
|
+
|
|
|
+ return (this.getUint8() & 1) === 1;
|
|
|
+ },
|
|
|
+
|
|
|
+ getBooleanArray: function getBooleanArray(size) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a.push(this.getBoolean());
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint8: function getUint8() {
|
|
|
+
|
|
|
+ var value = this.dv.getUint8(this.offset);
|
|
|
+ this.offset += 1;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt16: function getInt16() {
|
|
|
+
|
|
|
+ var value = this.dv.getInt16(this.offset, this.littleEndian);
|
|
|
+ this.offset += 2;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt32: function getInt32() {
|
|
|
+
|
|
|
+ var value = this.dv.getInt32(this.offset, this.littleEndian);
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt32Array: function getInt32Array(size) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a.push(this.getInt32());
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint32: function getUint32() {
|
|
|
+
|
|
|
+ var value = this.dv.getUint32(this.offset, this.littleEndian);
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ // JavaScript doesn't support 64-bit integer so calculate this here
|
|
|
+ // 1 << 32 will return 1 so using multiply operation instead here.
|
|
|
+ // There's a possibility that this method returns wrong value if the value
|
|
|
+ // is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
|
|
|
+ // TODO: safely handle 64-bit integer
|
|
|
+ getInt64: function getInt64() {
|
|
|
+
|
|
|
+ var low, high;
|
|
|
+
|
|
|
+ if (this.littleEndian) {
|
|
|
+
|
|
|
+ low = this.getUint32();
|
|
|
+ high = this.getUint32();
|
|
|
+ } else {
|
|
|
+
|
|
|
+ high = this.getUint32();
|
|
|
+ low = this.getUint32();
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate negative value
|
|
|
+ if (high & 0x80000000) {
|
|
|
+
|
|
|
+ high = ~high & 0xFFFFFFFF;
|
|
|
+ low = ~low & 0xFFFFFFFF;
|
|
|
+
|
|
|
+ if (low === 0xFFFFFFFF) high = high + 1 & 0xFFFFFFFF;
|
|
|
+
|
|
|
+ low = low + 1 & 0xFFFFFFFF;
|
|
|
+
|
|
|
+ return -(high * 0x100000000 + low);
|
|
|
+ }
|
|
|
+
|
|
|
+ return high * 0x100000000 + low;
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt64Array: function getInt64Array(size) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a.push(this.getInt64());
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ },
|
|
|
+
|
|
|
+ // Note: see getInt64() comment
|
|
|
+ getUint64: function getUint64() {
|
|
|
+
|
|
|
+ var low, high;
|
|
|
+
|
|
|
+ if (this.littleEndian) {
|
|
|
+
|
|
|
+ low = this.getUint32();
|
|
|
+ high = this.getUint32();
|
|
|
+ } else {
|
|
|
+
|
|
|
+ high = this.getUint32();
|
|
|
+ low = this.getUint32();
|
|
|
+ }
|
|
|
+
|
|
|
+ return high * 0x100000000 + low;
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat32: function getFloat32() {
|
|
|
+
|
|
|
+ var value = this.dv.getFloat32(this.offset, this.littleEndian);
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat32Array: function getFloat32Array(size) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a.push(this.getFloat32());
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat64: function getFloat64() {
|
|
|
+
|
|
|
+ var value = this.dv.getFloat64(this.offset, this.littleEndian);
|
|
|
+ this.offset += 8;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat64Array: function getFloat64Array(size) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a.push(this.getFloat64());
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ },
|
|
|
+
|
|
|
+ getArrayBuffer: function getArrayBuffer(size) {
|
|
|
+
|
|
|
+ var value = this.dv.buffer.slice(this.offset, this.offset + size);
|
|
|
+ this.offset += size;
|
|
|
+ return value;
|
|
|
+ },
|
|
|
+
|
|
|
+ getString: function getString(size) {
|
|
|
+
|
|
|
+ var a = new Uint8Array(size);
|
|
|
+
|
|
|
+ for (var i = 0; i < size; i++) {
|
|
|
+
|
|
|
+ a[i] = this.getUint8();
|
|
|
+ }
|
|
|
+
|
|
|
+ var nullByte = a.indexOf(0);
|
|
|
+ if (nullByte >= 0) a = a.slice(0, nullByte);
|
|
|
+
|
|
|
+ return THREE.LoaderUtils.decodeText(a);
|
|
|
+ }
|
|
|
+
|
|
|
+ });
|
|
|
+
|
|
|
+ // FBXTree holds a representation of the FBX data, returned by the TextParser ( FBX ASCII format)
|
|
|
+ // and BinaryParser( FBX Binary format)
|
|
|
+ function FBXTree() {}
|
|
|
+
|
|
|
+ Object.assign(FBXTree.prototype, {
|
|
|
+
|
|
|
+ add: function add(key, val) {
|
|
|
+
|
|
|
+ this[key] = val;
|
|
|
+ }
|
|
|
+
|
|
|
+ });
|
|
|
+
|
|
|
+ function isFbxFormatBinary(buffer) {
|
|
|
+
|
|
|
+ var CORRECT = 'Kaydara FBX Binary \0';
|
|
|
+
|
|
|
+ return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString(buffer, 0, CORRECT.length);
|
|
|
+ }
|
|
|
+
|
|
|
+ function isFbxFormatASCII(text) {
|
|
|
+
|
|
|
+ var CORRECT = ['K', 'a', 'y', 'd', 'a', 'r', 'a', '\\', 'F', 'B', 'X', '\\', 'B', 'i', 'n', 'a', 'r', 'y', '\\', '\\'];
|
|
|
+
|
|
|
+ var cursor = 0;
|
|
|
+
|
|
|
+ function read(offset) {
|
|
|
+
|
|
|
+ var result = text[offset - 1];
|
|
|
+ text = text.slice(cursor + offset);
|
|
|
+ cursor++;
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var i = 0; i < CORRECT.length; ++i) {
|
|
|
+
|
|
|
+ var num = read(1);
|
|
|
+ if (num === CORRECT[i]) {
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ function getFbxVersion(text) {
|
|
|
+
|
|
|
+ var versionRegExp = /FBXVersion: (\d+)/;
|
|
|
+ var match = text.match(versionRegExp);
|
|
|
+ if (match) {
|
|
|
+
|
|
|
+ var version = parseInt(match[1]);
|
|
|
+ return version;
|
|
|
+ }
|
|
|
+ throw new Error('THREE.FBXLoader: Cannot find the version number for the file given.');
|
|
|
+ }
|
|
|
+
|
|
|
+ // Converts FBX ticks into real time seconds.
|
|
|
+ function convertFBXTimeToSeconds(time) {
|
|
|
+
|
|
|
+ return time / 46186158000;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parses comma separated list of numbers and returns them an array.
|
|
|
+ // Used internally by the TextParser
|
|
|
+ function parseNumberArray(value) {
|
|
|
+
|
|
|
+ var array = value.split(',').map(function (val) {
|
|
|
+
|
|
|
+ return parseFloat(val);
|
|
|
+ });
|
|
|
+
|
|
|
+ return array;
|
|
|
+ }
|
|
|
+
|
|
|
+ function convertArrayBufferToString(buffer, from, to) {
|
|
|
+
|
|
|
+ if (from === undefined) from = 0;
|
|
|
+ if (to === undefined) to = buffer.byteLength;
|
|
|
+
|
|
|
+ return THREE.LoaderUtils.decodeText(new Uint8Array(buffer, from, to));
|
|
|
+ }
|
|
|
+
|
|
|
+ function append(a, b) {
|
|
|
+
|
|
|
+ for (var i = 0, j = a.length, l = b.length; i < l; i++, j++) {
|
|
|
+
|
|
|
+ a[j] = b[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function slice(a, b, from, to) {
|
|
|
+
|
|
|
+ for (var i = from, j = 0; i < to; i++, j++) {
|
|
|
+
|
|
|
+ a[j] = b[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ }
|
|
|
+})();
|
|
|
+
|
|
|
+},{}],3:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+/**
|
|
|
+ * @author Wei Meng / http://about.me/menway
|
|
|
+ *
|
|
|
+ * Description: A THREE loader for PLY ASCII files (known as the Polygon File Format or the Stanford Triangle Format).
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * Limitations: ASCII decoding assumes file is UTF-8.
|
|
|
+ *
|
|
|
+ * Usage:
|
|
|
+ * var loader = new THREE.PLYLoader();
|
|
|
+ * loader.load('./models/ply/ascii/dolphins.ply', function (geometry) {
|
|
|
+ *
|
|
|
+ * scene.add( new THREE.Mesh( geometry ) );
|
|
|
+ *
|
|
|
+ * } );
|
|
|
+ *
|
|
|
+ * If the PLY file uses non standard property names, they can be mapped while
|
|
|
+ * loading. For example, the following maps the properties
|
|
|
+ * “diffuse_(red|green|blue)” in the file to standard color names.
|
|
|
+ *
|
|
|
+ * loader.setPropertyNameMapping( {
|
|
|
+ * diffuse_red: 'red',
|
|
|
+ * diffuse_green: 'green',
|
|
|
+ * diffuse_blue: 'blue'
|
|
|
+ * } );
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+module.exports = THREE.PLYLoader = function (manager) {
|
|
|
+
|
|
|
+ this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager;
|
|
|
+
|
|
|
+ this.propertyNameMapping = {};
|
|
|
+};
|
|
|
+
|
|
|
+THREE.PLYLoader.prototype = {
|
|
|
+
|
|
|
+ constructor: THREE.PLYLoader,
|
|
|
+
|
|
|
+ load: function load(url, onLoad, onProgress, onError) {
|
|
|
+
|
|
|
+ var scope = this;
|
|
|
+
|
|
|
+ var loader = new THREE.XHRLoader(this.manager);
|
|
|
+ loader.setResponseType('arraybuffer');
|
|
|
+ loader.load(url, function (text) {
|
|
|
+
|
|
|
+ onLoad(scope.parse(text));
|
|
|
+ }, onProgress, onError);
|
|
|
+ },
|
|
|
+
|
|
|
+ setPropertyNameMapping: function setPropertyNameMapping(mapping) {
|
|
|
+
|
|
|
+ this.propertyNameMapping = mapping;
|
|
|
+ },
|
|
|
+
|
|
|
+ bin2str: function bin2str(buf) {
|
|
|
+
|
|
|
+ var array_buffer = new Uint8Array(buf);
|
|
|
+ var str = '';
|
|
|
+ for (var i = 0; i < buf.byteLength; i++) {
|
|
|
+
|
|
|
+ str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
|
|
|
+ }
|
|
|
+
|
|
|
+ return str;
|
|
|
+ },
|
|
|
+
|
|
|
+ isASCII: function isASCII(data) {
|
|
|
+
|
|
|
+ var header = this.parseHeader(this.bin2str(data));
|
|
|
+
|
|
|
+ return header.format === "ascii";
|
|
|
+ },
|
|
|
+
|
|
|
+ parse: function parse(data) {
|
|
|
+
|
|
|
+ if (data instanceof ArrayBuffer) {
|
|
|
+
|
|
|
+ return this.isASCII(data) ? this.parseASCII(this.bin2str(data)) : this.parseBinary(data);
|
|
|
+ } else {
|
|
|
+
|
|
|
+ return this.parseASCII(data);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ parseHeader: function parseHeader(data) {
|
|
|
+
|
|
|
+ var patternHeader = /ply([\s\S]*)end_header\s/;
|
|
|
+ var headerText = "";
|
|
|
+ var headerLength = 0;
|
|
|
+ var result = patternHeader.exec(data);
|
|
|
+ if (result !== null) {
|
|
|
+
|
|
|
+ headerText = result[1];
|
|
|
+ headerLength = result[0].length;
|
|
|
+ }
|
|
|
+
|
|
|
+ var header = {
|
|
|
+ comments: [],
|
|
|
+ elements: [],
|
|
|
+ headerLength: headerLength
|
|
|
+ };
|
|
|
+
|
|
|
+ var lines = headerText.split('\n');
|
|
|
+ var currentElement = undefined;
|
|
|
+ var lineType, lineValues;
|
|
|
+
|
|
|
+ function make_ply_element_property(propertValues, propertyNameMapping) {
|
|
|
+
|
|
|
+ var property = {
|
|
|
+ type: propertValues[0]
|
|
|
+ };
|
|
|
+
|
|
|
+ if (property.type === 'list') {
|
|
|
+
|
|
|
+ property.name = propertValues[3];
|
|
|
+ property.countType = propertValues[1];
|
|
|
+ property.itemType = propertValues[2];
|
|
|
+ } else {
|
|
|
+
|
|
|
+ property.name = propertValues[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (property.name in propertyNameMapping) {
|
|
|
+
|
|
|
+ property.name = propertyNameMapping[property.name];
|
|
|
+ }
|
|
|
+
|
|
|
+ return property;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var i = 0; i < lines.length; i++) {
|
|
|
+
|
|
|
+ var line = lines[i];
|
|
|
+ line = line.trim();
|
|
|
+ if (line === "") {
|
|
|
+
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ lineValues = line.split(/\s+/);
|
|
|
+ lineType = lineValues.shift();
|
|
|
+ line = lineValues.join(" ");
|
|
|
+
|
|
|
+ switch (lineType) {
|
|
|
+
|
|
|
+ case "format":
|
|
|
+
|
|
|
+ header.format = lineValues[0];
|
|
|
+ header.version = lineValues[1];
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ case "comment":
|
|
|
+
|
|
|
+ header.comments.push(line);
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ case "element":
|
|
|
+
|
|
|
+ if (!(currentElement === undefined)) {
|
|
|
+
|
|
|
+ header.elements.push(currentElement);
|
|
|
+ }
|
|
|
+
|
|
|
+ currentElement = Object();
|
|
|
+ currentElement.name = lineValues[0];
|
|
|
+ currentElement.count = parseInt(lineValues[1]);
|
|
|
+ currentElement.properties = [];
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ case "property":
|
|
|
+
|
|
|
+ currentElement.properties.push(make_ply_element_property(lineValues, this.propertyNameMapping));
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+
|
|
|
+ console.log("unhandled", lineType, lineValues);
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!(currentElement === undefined)) {
|
|
|
+
|
|
|
+ header.elements.push(currentElement);
|
|
|
+ }
|
|
|
+
|
|
|
+ return header;
|
|
|
+ },
|
|
|
+
|
|
|
+ parseASCIINumber: function parseASCIINumber(n, type) {
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case 'char':case 'uchar':case 'short':case 'ushort':case 'int':case 'uint':
|
|
|
+ case 'int8':case 'uint8':case 'int16':case 'uint16':case 'int32':case 'uint32':
|
|
|
+
|
|
|
+ return parseInt(n);
|
|
|
+
|
|
|
+ case 'float':case 'double':case 'float32':case 'float64':
|
|
|
+
|
|
|
+ return parseFloat(n);
|
|
|
+
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ parseASCIIElement: function parseASCIIElement(properties, line) {
|
|
|
+
|
|
|
+ var values = line.split(/\s+/);
|
|
|
+
|
|
|
+ var element = Object();
|
|
|
+
|
|
|
+ for (var i = 0; i < properties.length; i++) {
|
|
|
+
|
|
|
+ if (properties[i].type === "list") {
|
|
|
+
|
|
|
+ var list = [];
|
|
|
+ var n = this.parseASCIINumber(values.shift(), properties[i].countType);
|
|
|
+
|
|
|
+ for (var j = 0; j < n; j++) {
|
|
|
+
|
|
|
+ list.push(this.parseASCIINumber(values.shift(), properties[i].itemType));
|
|
|
+ }
|
|
|
+
|
|
|
+ element[properties[i].name] = list;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ element[properties[i].name] = this.parseASCIINumber(values.shift(), properties[i].type);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return element;
|
|
|
+ },
|
|
|
+
|
|
|
+ parseASCII: function parseASCII(data) {
|
|
|
+
|
|
|
+ // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
|
|
|
+
|
|
|
+ var geometry = new THREE.Geometry();
|
|
|
+
|
|
|
+ var result;
|
|
|
+
|
|
|
+ var header = this.parseHeader(data);
|
|
|
+
|
|
|
+ var patternBody = /end_header\s([\s\S]*)$/;
|
|
|
+ var body = "";
|
|
|
+ if ((result = patternBody.exec(data)) !== null) {
|
|
|
+
|
|
|
+ body = result[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ var lines = body.split('\n');
|
|
|
+ var currentElement = 0;
|
|
|
+ var currentElementCount = 0;
|
|
|
+ geometry.useColor = false;
|
|
|
+
|
|
|
+ for (var i = 0; i < lines.length; i++) {
|
|
|
+
|
|
|
+ var line = lines[i];
|
|
|
+ line = line.trim();
|
|
|
+ if (line === "") {
|
|
|
+
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (currentElementCount >= header.elements[currentElement].count) {
|
|
|
+
|
|
|
+ currentElement++;
|
|
|
+ currentElementCount = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ var element = this.parseASCIIElement(header.elements[currentElement].properties, line);
|
|
|
+
|
|
|
+ this.handleElement(geometry, header.elements[currentElement].name, element);
|
|
|
+
|
|
|
+ currentElementCount++;
|
|
|
+ }
|
|
|
+
|
|
|
+ return this.postProcess(geometry);
|
|
|
+ },
|
|
|
+
|
|
|
+ postProcess: function postProcess(geometry) {
|
|
|
+
|
|
|
+ if (geometry.useColor) {
|
|
|
+
|
|
|
+ for (var i = 0; i < geometry.faces.length; i++) {
|
|
|
+
|
|
|
+ geometry.faces[i].vertexColors = [geometry.colors[geometry.faces[i].a], geometry.colors[geometry.faces[i].b], geometry.colors[geometry.faces[i].c]];
|
|
|
+ }
|
|
|
+
|
|
|
+ geometry.elementsNeedUpdate = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ geometry.computeBoundingSphere();
|
|
|
+
|
|
|
+ return geometry;
|
|
|
+ },
|
|
|
+
|
|
|
+ handleElement: function handleElement(geometry, elementName, element) {
|
|
|
+
|
|
|
+ if (elementName === "vertex") {
|
|
|
+
|
|
|
+ geometry.vertices.push(new THREE.Vector3(element.x, element.y, element.z));
|
|
|
+
|
|
|
+ if ('red' in element && 'green' in element && 'blue' in element) {
|
|
|
+
|
|
|
+ geometry.useColor = true;
|
|
|
+
|
|
|
+ var color = new THREE.Color();
|
|
|
+ color.setRGB(element.red / 255.0, element.green / 255.0, element.blue / 255.0);
|
|
|
+ geometry.colors.push(color);
|
|
|
+ }
|
|
|
+ } else if (elementName === "face") {
|
|
|
+
|
|
|
+ // BEGIN: Edits by donmccurdy.
|
|
|
+ var vertex_indices = element.vertex_indices || element.vertex_index;
|
|
|
+ // END: Edits by donmccurdy.
|
|
|
+
|
|
|
+ if (vertex_indices.length === 3) {
|
|
|
+
|
|
|
+ geometry.faces.push(new THREE.Face3(vertex_indices[0], vertex_indices[1], vertex_indices[2]));
|
|
|
+ } else if (vertex_indices.length === 4) {
|
|
|
+
|
|
|
+ geometry.faces.push(new THREE.Face3(vertex_indices[0], vertex_indices[1], vertex_indices[3]), new THREE.Face3(vertex_indices[1], vertex_indices[2], vertex_indices[3]));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ binaryRead: function binaryRead(dataview, at, type, little_endian) {
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ // corespondences for non-specific length types here match rply:
|
|
|
+ case 'int8':case 'char':
|
|
|
+ return [dataview.getInt8(at), 1];
|
|
|
+
|
|
|
+ case 'uint8':case 'uchar':
|
|
|
+ return [dataview.getUint8(at), 1];
|
|
|
+
|
|
|
+ case 'int16':case 'short':
|
|
|
+ return [dataview.getInt16(at, little_endian), 2];
|
|
|
+
|
|
|
+ case 'uint16':case 'ushort':
|
|
|
+ return [dataview.getUint16(at, little_endian), 2];
|
|
|
+
|
|
|
+ case 'int32':case 'int':
|
|
|
+ return [dataview.getInt32(at, little_endian), 4];
|
|
|
+
|
|
|
+ case 'uint32':case 'uint':
|
|
|
+ return [dataview.getUint32(at, little_endian), 4];
|
|
|
+
|
|
|
+ case 'float32':case 'float':
|
|
|
+ return [dataview.getFloat32(at, little_endian), 4];
|
|
|
+
|
|
|
+ case 'float64':case 'double':
|
|
|
+ return [dataview.getFloat64(at, little_endian), 8];
|
|
|
+
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ binaryReadElement: function binaryReadElement(dataview, at, properties, little_endian) {
|
|
|
+
|
|
|
+ var element = Object();
|
|
|
+ var result,
|
|
|
+ read = 0;
|
|
|
+
|
|
|
+ for (var i = 0; i < properties.length; i++) {
|
|
|
+
|
|
|
+ if (properties[i].type === "list") {
|
|
|
+
|
|
|
+ var list = [];
|
|
|
+
|
|
|
+ result = this.binaryRead(dataview, at + read, properties[i].countType, little_endian);
|
|
|
+ var n = result[0];
|
|
|
+ read += result[1];
|
|
|
+
|
|
|
+ for (var j = 0; j < n; j++) {
|
|
|
+
|
|
|
+ result = this.binaryRead(dataview, at + read, properties[i].itemType, little_endian);
|
|
|
+ list.push(result[0]);
|
|
|
+ read += result[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ element[properties[i].name] = list;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ result = this.binaryRead(dataview, at + read, properties[i].type, little_endian);
|
|
|
+ element[properties[i].name] = result[0];
|
|
|
+ read += result[1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return [element, read];
|
|
|
+ },
|
|
|
+
|
|
|
+ parseBinary: function parseBinary(data) {
|
|
|
+
|
|
|
+ var geometry = new THREE.Geometry();
|
|
|
+
|
|
|
+ var header = this.parseHeader(this.bin2str(data));
|
|
|
+ var little_endian = header.format === "binary_little_endian";
|
|
|
+ var body = new DataView(data, header.headerLength);
|
|
|
+ var result,
|
|
|
+ loc = 0;
|
|
|
+
|
|
|
+ for (var currentElement = 0; currentElement < header.elements.length; currentElement++) {
|
|
|
+
|
|
|
+ for (var currentElementCount = 0; currentElementCount < header.elements[currentElement].count; currentElementCount++) {
|
|
|
+
|
|
|
+ result = this.binaryReadElement(body, loc, header.elements[currentElement].properties, little_endian);
|
|
|
+ loc += result[1];
|
|
|
+ var element = result[0];
|
|
|
+
|
|
|
+ this.handleElement(geometry, header.elements[currentElement].name, element);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return this.postProcess(geometry);
|
|
|
+ }
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+},{}],4:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+/**
|
|
|
+ * Source: https://github.com/Adobe-Marketing-Cloud/fetch-script
|
|
|
+ */
|
|
|
+
|
|
|
+function getScriptId() {
|
|
|
+ return 'script_' + Date.now() + '_' + Math.ceil(Math.random() * 100000);
|
|
|
+}
|
|
|
+
|
|
|
+function createScript(url, id) {
|
|
|
+ var script = document.createElement('script');
|
|
|
+ script.type = 'text/javascript';
|
|
|
+ script.async = true;
|
|
|
+ script.id = id;
|
|
|
+ script.src = url;
|
|
|
+
|
|
|
+ return script;
|
|
|
+}
|
|
|
+
|
|
|
+function removeScript(id) {
|
|
|
+ var script = document.getElementById(id);
|
|
|
+ var parent = script.parentNode;
|
|
|
+
|
|
|
+ try {
|
|
|
+ parent && parent.removeChild(script);
|
|
|
+ } catch (e) {
|
|
|
+ // ignore
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function appendScript(script) {
|
|
|
+ var firstScript = document.getElementsByTagName('script')[0];
|
|
|
+ firstScript.parentNode.insertBefore(script, firstScript);
|
|
|
+}
|
|
|
+
|
|
|
+function fetchScriptInternal(url, options, Promise) {
|
|
|
+ return new Promise(function (resolve, reject) {
|
|
|
+ var timeout = options.timeout || 5000;
|
|
|
+ var scriptId = getScriptId();
|
|
|
+ var script = createScript(url, scriptId);
|
|
|
+
|
|
|
+ var timeoutId = setTimeout(function () {
|
|
|
+ reject(new Error('Script request to ' + url + ' timed out'));
|
|
|
+
|
|
|
+ removeScript(scriptId);
|
|
|
+ }, timeout);
|
|
|
+
|
|
|
+ var disableTimeout = function disableTimeout(timeoutId) {
|
|
|
+ clearTimeout(timeoutId);
|
|
|
+ };
|
|
|
+
|
|
|
+ script.addEventListener('load', function (e) {
|
|
|
+ resolve({ ok: true });
|
|
|
+
|
|
|
+ disableTimeout(timeoutId);
|
|
|
+ removeScript(scriptId);
|
|
|
+ });
|
|
|
+
|
|
|
+ script.addEventListener('error', function (e) {
|
|
|
+ reject(new Error('Script request to ' + url + ' failed ' + e));
|
|
|
+
|
|
|
+ disableTimeout(timeoutId);
|
|
|
+ removeScript(scriptId);
|
|
|
+ });
|
|
|
+
|
|
|
+ appendScript(script);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function fetchScript(settings) {
|
|
|
+ settings = settings || {};
|
|
|
+ return function (url, options) {
|
|
|
+ options = options || {};
|
|
|
+ return fetchScriptInternal(url, options, settings.Promise || Promise);
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = fetchScript;
|
|
|
+
|
|
|
+},{}],5:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+var LoopMode = {
|
|
|
+ once: THREE.LoopOnce,
|
|
|
+ repeat: THREE.LoopRepeat,
|
|
|
+ pingpong: THREE.LoopPingPong
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * animation-mixer
|
|
|
+ *
|
|
|
+ * Player for animation clips. Intended to be compatible with any model format that supports
|
|
|
+ * skeletal or morph animations through THREE.AnimationMixer.
|
|
|
+ * See: https://threejs.org/docs/?q=animation#Reference/Animation/AnimationMixer
|
|
|
+ */
|
|
|
+module.exports = AFRAME.registerComponent('animation-mixer', {
|
|
|
+ schema: {
|
|
|
+ clip: { default: '*' },
|
|
|
+ duration: { default: 0 },
|
|
|
+ clampWhenFinished: { default: false, type: 'boolean' },
|
|
|
+ crossFadeDuration: { default: 0 },
|
|
|
+ loop: { default: 'repeat', oneOf: Object.keys(LoopMode) },
|
|
|
+ repetitions: { default: Infinity, min: 0 }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ /** @type {THREE.Mesh} */
|
|
|
+ this.model = null;
|
|
|
+ /** @type {THREE.AnimationMixer} */
|
|
|
+ this.mixer = null;
|
|
|
+ /** @type {Array<THREE.AnimationAction>} */
|
|
|
+ this.activeActions = [];
|
|
|
+
|
|
|
+ var model = this.el.getObject3D('mesh');
|
|
|
+
|
|
|
+ if (model) {
|
|
|
+ this.load(model);
|
|
|
+ } else {
|
|
|
+ this.el.addEventListener('model-loaded', function (e) {
|
|
|
+ _this.load(e.detail.model);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function load(model) {
|
|
|
+ var el = this.el;
|
|
|
+ this.model = model;
|
|
|
+ this.mixer = new THREE.AnimationMixer(model);
|
|
|
+ this.mixer.addEventListener('loop', function (e) {
|
|
|
+ el.emit('animation-loop', { action: e.action, loopDelta: e.loopDelta });
|
|
|
+ });
|
|
|
+ this.mixer.addEventListener('finished', function (e) {
|
|
|
+ el.emit('animation-finished', { action: e.action, direction: e.direction });
|
|
|
+ });
|
|
|
+ if (this.data.clip) this.update({});
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (this.mixer) this.mixer.stopAllAction();
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update(previousData) {
|
|
|
+ if (!previousData) return;
|
|
|
+
|
|
|
+ this.stopAction();
|
|
|
+
|
|
|
+ if (this.data.clip) {
|
|
|
+ this.playAction();
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ stopAction: function stopAction() {
|
|
|
+ var data = this.data;
|
|
|
+ for (var i = 0; i < this.activeActions.length; i++) {
|
|
|
+ data.crossFadeDuration ? this.activeActions[i].fadeOut(data.crossFadeDuration) : this.activeActions[i].stop();
|
|
|
+ }
|
|
|
+ this.activeActions.length = 0;
|
|
|
+ },
|
|
|
+
|
|
|
+ playAction: function playAction() {
|
|
|
+ if (!this.mixer) return;
|
|
|
+
|
|
|
+ var model = this.model,
|
|
|
+ data = this.data,
|
|
|
+ clips = model.animations || (model.geometry || {}).animations || [];
|
|
|
+
|
|
|
+ if (!clips.length) return;
|
|
|
+
|
|
|
+ var re = wildcardToRegExp(data.clip);
|
|
|
+
|
|
|
+ for (var clip, i = 0; clip = clips[i]; i++) {
|
|
|
+ if (clip.name.match(re)) {
|
|
|
+ var action = this.mixer.clipAction(clip, model);
|
|
|
+ action.enabled = true;
|
|
|
+ action.clampWhenFinished = data.clampWhenFinished;
|
|
|
+ if (data.duration) action.setDuration(data.duration);
|
|
|
+ action.setLoop(LoopMode[data.loop], data.repetitions).fadeIn(data.crossFadeDuration).play();
|
|
|
+ this.activeActions.push(action);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ tick: function tick(t, dt) {
|
|
|
+ if (this.mixer && !isNaN(dt)) this.mixer.update(dt / 1000);
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+/**
|
|
|
+ * Creates a RegExp from the given string, converting asterisks to .* expressions,
|
|
|
+ * and escaping all other characters.
|
|
|
+ */
|
|
|
+function wildcardToRegExp(s) {
|
|
|
+ return new RegExp('^' + s.split(/\*+/).map(regExpEscape).join('.*') + '$');
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * RegExp-escapes all characters in the given string.
|
|
|
+ */
|
|
|
+function regExpEscape(s) {
|
|
|
+ return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
|
|
|
+}
|
|
|
+
|
|
|
+},{}],6:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+THREE.FBXLoader = require('../../lib/FBXLoader');
|
|
|
+
|
|
|
+/**
|
|
|
+ * fbx-model
|
|
|
+ *
|
|
|
+ * Loader for FBX format. Supports ASCII, but *not* binary, models.
|
|
|
+ */
|
|
|
+module.exports = AFRAME.registerComponent('fbx-model', {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update() {
|
|
|
+ var data = this.data;
|
|
|
+ if (!data.src) return;
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+ var loader = new THREE.FBXLoader();
|
|
|
+ if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
|
|
|
+ loader.load(data.src, this.load.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function load(model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', { format: 'fbx', model: model });
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+},{"../../lib/FBXLoader":2}],7:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+var fetchScript = require('../../lib/fetch-script')();
|
|
|
+
|
|
|
+var LOADER_SRC = 'https://rawgit.com/mrdoob/three.js/r86/examples/js/loaders/GLTFLoader.js';
|
|
|
+
|
|
|
+var loadLoader = function () {
|
|
|
+ var promise = void 0;
|
|
|
+ return function () {
|
|
|
+ promise = promise || fetchScript(LOADER_SRC);
|
|
|
+ return promise;
|
|
|
+ };
|
|
|
+}();
|
|
|
+
|
|
|
+/**
|
|
|
+ * Legacy loader for glTF 1.0 models.
|
|
|
+ * Asynchronously loads THREE.GLTFLoader from rawgit.
|
|
|
+ */
|
|
|
+module.exports = AFRAME.registerComponent('gltf-model-legacy', {
|
|
|
+ schema: { type: 'model' },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ this.model = null;
|
|
|
+ this.loader = null;
|
|
|
+ this.loaderPromise = loadLoader().then(function () {
|
|
|
+ _this.loader = new THREE.GLTFLoader();
|
|
|
+ _this.loader.setCrossOrigin('Anonymous');
|
|
|
+ });
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update() {
|
|
|
+ var _this2 = this;
|
|
|
+
|
|
|
+ var self = this;
|
|
|
+ var el = this.el;
|
|
|
+ var src = this.data;
|
|
|
+
|
|
|
+ if (!src) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+
|
|
|
+ this.loaderPromise.then(function () {
|
|
|
+ _this2.loader.load(src, function gltfLoaded(gltfModel) {
|
|
|
+ self.model = gltfModel.scene;
|
|
|
+ self.model.animations = gltfModel.animations;
|
|
|
+ el.setObject3D('mesh', self.model);
|
|
|
+ el.emit('model-loaded', { format: 'gltf', model: self.model });
|
|
|
+ });
|
|
|
+ });
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (!this.model) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+},{"../../lib/fetch-script":4}],8:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+require('./animation-mixer');
|
|
|
+require('./fbx-model');
|
|
|
+require('./gltf-model-legacy');
|
|
|
+require('./json-model');
|
|
|
+require('./object-model');
|
|
|
+require('./ply-model');
|
|
|
+
|
|
|
+},{"./animation-mixer":5,"./fbx-model":6,"./gltf-model-legacy":7,"./json-model":9,"./object-model":10,"./ply-model":11}],9:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+/**
|
|
|
+ * json-model
|
|
|
+ *
|
|
|
+ * Loader for THREE.js JSON format. Somewhat confusingly, there are two different THREE.js formats,
|
|
|
+ * both having the .json extension. This loader supports only THREE.JsonLoader, which typically
|
|
|
+ * includes only a single mesh.
|
|
|
+ *
|
|
|
+ * Check the console for errors, if in doubt. You may need to use `object-model` or
|
|
|
+ * `blend-character-model` for some .js and .json files.
|
|
|
+ *
|
|
|
+ * See: https://clara.io/learn/user-guide/data_exchange/threejs_export
|
|
|
+ */
|
|
|
+
|
|
|
+module.exports = AFRAME.registerComponent('json-model', {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update() {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ var loader = void 0;
|
|
|
+ var data = this.data;
|
|
|
+ if (!data.src) return;
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+ loader = new THREE.JSONLoader();
|
|
|
+ if (data.crossorigin) loader.crossOrigin = data.crossorigin;
|
|
|
+ loader.load(data.src, function (geometry, materials) {
|
|
|
+
|
|
|
+ // Attempt to automatically detect common material options.
|
|
|
+ materials.forEach(function (mat) {
|
|
|
+ mat.vertexColors = (geometry.faces[0] || {}).color ? THREE.FaceColors : THREE.NoColors;
|
|
|
+ mat.skinning = !!(geometry.bones || []).length;
|
|
|
+ mat.morphTargets = !!(geometry.morphTargets || []).length;
|
|
|
+ mat.morphNormals = !!(geometry.morphNormals || []).length;
|
|
|
+ });
|
|
|
+
|
|
|
+ var model = (geometry.bones || []).length ? new THREE.SkinnedMesh(geometry, new THREE.MultiMaterial(materials)) : new THREE.Mesh(geometry, new THREE.MultiMaterial(materials));
|
|
|
+
|
|
|
+ _this.load(model);
|
|
|
+ });
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function load(model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', { format: 'json', model: model });
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+},{}],10:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+/**
|
|
|
+ * object-model
|
|
|
+ *
|
|
|
+ * Loader for THREE.js JSON format. Somewhat confusingly, there are two different THREE.js formats,
|
|
|
+ * both having the .json extension. This loader supports only THREE.ObjectLoader, which typically
|
|
|
+ * includes multiple meshes or an entire scene.
|
|
|
+ *
|
|
|
+ * Check the console for errors, if in doubt. You may need to use `json-model` or
|
|
|
+ * `blend-character-model` for some .js and .json files.
|
|
|
+ *
|
|
|
+ * See: https://clara.io/learn/user-guide/data_exchange/threejs_export
|
|
|
+ */
|
|
|
+
|
|
|
+module.exports = AFRAME.registerComponent('object-model', {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update() {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ var loader = void 0;
|
|
|
+ var data = this.data;
|
|
|
+ if (!data.src) return;
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+ loader = new THREE.ObjectLoader();
|
|
|
+ if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
|
|
|
+ loader.load(data.src, function (object) {
|
|
|
+
|
|
|
+ // Enable skinning, if applicable.
|
|
|
+ object.traverse(function (o) {
|
|
|
+ if (o instanceof THREE.SkinnedMesh && o.material) {
|
|
|
+ o.material.skinning = !!(o.geometry && o.geometry.bones || []).length;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ _this.load(object);
|
|
|
+ });
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function load(model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', { format: 'json', model: model });
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+},{}],11:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+/**
|
|
|
+ * ply-model
|
|
|
+ *
|
|
|
+ * Wraps THREE.PLYLoader.
|
|
|
+ */
|
|
|
+
|
|
|
+THREE.PLYLoader = require('../../lib/PLYLoader');
|
|
|
+
|
|
|
+/**
|
|
|
+ * Loads, caches, resolves geometries.
|
|
|
+ *
|
|
|
+ * @member cache - Promises that resolve geometries keyed by `src`.
|
|
|
+ */
|
|
|
+module.exports.System = AFRAME.registerSystem('ply-model', {
|
|
|
+ init: function init() {
|
|
|
+ this.cache = {};
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @returns {Promise}
|
|
|
+ */
|
|
|
+ getOrLoadGeometry: function getOrLoadGeometry(src, skipCache) {
|
|
|
+ var cache = this.cache;
|
|
|
+ var cacheItem = cache[src];
|
|
|
+
|
|
|
+ if (!skipCache && cacheItem) {
|
|
|
+ return cacheItem;
|
|
|
+ }
|
|
|
+
|
|
|
+ cache[src] = new Promise(function (resolve) {
|
|
|
+ var loader = new THREE.PLYLoader();
|
|
|
+ loader.load(src, function (geometry) {
|
|
|
+ resolve(geometry);
|
|
|
+ });
|
|
|
+ });
|
|
|
+ return cache[src];
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+module.exports.Component = AFRAME.registerComponent('ply-model', {
|
|
|
+ schema: {
|
|
|
+ skipCache: { type: 'boolean', default: false },
|
|
|
+ src: { type: 'asset' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function init() {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function update() {
|
|
|
+ var data = this.data;
|
|
|
+ var el = this.el;
|
|
|
+
|
|
|
+ if (!data.src) {
|
|
|
+ console.warn('[%s] `src` property is required.', this.name);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Get geometry from system, create and set mesh.
|
|
|
+ this.system.getOrLoadGeometry(data.src, data.skipCache).then(function (geometry) {
|
|
|
+ var model = createModel(geometry);
|
|
|
+ el.setObject3D('mesh', model);
|
|
|
+ el.emit('model-loaded', { format: 'ply', model: model });
|
|
|
+ });
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function remove() {
|
|
|
+ if (this.model) {
|
|
|
+ this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+function createModel(geometry) {
|
|
|
+ return new THREE.Mesh(geometry, new THREE.MeshPhongMaterial({
|
|
|
+ color: 0xFFFFFF,
|
|
|
+ shading: THREE.FlatShading,
|
|
|
+ vertexColors: THREE.VertexColors,
|
|
|
+ shininess: 0
|
|
|
+ }));
|
|
|
+}
|
|
|
+
|
|
|
+},{"../../lib/PLYLoader":3}]},{},[1]);
|
