|
|
@@ -0,0 +1,6369 @@
|
|
|
+(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){
|
|
|
+require('./src/loaders').registerAll();
|
|
|
+},{"./src/loaders":9}],2:[function(require,module,exports){
|
|
|
+/**
|
|
|
+ * @author Kyle-Larson https://github.com/Kyle-Larson
|
|
|
+ * @author Takahiro https://github.com/takahirox
|
|
|
+ *
|
|
|
+ * 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:
|
|
|
+ * Indexed Buffers
|
|
|
+ * PreRotation support.
|
|
|
+ */
|
|
|
+
|
|
|
+( function () {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a loader for loading FBX files from URL and parsing into
|
|
|
+ * a THREE.Group.
|
|
|
+ * @param {THREE.LoadingManager} manager - Loading Manager for loader to use.
|
|
|
+ */
|
|
|
+ module.exports = THREE.FBXLoader = function ( manager ) {
|
|
|
+
|
|
|
+ this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ Object.assign( THREE.FBXLoader.prototype, {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Loads an ASCII/Binary FBX file from URL and parses into a THREE.Group.
|
|
|
+ * THREE.Group will have an animations property of AnimationClips
|
|
|
+ * of the different animations exported with the FBX.
|
|
|
+ * @param {string} url - URL of the FBX file.
|
|
|
+ * @param {function(THREE.Group):void} onLoad - Callback for when FBX file is loaded and parsed.
|
|
|
+ * @param {function(ProgressEvent):void} onProgress - Callback fired periodically when file is being retrieved from server.
|
|
|
+ * @param {function(Event):void} onError - Callback fired when error occurs (Currently only with retrieving file, not with parsing errors).
|
|
|
+ */
|
|
|
+ load: function ( url, onLoad, onProgress, onError ) {
|
|
|
+
|
|
|
+ var self = this;
|
|
|
+
|
|
|
+ var resourceDirectory = THREE.Loader.prototype.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 );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses an ASCII/Binary FBX file and returns a THREE.Group.
|
|
|
+ * THREE.Group will have an animations property of AnimationClips
|
|
|
+ * of the different animations within the FBX file.
|
|
|
+ * @param {ArrayBuffer} FBXBuffer - Contents of FBX file to parse.
|
|
|
+ * @param {string} resourceDirectory - Directory to load external assets (e.g. textures ) from.
|
|
|
+ * @returns {THREE.Group}
|
|
|
+ */
|
|
|
+ parse: function ( 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 deformers = parseDeformers( FBXTree, connections );
|
|
|
+ var geometryMap = parseGeometries( FBXTree, connections, deformers );
|
|
|
+ var sceneGraph = parseScene( FBXTree, connections, deformers, geometryMap, materials );
|
|
|
+
|
|
|
+ return sceneGraph;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses map of relationships between objects.
|
|
|
+ * @param {{Connections: { properties: { connections: [number, number, string][]}}}} FBXTree
|
|
|
+ * @returns {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>}
|
|
|
+ */
|
|
|
+ function parseConnections( FBXTree ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Map<number, { parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>}
|
|
|
+ */
|
|
|
+ var connectionMap = new Map();
|
|
|
+
|
|
|
+ if ( 'Connections' in FBXTree ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {[number, number, string][]}
|
|
|
+ */
|
|
|
+ var connectionArray = FBXTree.Connections.properties.connections;
|
|
|
+ for ( var connectionArrayIndex = 0, connectionArrayLength = connectionArray.length; connectionArrayIndex < connectionArrayLength; ++ connectionArrayIndex ) {
|
|
|
+
|
|
|
+ var connection = connectionArray[ connectionArrayIndex ];
|
|
|
+
|
|
|
+ if ( ! connectionMap.has( connection[ 0 ] ) ) {
|
|
|
+
|
|
|
+ connectionMap.set( connection[ 0 ], {
|
|
|
+ parents: [],
|
|
|
+ children: []
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var parentRelationship = { ID: connection[ 1 ], relationship: connection[ 2 ] };
|
|
|
+ connectionMap.get( connection[ 0 ] ).parents.push( parentRelationship );
|
|
|
+
|
|
|
+ if ( ! connectionMap.has( connection[ 1 ] ) ) {
|
|
|
+
|
|
|
+ connectionMap.set( connection[ 1 ], {
|
|
|
+ parents: [],
|
|
|
+ children: []
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var childRelationship = { ID: connection[ 0 ], relationship: connection[ 2 ] };
|
|
|
+ connectionMap.get( connection[ 1 ] ).children.push( childRelationship );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return connectionMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses map of images referenced in FBXTree.
|
|
|
+ * @param {{Objects: {subNodes: {Texture: Object.<string, FBXTextureNode>}}}} FBXTree
|
|
|
+ * @returns {Map<number, string(image blob/data URL)>}
|
|
|
+ */
|
|
|
+ function parseImages( FBXTree ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Map<number, string(image blob/data URL)>}
|
|
|
+ */
|
|
|
+ var imageMap = new Map();
|
|
|
+
|
|
|
+ if ( 'Video' in FBXTree.Objects.subNodes ) {
|
|
|
+
|
|
|
+ var videoNodes = FBXTree.Objects.subNodes.Video;
|
|
|
+
|
|
|
+ for ( var nodeID in videoNodes ) {
|
|
|
+
|
|
|
+ var videoNode = videoNodes[ nodeID ];
|
|
|
+
|
|
|
+ // raw image data is in videoNode.properties.Content
|
|
|
+ if ( 'Content' in videoNode.properties ) {
|
|
|
+
|
|
|
+ var image = parseImage( videoNodes[ nodeID ] );
|
|
|
+ imageMap.set( parseInt( nodeID ), image );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return imageMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {videoNode} videoNode - Node to get texture image information from.
|
|
|
+ * @returns {string} - image blob/data URL
|
|
|
+ */
|
|
|
+ function parseImage( videoNode ) {
|
|
|
+
|
|
|
+ var content = videoNode.properties.Content;
|
|
|
+ var fileName = videoNode.properties.RelativeFilename || videoNode.properties.Filename;
|
|
|
+ var extension = fileName.slice( fileName.lastIndexOf( '.' ) + 1 ).toLowerCase();
|
|
|
+
|
|
|
+ var type;
|
|
|
+
|
|
|
+ switch ( extension ) {
|
|
|
+
|
|
|
+ case 'bmp':
|
|
|
+
|
|
|
+ type = 'image/bmp';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'jpg':
|
|
|
+
|
|
|
+ type = 'image/jpeg';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'png':
|
|
|
+
|
|
|
+ type = 'image/png';
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'tif':
|
|
|
+
|
|
|
+ type = 'image/tiff';
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+
|
|
|
+ console.warn( 'FBXLoader: No support image type ' + extension );
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( typeof content === 'string' ) {
|
|
|
+
|
|
|
+ return 'data:' + type + ';base64,' + content;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var array = new Uint8Array( content );
|
|
|
+ return window.URL.createObjectURL( new Blob( [ array ], { type: type } ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses map of textures referenced in FBXTree.
|
|
|
+ * @param {{Objects: {subNodes: {Texture: Object.<string, FBXTextureNode>}}}} FBXTree
|
|
|
+ * @param {THREE.TextureLoader} loader
|
|
|
+ * @param {Map<number, string(image blob/data URL)>} imageMap
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @returns {Map<number, THREE.Texture>}
|
|
|
+ */
|
|
|
+ function parseTextures( FBXTree, loader, imageMap, connections ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Map<number, THREE.Texture>}
|
|
|
+ */
|
|
|
+ var textureMap = new Map();
|
|
|
+
|
|
|
+ if ( 'Texture' in FBXTree.Objects.subNodes ) {
|
|
|
+
|
|
|
+ var textureNodes = FBXTree.Objects.subNodes.Texture;
|
|
|
+ for ( var nodeID in textureNodes ) {
|
|
|
+
|
|
|
+ var texture = parseTexture( textureNodes[ nodeID ], loader, imageMap, connections );
|
|
|
+ textureMap.set( parseInt( nodeID ), texture );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return textureMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {textureNode} textureNode - Node to get texture information from.
|
|
|
+ * @param {THREE.TextureLoader} loader
|
|
|
+ * @param {Map<number, string(image blob/data URL)>} imageMap
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @returns {THREE.Texture}
|
|
|
+ */
|
|
|
+ function parseTexture( textureNode, loader, imageMap, connections ) {
|
|
|
+
|
|
|
+ var FBX_ID = textureNode.id;
|
|
|
+
|
|
|
+ var name = textureNode.name;
|
|
|
+
|
|
|
+ var fileName;
|
|
|
+
|
|
|
+ var filePath = textureNode.properties.FileName;
|
|
|
+ var relativeFilePath = textureNode.properties.RelativeFilename;
|
|
|
+
|
|
|
+ var children = connections.get( FBX_ID ).children;
|
|
|
+
|
|
|
+ if ( children !== undefined && children.length > 0 && imageMap.has( children[ 0 ].ID ) ) {
|
|
|
+
|
|
|
+ fileName = imageMap.get( children[ 0 ].ID );
|
|
|
+
|
|
|
+ } else if ( relativeFilePath !== undefined && relativeFilePath[ 0 ] !== '/' &&
|
|
|
+ relativeFilePath.match( /^[a-zA-Z]:/ ) === null ) {
|
|
|
+
|
|
|
+ // use textureNode.properties.RelativeFilename
|
|
|
+ // if it exists and it doesn't seem an absolute path
|
|
|
+
|
|
|
+ fileName = relativeFilePath;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var split = filePath.split( /[\\\/]/ );
|
|
|
+
|
|
|
+ if ( split.length > 0 ) {
|
|
|
+
|
|
|
+ fileName = split[ split.length - 1 ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ fileName = filePath;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var currentPath = loader.path;
|
|
|
+
|
|
|
+ if ( fileName.indexOf( 'blob:' ) === 0 || fileName.indexOf( 'data:' ) === 0 ) {
|
|
|
+
|
|
|
+ loader.setPath( undefined );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {THREE.Texture}
|
|
|
+ */
|
|
|
+ var texture = loader.load( fileName );
|
|
|
+ texture.name = name;
|
|
|
+ texture.FBX_ID = FBX_ID;
|
|
|
+
|
|
|
+ var wrapModeU = textureNode.properties.WrapModeU;
|
|
|
+ var wrapModeV = textureNode.properties.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;
|
|
|
+
|
|
|
+ loader.setPath( currentPath );
|
|
|
+
|
|
|
+ return texture;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses map of Material information.
|
|
|
+ * @param {{Objects: {subNodes: {Material: Object.<number, FBXMaterialNode>}}}} FBXTree
|
|
|
+ * @param {Map<number, THREE.Texture>} textureMap
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @returns {Map<number, THREE.Material>}
|
|
|
+ */
|
|
|
+ function parseMaterials( FBXTree, textureMap, connections ) {
|
|
|
+
|
|
|
+ var materialMap = new Map();
|
|
|
+
|
|
|
+ if ( 'Material' in FBXTree.Objects.subNodes ) {
|
|
|
+
|
|
|
+ var materialNodes = FBXTree.Objects.subNodes.Material;
|
|
|
+ for ( var nodeID in materialNodes ) {
|
|
|
+
|
|
|
+ var material = parseMaterial( materialNodes[ nodeID ], textureMap, connections );
|
|
|
+ if ( material !== null ) materialMap.set( parseInt( nodeID ), material );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return materialMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Takes information from Material node and returns a generated THREE.Material
|
|
|
+ * @param {FBXMaterialNode} materialNode
|
|
|
+ * @param {Map<number, THREE.Texture>} textureMap
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @returns {THREE.Material}
|
|
|
+ */
|
|
|
+ function parseMaterial( materialNode, textureMap, connections ) {
|
|
|
+
|
|
|
+ var FBX_ID = materialNode.id;
|
|
|
+ var name = materialNode.attrName;
|
|
|
+ var type = materialNode.properties.ShadingModel;
|
|
|
+
|
|
|
+ //Case where FBXs wrap shading model in property object.
|
|
|
+ if ( typeof type === 'object' ) {
|
|
|
+
|
|
|
+ type = type.value;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Seems like FBX can include unused materials which don't have any connections.
|
|
|
+ // Ignores them so far.
|
|
|
+ if ( ! connections.has( FBX_ID ) ) return null;
|
|
|
+
|
|
|
+ var children = connections.get( FBX_ID ).children;
|
|
|
+
|
|
|
+ var parameters = parseParameters( materialNode.properties, textureMap, children );
|
|
|
+
|
|
|
+ var material;
|
|
|
+
|
|
|
+ switch ( type.toLowerCase() ) {
|
|
|
+
|
|
|
+ case 'phong':
|
|
|
+ material = new THREE.MeshPhongMaterial();
|
|
|
+ break;
|
|
|
+ case 'lambert':
|
|
|
+ material = new THREE.MeshLambertMaterial();
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ console.warn( 'THREE.FBXLoader: No implementation given for material type %s in FBXLoader.js. Defaulting to standard material.', type );
|
|
|
+ material = new THREE.MeshStandardMaterial( { color: 0x3300ff } );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ material.setValues( parameters );
|
|
|
+ material.name = name;
|
|
|
+
|
|
|
+ return material;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @typedef {{Diffuse: FBXVector3, Specular: FBXVector3, Shininess: FBXValue, Emissive: FBXVector3, EmissiveFactor: FBXValue, Opacity: FBXValue}} FBXMaterialProperties
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{color: THREE.Color=, specular: THREE.Color=, shininess: number=, emissive: THREE.Color=, emissiveIntensity: number=, opacity: number=, transparent: boolean=, map: THREE.Texture=}} THREEMaterialParameterPack
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @param {FBXMaterialProperties} properties
|
|
|
+ * @param {Map<number, THREE.Texture>} textureMap
|
|
|
+ * @param {{ID: number, relationship: string}[]} childrenRelationships
|
|
|
+ * @returns {THREEMaterialParameterPack}
|
|
|
+ */
|
|
|
+ function parseParameters( properties, textureMap, childrenRelationships ) {
|
|
|
+
|
|
|
+ var parameters = {};
|
|
|
+
|
|
|
+ if ( properties.Diffuse ) {
|
|
|
+
|
|
|
+ parameters.color = parseColor( properties.Diffuse );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( properties.Specular ) {
|
|
|
+
|
|
|
+ parameters.specular = parseColor( properties.Specular );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( properties.Shininess ) {
|
|
|
+
|
|
|
+ parameters.shininess = properties.Shininess.value;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( properties.Emissive ) {
|
|
|
+
|
|
|
+ parameters.emissive = parseColor( properties.Emissive );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( properties.EmissiveFactor ) {
|
|
|
+
|
|
|
+ parameters.emissiveIntensity = properties.EmissiveFactor.value;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( properties.Opacity ) {
|
|
|
+
|
|
|
+ parameters.opacity = properties.Opacity.value;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( parameters.opacity < 1.0 ) {
|
|
|
+
|
|
|
+ parameters.transparent = true;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var childrenRelationshipsIndex = 0, childrenRelationshipsLength = childrenRelationships.length; childrenRelationshipsIndex < childrenRelationshipsLength; ++ childrenRelationshipsIndex ) {
|
|
|
+
|
|
|
+ var relationship = childrenRelationships[ childrenRelationshipsIndex ];
|
|
|
+
|
|
|
+ var type = relationship.relationship;
|
|
|
+
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case 'DiffuseColor':
|
|
|
+ case ' "DiffuseColor':
|
|
|
+ parameters.map = textureMap.get( relationship.ID );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'Bump':
|
|
|
+ case ' "Bump':
|
|
|
+ parameters.bumpMap = textureMap.get( relationship.ID );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NormalMap':
|
|
|
+ case ' "NormalMap':
|
|
|
+ parameters.normalMap = textureMap.get( relationship.ID );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'AmbientColor':
|
|
|
+ case 'EmissiveColor':
|
|
|
+ case ' "AmbientColor':
|
|
|
+ case ' "EmissiveColor':
|
|
|
+ default:
|
|
|
+ console.warn( 'THREE.FBXLoader: Unknown texture application of type %s, skipping texture.', type );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return parameters;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates map of Skeleton-like objects for use later when generating and binding skeletons.
|
|
|
+ * @param {{Objects: {subNodes: {Deformer: Object.<number, FBXSubDeformerNode>}}}} FBXTree
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @returns {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}>}
|
|
|
+ */
|
|
|
+ function parseDeformers( FBXTree, connections ) {
|
|
|
+
|
|
|
+ var deformers = {};
|
|
|
+
|
|
|
+ if ( 'Deformer' in FBXTree.Objects.subNodes ) {
|
|
|
+
|
|
|
+ var DeformerNodes = FBXTree.Objects.subNodes.Deformer;
|
|
|
+
|
|
|
+ for ( var nodeID in DeformerNodes ) {
|
|
|
+
|
|
|
+ var deformerNode = DeformerNodes[ nodeID ];
|
|
|
+
|
|
|
+ if ( deformerNode.attrType === 'Skin' ) {
|
|
|
+
|
|
|
+ var conns = connections.get( parseInt( nodeID ) );
|
|
|
+ var skeleton = parseSkeleton( conns, DeformerNodes );
|
|
|
+ skeleton.FBX_ID = parseInt( nodeID );
|
|
|
+
|
|
|
+ deformers[ nodeID ] = skeleton;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return deformers;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a "Skeleton Representation" of FBX nodes based on an FBX Skin Deformer's connections and an object containing SubDeformer nodes.
|
|
|
+ * @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} connections
|
|
|
+ * @param {Object.<number, FBXSubDeformerNode>} DeformerNodes
|
|
|
+ * @returns {{map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}}
|
|
|
+ */
|
|
|
+ function parseSkeleton( connections, DeformerNodes ) {
|
|
|
+
|
|
|
+ var subDeformers = {};
|
|
|
+ var children = connections.children;
|
|
|
+
|
|
|
+ for ( var i = 0, l = children.length; i < l; ++ i ) {
|
|
|
+
|
|
|
+ var child = children[ i ];
|
|
|
+
|
|
|
+ var subDeformerNode = DeformerNodes[ child.ID ];
|
|
|
+
|
|
|
+ var subDeformer = {
|
|
|
+ FBX_ID: child.ID,
|
|
|
+ index: i,
|
|
|
+ indices: [],
|
|
|
+ weights: [],
|
|
|
+ transform: parseMatrixArray( subDeformerNode.subNodes.Transform.properties.a ),
|
|
|
+ transformLink: parseMatrixArray( subDeformerNode.subNodes.TransformLink.properties.a ),
|
|
|
+ linkMode: subDeformerNode.properties.Mode
|
|
|
+ };
|
|
|
+
|
|
|
+ if ( 'Indexes' in subDeformerNode.subNodes ) {
|
|
|
+
|
|
|
+ subDeformer.indices = parseIntArray( subDeformerNode.subNodes.Indexes.properties.a );
|
|
|
+ subDeformer.weights = parseFloatArray( subDeformerNode.subNodes.Weights.properties.a );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ subDeformers[ child.ID ] = subDeformer;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ map: subDeformers,
|
|
|
+ bones: []
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates Buffer geometries from geometry information in FBXTree, and generates map of THREE.BufferGeometries
|
|
|
+ * @param {{Objects: {subNodes: {Geometry: Object.<number, FBXGeometryNode}}}} FBXTree
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}>} deformers
|
|
|
+ * @returns {Map<number, THREE.BufferGeometry>}
|
|
|
+ */
|
|
|
+ function parseGeometries( FBXTree, connections, deformers ) {
|
|
|
+
|
|
|
+ var geometryMap = new Map();
|
|
|
+
|
|
|
+ if ( 'Geometry' in FBXTree.Objects.subNodes ) {
|
|
|
+
|
|
|
+ var geometryNodes = FBXTree.Objects.subNodes.Geometry;
|
|
|
+
|
|
|
+ for ( var nodeID in geometryNodes ) {
|
|
|
+
|
|
|
+ var relationships = connections.get( parseInt( nodeID ) );
|
|
|
+ var geo = parseGeometry( geometryNodes[ nodeID ], relationships, deformers );
|
|
|
+ geometryMap.set( parseInt( nodeID ), geo );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return geometryMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates BufferGeometry from FBXGeometryNode.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships
|
|
|
+ * @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}>} deformers
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ function parseGeometry( geometryNode, relationships, deformers ) {
|
|
|
+
|
|
|
+ switch ( geometryNode.attrType ) {
|
|
|
+
|
|
|
+ case 'Mesh':
|
|
|
+ return parseMeshGeometry( geometryNode, relationships, deformers );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NurbsCurve':
|
|
|
+ return parseNurbsGeometry( geometryNode );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Specialty function for parsing Mesh based Geometry Nodes.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships - Object representing relationships between specific geometry node and other nodes.
|
|
|
+ * @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}>} deformers - Map object of deformers and subDeformers by ID.
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ function parseMeshGeometry( geometryNode, relationships, deformers ) {
|
|
|
+
|
|
|
+ for ( var i = 0; i < relationships.children.length; ++ i ) {
|
|
|
+
|
|
|
+ var deformer = deformers[ relationships.children[ i ].ID ];
|
|
|
+ if ( deformer !== undefined ) break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return genGeometry( geometryNode, deformer );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {{map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}} deformer - Skeleton representation for geometry instance.
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ function genGeometry( geometryNode, deformer ) {
|
|
|
+
|
|
|
+ var geometry = new Geometry();
|
|
|
+
|
|
|
+ var subNodes = geometryNode.subNodes;
|
|
|
+
|
|
|
+ // First, each index is going to be its own vertex.
|
|
|
+
|
|
|
+ var vertexBuffer = parseFloatArray( subNodes.Vertices.properties.a );
|
|
|
+ var indexBuffer = parseIntArray( subNodes.PolygonVertexIndex.properties.a );
|
|
|
+
|
|
|
+ if ( subNodes.LayerElementNormal ) {
|
|
|
+
|
|
|
+ var normalInfo = getNormals( subNodes.LayerElementNormal[ 0 ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( subNodes.LayerElementUV ) {
|
|
|
+
|
|
|
+ var uvInfo = getUVs( subNodes.LayerElementUV[ 0 ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( subNodes.LayerElementColor ) {
|
|
|
+
|
|
|
+ var colorInfo = getColors( subNodes.LayerElementColor[ 0 ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( subNodes.LayerElementMaterial ) {
|
|
|
+
|
|
|
+ var materialInfo = getMaterials( subNodes.LayerElementMaterial[ 0 ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var weightTable = {};
|
|
|
+
|
|
|
+ if ( deformer ) {
|
|
|
+
|
|
|
+ var subDeformers = deformer.map;
|
|
|
+
|
|
|
+ for ( var key in subDeformers ) {
|
|
|
+
|
|
|
+ var subDeformer = subDeformers[ key ];
|
|
|
+ var indices = subDeformer.indices;
|
|
|
+
|
|
|
+ for ( var j = 0; j < indices.length; j ++ ) {
|
|
|
+
|
|
|
+ var index = indices[ j ];
|
|
|
+ var weight = subDeformer.weights[ j ];
|
|
|
+
|
|
|
+ if ( weightTable[ index ] === undefined ) weightTable[ index ] = [];
|
|
|
+
|
|
|
+ weightTable[ index ].push( {
|
|
|
+ id: subDeformer.index,
|
|
|
+ weight: weight
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var faceVertexBuffer = [];
|
|
|
+ var polygonIndex = 0;
|
|
|
+ var displayedWeightsWarning = false;
|
|
|
+
|
|
|
+ for ( var polygonVertexIndex = 0; polygonVertexIndex < indexBuffer.length; polygonVertexIndex ++ ) {
|
|
|
+
|
|
|
+ var vertexIndex = indexBuffer[ polygonVertexIndex ];
|
|
|
+
|
|
|
+ var endOfFace = false;
|
|
|
+
|
|
|
+ if ( vertexIndex < 0 ) {
|
|
|
+
|
|
|
+ vertexIndex = vertexIndex ^ - 1;
|
|
|
+ indexBuffer[ polygonVertexIndex ] = vertexIndex;
|
|
|
+ endOfFace = true;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var vertex = new Vertex();
|
|
|
+ var weightIndices = [];
|
|
|
+ var weights = [];
|
|
|
+
|
|
|
+ vertex.position.fromArray( vertexBuffer, vertexIndex * 3 );
|
|
|
+
|
|
|
+ if ( deformer ) {
|
|
|
+
|
|
|
+ if ( weightTable[ vertexIndex ] !== undefined ) {
|
|
|
+
|
|
|
+ var array = weightTable[ vertexIndex ];
|
|
|
+
|
|
|
+ for ( var j = 0, jl = array.length; j < jl; j ++ ) {
|
|
|
+
|
|
|
+ weights.push( array[ j ].weight );
|
|
|
+ weightIndices.push( array[ j ].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;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var i = weights.length; i < 4; ++ i ) {
|
|
|
+
|
|
|
+ weights[ i ] = 0;
|
|
|
+ weightIndices[ i ] = 0;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ vertex.skinWeights.fromArray( weights );
|
|
|
+ vertex.skinIndices.fromArray( weightIndices );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( normalInfo ) {
|
|
|
+
|
|
|
+ vertex.normal.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, normalInfo ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( uvInfo ) {
|
|
|
+
|
|
|
+ vertex.uv.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, uvInfo ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( colorInfo ) {
|
|
|
+
|
|
|
+ vertex.color.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, colorInfo ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ faceVertexBuffer.push( vertex );
|
|
|
+
|
|
|
+ if ( endOfFace ) {
|
|
|
+
|
|
|
+ var face = new Face();
|
|
|
+ face.genTrianglesFromVertices( faceVertexBuffer );
|
|
|
+
|
|
|
+ if ( materialInfo !== undefined ) {
|
|
|
+
|
|
|
+ var materials = getData( polygonVertexIndex, polygonIndex, vertexIndex, materialInfo );
|
|
|
+ face.materialIndex = materials[ 0 ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // Seems like some models don't have materialInfo(subNodes.LayerElementMaterial).
|
|
|
+ // Set 0 in such a case.
|
|
|
+ face.materialIndex = 0;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ geometry.faces.push( face );
|
|
|
+ faceVertexBuffer = [];
|
|
|
+ polygonIndex ++;
|
|
|
+
|
|
|
+ endOfFace = false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{vertexBuffer: number[], normalBuffer: number[], uvBuffer: number[], skinIndexBuffer: number[], skinWeightBuffer: number[], materialIndexBuffer: number[]}}
|
|
|
+ */
|
|
|
+ var bufferInfo = geometry.flattenToBuffers();
|
|
|
+
|
|
|
+ var geo = new THREE.BufferGeometry();
|
|
|
+ geo.name = geometryNode.name;
|
|
|
+ geo.addAttribute( 'position', new THREE.Float32BufferAttribute( bufferInfo.vertexBuffer, 3 ) );
|
|
|
+
|
|
|
+ if ( bufferInfo.normalBuffer.length > 0 ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'normal', new THREE.Float32BufferAttribute( bufferInfo.normalBuffer, 3 ) );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( bufferInfo.uvBuffer.length > 0 ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'uv', new THREE.Float32BufferAttribute( bufferInfo.uvBuffer, 2 ) );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( subNodes.LayerElementColor ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'color', new THREE.Float32BufferAttribute( bufferInfo.colorBuffer, 3 ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( deformer ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'skinIndex', new THREE.Float32BufferAttribute( bufferInfo.skinIndexBuffer, 4 ) );
|
|
|
+
|
|
|
+ geo.addAttribute( 'skinWeight', new THREE.Float32BufferAttribute( bufferInfo.skinWeightBuffer, 4 ) );
|
|
|
+
|
|
|
+ geo.FBX_Deformer = deformer;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Convert the material indices of each vertex into rendering groups on the geometry.
|
|
|
+
|
|
|
+ var materialIndexBuffer = bufferInfo.materialIndexBuffer;
|
|
|
+ var prevMaterialIndex = materialIndexBuffer[ 0 ];
|
|
|
+ var startIndex = 0;
|
|
|
+
|
|
|
+ for ( var i = 0; i < materialIndexBuffer.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( materialIndexBuffer[ i ] !== prevMaterialIndex ) {
|
|
|
+
|
|
|
+ geo.addGroup( startIndex, i - startIndex, prevMaterialIndex );
|
|
|
+
|
|
|
+ prevMaterialIndex = materialIndexBuffer[ i ];
|
|
|
+ startIndex = i;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return geo;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses normal information for geometry.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getNormals( NormalNode ) {
|
|
|
+
|
|
|
+ var mappingType = NormalNode.properties.MappingInformationType;
|
|
|
+ var referenceType = NormalNode.properties.ReferenceInformationType;
|
|
|
+ var buffer = parseFloatArray( NormalNode.subNodes.Normals.properties.a );
|
|
|
+ var indexBuffer = [];
|
|
|
+ if ( referenceType === 'IndexToDirect' ) {
|
|
|
+
|
|
|
+ if ( 'NormalIndex' in NormalNode.subNodes ) {
|
|
|
+
|
|
|
+ indexBuffer = parseIntArray( NormalNode.subNodes.NormalIndex.properties.a );
|
|
|
+
|
|
|
+ } else if ( 'NormalsIndex' in NormalNode.subNodes ) {
|
|
|
+
|
|
|
+ indexBuffer = parseIntArray( NormalNode.subNodes.NormalsIndex.properties.a );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 3,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses UV information for geometry.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getUVs( UVNode ) {
|
|
|
+
|
|
|
+ var mappingType = UVNode.properties.MappingInformationType;
|
|
|
+ var referenceType = UVNode.properties.ReferenceInformationType;
|
|
|
+ var buffer = parseFloatArray( UVNode.subNodes.UV.properties.a );
|
|
|
+ var indexBuffer = [];
|
|
|
+ if ( referenceType === 'IndexToDirect' ) {
|
|
|
+
|
|
|
+ indexBuffer = parseIntArray( UVNode.subNodes.UVIndex.properties.a );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 2,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses Vertex Color information for geometry.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getColors( ColorNode ) {
|
|
|
+
|
|
|
+ var mappingType = ColorNode.properties.MappingInformationType;
|
|
|
+ var referenceType = ColorNode.properties.ReferenceInformationType;
|
|
|
+ var buffer = parseFloatArray( ColorNode.subNodes.Colors.properties.a );
|
|
|
+ var indexBuffer = [];
|
|
|
+ if ( referenceType === 'IndexToDirect' ) {
|
|
|
+
|
|
|
+ indexBuffer = parseFloatArray( ColorNode.subNodes.ColorIndex.properties.a );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 4,
|
|
|
+ buffer: buffer,
|
|
|
+ indices: indexBuffer,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses material application information for geometry.
|
|
|
+ * @param {FBXGeometryNode}
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getMaterials( MaterialNode ) {
|
|
|
+
|
|
|
+ var mappingType = MaterialNode.properties.MappingInformationType;
|
|
|
+ var referenceType = MaterialNode.properties.ReferenceInformationType;
|
|
|
+
|
|
|
+ if ( mappingType === 'NoMappingInformation' ) {
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 1,
|
|
|
+ buffer: [ 0 ],
|
|
|
+ indices: [ 0 ],
|
|
|
+ mappingType: 'AllSame',
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var materialIndexBuffer = parseIntArray( MaterialNode.subNodes.Materials.properties.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 materialIndexBufferIndex = 0, materialIndexBufferLength = materialIndexBuffer.length; materialIndexBufferIndex < materialIndexBufferLength; ++ materialIndexBufferIndex ) {
|
|
|
+
|
|
|
+ materialIndices.push( materialIndexBufferIndex );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ dataSize: 1,
|
|
|
+ buffer: materialIndexBuffer,
|
|
|
+ indices: materialIndices,
|
|
|
+ mappingType: mappingType,
|
|
|
+ referenceType: referenceType
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+
|
|
|
+ var dataArray = [];
|
|
|
+
|
|
|
+ var GetData = {
|
|
|
+
|
|
|
+ ByPolygonVertex: {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var from = ( polygonVertexIndex * infoObject.dataSize );
|
|
|
+ var to = ( polygonVertexIndex * infoObject.dataSize ) + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var index = infoObject.indices[ polygonVertexIndex ];
|
|
|
+ var from = ( index * infoObject.dataSize );
|
|
|
+ var to = ( index * infoObject.dataSize ) + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ ByPolygon: {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var from = polygonIndex * infoObject.dataSize;
|
|
|
+ var to = polygonIndex * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var index = infoObject.indices[ polygonIndex ];
|
|
|
+ var from = index * infoObject.dataSize;
|
|
|
+ var to = index * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ ByVertice: {
|
|
|
+
|
|
|
+ Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var from = ( vertexIndex * infoObject.dataSize );
|
|
|
+ var to = ( vertexIndex * infoObject.dataSize ) + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ AllSame: {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Function uses the infoObject and given indices to return value array of object.
|
|
|
+ * @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
|
|
|
+ * @param {number} polygonIndex - Index of polygon in geometry.
|
|
|
+ * @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
|
|
|
+ * @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ var from = infoObject.indices[ 0 ] * infoObject.dataSize;
|
|
|
+ var to = infoObject.indices[ 0 ] * infoObject.dataSize + infoObject.dataSize;
|
|
|
+
|
|
|
+ // return infoObject.buffer.slice( from, to );
|
|
|
+ return slice( dataArray, infoObject.buffer, from, to );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ return GetData[ infoObject.mappingType ][ infoObject.referenceType ]( polygonVertexIndex, polygonIndex, vertexIndex, infoObject );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Specialty function for parsing NurbsCurve based Geometry Nodes.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ 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.properties.Order );
|
|
|
+
|
|
|
+ if ( isNaN( order ) ) {
|
|
|
+
|
|
|
+ console.error( 'THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geometryNode.properties.Order, geometryNode.id );
|
|
|
+ return new THREE.BufferGeometry();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var degree = order - 1;
|
|
|
+
|
|
|
+ var knots = parseFloatArray( geometryNode.subNodes.KnotVector.properties.a );
|
|
|
+ var controlPoints = [];
|
|
|
+ var pointsValues = parseFloatArray( geometryNode.subNodes.Points.properties.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.properties.Form === 'Closed' ) {
|
|
|
+
|
|
|
+ controlPoints.push( controlPoints[ 0 ] );
|
|
|
+
|
|
|
+ } else if ( geometryNode.properties.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 );
|
|
|
+
|
|
|
+ for ( var i = 0, l = vertices.length; i < l; ++ i ) {
|
|
|
+
|
|
|
+ vertices[ i ].toArray( positions, i * 3 );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var geometry = new THREE.BufferGeometry();
|
|
|
+ geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
|
|
|
+
|
|
|
+ return geometry;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Finally generates Scene graph and Scene graph Objects.
|
|
|
+ * @param {{Objects: {subNodes: {Model: Object.<number, FBXModelNode>}}}} FBXTree
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}>} deformers
|
|
|
+ * @param {Map<number, THREE.BufferGeometry>} geometryMap
|
|
|
+ * @param {Map<number, THREE.Material>} materialMap
|
|
|
+ * @returns {THREE.Group}
|
|
|
+ */
|
|
|
+ function parseScene( FBXTree, connections, deformers, geometryMap, materialMap ) {
|
|
|
+
|
|
|
+ var sceneGraph = new THREE.Group();
|
|
|
+
|
|
|
+ var ModelNode = FBXTree.Objects.subNodes.Model;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Array.<THREE.Object3D>}
|
|
|
+ */
|
|
|
+ var modelArray = [];
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Map.<number, THREE.Object3D>}
|
|
|
+ */
|
|
|
+ var modelMap = new Map();
|
|
|
+
|
|
|
+ for ( var nodeID in ModelNode ) {
|
|
|
+
|
|
|
+ var id = parseInt( nodeID );
|
|
|
+ var node = ModelNode[ nodeID ];
|
|
|
+ var conns = connections.get( id );
|
|
|
+ var model = null;
|
|
|
+
|
|
|
+ for ( var i = 0; i < conns.parents.length; ++ i ) {
|
|
|
+
|
|
|
+ for ( var FBX_ID in deformers ) {
|
|
|
+
|
|
|
+ var deformer = deformers[ FBX_ID ];
|
|
|
+ var subDeformers = deformer.map;
|
|
|
+ var subDeformer = subDeformers[ conns.parents[ i ].ID ];
|
|
|
+
|
|
|
+ if ( subDeformer ) {
|
|
|
+
|
|
|
+ var model2 = model;
|
|
|
+ model = new THREE.Bone();
|
|
|
+ deformer.bones[ subDeformer.index ] = model;
|
|
|
+
|
|
|
+ // seems like we need this not to make non-connected bone, maybe?
|
|
|
+ // TODO: confirm
|
|
|
+ if ( model2 !== null ) model.add( model2 );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( ! model ) {
|
|
|
+
|
|
|
+ switch ( node.attrType ) {
|
|
|
+
|
|
|
+ case 'Mesh':
|
|
|
+ /**
|
|
|
+ * @type {?THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ var geometry = null;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {THREE.MultiMaterial|THREE.Material}
|
|
|
+ */
|
|
|
+ var material = null;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Array.<THREE.Material>}
|
|
|
+ */
|
|
|
+ var materials = [];
|
|
|
+
|
|
|
+ for ( var childrenIndex = 0, childrenLength = conns.children.length; childrenIndex < childrenLength; ++ childrenIndex ) {
|
|
|
+
|
|
|
+ var child = conns.children[ childrenIndex ];
|
|
|
+
|
|
|
+ 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.MeshStandardMaterial( { color: 0x3300ff } );
|
|
|
+ materials.push( material );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( 'color' in geometry.attributes ) {
|
|
|
+
|
|
|
+ for ( var materialIndex = 0, numMaterials = materials.length; materialIndex < numMaterials; ++materialIndex ) {
|
|
|
+
|
|
|
+ materials[ materialIndex ].vertexColors = THREE.VertexColors;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( geometry.FBX_Deformer ) {
|
|
|
+
|
|
|
+ for ( var materialsIndex = 0, materialsLength = materials.length; materialsIndex < materialsLength; ++ materialsIndex ) {
|
|
|
+
|
|
|
+ materials[ materialsIndex ].skinning = true;
|
|
|
+
|
|
|
+ }
|
|
|
+ model = new THREE.SkinnedMesh( geometry, material );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ model = new THREE.Mesh( geometry, material );
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NurbsCurve':
|
|
|
+ var geometry = null;
|
|
|
+
|
|
|
+ for ( var childrenIndex = 0, childrenLength = conns.children.length; childrenIndex < childrenLength; ++ childrenIndex ) {
|
|
|
+
|
|
|
+ var child = conns.children[ childrenIndex ];
|
|
|
+
|
|
|
+ if ( geometryMap.has( child.ID ) ) {
|
|
|
+
|
|
|
+ geometry = geometryMap.get( child.ID );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // FBX does not list materials for Nurbs lines, so we'll just put our own in here.
|
|
|
+ material = new THREE.LineBasicMaterial( { color: 0x3300ff, linewidth: 5 } );
|
|
|
+ model = new THREE.Line( geometry, material );
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ model = new THREE.Object3D();
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ model.name = node.attrName.replace( /:/, '' ).replace( /_/, '' ).replace( /-/, '' );
|
|
|
+ model.FBX_ID = id;
|
|
|
+
|
|
|
+ modelArray.push( model );
|
|
|
+ modelMap.set( id, model );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var modelArrayIndex = 0, modelArrayLength = modelArray.length; modelArrayIndex < modelArrayLength; ++ modelArrayIndex ) {
|
|
|
+
|
|
|
+ var model = modelArray[ modelArrayIndex ];
|
|
|
+
|
|
|
+ var node = ModelNode[ model.FBX_ID ];
|
|
|
+
|
|
|
+ if ( 'Lcl_Translation' in node.properties ) {
|
|
|
+
|
|
|
+ model.position.fromArray( parseFloatArray( node.properties.Lcl_Translation.value ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'Lcl_Rotation' in node.properties ) {
|
|
|
+
|
|
|
+ var rotation = parseFloatArray( node.properties.Lcl_Rotation.value ).map( degreeToRadian );
|
|
|
+ rotation.push( 'ZYX' );
|
|
|
+ model.rotation.fromArray( rotation );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'Lcl_Scaling' in node.properties ) {
|
|
|
+
|
|
|
+ model.scale.fromArray( parseFloatArray( node.properties.Lcl_Scaling.value ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'PreRotation' in node.properties ) {
|
|
|
+
|
|
|
+ var preRotations = new THREE.Euler().setFromVector3( parseVector3( node.properties.PreRotation ).multiplyScalar( DEG2RAD ), 'ZYX' );
|
|
|
+ preRotations = new THREE.Quaternion().setFromEuler( preRotations );
|
|
|
+ var currentRotation = new THREE.Quaternion().setFromEuler( model.rotation );
|
|
|
+ preRotations.multiply( currentRotation );
|
|
|
+ model.rotation.setFromQuaternion( preRotations, 'ZYX' );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = connections.get( model.FBX_ID );
|
|
|
+ for ( var parentIndex = 0; parentIndex < conns.parents.length; parentIndex ++ ) {
|
|
|
+
|
|
|
+ var pIndex = findIndex( modelArray, function ( mod ) {
|
|
|
+
|
|
|
+ return mod.FBX_ID === conns.parents[ parentIndex ].ID;
|
|
|
+
|
|
|
+ } );
|
|
|
+ if ( pIndex > - 1 ) {
|
|
|
+
|
|
|
+ modelArray[ pIndex ].add( model );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( model.parent === null ) {
|
|
|
+
|
|
|
+ sceneGraph.add( model );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // Now with the bones created, we can update the skeletons and bind them to the skinned meshes.
|
|
|
+ sceneGraph.updateMatrixWorld( true );
|
|
|
+
|
|
|
+ // Put skeleton into bind pose.
|
|
|
+ var BindPoseNode = FBXTree.Objects.subNodes.Pose;
|
|
|
+ for ( var nodeID in BindPoseNode ) {
|
|
|
+
|
|
|
+ if ( BindPoseNode[ nodeID ].attrType === 'BindPose' ) {
|
|
|
+
|
|
|
+ BindPoseNode = BindPoseNode[ nodeID ];
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( BindPoseNode ) {
|
|
|
+
|
|
|
+ var PoseNode = BindPoseNode.subNodes.PoseNode;
|
|
|
+ var worldMatrices = new Map();
|
|
|
+
|
|
|
+ for ( var PoseNodeIndex = 0, PoseNodeLength = PoseNode.length; PoseNodeIndex < PoseNodeLength; ++ PoseNodeIndex ) {
|
|
|
+
|
|
|
+ var node = PoseNode[ PoseNodeIndex ];
|
|
|
+
|
|
|
+ var rawMatWrd = parseMatrixArray( node.subNodes.Matrix.properties.a );
|
|
|
+
|
|
|
+ worldMatrices.set( parseInt( node.id ), rawMatWrd );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var FBX_ID in deformers ) {
|
|
|
+
|
|
|
+ var deformer = deformers[ FBX_ID ];
|
|
|
+ var subDeformers = deformer.map;
|
|
|
+
|
|
|
+ for ( var key in subDeformers ) {
|
|
|
+
|
|
|
+ var subDeformer = subDeformers[ key ];
|
|
|
+ var subDeformerIndex = subDeformer.index;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {THREE.Bone}
|
|
|
+ */
|
|
|
+ var bone = deformer.bones[ subDeformerIndex ];
|
|
|
+ if ( ! worldMatrices.has( bone.FBX_ID ) ) {
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+ var mat = worldMatrices.get( bone.FBX_ID );
|
|
|
+ bone.matrixWorld.copy( mat );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Now that skeleton is in bind pose, bind to model.
|
|
|
+ deformer.skeleton = new THREE.Skeleton( deformer.bones );
|
|
|
+
|
|
|
+ var conns = connections.get( deformer.FBX_ID );
|
|
|
+ var parents = conns.parents;
|
|
|
+
|
|
|
+ for ( var parentsIndex = 0, parentsLength = parents.length; parentsIndex < parentsLength; ++ parentsIndex ) {
|
|
|
+
|
|
|
+ var parent = parents[ parentsIndex ];
|
|
|
+
|
|
|
+ if ( geometryMap.has( parent.ID ) ) {
|
|
|
+
|
|
|
+ var geoID = parent.ID;
|
|
|
+ var geoConns = connections.get( geoID );
|
|
|
+
|
|
|
+ for ( var i = 0; i < geoConns.parents.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( modelMap.has( geoConns.parents[ i ].ID ) ) {
|
|
|
+
|
|
|
+ var model = modelMap.get( geoConns.parents[ i ].ID );
|
|
|
+ //ASSERT model typeof SkinnedMesh
|
|
|
+ model.bind( deformer.skeleton, model.matrixWorld );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ //Skeleton is now bound, return objects to starting
|
|
|
+ //world positions.
|
|
|
+ sceneGraph.updateMatrixWorld( true );
|
|
|
+
|
|
|
+ // Silly hack with the animation parsing. We're gonna pretend the scene graph has a skeleton
|
|
|
+ // to attach animations to, since FBXs treat animations as animations for the entire scene,
|
|
|
+ // not just for individual objects.
|
|
|
+ sceneGraph.skeleton = {
|
|
|
+ bones: modelArray
|
|
|
+ };
|
|
|
+
|
|
|
+ var animations = parseAnimations( FBXTree, connections, sceneGraph );
|
|
|
+
|
|
|
+ addAnimations( sceneGraph, animations );
|
|
|
+
|
|
|
+ return sceneGraph;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses animation information from FBXTree and generates an AnimationInfoObject.
|
|
|
+ * @param {{Objects: {subNodes: {AnimationCurveNode: any, AnimationCurve: any, AnimationLayer: any, AnimationStack: any}}}} FBXTree
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ */
|
|
|
+ function parseAnimations( FBXTree, connections, sceneGraph ) {
|
|
|
+
|
|
|
+ var rawNodes = FBXTree.Objects.subNodes.AnimationCurveNode;
|
|
|
+ var rawCurves = FBXTree.Objects.subNodes.AnimationCurve;
|
|
|
+ var rawLayers = FBXTree.Objects.subNodes.AnimationLayer;
|
|
|
+ var rawStacks = FBXTree.Objects.subNodes.AnimationStack;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{
|
|
|
+ curves: Map<number, {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ },
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ },
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }>,
|
|
|
+ layers: Map<number, {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ },
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ },
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ }
|
|
|
+ }[]>,
|
|
|
+ stacks: Map<number, {
|
|
|
+ name: string,
|
|
|
+ layers: {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ }[][],
|
|
|
+ length: number,
|
|
|
+ frames: number }>,
|
|
|
+ length: number,
|
|
|
+ fps: number,
|
|
|
+ frames: number
|
|
|
+ }}
|
|
|
+ */
|
|
|
+ var returnObject = {
|
|
|
+ curves: new Map(),
|
|
|
+ layers: {},
|
|
|
+ stacks: {},
|
|
|
+ length: 0,
|
|
|
+ fps: 30,
|
|
|
+ frames: 0
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Array.<{
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ }>}
|
|
|
+ */
|
|
|
+ var animationCurveNodes = [];
|
|
|
+ for ( var nodeID in rawNodes ) {
|
|
|
+
|
|
|
+ if ( nodeID.match( /\d+/ ) ) {
|
|
|
+
|
|
|
+ var animationNode = parseAnimationNode( FBXTree, rawNodes[ nodeID ], connections, sceneGraph );
|
|
|
+ animationCurveNodes.push( animationNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {Map.<number, {
|
|
|
+ id: number,
|
|
|
+ attr: string,
|
|
|
+ internalID: number,
|
|
|
+ attrX: boolean,
|
|
|
+ attrY: boolean,
|
|
|
+ attrZ: boolean,
|
|
|
+ containerBoneID: number,
|
|
|
+ containerID: number,
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ y: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ z: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }>}
|
|
|
+ */
|
|
|
+ var tmpMap = new Map();
|
|
|
+ for ( var animationCurveNodeIndex = 0; animationCurveNodeIndex < animationCurveNodes.length; ++ animationCurveNodeIndex ) {
|
|
|
+
|
|
|
+ if ( animationCurveNodes[ animationCurveNodeIndex ] === null ) {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+ tmpMap.set( animationCurveNodes[ animationCurveNodeIndex ].id, animationCurveNodes[ animationCurveNodeIndex ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ }[]}
|
|
|
+ */
|
|
|
+ var animationCurves = [];
|
|
|
+ for ( nodeID in rawCurves ) {
|
|
|
+
|
|
|
+ if ( nodeID.match( /\d+/ ) ) {
|
|
|
+
|
|
|
+ var animationCurve = parseAnimationCurve( rawCurves[ nodeID ] );
|
|
|
+
|
|
|
+ // seems like this check would be necessary?
|
|
|
+ if ( ! connections.has( animationCurve.id ) ) continue;
|
|
|
+
|
|
|
+ animationCurves.push( animationCurve );
|
|
|
+
|
|
|
+ var firstParentConn = connections.get( animationCurve.id ).parents[ 0 ];
|
|
|
+ var firstParentID = firstParentConn.ID;
|
|
|
+ var firstParentRelationship = firstParentConn.relationship;
|
|
|
+ var axis = '';
|
|
|
+
|
|
|
+ if ( firstParentRelationship.match( /X/ ) ) {
|
|
|
+
|
|
|
+ axis = 'x';
|
|
|
+
|
|
|
+ } else if ( firstParentRelationship.match( /Y/ ) ) {
|
|
|
+
|
|
|
+ axis = 'y';
|
|
|
+
|
|
|
+ } else if ( firstParentRelationship.match( /Z/ ) ) {
|
|
|
+
|
|
|
+ axis = 'z';
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ tmpMap.get( firstParentID ).curves[ axis ] = animationCurve;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ tmpMap.forEach( function ( curveNode ) {
|
|
|
+
|
|
|
+ var id = curveNode.containerBoneID;
|
|
|
+ if ( ! returnObject.curves.has( id ) ) {
|
|
|
+
|
|
|
+ returnObject.curves.set( id, { T: null, R: null, S: null } );
|
|
|
+
|
|
|
+ }
|
|
|
+ returnObject.curves.get( id )[ curveNode.attr ] = curveNode;
|
|
|
+ if ( curveNode.attr === 'R' ) {
|
|
|
+
|
|
|
+ var curves = curveNode.curves;
|
|
|
+
|
|
|
+ // Seems like some FBX files have AnimationCurveNode
|
|
|
+ // which doesn't have any connected AnimationCurve.
|
|
|
+ // Setting animation parameter for them here.
|
|
|
+
|
|
|
+ if ( curves.x === null ) {
|
|
|
+
|
|
|
+ curves.x = {
|
|
|
+ version: null,
|
|
|
+ times: [ 0.0 ],
|
|
|
+ values: [ 0.0 ]
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( curves.y === null ) {
|
|
|
+
|
|
|
+ curves.y = {
|
|
|
+ version: null,
|
|
|
+ times: [ 0.0 ],
|
|
|
+ values: [ 0.0 ]
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( curves.z === null ) {
|
|
|
+
|
|
|
+ curves.z = {
|
|
|
+ version: null,
|
|
|
+ times: [ 0.0 ],
|
|
|
+ values: [ 0.0 ]
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ curves.x.values = curves.x.values.map( degreeToRadian );
|
|
|
+ curves.y.values = curves.y.values.map( degreeToRadian );
|
|
|
+ curves.z.values = curves.z.values.map( degreeToRadian );
|
|
|
+
|
|
|
+ if ( curveNode.preRotations !== null ) {
|
|
|
+
|
|
|
+ var preRotations = new THREE.Euler().setFromVector3( curveNode.preRotations, 'ZYX' );
|
|
|
+ preRotations = new THREE.Quaternion().setFromEuler( preRotations );
|
|
|
+ var frameRotation = new THREE.Euler();
|
|
|
+ var frameRotationQuaternion = new THREE.Quaternion();
|
|
|
+ for ( var frame = 0; frame < curves.x.times.length; ++ frame ) {
|
|
|
+
|
|
|
+ frameRotation.set( curves.x.values[ frame ], curves.y.values[ frame ], curves.z.values[ frame ], 'ZYX' );
|
|
|
+ frameRotationQuaternion.setFromEuler( frameRotation ).premultiply( preRotations );
|
|
|
+ frameRotation.setFromQuaternion( frameRotationQuaternion, 'ZYX' );
|
|
|
+ curves.x.values[ frame ] = frameRotation.x;
|
|
|
+ curves.y.values[ frame ] = frameRotation.y;
|
|
|
+ curves.z.values[ frame ] = frameRotation.z;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ for ( var nodeID in rawLayers ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ },
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ },
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ },
|
|
|
+ }
|
|
|
+ }[]}
|
|
|
+ */
|
|
|
+ var layer = [];
|
|
|
+ var children = connections.get( parseInt( nodeID ) ).children;
|
|
|
+
|
|
|
+ for ( var childIndex = 0; childIndex < children.length; childIndex ++ ) {
|
|
|
+
|
|
|
+ // Skip lockInfluenceWeights
|
|
|
+ if ( tmpMap.has( children[ childIndex ].ID ) ) {
|
|
|
+
|
|
|
+ var curveNode = tmpMap.get( children[ childIndex ].ID );
|
|
|
+ var boneID = curveNode.containerBoneID;
|
|
|
+ if ( layer[ boneID ] === undefined ) {
|
|
|
+
|
|
|
+ layer[ boneID ] = {
|
|
|
+ T: null,
|
|
|
+ R: null,
|
|
|
+ S: null
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ layer[ boneID ][ curveNode.attr ] = curveNode;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ returnObject.layers[ nodeID ] = layer;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var nodeID in rawStacks ) {
|
|
|
+
|
|
|
+ var layers = [];
|
|
|
+ var children = connections.get( parseInt( nodeID ) ).children;
|
|
|
+ var timestamps = { max: 0, min: Number.MAX_VALUE };
|
|
|
+
|
|
|
+ for ( var childIndex = 0; childIndex < children.length; ++ childIndex ) {
|
|
|
+
|
|
|
+ var currentLayer = returnObject.layers[ children[ childIndex ].ID ];
|
|
|
+
|
|
|
+ if ( currentLayer !== undefined ) {
|
|
|
+
|
|
|
+ layers.push( currentLayer );
|
|
|
+
|
|
|
+ for ( var currentLayerIndex = 0, currentLayerLength = currentLayer.length; currentLayerIndex < currentLayerLength; ++ currentLayerIndex ) {
|
|
|
+
|
|
|
+ var layer = currentLayer[ currentLayerIndex ];
|
|
|
+
|
|
|
+ if ( layer ) {
|
|
|
+
|
|
|
+ getCurveNodeMaxMinTimeStamps( layer, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Do we have an animation clip with actual length?
|
|
|
+ if ( timestamps.max > timestamps.min ) {
|
|
|
+
|
|
|
+ returnObject.stacks[ nodeID ] = {
|
|
|
+ name: rawStacks[ nodeID ].attrName,
|
|
|
+ layers: layers,
|
|
|
+ length: timestamps.max - timestamps.min,
|
|
|
+ frames: ( timestamps.max - timestamps.min ) * 30
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return returnObject;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {Object} FBXTree
|
|
|
+ * @param {{id: number, attrName: string, properties: Object<string, any>}} animationCurveNode
|
|
|
+ * @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
|
|
|
+ * @param {{skeleton: {bones: {FBX_ID: number}[]}}} sceneGraph
|
|
|
+ */
|
|
|
+ function parseAnimationNode( FBXTree, animationCurveNode, connections, sceneGraph ) {
|
|
|
+
|
|
|
+ var rawModels = FBXTree.Objects.subNodes.Model;
|
|
|
+
|
|
|
+ var returnObject = {
|
|
|
+ /**
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ id: animationCurveNode.id,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {string}
|
|
|
+ */
|
|
|
+ attr: animationCurveNode.attrName,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ internalID: animationCurveNode.id,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {boolean}
|
|
|
+ */
|
|
|
+ attrX: false,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {boolean}
|
|
|
+ */
|
|
|
+ attrY: false,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {boolean}
|
|
|
+ */
|
|
|
+ attrZ: false,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ containerBoneID: - 1,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ containerID: - 1,
|
|
|
+
|
|
|
+ curves: {
|
|
|
+ x: null,
|
|
|
+ y: null,
|
|
|
+ z: null
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {number[]}
|
|
|
+ */
|
|
|
+ preRotations: null
|
|
|
+ };
|
|
|
+
|
|
|
+ if ( returnObject.attr.match( /S|R|T/ ) ) {
|
|
|
+
|
|
|
+ for ( var attributeKey in animationCurveNode.properties ) {
|
|
|
+
|
|
|
+ if ( attributeKey.match( /X/ ) ) {
|
|
|
+
|
|
|
+ returnObject.attrX = true;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( attributeKey.match( /Y/ ) ) {
|
|
|
+
|
|
|
+ returnObject.attrY = true;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( attributeKey.match( /Z/ ) ) {
|
|
|
+
|
|
|
+ returnObject.attrZ = true;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ return null;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = connections.get( returnObject.id );
|
|
|
+ var containerIndices = conns.parents;
|
|
|
+
|
|
|
+ for ( var containerIndicesIndex = containerIndices.length - 1; containerIndicesIndex >= 0; -- containerIndicesIndex ) {
|
|
|
+
|
|
|
+ var boneID = findIndex( sceneGraph.skeleton.bones, function ( bone ) {
|
|
|
+
|
|
|
+ return bone.FBX_ID === containerIndices[ containerIndicesIndex ].ID;
|
|
|
+
|
|
|
+ } );
|
|
|
+ if ( boneID > - 1 ) {
|
|
|
+
|
|
|
+ returnObject.containerBoneID = boneID;
|
|
|
+ returnObject.containerID = containerIndices[ containerIndicesIndex ].ID;
|
|
|
+ var model = rawModels[ returnObject.containerID.toString() ];
|
|
|
+ if ( 'PreRotation' in model.properties ) {
|
|
|
+
|
|
|
+ returnObject.preRotations = parseVector3( model.properties.PreRotation ).multiplyScalar( Math.PI / 180 );
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return returnObject;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {{id: number, subNodes: {KeyTime: {properties: {a: string}}, KeyValueFloat: {properties: {a: string}}, KeyAttrFlags: {properties: {a: string}}, KeyAttrDataFloat: {properties: {a: string}}}}} animationCurve
|
|
|
+ */
|
|
|
+ function parseAnimationCurve( animationCurve ) {
|
|
|
+
|
|
|
+ return {
|
|
|
+ version: null,
|
|
|
+ id: animationCurve.id,
|
|
|
+ internalID: animationCurve.id,
|
|
|
+ times: parseFloatArray( animationCurve.subNodes.KeyTime.properties.a ).map( convertFBXTimeToSeconds ),
|
|
|
+ values: parseFloatArray( animationCurve.subNodes.KeyValueFloat.properties.a ),
|
|
|
+
|
|
|
+ attrFlag: parseIntArray( animationCurve.subNodes.KeyAttrFlags.properties.a ),
|
|
|
+ attrData: parseFloatArray( animationCurve.subNodes.KeyAttrDataFloat.properties.a )
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the maxTimeStamp and minTimeStamp variables if it has timeStamps that are either larger or smaller
|
|
|
+ * than the max or min respectively.
|
|
|
+ * @param {{
|
|
|
+ T: {
|
|
|
+ id: number,
|
|
|
+ attr: string,
|
|
|
+ internalID: number,
|
|
|
+ attrX: boolean,
|
|
|
+ attrY: boolean,
|
|
|
+ attrZ: boolean,
|
|
|
+ containerBoneID: number,
|
|
|
+ containerID: number,
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ y: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ z: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ },
|
|
|
+ },
|
|
|
+ R: {
|
|
|
+ id: number,
|
|
|
+ attr: string,
|
|
|
+ internalID: number,
|
|
|
+ attrX: boolean,
|
|
|
+ attrY: boolean,
|
|
|
+ attrZ: boolean,
|
|
|
+ containerBoneID: number,
|
|
|
+ containerID: number,
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ y: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ z: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ },
|
|
|
+ },
|
|
|
+ S: {
|
|
|
+ id: number,
|
|
|
+ attr: string,
|
|
|
+ internalID: number,
|
|
|
+ attrX: boolean,
|
|
|
+ attrY: boolean,
|
|
|
+ attrZ: boolean,
|
|
|
+ containerBoneID: number,
|
|
|
+ containerID: number,
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ y: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ z: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ },
|
|
|
+ },
|
|
|
+ }} layer
|
|
|
+ */
|
|
|
+ function getCurveNodeMaxMinTimeStamps( layer, timestamps ) {
|
|
|
+
|
|
|
+ if ( layer.R ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.R.curves, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( layer.S ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.S.curves, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( layer.T ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.T.curves, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the maxTimeStamp and minTimeStamp if one of the curve's time stamps
|
|
|
+ * exceeds the maximum or minimum.
|
|
|
+ * @param {{
|
|
|
+ x: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ y: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ },
|
|
|
+ z: {
|
|
|
+ version: any,
|
|
|
+ id: number,
|
|
|
+ internalID: number,
|
|
|
+ times: number[],
|
|
|
+ values: number[],
|
|
|
+ attrFlag: number[],
|
|
|
+ attrData: number[],
|
|
|
+ }
|
|
|
+ }} curve
|
|
|
+ */
|
|
|
+ function getCurveMaxMinTimeStamp( curve, timestamps ) {
|
|
|
+
|
|
|
+ if ( curve.x ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.x, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( curve.y ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.y, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( curve.z ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.z, timestamps );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the maxTimeStamp and minTimeStamp if one of its timestamps exceeds the maximum or minimum.
|
|
|
+ * @param {{times: number[]}} axis
|
|
|
+ */
|
|
|
+ function getCurveAxisMaxMinTimeStamps( axis, timestamps ) {
|
|
|
+
|
|
|
+ timestamps.max = axis.times[ axis.times.length - 1 ] > timestamps.max ? axis.times[ axis.times.length - 1 ] : timestamps.max;
|
|
|
+ timestamps.min = axis.times[ 0 ] < timestamps.min ? axis.times[ 0 ] : timestamps.min;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {{
|
|
|
+ curves: Map<number, {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ }>;
|
|
|
+ layers: Map<number, {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ }[]>;
|
|
|
+ stacks: Map<number, {
|
|
|
+ name: string;
|
|
|
+ layers: {
|
|
|
+ T: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ R: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ S: {
|
|
|
+ id: number;
|
|
|
+ attr: string;
|
|
|
+ internalID: number;
|
|
|
+ attrX: boolean;
|
|
|
+ attrY: boolean;
|
|
|
+ attrZ: boolean;
|
|
|
+ containerBoneID: number;
|
|
|
+ containerID: number;
|
|
|
+ curves: {
|
|
|
+ x: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ y: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ z: {
|
|
|
+ version: any;
|
|
|
+ id: number;
|
|
|
+ internalID: number;
|
|
|
+ times: number[];
|
|
|
+ values: number[];
|
|
|
+ attrFlag: number[];
|
|
|
+ attrData: number[];
|
|
|
+ };
|
|
|
+ };
|
|
|
+ };
|
|
|
+ }[][];
|
|
|
+ length: number;
|
|
|
+ frames: number;
|
|
|
+ }>;
|
|
|
+ length: number;
|
|
|
+ fps: number;
|
|
|
+ frames: number;
|
|
|
+ }} animations,
|
|
|
+ * @param {{skeleton: { bones: THREE.Bone[]}}} group
|
|
|
+ */
|
|
|
+ function addAnimations( group, animations ) {
|
|
|
+
|
|
|
+ if ( group.animations === undefined ) {
|
|
|
+
|
|
|
+ group.animations = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var stacks = animations.stacks;
|
|
|
+
|
|
|
+ for ( var key in stacks ) {
|
|
|
+
|
|
|
+ var stack = stacks[ key ];
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{
|
|
|
+ * name: string,
|
|
|
+ * fps: number,
|
|
|
+ * length: number,
|
|
|
+ * hierarchy: Array.<{
|
|
|
+ * parent: number,
|
|
|
+ * name: string,
|
|
|
+ * keys: Array.<{
|
|
|
+ * time: number,
|
|
|
+ * pos: Array.<number>,
|
|
|
+ * rot: Array.<number>,
|
|
|
+ * scl: Array.<number>
|
|
|
+ * }>
|
|
|
+ * }>
|
|
|
+ * }}
|
|
|
+ */
|
|
|
+ var animationData = {
|
|
|
+ name: stack.name,
|
|
|
+ fps: 30,
|
|
|
+ length: stack.length,
|
|
|
+ hierarchy: []
|
|
|
+ };
|
|
|
+
|
|
|
+ var bones = group.skeleton.bones;
|
|
|
+
|
|
|
+ for ( var bonesIndex = 0, bonesLength = bones.length; bonesIndex < bonesLength; ++ bonesIndex ) {
|
|
|
+
|
|
|
+ var bone = bones[ bonesIndex ];
|
|
|
+
|
|
|
+ var name = bone.name.replace( /.*:/, '' );
|
|
|
+ var parentIndex = findIndex( bones, function ( parentBone ) {
|
|
|
+
|
|
|
+ return bone.parent === parentBone;
|
|
|
+
|
|
|
+ } );
|
|
|
+ animationData.hierarchy.push( { parent: parentIndex, name: name, keys: [] } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var frame = 0; frame <= stack.frames; frame ++ ) {
|
|
|
+
|
|
|
+ for ( var bonesIndex = 0, bonesLength = bones.length; bonesIndex < bonesLength; ++ bonesIndex ) {
|
|
|
+
|
|
|
+ var bone = bones[ bonesIndex ];
|
|
|
+ var boneIndex = bonesIndex;
|
|
|
+
|
|
|
+ var animationNode = stack.layers[ 0 ][ boneIndex ];
|
|
|
+
|
|
|
+ for ( var hierarchyIndex = 0, hierarchyLength = animationData.hierarchy.length; hierarchyIndex < hierarchyLength; ++ hierarchyIndex ) {
|
|
|
+
|
|
|
+ var node = animationData.hierarchy[ hierarchyIndex ];
|
|
|
+
|
|
|
+ if ( node.name === bone.name ) {
|
|
|
+
|
|
|
+ node.keys.push( generateKey( animations, animationNode, bone, frame ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ group.animations.push( THREE.AnimationClip.parseAnimation( animationData, bones ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var euler = new THREE.Euler();
|
|
|
+ var quaternion = new THREE.Quaternion();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {THREE.Bone} bone
|
|
|
+ */
|
|
|
+ function generateKey( animations, animationNode, bone, frame ) {
|
|
|
+
|
|
|
+ var key = {
|
|
|
+ time: frame / animations.fps,
|
|
|
+ pos: bone.position.toArray(),
|
|
|
+ rot: bone.quaternion.toArray(),
|
|
|
+ scl: bone.scale.toArray()
|
|
|
+ };
|
|
|
+
|
|
|
+ if ( animationNode === undefined ) return key;
|
|
|
+
|
|
|
+ try {
|
|
|
+
|
|
|
+ if ( hasCurve( animationNode, 'T' ) && hasKeyOnFrame( animationNode.T, frame ) ) {
|
|
|
+
|
|
|
+ key.pos = [ animationNode.T.curves.x.values[ frame ], animationNode.T.curves.y.values[ frame ], animationNode.T.curves.z.values[ frame ] ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( hasCurve( animationNode, 'R' ) && hasKeyOnFrame( animationNode.R, frame ) ) {
|
|
|
+
|
|
|
+ var rotationX = animationNode.R.curves.x.values[ frame ];
|
|
|
+ var rotationY = animationNode.R.curves.y.values[ frame ];
|
|
|
+ var rotationZ = animationNode.R.curves.z.values[ frame ];
|
|
|
+
|
|
|
+ quaternion.setFromEuler( euler.set( rotationX, rotationY, rotationZ, 'ZYX' ) );
|
|
|
+ key.rot = quaternion.toArray();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( hasCurve( animationNode, 'S' ) && hasKeyOnFrame( animationNode.S, frame ) ) {
|
|
|
+
|
|
|
+ key.scl = [ animationNode.S.curves.x.values[ frame ], animationNode.S.curves.y.values[ frame ], animationNode.S.curves.z.values[ frame ] ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } catch ( error ) {
|
|
|
+
|
|
|
+ // Curve is not fully plotted.
|
|
|
+ console.log( 'THREE.FBXLoader: ', bone );
|
|
|
+ console.log( 'THREE.FBXLoader: ', error );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return key;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var AXES = [ 'x', 'y', 'z' ];
|
|
|
+
|
|
|
+ function hasCurve( animationNode, attribute ) {
|
|
|
+
|
|
|
+ if ( animationNode === undefined ) {
|
|
|
+
|
|
|
+ return false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var attributeNode = animationNode[ attribute ];
|
|
|
+
|
|
|
+ if ( ! attributeNode ) {
|
|
|
+
|
|
|
+ return false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return AXES.every( function ( key ) {
|
|
|
+
|
|
|
+ return attributeNode.curves[ key ] !== null;
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ function hasKeyOnFrame( attributeNode, frame ) {
|
|
|
+
|
|
|
+ return AXES.every( function ( key ) {
|
|
|
+
|
|
|
+ return isKeyExistOnFrame( attributeNode.curves[ key ], frame );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ function isKeyExistOnFrame( curve, frame ) {
|
|
|
+
|
|
|
+ return curve.values[ frame ] !== undefined;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * An instance of a Vertex with data for drawing vertices to the screen.
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function Vertex() {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Position of the vertex.
|
|
|
+ * @type {THREE.Vector3}
|
|
|
+ */
|
|
|
+ this.position = new THREE.Vector3();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Normal of the vertex
|
|
|
+ * @type {THREE.Vector3}
|
|
|
+ */
|
|
|
+ this.normal = new THREE.Vector3();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * UV coordinates of the vertex.
|
|
|
+ * @type {THREE.Vector2}
|
|
|
+ */
|
|
|
+ this.uv = new THREE.Vector2();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Color of the vertex
|
|
|
+ * @type {THREE.Vector3}
|
|
|
+ */
|
|
|
+ this.color = new THREE.Vector3();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Indices of the bones vertex is influenced by.
|
|
|
+ * @type {THREE.Vector4}
|
|
|
+ */
|
|
|
+ this.skinIndices = new THREE.Vector4( 0, 0, 0, 0 );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Weights that each bone influences the vertex.
|
|
|
+ * @type {THREE.Vector4}
|
|
|
+ */
|
|
|
+ this.skinWeights = new THREE.Vector4( 0, 0, 0, 0 );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Object.assign( Vertex.prototype, {
|
|
|
+
|
|
|
+ copy: function ( target ) {
|
|
|
+
|
|
|
+ var returnVar = target || new Vertex();
|
|
|
+
|
|
|
+ returnVar.position.copy( this.position );
|
|
|
+ returnVar.normal.copy( this.normal );
|
|
|
+ returnVar.uv.copy( this.uv );
|
|
|
+ returnVar.skinIndices.copy( this.skinIndices );
|
|
|
+ returnVar.skinWeights.copy( this.skinWeights );
|
|
|
+
|
|
|
+ return returnVar;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ flattenToBuffers: function ( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer ) {
|
|
|
+
|
|
|
+ this.position.toArray( vertexBuffer, vertexBuffer.length );
|
|
|
+ this.normal.toArray( normalBuffer, normalBuffer.length );
|
|
|
+ this.uv.toArray( uvBuffer, uvBuffer.length );
|
|
|
+ this.color.toArray( colorBuffer, colorBuffer.length );
|
|
|
+ this.skinIndices.toArray( skinIndexBuffer, skinIndexBuffer.length );
|
|
|
+ this.skinWeights.toArray( skinWeightBuffer, skinWeightBuffer.length );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function Triangle() {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{position: THREE.Vector3, normal: THREE.Vector3, uv: THREE.Vector2, skinIndices: THREE.Vector4, skinWeights: THREE.Vector4}[]}
|
|
|
+ */
|
|
|
+ this.vertices = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Object.assign( Triangle.prototype, {
|
|
|
+
|
|
|
+ copy: function ( target ) {
|
|
|
+
|
|
|
+ var returnVar = target || new Triangle();
|
|
|
+
|
|
|
+ for ( var i = 0; i < this.vertices.length; ++ i ) {
|
|
|
+
|
|
|
+ this.vertices[ i ].copy( returnVar.vertices[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return returnVar;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ flattenToBuffers: function ( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer ) {
|
|
|
+
|
|
|
+ var vertices = this.vertices;
|
|
|
+
|
|
|
+ for ( var i = 0, l = vertices.length; i < l; ++ i ) {
|
|
|
+
|
|
|
+ vertices[ i ].flattenToBuffers( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function Face() {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{vertices: {position: THREE.Vector3, normal: THREE.Vector3, uv: THREE.Vector2, skinIndices: THREE.Vector4, skinWeights: THREE.Vector4}[]}[]}
|
|
|
+ */
|
|
|
+ this.triangles = [];
|
|
|
+ this.materialIndex = 0;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Object.assign( Face.prototype, {
|
|
|
+
|
|
|
+ copy: function ( target ) {
|
|
|
+
|
|
|
+ var returnVar = target || new Face();
|
|
|
+
|
|
|
+ for ( var i = 0; i < this.triangles.length; ++ i ) {
|
|
|
+
|
|
|
+ this.triangles[ i ].copy( returnVar.triangles[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ returnVar.materialIndex = this.materialIndex;
|
|
|
+
|
|
|
+ return returnVar;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ genTrianglesFromVertices: function ( vertexArray ) {
|
|
|
+
|
|
|
+ for ( var i = 2; i < vertexArray.length; ++ i ) {
|
|
|
+
|
|
|
+ var triangle = new Triangle();
|
|
|
+ triangle.vertices[ 0 ] = vertexArray[ 0 ];
|
|
|
+ triangle.vertices[ 1 ] = vertexArray[ i - 1 ];
|
|
|
+ triangle.vertices[ 2 ] = vertexArray[ i ];
|
|
|
+ this.triangles.push( triangle );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ flattenToBuffers: function ( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer, materialIndexBuffer ) {
|
|
|
+
|
|
|
+ var triangles = this.triangles;
|
|
|
+ var materialIndex = this.materialIndex;
|
|
|
+
|
|
|
+ for ( var i = 0, l = triangles.length; i < l; ++ i ) {
|
|
|
+
|
|
|
+ triangles[ i ].flattenToBuffers( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer );
|
|
|
+ append( materialIndexBuffer, [ materialIndex, materialIndex, materialIndex ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function Geometry() {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{triangles: {vertices: {position: THREE.Vector3, normal: THREE.Vector3, uv: THREE.Vector2, skinIndices: THREE.Vector4, skinWeights: THREE.Vector4}[]}[], materialIndex: number}[]}
|
|
|
+ */
|
|
|
+ this.faces = [];
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {{}|THREE.Skeleton}
|
|
|
+ */
|
|
|
+ this.skeleton = null;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Object.assign( Geometry.prototype, {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @returns {{vertexBuffer: number[], normalBuffer: number[], uvBuffer: number[], skinIndexBuffer: number[], skinWeightBuffer: number[], materialIndexBuffer: number[]}}
|
|
|
+ */
|
|
|
+ flattenToBuffers: function () {
|
|
|
+
|
|
|
+ var vertexBuffer = [];
|
|
|
+ var normalBuffer = [];
|
|
|
+ var uvBuffer = [];
|
|
|
+ var colorBuffer = [];
|
|
|
+ var skinIndexBuffer = [];
|
|
|
+ var skinWeightBuffer = [];
|
|
|
+
|
|
|
+ var materialIndexBuffer = [];
|
|
|
+
|
|
|
+ var faces = this.faces;
|
|
|
+
|
|
|
+ for ( var i = 0, l = faces.length; i < l; ++ i ) {
|
|
|
+
|
|
|
+ faces[ i ].flattenToBuffers( vertexBuffer, normalBuffer, uvBuffer, colorBuffer, skinIndexBuffer, skinWeightBuffer, materialIndexBuffer );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ vertexBuffer: vertexBuffer,
|
|
|
+ normalBuffer: normalBuffer,
|
|
|
+ uvBuffer: uvBuffer,
|
|
|
+ colorBuffer: colorBuffer,
|
|
|
+ skinIndexBuffer: skinIndexBuffer,
|
|
|
+ skinWeightBuffer: skinWeightBuffer,
|
|
|
+ materialIndexBuffer: materialIndexBuffer
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ function TextParser() {}
|
|
|
+
|
|
|
+ Object.assign( TextParser.prototype, {
|
|
|
+
|
|
|
+ getPrevNode: function () {
|
|
|
+
|
|
|
+ return this.nodeStack[ this.currentIndent - 2 ];
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getCurrentNode: function () {
|
|
|
+
|
|
|
+ return this.nodeStack[ this.currentIndent - 1 ];
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getCurrentProp: function () {
|
|
|
+
|
|
|
+ return this.currentProp;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ pushStack: function ( node ) {
|
|
|
+
|
|
|
+ this.nodeStack.push( node );
|
|
|
+ this.currentIndent += 1;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ popStack: function () {
|
|
|
+
|
|
|
+ this.nodeStack.pop();
|
|
|
+ this.currentIndent -= 1;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ setCurrentProp: function ( val, name ) {
|
|
|
+
|
|
|
+ this.currentProp = val;
|
|
|
+ this.currentPropName = name;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ // ----------parse ---------------------------------------------------
|
|
|
+ parse: function ( text ) {
|
|
|
+
|
|
|
+ this.currentIndent = 0;
|
|
|
+ this.allNodes = new FBXTree();
|
|
|
+ this.nodeStack = [];
|
|
|
+ this.currentProp = [];
|
|
|
+ this.currentPropName = '';
|
|
|
+
|
|
|
+ var split = text.split( '\n' );
|
|
|
+
|
|
|
+ for ( var lineNum = 0, lineLength = split.length; lineNum < lineLength; lineNum ++ ) {
|
|
|
+
|
|
|
+ var l = split[ lineNum ];
|
|
|
+
|
|
|
+ // skip comment line
|
|
|
+ if ( l.match( /^[\s\t]*;/ ) ) {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // skip empty line
|
|
|
+ if ( l.match( /^[\s\t]*$/ ) ) {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // beginning of node
|
|
|
+ var beginningOfNodeExp = new RegExp( '^\\t{' + this.currentIndent + '}(\\w+):(.*){', '' );
|
|
|
+ var match = l.match( beginningOfNodeExp );
|
|
|
+
|
|
|
+ if ( match ) {
|
|
|
+
|
|
|
+ var nodeName = match[ 1 ].trim().replace( /^"/, '' ).replace( /"$/, '' );
|
|
|
+ var nodeAttrs = match[ 2 ].split( ',' );
|
|
|
+
|
|
|
+ for ( var i = 0, l = nodeAttrs.length; i < l; i ++ ) {
|
|
|
+ nodeAttrs[ i ] = nodeAttrs[ i ].trim().replace( /^"/, '' ).replace( /"$/, '' );
|
|
|
+ }
|
|
|
+
|
|
|
+ this.parseNodeBegin( l, nodeName, nodeAttrs || null );
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // node's property
|
|
|
+ var propExp = new RegExp( '^\\t{' + ( this.currentIndent ) + '}(\\w+):[\\s\\t\\r\\n](.*)' );
|
|
|
+ var match = l.match( propExp );
|
|
|
+
|
|
|
+ if ( match ) {
|
|
|
+
|
|
|
+ var propName = match[ 1 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
|
|
|
+ var propValue = match[ 2 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
|
|
|
+
|
|
|
+ // for special case: base64 image data follows "Content: ," line
|
|
|
+ // Content: ,
|
|
|
+ // "iVB..."
|
|
|
+ if ( propName === 'Content' && propValue === ',' ) {
|
|
|
+
|
|
|
+ propValue = split[ ++ lineNum ].replace( /"/g, '' ).trim();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ this.parseNodeProperty( l, propName, propValue );
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // end of node
|
|
|
+ var endOfNodeExp = new RegExp( '^\\t{' + ( this.currentIndent - 1 ) + '}}' );
|
|
|
+
|
|
|
+ if ( l.match( endOfNodeExp ) ) {
|
|
|
+
|
|
|
+ this.nodeEnd();
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // for special case,
|
|
|
+ //
|
|
|
+ // Vertices: *8670 {
|
|
|
+ // a: 0.0356229953467846,13.9599733352661,-0.399196773.....(snip)
|
|
|
+ // -0.0612030513584614,13.960485458374,-0.409748703241348,-0.10.....
|
|
|
+ // 0.12490539252758,13.7450733184814,-0.454119384288788,0.09272.....
|
|
|
+ // 0.0836158767342567,13.5432004928589,-0.435397416353226,0.028.....
|
|
|
+ //
|
|
|
+ // these case the lines must contiue with previous line
|
|
|
+ if ( l.match( /^[^\s\t}]/ ) ) {
|
|
|
+
|
|
|
+ this.parseNodePropertyContinued( l );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return this.allNodes;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeBegin: function ( line, nodeName, nodeAttrs ) {
|
|
|
+
|
|
|
+ // var nodeName = match[1];
|
|
|
+ var node = { 'name': nodeName, properties: {}, 'subNodes': {} };
|
|
|
+ var attrs = this.parseNodeAttr( nodeAttrs );
|
|
|
+ var currentNode = this.getCurrentNode();
|
|
|
+
|
|
|
+ // a top node
|
|
|
+ if ( this.currentIndent === 0 ) {
|
|
|
+
|
|
|
+ this.allNodes.add( nodeName, node );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // a subnode
|
|
|
+
|
|
|
+ // already exists subnode, then append it
|
|
|
+ if ( nodeName in currentNode.subNodes ) {
|
|
|
+
|
|
|
+ var tmp = currentNode.subNodes[ nodeName ];
|
|
|
+
|
|
|
+ // console.log( "duped entry found\nkey: " + nodeName + "\nvalue: " + propValue );
|
|
|
+ if ( this.isFlattenNode( currentNode.subNodes[ nodeName ] ) ) {
|
|
|
+
|
|
|
+
|
|
|
+ if ( attrs.id === '' ) {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ] = [];
|
|
|
+ currentNode.subNodes[ nodeName ].push( tmp );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ] = {};
|
|
|
+ currentNode.subNodes[ nodeName ][ tmp.id ] = tmp;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( attrs.id === '' ) {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ].push( node );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ][ attrs.id ] = node;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if ( typeof attrs.id === 'number' || attrs.id.match( /^\d+$/ ) ) {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ] = {};
|
|
|
+ currentNode.subNodes[ nodeName ][ attrs.id ] = node;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ currentNode.subNodes[ nodeName ] = node;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // for this ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
|
|
|
+ // NodeAttribute: 1001463072, "NodeAttribute::", "LimbNode" {
|
|
|
+ if ( nodeAttrs ) {
|
|
|
+
|
|
|
+ node.id = attrs.id;
|
|
|
+ node.attrName = attrs.name;
|
|
|
+ node.attrType = attrs.type;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ this.pushStack( node );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeAttr: function ( attrs ) {
|
|
|
+
|
|
|
+ var id = attrs[ 0 ];
|
|
|
+
|
|
|
+ if ( attrs[ 0 ] !== '' ) {
|
|
|
+
|
|
|
+ id = parseInt( attrs[ 0 ] );
|
|
|
+
|
|
|
+ if ( isNaN( id ) ) {
|
|
|
+
|
|
|
+ // PolygonVertexIndex: *16380 {
|
|
|
+ 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 ( line, propName, propValue ) {
|
|
|
+
|
|
|
+ var currentNode = this.getCurrentNode();
|
|
|
+ var parentName = currentNode.name;
|
|
|
+
|
|
|
+ // special case parent node's is like "Properties70"
|
|
|
+ // these children nodes must treat with careful
|
|
|
+ if ( parentName !== undefined ) {
|
|
|
+
|
|
|
+ var propMatch = parentName.match( /Properties(\d)+/ );
|
|
|
+ if ( propMatch ) {
|
|
|
+
|
|
|
+ this.parseNodeSpecialProperty( line, propName, propValue );
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // special case 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 );
|
|
|
+
|
|
|
+ propName = 'connections';
|
|
|
+ propValue = [ from, to ];
|
|
|
+ append( propValue, rest );
|
|
|
+
|
|
|
+ if ( currentNode.properties[ propName ] === undefined ) {
|
|
|
+
|
|
|
+ currentNode.properties[ propName ] = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // special case Connections
|
|
|
+ if ( propName === 'Node' ) {
|
|
|
+
|
|
|
+ var id = parseInt( propValue );
|
|
|
+ currentNode.properties.id = id;
|
|
|
+ currentNode.id = id;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // already exists in properties, then append this
|
|
|
+ if ( propName in currentNode.properties ) {
|
|
|
+
|
|
|
+ // console.log( "duped entry found\nkey: " + propName + "\nvalue: " + propValue );
|
|
|
+ if ( Array.isArray( currentNode.properties[ propName ] ) ) {
|
|
|
+
|
|
|
+ currentNode.properties[ propName ].push( propValue );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ currentNode.properties[ propName ] += propValue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // console.log( propName + ": " + propValue );
|
|
|
+ if ( Array.isArray( currentNode.properties[ propName ] ) ) {
|
|
|
+
|
|
|
+ currentNode.properties[ propName ].push( propValue );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ currentNode.properties[ propName ] = propValue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ this.setCurrentProp( currentNode.properties, propName );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ // TODO:
|
|
|
+ parseNodePropertyContinued: function ( line ) {
|
|
|
+
|
|
|
+ this.currentProp[ this.currentPropName ] += line;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parseNodeSpecialProperty: function ( 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( '",' );
|
|
|
+
|
|
|
+ for ( var i = 0, l = props.length; i < l; i ++ ) {
|
|
|
+ props[ i ] = props[ i ].trim().replace( /^\"/, '' ).replace( /\s/, '_' );
|
|
|
+ }
|
|
|
+
|
|
|
+ var innerPropName = props[ 0 ];
|
|
|
+ var innerPropType1 = props[ 1 ];
|
|
|
+ var innerPropType2 = props[ 2 ];
|
|
|
+ var innerPropFlag = props[ 3 ];
|
|
|
+ var innerPropValue = props[ 4 ];
|
|
|
+
|
|
|
+ /*
|
|
|
+ if ( innerPropValue === undefined ) {
|
|
|
+ innerPropValue = props[3];
|
|
|
+ }
|
|
|
+ */
|
|
|
+
|
|
|
+ // cast value in its type
|
|
|
+ switch ( innerPropType1 ) {
|
|
|
+
|
|
|
+ case 'int':
|
|
|
+ innerPropValue = parseInt( innerPropValue );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'double':
|
|
|
+ innerPropValue = parseFloat( innerPropValue );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'ColorRGB':
|
|
|
+ case 'Vector3D':
|
|
|
+ innerPropValue = parseFloatArray( innerPropValue );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // CAUTION: these props must append to parent's parent
|
|
|
+ this.getPrevNode().properties[ innerPropName ] = {
|
|
|
+
|
|
|
+ 'type': innerPropType1,
|
|
|
+ 'type2': innerPropType2,
|
|
|
+ 'flag': innerPropFlag,
|
|
|
+ 'value': innerPropValue
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ this.setCurrentProp( this.getPrevNode().properties, innerPropName );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ nodeEnd: function () {
|
|
|
+
|
|
|
+ this.popStack();
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /* ---------------------------------------------------------------- */
|
|
|
+ /* util */
|
|
|
+ isFlattenNode: function ( node ) {
|
|
|
+
|
|
|
+ return ( 'subNodes' in node && 'properties' in node ) ? true : false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ // 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)
|
|
|
+ function BinaryParser() {}
|
|
|
+
|
|
|
+ Object.assign( BinaryParser.prototype, {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses binary data and builds FBXTree as much compatible as possible with the one built by TextParser.
|
|
|
+ * @param {ArrayBuffer} buffer
|
|
|
+ * @returns {THREE.FBXTree}
|
|
|
+ */
|
|
|
+ parse: function ( 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;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Checks if reader has reached the end of content.
|
|
|
+ * @param {BinaryReader} reader
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ endOfContent: function( 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();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses Node as much compatible as possible with the one parsed by TextParser
|
|
|
+ * TODO: could be optimized more?
|
|
|
+ * @param {BinaryReader} reader
|
|
|
+ * @param {number} version
|
|
|
+ * @returns {Object} - Returns an Object as node, or null if NULL-record.
|
|
|
+ */
|
|
|
+ parseNode: function ( reader, version ) {
|
|
|
+
|
|
|
+ // The first three data sizes depends on version.
|
|
|
+ var endOffset = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
|
|
|
+ var numProperties = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
|
|
|
+ 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 ] : '';
|
|
|
+
|
|
|
+ var subNodes = {};
|
|
|
+ var properties = {};
|
|
|
+
|
|
|
+ var isSingleProperty = false;
|
|
|
+
|
|
|
+ // 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]}
|
|
|
+ if ( numProperties === 1 && reader.getOffset() === endOffset ) {
|
|
|
+
|
|
|
+ isSingleProperty = true;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ while ( endOffset > reader.getOffset() ) {
|
|
|
+
|
|
|
+ var node = this.parseNode( reader, version );
|
|
|
+
|
|
|
+ if ( node === null ) continue;
|
|
|
+
|
|
|
+ // special case: child node is single property
|
|
|
+ if ( node.singleProperty === true ) {
|
|
|
+
|
|
|
+ var value = node.propertyList[ 0 ];
|
|
|
+
|
|
|
+ if ( Array.isArray( value ) ) {
|
|
|
+
|
|
|
+ // node represents
|
|
|
+ // Vertices: *3 {
|
|
|
+ // a: 0.01, 0.02, 0.03
|
|
|
+ // }
|
|
|
+ // of text format here.
|
|
|
+
|
|
|
+ node.properties[ node.name ] = node.propertyList[ 0 ];
|
|
|
+ subNodes[ node.name ] = node;
|
|
|
+
|
|
|
+ // Later phase expects single property array is in node.properties.a as String.
|
|
|
+ // TODO: optimize
|
|
|
+ node.properties.a = value.toString();
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // node represents
|
|
|
+ // Version: 100
|
|
|
+ // of text format here.
|
|
|
+
|
|
|
+ properties[ node.name ] = value;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // special case: connections
|
|
|
+ if ( name === 'Connections' && node.name === 'C' ) {
|
|
|
+
|
|
|
+ var array = [];
|
|
|
+
|
|
|
+ // node.propertyList would be like
|
|
|
+ // ["OO", 111264976, 144038752, "d|x"] (?, from, to, additional values)
|
|
|
+ for ( var i = 1, il = node.propertyList.length; i < il; i ++ ) {
|
|
|
+
|
|
|
+ array[ i - 1 ] = node.propertyList[ i ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( properties.connections === undefined ) {
|
|
|
+
|
|
|
+ properties.connections = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ properties.connections.push( array );
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // special case: child node is Properties\d+
|
|
|
+ if ( node.name.match( /^Properties\d+$/ ) ) {
|
|
|
+
|
|
|
+ // move child node's properties to this node.
|
|
|
+
|
|
|
+ var keys = Object.keys( node.properties );
|
|
|
+
|
|
|
+ for ( var i = 0, il = keys.length; i < il; i ++ ) {
|
|
|
+
|
|
|
+ var key = keys[ i ];
|
|
|
+ properties[ key ] = node.properties[ key ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // special case: properties
|
|
|
+ if ( name.match( /^Properties\d+$/ ) && node.name === 'P' ) {
|
|
|
+
|
|
|
+ var innerPropName = node.propertyList[ 0 ];
|
|
|
+ var innerPropType1 = node.propertyList[ 1 ];
|
|
|
+ var innerPropType2 = node.propertyList[ 2 ];
|
|
|
+ var innerPropFlag = node.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 === 'ColorRGB' || innerPropType1 === 'Vector' ||
|
|
|
+ innerPropType1 === 'Vector3D' || innerPropType1.indexOf( 'Lcl_' ) === 0 ) {
|
|
|
+
|
|
|
+ innerPropValue = [
|
|
|
+ node.propertyList[ 4 ],
|
|
|
+ node.propertyList[ 5 ],
|
|
|
+ node.propertyList[ 6 ]
|
|
|
+ ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ innerPropValue = node.propertyList[ 4 ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( innerPropType1.indexOf( 'Lcl_' ) === 0 ) {
|
|
|
+
|
|
|
+ innerPropValue = innerPropValue.toString();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // this will be copied to parent. see above.
|
|
|
+ properties[ innerPropName ] = {
|
|
|
+
|
|
|
+ 'type': innerPropType1,
|
|
|
+ 'type2': innerPropType2,
|
|
|
+ 'flag': innerPropFlag,
|
|
|
+ 'value': innerPropValue
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // standard case
|
|
|
+ // follows TextParser's manner.
|
|
|
+ if ( subNodes[ node.name ] === undefined ) {
|
|
|
+
|
|
|
+ if ( typeof node.id === 'number' ) {
|
|
|
+
|
|
|
+ subNodes[ node.name ] = {};
|
|
|
+ subNodes[ node.name ][ node.id ] = node;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ subNodes[ node.name ] = node;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ if ( node.id === '' ) {
|
|
|
+
|
|
|
+ if ( ! Array.isArray( subNodes[ node.name ] ) ) {
|
|
|
+
|
|
|
+ subNodes[ node.name ] = [ subNodes[ node.name ] ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ subNodes[ node.name ].push( node );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ if ( subNodes[ node.name ][ node.id ] === undefined ) {
|
|
|
+
|
|
|
+ subNodes[ node.name ][ node.id ] = node;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // conflict id. irregular?
|
|
|
+
|
|
|
+ if ( ! Array.isArray( subNodes[ node.name ][ node.id ] ) ) {
|
|
|
+
|
|
|
+ subNodes[ node.name ][ node.id ] = [ subNodes[ node.name ][ node.id ] ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ subNodes[ node.name ][ node.id ].push( node );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+
|
|
|
+ singleProperty: isSingleProperty,
|
|
|
+ id: id,
|
|
|
+ attrName: attrName,
|
|
|
+ attrType: attrType,
|
|
|
+ name: name,
|
|
|
+ properties: properties,
|
|
|
+ propertyList: propertyList, // raw property list, would be used by parent
|
|
|
+ subNodes: subNodes
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parseProperty: function ( reader ) {
|
|
|
+
|
|
|
+ var type = reader.getChar();
|
|
|
+
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case 'F':
|
|
|
+ return reader.getFloat32();
|
|
|
+
|
|
|
+ case 'D':
|
|
|
+ return reader.getFloat64();
|
|
|
+
|
|
|
+ case 'L':
|
|
|
+ return reader.getInt64();
|
|
|
+
|
|
|
+ case 'I':
|
|
|
+ return reader.getInt32();
|
|
|
+
|
|
|
+ case 'Y':
|
|
|
+ return reader.getInt16();
|
|
|
+
|
|
|
+ case 'C':
|
|
|
+ return reader.getBoolean();
|
|
|
+
|
|
|
+ case 'f':
|
|
|
+ case 'd':
|
|
|
+ case 'l':
|
|
|
+ case 'i':
|
|
|
+ case 'b':
|
|
|
+
|
|
|
+ var arrayLength = reader.getUint32();
|
|
|
+ var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
|
|
|
+ var compressedLength = reader.getUint32();
|
|
|
+
|
|
|
+ if ( encoding === 0 ) {
|
|
|
+
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case 'f':
|
|
|
+ return reader.getFloat32Array( arrayLength );
|
|
|
+
|
|
|
+ case 'd':
|
|
|
+ return reader.getFloat64Array( arrayLength );
|
|
|
+
|
|
|
+ case 'l':
|
|
|
+ return reader.getInt64Array( arrayLength );
|
|
|
+
|
|
|
+ case 'i':
|
|
|
+ return reader.getInt32Array( arrayLength );
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ return reader.getBooleanArray( arrayLength );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( window.Zlib === undefined ) {
|
|
|
+
|
|
|
+ throw new 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 ) ) );
|
|
|
+ var reader2 = new BinaryReader( inflate.decompress().buffer );
|
|
|
+
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case 'f':
|
|
|
+ return reader2.getFloat32Array( arrayLength );
|
|
|
+
|
|
|
+ case 'd':
|
|
|
+ return reader2.getFloat64Array( arrayLength );
|
|
|
+
|
|
|
+ case 'l':
|
|
|
+ return reader2.getInt64Array( arrayLength );
|
|
|
+
|
|
|
+ case 'i':
|
|
|
+ return reader2.getInt32Array( arrayLength );
|
|
|
+
|
|
|
+ case 'b':
|
|
|
+ return reader2.getBooleanArray( arrayLength );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ case 'S':
|
|
|
+ var length = reader.getUint32();
|
|
|
+ return reader.getString( length );
|
|
|
+
|
|
|
+ case 'R':
|
|
|
+ var length = reader.getUint32();
|
|
|
+ return reader.getArrayBuffer( length );
|
|
|
+
|
|
|
+ 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 () {
|
|
|
+
|
|
|
+ return this.offset;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ size: function () {
|
|
|
+
|
|
|
+ return this.dv.buffer.byteLength;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ skip: function ( 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 () {
|
|
|
+
|
|
|
+ return ( this.getUint8() & 1 ) === 1;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getBooleanArray: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getBoolean() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt8: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getInt8( this.offset );
|
|
|
+ this.offset += 1;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt8Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getInt8() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint8: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getUint8( this.offset );
|
|
|
+ this.offset += 1;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint8Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getUint8() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt16: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getInt16( this.offset, this.littleEndian );
|
|
|
+ this.offset += 2;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt16Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getInt16() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint16: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getUint16( this.offset, this.littleEndian );
|
|
|
+ this.offset += 2;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint16Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getUint16() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt32: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getInt32( this.offset, this.littleEndian );
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getInt32Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getInt32() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint32: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getUint32( this.offset, this.littleEndian );
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint32Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getUint32() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ // JavaScript doesn't support 64-bit integer so attempting to calculate by ourselves.
|
|
|
+ // 1 << 32 will return 1 so using multiply operation instead here.
|
|
|
+ // There'd be 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 () {
|
|
|
+
|
|
|
+ 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 ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getInt64() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ // Note: see getInt64() comment
|
|
|
+ getUint64: function () {
|
|
|
+
|
|
|
+ var low, high;
|
|
|
+
|
|
|
+ if ( this.littleEndian ) {
|
|
|
+
|
|
|
+ low = this.getUint32();
|
|
|
+ high = this.getUint32();
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ high = this.getUint32();
|
|
|
+ low = this.getUint32();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return high * 0x100000000 + low;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getUint64Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getUint64() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat32: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getFloat32( this.offset, this.littleEndian );
|
|
|
+ this.offset += 4;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat32Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getFloat32() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat64: function () {
|
|
|
+
|
|
|
+ var value = this.dv.getFloat64( this.offset, this.littleEndian );
|
|
|
+ this.offset += 8;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getFloat64Array: function ( size ) {
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for ( var i = 0; i < size; i ++ ) {
|
|
|
+
|
|
|
+ a.push( this.getFloat64() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getArrayBuffer: function ( size ) {
|
|
|
+
|
|
|
+ var value = this.dv.buffer.slice( this.offset, this.offset + size );
|
|
|
+ this.offset += size;
|
|
|
+ return value;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getChar: function () {
|
|
|
+
|
|
|
+ return String.fromCharCode( this.getUint8() );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ getString: function ( size ) {
|
|
|
+
|
|
|
+ var s = '';
|
|
|
+
|
|
|
+ while ( size > 0 ) {
|
|
|
+
|
|
|
+ var value = this.getUint8();
|
|
|
+ size--;
|
|
|
+
|
|
|
+ if ( value === 0 ) break;
|
|
|
+
|
|
|
+ s += String.fromCharCode( value );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ this.skip( size );
|
|
|
+
|
|
|
+ return s;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+
|
|
|
+ function FBXTree() {}
|
|
|
+
|
|
|
+ Object.assign( FBXTree.prototype, {
|
|
|
+
|
|
|
+ add: function ( key, val ) {
|
|
|
+
|
|
|
+ this[ key ] = val;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ searchConnectionParent: function ( id ) {
|
|
|
+
|
|
|
+ if ( this.__cache_search_connection_parent === undefined ) {
|
|
|
+
|
|
|
+ this.__cache_search_connection_parent = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( this.__cache_search_connection_parent[ id ] !== undefined ) {
|
|
|
+
|
|
|
+ return this.__cache_search_connection_parent[ id ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.__cache_search_connection_parent[ id ] = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = this.Connections.properties.connections;
|
|
|
+
|
|
|
+ var results = [];
|
|
|
+ for ( var i = 0; i < conns.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( conns[ i ][ 0 ] == id ) {
|
|
|
+
|
|
|
+ // 0 means scene root
|
|
|
+ var res = conns[ i ][ 1 ] === 0 ? - 1 : conns[ i ][ 1 ];
|
|
|
+ results.push( res );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( results.length > 0 ) {
|
|
|
+
|
|
|
+ append( this.__cache_search_connection_parent[ id ], results );
|
|
|
+ return results;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.__cache_search_connection_parent[ id ] = [ - 1 ];
|
|
|
+ return [ - 1 ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ searchConnectionChildren: function ( id ) {
|
|
|
+
|
|
|
+ if ( this.__cache_search_connection_children === undefined ) {
|
|
|
+
|
|
|
+ this.__cache_search_connection_children = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( this.__cache_search_connection_children[ id ] !== undefined ) {
|
|
|
+
|
|
|
+ return this.__cache_search_connection_children[ id ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.__cache_search_connection_children[ id ] = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = this.Connections.properties.connections;
|
|
|
+
|
|
|
+ var res = [];
|
|
|
+ for ( var i = 0; i < conns.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( conns[ i ][ 1 ] == id ) {
|
|
|
+
|
|
|
+ // 0 means scene root
|
|
|
+ res.push( conns[ i ][ 0 ] === 0 ? - 1 : conns[ i ][ 0 ] );
|
|
|
+ // there may more than one kid, then search to the end
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( res.length > 0 ) {
|
|
|
+
|
|
|
+ append( this.__cache_search_connection_children[ id ], res );
|
|
|
+ return res;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.__cache_search_connection_children[ id ] = [ ];
|
|
|
+ return [ ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ searchConnectionType: function ( id, to ) {
|
|
|
+
|
|
|
+ var key = id + ',' + to; // TODO: to hash
|
|
|
+ if ( this.__cache_search_connection_type === undefined ) {
|
|
|
+
|
|
|
+ this.__cache_search_connection_type = {};
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( this.__cache_search_connection_type[ key ] !== undefined ) {
|
|
|
+
|
|
|
+ return this.__cache_search_connection_type[ key ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.__cache_search_connection_type[ key ] = '';
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = this.Connections.properties.connections;
|
|
|
+
|
|
|
+ for ( var i = 0; i < conns.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( conns[ i ][ 0 ] == id && conns[ i ][ 1 ] == to ) {
|
|
|
+
|
|
|
+ // 0 means scene root
|
|
|
+ this.__cache_search_connection_type[ key ] = conns[ i ][ 2 ];
|
|
|
+ return conns[ i ][ 2 ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ this.__cache_search_connection_type[ id ] = null;
|
|
|
+ return null;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {ArrayBuffer} buffer
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ function isFbxFormatBinary( buffer ) {
|
|
|
+
|
|
|
+ var CORRECT = 'Kaydara FBX Binary \0';
|
|
|
+
|
|
|
+ return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString( buffer, 0, CORRECT.length );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ 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;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @returns {number}
|
|
|
+ */
|
|
|
+ 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.
|
|
|
+ * @param {number} time - FBX tick timestamp to convert.
|
|
|
+ * @returns {number} - FBX tick in real world time.
|
|
|
+ */
|
|
|
+ function convertFBXTimeToSeconds( time ) {
|
|
|
+
|
|
|
+ // Constant is FBX ticks per second.
|
|
|
+ return time / 46186158000;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses comma separated list of float numbers and returns them in an array.
|
|
|
+ * @example
|
|
|
+ * // Returns [ 5.6, 9.4, 2.5, 1.4 ]
|
|
|
+ * parseFloatArray( "5.6,9.4,2.5,1.4" )
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ function parseFloatArray( string ) {
|
|
|
+
|
|
|
+ var array = string.split( ',' );
|
|
|
+
|
|
|
+ for ( var i = 0, l = array.length; i < l; i ++ ) {
|
|
|
+
|
|
|
+ array[ i ] = parseFloat( array[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return array;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses comma separated list of int numbers and returns them in an array.
|
|
|
+ * @example
|
|
|
+ * // Returns [ 5, 8, 2, 3 ]
|
|
|
+ * parseFloatArray( "5,8,2,3" )
|
|
|
+ * @returns {number[]}
|
|
|
+ */
|
|
|
+ function parseIntArray( string ) {
|
|
|
+
|
|
|
+ var array = string.split( ',' );
|
|
|
+
|
|
|
+ for ( var i = 0, l = array.length; i < l; i ++ ) {
|
|
|
+
|
|
|
+ array[ i ] = parseInt( array[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return array;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses Vector3 property from FBXTree. Property is given as .value.x, .value.y, etc.
|
|
|
+ * @param {FBXVector3} property - Property to parse as Vector3.
|
|
|
+ * @returns {THREE.Vector3}
|
|
|
+ */
|
|
|
+ function parseVector3( property ) {
|
|
|
+
|
|
|
+ return new THREE.Vector3().fromArray( property.value );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses Color property from FBXTree. Property is given as .value.x, .value.y, etc.
|
|
|
+ * @param {FBXVector3} property - Property to parse as Color.
|
|
|
+ * @returns {THREE.Color}
|
|
|
+ */
|
|
|
+ function parseColor( property ) {
|
|
|
+
|
|
|
+ return new THREE.Color().fromArray( property.value );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseMatrixArray( floatString ) {
|
|
|
+
|
|
|
+ return new THREE.Matrix4().fromArray( parseFloatArray( floatString ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Converts ArrayBuffer to String.
|
|
|
+ * @param {ArrayBuffer} buffer
|
|
|
+ * @param {number} from
|
|
|
+ * @param {number} to
|
|
|
+ * @returns {String}
|
|
|
+ */
|
|
|
+ function convertArrayBufferToString( buffer, from, to ) {
|
|
|
+
|
|
|
+ if ( from === undefined ) from = 0;
|
|
|
+ if ( to === undefined ) to = buffer.byteLength;
|
|
|
+
|
|
|
+ var array = new Uint8Array( buffer, from, to );
|
|
|
+
|
|
|
+ if ( window.TextDecoder !== undefined ) {
|
|
|
+
|
|
|
+ return new TextDecoder().decode( array );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var s = '';
|
|
|
+
|
|
|
+ for ( var i = 0, il = array.length; i < il; i ++ ) {
|
|
|
+
|
|
|
+ s += String.fromCharCode( array[ i ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return s;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Converts number from degrees into radians.
|
|
|
+ * @param {number} value
|
|
|
+ * @returns {number}
|
|
|
+ */
|
|
|
+ function degreeToRadian( value ) {
|
|
|
+
|
|
|
+ return value * DEG2RAD;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var DEG2RAD = Math.PI / 180;
|
|
|
+
|
|
|
+ //
|
|
|
+
|
|
|
+ function findIndex( array, func ) {
|
|
|
+
|
|
|
+ for ( var i = 0, l = array.length; i < l; i ++ ) {
|
|
|
+
|
|
|
+ if ( func( array[ i ] ) ) return i;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ 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){
|
|
|
+/**
|
|
|
+ * @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 ( 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 ( mapping ) {
|
|
|
+
|
|
|
+ this.propertyNameMapping = mapping;
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ bin2str: function ( 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( data ) {
|
|
|
+
|
|
|
+ var header = this.parseHeader( this.bin2str( data ) );
|
|
|
+
|
|
|
+ return header.format === "ascii";
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parse: function ( data ) {
|
|
|
+
|
|
|
+ if ( data instanceof ArrayBuffer ) {
|
|
|
+
|
|
|
+ return this.isASCII( data )
|
|
|
+ ? this.parseASCII( this.bin2str( data ) )
|
|
|
+ : this.parseBinary( data );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ return this.parseASCII( data );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ parseHeader: function ( 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 ( 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 ( 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 ( 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 ( 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 ( 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 ( 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 ( 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 ( 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){
|
|
|
+/**
|
|
|
+ * 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) {
|
|
|
+ const script = document.getElementById(id);
|
|
|
+ const parent = script.parentNode;
|
|
|
+
|
|
|
+ try {
|
|
|
+ parent && parent.removeChild(script);
|
|
|
+ } catch (e) {
|
|
|
+ // ignore
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function appendScript(script) {
|
|
|
+ const firstScript = document.getElementsByTagName('script')[0];
|
|
|
+ firstScript.parentNode.insertBefore(script, firstScript);
|
|
|
+}
|
|
|
+
|
|
|
+function fetchScriptInternal(url, options, Promise) {
|
|
|
+ return new Promise(function(resolve, reject) {
|
|
|
+ const timeout = options.timeout || 5000;
|
|
|
+ const scriptId = getScriptId();
|
|
|
+ const script = createScript(url, scriptId);
|
|
|
+
|
|
|
+ const timeoutId = setTimeout(function() {
|
|
|
+ reject(new Error('Script request to ' + url + ' timed out'));
|
|
|
+
|
|
|
+ removeScript(scriptId);
|
|
|
+ }, timeout);
|
|
|
+
|
|
|
+ const disableTimeout = function(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){
|
|
|
+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 = {
|
|
|
+ schema: {
|
|
|
+ clip: {default: '*'},
|
|
|
+ duration: {default: 0},
|
|
|
+ crossFadeDuration: {default: 0},
|
|
|
+ loop: {default: 'repeat', oneOf: Object.keys(LoopMode)},
|
|
|
+ repetitions: {default: Infinity, min: 0}
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ /** @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);
|
|
|
+ }.bind(this));
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function (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});
|
|
|
+ }.bind(this));
|
|
|
+ this.mixer.addEventListener('finished', function (e) {
|
|
|
+ el.emit('animation-finished', {action: e.action, direction: e.direction});
|
|
|
+ }.bind(this));
|
|
|
+ if (this.data.clip) this.update({});
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (this.mixer) this.mixer.stopAllAction();
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function (previousData) {
|
|
|
+ if (!previousData) return;
|
|
|
+
|
|
|
+ this.stopAction();
|
|
|
+
|
|
|
+ if (this.data.clip) {
|
|
|
+ this.playAction();
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ stopAction: function () {
|
|
|
+ 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 () {
|
|
|
+ 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;
|
|
|
+ if (data.duration) action.setDuration(data.duration);
|
|
|
+ action
|
|
|
+ .setLoop(LoopMode[data.loop], data.repetitions)
|
|
|
+ .fadeIn(data.crossFadeDuration)
|
|
|
+ .play();
|
|
|
+ this.activeActions.push(action);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ tick: function (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){
|
|
|
+THREE.FBXLoader = require('../../lib/FBXLoader');
|
|
|
+
|
|
|
+/**
|
|
|
+ * fbx-model
|
|
|
+ *
|
|
|
+ * Loader for FBX format. Supports ASCII, but *not* binary, models.
|
|
|
+ */
|
|
|
+module.exports = {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var loader,
|
|
|
+ data = this.data;
|
|
|
+ if (!data.src) return;
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+ loader = new THREE.FBXLoader();
|
|
|
+ if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
|
|
|
+ loader.load(data.src, this.load.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function (model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', {format: 'fbx', model: model});
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+},{"../../lib/FBXLoader":2}],7:[function(require,module,exports){
|
|
|
+var fetchScript = require('../../lib/fetch-script')();
|
|
|
+
|
|
|
+var LOADER_SRC = 'https://rawgit.com/mrdoob/three.js/r86/examples/js/loaders/GLTFLoader.js';
|
|
|
+
|
|
|
+/**
|
|
|
+ * Legacy loader for glTF 1.0 models.
|
|
|
+ * Asynchronously loads THREE.GLTFLoader from rawgit.
|
|
|
+ */
|
|
|
+module.exports = {
|
|
|
+ schema: {type: 'model'},
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ this.loader = null;
|
|
|
+ this.loaderPromise = loadLoader().then(function () {
|
|
|
+ this.loader = new THREE.GLTFLoader();
|
|
|
+ this.loader.setCrossOrigin('Anonymous');
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var self = this;
|
|
|
+ var el = this.el;
|
|
|
+ var src = this.data;
|
|
|
+
|
|
|
+ if (!src) { return; }
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+
|
|
|
+ this.loaderPromise.then(function () {
|
|
|
+ this.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});
|
|
|
+ });
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (!this.model) { return; }
|
|
|
+ this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+var loadLoader = (function () {
|
|
|
+ var promise;
|
|
|
+ return function () {
|
|
|
+ promise = promise || fetchScript(LOADER_SRC);
|
|
|
+ return promise;
|
|
|
+ };
|
|
|
+}());
|
|
|
+
|
|
|
+},{"../../lib/fetch-script":4}],8:[function(require,module,exports){
|
|
|
+var fetchScript = require('../../lib/fetch-script')();
|
|
|
+
|
|
|
+var LOADER_SRC = 'https://rawgit.com/mrdoob/three.js/r87/examples/js/loaders/GLTFLoader.js';
|
|
|
+// Monkeypatch while waiting for three.js r86.
|
|
|
+if (THREE.PropertyBinding.sanitizeNodeName === undefined) {
|
|
|
+
|
|
|
+ THREE.PropertyBinding.sanitizeNodeName = function (s) {
|
|
|
+ return s.replace( /\s/g, '_' ).replace( /[^\w-]/g, '' );
|
|
|
+ };
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Upcoming loader for glTF 2.0 models.
|
|
|
+ * Asynchronously loads THREE.GLTF2Loader from rawgit.
|
|
|
+ */
|
|
|
+module.exports = {
|
|
|
+ schema: {type: 'model'},
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ this.loader = null;
|
|
|
+ this.loaderPromise = loadLoader().then(function () {
|
|
|
+ this.loader = new THREE.GLTFLoader();
|
|
|
+ this.loader.setCrossOrigin('Anonymous');
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var self = this;
|
|
|
+ var el = this.el;
|
|
|
+ var src = this.data;
|
|
|
+
|
|
|
+ if (!src) { return; }
|
|
|
+
|
|
|
+ this.remove();
|
|
|
+
|
|
|
+ this.loaderPromise.then(function () {
|
|
|
+ this.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});
|
|
|
+ });
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (!this.model) { return; }
|
|
|
+ this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+var loadLoader = (function () {
|
|
|
+ var promise;
|
|
|
+ return function () {
|
|
|
+ promise = promise || fetchScript(LOADER_SRC);
|
|
|
+ return promise;
|
|
|
+ };
|
|
|
+}());
|
|
|
+
|
|
|
+},{"../../lib/fetch-script":4}],9:[function(require,module,exports){
|
|
|
+module.exports = {
|
|
|
+ 'animation-mixer': require('./animation-mixer'),
|
|
|
+ 'fbx-model': require('./fbx-model'),
|
|
|
+ 'gltf-model-next': require('./gltf-model-next'),
|
|
|
+ 'gltf-model-legacy': require('./gltf-model-legacy'),
|
|
|
+ 'json-model': require('./json-model'),
|
|
|
+ 'object-model': require('./object-model'),
|
|
|
+ 'ply-model': require('./ply-model'),
|
|
|
+ 'three-model': require('./three-model'),
|
|
|
+
|
|
|
+ registerAll: function (AFRAME) {
|
|
|
+ if (this._registered) return;
|
|
|
+
|
|
|
+ AFRAME = AFRAME || window.AFRAME;
|
|
|
+
|
|
|
+ // THREE.AnimationMixer
|
|
|
+ if (!AFRAME.components['animation-mixer']) {
|
|
|
+ AFRAME.registerComponent('animation-mixer', this['animation-mixer']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.PlyLoader
|
|
|
+ if (!AFRAME.systems['ply-model']) {
|
|
|
+ AFRAME.registerSystem('ply-model', this['ply-model'].System);
|
|
|
+ }
|
|
|
+ if (!AFRAME.components['ply-model']) {
|
|
|
+ AFRAME.registerComponent('ply-model', this['ply-model'].Component);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.FBXLoader
|
|
|
+ if (!AFRAME.components['fbx-model']) {
|
|
|
+ AFRAME.registerComponent('fbx-model', this['fbx-model']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.GLTF2Loader
|
|
|
+ if (!AFRAME.components['gltf-model-next']) {
|
|
|
+ AFRAME.registerComponent('gltf-model-next', this['gltf-model-next']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.GLTFLoader
|
|
|
+ if (!AFRAME.components['gltf-model-legacy']) {
|
|
|
+ AFRAME.registerComponent('gltf-model-legacy', this['gltf-model-legacy']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.JsonLoader
|
|
|
+ if (!AFRAME.components['json-model']) {
|
|
|
+ AFRAME.registerComponent('json-model', this['json-model']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // THREE.ObjectLoader
|
|
|
+ if (!AFRAME.components['object-model']) {
|
|
|
+ AFRAME.registerComponent('object-model', this['object-model']);
|
|
|
+ }
|
|
|
+
|
|
|
+ // (deprecated) THREE.JsonLoader and THREE.ObjectLoader
|
|
|
+ if (!AFRAME.components['three-model']) {
|
|
|
+ AFRAME.registerComponent('three-model', this['three-model']);
|
|
|
+ }
|
|
|
+
|
|
|
+ this._registered = true;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+},{"./animation-mixer":5,"./fbx-model":6,"./gltf-model-legacy":7,"./gltf-model-next":8,"./json-model":10,"./object-model":11,"./ply-model":12,"./three-model":13}],10:[function(require,module,exports){
|
|
|
+/**
|
|
|
+ * 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 = {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var loader,
|
|
|
+ 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);
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function (model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', {format: 'json', model: model});
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+},{}],11:[function(require,module,exports){
|
|
|
+/**
|
|
|
+ * 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 = {
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var loader,
|
|
|
+ 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);
|
|
|
+ }.bind(this));
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function (model) {
|
|
|
+ this.model = model;
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', {format: 'json', model: model});
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+},{}],12:[function(require,module,exports){
|
|
|
+/**
|
|
|
+ * 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 = {
|
|
|
+ init: function () {
|
|
|
+ this.cache = {};
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @returns {Promise}
|
|
|
+ */
|
|
|
+ getOrLoadGeometry: function (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 = {
|
|
|
+ schema: {
|
|
|
+ skipCache: {type: 'boolean', default: false},
|
|
|
+ src: {type: 'asset'}
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function () {
|
|
|
+ var data = this.data;
|
|
|
+ var el = this.el;
|
|
|
+ var loader;
|
|
|
+
|
|
|
+ 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 () {
|
|
|
+ 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}],13:[function(require,module,exports){
|
|
|
+var DEFAULT_ANIMATION = '__auto__';
|
|
|
+
|
|
|
+/**
|
|
|
+ * three-model
|
|
|
+ *
|
|
|
+ * Loader for THREE.js JSON format. Somewhat confusingly, there are two
|
|
|
+ * different THREE.js formats, both having the .json extension. This loader
|
|
|
+ * supports both, but requires you to specify the mode as "object" or "json".
|
|
|
+ *
|
|
|
+ * Typically, you will use "json" for a single mesh, and "object" for a scene
|
|
|
+ * or multiple meshes. Check the console for errors, if in doubt.
|
|
|
+ *
|
|
|
+ * See: https://clara.io/learn/user-guide/data_exchange/threejs_export
|
|
|
+ */
|
|
|
+module.exports = {
|
|
|
+ deprecated: true,
|
|
|
+
|
|
|
+ schema: {
|
|
|
+ src: { type: 'asset' },
|
|
|
+ loader: { default: 'object', oneOf: ['object', 'json'] },
|
|
|
+ enableAnimation: { default: true },
|
|
|
+ animation: { default: DEFAULT_ANIMATION },
|
|
|
+ animationDuration: { default: 0 },
|
|
|
+ crossorigin: { default: '' }
|
|
|
+ },
|
|
|
+
|
|
|
+ init: function () {
|
|
|
+ this.model = null;
|
|
|
+ this.mixer = null;
|
|
|
+ console.warn('[three-model] Component is deprecated. Use json-model or object-model instead.');
|
|
|
+ },
|
|
|
+
|
|
|
+ update: function (previousData) {
|
|
|
+ previousData = previousData || {};
|
|
|
+
|
|
|
+ var loader,
|
|
|
+ data = this.data;
|
|
|
+
|
|
|
+ if (!data.src) {
|
|
|
+ this.remove();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // First load.
|
|
|
+ if (!Object.keys(previousData).length) {
|
|
|
+ this.remove();
|
|
|
+ if (data.loader === 'object') {
|
|
|
+ loader = new THREE.ObjectLoader();
|
|
|
+ if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
|
|
|
+ loader.load(data.src, function(loaded) {
|
|
|
+ loaded.traverse( function(object) {
|
|
|
+ if (object instanceof THREE.SkinnedMesh)
|
|
|
+ loaded = object;
|
|
|
+ });
|
|
|
+ if(loaded.material)
|
|
|
+ loaded.material.skinning = !!((loaded.geometry && loaded.geometry.bones) || []).length;
|
|
|
+ this.load(loaded);
|
|
|
+ }.bind(this));
|
|
|
+ } else if (data.loader === 'json') {
|
|
|
+ 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 mesh = (geometry.bones || []).length
|
|
|
+ ? new THREE.SkinnedMesh(geometry, new THREE.MultiMaterial(materials))
|
|
|
+ : new THREE.Mesh(geometry, new THREE.MultiMaterial(materials));
|
|
|
+
|
|
|
+ this.load(mesh);
|
|
|
+ }.bind(this));
|
|
|
+ } else {
|
|
|
+ throw new Error('[three-model] Invalid mode "%s".', data.mode);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var activeAction = this.model && this.model.activeAction;
|
|
|
+
|
|
|
+ if (data.animation !== previousData.animation) {
|
|
|
+ if (activeAction) activeAction.stop();
|
|
|
+ this.playAnimation();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (activeAction && data.enableAnimation !== activeAction.isRunning()) {
|
|
|
+ data.enableAnimation ? this.playAnimation() : activeAction.stop();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (activeAction && data.animationDuration) {
|
|
|
+ activeAction.setDuration(data.animationDuration);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ load: function (model) {
|
|
|
+ this.model = model;
|
|
|
+ this.mixer = new THREE.AnimationMixer(this.model);
|
|
|
+ this.el.setObject3D('mesh', model);
|
|
|
+ this.el.emit('model-loaded', {format: 'three', model: model});
|
|
|
+
|
|
|
+ if (this.data.enableAnimation) this.playAnimation();
|
|
|
+ },
|
|
|
+
|
|
|
+ playAnimation: function () {
|
|
|
+ var clip,
|
|
|
+ data = this.data,
|
|
|
+ animations = this.model.animations || this.model.geometry.animations || [];
|
|
|
+
|
|
|
+ if (!data.enableAnimation || !data.animation || !animations.length) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ clip = data.animation === DEFAULT_ANIMATION
|
|
|
+ ? animations[0]
|
|
|
+ : THREE.AnimationClip.findByName(animations, data.animation);
|
|
|
+
|
|
|
+ if (!clip) {
|
|
|
+ console.error('[three-model] Animation "%s" not found.', data.animation);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.model.activeAction = this.mixer.clipAction(clip, this.model);
|
|
|
+ if (data.animationDuration) {
|
|
|
+ this.model.activeAction.setDuration(data.animationDuration);
|
|
|
+ }
|
|
|
+ this.model.activeAction.play();
|
|
|
+ },
|
|
|
+
|
|
|
+ remove: function () {
|
|
|
+ if (this.mixer) this.mixer.stopAllAction();
|
|
|
+ if (this.model) this.el.removeObject3D('mesh');
|
|
|
+ },
|
|
|
+
|
|
|
+ tick: function (t, dt) {
|
|
|
+ if (this.mixer && !isNaN(dt)) {
|
|
|
+ this.mixer.update(dt / 1000);
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+},{}]},{},[1]);
|
