Merged in NRRPLT-7542_robot-designer-mirror (pull request #34)

[NRRPLT-7542] robot designer changes, prettify toolchain

Approved-by: Manos Angelidis <angelidis@fortiss.org>
Approved-by: Axel von Arnim <axel.vonarnim@fortiss.org>

.editorconfig

+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 2
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

.prettierignore

 package.json
 gz3d/utils/package.json
+gz3d/utils/Gruntfile.js
+gz3d/client/js
+bower_components
+node_modules
+build
+cmake
+gzbridge
+http
\ No newline at end of file

.prettierrc

+{
+  "singleQuote": true
+}

bower.json

 {
-  "name": "gz3d-hbp", 
-  "description": "3D rendering component of gzweb, modified for HBP", 
-  "version": "2.3.2", 
-  "private": true, 
+  "name": "gz3d-hbp",
+  "description": "3D rendering component of gzweb, modified for HBP",
+  "version": "2.3.2",
+  "private": true,
   "repository": {
-    "url": "git+ssh://bbpcode.epfl.ch/neurorobotics/gzweb", 
+    "url": "git+ssh://bbpcode.epfl.ch/neurorobotics/gzweb",
     "type": "git"
-  }, 
-  "main": [
-    "gz3d/build/gz3d.js"
-  ], 
+  },
+  "main": ["gz3d/build/gz3d.js"],
   "dependencies": {
-    "three.js": "threejs#r89", 
-    "eventemitter2": "latest", 
-    "xml2json": "latest", 
-    "roslibjs": "~0.17.0", 
+    "three.js": "threejs#r89",
+    "eventemitter2": "latest",
+    "xml2json": "latest",
+    "roslibjs": "~0.17.0",
     "lodash": "^4.15.0"
-  }, 
-  "keywords": [
-    "gzweb", 
-    "rendering", 
-    "webgl", 
-    "three.js", 
-    "hbp"
-  ], 
-  "authors": [
-    "Sandro Weber <webers@in.tum.de>"
-  ], 
+  },
+  "keywords": ["gzweb", "rendering", "webgl", "three.js", "hbp"],
+  "authors": ["Sandro Weber <webers@in.tum.de>"],
   "ignore": [
-    "**/.*", 
-    "bower_components/", 
-    "build/", 
-    "cmake/", 
-    "gz3d/client/js/external/", 
-    "gz3d/http/", 
-    "gz3d/src/", 
-    "gz3d/utils/", 
-    "gzbridge/", 
-    "hbp/", 
-    "http/", 
-    "node_modules/", 
-    "tools/", 
-    "Gruntfile.js", 
-    "package.json", 
-    "*.sh", 
-    "*.py", 
-    "*.html", 
-    "README", 
+    "**/.*",
+    "bower_components/",
+    "build/",
+    "cmake/",
+    "gz3d/client/js/external/",
+    "gz3d/http/",
+    "gz3d/src/",
+    "gz3d/utils/",
+    "gzbridge/",
+    "hbp/",
+    "http/",
+    "node_modules/",
+    "tools/",
+    "Gruntfile.js",
+    "package.json",
+    "*.sh",
+    "*.py",
+    "*.html",
+    "README",
     "CMakeLists.txt"
   ]
-}
+}
\ No newline at end of file

gz3d/src/ROSLIB.PhoenixRos.js

@@ -150,11 +150,11 @@
       }
     }
 
