three-stdlib 2.25.0 → 2.26.0

package/misc/GPUComputationRenderer.cjs

@@ -1,205 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-class GPUComputationRenderer {
-  constructor(sizeX, sizeY, renderer) {
-    this.variables = [];
-    this.currentTextureIndex = 0;
-    let dataType = THREE.FloatType;
-    const scene = new THREE.Scene();
-    const camera = new THREE.Camera();
-    camera.position.z = 1;
-    const passThruUniforms = {
-      passThruTexture: { value: null }
-    };
-    const passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
-    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), passThruShader);
-    scene.add(mesh);
-    this.setDataType = function(type) {
-      dataType = type;
-      return this;
-    };
-    this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
-      const material = this.createShaderMaterial(computeFragmentShader);
-      const variable = {
-        name: variableName,
-        initialValueTexture,
-        material,
-        dependencies: null,
-        renderTargets: [],
-        wrapS: null,
-        wrapT: null,
-        minFilter: THREE.NearestFilter,
-        magFilter: THREE.NearestFilter
-      };
-      this.variables.push(variable);
-      return variable;
-    };
-    this.setVariableDependencies = function(variable, dependencies) {
-      variable.dependencies = dependencies;
-    };
-    this.init = function() {
-      if (renderer.capabilities.isWebGL2 === false && renderer.extensions.has("OES_texture_float") === false) {
-        return "No OES_texture_float support for float textures.";
-      }
-      if (renderer.capabilities.maxVertexTextures === 0) {
-        return "No support for vertex shader textures.";
-      }
-      for (let i = 0; i < this.variables.length; i++) {
-        const variable = this.variables[i];
-        variable.renderTargets[0] = this.createRenderTarget(
-          sizeX,
-          sizeY,
-          variable.wrapS,
-          variable.wrapT,
-          variable.minFilter,
-          variable.magFilter
-        );
-        variable.renderTargets[1] = this.createRenderTarget(
-          sizeX,
-          sizeY,
-          variable.wrapS,
-          variable.wrapT,
-          variable.minFilter,
-          variable.magFilter
-        );
-        this.renderTexture(variable.initialValueTexture, variable.renderTargets[0]);
-        this.renderTexture(variable.initialValueTexture, variable.renderTargets[1]);
-        const material = variable.material;
-        const uniforms = material.uniforms;
-        if (variable.dependencies !== null) {
-          for (let d = 0; d < variable.dependencies.length; d++) {
-            const depVar = variable.dependencies[d];
-            if (depVar.name !== variable.name) {
-              let found = false;
-              for (let j = 0; j < this.variables.length; j++) {
-                if (depVar.name === this.variables[j].name) {
-                  found = true;
-                  break;
-                }
-              }
-              if (!found) {
-                return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
-              }
-            }
-            uniforms[depVar.name] = { value: null };
-            material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
-          }
-        }
-      }
-      this.currentTextureIndex = 0;
-      return null;
-    };
-    this.compute = function() {
-      const currentTextureIndex = this.currentTextureIndex;
-      const nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
-      for (let i = 0, il = this.variables.length; i < il; i++) {
-        const variable = this.variables[i];
-        if (variable.dependencies !== null) {
-          const uniforms = variable.material.uniforms;
-          for (let d = 0, dl = variable.dependencies.length; d < dl; d++) {
-            const depVar = variable.dependencies[d];
-            uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
-          }
-        }
-        this.doRenderTarget(variable.material, variable.renderTargets[nextTextureIndex]);
-      }
-      this.currentTextureIndex = nextTextureIndex;
-    };
-    this.getCurrentRenderTarget = function(variable) {
-      return variable.renderTargets[this.currentTextureIndex];
-    };
-    this.getAlternateRenderTarget = function(variable) {
-      return variable.renderTargets[this.currentTextureIndex === 0 ? 1 : 0];
-    };
-    this.dispose = function() {
-      mesh.geometry.dispose();
-      mesh.material.dispose();
-      const variables = this.variables;
-      for (let i = 0; i < variables.length; i++) {
-        const variable = variables[i];
-        if (variable.initialValueTexture)
-          variable.initialValueTexture.dispose();
-        const renderTargets = variable.renderTargets;
-        for (let j = 0; j < renderTargets.length; j++) {
-          const renderTarget = renderTargets[j];
-          renderTarget.dispose();
-        }
-      }
-    };
-    function addResolutionDefine(materialShader) {
-      materialShader.defines.resolution = "vec2( " + sizeX.toFixed(1) + ", " + sizeY.toFixed(1) + " )";
-    }
-    this.addResolutionDefine = addResolutionDefine;
-    function createShaderMaterial(computeFragmentShader, uniforms) {
-      uniforms = uniforms || {};
-      const material = new THREE.ShaderMaterial({
-        uniforms,
-        vertexShader: getPassThroughVertexShader(),
-        fragmentShader: computeFragmentShader
-      });
-      addResolutionDefine(material);
-      return material;
-    }
-    this.createShaderMaterial = createShaderMaterial;
-    this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
-      sizeXTexture = sizeXTexture || sizeX;
-      sizeYTexture = sizeYTexture || sizeY;
-      wrapS = wrapS || THREE.ClampToEdgeWrapping;
-      wrapT = wrapT || THREE.ClampToEdgeWrapping;
-      minFilter = minFilter || THREE.NearestFilter;
-      magFilter = magFilter || THREE.NearestFilter;
-      const renderTarget = new THREE.WebGLRenderTarget(sizeXTexture, sizeYTexture, {
-        wrapS,
-        wrapT,
-        minFilter,
-        magFilter,
-        format: THREE.RGBAFormat,
-        type: dataType,
-        depthBuffer: false
-      });
-      return renderTarget;
-    };
-    this.createTexture = function() {
-      const data = new Float32Array(sizeX * sizeY * 4);
-      const texture = new THREE.DataTexture(data, sizeX, sizeY, THREE.RGBAFormat, THREE.FloatType);
-      texture.needsUpdate = true;
-      return texture;
-    };
-    this.renderTexture = function(input, output) {
-      passThruUniforms.passThruTexture.value = input;
-      this.doRenderTarget(passThruShader, output);
-      passThruUniforms.passThruTexture.value = null;
-    };
-    this.doRenderTarget = function(material, output) {
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      const currentOutputColorSpace = renderer.outputColorSpace;
-      const currentToneMapping = renderer.toneMapping;
-      renderer.xr.enabled = false;
-      renderer.shadowMap.autoUpdate = false;
-      if ("outputColorSpace" in renderer)
-        renderer.outputColorSpace = "srgb-linear";
-      else
-        renderer.encoding = 3e3;
-      renderer.toneMapping = THREE.NoToneMapping;
-      mesh.material = material;
-      renderer.setRenderTarget(output);
-      renderer.render(scene, camera);
-      mesh.material = passThruShader;
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.outputColorSpace = currentOutputColorSpace;
-      renderer.toneMapping = currentToneMapping;
-      renderer.setRenderTarget(currentRenderTarget);
-    };
-    function getPassThroughVertexShader() {
-      return "void main()	{\n\n	gl_Position = vec4( position, 1.0 );\n\n}\n";
-    }
-    function getPassThroughFragmentShader() {
-      return "uniform sampler2D passThruTexture;\n\nvoid main() {\n\n	vec2 uv = gl_FragCoord.xy / resolution.xy;\n\n	gl_FragColor = texture2D( passThruTexture, uv );\n\n}\n";
-    }
-  }
-}
-exports.GPUComputationRenderer = GPUComputationRenderer;

