CourseMiner

├── content ├── sprSand.png ├── sprGrass.png └── sprWater.png ├── js ├── game.js ├── noisejs-master │ ├── LICENSE │ ├── README.md │ ├── demo.html │ ├── demo3d.html │ └── perlin.js ├── Entities.js └── SceneMain.js ├── index.html └── LICENSE /content/sprSand.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jaredyork/TutorialInfiniteTerrain/HEAD/content/sprSand.png -------------------------------------------------------------------------------- /content/sprGrass.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jaredyork/TutorialInfiniteTerrain/HEAD/content/sprGrass.png -------------------------------------------------------------------------------- /content/sprWater.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jaredyork/TutorialInfiniteTerrain/HEAD/content/sprWater.png -------------------------------------------------------------------------------- /js/game.js: -------------------------------------------------------------------------------- 1 | var config = { 2 | type: Phaser.WEBGL, 3 | width: 640, 4 | height: 640, 5 | backgroundColor: "black", 6 | physics: { 7 | default: "arcade", 8 | arcade: { 9 | gravity: { x: 0, y: 0 } 10 | } 11 | }, 12 | scene: [ 13 | SceneMain 14 | ], 15 | pixelArt: true, 16 | roundPixels: true 17 | }; 18 | 19 | var game = new Phaser.Game(config); 20 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | CourseMiner 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /js/noisejs-master/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2013, Joseph Gentle 4 | 5 | Permission to use, copy, modify, and/or distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 10 | REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 11 | AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 12 | INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 13 | LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 14 | OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 15 | PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Jared York 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /js/noisejs-master/README.md: -------------------------------------------------------------------------------- 1 | # NOISE! 2 | 3 | This is a simple library for 2d & 3d perlin noise and simplex noise in 4 | javascript. Noise is 5 | [pretty](https://josephg.com/perlin/3/). 6 | 7 | The library is pretty fast (10M queries / sec). But its still way slower than 8 | using a shader. For example, if you try and update an entire screen's worth of 9 | pixels, it'll be [slow](http://josephg.github.com/noisejs/demo3d.html). 10 | 11 | The code is based on Stefan Gustavson's implementation. Do whatever you want 12 | with it, etc. 13 | 14 | ## How to make noise: 15 | 16 | ```javascript 17 | noise.seed(Math.random()); 18 | 19 | for (var x = 0; x < canvas.width; x++) { 20 | for (var y = 0; y < canvas.height; y++) { 21 | // All noise functions return values in the range of -1 to 1. 22 | 23 | // noise.simplex2 and noise.perlin2 for 2d noise 24 | var value = noise.simplex2(x / 100, y / 100); 25 | // ... or noise.simplex3 and noise.perlin3: 26 | var value = noise.simplex3(x / 100, y / 100, time); 27 | 28 | image[x][y].r = Math.abs(value) * 256; // Or whatever. Open demo.html to see it used with canvas. 29 | } 30 | } 31 | ``` 32 | 33 | The library exposes an object called `noise` with the following properties: 34 | 35 | - **simplex2(x, y)**: 2D Simplex noise function 36 | - **simplex3(x, y, z)**: 3D Simplex noise function 37 | - **perlin2(x, y)**: 2D Perlin noise function 38 | - **perlin3(x, y, z)**: 3D Perlin noise function 39 | - **seed(val)**: Seed the noise functions. Only 65536 different seeds are supported. Use a float between 0 and 1 or an integer from 1 to 65536. 40 | 41 | -------------------------------------------------------------------------------- /js/Entities.js: -------------------------------------------------------------------------------- 1 | class Chunk { 2 | constructor(scene, x, y) { 3 | this.scene = scene; 4 | this.x = x; 5 | this.y = y; 6 | this.tiles = this.scene.add.group(); 7 | this.isLoaded = false; 8 | } 9 | 10 | unload() { 11 | if (this.isLoaded) { 12 | this.tiles.clear(true, true); 13 | 14 | this.isLoaded = false; 15 | } 16 | } 17 | 18 | load() { 19 | if (!this.isLoaded) { 20 | for (var x = 0; x < this.scene.chunkSize; x++) { 21 | for (var y = 0; y < this.scene.chunkSize; y++) { 22 | 23 | var tileX = (this.x * (this.scene.chunkSize * this.scene.tileSize)) + (x * this.scene.tileSize); 24 | var tileY = (this.y * (this.scene.chunkSize * this.scene.tileSize)) + (y * this.scene.tileSize); 25 | 26 | var perlinValue = noise.perlin2(tileX / 100, tileY / 100); 27 | 28 | var key = ""; 29 | var animationKey = ""; 30 | 31 | if (perlinValue < 0.2) { 32 | key = "sprWater"; 33 | animationKey = "sprWater"; 34 | } 35 | else if (perlinValue >= 0.2 && perlinValue < 0.3) { 36 | key = "sprSand"; 37 | } 38 | else if (perlinValue >= 0.3) { 39 | key = "sprGrass"; 40 | } 41 | 42 | 43 | var tile = new Tile(this.scene, tileX, tileY, key); 44 | 45 | if (animationKey !== "") { 46 | tile.play(animationKey); 47 | } 48 | 49 | this.tiles.add(tile); 50 | } 51 | } 52 | 53 | this.isLoaded = true; 54 | } 55 | } 56 | } 57 | 58 | class Tile extends Phaser.GameObjects.Sprite { 59 | constructor(scene, x, y, key) { 60 | super(scene, x, y, key); 61 | this.scene = scene; 62 | this.scene.add.existing(this); 63 | this.setOrigin(0); 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /js/noisejs-master/demo.html: -------------------------------------------------------------------------------- 1 | 2 | Perlin noise 3 | 31 |

