--- /dev/null
+
+/**
+ * @author Jey-en https://github.com/adrs2002
+ *
+ * this loader repo -> https://github.com/adrs2002/threeXLoader
+ *
+ * This loader is load model (and animation) from .X file format. (for old DirectX).
+ * ! this version are load from TEXT format .X only ! not a Binary.
+ *
+ * Support
+ * - mesh
+ * - texture
+ * - normal / uv
+ * - material
+ * - skinning
+ *
+ * Not Support
+ * - template
+ * - material(ditail)
+ * - morph
+ * - scene
+ */
+
+THREE.XLoader = function (manager, Texloader, _zflg) {
+
+ this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+ this.Texloader = ( Texloader !== undefined ) ? Texloader : new THREE.TextureLoader();
+ this.zflg = _zflg === undefined ? false : _zflg;
+ this.url = "";
+ this.baseDir = "";
+ this.nowReadMode = THREE.XLoader.XfileLoadMode.none;
+ this.nowAnimationKeyType = 4;
+ this.tgtLength = 0;
+ this.nowReaded = 0;
+ this.elementLv = 0;
+ this.geoStartLv = Number.MAX_VALUE;
+ this.frameStartLv = Number.MAX_VALUE;
+ this.matReadLine = 0;
+ this.putMatLength = 0;
+ this.nowMat = null;
+ this.BoneInf = new THREE.XLoader.XboneInf();
+ this.tmpUvArray = [];
+ this.normalVectors = [];
+ this.facesNormal = [];
+ this.nowFrameName = "";
+ this.nowAnimationSetName = "";
+ this.frameHierarchie = [];
+ this.endLineCount = 0;
+ this.geometry = null;
+ this.loadingXdata = null;
+ this.lines = null;
+ this.keyInfo = null;
+ this.animeKeyNames = null;
+ this.data = null;
+ this.onLoad = null;
+
+};
+
+THREE.XLoader.prototype = {
+
+ constructor: THREE.XLoader,
+
+ load: function (_arg, onLoad, onProgress, onError) {
+
+ var scope = this;
+ scope.IsUvYReverse = true;
+ var loader = new THREE.FileLoader(scope.manager);
+ loader.setResponseType('arraybuffer');
+
+ for (var i = 0; i < _arg.length; i++) {
+
+ switch (i) {
+
+ case 0:
+ scope.url = _arg[i]; break;
+ case 1:
+ scope.zflg = _arg[i]; break;
+
+ }
+
+ }
+
+ loader.load(scope.url, function (response) {
+
+ scope.parse(response, onLoad);
+
+ }, onProgress, onError);
+
+ },
+
+ isBinary: function (binData) {
+
+ var reader = new DataView(binData);
+ var face_size = 32 / 8 * 3 + 32 / 8 * 3 * 3 + 16 / 8;
+ var n_faces = reader.getUint32(80, true);
+ var expect = 80 + 32 / 8 + n_faces * face_size;
+ if (expect === reader.byteLength) {
+
+ return true;
+
+ }
+ var fileLength = reader.byteLength;
+ for (var index = 0; index < fileLength; index++) {
+
+ if (reader.getUint8(index, false) > 127) {
+
+ return true;
+
+ }
+
+ }
+ return false;
+
+ },
+
+ ensureBinary: function (buf) {
+
+ if (typeof buf === "string") {
+
+ var array_buffer = new Uint8Array(buf.length);
+ for (var i = 0; i < buf.length; i++) {
+
+ array_buffer[i] = buf.charCodeAt(i) & 0xff;
+
+ }
+ return array_buffer.buffer || array_buffer;
+
+ } else {
+
+ return buf;
+
+
+ }
+
+ },
+
+ ensureString: function (buf) {
+
+ if (typeof buf !== "string") {
+
+ var array_buffer = new Uint8Array(buf);
+ var str = '';
+ for (var i = 0; i < buf.byteLength; i++) {
+
+ str += String.fromCharCode(array_buffer[i]);
+
+ }
+ return str;
+
+ } else {
+
+ return buf;
+
+ }
+
+ },
+
+ parse: function (data, onLoad) {
+
+ var scope = this;
+ var binData = scope.ensureBinary(data);
+ scope.data = scope.ensureString(data);
+ scope.onLoad = onLoad;
+ return scope.isBinary(binData) ? scope.parseBinary(binData) : scope.parseASCII();
+
+ },
+
+ parseBinary: function (data) {
+
+ return parseASCII(String.fromCharCode.apply(null, data));
+
+ },
+
+ parseASCII: function () {
+
+ var scope = this;
+ var baseDir = "";
+ if (scope.url.lastIndexOf("/") > 0) {
+
+ scope.baseDir = scope.url.substr(0, scope.url.lastIndexOf("/") + 1);
+
+ }
+ scope.loadingXdata = new THREE.XLoader.Xdata();
+ scope.loadingXdata.vertexNormalFromFile = false;
+ scope.loadingXdata.faceNormalFromFile = false;
+ scope.lines = scope.data;
+ scope.readedLength = 0;
+ scope.mainloop();
+
+ },
+
+ mainloop: function () {
+
+ var scope = this;
+ var EndFlg = false;
+ for (var i = 0; i < 10; i++) {
+
+ var forceBreak = scope.SectionRead();
+ scope.endLineCount++;
+ if (scope.readedLength >= scope.data.length) {
+
+ EndFlg = true;
+ scope.readFinalize();
+ setTimeout(function () {
+
+ scope.animationFinalize();
+
+ }, 1);
+ break;
+
+ }
+ if (forceBreak) {
+
+ break;
+
+ }
+
+ }
+ if (!EndFlg) {
+
+ setTimeout(function () {
+
+ scope.mainloop();
+
+ }, 1);
+
+ }
+
+ },
+
+ getNextSection: function (_offset, _start, _end) {
+
+ var scope = this;
+ var find = scope.data.indexOf("{", _offset);
+ return [scope.data.substr(_offset, _start - _offset).trim(), scope.data.substr(_start + 1, _end - _start - 1)];
+
+ },
+
+ getNextSection2: function (_obj, _offset, _start, _end) {
+
+ var find = _obj.indexOf("{", _offset);
+ return [_obj.substr(_offset, _start - _offset).trim(), _obj.substr(_start + 1, _end - _start - 1)];
+
+ },
+
+ readMeshSection: function (_baseOffset) {
+
+ var scope = this;
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry = new THREE.Geometry();
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Materials = [];
+ var find_2semi = scope.data.indexOf(";;", _baseOffset);
+ var offset = 0;
+ var v_data = scope.getVertextDataSection(scope.data.substr(_baseOffset, find_2semi - _baseOffset), 0);
+ for (var i = 0; i < v_data[0].length; i++) {
+
+ scope.readVertex(v_data[0][i]);
+
+ }
+ offset = find_2semi + 2;
+ find_2semi = scope.data.indexOf(";;", offset);
+ var v_data2 = scope.getVertextDataSection(scope.data.substr(offset + 1, find_2semi - offset + 1), 0);
+ for (var _i = 0; _i < v_data2[0].length; _i++) {
+
+ scope.readVertexIndex(v_data2[0][_i]);
+
+ }
+ scope.readedLength = offset + v_data2[1] + 1;
+
+ },
+
+ getVertextDataSection: function (_data, _offset) {
+
+ var find = _data.indexOf(";", _offset);
+ var find_2semi = _data.indexOf(";;", _offset);
+ if (find_2semi === - 1) {
+
+ find_2semi = _data.length - 1;
+
+ }
+ var v_data_base = _data.substr(find + 1, find_2semi - find + 2);
+ return [v_data_base.split(";,"), find_2semi + 2];
+
+ },
+
+ readMeshMaterialSet: function (_baseOffset) {
+
+ var scope = this;
+ var find = scope.data.indexOf(";", _baseOffset);
+ find = scope.data.indexOf(";", find + 2);
+ var find2 = scope.data.indexOf(";", find + 2);
+ var _data = scope.data.substr(find + 1, find2 - find + 1);
+ var v_data = _data.split(",");
+ for (var i = 0; i < v_data.length; i++) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[i].materialIndex = parseInt(v_data[i], 10);
+
+ }
+ scope.readedLength = find2 + 1;
+
+ },
+
+ readMaterial: function (_dataLine) {
+
+ var scope = this;
+ scope.nowMat = new THREE.MeshPhongMaterial({ color: Math.random() * 0xffffff });
+ if (scope.zflg) {
+
+ scope.nowMat.side = THREE.BackSide;
+
+ } else {
+
+ scope.nowMat.side = THREE.FrontSide;
+
+ }
+ var find = _dataLine.indexOf(";;");
+ var _diff = _dataLine.substr(0, find).split(";");
+ scope.nowMat.color.r = parseFloat(_diff[0]);
+ scope.nowMat.color.g = parseFloat(_diff[1]);
+ scope.nowMat.color.b = parseFloat(_diff[2]);
+ var find2 = _dataLine.indexOf(";", find + 3);
+ scope.nowMat.shininess = parseFloat(_dataLine.substr(find + 2, find2 - find - 2));
+ find = _dataLine.indexOf(";;", find2 + 1);
+ var _specular = _dataLine.substr(find2 + 1, find - find2).split(";");
+ scope.nowMat.specular.r = parseFloat(_specular[0]);
+ scope.nowMat.specular.g = parseFloat(_specular[1]);
+ scope.nowMat.specular.b = parseFloat(_specular[2]);
+ find2 = _dataLine.indexOf(";;", find + 2);
+ var _emissive = _dataLine.substr(find + 2, find2 - find - 2).split(";");
+ scope.nowMat.emissive.r = parseFloat(_emissive[0]);
+ scope.nowMat.emissive.g = parseFloat(_emissive[1]);
+ scope.nowMat.emissive.b = parseFloat(_emissive[2]);
+
+ },
+
+ readSkinWeights: function (_data) {
+
+ var scope = this;
+ scope.BoneInf = new THREE.XLoader.XboneInf();
+ var find = _data.indexOf(";");
+ scope.readBoneName(_data.substr(0, find - 1).replace('"', ''));
+ var find_1 = _data.indexOf(";", find + 1) + 1;
+ var matrixStart = 0;
+ if (parseInt(_data.substr(find, find_1 - find), 10) === 0) {
+
+ matrixStart = find_1 + 1;
+
+ } else {
+
+ var _find = _data.indexOf(";", find_1 + 1);
+ var i_data = _data.substr(find_1, _find - find_1).split(",");
+ for (var i = 0; i < i_data.length; i++) {
+
+ scope.BoneInf.Indeces.push(parseInt(i_data[i], 10));
+
+ }
+ var find3 = _data.indexOf(";", _find + 1);
+ var w_data = _data.substr(_find + 1, find3 - _find).split(",");
+ for (var _i2 = 0; _i2 < w_data.length; _i2++) {
+
+ scope.BoneInf.Weights.push(parseFloat(w_data[_i2]));
+
+ }
+ matrixStart = find3 + 1;
+
+ }
+ var find4 = _data.indexOf(";;", matrixStart + 1);
+ var m_data = _data.substr(matrixStart, find4 - matrixStart).split(",");
+ scope.BoneInf.initMatrix = new THREE.Matrix4();
+ scope.ParseMatrixData(scope.BoneInf.initMatrix, m_data);
+ scope.BoneInf.OffsetMatrix = new THREE.Matrix4();
+ scope.BoneInf.OffsetMatrix.getInverse(scope.BoneInf.initMatrix);
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].BoneInfs.push(scope.BoneInf);
+
+ },
+
+ getPlaneStr: function (_str) {
+
+ var scope = this;
+ var firstDbl = _str.indexOf('"') + 1;
+ var dbl2 = _str.indexOf('"', firstDbl);
+ return _str.substr(firstDbl, dbl2 - firstDbl);
+
+ },
+
+ readAnimationKeyFrame: function (_data) {
+
+ var scope = this;
+ var find1 = _data.indexOf(';');
+ scope.nowAnimationKeyType = parseInt(_data.substr(0, find1), 10);
+ var find2 = _data.indexOf(';', find1 + 1);
+ var lines = _data.substr(find2 + 1).split(';;,');
+ for (var i = 0; i < lines.length; i++) {
+
+ scope.readAnimationKeyFrameValue(lines[i]);
+
+ }
+
+ },
+
+ SectionRead: function () {
+
+ var scope = this;
+ var find = scope.data.indexOf("{", scope.readedLength);
+ if (find === - 1) {
+
+ scope.readedLength = scope.data.length; return;
+
+ }
+ var lines = scope.data.substr(scope.readedLength, find - scope.readedLength).split(/\r\n|\r|\n/);
+ var line = lines[0];
+ for (var i = lines.length - 1; i >= 0; i--) {
+
+ if (lines[i].trim().length > 0 && lines[i].indexOf('//') < 0) {
+
+ line = lines[i];
+ break;
+
+ }
+
+ }
+ var find2 = scope.data.indexOf("{", find + 1);
+ var find3 = scope.data.indexOf("}", find + 1);
+ var find4 = scope.data.indexOf("}", scope.readedLength);
+ if (find4 < find) {
+
+ if (scope.elementLv < 1 || scope.nowFrameName === "") {
+
+ scope.elementLv = 0;
+
+ } else {
+
+ scope.endElement();
+
+ }
+ scope.readedLength = find4 + 1;
+ return false;
+
+ }
+ if (find3 > find2) {
+
+ scope.elementLv++;
+ if (line.indexOf("Frame ") > - 1) {
+
+ scope.beginFrame(line);
+
+ } else if (line.indexOf("Mesh ") > - 1) {
+
+ scope.readMeshSection(find + 1);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mesh;
+ return true;
+
+ } else if (line.indexOf("MeshMaterialList ") > - 1) {
+
+ scope.readMeshMaterialSet(find + 1);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set;
+ return true;
+
+ } else if (line.indexOf("Material ") > - 1) {
+
+ var nextSemic = scope.data.indexOf(";;", find + 1);
+ nextSemic = scope.data.indexOf(";;", nextSemic + 1);
+ nextSemic = scope.data.indexOf(";;", nextSemic + 1);
+ scope.readMaterial(scope.data.substr(find + 1, nextSemic - find + 1));
+ scope.readedLength = nextSemic + 2;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_detail;
+ return true;
+
+ } else if (line.indexOf("AnimationSet ") > - 1) {
+
+ scope.readandCreateAnimationSet(line);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Anim_init;
+ scope.readedLength = find + 1;
+ return false;
+
+ } else if (line.indexOf("Animation ") > - 1) {
+
+ scope.readAndCreateAnimation(line);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Anim_Reading;
+ var tgtBoneName = scope.data.substr(find2 + 1, find3 - find2 - 1).trim();
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].boneName = tgtBoneName;
+ scope.readedLength = find3 + 1;
+ return false;
+
+ }
+ scope.readedLength = find + 1;
+ return false;
+
+ } else {
+
+ var section = scope.getNextSection(scope.readedLength, find, find3);
+ scope.readedLength = find3 + 1;
+ if (line.indexOf("template ") > - 1) {
+
+ scope.elementLv = 0;
+ return false;
+
+ } else if (line.indexOf("AnimTicksPerSecond") > - 1) {
+
+ scope.loadingXdata.AnimTicksPerSecond = parseInt(section[1].substr(0, section[1].indexOf(";")), 10);
+ scope.elementLv = 0;
+ return false;
+
+ } else if (line.indexOf("FrameTransformMatrix") > - 1) {
+
+ var data = section[1].split(",");
+ data[15] = data[15].substr(0, data[15].indexOf(';;'));
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameTransformMatrix = new THREE.Matrix4();
+ scope.ParseMatrixData(scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameTransformMatrix, data);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+ return false;
+
+ } else if (line.indexOf("MeshTextureCoords") > - 1) {
+
+ var v_data = scope.getVertextDataSection(section[1], 0);
+ for (var _i3 = 0; _i3 < v_data[0].length; _i3++) {
+
+ scope.readUv(v_data[0][_i3]);
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0] = [];
+ for (var m = 0; m < scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces.length; m++) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0][m] = [];
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0][m].push(scope.tmpUvArray[scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[m].a]);
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0][m].push(scope.tmpUvArray[scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[m].b]);
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0][m].push(scope.tmpUvArray[scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[m].c]);
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.uvsNeedUpdate = true;
+ return true;
+
+ } else if (line.indexOf("Material ") > - 1) {
+
+ scope.readMaterial(section[1]);
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Materials.push(scope.nowMat);
+ return false;
+
+ } else if (line.indexOf("TextureFilename") > - 1) {
+
+ if (section[1].length > 0) {
+
+ scope.nowMat.map = scope.Texloader.load(scope.baseDir + scope.getPlaneStr(section[1]));
+
+ }
+ return false;
+
+ } else if (line.indexOf("BumpMapFilename") > - 1) {
+
+ if (section[1].length > 0) {
+
+ scope.nowMat.bumpMap = scope.Texloader.load(scope.baseDir + scope.getPlaneStr(section[1]));
+ scope.nowMat.bumpScale = 0.05;
+
+ }
+ return false;
+
+ } else if (line.indexOf("NormalMapFilename") > - 1) {
+
+ if (section[1].length > 0) {
+
+ scope.nowMat.normalMap = scope.Texloader.load(scope.baseDir + scope.getPlaneStr(section[1]));
+ scope.nowMat.normalScale = new THREE.Vector2(2, 2);
+
+ }
+ return false;
+
+ } else if (line.indexOf("EmissiveMapFilename") > - 1) {
+
+ if (section[1].length > 0) {
+
+ scope.nowMat.emissiveMap = scope.Texloader.load(scope.baseDir + scope.getPlaneStr(section[1]));
+
+ }
+ return false;
+
+ } else if (line.indexOf("LightMapFilename") > - 1) {
+
+ if (section[1].length > 0) {
+
+ scope.nowMat.lightMap = scope.Texloader.load(scope.baseDir + scope.getPlaneStr(section[1]));
+
+ }
+ return false;
+
+ } else if (line.indexOf("XSkinMeshHeader") > - 1) {
+
+ return false;
+
+ } else if (line.indexOf("SkinWeights") > - 1) {
+
+ scope.readSkinWeights(section[1]);
+ return true;
+
+ } else if (line.indexOf("AnimationKey") > - 1) {
+
+ scope.readAnimationKeyFrame(section[1]);
+ return true;
+
+ }
+
+ }
+ return false;
+
+ },
+
+ endElement: function (line) {
+
+ var scope = this;
+ if (scope.nowReadMode == THREE.XLoader.XfileLoadMode.Mesh) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+
+ } else if (scope.nowReadMode == THREE.XLoader.XfileLoadMode.Mat_Set) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mesh;
+
+ } else if (scope.nowReadMode == THREE.XLoader.XfileLoadMode.Mat_detail) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Materials.push(scope.nowMat);
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set;
+
+ } else if (scope.nowReadMode == THREE.XLoader.XfileLoadMode.Anim_Reading) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Anim_init;
+
+ } else if (scope.nowReadMode < THREE.XLoader.XfileLoadMode.Anim_init && scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameStartLv === scope.elementLv && scope.nowReadMode > THREE.XLoader.XfileLoadMode.none) {
+
+ if (scope.frameHierarchie.length > 0) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].children = [];
+ var keys = Object.keys(scope.loadingXdata.FrameInfo_Raw);
+ for (var m = 0; m < keys.length; m++) {
+
+ if (scope.loadingXdata.FrameInfo_Raw[keys[m]].ParentName === scope.nowFrameName) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].children.push(keys[m]);
+
+ }
+
+ }
+ scope.frameHierarchie.pop();
+
+ }
+ scope.MakeOutputGeometry(scope.nowFrameName, scope.zflg);
+ scope.frameStartLv = scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameStartLv;
+ if (scope.frameHierarchie.length > 0) {
+
+ scope.nowFrameName = scope.frameHierarchie[scope.frameHierarchie.length - 1];
+ scope.frameStartLv = scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameStartLv;
+
+ } else {
+
+ scope.nowFrameName = "";
+
+ }
+
+ } else if (scope.nowReadMode == THREE.XLoader.XfileLoadMode.Anim_init) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+
+ }
+ scope.elementLv--;
+
+ },
+
+ beginFrame: function (line) {
+
+ var scope = this;
+ scope.frameStartLv = scope.elementLv;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+ var findindex = line.indexOf("Frame ");
+ scope.nowFrameName = line.substr(findindex + 6, line.length - findindex + 1).trim();
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName] = new THREE.XLoader.XFrameInfo();
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameName = scope.nowFrameName;
+ if (scope.frameHierarchie.length > 0) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].ParentName = scope.frameHierarchie[scope.frameHierarchie.length - 1];
+
+ }
+ scope.frameHierarchie.push(scope.nowFrameName);
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameStartLv = scope.frameStartLv;
+
+ },
+
+ beginReadMesh: function (line) {
+
+ var scope = this;
+ if (scope.nowFrameName === "") {
+
+ scope.frameStartLv = scope.elementLv;
+ scope.nowFrameName = line.substr(5, line.length - 6);
+ if (scope.nowFrameName === "") {
+
+ scope.nowFrameName = "mesh_" + scope.loadingXdata.FrameInfo_Raw.length;
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName] = new THREE.XLoader.XFrameInfo();
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameName = scope.nowFrameName;
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].FrameStartLv = scope.frameStartLv;
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry = new THREE.Geometry();
+ scope.geoStartLv = scope.elementLv;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Vartex_init;
+ Bones = [];
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Materials = [];
+
+ },
+
+ readVertexCount: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Vartex_Read;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readVertex: function (line) {
+
+ var scope = this;
+ var data = line.substr(0, line.length - 2).split(";");
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.vertices.push(new THREE.Vector3(parseFloat(data[0]), parseFloat(data[1]), parseFloat(data[2])));
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.skinIndices.push(new THREE.Vector4(0, 0, 0, 0));
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.skinWeights.push(new THREE.Vector4(1, 0, 0, 0));
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].VertexSetedBoneCount.push(0);
+ scope.nowReaded++;
+ return false;
+
+ },
+
+ readIndexLength: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.index_Read;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readVertexIndex: function (line) {
+
+ var scope = this;
+ var firstFind = line.indexOf(';') + 1;
+ var data = line.substr(firstFind).split(",");
+ if (scope.zflg) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces.push(new THREE.Face3(parseInt(data[2], 10), parseInt(data[1], 10), parseInt(data[0], 10), new THREE.Vector3(1, 1, 1).normalize()));
+
+ } else {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces.push(new THREE.Face3(parseInt(data[0], 10), parseInt(data[1], 10), parseInt(data[2], 10), new THREE.Vector3(1, 1, 1).normalize()));
+
+ }
+ return false;
+
+ },
+
+ beginMeshNormal: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Normal_V_init;
+ scope.normalVectors = [];
+ scope.facesNormal = [];
+
+ },
+
+ readMeshNormalCount: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Normal_V_Read;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readMeshNormalVertex: function (line) {
+
+ var scope = this;
+ var data = line.split(";");
+ scope.normalVectors.push([parseFloat(data[0]), parseFloat(data[1]), parseFloat(data[2])]);
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Normal_I_init;
+ return true;
+
+ }
+ return false;
+
+ },
+
+ readMeshNormalIndexCount: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Normal_I_Read;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readMeshNormalIndex: function (line) {
+
+ var scope = this;
+ var data = line.substr(2, line.length - 4).split(",");
+ var nowID = parseInt(data[0], 10);
+ var v1 = new THREE.Vector3(scope.normalVectors[nowID][0], scope.normalVectors[nowID][1], scope.normalVectors[nowID][2]);
+ nowID = parseInt(data[1], 10);
+ var v2 = new THREE.Vector3(scope.normalVectors[nowID][0], scope.normalVectors[nowID][1], scope.normalVectors[nowID][2]);
+ nowID = parseInt(data[2], 10);
+ var v3 = new THREE.Vector3(scope.normalVectors[nowID][0], scope.normalVectors[nowID][1], scope.normalVectors[nowID][2]);
+ if (scope.zflg) {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[scope.nowReaded].vertexNormals = [v3, v2, v1];
+
+ } else {
+
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[scope.nowReaded].vertexNormals = [v1, v2, v3];
+
+ }
+ scope.facesNormal.push(v1.normalize());
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+ return true;
+
+ }
+ return false;
+
+ },
+
+ readUvInit: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Uv_Read;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+ scope.tmpUvArray = [];
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faceVertexUvs[0] = [];
+
+ },
+
+ readUv: function (line) {
+
+ var scope = this;
+ var data = line.split(";");
+ if (scope.IsUvYReverse) {
+
+ scope.tmpUvArray.push(new THREE.Vector2(parseFloat(data[0]), 1 - parseFloat(data[1])));
+
+ } else {
+
+ scope.tmpUvArray.push(new THREE.Vector2(parseFloat(data[0]), parseFloat(data[1])));
+
+ }
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength) {
+
+ return true;
+
+ }
+ return false;
+
+ },
+
+ readMatrixSetLength: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Face_Set;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readMaterialBind: function (line) {
+
+ var scope = this;
+ var data = line.split(",");
+ scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].Geometry.faces[scope.nowReaded].materialIndex = parseInt(data[0]);
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Element;
+ return true;
+
+ }
+ return false;
+
+ },
+
+ readMaterialInit: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set;
+ scope.matReadLine = 0;
+ scope.nowMat = new THREE.MeshPhongMaterial({ color: Math.random() * 0xffffff });
+ var matName = line.substr(9, line.length - 10);
+ if (matName !== "") {
+
+ scope.nowMat.name = matName;
+
+ }
+ if (scope.zflg) {
+
+ scope.nowMat.side = THREE.BackSide;
+
+ } else {
+
+ scope.nowMat.side = THREE.FrontSide;
+
+ }
+ scope.nowMat.side = THREE.FrontSide;
+
+ },
+
+ readandSetMaterial: function (line) {
+
+ var scope = this;
+ var data = line.split(";");
+ scope.matReadLine++;
+ switch (scope.matReadLine) {
+
+ case 1:
+ scope.nowMat.color.r = data[0];
+ scope.nowMat.color.g = data[1];
+ scope.nowMat.color.b = data[2];
+ break;
+ case 2:
+ scope.nowMat.shininess = data[0];
+ break;
+ case 3:
+ scope.nowMat.specular.r = data[0];
+ scope.nowMat.specular.g = data[1];
+ scope.nowMat.specular.b = data[2];
+ break;
+ case 4:
+ scope.nowMat.emissive.r = data[0];
+ scope.nowMat.emissive.g = data[1];
+ scope.nowMat.emissive.b = data[2];
+ break;
+
+ }
+ if (line.indexOf("TextureFilename") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set_Texture;
+
+ } else if (line.indexOf("BumpMapFilename") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set_BumpTex;
+ scope.nowMat.bumpScale = 0.05;
+
+ } else if (line.indexOf("NormalMapFilename") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set_NormalTex;
+ scope.nowMat.normalScale = new THREE.Vector2(2, 2);
+
+ } else if (line.indexOf("EmissiveMapFilename") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set_EmissiveTex;
+
+ } else if (line.indexOf("LightMapFilename") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set_LightTex;
+
+ }
+
+ },
+
+ readandSetMaterialTexture: function (line) {
+
+ var scope = this;
+ var data = line.substr(1, line.length - 3);
+ if (data != undefined && data.length > 0) {
+
+ switch (scope.nowReadMode) {
+
+ case THREE.XLoader.XfileLoadMode.Mat_Set_Texture:
+ scope.nowMat.map = scope.Texloader.load(scope.baseDir + data);
+ break;
+ case THREE.XLoader.XfileLoadMode.Mat_Set_BumpTex:
+ scope.nowMat.bumpMap = scope.Texloader.load(scope.baseDir + data);
+ break;
+ case THREE.XLoader.XfileLoadMode.Mat_Set_NormalTex:
+ scope.nowMat.normalMap = scope.Texloader.load(scope.baseDir + data);
+ break;
+ case THREE.XLoader.XfileLoadMode.Mat_Set_EmissiveTex:
+ scope.nowMat.emissiveMap = scope.Texloader.load(scope.baseDir + data);
+ break;
+ case THREE.XLoader.XfileLoadMode.Mat_Set_LightTex:
+ scope.nowMat.lightMap = scope.Texloader.load(scope.baseDir + data);
+ break;
+ case THREE.XLoader.XfileLoadMode.Mat_Set_EnvTex:
+ scope.nowMat.envMap = scope.Texloader.load(scope.baseDir + data);
+ break;
+
+ }
+
+ }
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Mat_Set;
+ scope.endLineCount++;
+ scope.elementLv--;
+
+ },
+
+ readBoneInit: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Weit_init;
+ scope.BoneInf = new XboneInf();
+
+ },
+
+ readBoneName: function (line) {
+
+ var scope = this;
+ scope.BoneInf.boneName = line.trim();
+ scope.BoneInf.BoneIndex = scope.loadingXdata.FrameInfo_Raw[scope.nowFrameName].BoneInfs.length;
+ scope.nowReaded = 0;
+
+ },
+
+ readBoneVertexLength: function (line) {
+
+ var scope = this;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Weit_Read_Index;
+ scope.tgtLength = parseInt(line.substr(0, line.length - 1), 10);
+ scope.nowReaded = 0;
+
+ },
+
+ readandSetBoneVertex: function (line) {
+
+ var scope = this;
+ scope.BoneInf.Indeces.push(parseInt(line.substr(0, line.length - 1), 10));
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength || line.indexOf(";") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Weit_Read_Value;
+ scope.nowReaded = 0;
+
+ }
+
+ },
+
+ readandSetBoneWeightValue: function (line) {
+
+ var scope = this;
+ var nowVal = parseFloat(line.substr(0, line.length - 1));
+ scope.BoneInf.Weights.push(nowVal);
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.tgtLength || line.indexOf(";") > - 1) {
+
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Weit_Read_Matrx;
+
+
+ }
+
+ },
+
+ readandCreateAnimationSet: function (line) {
+
+ var scope = this;
+ scope.frameStartLv = scope.elementLv;
+ scope.nowReadMode = THREE.XLoader.XfileLoadMode.Anim_init;
+ scope.nowAnimationSetName = line.substr(13, line.length - 14).trim();
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName] = [];
+
+ },
+
+ readAndCreateAnimation: function (line) {
+
+ var scope = this;
+ scope.nowFrameName = line.substr(10, line.length - 11).trim();
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName] = new THREE.XLoader.XAnimationInfo();
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].animeName = scope.nowFrameName;
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].FrameStartLv = scope.frameStartLv;
+
+ },
+
+ readAnimationKeyFrameValue: function (line) {
+
+ var scope = this;
+ scope.keyInfo = null;
+ var data = line.split(";");
+ if (data == null || data.length < 3) {
+
+ return;
+
+ }
+ var nowKeyframe = parseInt(data[0], 10);
+ var frameFound = false;
+ var tmpM = new THREE.Matrix4();
+ if (scope.nowAnimationKeyType != 4) {
+
+ for (var mm = 0; mm < scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].keyFrames.length; mm++) {
+
+ if (scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].keyFrames[mm].Frame === nowKeyframe) {
+
+ scope.keyInfo = scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].keyFrames[mm];
+ frameFound = true;
+ break;
+
+ }
+
+ }
+
+ }
+ if (!frameFound) {
+
+ scope.keyInfo = new THREE.XLoader.XKeyFrameInfo();
+ scope.keyInfo.matrix = new THREE.Matrix4();
+ scope.keyInfo.Frame = nowKeyframe;
+
+ }
+ var data2 = data[2].split(",");
+ switch (scope.nowAnimationKeyType) {
+
+ case 0:
+ tmpM.makeRotationFromQuaternion(new THREE.Quaternion(parseFloat(data2[0]), parseFloat(data2[1]), parseFloat(data2[2]), parseFloat(data2[3])));
+ scope.keyInfo.matrix.multiply(tmpM);
+ break;
+ case 1:
+ tmpM.makeScale(parseFloat(data2[0]), parseFloat(data2[1]), parseFloat(data2[2]));
+ scope.keyInfo.matrix.multiply(tmpM);
+ break;
+ case 2:
+ tmpM.makeTranslation(parseFloat(data2[0]), parseFloat(data2[1]), parseFloat(data2[2]));
+ scope.keyInfo.matrix.multiply(tmpM);
+ break;
+ case 3:
+ case 4:
+ scope.ParseMatrixData(scope.keyInfo.matrix, data2);
+ break;
+
+ }
+ if (!frameFound) {
+
+ scope.keyInfo.index = scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].keyFrames.length;
+ scope.keyInfo.time = /*1.0 / scope.loadingXdata.AnimTicksPerSecond * */scope.keyInfo.Frame;
+ scope.loadingXdata.AnimationSetInfo[scope.nowAnimationSetName][scope.nowFrameName].keyFrames.push(scope.keyInfo);
+
+ }
+
+ },
+
+ readFinalize: function () {
+
+ var scope = this;
+ scope.loadingXdata.FrameInfo = [];
+ var keys = Object.keys(scope.loadingXdata.FrameInfo_Raw);
+ for (var i = 0; i < keys.length; i++) {
+
+ if (scope.loadingXdata.FrameInfo_Raw[keys[i]].Mesh != null) {
+
+ scope.loadingXdata.FrameInfo.push(scope.loadingXdata.FrameInfo_Raw[keys[i]].Mesh);
+
+ }
+
+ }
+ if (scope.loadingXdata.FrameInfo != null & scope.loadingXdata.FrameInfo.length > 0) {
+
+ for (var _i4 = 0; _i4 < scope.loadingXdata.FrameInfo.length; _i4++) {
+
+ if (scope.loadingXdata.FrameInfo[_i4].parent == null) {
+
+ scope.loadingXdata.FrameInfo[_i4].zflag = scope.zflg;
+ if (scope.zflg) {
+
+ scope.loadingXdata.FrameInfo[_i4].scale.set(- 1, 1, 1);
+
+ }
+
+ }
+
+ }
+
+ }
+
+ },
+
+ ParseMatrixData: function (targetMatrix, data) {
+
+ targetMatrix.set(parseFloat(data[0]), parseFloat(data[4]), parseFloat(data[8]), parseFloat(data[12]), parseFloat(data[1]), parseFloat(data[5]), parseFloat(data[9]), parseFloat(data[13]), parseFloat(data[2]), parseFloat(data[6]), parseFloat(data[10]), parseFloat(data[14]), parseFloat(data[3]), parseFloat(data[7]), parseFloat(data[11]), parseFloat(data[15]));
+
+ },
+
+ MakeOutputGeometry: function (nowFrameName, _zflg) {
+
+ var scope = this;
+ if (scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry != null) {
+
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.computeBoundingBox();
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.computeBoundingSphere();
+ if (!scope.loadingXdata.faceNormalFromFile) {
+
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.computeFaceNormals();
+
+ }
+ if (!scope.loadingXdata.vertexNormalFromFile) {
+
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.computeVertexNormals();
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.verticesNeedUpdate = true;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.normalsNeedUpdate = true;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.colorsNeedUpdate = true;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.uvsNeedUpdate = true;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.groupsNeedUpdate = true;
+ var putBones = [];
+ var BoneInverse = [];
+ var BoneDics = [];
+ var rootBone = new THREE.Bone();
+ if (scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs != null && scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs.length) {
+
+ var keys = Object.keys(scope.loadingXdata.FrameInfo_Raw);
+ var BoneDics_Name = [];
+ for (var m = 0; m < keys.length; m++) {
+
+ if (scope.loadingXdata.FrameInfo_Raw[keys[m]].FrameStartLv <= scope.loadingXdata.FrameInfo_Raw[nowFrameName].FrameStartLv && nowFrameName != keys[m]) {
+
+ continue;
+
+ }
+ var b = new THREE.Bone();
+ b.name = keys[m];
+ b.applyMatrix(scope.loadingXdata.FrameInfo_Raw[keys[m]].FrameTransformMatrix);
+ BoneDics_Name[b.name] = putBones.length;
+ putBones.push(b);
+ var ivm = new THREE.Matrix4();
+ ivm.getInverse(scope.loadingXdata.FrameInfo_Raw[keys[m]].FrameTransformMatrix);
+ BoneInverse.push(ivm);
+
+ }
+ for (var _m = 0; _m < putBones.length; _m++) {
+
+ for (var dx = 0; dx < scope.loadingXdata.FrameInfo_Raw[putBones[_m].name].children.length; dx++) {
+
+ var nowBoneIndex = BoneDics_Name[scope.loadingXdata.FrameInfo_Raw[putBones[_m].name].children[dx]];
+ if (putBones[nowBoneIndex] != null) {
+
+ putBones[_m].add(putBones[nowBoneIndex]);
+
+ }
+
+ }
+
+ }
+
+ }
+ var mesh = null;
+ var bufferGeometry = new THREE.BufferGeometry();
+ if (putBones.length > 0) {
+
+ if (scope.loadingXdata.FrameInfo_Raw[putBones[0].name].children.length === 0 && nowFrameName != putBones[0].name) {
+
+ putBones[0].add(putBones[1]);
+ putBones[0].zflag = _zflg;
+
+ }
+ for (var _m2 = 0; _m2 < putBones.length; _m2++) {
+
+ if (putBones[_m2].parent === null) {
+
+ putBones[_m2].zflag = _zflg;
+
+ }
+ for (var bi = 0; bi < scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs.length; bi++) {
+
+ if (putBones[_m2].name === scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs[bi].boneName) {
+
+ for (var vi = 0; vi < scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs[bi].Indeces.length; vi++) {
+
+ var nowVertexID = scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs[bi].Indeces[vi];
+ var nowVal = scope.loadingXdata.FrameInfo_Raw[nowFrameName].BoneInfs[bi].Weights[vi];
+ switch (scope.loadingXdata.FrameInfo_Raw[nowFrameName].VertexSetedBoneCount[nowVertexID]) {
+
+ case 0:
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinIndices[nowVertexID].x = _m2;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinWeights[nowVertexID].x = nowVal;
+ break;
+ case 1:
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinIndices[nowVertexID].y = _m2;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinWeights[nowVertexID].y = nowVal;
+ break;
+ case 2:
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinIndices[nowVertexID].z = _m2;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinWeights[nowVertexID].z = nowVal;
+ break;
+ case 3:
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinIndices[nowVertexID].w = _m2;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry.skinWeights[nowVertexID].w = nowVal;
+ break;
+
+ }
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].VertexSetedBoneCount[nowVertexID]++;
+
+ }
+ break;
+
+ }
+
+ }
+
+ }
+ for (var sk = 0; sk < scope.loadingXdata.FrameInfo_Raw[nowFrameName].Materials.length; sk++) {
+
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Materials[sk].skinning = true;
+
+ }
+ mesh = new THREE.SkinnedMesh(bufferGeometry.fromGeometry(scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry), scope.loadingXdata.FrameInfo_Raw[nowFrameName].Materials);
+ var skeleton = new THREE.Skeleton(putBones /*, BoneInverse*/);
+ mesh.add(putBones[0]);
+ mesh.bind(skeleton);
+
+ } else {
+
+ mesh = new THREE.Mesh(bufferGeometry.fromGeometry(scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry), scope.loadingXdata.FrameInfo_Raw[nowFrameName].Materials);
+
+ }
+ mesh.name = nowFrameName;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Mesh = mesh;
+ scope.loadingXdata.FrameInfo_Raw[nowFrameName].Geometry = null;
+
+ }
+
+ },
+
+ animationFinalize: function () {
+
+ var scope = this;
+ scope.animeKeyNames = Object.keys(scope.loadingXdata.AnimationSetInfo);
+ if (scope.animeKeyNames != null && scope.animeKeyNames.length > 0) {
+
+ scope.nowReaded = 0;
+ scope.loadingXdata.XAnimationObj = [];
+ scope.animationFinalize_step();
+
+ } else {
+
+ scope.finalproc();
+
+
+ }
+
+ },
+
+ animationFinalize_step: function () {
+
+ var scope = this;
+ var i = scope.nowReaded;
+ var keys = Object.keys(scope.loadingXdata.FrameInfo_Raw);
+ var tgtModel = null;
+ for (var m = 0; m < scope.loadingXdata.FrameInfo.length; m++) {
+
+ var keys2 = Object.keys(scope.loadingXdata.AnimationSetInfo[scope.animeKeyNames[i]]);
+ if (scope.loadingXdata.AnimationSetInfo[scope.animeKeyNames[i]][keys2[0]].boneName == scope.loadingXdata.FrameInfo[m].name) {
+
+ tgtModel = scope.loadingXdata.FrameInfo[m];
+ break;
+
+ }
+
+ }
+ if (tgtModel != null) {
+
+ scope.loadingXdata.XAnimationObj[i] = new THREE.XLoader.XAnimationObj();
+ scope.loadingXdata.XAnimationObj[i].fps = scope.loadingXdata.AnimTicksPerSecond;
+ scope.loadingXdata.XAnimationObj[i].name = scope.animeKeyNames[i];
+ scope.loadingXdata.XAnimationObj[i].make(scope.loadingXdata.AnimationSetInfo[scope.animeKeyNames[i]], tgtModel);
+
+ }
+ scope.nowReaded++;
+ if (scope.nowReaded >= scope.animeKeyNames.length) {
+
+ scope.loadingXdata.AnimationSetInfo = null;
+ scope.finalproc();
+
+ } else {
+
+ scope.animationFinalize_step();
+
+ }
+
+ },
+
+ finalproc: function () {
+
+ var scope = this;
+ setTimeout(function () {
+
+ scope.onLoad(scope.loadingXdata);
+
+ }, 1);
+
+ }
+};
+
+THREE.XLoader.XfileLoadMode = {
+ none: - 1,
+ Element: 1,
+ FrameTransformMatrix_Read: 3,
+ Mesh: 5,
+ Vartex_init: 10,
+ Vartex_Read: 11,
+ Index_init: 20,
+ index_Read: 21,
+ Uv_init: 30,
+ Uv_Read: 31,
+ Normal_V_init: 40,
+ Normal_V_Read: 41,
+ Normal_I_init: 42,
+ Normal_I_Read: 43,
+ Mat_Face_init: 101,
+ Mat_Face_len_Read: 102,
+ Mat_Face_Set: 103,
+ Mat_Set: 111,
+ Mat_detail: 121,
+ Mat_Set_Texture: 121,
+ Mat_Set_LightTex: 122,
+ Mat_Set_EmissiveTex: 123,
+ Mat_Set_BumpTex: 124,
+ Mat_Set_NormalTex: 125,
+ Mat_Set_EnvTex: 126,
+ Weit_init: 201,
+ Weit_IndexLength: 202,
+ Weit_Read_Index: 203,
+ Weit_Read_Value: 204,
+ Weit_Read_Matrx: 205,
+ Anim_init: 1001,
+ Anim_Reading: 1002,
+ Anim_KeyValueTypeRead: 1003,
+ Anim_KeyValueLength: 1004,
+ Anime_ReadKeyFrame: 1005
+};
+
+
+THREE.XLoader.XAnimationObj = function () {
+
+ this.fps = 30;
+ this.name = 'xanimation';
+ this.length = 0;
+ this.hierarchy = [];
+
+};
+
+THREE.XLoader.XAnimationObj.prototype = {
+
+ constructor: THREE.XLoader.XAnimationObj,
+
+ make: function (XAnimationInfoArray, mesh) {
+
+ var scope = this;
+ var keys = Object.keys(XAnimationInfoArray);
+ var hierarchy_tmp = [];
+ for (var i = 0; i < keys.length; i++) {
+
+ var bone = null;
+ var parent = - 1;
+ var baseIndex = - 1;
+ for (var m = 0; m < mesh.skeleton.bones.length; m++) {
+
+ if (mesh.skeleton.bones[m].name == XAnimationInfoArray[keys[i]].boneName) {
+
+ bone = XAnimationInfoArray[keys[i]];
+ parent = mesh.skeleton.bones[m].parent.name;
+ baseIndex = m;
+ break;
+
+ }
+
+ }
+ hierarchy_tmp[baseIndex] = scope.makeBonekeys(XAnimationInfoArray[keys[i]], bone, parent);
+
+ }
+ var keys2 = Object.keys(hierarchy_tmp);
+ for (var _i = 0; _i < keys2.length; _i++) {
+
+ scope.hierarchy.push(hierarchy_tmp[_i]);
+ var parentId = - 1;
+ for (var _m = 0; _m < scope.hierarchy.length; _m++) {
+
+ if (_i != _m && scope.hierarchy[_i].parent === scope.hierarchy[_m].name) {
+
+ parentId = _m;
+ break;
+
+ }
+
+ }
+ scope.hierarchy[_i].parent = parentId;
+
+ }
+
+ },
+
+ makeBonekeys: function (XAnimationInfo, bone, parent) {
+
+ var refObj = {};
+ refObj.name = bone.boneName;
+ refObj.parent = parent;
+ refObj.keys = [];
+ for (var i = 0; i < XAnimationInfo.keyFrames.length; i++) {
+
+ var keyframe = {};
+ keyframe.time = XAnimationInfo.keyFrames[i].time * this.fps;
+ keyframe.matrix = XAnimationInfo.keyFrames[i].matrix;
+ keyframe.pos = new THREE.Vector3().setFromMatrixPosition(keyframe.matrix);
+ keyframe.rot = new THREE.Quaternion().setFromRotationMatrix(keyframe.matrix);
+ keyframe.scl = new THREE.Vector3().setFromMatrixScale(keyframe.matrix);
+ refObj.keys.push(keyframe);
+
+ }
+ return refObj;
+
+ }
+
+};
+
+THREE.XLoader.Xdata = function () {
+
+ this.FrameInfo = [];
+ this.FrameInfo_Raw = [];
+ this.AnimationSetInfo = [];
+ this.AnimTicksPerSecond = 60;
+ this.XAnimationObj = null;
+
+};
+
+THREE.XLoader.XboneInf = function () {
+
+ this.boneName = "";
+ this.BoneIndex = 0;
+ this.Indeces = [];
+ this.Weights = [];
+ this.initMatrix = null;
+ this.OffsetMatrix = null;
+
+};
+
+THREE.XLoader.XAnimationInfo = function () {
+
+ this.animeName = "";
+ this.boneName = "";
+ this.targetBone = null;
+ this.frameStartLv = 0;
+ this.keyFrames = [];
+ this.InverseMx = null;
+
+};
+
+THREE.XLoader.XFrameInfo = function () {
+
+ this.Mesh = null;
+ this.Geometry = null;
+ this.FrameName = "";
+ this.ParentName = "";
+ this.frameStartLv = 0;
+ this.FrameTransformMatrix = null;
+ this.children = [];
+ this.BoneInfs = [];
+ this.VertexSetedBoneCount = [];
+ this.Materials = [];
+
+};
+
+THREE.XLoader.XKeyFrameInfo = function () {
+
+ this.index = 0;
+ this.Frame = 0;
+ this.time = 0.0;
+ this.matrix = null;
+
+};
OSDN Git Service