package/misc/GPUComputationRenderer.js

@@ -1,205 +0,0 @@
-import { FloatType, Scene, Camera, Mesh, PlaneGeometry, NearestFilter, ShaderMaterial, ClampToEdgeWrapping, WebGLRenderTarget, RGBAFormat, DataTexture, NoToneMapping } from "three";
-class GPUComputationRenderer {
-  constructor(sizeX, sizeY, renderer) {
-    this.variables = [];
-    this.currentTextureIndex = 0;
-    let dataType = FloatType;
-    const scene = new Scene();
-    const camera = new Camera();
-    camera.position.z = 1;
-    const passThruUniforms = {
-      passThruTexture: { value: null }
-    };
-    const passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
-    const mesh = new Mesh(new PlaneGeometry(2, 2), passThruShader);
-    scene.add(mesh);
-    this.setDataType = function(type) {
-      dataType = type;
-      return this;
-    };
-    this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
-      const material = this.createShaderMaterial(computeFragmentShader);
-      const variable = {
-        name: variableName,
-        initialValueTexture,
-        material,
-        dependencies: null,
-        renderTargets: [],
-        wrapS: null,
-        wrapT: null,
-        minFilter: NearestFilter,
-        magFilter: NearestFilter
-      };
-      this.variables.push(variable);
-      return variable;
-    };
-    this.setVariableDependencies = function(variable, dependencies) {
-      variable.dependencies = dependencies;
-    };
-    this.init = function() {
-      if (renderer.capabilities.isWebGL2 === false && renderer.extensions.has("OES_texture_float") === false) {
-        return "No OES_texture_float support for float textures.";
-      }
-      if (renderer.capabilities.maxVertexTextures === 0) {
-        return "No support for vertex shader textures.";
-      }
-      for (let i = 0; i < this.variables.length; i++) {
-        const variable = this.variables[i];
-        variable.renderTargets[0] = this.createRenderTarget(
-          sizeX,
-          sizeY,
-          variable.wrapS,
-          variable.wrapT,
-          variable.minFilter,
-          variable.magFilter
-        );
-        variable.renderTargets[1] = this.createRenderTarget(
-          sizeX,
-          sizeY,
-          variable.wrapS,
-          variable.wrapT,
-          variable.minFilter,
-          variable.magFilter
-        );
-        this.renderTexture(variable.initialValueTexture, variable.renderTargets[0]);
-        this.renderTexture(variable.initialValueTexture, variable.renderTargets[1]);
-        const material = variable.material;
-        const uniforms = material.uniforms;
-        if (variable.dependencies !== null) {
-          for (let d = 0; d < variable.dependencies.length; d++) {
-            const depVar = variable.dependencies[d];
-            if (depVar.name !== variable.name) {
-              let found = false;
-              for (let j = 0; j < this.variables.length; j++) {
-                if (depVar.name === this.variables[j].name) {
-                  found = true;
-                  break;
-                }
-              }
-              if (!found) {
-                return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
-              }
-            }
-            uniforms[depVar.name] = { value: null };
-            material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
-          }
-        }
-      }
-      this.currentTextureIndex = 0;
-      return null;
-    };
-    this.compute = function() {
-      const currentTextureIndex = this.currentTextureIndex;
-      const nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
-      for (let i = 0, il = this.variables.length; i < il; i++) {
-        const variable = this.variables[i];
-        if (variable.dependencies !== null) {
-          const uniforms = variable.material.uniforms;
-          for (let d = 0, dl = variable.dependencies.length; d < dl; d++) {
-            const depVar = variable.dependencies[d];
-            uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
-          }
-        }
-        this.doRenderTarget(variable.material, variable.renderTargets[nextTextureIndex]);
-      }
-      this.currentTextureIndex = nextTextureIndex;
-    };
-    this.getCurrentRenderTarget = function(variable) {
-      return variable.renderTargets[this.currentTextureIndex];
-    };
-    this.getAlternateRenderTarget = function(variable) {
-      return variable.renderTargets[this.currentTextureIndex === 0 ? 1 : 0];
-    };
-    this.dispose = function() {
-      mesh.geometry.dispose();
-      mesh.material.dispose();
-      const variables = this.variables;
-      for (let i = 0; i < variables.length; i++) {
-        const variable = variables[i];
-        if (variable.initialValueTexture)
-          variable.initialValueTexture.dispose();
-        const renderTargets = variable.renderTargets;
-        for (let j = 0; j < renderTargets.length; j++) {
-          const renderTarget = renderTargets[j];
-          renderTarget.dispose();
-        }
-      }
-    };
-    function addResolutionDefine(materialShader) {
-      materialShader.defines.resolution = "vec2( " + sizeX.toFixed(1) + ", " + sizeY.toFixed(1) + " )";
-    }
-    this.addResolutionDefine = addResolutionDefine;
-    function createShaderMaterial(computeFragmentShader, uniforms) {
-      uniforms = uniforms || {};
-      const material = new ShaderMaterial({
-        uniforms,
-        vertexShader: getPassThroughVertexShader(),
-        fragmentShader: computeFragmentShader
-      });
-      addResolutionDefine(material);
-      return material;
-    }
-    this.createShaderMaterial = createShaderMaterial;
-    this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
-      sizeXTexture = sizeXTexture || sizeX;
-      sizeYTexture = sizeYTexture || sizeY;
-      wrapS = wrapS || ClampToEdgeWrapping;
-      wrapT = wrapT || ClampToEdgeWrapping;
-      minFilter = minFilter || NearestFilter;
-      magFilter = magFilter || NearestFilter;
-      const renderTarget = new WebGLRenderTarget(sizeXTexture, sizeYTexture, {
-        wrapS,
-        wrapT,
-        minFilter,
-        magFilter,
-        format: RGBAFormat,
-        type: dataType,
-        depthBuffer: false
-      });
-      return renderTarget;
-    };
-    this.createTexture = function() {
-      const data = new Float32Array(sizeX * sizeY * 4);
-      const texture = new DataTexture(data, sizeX, sizeY, RGBAFormat, FloatType);
-      texture.needsUpdate = true;
-      return texture;
-    };
-    this.renderTexture = function(input, output) {
-      passThruUniforms.passThruTexture.value = input;
-      this.doRenderTarget(passThruShader, output);
-      passThruUniforms.passThruTexture.value = null;
-    };
-    this.doRenderTarget = function(material, output) {
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      const currentOutputColorSpace = renderer.outputColorSpace;
-      const currentToneMapping = renderer.toneMapping;
-      renderer.xr.enabled = false;
-      renderer.shadowMap.autoUpdate = false;
-      if ("outputColorSpace" in renderer)
-        renderer.outputColorSpace = "srgb-linear";
-      else
-        renderer.encoding = 3e3;
-      renderer.toneMapping = NoToneMapping;
-      mesh.material = material;
-      renderer.setRenderTarget(output);
-      renderer.render(scene, camera);
-      mesh.material = passThruShader;
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.outputColorSpace = currentOutputColorSpace;
-      renderer.toneMapping = currentToneMapping;
-      renderer.setRenderTarget(currentRenderTarget);
-    };
-    function getPassThroughVertexShader() {
-      return "void main()	{\n\n	gl_Position = vec4( position, 1.0 );\n\n}\n";
-    }
-    function getPassThroughFragmentShader() {
-      return "uniform sampler2D passThruTexture;\n\nvoid main() {\n\n	vec2 uv = gl_FragCoord.xy / resolution.xy;\n\n	gl_FragColor = texture2D( passThruTexture, uv );\n\n}\n";
-    }
-  }
-}
-export {
-  GPUComputationRenderer
-};

