From 5d6224db0886da15244f27f7075b2c132c65bffa Mon Sep 17 00:00:00 2001 From: cyberpwn Date: Tue, 6 Sep 2022 23:26:24 -0400 Subject: [PATCH] ffs --- .../iris/platform/bukkit/IrisBukkit.java | 61 ++++++++++++++++++- .../bukkit/IrisBukkitChunkGenerator.java | 50 ++++++++++++++- .../bukkit/util/StaticBiomeProvider.java | 27 ++++++++ .../java/com/volmit/iris/engine/Engine.java | 15 +++-- .../volmit/iris/engine/feature/Feature.java | 2 + .../engine/feature/FeatureSizedTarget.java | 22 ++++--- .../iris/engine/feature/FeatureTask.java | 7 +-- .../engine/feature/features/FeatureError.java | 38 ++++++++++++ .../feature/features/FeatureTerrain.java | 49 ++++++++++++--- .../optimizer/HunkSlizeConfiguration.java | 5 ++ .../optimizer/IrisOptimizationAttempt.java | 9 +-- .../iris/engine/optimizer/IrisOptimizer.java | 48 ++++++++++----- .../iris/engine/pipeline/EnginePlumbing.java | 14 +++-- .../iris/engine/pipeline/PipelinePhase.java | 2 +- .../iris/engine/pipeline/PipelineTask.java | 7 +-- .../volmit/iris/platform/IrisPlatform.java | 8 +++ .../volmit/iris/util/HunkedNoisePlane.java | 17 ++++++ .../com/volmit/iris/util/ShortNoiseCache.java | 4 +- 18 files changed, 322 insertions(+), 63 deletions(-) create mode 100644 bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java create mode 100644 engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureError.java create mode 100644 engine/src/main/java/com/volmit/iris/util/HunkedNoisePlane.java diff --git a/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java index 5c7e2b8b8..554e241a4 100644 --- a/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java +++ b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java @@ -1,6 +1,7 @@ package com.volmit.iris.platform.bukkit; import art.arcane.amulet.io.IO; +import art.arcane.amulet.logging.LogListener; import com.volmit.iris.engine.EngineConfiguration; import com.volmit.iris.platform.IrisPlatform; import com.volmit.iris.platform.PlatformBiome; @@ -14,10 +15,13 @@ import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld; import lombok.Data; import lombok.EqualsAndHashCode; import org.bukkit.Bukkit; +import org.bukkit.ChatColor; import org.bukkit.Material; +import org.bukkit.Warning; import org.bukkit.World; import org.bukkit.WorldCreator; import org.bukkit.block.Biome; +import org.bukkit.command.ConsoleCommandSender; import org.bukkit.entity.Player; import org.bukkit.generator.ChunkGenerator; import org.bukkit.plugin.java.JavaPlugin; @@ -29,11 +33,16 @@ import java.util.Arrays; import java.util.UUID; import java.util.stream.Stream; -public class IrisBukkit extends JavaPlugin implements IrisPlatform { +public class IrisBukkit extends JavaPlugin implements IrisPlatform, LogListener { + private static final String TAG = ChatColor.DARK_GRAY + "[" + ChatColor.GREEN + "Iris" + ChatColor.DARK_GREEN + "/"; + private static final String TAG_STRIPPED = ChatColor.stripColor(TAG); private static IrisBukkit instance; + private ConsoleCommandSender consoleSender; public void onEnable() { instance = this; + consoleSender = Bukkit.getConsoleSender(); + LogListener.listener.set(this); getServer().getScheduler().scheduleSyncDelayedTask(this, () -> { World world = Bukkit.createWorld(new WorldCreator("iristests/" + UUID.randomUUID()).generator(new IrisBukkitChunkGenerator(this, EngineConfiguration.builder() @@ -84,6 +93,36 @@ public class IrisBukkit extends JavaPlugin implements IrisPlatform { return instance; } + private void messageConsole(String color, String key, Object o) { + try { + consoleSender.sendMessage(TAG + key + ChatColor.DARK_GRAY + "]: " + color + o.toString()); + } + + catch(Throwable e) { + System.out.println(TAG_STRIPPED + key + "]: " + o.toString()); + } + } + + @Override + public void logError(String k, Object o) { + messageConsole(ChatColor.RED.toString(), k, o); + } + + @Override + public void logInfo(String k, Object o) { + messageConsole(ChatColor.WHITE.toString(), k, o); + } + + @Override + public void logWarning(String k, Object o) { + messageConsole(ChatColor.YELLOW.toString(), k, o); + } + + @Override + public void logDebug(String k, Object o) { + messageConsole(ChatColor.GRAY.toString(), k, o); + } + @Override public String getPlatformName() { return "Bukkit"; @@ -155,4 +194,24 @@ public class IrisBukkit extends JavaPlugin implements IrisPlatform { .timings(true) .build()); } + + @Override + public void i(String s, Object o) { + logInfo(s, o); + } + + @Override + public void f(String s, Object o) { + logError(s, o); + } + + @Override + public void w(String s, Object o) { + logWarning(s, o); + } + + @Override + public void d(String s, Object o) { + logDebug(s, o); + } } diff --git a/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java index f63b46383..1b633e9fd 100644 --- a/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java +++ b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java @@ -10,11 +10,15 @@ import com.volmit.iris.engine.feature.FeatureTarget; import com.volmit.iris.engine.pipeline.PipedHunkStack; import com.volmit.iris.platform.IrisPlatform; import com.volmit.iris.platform.block.PlatformBlock; +import com.volmit.iris.platform.bukkit.util.StaticBiomeProvider; import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld; import org.bukkit.Bukkit; import org.bukkit.World; +import org.bukkit.block.Biome; +import org.bukkit.generator.BiomeProvider; import org.bukkit.generator.ChunkGenerator; import com.volmit.iris.platform.bukkit.util.ChunkDataHunkView; +import org.bukkit.generator.WorldInfo; import java.io.Closeable; import java.io.IOException; @@ -31,13 +35,15 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator implements Closeabl private final AtomicInteger perSecond; private final PrecisionStopwatch p = PrecisionStopwatch.start(); private final Average a = new Average(128); + private final StaticBiomeProvider staticBiomeProvider; public IrisBukkitChunkGenerator(IrisPlatform platform, EngineConfiguration configuration) { this.perSecond = new AtomicInteger(0); this.platform = platform; this.configuration = configuration; - engine = new AtomicReference<>(); - engineLock = new ReentrantLock(); + this.staticBiomeProvider = new StaticBiomeProvider(Biome.PLAINS); + this.engine = new AtomicReference<>(); + this.engineLock = new ReentrantLock(); } @Override @@ -94,8 +100,48 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator implements Closeabl return false; } + @Override + public BiomeProvider getDefaultBiomeProvider(WorldInfo worldInfo) { + return staticBiomeProvider; + } + @Override public void close() throws IOException { engine.get().close(); } + + @Override + public boolean shouldGenerateNoise() { + return super.shouldGenerateNoise(); + } + + @Override + public boolean shouldGenerateSurface() { + return super.shouldGenerateSurface(); + } + + @Override + public boolean shouldGenerateBedrock() { + return super.shouldGenerateBedrock(); + } + + @Override + public boolean shouldGenerateCaves() { + return super.shouldGenerateCaves(); + } + + @Override + public boolean shouldGenerateDecorations() { + return super.shouldGenerateDecorations(); + } + + @Override + public boolean shouldGenerateMobs() { + return super.shouldGenerateMobs(); + } + + @Override + public boolean shouldGenerateStructures() { + return super.shouldGenerateStructures(); + } } diff --git a/bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java new file mode 100644 index 000000000..e9f4e6f36 --- /dev/null +++ b/bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java @@ -0,0 +1,27 @@ +package com.volmit.iris.platform.bukkit.util; + +import org.bukkit.block.Biome; +import org.bukkit.generator.BiomeProvider; +import org.bukkit.generator.WorldInfo; + +import java.util.Arrays; +import java.util.List; + +public class StaticBiomeProvider extends BiomeProvider { + private static final List ALL_BIOMES = Arrays.stream(Biome.values()).without((i) -> i.equals(Biome.CUSTOM)).toList().unmodifiable(); + private final Biome defaultBiome; + + public StaticBiomeProvider(Biome defaultBiome) { + this.defaultBiome = defaultBiome; + } + + @Override + public Biome getBiome(WorldInfo worldInfo, int x, int y, int z) { + return defaultBiome; + } + + @Override + public List getBiomes(WorldInfo worldInfo) { + return ALL_BIOMES; + } +} diff --git a/engine/src/main/java/com/volmit/iris/engine/Engine.java b/engine/src/main/java/com/volmit/iris/engine/Engine.java index 7c73c7765..d1d8d4c49 100644 --- a/engine/src/main/java/com/volmit/iris/engine/Engine.java +++ b/engine/src/main/java/com/volmit/iris/engine/Engine.java @@ -1,5 +1,6 @@ package com.volmit.iris.engine; +import com.volmit.iris.engine.feature.features.FeatureError; import com.volmit.iris.engine.feature.features.FeatureTerrain; import com.volmit.iris.engine.pipeline.EnginePipeline; import com.volmit.iris.engine.pipeline.EnginePlumbing; @@ -51,6 +52,11 @@ public class Engine implements Closeable { this.seedManager = getSeedManager(); this.executor = new EngineExecutor(this); this.plumbing = EnginePlumbing.builder().engine(this) + .errorPipeline(EnginePipeline.builder() + .phase(PipelinePhase.builder() + .task(new PipelineTask<>(new FeatureError(this), PlatformBlock.class)) + .build()) + .build()) .pipeline(EnginePipeline.builder() .phase(PipelinePhase.builder() .task(new PipelineTask<>(new FeatureTerrain(this), PlatformBlock.class)) @@ -59,18 +65,15 @@ public class Engine implements Closeable { .build(); } - public PlatformBlock block(String block) - { + public PlatformBlock block(String block) { return blockCache.get(block); } - public PlatformNamespaceKey key(String nsk) - { + public PlatformNamespaceKey key(String nsk) { return getPlatform().key(nsk); } - public static Optional context() - { + public static Optional context() { WeakReference reference = engineContext.get(Thread.currentThread()); if(reference != null) diff --git a/engine/src/main/java/com/volmit/iris/engine/feature/Feature.java b/engine/src/main/java/com/volmit/iris/engine/feature/Feature.java index da51d2ea1..55af9c743 100644 --- a/engine/src/main/java/com/volmit/iris/engine/feature/Feature.java +++ b/engine/src/main/java/com/volmit/iris/engine/feature/Feature.java @@ -8,12 +8,14 @@ import lombok.Data; public abstract class Feature { private final String name; private final Engine engine; + private boolean optimize; private boolean heightAgnostic; public Feature(String name, Engine engine) { this.engine = engine; this.name = name; + this.optimize = true; this.heightAgnostic = true; } diff --git a/engine/src/main/java/com/volmit/iris/engine/feature/FeatureSizedTarget.java b/engine/src/main/java/com/volmit/iris/engine/feature/FeatureSizedTarget.java index fc61ab694..920f774cf 100644 --- a/engine/src/main/java/com/volmit/iris/engine/feature/FeatureSizedTarget.java +++ b/engine/src/main/java/com/volmit/iris/engine/feature/FeatureSizedTarget.java @@ -45,13 +45,13 @@ public class FeatureSizedTarget { if(width <= 1) { return Stream.of(this); } - + int wo2 = width/2; return Stream.of(FeatureSizedTarget.builder() - .width(width/2).height(height).depth(depth) + .width(wo2).height(height).depth(depth) .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(), FeatureSizedTarget.builder() - .width(width - (width/2)).height(height).depth(depth) - .offsetX(offsetX + (width/2)).offsetY(offsetY).offsetZ(offsetZ).build()); + .width(width - wo2).height(height).depth(depth) + .offsetX(offsetX + wo2).offsetY(offsetY).offsetZ(offsetZ).build()); } Stream splitY() { @@ -59,12 +59,13 @@ public class FeatureSizedTarget { return Stream.of(this); } + int ho2 = height / 2; return Stream.of(FeatureSizedTarget.builder() - .width(width).height(height/2).depth(depth) + .width(width).height(ho2).depth(depth) .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(), FeatureSizedTarget.builder() - .width(width).height(height - (height / 2)).depth(depth) - .offsetX(offsetX).offsetY(offsetY + (height/2)).offsetZ(offsetZ).build()); + .width(width).height(height - ho2).depth(depth) + .offsetX(offsetX).offsetY(offsetY + ho2).offsetZ(offsetZ).build()); } Stream splitZ() { @@ -72,12 +73,13 @@ public class FeatureSizedTarget { return Stream.of(this); } + int do2 = depth / 2; return Stream.of(FeatureSizedTarget.builder() - .width(width).height(height).depth(depth/2) + .width(width).height(height).depth(do2) .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(), FeatureSizedTarget.builder() - .width(width).height(height).depth(depth - (depth/2)) - .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ + (depth/2)).build()); + .width(width).height(height).depth(depth - do2) + .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ + do2).build()); } public int getAbsoluteMaxX() diff --git a/engine/src/main/java/com/volmit/iris/engine/feature/FeatureTask.java b/engine/src/main/java/com/volmit/iris/engine/feature/FeatureTask.java index d2e0ea96c..c43e870a9 100644 --- a/engine/src/main/java/com/volmit/iris/engine/feature/FeatureTask.java +++ b/engine/src/main/java/com/volmit/iris/engine/feature/FeatureTask.java @@ -34,13 +34,11 @@ public class FeatureTask e FeatureTarget result; PrecisionStopwatch p = null; - if(timings != null) - { + if(timings != null) { p = PrecisionStopwatch.start(); } if(!heightAgnostic && size.getHeight() > verticalPrepareSize * 2) { - result = FeatureTarget.mergedTarget(size.splitY() .map(i -> engine.getExecutor().getForks().submit((ForkJoinTask>) with(i))) .map(ForkJoinTask::join), origin, false, true, false); @@ -61,8 +59,7 @@ public class FeatureTask e result = preparedFeature.generate(origin, storage); } - if(timings != null) - { + if(timings != null) { timings.onCompleted(p.getMilliseconds()); } diff --git a/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureError.java b/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureError.java new file mode 100644 index 000000000..320667b30 --- /dev/null +++ b/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureError.java @@ -0,0 +1,38 @@ +package com.volmit.iris.engine.feature.features; + +import com.volmit.iris.engine.Engine; +import com.volmit.iris.engine.feature.Feature; +import com.volmit.iris.engine.feature.FeatureSizedTarget; +import com.volmit.iris.engine.feature.FeatureState; +import com.volmit.iris.engine.feature.FeatureStorage; +import com.volmit.iris.engine.feature.FeatureTarget; +import com.volmit.iris.platform.block.PlatformBlock; +import lombok.AllArgsConstructor; +import lombok.Data; + +public class FeatureError extends Feature { + private static final State DEFAULT_STATE = new State(); + private final PlatformBlock ERROR_BLOCK; + + public FeatureError(Engine engine) { + super("error", engine); + setOptimize(false); + ERROR_BLOCK = engine.block("red_sandstone"); + } + + @Override + public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) { + return DEFAULT_STATE; + } + + @Override + public void generate(Engine engine, State state, FeatureTarget target, FeatureStorage storage) { + target.forXZ((x, z) -> target.forYCap((y -> target.getHunk().set(x, y, z, ERROR_BLOCK)), 1)); + } + + @Data + @AllArgsConstructor + public static class State implements FeatureState { + + } +} diff --git a/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java b/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java index 750e66629..72ed99446 100644 --- a/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java +++ b/engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java @@ -1,40 +1,73 @@ package com.volmit.iris.engine.feature.features; import art.arcane.source.NoisePlane; +import art.arcane.source.interpolator.CubicInterpolator; +import art.arcane.source.interpolator.Interpolator; +import art.arcane.source.interpolator.LinearInterpolator; +import art.arcane.source.interpolator.StarcastInterpolator; +import art.arcane.source.noise.provider.MirroredCacheProvider; import art.arcane.source.util.NoisePreset; +import art.arcane.spatial.hunk.Hunk; +import art.arcane.spatial.hunk.storage.ArrayHunk; import com.volmit.iris.engine.Engine; import com.volmit.iris.engine.feature.*; import com.volmit.iris.platform.block.PlatformBlock; -import com.volmit.iris.util.ShortNoiseCache; import lombok.AllArgsConstructor; import lombok.Data; public class FeatureTerrain extends Feature { private final PlatformBlock stone; private final NoisePlane generator; + private final NoisePlane generator2; public FeatureTerrain(Engine engine) { super("terrain", engine); + setOptimize(true); stone = engine.block("stone"); - this.generator = NoisePreset.NATURAL.create(1234).fit(0, 64).scale(0.2); + this.generator = NoisePreset.NATURAL.create(1234); + this.generator2 = NoisePreset.NATURAL.create(6664).fit(0, 1).scale(0.1); } @Override public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) { - target.forXZ((x, z) -> storage.getHeight().set(x & storage.getW() - 1, z & storage.getH() - 1, (short) generator.noise(x, z))); - return new State(storage.getHeight()); + Hunk snc = new ArrayHunk<>(target.getWidth(), target.getHeight(), target.getDepth()); + short n; + int fdx,fdz; + for(int x : target.x()) { + fdx = Math.floorMod(x, target.getWidth()); + for(int z : target.z()) { + fdz = Math.floorMod(z, target.getDepth()); + n = (short) generator.noise(x, z); + for(int y = 0; y < n; y++) { + if(generator2.noise(x,y,z) > 0.5) { + snc.set(fdx, y, fdz, 1D); + } + } + } + } + + return new State(snc); } @Override public void generate(Engine engine, State state, FeatureTarget target, FeatureStorage storage) { - target.forXZ((x, z) -> target.forYCap((y -> { - target.getHunk().set(x, y, z, stone); - }), state.getNoise().get(x, z))); + int y; + for(int x : target.localX()) { + for(int z : target.localZ()) { + for(int i = 0; i < target.getHeight(); i++) { + Double v = state.getNoise().get(x, i, z); + v = v == null ? 0f : v; + if(v >= 0.5) { + target.getHunk().set(x,i, z, stone); + } + } + } + } } @Data @AllArgsConstructor public static class State implements FeatureState { - private final ShortNoiseCache noise; + private final Hunk noise; } } diff --git a/engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java b/engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java index 20533a751..d719f0580 100644 --- a/engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java +++ b/engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java @@ -13,6 +13,11 @@ public class HunkSlizeConfiguration { private final int verticalSlice; private final int horizontalSlize; + public String toString() + { + return "H" + horizontalSlize + "" + ((verticalSlice < 8192) ? ("V" + verticalSlice) : ""); + } + public static List generateConfigurations(IntegerRange vertical, IntegerRange horizontal) { List configurations = new ArrayList<>(); diff --git a/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java b/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java index 7867ea825..e7a93f1cd 100644 --- a/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java +++ b/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java @@ -1,13 +1,14 @@ package com.volmit.iris.engine.optimizer; import art.arcane.chrono.Average; +import art.arcane.spatial.hunk.storage.AtomicDoubleHunk; import lombok.Data; import java.util.concurrent.atomic.AtomicInteger; @Data public class IrisOptimizationAttempt { - private final Average average; + private double value; private final AtomicInteger runs; private final int testRuns; private final T parameters; @@ -16,13 +17,13 @@ public class IrisOptimizationAttempt { { this.parameters = parameters; this.testRuns = testRuns; - this.average = new Average(testRuns); + this.value = 0; this.runs = new AtomicInteger(0); } public double getAverageTime() { - return average.getAverage(); + return value; } public boolean isComplete() @@ -31,7 +32,7 @@ public class IrisOptimizationAttempt { } public void report(double ms) { - average.put(ms); + value += ms; runs.incrementAndGet(); } } diff --git a/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java b/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java index 79d92b636..330b7f4d9 100644 --- a/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java +++ b/engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java @@ -1,5 +1,7 @@ package com.volmit.iris.engine.optimizer; +import art.arcane.amulet.format.Form; +import art.arcane.chrono.Average; import lombok.Builder; import lombok.Data; import lombok.Singular; @@ -12,58 +14,72 @@ import java.util.concurrent.ConcurrentHashMap; @Data public class IrisOptimizer { + private final String optimizedFeatureName; private final int testRuns; + private int dummyRuns; private final List options; + private final Map results; private final Map> attempts = new ConcurrentHashMap<>(); private T defaultOption; private final double chanceToTest; private double bestTime; - public IrisOptimizer(int testRuns, List options, T defaultOption, double chanceToTest) - { + public IrisOptimizer(int testRuns, List options, T defaultOption, double chanceToTest, String optimizedFeatureName) { this.bestTime = Double.MAX_VALUE; + this.dummyRuns = 1024; this.testRuns = testRuns; + this.results = new HashMap<>(); this.options = options; + this.optimizedFeatureName = optimizedFeatureName; this.defaultOption = defaultOption; this.chanceToTest = chanceToTest; - for(T i : options) - { + for(T i : options) { attempts.put(i, new IrisOptimizationAttempt<>(i, testRuns)); } } - public String toString() - { + public String toString() { return "optimizer"; } public synchronized void report(T parameters, double ms) { + if(dummyRuns-- > 0) + { + return; + } + IrisOptimizationAttempt attempt = attempts.get(parameters); - if(attempt != null) - { + if(attempt != null) { attempt.report(ms); - if(attempt.isComplete()) - { + if(attempt.isComplete()) { + results.put(parameters, attempt.getAverageTime()); attempts.remove(parameters); double result = attempt.getAverageTime(); - if(result < bestTime) - { + if(result < bestTime) { bestTime = result; defaultOption = attempt.getParameters(); } + + d("Attempted " + optimizedFeatureName + " with " + defaultOption.toString() + " " + Form.duration(attempt.getAverageTime(), 2)); + + if(attempts.isEmpty()) { + d("Fully Optimized " + optimizedFeatureName + " with " + defaultOption.toString()); + + for(T i : results.keySet()) { + d(i.toString() + ": " + Form.duration(results.get(i), 2)); + } + } } } } - public T nextParameters() - { - if(!attempts.isEmpty() && Math.r(chanceToTest)) - { + public T nextParameters() { + if(!attempts.isEmpty() && Math.r(chanceToTest)) { return attempts.k().popRandom(); } diff --git a/engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java b/engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java index 6ee389246..1c0716c21 100644 --- a/engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java +++ b/engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java @@ -16,12 +16,18 @@ public class EnginePlumbing { private final Engine engine; @Singular private final List pipelines; + private final EnginePipeline errorPipeline; - public void generate(Engine engine, FeatureSizedTarget target, PipedHunkStack stack) - { - for(EnginePipeline i : pipelines) - { + public void generate(Engine engine, FeatureSizedTarget target, PipedHunkStack stack) { + for(EnginePipeline i : pipelines) { i.generate(engine, target, stack); } + try { + } + + catch(Throwable e) { + e.printStackTrace(); + getErrorPipeline().generate(engine, target, stack); + } } } diff --git a/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java b/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java index c1adb1ec9..769ab9e51 100644 --- a/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java +++ b/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java @@ -26,7 +26,7 @@ public class PipelinePhase .collect(Collectors.toList())).stream().map(i -> { try { return i.get(); - } catch(InterruptedException | ExecutionException e) { + } catch(Throwable e) { throw new RuntimeException(e); } }).collect(Collectors.toList()); diff --git a/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java b/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java index b3b553d02..bbffa0f73 100644 --- a/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java +++ b/engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java @@ -30,16 +30,15 @@ public class PipelineTask this.horizontalEnvelope = horizontalEnvelope; List configurations = feature.isHeightAgnostic() ? HunkSlizeConfiguration.generateConfigurations(Integer.MAX_VALUE, horizontalEnvelope) : HunkSlizeConfiguration.generateConfigurations(verticalEnvelope, horizontalEnvelope); - this.optimizer = new IrisOptimizer<>(256, configurations, configurations[0], 0.75); + this.optimizer = new IrisOptimizer<>(128, configurations, configurations[0], 1, feature.getName()); } - public PipelineTask(Feature feature, Class target) - { + public PipelineTask(Feature feature, Class target) { this(feature, target, 1 to 16, 1 to 16); } public FeatureTask task(FeatureSizedTarget target, FeatureTarget origin, FeatureStorage storage){ - HunkSlizeConfiguration configuration = optimizer.nextParameters(); + HunkSlizeConfiguration configuration = getFeature().isOptimize() ? optimizer.nextParameters() : optimizer.getDefaultOption(); return feature.task(target, origin, storage, configuration.getVerticalSlice(), configuration.getHorizontalSlize(), (ms) -> optimizer.report(configuration, ms)); } } diff --git a/engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java b/engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java index 235f8b77e..36b0e3e98 100644 --- a/engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java +++ b/engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java @@ -6,6 +6,14 @@ import java.io.File; import java.util.stream.Stream; public interface IrisPlatform { + void logError(String k, Object o); + + void logInfo(String k, Object o); + + void logWarning(String k, Object o); + + void logDebug(String k, Object o); + String getPlatformName(); Stream getBlocks(); diff --git a/engine/src/main/java/com/volmit/iris/util/HunkedNoisePlane.java b/engine/src/main/java/com/volmit/iris/util/HunkedNoisePlane.java new file mode 100644 index 000000000..03353d43a --- /dev/null +++ b/engine/src/main/java/com/volmit/iris/util/HunkedNoisePlane.java @@ -0,0 +1,17 @@ +package com.volmit.iris.util; + +import art.arcane.source.NoisePlane; +import art.arcane.spatial.hunk.Hunk; +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class HunkedNoisePlane implements NoisePlane { + private final Hunk noise; + + @Override + public double noise(double x, double y, double z) { + Double d = noise.get(Math.floorMod((int)x, noise.getWidth()), Math.floorMod((int)y, noise.getHeight()), Math.floorMod((int)z, noise.getDepth())); + + return d != null ? d : 0; + } +} diff --git a/engine/src/main/java/com/volmit/iris/util/ShortNoiseCache.java b/engine/src/main/java/com/volmit/iris/util/ShortNoiseCache.java index d06e99b84..82f728664 100644 --- a/engine/src/main/java/com/volmit/iris/util/ShortNoiseCache.java +++ b/engine/src/main/java/com/volmit/iris/util/ShortNoiseCache.java @@ -13,10 +13,10 @@ public class ShortNoiseCache { } public void set(int x, int y, short v) { - this.cache[y % this.height * this.width + x % this.width] = v; + this.cache[(Math.floorMod(y,this.height) * this.width) + Math.floorMod(x, this.width)] = v; } public short get(int x, int y) { - return this.cache[y % this.height * this.width + x % this.width]; + return this.cache[(Math.floorMod(y,this.height) * this.width) + Math.floorMod(x,this.width)]; } }