-    function setRoscmdListener(fn){
+    function setRoscmdListener(fn) {
       connections[url].roscmdListener = fn;
     }
 
-    function removeRoscmdListener(){
+    function removeRoscmdListener() {
       delete connections[url].roscmdListener;
     }
   }

gz3d/src/gz.js

 var GZ3D = GZ3D || {
-  REVISION : '1',
+  REVISION: '1',
   assetsPath: 'http://localhost:8080/assets',
   webSocketUrl: 'ws://localhost:7681',
   webSocketToken: undefined,
-  isRobot: function (model) {
+  isRobot: function(model) {
     return false;
   }
-};
+};
\ No newline at end of file

gz3d/src/gz3d-animated-models.js

-
 GZ3D.AnimatedModel = function(scene) {
   this.scene = scene;
   this.loader = null;
@@ -6,11 +5,13 @@ GZ3D.AnimatedModel = function(scene) {
 
 GZ3D.AnimatedModel.prototype.loadAnimatedModel = function(modelName) {
   this.loader = new THREE.ColladaLoader();
-  this.loader.textureLoadedCallback = ()=>{this.scene.refresh3DViews();};
+  this.loader.textureLoadedCallback = () => {
+    this.scene.refresh3DViews();
+  };
 
   // Helper function to enable 'skinning' property so three.js treats meshes as deformable
 
-  var enableSkinning = function (skinnedMesh) {
+  var enableSkinning = function(skinnedMesh) {
     var materials = skinnedMesh.material.materials;
     if (materials !== null && materials !== undefined) {
       for (var i = 0, length = materials.length; i < length; i++) {
@@ -35,121 +36,127 @@ GZ3D.AnimatedModel.prototype.loadAnimatedModel = function(modelName) {
   element.done = false;
   GZ3D.assetProgressData.assets.push(element);
   var scene = this.scene;
-  this.loader.load(element.url, function (collada) {
-    var modelParent = new THREE.Object3D();
-    modelParent.name = modelName + '_animated';
-    var linkParent = new THREE.Object3D();
-
-    // Set gray, phong-shaded material for loaded model
-    collada.scene.traverse(function (child)
-    {
-      if (child instanceof THREE.Mesh)
-      {
-        var applyDefaultMaterial = true;
-
-        if (child.material instanceof THREE.MultiMaterial)
-        {
-          if (child.material.materials[0].pbrMaterialDescription !== undefined)
-          {
-            child.material = child.material.materials[0];
+  this.loader.load(
+    element.url,
+    function(collada) {
+      var modelParent = new THREE.Object3D();
+      modelParent.name = modelName + '_animated';
+      var linkParent = new THREE.Object3D();
+
+      // Set gray, phong-shaded material for loaded model
+      collada.scene.traverse(function(child) {
+        if (child instanceof THREE.Mesh) {
+          var applyDefaultMaterial = true;
+
+          if (child.material instanceof THREE.MultiMaterial) {
+            if (
+              child.material.materials[0].pbrMaterialDescription !== undefined
+            ) {
+              child.material = child.material.materials[0];
+              applyDefaultMaterial = false;
+            }
+          } else if (child.material instanceof THREE.MeshPhongMaterial) {
             applyDefaultMaterial = false;
           }
-        }
-        else if (child.material instanceof THREE.MeshPhongMaterial)
-        {
-            applyDefaultMaterial = false;
-        }
 
-        if (applyDefaultMaterial)
-        {
-          var transparentMaterial = new THREE.MeshPhongMaterial({ color: 0x707070 });
-          transparentMaterial.wireframe = false;
-          child.material = transparentMaterial;
+          if (applyDefaultMaterial) {
+            var transparentMaterial = new THREE.MeshPhongMaterial({
+              color: 0x707070
+            });
+            transparentMaterial.wireframe = false;
+            child.material = transparentMaterial;
+          }
         }
-      }
-    });
+      });
 
-    // Enable skinning for all child meshes
-    collada.scene.traverse(function (child) {
-      if (child instanceof THREE.SkinnedMesh) {
-        enableSkinning(child);
-      }
-    });
+      // Enable skinning for all child meshes
+      collada.scene.traverse(function(child) {
+        if (child instanceof THREE.SkinnedMesh) {
+          enableSkinning(child);
+        }
+      });
 
-    linkParent.add(collada.scene);
+      linkParent.add(collada.scene);
 
-    // Hide model coordinate frames for the time being; remove as soon as position offset and rotation axis issues are fixed
-    /*var collada_scene_axes = new THREE.AxisHelper(2);
+      // Hide model coordinate frames for the time being; remove as soon as position offset and rotation axis issues are fixed
+      /*var collada_scene_axes = new THREE.AxisHelper(2);
      linkParent.add(collada_scene_axes);*/
 
-    modelParent.add(linkParent);
+      modelParent.add(linkParent);
 
-    // Hide model coordinate frames for the time being; remove as soon as position offset and rotation axis issues are fixed
-    /*var model_parent_axes = new THREE.AxisHelper(4);
+      // Hide model coordinate frames for the time being; remove as soon as position offset and rotation axis issues are fixed
+      /*var model_parent_axes = new THREE.AxisHelper(4);
      modelParent.add(model_parent_axes);*/
 
-    // Use scale, position, and rotation offsets provided in animated robot model specification
-    var p = GZ3D.animatedModel.visualModelParams;
-    modelParent.scale.x = modelParent.scale.y = modelParent.scale.z = p[6];
-    modelParent.position.x = modelParent.position.x + p[0] ;
-    modelParent.position.y = modelParent.position.y + p[1];
-    modelParent.position.z = modelParent.position.z + p[2];
-    modelParent.rotation.x = modelParent.rotation.x + p[3];
-    modelParent.rotation.y = modelParent.rotation.y + p[4];
-    modelParent.rotation.z = modelParent.rotation.z + p[5];
-
-    // Build list of bones in rig, and attach it to scene node (userData) for later retrieval in animation handling
-    var getBoneList = function (object) {
-      var boneList = [];
-
-      if (object instanceof THREE.Bone) {
-        boneList.push(object);
-      }
+      // Use scale, position, and rotation offsets provided in animated robot model specification
+      var p = GZ3D.animatedModel.visualModelParams;
+      modelParent.scale.x = modelParent.scale.y = modelParent.scale.z = p[6];
+      modelParent.position.x = modelParent.position.x + p[0];
+      modelParent.position.y = modelParent.position.y + p[1];
+      modelParent.position.z = modelParent.position.z + p[2];
+      modelParent.rotation.x = modelParent.rotation.x + p[3];
+      modelParent.rotation.y = modelParent.rotation.y + p[4];
+      modelParent.rotation.z = modelParent.rotation.z + p[5];
+
+      // Build list of bones in rig, and attach it to scene node (userData) for later retrieval in animation handling
+      var getBoneList = function(object) {
+        var boneList = [];
+
+        if (object instanceof THREE.Bone) {
+          boneList.push(object);
+        }
 
-      for (var i = 0; i < object.children.length; i++) {
-        boneList.push.apply(boneList, getBoneList(object.children[i]));
-      }
+        for (var i = 0; i < object.children.length; i++) {
+          boneList.push.apply(boneList, getBoneList(object.children[i]));
+        }
 
-      return boneList;
-    };
+        return boneList;
+      };
 
-    var boneList = getBoneList(collada.scene);
-    var boneHash = {};
-    for (var k = 0; k < boneList.length; k++) {
-      boneHash[boneList[k].name] = boneList[k];
-    }
-    // Skeleton visualization helper class
-    var helper = new THREE.SkeletonHelper(collada.scene);
+      var boneList = getBoneList(collada.scene);
+      var boneHash = {};
+      for (var k = 0; k < boneList.length; k++) {
+        boneHash[boneList[k].name] = boneList[k];
+      }
+      // Skeleton visualization helper class
+      var helper = new THREE.SkeletonHelper(collada.scene);
 
-    boneHash['Skeleton_Visual_Helper'] = helper;
-    modelParent.userData = boneHash;
+      boneHash['Skeleton_Visual_Helper'] = helper;
+      modelParent.userData = boneHash;
 
-    helper.material.linewidth = 3;
-    // Hide skeleton helper for the time being
-    // TODO: Make this configurable for visualizing the underlying skeleton
-    helper.visible = false;
+      helper.material.linewidth = 3;
+      // Hide skeleton helper for the time being
+      // TODO: Make this configurable for visualizing the underlying skeleton
+      helper.visible = false;
 
-    that.scene.add(helper);
-    that.scene.add(modelParent);
+      that.scene.add(helper);
+      that.scene.add(modelParent);
 
-    that.scene.applyComposerSettingsToModel(modelParent);
+      that.scene.applyComposerSettingsToModel(modelParent);
 
-    // Progress update: execute callback
-    element.done = true;
-    if (GZ3D.assetProgressCallback) {
-      GZ3D.assetProgressCallback(GZ3D.assetProgressData);
-    }
-  }, function(progress){
-    element.progress = progress.loaded;
-    element.totalSize = progress.total;
-    element.error = progress.error;
-    if (GZ3D.assetProgressCallback) {
-      GZ3D.assetProgressCallback(GZ3D.assetProgressData);
+      // Progress update: execute callback
+      element.done = true;
+      if (GZ3D.assetProgressCallback) {
+        GZ3D.assetProgressCallback(GZ3D.assetProgressData);
+      }
+    },
+    function(progress) {
+      element.progress = progress.loaded;
+      element.totalSize = progress.total;
+      element.error = progress.error;
+      if (GZ3D.assetProgressCallback) {
+        GZ3D.assetProgressCallback(GZ3D.assetProgressData);
+      }
     }
-  });
+  );
 };
 
-GZ3D.AnimatedModel.prototype.updateJoint = function(robotName, jointName, jointValue, jointAxis) {
+GZ3D.AnimatedModel.prototype.updateJoint = function(
+  robotName,
+  jointName,
+  jointValue,
+  jointAxis
+) {
   // Check if there is an animated model for it on the client side
   var entity = this.scene.getByName(robotName + '_animated');
   if (entity) {
@@ -157,7 +164,10 @@ GZ3D.AnimatedModel.prototype.updateJoint = function(robotName, jointName, jointV
       var boneName = jointName;
 
       // Retrieve bone instance from userData map of bone instances in animated model
-      if (entity.userData[boneName] !== undefined && entity.userData[boneName] !== null) {
+      if (
+        entity.userData[boneName] !== undefined &&
+        entity.userData[boneName] !== null
+      ) {
         var targetBone = entity.userData[boneName];
         var rotationAxis = jointAxis;
         var rotationAngle = jointValue;

gz3d/src/gz3d-muscle-vis.js

-
 GZ3D.VisualMuscleModel = function(scene, robotName) {
   this.scene = scene;
   this.cylinderShapes = {};
@@ -12,15 +11,12 @@ GZ3D.VisualMuscleModel = function(scene, robotName) {
 };
 
 GZ3D.VisualMuscleModel.prototype.setVisible = function(visible) {
-
   this.rootGroup.visible = visible;
 };
 
 GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
-
   if (message.robot_name === this.robotName) {
-    if (this.last_muscle_count !== message.muscle.length)
-    {
+    if (this.last_muscle_count !== message.muscle.length) {
       // Compute the radius as fraction of the average length of all cylinders.
       var total_length = 0;
       for (var k1 = 0; k1 < message.muscle.length; ++k1) {
@@ -41,9 +37,9 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
       var activation = message.muscle[k].activation;
       var color;
       if (message.muscle[k].isMuscle) {
-        color = new THREE.Color(activation, 0, 1-activation);
+        color = new THREE.Color(activation, 0, 1 - activation);
       } else {
-        color = new THREE.Color(activation, 1-activation, 0); // Path actuators are green.
+        color = new THREE.Color(activation, 1 - activation, 0); // Path actuators are green.
       }
       var num_segments = message.muscle[k].pathPoint.length - 1;
 
@@ -52,8 +48,8 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
       // It would result in superfluous visible geometry.
       if (!(k in this.cylinderShapes)) {
         this.cylinderShapes[k] = {
-          cylinders : [],
-          spheres : []
+          cylinders: [],
+          spheres: []
         };
       }
       let cylinders = this.cylinderShapes[k].cylinders;
@@ -61,11 +57,14 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
         // Create new cylinder on demand.
         if (cylinders.length <= cq) {
           let edgeGeometry = new THREE.CylinderBufferGeometry(1, 1, 1, 8, 1);
-          let cylinder = new THREE.Mesh(edgeGeometry, new THREE.MeshLambertMaterial({
-            color: color,
-            wireframe: false,
-            flatShading: THREE.FlatShading
-          }));
+          let cylinder = new THREE.Mesh(
+            edgeGeometry,
+            new THREE.MeshLambertMaterial({
+              color: color,
+              wireframe: false,
+              flatShading: THREE.FlatShading
+            })
+          );
           this.rootGroup.add(cylinder);
           cylinders.push(cylinder);
         }
@@ -76,25 +75,33 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
         cylinderEndPoint_1 = new THREE.Vector3(
           message.muscle[k].pathPoint[cq].x,
           message.muscle[k].pathPoint[cq].y,
-          message.muscle[k].pathPoint[cq].z);
+          message.muscle[k].pathPoint[cq].z
+        );
         cylinderEndPoint_2 = new THREE.Vector3(
           message.muscle[k].pathPoint[cq + 1].x,
           message.muscle[k].pathPoint[cq + 1].y,
-          message.muscle[k].pathPoint[cq + 1].z);
-        let cylinder_direction = new THREE.Vector3().subVectors(cylinderEndPoint_2, cylinderEndPoint_1);
+          message.muscle[k].pathPoint[cq + 1].z
+        );
+        let cylinder_direction = new THREE.Vector3().subVectors(
+          cylinderEndPoint_2,
+          cylinderEndPoint_1
+        );
         cylinder.material.color = color;
         cylinder.scale.y = cylinder_direction.length();
         cylinder.scale.x = radius;
         cylinder.scale.z = radius;
         cylinder_direction.normalize();
-        cylinder.quaternion.setFromUnitVectors(new THREE.Vector3(0,1,0), cylinder_direction);
+        cylinder.quaternion.setFromUnitVectors(
+          new THREE.Vector3(0, 1, 0),
+          cylinder_direction
+        );
         cylinder.position.x = (cylinderEndPoint_2.x + cylinderEndPoint_1.x) / 2;
         cylinder.position.y = (cylinderEndPoint_2.y + cylinderEndPoint_1.y) / 2;
         cylinder.position.z = (cylinderEndPoint_2.z + cylinderEndPoint_1.z) / 2;
       } // end for path points
       // I don't bother tracking how many segments were needed last time.
       // Simply loop over all superfluous segments and turn them all off.
-      for(; cq < cylinders.length; ++cq) {
+      for (; cq < cylinders.length; ++cq) {
         cylinders[cq].visible = false;
       }
       // Now the spheres!
@@ -103,11 +110,14 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
         // Create one if needed.
         if (spheres.length <= cq) {
           let geom = new THREE.SphereBufferGeometry(1, 8, 8);
-          let s = new THREE.Mesh(geom, new THREE.MeshLambertMaterial({
-            color: color,
-            wireframe: false,
-            flatShading: THREE.FlatShading
-          }));
+          let s = new THREE.Mesh(
+            geom,
+            new THREE.MeshLambertMaterial({
+              color: color,
+              wireframe: false,
+              flatShading: THREE.FlatShading
+            })
+          );
           this.rootGroup.add(s);
           spheres.push(s);
         }
@@ -118,14 +128,15 @@ GZ3D.VisualMuscleModel.prototype.updateVisualization = function(message) {
         let pos = new THREE.Vector3(
           message.muscle[k].pathPoint[cq].x,
           message.muscle[k].pathPoint[cq].y,
-          message.muscle[k].pathPoint[cq].z);
+          message.muscle[k].pathPoint[cq].z
+        );
         sphere.position.copy(pos);
         sphere.scale.x = radius;
         sphere.scale.y = radius;
         sphere.scale.z = radius;
       }
       // Turn off not needed ones.
-      for(; cq < spheres.length; ++cq) {
+      for (; cq < spheres.length; ++cq) {
         spheres[cq].visible = false;
       }
     } // end for message.muscle

gz3d/src/gzcomposersettings.js

@@ -16,45 +16,43 @@ GZ3D.MASTER_QUALITY_MINIMAL = 'Minimal';
 
 // Composer Settings
 
-GZ3D.ComposerSettings = function ()
-{
-    this.shadows = false;
-    this.antiAliasing = true;
+GZ3D.ComposerSettings = function() {
+  this.shadows = false;
+  this.antiAliasing = true;
 
-    this.ssao = false;                       // Screen space ambient occlusion
-    this.ssaoDisplay = false;
-    this.ssaoClamp = 0.8;
-    this.ssaoLumInfluence = 0.7;
+  this.ssao = false; // Screen space ambient occlusion
+  this.ssaoDisplay = false;
+  this.ssaoClamp = 0.8;
+  this.ssaoLumInfluence = 0.7;
 
-    this.rgbCurve = {'red':[],'green':[],'blue':[]};    // Color correction, disabled by default
+  this.rgbCurve = { red: [], green: [], blue: [] }; // Color correction, disabled by default
 
-    this.levelsInBlack = 0.0;     // Color levels
-    this.levelsInGamma = 1.0;
-    this.levelsInWhite = 1.0;
-    this.levelsOutBlack = 0.0;
-    this.levelsOutWhite = 1.0;
+  this.levelsInBlack = 0.0; // Color levels
+  this.levelsInGamma = 1.0;
+  this.levelsInWhite = 1.0;
+  this.levelsOutBlack = 0.0;
+  this.levelsOutWhite = 1.0;
 
-    this.skyBox = '';               // The file path of the sky box (without file extension) or empty string for plain color background
-    this.dynamicEnvMap = true;      // Environment map is generated at the beginning of the experiment
+  this.skyBox = ''; // The file path of the sky box (without file extension) or empty string for plain color background
+  this.dynamicEnvMap = true; // Environment map is generated at the beginning of the experiment
 
-    this.sun = '';                  // empty string for no sun or "SIMPLELENSFLARE" for simple lens flare rendering
+  this.sun = ''; // empty string for no sun or "SIMPLELENSFLARE" for simple lens flare rendering
 
-    this.bloom = false;             // Bloom
-    this.bloomStrength = 1.0;
-    this.bloomRadius = 0.37;
-    this.bloomThreshold = 0.98;
+  this.bloom = false; // Bloom
+  this.bloomStrength = 1.0;
+  this.bloomRadius = 0.37;
+  this.bloomThreshold = 0.98;
 
-    this.fog = false;               // Fog
-    this.fogDensity = 0.05;
-    this.fogColor = '#b2b2b2';      // CSS style
+  this.fog = false; // Fog
+  this.fogDensity = 0.05;
+  this.fogColor = '#b2b2b2'; // CSS style
 
-    this.pbrMaterial = true;       // Physically based material
+  this.pbrMaterial = true; // Physically based material
 
-    // User camera frustum settings
+  // User camera frustum settings
 
-    this.verticalFOV = 60.0;
-    this.nearClippingDistance = 0.15;
-    this.farClippingDistance = 100.0;
-    this.showCameraHelper = false;
+  this.verticalFOV = 60.0;
+  this.nearClippingDistance = 0.15;
+  this.farClippingDistance = 100.0;
+  this.showCameraHelper = false;
 };
-

gz3d/src/gzlevelsShader.js

@@ -4,57 +4,48 @@
  */
 
 GZ3D.LevelsShader = {
+  uniforms: {
+    tDiffuse: { value: null },
 
-	uniforms: {
+    // Levels parameters
 
-		'tDiffuse': { value: null },
+    inBlack: { value: 0.0 },
+    inWhite: { value: 1.0 },
+    inGamma: { value: 1.0 },
 
-		// Levels parameters
+    outBlack: { value: 0.0 },
+    outWhite: { value: 1.0 }
+  },
 
-		'inBlack': { value: 0.0 },
-		'inWhite': { value: 1.0 },
-		'inGamma': { value: 1.0 },
+  vertexShader: [
+    'varying vec2 vUv;',
 
-		'outBlack': { value: 0.0 },
-		'outWhite': { value: 1.0 },
-	},
+    'void main() {',
 
-	vertexShader: [
+    'vUv = uv;',
+    'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-		'varying vec2 vUv;',
+    '}'
+  ].join('\n'),
 
-		'void main() {',
+  fragmentShader: [
+    'uniform float inBlack,inWhite,inGamma,outBlack,outWhite;',
+    'uniform sampler2D tDiffuse;',
 
-		'vUv = uv;',
-		'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    'varying vec2 vUv;',
 
-		'}'
+    'void main() {',
 
-	].join('\n'),
+    'vec4 texel = texture2D( tDiffuse, vUv );',
 
-	fragmentShader: [
+    'float outf =  (outWhite - outBlack);',
 
-		'uniform float inBlack,inWhite,inGamma,outBlack,outWhite;',
-		'uniform sampler2D tDiffuse;',
+    'texel[0] = pow((texel[0] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
+    'texel[1] = pow((texel[1] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
+    'texel[2] = pow((texel[2] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
 
-		'varying vec2 vUv;',
-
-		'void main() {',
-
-		'vec4 texel = texture2D( tDiffuse, vUv );',
-
-		'float outf =  (outWhite - outBlack);',
-
-		'texel[0] = pow((texel[0] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
-		'texel[1] = pow((texel[1] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
-		'texel[2] = pow((texel[2] - inBlack) / (inWhite - inBlack),inGamma) * outf + outBlack;',
-
-		'gl_FragColor = texel;',
-
-		'}'
-
-	].join('\n')
+    'gl_FragColor = texel;',
 
+    '}'
+  ].join('\n')
 };
-
-