Include simplex-noise module in the node.js examples

Super useful!

examples/node/node_modules/simplex-noise/.jshintrc

+{
+    "predef": [
+        'define'
+    ],
+    "browser" : true,
+    "node" : true,
+    "jquery" : true,
+    "boss" : true,
+    "eqeqeq": false,
+    "evil": false,
+    "eqnull": true,
+    "forin": false,
+    "laxbreak": false,
+    "newcap": true,
+    "noarg": true,
+    "noempty": false,
+    "nonew": false,
+    "nomen": false,
+    "plusplus": false,
+    "regexp": false,
+    "undef": true,
+    "sub": true,
+    "strict": false,
+    "white": false,
+    "latedef": false
+}

examples/node/node_modules/simplex-noise/.npmignore

+node_modules

examples/node/node_modules/simplex-noise/Makefile

+all: tests simplex-noise.min.js
+
+tests:
+	jshint simplex-noise.js
+	./node_modules/buster/bin/buster test
+
+
+simplex-noise.min.js: simplex-noise.js
+	echo "/*! simplex-noise.js: copyright 2012 Jonas Wagner, licensed under a MIT license. See https://github.com/jwagner/simplex-noise.js for details */" > simplex-noise.min.js
+	uglifyjs -nc --unsafe < simplex-noise.js >> simplex-noise.min.js

examples/node/node_modules/simplex-noise/README.md

