three
Version:
JavaScript 3D library
2,169 lines (1,331 loc) • 61.1 kB
JavaScript
/**
* @author yamahigashi https://github.com/yamahigashi
*
* This loader loads FBX file in *ASCII and version 7 format*.
*
* Support
* - mesh
* - skinning
* - normal / uv
*
* Not Support
* - material
* - texture
* - morph
*/
( function() {
THREE.FBXLoader = function ( showStatus, manager ) {
THREE.Loader.call( this, showStatus );
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;
THREE.FBXLoader.prototype.load = function ( url, onLoad, onProgress, onError ) {
var scope = this;
var loader = new THREE.XHRLoader( 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 );
};
THREE.FBXLoader.prototype.setCrossOrigin = function ( value ) {
this.crossOrigin = value;
};
THREE.FBXLoader.prototype.isFbxFormatASCII = function ( body ) {
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 ) {
num = read( 1 );
if ( num == CORRECT[ i ] ) {
return false;
}
}
return true;
};
THREE.FBXLoader.prototype.isFbxVersionSupported = function ( body ) {
var versionExp = /FBXVersion: (\d+)/;
match = body.match( versionExp );
if ( match ) {
var version = parseInt( match[ 1 ] );
console.log( 'FBXLoader: FBX version ' + version );
return version >= 7000;
}
return false;
};
THREE.FBXLoader.prototype.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 );
console.timeEnd( 'FBXLoader: ObjectParser' );
console.time( 'FBXLoader: GeometryParser' );
geometries = this.parseGeometries( nodes );
console.timeEnd( 'FBXLoader: GeometryParser' );
var container = new THREE.Group();
for ( var i = 0; i < geometries.length; ++ i ) {
if ( geometries[ i ] === undefined ) {
continue;
}
container.add( geometries[ 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;
};
THREE.FBXLoader.prototype.parseGeometries = function ( node ) {
// has not geo, return []
if ( ! ( 'Geometry' in node.Objects.subNodes ) ) {
return [];
}
// has many
var geoCount = 0;
for ( var geo in node.Objects.subNodes.Geometry ) {
if ( geo.match( /^\d+$/ ) ) {
geoCount ++;
}
}
var res = [];
if ( geoCount > 0 ) {
for ( geo in node.Objects.subNodes.Geometry ) {
if ( node.Objects.subNodes.Geometry[ geo ].attrType === 'Mesh' ) {
res.push( this.parseGeometry( node.Objects.subNodes.Geometry[ geo ], node ) );
}
}
} else {
res.push( this.parseGeometry( node.Objects.subNodes.Geometry, node ) );
}
return res;
};
THREE.FBXLoader.prototype.parseGeometry = function ( node, nodes ) {
geo = ( new Geometry() ).parse( node );
geo.addBones( this.hierarchy.hierarchy );
//*
var geometry = new THREE.BufferGeometry();
geometry.name = geo.name;
geometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( geo.vertices ), 3 ) );
if ( geo.normals !== undefined && geo.normals.length > 0 ) {
geometry.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( geo.normals ), 3 ) );
}
if ( geo.uvs !== undefined && geo.uvs.length > 0 ) {
geometry.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( geo.uvs ), 2 ) );
}
if ( geo.indices !== undefined && geo.indices.length > 65535 ) {
geometry.setIndex( new THREE.BufferAttribute( new Uint32Array( geo.indices ), 1 ) );
} else if ( geo.indices !== undefined ) {
geometry.setIndex( new THREE.BufferAttribute( new Uint16Array( geo.indices ), 1 ) );
}
geometry.verticesNeedUpdate = true;
geometry.computeBoundingSphere();
geometry.computeBoundingBox();
// TODO: texture & material support
var texture;
var texs = this.textures.getById( nodes.searchConnectionParent( geo.id ) );
if ( texs !== undefined && texs.length > 0 ) {
if ( this.textureLoader === null ) {
this.textureLoader = new THREE.TextureLoader();
}
texture = this.textureLoader.load( this.textureBasePath + '/' + texs[ 0 ].fileName );
}
var material;
if ( texture !== undefined ) {
material = new THREE.MeshBasicMaterial( { map: texture } );
} else {
material = new THREE.MeshBasicMaterial( { color: 0x3300ff } );
}
geometry = new THREE.Geometry().fromBufferGeometry( geometry );
geometry.bones = geo.bones;
geometry.skinIndices = this.weights.skinIndices;
geometry.skinWeights = this.weights.skinWeights;
var mesh = null;
if ( geo.bones === undefined || geo.skins === undefined || this.animations === undefined || this.animations.length === 0 ) {
mesh = new THREE.Mesh( geometry, material );
} else {
material.skinning = true;
mesh = new THREE.SkinnedMesh( geometry, material );
this.addAnimation( mesh, this.weights.matrices, this.animations );
}
return mesh;
};
THREE.FBXLoader.prototype.addAnimation = function ( mesh, matrices, animations ) {
var animationdata = { "name": 'animationtest', "fps": 30, "length": animations.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: [] } );
}
var hasCurve = function ( animNode, attr ) {
if ( animNode === undefined ) {
return false;
}
var attrNode;
switch ( attr ) {
case 'S':
if ( animNode.S === undefined ) {
return false;
}
attrNode = animNode.S;
break;
case 'R':
if ( animNode.R === undefined ) {
return false;
}
attrNode = animNode.R;
break;
case 'T':
if ( animNode.T === undefined ) {
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;
};
var hasKeyOnFrame = function ( 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;
};
var isKeyExistOnFrame = function ( curve, frame ) {
var value = curve.values[ frame ];
return value !== undefined;
};
var genKey = function ( 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 ];
} else {
delete key.pos;
}
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 ];
} else {
delete key.rot;
}
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 ];
} else {
delete key.scl;
}
} catch ( e ) {
// curve is not full plotted
console.log( bone );
console.log( e );
}
return key;
};
var bones = mesh.geometry.bones;
for ( frame = 0; frame < animations.frames; frame ++ ) {
for ( i = 0; i < bones.length; i ++ ) {
var bone = bones[ i ];
var animNode = animations.curves[ 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 ) );
};
THREE.FBXLoader.prototype.parseMaterials = function ( node ) {
// has not mat, return []
if ( ! ( 'Material' in node.subNodes ) ) {
return [];
}
// has many
var matCount = 0;
for ( var mat in node.subNodes.Materials ) {
if ( mat.match( /^\d+$/ ) ) {
matCount ++;
}
}
var res = [];
if ( matCount > 0 ) {
for ( mat in node.subNodes.Material ) {
res.push( parseMaterial( node.subNodes.Material[ mat ] ) );
}
} else {
res.push( parseMaterial( node.subNodes.Material ) );
}
return res;
};
// TODO
THREE.FBXLoader.prototype.parseMaterial = function ( node ) {
};
THREE.FBXLoader.prototype.loadFile = function ( url, onLoad, onProgress, onError, responseType ) {
var loader = new THREE.XHRLoader( this.manager );
loader.setResponseType( responseType );
var request = loader.load( url, function ( result ) {
onLoad( result );
}, onProgress, onError );
return request;
};
THREE.FBXLoader.prototype.loadFileAsBuffer = function ( url, onload, onProgress, onError ) {
this.loadFile( url, onLoad, onProgress, onError, 'arraybuffer' );
};
THREE.FBXLoader.prototype.loadFileAsText = function ( url, onLoad, onProgress, onError ) {
this.loadFile( url, onLoad, onProgress, onError, 'text' );
};
/* ----------------------------------------------------------------- */
function FBXNodes() {}
FBXNodes.prototype.add = function ( key, val ) {
this[ key ] = val;
};
FBXNodes.prototype.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 ];
}
};
FBXNodes.prototype.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 ] = [ - 1 ];
return [ - 1 ];
}
};
FBXNodes.prototype.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() {}
FBXParser.prototype = {
// constructor: FBXParser,
// ------------ node stack manipulations ----------------------------------
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+):(.*){", '' );
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](.*)" );
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 {
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 ( line ) {
this.popStack();
},
/* ---------------------------------------------------------------- */
/* util */
isFlattenNode: function ( node ) {
return ( 'subNodes' in node && 'properties' in node ) ? true : false;
}
};
function FBXAnalyzer() {}
FBXAnalyzer.prototype = {
};
// 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 = toInt( entry.subNodes.Indexes.properties.a.split( ',' ) );
var _weights = toFloat( entry.subNodes.Weights.properties.a.split( ',' ) );
var _transform = toMat44( toFloat( entry.subNodes.Transform.properties.a.split( ',' ) ) );
var _link = toMat44( toFloat( entry.subNodes.TransformLink.properties.a.split( ',' ) ) );
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 ++ ) {
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 = toFloat( bone.properties.Lcl_Translation.value.split( ',' ) );
}
if ( 'Lcl_Rotation' in bone.properties ) {
r = toRad( toFloat( bone.properties.Lcl_Rotation.value.split( ',' ) ) );
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 = toFloat( bone.properties.Lcl_Scaling.value.split( ',' ) );
}
// 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;
}
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 = toMat44( poseNode[ i ].subNodes.Matrix.properties.a.split( ',' ) );
var rawMatWrd = toMat44( poseNode[ i ].subNodes.Matrix.properties.a.split( ',' ) );
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 ) {
var res = i;
node.__cache_get_boneid_from_internalid[ id ] = i;
return i;
}
}
// console.warn( 'FBXLoader: bone internalId(' + id + ') not found in bone hierarchy' );
return - 1;
};
function Geometry() {
this.node = null;
this.name = null;
this.id = null;
this.vertices = [];
this.indices = [];
this.normals = [];
this.uvs = [];
this.bones = [];
this.skins = null;
}
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 );
if ( this.getPolygonTopologyMax() > 3 ) {
this.indices = this.convertPolyIndicesToTri(
this.indices, this.getPolygonTopologyArray() );
}
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 )....
Geometry.prototype.convertPolyIndicesToTri = function ( indices, strides ) {
var res = [];
var i = 0;
var tmp = [];
var currentPolyNum = 0;
var currentStride = 0;
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 ) ] );
}
currentPolyNum ++;
i += currentStride;
}
return res;
};
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 );
if ( uvNode === undefined ) {
// console.log( node.attrName + "(" + node.id + ")" + " has no LayerElementUV." );
return [];
}
var count = 0;
var x = '';
for ( var n in uvNode ) {
if ( n.match( /^\d+$/ ) ) {
count ++;
x = n;
}
}
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 = toFloat( uvs.split( ',' ) );
this.index = toInt( uvIndex.split( ',' ) );
this.map = uvMap; // TODO: normalize notation shaking... FOR BLENDER
this.ref = uvRef;
return this.uv;
};
UV.prototype.parse = function ( node, geo ) {
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 );
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 = toFloat( rawTextNormals.split( ',' ) );
// 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;
};