heightmap selection - refactor, make generation immutable to get predictable result

utils/arrayUtils.js

@@ -1,7 +1,5 @@
 "use strict";
-// FMG utils related to arrays
 
-// return the last element of array
 function last(array) {
   return array[array.length - 1];
 }
@@ -37,9 +35,24 @@ function deepCopy(obj) {
     [Set, s => [...s.values()].map(dcAny)],
     [Date, d => new Date(d.getTime())],
     [Object, dcObject]
-    // other types will be referenced
     // ... extend here to implement their custom deep copy
   ]);
 
   return dcAny(obj);
 }
+
+function getTypedArray(maxValue) {
+  console.assert(
+    Number.isInteger(maxValue) && maxValue >= 0 && maxValue <= 4294967295,
+    `Array maxValue must be an integer between 0 and 4294967295, got ${maxValue}`
+  );
+
+  if (maxValue <= 255) return Uint8Array;
+  if (maxValue <= 65535) return Uint16Array;
+  if (maxValue <= 4294967295) return Uint32Array;
+  return Uint32Array;
+}
+
+function createTypedArray({maxValue, length}) {
+  return new (getTypedArray(maxValue))(length);
+}

utils/graphUtils.js

@@ -1,7 +1,60 @@
 "use strict";
 // FMG utils related to graph
 
-// add boundary points to pseudo-clip voronoi cells
+// check if new grid graph should be generated or we can use the existing one
+function shouldRegenerateGrid(grid) {
+  const cellsDesired = +byId("pointsInput").dataset.cells;
+  if (cellsDesired !== grid.cellsDesired) return true;
+
+  const newSpacing = rn(Math.sqrt((graphWidth * graphHeight) / cellsDesired), 2);
+  const newCellsX = Math.floor((graphWidth + 0.5 * newSpacing - 1e-10) / newSpacing);
+  const newCellsY = Math.floor((graphHeight + 0.5 * newSpacing - 1e-10) / newSpacing);
+
+  return grid.spacing !== newSpacing || grid.cellsX !== newCellsX || grid.cellsY !== newCellsY;
+}
+
+function generateGrid() {
+  Math.random = aleaPRNG(seed); // reset PRNG
+  const {spacing, cellsDesired, boundary, points, cellsX, cellsY} = placePoints();
+  const {cells, vertices} = calculateVoronoi(points, boundary);
+  return {spacing, cellsDesired, boundary, points, cellsX, cellsY, cells, vertices};
+}
+
+// place random points to calculate Voronoi diagram
+function placePoints() {
+  TIME && console.time("placePoints");
+  const cellsDesired = +byId("pointsInput").dataset.cells;
+  const spacing = rn(Math.sqrt((graphWidth * graphHeight) / cellsDesired), 2); // spacing between points before jirrering
+
+  const boundary = getBoundaryPoints(graphWidth, graphHeight, spacing);
+  const points = getJitteredGrid(graphWidth, graphHeight, spacing); // points of jittered square grid
+  const cellsX = Math.floor((graphWidth + 0.5 * spacing - 1e-10) / spacing);
+  const cellsY = Math.floor((graphHeight + 0.5 * spacing - 1e-10) / spacing);
+  TIME && console.timeEnd("placePoints");
+
+  return {spacing, cellsDesired, boundary, points, cellsX, cellsY};
+}
+
+// calculate Delaunay and then Voronoi diagram
+function calculateVoronoi(points, boundary) {
+  TIME && console.time("calculateDelaunay");
+  const allPoints = points.concat(boundary);
+  const delaunay = Delaunator.from(allPoints);
+  TIME && console.timeEnd("calculateDelaunay");
+
+  TIME && console.time("calculateVoronoi");
+  const n = points.length;
+  const voronoi = new Voronoi(delaunay, allPoints, n);
+
+  const cells = voronoi.cells;
+  cells.i = getTypedArray(n).from(d3.range(n)); // array of indexes
+  const vertices = voronoi.vertices;
+  TIME && console.timeEnd("calculateVoronoi");
+
+  return {cells, vertices};
+}
+
+// add points along map edge to pseudo-clip voronoi cells
 function getBoundaryPoints(width, height, spacing) {
   const offset = rn(-1 * spacing);
   const bSpacing = spacing * 2;
@@ -9,15 +62,18 @@ function getBoundaryPoints(width, height, spacing) {
   const h = height - offset * 2;
   const numberX = Math.ceil(w / bSpacing) - 1;
   const numberY = Math.ceil(h / bSpacing) - 1;
-  let points = [];
+  const points = [];
+
   for (let i = 0.5; i < numberX; i++) {
     let x = Math.ceil((w * i) / numberX + offset);
     points.push([x, offset], [x, h + offset]);
   }
+
   for (let i = 0.5; i < numberY; i++) {
     let y = Math.ceil((h * i) / numberY + offset);
     points.push([offset, y], [w + offset, y]);
   }
+
   return points;
 }
 
@@ -40,7 +96,7 @@ function getJitteredGrid(width, height, spacing) {
 }
 
 // return cell index on a regular square grid
-function findGridCell(x, y) {
+function findGridCell(x, y, grid) {
   return Math.floor(Math.min(y / grid.spacing, grid.cellsY - 1)) * grid.cellsX + Math.floor(Math.min(x / grid.spacing, grid.cellsX - 1));
 }
 
@@ -48,7 +104,7 @@ function findGridCell(x, y) {
 function findGridAll(x, y, radius) {
   const c = grid.cells.c;
   let r = Math.floor(radius / grid.spacing);
-  let found = [findGridCell(x, y)];
+  let found = [findGridCell(x, y, grid)];
   if (!r || radius === 1) return found;
   if (r > 0) found = found.concat(c[found[0]]);
   if (r > 1) {