+# simplex-noise.js
+
+simplex-noise.js is a fast simplex noise implementation in Javascript. It works in the browser and on nodejs.
+
+## Requirements
+
+It requires typed arrays, if you want to use it in browsers without support
+you will need to use a polyfill like [typedarray.js](http://www.calormen.com/polyfill/typedarray.js).
+
+## Demo
+Simple 2D plasma demo on [jsfiddle.net](http://jsfiddle.net/UL69K/5/).
+
+## Usage
+
+```javascript
+// initializing a simplex instance
+// do this only once it's relatively expensive
+var simplex = new SimplexNoise(),
+    value2d = simplex.noise2D(x, y),
+    value3d = simplex.noise3D(x, y, z),
+    value4d = simplex.noise2D(x, y, z, w);
+```
+
+You can also pass an alternative random function to the constructor that is
+used to build the permutation table:
+
+```javascript
+var simplex = new SimplexNoise(Math.random),
+    value2d = simplex.noise2D(x, y);
+```
+
+## node.js
+
+Node.js is also supported, you can install the package using [npm](https://npmjs.org/package/simplex-noise).
+
+```javascript
+var SimplexNoise = require('simplex-noise'),
+    simplex = new SimplexNoise(Math.random),
+    value2d = simplex.noise2D(x, y);
+```
+
+## Benchmarks
+
+- [Comparison between 2D and 3D noise](http://jsperf.com/simplex-noise/2)
+- [Comparison with simplex implementation in three.js](http://jsperf.com/simplex-noise-comparison)
+
+## Tests
+
+There are some simple buster.js tests for this library to run them first install buster.js and jshint:
+```shell
+npm install buster.js
+# if you haven't done so already
+npm install -g jshint
+make tests
+```
+
+## Changelog
+
+### 2.1.1
+- Increased entropy by fixing a little initialization issue.
+
+### 2.1.0
+- AMD support
+
+### 2.0.0
+- Changed node.js api, SimplexNoise is now exported directly.
+- Added unit tests
+
+### 1.0.0
+- Initial Release
+
+## Credits
+
+This is mostly a direct javascript port of the [Java implementation](http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java)
+by Stefan Gustavson and Peter Eastman.

examples/node/node_modules/simplex-noise/package.json

+{
+  "name": "simplex-noise",
+  "version": "2.1.1",
+  "description": "simplex-noise is a fast simplex noise implementation in Javascript.",
+  "homepage": "https://github.com/jwagner/simplex-noise.js",
+  "author": {
+    "name": "Jonas Wagner",
+    "email": "jonas@29a.ch",
+    "url": "http://29a.ch/"
+  },
+  "main": "./simplex-noise",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jwagner/simplex-noise.js.git"
+  },
+  "readme": "# simplex-noise.js\n\nsimplex-noise.js is a fast simplex noise implementation in Javascript. It works in the browser and on nodejs.\n\n## Requirements\n\nIt requires typed arrays, if you want to use it in browsers without support\nyou will need to use a polyfill like [typedarray.js](http://www.calormen.com/polyfill/typedarray.js).\n\n## Demo\nSimple 2D plasma demo on [jsfiddle.net](http://jsfiddle.net/UL69K/5/).\n\n## Usage\n\n```javascript\n// initializing a simplex instance\n// do this only once it's relatively expensive\nvar simplex = new SimplexNoise(),\n    value2d = simplex.noise2D(x, y),\n    value3d = simplex.noise3D(x, y, z),\n    value4d = simplex.noise2D(x, y, z, w);\n```\n\nYou can also pass an alternative random function to the constructor that is\nused to build the permutation table:\n\n```javascript\nvar simplex = new SimplexNoise(Math.random),\n    value2d = simplex.noise2D(x, y);\n```\n\n## node.js\n\nNode.js is also supported, you can install the package using [npm](https://npmjs.org/package/simplex-noise).\n\n```javascript\nvar SimplexNoise = require('simplex-noise'),\n    simplex = new SimplexNoise(Math.random),\n    value2d = simplex.noise2D(x, y);\n```\n\n## Benchmarks\n\n- [Comparison between 2D and 3D noise](http://jsperf.com/simplex-noise/2)\n- [Comparison with simplex implementation in three.js](http://jsperf.com/simplex-noise-comparison)\n\n## Tests\n\nThere are some simple buster.js tests for this library to run them first install buster.js and jshint:\n```shell\nnpm install buster.js\n# if you haven't done so already\nnpm install -g jshint\nmake tests\n```\n\n## Changelog\n\n### 2.1.1\n- Increased entropy by fixing a little initialization issue.\n\n### 2.1.0\n- AMD support\n\n### 2.0.0\n- Changed node.js api, SimplexNoise is now exported directly.\n- Added unit tests\n\n### 1.0.0\n- Initial Release\n\n## Credits\n\nThis is mostly a direct javascript port of the [Java implementation](http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java)\nby Stefan Gustavson and Peter Eastman.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/jwagner/simplex-noise.js/issues"
+  },
+  "_id": "simplex-noise@2.1.1",
+  "dist": {
+    "shasum": "d9e89da95ca137f7c42778c9f9da6d44f8899b78"
+  },
+  "_from": "simplex-noise@",
+  "_resolved": "https://registry.npmjs.org/simplex-noise/-/simplex-noise-2.1.1.tgz"
+}

examples/node/node_modules/simplex-noise/simplex-noise.js

+/*
+ * A fast javascript implementation of simplex noise by Jonas Wagner
+ *
+ * Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
+ * Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
+ * With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+ * Better rank ordering method by Stefan Gustavson in 2012.
+ *
+ *
+ * Copyright (C) 2012 Jonas Wagner
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+(function () {
+
+var F2 = 0.5 * (Math.sqrt(3.0) - 1.0),
+    G2 = (3.0 - Math.sqrt(3.0)) / 6.0,
+    F3 = 1.0 / 3.0,
+    G3 = 1.0 / 6.0,
+    F4 = (Math.sqrt(5.0) - 1.0) / 4.0,
+    G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+
+
+function SimplexNoise(random) {
+    if (!random) random = Math.random;
+    this.p = new Uint8Array(256);
+    this.perm = new Uint8Array(512);
+    this.permMod12 = new Uint8Array(512);
+    for (var i = 0; i < 256; i++) {
+        this.p[i] = random() * 256;
+    }
+    for (i = 0; i < 512; i++) {
+        this.perm[i] = this.p[i & 255];
+        this.permMod12[i] = this.perm[i] % 12;
+    }
+
+}
+SimplexNoise.prototype = {
+    grad3: new Float32Array([1, 1, 0,
+                            - 1, 1, 0,
+                            1, - 1, 0,
+
+                            - 1, - 1, 0,
+                            1, 0, 1,
+                            - 1, 0, 1,
+
+                            1, 0, - 1,
+                            - 1, 0, - 1,
+                            0, 1, 1,
+
+                            0, - 1, 1,
+                            0, 1, - 1,
+                            0, - 1, - 1]),
+    grad4: new Float32Array([0, 1, 1, 1, 0, 1, 1, - 1, 0, 1, - 1, 1, 0, 1, - 1, - 1,
+                            0, - 1, 1, 1, 0, - 1, 1, - 1, 0, - 1, - 1, 1, 0, - 1, - 1, - 1,
+                            1, 0, 1, 1, 1, 0, 1, - 1, 1, 0, - 1, 1, 1, 0, - 1, - 1,
+                            - 1, 0, 1, 1, - 1, 0, 1, - 1, - 1, 0, - 1, 1, - 1, 0, - 1, - 1,
+                            1, 1, 0, 1, 1, 1, 0, - 1, 1, - 1, 0, 1, 1, - 1, 0, - 1,
+                            - 1, 1, 0, 1, - 1, 1, 0, - 1, - 1, - 1, 0, 1, - 1, - 1, 0, - 1,
+                            1, 1, 1, 0, 1, 1, - 1, 0, 1, - 1, 1, 0, 1, - 1, - 1, 0,
+                            - 1, 1, 1, 0, - 1, 1, - 1, 0, - 1, - 1, 1, 0, - 1, - 1, - 1, 0]),
+    noise2D: function (xin, yin) {
+        var permMod12 = this.permMod12,
+            perm = this.perm,
+            grad3 = this.grad3;
+        var n0, n1, n2; // Noise contributions from the three corners
+        // Skew the input space to determine which simplex cell we're in
+        var s = (xin + yin) * F2; // Hairy factor for 2D
+        var i = Math.floor(xin + s);
+        var j = Math.floor(yin + s);
+        var t = (i + j) * G2;
+        var X0 = i - t; // Unskew the cell origin back to (x,y) space
+        var Y0 = j - t;
+        var x0 = xin - X0; // The x,y distances from the cell origin
+        var y0 = yin - Y0;
+        // For the 2D case, the simplex shape is an equilateral triangle.
+        // Determine which simplex we are in.
+        var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+        if (x0 > y0) {
+            i1 = 1;
+            j1 = 0;
+        } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+        else {
+            i1 = 0;
+            j1 = 1;
+        } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+        // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+        // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+        // c = (3-sqrt(3))/6
+        var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+        var y1 = y0 - j1 + G2;
+        var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+        var y2 = y0 - 1.0 + 2.0 * G2;
+        // Work out the hashed gradient indices of the three simplex corners
+        var ii = i & 255;
+        var jj = j & 255;
+        // Calculate the contribution from the three corners
+        var t0 = 0.5 - x0 * x0 - y0 * y0;
+        if (t0 < 0) n0 = 0.0;
+        else {
+            var gi0 = permMod12[ii + perm[jj]] * 3;
+            t0 *= t0;
+            n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
+        }
+        var t1 = 0.5 - x1 * x1 - y1 * y1;
+        if (t1 < 0) n1 = 0.0;
+        else {
+            var gi1 = permMod12[ii + i1 + perm[jj + j1]] * 3;
+            t1 *= t1;
+            n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1);
+        }
+        var t2 = 0.5 - x2 * x2 - y2 * y2;
+        if (t2 < 0) n2 = 0.0;
+        else {
+            var gi2 = permMod12[ii + 1 + perm[jj + 1]] * 3;
+            t2 *= t2;
+            n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2);
+        }
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to return values in the interval [-1,1].
+        return 70.0 * (n0 + n1 + n2);
+    },
+    // 3D simplex noise
+    noise3D: function (xin, yin, zin) {
+        var permMod12 = this.permMod12,
+            perm = this.perm,
+            grad3 = this.grad3;
+        var n0, n1, n2, n3; // Noise contributions from the four corners
+        // Skew the input space to determine which simplex cell we're in
+        var s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
+        var i = Math.floor(xin + s);
+        var j = Math.floor(yin + s);
+        var k = Math.floor(zin + s);
+        var t = (i + j + k) * G3;
+        var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+        var Y0 = j - t;
+        var Z0 = k - t;
+        var x0 = xin - X0; // The x,y,z distances from the cell origin
+        var y0 = yin - Y0;
+        var z0 = zin - Z0;
+        // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
+        // Determine which simplex we are in.
+        var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
+        var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
+        if (x0 >= y0) {
+            if (y0 >= z0) {
+                i1 = 1;
+                j1 = 0;
+                k1 = 0;
+                i2 = 1;
+                j2 = 1;
+                k2 = 0;
+            } // X Y Z order
+            else if (x0 >= z0) {
+                i1 = 1;
+                j1 = 0;
+                k1 = 0;
+                i2 = 1;
+                j2 = 0;
+                k2 = 1;
+            } // X Z Y order
+            else {
+                i1 = 0;
+                j1 = 0;
+                k1 = 1;
+                i2 = 1;
+                j2 = 0;
+                k2 = 1;
+            } // Z X Y order
+        }
+        else { // x0<y0
+            if (y0 < z0) {
+                i1 = 0;
+                j1 = 0;
+                k1 = 1;
+                i2 = 0;
+                j2 = 1;
+                k2 = 1;
+            } // Z Y X order
+            else if (x0 < z0) {
+                i1 = 0;
+                j1 = 1;
+                k1 = 0;
+                i2 = 0;
+                j2 = 1;
+                k2 = 1;
+            } // Y Z X order
+            else {
+                i1 = 0;
+                j1 = 1;
+                k1 = 0;
+                i2 = 1;
+                j2 = 1;
+                k2 = 0;
+            } // Y X Z order
+        }
+        // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
+        // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
+        // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
+        // c = 1/6.
+        var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+        var y1 = y0 - j1 + G3;
+        var z1 = z0 - k1 + G3;
+        var x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+        var y2 = y0 - j2 + 2.0 * G3;
+        var z2 = z0 - k2 + 2.0 * G3;
+        var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+        var y3 = y0 - 1.0 + 3.0 * G3;
+        var z3 = z0 - 1.0 + 3.0 * G3;
+        // Work out the hashed gradient indices of the four simplex corners
+        var ii = i & 255;
+        var jj = j & 255;
+        var kk = k & 255;
+        // Calculate the contribution from the four corners
+        var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+        if (t0 < 0) n0 = 0.0;
+        else {
+            var gi0 = permMod12[ii + perm[jj + perm[kk]]] * 3;
+            t0 *= t0;
+            n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0 + grad3[gi0 + 2] * z0);
+        }
+        var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+        if (t1 < 0) n1 = 0.0;
+        else {
+            var gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
+            t1 *= t1;
+            n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1 + grad3[gi1 + 2] * z1);
+        }
+        var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+        if (t2 < 0) n2 = 0.0;
+        else {
+            var gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
+            t2 *= t2;
+            n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2 + grad3[gi2 + 2] * z2);
+        }
+        var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+        if (t3 < 0) n3 = 0.0;
+        else {
+            var gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
+            t3 *= t3;
+            n3 = t3 * t3 * (grad3[gi3] * x3 + grad3[gi3 + 1] * y3 + grad3[gi3 + 2] * z3);
+        }
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to stay just inside [-1,1]
+        return 32.0 * (n0 + n1 + n2 + n3);
+    },
+    // 4D simplex noise, better simplex rank ordering method 2012-03-09
+    noise4D: function (x, y, z, w) {
+        var permMod12 = this.permMod12,
+            perm = this.perm,
+            grad4 = this.grad4;
+
+        var n0, n1, n2, n3, n4; // Noise contributions from the five corners
+        // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
+        var s = (x + y + z + w) * F4; // Factor for 4D skewing
+        var i = Math.floor(x + s);
+        var j = Math.floor(y + s);
+        var k = Math.floor(z + s);
+        var l = Math.floor(w + s);
+        var t = (i + j + k + l) * G4; // Factor for 4D unskewing
+        var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+        var Y0 = j - t;
+        var Z0 = k - t;
+        var W0 = l - t;
+        var x0 = x - X0; // The x,y,z,w distances from the cell origin
+        var y0 = y - Y0;
+        var z0 = z - Z0;
+        var w0 = w - W0;
+        // For the 4D case, the simplex is a 4D shape I won't even try to describe.
+        // To find out which of the 24 possible simplices we're in, we need to
+        // determine the magnitude ordering of x0, y0, z0 and w0.
+        // Six pair-wise comparisons are performed between each possible pair
+        // of the four coordinates, and the results are used to rank the numbers.
+        var rankx = 0;
+        var ranky = 0;
+        var rankz = 0;
+        var rankw = 0;
+        if (x0 > y0) rankx++;
+        else ranky++;
+        if (x0 > z0) rankx++;
+        else rankz++;
+        if (x0 > w0) rankx++;
+        else rankw++;
+        if (y0 > z0) ranky++;
+        else rankz++;
+        if (y0 > w0) ranky++;
+        else rankw++;
+        if (z0 > w0) rankz++;
+        else rankw++;
+        var i1, j1, k1, l1; // The integer offsets for the second simplex corner
+        var i2, j2, k2, l2; // The integer offsets for the third simplex corner
+        var i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
+        // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
+        // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
+        // impossible. Only the 24 indices which have non-zero entries make any sense.
+        // We use a thresholding to set the coordinates in turn from the largest magnitude.
+        // Rank 3 denotes the largest coordinate.
+        i1 = rankx >= 3 ? 1 : 0;
+        j1 = ranky >= 3 ? 1 : 0;
+        k1 = rankz >= 3 ? 1 : 0;
+        l1 = rankw >= 3 ? 1 : 0;
+        // Rank 2 denotes the second largest coordinate.
+        i2 = rankx >= 2 ? 1 : 0;
+        j2 = ranky >= 2 ? 1 : 0;
+        k2 = rankz >= 2 ? 1 : 0;
+        l2 = rankw >= 2 ? 1 : 0;
+        // Rank 1 denotes the second smallest coordinate.
+        i3 = rankx >= 1 ? 1 : 0;
+        j3 = ranky >= 1 ? 1 : 0;
+        k3 = rankz >= 1 ? 1 : 0;
+        l3 = rankw >= 1 ? 1 : 0;
+        // The fifth corner has all coordinate offsets = 1, so no need to compute that.
+        var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+        var y1 = y0 - j1 + G4;
+        var z1 = z0 - k1 + G4;
+        var w1 = w0 - l1 + G4;
+        var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+        var y2 = y0 - j2 + 2.0 * G4;
+        var z2 = z0 - k2 + 2.0 * G4;
+        var w2 = w0 - l2 + 2.0 * G4;
+        var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+        var y3 = y0 - j3 + 3.0 * G4;
+        var z3 = z0 - k3 + 3.0 * G4;
+        var w3 = w0 - l3 + 3.0 * G4;
+        var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+        var y4 = y0 - 1.0 + 4.0 * G4;
+        var z4 = z0 - 1.0 + 4.0 * G4;
+        var w4 = w0 - 1.0 + 4.0 * G4;
+        // Work out the hashed gradient indices of the five simplex corners
+        var ii = i & 255;
+        var jj = j & 255;
+        var kk = k & 255;
+        var ll = l & 255;
+        // Calculate the contribution from the five corners
+        var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+        if (t0 < 0) n0 = 0.0;
+        else {
+            var gi0 = (perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32) * 4;
+            t0 *= t0;
+            n0 = t0 * t0 * (grad4[gi0] * x0 + grad4[gi0 + 1] * y0 + grad4[gi0 + 2] * z0 + grad4[gi0 + 3] * w0);
+        }
+        var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+        if (t1 < 0) n1 = 0.0;
+        else {
+            var gi1 = (perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32) * 4;
+            t1 *= t1;
+            n1 = t1 * t1 * (grad4[gi1] * x1 + grad4[gi1 + 1] * y1 + grad4[gi1 + 2] * z1 + grad4[gi1 + 3] * w1);
+        }
+        var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+        if (t2 < 0) n2 = 0.0;
+        else {
+            var gi2 = (perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32) * 4;
+            t2 *= t2;
+            n2 = t2 * t2 * (grad4[gi2] * x2 + grad4[gi2 + 1] * y2 + grad4[gi2 + 2] * z2 + grad4[gi2 + 3] * w2);
+        }
+        var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+        if (t3 < 0) n3 = 0.0;
+        else {
+            var gi3 = (perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32) * 4;
+            t3 *= t3;
+            n3 = t3 * t3 * (grad4[gi3] * x3 + grad4[gi3 + 1] * y3 + grad4[gi3 + 2] * z3 + grad4[gi3 + 3] * w3);
+        }
+        var t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+        if (t4 < 0) n4 = 0.0;
+        else {
+            var gi4 = (perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32) * 4;
+            t4 *= t4;
+            n4 = t4 * t4 * (grad4[gi4] * x4 + grad4[gi4 + 1] * y4 + grad4[gi4 + 2] * z4 + grad4[gi4 + 3] * w4);
+        }
+        // Sum up and scale the result to cover the range [-1,1]
+        return 27.0 * (n0 + n1 + n2 + n3 + n4);
+    }
+
+
+};
+
+// amd
+if (typeof define !== 'undefined' && define.amd) define(function(){return SimplexNoise;});
+// browser
+else if (typeof window !== 'undefined') window.SimplexNoise = SimplexNoise;
+//common js
+if (typeof exports !== 'undefined') exports.SimplexNoise = SimplexNoise;
+// nodejs
+if (typeof module !== 'undefined') {
+    module.exports = SimplexNoise;
+}
+
+})();

examples/node/node_modules/simplex-noise/simplex-noise.min.js

+/*! copyright 2012 Jonas Wagner, licensed under a MIT license. See https://github.com/jwagner/simplex-noise.js for details */
+(function(){function g(a){a||(a=Math.random),this.p=new Uint8Array(256),this.perm=new Uint8Array(512),this.permMod12=new Uint8Array(512);for(var b=0;b<256;b++)this.p[b]=a()*256;for(b=0;b<512;b++)this.perm[b]=this.p[b&255],this.permMod12[b]=this.perm[b]%12}var a=.5*(Math.sqrt(3)-1),b=(3-Math.sqrt(3))/6,c=1/3,d=1/6,e=(Math.sqrt(5)-1)/4,f=(5-Math.sqrt(5))/20;g.prototype={grad3:new Float32Array([1,1,0,-1,1,0,1,-1,0,-1,-1,0,1,0,1,-1,0,1,1,0,-1,-1,0,-1,0,1,1,0,-1,1,0,1,-1,0,-1,-1]),grad4:new Float32Array([0,1,1,1,0,1,1,-1,0,1,-1,1,0,1,-1,-1,0,-1,1,1,0,-1,1,-1,0,-1,-1,1,0,-1,-1,-1,1,0,1,1,1,0,1,-1,1,0,-1,1,1,0,-1,-1,-1,0,1,1,-1,0,1,-1,-1,0,-1,1,-1,0,-1,-1,1,1,0,1,1,1,0,-1,1,-1,0,1,1,-1,0,-1,-1,1,0,1,-1,1,0,-1,-1,-1,0,1,-1,-1,0,-1,1,1,1,0,1,1,-1,0,1,-1,1,0,1,-1,-1,0,-1,1,1,0,-1,1,-1,0,-1,-1,1,0,-1,-1,-1,0]),noise2D:function(c,d){var e=this.permMod12,f=this.perm,g=this.grad3,h,i,j,k=(c+d)*a,l=Math.floor(c+k),m=Math.floor(d+k),n=(l+m)*b,o=l-n,p=m-n,q=c-o,r=d-p,s,t;q>r?(s=1,t=0):(s=0,t=1);var u=q-s+b,v=r-t+b,w=q-1+2*b,x=r-1+2*b,y=l&255,z=m&255,A=.5-q*q-r*r;if(A<0)h=0;else{var B=e[y+f[z]]*3;A*=A,h=A*A*(g[B]*q+g[B+1]*r)}var C=.5-u*u-v*v;if(C<0)i=0;else{var D=e[y+s+f[z+t]]*3;C*=C,i=C*C*(g[D]*u+g[D+1]*v)}var E=.5-w*w-x*x;if(E<0)j=0;else{var F=e[y+1+f[z+1]]*3;E*=E,j=E*E*(g[F]*w+g[F+1]*x)}return 70*(h+i+j)},noise3D:function(a,b,e){var f=this.permMod12,g=this.perm,h=this.grad3,i,j,k,l,m=(a+b+e)*c,n=Math.floor(a+m),o=Math.floor(b+m),p=Math.floor(e+m),q=(n+o+p)*d,r=n-q,s=o-q,t=p-q,u=a-r,v=b-s,w=e-t,x,y,z,A,B,C;u<v?v<w?(x=0,y=0,z=1,A=0,B=1,C=1):u<w?(x=0,y=1,z=0,A=0,B=1,C=1):(x=0,y=1,z=0,A=1,B=1,C=0):v<w?u<w?(x=0,y=0,z=1,A=1,B=0,C=1):(x=1,y=0,z=0,A=1,B=0,C=1):(x=1,y=0,z=0,A=1,B=1,C=0);var D=u-x+d,E=v-y+d,F=w-z+d,G=u-A+2*d,H=v-B+2*d,I=w-C+2*d,J=u-1+3*d,K=v-1+3*d,L=w-1+3*d,M=n&255,N=o&255,O=p&255,P=.6-u*u-v*v-w*w;if(P<0)i=0;else{var Q=f[M+g[N+g[O]]]*3;P*=P,i=P*P*(h[Q]*u+h[Q+1]*v+h[Q+2]*w)}var R=.6-D*D-E*E-F*F;if(R<0)j=0;else{var S=f[M+x+g[N+y+g[O+z]]]*3;R*=R,j=R*R*(h[S]*D+h[S+1]*E+h[S+2]*F)}var T=.6-G*G-H*H-I*I;if(T<0)k=0;else{var U=f[M+A+g[N+B+g[O+C]]]*3;T*=T,k=T*T*(h[U]*G+h[U+1]*H+h[U+2]*I)}var V=.6-J*J-K*K-L*L;if(V<0)l=0;else{var W=f[M+1+g[N+1+g[O+1]]]*3;V*=V,l=V*V*(h[W]*J+h[W+1]*K+h[W+2]*L)}return 32*(i+j+k+l)},noise4D:function(a,b,c,d){var g=this.permMod12,h=this.perm,i=this.grad4,j,k,l,m,n,o=(a+b+c+d)*e,p=Math.floor(a+o),q=Math.floor(b+o),r=Math.floor(c+o),s=Math.floor(d+o),t=(p+q+r+s)*f,u=p-t,v=q-t,w=r-t,x=s-t,y=a-u,z=b-v,A=c-w,B=d-x,C=0,D=0,E=0,F=0;y>z?C++:D++,y>A?C++:E++,y>B?C++:F++,z>A?D++:E++,z>B?D++:F++,A>B?E++:F++;var G,H,I,J,K,L,M,N,O,P,Q,R;G=C>=3?1:0,H=D>=3?1:0,I=E>=3?1:0,J=F>=3?1:0,K=C>=2?1:0,L=D>=2?1:0,M=E>=2?1:0,N=F>=2?1:0,O=C>=1?1:0,P=D>=1?1:0,Q=E>=1?1:0,R=F>=1?1:0;var S=y-G+f,T=z-H+f,U=A-I+f,V=B-J+f,W=y-K+2*f,X=z-L+2*f,Y=A-M+2*f,Z=B-N+2*f,$=y-O+3*f,_=z-P+3*f,ba=A-Q+3*f,bb=B-R+3*f,bc=y-1+4*f,bd=z-1+4*f,be=A-1+4*f,bf=B-1+4*f,bg=p&255,bh=q&255,bi=r&255,bj=s&255,bk=.6-y*y-z*z-A*A-B*B;if(bk<0)j=0;else{var bl=h[bg+h[bh+h[bi+h[bj]]]]%32*4;bk*=bk,j=bk*bk*(i[bl]*y+i[bl+1]*z+i[bl+2]*A+i[bl+3]*B)}var bm=.6-S*S-T*T-U*U-V*V;if(bm<0)k=0;else{var bn=h[bg+G+h[bh+H+h[bi+I+h[bj+J]]]]%32*4;bm*=bm,k=bm*bm*(i[bn]*S+i[bn+1]*T+i[bn+2]*U+i[bn+3]*V)}var bo=.6-W*W-X*X-Y*Y-Z*Z;if(bo<0)l=0;else{var bp=h[bg+K+h[bh+L+h[bi+M+h[bj+N]]]]%32*4;bo*=bo,l=bo*bo*(i[bp]*W+i[bp+1]*X+i[bp+2]*Y+i[bp+3]*Z)}var bq=.6-$*$-_*_-ba*ba-bb*bb;if(bq<0)m=0;else{var br=h[bg+O+h[bh+P+h[bi+Q+h[bj+R]]]]%32*4;bq*=bq,m=bq*bq*(i[br]*$+i[br+1]*_+i[br+2]*ba+i[br+3]*bb)}var bs=.6-bc*bc-bd*bd-be*be-bf*bf;if(bs<0)n=0;else{var bt=h[bg+1+h[bh+1+h[bi+1+h[bj+1]]]]%32*4;bs*=bs,n=bs*bs*(i[bt]*bc+i[bt+1]*bd+i[bt+2]*be+i[bt+3]*bf)}return 27*(j+k+l+m+n)}},typeof window!="undefined"&&(window.SimplexNoise=g),typeof exports!="undefined"&&(exports.SimplexNoise=g),typeof module!="undefined"&&(module.exports=g)})()
\ No newline at end of file

examples/node/node_modules/simplex-noise/test/buster.js

+var config = module.exports;
+
+config["tests"] = {
+    rootPath: '../',
+    environment: 'node',
+    sources: ['simplex-noise.js'],
+    tests: ['test/*-test.js']
+};

examples/node/node_modules/simplex-noise/test/simplex-noise-test.js

+if(typeof require !== 'undefined'){
+    var buster = require("buster");
+    var SimplexNoise = require("../simplex-noise");
+}
+
+var assert = buster.assertions.assert,
+    refute = buster.assertions.refute;
+
+var _rnd;
+function random(){
+    return 1.0/(_rnd++);
+}
+
+buster.testCase("simplex-noise", {
+    setUp: function() {_rnd = 0;},
+    "should initialize with Math.random": function () {
+        var simplex = new SimplexNoise();
+        assert.equals(simplex.perm.length, 512);
+        assert.equals(simplex.permMod12.length, 512);
+        for(var i = 0; i < 512; i++){
+            assert(simplex.perm[i] < 256);
+            assert(simplex.perm[i] >= 0);
+            assert(simplex.perm[i] >= 0);
+            assert.equals(simplex.perm[i], simplex.perm[i&255]);
+            assert.equals(simplex.permMod12[i], simplex.perm[i]%12);
+        }
+    },
+    "should initialize with a custom random function": function () {
+        var i = 2,
+            simplex = new SimplexNoise(function(){return 1.0/i++;});
+            assert.equals(simplex.perm.length, 512);
+            assert.equals(simplex.permMod12.length, 512);
+            assert.equals(simplex.perm[0], 128);
+            assert.equals(simplex.perm[1], 85);
+            assert.equals(simplex.perm[256], 128);
+            assert.equals(simplex.perm[257], 85);
+            assert.equals(simplex.permMod12[0], 128%12);
+            assert.equals(simplex.permMod12[1], 85%12);
+    },
+    'noise': {
+        setUp: function() {
+            this.simplex = new SimplexNoise(random);
+        },
+        'noise2D': {
+            'should return the same value for the same input': function() {
+                assert.equals(this.simplex.noise2D(0.1, 0.2), this.simplex.noise2D(0.1, 0.2));
+            },
+            'should return a different value for a different input': function() {
+                refute.equals(this.simplex.noise2D(0.1, 0.2), this.simplex.noise2D(0.101, 0.202));
+            },
+            'should return values between -1 and 1': function () {
+                for(var x = 0; x < 10; x++) {
+                    for(var y = 0; y < 10; y++) {
+                        assert(this.simplex.noise2D(x/5, y/5) >= -1);
+                        assert(this.simplex.noise2D(x/5, y/5) <= 1);
+                    }
+                }
+            },
+            'should return similar values for similar inputs': function () {
+                assert(Math.abs(this.simplex.noise2D(0.1, 0.2)-this.simplex.noise2D(0.101, 0.202))<0.1);
+            }
+        },
+        'noise3D': {
+            'should return the same value for the same input': function() {
+                assert.equals(this.simplex.noise3D(0.1, 0.2, 0.3), this.simplex.noise3D(0.1, 0.2, 0.3));
+            },
+            'should return a different value for a different input': function() {
+                refute.equals(this.simplex.noise3D(0.1, 0.2, 0.3), this.simplex.noise3D(0.101, 0.202, 0.303));
+                refute.equals(this.simplex.noise3D(0.1, 0.2, 0.3), this.simplex.noise3D(0.1, 0.2, 0.303));
+            },
+            'should return values between -1 and 1': function () {
+                for(var x = 0; x < 10; x++) {
+                    for(var y = 0; y < 10; y++) {
+                        assert(this.simplex.noise3D(x/5, y/5, x+y) >= -1);
+                        assert(this.simplex.noise3D(x/5, y/5, x+y) <= 1);
+                    }
+                }
+            },
+            'should return similar values for similar inputs': function () {
+                assert(Math.abs(this.simplex.noise3D(0.1, 0.2, 0.3)-this.simplex.noise3D(0.101, 0.202, 0.303))<0.1);
+            }
+        },
+        'noise4D': {
+            'should return the same value for the same input': function() {
+                assert.equals(this.simplex.noise4D(0.1, 0.2, 0.3, 0.4), this.simplex.noise4D(0.1, 0.2, 0.3, 0.4));
+            },
+            'should return a different value for a different input': function() {
+                refute.equals(this.simplex.noise4D(0.1, 0.2, 0.3, 0.4), this.simplex.noise4D(0.101, 0.202, 0.303, 0.404));
+                refute.equals(this.simplex.noise4D(0.1, 0.2, 0.3, 0.4), this.simplex.noise4D(0.1, 0.2, 0.3, 0.404));
+            },
+            'should return values between -1 and 1': function () {
+                for(var x = 0; x < 10; x++) {
+                    for(var y = 0; y < 10; y++) {
+                        assert(this.simplex.noise4D(x/5, y/5, x+y, x-y) >= -1);
+                        assert(this.simplex.noise4D(x/5, y/5, x+y, x-y) <= 1);
+                    }
+                }
+            },
+            'should return similar values for similar inputs': function () {
+                assert(Math.abs(this.simplex.noise4D(0.1, 0.2, 0.3, 0.4)-this.simplex.noise4D(0.101, 0.202, 0.303, 0.404))<0.1);
+            }
+        }
+
+
+    } 
+});