32 | 33 | 82 | -------------------------------------------------------------------------------- /js/noisejs-master/demo3d.html: -------------------------------------------------------------------------------- 1 | 2 | Perlin noise 3 | 31 |

32 | 33 | 98 | -------------------------------------------------------------------------------- /js/SceneMain.js: -------------------------------------------------------------------------------- 1 | class SceneMain extends Phaser.Scene { 2 | constructor() { 3 | super({ key: "SceneMain" }); 4 | } 5 | 6 | preload() { 7 | this.load.spritesheet("sprWater", "content/sprWater.png", { 8 | frameWidth: 16, 9 | frameHeight: 16 10 | }); 11 | this.load.image("sprSand", "content/sprSand.png"); 12 | this.load.image("sprGrass", "content/sprGrass.png"); 13 | } 14 | 15 | create() { 16 | 17 | this.anims.create({ 18 | key: "sprWater", 19 | frames: this.anims.generateFrameNumbers("sprWater"), 20 | frameRate: 5, 21 | repeat: -1 22 | }); 23 | 24 | this.chunkSize = 16; 25 | this.tileSize = 16; 26 | this.cameraSpeed = 10; 27 | 28 | this.cameras.main.setZoom(2); 29 | this.followPoint = new Phaser.Math.Vector2( 30 | this.cameras.main.worldView.x + (this.cameras.main.worldView.width * 0.5), 31 | this.cameras.main.worldView.y + (this.cameras.main.worldView.height * 0.5) 32 | ); 33 | 34 | this.chunks = []; 35 | 36 | this.keyW = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W); 37 | this.keyS = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S); 38 | this.keyA = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A); 39 | this.keyD = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D); 40 | } 41 | 42 | getChunk(x, y) { 43 | var chunk = null; 44 | for (var i = 0; i < this.chunks.length; i++) { 45 | if (this.chunks[i].x == x && this.chunks[i].y == y) { 46 | chunk = this.chunks[i]; 47 | } 48 | } 49 | return chunk; 50 | } 51 | 52 | update() { 53 | 54 | var snappedChunkX = (this.chunkSize * this.tileSize) * Math.round(this.followPoint.x / (this.chunkSize * this.tileSize)); 55 | var snappedChunkY = (this.chunkSize * this.tileSize) * Math.round(this.followPoint.y / (this.chunkSize * this.tileSize)); 56 | 57 | snappedChunkX = snappedChunkX / this.chunkSize / this.tileSize; 58 | snappedChunkY = snappedChunkY / this.chunkSize / this.tileSize; 59 | 60 | for (var x = snappedChunkX - 2; x < snappedChunkX + 2; x++) { 61 | for (var y = snappedChunkY - 2; y < snappedChunkY + 2; y++) { 62 | var existingChunk = this.getChunk(x, y); 63 | 64 | if (existingChunk == null) { 65 | var newChunk = new Chunk(this, x, y); 66 | this.chunks.push(newChunk); 67 | } 68 | } 69 | } 70 | 71 | for (var i = 0; i < this.chunks.length; i++) { 72 | var chunk = this.chunks[i]; 73 | 74 | if (Phaser.Math.Distance.Between( 75 | snappedChunkX, 76 | snappedChunkY, 77 | chunk.x, 78 | chunk.y 79 | ) < 3) { 80 | if (chunk !== null) { 81 | chunk.load(); 82 | } 83 | } 84 | else { 85 | if (chunk !== null) { 86 | chunk.unload(); 87 | } 88 | } 89 | } 90 | 91 | if (this.keyW.isDown) { 92 | this.followPoint.y -= this.cameraSpeed; 93 | } 94 | if (this.keyS.isDown) { 95 | this.followPoint.y += this.cameraSpeed; 96 | } 97 | if (this.keyA.isDown) { 98 | this.followPoint.x -= this.cameraSpeed; 99 | } 100 | if (this.keyD.isDown) { 101 | this.followPoint.x += this.cameraSpeed; 102 | } 103 | 104 | this.cameras.main.centerOn(this.followPoint.x, this.followPoint.y); 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /js/noisejs-master/perlin.js: -------------------------------------------------------------------------------- 1 | /* 2 | * A speed-improved perlin and simplex noise algorithms for 2D. 3 | * 4 | * Based on example code by Stefan Gustavson (stegu@itn.liu.se). 5 | * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu). 6 | * Better rank ordering method by Stefan Gustavson in 2012. 7 | * Converted to Javascript by Joseph Gentle. 8 | * 9 | * Version 2012-03-09 10 | * 11 | * This code was placed in the public domain by its original author, 12 | * Stefan Gustavson. You may use it as you see fit, but 13 | * attribution is appreciated. 14 | * 15 | */ 16 | 17 | (function(global){ 18 | var module = global.noise = {}; 19 | 20 | function Grad(x, y, z) { 21 | this.x = x; this.y = y; this.z = z; 22 | } 23 | 24 | Grad.prototype.dot2 = function(x, y) { 25 | return this.x*x + this.y*y; 26 | }; 27 | 28 | Grad.prototype.dot3 = function(x, y, z) { 29 | return this.x*x + this.y*y + this.z*z; 30 | }; 31 | 32 | var grad3 = [new Grad(1,1,0),new Grad(-1,1,0),new Grad(1,-1,0),new Grad(-1,-1,0), 33 | new Grad(1,0,1),new Grad(-1,0,1),new Grad(1,0,-1),new Grad(-1,0,-1), 34 | new Grad(0,1,1),new Grad(0,-1,1),new Grad(0,1,-1),new Grad(0,-1,-1)]; 35 | 36 | var p = [151,160,137,91,90,15, 37 | 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23, 38 | 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33, 39 | 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166, 40 | 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244, 41 | 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196, 42 | 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123, 43 | 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42, 44 | 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9, 45 | 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228, 46 | 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107, 47 | 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254, 48 | 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180]; 49 | // To remove the need for index wrapping, double the permutation table length 50 | var perm = new Array(512); 51 | var gradP = new Array(512); 52 | 53 | // This isn't a very good seeding function, but it works ok. It supports 2^16 54 | // different seed values. Write something better if you need more seeds. 55 | module.seed = function(seed) { 56 | if(seed > 0 && seed < 1) { 57 | // Scale the seed out 58 | seed *= 65536; 59 | } 60 | 61 | seed = Math.floor(seed); 62 | if(seed < 256) { 63 | seed |= seed << 8; 64 | } 65 | 66 | for(var i = 0; i < 256; i++) { 67 | var v; 68 | if (i & 1) { 69 | v = p[i] ^ (seed & 255); 70 | } else { 71 | v = p[i] ^ ((seed>>8) & 255); 72 | } 73 | 74 | perm[i] = perm[i + 256] = v; 75 | gradP[i] = gradP[i + 256] = grad3[v % 12]; 76 | } 77 | }; 78 | 79 | module.seed(0); 80 | 81 | /* 82 | for(var i=0; i<256; i++) { 83 | perm[i] = perm[i + 256] = p[i]; 84 | gradP[i] = gradP[i + 256] = grad3[perm[i] % 12]; 85 | }*/ 86 | 87 | // Skewing and unskewing factors for 2, 3, and 4 dimensions 88 | var F2 = 0.5*(Math.sqrt(3)-1); 89 | var G2 = (3-Math.sqrt(3))/6; 90 | 91 | var F3 = 1/3; 92 | var G3 = 1/6; 93 | 94 | // 2D simplex noise 95 | module.simplex2 = function(xin, yin) { 96 | var n0, n1, n2; // Noise contributions from the three corners 97 | // Skew the input space to determine which simplex cell we're in 98 | var s = (xin+yin)*F2; // Hairy factor for 2D 99 | var i = Math.floor(xin+s); 100 | var j = Math.floor(yin+s); 101 | var t = (i+j)*G2; 102 | var x0 = xin-i+t; // The x,y distances from the cell origin, unskewed. 103 | var y0 = yin-j+t; 104 | // For the 2D case, the simplex shape is an equilateral triangle. 105 | // Determine which simplex we are in. 106 | var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords 107 | if(x0>y0) { // lower triangle, XY order: (0,0)->(1,0)->(1,1) 108 | i1=1; j1=0; 109 | } else { // upper triangle, YX order: (0,0)->(0,1)->(1,1) 110 | i1=0; j1=1; 111 | } 112 | // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and 113 | // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where 114 | // c = (3-sqrt(3))/6 115 | var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords 116 | var y1 = y0 - j1 + G2; 117 | var x2 = x0 - 1 + 2 * G2; // Offsets for last corner in (x,y) unskewed coords 118 | var y2 = y0 - 1 + 2 * G2; 119 | // Work out the hashed gradient indices of the three simplex corners 120 | i &= 255; 121 | j &= 255; 122 | var gi0 = gradP[i+perm[j]]; 123 | var gi1 = gradP[i+i1+perm[j+j1]]; 124 | var gi2 = gradP[i+1+perm[j+1]]; 125 | // Calculate the contribution from the three corners 126 | var t0 = 0.5 - x0*x0-y0*y0; 127 | if(t0<0) { 128 | n0 = 0; 129 | } else { 130 | t0 *= t0; 131 | n0 = t0 * t0 * gi0.dot2(x0, y0); // (x,y) of grad3 used for 2D gradient 132 | } 133 | var t1 = 0.5 - x1*x1-y1*y1; 134 | if(t1<0) { 135 | n1 = 0; 136 | } else { 137 | t1 *= t1; 138 | n1 = t1 * t1 * gi1.dot2(x1, y1); 139 | } 140 | var t2 = 0.5 - x2*x2-y2*y2; 141 | if(t2<0) { 142 | n2 = 0; 143 | } else { 144 | t2 *= t2; 145 | n2 = t2 * t2 * gi2.dot2(x2, y2); 146 | } 147 | // Add contributions from each corner to get the final noise value. 148 | // The result is scaled to return values in the interval [-1,1]. 149 | return 70 * (n0 + n1 + n2); 150 | }; 151 | 152 | // 3D simplex noise 153 | module.simplex3 = function(xin, yin, zin) { 154 | var n0, n1, n2, n3; // Noise contributions from the four corners 155 | 156 | // Skew the input space to determine which simplex cell we're in 157 | var s = (xin+yin+zin)*F3; // Hairy factor for 2D 158 | var i = Math.floor(xin+s); 159 | var j = Math.floor(yin+s); 160 | var k = Math.floor(zin+s); 161 | 162 | var t = (i+j+k)*G3; 163 | var x0 = xin-i+t; // The x,y distances from the cell origin, unskewed. 164 | var y0 = yin-j+t; 165 | var z0 = zin-k+t; 166 | 167 | // For the 3D case, the simplex shape is a slightly irregular tetrahedron. 168 | // Determine which simplex we are in. 169 | var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords 170 | var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords 171 | if(x0 >= y0) { 172 | if(y0 >= z0) { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } 173 | else if(x0 >= z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } 174 | else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } 175 | } else { 176 | if(y0 < z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } 177 | else if(x0 < z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } 178 | else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } 179 | } 180 | // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), 181 | // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and 182 | // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where 183 | // c = 1/6. 184 | var x1 = x0 - i1 + G3; // Offsets for second corner 185 | var y1 = y0 - j1 + G3; 186 | var z1 = z0 - k1 + G3; 187 | 188 | var x2 = x0 - i2 + 2 * G3; // Offsets for third corner 189 | var y2 = y0 - j2 + 2 * G3; 190 | var z2 = z0 - k2 + 2 * G3; 191 | 192 | var x3 = x0 - 1 + 3 * G3; // Offsets for fourth corner 193 | var y3 = y0 - 1 + 3 * G3; 194 | var z3 = z0 - 1 + 3 * G3; 195 | 196 | // Work out the hashed gradient indices of the four simplex corners 197 | i &= 255; 198 | j &= 255; 199 | k &= 255; 200 | var gi0 = gradP[i+ perm[j+ perm[k ]]]; 201 | var gi1 = gradP[i+i1+perm[j+j1+perm[k+k1]]]; 202 | var gi2 = gradP[i+i2+perm[j+j2+perm[k+k2]]]; 203 | var gi3 = gradP[i+ 1+perm[j+ 1+perm[k+ 1]]]; 204 | 205 | // Calculate the contribution from the four corners 206 | var t0 = 0.6 - x0*x0 - y0*y0 - z0*z0; 207 | if(t0<0) { 208 | n0 = 0; 209 | } else { 210 | t0 *= t0; 211 | n0 = t0 * t0 * gi0.dot3(x0, y0, z0); // (x,y) of grad3 used for 2D gradient 212 | } 213 | var t1 = 0.6 - x1*x1 - y1*y1 - z1*z1; 214 | if(t1<0) { 215 | n1 = 0; 216 | } else { 217 | t1 *= t1; 218 | n1 = t1 * t1 * gi1.dot3(x1, y1, z1); 219 | } 220 | var t2 = 0.6 - x2*x2 - y2*y2 - z2*z2; 221 | if(t2<0) { 222 | n2 = 0; 223 | } else { 224 | t2 *= t2; 225 | n2 = t2 * t2 * gi2.dot3(x2, y2, z2); 226 | } 227 | var t3 = 0.6 - x3*x3 - y3*y3 - z3*z3; 228 | if(t3<0) { 229 | n3 = 0; 230 | } else { 231 | t3 *= t3; 232 | n3 = t3 * t3 * gi3.dot3(x3, y3, z3); 233 | } 234 | // Add contributions from each corner to get the final noise value. 235 | // The result is scaled to return values in the interval [-1,1]. 236 | return 32 * (n0 + n1 + n2 + n3); 237 | 238 | }; 239 | 240 | // ##### Perlin noise stuff 241 | 242 | function fade(t) { 243 | return t*t*t*(t*(t*6-15)+10); 244 | } 245 | 246 | function lerp(a, b, t) { 247 | return (1-t)*a + t*b; 248 | } 249 | 250 | // 2D Perlin Noise 251 | module.perlin2 = function(x, y) { 252 | // Find unit grid cell containing point 253 | var X = Math.floor(x), Y = Math.floor(y); 254 | // Get relative xy coordinates of point within that cell 255 | x = x - X; y = y - Y; 256 | // Wrap the integer cells at 255 (smaller integer period can be introduced here) 257 | X = X & 255; Y = Y & 255; 258 | 259 | // Calculate noise contributions from each of the four corners 260 | var n00 = gradP[X+perm[Y]].dot2(x, y); 261 | var n01 = gradP[X+perm[Y+1]].dot2(x, y-1); 262 | var n10 = gradP[X+1+perm[Y]].dot2(x-1, y); 263 | var n11 = gradP[X+1+perm[Y+1]].dot2(x-1, y-1); 264 | 265 | // Compute the fade curve value for x 266 | var u = fade(x); 267 | 268 | // Interpolate the four results 269 | return lerp( 270 | lerp(n00, n10, u), 271 | lerp(n01, n11, u), 272 | fade(y)); 273 | }; 274 | 275 | // 3D Perlin Noise 276 | module.perlin3 = function(x, y, z) { 277 | // Find unit grid cell containing point 278 | var X = Math.floor(x), Y = Math.floor(y), Z = Math.floor(z); 279 | // Get relative xyz coordinates of point within that cell 280 | x = x - X; y = y - Y; z = z - Z; 281 | // Wrap the integer cells at 255 (smaller integer period can be introduced here) 282 | X = X & 255; Y = Y & 255; Z = Z & 255; 283 | 284 | // Calculate noise contributions from each of the eight corners 285 | var n000 = gradP[X+ perm[Y+ perm[Z ]]].dot3(x, y, z); 286 | var n001 = gradP[X+ perm[Y+ perm[Z+1]]].dot3(x, y, z-1); 287 | var n010 = gradP[X+ perm[Y+1+perm[Z ]]].dot3(x, y-1, z); 288 | var n011 = gradP[X+ perm[Y+1+perm[Z+1]]].dot3(x, y-1, z-1); 289 | var n100 = gradP[X+1+perm[Y+ perm[Z ]]].dot3(x-1, y, z); 290 | var n101 = gradP[X+1+perm[Y+ perm[Z+1]]].dot3(x-1, y, z-1); 291 | var n110 = gradP[X+1+perm[Y+1+perm[Z ]]].dot3(x-1, y-1, z); 292 | var n111 = gradP[X+1+perm[Y+1+perm[Z+1]]].dot3(x-1, y-1, z-1); 293 | 294 | // Compute the fade curve value for x, y, z 295 | var u = fade(x); 296 | var v = fade(y); 297 | var w = fade(z); 298 | 299 | // Interpolate 300 | return lerp( 301 | lerp( 302 | lerp(n000, n100, u), 303 | lerp(n001, n101, u), w), 304 | lerp( 305 | lerp(n010, n110, u), 306 | lerp(n011, n111, u), w), 307 | v); 308 | }; 309 | 310 | })(this); 311 | --------------------------------------------------------------------------------