package/misc/Gyroscope.cjs

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const _translationObject = /* @__PURE__ */ new THREE.Vector3();
-const _quaternionObject = /* @__PURE__ */ new THREE.Quaternion();
-const _scaleObject = /* @__PURE__ */ new THREE.Vector3();
-const _translationWorld = /* @__PURE__ */ new THREE.Vector3();
-const _quaternionWorld = /* @__PURE__ */ new THREE.Quaternion();
-const _scaleWorld = /* @__PURE__ */ new THREE.Vector3();
-class Gyroscope extends THREE.Object3D {
-  constructor() {
-    super();
-  }
-  updateMatrixWorld(force) {
-    this.matrixAutoUpdate && this.updateMatrix();
-    if (this.matrixWorldNeedsUpdate || force) {
-      if (this.parent !== null) {
-        this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
-        this.matrixWorld.decompose(_translationWorld, _quaternionWorld, _scaleWorld);
-        this.matrix.decompose(_translationObject, _quaternionObject, _scaleObject);
-        this.matrixWorld.compose(_translationWorld, _quaternionObject, _scaleWorld);
-      } else {
-        this.matrixWorld.copy(this.matrix);
-      }
-      this.matrixWorldNeedsUpdate = false;
-      force = true;
-    }
-    for (let i = 0, l = this.children.length; i < l; i++) {
-      this.children[i].updateMatrixWorld(force);
-    }
-  }
-}
-exports.Gyroscope = Gyroscope;

