From cc031529a182f4d45e48ab594a6205d0b7d7ea2a Mon Sep 17 00:00:00 2001 From: OLEGSHA Date: Sat, 2 Jan 2021 20:48:29 +0300 Subject: [PATCH] Added OpenSimplex2 and a fancy world generator --- README.md | 2 +- .../opensimplex2/areagen/OpenSimplex2S.java | 998 ++++++++++++++++++ .../progressia/server/PlayerManager.java | 2 +- .../progressia/test/LayerTestGUI.java | 16 + .../test/gen/TestTerrainGenerator.java | 126 +++ .../test/gen/TestWorldGenerator.java | 80 +- 6 files changed, 1187 insertions(+), 37 deletions(-) create mode 100644 src/main/java/kdotjpg/opensimplex2/areagen/OpenSimplex2S.java create mode 100644 src/main/java/ru/windcorp/progressia/test/gen/TestTerrainGenerator.java diff --git a/README.md b/README.md index a5b54ce..b6b96f1 100644 --- a/README.md +++ b/README.md @@ -42,5 +42,5 @@ plugins { * Google Guava * Trove4j * java-graphics/glm - GLM ported to Java. _Maven Central contains an outdated version, a custom repository used instead_ -* Apache Commons Math (_not currently used_) +* OpenSimplex2 * log4j diff --git a/src/main/java/kdotjpg/opensimplex2/areagen/OpenSimplex2S.java b/src/main/java/kdotjpg/opensimplex2/areagen/OpenSimplex2S.java new file mode 100644 index 0000000..ff22baf --- /dev/null +++ b/src/main/java/kdotjpg/opensimplex2/areagen/OpenSimplex2S.java @@ -0,0 +1,998 @@ +package kdotjpg.opensimplex2.areagen; +/* + * This file has been modified in the following ways: + * - added a package declaration at line 1; + * - added missing @Override annotations; + * - commented out line 965 due to unused variables. + * The original version of this file can be found at + * https://raw.githubusercontent.com/KdotJPG/OpenSimplex2/master/java/areagen/OpenSimplex2S.java + */ + +/** + * K.jpg's OpenSimplex 2, smooth variant ("SuperSimplex") + * With area generators. + * + * - 2D is standard simplex, modified to support larger kernels. + * Implemented using a lookup table. + * - 3D is "Re-oriented 8-point BCC noise" which constructs an + * isomorphic BCC lattice in a much different way than usual. + * + * Multiple versions of each function are provided. See the + * documentation above each, for more info. + */ +import java.util.Queue; +import java.util.LinkedList; +import java.util.Set; +import java.util.HashSet; + +public class OpenSimplex2S { + + private static final int PSIZE = 2048; + private static final int PMASK = 2047; + + private short[] perm; + private Grad2[] permGrad2; + private Grad3[] permGrad3; + + public OpenSimplex2S(long seed) { + perm = new short[PSIZE]; + permGrad2 = new Grad2[PSIZE]; + permGrad3 = new Grad3[PSIZE]; + short[] source = new short[PSIZE]; + for (short i = 0; i < PSIZE; i++) + source[i] = i; + for (int i = PSIZE - 1; i >= 0; i--) { + seed = seed * 6364136223846793005L + 1442695040888963407L; + int r = (int)((seed + 31) % (i + 1)); + if (r < 0) + r += (i + 1); + perm[i] = source[r]; + permGrad2[i] = GRADIENTS_2D[perm[i]]; + permGrad3[i] = GRADIENTS_3D[perm[i]]; + source[r] = source[i]; + } + } + + /* + * Traditional evaluators + */ + + /** + * 2D SuperSimplex noise, standard lattice orientation. + */ + public double noise2(double x, double y) { + + // Get points for A2* lattice + double s = 0.366025403784439 * (x + y); + double xs = x + s, ys = y + s; + + return noise2_Base(xs, ys); + } + + /** + * 2D SuperSimplex noise, with Y pointing down the main diagonal. + * Might be better for a 2D sandbox style game, where Y is vertical. + * Probably slightly less optimal for heightmaps or continent maps. + */ + public double noise2_XBeforeY(double x, double y) { + + // Skew transform and rotation baked into one. + double xx = x * 0.7071067811865476; + double yy = y * 1.224744871380249; + + return noise2_Base(yy + xx, yy - xx); + } + + /** + * 2D SuperSimplex noise base. + * Lookup table implementation inspired by DigitalShadow. + */ + private double noise2_Base(double xs, double ys) { + double value = 0; + + // Get base points and offsets + int xsb = fastFloor(xs), ysb = fastFloor(ys); + double xsi = xs - xsb, ysi = ys - ysb; + + // Index to point list + int a = (int)(xsi + ysi); + int index = + (a << 2) | + (int)(xsi - ysi / 2 + 1 - a / 2.0) << 3 | + (int)(ysi - xsi / 2 + 1 - a / 2.0) << 4; + + double ssi = (xsi + ysi) * -0.211324865405187; + double xi = xsi + ssi, yi = ysi + ssi; + + // Point contributions + for (int i = 0; i < 4; i++) { + LatticePoint2D c = LOOKUP_2D[index + i]; + + double dx = xi + c.dx, dy = yi + c.dy; + double attn = 2.0 / 3.0 - dx * dx - dy * dy; + if (attn <= 0) continue; + + int pxm = (xsb + c.xsv) & PMASK, pym = (ysb + c.ysv) & PMASK; + Grad2 grad = permGrad2[perm[pxm] ^ pym]; + double extrapolation = grad.dx * dx + grad.dy * dy; + + attn *= attn; + value += attn * attn * extrapolation; + } + + return value; + } + + /** + * 3D Re-oriented 8-point BCC noise, classic orientation + * Proper substitute for what 3D SuperSimplex would be, + * in light of Forbidden Formulae. + * Use noise3_XYBeforeZ or noise3_XZBeforeY instead, wherever appropriate. + */ + public double noise3_Classic(double x, double y, double z) { + + // Re-orient the cubic lattices via rotation, to produce the expected look on cardinal planar slices. + // If texturing objects that don't tend to have cardinal plane faces, you could even remove this. + // Orthonormal rotation. Not a skew transform. + double r = (2.0 / 3.0) * (x + y + z); + double xr = r - x, yr = r - y, zr = r - z; + + // Evaluate both lattices to form a BCC lattice. + return noise3_BCC(xr, yr, zr); + } + + /** + * 3D Re-oriented 8-point BCC noise, with better visual isotropy in (X, Y). + * Recommended for 3D terrain and time-varied animations. + * The Z coordinate should always be the "different" coordinate in your use case. + * If Y is vertical in world coordinates, call noise3_XYBeforeZ(x, z, Y) or use noise3_XZBeforeY. + * If Z is vertical in world coordinates, call noise3_XYBeforeZ(x, y, Z). + * For a time varied animation, call noise3_XYBeforeZ(x, y, T). + */ + public double noise3_XYBeforeZ(double x, double y, double z) { + + // Re-orient the cubic lattices without skewing, to make X and Y triangular like 2D. + // Orthonormal rotation. Not a skew transform. + double xy = x + y; + double s2 = xy * -0.211324865405187; + double zz = z * 0.577350269189626; + double xr = x + s2 - zz, yr = y + s2 - zz; + double zr = xy * 0.577350269189626 + zz; + + // Evaluate both lattices to form a BCC lattice. + return noise3_BCC(xr, yr, zr); + } + + /** + * 3D Re-oriented 8-point BCC noise, with better visual isotropy in (X, Z). + * Recommended for 3D terrain and time-varied animations. + * The Y coordinate should always be the "different" coordinate in your use case. + * If Y is vertical in world coordinates, call noise3_XZBeforeY(x, Y, z). + * If Z is vertical in world coordinates, call noise3_XZBeforeY(x, Z, y) or use noise3_XYBeforeZ. + * For a time varied animation, call noise3_XZBeforeY(x, T, y) or use noise3_XYBeforeZ. + */ + public double noise3_XZBeforeY(double x, double y, double z) { + + // Re-orient the cubic lattices without skewing, to make X and Z triangular like 2D. + // Orthonormal rotation. Not a skew transform. + double xz = x + z; + double s2 = xz * -0.211324865405187; + double yy = y * 0.577350269189626; + double xr = x + s2 - yy; double zr = z + s2 - yy; + double yr = xz * 0.577350269189626 + yy; + + // Evaluate both lattices to form a BCC lattice. + return noise3_BCC(xr, yr, zr); + } + + /** + * Generate overlapping cubic lattices for 3D Re-oriented BCC noise. + * Lookup table implementation inspired by DigitalShadow. + * It was actually faster to narrow down the points in the loop itself, + * than to build up the index with enough info to isolate 8 points. + */ + private double noise3_BCC(double xr, double yr, double zr) { + + // Get base and offsets inside cube of first lattice. + int xrb = fastFloor(xr), yrb = fastFloor(yr), zrb = fastFloor(zr); + double xri = xr - xrb, yri = yr - yrb, zri = zr - zrb; + + // Identify which octant of the cube we're in. This determines which cell + // in the other cubic lattice we're in, and also narrows down one point on each. + int xht = (int)(xri + 0.5), yht = (int)(yri + 0.5), zht = (int)(zri + 0.5); + int index = (xht << 0) | (yht << 1) | (zht << 2); + + // Point contributions + double value = 0; + LatticePoint3D c = LOOKUP_3D[index]; + while (c != null) { + double dxr = xri + c.dxr, dyr = yri + c.dyr, dzr = zri + c.dzr; + double attn = 0.75 - dxr * dxr - dyr * dyr - dzr * dzr; + if (attn < 0) { + c = c.nextOnFailure; + } else { + int pxm = (xrb + c.xrv) & PMASK, pym = (yrb + c.yrv) & PMASK, pzm = (zrb + c.zrv) & PMASK; + Grad3 grad = permGrad3[perm[perm[pxm] ^ pym] ^ pzm]; + double extrapolation = grad.dx * dxr + grad.dy * dyr + grad.dz * dzr; + + attn *= attn; + value += attn * attn * extrapolation; + c = c.nextOnSuccess; + } + } + return value; + } + + /* + * Area Generators + */ + + /** + * Generate the 2D noise over a large area. + * Propagates by flood-fill instead of iterating over a range. + * Results may occasionally slightly exceed [-1, 1] due to the grid-snapped pre-generated kernel. + */ + public void generate2(GenerateContext2D context, double[][] buffer, int x0, int y0) { + int height = buffer.length; + int width = buffer[0].length; + generate2(context, buffer, x0, y0, width, height, 0, 0); + } + + /** + * Generate the 2D noise over a large area. + * Propagates by flood-fill instead of iterating over a range. + * Results may occasionally slightly exceed [-1, 1] due to the grid-snapped pre-generated kernel. + */ + public void generate2(GenerateContext2D context, double[][] buffer, int x0, int y0, int width, int height, int skipX, int skipY) { + Queue queue = new LinkedList(); + Set seen = new HashSet(); + + int scaledRadiusX = context.scaledRadiusX; + int scaledRadiusY = context.scaledRadiusY; + double[][] kernel = context.kernel; + int x0Skipped = x0 + skipX, y0Skipped = y0 + skipY; + + // It seems that it's better for performance, to create a local copy. + // - Slightly faster than generating the kernel here. + // - Much faster than referencing it directly from the context object. + // - Much faster than computing the kernel equation every time. + // You can remove these lines if you find it's the opposite for you. + // You'll have to double the bounds again in GenerateContext2D + kernel = new double[scaledRadiusY * 2][/*scaledRadiusX * 2*/]; + for (int yy = 0; yy < scaledRadiusY; yy++) { + kernel[2 * scaledRadiusY - yy - 1] = kernel[yy] = (double[]) context.kernel[yy].clone(); + } + + // Get started with one point/vertex. + // For some lattices, you might need to try a handful of points in the cell, + // or flip a couple of coordinates, to guarantee it or a neighbor contributes. + // For An* lattices, the base coordinate seems fine. + double x0f = x0Skipped * context.xFrequency; double y0f = y0Skipped * context.yFrequency; + double x0s = context.orientation.s00 * x0f + context.orientation.s01 * y0f; + double y0s = context.orientation.s10 * x0f + context.orientation.s11 * y0f; + int x0sb = fastFloor(x0s), y0sb = fastFloor(y0s); + AreaGenLatticePoint2D firstPoint = new AreaGenLatticePoint2D(context, x0sb, y0sb); + queue.add(firstPoint); + seen.add(firstPoint); + + while (!queue.isEmpty()) { + AreaGenLatticePoint2D point = queue.remove(); + int destPointX = point.destPointX; + int destPointY = point.destPointY; + + // Prepare gradient vector + int pxm = point.xsv & PMASK, pym = point.ysv & PMASK; + Grad2 grad = context.orientation.gradients[perm[perm[pxm] ^ pym]]; + double gx = grad.dx * context.xFrequency; + double gy = grad.dy * context.yFrequency; + double gOff = 0.5 * (gx + gy); // to correct for (0.5, 0.5)-offset kernel + + // Contribution kernel bounds + int yy0 = destPointY - scaledRadiusY; if (yy0 < y0Skipped) yy0 = y0Skipped; + int yy1 = destPointY + scaledRadiusY; if (yy1 > y0 + height) yy1 = y0 + height; + + // For each row of the contribution circle, + for (int yy = yy0; yy < yy1; yy++) { + int dy = yy - destPointY; + int ky = dy + scaledRadiusY; + + // Set up bounds so we only loop over what we need to + int thisScaledRadiusX = context.kernelBounds[ky]; + int xx0 = destPointX - thisScaledRadiusX; if (xx0 < x0Skipped) xx0 = x0Skipped; + int xx1 = destPointX + thisScaledRadiusX; if (xx1 > x0 + width) xx1 = x0 + width; + + // For each point on that row + for (int xx = xx0; xx < xx1; xx++) { + int dx = xx - destPointX; + int kx = dx + scaledRadiusX; + + // gOff accounts for our choice to offset the pre-generated kernel by (0.5, 0.5) to avoid the zero center. + // I found almost no difference in performance using gOff vs not (under 1ns diff per value on my system) + double extrapolation = gx * dx + gy * dy + gOff; + buffer[yy - y0][xx - x0] += kernel[ky][kx] * extrapolation; + + } + } + + // For each neighbor of the point + for (int i = 0; i < NEIGHBOR_MAP_2D.length; i++) { + AreaGenLatticePoint2D neighbor = new AreaGenLatticePoint2D(context, + point.xsv + NEIGHBOR_MAP_2D[i][0], point.ysv + NEIGHBOR_MAP_2D[i][1]); + + // If it's in range of the buffer region and not seen before + if (neighbor.destPointX + scaledRadiusX >= x0Skipped && neighbor.destPointX - scaledRadiusX <= x0 + width - 1 + && neighbor.destPointY + scaledRadiusY >= y0Skipped && neighbor.destPointY - scaledRadiusY <= y0 + height - 1 + && !seen.contains(neighbor)) { + + // Add it to the queue so we can process it at some point + queue.add(neighbor); + + // Add it to the set so we don't add it to the queue again + seen.add(neighbor); + } + } + } + } + + /** + * Generate the 3D noise over a large area/volume. + * Propagates by flood-fill instead of iterating over a range. + * Results may occasionally slightly exceed [-1, 1] due to the grid-snapped pre-generated kernel. + */ + public void generate3(GenerateContext3D context, double[][][] buffer, int x0, int y0, int z0) { + int depth = buffer.length; + int height = buffer[0].length; + int width = buffer[0][0].length; + generate3(context, buffer, x0, y0, z0, width, height, depth, 0, 0, 0); + } + + /** + * Generate the 3D noise over a large area/volume. + * Propagates by flood-fill instead of iterating over a range. + * Results may occasionally slightly exceed [-1, 1] due to the grid-snapped pre-generated kernel. + */ + public void generate3(GenerateContext3D context, double[][][] buffer, int x0, int y0, int z0, int width, int height, int depth, int skipX, int skipY, int skipZ) { + Queue queue = new LinkedList(); + Set seen = new HashSet(); + + int scaledRadiusX = context.scaledRadiusX; + int scaledRadiusY = context.scaledRadiusY; + int scaledRadiusZ = context.scaledRadiusZ; + double[][][] kernel = context.kernel; + int x0Skipped = x0 + skipX, y0Skipped = y0 + skipY, z0Skipped = z0 + skipZ; + + // Quaternion multiplication for rotation. + // https://blog.molecular-matters.com/2013/05/24/a-faster-quaternion-vector-multiplication/ + double qx = context.orientation.qx, qy = context.orientation.qy, qz = context.orientation.qz, qw = context.orientation.qw; + double x0f = x0Skipped * context.xFrequency, y0f = y0Skipped * context.yFrequency, z0f = z0Skipped * context.zFrequency; + double tx = 2 * (qy * z0f - qz * y0f); + double ty = 2 * (qz * x0f - qx * z0f); + double tz = 2 * (qx * y0f - qy * x0f); + double x0r = x0f + qw * tx + (qy * tz - qz * ty); + double y0r = y0f + qw * ty + (qz * tx - qx * tz); + double z0r = z0f + qw * tz + (qx * ty - qy * tx); + + int x0rb = fastFloor(x0r), y0rb = fastFloor(y0r), z0rb = fastFloor(z0r); + + AreaGenLatticePoint3D firstPoint = new AreaGenLatticePoint3D(context, x0rb, y0rb, z0rb, 0); + queue.add(firstPoint); + seen.add(firstPoint); + + while (!queue.isEmpty()) { + AreaGenLatticePoint3D point = queue.remove(); + int destPointX = point.destPointX; + int destPointY = point.destPointY; + int destPointZ = point.destPointZ; + + // Prepare gradient vector + int pxm = point.xsv & PMASK, pym = point.ysv & PMASK, pzm = point.zsv & PMASK; + Grad3 grad = context.orientation.gradients[perm[perm[perm[pxm] ^ pym] ^ pzm]]; + double gx = grad.dx * context.xFrequency; + double gy = grad.dy * context.yFrequency; + double gz = grad.dz * context.zFrequency; + double gOff = 0.5 * (gx + gy + gz); // to correct for (0.5, 0.5, 0.5)-offset kernel + + // Contribution kernel bounds. + int zz0 = destPointZ - scaledRadiusZ; if (zz0 < z0Skipped) zz0 = z0Skipped; + int zz1 = destPointZ + scaledRadiusZ; if (zz1 > z0 + depth) zz1 = z0 + depth; + + // For each x/y slice of the contribution sphere, + for (int zz = zz0; zz < zz1; zz++) { + int dz = zz - destPointZ; + int kz = dz + scaledRadiusZ; + + // Set up bounds so we only loop over what we need to + int thisScaledRadiusY = context.kernelBoundsY[kz]; + int yy0 = destPointY - thisScaledRadiusY; if (yy0 < y0Skipped) yy0 = y0Skipped; + int yy1 = destPointY + thisScaledRadiusY; if (yy1 > y0 + height) yy1 = y0 + height; + + // For each row of the contribution circle, + for (int yy = yy0; yy < yy1; yy++) { + int dy = yy - destPointY; + int ky = dy + scaledRadiusY; + + // Set up bounds so we only loop over what we need to + int thisScaledRadiusX = context.kernelBoundsX[kz][ky]; + int xx0 = destPointX - thisScaledRadiusX; if (xx0 < x0Skipped) xx0 = x0Skipped; + int xx1 = destPointX + thisScaledRadiusX; if (xx1 > x0 + width) xx1 = x0 + width; + + // For each point on that row + for (int xx = xx0; xx < xx1; xx++) { + int dx = xx - destPointX; + int kx = dx + scaledRadiusX; + + // gOff accounts for our choice to offset the pre-generated kernel by (0.5, 0.5, 0.5) to avoid the zero center. + double extrapolation = gx * dx + gy * dy + gz * dz + gOff; + buffer[zz - z0][yy - y0][xx - x0] += kernel[kz][ky][kx] * extrapolation; + + } + } + } + + // For each neighbor of the point + for (int i = 0; i < NEIGHBOR_MAP_3D[0].length; i++) { + int l = point.lattice; + AreaGenLatticePoint3D neighbor = new AreaGenLatticePoint3D(context, + point.xsv + NEIGHBOR_MAP_3D[l][i][0], point.ysv + NEIGHBOR_MAP_3D[l][i][1], point.zsv + NEIGHBOR_MAP_3D[l][i][2], 1 ^ l); + + // If it's in range of the buffer region and not seen before + if (neighbor.destPointX + scaledRadiusX >= x0Skipped && neighbor.destPointX - scaledRadiusX <= x0 + width - 1 + && neighbor.destPointY + scaledRadiusY >= y0Skipped && neighbor.destPointY - scaledRadiusY <= y0 + height - 1 + && neighbor.destPointZ + scaledRadiusZ >= z0Skipped && neighbor.destPointZ - scaledRadiusZ <= z0 + depth - 1 + && !seen.contains(neighbor)) { + + // Add it to the queue so we can process it at some point + queue.add(neighbor); + + // Add it to the set so we don't add it to the queue again + seen.add(neighbor); + } + } + } + } + + /* + * Utility + */ + + private static int fastFloor(double x) { + int xi = (int)x; + return x < xi ? xi - 1 : xi; + } + + /* + * Definitions + */ + + private static final LatticePoint2D[] LOOKUP_2D; + private static final LatticePoint3D[] LOOKUP_3D; + static { + LOOKUP_2D = new LatticePoint2D[8 * 4]; + LOOKUP_3D = new LatticePoint3D[8]; + + for (int i = 0; i < 8; i++) { + int i1, j1, i2, j2; + if ((i & 1) == 0) { + if ((i & 2) == 0) { i1 = -1; j1 = 0; } else { i1 = 1; j1 = 0; } + if ((i & 4) == 0) { i2 = 0; j2 = -1; } else { i2 = 0; j2 = 1; } + } else { + if ((i & 2) != 0) { i1 = 2; j1 = 1; } else { i1 = 0; j1 = 1; } + if ((i & 4) != 0) { i2 = 1; j2 = 2; } else { i2 = 1; j2 = 0; } + } + LOOKUP_2D[i * 4 + 0] = new LatticePoint2D(0, 0); + LOOKUP_2D[i * 4 + 1] = new LatticePoint2D(1, 1); + LOOKUP_2D[i * 4 + 2] = new LatticePoint2D(i1, j1); + LOOKUP_2D[i * 4 + 3] = new LatticePoint2D(i2, j2); + } + + for (int i = 0; i < 8; i++) { + int i1, j1, k1, i2, j2, k2; + i1 = (i >> 0) & 1; j1 = (i >> 1) & 1; k1 = (i >> 2) & 1; + i2 = i1 ^ 1; j2 = j1 ^ 1; k2 = k1 ^ 1; + + // The two points within this octant, one from each of the two cubic half-lattices. + LatticePoint3D c0 = new LatticePoint3D(i1, j1, k1, 0); + LatticePoint3D c1 = new LatticePoint3D(i1 + i2, j1 + j2, k1 + k2, 1); + + // (1, 0, 0) vs (0, 1, 1) away from octant. + LatticePoint3D c2 = new LatticePoint3D(i1 ^ 1, j1, k1, 0); + LatticePoint3D c3 = new LatticePoint3D(i1, j1 ^ 1, k1 ^ 1, 0); + + // (1, 0, 0) vs (0, 1, 1) away from octant, on second half-lattice. + LatticePoint3D c4 = new LatticePoint3D(i1 + (i2 ^ 1), j1 + j2, k1 + k2, 1); + LatticePoint3D c5 = new LatticePoint3D(i1 + i2, j1 + (j2 ^ 1), k1 + (k2 ^ 1), 1); + + // (0, 1, 0) vs (1, 0, 1) away from octant. + LatticePoint3D c6 = new LatticePoint3D(i1, j1 ^ 1, k1, 0); + LatticePoint3D c7 = new LatticePoint3D(i1 ^ 1, j1, k1 ^ 1, 0); + + // (0, 1, 0) vs (1, 0, 1) away from octant, on second half-lattice. + LatticePoint3D c8 = new LatticePoint3D(i1 + i2, j1 + (j2 ^ 1), k1 + k2, 1); + LatticePoint3D c9 = new LatticePoint3D(i1 + (i2 ^ 1), j1 + j2, k1 + (k2 ^ 1), 1); + + // (0, 0, 1) vs (1, 1, 0) away from octant. + LatticePoint3D cA = new LatticePoint3D(i1, j1, k1 ^ 1, 0); + LatticePoint3D cB = new LatticePoint3D(i1 ^ 1, j1 ^ 1, k1, 0); + + // (0, 0, 1) vs (1, 1, 0) away from octant, on second half-lattice. + LatticePoint3D cC = new LatticePoint3D(i1 + i2, j1 + j2, k1 + (k2 ^ 1), 1); + LatticePoint3D cD = new LatticePoint3D(i1 + (i2 ^ 1), j1 + (j2 ^ 1), k1 + k2, 1); + + // First two points are guaranteed. + c0.nextOnFailure = c0.nextOnSuccess = c1; + c1.nextOnFailure = c1.nextOnSuccess = c2; + + // If c2 is in range, then we know c3 and c4 are not. + c2.nextOnFailure = c3; c2.nextOnSuccess = c5; + c3.nextOnFailure = c4; c3.nextOnSuccess = c4; + + // If c4 is in range, then we know c5 is not. + c4.nextOnFailure = c5; c4.nextOnSuccess = c6; + c5.nextOnFailure = c5.nextOnSuccess = c6; + + // If c6 is in range, then we know c7 and c8 are not. + c6.nextOnFailure = c7; c6.nextOnSuccess = c9; + c7.nextOnFailure = c8; c7.nextOnSuccess = c8; + + // If c8 is in range, then we know c9 is not. + c8.nextOnFailure = c9; c8.nextOnSuccess = cA; + c9.nextOnFailure = c9.nextOnSuccess = cA; + + // If cA is in range, then we know cB and cC are not. + cA.nextOnFailure = cB; cA.nextOnSuccess = cD; + cB.nextOnFailure = cC; cB.nextOnSuccess = cC; + + // If cC is in range, then we know cD is not. + cC.nextOnFailure = cD; cC.nextOnSuccess = null; + cD.nextOnFailure = cD.nextOnSuccess = null; + + LOOKUP_3D[i] = c0; + + } + } + + // Hexagon surrounding each vertex. + private static final int[][] NEIGHBOR_MAP_2D = { + { 1, 0 }, { 1, 1 }, { 0, 1 }, { 0, -1 }, { -1, -1 }, { -1, 0 } + }; + + // Cube surrounding each vertex. + // Alternates between half-lattices. + private static final int[][][] NEIGHBOR_MAP_3D = { + { + { 1024, 1024, 1024 }, { 1025, 1024, 1024 }, { 1024, 1025, 1024 }, { 1025, 1025, 1024 }, + { 1024, 1024, 1025 }, { 1025, 1024, 1025 }, { 1024, 1025, 1025 }, { 1025, 1025, 1025 } + }, + { + { -1024, -1024, -1024 }, { -1025, -1024, 1024 }, { -1024, -1025, -1024 }, { -1025, -1025, -1024 }, + { -1024, -1024, -1025 }, { -1025, -1024, -1025 }, { -1024, -1025, -1025 }, { -1025, -1025, 1025 } + }, + }; + + private static class LatticePoint2D { + int xsv, ysv; + double dx, dy; + public LatticePoint2D(int xsv, int ysv) { + this.xsv = xsv; this.ysv = ysv; + double ssv = (xsv + ysv) * -0.211324865405187; + this.dx = -xsv - ssv; + this.dy = -ysv - ssv; + } + } + + private static class LatticePoint3D { + public double dxr, dyr, dzr; + public int xrv, yrv, zrv; + LatticePoint3D nextOnFailure, nextOnSuccess; + public LatticePoint3D(int xrv, int yrv, int zrv, int lattice) { + this.dxr = -xrv + lattice * 0.5; this.dyr = -yrv + lattice * 0.5; this.dzr = -zrv + lattice * 0.5; + this.xrv = xrv + lattice * 1024; this.yrv = yrv + lattice * 1024; this.zrv = zrv + lattice * 1024; + } + } + + private static class AreaGenLatticePoint2D { + int xsv, ysv; + int destPointX, destPointY; + public AreaGenLatticePoint2D(GenerateContext2D context, int xsv, int ysv) { + this.xsv = xsv; this.ysv = ysv; + + //Matrix multiplication for inverse rotation. Simplex skew transforms have always been shorthand for matrices. + this.destPointX = (int)Math.ceil((context.orientation.t00 * xsv + context.orientation.t01 * ysv) * context.xFrequencyInverse); + this.destPointY = (int)Math.ceil((context.orientation.t10 * xsv + context.orientation.t11 * ysv) * context.yFrequencyInverse); + } + @Override + public int hashCode() { + return xsv * 7841 + ysv; + } + @Override + public boolean equals(Object obj) { + if (!(obj instanceof AreaGenLatticePoint2D)) return false; + AreaGenLatticePoint2D other = (AreaGenLatticePoint2D) obj; + return (other.xsv == this.xsv && other.ysv == this.ysv); + } + } + + private static class AreaGenLatticePoint3D { + int xsv, ysv, zsv, lattice; + int destPointX, destPointY, destPointZ; + public AreaGenLatticePoint3D(GenerateContext3D context, int xsv, int ysv, int zsv, int lattice) { + this.xsv = xsv; this.ysv = ysv; this.zsv = zsv; this.lattice = lattice; + double xr = (xsv - lattice * 1024.5); + double yr = (ysv - lattice * 1024.5); + double zr = (zsv - lattice * 1024.5); + + // Quaternion multiplication for inverse rotation. + // https://blog.molecular-matters.com/2013/05/24/a-faster-quaternion-vector-multiplication/ + double qx = -context.orientation.qx, qy = -context.orientation.qy, qz = -context.orientation.qz, qw = context.orientation.qw; + double tx = 2 * (qy * zr - qz * yr); + double ty = 2 * (qz * xr - qx * zr); + double tz = 2 * (qx * yr - qy * xr); + double xrr = xr + qw * tx + (qy * tz - qz * ty); + double yrr = yr + qw * ty + (qz * tx - qx * tz); + double zrr = zr + qw * tz + (qx * ty - qy * tx); + + this.destPointX = (int)Math.ceil(xrr * context.xFrequencyInverse); + this.destPointY = (int)Math.ceil(yrr * context.yFrequencyInverse); + this.destPointZ = (int)Math.ceil(zrr * context.zFrequencyInverse); + } + @Override + public int hashCode() { + return xsv * 2122193 + ysv * 2053 + zsv * 2 + lattice; + } + @Override + public boolean equals(Object obj) { + if (!(obj instanceof AreaGenLatticePoint3D)) return false; + AreaGenLatticePoint3D other = (AreaGenLatticePoint3D) obj; + return (other.xsv == this.xsv && other.ysv == this.ysv && other.zsv == this.zsv && other.lattice == this.lattice); + } + } + + public static class GenerateContext2D { + + double xFrequency; + double yFrequency; + double xFrequencyInverse; + double yFrequencyInverse; + int scaledRadiusX; + int scaledRadiusY; + double[][] kernel; + int[] kernelBounds; + LatticeOrientation2D orientation; + + public GenerateContext2D(LatticeOrientation2D orientation, double xFrequency, double yFrequency, double amplitude) { + + // These will be used by every call to generate + this.orientation = orientation; + this.xFrequency = xFrequency; + this.yFrequency = yFrequency; + this.xFrequencyInverse = 1.0 / xFrequency; + this.yFrequencyInverse = 1.0 / yFrequency; + + double preciseScaledRadiusX = Math.sqrt(2.0 / 3.0) * xFrequencyInverse; + double preciseScaledRadiusY = Math.sqrt(2.0 / 3.0) * yFrequencyInverse; + + // 0.25 because we offset center by 0.5 + this.scaledRadiusX = (int)Math.ceil(preciseScaledRadiusX + 0.25); + this.scaledRadiusY = (int)Math.ceil(preciseScaledRadiusY + 0.25); + + // So will these + kernel = new double[scaledRadiusY/* * 2*/][]; + kernelBounds = new int[scaledRadiusY * 2]; + for (int yy = 0; yy < scaledRadiusY * 2; yy++) { + + // Pre-generate boundary of circle + kernelBounds[yy] = (int)Math.ceil( + Math.sqrt(1.0 + - (yy + 0.5 - scaledRadiusY) * (yy + 0.5 - scaledRadiusY) / (scaledRadiusY * scaledRadiusY) + ) * scaledRadiusX); + + if (yy < scaledRadiusY) { + kernel[yy] = new double[scaledRadiusX * 2]; + + // Pre-generate kernel + for (int xx = 0; xx < scaledRadiusX * 2; xx++) { + double dx = (xx + 0.5 - scaledRadiusX) * xFrequency; + double dy = (yy + 0.5 - scaledRadiusY) * yFrequency; + double attn = (2.0 / 3.0) - dx * dx - dy * dy; + if (attn > 0) { + attn *= attn; + kernel[yy][xx] = attn * attn * amplitude; + } else { + kernel[yy][xx] = 0.0; + } + } + } /* else kernel[yy] = kernel[2 * scaledRadiusY - yy - 1];*/ + } + } + } + + public static class GenerateContext3D { + + double xFrequency; + double yFrequency; + double zFrequency; + double xFrequencyInverse; + double yFrequencyInverse; + double zFrequencyInverse; + int scaledRadiusX; + int scaledRadiusY; + int scaledRadiusZ; + double[][][] kernel; + int[] kernelBoundsY; + int[][] kernelBoundsX; + LatticeOrientation3D orientation; + + public GenerateContext3D(LatticeOrientation3D orientation, double xFrequency, double yFrequency, double zFrequency, double amplitude) { + + // These will be used by every call to generate + this.orientation = orientation; + this.xFrequency = xFrequency; + this.yFrequency = yFrequency; + this.zFrequency = zFrequency; + this.xFrequencyInverse = 1.0 / xFrequency; + this.yFrequencyInverse = 1.0 / yFrequency; + this.zFrequencyInverse = 1.0 / zFrequency; + + double preciseScaledRadiusX = Math.sqrt(0.75) * xFrequencyInverse; + double preciseScaledRadiusY = Math.sqrt(0.75) * yFrequencyInverse; + double preciseScaledRadiusZ = Math.sqrt(0.75) * zFrequencyInverse; + + // 0.25 because we offset center by 0.5 + this.scaledRadiusX = (int)Math.ceil(preciseScaledRadiusX + 0.25); + this.scaledRadiusY = (int)Math.ceil(preciseScaledRadiusY + 0.25); + this.scaledRadiusZ = (int)Math.ceil(preciseScaledRadiusZ + 0.25); + + // So will these + kernel = new double[scaledRadiusZ * 2][][]; + kernelBoundsY = new int[scaledRadiusZ * 2]; + kernelBoundsX = new int[scaledRadiusZ * 2][]; + for (int zz = 0; zz < scaledRadiusZ * 2; zz++) { + + // Pre-generate boundary of sphere + kernelBoundsY[zz] = (int)Math.ceil( + Math.sqrt(1.0 - (zz + 0.5 - scaledRadiusZ) * (zz + 0.5 - scaledRadiusZ) + / (scaledRadiusZ * scaledRadiusZ)) * scaledRadiusY); + + if (zz < scaledRadiusZ) { + kernel[zz] = new double[scaledRadiusY * 2][]; + kernelBoundsX[zz] = new int[scaledRadiusY * 2]; + } else { + kernel[zz] = kernel[2 * scaledRadiusZ - zz - 1]; + kernelBoundsX[zz] = kernelBoundsX[2 * scaledRadiusZ - zz - 1]; + } + + if (zz < scaledRadiusZ) { + for (int yy = 0; yy < scaledRadiusY * 2; yy++) { + + // Pre-generate boundary of sphere + kernelBoundsX[zz][yy] = (int)Math.ceil( + Math.sqrt(1.0 + - (yy + 0.5 - scaledRadiusY) * (yy + 0.5 - scaledRadiusY) / (scaledRadiusY * scaledRadiusY) + - (zz + 0.5 - scaledRadiusZ) * (zz + 0.5 - scaledRadiusZ) / (scaledRadiusZ * scaledRadiusZ) + ) * scaledRadiusX); + + if (yy < scaledRadiusY) { + kernel[zz][yy] = new double[scaledRadiusX * 2]; + + // Pre-generate kernel + for (int xx = 0; xx < scaledRadiusX * 2; xx++) { + double dx = (xx + 0.5 - scaledRadiusX) * xFrequency; + double dy = (yy + 0.5 - scaledRadiusY) * yFrequency; + double dz = (zz + 0.5 - scaledRadiusZ) * zFrequency; + double attn = 0.75 - dx * dx - dy * dy - dz * dz; + if (attn > 0) { + attn *= attn; + kernel[zz][yy][xx] = attn * attn * amplitude; + } else { + kernel[zz][yy][xx] = 0.0; + } + } + + } else kernel[zz][yy] = kernel[zz][2 * scaledRadiusY - yy - 1]; + } + } + } + } + } + + public enum LatticeOrientation2D { + // Simplex skew transforms have always been shorthand for the matrices they represent. + // But when we bake the rotation into the skew transform, we need to use the general form. + Standard(GRADIENTS_2D, + 1.366025403784439, 0.366025403784439, 0.366025403784439, 1.366025403784439, + 0.788675134594813, -0.211324865405187, -0.211324865405187, 0.788675134594813), + XBeforeY(GRADIENTS_2D_X_BEFORE_Y, + 0.7071067811865476, 1.224744871380249, -0.7071067811865476, 1.224744871380249, + 0.7071067811865476, -0.7071067811865476, 0.40824829046764305, 0.40824829046764305); + + Grad2[] gradients; + double s00, s01, s10, s11; + double t00, t01, t10, t11; + + private LatticeOrientation2D(Grad2[] gradients, + double s00, double s01, double s10, double s11, + double t00, double t01, double t10, double t11) { + this.gradients = gradients; + this.s00 = s00; this.s01 = s01; this.s10 = s10; this.s11 = s11; + this.t00 = t00; this.t01 = t01; this.t10 = t10; this.t11 = t11; + } + } + + public enum LatticeOrientation3D { + // Quaternions for 3D. Could use matrices, but I already wrote this code before I moved them into here. + Classic(GRADIENTS_3D_CLASSIC, 0.577350269189626, 0.577350269189626, 0.577350269189626, 0), + XYBeforeZ(GRADIENTS_3D_XY_BEFORE_Z, 0.3250575836718682, -0.3250575836718682, 0, 0.8880738339771154), + XZBeforeY(GRADIENTS_3D_XZ_BEFORE_Y, -0.3250575836718682, 0, 0.3250575836718682, 0.8880738339771154); + + Grad3[] gradients; + double qx, qy, qz, qw; + + private LatticeOrientation3D(Grad3[] gradients, double qx, double qy, double qz, double qw) { + this.gradients = gradients; + this.qx = qx; this.qy = qy; this.qz = qz; this.qw = qw; + } + } + + /* + * Gradients + */ + + public static class Grad2 { + double dx, dy; + public Grad2(double dx, double dy) { + this.dx = dx; this.dy = dy; + } + } + + public static class Grad3 { + double dx, dy, dz; + public Grad3(double dx, double dy, double dz) { + this.dx = dx; this.dy = dy; this.dz = dz; + } + } + + public static final double N2 = 0.05481866495625118; + public static final double N3 = 0.2781926117527186; + private static final Grad2[] GRADIENTS_2D, GRADIENTS_2D_X_BEFORE_Y; + private static final Grad3[] GRADIENTS_3D, GRADIENTS_3D_CLASSIC, GRADIENTS_3D_XY_BEFORE_Z, GRADIENTS_3D_XZ_BEFORE_Y; + static { + + GRADIENTS_2D = new Grad2[PSIZE]; + GRADIENTS_2D_X_BEFORE_Y = new Grad2[PSIZE]; + Grad2[] grad2 = { + new Grad2( 0.130526192220052, 0.99144486137381), + new Grad2( 0.38268343236509, 0.923879532511287), + new Grad2( 0.608761429008721, 0.793353340291235), + new Grad2( 0.793353340291235, 0.608761429008721), + new Grad2( 0.923879532511287, 0.38268343236509), + new Grad2( 0.99144486137381, 0.130526192220051), + new Grad2( 0.99144486137381, -0.130526192220051), + new Grad2( 0.923879532511287, -0.38268343236509), + new Grad2( 0.793353340291235, -0.60876142900872), + new Grad2( 0.608761429008721, -0.793353340291235), + new Grad2( 0.38268343236509, -0.923879532511287), + new Grad2( 0.130526192220052, -0.99144486137381), + new Grad2(-0.130526192220052, -0.99144486137381), + new Grad2(-0.38268343236509, -0.923879532511287), + new Grad2(-0.608761429008721, -0.793353340291235), + new Grad2(-0.793353340291235, -0.608761429008721), + new Grad2(-0.923879532511287, -0.38268343236509), + new Grad2(-0.99144486137381, -0.130526192220052), + new Grad2(-0.99144486137381, 0.130526192220051), + new Grad2(-0.923879532511287, 0.38268343236509), + new Grad2(-0.793353340291235, 0.608761429008721), + new Grad2(-0.608761429008721, 0.793353340291235), + new Grad2(-0.38268343236509, 0.923879532511287), + new Grad2(-0.130526192220052, 0.99144486137381) + }; + Grad2[] grad2XBeforeY = new Grad2[grad2.length]; + for (int i = 0; i < grad2.length; i++) { + grad2[i].dx /= N2; grad2[i].dy /= N2; + + // Unrotated gradients for XBeforeY 2D + double xx = grad2[i].dx * 0.7071067811865476; + double yy = grad2[i].dy * 0.7071067811865476; + grad2XBeforeY[i] = new Grad2(xx - yy, xx + yy); + } + for (int i = 0; i < PSIZE; i++) { + GRADIENTS_2D[i] = grad2[i % grad2.length]; + GRADIENTS_2D_X_BEFORE_Y[i] = grad2XBeforeY[i % grad2XBeforeY.length]; + } + + GRADIENTS_3D = new Grad3[PSIZE]; + GRADIENTS_3D_CLASSIC = new Grad3[PSIZE]; + GRADIENTS_3D_XY_BEFORE_Z = new Grad3[PSIZE]; + GRADIENTS_3D_XZ_BEFORE_Y = new Grad3[PSIZE]; + Grad3[] grad3 = { + new Grad3(-2.22474487139, -2.22474487139, -1.0), + new Grad3(-2.22474487139, -2.22474487139, 1.0), + new Grad3(-3.0862664687972017, -1.1721513422464978, 0.0), + new Grad3(-1.1721513422464978, -3.0862664687972017, 0.0), + new Grad3(-2.22474487139, -1.0, -2.22474487139), + new Grad3(-2.22474487139, 1.0, -2.22474487139), + new Grad3(-1.1721513422464978, 0.0, -3.0862664687972017), + new Grad3(-3.0862664687972017, 0.0, -1.1721513422464978), + new Grad3(-2.22474487139, -1.0, 2.22474487139), + new Grad3(-2.22474487139, 1.0, 2.22474487139), + new Grad3(-3.0862664687972017, 0.0, 1.1721513422464978), + new Grad3(-1.1721513422464978, 0.0, 3.0862664687972017), + new Grad3(-2.22474487139, 2.22474487139, -1.0), + new Grad3(-2.22474487139, 2.22474487139, 1.0), + new Grad3(-1.1721513422464978, 3.0862664687972017, 0.0), + new Grad3(-3.0862664687972017, 1.1721513422464978, 0.0), + new Grad3(-1.0, -2.22474487139, -2.22474487139), + new Grad3( 1.0, -2.22474487139, -2.22474487139), + new Grad3( 0.0, -3.0862664687972017, -1.1721513422464978), + new Grad3( 0.0, -1.1721513422464978, -3.0862664687972017), + new Grad3(-1.0, -2.22474487139, 2.22474487139), + new Grad3( 1.0, -2.22474487139, 2.22474487139), + new Grad3( 0.0, -1.1721513422464978, 3.0862664687972017), + new Grad3( 0.0, -3.0862664687972017, 1.1721513422464978), + new Grad3(-1.0, 2.22474487139, -2.22474487139), + new Grad3( 1.0, 2.22474487139, -2.22474487139), + new Grad3( 0.0, 1.1721513422464978, -3.0862664687972017), + new Grad3( 0.0, 3.0862664687972017, -1.1721513422464978), + new Grad3(-1.0, 2.22474487139, 2.22474487139), + new Grad3( 1.0, 2.22474487139, 2.22474487139), + new Grad3( 0.0, 3.0862664687972017, 1.1721513422464978), + new Grad3( 0.0, 1.1721513422464978, 3.0862664687972017), + new Grad3( 2.22474487139, -2.22474487139, -1.0), + new Grad3( 2.22474487139, -2.22474487139, 1.0), + new Grad3( 1.1721513422464978, -3.0862664687972017, 0.0), + new Grad3( 3.0862664687972017, -1.1721513422464978, 0.0), + new Grad3( 2.22474487139, -1.0, -2.22474487139), + new Grad3( 2.22474487139, 1.0, -2.22474487139), + new Grad3( 3.0862664687972017, 0.0, -1.1721513422464978), + new Grad3( 1.1721513422464978, 0.0, -3.0862664687972017), + new Grad3( 2.22474487139, -1.0, 2.22474487139), + new Grad3( 2.22474487139, 1.0, 2.22474487139), + new Grad3( 1.1721513422464978, 0.0, 3.0862664687972017), + new Grad3( 3.0862664687972017, 0.0, 1.1721513422464978), + new Grad3( 2.22474487139, 2.22474487139, -1.0), + new Grad3( 2.22474487139, 2.22474487139, 1.0), + new Grad3( 3.0862664687972017, 1.1721513422464978, 0.0), + new Grad3( 1.1721513422464978, 3.0862664687972017, 0.0) + }; + Grad3[] grad3Classic = new Grad3[grad3.length]; + Grad3[] grad3XYBeforeZ = new Grad3[grad3.length]; + Grad3[] grad3XZBeforeY = new Grad3[grad3.length]; + for (int i = 0; i < grad3.length; i++) { + grad3[i].dx /= N3; grad3[i].dy /= N3; grad3[i].dz /= N3; + double gxr = grad3[i].dx, gyr = grad3[i].dy, gzr = grad3[i].dz; + + // Unrotated gradients for classic 3D + double grr = (2.0 / 3.0) * (gxr + gyr + gzr); +// double dx = grr - gxr, dy = grr - gyr, dz = grr - gzr; + grad3Classic[i] = new Grad3( grr - gxr, grr - gyr, grr - gzr ); + + // Unrotated gradients for XYBeforeZ 3D + double s2 = (gxr + gyr) * -0.211324865405187; + double zz = gzr * 0.577350269189626; + grad3XYBeforeZ[i] = new Grad3( gxr + s2 + zz, gyr + s2 + zz, (gzr - gxr - gyr) * 0.577350269189626 ); + + // Unrotated gradients for plane-first 3D + s2 = (gxr + gzr) * -0.211324865405187; + double yy = gyr * 0.577350269189626; + grad3XZBeforeY[i] = new Grad3( gxr + s2 + yy, (gyr - gxr - gzr) * 0.577350269189626, gzr + s2 + yy ); + } + for (int i = 0; i < PSIZE; i++) { + GRADIENTS_3D[i] = grad3[i % grad3.length]; + GRADIENTS_3D_CLASSIC[i] = grad3Classic[i % grad3Classic.length]; + GRADIENTS_3D_XY_BEFORE_Z[i] = grad3XYBeforeZ[i % grad3XYBeforeZ.length]; + GRADIENTS_3D_XZ_BEFORE_Y[i] = grad3XZBeforeY[i % grad3XZBeforeY.length]; + } + } +} + + + + + + + + + + + + + diff --git a/src/main/java/ru/windcorp/progressia/server/PlayerManager.java b/src/main/java/ru/windcorp/progressia/server/PlayerManager.java index 41e3d5b..86e14ce 100644 --- a/src/main/java/ru/windcorp/progressia/server/PlayerManager.java +++ b/src/main/java/ru/windcorp/progressia/server/PlayerManager.java @@ -30,7 +30,7 @@ public class PlayerManager { this.players.add(player); } - private static final Vec3i SPAWN = new Vec3i(8, 8, 20); + private static final Vec3i SPAWN = new Vec3i(8, 8, 900); public EntityData conjurePlayerEntity(String login) { // TODO Live up to the name diff --git a/src/main/java/ru/windcorp/progressia/test/LayerTestGUI.java b/src/main/java/ru/windcorp/progressia/test/LayerTestGUI.java index 1a513bd..8712a7f 100755 --- a/src/main/java/ru/windcorp/progressia/test/LayerTestGUI.java +++ b/src/main/java/ru/windcorp/progressia/test/LayerTestGUI.java @@ -21,6 +21,8 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Locale; +import glm.vec._3.Vec3; +import ru.windcorp.progressia.client.Client; import ru.windcorp.progressia.client.ClientState; import ru.windcorp.progressia.client.graphics.backend.GraphicsInterface; import ru.windcorp.progressia.client.graphics.font.Font; @@ -81,6 +83,12 @@ public class LayerTestGUI extends GUILayer { 128 )); + panel.addChild(new DynamicLabel( + "PosDisplay", new Font().withColor(0x37A3E6).deriveShadow(), + LayerTestGUI::getPos, + 128 + )); + panel.getChildren().forEach(c -> { if (c instanceof Label) { labels.add((Label) c); @@ -151,6 +159,14 @@ public class LayerTestGUI extends GUILayer { return String.format(Locale.US, "TPS: %5.1f", TPS_RECORD.update(server.getTPS())); } + private static String getPos() { + Client client = ClientState.getInstance(); + if (client == null) return "Pos: n/a"; + + Vec3 pos = client.getCamera().getLastAnchorPosition(); + return String.format(Locale.US, "Pos: %+7.1f %+7.1f %+7.1f", pos.x, pos.y, pos.z); + } + // private static class DebugComponent extends Component { // private final int color; // diff --git a/src/main/java/ru/windcorp/progressia/test/gen/TestTerrainGenerator.java b/src/main/java/ru/windcorp/progressia/test/gen/TestTerrainGenerator.java new file mode 100644 index 0000000..c60e68b --- /dev/null +++ b/src/main/java/ru/windcorp/progressia/test/gen/TestTerrainGenerator.java @@ -0,0 +1,126 @@ +package ru.windcorp.progressia.test.gen; + +import kdotjpg.opensimplex2.areagen.OpenSimplex2S; +import ru.windcorp.progressia.server.world.WorldLogic; + +class TestTerrainGenerator { + + @FunctionalInterface + private interface Func2D { + double compute(double x, double y); + } + + private final OpenSimplex2S noise; + private final Func2D shape; + + public TestTerrainGenerator(TestWorldGenerator testWorldGenerator, WorldLogic world) { + this.noise = new OpenSimplex2S("We're getting somewhere".hashCode()); + + Func2D plainsHeight = + tweak( + octaves( + tweak(primitive(), 0.01, 0.5), + 2, 3 + ), + 1, 0.2, 0.2 + ); + + Func2D mountainsHeight = + tweak( + octaves( + ridge(tweak(primitive(), 0.01, 1)), + 2, 1.5, 12 + ), + 1, 3 + ); + + Func2D mountainousity = + tweak( + octaves( + tweak(primitive(), 0.007, 1), + 2, 3 + ), + 1, 1, -0.25 + ); + + shape = tweak( + add(multiply(squash(mountainousity, 10), mountainsHeight), plainsHeight), + 0.001, 1000, 0 + ); + } + + public void compute(int startX, int startY, double[][] heightMap, double[][] slopeMap) { + for (int x = 0; x < heightMap.length; ++x) { + for (int y = 0; y < heightMap.length; ++y) { + heightMap[x][y] = shape.compute(x + startX, y + startY); + slopeMap[x][y] = computeSlope(shape, x + startX, y + startY, heightMap[x][y]); + } + } + } + + private double computeSlope(Func2D f, double x0, double y0, double f0) { + double di = 0.5; + + double dfdx = (f.compute(x0 + di, y0) - f0) / di; + double dfdy = (f.compute(x0, y0 + di) - f0) / di; + + return Math.hypot(dfdx, dfdy); + } + + /* + * Utility functions + */ + + private Func2D primitive() { + return noise::noise2; + } + + private Func2D add(Func2D a, Func2D b) { + return (x, y) -> a.compute(x, y) + b.compute(x, y); + } + + private Func2D multiply(Func2D a, Func2D b) { + return (x, y) -> a.compute(x, y) * b.compute(x, y); + } + + private Func2D tweak(Func2D f, double scale, double amplitude, double bias) { + return (x, y) -> f.compute(x * scale, y * scale) * amplitude + bias; + } + + private Func2D tweak(Func2D f, double scale, double amplitude) { + return tweak(f, scale, amplitude, 0); + } + + private Func2D octaves(Func2D f, double scaleFactor, double amplitudeFactor, int octaves) { + return (x, y) -> { + double result = 0; + + double scale = 1; + double amplitude = 1; + + for (int i = 0; i < octaves; ++i) { + result += f.compute(x * scale, y * scale) * amplitude; + scale *= scaleFactor; + amplitude /= amplitudeFactor; + } + + return result; + }; + } + + private Func2D octaves(Func2D f, double factor, int octaves) { + return octaves(f, factor, factor, octaves); + } + + private Func2D squash(Func2D f, double slope) { + return (x, y) -> 1 / (1 + Math.exp(-slope * f.compute(x, y))); + } + + private Func2D ridge(Func2D f) { + return (x, y) -> { + double result = 1 - Math.abs(f.compute(x, y)); + return result * result; + }; + } + +} diff --git a/src/main/java/ru/windcorp/progressia/test/gen/TestWorldGenerator.java b/src/main/java/ru/windcorp/progressia/test/gen/TestWorldGenerator.java index 3981d61..7c9f18a 100644 --- a/src/main/java/ru/windcorp/progressia/test/gen/TestWorldGenerator.java +++ b/src/main/java/ru/windcorp/progressia/test/gen/TestWorldGenerator.java @@ -23,8 +23,11 @@ import ru.windcorp.progressia.server.world.generation.AbstractWorldGenerator; public class TestWorldGenerator extends AbstractWorldGenerator { + private final TestTerrainGenerator terrainGen; + public TestWorldGenerator(WorldLogic world) { super("Test:WorldGenerator", Boolean.class); + this.terrainGen = new TestTerrainGenerator(this, world); world.getData().addListener(new WorldDataListener() { @Override @@ -66,28 +69,26 @@ public class TestWorldGenerator extends AbstractWorldGenerator { BlockData stone = BlockDataRegistry.getInstance().get("Test:Stone"); BlockData air = BlockDataRegistry.getInstance().get("Test:Air"); - final float maxHeight = 32; - final float rho = 2000; + double[][] heightMap = new double[bpc][bpc]; + double[][] gradMap = new double[bpc][bpc]; - int[][] heightMap = new int[bpc][bpc]; + int startX = Coordinates.getInWorld(chunk.getX(), 0); + int startY = Coordinates.getInWorld(chunk.getY(), 0); + int startZ = Coordinates.getInWorld(chunk.getZ(), 0); - for (int yic = 0; yic < heightMap.length; ++yic) { - int yiw = Coordinates.getInWorld(chunk.getY(), yic); - for (int xic = 0; xic < heightMap[yic].length; ++xic) { - int xiw = Coordinates.getInWorld(chunk.getX(), xic); - - int rsq = (xiw*xiw + yiw*yiw); - heightMap[xic][yic] = (int) (rsq / (rho + rsq) * maxHeight) - chunk.getZ()*bpc; - } - } + terrainGen.compute(startX, startY, heightMap, gradMap); VectorUtil.iterateCuboid(0, 0, 0, bpc, bpc, bpc, pos -> { - int layer = pos.z - heightMap[pos.x][pos.y]; + double layer = pos.z - heightMap[pos.x][pos.y] + startZ; if (layer < -4) { chunk.setBlock(pos, stone, false); } else if (layer < 0) { - chunk.setBlock(pos, dirt, false); + if (gradMap[pos.x][pos.y] > 0.3) { + chunk.setBlock(pos, stone, false); + } else { + chunk.setBlock(pos, dirt, false); + } } else { chunk.setBlock(pos, air, false); } @@ -140,6 +141,7 @@ public class TestWorldGenerator extends AbstractWorldGenerator { assert chunk != null : "Something went wrong when populating chunk at (" + chunkPos.x + "; " + chunkPos.y + "; " + chunkPos.z + ")"; BlockData air = BlockDataRegistry.getInstance().get("Test:Air"); + BlockData dirt = BlockDataRegistry.getInstance().get("Test:Dirt"); Vec3i biw = new Vec3i(); @@ -159,7 +161,7 @@ public class TestWorldGenerator extends AbstractWorldGenerator { if (biw.z == maxZ) continue; if (biw.z < minZ) continue; - addTiles(chunk, biw, world, random); + addTiles(chunk, biw, world, random, world.getBlock(biw) == dirt); } } @@ -167,9 +169,9 @@ public class TestWorldGenerator extends AbstractWorldGenerator { chunk.setGenerationHint(true); } - private void addTiles(ChunkData chunk, Vec3i biw, WorldData world, Random random) { - addGrass(chunk, biw, world, random); - addDecor(chunk, biw, world, random); + private void addTiles(ChunkData chunk, Vec3i biw, WorldData world, Random random, boolean isDirt) { + if (isDirt) addGrass(chunk, biw, world, random); + addDecor(chunk, biw, world, random, isDirt); } private void addGrass(ChunkData chunk, Vec3i biw, WorldData world, Random random) { @@ -191,23 +193,31 @@ public class TestWorldGenerator extends AbstractWorldGenerator { } } - private void addDecor(ChunkData chunk, Vec3i biw, WorldData world, Random random) { - if (random.nextInt(8) == 0) { - world.getTiles(biw, BlockFace.TOP).addFarthest( - TileDataRegistry.getInstance().get("Test:Sand") - ); - } - - if (random.nextInt(8) == 0) { - world.getTiles(biw, BlockFace.TOP).addFarthest( - TileDataRegistry.getInstance().get("Test:Stones") - ); - } - - if (random.nextInt(8) == 0) { - world.getTiles(biw, BlockFace.TOP).addFarthest( - TileDataRegistry.getInstance().get("Test:YellowFlowers") - ); + private void addDecor(ChunkData chunk, Vec3i biw, WorldData world, Random random, boolean isDirt) { + if (isDirt) { + if (random.nextInt(8) == 0) { + world.getTiles(biw, BlockFace.TOP).addFarthest( + TileDataRegistry.getInstance().get("Test:Sand") + ); + } + + if (random.nextInt(8) == 0) { + world.getTiles(biw, BlockFace.TOP).addFarthest( + TileDataRegistry.getInstance().get("Test:Stones") + ); + } + + if (random.nextInt(8) == 0) { + world.getTiles(biw, BlockFace.TOP).addFarthest( + TileDataRegistry.getInstance().get("Test:YellowFlowers") + ); + } + } else { + if (random.nextInt(2) == 0) { + world.getTiles(biw, BlockFace.TOP).addFarthest( + TileDataRegistry.getInstance().get("Test:Stones") + ); + } } }