three-stdlib 2.16.0 → 2.16.2

package/misc/GPUComputationRenderer.js

@@ -1,171 +1,296 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-var GPUComputationRenderer = function(sizeX, sizeY, renderer) {
+import { Scene, Camera, Mesh, PlaneGeometry, ShaderMaterial, WebGLRenderTarget, RGBAFormat, DataTexture, FloatType, NearestFilter, ClampToEdgeWrapping } from 'three';
+
+/**
+ * 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
+ * var gpuCompute = new GPUComputationRenderer( 1024, 1024, renderer );
+ *
+ * // Create initial state float textures
+ * var pos0 = gpuCompute.createTexture();
+ * var vel0 = gpuCompute.createTexture();
+ * // and fill in here the texture data...
+ *
+ * // Add texture variables
+ * var velVar = gpuCompute.addVariable( "textureVelocity", fragmentShaderVel, pos0 );
+ * var 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
+ * var 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.
+ *
+ * var myFilter1 = gpuCompute.createShaderMaterial( myFilterFragmentShader1, { theTexture: { value: null } } );
+ * var myFilter2 = gpuCompute.createShaderMaterial( myFilterFragmentShader2, { theTexture: { value: null } } );
+ *
+ * var inputTexture = gpuCompute.createTexture();
+ *
+ * // Fill in here inputTexture...
+ *
+ * myFilter1.uniforms.theTexture.value = inputTexture;
+ *
+ * var myRenderTarget = gpuCompute.createRenderTarget();
+ * myFilter2.uniforms.theTexture.value = myRenderTarget.texture;
+ *
+ * var 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 = function (sizeX, sizeY, renderer) {
   this.variables = [];
   this.currentTextureIndex = 0;
-  var dataType = THREE.FloatType;
-  var scene = new THREE.Scene();
-  var camera = new THREE.Camera();
+  var dataType = FloatType;
+  var scene = new Scene();
+  var camera = new Camera();
   camera.position.z = 1;
   var passThruUniforms = {
-    passThruTexture: { value: null }
+    passThruTexture: {
+      value: null
+    }
   };
   var passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
-  var mesh = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), passThruShader);
+  var mesh = new Mesh(new PlaneGeometry(2, 2), passThruShader);
   scene.add(mesh);
-  this.setDataType = function(type) {
+
+  this.setDataType = function (type) {
     dataType = type;
     return this;
   };
-  this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
+
+  this.addVariable = function (variableName, computeFragmentShader, initialValueTexture) {
     var material = this.createShaderMaterial(computeFragmentShader);
     var variable = {
       name: variableName,
-      initialValueTexture,
-      material,
+      initialValueTexture: initialValueTexture,
+      material: material,
       dependencies: null,
       renderTargets: [],
       wrapS: null,
       wrapT: null,
-      minFilter: THREE.NearestFilter,
-      magFilter: THREE.NearestFilter
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
     };
     this.variables.push(variable);
     return variable;
   };
-  this.setVariableDependencies = function(variable, dependencies) {
+
+  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.";
+
+  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.";
+      return 'No support for vertex shader textures.';
     }
+
     for (let i = 0; i < this.variables.length; i++) {
-      var 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
-      );
+      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]);
+      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 (let 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 (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;
+              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;
+
+          uniforms[depVar.name] = {
+            value: null
+          };
+          material.fragmentShader = '\nuniform sampler2D ' + depVar.name + ';\n' + material.fragmentShader;
         }
       }
     }
+
     this.currentTextureIndex = 0;
     return null;
   };
-  this.compute = function() {
+
+  this.compute = function () {
     var currentTextureIndex = this.currentTextureIndex;
     var nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+
     for (let i = 0, il = this.variables.length; i < il; i++) {
-      var variable = this.variables[i];
+      var variable = this.variables[i]; // Sets texture dependencies uniforms
+
       if (variable.dependencies !== null) {
         var uniforms = variable.material.uniforms;
+
         for (let 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) {
+
+  this.getCurrentRenderTarget = function (variable) {
     return variable.renderTargets[this.currentTextureIndex];
   };
-  this.getAlternateRenderTarget = function(variable) {
+
+  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) + " )";
+    materialShader.defines.resolution = 'vec2( ' + sizeX.toFixed(1) + ', ' + sizeY.toFixed(1) + ' )';
   }
-  this.addResolutionDefine = addResolutionDefine;
+
+  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,
+    var material = new ShaderMaterial({
+      uniforms: uniforms,
       vertexShader: getPassThroughVertexShader(),
       fragmentShader: computeFragmentShader
     });
     addResolutionDefine(material);
     return material;
   }
+
   this.createShaderMaterial = createShaderMaterial;
-  this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
+
+  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,
-      wrapT,
-      minFilter,
-      magFilter,
-      format: THREE.RGBAFormat,
+    wrapS = wrapS || ClampToEdgeWrapping;
+    wrapT = wrapT || ClampToEdgeWrapping;
+    minFilter = minFilter || NearestFilter;
+    magFilter = magFilter || NearestFilter;
+    var renderTarget = new WebGLRenderTarget(sizeXTexture, sizeYTexture, {
+      wrapS: wrapS,
+      wrapT: wrapT,
+      minFilter: minFilter,
+      magFilter: magFilter,
+      format: RGBAFormat,
       type: dataType,
       depthBuffer: false
     });
     return renderTarget;
   };
-  this.createTexture = function() {
+
+  this.createTexture = function () {
     var data = new Float32Array(sizeX * sizeY * 4);
-    return new THREE.DataTexture(data, sizeX, sizeY, THREE.RGBAFormat, THREE.FloatType);
+    return new DataTexture(data, sizeX, sizeY, RGBAFormat, FloatType);
   };
-  this.renderTexture = function(input, output) {
+
+  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) {
+
+  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";
+    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";
+    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;
+
+export { GPUComputationRenderer };

package/misc/Gyroscope.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t,e,r,i,o,a,s=require("three"),c=function(){s.Object3D.call(this)};(c.prototype=Object.create(s.Object3D.prototype)).constructor=c,c.prototype.updateMatrixWorld=(t=new s.Vector3,e=new s.Quaternion,r=new s.Vector3,i=new s.Vector3,o=new s.Quaternion,a=new s.Vector3,function(s){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||s)&&(null!==this.parent?(this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorld.decompose(i,o,a),this.matrix.decompose(t,e,r),this.matrixWorld.compose(i,e,a)):this.matrixWorld.copy(this.matrix),this.matrixWorldNeedsUpdate=!1,s=!0);for(let t=0,e=this.children.length;t<e;t++)this.children[t].updateMatrixWorld(s)}),exports.Gyroscope=c;

package/misc/Gyroscope.js

@@ -1,20 +1,22 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-var Gyroscope = function() {
-  THREE.Object3D.call(this);
+import { Object3D, Vector3, Quaternion } from 'three';
+
+var Gyroscope = function () {
+  Object3D.call(this);
 };
-Gyroscope.prototype = Object.create(THREE.Object3D.prototype);
+
+Gyroscope.prototype = Object.create(Object3D.prototype);
 Gyroscope.prototype.constructor = Gyroscope;
-Gyroscope.prototype.updateMatrixWorld = function() {
-  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();
+
+Gyroscope.prototype.updateMatrixWorld = function () {
+  var translationObject = new Vector3();
+  var quaternionObject = new Quaternion();
+  var scaleObject = new Vector3();
+  var translationWorld = new Vector3();
+  var quaternionWorld = new Quaternion();
+  var scaleWorld = new Vector3();
   return function updateMatrixWorld(force) {
-    this.matrixAutoUpdate && this.updateMatrix();
+    this.matrixAutoUpdate && this.updateMatrix(); // update matrixWorld
+
     if (this.matrixWorldNeedsUpdate || force) {
       if (this.parent !== null) {
         this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
@@ -24,12 +26,16 @@ Gyroscope.prototype.updateMatrixWorld = function() {
       } else {
         this.matrixWorld.copy(this.matrix);
       }
+
       this.matrixWorldNeedsUpdate = false;
       force = true;
-    }
+    } // update children
+
+
     for (let i = 0, l = this.children.length; i < l; i++) {
       this.children[i].updateMatrixWorld(force);
     }
   };
 }();
-exports.Gyroscope = Gyroscope;
+
+export { Gyroscope };

package/misc/MD2Character.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("../loaders/MD2Loader.cjs.js");exports.MD2Character=function(){var i=this;function s(t,i){var s=new e.TextureLoader,a=[];for(let n=0;n<i.length;n++)a[n]=s.load(t+i[n],o),a[n].mapping=e.UVMapping,a[n].name=i[n],a[n].encoding=e.sRGBEncoding;return a}function a(t,i){var s=new e.MeshLambertMaterial({color:16755200,wireframe:!0,morphTargets:!0,morphNormals:!0}),a=new e.MeshLambertMaterial({color:16777215,wireframe:!1,map:i,morphTargets:!0,morphNormals:!0}),o=new e.Mesh(t,a);return o.rotation.y=-Math.PI/2,o.castShadow=!0,o.receiveShadow=!0,o.materialTexture=a,o.materialWireframe=s,o}function o(){i.loadCounter-=1,0===i.loadCounter&&i.onLoadComplete()}this.scale=1,this.animationFPS=6,this.root=new e.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,this.loadParts=function(n){this.loadCounter=2*n.weapons.length+n.skins.length+1;var h=[];for(let e=0;e<n.weapons.length;e++)h[e]=n.weapons[e][1];this.skinsBody=s(n.baseUrl+"skins/",n.skins),this.skinsWeapon=s(n.baseUrl+"skins/",h);var r=new t.MD2Loader;r.load(n.baseUrl+n.body,(function(t){var s=new e.Box3;s.setFromBufferAttribute(t.attributes.position),i.root.position.y=-i.scale*s.min.y;var n=a(t,i.skinsBody[0]);n.scale.set(i.scale,i.scale,i.scale),i.root.add(n),i.meshBody=n,i.meshBody.clipOffset=0,i.activeAnimationClipName=n.geometry.animations[0].name,i.mixer=new e.AnimationMixer(n),o()}));var m=function(e,t){return function(s){var n=a(s,i.skinsWeapon[e]);n.scale.set(i.scale,i.scale,i.scale),n.visible=!1,n.name=t,i.root.add(n),i.weapons[e]=n,i.meshWeapon=n,o()}};for(let e=0;e<n.weapons.length;e++)r.load(n.baseUrl+n.weapons[e][0],m(e,n.weapons[e][0]))},this.setPlaybackRate=function(e){this.mixer.timeScale=0!==e?1/e:0},this.setWireframe=function(e){e?(this.meshBody&&(this.meshBody.material=this.meshBody.materialWireframe),this.meshWeapon&&(this.meshWeapon.material=this.meshWeapon.materialWireframe)):(this.meshBody&&(this.meshBody.material=this.meshBody.materialTexture),this.meshWeapon&&(this.meshWeapon.material=this.meshWeapon.materialTexture))},this.setSkin=function(e){this.meshBody&&!1===this.meshBody.material.wireframe&&(this.meshBody.material.map=this.skinsBody[e])},this.setWeapon=function(e){for(let e=0;e<this.weapons.length;e++)this.weapons[e].visible=!1;var t=this.weapons[e];t&&(t.visible=!0,this.meshWeapon=t,i.syncWeaponAnimation())},this.setAnimation=function(e){if(this.meshBody){this.meshBody.activeAction&&(this.meshBody.activeAction.stop(),this.meshBody.activeAction=null);var t=this.mixer.clipAction(e,this.meshBody);t&&(this.meshBody.activeAction=t.play())}i.activeClipName=e,i.syncWeaponAnimation()},this.syncWeaponAnimation=function(){var e=i.activeClipName;if(i.meshWeapon){this.meshWeapon.activeAction&&(this.meshWeapon.activeAction.stop(),this.meshWeapon.activeAction=null);var t=this.mixer.clipAction(e,this.meshWeapon);t&&(this.meshWeapon.activeAction=t.syncWith(this.meshBody.activeAction).play())}},this.update=function(e){this.mixer&&this.mixer.update(e)}};

package/misc/MD2Character.js

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const MD2Loader = require("../loaders/MD2Loader.js");
-var MD2Character = function() {
+import { Object3D, Box3, AnimationMixer, TextureLoader, UVMapping, sRGBEncoding, MeshLambertMaterial, Mesh } from 'three';
+import { MD2Loader } from '../loaders/MD2Loader.js';
+
+var MD2Character = function () {
   var scope = this;
   this.scale = 1;
   this.animationFPS = 6;
-  this.root = new THREE.Object3D();
+  this.root = new Object3D();
   this.meshBody = null;
   this.meshWeapon = null;
   this.skinsBody = [];
@@ -14,19 +13,24 @@ var MD2Character = function() {
   this.weapons = [];
   this.activeAnimation = null;
   this.mixer = null;
-  this.onLoadComplete = function() {
-  };
+
+  this.onLoadComplete = function () {};
+
   this.loadCounter = 0;
-  this.loadParts = function(config) {
+
+  this.loadParts = function (config) {
     this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
     var 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);
-    var loader = new MD2Loader.MD2Loader();
-    loader.load(config.baseUrl + config.body, function(geo) {
-      var boundingBox = new THREE.Box3();
+
+    for (let 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();
+    loader.load(config.baseUrl + config.body, function (geo) {
+      var boundingBox = new Box3();
       boundingBox.setFromBufferAttribute(geo.attributes.position);
       scope.root.position.y = -scope.scale * boundingBox.min.y;
       var mesh = createPart(geo, scope.skinsBody[0]);
@@ -35,11 +39,12 @@ var MD2Character = function() {
       scope.meshBody = mesh;
       scope.meshBody.clipOffset = 0;
       scope.activeAnimationClipName = mesh.geometry.animations[0].name;
-      scope.mixer = new THREE.AnimationMixer(mesh);
+      scope.mixer = new AnimationMixer(mesh);
       checkLoadingComplete();
-    });
-    var generateCallback = function(index, name) {
-      return function(geo) {
+    }); // WEAPONS
+
+    var generateCallback = function (index, name) {
+      return function (geo) {
         var mesh = createPart(geo, scope.skinsWeapon[index]);
         mesh.scale.set(scope.scale, scope.scale, scope.scale);
         mesh.visible = false;
@@ -50,113 +55,130 @@ var MD2Character = function() {
         checkLoadingComplete();
       };
     };
+
     for (let i = 0; i < config.weapons.length; i++) {
       loader.load(config.baseUrl + config.weapons[i][0], generateCallback(i, config.weapons[i][0]));
     }
   };
-  this.setPlaybackRate = function(rate) {
+
+  this.setPlaybackRate = function (rate) {
     if (rate !== 0) {
       this.mixer.timeScale = 1 / rate;
     } else {
       this.mixer.timeScale = 0;
     }
   };
-  this.setWireframe = function(wireframeEnabled) {
+
+  this.setWireframe = function (wireframeEnabled) {
     if (wireframeEnabled) {
-      if (this.meshBody)
-        this.meshBody.material = this.meshBody.materialWireframe;
-      if (this.meshWeapon)
-        this.meshWeapon.material = this.meshWeapon.materialWireframe;
+      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;
+      if (this.meshBody) this.meshBody.material = this.meshBody.materialTexture;
+      if (this.meshWeapon) this.meshWeapon.material = this.meshWeapon.materialTexture;
     }
   };
-  this.setSkin = function(index) {
+
+  this.setSkin = function (index) {
     if (this.meshBody && this.meshBody.material.wireframe === false) {
       this.meshBody.material.map = this.skinsBody[index];
     }
   };
-  this.setWeapon = function(index) {
-    for (let i = 0; i < this.weapons.length; i++)
-      this.weapons[i].visible = false;
+
+  this.setWeapon = function (index) {
+    for (let 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;
       scope.syncWeaponAnimation();
     }
   };
-  this.setAnimation = function(clipName) {
+
+  this.setAnimation = function (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();
       }
     }
+
     scope.activeClipName = clipName;
     scope.syncWeaponAnimation();
   };
-  this.syncWeaponAnimation = function() {
+
+  this.syncWeaponAnimation = function () {
     var clipName = scope.activeClipName;
+
     if (scope.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();
       }
     }
   };
-  this.update = function(delta) {
-    if (this.mixer)
-      this.mixer.update(delta);
+
+  this.update = function (delta) {
+    if (this.mixer) this.mixer.update(delta);
   };
+
   function loadTextures(baseUrl, textureUrls) {
-    var textureLoader = new THREE.TextureLoader();
+    var textureLoader = new TextureLoader();
     var textures = [];
+
     for (let i = 0; i < textureUrls.length; i++) {
       textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
-      textures[i].mapping = THREE.UVMapping;
+      textures[i].mapping = UVMapping;
       textures[i].name = textureUrls[i];
-      textures[i].encoding = THREE.sRGBEncoding;
+      textures[i].encoding = sRGBEncoding;
     }
+
     return textures;
   }
+
   function createPart(geometry, skinMap) {
-    var materialWireframe = new THREE.MeshLambertMaterial({
-      color: 16755200,
+    var materialWireframe = new MeshLambertMaterial({
+      color: 0xffaa00,
       wireframe: true,
       morphTargets: true,
       morphNormals: true
     });
-    var materialTexture = new THREE.MeshLambertMaterial({
-      color: 16777215,
+    var materialTexture = new MeshLambertMaterial({
+      color: 0xffffff,
       wireframe: false,
       map: skinMap,
       morphTargets: true,
       morphNormals: true
-    });
-    var mesh = new THREE.Mesh(geometry, materialTexture);
+    }); //
+
+    var mesh = new Mesh(geometry, materialTexture);
     mesh.rotation.y = -Math.PI / 2;
     mesh.castShadow = true;
-    mesh.receiveShadow = true;
+    mesh.receiveShadow = true; //
+
     mesh.materialTexture = materialTexture;
     mesh.materialWireframe = materialWireframe;
     return mesh;
   }
+
   function checkLoadingComplete() {
     scope.loadCounter -= 1;
-    if (scope.loadCounter === 0)
-      scope.onLoadComplete();
+    if (scope.loadCounter === 0) scope.onLoadComplete();
   }
 };
-exports.MD2Character = MD2Character;
+
+export { MD2Character };