opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/misc/GPUComputationRenderer.js

@@ -0,0 +1,322 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.GPUComputationRenderer = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.GPUComputationRenderer = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  /**
+   * GPUComputationRenderer, based on SimulationRenderer by zz85
+   *
+   * The GPUComputationRenderer uses the concept of variables. These variables are RGBA float textures that hold 4 floats
+   * for each compute element (texel)
+   *
+   * Each variable has a fragment shader that defines the computation made to obtain the variable in question.
+   * You can use as many variables you need, and make dependencies so you can use textures of other variables in the shader
+   * (the sampler uniforms are added automatically) Most of the variables will need themselves as dependency.
+   *
+   * The renderer has actually two render targets per variable, to make ping-pong. Textures from the current frame are used
+   * as inputs to render the textures of the next frame.
+   *
+   * The render targets of the variables can be used as input textures for your visualization shaders.
+   *
+   * Variable names should be valid identifiers and should not collide with THREE GLSL used identifiers.
+   * a common approach could be to use 'texture' prefixing the variable name; i.e texturePosition, textureVelocity...
+   *
+   * The size of the computation (sizeX * sizeY) is defined as 'resolution' automatically in the shader. For example:
+   * #DEFINE resolution vec2( 1024.0, 1024.0 )
+   *
+   * -------------
+   *
+   * Basic use:
+   *
+   * // Initialization...
+   *
+   * // Create computation renderer
+   * const gpuCompute = new GPUComputationRenderer( 1024, 1024, renderer );
+   *
+   * // Create initial state float textures
+   * const pos0 = gpuCompute.createTexture();
+   * const vel0 = gpuCompute.createTexture();
+   * // and fill in here the texture data...
+   *
+   * // Add texture variables
+   * const velVar = gpuCompute.addVariable( "textureVelocity", fragmentShaderVel, pos0 );
+   * const posVar = gpuCompute.addVariable( "texturePosition", fragmentShaderPos, vel0 );
+   *
+   * // Add variable dependencies
+   * gpuCompute.setVariableDependencies( velVar, [ velVar, posVar ] );
+   * gpuCompute.setVariableDependencies( posVar, [ velVar, posVar ] );
+   *
+   * // Add custom uniforms
+   * velVar.material.uniforms.time = { value: 0.0 };
+   *
+   * // Check for completeness
+   * const error = gpuCompute.init();
+   * if ( error !== null ) {
+   *		console.error( error );
+    * }
+   *
+   *
+   * // In each frame...
+   *
+   * // Compute!
+   * gpuCompute.compute();
+   *
+   * // Update texture uniforms in your visualization materials with the gpu renderer output
+   * myMaterial.uniforms.myTexture.value = gpuCompute.getCurrentRenderTarget( posVar ).texture;
+   *
+   * // Do your rendering
+   * renderer.render( myScene, myCamera );
+   *
+   * -------------
+   *
+   * Also, you can use utility functions to create ShaderMaterial and perform computations (rendering between textures)
+   * Note that the shaders can have multiple input textures.
+   *
+   * const myFilter1 = gpuCompute.createShaderMaterial( myFilterFragmentShader1, { theTexture: { value: null } } );
+   * const myFilter2 = gpuCompute.createShaderMaterial( myFilterFragmentShader2, { theTexture: { value: null } } );
+   *
+   * const inputTexture = gpuCompute.createTexture();
+   *
+   * // Fill in here inputTexture...
+   *
+   * myFilter1.uniforms.theTexture.value = inputTexture;
+   *
+   * const myRenderTarget = gpuCompute.createRenderTarget();
+   * myFilter2.uniforms.theTexture.value = myRenderTarget.texture;
+   *
+   * const outputRenderTarget = gpuCompute.createRenderTarget();
+   *
+   * // Now use the output texture where you want:
+   * myMaterial.uniforms.map.value = outputRenderTarget.texture;
+   *
+   * // And compute each frame, before rendering to screen:
+   * gpuCompute.doRenderTarget( myFilter1, myRenderTarget );
+   * gpuCompute.doRenderTarget( myFilter2, outputRenderTarget );
+   *
+   *
+   *
+   * @param {int} sizeX Computation problem size is always 2d: sizeX * sizeY elements.
+   * @param {int} sizeY Computation problem size is always 2d: sizeX * sizeY elements.
+   * @param {WebGLRenderer} renderer The renderer
+    */
+  var GPUComputationRenderer = /*#__PURE__*/_createClass(function GPUComputationRenderer(sizeX, sizeY, renderer) {
+    _classCallCheck(this, GPUComputationRenderer);
+
+    this.variables = [];
+    this.currentTextureIndex = 0;
+    var dataType = _three.FloatType;
+    var scene = new _three.Scene();
+    var camera = new _three.Camera();
+    camera.position.z = 1;
+    var passThruUniforms = {
+      passThruTexture: {
+        value: null
+      }
+    };
+    var passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
+    var 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) {
+      var material = this.createShaderMaterial(computeFragmentShader);
+      var variable = {
+        name: variableName,
+        initialValueTexture: initialValueTexture,
+        material: 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 (var i = 0; i < this.variables.length; i++) {
+        var variable = this.variables[i]; // Creates rendertargets and initialize them with input texture
+
+        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]); // Adds dependencies uniforms to the ShaderMaterial
+
+        var material = variable.material;
+        var uniforms = material.uniforms;
+
+        if (variable.dependencies !== null) {
+          for (var d = 0; d < variable.dependencies.length; d++) {
+            var depVar = variable.dependencies[d];
+
+            if (depVar.name !== variable.name) {
+              // Checks if variable exists
+              var found = false;
+
+              for (var 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 () {
+      var currentTextureIndex = this.currentTextureIndex;
+      var nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+
+      for (var i = 0, il = this.variables.length; i < il; i++) {
+        var variable = this.variables[i]; // Sets texture dependencies uniforms
+
+        if (variable.dependencies !== null) {
+          var uniforms = variable.material.uniforms;
+
+          for (var d = 0, dl = variable.dependencies.length; d < dl; d++) {
+            var depVar = variable.dependencies[d];
+            uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
+          }
+        } // Performs the computation for this variable
+
+
+        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];
+    };
+
+    function addResolutionDefine(materialShader) {
+      materialShader.defines.resolution = 'vec2( ' + sizeX.toFixed(1) + ', ' + sizeY.toFixed(1) + ' )';
+    }
+
+    this.addResolutionDefine = addResolutionDefine; // The following functions can be used to compute things manually
+
+    function createShaderMaterial(computeFragmentShader, uniforms) {
+      uniforms = uniforms || {};
+      var material = new _three.ShaderMaterial({
+        uniforms: 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;
+      var renderTarget = new _three.WebGLRenderTarget(sizeXTexture, sizeYTexture, {
+        wrapS: wrapS,
+        wrapT: wrapT,
+        minFilter: minFilter,
+        magFilter: magFilter,
+        format: _three.RGBAFormat,
+        type: dataType,
+        depthBuffer: false
+      });
+      return renderTarget;
+    };
+
+    this.createTexture = function () {
+      var data = new Float32Array(sizeX * sizeY * 4);
+      return new _three.DataTexture(data, sizeX, sizeY, _three.RGBAFormat, _three.FloatType);
+    };
+
+    this.renderTexture = function (input, output) {
+      // Takes a texture, and render out in rendertarget
+      // input = Texture
+      // output = RenderTarget
+      passThruUniforms.passThruTexture.value = input;
+      this.doRenderTarget(passThruShader, output);
+      passThruUniforms.passThruTexture.value = null;
+    };
+
+    this.doRenderTarget = function (material, output) {
+      var currentRenderTarget = renderer.getRenderTarget();
+      mesh.material = material;
+      renderer.setRenderTarget(output);
+      renderer.render(scene, camera);
+      mesh.material = passThruShader;
+      renderer.setRenderTarget(currentRenderTarget);
+    }; // Shaders
+
+
+    function getPassThroughVertexShader() {
+      return 'void main()	{\n' + '\n' + '	gl_Position = vec4( position, 1.0 );\n' + '\n' + '}\n';
+    }
+
+    function getPassThroughFragmentShader() {
+      return 'uniform sampler2D passThruTexture;\n' + '\n' + 'void main() {\n' + '\n' + '	vec2 uv = gl_FragCoord.xy / resolution.xy;\n' + '\n' + '	gl_FragColor = texture2D( passThruTexture, uv );\n' + '\n' + '}\n';
+    }
+  });
+
+  _exports.GPUComputationRenderer = GPUComputationRenderer;
+});

data/lib-opal/js_wrap/three/misc/Gyroscope.js

@@ -0,0 +1,94 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.Gyroscope = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Gyroscope = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _translationObject = new _three.Vector3();
+
+  var _quaternionObject = new _three.Quaternion();
+
+  var _scaleObject = new _three.Vector3();
+
+  var _translationWorld = new _three.Vector3();
+
+  var _quaternionWorld = new _three.Quaternion();
+
+  var _scaleWorld = new _three.Vector3();
+
+  var Gyroscope = /*#__PURE__*/function (_Object3D) {
+    _inherits(Gyroscope, _Object3D);
+
+    var _super = _createSuper(Gyroscope);
+
+    function Gyroscope() {
+      _classCallCheck(this, Gyroscope);
+
+      return _super.call(this);
+    }
+
+    _createClass(Gyroscope, [{
+      key: "updateMatrixWorld",
+      value: function updateMatrixWorld(force) {
+        this.matrixAutoUpdate && this.updateMatrix(); // update matrixWorld
+
+        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;
+        } // update children
+
+
+        for (var i = 0, l = this.children.length; i < l; i++) {
+          this.children[i].updateMatrixWorld(force);
+        }
+      }
+    }]);
+
+    return Gyroscope;
+  }(_three.Object3D);
+
+  _exports.Gyroscope = Gyroscope;
+});

data/lib-opal/js_wrap/three/misc/MD2Character.js

@@ -0,0 +1,225 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../loaders/MD2Loader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../loaders/MD2Loader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.MD2Loader);
+    global.MD2Character = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _MD2Loader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MD2Character = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var MD2Character = /*#__PURE__*/function () {
+    function MD2Character() {
+      _classCallCheck(this, MD2Character);
+
+      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;
+    }
+
+    _createClass(MD2Character, [{
+      key: "loadParts",
+      value: function loadParts(config) {
+        var scope = this;
+
+        function createPart(geometry, skinMap) {
+          var materialWireframe = new _three.MeshLambertMaterial({
+            color: 0xffaa00,
+            wireframe: true
+          });
+          var materialTexture = new _three.MeshLambertMaterial({
+            color: 0xffffff,
+            wireframe: false,
+            map: skinMap
+          }); //
+
+          var 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) {
+          var textureLoader = new _three.TextureLoader();
+          var textures = [];
+
+          for (var i = 0; i < textureUrls.length; i++) {
+            textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
+            textures[i].mapping = _three.UVMapping;
+            textures[i].name = textureUrls[i];
+            textures[i].encoding = _three.sRGBEncoding;
+          }
+
+          return textures;
+        }
+
+        function checkLoadingComplete() {
+          scope.loadCounter -= 1;
+          if (scope.loadCounter === 0) scope.onLoadComplete();
+        }
+
+        this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
+        var weaponsTextures = [];
+
+        for (var i = 0; i < config.weapons.length; i++) {
+          weaponsTextures[i] = config.weapons[i][1];
+        } // SKINS
+
+
+        this.skinsBody = loadTextures(config.baseUrl + 'skins/', config.skins);
+        this.skinsWeapon = loadTextures(config.baseUrl + 'skins/', weaponsTextures); // BODY
+
+        var loader = new _MD2Loader.MD2Loader();
+        loader.load(config.baseUrl + config.body, function (geo) {
+          var boundingBox = new _three.Box3();
+          boundingBox.setFromBufferAttribute(geo.attributes.position);
+          scope.root.position.y = -scope.scale * boundingBox.min.y;
+          var 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();
+        }); // WEAPONS
+
+        var generateCallback = function generateCallback(index, name) {
+          return function (geo) {
+            var 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 (var _i = 0; _i < config.weapons.length; _i++) {
+          loader.load(config.baseUrl + config.weapons[_i][0], generateCallback(_i, config.weapons[_i][0]));
+        }
+      }
+    }, {
+      key: "setPlaybackRate",
+      value: function setPlaybackRate(rate) {
+        if (rate !== 0) {
+          this.mixer.timeScale = 1 / rate;
+        } else {
+          this.mixer.timeScale = 0;
+        }
+      }
+    }, {
+      key: "setWireframe",
+      value: function 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;
+        }
+      }
+    }, {
+      key: "setSkin",
+      value: function setSkin(index) {
+        if (this.meshBody && this.meshBody.material.wireframe === false) {
+          this.meshBody.material.map = this.skinsBody[index];
+        }
+      }
+    }, {
+      key: "setWeapon",
+      value: function setWeapon(index) {
+        for (var i = 0; i < this.weapons.length; i++) {
+          this.weapons[i].visible = false;
+        }
+
+        var activeWeapon = this.weapons[index];
+
+        if (activeWeapon) {
+          activeWeapon.visible = true;
+          this.meshWeapon = activeWeapon;
+          this.syncWeaponAnimation();
+        }
+      }
+    }, {
+      key: "setAnimation",
+      value: function setAnimation(clipName) {
+        if (this.meshBody) {
+          if (this.meshBody.activeAction) {
+            this.meshBody.activeAction.stop();
+            this.meshBody.activeAction = null;
+          }
+
+          var action = this.mixer.clipAction(clipName, this.meshBody);
+
+          if (action) {
+            this.meshBody.activeAction = action.play();
+          }
+        }
+
+        this.activeClipName = clipName;
+        this.syncWeaponAnimation();
+      }
+    }, {
+      key: "syncWeaponAnimation",
+      value: function syncWeaponAnimation() {
+        var clipName = this.activeClipName;
+
+        if (this.meshWeapon) {
+          if (this.meshWeapon.activeAction) {
+            this.meshWeapon.activeAction.stop();
+            this.meshWeapon.activeAction = null;
+          }
+
+          var action = this.mixer.clipAction(clipName, this.meshWeapon);
+
+          if (action) {
+            this.meshWeapon.activeAction = action.syncWith(this.meshBody.activeAction).play();
+          }
+        }
+      }
+    }, {
+      key: "update",
+      value: function update(delta) {
+        if (this.mixer) this.mixer.update(delta);
+      }
+    }]);
+
+    return MD2Character;
+  }();
+
+  _exports.MD2Character = MD2Character;
+});