@blockv/threejs-to-v3d
Version:
Converts any format supported by ThreeJS to V3D.
1,757 lines (1,191 loc) • 117 kB
JavaScript
/**
* @author Kyle-Larson https://github.com/Kyle-Larson
* @author Takahiro https://github.com/takahirox
*
* Loader loads FBX file and generates Group representing FBX scene.
* Requires FBX file to be >= 7.0 and in ASCII or to be any version in Binary format.
*
* Supports:
* Mesh Generation (Positional Data)
* Normal Data (Per Vertex Drawing Instance)
* UV Data (Per Vertex Drawing Instance)
* Skinning
* Animation
* - Separated Animations based on stacks.
* - Skeletal & Non-Skeletal Animations
* NURBS (Open, Closed and Periodic forms)
*
* Needs Support:
* Indexed Buffers
* PreRotation support.
*/
// Simulate global window
var window = {};
// Simulate global document
var document = {};
window.document = document;
// Import dependencies
var Zlib = require("zlibjs/bin/inflate.min.js").Zlib;
window.Zlib = Zlib;
module.exports = ( function (THREE, CUSTOM_RESOURCE_LOADER) {
/**
* 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 ) {
this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
};
Object.assign( THREE.FBXLoader.prototype, {
/**
* Loads an ASCII/Binary FBX file from URL and parses into a THREE.Group.
* THREE.Group will have an animations property of AnimationClips
* of the different animations exported with the FBX.
* @param {string} url - URL of the FBX file.
* @param {function(THREE.Group):void} onLoad - Callback for when FBX file is loaded and parsed.
* @param {function(ProgressEvent):void} onProgress - Callback fired periodically when file is being retrieved from server.
* @param {function(Event):void} onError - Callback fired when error occurs (Currently only with retrieving file, not with parsing errors).
*/
load: function ( url, onLoad, onProgress, onError ) {
var self = this;
var resourceDirectory = url.split( /[\\\/]/ );
resourceDirectory.pop();
resourceDirectory = resourceDirectory.join( '/' ) + '/';
var loader = new THREE.FileLoader( this.manager );
loader.setResponseType( 'arraybuffer' );
loader.load( url, function ( buffer ) {
try {
var scene = self.parse( buffer, resourceDirectory );
onLoad( scene );
} catch ( error ) {
window.setTimeout( function () {
if ( onError ) onError( error );
self.manager.itemError( url );
}, 0 );
}
}, onProgress, onError );
},
/**
* Parses an ASCII/Binary FBX file and returns a THREE.Group.
* THREE.Group will have an animations property of AnimationClips
* of the different animations within the FBX file.
* @param {ArrayBuffer} FBXBuffer - Contents of FBX file to parse.
* @param {string} resourceDirectory - Directory to load external assets (e.g. textures ) from.
* @returns {THREE.Group}
*/
parse: function ( FBXBuffer, resourceDirectory ) {
var FBXTree;
if ( isFbxFormatBinary( FBXBuffer ) ) {
FBXTree = new BinaryParser().parse( FBXBuffer );
} else {
var FBXText = convertArrayBufferToString( FBXBuffer );
if ( ! isFbxFormatASCII( FBXText ) ) {
self.manager.itemError( url );
throw new Error( 'FBXLoader: Unknown format.' );
}
if ( getFbxVersion( FBXText ) < 7000 ) {
self.manager.itemError( url );
throw new Error( 'FBXLoader: FBX version not supported for file at ' + url + ', FileVersion: ' + getFbxVersion( FBXText ) );
}
FBXTree = new TextParser().parse( FBXText );
}
// console.log( FBXTree );
var connections = parseConnections( FBXTree );
var images = parseImages( FBXTree );
var textures = parseTextures( FBXTree, CUSTOM_RESOURCE_LOADER || new THREE.TextureLoader( this.manager ).setPath( resourceDirectory ), images, connections );
var materials = parseMaterials( FBXTree, textures, connections );
var deformers = parseDeformers( FBXTree, connections );
var geometryMap = parseGeometries( FBXTree, connections, deformers );
var sceneGraph = parseScene( FBXTree, connections, deformers, geometryMap, materials );
return sceneGraph;
}
} );
/**
* Parses map of relationships between objects.
* @param {{Connections: { properties: { connections: [number, number, string][]}}}} FBXTree
* @returns {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>}
*/
function parseConnections( FBXTree ) {
/**
* @type {Map<number, { parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>}
*/
var connectionMap = new Map();
if ( 'Connections' in FBXTree ) {
/**
* @type {[number, number, string][]}
*/
var connectionArray = FBXTree.Connections.properties.connections;
for ( var connectionArrayIndex = 0, connectionArrayLength = connectionArray.length; connectionArrayIndex < connectionArrayLength; ++ connectionArrayIndex ) {
var connection = connectionArray[ connectionArrayIndex ];
if ( ! connectionMap.has( connection[ 0 ] ) ) {
connectionMap.set( connection[ 0 ], {
parents: [],
children: []
} );
}
var parentRelationship = { ID: connection[ 1 ], relationship: connection[ 2 ] };
connectionMap.get( connection[ 0 ] ).parents.push( parentRelationship );
if ( ! connectionMap.has( connection[ 1 ] ) ) {
connectionMap.set( connection[ 1 ], {
parents: [],
children: []
} );
}
var childRelationship = { ID: connection[ 0 ], relationship: connection[ 2 ] };
connectionMap.get( connection[ 1 ] ).children.push( childRelationship );
}
}
return connectionMap;
}
/**
* Parses map of images referenced in FBXTree.
* @param {{Objects: {subNodes: {Texture: Object.<string, FBXTextureNode>}}}} FBXTree
* @returns {Map<number, string(image blob URL)>}
*/
function parseImages( FBXTree ) {
/**
* @type {Map<number, string(image blob URL)>}
*/
var imageMap = new Map();
if ( 'Video' in FBXTree.Objects.subNodes ) {
var videoNodes = FBXTree.Objects.subNodes.Video;
for ( var nodeID in videoNodes ) {
var videoNode = videoNodes[ nodeID ];
// raw image data is in videoNode.properties.Content
if ( 'Content' in videoNode.properties ) {
var image = parseImage( videoNodes[ nodeID ] );
imageMap.set( parseInt( nodeID ), image );
}
}
}
return imageMap;
}
/**
* @param {videoNode} videoNode - Node to get texture image information from.
* @returns {string} - image blob URL
*/
function parseImage( videoNode ) {
var buffer = videoNode.properties.Content;
var array = new Uint8Array( buffer );
var fileName = videoNode.properties.RelativeFilename || videoNode.properties.Filename;
var extension = fileName.slice( fileName.lastIndexOf( '.' ) + 1 ).toLowerCase();
var type;
switch ( extension ) {
case 'bmp':
type = 'image/bmp';
break;
case 'jpg':
type = 'image/jpeg';
break;
case 'png':
type = 'image/png';
break;
case 'tif':
type = 'image/tiff';
break;
default:
console.warn( 'FBXLoader: No support image type ' + extension );
return;
}
// Store ArrayBuffer of the texture for exporting to v3d later!
return {
type: "arraybuffer",
mimetype: type,
data: buffer
};//window.URL.createObjectURL( new Blob( [ array ], { type: type } ) );
}
/**
* Parses map of textures referenced in FBXTree.
* @param {{Objects: {subNodes: {Texture: Object.<string, FBXTextureNode>}}}} FBXTree
* @param {THREE.TextureLoader} loader
* @param {Map<number, string(image blob URL)>} imageMap
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @returns {Map<number, THREE.Texture>}
*/
function parseTextures( FBXTree, loader, imageMap, connections ) {
/**
* @type {Map<number, THREE.Texture>}
*/
var textureMap = new Map();
if ( 'Texture' in FBXTree.Objects.subNodes ) {
var textureNodes = FBXTree.Objects.subNodes.Texture;
for ( var nodeID in textureNodes ) {
var texture = parseTexture( textureNodes[ nodeID ], loader, imageMap, connections );
textureMap.set( parseInt( nodeID ), texture );
}
}
return textureMap;
}
/**
* @param {textureNode} textureNode - Node to get texture information from.
* @param {THREE.TextureLoader} loader
* @param {Map<number, string(image blob URL)>} imageMap
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @returns {THREE.Texture}
*/
function parseTexture( textureNode, loader, imageMap, connections ) {
var FBX_ID = textureNode.id;
var name = textureNode.name;
var fileName;
var filePath = textureNode.properties.FileName;
var relativeFilePath = textureNode.properties.RelativeFilename;
var children = connections.get( FBX_ID ).children;
if ( children !== undefined && children.length > 0 && imageMap.has( children[ 0 ].ID ) ) {
fileName = imageMap.get( children[ 0 ].ID );
} else if ( relativeFilePath !== undefined && relativeFilePath[ 0 ] !== '/' &&
relativeFilePath.match( /^[a-zA-Z]:/ ) === null ) {
// use textureNode.properties.RelativeFilename
// if it exists and it doesn't seem an absolute path
fileName = relativeFilePath;
} else {
var split = filePath.split( /[\\\/]/ );
if ( split.length > 0 ) {
fileName = split[ split.length - 1 ];
} else {
fileName = filePath;
}
}
var currentPath = loader.path;
// HACK: We return an object instead of the expected string if loading embedded textures.
if ( fileName && fileName.type == "arraybuffer") {
var tex = new THREE.Texture();
tex.arrayBuffer = fileName.data;
tex.mimetype = fileName.mimetype;
tex.wrapS = THREE.RepeatWrapping;
tex.wrapT = THREE.RepeatWrapping;
return tex;
}
if ( fileName && fileName.indexOf( 'blob:' ) === 0 ) {
loader.setPath( undefined );
}
/**
* @type {THREE.Texture}
*/
var texture = loader.load( fileName );
texture.name = name;
texture.FBX_ID = FBX_ID;
loader.setPath( currentPath );
return texture;
}
/**
* Parses map of Material information.
* @param {{Objects: {subNodes: {Material: Object.<number, FBXMaterialNode>}}}} FBXTree
* @param {Map<number, THREE.Texture>} textureMap
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @returns {Map<number, THREE.Material>}
*/
function parseMaterials( FBXTree, textureMap, connections ) {
var materialMap = new Map();
if ( 'Material' in FBXTree.Objects.subNodes ) {
var materialNodes = FBXTree.Objects.subNodes.Material;
for ( var nodeID in materialNodes ) {
var material = parseMaterial( materialNodes[ nodeID ], textureMap, connections );
materialMap.set( parseInt( nodeID ), material );
}
}
return materialMap;
}
/**
* Takes information from Material node and returns a generated THREE.Material
* @param {FBXMaterialNode} materialNode
* @param {Map<number, THREE.Texture>} textureMap
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @returns {THREE.Material}
*/
function parseMaterial( materialNode, textureMap, connections ) {
var FBX_ID = materialNode.id;
var name = materialNode.attrName;
var type = materialNode.properties.ShadingModel;
//Case where FBXs wrap shading model in property object.
if ( typeof type === 'object' ) {
type = type.value;
}
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;
}
for ( var childrenRelationshipsIndex = 0, childrenRelationshipsLength = childrenRelationships.length; childrenRelationshipsIndex < childrenRelationshipsLength; ++ childrenRelationshipsIndex ) {
var relationship = childrenRelationships[ childrenRelationshipsIndex ];
var type = relationship.relationship;
switch ( type ) {
case "DiffuseColor":
case " \"DiffuseColor":
parameters.map = textureMap.get( relationship.ID );
if (!parameters.map) {
console.warn("WARNING: Invalid relationship ID in FBX file! We've used the first texture, but that's probably wrong!");
for (var itms of textureMap) {
parameters.map = itms[1];
if (parameters.map)
break;
}
}
break;
case "Bump":
case " \"Bump":
parameters.bumpMap = textureMap.get( relationship.ID );
break;
case "NormalMap":
case " \"NormalMap":
parameters.normalMap = textureMap.get( relationship.ID );
break;
case " \"AmbientColor":
case " \"EmissiveColor":
case "AmbientColor":
case "EmissiveColor":
default:
console.warn( '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 deformers = {};
if ( 'Deformer' in FBXTree.Objects.subNodes ) {
var DeformerNodes = FBXTree.Objects.subNodes.Deformer;
for ( var nodeID in DeformerNodes ) {
var deformerNode = DeformerNodes[ nodeID ];
if ( deformerNode.attrType === 'Skin' ) {
var conns = connections.get( parseInt( nodeID ) );
var skeleton = parseSkeleton( conns, DeformerNodes );
skeleton.FBX_ID = parseInt( nodeID );
deformers[ nodeID ] = skeleton;
}
}
}
return deformers;
}
/**
* Generates a "Skeleton Representation" of FBX nodes based on an FBX Skin Deformer's connections and an object containing SubDeformer nodes.
* @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} connections
* @param {Object.<number, FBXSubDeformerNode>} DeformerNodes
* @returns {{map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}}
*/
function parseSkeleton( connections, DeformerNodes ) {
var subDeformers = {};
var children = connections.children;
for ( var i = 0, l = children.length; i < l; ++ i ) {
var child = children[ i ];
var subDeformerNode = DeformerNodes[ child.ID ];
var subDeformer = {
FBX_ID: child.ID,
index: i,
indices: [],
weights: [],
transform: parseMatrixArray( subDeformerNode.subNodes.Transform.properties.a ),
transformLink: parseMatrixArray( subDeformerNode.subNodes.TransformLink.properties.a ),
linkMode: subDeformerNode.properties.Mode
};
if ( 'Indexes' in subDeformerNode.subNodes ) {
subDeformer.indices = parseIntArray( subDeformerNode.subNodes.Indexes.properties.a );
subDeformer.weights = parseFloatArray( subDeformerNode.subNodes.Weights.properties.a );
}
subDeformers[ child.ID ] = subDeformer;
}
return {
map: subDeformers,
bones: []
};
}
/**
* Generates Buffer geometries from geometry information in FBXTree, and generates map of THREE.BufferGeometries
* @param {{Objects: {subNodes: {Geometry: Object.<number, FBXGeometryNode}}}} FBXTree
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}>} deformers
* @returns {Map<number, THREE.BufferGeometry>}
*/
function parseGeometries( FBXTree, connections, deformers ) {
var geometryMap = new Map();
if ( 'Geometry' in FBXTree.Objects.subNodes ) {
var geometryNodes = FBXTree.Objects.subNodes.Geometry;
for ( var nodeID in geometryNodes ) {
var relationships = connections.get( parseInt( nodeID ) );
var geo = parseGeometry( geometryNodes[ nodeID ], relationships, deformers );
geometryMap.set( parseInt( nodeID ), geo );
}
}
return geometryMap;
}
/**
* Generates BufferGeometry from FBXGeometryNode.
* @param {FBXGeometryNode} geometryNode
* @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships
* @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}>} deformers
* @returns {THREE.BufferGeometry}
*/
function parseGeometry( geometryNode, relationships, deformers ) {
switch ( geometryNode.attrType ) {
case 'Mesh':
return parseMeshGeometry( geometryNode, relationships, deformers );
break;
case 'NurbsCurve':
return parseNurbsGeometry( geometryNode );
break;
}
}
/**
* Specialty function for parsing Mesh based Geometry Nodes.
* @param {FBXGeometryNode} geometryNode
* @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships - Object representing relationships between specific geometry node and other nodes.
* @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}>} deformers - Map object of deformers and subDeformers by ID.
* @returns {THREE.BufferGeometry}
*/
function parseMeshGeometry( geometryNode, relationships, deformers ) {
for ( var i = 0; i < relationships.children.length; ++ i ) {
var deformer = deformers[ relationships.children[ i ].ID ];
if ( deformer !== undefined ) break;
}
return genGeometry( geometryNode, deformer );
}
/**
* @param {{map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[]}} deformer - Skeleton representation for geometry instance.
* @returns {THREE.BufferGeometry}
*/
function genGeometry( geometryNode, deformer ) {
var geometry = new Geometry();
var subNodes = geometryNode.subNodes;
// First, each index is going to be its own vertex.
var vertexBuffer = parseFloatArray( subNodes.Vertices.properties.a );
var indexBuffer = parseIntArray( subNodes.PolygonVertexIndex.properties.a );
if ( subNodes.LayerElementNormal ) {
var normalInfo = getNormals( subNodes.LayerElementNormal[ 0 ] );
}
if ( subNodes.LayerElementUV ) {
var uvInfo = getUVs( subNodes.LayerElementUV[ 0 ] );
}
if ( subNodes.LayerElementColor ) {
var colorInfo = getColors( subNodes.LayerElementColor[ 0 ] );
}
if ( subNodes.LayerElementMaterial ) {
var materialInfo = getMaterials( subNodes.LayerElementMaterial[ 0 ] );
}
var faceVertexBuffer = [];
var polygonIndex = 0;
for ( var polygonVertexIndex = 0; polygonVertexIndex < indexBuffer.length; polygonVertexIndex ++ ) {
var vertexIndex = indexBuffer[ polygonVertexIndex ];
var endOfFace = false;
if ( vertexIndex < 0 ) {
vertexIndex = vertexIndex ^ - 1;
indexBuffer[ polygonVertexIndex ] = vertexIndex;
endOfFace = true;
}
var vertex = new Vertex();
var weightIndices = [];
var weights = [];
vertex.position.fromArray( vertexBuffer, vertexIndex * 3 );
if ( deformer ) {
var subDeformers = deformer.map;
for ( var key in subDeformers ) {
var subDeformer = subDeformers[ key ];
var indices = subDeformer.indices;
for ( var j = 0; j < indices.length; j ++ ) {
var index = indices[ j ];
if ( index === vertexIndex ) {
weights.push( subDeformer.weights[ j ] );
weightIndices.push( subDeformer.index );
break;
}
}
}
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 ];
weights.forEach( function ( weight, weightIndex ) {
var currentWeight = weight;
var currentIndex = weightIndices[ weightIndex ];
Weight.forEach( function ( comparedWeight, comparedWeightIndex, comparedWeightArray ) {
if ( currentWeight > comparedWeight ) {
comparedWeightArray[ comparedWeightIndex ] = currentWeight;
currentWeight = comparedWeight;
var tmp = WIndex[ comparedWeightIndex ];
WIndex[ comparedWeightIndex ] = currentIndex;
currentIndex = tmp;
}
} );
} );
weightIndices = WIndex;
weights = Weight;
}
for ( var i = weights.length; i < 4; ++ i ) {
weights[ i ] = 0;
weightIndices[ i ] = 0;
}
vertex.skinWeights.fromArray( weights );
vertex.skinIndices.fromArray( weightIndices );
}
if ( normalInfo ) {
vertex.normal.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, normalInfo ) );
}
if ( uvInfo ) {
vertex.uv.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, uvInfo ) );
}
if ( colorInfo ) {
vertex.color.fromArray( getData( polygonVertexIndex, polygonIndex, vertexIndex, colorInfo ) );
}
faceVertexBuffer.push( vertex );
if ( endOfFace ) {
var face = new Face();
face.genTrianglesFromVertices( faceVertexBuffer );
if ( materialInfo !== undefined ) {
var materials = getData( polygonVertexIndex, polygonIndex, vertexIndex, materialInfo );
face.materialIndex = materials[ 0 ];
} else {
// Seems like some models don't have materialInfo(subNodes.LayerElementMaterial).
// Set 0 in such a case.
face.materialIndex = 0;
}
geometry.faces.push( face );
faceVertexBuffer = [];
polygonIndex ++;
endOfFace = false;
}
}
/**
* @type {{vertexBuffer: number[], normalBuffer: number[], uvBuffer: number[], skinIndexBuffer: number[], skinWeightBuffer: number[], materialIndexBuffer: number[]}}
*/
var bufferInfo = geometry.flattenToBuffers();
var geo = new THREE.BufferGeometry();
geo.name = geometryNode.name;
geo.addAttribute( 'position', new THREE.Float32BufferAttribute( bufferInfo.vertexBuffer, 3 ) );
if ( bufferInfo.normalBuffer.length > 0 ) {
geo.addAttribute( 'normal', new THREE.Float32BufferAttribute( bufferInfo.normalBuffer, 3 ) );
}
if ( bufferInfo.uvBuffer.length > 0 ) {
geo.addAttribute( 'uv', new THREE.Float32BufferAttribute( bufferInfo.uvBuffer, 2 ) );
}
if ( subNodes.LayerElementColor ) {
geo.addAttribute( 'color', new THREE.Float32BufferAttribute( bufferInfo.colorBuffer, 3 ) );
}
if ( deformer ) {
geo.addAttribute( 'skinIndex', new THREE.Float32BufferAttribute( bufferInfo.skinIndexBuffer, 4 ) );
geo.addAttribute( 'skinWeight', new THREE.Float32BufferAttribute( bufferInfo.skinWeightBuffer, 4 ) );
geo.FBX_Deformer = deformer;
}
// Convert the material indices of each vertex into rendering groups on the geometry.
var materialIndexBuffer = bufferInfo.materialIndexBuffer;
var prevMaterialIndex = materialIndexBuffer[ 0 ];
var startIndex = 0;
for ( var i = 0; i < materialIndexBuffer.length; ++ i ) {
if ( materialIndexBuffer[ i ] !== prevMaterialIndex ) {
geo.addGroup( startIndex, i - startIndex, prevMaterialIndex );
prevMaterialIndex = materialIndexBuffer[ i ];
startIndex = i;
}
}
return geo;
}
/**
* Parses normal information for geometry.
* @param {FBXGeometryNode} geometryNode
* @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
*/
function getNormals( NormalNode ) {
var mappingType = NormalNode.properties.MappingInformationType;
var referenceType = NormalNode.properties.ReferenceInformationType;
var buffer = parseFloatArray( NormalNode.subNodes.Normals.properties.a );
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
if ( 'NormalIndex' in NormalNode.subNodes ) {
indexBuffer = parseIntArray( NormalNode.subNodes.NormalIndex.properties.a );
} else if ( 'NormalsIndex' in NormalNode.subNodes ) {
indexBuffer = parseIntArray( NormalNode.subNodes.NormalsIndex.properties.a );
}
}
return {
dataSize: 3,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
}
/**
* Parses UV information for geometry.
* @param {FBXGeometryNode} geometryNode
* @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
*/
function getUVs( UVNode ) {
var mappingType = UVNode.properties.MappingInformationType;
var referenceType = UVNode.properties.ReferenceInformationType;
var buffer = parseFloatArray( UVNode.subNodes.UV.properties.a );
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
indexBuffer = parseIntArray( UVNode.subNodes.UVIndex.properties.a );
}
return {
dataSize: 2,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
}
/**
* Parses Vertex Color information for geometry.
* @param {FBXGeometryNode} geometryNode
* @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
*/
function getColors( ColorNode ) {
var mappingType = ColorNode.properties.MappingInformationType;
var referenceType = ColorNode.properties.ReferenceInformationType;
var buffer = parseFloatArray( ColorNode.subNodes.Colors.properties.a );
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
indexBuffer = parseFloatArray( ColorNode.subNodes.ColorIndex.properties.a );
}
return {
dataSize: 4,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
}
/**
* Parses material application information for geometry.
* @param {FBXGeometryNode}
* @returns {{dataSize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}}
*/
function getMaterials( MaterialNode ) {
var mappingType = MaterialNode.properties.MappingInformationType;
var referenceType = MaterialNode.properties.ReferenceInformationType;
if ( mappingType === 'NoMappingInformation' ) {
return {
dataSize: 1,
buffer: [ 0 ],
indices: [ 0 ],
mappingType: 'AllSame',
referenceType: referenceType
};
}
var materialIndexBuffer = parseIntArray( MaterialNode.subNodes.Materials.properties.a );
// Since materials are stored as indices, there's a bit of a mismatch between FBX and what
// we expect. So we create an intermediate buffer that points to the index in the buffer,
// for conforming with the other functions we've written for other data.
var materialIndices = [];
for ( var materialIndexBufferIndex = 0, materialIndexBufferLength = materialIndexBuffer.length; materialIndexBufferIndex < materialIndexBufferLength; ++ materialIndexBufferIndex ) {
materialIndices.push( materialIndexBufferIndex );
}
return {
dataSize: 1,
buffer: materialIndexBuffer,
indices: materialIndices,
mappingType: mappingType,
referenceType: referenceType
};
}
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
var dataArray = [];
var GetData = {
ByPolygonVertex: {
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var from = ( polygonVertexIndex * infoObject.dataSize );
var to = ( polygonVertexIndex * infoObject.dataSize ) + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
},
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var index = infoObject.indices[ polygonVertexIndex ];
var from = ( index * infoObject.dataSize );
var to = ( index * infoObject.dataSize ) + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
}
},
ByPolygon: {
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var from = polygonIndex * infoObject.dataSize;
var to = polygonIndex * infoObject.dataSize + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
},
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var index = infoObject.indices[ polygonIndex ];
var from = index * infoObject.dataSize;
var to = index * infoObject.dataSize + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
}
},
ByVertice: {
Direct: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var from = ( vertexIndex * infoObject.dataSize );
var to = ( vertexIndex * infoObject.dataSize ) + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
}
},
AllSame: {
/**
* Function uses the infoObject and given indices to return value array of object.
* @param {number} polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
* @param {number} polygonIndex - Index of polygon in geometry.
* @param {number} vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
* @param {{datasize: number, buffer: number[], indices: number[], mappingType: string, referenceType: string}} infoObject - Object containing data and how to access data.
* @returns {number[]}
*/
IndexToDirect: function ( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var from = infoObject.indices[ 0 ] * infoObject.dataSize;
var to = infoObject.indices[ 0 ] * infoObject.dataSize + infoObject.dataSize;
// return infoObject.buffer.slice( from, to );
return slice( dataArray, infoObject.buffer, from, to );
}
}
};
function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
return GetData[ infoObject.mappingType ][ infoObject.referenceType ]( polygonVertexIndex, polygonIndex, vertexIndex, infoObject );
}
/**
* Specialty function for parsing NurbsCurve based Geometry Nodes.
* @param {FBXGeometryNode} geometryNode
* @param {{parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}} relationships
* @returns {THREE.BufferGeometry}
*/
function parseNurbsGeometry( geometryNode ) {
if ( THREE.NURBSCurve === undefined ) {
console.error( "THREE.FBXLoader 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 degree = order - 1;
var knots = parseFloatArray( geometryNode.subNodes.KnotVector.properties.a );
var controlPoints = [];
var pointsValues = parseFloatArray( geometryNode.subNodes.Points.properties.a );
for ( var i = 0, l = pointsValues.length; i < l; i += 4 ) {
controlPoints.push( new THREE.Vector4().fromArray( pointsValues, i ) );
}
var startKnot, endKnot;
if ( geometryNode.properties.Form === 'Closed' ) {
controlPoints.push( controlPoints[ 0 ] );
} else if ( geometryNode.properties.Form === 'Periodic' ) {
startKnot = degree;
endKnot = knots.length - 1 - startKnot;
for ( var i = 0; i < degree; ++ i ) {
controlPoints.push( controlPoints[ i ] );
}
}
var curve = new THREE.NURBSCurve( degree, knots, controlPoints, startKnot, endKnot );
var vertices = curve.getPoints( controlPoints.length * 7 );
var positions = new Float32Array( vertices.length * 3 );
for ( var i = 0, l = vertices.length; i < l; ++ i ) {
vertices[ i ].toArray( positions, i * 3 );
}
var geometry = new THREE.BufferGeometry();
geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
return geometry;
}
/**
* Finally generates Scene graph and Scene graph Objects.
* @param {{Objects: {subNodes: {Model: Object.<number, FBXModelNode>}}}} FBXTree
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
* @param {Map<number, {map: Map<number, {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}>, array: {FBX_ID: number, indices: number[], weights: number[], transform: number[], transformLink: number[], linkMode: string}[], skeleton: THREE.Skeleton|null}>} deformers
* @param {Map<number, THREE.BufferGeometry>} geometryMap
* @param {Map<number, THREE.Material>} materialMap
* @returns {THREE.Group}
*/
function parseScene( FBXTree, connections, deformers, geometryMap, materialMap ) {
var sceneGraph = new THREE.Group();
var ModelNode = FBXTree.Objects.subNodes.Model;
/**
* @type {Array.<THREE.Object3D>}
*/
var modelArray = [];
/**
* @type {Map.<number, THREE.Object3D>}
*/
var modelMap = new Map();
for ( var nodeID in ModelNode ) {
var id = parseInt( nodeID );
var node = ModelNode[ nodeID ];
var conns = connections.get( id );
var model = null;
for ( var i = 0; i < conns.parents.length; ++ i ) {
for ( var FBX_ID in deformers ) {
var deformer = deformers[ FBX_ID ];
var subDeformers = deformer.map;
var subDeformer = subDeformers[ conns.parents[ i ].ID ];
if ( subDeformer ) {
var model2 = model;
model = new THREE.Bone();
deformer.bones[ subDeformer.index ] = model;
// seems like we need this not to make non-connected bone, maybe?
// TODO: confirm
if ( model2 !== null ) model.add( model2 );
}
}
}
if ( ! model ) {
switch ( node.attrType ) {
case "Mesh":
/**
* @type {?THREE.BufferGeometry}
*/
var geometry = null;
/**
* @type {THREE.MultiMaterial|THREE.Material}
*/
var material = null;
/**
* @type {Array.<THREE.Material>}
*/
var materials = [];
for ( var childrenIndex = 0, childrenLength = conns.children.length; childrenIndex < childrenLength; ++ childrenIndex ) {
var child = conns.children[ childrenIndex ];
if ( geometryMap.has( child.ID ) ) {
geometry = geometryMap.get( child.ID );
}
if ( materialMap.has( child.ID ) ) {
materials.push( materialMap.get( child.ID ) );
}
}
if ( materials.length > 1 ) {
material = materials;
} else if ( materials.length > 0 ) {
material = materials[ 0 ];
} else {
material = new THREE.MeshBasicMaterial( { color: 0x3300ff } );
materials.push( material );
}
if ( 'color' in geometry.attributes ) {
for ( var materialIndex = 0, numMaterials = materials.length; materialIndex < numMaterials; ++materialIndex ) {
materials[ materialIndex ].vertexColors = THREE.VertexColors;
}
}
if ( geometry.FBX_Deformer ) {
for ( var materialsIndex = 0, materialsLength = materials.length; materialsIndex < materialsLength; ++ materialsIndex ) {
materials[ materialsIndex ].skinning = true;
}
model = new THREE.SkinnedMesh( geometry, material );
} else {
model = new THREE.Mesh( geometry, material );
}
break;
case "NurbsCurve":
var geometry = null;
for ( var childrenIndex = 0, childrenLength = conns.children.length; childrenIndex < childrenLength; ++ childrenIndex ) {
var child = conns.children[ childrenIndex ];
if ( geometryMap.has( child.ID ) ) {
geometry = geometryMap.get( child.ID );
}
}
// FBX does not list materials for Nurbs lines, so we'll just put our own in here.
material = new THREE.LineBasicMaterial( { color: 0x3300ff, linewidth: 5 } );
model = new THREE.Line( geometry, material );
break;
default:
model = new THREE.Object3D();
break;
}
}
model.name = node.attrName.replace( /:/, '' ).replace( /_/, '' ).replace( /-/, '' );
model.FBX_ID = id;
modelArray.push( model );
modelMap.set( id, model );
}
for ( var modelArrayIndex = 0, modelArrayLength = modelArray.length; modelArrayIndex < modelArrayLength; ++ modelArrayIndex ) {
var model = modelArray[ modelArrayIndex ];
var node = ModelNode[ model.FBX_ID ];
if ( 'Lcl_Translation' in node.properties ) {
model.position.fromArray( parseFloatArray( node.properties.Lcl_Translation.value ) );
}
if ( 'Lcl_Rotation' in node.properties ) {
var rotation = parseFloatArray( node.properties.Lcl_Rotation.value ).map( degreeToRadian );
rotation.push( 'ZYX' );
model.rotation.fromArray( rotation );
}
if ( 'Lcl_Scaling' in node.properties ) {
model.scale.fromArray( parseFloatArray( node.properties.Lcl_Scaling.value ) );
}
if ( 'PreRotation' in node.properties ) {
var preRotations = new THREE.Euler().setFromVector3( parseVector3( node.properties.PreRotation ).multiplyScalar( DEG2RAD ), 'ZYX' );
preRotations = new THREE.Quaternion().setFromEuler( preRotations );
var currentRotation = new THREE.Quaternion().setFromEuler( model.rotation );
preRotations.multiply( currentRotation );
model.rotation.setFromQuaternion( preRotations, 'ZYX' );
}
var conns = connections.get( model.FBX_ID );
for ( var parentIndex = 0; parentIndex < conns.parents.length; parentIndex ++ ) {
var pIndex = findIndex( modelArray, function ( mod ) {
return mod.FBX_ID === conns.parents[ parentIndex ].ID;
} );
if ( pIndex > - 1 ) {
modelArray[ pIndex ].add( model );
break;
}
}
if ( model.parent === null ) {
sceneGraph.add( model );
}
}
// Now with the bones created, we can update the skeletons and bind them to the skinned meshes.
sceneGraph.updateMatrixWorld( true );
// Put skeleton into bind pose.
var BindPoseNode = FBXTree.Objects.subNodes.Pose;
for ( var nodeID in BindPoseNode ) {
if ( BindPoseNode[ nodeID ].attrType === 'BindPose' ) {
BindPoseNode = BindPoseNode[ nodeID ];
break;
}
}
if ( BindPoseNode ) {
var PoseNode = BindPoseNode.subNodes.PoseNode;
var worldMatrices = new Map();
for ( var PoseNodeIndex = 0, PoseNodeLength = PoseNode.length; PoseNodeIndex < PoseNodeLength; ++ PoseNodeIndex ) {
var node = PoseNode[ PoseNodeIndex ];
var rawMatWrd = parseMatrixArray( node.subNodes.Matrix.properties.a );
worldMatrices.set( parseInt( node.id ), rawMatWrd );
}
}
for ( var FBX_ID in deformers ) {
var deformer = deformers[ FBX_ID ];
var subDeformers = deformer.map;
for ( var key in subDeformers ) {
var subDeformer = subDeformers[ key ];
var subDeformerIndex = subDeformer.index;
/**
* @type {THREE.Bone}
*/
var bone = deformer.bones[ subDeformerIndex ];
if ( ! worldMatrices.has( bone.FBX_ID ) ) {
break;
}
var mat = worldMatrices.get( bone.FBX_ID );
bone.matrixWorld.copy( mat );
}
// Now that skeleton is in bind pose, bind to model.
deformer.skeleton = new THREE.Skeleton( deformer.bones );
var conns = connections.get( deformer.FBX_ID );
var parents = conns.parents;
for ( var parentsIndex = 0, parentsLength = parents.length; parentsIndex < parentsLength; ++ parentsIndex ) {
var parent = parents[ parentsIndex ];
if ( geometryMap.has( parent.ID ) ) {
var geoID = parent.ID;
var geoConns = connections.get( geoID );
for ( var i = 0; i < geoConns.parents.length; ++ i ) {
if ( modelMap.has( geoConns.parents[ i ].ID ) ) {
var model = modelMap.get( geoConns.parents[ i ].ID );
//ASSERT model typeof SkinnedMesh
model.bind( deformer.skeleton, model.matrixWorld );
break;
}
}
}
}
}
//Skeleton is now bound, return objects to starting
//world positions.
sceneGraph.updateMatrixWorld( true );
// Silly hack with the animation parsing. We're gonna pretend the scene graph has a skeleton
// to attach animations to, since FBXs treat animations as animations for the entire scene,
// not just for individual objects.
sceneGraph.skeleton = {
bones: modelArray
};
var animations = parseAnimations( FBXTree, connections, sceneGraph );
addAnimations( sceneGraph, animations );
return sceneGraph;
}
/**
* Parses animation information from FBXTree and generates an AnimationInfoObject.
* @param {{Objects: {subNodes: {AnimationCurveNode: any, AnimationCurve: any, AnimationLayer: any, AnimationStack: any}}}} FBXTree
* @param {Map<number, {parents: {ID: number, relationship: string}[], children: {ID: number, relationship: string}[]}>} connections
*/
function parseAnimations( FBXTree, connections, sceneGraph ) {
var rawNodes = FBXTree.Objects.subNodes.AnimationCurveNode;
var rawCurves = FBXTree.Objects.subNodes.AnimationCurve;
var rawLayers = FBXTree.Objects.subNodes.AnimationLayer;
var rawStacks = FBXTree.Objects.subNodes.AnimationStack;
/**
* @type {{
curves: Map<number, {
T: {
id: number;
attr: string;
internalID: number;
attrX: boolean;
attrY: boolean;
attrZ: boolean;
containerBoneID: number;
containerID: number;
curves: {
x: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
y: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
z: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
};
},
R: {
id: number;
attr: string;
internalID: number;
attrX: boolean;
attrY: boolean;
attrZ: boolean;
containerBoneID: number;
containerID: number;
curves: {
x: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
y: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
z: {
version: any;
id: number;
internalID: number;
times: number[];
values: number[];
attrFlag: number[];
attrData: number[];
};
};
},
S: {
id: number;
attr: string;
internalID: number;
attrX: boolean;
attrY: boolean;
attrZ: boolean;
containerBoneID: number;
containerID: number;
curves: {
x: {
version: any;
id: number;