package/misc/Gyroscope.js

@@ -1,33 +0,0 @@
-import { Vector3, Quaternion, Object3D } from "three";
-const _translationObject = /* @__PURE__ */ new Vector3();
-const _quaternionObject = /* @__PURE__ */ new Quaternion();
-const _scaleObject = /* @__PURE__ */ new Vector3();
-const _translationWorld = /* @__PURE__ */ new Vector3();
-const _quaternionWorld = /* @__PURE__ */ new Quaternion();
-const _scaleWorld = /* @__PURE__ */ new Vector3();
-class Gyroscope extends Object3D {
-  constructor() {
-    super();
-  }
-  updateMatrixWorld(force) {
-    this.matrixAutoUpdate && this.updateMatrix();
-    if (this.matrixWorldNeedsUpdate || force) {
-      if (this.parent !== null) {
-        this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
-        this.matrixWorld.decompose(_translationWorld, _quaternionWorld, _scaleWorld);
-        this.matrix.decompose(_translationObject, _quaternionObject, _scaleObject);
-        this.matrixWorld.compose(_translationWorld, _quaternionObject, _scaleWorld);
-      } else {
-        this.matrixWorld.copy(this.matrix);
-      }
-      this.matrixWorldNeedsUpdate = false;
-      force = true;
-    }
-    for (let i = 0, l = this.children.length; i < l; i++) {
-      this.children[i].updateMatrixWorld(force);
-    }
-  }
-}
-export {
-  Gyroscope
-};

