THUTHACH/wwwroot/games/G10/js/FBXLoader.js

/**
 * @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);


            var aConnections = nodes.Connections.properties.connections;
            var aModels = nodes.Objects.subNodes.Model;
          //  console.log(nodes);

            for (var i = 0; i < aConnections.length; i++) {
                if (aConnections[i][0] === node.id) {
                    // associo il nome della mesh pescandolo tramite la struttura connections nell'array di models
                        mesh.name = aModels[aConnections[i][1]].attrName;
                        if (aModels[aConnections[i][1]].properties.Lcl_Translation) {
                            //console.log(aModels[aConnections[i][1]].properties.Lcl_Translation);

                            var aCoordinate = aModels[aConnections[i][1]].properties.Lcl_Translation.value.split(",");
                            //  console.log(parseFloat(aModels[aConnections[i][1]].properties.Lcl_Translation.value));
                            for (var i = 0; i < aCoordinate.length; i++) {
                                aCoordinate[i] = parseFloat(aCoordinate[i]);
                            }

                            //INVERTED AXIS Y UP TO Z UP                   
                            mesh.position.x = aCoordinate[0];
                            mesh.position.y = aCoordinate[1];
                            mesh.position.z = aCoordinate[2];


                        } else {
                            // console.log(aModels[aConnections[i][1]].properties.GeometricTranslation.value);
                        }
                        break;
                    
                }
            }
            //------------------------------------------
        } 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;

        //bbb

        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;

    };

    Normal.prototype.parseNormal_ByVertex_Direct = function (node) {

        console.warn("not implemented");
        return node;

    };

    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 = toFloat(this.times.split(','));
        this.values = toFloat(this.values.split(','));
        this.attrData = toFloat(this.attrData.split(','));
        this.attrFlag = toInt(this.attrFlag.split(','));

        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;

        // 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 = [];
        var max = 0.0;
        for (key in rawCurves) {

            if (key.match(/\d+/)) {

                var c = (new AnimationCurve()).fromNode(rawCurves[ key ]);
                ac.push(c);
                max = c.getLength() ? c.getLength() : max;

                var parentId = node.searchConnectionParent(c.id)[ 0 ];
                var axis = node.searchConnectionType(c.id, parentId);

                if (axis.match(/X/)) {

                    axis = 'x';

                }
                if (axis.match(/Y/)) {

                    axis = 'y';

                }
                if (axis.match(/Z/)) {

                    axis = 'z';

                }

                tmp[ parentId ].curves[ axis ] = c;

            }

        }

        // forth:
        for (var t in tmp) {

            var id = tmp[ t ].containerBoneId;
            if (this.curves[ id ] === undefined) {

                this.curves[ id ] = {};

            }

            this.curves[ id ][ tmp[ t ].attr ] = tmp[ t ];

        }

        this.length = max;
        this.frames = this.length * this.fps;

        return this;

    };


    function Textures() {

        this.textures = [];
        this.perGeoMap = {};

    }

    Textures.prototype.add = function (tex) {

        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, bones) {

        var rawNodes = node.Objects.subNodes.Texture;

        for (var n in rawNodes) {

            var tex = (new Texture()).parse(rawNodes[ n ], node);
            this.add(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 loadTextureImage(texture, url) {

        var loader = new THREE.ImageLoader();

        loader.load(url, function (image) {


        });

        loader.load(url, function (image) {

            texture.image = image;
            texture.needUpdate = true;
            console.log('tex load done');

        },
                // Function called when download progresses
                        function (xhr) {

                            console.log((xhr.loaded / xhr.total * 100) + '% loaded');

                        },
                        // Function called when download errors
                                function (xhr) {

                                    console.log('An error happened');

                                }
                        );

                    }

            // 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
            parse_Data_ByPolygonVertex_Direct = function (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
            var FBXTimeToSeconds = function (adskTime) {

                return adskTime / 46186158000;

            };

            degToRad = function (degrees) {

                return degrees * Math.PI / 180;

            };

            radToDeg = function (radians) {

                return radians * 180 / Math.PI;

            };

            quatFromVec = function (x, y, z) {

                var euler = new THREE.Euler(x, y, z, 'ZYX');
                var quat = new THREE.Quaternion();
                quat.setFromEuler(euler);

                return quat;

            };


            // extend Array.prototype ?  ....uuuh
            toInt = function (arr) {

                return arr.map(function (element) {

                    return parseInt(element);

                });

            };

            toFloat = function (arr) {

                return arr.map(function (element) {

                    return parseFloat(element);

                });

            };

            toRad = function (arr) {

                return arr.map(function (element) {

                    return degToRad(element);

                });

            };

            toMat44 = function (arr) {

                var mat = new THREE.Matrix4();
                mat.set(
                        arr[ 0 ], arr[ 4 ], arr[ 8 ], arr[ 12 ],
                        arr[ 1 ], arr[ 5 ], arr[ 9 ], arr[ 13 ],
                        arr[ 2 ], arr[ 6 ], arr[ 10 ], arr[ 14 ],
                        arr[ 3 ], arr[ 7 ], arr[ 11 ], arr[ 15 ]
                        );

                /*
                 mat.set(
                 arr[ 0], arr[ 1], arr[ 2], arr[ 3],
                 arr[ 4], arr[ 5], arr[ 6], arr[ 7],
                 arr[ 8], arr[ 9], arr[10], arr[11],
                 arr[12], arr[13], arr[14], arr[15]
                 );
                 // */

                return mat;

            };

        })();