mountains = (u, v, target) => { let perlin; // will be initialized lazily by noise() or noiseSeed() let perlin_octaves = 4; // default to medium smooth let perlin_amp_falloff = 0.5; // 50% reduction/octave const scaled_cosine = (i) => 0.5 * (1.0 - Math.cos(i * Math.PI)); const PERLIN_YWRAPB = 4; const PERLIN_YWRAP = 1 << PERLIN_YWRAPB; const PERLIN_ZWRAPB = 8; const PERLIN_ZWRAP = 1 << PERLIN_ZWRAPB; const PERLIN_SIZE = 4095; function fbm(x, y, z, h = 1, octaves = 6) { let g = 2 ** -h; let f = 1.0; let a = 1.0; let t = 0.0; for (let i = 0; i < octaves; i++) { t += a * noise(f * (x + i * 2 * Math.PI), y, z); f *= 2.0; a *= g; } return t * 0.25 + 0.5; } function constrain(n, low, high) { return Math.max(Math.min(n, high), low); } function map(n, start1, stop1, start2, stop2, withinBounds) { const newval = ((n - start1) / (stop1 - start1)) * (stop2 - start2) + start2; if (!withinBounds) { return newval; } if (start2 < stop2) { return constrain(newval, start2, stop2); } else { return constrain(newval, stop2, start2); } } function noise(x, y = 0, z = 0) { if (perlin == null) { perlin = new Array(PERLIN_SIZE + 1); for (let i = 0; i < PERLIN_SIZE + 1; i++) { perlin[i] = Math.random(); } } if (x < 0) { x = -x; } if (y < 0) { y = -y; } if (z < 0) { z = -z; } let xi = Math.floor(x), yi = Math.floor(y), zi = Math.floor(z); let xf = x - xi; let yf = y - yi; let zf = z - zi; let rxf, ryf; let r = 0; let ampl = 0.5; let n1, n2, n3; for (let o = 0; o < perlin_octaves; o++) { let of = xi + (yi << PERLIN_YWRAPB) + (zi << PERLIN_ZWRAPB); rxf = scaled_cosine(xf); ryf = scaled_cosine(yf); n1 = perlin[of & PERLIN_SIZE]; n1 += rxf * (perlin[(of + 1) & PERLIN_SIZE] - n1); n2 = perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE]; n2 += rxf * (perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n2); n1 += ryf * (n2 - n1); of += PERLIN_ZWRAP; n2 = perlin[of & PERLIN_SIZE]; n2 += rxf * (perlin[(of + 1) & PERLIN_SIZE] - n2); n3 = perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE]; n3 += rxf * (perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n3); n2 += ryf * (n3 - n2); n1 += scaled_cosine(zf) * (n2 - n1); r += n1 * ampl; ampl *= perlin_amp_falloff; xi <<= 1; xf *= 2; yi <<= 1; yf *= 2; zi <<= 1; zf *= 2; if (xf >= 1.0) { xi++; xf--; } if (yf >= 1.0) { yi++; yf--; } if (zf >= 1.0) { zi++; zf--; } } return r; } function noiseSeed(seed) { // Linear Congruential Generator // Variant of a Lehman Generator const lcg = (() => { // Set to values from http://en.wikipedia.org/wiki/Numerical_Recipes // m is basically chosen to be large (as it is the max period) // and for its relationships to a and c const m = 4294967296; // a - 1 should be divisible by m's prime factors const a = 1664525; // c and m should be co-prime const c = 1013904223; let seed, z; return { setSeed(val) { // pick a random seed if val is undefined or null // the >>> 0 casts the seed to an unsigned 32-bit integer z = seed = (val == null ? Math.random() * m : val) >>> 0; }, getSeed() { return seed; }, rand() { // define the recurrence relationship z = (a * z + c) % m; // return a float in [0, 1) // if z = m then z / m = 0 therefore (z % m) / m < 1 always return z / m; } }; })(); lcg.setSeed(seed); perlin = new Array(PERLIN_SIZE + 1); for (let i = 0; i < PERLIN_SIZE + 1; i++) { perlin[i] = lcg.rand(); } } let x = u - 1 + 2 * (fbm(3 * v, u, 0, 1, 4) - 0.5); let y = 1.5 * v; let j = constrain(y, 0, 1); let h = map(j ** 0.5, 0, 1, 2, 1); let freq = map(j, 0, 1, 3, 10); let amp = map(j, 0, 1, 1, 1); //let offset = map(y, 0, 1.5, -0.7, -0.1, true); let z = amp * fbm(freq * x, 10 * y, freq, h); // + offset target.set(u, v, 0.5 * z); //return { u, v, z: z * 0.5 }; }