package/misc/MD2Character.cjs

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const MD2Loader = require("../loaders/MD2Loader.cjs");
-class MD2Character {
-  constructor() {
-    this.scale = 1;
-    this.animationFPS = 6;
-    this.root = new THREE.Object3D();
-    this.meshBody = null;
-    this.meshWeapon = null;
-    this.skinsBody = [];
-    this.skinsWeapon = [];
-    this.weapons = [];
-    this.activeAnimation = null;
-    this.mixer = null;
-    this.onLoadComplete = function() {
-    };
-    this.loadCounter = 0;
-  }
-  loadParts(config) {
-    const scope = this;
-    function createPart(geometry, skinMap) {
-      const materialWireframe = new THREE.MeshLambertMaterial({
-        color: 16755200,
-        wireframe: true,
-        morphTargets: true,
-        morphNormals: true
-      });
-      const materialTexture = new THREE.MeshLambertMaterial({
-        color: 16777215,
-        wireframe: false,
-        map: skinMap,
-        morphTargets: true,
-        morphNormals: true
-      });
-      const mesh = new THREE.Mesh(geometry, materialTexture);
-      mesh.rotation.y = -Math.PI / 2;
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      mesh.materialTexture = materialTexture;
-      mesh.materialWireframe = materialWireframe;
-      return mesh;
-    }
-    function loadTextures(baseUrl, textureUrls) {
-      const textureLoader = new THREE.TextureLoader();
-      const textures = [];
-      for (let i = 0; i < textureUrls.length; i++) {
-        textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
-        textures[i].mapping = THREE.UVMapping;
-        textures[i].name = textureUrls[i];
-        if ("colorSpace" in textures[i])
-          textures[i].colorSpace = "srgb";
-        else
-          textures[i].encoding = 3001;
-      }
-      return textures;
-    }
-    function checkLoadingComplete() {
-      scope.loadCounter -= 1;
-      if (scope.loadCounter === 0)
-        scope.onLoadComplete();
-    }
-    this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
-    const weaponsTextures = [];
-    for (let i = 0; i < config.weapons.length; i++)
-      weaponsTextures[i] = config.weapons[i][1];
-    this.skinsBody = loadTextures(config.baseUrl + "skins/", config.skins);
-    this.skinsWeapon = loadTextures(config.baseUrl + "skins/", weaponsTextures);
-    const loader = new MD2Loader.MD2Loader();
-    loader.load(config.baseUrl + config.body, function(geo) {
-      const boundingBox = new THREE.Box3();
-      boundingBox.setFromBufferAttribute(geo.attributes.position);
-      scope.root.position.y = -scope.scale * boundingBox.min.y;
-      const mesh = createPart(geo, scope.skinsBody[0]);
-      mesh.scale.set(scope.scale, scope.scale, scope.scale);
-      scope.root.add(mesh);
-      scope.meshBody = mesh;
-      scope.meshBody.clipOffset = 0;
-      scope.activeAnimationClipName = mesh.geometry.animations[0].name;
-      scope.mixer = new THREE.AnimationMixer(mesh);
-      checkLoadingComplete();
-    });
-    const generateCallback = function(index, name) {
-      return function(geo) {
-        const mesh = createPart(geo, scope.skinsWeapon[index]);
-        mesh.scale.set(scope.scale, scope.scale, scope.scale);
-        mesh.visible = false;
-        mesh.name = name;
-        scope.root.add(mesh);
-        scope.weapons[index] = mesh;
-        scope.meshWeapon = mesh;
-        checkLoadingComplete();
-      };
-    };
-    for (let i = 0; i < config.weapons.length; i++) {
-      loader.load(config.baseUrl + config.weapons[i][0], generateCallback(i, config.weapons[i][0]));
-    }
-  }
-  setPlaybackRate(rate) {
-    if (rate !== 0) {
-      this.mixer.timeScale = 1 / rate;
-    } else {
-      this.mixer.timeScale = 0;
-    }
-  }
-  setWireframe(wireframeEnabled) {
-    if (wireframeEnabled) {
-      if (this.meshBody)
-        this.meshBody.material = this.meshBody.materialWireframe;
-      if (this.meshWeapon)
-        this.meshWeapon.material = this.meshWeapon.materialWireframe;
-    } else {
-      if (this.meshBody)
-        this.meshBody.material = this.meshBody.materialTexture;
-      if (this.meshWeapon)
-        this.meshWeapon.material = this.meshWeapon.materialTexture;
-    }
-  }
-  setSkin(index) {
-    if (this.meshBody && this.meshBody.material.wireframe === false) {
-      this.meshBody.material.map = this.skinsBody[index];
-    }
-  }
-  setWeapon(index) {
-    for (let i = 0; i < this.weapons.length; i++)
-      this.weapons[i].visible = false;
-    const activeWeapon = this.weapons[index];
-    if (activeWeapon) {
-      activeWeapon.visible = true;
-      this.meshWeapon = activeWeapon;
-      this.syncWeaponAnimation();
-    }
-  }
-  setAnimation(clipName) {
-    if (this.meshBody) {
-      if (this.meshBody.activeAction) {
-        this.meshBody.activeAction.stop();
-        this.meshBody.activeAction = null;
-      }
-      const action = this.mixer.clipAction(clipName, this.meshBody);
-      if (action) {
-        this.meshBody.activeAction = action.play();
-      }
-    }
-    this.activeClipName = clipName;
-    this.syncWeaponAnimation();
-  }
-  syncWeaponAnimation() {
-    const clipName = this.activeClipName;
-    if (this.meshWeapon) {
-      if (this.meshWeapon.activeAction) {
-        this.meshWeapon.activeAction.stop();
-        this.meshWeapon.activeAction = null;
-      }
-      const action = this.mixer.clipAction(clipName, this.meshWeapon);
-      if (action) {
-        this.meshWeapon.activeAction = action.syncWith(this.meshBody.activeAction).play();
-      }
-    }
-  }
-  update(delta) {
-    if (this.mixer)
-      this.mixer.update(delta);
-  }
-}
-exports.MD2Character = MD2Character;