|
|
@@ -0,0 +1,3860 @@
|
|
|
+/**
|
|
|
+ * @author Kyle-Larson https://github.com/Kyle-Larson
|
|
|
+ *
|
|
|
+ * Loader loads FBX file and generates Group representing FBX scene.
|
|
|
+ * Requires FBX file to be >= 7.0 and in ASCII 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
|
|
|
+ *
|
|
|
+ * 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.
|
|
|
+ */
|
|
|
+ THREE.FBXLoader = function ( manager ) {
|
|
|
+
|
|
|
+ THREE.Loader.call( this );
|
|
|
+ this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
|
|
|
+ this.fileLoader = new THREE.FileLoader( this.manager );
|
|
|
+ this.textureLoader = new THREE.TextureLoader( this.manager );
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ Object.assign( THREE.FBXLoader.prototype, THREE.Loader.prototype );
|
|
|
+
|
|
|
+ THREE.FBXLoader.prototype.constructor = THREE.FBXLoader;
|
|
|
+
|
|
|
+ Object.assign( THREE.FBXLoader.prototype, {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Loads an ASCII 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 = url.split( /[\\\/]/ );
|
|
|
+ resourceDirectory.pop();
|
|
|
+ resourceDirectory = resourceDirectory.join( '/' );
|
|
|
+
|
|
|
+ this.fileLoader.load( url, function ( text ) {
|
|
|
+
|
|
|
+ if ( ! isFbxFormatASCII( text ) ) {
|
|
|
+
|
|
|
+ console.error( 'FBXLoader: FBX Binary format not supported.' );
|
|
|
+ self.manager.itemError( url );
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( getFbxVersion( text ) < 7000 ) {
|
|
|
+
|
|
|
+ console.error( 'FBXLoader: FBX version not supported for file at ' + url + ', FileVersion: ' + getFbxVersion( text ) );
|
|
|
+ self.manager.itemError( url );
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var scene = self.parse( text, resourceDirectory );
|
|
|
+ onLoad( scene );
|
|
|
+
|
|
|
+ }, onProgress, onError );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses an ASCII 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 {string} FBXText - Contents of FBX file to parse.
|
|
|
+ * @param {string} resourceDirectory - Directory to load external assets (e.g. textures ) from.
|
|
|
+ * @returns {THREE.Group}
|
|
|
+ */
|
|
|
+ parse: function ( FBXText, resourceDirectory ) {
|
|
|
+
|
|
|
+ var loader = this;
|
|
|
+
|
|
|
+ var FBXTree = new TextParser().parse( FBXText );
|
|
|
+
|
|
|
+ var connections = parseConnections( FBXTree );
|
|
|
+
|
|
|
+ var textures = parseTextures( FBXTree );
|
|
|
+
|
|
|
+ var materials = parseMaterials( FBXTree, textures, connections );
|
|
|
+
|
|
|
+ var deformerMap = parseDeformers( FBXTree, connections );
|
|
|
+
|
|
|
+ var geometryMap = parseGeometries( FBXTree, connections, deformerMap );
|
|
|
+
|
|
|
+ var sceneGraph = parseScene( FBXTree, connections, deformerMap, geometryMap, materials );
|
|
|
+
|
|
|
+ return sceneGraph;
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @typedef {{value: number}} FBXValue
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{value: {x: string, y: string, z: string}}} FBXVector3
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{properties: {a: string}}} FBXArrayNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{properties: {MappingInformationType: string, ReferenceInformationType: string }, subNodes: Object<string, FBXArrayNode>}} FBXMappedArrayNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{id: number, name: string, properties: {FileName: string}}} FBXTextureNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{id: number, attrName: string, properties: {ShadingModel: string, Diffuse: FBXVector3, Specular: FBXVector3, Shininess: FBXValue, Emissive: FBXVector3, EmissiveFactor: FBXValue, Opacity: FBXValue}}} FBXMaterialNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{subNodes: {Indexes: FBXArrayNode, Weights: FBXArrayNode, Transform: FBXArrayNode, TransformLink: FBXArrayNode}, properties: { Mode: string }}} FBXSubDeformerNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{id: number, attrName: string, attrType: string, subNodes: {Vertices: FBXArrayNode, PolygonVertexIndex: FBXArrayNode, LayerElementNormal: FBXMappedArrayNode[], LayerElementMaterial: FBXMappedArrayNode[], LayerElementUV: FBXMappedArrayNode[]}}} FBXGeometryNode
|
|
|
+ */
|
|
|
+ /**
|
|
|
+ * @typedef {{id: number, attrName: string, attrType: string, properties: {Lcl_Translation: FBXValue, Lcl_Rotation: FBXValue, Lcl_Scaling: FBXValue}}} FBXModelNode
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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;
|
|
|
+ connectionArray.forEach( function ( connection ) {
|
|
|
+
|
|
|
+ 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 textures referenced in FBXTree.
|
|
|
+ * @param {{Objects: {subNodes: {Texture: Object.<string, FBXTextureNode>}}}} FBXTree
|
|
|
+ * @returns {Map<number, THREE.Texture>}
|
|
|
+ */
|
|
|
+ function parseTextures( FBXTree ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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 ] );
|
|
|
+ textureMap.set( parseInt( nodeID ), texture );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return textureMap;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {textureNode} textureNode - Node to get texture information from.
|
|
|
+ * @returns {THREE.Texture}
|
|
|
+ */
|
|
|
+ function parseTexture( textureNode ) {
|
|
|
+
|
|
|
+ var FBX_ID = textureNode.id;
|
|
|
+ var name = textureNode.name;
|
|
|
+ var filePath = textureNode.properties.FileName;
|
|
|
+ var split = filePath.split( /[\\\/]/ );
|
|
|
+ if ( split.length > 0 ) {
|
|
|
+
|
|
|
+ var fileName = split[ split.length - 1 ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var fileName = filePath;
|
|
|
+
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * @type {THREE.Texture}
|
|
|
+ */
|
|
|
+ var texture = loader.textureLoader.load( resourceDirectory + '/' + fileName );
|
|
|
+ texture.name = name;
|
|
|
+ texture.FBX_ID = FBX_ID;
|
|
|
+
|
|
|
+ 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 );
|
|
|
+ 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;
|
|
|
+
|
|
|
+ var children = connections.get( FBX_ID ).children;
|
|
|
+
|
|
|
+ var parameters = parseParameters( materialNode.properties, textureMap, children );
|
|
|
+
|
|
|
+ var material;
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case 'phong':
|
|
|
+ material = new THREE.MeshPhongMaterial();
|
|
|
+ break;
|
|
|
+ case 'lambert':
|
|
|
+ material = new THREE.MeshLambertMaterial();
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ console.warn( 'No implementation given for material type ' + type + ' in FBXLoader.js. Defaulting to basic material' );
|
|
|
+ material = new THREE.MeshBasicMaterial( { 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;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ childrenRelationships.forEach( function ( relationship ) {
|
|
|
+
|
|
|
+ var type = relationship.relationship;
|
|
|
+ switch ( type ) {
|
|
|
+
|
|
|
+ case " \"AmbientColor":
|
|
|
+ //TODO: Support AmbientColor textures
|
|
|
+ break;
|
|
|
+
|
|
|
+ case " \"DiffuseColor":
|
|
|
+ parameters.map = textureMap.get( relationship.ID );
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ console.warn( 'Unknown texture application of type ' + type + ', skipping texture' );
|
|
|
+ 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 skeletonMap = new Map();
|
|
|
+
|
|
|
+ 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 );
|
|
|
+ skeletonMap.set( parseInt( nodeID ), skeleton );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return skeletonMap;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 = new Map();
|
|
|
+ var subDeformerArray = [];
|
|
|
+ connections.children.forEach( function ( child ) {
|
|
|
+
|
|
|
+ var subDeformerNode = DeformerNodes[ child.ID ];
|
|
|
+ var subDeformer = {
|
|
|
+ FBX_ID: child.ID,
|
|
|
+ indices: parseIntArray( subDeformerNode.subNodes.Indexes.properties.a ),
|
|
|
+ weights: parseFloatArray( subDeformerNode.subNodes.Weights.properties.a ),
|
|
|
+ transform: parseMatrixArray( subDeformerNode.subNodes.Transform.properties.a ),
|
|
|
+ transformLink: parseMatrixArray( subDeformerNode.subNodes.TransformLink.properties.a ),
|
|
|
+ linkMode: subDeformerNode.properties.Mode
|
|
|
+ };
|
|
|
+ subDeformers.set( child.ID, subDeformer );
|
|
|
+ subDeformerArray.push( subDeformer );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ return {
|
|
|
+ map: subDeformers,
|
|
|
+ array: subDeformerArray,
|
|
|
+ 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}>} deformerMap
|
|
|
+ * @returns {Map<number, THREE.BufferGeometry>}
|
|
|
+ */
|
|
|
+ function parseGeometries( FBXTree, connections, deformerMap ) {
|
|
|
+
|
|
|
+ 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, deformerMap );
|
|
|
+ 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}[]}>} deformerMap
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ function parseGeometry( geometryNode, relationships, deformerMap ) {
|
|
|
+
|
|
|
+ switch ( geometryNode.attrType ) {
|
|
|
+
|
|
|
+ case 'Mesh':
|
|
|
+ return parseMeshGeometry( geometryNode, relationships, deformerMap );
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'NurbsCurve':
|
|
|
+ return parseNurbsGeometry( geometryNode, relationships, deformerMap );
|
|
|
+ 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}[]}>} deformerMap - Map object of deformers and subDeformers by ID.
|
|
|
+ * @returns {THREE.BufferGeometry}
|
|
|
+ */
|
|
|
+ function parseMeshGeometry( geometryNode, relationships, deformerMap ) {
|
|
|
+
|
|
|
+ var FBX_ID = geometryNode.id;
|
|
|
+ var name = geometryNode.attrName;
|
|
|
+ for ( var i = 0; i < relationships.children.length; ++ i ) {
|
|
|
+
|
|
|
+ if ( deformerMap.has( relationships.children[ i ].ID ) ) {
|
|
|
+
|
|
|
+ var deformer = deformerMap.get( relationships.children[ i ].ID );
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var geometry = genGeometry( geometryNode, deformer );
|
|
|
+
|
|
|
+ return geometry;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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();
|
|
|
+
|
|
|
+ //First, each index is going to be its own vertex.
|
|
|
+ var vertexBuffer = parseFloatArray( geometryNode.subNodes.Vertices.properties.a );
|
|
|
+ var indexBuffer = parseIntArray( geometryNode.subNodes.PolygonVertexIndex.properties.a );
|
|
|
+
|
|
|
+ if ( 'LayerElementNormal' in geometryNode.subNodes ) {
|
|
|
+
|
|
|
+ var normalInfo = getNormals( geometryNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'LayerElementUV' in geometryNode.subNodes ) {
|
|
|
+
|
|
|
+ var uvInfo = getUVs( geometryNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'LayerElementMaterial' in geometryNode.subNodes ) {
|
|
|
+
|
|
|
+ var materialInfo = getMaterials( geometryNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var faceVertexBuffer = [];
|
|
|
+ var polygonIndex = 0;
|
|
|
+ for ( var polygonVertexIndex = 0; polygonVertexIndex < indexBuffer.length; ++ polygonVertexIndex ) {
|
|
|
+
|
|
|
+ var endOfFace;
|
|
|
+ var vertexIndex = indexBuffer[ polygonVertexIndex ];
|
|
|
+ if ( indexBuffer[ polygonVertexIndex ] < 0 ) {
|
|
|
+
|
|
|
+ vertexIndex = vertexIndex ^ - 1;
|
|
|
+ indexBuffer[ polygonVertexIndex ] = vertexIndex;
|
|
|
+ endOfFace = true;
|
|
|
+
|
|
|
+ }
|
|
|
+ var vertex = new Vertex();
|
|
|
+ var weightIndices = [];
|
|
|
+ var weights = [];
|
|
|
+ vertex.position.fromArray( vertexBuffer, vertexIndex * 3 );
|
|
|
+
|
|
|
+ // If we have a deformer for this geometry, get the skinIndex and skinWeights for this object.
|
|
|
+ // They are stored as vertex indices on each deformer, and we need them as deformer indices
|
|
|
+ // for each vertex.
|
|
|
+ if ( deformer ) {
|
|
|
+
|
|
|
+ for ( var j = 0; j < deformer.array.length; ++ j ) {
|
|
|
+
|
|
|
+ var index = deformer.array[ j ].indices.findIndex( function ( index ) {
|
|
|
+
|
|
|
+ return index === indexBuffer[ polygonVertexIndex ];
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ if ( index !== - 1 ) {
|
|
|
+
|
|
|
+ weights.push( deformer.array[ j ].weights[ index ] );
|
|
|
+ weightIndices.push( j );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( weights.length > 4 ) {
|
|
|
+
|
|
|
+ console.warn( 'FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.' );
|
|
|
+
|
|
|
+ var WIndex = [ 0, 0, 0, 0 ];
|
|
|
+ var Weight = [ 0, 0, 0, 0 ];
|
|
|
+
|
|
|
+ for ( var polygonVertexIndex = 0; polygonVertexIndex < weights.length; ++ polygonVertexIndex ) {
|
|
|
+
|
|
|
+ var currentWeight = weights[ polygonVertexIndex ];
|
|
|
+ var currentIndex = weightIndices[ polygonVertexIndex ];
|
|
|
+ for ( var j = 0; j < Weight.length; ++ j ) {
|
|
|
+
|
|
|
+ if ( currentWeight > Weight[ j ] ) {
|
|
|
+
|
|
|
+ var tmp = Weight[ j ];
|
|
|
+ Weight[ j ] = currentWeight;
|
|
|
+ currentWeight = tmp;
|
|
|
+
|
|
|
+ tmp = WIndex[ j ];
|
|
|
+ WIndex[ j ] = 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 );
|
|
|
+
|
|
|
+ //vertex.skinWeights.normalize();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( normalInfo ) {
|
|
|
+
|
|
|
+ vertex.normal.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, normalInfo ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( uvInfo ) {
|
|
|
+
|
|
|
+ vertex.uv.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, uvInfo ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ //Add vertex to face buffer.
|
|
|
+ faceVertexBuffer.push( vertex );
|
|
|
+
|
|
|
+ // If index was negative to start with, we have finished this individual face
|
|
|
+ // and can generate the face data to the geometry.
|
|
|
+ if ( endOfFace ) {
|
|
|
+
|
|
|
+ var face = new Face();
|
|
|
+ var materials = getData( polygonVertexIndex, polygonIndex, vertexIndex, materialInfo );
|
|
|
+ face.genTrianglesFromVertices( faceVertexBuffer );
|
|
|
+ face.materialIndex = materials[ 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.BufferAttribute( new Float32Array( bufferInfo.vertexBuffer ), 3 ) );
|
|
|
+
|
|
|
+ if ( bufferInfo.normalBuffer.length > 0 ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( bufferInfo.normalBuffer ), 3 ) );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( bufferInfo.uvBuffer.length > 0 ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( bufferInfo.uvBuffer ), 2 ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( deformer ) {
|
|
|
+
|
|
|
+ geo.addAttribute( 'skinIndex', new THREE.BufferAttribute( new Float32Array( bufferInfo.skinIndexBuffer ), 4 ) );
|
|
|
+
|
|
|
+ geo.addAttribute( 'skinWeight', new THREE.BufferAttribute( new Float32Array( bufferInfo.skinWeightBuffer ), 4 ) );
|
|
|
+
|
|
|
+ geo.FBX_Deformer = deformer;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Convert the material indices of each vertex into rendering groups on the geometry.
|
|
|
+ var prevMaterialIndex = bufferInfo.materialIndexBuffer[ 0 ];
|
|
|
+ var startIndex = 0;
|
|
|
+ for ( var materialBufferIndex = 0; materialBufferIndex < bufferInfo.materialIndexBuffer.length; ++ materialBufferIndex ) {
|
|
|
+
|
|
|
+ if ( bufferInfo.materialIndexBuffer[ materialBufferIndex ] !== prevMaterialIndex ) {
|
|
|
+
|
|
|
+ geo.addGroup( startIndex, materialBufferIndex - startIndex, prevMaterialIndex );
|
|
|
+ startIndex = materialBufferIndex;
|
|
|
+ prevMaterialIndex = bufferInfo.materialIndexBuffer[ materialBufferIndex ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return geo;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parses normal information for geometry.
|
|
|
+ * @param {FBXGeometryNode} geometryNode
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getNormals( geometryNode ) {
|
|
|
+
|
|
|
+ var NormalNode = geometryNode.subNodes.LayerElementNormal[ 0 ];
|
|
|
+
|
|
|
+ var mappingType = NormalNode.properties.MappingInformationType;
|
|
|
+ var referenceType = NormalNode.properties.ReferenceInformationType;
|
|
|
+ var buffer = parseFloatArray( NormalNode.subNodes.Normals.properties.a );
|
|
|
+ var indexBuffer = [];
|
|
|
+ if ( referenceType === 'IndexToDirect' ) {
|
|
|
+
|
|
|
+ indexBuffer = parseIntArray( NormalNode.subNodes.NormalIndex.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( geometryNode ) {
|
|
|
+
|
|
|
+ var UVNode = geometryNode.subNodes.LayerElementUV[ 0 ];
|
|
|
+
|
|
|
+ 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 material application information for geometry.
|
|
|
+ * @param {FBXGeometryNode}
|
|
|
+ * @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
|
|
|
+ */
|
|
|
+ function getMaterials( geometryNode ) {
|
|
|
+
|
|
|
+ var MaterialNode = geometryNode.subNodes.LayerElementMaterial[ 0 ];
|
|
|
+ var mappingType = MaterialNode.properties.MappingInformationType;
|
|
|
+ var referenceType = MaterialNode.properties.ReferenceInformationType;
|
|
|
+ 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 = [];
|
|
|
+ materialIndexBuffer.forEach( function ( materialIndex, index ) {
|
|
|
+
|
|
|
+ materialIndices.push( index );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ 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[]}
|
|
|
+ */
|
|
|
+ function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
|
|
|
+
|
|
|
+ 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 ) {
|
|
|
+
|
|
|
+ return infoObject.buffer.slice( ( polygonVertexIndex * infoObject.dataSize ), ( polygonVertexIndex * infoObject.dataSize ) + infoObject.dataSize );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 ];
|
|
|
+ return infoObject.buffer.slice( ( index * infoObject.dataSize ), ( index * infoObject.dataSize ) + infoObject.dataSize );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ 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 ) {
|
|
|
+
|
|
|
+ return infoObject.buffer.slice( polygonIndex * infoObject.dataSize, polygonIndex * infoObject.dataSize + infoObject.dataSize );
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 ];
|
|
|
+ return infoObject.buffer.slice( index * infoObject.dataSize, index * infoObject.dataSize + infoObject.dataSize );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ 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 ) {
|
|
|
+
|
|
|
+ return infoObject.buffer.slice( infoObject.indices[ 0 ] * infoObject.dataSize, infoObject.indices[ 0 ] * infoObject.dataSize + infoObject.dataSize );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+ 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, relationships ) {
|
|
|
+
|
|
|
+ if ( THREE.NURBSCurve === undefined ) {
|
|
|
+
|
|
|
+ console.error( "THREE.FBXLoader 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( "FBXLoader: Invalid Order " + geometryNode.properties.Order + " given for geometry ID: " + geometryNode.id );
|
|
|
+ return new THREE.BufferGeometry();
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var knots = parseFloatArray( geometryNode.subNodes.KnotVector.properties.a );
|
|
|
+ var controlPoints = [];
|
|
|
+ var pointsValues = parseFloatArray( geometryNode.subNodes.Points.properties.a );
|
|
|
+
|
|
|
+ for ( var i = 0; i < pointsValues.length; i += 4 ) {
|
|
|
+
|
|
|
+ controlPoints.push( new THREE.Vector4( pointsValues[ i ], pointsValues[ i + 1 ], pointsValues[ i + 2 ], pointsValues[ i + 3 ] ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( geometryNode.properties.Form === 'Closed' ) {
|
|
|
+
|
|
|
+ controlPoints.push( controlPoints[ 0 ] );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var curve = new THREE.NURBSCurve( order - 1, knots, controlPoints );
|
|
|
+ var vertices = curve.getPoints( controlPoints.length * 1.5 );
|
|
|
+
|
|
|
+ var vertexBuffer = [];
|
|
|
+ vertices.forEach( function ( position ) {
|
|
|
+
|
|
|
+ var array = position.toArray();
|
|
|
+ vertexBuffer = vertexBuffer.concat( array );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ var geometry = new THREE.BufferGeometry();
|
|
|
+ geometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertexBuffer ), 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}>} deformerMap
|
|
|
+ * @param {Map<number, THREE.BufferGeometry>} geometryMap
|
|
|
+ * @param {Map<number, THREE.Material>} materialMap
|
|
|
+ * @returns {THREE.Group}
|
|
|
+ */
|
|
|
+ function parseScene( FBXTree, connections, deformerMap, 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 ) {
|
|
|
+
|
|
|
+ deformerMap.forEach( function ( deformer ) {
|
|
|
+
|
|
|
+ if ( deformer.map.has( conns.parents[ i ].ID ) ) {
|
|
|
+
|
|
|
+ model = new THREE.Bone();
|
|
|
+ var index = deformer.array.findIndex( function ( subDeformer ) {
|
|
|
+
|
|
|
+ return subDeformer.FBX_ID === conns.parents[ i ].ID;
|
|
|
+
|
|
|
+ } );
|
|
|
+ deformer.bones[ index ] = model;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+ 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 = [];
|
|
|
+
|
|
|
+ conns.children.forEach( function ( child ) {
|
|
|
+
|
|
|
+ if ( geometryMap.has( child.ID ) ) {
|
|
|
+
|
|
|
+ geometry = geometryMap.get( child.ID );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( materialMap.has( child.ID ) ) {
|
|
|
+
|
|
|
+ materials.push( materialMap.get( child.ID ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+ if ( materials.length > 1 ) {
|
|
|
+
|
|
|
+ material = new THREE.MultiMaterial( materials );
|
|
|
+
|
|
|
+ } else if ( materials.length > 0 ) {
|
|
|
+
|
|
|
+ material = materials[ 0 ];
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ material = new THREE.MeshBasicMaterial( { color: 0x3300ff } );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( geometry.FBX_Deformer ) {
|
|
|
+
|
|
|
+ materials.forEach( function ( material ) {
|
|
|
+
|
|
|
+ material.skinning = true;
|
|
|
+
|
|
|
+ } );
|
|
|
+ material.skinning = true;
|
|
|
+ model = new THREE.SkinnedMesh( geometry, material );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ model = new THREE.Mesh( geometry, material );
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case "NurbsCurve":
|
|
|
+ var geometry = null;
|
|
|
+
|
|
|
+ conns.children.forEach( function ( child ) {
|
|
|
+
|
|
|
+ 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 );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ modelArray.forEach( function ( model ) {
|
|
|
+
|
|
|
+ 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( function ( value ) {
|
|
|
+
|
|
|
+ return value * Math.PI / 180;
|
|
|
+
|
|
|
+ } );
|
|
|
+ rotation.push( 'ZYX' );
|
|
|
+ model.rotation.fromArray( rotation );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'Lcl_Scaling' in node.properties ) {
|
|
|
+
|
|
|
+ model.scale.fromArray( parseFloatArray( node.properties.Lcl_Scaling.value ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var conns = connections.get( model.FBX_ID );
|
|
|
+ for ( var parentIndex = 0; parentIndex < conns.parents.length; parentIndex ++ ) {
|
|
|
+
|
|
|
+ var pIndex = modelArray.findIndex( 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();
|
|
|
+
|
|
|
+ PoseNode.forEach( function ( node ) {
|
|
|
+
|
|
|
+ var rawMatWrd = parseMatrixArray( node.subNodes.Matrix.properties.a );
|
|
|
+
|
|
|
+ worldMatrices.set( parseInt( node.id ), rawMatWrd );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ deformerMap.forEach( function ( deformer, FBX_ID ) {
|
|
|
+
|
|
|
+ deformer.array.forEach( function ( subDeformer, subDeformerIndex ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type {THREE.Bone}
|
|
|
+ */
|
|
|
+ var bone = deformer.bones[ subDeformerIndex ];
|
|
|
+ if ( ! worldMatrices.has( bone.FBX_ID ) ) {
|
|
|
+
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+ 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( FBX_ID );
|
|
|
+ conns.parents.forEach( function ( parent ) {
|
|
|
+
|
|
|
+ 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, we are now free to set up the
|
|
|
+ // scene graph.
|
|
|
+ modelArray.forEach( function ( model ) {
|
|
|
+
|
|
|
+ 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( function ( value ) {
|
|
|
+
|
|
|
+ return value * Math.PI / 180;
|
|
|
+
|
|
|
+ } );
|
|
|
+ rotation.push( 'ZYX' );
|
|
|
+ model.rotation.fromArray( rotation );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( 'Lcl_Scaling' in node.properties ) {
|
|
|
+
|
|
|
+ model.scale.fromArray( parseFloatArray( node.properties.Lcl_Scaling.value ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ // 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: new Map(),
|
|
|
+ stacks: new Map(),
|
|
|
+ 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 ] );
|
|
|
+ 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;
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ 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.set( parseInt( nodeID ), layer );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var nodeID in rawStacks ) {
|
|
|
+
|
|
|
+ var layers = [];
|
|
|
+ var children = connections.get( parseInt( nodeID ) ).children;
|
|
|
+ var maxTimeStamp = 0;
|
|
|
+ var minTimeStamp = Number.MAX_VALUE;
|
|
|
+ for ( var childIndex = 0; childIndex < children.length; ++ childIndex ) {
|
|
|
+
|
|
|
+ if ( returnObject.layers.has( children[ childIndex ].ID ) ) {
|
|
|
+
|
|
|
+ var currentLayer = returnObject.layers.get( children[ childIndex ].ID );
|
|
|
+ layers.push( currentLayer );
|
|
|
+
|
|
|
+ currentLayer.forEach( function ( layer ) {
|
|
|
+
|
|
|
+ if ( layer ) {
|
|
|
+
|
|
|
+ getCurveNodeMaxMinTimeStamps( layer );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 ) {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the maxTimeStamp and minTimeStamp if one of its timestamps exceeds the maximum or minimum.
|
|
|
+ * @param {{times: number[]}} axis
|
|
|
+ */
|
|
|
+ function getCurveAxisMaxMinTimeStamps( axis ) {
|
|
|
+
|
|
|
+ maxTimeStamp = axis.times[ axis.times.length - 1 ] > maxTimeStamp ? axis.times[ axis.times.length - 1 ] : maxTimeStamp;
|
|
|
+ minTimeStamp = axis.times[ 0 ] < minTimeStamp ? axis.times[ 0 ] : minTimeStamp;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( curve.x ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.x );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( curve.y ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.y );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( curve.z ) {
|
|
|
+
|
|
|
+ getCurveAxisMaxMinTimeStamps( curve.z );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( layer.R ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.R.curves );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( layer.S ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.S.curves );
|
|
|
+
|
|
|
+ }
|
|
|
+ if ( layer.T ) {
|
|
|
+
|
|
|
+ getCurveMaxMinTimeStamp( layer.T.curves );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Do we have an animation clip with actual length?
|
|
|
+ if ( maxTimeStamp > minTimeStamp ) {
|
|
|
+
|
|
|
+ returnObject.stacks.set( parseInt( nodeID ), {
|
|
|
+ name: rawStacks[ nodeID ].attrName,
|
|
|
+ layers: layers,
|
|
|
+ length: maxTimeStamp - minTimeStamp,
|
|
|
+ frames: ( maxTimeStamp - minTimeStamp ) * 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 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
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ 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 = sceneGraph.skeleton.bones.findIndex( function ( bone ) {
|
|
|
+
|
|
|
+ return bone.FBX_ID === containerIndices[ containerIndicesIndex ].ID;
|
|
|
+
|
|
|
+ } );
|
|
|
+ if ( boneID > - 1 ) {
|
|
|
+
|
|
|
+ returnObject.containerBoneID = boneID;
|
|
|
+ returnObject.containerID = containerIndices[ containerIndicesIndex ].ID;
|
|
|
+ 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( function ( time ) {
|
|
|
+
|
|
|
+ return ConvertFBXTimeToSeconds( time );
|
|
|
+
|
|
|
+ } ),
|
|
|
+ values: parseFloatArray( animationCurve.subNodes.KeyValueFloat.properties.a ),
|
|
|
+
|
|
|
+ attrFlag: parseIntArray( animationCurve.subNodes.KeyAttrFlags.properties.a ),
|
|
|
+ attrData: parseFloatArray( animationCurve.subNodes.KeyAttrDataFloat.properties.a )
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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 = [];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ animations.stacks.forEach( function ( stack ) {
|
|
|
+
|
|
|
+ var animationData = {
|
|
|
+ name: stack.name,
|
|
|
+ fps: 30,
|
|
|
+ length: stack.length,
|
|
|
+ hierarchy: []
|
|
|
+ };
|
|
|
+
|
|
|
+ var bones = group.skeleton.bones;
|
|
|
+
|
|
|
+ bones.forEach( function ( bone ) {
|
|
|
+
|
|
|
+ var name = bone.name.replace( /.*:/, '' );
|
|
|
+ var parentIndex = bones.findIndex( function ( parentBone ) {
|
|
|
+
|
|
|
+ return bone.parent === parentBone;
|
|
|
+
|
|
|
+ } );
|
|
|
+ animationData.hierarchy.push( { parent: parentIndex, name: name, keys: [] } );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ for ( var frame = 0; frame < stack.frames; frame ++ ) {
|
|
|
+
|
|
|
+ bones.forEach( function ( bone, boneIndex ) {
|
|
|
+
|
|
|
+ var animationNode = stack.layers[ 0 ][ boneIndex ];
|
|
|
+
|
|
|
+ animationData.hierarchy.forEach( function ( node ) {
|
|
|
+
|
|
|
+ if ( node.name === bone.name ) {
|
|
|
+
|
|
|
+ node.keys.push( generateKey( animationNode, bone, frame ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ group.animations.push( THREE.AnimationClip.parseAnimation( animationData, bones ) );
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {THREE.Bone} bone
|
|
|
+ */
|
|
|
+ function generateKey( 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 = degreeToRadian( animationNode.R.curves.x.values[ frame ] );
|
|
|
+ var rotationY = degreeToRadian( animationNode.R.curves.y.values[ frame ] );
|
|
|
+ var rotationZ = degreeToRadian( animationNode.R.curves.z.values[ frame ] );
|
|
|
+ var euler = new THREE.Euler( rotationX, rotationY, rotationZ, 'ZYX' );
|
|
|
+ key.rot = new THREE.Quaternion().setFromEuler( euler ).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( bone );
|
|
|
+ console.log( error );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return key;
|
|
|
+
|
|
|
+ function hasCurve( animationNode, attribute ) {
|
|
|
+
|
|
|
+ if ( animationNode === undefined ) {
|
|
|
+
|
|
|
+ return false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ var attributeNode = animationNode[ attribute ];
|
|
|
+ if ( ! attributeNode ) {
|
|
|
+
|
|
|
+ return false;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return [ 'x', 'y', 'z' ].every( function ( key ) {
|
|
|
+
|
|
|
+ return attributeNode.curves[ key ] !== undefined;
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ function hasKeyOnFrame( attributeNode, frame ) {
|
|
|
+
|
|
|
+ return [ 'x', 'y', 'z' ].every( function ( key ) {
|
|
|
+
|
|
|
+ return isKeyExistOnFrame( attributeNode.curves[ key ], frame );
|
|
|
+
|
|
|
+ function isKeyExistOnFrame( curve, frame ) {
|
|
|
+
|
|
|
+ return curve.values[ frame ] !== undefined;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ // UTILS
|
|
|
+ /**
|
|
|
+ * 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( parseFloat( property.value.x ), parseFloat( property.value.y ), parseFloat( property.value.z ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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( parseVector3( property ).toArray() );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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( );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 () {
|
|
|
+
|
|
|
+ var vertexBuffer = this.position.toArray();
|
|
|
+ var normalBuffer = this.normal.toArray();
|
|
|
+ var uvBuffer = this.uv.toArray();
|
|
|
+ var skinIndexBuffer = this.skinIndices.toArray();
|
|
|
+ var skinWeightBuffer = this.skinWeights.toArray();
|
|
|
+
|
|
|
+ return {
|
|
|
+ vertexBuffer: vertexBuffer,
|
|
|
+ normalBuffer: normalBuffer,
|
|
|
+ uvBuffer: uvBuffer,
|
|
|
+ skinIndexBuffer: skinIndexBuffer,
|
|
|
+ skinWeightBuffer: skinWeightBuffer,
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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 () {
|
|
|
+
|
|
|
+ var vertexBuffer = [];
|
|
|
+ var normalBuffer = [];
|
|
|
+ var uvBuffer = [];
|
|
|
+ var skinIndexBuffer = [];
|
|
|
+ var skinWeightBuffer = [];
|
|
|
+
|
|
|
+ this.vertices.forEach( function ( vertex ) {
|
|
|
+
|
|
|
+ var flatVertex = vertex.flattenToBuffers();
|
|
|
+ vertexBuffer = vertexBuffer.concat( flatVertex.vertexBuffer );
|
|
|
+ normalBuffer = normalBuffer.concat( flatVertex.normalBuffer );
|
|
|
+ uvBuffer = uvBuffer.concat( flatVertex.uvBuffer );
|
|
|
+ skinIndexBuffer = skinIndexBuffer.concat( flatVertex.skinIndexBuffer );
|
|
|
+ skinWeightBuffer = skinWeightBuffer.concat( flatVertex.skinWeightBuffer );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ return {
|
|
|
+ vertexBuffer: vertexBuffer,
|
|
|
+ normalBuffer: normalBuffer,
|
|
|
+ uvBuffer: uvBuffer,
|
|
|
+ skinIndexBuffer: skinIndexBuffer,
|
|
|
+ skinWeightBuffer: 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 () {
|
|
|
+
|
|
|
+ var vertexBuffer = [];
|
|
|
+ var normalBuffer = [];
|
|
|
+ var uvBuffer = [];
|
|
|
+ var skinIndexBuffer = [];
|
|
|
+ var skinWeightBuffer = [];
|
|
|
+
|
|
|
+ var materialIndexBuffer = [];
|
|
|
+
|
|
|
+ var materialIndex = this.materialIndex;
|
|
|
+
|
|
|
+ this.triangles.forEach( function ( triangle ) {
|
|
|
+
|
|
|
+ var flatTriangle = triangle.flattenToBuffers();
|
|
|
+ vertexBuffer = vertexBuffer.concat( flatTriangle.vertexBuffer );
|
|
|
+ normalBuffer = normalBuffer.concat( flatTriangle.normalBuffer );
|
|
|
+ uvBuffer = uvBuffer.concat( flatTriangle.uvBuffer );
|
|
|
+ skinIndexBuffer = skinIndexBuffer.concat( flatTriangle.skinIndexBuffer );
|
|
|
+ skinWeightBuffer = skinWeightBuffer.concat( flatTriangle.skinWeightBuffer );
|
|
|
+ materialIndexBuffer = materialIndexBuffer.concat( [ materialIndex, materialIndex, materialIndex ] );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ return {
|
|
|
+ vertexBuffer: vertexBuffer,
|
|
|
+ normalBuffer: normalBuffer,
|
|
|
+ uvBuffer: uvBuffer,
|
|
|
+ skinIndexBuffer: skinIndexBuffer,
|
|
|
+ skinWeightBuffer: skinWeightBuffer,
|
|
|
+ materialIndexBuffer: materialIndexBuffer
|
|
|
+ };
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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 skinIndexBuffer = [];
|
|
|
+ var skinWeightBuffer = [];
|
|
|
+
|
|
|
+ var materialIndexBuffer = [];
|
|
|
+
|
|
|
+ this.faces.forEach( function ( face ) {
|
|
|
+
|
|
|
+ var flatFace = face.flattenToBuffers();
|
|
|
+ vertexBuffer = vertexBuffer.concat( flatFace.vertexBuffer );
|
|
|
+ normalBuffer = normalBuffer.concat( flatFace.normalBuffer );
|
|
|
+ uvBuffer = uvBuffer.concat( flatFace.uvBuffer );
|
|
|
+ skinIndexBuffer = skinIndexBuffer.concat( flatFace.skinIndexBuffer );
|
|
|
+ skinWeightBuffer = skinWeightBuffer.concat( flatFace.skinWeightBuffer );
|
|
|
+ materialIndexBuffer = materialIndexBuffer.concat( flatFace.materialIndexBuffer );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ return {
|
|
|
+ vertexBuffer: vertexBuffer,
|
|
|
+ normalBuffer: normalBuffer,
|
|
|
+ uvBuffer: uvBuffer,
|
|
|
+ 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 line in split ) {
|
|
|
+
|
|
|
+ var l = split[ line ];
|
|
|
+
|
|
|
+ // short cut
|
|
|
+ if ( l.match( /^[\s\t]*;/ ) ) {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ } // skip comment line
|
|
|
+ if ( l.match( /^[\s\t]*$/ ) ) {
|
|
|
+
|
|
|
+ continue;
|
|
|
+
|
|
|
+ } // skip empty line
|
|
|
+
|
|
|
+ // 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( ',' ).map( function ( element ) {
|
|
|
+
|
|
|
+ return element.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();
|
|
|
+
|
|
|
+ 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;
|
|
|
+ var 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 chilren 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 ];
|
|
|
+ propValue = propValue.concat( 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( '",' ).map( function ( element ) {
|
|
|
+
|
|
|
+ return element.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":
|
|
|
+ var tmp = innerPropValue.split( ',' );
|
|
|
+ innerPropValue = new THREE.Vector3( tmp[ 0 ], tmp[ 1 ], tmp[ 2 ] );
|
|
|
+ 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;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ 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 ) {
|
|
|
+
|
|
|
+ this.__cache_search_connection_parent[ id ] = this.__cache_search_connection_parent[ id ].concat( 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 ) {
|
|
|
+
|
|
|
+ this.__cache_search_connection_children[ id ] = this.__cache_search_connection_children[ id ].concat( 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;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @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;
|
|
|
+ var read = function ( 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( '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( floatString ) {
|
|
|
+
|
|
|
+ return floatString.split( ',' ).map( function ( stringValue ) {
|
|
|
+
|
|
|
+ return parseFloat( stringValue );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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( intString ) {
|
|
|
+
|
|
|
+ return intString.split( ',' ).map( function ( stringValue ) {
|
|
|
+
|
|
|
+ return parseInt( stringValue );
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ function parseMatrixArray( floatString ) {
|
|
|
+
|
|
|
+ return new THREE.Matrix4().fromArray( parseFloatArray( floatString ) );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Converts number from degrees into radians.
|
|
|
+ * @param {number} value
|
|
|
+ * @returns {number}
|
|
|
+ */
|
|
|
+ function degreeToRadian( value ) {
|
|
|
+
|
|
|
+ return value * Math.PI / 180;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+} )();
|
Kyle Larson