120 lines
4.6 KiB
Java
120 lines
4.6 KiB
Java
package com.hypixel.hytale.builtin.hytalegenerator.fields.points;
|
|
|
|
import com.hypixel.hytale.builtin.hytalegenerator.VectorUtil;
|
|
import com.hypixel.hytale.builtin.hytalegenerator.fields.FastNoiseLite;
|
|
import com.hypixel.hytale.math.vector.Vector2d;
|
|
import com.hypixel.hytale.math.vector.Vector2i;
|
|
import com.hypixel.hytale.math.vector.Vector3d;
|
|
import com.hypixel.hytale.math.vector.Vector3i;
|
|
import java.util.function.Consumer;
|
|
import javax.annotation.Nonnull;
|
|
|
|
public class JitterPointField extends PointField {
|
|
@Nonnull
|
|
private final FastNoiseLite noise;
|
|
private final int seed;
|
|
private final double jitter;
|
|
@Nonnull
|
|
private final Vector3d scaleDown3d;
|
|
@Nonnull
|
|
private final Vector3d scaleUp3d;
|
|
@Nonnull
|
|
private final Vector2d scaleDown2d;
|
|
@Nonnull
|
|
private final Vector2d scaleUp2d;
|
|
|
|
public JitterPointField(int seed, double jitter) {
|
|
this.jitter = jitter;
|
|
this.seed = seed;
|
|
this.noise = new FastNoiseLite();
|
|
this.scaleDown3d = new Vector3d(1.0, 1.0, 1.0);
|
|
this.scaleUp3d = new Vector3d(1.0, 1.0, 1.0);
|
|
this.scaleDown2d = new Vector2d(1.0, 1.0);
|
|
this.scaleUp2d = new Vector2d(1.0, 1.0);
|
|
}
|
|
|
|
@Override
|
|
public PointField setScale(double scaleX, double scaleY, double scaleZ, double scaleW) {
|
|
this.scaleDown3d.x = 1.0 / scaleX;
|
|
this.scaleDown3d.y = 1.0 / scaleY;
|
|
this.scaleDown3d.z = 1.0 / scaleZ;
|
|
this.scaleUp3d.x = scaleX;
|
|
this.scaleUp3d.y = scaleY;
|
|
this.scaleUp3d.z = scaleZ;
|
|
this.scaleDown2d.x = 1.0 / scaleX;
|
|
this.scaleDown2d.y = 1.0 / scaleZ;
|
|
this.scaleUp2d.x = scaleX;
|
|
this.scaleUp2d.y = scaleZ;
|
|
return super.setScale(scaleX, scaleY, scaleZ, scaleW);
|
|
}
|
|
|
|
@Override
|
|
public void points3i(@Nonnull Vector3i min, @Nonnull Vector3i max, @Nonnull Consumer<Vector3i> pointsOut) {
|
|
this.points3d(min.toVector3d(), max.toVector3d(), p -> pointsOut.accept(p.toVector3i()));
|
|
}
|
|
|
|
@Override
|
|
public void points2i(@Nonnull Vector2i min, @Nonnull Vector2i max, @Nonnull Consumer<Vector2i> pointsOut) {
|
|
this.points2d(new Vector2d(min.x, min.y), new Vector2d(max.x, max.y), p -> pointsOut.accept(new Vector2i((int)p.x, (int)p.y)));
|
|
}
|
|
|
|
@Override
|
|
public void points1i(int min, int max, @Nonnull Consumer<Integer> pointsOut) {
|
|
this.points1d(min, max, p -> pointsOut.accept(FastNoiseLite.fastRound(p)));
|
|
}
|
|
|
|
@Override
|
|
public void points3d(@Nonnull Vector3d min, @Nonnull Vector3d max, @Nonnull Consumer<Vector3d> pointsOut) {
|
|
Vector3d cellMin = min.clone().scale(this.scaleDown3d);
|
|
Vector3d cellMax = max.clone().scale(this.scaleDown3d);
|
|
cellMin.x = FastNoiseLite.fastRound(cellMin.x);
|
|
cellMin.y = FastNoiseLite.fastRound(cellMin.y);
|
|
cellMin.z = FastNoiseLite.fastRound(cellMin.z);
|
|
cellMax.x = FastNoiseLite.fastRound(cellMax.x);
|
|
cellMax.y = FastNoiseLite.fastRound(cellMax.y);
|
|
cellMax.z = FastNoiseLite.fastRound(cellMax.z);
|
|
|
|
for (double x = cellMin.x; x <= cellMax.x + 0.25; x++) {
|
|
for (double y = cellMin.y; y <= cellMax.y + 0.25; y++) {
|
|
for (double z = cellMin.z; z <= cellMax.z + 0.25; z++) {
|
|
Vector3d point = this.noise.pointFor(this.seed, this.jitter, x, y, z);
|
|
point.scale(this.scaleUp3d);
|
|
if (VectorUtil.isInside(point, min, max)) {
|
|
pointsOut.accept(point);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void points2d(@Nonnull Vector2d min, @Nonnull Vector2d max, @Nonnull Consumer<Vector2d> pointsOut) {
|
|
Vector2d cellMin = min.clone().scale(this.scaleDown2d);
|
|
Vector2d cellMax = max.clone().scale(this.scaleDown2d);
|
|
cellMin.x = FastNoiseLite.fastRound(cellMin.x);
|
|
cellMin.y = FastNoiseLite.fastRound(cellMin.y);
|
|
cellMax.x = FastNoiseLite.fastRound(cellMax.x);
|
|
cellMax.y = FastNoiseLite.fastRound(cellMax.y);
|
|
|
|
for (double x = cellMin.x; x <= cellMax.x + 0.25; x++) {
|
|
for (double z = cellMin.y; z <= cellMax.y + 0.25; z++) {
|
|
Vector2d point = this.noise.pointFor(this.seed, this.jitter, x, z);
|
|
point.scale(this.scaleUp2d);
|
|
if (VectorUtil.isInside(point, min, max)) {
|
|
pointsOut.accept(point);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void points1d(double min, double max, @Nonnull Consumer<Double> pointsOut) {
|
|
for (double x = min - this.scaleX; x < max + this.scaleX; x += this.scaleX) {
|
|
double point = this.noise.pointFor(this.seed, this.jitter, x);
|
|
if (!(point < min) || point < max) {
|
|
pointsOut.accept(point);
|
|
}
|
|
}
|
|
}
|
|
}
|