A seamless terrain based on pseudo quadtree algorithm and DelaunatorJS (https://github.com/mapbox/delaunator) by Mapbox team. The simplex noise library by Jonas Wagner is just for demonstration purpose.
Last active
January 4, 2023 07:56
-
-
Save vkuchinov/d18721e49d3061fa15548750b7b375cd to your computer and use it in GitHub Desktop.
THREE.JS | Delaunator.JS Pseudo Quadree Coherent Terrain
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
//by Mapbox https://github.com/mapbox/delaunator | |
(function (global, factory) { | |
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : | |
typeof define === 'function' && define.amd ? define(factory) : | |
(global.Delaunator = factory()); | |
}(this, (function () { 'use strict'; | |
var EPSILON = Math.pow(2, -52); | |
var Delaunator = function Delaunator(coords) { | |
var this$1 = this; | |
var n = coords.length >> 1; | |
if (n > 0 && typeof coords[0] !== 'number') { throw new Error('Expected coords to contain numbers.'); } | |
this.coords = coords; | |
var maxTriangles = 2 * n - 5; | |
var triangles = this.triangles = new Uint32Array(maxTriangles * 3); | |
var halfedges = this.halfedges = new Int32Array(maxTriangles * 3); | |
this._hashSize = Math.ceil(Math.sqrt(n)); | |
var hullPrev = this.hullPrev = new Uint32Array(n); | |
var hullNext = this.hullNext = new Uint32Array(n); | |
var hullTri = this.hullTri = new Uint32Array(n); | |
var hullHash = new Int32Array(this._hashSize).fill(-1); | |
var ids = new Uint32Array(n); | |
var minX = Infinity; | |
var minY = Infinity; | |
var maxX = -Infinity; | |
var maxY = -Infinity; | |
for (var i = 0; i < n; i++) { | |
var x = coords[2 * i]; | |
var y = coords[2 * i + 1]; | |
if (x < minX) { minX = x; } | |
if (y < minY) { minY = y; } | |
if (x > maxX) { maxX = x; } | |
if (y > maxY) { maxY = y; } | |
ids[i] = i; | |
} | |
var cx = (minX + maxX) / 2; | |
var cy = (minY + maxY) / 2; | |
var minDist = Infinity; | |
var i0, i1, i2; | |
for (var i$1 = 0; i$1 < n; i$1++) { | |
var d = dist(cx, cy, coords[2 * i$1], coords[2 * i$1 + 1]); | |
if (d < minDist) { | |
i0 = i$1; | |
minDist = d; | |
} | |
} | |
var i0x = coords[2 * i0]; | |
var i0y = coords[2 * i0 + 1]; | |
minDist = Infinity; | |
for (var i$2 = 0; i$2 < n; i$2++) { | |
if (i$2 === i0) { continue; } | |
var d$1 = dist(i0x, i0y, coords[2 * i$2], coords[2 * i$2 + 1]); | |
if (d$1 < minDist && d$1 > 0) { | |
i1 = i$2; | |
minDist = d$1; | |
} | |
} | |
var i1x = coords[2 * i1]; | |
var i1y = coords[2 * i1 + 1]; | |
var minRadius = Infinity; | |
for (var i$3 = 0; i$3 < n; i$3++) { | |
if (i$3 === i0 || i$3 === i1) { continue; } | |
var r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i$3], coords[2 * i$3 + 1]); | |
if (r < minRadius) { | |
i2 = i$3; | |
minRadius = r; | |
} | |
} | |
var i2x = coords[2 * i2]; | |
var i2y = coords[2 * i2 + 1]; | |
if (minRadius === Infinity) { | |
throw new Error('No Delaunay triangulation exists for this input.'); | |
} | |
if (orient(i0x, i0y, i1x, i1y, i2x, i2y)) { | |
var i$4 = i1; | |
var x$1 = i1x; | |
var y$1 = i1y; | |
i1 = i2; | |
i1x = i2x; | |
i1y = i2y; | |
i2 = i$4; | |
i2x = x$1; | |
i2y = y$1; | |
} | |
var center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y); | |
this._cx = center.x; | |
this._cy = center.y; | |
var dists = new Float64Array(n); | |
for (var i$5 = 0; i$5 < n; i$5++) { | |
dists[i$5] = dist(coords[2 * i$5], coords[2 * i$5 + 1], center.x, center.y); | |
} | |
quicksort(ids, dists, 0, n - 1); | |
this.hullStart = i0; | |
var hullSize = 3; | |
hullNext[i0] = hullPrev[i2] = i1; | |
hullNext[i1] = hullPrev[i0] = i2; | |
hullNext[i2] = hullPrev[i1] = i0; | |
hullTri[i0] = 0; | |
hullTri[i1] = 1; | |
hullTri[i2] = 2; | |
hullHash[this._hashKey(i0x, i0y)] = i0; | |
hullHash[this._hashKey(i1x, i1y)] = i1; | |
hullHash[this._hashKey(i2x, i2y)] = i2; | |
this.trianglesLen = 0; | |
this._addTriangle(i0, i1, i2, -1, -1, -1); | |
for (var k = 0, xp = (void 0), yp = (void 0); k < ids.length; k++) { | |
var i$6 = ids[k]; | |
var x$2 = coords[2 * i$6]; | |
var y$2 = coords[2 * i$6 + 1]; | |
if (k > 0 && Math.abs(x$2 - xp) <= EPSILON && Math.abs(y$2 - yp) <= EPSILON) { continue; } | |
xp = x$2; | |
yp = y$2; | |
if (i$6 === i0 || i$6 === i1 || i$6 === i2) { continue; } | |
var start = 0; | |
for (var j = 0, key = this._hashKey(x$2, y$2); j < this._hashSize; j++) { | |
start = hullHash[(key + j) % this$1._hashSize]; | |
if (start !== -1 && start !== hullNext[start]) { break; } | |
} | |
start = hullPrev[start]; | |
var e = start, q = (void 0); | |
while (q = hullNext[e], !orient(x$2, y$2, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1])) { | |
e = q; | |
if (e === start) { | |
e = -1; | |
break; | |
} | |
} | |
if (e === -1) { continue; } | |
var t = this$1._addTriangle(e, i$6, hullNext[e], -1, -1, hullTri[e]); | |
hullTri[i$6] = this$1._legalize(t + 2); | |
hullTri[e] = t; | |
hullSize++; | |
var n$1 = hullNext[e]; | |
while (q = hullNext[n$1], orient(x$2, y$2, coords[2 * n$1], coords[2 * n$1 + 1], coords[2 * q], coords[2 * q + 1])) { | |
t = this$1._addTriangle(n$1, i$6, q, hullTri[i$6], -1, hullTri[n$1]); | |
hullTri[i$6] = this$1._legalize(t + 2); | |
hullNext[n$1] = n$1; | |
hullSize--; | |
n$1 = q; | |
} | |
if (e === start) { | |
while (q = hullPrev[e], orient(x$2, y$2, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1])) { | |
t = this$1._addTriangle(q, i$6, e, -1, hullTri[e], hullTri[q]); | |
this$1._legalize(t + 2); | |
hullTri[q] = t; | |
hullNext[e] = e; | |
hullSize--; | |
e = q; | |
} | |
} | |
this$1.hullStart = hullPrev[i$6] = e; | |
hullNext[e] = hullPrev[n$1] = i$6; | |
hullNext[i$6] = n$1; | |
hullHash[this$1._hashKey(x$2, y$2)] = i$6; | |
hullHash[this$1._hashKey(coords[2 * e], coords[2 * e + 1])] = e; | |
} | |
this.hull = new Uint32Array(hullSize); | |
for (var i$7 = 0, e$1 = this.hullStart; i$7 < hullSize; i$7++) { | |
this$1.hull[i$7] = e$1; | |
e$1 = hullNext[e$1]; | |
} | |
this.hullPrev = this.hullNext = this.hullTri = null; | |
this.triangles = triangles.subarray(0, this.trianglesLen); | |
this.halfedges = halfedges.subarray(0, this.trianglesLen); | |
}; | |
Delaunator.from = function from (points, getX, getY) { | |
if ( getX === void 0 ) getX = defaultGetX; | |
if ( getY === void 0 ) getY = defaultGetY; | |
var n = points.length; | |
var coords = new Float64Array(n * 2); | |
for (var i = 0; i < n; i++) { | |
var p = points[i]; | |
coords[2 * i] = getX(p); | |
coords[2 * i + 1] = getY(p); | |
} | |
return new Delaunator(coords); | |
}; | |
Delaunator.prototype._hashKey = function _hashKey (x, y) { | |
return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize; | |
}; | |
Delaunator.prototype._legalize = function _legalize (a) { | |
var this$1 = this; | |
var ref = this; | |
var triangles = ref.triangles; | |
var coords = ref.coords; | |
var halfedges = ref.halfedges; | |
var b = halfedges[a]; | |
var a0 = a - a % 3; | |
var b0 = b - b % 3; | |
var al = a0 + (a + 1) % 3; | |
var ar = a0 + (a + 2) % 3; | |
var bl = b0 + (b + 2) % 3; | |
if (b === -1) { return ar; } | |
var p0 = triangles[ar]; | |
var pr = triangles[a]; | |
var pl = triangles[al]; | |
var p1 = triangles[bl]; | |
var illegal = inCircle( | |
coords[2 * p0], coords[2 * p0 + 1], | |
coords[2 * pr], coords[2 * pr + 1], | |
coords[2 * pl], coords[2 * pl + 1], | |
coords[2 * p1], coords[2 * p1 + 1]); | |
if (illegal) { | |
triangles[a] = p1; | |
triangles[b] = p0; | |
var hbl = halfedges[bl]; | |
if (hbl === -1) { | |
var e = this.hullStart; | |
do { | |
if (this$1.hullTri[e] === bl) { | |
this$1.hullTri[e] = a; | |
break; | |
} | |
e = this$1.hullNext[e]; | |
} while (e !== this.hullStart); | |
} | |
this._link(a, hbl); | |
this._link(b, halfedges[ar]); | |
this._link(ar, bl); | |
var br = b0 + (b + 1) % 3; | |
this._legalize(a); | |
return this._legalize(br); | |
} | |
return ar; | |
}; | |
Delaunator.prototype._link = function _link (a, b) { | |
this.halfedges[a] = b; | |
if (b !== -1) { this.halfedges[b] = a; } | |
}; | |
Delaunator.prototype._addTriangle = function _addTriangle (i0, i1, i2, a, b, c) { | |
var t = this.trianglesLen; | |
this.triangles[t] = i0; | |
this.triangles[t + 1] = i1; | |
this.triangles[t + 2] = i2; | |
this._link(t, a); | |
this._link(t + 1, b); | |
this._link(t + 2, c); | |
this.trianglesLen += 3; | |
return t; | |
}; | |
function pseudoAngle(dx, dy) { | |
var p = dx / (Math.abs(dx) + Math.abs(dy)); | |
return (dy > 0 ? 3 - p : 1 + p) / 4; | |
} | |
function dist(ax, ay, bx, by) { | |
var dx = ax - bx; | |
var dy = ay - by; | |
return dx * dx + dy * dy; | |
} | |
function orient(px, py, qx, qy, rx, ry) { | |
return (qy - py) * (rx - qx) - (qx - px) * (ry - qy) < 0; | |
} | |
function inCircle(ax, ay, bx, by, cx, cy, px, py) { | |
var dx = ax - px; | |
var dy = ay - py; | |
var ex = bx - px; | |
var ey = by - py; | |
var fx = cx - px; | |
var fy = cy - py; | |
var ap = dx * dx + dy * dy; | |
var bp = ex * ex + ey * ey; | |
var cp = fx * fx + fy * fy; | |
return dx * (ey * cp - bp * fy) - | |
dy * (ex * cp - bp * fx) + | |
ap * (ex * fy - ey * fx) < 0; | |
} | |
function circumradius(ax, ay, bx, by, cx, cy) { | |
var dx = bx - ax; | |
var dy = by - ay; | |
var ex = cx - ax; | |
var ey = cy - ay; | |
var bl = dx * dx + dy * dy; | |
var cl = ex * ex + ey * ey; | |
var d = 0.5 / (dx * ey - dy * ex); | |
var x = (ey * bl - dy * cl) * d; | |
var y = (dx * cl - ex * bl) * d; | |
return x * x + y * y; | |
} | |
function circumcenter(ax, ay, bx, by, cx, cy) { | |
var dx = bx - ax; | |
var dy = by - ay; | |
var ex = cx - ax; | |
var ey = cy - ay; | |
var bl = dx * dx + dy * dy; | |
var cl = ex * ex + ey * ey; | |
var d = 0.5 / (dx * ey - dy * ex); | |
var x = ax + (ey * bl - dy * cl) * d; | |
var y = ay + (dx * cl - ex * bl) * d; | |
return {x: x, y: y}; | |
} | |
function quicksort(ids, dists, left, right) { | |
if (right - left <= 20) { | |
for (var i = left + 1; i <= right; i++) { | |
var temp = ids[i]; | |
var tempDist = dists[temp]; | |
var j = i - 1; | |
while (j >= left && dists[ids[j]] > tempDist) { ids[j + 1] = ids[j--]; } | |
ids[j + 1] = temp; | |
} | |
} else { | |
var median = (left + right) >> 1; | |
var i$1 = left + 1; | |
var j$1 = right; | |
swap(ids, median, i$1); | |
if (dists[ids[left]] > dists[ids[right]]) { swap(ids, left, right); } | |
if (dists[ids[i$1]] > dists[ids[right]]) { swap(ids, i$1, right); } | |
if (dists[ids[left]] > dists[ids[i$1]]) { swap(ids, left, i$1); } | |
var temp$1 = ids[i$1]; | |
var tempDist$1 = dists[temp$1]; | |
while (true) { | |
do { i$1++; } while (dists[ids[i$1]] < tempDist$1); | |
do { j$1--; } while (dists[ids[j$1]] > tempDist$1); | |
if (j$1 < i$1) { break; } | |
swap(ids, i$1, j$1); | |
} | |
ids[left + 1] = ids[j$1]; | |
ids[j$1] = temp$1; | |
if (right - i$1 + 1 >= j$1 - left) { | |
quicksort(ids, dists, i$1, right); | |
quicksort(ids, dists, left, j$1 - 1); | |
} else { | |
quicksort(ids, dists, left, j$1 - 1); | |
quicksort(ids, dists, i$1, right); | |
} | |
} | |
} | |
function swap(arr, i, j) { | |
var tmp = arr[i]; | |
arr[i] = arr[j]; | |
arr[j] = tmp; | |
} | |
function defaultGetX(p) { | |
return p[0]; | |
} | |
function defaultGetY(p) { | |
return p[1]; | |
} | |
return Delaunator; | |
}))); |
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
<!DOCTYPE html> | |
<html> | |
<head> | |
<meta charset="utf-8" /> | |
<title>PSEUDO QUAD COHERENTTERRAIN based on DelaunatorJS</title> | |
<meta name="viewport" content="initial-scale=1,maximum-scale=1,user-scalable=no" /> | |
<script src="https://unpkg.com/three@0.116.0/build/three.min.js"></script> | |
<script src="https://unpkg.com/three@0.116.0/examples/js/controls/OrbitControls.js"></script> | |
<script src="simplex-noise.js"></script> | |
<script src="delaunator.3.0.2.js"></script> | |
<style>body { margin: 0; } </style> | |
</head> | |
<body> | |
<script> | |
var renderer, scene, camera, controls, loader, terrain, glsl, uniforms, root, tree, lastCameraPosition = new THREE.Vector3(0, 0, 0), EPSILON = 1E-1; | |
var simplex = new SimplexNoise(); | |
Number.prototype.between = function(domain_) { | |
var min = Math.min.apply(Math, [domain_[0], domain_[1]]), | |
max = Math.max.apply(Math, [domain_[0], domain_[1]]); | |
return this >= min && this <= max; | |
}; | |
class Node{ | |
constructor (level_, index_, centerX_, centerY_, width_, height_, resolution_){ | |
this.level = level_; | |
this.index = index_; | |
this.w = width_; | |
this.h = height_; | |
this.x = centerX_; | |
this.y = centerY_; | |
this.neighbours = { all: [], left: [], up: [], right: [], down: [] }; | |
this.resolution = resolution_; | |
this.lifetime = 128; | |
this.edges = this.getEdges(); | |
} | |
getSide = function(side_){ | |
if(side_ == "left") { return [new THREE.Vector3(this.x - this.w / 2, 0, this.y - this.h / 2), new THREE.Vector3(this.x - this.w / 2, 0, this.y + this.h / 2)]; } | |
else if(side_ == "right") { return [new THREE.Vector3(this.x + this.w / 2, 0, this.y - this.h / 2), new THREE.Vector3(this.x + this.w / 2, 0, this.y + this.h / 2)]; } | |
else if(side_ == "up") { return [new THREE.Vector3(this.x - this.w / 2, 0, this.y + this.h / 2), new THREE.Vector3(this.x + this.w / 2, 0, this.y + this.h / 2)]; } | |
else if(side_ == "down") { return [new THREE.Vector3(this.x - this.w / 2, 0, this.y - this.h / 2), new THREE.Vector3(this.x + this.w / 2, 0, this.y - this.h / 2)]; } | |
else { return null; } | |
} | |
getEdges = function(){ | |
return [ | |
new THREE.Vector3(this.x - this.w / 2, 0, this.y - this.h / 2), | |
new THREE.Vector3(this.x + this.w / 2, 0, this.y - this.h / 2), | |
new THREE.Vector3(this.x - this.w / 2, 0, this.y + this.h / 2), | |
new THREE.Vector3(this.x + this.w / 2, 0, this.y + this.h / 2) | |
]; | |
} | |
} | |
class Quadtree{ | |
constructor(root_, levels_, distance_){ | |
var this_ = this; | |
this.elevationMatrix2D = []; | |
for(var x = 0; x < 256; x ++){ | |
this.elevationMatrix2D[x] = []; | |
for(var y = 0; y < 256; y ++){ | |
this.elevationMatrix2D[x][y] = simplex.noise2D(y * 0.01, x * 0.01) * 16.0; | |
} | |
} | |
this.levels = levels_; | |
this.distance = distance_; | |
this.root = root_; | |
this.nodes = []; | |
this.nodes = this.splitNode(0, this.root, false); | |
this.last = [...this.nodes]; | |
this.tiles = {}; | |
this.debug = {}; | |
this.points = []; | |
this.generateLevels(); | |
this.nodes.forEach(function(node_){ this_.createTile(node_, 8); }); | |
} | |
generateLevels = function(){ | |
var this_ = this; | |
for(var i = 0; i < this.levels; i++){ | |
var tmpNodes = []; | |
for(var j = 0; j < this.nodes.length; j++){ | |
tmpNodes.push(...this.splitNode(j, this.nodes[j], true)); | |
} | |
this.nodes = tmpNodes; | |
} | |
var sorted = {}; | |
this.nodes.forEach(function(node_, i_){ | |
if(!sorted.hasOwnProperty(node_.level)){ sorted[node_.level] = [i_]; } | |
else { sorted[node_.level].push(i_); } | |
}) | |
if(sorted[1] != undefined){ | |
sorted[1].forEach(function(node_){ | |
var filtered = []; | |
if(sorted[2] != undefined) { filtered.push(...sorted[2]); } | |
if(sorted[3] != undefined) { filtered.push(...sorted[3]); } | |
if(sorted[4] != undefined) { filtered.push(...sorted[4]); } | |
if(sorted[5] != undefined) { filtered.push(...sorted[5]); } | |
filtered.forEach(function(subnode_){ | |
this_.lookForNeighbours(node_, subnode_); | |
}) | |
}) | |
} | |
if(sorted[2] != undefined){ | |
sorted[2].forEach(function(node_){ | |
var filtered = []; | |
if(sorted[3] != undefined) { filtered.push(...sorted[3]); } | |
if(sorted[4] != undefined) { filtered.push(...sorted[4]); } | |
if(sorted[5] != undefined) { filtered.push(...sorted[5]); } | |
filtered.forEach(function(subnode_){ | |
this_.lookForNeighbours(node_, subnode_); | |
}) | |
}) | |
} | |
if(sorted[3] != undefined){ | |
sorted[3].forEach(function(node_){ | |
var filtered = []; | |
if(sorted[4] != undefined) { filtered.push(...sorted[4]); } | |
if(sorted[5] != undefined) { filtered.push(...sorted[5]); } | |
filtered.forEach(function(subnode_){ | |
this_.lookForNeighbours(node_, subnode_); | |
}) | |
}) | |
} | |
if(sorted[4] != undefined){ | |
sorted[4].forEach(function(node_){ | |
var filtered = []; | |
if(sorted[5] != undefined) { filtered.push(...sorted[5]); } | |
filtered.forEach(function(subnode_){ | |
this_.lookForNeighbours(node_, subnode_); | |
}) | |
}) | |
} | |
var existed = {}; | |
scene.children.forEach(function(child_){ existed[child_.name] = true; }) | |
this.nodes.forEach(function(node_){ | |
var name = "tile" + node_.level + "_" + node_.index.x + "_" + node_.index.z; | |
if(existed.hasOwnProperty(name)) { | |
var geometry = this_.createGeometry(node_, 8); | |
if(scene.getObjectByName(name).geometry.attributes.position.array.length != geometry.attributes.position.array.length){ | |
scene.getObjectByName(name).geometry = geometry; | |
} | |
} | |
if(!existed.hasOwnProperty(name)) { this_.createTile(node_, 8); } | |
else { delete existed[name]; } | |
}); | |
Object.keys(existed).forEach(function(key_){ | |
if(scene.getObjectByName(key_) != undefined){ | |
scene.remove(scene.getObjectByName(key_)); | |
} | |
}) | |
this.last = [...this.nodes]; | |
} | |
clear() { | |
for(var i = scene.children.length - 1; i >= 0; i--) { | |
var obj = scene.children[i]; | |
scene.remove(obj); | |
} | |
} | |
createGeometry(parent_, segments_){ | |
var this_ = this; | |
var points = [], indices = [], quad_uvs = [], positions = []; | |
var geometry = new THREE.BufferGeometry(); | |
for(var x = 0; x < segments_; x++){ | |
for(var z = 0; z < segments_; z++){ | |
var dx = remapFloat(x, 0, segments_ - 1, parent_.x - parent_.w / 2, parent_.x + parent_.w / 2); | |
var dz = remapFloat(z, 0, segments_ - 1, parent_.y - parent_.h / 2, parent_.y + parent_.h / 2); | |
var nx = Math.floor(remapFloat(dx, -512, 512, 0, 255)); | |
var nz = Math.floor(remapFloat(dz, -512, 512, 0, 255)); | |
var dy = this.elevationMatrix2D[nx][nz]; | |
points.push(new THREE.Vector3(dx, dy, dz)); | |
} | |
} | |
var sides = Object.keys(parent_.neighbours); | |
sides.forEach(function(side_){ | |
parent_.neighbours[side_].forEach(function(neighbour_){ | |
if(side_ == "up") { points.push(...this_.getEdgePoints(neighbour_, [0, 8], [7, 8], 8)); } | |
if(side_ == "down") { points.push(...this_.getEdgePoints(neighbour_, [0, 8], [0, 1], 8)); } | |
if(side_ == "left") { points.push(...this_.getEdgePoints(neighbour_, [7, 8], [0, 8], 8)); } | |
if(side_ == "right") { points.push(...this_.getEdgePoints(neighbour_, [0, 1], [0, 8], 8));} | |
}) | |
}); | |
var delaunay = Delaunator.from(points.map(function(v_) { return [v_.x, v_.z]; })); | |
for(var i = 0; i < delaunay.triangles.length; i++){ indices.push(delaunay.triangles[i]); } | |
for(var i = 0; i < points.length; i++){ | |
var qx = remapFloat(points[i].x, parent_.x - parent_.w / 2, parent_.x + parent_.w / 2, 1, 0); | |
var qz = remapFloat(points[i].z, parent_.z - parent_.h / 2, parent_.z + parent_.h / 2, 0, 1); | |
quad_uvs.push(...[qx, qz]); | |
positions.push(...[points[i].x, points[i].y, points[i].z]) | |
} | |
var uvs = new Float32Array(quad_uvs); | |
geometry.setAttribute( "position", new THREE.BufferAttribute( new Float32Array(positions), 3 ) ); | |
geometry.setAttribute( "uv", new THREE.BufferAttribute( uvs, 2 ) ); | |
geometry.setIndex(indices); | |
geometry.computeVertexNormals(); | |
return geometry; | |
} | |
createTile(parent_, segments_){ | |
var this_ = this; | |
var points = [], indices = [], quad_uvs = [], positions = []; | |
var dist = new THREE.Vector2(parent_.x, parent_.y).distanceTo(new THREE.Vector2(0, 0)); | |
var rgb = {r: Math.floor(remapFloat(parent_.x, -512, 512, 0, 255)), g: Math.floor(remapFloat(dist, 1024, 0, 255, 0)), b: Math.floor(remapFloat(parent_.y, -512, 512, 0, 255)) }; | |
var geometry = new THREE.BufferGeometry(); | |
for(var x = 0; x < segments_; x++){ | |
for(var z = 0; z < segments_; z++){ | |
var dx = remapFloat(x, 0, segments_ - 1, parent_.x - parent_.w / 2, parent_.x + parent_.w / 2); | |
var dz = remapFloat(z, 0, segments_ - 1, parent_.y - parent_.h / 2, parent_.y + parent_.h / 2); | |
var nx = Math.floor(remapFloat(dx, -512, 512, 0, 255)); | |
var nz = Math.floor(remapFloat(dz, -512, 512, 0, 255)); | |
var dy = this.elevationMatrix2D[nx][nz]; | |
points.push(new THREE.Vector3(dx, dy, dz)); | |
} | |
} | |
var sides = Object.keys(parent_.neighbours); | |
sides.forEach(function(side_){ | |
parent_.neighbours[side_].forEach(function(neighbour_){ | |
if(side_ == "up") { points.push(...this_.getEdgePoints(neighbour_, [0, 8], [7, 8], 8)); } | |
if(side_ == "down") { points.push(...this_.getEdgePoints(neighbour_, [0, 8], [0, 1], 8)); } | |
if(side_ == "left") { points.push(...this_.getEdgePoints(neighbour_, [7, 8], [0, 8], 8)); } | |
if(side_ == "right") { points.push(...this_.getEdgePoints(neighbour_, [0, 1], [0, 8], 8));} | |
}) | |
}); | |
var delaunay = Delaunator.from(points.map(function(v_) { return [v_.x, v_.z]; })); | |
for(var i = 0; i < delaunay.triangles.length; i++){ indices.push(delaunay.triangles[i]); } | |
for(var i = 0; i < points.length; i++){ | |
var qx = remapFloat(points[i].x, parent_.x - parent_.w / 2, parent_.x + parent_.w / 2, 1, 0); | |
var qz = remapFloat(points[i].z, parent_.z - parent_.h / 2, parent_.z + parent_.h / 2, 0, 1); | |
quad_uvs.push(...[qx, qz]); | |
positions.push(...[points[i].x, points[i].y, points[i].z]) | |
} | |
var uvs = new Float32Array(quad_uvs); | |
geometry.setAttribute( "position", new THREE.BufferAttribute( new Float32Array(positions), 3 ) ); | |
geometry.setAttribute( "uv", new THREE.BufferAttribute( uvs, 2 ) ); | |
geometry.setIndex(indices); | |
geometry.computeVertexNormals(); | |
var plane = new THREE.Mesh(geometry, new THREE.MeshBasicMaterial({ color: new THREE.Color("rgb(" + rgb.r + "," + rgb.g + "," + rgb.b + ")"), wireframe: true })); | |
plane.name = "tile" + parent_.level + "_" + parent_.index.x + "_" + parent_.index.z; | |
scene.add(plane); | |
} | |
getEdgePoints(node_, xs_, zs_, segments_, side_){ | |
var points = []; | |
//var debug = {x: [], z: [] }; | |
for(var x = xs_[0]; x < xs_[1]; x++){ | |
for(var z = zs_[0]; z < zs_[1]; z++){ | |
var dx = remapFloat(x, 0, segments_ - 1, node_.x - node_.w / 2, node_.x + node_.w / 2); | |
var dz = remapFloat(z, 0, segments_ - 1, node_.y - node_.h / 2, node_.y + node_.h / 2); | |
var nx = Math.floor(remapFloat(dx, -512, 512, 0, 255)); | |
var nz = Math.floor(remapFloat(dz, -512, 512, 0, 255)); | |
var dy = this.elevationMatrix2D[nx][nz]; | |
points.push(new THREE.Vector3(dx, dy, dz)); | |
} | |
} | |
return points; | |
} | |
lookForNeighbours(node_, subnode_){ | |
var this_ = this; | |
var EPSILON = 1E-3; | |
var n = this.nodes[node_]; | |
var sub = this.nodes[subnode_]; | |
var r1 = { | |
up: { x1: n.x - n.w / 2, y1: n.y - n.h / 2, x2: n.x + n.w / 2, y2: n.y - n.h / 2 }, | |
down: { x1: n.x - n.w / 2, y1: n.y + n.h / 2, x2: n.x + n.w / 2, y2: n.y + n.h / 2 }, | |
left: { x1: n.x - n.w / 2, y1: n.y - n.h / 2, x2: n.x - n.w / 2, y2: n.y + n.h / 2 }, | |
right: { x1: n.x + n.w / 2, y1: n.y - n.h / 2, x2: n.x + n.w / 2, y2: n.y + n.h / 2 } | |
}; | |
var r2 = { | |
up: { x1: sub.x - sub.w / 2, y1: sub.y - sub.h / 2, x2: sub.x + sub.w / 2, y2: sub.y - sub.h / 2 }, | |
down: { x1: sub.x - sub.w / 2, y1: sub.y + sub.h / 2, x2: sub.x + sub.w / 2, y2: sub.y + sub.h / 2 }, | |
left: { x1: sub.x - sub.w / 2, y1: sub.y - sub.h / 2, x2: sub.x - sub.w / 2, y2: sub.y + sub.h / 2 }, | |
right: { x1: sub.x + sub.w / 2, y1: sub.y - sub.h / 2, x2: sub.x + sub.w / 2, y2: sub.y + sub.h / 2 } | |
} | |
var sides = Object.keys(r1); | |
if(r1.up.y1 == r2.down.y1 && this.isBetween(r2.down.x1, r1.up.x1, r1.up.x2) && this.isBetween(r2.down.x2, r1.up.x1, r1.up.x2)) { n.neighbours.up.push(sub); } | |
if(r1.down.y1 == r2.up.y1 && this.isBetween(r2.up.x1, r1.down.x1, r1.down.x2) && this.isBetween(r2.up.x2, r1.down.x1, r1.down.x2)) { n.neighbours.down.push(sub); } | |
if(r1.left.x1 == r2.right.x1 && this.isBetween(r2.right.y1, r1.left.y1, r1.left.y2) && this.isBetween(r2.right.y2, r1.left.y1, r1.left.y2)) { n.neighbours.left.push(sub);} | |
if(r1.right.x1 == r2.left.x1 && this.isBetween(r2.left.y1, r1.right.y1, r1.right.y2) && this.isBetween(r2.left.y2, r1.right.y1, r1.right.y2)) { n.neighbours.right.push(sub); } | |
} | |
isNeighbour(side0_, side1_){ return this.is_between(side1_[0], side0_); } | |
isBetween(v_, a_, b_) { var min = Math.min(a_, b_), max = Math.max(a_, b_); return v_ >= min && v_ <= max; } | |
dist2D = function(x1_, y1_, y2_, x2_){ return Math.sqrt(Math.pow(x2_ - x1_, 2) + Math.pow(y2_ - y1_, 2)); } | |
halfHyp = function(a_, b_) { return Math.sqrt(a_ * a_ + b_ * b_) / 2.0; } | |
update = function(){ | |
var this_ = this; | |
this.nodes = []; | |
this.nodes = this.splitNode(0, this.root, false); | |
this.generateLevels(); | |
} | |
splitNode = function(index_, parent_, check_){ | |
if((parent_.level < this.levels && this.sqrtDistance(parent_) < this.distance) || !check_){ | |
var lt = new Node(parent_.level + 1, { x: parent_.index.x * 2, z: parent_.index.z * 2 }, parent_.x - parent_.w / 4, parent_.y - parent_.h / 4, parent_.w / 2, parent_.h / 2, parent_.resolution); | |
var rt = new Node(parent_.level + 1, { x: parent_.index.x * 2, z: parent_.index.z * 2 + 1 }, parent_.x + parent_.w / 4, parent_.y - parent_.h / 4, parent_.w / 2, parent_.h / 2, parent_.resolution); | |
var lb = new Node(parent_.level + 1, { x: parent_.index.x * 2 + 1, z: parent_.index.z * 2 }, parent_.x - parent_.w / 4, parent_.y + parent_.h / 4, parent_.w / 2, parent_.h / 2, parent_.resolution); | |
var rb = new Node(parent_.level + 1, { x: parent_.index.x * 2 + 1, z: parent_.index.z * 2 + 1 }, parent_.x + parent_.w / 4, parent_.y + parent_.h / 4, parent_.w / 2, parent_.h / 2, parent_.resolution); | |
return [lt, rt, lb, rb]; | |
} | |
return [parent_]; | |
} | |
sqrtDistance = function(node_){ | |
var target = new THREE.Vector2(camera.position.x, camera.position.z).lerp(new THREE.Vector2(controls.target.x, controls.target.z), 1.0); | |
var x1 = node_.x - node_.w / 2.0; | |
var y1 = node_.y - node_.h / 2.0; | |
var x2 = node_.x + node_.w / 2.0; | |
var y2 = node_.y + node_.h / 2.0; | |
var rx = (x1 + x2) / 2.0; | |
var ry = (y1 + y2) / 2.0; | |
var rwidth = node_.w; | |
var rheight = node_.h; | |
var dx = Math.max(Math.abs(target.x - rx) - rwidth / 2, 0); | |
var dy = Math.max(Math.abs(target.y - ry) - rheight / 2, 0); | |
return Math.sqrt(dx * dx + dy * dy); | |
} | |
} | |
renderer = new THREE.WebGLRenderer({ antialias: true }); | |
renderer.setPixelRatio(window.devicePixelRatio); | |
renderer.setSize(window.innerWidth, window.innerHeight); | |
renderer.setClearColor(0x000000); | |
document.body.appendChild(renderer.domElement); | |
scene = new THREE.Scene(); | |
loader = new THREE.TextureLoader(); | |
loader.crossOrigin = ""; | |
camera = new THREE.PerspectiveCamera(50, window.innerWidth / window.innerHeight, 1, 51200); | |
camera.position.set(-2048, 2048, -2048); | |
lastCameraPosition.set(camera.position.x, camera.position.y, camera.position.z); | |
controls = new THREE.OrbitControls(camera, renderer.domElement); | |
controls.enableDamping = true; | |
controls.dampingFactor = 0.05; | |
controls.screenSpacePanning = false; | |
controls.minDistance = 8; | |
controls.maxDistance = 5120; | |
controls.maxPolarAngle = Math.PI / 2; | |
camera.position.set(-512, 512, -512); | |
controls.target.set(0, 0, 0); | |
root = new Node(0, {x: 0, z: 0}, 0, 0, 1024, 1024, 16); | |
tree = new Quadtree(root, 5, 32); | |
document.addEventListener("mousemove", onMouseMove, false); | |
animate(); | |
function animate(){ | |
controls.update(); | |
renderer.render(scene, camera); | |
requestAnimationFrame(animate); | |
if(camera.position.distanceTo(lastCameraPosition) > EPSILON){ | |
tree.update(); | |
lastCameraPosition.set(camera.position.x, camera.position.y, camera.position.z); | |
} | |
} | |
function lerpFloat(a_, b_, t_){ return a_ + t_ * (b_ - a_); } | |
function remapFloat(v_, min0_, max0_, min1_, max1_) { return min1_ + (v_ - min0_) / (max0_ - min0_) * (max1_ - min1_); } | |
function onMouseMove(e_){ | |
mouse = new THREE.Vector2(); | |
mouse.x = (e_.clientX / window.innerWidth) * 2 - 1; | |
mouse.y = -(e_.clientY / window.innerHeight) * 2 + 1; | |
} | |
</script> | |
</body> | |
</html> |
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
/* | |
* 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) 2018 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() { | |
'use strict'; | |
var F2 = 0.5 * (Math.sqrt(3.0) - 1.0); | |
var G2 = (3.0 - Math.sqrt(3.0)) / 6.0; | |
var F3 = 1.0 / 3.0; | |
var G3 = 1.0 / 6.0; | |
var F4 = (Math.sqrt(5.0) - 1.0) / 4.0; | |
var G4 = (5.0 - Math.sqrt(5.0)) / 20.0; | |
function SimplexNoise(randomOrSeed) { | |
var random; | |
if (typeof randomOrSeed == 'function') { | |
random = randomOrSeed; | |
} | |
else if (randomOrSeed) { | |
random = alea(randomOrSeed); | |
} else { | |
random = Math.random; | |
} | |
this.p = buildPermutationTable(random); | |
this.perm = new Uint8Array(512); | |
this.permMod12 = new Uint8Array(512); | |
for (var 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; | |
var perm = this.perm; | |
var grad3 = this.grad3; | |
var n0 = 0; // Noise contributions from the three corners | |
var n1 = 0; | |
var n2 = 0; | |
// 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) { | |
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) { | |
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) { | |
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; | |
var perm = this.perm; | |
var 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 perm = this.perm; | |
var 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); | |
} | |
}; | |
function buildPermutationTable(random) { | |
var i; | |
var p = new Uint8Array(256); | |
for (i = 0; i < 256; i++) { | |
p[i] = i; | |
} | |
for (i = 0; i < 255; i++) { | |
var r = i + ~~(random() * (256 - i)); | |
var aux = p[i]; | |
p[i] = p[r]; | |
p[r] = aux; | |
} | |
return p; | |
} | |
SimplexNoise._buildPermutationTable = buildPermutationTable; | |
/* | |
The ALEA PRNG and masher code used by simplex-noise.js | |
is based on code by Johannes Baagøe, modified by Jonas Wagner. | |
See alea.md for the full license. | |
*/ | |
function alea() { | |
var s0 = 0; | |
var s1 = 0; | |
var s2 = 0; | |
var c = 1; | |
var mash = masher(); | |
s0 = mash(' '); | |
s1 = mash(' '); | |
s2 = mash(' '); | |
for (var i = 0; i < arguments.length; i++) { | |
s0 -= mash(arguments[i]); | |
if (s0 < 0) { | |
s0 += 1; | |
} | |
s1 -= mash(arguments[i]); | |
if (s1 < 0) { | |
s1 += 1; | |
} | |
s2 -= mash(arguments[i]); | |
if (s2 < 0) { | |
s2 += 1; | |
} | |
} | |
mash = null; | |
return function() { | |
var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32 | |
s0 = s1; | |
s1 = s2; | |
return s2 = t - (c = t | 0); | |
}; | |
} | |
function masher() { | |
var n = 0xefc8249d; | |
return function(data) { | |
data = data.toString(); | |
for (var i = 0; i < data.length; i++) { | |
n += data.charCodeAt(i); | |
var h = 0.02519603282416938 * n; | |
n = h >>> 0; | |
h -= n; | |
h *= n; | |
n = h >>> 0; | |
h -= n; | |
n += h * 0x100000000; // 2^32 | |
} | |
return (n >>> 0) * 2.3283064365386963e-10; // 2^-32 | |
}; | |
} | |
// amd | |
if (typeof define !== 'undefined' && define.amd) define(function() {return SimplexNoise;}); | |
// common js | |
if (typeof exports !== 'undefined') exports.SimplexNoise = SimplexNoise; | |
// browser | |
else if (typeof window !== 'undefined') window.SimplexNoise = SimplexNoise; | |
// nodejs | |
if (typeof module !== 'undefined') { | |
module.exports = SimplexNoise; | |
} | |
})(); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment