Created
April 14, 2014 19:53
-
-
Save birarda/10677986 to your computer and use it in GitHub Desktop.
landscape generation script for High Fidelity
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// | |
// perlin.js | |
// | |
// Copyright 2013 High Fidelity, Inc. | |
// | |
// Distributed under the Apache License, Version 2.0. | |
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html | |
// | |
// Ported from Stefan Gustavson's java implementation | |
// http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf | |
// Read Stefan's excellent paper for details on how this code works. | |
// | |
// Sean McCullough banksean@gmail.com | |
var SimplexNoise = function(r) { | |
if (r == undefined) r = Math; | |
this.grad3 = [[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]]; | |
this.p = []; | |
for (var i=0; i<256; i++) { | |
this.p[i] = Math.floor(r.random()*256); | |
} | |
// To remove the need for index wrapping, double the permutation table length | |
this.perm = []; | |
for(var i=0; i<512; i++) { | |
this.perm[i]=this.p[i & 255]; | |
} | |
// A lookup table to traverse the simplex around a given point in 4D. | |
// Details can be found where this table is used, in the 4D noise method. | |
this.simplex = [ | |
[0,1,2,3],[0,1,3,2],[0,0,0,0],[0,2,3,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,2,3,0], | |
[0,2,1,3],[0,0,0,0],[0,3,1,2],[0,3,2,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,3,2,0], | |
[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0], | |
[1,2,0,3],[0,0,0,0],[1,3,0,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,3,0,1],[2,3,1,0], | |
[1,0,2,3],[1,0,3,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,0,3,1],[0,0,0,0],[2,1,3,0], | |
[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0], | |
[2,0,1,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,0,1,2],[3,0,2,1],[0,0,0,0],[3,1,2,0], | |
[2,1,0,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,1,0,2],[0,0,0,0],[3,2,0,1],[3,2,1,0]]; | |
}; | |
SimplexNoise.prototype.dot = function(g, x, y) { | |
return g[0]*x + g[1]*y; | |
}; | |
SimplexNoise.prototype.noise = function(xin, yin) { | |
var n0, n1, n2; // Noise contributions from the three corners | |
// Skew the input space to determine which simplex cell we're in | |
var F2 = 0.5*(Math.sqrt(3.0)-1.0); | |
var s = (xin+yin)*F2; // Hairy factor for 2D | |
var i = Math.floor(xin+s); | |
var j = Math.floor(yin+s); | |
var G2 = (3.0-Math.sqrt(3.0))/6.0; | |
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; | |
var gi0 = this.perm[ii+this.perm[jj]] % 12; | |
var gi1 = this.perm[ii+i1+this.perm[jj+j1]] % 12; | |
var gi2 = this.perm[ii+1+this.perm[jj+1]] % 12; | |
// Calculate the contribution from the three corners | |
var t0 = 0.5 - x0*x0-y0*y0; | |
if(t0<0) n0 = 0.0; | |
else { | |
t0 *= t0; | |
n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient | |
} | |
var t1 = 0.5 - x1*x1-y1*y1; | |
if(t1<0) n1 = 0.0; | |
else { | |
t1 *= t1; | |
n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1); | |
} | |
var t2 = 0.5 - x2*x2-y2*y2; | |
if(t2<0) n2 = 0.0; | |
else { | |
t2 *= t2; | |
n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, 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 | |
SimplexNoise.prototype.noise3d = function(xin, yin, zin) { | |
var n0, n1, n2, n3; // Noise contributions from the four corners | |
// Skew the input space to determine which simplex cell we're in | |
var F3 = 1.0/3.0; | |
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 G3 = 1.0/6.0; // Very nice and simple unskew factor, too | |
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; | |
var gi0 = this.perm[ii+this.perm[jj+this.perm[kk]]] % 12; | |
var gi1 = this.perm[ii+i1+this.perm[jj+j1+this.perm[kk+k1]]] % 12; | |
var gi2 = this.perm[ii+i2+this.perm[jj+j2+this.perm[kk+k2]]] % 12; | |
var gi3 = this.perm[ii+1+this.perm[jj+1+this.perm[kk+1]]] % 12; | |
// Calculate the contribution from the four corners | |
var t0 = 0.6 - x0*x0 - y0*y0 - z0*z0; | |
if(t0<0) n0 = 0.0; | |
else { | |
t0 *= t0; | |
n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0, z0); | |
} | |
var t1 = 0.6 - x1*x1 - y1*y1 - z1*z1; | |
if(t1<0) n1 = 0.0; | |
else { | |
t1 *= t1; | |
n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1, z1); | |
} | |
var t2 = 0.6 - x2*x2 - y2*y2 - z2*z2; | |
if(t2<0) n2 = 0.0; | |
else { | |
t2 *= t2; | |
n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2, z2); | |
} | |
var t3 = 0.6 - x3*x3 - y3*y3 - z3*z3; | |
if(t3<0) n3 = 0.0; | |
else { | |
t3 *= t3; | |
n3 = t3 * t3 * this.dot(this.grad3[gi3], x3, y3, 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); | |
}; | |
// Create a simple ground plane sheet of voxels | |
var PLANE_SIDE_LENGTH = 8192; | |
var BASE_BLOCK_SIZE = 64; | |
var MIN_X = 0; | |
var MIN_Z = 0; | |
var z = MIN_Z; | |
var MAX_X = (PLANE_SIDE_LENGTH + MIN_Z); | |
var MAX_Z = (PLANE_SIDE_LENGTH + MIN_Z); | |
var PLANE_MAX_HEIGHT = 250; | |
function getColorByHeight(height) { | |
var WATER_LEVEL = .60; | |
var GREEN_LEVEL = .80; | |
var BROWN_LEVEL = 1; | |
var r,g,b; | |
var noise = 0; | |
var color = {}; | |
var darkenMultiplier = 0; | |
var sectionHeight = 0; | |
if (height < (WATER_LEVEL * PLANE_MAX_HEIGHT)) { | |
// Water | |
color.r = 57; | |
color.g = 88; | |
color.b = 121; | |
sectionHeight = (WATER_LEVEL - 0) * PLANE_MAX_HEIGHT; | |
darkenMultiplier = 0.25 + (0.75 * height / sectionHeight); | |
noise = 25; | |
} else if (height < (GREEN_LEVEL * PLANE_MAX_HEIGHT)) { | |
// Grass | |
color.r = 38; | |
color.g = 106; | |
color.b = 46; | |
sectionHeight = (GREEN_LEVEL - WATER_LEVEL) * PLANE_MAX_HEIGHT; | |
darkenMultiplier = 0.25 + (0.75 * (height - (WATER_LEVEL * PLANE_MAX_HEIGHT)) / sectionHeight); | |
noise = 15; | |
} else if (height < (BROWN_LEVEL * PLANE_MAX_HEIGHT)) { | |
// Dirt | |
color.r = 120; | |
color.g = 72; | |
color.b = 0; | |
sectionHeight = (BROWN_LEVEL - GREEN_LEVEL) * PLANE_MAX_HEIGHT; | |
darkenMultiplier = 0.25 + (0.75 * (height - (GREEN_LEVEL * PLANE_MAX_HEIGHT)) / sectionHeight); | |
noise = 25; | |
} else { | |
// Snow | |
color.r = 238; | |
color.g = 233; | |
color.b = 233; | |
sectionHeight = (1 - BROWN_LEVEL) * PLANE_MAX_HEIGHT; | |
darkenMultiplier = 0.25 + (0.75 * (height - (BROWN_LEVEL * PLANE_MAX_HEIGHT)) / sectionHeight); | |
noise = 10; | |
} | |
var noiseColor = Math.random() * noise; | |
color.r += noiseColor; | |
color.g += noiseColor; | |
color.b += noiseColor; | |
color.r *= darkenMultiplier; | |
color.g *= darkenMultiplier; | |
color.b *= darkenMultiplier; | |
return color; | |
} | |
function SeededRandom(){ | |
var seed = 42; | |
this.random = function(){ | |
var x = Math.sin(seed++) * 10000; | |
return x - Math.floor(x); | |
}; | |
} | |
var perlin = new SimplexNoise(new SeededRandom()); | |
var PERLIN_BASE_RANGE = 4; | |
var PERLIN_DENOMINATOR = 16384 / PERLIN_BASE_RANGE; | |
function getHeight(x, z) { | |
var scaledX = x / (PERLIN_DENOMINATOR); | |
var scaledZ = z / (PERLIN_DENOMINATOR); | |
var basePerlin = perlin.noise(scaledX, scaledZ); | |
var scaledBasePerlin = (basePerlin + 1) / 2; | |
var secondPerlin = perlin.noise(10 * scaledX, 5 * scaledZ); | |
scaledSecondPerlin = (secondPerlin + 1) / 2; | |
var thirdPerlin = perlin.noise(30 * scaledX, 15 * scaledZ); | |
scaledThirdPerlin = (thirdPerlin + 1) / 2; | |
var combinedPerlin = scaledBasePerlin + (0.25 * scaledSecondPerlin) + (0.125 * scaledThirdPerlin); | |
combinedPerlin /= 1.0 + 0.25 + 0.125; | |
return combinedPerlin * PLANE_MAX_HEIGHT; | |
} | |
var createdVoxels = 0; | |
function recursivelyAddTopLayersToBase(baseX, baseZ, baseSize, heightPush) { | |
var blockSize = baseSize / 2; | |
if (blockSize >= BASE_BLOCK_SIZE / 4) { | |
for (var x = 0; x < 2; x++) { | |
for (var z = 0; z < 2; z++) { | |
// x, z | |
var blockBaseY = getHeight(baseX + (blockSize * x) + (blockSize / 2), baseZ + (blockSize * z) + (blockSize / 2)); | |
blockBaseY += heightPush; | |
var blockY = blockBaseY; | |
var blockColor = getColorByHeight(blockBaseY); | |
Voxels.setVoxel(baseX + (blockSize * x), blockY, baseZ + (blockSize * z), blockSize, blockColor.r, blockColor.g, blockColor.b); | |
createdVoxels++; | |
recursivelyAddTopLayersToBase(baseX + (blockSize * x), baseZ + (blockSize * z), blockSize, heightPush + blockSize); | |
} | |
} | |
} | |
} | |
var done = false; | |
// here I'm creating a function to fire before each data send | |
function makeBlocks() { | |
if (!done) { | |
for (var x = MIN_X; x < MAX_X; x += BASE_BLOCK_SIZE) { | |
// get the height at the center of the voxel | |
var baseY = getHeight(x + (BASE_BLOCK_SIZE / 2), z + (BASE_BLOCK_SIZE / 2)); | |
var baseColor = getColorByHeight(baseY); | |
createdVoxels++; | |
Voxels.setVoxel(x, baseY, z, BASE_BLOCK_SIZE, baseColor.r, baseColor.g, baseColor.b); | |
// call our helper to add the top layers to this base block | |
recursivelyAddTopLayersToBase(x, z, BASE_BLOCK_SIZE, BASE_BLOCK_SIZE); | |
} | |
z += BASE_BLOCK_SIZE; | |
print("z: " + z + " - " + createdVoxels + " voxels\n"); | |
if (z >= MAX_Z) { | |
done = true; | |
print("Done building ground. Created " + createdVoxels + " voxels.\n"); | |
// Agent.stop(); | |
} | |
} | |
} | |
// register the call back so it fires before each data send | |
Script.update.connect(makeBlocks); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment