"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const THREE = require("three");
const LoaderUtils = require("../_polyfill/LoaderUtils.cjs");
var XLoader = /* @__PURE__ */ function() {
  var classCallCheck = function(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  var createClass = function() {
    function defineProperties(target, props) {
      for (let i2 = 0; i2 < props.length; i2++) {
        var descriptor = props[i2];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    return function(Constructor, protoProps, staticProps) {
      if (protoProps)
        defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();
  var XboneInf = function XboneInf2() {
    classCallCheck(this, XboneInf2);
    this.boneName = "";
    this.BoneIndex = 0;
    this.Indeces = [];
    this.Weights = [];
    this.initMatrix = null;
    this.OffsetMatrix = null;
  };
  var XAnimationInfo = function XAnimationInfo2() {
    classCallCheck(this, XAnimationInfo2);
    this.animeName = "";
    this.boneName = "";
    this.targetBone = null;
    this.keyType = 4;
    this.frameStartLv = 0;
    this.keyFrames = [];
    this.InverseMx = null;
  };
  var XAnimationObj = function() {
    function XAnimationObj2(_flags) {
      classCallCheck(this, XAnimationObj2);
      this.fps = 30;
      this.name = "xanimation";
      this.length = 0;
      this.hierarchy = [];
      this.putFlags = _flags;
      if (this.putFlags.putPos === void 0) {
        this.putFlags.putPos = true;
      }
      if (this.putFlags.putRot === void 0) {
        this.putFlags.putRot = true;
      }
      if (this.putFlags.putScl === void 0) {
        this.putFlags.putScl = true;
      }
    }
    createClass(XAnimationObj2, [
      {
        key: "make",
        value: function make(XAnimationInfoArray) {
          for (let i2 = 0; i2 < XAnimationInfoArray.length; i2++) {
            this.hierarchy.push(this.makeBonekeys(XAnimationInfoArray[i2]));
          }
          this.length = this.hierarchy[0].keys[this.hierarchy[0].keys.length - 1].time;
        }
      },
      {
        key: "clone",
        value: function clone() {
          return Object.assign({}, this);
        }
      },
      {
        key: "makeBonekeys",
        value: function makeBonekeys(XAnimationInfo2) {
          var refObj = {};
          refObj.name = XAnimationInfo2.boneName;
          refObj.parent = "";
          refObj.keys = this.keyFrameRefactor(XAnimationInfo2);
          refObj.copy = function() {
            return Object.assign({}, this);
          };
          return refObj;
        }
      },
      {
        key: "keyFrameRefactor",
        value: function keyFrameRefactor(XAnimationInfo2) {
          var keys = [];
          for (let i2 = 0; i2 < XAnimationInfo2.keyFrames.length; i2++) {
            var keyframe = {};
            keyframe.time = XAnimationInfo2.keyFrames[i2].time * this.fps;
            if (XAnimationInfo2.keyFrames[i2].pos && this.putFlags.putPos) {
              keyframe.pos = XAnimationInfo2.keyFrames[i2].pos;
            }
            if (XAnimationInfo2.keyFrames[i2].rot && this.putFlags.putRot) {
              keyframe.rot = XAnimationInfo2.keyFrames[i2].rot;
            }
            if (XAnimationInfo2.keyFrames[i2].scl && this.putFlags.putScl) {
              keyframe.scl = XAnimationInfo2.keyFrames[i2].scl;
            }
            if (XAnimationInfo2.keyFrames[i2].matrix) {
              keyframe.matrix = XAnimationInfo2.keyFrames[i2].matrix;
              if (this.putFlags.putPos) {
                keyframe.pos = new THREE.Vector3().setFromMatrixPosition(keyframe.matrix);
              }
              if (this.putFlags.putRot) {
                keyframe.rot = new THREE.Quaternion().setFromRotationMatrix(keyframe.matrix);
              }
              if (this.putFlags.putScl) {
                keyframe.scl = new THREE.Vector3().setFromMatrixScale(keyframe.matrix);
              }
            }
            keys.push(keyframe);
          }
          return keys;
        }
      }
    ]);
    return XAnimationObj2;
  }();
  var XKeyFrameInfo = function XKeyFrameInfo2() {
    classCallCheck(this, XKeyFrameInfo2);
    this.index = 0;
    this.Frame = 0;
    this.time = 0;
    this.matrix = null;
  };
  var XLoader2 = function() {
    function XLoader3(manager) {
      THREE.Loader.call(this, manager);
      classCallCheck(this, XLoader3);
      this.debug = false;
      this.texloader = new THREE.TextureLoader(this.manager);
      this.url = "";
      this._putMatLength = 0;
      this._nowMat = null;
      this._nowFrameName = "";
      this.frameHierarchie = [];
      this.Hierarchies = {};
      this.HieStack = [];
      this._currentObject = {};
      this._currentFrame = {};
      this._data = null;
      this.onLoad = null;
      this.IsUvYReverse = true;
      this.Meshes = [];
      this.animations = [];
      this.animTicksPerSecond = 30;
      this._currentGeo = null;
      this._currentAnime = null;
      this._currentAnimeFrames = null;
    }
    createClass(XLoader3, [
      {
        key: "_setArgOption",
        value: function _setArgOption(_arg) {
          var _start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
          if (!_arg) {
            return;
          }
          for (let i2 = _start; i2 < _arg.length; i2++) {
            switch (i2) {
              case 0:
                this.url = _arg[i2];
                break;
              case 1:
                this.options = _arg[i2];
                break;
            }
          }
          if (this.options === void 0) {
            this.options = {};
          }
        }
      },
      {
        key: "load",
        value: function load(_arg, onLoad, onProgress, onError) {
          var _this = this;
          this._setArgOption(_arg);
          var loader = new THREE.FileLoader(this.manager);
          loader.setPath(this.path);
          loader.setResponseType("arraybuffer");
          loader.setRequestHeader(this.requestHeader);
          loader.setWithCredentials(this.withCredentials);
          loader.load(
            this.url,
            function(response) {
              try {
                _this.parse(response, onLoad);
              } catch (e) {
                if (onError) {
                  onError(e);
                } else {
                  console.error(e);
                }
                _this.manager.itemError(_this.url);
              }
            },
            onProgress,
            onError
          );
        }
      },
      {
        key: "_readLine",
        value: function _readLine(line) {
          var readed = 0;
          while (true) {
            var find = -1;
            find = line.indexOf("//", readed);
            if (find === -1) {
              find = line.indexOf("#", readed);
            }
            if (find > -1 && find < 2) {
              var foundNewLine = -1;
              foundNewLine = line.indexOf("\r\n", readed);
              if (foundNewLine > 0) {
                readed = foundNewLine + 2;
              } else {
                foundNewLine = line.indexOf("\r", readed);
                if (foundNewLine > 0) {
                  readed = foundNewLine + 1;
                } else {
                  readed = line.indexOf("\n", readed) + 1;
                }
              }
            } else {
              break;
            }
          }
          return line.substr(readed);
        }
      },
      {
        key: "_readLine",
        value: function _readLine(line) {
          var readed = 0;
          while (true) {
            var find = -1;
            find = line.indexOf("//", readed);
            if (find === -1) {
              find = line.indexOf("#", readed);
            }
            if (find > -1 && find < 2) {
              var foundNewLine = -1;
              foundNewLine = line.indexOf("\r\n", readed);
              if (foundNewLine > 0) {
                readed = foundNewLine + 2;
              } else {
                foundNewLine = line.indexOf("\r", readed);
                if (foundNewLine > 0) {
                  readed = foundNewLine + 1;
                } else {
                  readed = line.indexOf("\n", readed) + 1;
                }
              }
            } else {
              break;
            }
          }
          return line.substr(readed);
        }
      },
      {
        key: "_isBinary",
        value: function _isBinary(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 (let index = 0; index < fileLength; index++) {
            if (reader.getUint8(index, false) > 127) {
              return true;
            }
          }
          return false;
        }
      },
      {
        key: "_ensureBinary",
        value: function _ensureBinary(buf) {
          if (typeof buf === "string") {
            var array_buffer = new Uint8Array(buf.length);
            for (let i2 = 0; i2 < buf.length; i2++) {
              array_buffer[i2] = buf.charCodeAt(i2) & 255;
            }
            return array_buffer.buffer || array_buffer;
          } else {
            return buf;
          }
        }
      },
      {
        key: "_ensureString",
        value: function _ensureString(buf) {
          if (typeof buf !== "string") {
            return LoaderUtils.decodeText(new Uint8Array(buf));
          } else {
            return buf;
          }
        }
      },
      {
        key: "parse",
        value: function _parse(data, onLoad) {
          var binData = this._ensureBinary(data);
          this._data = this._ensureString(data);
          this.onLoad = onLoad;
          return this._isBinary(binData) ? this._parseBinary(binData) : this._parseASCII();
        }
      },
      {
        key: "_parseBinary",
        value: function _parseBinary(data) {
          return this._parseASCII(LoaderUtils.decodeText(new Uint8Array(data)));
        }
      },
      {
        key: "_parseASCII",
        value: function _parseASCII() {
          var path;
          if (this.resourcePath !== "") {
            path = this.resourcePath;
          } else if (this.path !== "") {
            path = this.path;
          } else {
            path = THREE.LoaderUtils.extractUrlBase(this.url);
          }
          this.texloader.setPath(path).setCrossOrigin(this.crossOrigin);
          var endRead = 16;
          this.Hierarchies.children = [];
          this._hierarchieParse(this.Hierarchies, endRead);
          this._changeRoot();
          this._currentObject = this.Hierarchies.children.shift();
          this._mainloop();
        }
      },
      {
        key: "_hierarchieParse",
        value: function _hierarchieParse(_parent, _end) {
          var endRead = _end;
          while (true) {
            var find1 = this._data.indexOf("{", endRead) + 1;
            var findEnd = this._data.indexOf("}", endRead);
            var findNext = this._data.indexOf("{", find1) + 1;
            if (find1 > 0 && findEnd > find1) {
              var _currentObject = {};
              _currentObject.children = [];
              var nameData = this._readLine(this._data.substr(endRead, find1 - endRead - 1)).trim();
              var word = nameData.split(/ /g);
              if (word.length > 0) {
                _currentObject.type = word[0];
                if (word.length >= 2) {
                  _currentObject.name = word[1];
                } else {
                  _currentObject.name = word[0] + this.Hierarchies.children.length;
                }
              } else {
                _currentObject.name = nameData;
                _currentObject.type = "";
              }
              if (_currentObject.type === "Animation") {
                _currentObject.data = this._data.substr(findNext, findEnd - findNext).trim();
                var refs = this._hierarchieParse(_currentObject, findEnd + 1);
                endRead = refs.end;
                _currentObject.children = refs.parent.children;
              } else {
                var DataEnder = this._data.lastIndexOf(";", findNext > 0 ? Math.min(findNext, findEnd) : findEnd);
                _currentObject.data = this._data.substr(find1, DataEnder - find1).trim();
                if (findNext <= 0 || findEnd < findNext) {
                  endRead = findEnd + 1;
                } else {
                  var nextStart = Math.max(DataEnder + 1, find1);
                  var _refs = this._hierarchieParse(_currentObject, nextStart);
                  endRead = _refs.end;
                  _currentObject.children = _refs.parent.children;
                }
              }
              _currentObject.parent = _parent;
              if (_currentObject.type != "template") {
                _parent.children.push(_currentObject);
              }
            } else {
              endRead = find1 === -1 ? this._data.length : findEnd + 1;
              break;
            }
          }
          return {
            parent: _parent,
            end: endRead
          };
        }
      },
      {
        key: "_mainloop",
        value: function _mainloop() {
          var _this2 = this;
          this._mainProc();
          if (this._currentObject.parent || this._currentObject.children.length > 0 || !this._currentObject.worked) {
            setTimeout(function() {
              _this2._mainloop();
            }, 1);
          } else {
            setTimeout(function() {
              _this2.onLoad({
                models: _this2.Meshes,
                animations: _this2.animations
              });
            }, 1);
          }
        }
      },
      {
        key: "_mainProc",
        value: function _mainProc() {
          var breakFlag = false;
          while (true) {
            if (!this._currentObject.worked) {
              switch (this._currentObject.type) {
                case "template":
                  break;
                case "AnimTicksPerSecond":
                  this.animTicksPerSecond = parseInt(this._currentObject.data);
                  break;
                case "Frame":
                  this._setFrame();
                  break;
                case "FrameTransformMatrix":
                  this._setFrameTransformMatrix();
                  break;
                case "Mesh":
                  this._changeRoot();
                  this._currentGeo = {};
                  this._currentGeo.name = this._currentObject.name.trim();
                  this._currentGeo.parentName = this._getParentName(this._currentObject).trim();
                  this._currentGeo.VertexSetedBoneCount = [];
                  this._currentGeo.GeometryData = {
                    vertices: [],
                    normals: [],
                    uvs: [],
                    skinIndices: [],
                    skinWeights: [],
                    indices: [],
                    materialIndices: []
                  };
                  this._currentGeo.Materials = [];
                  this._currentGeo.normalVectors = [];
                  this._currentGeo.BoneInfs = [];
                  this._currentGeo.baseFrame = this._currentFrame;
                  this._makeBoneFrom_CurrentFrame();
                  this._readVertexDatas();
                  breakFlag = true;
                  break;
                case "MeshNormals":
                  this._readVertexDatas();
                  break;
                case "MeshTextureCoords":
                  this._setMeshTextureCoords();
                  break;
                case "VertexDuplicationIndices":
                  break;
                case "MeshMaterialList":
                  this._setMeshMaterialList();
                  break;
                case "Material":
                  this._setMaterial();
                  break;
                case "SkinWeights":
                  this._setSkinWeights();
                  break;
                case "AnimationSet":
                  this._changeRoot();
                  this._currentAnime = {};
                  this._currentAnime.name = this._currentObject.name.trim();
                  this._currentAnime.AnimeFrames = [];
                  break;
                case "Animation":
                  if (this._currentAnimeFrames) {
                    this._currentAnime.AnimeFrames.push(this._currentAnimeFrames);
                  }
                  this._currentAnimeFrames = new XAnimationInfo();
                  this._currentAnimeFrames.boneName = this._currentObject.data.trim();
                  break;
                case "AnimationKey":
                  this._readAnimationKey();
                  breakFlag = true;
                  break;
              }
              this._currentObject.worked = true;
            }
            if (this._currentObject.children.length > 0) {
              this._currentObject = this._currentObject.children.shift();
              if (this.debug) {
                console.log("processing " + this._currentObject.name);
              }
              if (breakFlag)
                break;
            } else {
              if (this._currentObject.worked) {
                if (this._currentObject.parent && !this._currentObject.parent.parent) {
                  this._changeRoot();
                }
              }
              if (this._currentObject.parent) {
                this._currentObject = this._currentObject.parent;
              } else {
                breakFlag = true;
              }
              if (breakFlag)
                break;
            }
          }
          return;
        }
      },
      {
        key: "_changeRoot",
        value: function _changeRoot() {
          if (this._currentGeo != null && this._currentGeo.name) {
            this._makeOutputGeometry();
          }
          this._currentGeo = {};
          if (this._currentAnime != null && this._currentAnime.name) {
            if (this._currentAnimeFrames) {
              this._currentAnime.AnimeFrames.push(this._currentAnimeFrames);
              this._currentAnimeFrames = null;
            }
            this._makeOutputAnimation();
          }
          this._currentAnime = {};
        }
      },
      {
        key: "_getParentName",
        value: function _getParentName(_obj) {
          if (_obj.parent) {
            if (_obj.parent.name) {
              return _obj.parent.name;
            } else {
              return this._getParentName(_obj.parent);
            }
          } else {
            return "";
          }
        }
      },
      {
        key: "_setFrame",
        value: function _setFrame() {
          this._nowFrameName = this._currentObject.name.trim();
          this._currentFrame = {};
          this._currentFrame.name = this._nowFrameName;
          this._currentFrame.children = [];
          if (this._currentObject.parent && this._currentObject.parent.name) {
            this._currentFrame.parentName = this._currentObject.parent.name;
          }
          this.frameHierarchie.push(this._nowFrameName);
          this.HieStack[this._nowFrameName] = this._currentFrame;
        }
      },
      {
        key: "_setFrameTransformMatrix",
        value: function _setFrameTransformMatrix() {
          this._currentFrame.FrameTransformMatrix = new THREE.Matrix4();
          var data = this._currentObject.data.split(",");
          this._ParseMatrixData(this._currentFrame.FrameTransformMatrix, data);
          this._makeBoneFrom_CurrentFrame();
        }
      },
      {
        key: "_makeBoneFrom_CurrentFrame",
        value: function _makeBoneFrom_CurrentFrame() {
          if (!this._currentFrame.FrameTransformMatrix) {
            return;
          }
          var b = new THREE.Bone();
          b.name = this._currentFrame.name;
          b.applyMatrix4(this._currentFrame.FrameTransformMatrix);
          b.matrixWorld = b.matrix;
          b.FrameTransformMatrix = this._currentFrame.FrameTransformMatrix;
          this._currentFrame.putBone = b;
          if (this._currentFrame.parentName) {
            for (let frame in this.HieStack) {
              if (this.HieStack[frame].name === this._currentFrame.parentName) {
                this.HieStack[frame].putBone.add(this._currentFrame.putBone);
              }
            }
          }
        }
      },
      {
        key: "_readVertexDatas",
        value: function _readVertexDatas() {
          var endRead = 0;
          var mode = 0;
          var mode_local = 0;
          var maxLength = 0;
          while (true) {
            var changeMode = false;
            if (mode_local === 0) {
              var refO = this._readInt1(endRead);
              endRead = refO.endRead;
              mode_local = 1;
              maxLength = this._currentObject.data.indexOf(";;", endRead) + 1;
              if (maxLength <= 0) {
                maxLength = this._currentObject.data.length;
              }
            } else {
              var find = 0;
              switch (mode) {
                case 0:
                  find = this._currentObject.data.indexOf(",", endRead) + 1;
                  break;
                case 1:
                  find = this._currentObject.data.indexOf(";,", endRead) + 1;
                  break;
              }
              if (find === 0 || find > maxLength) {
                find = maxLength;
                mode_local = 0;
                changeMode = true;
              }
              switch (this._currentObject.type) {
                case "Mesh":
                  switch (mode) {
                    case 0:
                      this._readVertex1(this._currentObject.data.substr(endRead, find - endRead));
                      break;
                    case 1:
                      this._readFace1(this._currentObject.data.substr(endRead, find - endRead));
                      break;
                  }
                  break;
                case "MeshNormals":
                  switch (mode) {
                    case 0:
                      this._readNormalVector1(this._currentObject.data.substr(endRead, find - endRead));
                      break;
                  }
                  break;
              }
              endRead = find + 1;
              if (changeMode) {
                mode++;
              }
            }
            if (endRead >= this._currentObject.data.length) {
              break;
            }
          }
        }
      },
      {
        key: "_readInt1",
        value: function _readInt1(start) {
          var find = this._currentObject.data.indexOf(";", start);
          return {
            refI: parseInt(this._currentObject.data.substr(start, find - start)),
            endRead: find + 1
          };
        }
      },
      {
        key: "_readVertex1",
        value: function _readVertex1(line) {
          var data = this._readLine(line.trim()).substr(0, line.length - 2).split(";");
          this._currentGeo.GeometryData.vertices.push(parseFloat(data[0]), parseFloat(data[1]), parseFloat(data[2]));
          this._currentGeo.GeometryData.skinIndices.push(0, 0, 0, 0);
          this._currentGeo.GeometryData.skinWeights.push(1, 0, 0, 0);
          this._currentGeo.VertexSetedBoneCount.push(0);
        }
      },
      {
        key: "_readFace1",
        value: function _readFace1(line) {
          var data = this._readLine(line.trim()).substr(2, line.length - 4).split(",");
          this._currentGeo.GeometryData.indices.push(
            parseInt(data[0], 10),
            parseInt(data[1], 10),
            parseInt(data[2], 10)
          );
        }
      },
      {
        key: "_readNormalVector1",
        value: function _readNormalVector1(line) {
          var data = this._readLine(line.trim()).substr(0, line.length - 2).split(";");
          this._currentGeo.GeometryData.normals.push(parseFloat(data[0]), parseFloat(data[1]), parseFloat(data[2]));
        }
      },
      {
        key: "_buildGeometry",
        value: function _buildGeometry() {
          var bufferGeometry = new THREE.BufferGeometry();
          var position = [];
          var normals = [];
          var uvs = [];
          var skinIndices = [];
          var skinWeights = [];
          var data = this._currentGeo.GeometryData;
          for (let i2 = 0, l = data.indices.length; i2 < l; i2++) {
            var stride2 = data.indices[i2] * 2;
            var stride3 = data.indices[i2] * 3;
            var stride4 = data.indices[i2] * 4;
            position.push(data.vertices[stride3], data.vertices[stride3 + 1], data.vertices[stride3 + 2]);
            normals.push(data.normals[stride3], data.normals[stride3 + 1], data.normals[stride3 + 2]);
            skinIndices.push(
              data.skinIndices[stride4],
              data.skinIndices[stride4 + 1],
              data.skinIndices[stride4 + 2],
              data.skinIndices[stride4 + 3]
            );
            skinWeights.push(
              data.skinWeights[stride4],
              data.skinWeights[stride4 + 1],
              data.skinWeights[stride4 + 2],
              data.skinWeights[stride4 + 3]
            );
            uvs.push(data.uvs[stride2], data.uvs[stride2 + 1]);
          }
          bufferGeometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
          bufferGeometry.setAttribute("normal", new THREE.Float32BufferAttribute(normals, 3));
          bufferGeometry.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2));
          bufferGeometry.setAttribute("skinIndex", new THREE.Uint16BufferAttribute(skinIndices, 4));
          bufferGeometry.setAttribute("skinWeight", new THREE.Float32BufferAttribute(skinWeights, 4));
          this._computeGroups(bufferGeometry, data.materialIndices);
          return bufferGeometry;
        }
      },
      {
        key: "_computeGroups",
        value: function _computeGroups(bufferGeometry, materialIndices) {
          var group;
          var groups = [];
          var materialIndex = void 0;
          for (let i2 = 0; i2 < materialIndices.length; i2++) {
            var currentMaterialIndex = materialIndices[i2];
            if (currentMaterialIndex !== materialIndex) {
              materialIndex = currentMaterialIndex;
              if (group !== void 0) {
                group.count = i2 * 3 - group.start;
                groups.push(group);
              }
              group = {
                start: i2 * 3,
                materialIndex
              };
            }
          }
          if (group !== void 0) {
            group.count = i * 3 - group.start;
            groups.push(group);
          }
          bufferGeometry.groups = groups;
        }
      },
      {
        key: "_setMeshTextureCoords",
        value: function _setMeshTextureCoords() {
          var endRead = 0;
          var mode = 0;
          var mode_local = 0;
          while (true) {
            switch (mode) {
              case 0:
                if (mode_local === 0) {
                  var refO = this._readInt1(0);
                  endRead = refO.endRead;
                  mode_local = 1;
                } else {
                  var find = this._currentObject.data.indexOf(",", endRead) + 1;
                  if (find === 0) {
                    find = this._currentObject.data.length;
                    mode = 2;
                    mode_local = 0;
                  }
                  var line = this._currentObject.data.substr(endRead, find - endRead);
                  var data = this._readLine(line.trim()).split(";");
                  if (this.IsUvYReverse) {
                    this._currentGeo.GeometryData.uvs.push(parseFloat(data[0]), 1 - parseFloat(data[1]));
                  } else {
                    this._currentGeo.GeometryData.uvs.push(parseFloat(data[0]), parseFloat(data[1]));
                  }
                  endRead = find + 1;
                }
                break;
            }
            if (endRead >= this._currentObject.data.length) {
              break;
            }
          }
        }
      },
      {
        key: "_setMeshMaterialList",
        value: function _setMeshMaterialList() {
          var endRead = 0;
          var mode = 0;
          var mode_local = 0;
          while (true) {
            if (mode_local < 2) {
              var refO = this._readInt1(endRead);
              endRead = refO.endRead;
              mode_local++;
            } else {
              var find = this._currentObject.data.indexOf(";", endRead);
              if (find === -1) {
                find = this._currentObject.data.length;
                mode = 3;
                mode_local = 0;
              }
              var line = this._currentObject.data.substr(endRead, find - endRead);
              var data = this._readLine(line.trim()).split(",");
              for (let i2 = 0; i2 < data.length; i2++) {
                this._currentGeo.GeometryData.materialIndices[i2] = parseInt(data[i2]);
              }
              endRead = this._currentObject.data.length;
            }
            if (endRead >= this._currentObject.data.length || mode >= 3) {
              break;
            }
          }
        }
      },
      {
        key: "_setMaterial",
        value: function _setMaterial() {
          var _nowMat = new THREE.MeshPhongMaterial({
            color: Math.random() * 16777215
          });
          _nowMat.side = THREE.FrontSide;
          _nowMat.name = this._currentObject.name;
          var endRead = 0;
          var find = this._currentObject.data.indexOf(";;", endRead);
          var line = this._currentObject.data.substr(endRead, find - endRead);
          var data = this._readLine(line.trim()).split(";");
          _nowMat.color.r = parseFloat(data[0]);
          _nowMat.color.g = parseFloat(data[1]);
          _nowMat.color.b = parseFloat(data[2]);
          endRead = find + 2;
          find = this._currentObject.data.indexOf(";", endRead);
          line = this._currentObject.data.substr(endRead, find - endRead);
          _nowMat.shininess = parseFloat(this._readLine(line));
          endRead = find + 1;
          find = this._currentObject.data.indexOf(";;", endRead);
          line = this._currentObject.data.substr(endRead, find - endRead);
          var data2 = this._readLine(line.trim()).split(";");
          _nowMat.specular.r = parseFloat(data2[0]);
          _nowMat.specular.g = parseFloat(data2[1]);
          _nowMat.specular.b = parseFloat(data2[2]);
          endRead = find + 2;
          find = this._currentObject.data.indexOf(";;", endRead);
          if (find === -1) {
            find = this._currentObject.data.length;
          }
          line = this._currentObject.data.substr(endRead, find - endRead);
          var data3 = this._readLine(line.trim()).split(";");
          _nowMat.emissive.r = parseFloat(data3[0]);
          _nowMat.emissive.g = parseFloat(data3[1]);
          _nowMat.emissive.b = parseFloat(data3[2]);
          var localObject = null;
          while (true) {
            if (this._currentObject.children.length > 0) {
              localObject = this._currentObject.children.shift();
              if (this.debug) {
                console.log("processing " + localObject.name);
              }
              var fileName = localObject.data.substr(1, localObject.data.length - 2);
              switch (localObject.type) {
                case "TextureFilename":
                  _nowMat.map = this.texloader.load(fileName);
                  break;
                case "BumpMapFilename":
                  _nowMat.bumpMap = this.texloader.load(fileName);
                  _nowMat.bumpScale = 0.05;
                  break;
                case "NormalMapFilename":
                  _nowMat.normalMap = this.texloader.load(fileName);
                  _nowMat.normalScale = new THREE.Vector2(2, 2);
                  break;
                case "EmissiveMapFilename":
                  _nowMat.emissiveMap = this.texloader.load(fileName);
                  break;
                case "LightMapFilename":
                  _nowMat.lightMap = this.texloader.load(fileName);
                  break;
              }
            } else {
              break;
            }
          }
          this._currentGeo.Materials.push(_nowMat);
        }
      },
      {
        key: "_setSkinWeights",
        value: function _setSkinWeights() {
          var boneInf = new XboneInf();
          var endRead = 0;
          var find = this._currentObject.data.indexOf(";", endRead);
          var line = this._currentObject.data.substr(endRead, find - endRead);
          endRead = find + 1;
          boneInf.boneName = line.substr(1, line.length - 2);
          boneInf.BoneIndex = this._currentGeo.BoneInfs.length;
          find = this._currentObject.data.indexOf(";", endRead);
          endRead = find + 1;
          find = this._currentObject.data.indexOf(";", endRead);
          line = this._currentObject.data.substr(endRead, find - endRead);
          var data = this._readLine(line.trim()).split(",");
          for (let i2 = 0; i2 < data.length; i2++) {
            boneInf.Indeces.push(parseInt(data[i2]));
          }
          endRead = find + 1;
          find = this._currentObject.data.indexOf(";", endRead);
          line = this._currentObject.data.substr(endRead, find - endRead);
          var data2 = this._readLine(line.trim()).split(",");
          for (let _i = 0; _i < data2.length; _i++) {
            boneInf.Weights.push(parseFloat(data2[_i]));
          }
          endRead = find + 1;
          find = this._currentObject.data.indexOf(";", endRead);
          if (find <= 0) {
            find = this._currentObject.data.length;
          }
          line = this._currentObject.data.substr(endRead, find - endRead);
          var data3 = this._readLine(line.trim()).split(",");
          boneInf.OffsetMatrix = new THREE.Matrix4();
          this._ParseMatrixData(boneInf.OffsetMatrix, data3);
          this._currentGeo.BoneInfs.push(boneInf);
        }
      },
      {
        key: "_makePutBoneList",
        value: function _makePutBoneList(_RootName, _bones) {
          var putting = false;
          for (let frame in this.HieStack) {
            if (this.HieStack[frame].name === _RootName || putting) {
              putting = true;
              var b = new THREE.Bone();
              b.name = this.HieStack[frame].name;
              b.applyMatrix4(this.HieStack[frame].FrameTransformMatrix);
              b.matrixWorld = b.matrix;
              b.FrameTransformMatrix = this.HieStack[frame].FrameTransformMatrix;
              b.pos = new THREE.Vector3().setFromMatrixPosition(b.FrameTransformMatrix).toArray();
              b.rotq = new THREE.Quaternion().setFromRotationMatrix(b.FrameTransformMatrix).toArray();
              b.scl = new THREE.Vector3().setFromMatrixScale(b.FrameTransformMatrix).toArray();
              if (this.HieStack[frame].parentName && this.HieStack[frame].parentName.length > 0) {
                for (let i2 = 0; i2 < _bones.length; i2++) {
                  if (this.HieStack[frame].parentName === _bones[i2].name) {
                    _bones[i2].add(b);
                    b.parent = i2;
                    break;
                  }
                }
              }
              _bones.push(b);
            }
          }
        }
      },
      {
        key: "_makeOutputGeometry",
        value: function _makeOutputGeometry() {
          var mesh = null;
          if (this._currentGeo.BoneInfs.length > 0) {
            var putBones = [];
            this._makePutBoneList(this._currentGeo.baseFrame.parentName, putBones);
            for (let bi = 0; bi < this._currentGeo.BoneInfs.length; bi++) {
              var boneIndex = 0;
              for (let bb = 0; bb < putBones.length; bb++) {
                if (putBones[bb].name === this._currentGeo.BoneInfs[bi].boneName) {
                  boneIndex = bb;
                  putBones[bb].OffsetMatrix = new THREE.Matrix4();
                  putBones[bb].OffsetMatrix.copy(this._currentGeo.BoneInfs[bi].OffsetMatrix);
                  break;
                }
              }
              for (let vi = 0; vi < this._currentGeo.BoneInfs[bi].Indeces.length; vi++) {
                var nowVertexID = this._currentGeo.BoneInfs[bi].Indeces[vi];
                var nowVal = this._currentGeo.BoneInfs[bi].Weights[vi];
                var stride = nowVertexID * 4;
                switch (this._currentGeo.VertexSetedBoneCount[nowVertexID]) {
                  case 0:
                    this._currentGeo.GeometryData.skinIndices[stride] = boneIndex;
                    this._currentGeo.GeometryData.skinWeights[stride] = nowVal;
                    break;
                  case 1:
                    this._currentGeo.GeometryData.skinIndices[stride + 1] = boneIndex;
                    this._currentGeo.GeometryData.skinWeights[stride + 1] = nowVal;
                    break;
                  case 2:
                    this._currentGeo.GeometryData.skinIndices[stride + 2] = boneIndex;
                    this._currentGeo.GeometryData.skinWeights[stride + 2] = nowVal;
                    break;
                  case 3:
                    this._currentGeo.GeometryData.skinIndices[stride + 3] = boneIndex;
                    this._currentGeo.GeometryData.skinWeights[stride + 3] = nowVal;
                    break;
                }
                this._currentGeo.VertexSetedBoneCount[nowVertexID]++;
                if (this._currentGeo.VertexSetedBoneCount[nowVertexID] > 4) {
                  console.log("warn! over 4 bone weight! :" + nowVertexID);
                }
              }
            }
            for (let sk = 0; sk < this._currentGeo.Materials.length; sk++) {
              this._currentGeo.Materials[sk].skinning = true;
            }
            var offsetList = [];
            for (let _bi = 0; _bi < putBones.length; _bi++) {
              if (putBones[_bi].OffsetMatrix) {
                offsetList.push(putBones[_bi].OffsetMatrix);
              } else {
                offsetList.push(new THREE.Matrix4());
              }
            }
            var bufferGeometry = this._buildGeometry();
            mesh = new THREE.SkinnedMesh(
              bufferGeometry,
              this._currentGeo.Materials.length === 1 ? this._currentGeo.Materials[0] : this._currentGeo.Materials
            );
            this._initSkeleton(mesh, putBones, offsetList);
          } else {
            var _bufferGeometry = this._buildGeometry();
            mesh = new THREE.Mesh(
              _bufferGeometry,
              this._currentGeo.Materials.length === 1 ? this._currentGeo.Materials[0] : this._currentGeo.Materials
            );
          }
          mesh.name = this._currentGeo.name;
          var worldBaseMx = new THREE.Matrix4();
          var currentMxFrame = this._currentGeo.baseFrame.putBone;
          if (currentMxFrame && currentMxFrame.parent) {
            while (true) {
              currentMxFrame = currentMxFrame.parent;
              if (currentMxFrame) {
                worldBaseMx.multiply(currentMxFrame.FrameTransformMatrix);
              } else {
                break;
              }
            }
            mesh.applyMatrix4(worldBaseMx);
          }
          this.Meshes.push(mesh);
        }
      },
      {
        key: "_initSkeleton",
        value: function _initSkeleton(mesh, boneList, boneInverses) {
          var bones = [], bone, gbone;
          var i2, il;
          for (i2 = 0, il = boneList.length; i2 < il; i2++) {
            gbone = boneList[i2];
            bone = new THREE.Bone();
            bones.push(bone);
            bone.name = gbone.name;
            bone.position.fromArray(gbone.pos);
            bone.quaternion.fromArray(gbone.rotq);
            if (gbone.scl !== void 0)
              bone.scale.fromArray(gbone.scl);
          }
          for (i2 = 0, il = boneList.length; i2 < il; i2++) {
            gbone = boneList[i2];
            if (gbone.parent !== -1 && gbone.parent !== null && bones[gbone.parent] !== void 0) {
              bones[gbone.parent].add(bones[i2]);
            } else {
              mesh.add(bones[i2]);
            }
          }
          mesh.updateMatrixWorld(true);
          var skeleton = new THREE.Skeleton(bones, boneInverses);
          mesh.bind(skeleton, mesh.matrixWorld);
        }
      },
      {
        key: "_readAnimationKey",
        value: function _readAnimationKey() {
          var endRead = 0;
          var find = this._currentObject.data.indexOf(";", endRead);
          var line = this._currentObject.data.substr(endRead, find - endRead);
          endRead = find + 1;
          var nowKeyType = parseInt(this._readLine(line));
          find = this._currentObject.data.indexOf(";", endRead);
          endRead = find + 1;
          line = this._currentObject.data.substr(endRead);
          var data = this._readLine(line.trim()).split(";;,");
          for (let i2 = 0; i2 < data.length; i2++) {
            var data2 = data[i2].split(";");
            var keyInfo = new XKeyFrameInfo();
            keyInfo.type = nowKeyType;
            keyInfo.Frame = parseInt(data2[0]);
            keyInfo.index = this._currentAnimeFrames.keyFrames.length;
            keyInfo.time = keyInfo.Frame;
            if (nowKeyType != 4) {
              var frameFound = false;
              for (let mm = 0; mm < this._currentAnimeFrames.keyFrames.length; mm++) {
                if (this._currentAnimeFrames.keyFrames[mm].Frame === keyInfo.Frame) {
                  keyInfo = this._currentAnimeFrames.keyFrames[mm];
                  frameFound = true;
                  break;
                }
              }
              var frameValue = data2[2].split(",");
              switch (nowKeyType) {
                case 0:
                  keyInfo.rot = new THREE.Quaternion(
                    parseFloat(frameValue[1]),
                    parseFloat(frameValue[2]),
                    parseFloat(frameValue[3]),
                    parseFloat(frameValue[0]) * -1
                  );
                  break;
                case 1:
                  keyInfo.scl = new THREE.Vector3(
                    parseFloat(frameValue[0]),
                    parseFloat(frameValue[1]),
                    parseFloat(frameValue[2])
                  );
                  break;
                case 2:
                  keyInfo.pos = new THREE.Vector3(
                    parseFloat(frameValue[0]),
                    parseFloat(frameValue[1]),
                    parseFloat(frameValue[2])
                  );
                  break;
              }
              if (!frameFound) {
                this._currentAnimeFrames.keyFrames.push(keyInfo);
              }
            } else {
              keyInfo.matrix = new THREE.Matrix4();
              this._ParseMatrixData(keyInfo.matrix, data2[2].split(","));
              this._currentAnimeFrames.keyFrames.push(keyInfo);
            }
          }
        }
      },
      {
        key: "_makeOutputAnimation",
        value: function _makeOutputAnimation() {
          var animationObj = new XAnimationObj(this.options);
          animationObj.fps = this.animTicksPerSecond;
          animationObj.name = this._currentAnime.name;
          animationObj.make(this._currentAnime.AnimeFrames);
          this.animations.push(animationObj);
        }
      },
      {
        key: "assignAnimation",
        value: function assignAnimation(_model, _animation) {
          var model = _model;
          var animation = _animation;
          if (!model) {
            model = this.Meshes[0];
          }
          if (!animation) {
            animation = this.animations[0];
          }
          if (!model || !animation) {
            return null;
          }
          var put = {};
          put.fps = animation.fps;
          put.name = animation.name;
          put.length = animation.length;
          put.hierarchy = [];
          for (let b = 0; b < model.skeleton.bones.length; b++) {
            var findAnimation = false;
            for (let i2 = 0; i2 < animation.hierarchy.length; i2++) {
              if (model.skeleton.bones[b].name === animation.hierarchy[i2].name) {
                findAnimation = true;
                var c_key = animation.hierarchy[i2].copy();
                c_key.parent = -1;
                if (model.skeleton.bones[b].parent && model.skeleton.bones[b].parent.type === "Bone") {
                  for (let bb = 0; bb < put.hierarchy.length; bb++) {
                    if (put.hierarchy[bb].name === model.skeleton.bones[b].parent.name) {
                      c_key.parent = bb;
                      c_key.parentName = model.skeleton.bones[b].parent.name;
                    }
                  }
                }
                put.hierarchy.push(c_key);
                break;
              }
            }
            if (!findAnimation) {
              var _c_key = animation.hierarchy[0].copy();
              _c_key.name = model.skeleton.bones[b].name;
              _c_key.parent = -1;
              for (let k = 0; k < _c_key.keys.length; k++) {
                if (_c_key.keys[k].pos) {
                  _c_key.keys[k].pos.set(0, 0, 0);
                }
                if (_c_key.keys[k].scl) {
                  _c_key.keys[k].scl.set(1, 1, 1);
                }
                if (_c_key.keys[k].rot) {
                  _c_key.keys[k].rot.set(0, 0, 0, 1);
                }
              }
              put.hierarchy.push(_c_key);
            }
          }
          if (!model.geometry.animations) {
            model.geometry.animations = [];
          }
          model.geometry.animations.push(THREE.AnimationClip.parseAnimation(put, model.skeleton.bones));
          if (!model.animationMixer) {
            model.animationMixer = new THREE.AnimationMixer(model);
          }
          return put;
        }
      },
      {
        key: "_ParseMatrixData",
        value: function _ParseMatrixData(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])
          );
        }
      }
    ]);
    return XLoader3;
  }();
  return XLoader2;
}();
exports.XLoader = XLoader;
//# sourceMappingURL=XLoader.cjs.map