3242 lines
68 KiB
JavaScript
3242 lines
68 KiB
JavaScript
|
/**
|
|||
|
|
* @author yamahigashi https://github.com/yamahigashi
|
|||
|
|
* @author Kyle-Larson https://github.com/Kyle-Larson
|
|||
|
|
*
|
|||
|
|
* This loader loads FBX file in *ASCII and version 7 format*.
|
|||
|
|
*
|
|||
|
|
* Support
|
|||
|
|
* - mesh
|
|||
|
|
* - skinning
|
|||
|
|
* - normal / uv
|
|||
|
|
* - material (Multi-Material too)
|
|||
|
|
* - textures (Must be in same directory)
|
|||
|
|
* - nurbs
|
|||
|
|
*
|
|||
|
|
* No Support
|
|||
|
|
* - morph
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
( function () {
|
|||
|
|
|
|||
|
|
THREE.FBXLoader = function ( manager ) {
|
|||
|
|
|
|||
|
|
THREE.Loader.call( this );
|
|||
|
|
this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
|
|||
|
|
this.textureLoader = null;
|
|||
|
|
this.textureBasePath = null;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
THREE.FBXLoader.prototype = Object.create( THREE.Loader.prototype );
|
|||
|
|
|
|||
|
|
THREE.FBXLoader.prototype.constructor = THREE.FBXLoader;
|
|||
|
|
|
|||
|
|
Object.assign( THREE.FBXLoader.prototype, {
|
|||
|
|
|
|||
|
|
load: function ( url, onLoad, onProgress, onError ) {
|
|||
|
|
|
|||
|
|
var scope = this;
|
|||
|
|
|
|||
|
|
var loader = new THREE.FileLoader( scope.manager );
|
|||
|
|
// loader.setCrossOrigin( this.crossOrigin );
|
|||
|
|
loader.load( url, function ( text ) {
|
|||
|
|
|
|||
|
|
if ( ! scope.isFbxFormatASCII( text ) ) {
|
|||
|
|
|
|||
|
|
console.warn( 'FBXLoader: !!! FBX Binary format not supported !!!' );
|
|||
|
|
|
|||
|
|
} else if ( ! scope.isFbxVersionSupported( text ) ) {
|
|||
|
|
|
|||
|
|
console.warn( 'FBXLoader: !!! FBX Version below 7 not supported !!!' );
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
scope.textureBasePath = scope.extractUrlBase( url );
|
|||
|
|
onLoad( scope.parse( text ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}, onProgress, onError );
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
setCrossOrigin: function ( value ) {
|
|||
|
|
|
|||
|
|
this.crossOrigin = value;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
isFbxFormatASCII: function ( body ) {
|
|||
|
|
|
|||
|
|
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 = body[ offset - 1 ];
|
|||
|
|
body = body.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;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
isFbxVersionSupported: function ( body ) {
|
|||
|
|
|
|||
|
|
var versionExp = /FBXVersion: (\d+)/;
|
|||
|
|
var match = body.match( versionExp );
|
|||
|
|
if ( match ) {
|
|||
|
|
|
|||
|
|
var version = parseInt( match[ 1 ] );
|
|||
|
|
console.log( 'FBXLoader: FBX version ' + version );
|
|||
|
|
return version >= 7000;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parse: function ( text ) {
|
|||
|
|
|
|||
|
|
var scope = this;
|
|||
|
|
|
|||
|
|
console.time( 'FBXLoader' );
|
|||
|
|
|
|||
|
|
console.time( 'FBXLoader: TextParser' );
|
|||
|
|
var nodes = new FBXParser().parse( text );
|
|||
|
|
console.timeEnd( 'FBXLoader: TextParser' );
|
|||
|
|
|
|||
|
|
console.time( 'FBXLoader: ObjectParser' );
|
|||
|
|
scope.hierarchy = ( new Bones() ).parseHierarchy( nodes );
|
|||
|
|
scope.weights = ( new Weights() ).parse( nodes, scope.hierarchy );
|
|||
|
|
scope.animations = ( new Animation() ).parse( nodes, scope.hierarchy );
|
|||
|
|
scope.textures = ( new Textures() ).parse( nodes, scope.hierarchy );
|
|||
|
|
scope.materials = ( new Materials() ).parse( nodes, scope.hierarchy );
|
|||
|
|
scope.geometries = ( new Geometries() ).parse( nodes, scope.hierarchy );
|
|||
|
|
console.timeEnd( 'FBXLoader: ObjectParser' );
|
|||
|
|
|
|||
|
|
this.texture_cache = {};
|
|||
|
|
this.material_cache = {};
|
|||
|
|
this.geometry_cache = {};
|
|||
|
|
|
|||
|
|
console.time( 'FBXLoader: MeshParser' );
|
|||
|
|
var meshes = this.parseMeshes( nodes );
|
|||
|
|
console.timeEnd( 'FBXLoader: MeshParser' );
|
|||
|
|
|
|||
|
|
var container = new THREE.Group();
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < meshes.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( meshes[ i ] === undefined ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
container.add( meshes[ i ] );
|
|||
|
|
|
|||
|
|
//wireframe = new THREE.WireframeHelper( geometries[i], 0x00ff00 );
|
|||
|
|
//container.add( wireframe );
|
|||
|
|
|
|||
|
|
//vnh = new THREE.VertexNormalsHelper( geometries[i], 0.6 );
|
|||
|
|
//container.add( vnh );
|
|||
|
|
|
|||
|
|
//skh = new THREE.SkeletonHelper( geometries[i] );
|
|||
|
|
//container.add( skh );
|
|||
|
|
|
|||
|
|
// container.add( new THREE.BoxHelper( geometries[i] ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
console.timeEnd( 'FBXLoader' );
|
|||
|
|
return container;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getTexture: function ( texNode ) {
|
|||
|
|
|
|||
|
|
if ( ! ( texNode.id in this.texture_cache ) ) {
|
|||
|
|
|
|||
|
|
if ( this.textureLoader === null ) {
|
|||
|
|
|
|||
|
|
this.textureLoader = new THREE.TextureLoader();
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.texture_cache[ texNode.id ] = this.textureLoader.load( this.textureBasePath + '/' + texNode.fileName );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.texture_cache[ texNode.id ];
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getMaterial: function ( matNode, nodes ) {
|
|||
|
|
|
|||
|
|
if ( ! ( matNode.id in this.material_cache ) ) {
|
|||
|
|
|
|||
|
|
// TODO:
|
|||
|
|
// Cannot find a list of possible ShadingModel values.
|
|||
|
|
// If someone finds a list, please add additional cases
|
|||
|
|
// and map to appropriate materials.
|
|||
|
|
var tmpMat;
|
|||
|
|
switch ( matNode.type ) {
|
|||
|
|
|
|||
|
|
case "phong":
|
|||
|
|
tmpMat = new THREE.MeshPhongMaterial();
|
|||
|
|
break;
|
|||
|
|
case "lambert":
|
|||
|
|
tmpMat = new THREE.MeshLambertMaterial();
|
|||
|
|
break;
|
|||
|
|
default:
|
|||
|
|
console.warn( "No implementation given for material type " + matNode.type + " in FBXLoader.js. Defaulting to basic material" );
|
|||
|
|
tmpMat = new THREE.MeshBasicMaterial( { color: 0x3300ff } );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var children = nodes.searchConnectionChildren( matNode.id );
|
|||
|
|
for ( var i = 0; i < children.length; ++ i ) {
|
|||
|
|
|
|||
|
|
var type = nodes.searchConnectionType( children[ i ], matNode.id );
|
|||
|
|
switch ( type ) {
|
|||
|
|
|
|||
|
|
case " \"AmbientColor":
|
|||
|
|
//TODO: Support AmbientColor textures
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case " \"DiffuseColor":
|
|||
|
|
matNode.parameters.map = this.getTexture( this.textures.textures[ children[ i ] ] );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
console.warn( 'Unknown texture application of type ' + type + ', skipping texture' );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmpMat.setValues( matNode.parameters );
|
|||
|
|
|
|||
|
|
this.material_cache[ matNode.id ] = tmpMat;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.material_cache[ matNode.id ];
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getGeometry: function ( geoNode ) {
|
|||
|
|
|
|||
|
|
if ( ! ( geoNode.id in this.geometry_cache ) ) {
|
|||
|
|
|
|||
|
|
var tmpGeo = new THREE.BufferGeometry();
|
|||
|
|
tmpGeo.name = geoNode.name;
|
|||
|
|
tmpGeo.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( geoNode.vertices ), 3 ) );
|
|||
|
|
|
|||
|
|
if ( geoNode.normals !== undefined && geoNode.normals.length > 0 ) {
|
|||
|
|
|
|||
|
|
tmpGeo.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( geoNode.normals ), 3 ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( geoNode.uvs !== undefined && geoNode.uvs.length > 0 ) {
|
|||
|
|
|
|||
|
|
tmpGeo.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( geoNode.uvs ), 2 ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( geoNode.indices !== undefined && geoNode.indices.length > 0 ) {
|
|||
|
|
|
|||
|
|
tmpGeo.setIndex( geoNode.indices );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmpGeo.verticesNeedUpdate = true;
|
|||
|
|
tmpGeo.computeBoundingSphere();
|
|||
|
|
tmpGeo.computeBoundingBox();
|
|||
|
|
|
|||
|
|
//Material groupings
|
|||
|
|
if ( geoNode.materialIndices.length > 1 ) {
|
|||
|
|
|
|||
|
|
tmpGeo.groups = [];
|
|||
|
|
|
|||
|
|
for ( var i = 0, prevIndex = - 1; i < geoNode.materialIndices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( geoNode.materialIndices[ i ] !== prevIndex ) {
|
|||
|
|
|
|||
|
|
tmpGeo.groups.push( { start: i * 3, count: 0, materialIndex: geoNode.materialIndices[ i ] } );
|
|||
|
|
prevIndex = geoNode.materialIndices[ i ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmpGeo.groups[ tmpGeo.groups.length - 1 ].count += 3;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.geometry_cache[ geoNode.id ] = new THREE.Geometry().fromBufferGeometry( tmpGeo );
|
|||
|
|
this.geometry_cache[ geoNode.id ].bones = geoNode.bones;
|
|||
|
|
this.geometry_cache[ geoNode.id ].skinIndices = this.weights.skinIndices;
|
|||
|
|
this.geometry_cache[ geoNode.id ].skinWeights = this.weights.skinWeights;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.geometry_cache[ geoNode.id ];
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parseMeshes: function ( node ) {
|
|||
|
|
|
|||
|
|
var modelNode = node.Objects.subNodes.Model;
|
|||
|
|
var meshes = [];
|
|||
|
|
|
|||
|
|
for ( var ID in modelNode ) {
|
|||
|
|
|
|||
|
|
if ( modelNode[ ID ].attrType === 'Mesh' ) {
|
|||
|
|
|
|||
|
|
//Parse Mesh
|
|||
|
|
meshes.push( this.parseMesh( modelNode[ ID ], node ) );
|
|||
|
|
|
|||
|
|
} else if ( modelNode[ ID ].attrType === 'NurbsCurve' ) {
|
|||
|
|
|
|||
|
|
//Parse NURBS
|
|||
|
|
meshes.push( this.parseNURBS( modelNode[ ID ], node ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return meshes;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parseFloatList: function ( floatList ) {
|
|||
|
|
|
|||
|
|
return floatList.split( ',' ).map( function ( number ) {
|
|||
|
|
|
|||
|
|
return parseFloat( number );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parseNURBS: function ( meshNode, FBXNodes ) {
|
|||
|
|
|
|||
|
|
if ( THREE.NURBSCurve === undefined ) {
|
|||
|
|
|
|||
|
|
console.error( "THREE.FBXLoader relies on THREE.NURBSCurve" );
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var geoNodes = FBXNodes.Objects.subNodes.Geometry;
|
|||
|
|
|
|||
|
|
var children = FBXNodes.searchConnectionChildren( meshNode.id );
|
|||
|
|
var nurbsInfo;
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < children.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( children[ i ] in geoNodes ) {
|
|||
|
|
|
|||
|
|
nurbsInfo = geoNodes[ children[ i ] ];
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( nurbsInfo === undefined ) {
|
|||
|
|
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var order = parseInt( nurbsInfo.properties.Order );
|
|||
|
|
|
|||
|
|
if ( isNaN( order ) ) {
|
|||
|
|
|
|||
|
|
console.error( "Invalid Order: `" + nurbsInfo.properties.Order + "` (should be an integer)" );
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var knots = this.parseFloatList( nurbsInfo.subNodes.KnotVector.properties.a );
|
|||
|
|
|
|||
|
|
var controlPoints = [];
|
|||
|
|
var pointsValues = this.parseFloatList( nurbsInfo.subNodes.Points.properties.a );
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < pointsValues.length; i += 4 ) {
|
|||
|
|
|
|||
|
|
// NURBSCurve recreates a Vector4, so no need to construct it twice
|
|||
|
|
controlPoints.push( { x: pointsValues[ i ], y: pointsValues[ i + 1 ], z: pointsValues[ i + 2 ], w: pointsValues[ i + 3 ] } );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( nurbsInfo.properties.Form == "Closed" ) {
|
|||
|
|
|
|||
|
|
controlPoints.push( controlPoints[ 0 ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var curve = new THREE.NURBSCurve( order - 1, knots, controlPoints );
|
|||
|
|
|
|||
|
|
// Pre-generate a geometry
|
|||
|
|
var geometry = new THREE.Geometry();
|
|||
|
|
geometry.vertices = curve.getPoints( controlPoints.length * 1.5 );
|
|||
|
|
|
|||
|
|
var mesh = new THREE.Line( geometry );
|
|||
|
|
// Store the THREE.NURBSCurve class so the user can recreate a new geometry with a different number of points
|
|||
|
|
mesh.userData.curve = curve;
|
|||
|
|
|
|||
|
|
return mesh;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parseMesh: function ( meshNode, FBXNodes ) {
|
|||
|
|
|
|||
|
|
var geoNodes = FBXNodes.Objects.subNodes.Geometry;
|
|||
|
|
var matNodes = FBXNodes.Objects.subNodes.Material;
|
|||
|
|
|
|||
|
|
var children = FBXNodes.searchConnectionChildren( meshNode.id );
|
|||
|
|
var geometry;
|
|||
|
|
var materials = [];
|
|||
|
|
var material;
|
|||
|
|
var mesh;
|
|||
|
|
for ( var i = 0; i < children.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( children[ i ] in geoNodes ) {
|
|||
|
|
|
|||
|
|
geometry = this.getGeometry( this.geometries.geometries[ children[ i ] ] );
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( children[ i ] in matNodes ) {
|
|||
|
|
|
|||
|
|
materials.push( this.getMaterial( this.materials.materials[ children[ i ] ], FBXNodes ) );
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( materials.length > 1 ) {
|
|||
|
|
|
|||
|
|
material = new THREE.MultiMaterial( materials );
|
|||
|
|
//material = materials[ 0 ];
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
material = materials[ 0 ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( geometry.bones !== undefined && geometry.skinWeights !== undefined && geometry.skinWeights.length > 0 ) {
|
|||
|
|
|
|||
|
|
if ( material instanceof THREE.MultiMaterial ) {
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < material.materials.length; ++ i ) {
|
|||
|
|
|
|||
|
|
material.materials[ i ].skinning = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
material.skinning = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
mesh = new THREE.SkinnedMesh( geometry, material );
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
mesh = new THREE.Mesh( geometry, material );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( this.animations !== undefined ) {
|
|||
|
|
|
|||
|
|
this.addAnimation( mesh, this.weights.matrices, this.animations );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return mesh;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addAnimation: function ( mesh, matrices, animations ) {
|
|||
|
|
|
|||
|
|
for ( var key in animations.stacks ) {
|
|||
|
|
|
|||
|
|
var animationData = {
|
|||
|
|
name: animations.stacks[ key ].name,
|
|||
|
|
fps: 30,
|
|||
|
|
length: animations.stacks[ key ].length,
|
|||
|
|
hierarchy: []
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < mesh.geometry.bones.length; ++ i ) {
|
|||
|
|
|
|||
|
|
var name = mesh.geometry.bones[ i ].name;
|
|||
|
|
name = name.replace( /.*:/, '' );
|
|||
|
|
animationData.hierarchy.push( { parent: mesh.geometry.bones[ i ].parent, name: name, keys: [] } );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function hasCurve( animNode, attr ) {
|
|||
|
|
|
|||
|
|
if ( animNode === undefined ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var attrNode;
|
|||
|
|
switch ( attr ) {
|
|||
|
|
|
|||
|
|
case 'S':
|
|||
|
|
if ( ! ( animNode.S ) ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
attrNode = animNode.S;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case 'R':
|
|||
|
|
if ( ! ( animNode.R ) ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
attrNode = animNode.R;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case 'T':
|
|||
|
|
if ( ! ( animNode.T ) ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
attrNode = animNode.T;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( attrNode.curves.x === undefined ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( attrNode.curves.y === undefined ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( attrNode.curves.z === undefined ) {
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function hasKeyOnFrame( attrNode, frame ) {
|
|||
|
|
|
|||
|
|
var x = isKeyExistOnFrame( attrNode.curves.x, frame );
|
|||
|
|
var y = isKeyExistOnFrame( attrNode.curves.y, frame );
|
|||
|
|
var z = isKeyExistOnFrame( attrNode.curves.z, frame );
|
|||
|
|
|
|||
|
|
return x && y && z;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isKeyExistOnFrame( curve, frame ) {
|
|||
|
|
|
|||
|
|
var value = curve.values[ frame ];
|
|||
|
|
return value !== undefined;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function genKey( animNode, bone ) {
|
|||
|
|
|
|||
|
|
// key initialize with its bone's bind pose at first
|
|||
|
|
var key = {};
|
|||
|
|
key.time = frame / animations.fps; // TODO:
|
|||
|
|
key.pos = bone.pos;
|
|||
|
|
key.rot = bone.rotq;
|
|||
|
|
key.scl = bone.scl;
|
|||
|
|
|
|||
|
|
if ( animNode === undefined ) {
|
|||
|
|
|
|||
|
|
return key;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
|
|||
|
|
if ( hasCurve( animNode, 'T' ) && hasKeyOnFrame( animNode.T, frame ) ) {
|
|||
|
|
|
|||
|
|
var pos = new THREE.Vector3(
|
|||
|
|
animNode.T.curves.x.values[ frame ],
|
|||
|
|
animNode.T.curves.y.values[ frame ],
|
|||
|
|
animNode.T.curves.z.values[ frame ] );
|
|||
|
|
key.pos = [ pos.x, pos.y, pos.z ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( hasCurve( animNode, 'R' ) && hasKeyOnFrame( animNode.R, frame ) ) {
|
|||
|
|
|
|||
|
|
var rx = degToRad( animNode.R.curves.x.values[ frame ] );
|
|||
|
|
var ry = degToRad( animNode.R.curves.y.values[ frame ] );
|
|||
|
|
var rz = degToRad( animNode.R.curves.z.values[ frame ] );
|
|||
|
|
var eul = new THREE.Vector3( rx, ry, rz );
|
|||
|
|
var rot = quatFromVec( eul.x, eul.y, eul.z );
|
|||
|
|
key.rot = [ rot.x, rot.y, rot.z, rot.w ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( hasCurve( animNode, 'S' ) && hasKeyOnFrame( animNode.S, frame ) ) {
|
|||
|
|
|
|||
|
|
var scl = new THREE.Vector3(
|
|||
|
|
animNode.S.curves.x.values[ frame ],
|
|||
|
|
animNode.S.curves.y.values[ frame ],
|
|||
|
|
animNode.S.curves.z.values[ frame ] );
|
|||
|
|
key.scl = [ scl.x, scl.y, scl.z ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} catch ( e ) {
|
|||
|
|
|
|||
|
|
// curve is not full plotted
|
|||
|
|
console.log( bone );
|
|||
|
|
console.log( e );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return key;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var bones = mesh.geometry.bones;
|
|||
|
|
for ( var frame = 0; frame < animations.stacks[ key ].frames; frame ++ ) {
|
|||
|
|
|
|||
|
|
|
|||
|
|
for ( i = 0; i < bones.length; i ++ ) {
|
|||
|
|
|
|||
|
|
var bone = bones[ i ];
|
|||
|
|
var animNode = animations.stacks[ key ].layers[ 0 ][ i ];
|
|||
|
|
|
|||
|
|
for ( var j = 0; j < animationData.hierarchy.length; j ++ ) {
|
|||
|
|
|
|||
|
|
if ( animationData.hierarchy[ j ].name === bone.name ) {
|
|||
|
|
|
|||
|
|
animationData.hierarchy[ j ].keys.push( genKey( animNode, bone ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( mesh.geometry.animations === undefined ) {
|
|||
|
|
|
|||
|
|
mesh.geometry.animations = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
mesh.geometry.animations.push( THREE.AnimationClip.parseAnimation( animationData, mesh.geometry.bones ) );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
loadFile: function ( url, onLoad, onProgress, onError, responseType ) {
|
|||
|
|
|
|||
|
|
var loader = new THREE.FileLoader( this.manager );
|
|||
|
|
|
|||
|
|
loader.setResponseType( responseType );
|
|||
|
|
|
|||
|
|
var request = loader.load( url, onLoad, onProgress, onError );
|
|||
|
|
|
|||
|
|
return request;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
loadFileAsBuffer: function ( url, onLoad, onProgress, onError ) {
|
|||
|
|
|
|||
|
|
this.loadFile( url, onLoad, onProgress, onError, 'arraybuffer' );
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
loadFileAsText: function ( url, onLoad, onProgress, onError ) {
|
|||
|
|
|
|||
|
|
this.loadFile( url, onLoad, onProgress, onError, 'text' );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
/* ----------------------------------------------------------------- */
|
|||
|
|
|
|||
|
|
function FBXNodes() {}
|
|||
|
|
|
|||
|
|
Object.assign( FBXNodes.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;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
function FBXParser() {}
|
|||
|
|
|
|||
|
|
Object.assign( FBXParser.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 FBXNodes();
|
|||
|
|
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;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
|
|||
|
|
// generate skinIndices, skinWeights
|
|||
|
|
// @skinIndices: per vertex data, this represents the bone indexes affects that vertex
|
|||
|
|
// @skinWeights: per vertex data, this represents the Weight Values affects that vertex
|
|||
|
|
// @matrices: per `bones` data
|
|||
|
|
function Weights() {
|
|||
|
|
|
|||
|
|
this.skinIndices = [];
|
|||
|
|
this.skinWeights = [];
|
|||
|
|
|
|||
|
|
this.matrices = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
Weights.prototype.parseCluster = function ( node, id, entry ) {
|
|||
|
|
|
|||
|
|
var _p = node.searchConnectionParent( id );
|
|||
|
|
var _indices = parseArrayToInt( entry.subNodes.Indexes.properties.a );
|
|||
|
|
var _weights = parseArrayToFloat( entry.subNodes.Weights.properties.a );
|
|||
|
|
var _transform = parseArrayToMatrix( entry.subNodes.Transform.properties.a );
|
|||
|
|
var _link = parseArrayToMatrix( entry.subNodes.TransformLink.properties.a );
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
|
|||
|
|
'parent': _p,
|
|||
|
|
'id': parseInt( id ),
|
|||
|
|
'indices': _indices,
|
|||
|
|
'weights': _weights,
|
|||
|
|
'transform': _transform,
|
|||
|
|
'transformlink': _link,
|
|||
|
|
'linkMode': entry.properties.Mode
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Weights.prototype.parse = function ( node, bones ) {
|
|||
|
|
|
|||
|
|
this.skinIndices = [];
|
|||
|
|
this.skinWeights = [];
|
|||
|
|
|
|||
|
|
this.matrices = [];
|
|||
|
|
|
|||
|
|
var deformers = node.Objects.subNodes.Deformer;
|
|||
|
|
|
|||
|
|
var clusters = {};
|
|||
|
|
for ( var id in deformers ) {
|
|||
|
|
|
|||
|
|
if ( deformers[ id ].attrType === 'Cluster' ) {
|
|||
|
|
|
|||
|
|
if ( ! ( 'Indexes' in deformers[ id ].subNodes ) ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//clusters.push( this.parseCluster( node, id, deformers[id] ) );
|
|||
|
|
var cluster = this.parseCluster( node, id, deformers[ id ] );
|
|||
|
|
var boneId = node.searchConnectionChildren( cluster.id )[ 0 ];
|
|||
|
|
clusters[ boneId ] = cluster;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
// this clusters is per Bone data, thus we make this into per vertex data
|
|||
|
|
var weights = [];
|
|||
|
|
var hi = bones.hierarchy;
|
|||
|
|
for ( var b = 0; b < hi.length; ++ b ) {
|
|||
|
|
|
|||
|
|
var bid = hi[ b ].internalId;
|
|||
|
|
if ( clusters[ bid ] === undefined ) {
|
|||
|
|
|
|||
|
|
//console.log( bid );
|
|||
|
|
this.matrices.push( new THREE.Matrix4() );
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var clst = clusters[ bid ];
|
|||
|
|
// store transform matrix per bones
|
|||
|
|
this.matrices.push( clst.transform );
|
|||
|
|
//this.matrices.push( clst.transformlink );
|
|||
|
|
for ( var v = 0; v < clst.indices.length; ++ v ) {
|
|||
|
|
|
|||
|
|
if ( weights[ clst.indices[ v ] ] === undefined ) {
|
|||
|
|
|
|||
|
|
weights[ clst.indices[ v ] ] = {};
|
|||
|
|
weights[ clst.indices[ v ] ].joint = [];
|
|||
|
|
weights[ clst.indices[ v ] ].weight = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// indices
|
|||
|
|
var affect = node.searchConnectionChildren( clst.id );
|
|||
|
|
|
|||
|
|
if ( affect.length > 1 ) {
|
|||
|
|
|
|||
|
|
console.warn( "FBXLoader: node " + clst.id + " have many weight kids: " + affect );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
weights[ clst.indices[ v ] ].joint.push( bones.getBoneIdfromInternalId( node, affect[ 0 ] ) );
|
|||
|
|
|
|||
|
|
// weight value
|
|||
|
|
weights[ clst.indices[ v ] ].weight.push( clst.weights[ v ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// normalize the skin weights
|
|||
|
|
// TODO - this might be a good place to choose greatest 4 weights
|
|||
|
|
for ( var i = 0; i < weights.length; i ++ ) {
|
|||
|
|
|
|||
|
|
if ( weights[ i ] === undefined ) {
|
|||
|
|
|
|||
|
|
this.skinIndices.push( new THREE.Vector4( 0, 0, 0, 0 ) );
|
|||
|
|
this.skinWeights.push( new THREE.Vector4( 0, 0, 0, 0 ) );
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var indicies = new THREE.Vector4(
|
|||
|
|
weights[ i ].joint[ 0 ] ? weights[ i ].joint[ 0 ] : 0,
|
|||
|
|
weights[ i ].joint[ 1 ] ? weights[ i ].joint[ 1 ] : 0,
|
|||
|
|
weights[ i ].joint[ 2 ] ? weights[ i ].joint[ 2 ] : 0,
|
|||
|
|
weights[ i ].joint[ 3 ] ? weights[ i ].joint[ 3 ] : 0 );
|
|||
|
|
|
|||
|
|
var weight = new THREE.Vector4(
|
|||
|
|
weights[ i ].weight[ 0 ] ? weights[ i ].weight[ 0 ] : 0,
|
|||
|
|
weights[ i ].weight[ 1 ] ? weights[ i ].weight[ 1 ] : 0,
|
|||
|
|
weights[ i ].weight[ 2 ] ? weights[ i ].weight[ 2 ] : 0,
|
|||
|
|
weights[ i ].weight[ 3 ] ? weights[ i ].weight[ 3 ] : 0 );
|
|||
|
|
|
|||
|
|
this.skinIndices.push( indicies );
|
|||
|
|
this.skinWeights.push( weight );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//console.log( this );
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function Bones() {
|
|||
|
|
|
|||
|
|
// returns bones hierarchy tree.
|
|||
|
|
// [
|
|||
|
|
// {
|
|||
|
|
// "parent": id,
|
|||
|
|
// "name": name,
|
|||
|
|
// "pos": pos,
|
|||
|
|
// "rotq": quat
|
|||
|
|
// },
|
|||
|
|
// ...
|
|||
|
|
// {},
|
|||
|
|
// ...
|
|||
|
|
// ]
|
|||
|
|
//
|
|||
|
|
/* sample response
|
|||
|
|
|
|||
|
|
"bones" : [
|
|||
|
|
{"parent":-1, "name":"Fbx01", "pos":[-0.002, 98.739, 1.6e-05], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":0, "name":"Fbx01_Pelvis", "pos":[0.00015963, 0, 7.33107e-08], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":1, "name":"Fbx01_Spine", "pos":[6.577e-06, 10.216, 0.0106811], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":2, "name":"Fbx01_R_Thigh", "pos":[14.6537, -10.216, -0.00918758], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":3, "name":"Fbx01_R_Calf", "pos":[-3.70047, -42.9681, -7.78158], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":4, "name":"Fbx01_R_Foot", "pos":[-2.0696, -46.0488, 9.42052], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":5, "name":"Fbx01_R_Toe0", "pos":[-0.0234785, -9.46233, -15.3187], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":2, "name":"Fbx01_L_Thigh", "pos":[-14.6537, -10.216, -0.00918314], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":7, "name":"Fbx01_L_Calf", "pos":[3.70037, -42.968, -7.78155], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":8, "name":"Fbx01_L_Foot", "pos":[2.06954, -46.0488, 9.42052], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":9, "name":"Fbx01_L_Toe0", "pos":[0.0234566, -9.46235, -15.3187], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":2, "name":"Fbx01_Spine1", "pos":[-2.97523e-05, 11.5892, -9.81027e-05], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":11, "name":"Fbx01_Spine2", "pos":[-2.91292e-05, 11.4685, 8.27126e-05], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":12, "name":"Fbx01_Spine3", "pos":[-4.48857e-05, 11.5783, 8.35108e-05], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":13, "name":"Fbx01_Neck", "pos":[1.22987e-05, 11.5582, -0.0044775], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":14, "name":"Fbx01_Head", "pos":[-3.50709e-05, 6.62915, -0.00523254], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":15, "name":"Fbx01_R_Eye", "pos":[3.31681, 12.739, -10.5267], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":15, "name":"Fbx01_L_Eye", "pos":[-3.32038, 12.7391, -10.5267], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":15, "name":"Jaw", "pos":[-0.0017738, 7.43481, -4.08114], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":14, "name":"Fbx01_R_Clavicle", "pos":[3.10919, 2.46577, -0.0115284], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":19, "name":"Fbx01_R_UpperArm", "pos":[16.014, 4.57764e-05, 3.10405], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":20, "name":"Fbx01_R_Forearm", "pos":[22.7068, -1.66322, -2.13803], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":21, "name":"Fbx01_R_Hand", "pos":[25.5881, -0.80249, -6.37307], "rotq":[0, 0, 0, 1]},
|
|||
|
|
...
|
|||
|
|
{"parent":27, "name":"Fbx01_R_Finger32", "pos":[2.15572, -0.548737, -0.539604], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":22, "name":"Fbx01_R_Finger2", "pos":[9.79318, 0.132553, -2.97845], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":29, "name":"Fbx01_R_Finger21", "pos":[2.74037, 0.0483093, -0.650531], "rotq":[0, 0, 0, 1]},
|
|||
|
|
{"parent":55, "name":"Fbx01_L_Finger02", "pos":[-1.65308, -1.43208, -1.82885], "rotq":[0, 0, 0, 1]}
|
|||
|
|
]
|
|||
|
|
*/
|
|||
|
|
this.hierarchy = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Bones.prototype.parseHierarchy = function ( node ) {
|
|||
|
|
|
|||
|
|
var objects = node.Objects;
|
|||
|
|
var models = objects.subNodes.Model;
|
|||
|
|
|
|||
|
|
var bones = [];
|
|||
|
|
for ( var id in models ) {
|
|||
|
|
|
|||
|
|
if ( models[ id ].attrType === undefined ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
bones.push( models[ id ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.hierarchy = [];
|
|||
|
|
for ( var i = 0; i < bones.length; ++ i ) {
|
|||
|
|
|
|||
|
|
var bone = bones[ i ];
|
|||
|
|
|
|||
|
|
var p = node.searchConnectionParent( bone.id )[ 0 ];
|
|||
|
|
var t = [ 0.0, 0.0, 0.0 ];
|
|||
|
|
var r = [ 0.0, 0.0, 0.0, 1.0 ];
|
|||
|
|
var s = [ 1.0, 1.0, 1.0 ];
|
|||
|
|
|
|||
|
|
if ( 'Lcl_Translation' in bone.properties ) {
|
|||
|
|
|
|||
|
|
t = parseArrayToFloat( bone.properties.Lcl_Translation.value );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( 'Lcl_Rotation' in bone.properties ) {
|
|||
|
|
|
|||
|
|
r = parseArrayToRadians( bone.properties.Lcl_Rotation.value );
|
|||
|
|
var q = new THREE.Quaternion();
|
|||
|
|
q.setFromEuler( new THREE.Euler( r[ 0 ], r[ 1 ], r[ 2 ], 'ZYX' ) );
|
|||
|
|
r = [ q.x, q.y, q.z, q.w ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( 'Lcl_Scaling' in bone.properties ) {
|
|||
|
|
|
|||
|
|
s = parseArrayToFloat( bone.properties.Lcl_Scaling.value );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// replace unsafe character
|
|||
|
|
var name = bone.attrName;
|
|||
|
|
name = name.replace( /:/, '' );
|
|||
|
|
name = name.replace( /_/, '' );
|
|||
|
|
name = name.replace( /-/, '' );
|
|||
|
|
this.hierarchy.push( { "parent": p, "name": name, "pos": t, "rotq": r, "scl": s, "internalId": bone.id } );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.reindexParentId();
|
|||
|
|
|
|||
|
|
this.restoreBindPose( node );
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.reindexParentId = function () {
|
|||
|
|
|
|||
|
|
for ( var h = 0; h < this.hierarchy.length; h ++ ) {
|
|||
|
|
|
|||
|
|
for ( var ii = 0; ii < this.hierarchy.length; ++ ii ) {
|
|||
|
|
|
|||
|
|
if ( this.hierarchy[ h ].parent == this.hierarchy[ ii ].internalId ) {
|
|||
|
|
|
|||
|
|
this.hierarchy[ h ].parent = ii;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.restoreBindPose = function ( node ) {
|
|||
|
|
|
|||
|
|
var bindPoseNode = node.Objects.subNodes.Pose;
|
|||
|
|
if ( bindPoseNode === undefined ) {
|
|||
|
|
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( var key in bindPoseNode ) {
|
|||
|
|
|
|||
|
|
if ( bindPoseNode[ key ].attrType === 'BindPose' ) {
|
|||
|
|
|
|||
|
|
bindPoseNode = bindPoseNode[ key ];
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var poseNode = bindPoseNode.subNodes.PoseNode;
|
|||
|
|
var localMatrices = {}; // store local matrices, modified later( initialy world space )
|
|||
|
|
var worldMatrices = {}; // store world matrices
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < poseNode.length; ++ i ) {
|
|||
|
|
|
|||
|
|
var rawMatLcl = parseArrayToMatrix( poseNode[ i ].subNodes.Matrix.properties.a );
|
|||
|
|
var rawMatWrd = parseArrayToMatrix( poseNode[ i ].subNodes.Matrix.properties.a );
|
|||
|
|
|
|||
|
|
localMatrices[ poseNode[ i ].id ] = rawMatLcl;
|
|||
|
|
worldMatrices[ poseNode[ i ].id ] = rawMatWrd;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( var h = 0; h < this.hierarchy.length; ++ h ) {
|
|||
|
|
|
|||
|
|
var bone = this.hierarchy[ h ];
|
|||
|
|
var inId = bone.internalId;
|
|||
|
|
|
|||
|
|
if ( worldMatrices[ inId ] === undefined ) {
|
|||
|
|
|
|||
|
|
// has no bind pose node, possibly be mesh
|
|||
|
|
// console.log( bone );
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var t = new THREE.Vector3( 0, 0, 0 );
|
|||
|
|
var r = new THREE.Quaternion();
|
|||
|
|
var s = new THREE.Vector3( 1, 1, 1 );
|
|||
|
|
|
|||
|
|
var parentId;
|
|||
|
|
var parentNodes = node.searchConnectionParent( inId );
|
|||
|
|
for ( var pn = 0; pn < parentNodes.length; ++ pn ) {
|
|||
|
|
|
|||
|
|
if ( this.isBoneNode( parentNodes[ pn ] ) ) {
|
|||
|
|
|
|||
|
|
parentId = parentNodes[ pn ];
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( parentId !== undefined && localMatrices[ parentId ] !== undefined ) {
|
|||
|
|
|
|||
|
|
// convert world space matrix into local space
|
|||
|
|
var inv = new THREE.Matrix4();
|
|||
|
|
inv.getInverse( worldMatrices[ parentId ] );
|
|||
|
|
inv.multiply( localMatrices[ inId ] );
|
|||
|
|
localMatrices[ inId ] = inv;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
//console.log( bone );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
localMatrices[ inId ].decompose( t, r, s );
|
|||
|
|
bone.pos = [ t.x, t.y, t.z ];
|
|||
|
|
bone.rotq = [ r.x, r.y, r.z, r.w ];
|
|||
|
|
bone.scl = [ s.x, s.y, s.z ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.searchRealId = function ( internalId ) {
|
|||
|
|
|
|||
|
|
for ( var h = 0; h < this.hierarchy.length; h ++ ) {
|
|||
|
|
|
|||
|
|
if ( internalId == this.hierarchy[ h ].internalId ) {
|
|||
|
|
|
|||
|
|
return h;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// console.warn( 'FBXLoader: notfound internalId in bones: ' + internalId);
|
|||
|
|
return - 1;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.getByInternalId = function ( internalId ) {
|
|||
|
|
|
|||
|
|
for ( var h = 0; h < this.hierarchy.length; h ++ ) {
|
|||
|
|
|
|||
|
|
if ( internalId == this.hierarchy[ h ].internalId ) {
|
|||
|
|
|
|||
|
|
return this.hierarchy[ h ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return null;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.isBoneNode = function ( id ) {
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < this.hierarchy.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( id === this.hierarchy[ i ].internalId ) {
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Bones.prototype.getBoneIdfromInternalId = function ( node, id ) {
|
|||
|
|
|
|||
|
|
if ( node.__cache_get_boneid_from_internalid === undefined ) {
|
|||
|
|
|
|||
|
|
node.__cache_get_boneid_from_internalid = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( node.__cache_get_boneid_from_internalid[ id ] !== undefined ) {
|
|||
|
|
|
|||
|
|
return node.__cache_get_boneid_from_internalid[ id ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < this.hierarchy.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( this.hierarchy[ i ].internalId == id ) {
|
|||
|
|
|
|||
|
|
node.__cache_get_boneid_from_internalid[ id ] = i;
|
|||
|
|
return i;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// console.warn( 'FBXLoader: bone internalId(' + id + ') not found in bone hierarchy' );
|
|||
|
|
return - 1;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function Geometries() {
|
|||
|
|
|
|||
|
|
this.geometries = {};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Object.assign( Geometries.prototype, {
|
|||
|
|
|
|||
|
|
parse: function ( FBXNodes, hierarchy ) {
|
|||
|
|
|
|||
|
|
if ( ! ( 'Geometry' in FBXNodes.Objects.subNodes ) ) {
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( var geo in FBXNodes.Objects.subNodes.Geometry ) {
|
|||
|
|
|
|||
|
|
if ( FBXNodes.Objects.subNodes.Geometry[ geo ].attrType === 'Mesh' ) {
|
|||
|
|
|
|||
|
|
this.geometries[ geo ] = ( new Geometry() ).parse( FBXNodes.Objects.subNodes.Geometry[ geo ] );
|
|||
|
|
this.geometries[ geo ].addBones( hierarchy.hierarchy );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
|
|||
|
|
function Geometry() {
|
|||
|
|
|
|||
|
|
this.node = null;
|
|||
|
|
this.name = null;
|
|||
|
|
this.id = null;
|
|||
|
|
|
|||
|
|
this.vertices = [];
|
|||
|
|
this.indices = [];
|
|||
|
|
this.normals = [];
|
|||
|
|
this.uvs = [];
|
|||
|
|
|
|||
|
|
this.bones = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Geometry.prototype.parse = function ( geoNode ) {
|
|||
|
|
|
|||
|
|
this.node = geoNode;
|
|||
|
|
this.name = geoNode.attrName;
|
|||
|
|
this.id = geoNode.id;
|
|||
|
|
|
|||
|
|
this.vertices = this.getVertices();
|
|||
|
|
|
|||
|
|
if ( this.vertices === undefined ) {
|
|||
|
|
|
|||
|
|
console.log( 'FBXLoader: Geometry.parse(): pass' + this.node.id );
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.indices = this.getPolygonVertexIndices();
|
|||
|
|
this.uvs = ( new UV() ).parse( this.node, this );
|
|||
|
|
this.normals = ( new Normal() ).parse( this.node, this );
|
|||
|
|
this.materialIndices = ( new MaterialIndex() ).parse( this.node );
|
|||
|
|
|
|||
|
|
if ( this.getPolygonTopologyMax() > 3 ) {
|
|||
|
|
|
|||
|
|
var indexInfo = this.convertPolyIndicesToTri(
|
|||
|
|
this.indices,
|
|||
|
|
this.materialIndices,
|
|||
|
|
this.getPolygonTopologyArray() );
|
|||
|
|
this.indices = indexInfo.res;
|
|||
|
|
this.materialIndices = indexInfo.materialIndices;
|
|||
|
|
this.polyIndices = indexInfo.polyIndices;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
Geometry.prototype.getVertices = function () {
|
|||
|
|
|
|||
|
|
if ( this.node.__cache_vertices ) {
|
|||
|
|
|
|||
|
|
return this.node.__cache_vertices;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( this.node.subNodes.Vertices === undefined ) {
|
|||
|
|
|
|||
|
|
console.warn( 'this.node: ' + this.node.attrName + "(" + this.node.id + ") does not have Vertices" );
|
|||
|
|
this.node.__cache_vertices = undefined;
|
|||
|
|
return null;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var rawTextVert = this.node.subNodes.Vertices.properties.a;
|
|||
|
|
var vertices = rawTextVert.split( ',' ).map( function ( element ) {
|
|||
|
|
|
|||
|
|
return parseFloat( element );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
this.node.__cache_vertices = vertices;
|
|||
|
|
return this.node.__cache_vertices;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Geometry.prototype.getPolygonVertexIndices = function () {
|
|||
|
|
|
|||
|
|
if ( this.node.__cache_indices && this.node.__cache_poly_topology_max ) {
|
|||
|
|
|
|||
|
|
return this.node.__cache_indices;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( this.node.subNodes === undefined ) {
|
|||
|
|
|
|||
|
|
console.error( 'this.node.subNodes undefined' );
|
|||
|
|
console.log( this.node );
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( this.node.subNodes.PolygonVertexIndex === undefined ) {
|
|||
|
|
|
|||
|
|
console.warn( 'this.node: ' + this.node.attrName + "(" + this.node.id + ") does not have PolygonVertexIndex " );
|
|||
|
|
this.node.__cache_indices = undefined;
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var rawTextIndices = this.node.subNodes.PolygonVertexIndex.properties.a;
|
|||
|
|
var indices = rawTextIndices.split( ',' );
|
|||
|
|
|
|||
|
|
var currentTopo = 1;
|
|||
|
|
var topologyN = null;
|
|||
|
|
var topologyArr = [];
|
|||
|
|
|
|||
|
|
// The indices that make up the polygon are in order and a negative index
|
|||
|
|
// means that it’s the last index of the polygon. That index needs
|
|||
|
|
// to be made positive and then you have to subtract 1 from it!
|
|||
|
|
for ( var i = 0; i < indices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
var tmpI = parseInt( indices[ i ] );
|
|||
|
|
// found n
|
|||
|
|
if ( tmpI < 0 ) {
|
|||
|
|
|
|||
|
|
if ( currentTopo > topologyN ) {
|
|||
|
|
|
|||
|
|
topologyN = currentTopo;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
indices[ i ] = tmpI ^ - 1;
|
|||
|
|
topologyArr.push( currentTopo );
|
|||
|
|
currentTopo = 1;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
indices[ i ] = tmpI;
|
|||
|
|
currentTopo ++;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( topologyN === null ) {
|
|||
|
|
|
|||
|
|
console.warn( "FBXLoader: topology N not found: " + this.node.attrName );
|
|||
|
|
console.warn( this.node );
|
|||
|
|
topologyN = 3;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.node.__cache_poly_topology_max = topologyN;
|
|||
|
|
this.node.__cache_poly_topology_arr = topologyArr;
|
|||
|
|
this.node.__cache_indices = indices;
|
|||
|
|
|
|||
|
|
return this.node.__cache_indices;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Geometry.prototype.getPolygonTopologyMax = function () {
|
|||
|
|
|
|||
|
|
if ( this.node.__cache_indices && this.node.__cache_poly_topology_max ) {
|
|||
|
|
|
|||
|
|
return this.node.__cache_poly_topology_max;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.getPolygonVertexIndices( this.node );
|
|||
|
|
return this.node.__cache_poly_topology_max;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Geometry.prototype.getPolygonTopologyArray = function () {
|
|||
|
|
|
|||
|
|
if ( this.node.__cache_indices && this.node.__cache_poly_topology_max ) {
|
|||
|
|
|
|||
|
|
return this.node.__cache_poly_topology_arr;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.getPolygonVertexIndices( this.node );
|
|||
|
|
return this.node.__cache_poly_topology_arr;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// a - d
|
|||
|
|
// | |
|
|||
|
|
// b - c
|
|||
|
|
//
|
|||
|
|
// [( a, b, c, d ) ...........
|
|||
|
|
// [( a, b, c ), (a, c, d )....
|
|||
|
|
|
|||
|
|
// Also keep track of original poly index.
|
|||
|
|
Geometry.prototype.convertPolyIndicesToTri = function ( indices, materialIndices, strides ) {
|
|||
|
|
|
|||
|
|
var res = [];
|
|||
|
|
|
|||
|
|
var i = 0;
|
|||
|
|
var currentPolyNum = 0;
|
|||
|
|
var currentStride = 0;
|
|||
|
|
var polyIndices = [];
|
|||
|
|
|
|||
|
|
while ( i < indices.length ) {
|
|||
|
|
|
|||
|
|
currentStride = strides[ currentPolyNum ];
|
|||
|
|
|
|||
|
|
// CAUTIN: NG over 6gon
|
|||
|
|
for ( var j = 0; j <= ( currentStride - 3 ); j ++ ) {
|
|||
|
|
|
|||
|
|
res.push( indices[ i ] );
|
|||
|
|
res.push( indices[ i + ( currentStride - 2 - j ) ] );
|
|||
|
|
res.push( indices[ i + ( currentStride - 1 - j ) ] );
|
|||
|
|
|
|||
|
|
polyIndices.push( currentPolyNum );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
currentPolyNum ++;
|
|||
|
|
i += currentStride;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var newMaterialIndices = [ materialIndices[ 0 ] ];
|
|||
|
|
|
|||
|
|
if ( materialIndices.length > 1 ) {
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < polyIndices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
newMaterialIndices[ i ] = materialIndices[ polyIndices[ i ] ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
res: res,
|
|||
|
|
materialIndices: newMaterialIndices,
|
|||
|
|
polyIndices: polyIndices };
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Geometry.prototype.addBones = function ( bones ) {
|
|||
|
|
|
|||
|
|
this.bones = bones;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
function UV() {
|
|||
|
|
|
|||
|
|
this.uv = null;
|
|||
|
|
this.map = null;
|
|||
|
|
this.ref = null;
|
|||
|
|
this.node = null;
|
|||
|
|
this.index = null;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
UV.prototype.getUV = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.uv && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.uv;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
return this._parseText( node );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.getMap = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.uv && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.map;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.map;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.getRef = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.uv && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.ref;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.ref;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.getIndex = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.uv && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.index;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.index;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.getNode = function ( topnode ) {
|
|||
|
|
|
|||
|
|
if ( this.node !== null ) {
|
|||
|
|
|
|||
|
|
return this.node;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.node = topnode.subNodes.LayerElementUV;
|
|||
|
|
return this.node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype._parseText = function ( node ) {
|
|||
|
|
|
|||
|
|
var uvNode = this.getNode( node )[ 0 ];
|
|||
|
|
if ( uvNode === undefined ) {
|
|||
|
|
|
|||
|
|
// console.log( node.attrName + "(" + node.id + ")" + " has no LayerElementUV." );
|
|||
|
|
return [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var count = 0;
|
|||
|
|
for ( var n in uvNode ) {
|
|||
|
|
|
|||
|
|
if ( n.match( /^\d+$/ ) ) {
|
|||
|
|
|
|||
|
|
count ++;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( count > 0 ) {
|
|||
|
|
|
|||
|
|
console.warn( 'multi uv not supported' );
|
|||
|
|
uvNode = uvNode[ n ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var uvIndex = uvNode.subNodes.UVIndex.properties.a;
|
|||
|
|
var uvs = uvNode.subNodes.UV.properties.a;
|
|||
|
|
var uvMap = uvNode.properties.MappingInformationType;
|
|||
|
|
var uvRef = uvNode.properties.ReferenceInformationType;
|
|||
|
|
|
|||
|
|
|
|||
|
|
this.uv = parseArrayToFloat( uvs );
|
|||
|
|
this.index = parseArrayToInt( uvIndex );
|
|||
|
|
|
|||
|
|
this.map = uvMap; // TODO: normalize notation shaking... FOR BLENDER
|
|||
|
|
this.ref = uvRef;
|
|||
|
|
|
|||
|
|
return this.uv;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parse = function ( node, geo ) {
|
|||
|
|
|
|||
|
|
if ( ! ( 'LayerElementUV' in node.subNodes ) ) {
|
|||
|
|
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.uvNode = this.getNode( node );
|
|||
|
|
|
|||
|
|
this.uv = this.getUV( node );
|
|||
|
|
var mappingType = this.getMap( node );
|
|||
|
|
var refType = this.getRef( node );
|
|||
|
|
var indices = this.getIndex( node );
|
|||
|
|
|
|||
|
|
var strides = geo.getPolygonTopologyArray();
|
|||
|
|
|
|||
|
|
// it means that there is a normal for every vertex of every polygon of the model.
|
|||
|
|
// For example, if the models has 8 vertices that make up four quads, then there
|
|||
|
|
// will be 16 normals (one normal * 4 polygons * 4 vertices of the polygon). Note
|
|||
|
|
// that generally a game engine needs the vertices to have only one normal defined.
|
|||
|
|
// So, if you find a vertex has more tha one normal, you can either ignore the normals
|
|||
|
|
// you find after the first, or calculate the mean from all of them (normal smoothing).
|
|||
|
|
//if ( mappingType == "ByPolygonVertex" ){
|
|||
|
|
switch ( mappingType ) {
|
|||
|
|
|
|||
|
|
case "ByPolygonVertex":
|
|||
|
|
|
|||
|
|
switch ( refType ) {
|
|||
|
|
|
|||
|
|
// Direct
|
|||
|
|
// The this.uv are in order.
|
|||
|
|
case "Direct":
|
|||
|
|
this.uv = this.parseUV_ByPolygonVertex_Direct( this.uv, indices, strides, 2 );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// IndexToDirect
|
|||
|
|
// The order of the this.uv is given by the uvsIndex property.
|
|||
|
|
case "IndexToDirect":
|
|||
|
|
this.uv = this.parseUV_ByPolygonVertex_IndexToDirect( this.uv, indices );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// convert from by polygon(vert) data into by verts data
|
|||
|
|
this.uv = mapByPolygonVertexToByVertex( this.uv, geo.getPolygonVertexIndices( node ), 2 );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case "ByPolygon":
|
|||
|
|
|
|||
|
|
switch ( refType ) {
|
|||
|
|
|
|||
|
|
// Direct
|
|||
|
|
// The this.uv are in order.
|
|||
|
|
case "Direct":
|
|||
|
|
this.uv = this.parseUV_ByPolygon_Direct();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// IndexToDirect
|
|||
|
|
// The order of the this.uv is given by the uvsIndex property.
|
|||
|
|
case "IndexToDirect":
|
|||
|
|
this.uv = this.parseUV_ByPolygon_IndexToDirect();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.uv;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parseUV_ByPolygonVertex_Direct = function ( node, indices, strides, itemSize ) {
|
|||
|
|
|
|||
|
|
return parse_Data_ByPolygonVertex_Direct( node, indices, strides, itemSize );
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parseUV_ByPolygonVertex_IndexToDirect = function ( node, indices ) {
|
|||
|
|
|
|||
|
|
return parse_Data_ByPolygonVertex_IndexToDirect( node, indices, 2 );
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parseUV_ByPolygon_Direct = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parseUV_ByPolygon_IndexToDirect = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
UV.prototype.parseUV_ByVertex_Direct = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
function Normal() {
|
|||
|
|
|
|||
|
|
this.normal = null;
|
|||
|
|
this.map = null;
|
|||
|
|
this.ref = null;
|
|||
|
|
this.node = null;
|
|||
|
|
this.index = null;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Normal.prototype.getNormal = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.normal && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.normal;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.normal;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// mappingType: possible variant
|
|||
|
|
// ByPolygon
|
|||
|
|
// ByPolygonVertex
|
|||
|
|
// ByVertex (or also ByVertice, as the Blender exporter writes)
|
|||
|
|
// ByEdge
|
|||
|
|
// AllSame
|
|||
|
|
// var mappingType = node.properties.MappingInformationType;
|
|||
|
|
Normal.prototype.getMap = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.normal && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.map;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.map;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// refType: possible variants
|
|||
|
|
// Direct
|
|||
|
|
// IndexToDirect (or Index for older versions)
|
|||
|
|
// var refType = node.properties.ReferenceInformationType;
|
|||
|
|
Normal.prototype.getRef = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node && this.normal && this.map && this.ref ) {
|
|||
|
|
|
|||
|
|
return this.ref;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
this._parseText( node );
|
|||
|
|
return this.ref;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.getNode = function ( node ) {
|
|||
|
|
|
|||
|
|
if ( this.node ) {
|
|||
|
|
|
|||
|
|
return this.node;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.node = node.subNodes.LayerElementNormal;
|
|||
|
|
return this.node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype._parseText = function ( node ) {
|
|||
|
|
|
|||
|
|
var normalNode = this.getNode( node )[ 0 ];
|
|||
|
|
|
|||
|
|
if ( normalNode === undefined ) {
|
|||
|
|
|
|||
|
|
console.warn( 'node: ' + node.attrName + "(" + node.id + ") does not have LayerElementNormal" );
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var mappingType = normalNode.properties.MappingInformationType;
|
|||
|
|
var refType = normalNode.properties.ReferenceInformationType;
|
|||
|
|
|
|||
|
|
var rawTextNormals = normalNode.subNodes.Normals.properties.a;
|
|||
|
|
this.normal = parseArrayToFloat( rawTextNormals );
|
|||
|
|
|
|||
|
|
// TODO: normalize notation shaking, vertex / vertice... blender...
|
|||
|
|
this.map = mappingType;
|
|||
|
|
this.ref = refType;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parse = function ( topnode, geo ) {
|
|||
|
|
|
|||
|
|
var normals = this.getNormal( topnode );
|
|||
|
|
//var normalNode = this.getNode( topnode );
|
|||
|
|
var mappingType = this.getMap( topnode );
|
|||
|
|
var refType = this.getRef( topnode );
|
|||
|
|
|
|||
|
|
var indices = geo.getPolygonVertexIndices( topnode );
|
|||
|
|
var strides = geo.getPolygonTopologyArray( topnode );
|
|||
|
|
|
|||
|
|
// it means that there is a normal for every vertex of every polygon of the model.
|
|||
|
|
// For example, if the models has 8 vertices that make up four quads, then there
|
|||
|
|
// will be 16 normals (one normal * 4 polygons * 4 vertices of the polygon). Note
|
|||
|
|
// that generally a game engine needs the vertices to have only one normal defined.
|
|||
|
|
// So, if you find a vertex has more tha one normal, you can either ignore the normals
|
|||
|
|
// you find after the first, or calculate the mean from all of them (normal smoothing).
|
|||
|
|
//if ( mappingType == "ByPolygonVertex" ){
|
|||
|
|
switch ( mappingType ) {
|
|||
|
|
|
|||
|
|
case "ByPolygonVertex":
|
|||
|
|
|
|||
|
|
switch ( refType ) {
|
|||
|
|
|
|||
|
|
// Direct
|
|||
|
|
// The normals are in order.
|
|||
|
|
case "Direct":
|
|||
|
|
normals = this.parseNormal_ByPolygonVertex_Direct( normals, indices, strides, 3 );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// IndexToDirect
|
|||
|
|
// The order of the normals is given by the NormalsIndex property.
|
|||
|
|
case "IndexToDirect":
|
|||
|
|
normals = this.parseNormal_ByPolygonVertex_IndexToDirect();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case "ByPolygon":
|
|||
|
|
|
|||
|
|
switch ( refType ) {
|
|||
|
|
|
|||
|
|
// Direct
|
|||
|
|
// The normals are in order.
|
|||
|
|
case "Direct":
|
|||
|
|
normals = this.parseNormal_ByPolygon_Direct();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// IndexToDirect
|
|||
|
|
// The order of the normals is given by the NormalsIndex property.
|
|||
|
|
case "IndexToDirect":
|
|||
|
|
normals = this.parseNormal_ByPolygon_IndexToDirect();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return normals;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parseNormal_ByPolygonVertex_Direct = function ( node, indices, strides, itemSize ) {
|
|||
|
|
|
|||
|
|
return parse_Data_ByPolygonVertex_Direct( node, indices, strides, itemSize );
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parseNormal_ByPolygonVertex_IndexToDirect = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parseNormal_ByPolygon_Direct = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parseNormal_ByPolygon_IndexToDirect = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Normal.prototype.parseNormal_ByVertex_Direct = function ( node ) {
|
|||
|
|
|
|||
|
|
console.warn( "not implemented" );
|
|||
|
|
return node;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function MaterialIndex() {
|
|||
|
|
|
|||
|
|
this.indexBuffer = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Object.assign( MaterialIndex.prototype, {
|
|||
|
|
|
|||
|
|
parse: function ( node ) {
|
|||
|
|
|
|||
|
|
if ( ! ( 'LayerElementMaterial' in node.subNodes ) ) {
|
|||
|
|
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var indexNode = node.subNodes.LayerElementMaterial[ 0 ];
|
|||
|
|
var mappingType = indexNode.properties.MappingInformationType;
|
|||
|
|
var refType = indexNode.properties.ReferenceInformationType;
|
|||
|
|
var indices = parseArrayToInt( indexNode.subNodes.Materials.properties.a );
|
|||
|
|
|
|||
|
|
// it means that there is a normal for every vertex of every polygon of the model.
|
|||
|
|
// For example, if the models has 8 vertices that make up four quads, then there
|
|||
|
|
// will be 16 normals (one normal * 4 polygons * 4 vertices of the polygon). Note
|
|||
|
|
// that generally a game engine needs the vertices to have only one normal defined.
|
|||
|
|
// So, if you find a vertex has more tha one normal, you can either ignore the normals
|
|||
|
|
// you find after the first, or calculate the mean from all of them (normal smoothing).
|
|||
|
|
//if ( mappingType == "ByPolygonVertex" ){
|
|||
|
|
switch ( mappingType ) {
|
|||
|
|
|
|||
|
|
|
|||
|
|
case "ByPolygon":
|
|||
|
|
|
|||
|
|
switch ( refType ) {
|
|||
|
|
|
|||
|
|
// Direct
|
|||
|
|
// The material indices are in order.
|
|||
|
|
case "IndexToDirect":
|
|||
|
|
this.indexBuffer = this.parse_ByPolygon_IndexToDirect( indices );
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
this.indexBuffer = [ 0 ];
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
|
|||
|
|
this.indexBuffer = [ 0 ];
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.indexBuffer;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parse_ByPolygon_IndexToDirect: function ( indices ) {
|
|||
|
|
|
|||
|
|
return indices;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
function AnimationCurve() {
|
|||
|
|
|
|||
|
|
this.version = null;
|
|||
|
|
|
|||
|
|
this.id = null;
|
|||
|
|
this.internalId = null;
|
|||
|
|
this.times = null;
|
|||
|
|
this.values = null;
|
|||
|
|
|
|||
|
|
this.attrFlag = null; // tangeant
|
|||
|
|
this.attrData = null; // slope, weight
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
AnimationCurve.prototype.fromNode = function ( curveNode ) {
|
|||
|
|
|
|||
|
|
this.id = curveNode.id;
|
|||
|
|
this.internalId = curveNode.id;
|
|||
|
|
this.times = curveNode.subNodes.KeyTime.properties.a;
|
|||
|
|
this.values = curveNode.subNodes.KeyValueFloat.properties.a;
|
|||
|
|
|
|||
|
|
this.attrFlag = curveNode.subNodes.KeyAttrFlags.properties.a;
|
|||
|
|
this.attrData = curveNode.subNodes.KeyAttrDataFloat.properties.a;
|
|||
|
|
|
|||
|
|
this.times = parseArrayToFloat( this.times );
|
|||
|
|
this.values = parseArrayToFloat( this.values );
|
|||
|
|
this.attrData = parseArrayToFloat( this.attrData );
|
|||
|
|
this.attrFlag = parseArrayToInt( this.attrFlag );
|
|||
|
|
|
|||
|
|
this.times = this.times.map( function ( element ) {
|
|||
|
|
|
|||
|
|
return FBXTimeToSeconds( element );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
AnimationCurve.prototype.getLength = function () {
|
|||
|
|
|
|||
|
|
return this.times[ this.times.length - 1 ];
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function AnimationNode() {
|
|||
|
|
|
|||
|
|
this.id = null;
|
|||
|
|
this.attr = null; // S, R, T
|
|||
|
|
this.attrX = false;
|
|||
|
|
this.attrY = false;
|
|||
|
|
this.attrZ = false;
|
|||
|
|
this.internalId = null;
|
|||
|
|
this.containerInternalId = null; // bone, null etc Id
|
|||
|
|
this.containerBoneId = null; // bone, null etc Id
|
|||
|
|
this.curveIdx = null; // AnimationCurve's indices
|
|||
|
|
this.curves = {}; // AnimationCurve refs
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
AnimationNode.prototype.fromNode = function ( allNodes, node, bones ) {
|
|||
|
|
|
|||
|
|
this.id = node.id;
|
|||
|
|
this.attr = node.attrName;
|
|||
|
|
this.internalId = node.id;
|
|||
|
|
|
|||
|
|
if ( this.attr.match( /S|R|T/ ) ) {
|
|||
|
|
|
|||
|
|
for ( var attrKey in node.properties ) {
|
|||
|
|
|
|||
|
|
if ( attrKey.match( /X/ ) ) {
|
|||
|
|
|
|||
|
|
this.attrX = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( attrKey.match( /Y/ ) ) {
|
|||
|
|
|
|||
|
|
this.attrY = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( attrKey.match( /Z/ ) ) {
|
|||
|
|
|
|||
|
|
this.attrZ = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
// may be deform percent nodes
|
|||
|
|
return null;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.containerIndices = allNodes.searchConnectionParent( this.id );
|
|||
|
|
this.curveIdx = allNodes.searchConnectionChildren( this.id );
|
|||
|
|
|
|||
|
|
for ( var i = this.containerIndices.length - 1; i >= 0; -- i ) {
|
|||
|
|
|
|||
|
|
var boneId = bones.searchRealId( this.containerIndices[ i ] );
|
|||
|
|
if ( boneId >= 0 ) {
|
|||
|
|
|
|||
|
|
this.containerBoneId = boneId;
|
|||
|
|
this.containerId = this.containerIndices[ i ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( boneId >= 0 ) {
|
|||
|
|
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
// this.containerBoneId = bones.searchRealId( this.containerIndices );
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
AnimationNode.prototype.setCurve = function ( curve ) {
|
|||
|
|
|
|||
|
|
this.curves.push( curve );
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function Animation() {
|
|||
|
|
|
|||
|
|
this.curves = {};
|
|||
|
|
this.length = 0.0;
|
|||
|
|
this.fps = 30.0;
|
|||
|
|
this.frames = 0.0;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Animation.prototype.parse = function ( node, bones ) {
|
|||
|
|
|
|||
|
|
var rawNodes = node.Objects.subNodes.AnimationCurveNode;
|
|||
|
|
var rawCurves = node.Objects.subNodes.AnimationCurve;
|
|||
|
|
var rawLayers = node.Objects.subNodes.AnimationLayer;
|
|||
|
|
var rawStacks = node.Objects.subNodes.AnimationStack;
|
|||
|
|
|
|||
|
|
// first: expand AnimationCurveNode into curve nodes
|
|||
|
|
var curveNodes = [];
|
|||
|
|
for ( var key in rawNodes ) {
|
|||
|
|
|
|||
|
|
if ( key.match( /\d+/ ) ) {
|
|||
|
|
|
|||
|
|
var a = ( new AnimationNode() ).fromNode( node, rawNodes[ key ], bones );
|
|||
|
|
curveNodes.push( a );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// second: gen dict, mapped by internalId
|
|||
|
|
var tmp = {};
|
|||
|
|
for ( var i = 0; i < curveNodes.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( curveNodes[ i ] === null ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmp[ curveNodes[ i ].id ] = curveNodes[ i ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// third: insert curves into the dict
|
|||
|
|
var ac = [];
|
|||
|
|
for ( key in rawCurves ) {
|
|||
|
|
|
|||
|
|
if ( key.match( /\d+/ ) ) {
|
|||
|
|
|
|||
|
|
var c = ( new AnimationCurve() ).fromNode( rawCurves[ key ] );
|
|||
|
|
ac.push( c );
|
|||
|
|
|
|||
|
|
var parentId = node.searchConnectionParent( c.id )[ 0 ];
|
|||
|
|
var axis = node.searchConnectionType( c.id, parentId );
|
|||
|
|
|
|||
|
|
if ( axis.match( /X/ ) ) {
|
|||
|
|
|
|||
|
|
axis = 'x';
|
|||
|
|
|
|||
|
|
} else if ( axis.match( /Y/ ) ) {
|
|||
|
|
|
|||
|
|
axis = 'y';
|
|||
|
|
|
|||
|
|
} else if ( axis.match( /Z/ ) ) {
|
|||
|
|
|
|||
|
|
axis = 'z';
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmp[ parentId ].curves[ axis ] = c;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// forth:
|
|||
|
|
for ( var t in tmp ) {
|
|||
|
|
|
|||
|
|
var id = tmp[ t ].containerBoneId;
|
|||
|
|
if ( this.curves[ id ] === undefined ) {
|
|||
|
|
|
|||
|
|
this.curves[ id ] = {
|
|||
|
|
T: null,
|
|||
|
|
R: null,
|
|||
|
|
S: null
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.curves[ id ][ tmp[ t ].attr ] = tmp[ t ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Layers
|
|||
|
|
this.layers = {};
|
|||
|
|
for ( var key in rawLayers ) {
|
|||
|
|
|
|||
|
|
var layer = [];
|
|||
|
|
var children = node.searchConnectionChildren( key );
|
|||
|
|
for ( var i = 0; i < children.length; ++ i ) {
|
|||
|
|
|
|||
|
|
//Skip lockInfluenceWeights
|
|||
|
|
if ( tmp[ children[ i ] ] ) {
|
|||
|
|
|
|||
|
|
if ( layer[ tmp[ children[ i ] ].containerBoneId ] === undefined ) {
|
|||
|
|
|
|||
|
|
layer[ tmp[ children[ i ] ].containerBoneId ] = {
|
|||
|
|
T: null,
|
|||
|
|
R: null,
|
|||
|
|
S: null
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
layer[ tmp[ children[ i ] ].containerBoneId ][ tmp[ children[ i ] ].attr ] = tmp[ children[ i ] ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.layers[ key ] = layer;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Takes
|
|||
|
|
this.stacks = {};
|
|||
|
|
for ( var key in rawStacks ) {
|
|||
|
|
|
|||
|
|
var layers = [];
|
|||
|
|
var children = node.searchConnectionChildren( key );
|
|||
|
|
var max = 0.0;
|
|||
|
|
var min = Number.MAX_VALUE;
|
|||
|
|
for ( var i = 0; i < children.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( children[ i ] in this.layers ) {
|
|||
|
|
|
|||
|
|
layers.push( this.layers[ children[ i ] ] );
|
|||
|
|
|
|||
|
|
for ( var j = 0; j < this.layers[ children[ i ] ].length; ++ j ) {
|
|||
|
|
|
|||
|
|
function getMaxMin( layer ) {
|
|||
|
|
|
|||
|
|
function _getMaxMin( curves ) {
|
|||
|
|
|
|||
|
|
if ( curves.x ) {
|
|||
|
|
|
|||
|
|
max = curves.x.getLength() > max ? curves.x.getLength() : max;
|
|||
|
|
min = curves.x.times[ 0 ] < min ? curves.x.times[ 0 ] : min;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( curves.y ) {
|
|||
|
|
|
|||
|
|
max = curves.y.getLength() > max ? curves.y.getLength() : max;
|
|||
|
|
min = curves.y.times[ 0 ] < min ? curves.y.times[ 0 ] : min;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( curves.z ) {
|
|||
|
|
|
|||
|
|
max = curves.z.getLength() > max ? curves.z.getLength() : max;
|
|||
|
|
min = curves.z.times[ 0 ] < min ? curves.z.times[ 0 ] : min;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( layer.R ) {
|
|||
|
|
|
|||
|
|
_getMaxMin( layer.R.curves );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( layer.S ) {
|
|||
|
|
|
|||
|
|
_getMaxMin( layer.S.curves );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( layer.T ) {
|
|||
|
|
|
|||
|
|
_getMaxMin( layer.T.curves );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var layer = this.layers[ children[ i ] ][ j ];
|
|||
|
|
if ( layer ) {
|
|||
|
|
|
|||
|
|
getMaxMin( layer );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Do we have an animation clip with an actual length?
|
|||
|
|
if ( max > min ) {
|
|||
|
|
|
|||
|
|
this.stacks[ key ] = {
|
|||
|
|
|
|||
|
|
name: rawStacks[ key ].attrName,
|
|||
|
|
layers: layers,
|
|||
|
|
length: max - min,
|
|||
|
|
frames: ( max - min ) * 30,
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
function Textures() {
|
|||
|
|
|
|||
|
|
this.textures = {};
|
|||
|
|
//this.perGeoMap = {};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Textures.prototype.add = function ( tex ) {
|
|||
|
|
|
|||
|
|
debugger;
|
|||
|
|
|
|||
|
|
if ( this.textures === undefined ) {
|
|||
|
|
|
|||
|
|
this.textures = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.textures.push( tex );
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < tex.parentIds.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( this.perGeoMap[ tex.parentIds[ i ] ] === undefined ) {
|
|||
|
|
|
|||
|
|
this.perGeoMap[ tex.parentIds[ i ] ] = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.perGeoMap[ tex.parentIds[ i ] ].push( this.textures[ this.textures.length - 1 ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Textures.prototype.parse = function ( node ) {
|
|||
|
|
|
|||
|
|
var rawNodes = node.Objects.subNodes.Texture;
|
|||
|
|
|
|||
|
|
for ( var n in rawNodes ) {
|
|||
|
|
|
|||
|
|
var tex = ( new Texture() ).parse( rawNodes[ n ], node );
|
|||
|
|
this.textures[ n ] = tex;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Textures.prototype.getById = function ( id ) {
|
|||
|
|
|
|||
|
|
return this.perGeoMap[ id ];
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function Texture() {
|
|||
|
|
|
|||
|
|
this.fileName = "";
|
|||
|
|
this.name = "";
|
|||
|
|
this.id = null;
|
|||
|
|
this.parentIds = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Texture.prototype.parse = function ( node, nodes ) {
|
|||
|
|
|
|||
|
|
this.id = node.id;
|
|||
|
|
this.name = node.attrName;
|
|||
|
|
this.fileName = this.parseFileName( node.properties.FileName );
|
|||
|
|
|
|||
|
|
this.parentIds = this.searchParents( this.id, nodes );
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// TODO: support directory
|
|||
|
|
Texture.prototype.parseFileName = function ( fname ) {
|
|||
|
|
|
|||
|
|
if ( fname === undefined ) {
|
|||
|
|
|
|||
|
|
return "";
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ignore directory structure, flatten path
|
|||
|
|
var splitted = fname.split( /[\\\/]/ );
|
|||
|
|
if ( splitted.length > 0 ) {
|
|||
|
|
|
|||
|
|
return splitted[ splitted.length - 1 ];
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
return fname;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Texture.prototype.searchParents = function ( id, nodes ) {
|
|||
|
|
|
|||
|
|
var p = nodes.searchConnectionParent( id );
|
|||
|
|
|
|||
|
|
return p;
|
|||
|
|
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function Materials() {
|
|||
|
|
|
|||
|
|
this.materials = {};
|
|||
|
|
this.perGeoMap = {};
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Object.assign( Materials.prototype, {
|
|||
|
|
|
|||
|
|
parse: function ( node ) {
|
|||
|
|
|
|||
|
|
var rawNodes = node.Objects.subNodes.Material;
|
|||
|
|
|
|||
|
|
for ( var n in rawNodes ) {
|
|||
|
|
|
|||
|
|
var mat = ( new Material() ).parse( rawNodes[ n ], node );
|
|||
|
|
this.materials[ n ] = mat;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
function Material() {
|
|||
|
|
|
|||
|
|
this.fileName = "";
|
|||
|
|
this.name = "";
|
|||
|
|
this.id = null;
|
|||
|
|
this.parentIds = [];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Object.assign( Material.prototype, {
|
|||
|
|
|
|||
|
|
parse: function ( node, nodes ) {
|
|||
|
|
|
|||
|
|
this.id = node.id;
|
|||
|
|
this.name = node.attrName;
|
|||
|
|
this.type = node.properties.ShadingModel;
|
|||
|
|
|
|||
|
|
this.parameters = this.parseParameters( node.properties );
|
|||
|
|
|
|||
|
|
this.parentIds = this.searchParents( this.id, nodes );
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
parseParameters: function ( properties ) {
|
|||
|
|
|
|||
|
|
var parameters = {};
|
|||
|
|
|
|||
|
|
//TODO: Missing parameters:
|
|||
|
|
// - Ambient
|
|||
|
|
// - MultiLayer
|
|||
|
|
// - ShininessExponent (Same vals as Shininess)
|
|||
|
|
// - Specular (Same vals as SpecularColor)
|
|||
|
|
// - TransparencyFactor (Maybe same as Opacity?).
|
|||
|
|
|
|||
|
|
if ( properties.Diffuse ) {
|
|||
|
|
|
|||
|
|
parameters.color = new THREE.Color().fromArray( [ parseFloat( properties.Diffuse.value.x ), parseFloat( properties.Diffuse.value.y ), parseFloat( properties.Diffuse.value.z ) ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.Specular ) {
|
|||
|
|
|
|||
|
|
parameters.specular = new THREE.Color().fromArray( [ parseFloat( properties.Specular.value.x ), parseFloat( properties.Specular.value.y ), parseFloat( properties.Specular.value.z ) ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.Shininess ) {
|
|||
|
|
|
|||
|
|
parameters.shininess = properties.Shininess.value;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.Emissive ) {
|
|||
|
|
|
|||
|
|
parameters.emissive = new THREE.Color().fromArray( [ parseFloat( properties.Emissive.value.x ), parseFloat( properties.Emissive.value.y ), parseFloat( properties.Emissive.value.z ) ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.EmissiveFactor ) {
|
|||
|
|
|
|||
|
|
parameters.emissiveIntensity = properties.EmissiveFactor.value;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.Reflectivity ) {
|
|||
|
|
|
|||
|
|
parameters.reflectivity = properties.Reflectivity.value;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( properties.Opacity ) {
|
|||
|
|
|
|||
|
|
parameters.opacity = properties.Opacity.value;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
if ( parameters.opacity < 1.0 ) {
|
|||
|
|
|
|||
|
|
parameters.transparent = true;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Assigning textures
|
|||
|
|
|
|||
|
|
|
|||
|
|
return parameters;
|
|||
|
|
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
searchParents: function ( id, nodes ) {
|
|||
|
|
|
|||
|
|
return nodes.searchConnectionParent( id );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* --------------------------------------------------------------------- */
|
|||
|
|
/* --------------------------------------------------------------------- */
|
|||
|
|
/* --------------------------------------------------------------------- */
|
|||
|
|
/* --------------------------------------------------------------------- */
|
|||
|
|
|
|||
|
|
// LayerElementUV: 0 {
|
|||
|
|
// Version: 101
|
|||
|
|
// Name: "Texture_Projection"
|
|||
|
|
// MappingInformationType: "ByPolygonVertex"
|
|||
|
|
// ReferenceInformationType: "IndexToDirect"
|
|||
|
|
// UV: *1746 {
|
|||
|
|
// UVIndex: *7068 {
|
|||
|
|
//
|
|||
|
|
// The order of the uvs is given by the UVIndex property.
|
|||
|
|
function parse_Data_ByPolygonVertex_IndexToDirect( node, indices, itemSize ) {
|
|||
|
|
|
|||
|
|
var res = [];
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < indices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
for ( var j = 0; j < itemSize; ++ j ) {
|
|||
|
|
|
|||
|
|
res.push( node[ ( indices[ i ] * itemSize ) + j ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
// what want: normal per vertex, order vertice
|
|||
|
|
// i have: normal per polygon
|
|||
|
|
// i have: indice per polygon
|
|||
|
|
function parse_Data_ByPolygonVertex_Direct( node, indices, strides, itemSize ) {
|
|||
|
|
|
|||
|
|
// *21204 > 3573
|
|||
|
|
// Geometry: 690680816, "Geometry::", "Mesh" {
|
|||
|
|
// Vertices: *3573 {
|
|||
|
|
// PolygonVertexIndex: *7068 {
|
|||
|
|
|
|||
|
|
var tmp = [];
|
|||
|
|
var currentIndex = 0;
|
|||
|
|
|
|||
|
|
// first: sort to per vertex
|
|||
|
|
for ( var i = 0; i < indices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
tmp[ indices[ i ] ] = [];
|
|||
|
|
|
|||
|
|
// TODO: duped entry? blend or something?
|
|||
|
|
for ( var s = 0; s < itemSize; ++ s ) {
|
|||
|
|
|
|||
|
|
tmp[ indices[ i ] ][ s ] = node[ currentIndex + s ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
currentIndex += itemSize;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// second: expand x,y,z into serial array
|
|||
|
|
var res = [];
|
|||
|
|
for ( var jj = 0; jj < tmp.length; ++ jj ) {
|
|||
|
|
|
|||
|
|
if ( tmp[ jj ] === undefined ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( var t = 0; t < itemSize; ++ t ) {
|
|||
|
|
|
|||
|
|
if ( tmp[ jj ][ t ] === undefined ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
res.push( tmp[ jj ][ t ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// convert from by polygon(vert) data into by verts data
|
|||
|
|
function mapByPolygonVertexToByVertex( data, indices, stride ) {
|
|||
|
|
|
|||
|
|
var tmp = {};
|
|||
|
|
var res = [];
|
|||
|
|
var max = 0;
|
|||
|
|
|
|||
|
|
for ( var i = 0; i < indices.length; ++ i ) {
|
|||
|
|
|
|||
|
|
if ( indices[ i ] in tmp ) {
|
|||
|
|
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tmp[ indices[ i ] ] = {};
|
|||
|
|
|
|||
|
|
for ( var j = 0; j < stride; ++ j ) {
|
|||
|
|
|
|||
|
|
tmp[ indices[ i ] ][ j ] = data[ i * stride + j ];
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
max = max < indices[ i ] ? indices[ i ] : max;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
|
|||
|
|
for ( i = 0; i <= max; i ++ ) {
|
|||
|
|
|
|||
|
|
for ( var s = 0; s < stride; s ++ ) {
|
|||
|
|
|
|||
|
|
res.push( tmp[ i ][ s ] );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} catch ( e ) {
|
|||
|
|
//console.log( max );
|
|||
|
|
//console.log( tmp );
|
|||
|
|
//console.log( i );
|
|||
|
|
//console.log( e );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// AUTODESK uses broken clock. i guess
|
|||
|
|
function FBXTimeToSeconds( adskTime ) {
|
|||
|
|
|
|||
|
|
return adskTime / 46186158000;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function degToRad( degrees ) {
|
|||
|
|
|
|||
|
|
return degrees * Math.PI / 180;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function quatFromVec( x, y, z ) {
|
|||
|
|
|
|||
|
|
var euler = new THREE.Euler( x, y, z, 'ZYX' );
|
|||
|
|
var quat = new THREE.Quaternion();
|
|||
|
|
quat.setFromEuler( euler );
|
|||
|
|
|
|||
|
|
return quat;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseArrayToInt( string ) {
|
|||
|
|
|
|||
|
|
return string.split( ',' ).map( function ( element ) {
|
|||
|
|
|
|||
|
|
return parseInt( element );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseArrayToFloat( string ) {
|
|||
|
|
|
|||
|
|
return string.split( ',' ).map( function ( element ) {
|
|||
|
|
|
|||
|
|
return parseFloat( element );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseArrayToRadians( string ) {
|
|||
|
|
|
|||
|
|
return string.split( ',' ).map( function ( element ) {
|
|||
|
|
|
|||
|
|
return degToRad( parseFloat( element ) );
|
|||
|
|
|
|||
|
|
} );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseArrayToMatrix( string ) {
|
|||
|
|
|
|||
|
|
var arr = parseArrayToFloat( string );
|
|||
|
|
return new THREE.Matrix4().fromArray( arr );
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} )();
|