Repo-Mirror/Iris-World-Engine
9
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-12-26 18:49:06 +00:00
Code Issues Releases Activity

Actually decent

Browse Source
This commit is contained in:
cyberpwn
2022-06-28 03:47:23 -04:00
parent 5e2438d6f6
commit 6873051bcb
21 changed files with 364 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
engine/src/main/java/com/volmit/iris/engine/IrisEngine.java → engine/src/main/java/com/volmit/iris/engine/Engine.java
View File

@@ -20,8 +20,8 @@ import java.util.Map;
import java.util.Optional;
@Data
public class IrisEngine implements Closeable {
private static final Map<Thread, WeakReference<IrisEngine>> engineContext = new ConcurrentWeakHashMap<>();
public class Engine implements Closeable {
private static final Map<Thread, WeakReference<Engine>> engineContext = new ConcurrentWeakHashMap<>();
private final IrisPlatform platform;
private final EngineRegistry registry;
private final EngineConfiguration configuration;
@@ -30,7 +30,7 @@ public class IrisEngine implements Closeable {
private final EngineExecutor executor;
private final EnginePlumbing plumbing;
public IrisEngine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) {
public Engine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) {
this.configuration = configuration;
this.platform = platform;
this.world = world;
@@ -43,7 +43,7 @@ public class IrisEngine implements Closeable {
this.plumbing = EnginePlumbing.builder().engine(this)
.pipeline(EnginePipeline.builder()
.phase(PipelinePhase.builder()
.task(PipelineTask.<PlatformBlock>builder().target(PlatformBlock.class).feature(new FeatureTerrain(this)).build())
.task(new PipelineTask<>(new FeatureTerrain(this), PlatformBlock.class))
.build())
.build())
.build();
@@ -59,9 +59,9 @@ public class IrisEngine implements Closeable {
return getPlatform().key(nsk);
}
public static Optional<IrisEngine> context()
public static Optional<Engine> context()
{
WeakReference<IrisEngine> reference = engineContext.get(Thread.currentThread());
WeakReference<Engine> reference = engineContext.get(Thread.currentThread());
if(reference != null)
{

4
engine/src/main/java/com/volmit/iris/engine/EngineBlockCache.java
View File

@@ -7,10 +7,10 @@ import java.util.concurrent.ConcurrentHashMap;
public class EngineBlockCache
{
private final IrisEngine engine;
private final Engine engine;
private final Map<String, PlatformBlock> cache;
public EngineBlockCache(IrisEngine engine)
public EngineBlockCache(Engine engine)
{
this.engine = engine;
this.cache = new ConcurrentHashMap<>();

6
engine/src/main/java/com/volmit/iris/engine/EngineExecutor.java
View File

@@ -9,13 +9,13 @@ import java.util.concurrent.ForkJoinWorkerThread;
@Data
public class EngineExecutor implements ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, Closeable {
private final IrisEngine engine;
private final Engine engine;
private final ForkJoinPool forks;
public EngineExecutor(IrisEngine engine)
public EngineExecutor(Engine engine)
{
this.engine = engine;
forks = new ForkJoinPool(engine.getConfiguration().getThreads(), this, this, false);
forks = new ForkJoinPool(engine.getConfiguration().getThreads(), this, this, true);
}
@Override

18
engine/src/main/java/com/volmit/iris/engine/feature/IrisFeature.java
View File

@@ -1,33 +1,33 @@
package com.volmit.iris.engine.feature;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.Data;
@Data
public abstract class IrisFeature<T extends PlatformNamespaced, S extends IrisFeatureState> {
private final String name;
private final IrisEngine engine;
private final Engine engine;
private boolean heightAgnostic;
public IrisFeature(String name, IrisEngine engine)
public IrisFeature(String name, Engine engine)
{
this.engine = engine;
this.name = name;
this.heightAgnostic = true;
}
public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, int verticalExecutionSize, int horizontalExecutionSize)
public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin, int verticalExecutionSize, int horizontalExecutionSize, IrisFeatureTaskTiming timings)
{
return new IrisFeatureTask<>(engine, this, target, verticalExecutionSize, horizontalExecutionSize, heightAgnostic);
return new IrisFeatureTask<>(engine, this, target, origin, verticalExecutionSize, horizontalExecutionSize, heightAgnostic, timings);
}
public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, int horizontalExecutionSize)
public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin, int horizontalExecutionSize, IrisFeatureTaskTiming timings)
{
return new IrisFeatureTask<>(engine, this, target, Integer.MAX_VALUE, horizontalExecutionSize, heightAgnostic);
return new IrisFeatureTask<>(engine, this, target, origin, Integer.MAX_VALUE, horizontalExecutionSize, heightAgnostic, timings);
}
public abstract S prepare(IrisEngine engine, IrisFeatureSizedTarget target);
public abstract S prepare(Engine engine, IrisFeatureSizedTarget target);
public abstract void generate(IrisEngine engine, S state, IrisFeatureTarget<T> target);
public abstract void generate(Engine engine, S state, IrisFeatureTarget<T> target);
}

20
engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureSizedTarget.java
View File

@@ -2,6 +2,7 @@ package com.volmit.iris.engine.feature;
import art.arcane.amulet.collections.hunk.Hunk;
import art.arcane.amulet.collections.hunk.storage.ArrayHunk;
import art.arcane.amulet.collections.hunk.view.HunkView;
import art.arcane.amulet.geometry.Vec;
import art.arcane.amulet.range.IntegerRange;
import com.volmit.iris.platform.PlatformNamespaced;
@@ -37,6 +38,11 @@ public class IrisFeatureSizedTarget {
return new IrisFeatureTarget<>(new ArrayHunk<>(width, height, depth), this);
}
public <T extends PlatformNamespaced> IrisFeatureTarget<T> hunked(IrisFeatureTarget<T> origin)
{
return new IrisFeatureTarget<>(new HunkView<>(origin.getHunk(), width, height, depth, offsetX - origin.getOffsetX(), offsetY - origin.getOffsetY(), offsetZ - origin.getOffsetZ()), this);
}
Stream<IrisFeatureSizedTarget> splitX() {
if(width <= 1) {
return Stream.of(this);
@@ -121,15 +127,15 @@ public class IrisFeatureSizedTarget {
return new IntegerRange(0, getDepth() - 1);
}
public static IrisFeatureSizedTarget mergedSize(Stream<IrisFeatureSizedTarget> targets) {
public static IrisFeatureSizedTarget mergedSize(Stream<IrisFeatureSizedTarget> targets, boolean x, boolean y, boolean z) {
List<IrisFeatureSizedTarget> t = targets.toList();
return IrisFeatureSizedTarget.builder()
.width(t.stream().mapToInt(IrisFeatureSizedTarget::getWidth).sum())
.height(t.stream().mapToInt(IrisFeatureSizedTarget::getHeight).sum())
.depth(t.stream().mapToInt(IrisFeatureSizedTarget::getDepth).sum())
.offsetX(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetX).min().orElse(0))
.offsetY(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetY).min().orElse(0))
.offsetZ(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetZ).min().orElse(0))
.width(x ? t.stream().mapToInt(IrisFeatureSizedTarget::getWidth).sum() : t[0].getWidth())
.height(y ? t.stream().mapToInt(IrisFeatureSizedTarget::getHeight).sum() : t[0].getHeight())
.depth(z ? t.stream().mapToInt(IrisFeatureSizedTarget::getDepth).sum() : t[0].getDepth())
.offsetX(x ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetX).min().orElse(0) : t[0].getOffsetX())
.offsetY(y ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetY).min().orElse(0) : t[0].getOffsetY())
.offsetZ(z ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetZ).min().orElse(0) : t[0].getOffsetZ())
.build();
}
}

14
engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTarget.java
View File

@@ -1,6 +1,7 @@
package com.volmit.iris.engine.feature;
import art.arcane.amulet.collections.hunk.Hunk;
import art.arcane.amulet.collections.hunk.view.HunkView;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.AllArgsConstructor;
import lombok.Builder;
@@ -28,15 +29,14 @@ public class IrisFeatureTarget<T extends PlatformNamespaced> extends IrisFeature
this(hunk, target.getOffsetX(), target.getOffsetY(), target.getOffsetZ());
}
public static <V extends PlatformNamespaced> IrisFeatureTarget<V> mergedTarget(Stream<IrisFeatureTarget<V>> targets)
public static <V extends PlatformNamespaced> IrisFeatureTarget<V> mergedTarget(Stream<IrisFeatureTarget<V>> targets, IrisFeatureTarget<V> origin, boolean x, boolean y, boolean z)
{
List<IrisFeatureTarget<V>> t = targets.toList();
IrisFeatureSizedTarget mergedSize = IrisFeatureSizedTarget.mergedSize(t.stream().map(i -> i));
Hunk<V> hunk = Hunk.newArrayHunk(mergedSize.getWidth(), mergedSize.getHeight(), mergedSize.getDepth());
t.forEach(i -> hunk.insert(
i.getOffsetX() - mergedSize.getOffsetX(),
i.getOffsetY() - mergedSize.getOffsetY(),
i.getOffsetZ() - mergedSize.getOffsetZ(), i.getHunk()));
IrisFeatureSizedTarget mergedSize = IrisFeatureSizedTarget.mergedSize(t.stream().map(i -> i), x, y, z);
Hunk<V> hunk = new HunkView<>(origin.getHunk(), mergedSize.getWidth(), mergedSize.getHeight(), mergedSize.getDepth(),
mergedSize.getOffsetX() - origin.getOffsetX(),
mergedSize.getOffsetY() - origin.getOffsetY(),
mergedSize.getOffsetZ() - origin.getOffsetZ());
return new IrisFeatureTarget<>(hunk, mergedSize);
}
}

44
engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTask.java
View File

@@ -1,14 +1,14 @@
package com.volmit.iris.engine.feature;
import art.arcane.amulet.collections.hunk.Hunk;
import com.volmit.iris.engine.IrisEngine;
import art.arcane.amulet.metric.PrecisionStopwatch;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.AllArgsConstructor;
import lombok.Builder;
import java.util.concurrent.Callable;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.Collectors;
/**
* Continuously splits up a hunk of work in all 3 dimensions until the job size is within the
@@ -19,34 +19,58 @@ import java.util.stream.Collectors;
@Builder
@AllArgsConstructor
public class IrisFeatureTask<T extends PlatformNamespaced, S extends IrisFeatureState> extends RecursiveTask<IrisFeatureTarget<T>> implements Callable<IrisFeatureTarget<T>> {
private final IrisEngine engine;
private final Engine engine;
private final IrisFeature<T, S> feature;
private final IrisFeatureSizedTarget size;
private final IrisFeatureTarget<T> origin;
private final int verticalPrepareSize;
private final int horizontalPrepareSize;
private final boolean heightAgnostic;
private final IrisFeatureTaskTiming timings;
@Override
protected IrisFeatureTarget<T> compute() {
IrisFeatureTarget<T> result;
PrecisionStopwatch p = null;
if(timings != null)
{
p = PrecisionStopwatch.start();
}
if(!heightAgnostic && size.getHeight() > verticalPrepareSize * 2) {
return IrisFeatureTarget.mergedTarget(size.splitY().map(i -> engine.getExecutor().getForks().invoke(with(i))));
result = IrisFeatureTarget.mergedTarget(size.splitY()
.map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
.map(ForkJoinTask::join), origin, false, true, false);
}
else if(size.getWidth() > horizontalPrepareSize * 2) {
return IrisFeatureTarget.mergedTarget(size.splitX().map(i -> engine.getExecutor().getForks().invoke(with(i))));
result = IrisFeatureTarget.mergedTarget(size.splitX().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
.map(ForkJoinTask::join), origin, true, false, false);
}
else if(size.getDepth() > horizontalPrepareSize * 2) {
return IrisFeatureTarget.mergedTarget(size.splitZ().map(i -> engine.getExecutor().getForks().invoke(with(i))));
result = IrisFeatureTarget.mergedTarget(size.splitZ().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
.map(ForkJoinTask::join), origin, false, false, true);
}
IrisPreparedFeature<T, S> preparedFeature = new IrisPreparedFeature<>(engine, feature, size, feature.prepare(engine, size));
return preparedFeature.generate();
else {
IrisPreparedFeature<T, S> preparedFeature = new IrisPreparedFeature<>(engine, feature, size, feature.prepare(engine, size));
result = preparedFeature.generate(origin);
}
if(timings != null)
{
timings.onCompleted(p.getMilliseconds());
}
return result;
}
private IrisFeatureTask<T, S> with(IrisFeatureSizedTarget size)
{
return new IrisFeatureTask<>(engine, feature, size, verticalPrepareSize, horizontalPrepareSize, heightAgnostic);
return new IrisFeatureTask<>(engine, feature, size, origin, verticalPrepareSize, horizontalPrepareSize, heightAgnostic, null);
}
@Override

6
engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTaskTiming.java Normal file
View File

@@ -0,0 +1,6 @@
package com.volmit.iris.engine.feature;
@FunctionalInterface
public interface IrisFeatureTaskTiming {
void onCompleted(double ms);
}

14
engine/src/main/java/com/volmit/iris/engine/feature/IrisPreparedFeature.java
View File

@@ -1,6 +1,6 @@
package com.volmit.iris.engine.feature;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.Builder;
import lombok.Data;
@@ -8,19 +8,15 @@ import lombok.Data;
@Builder
@Data
public class IrisPreparedFeature<T extends PlatformNamespaced, S extends IrisFeatureState> {
private final IrisEngine engine;
private final Engine engine;
private final IrisFeature<T, S> feature;
private final IrisFeatureSizedTarget size;
private final S state;
public IrisFeatureTarget<T> generate()
public IrisFeatureTarget<T> generate(IrisFeatureTarget<T> origin)
{
IrisFeatureTarget<T> target = size.hunked();
if(Math.r(0.25))
{
feature.generate(engine, state, target);
}
IrisFeatureTarget<T> target = size.hunked(origin);
feature.generate(engine, state, target);
return target;
}

20
engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java
View File

@@ -1,9 +1,13 @@
package com.volmit.iris.engine.feature.features;
import art.arcane.amulet.range.IntegerRange;
import art.arcane.source.api.NoisePlane;
import art.arcane.source.api.fractal.FractalFBMProvider;
import art.arcane.source.api.interpolator.StarcastInterpolator;
import art.arcane.source.api.noise.Generator;
import art.arcane.source.api.noise.provider.CellularProvider;
import art.arcane.source.api.noise.provider.SimplexProvider;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.engine.feature.IrisFeature;
import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
import com.volmit.iris.engine.feature.IrisFeatureState;
@@ -16,20 +20,22 @@ import lombok.Data;
public class FeatureTerrain extends IrisFeature<PlatformBlock, FeatureTerrain.TerrainFeatureState>
{
private final PlatformBlock stone;
private final Generator generator;
private final NoisePlane generator;
public FeatureTerrain(IrisEngine engine)
public FeatureTerrain(Engine engine)
{
super("terrain", engine);
stone = engine.block("stone");
this.generator = new Generator(new SimplexProvider(engine.getWorld().getSeed()))
Generator g = new Generator(new FractalFBMProvider((s) -> new CellularProvider(s), 1234));
g.scale(0.01);
this.generator = new StarcastInterpolator(new Generator(new SimplexProvider(engine.getWorld().getSeed()))
.maxOutput(64)
.minOutput(0)
.scale(0.01);
.scale(0.01).warp(g), 8, 96);
}
@Override
public TerrainFeatureState prepare(IrisEngine engine, IrisFeatureSizedTarget target) {
public TerrainFeatureState prepare(Engine engine, IrisFeatureSizedTarget target) {
final ShortNoiseCache noise = new ShortNoiseCache(target.getWidth(), target.getDepth());
int cx,cz;
@@ -48,7 +54,7 @@ public class FeatureTerrain extends IrisFeature<PlatformBlock, FeatureTerrain.Te
}
@Override
public void generate(IrisEngine engine, TerrainFeatureState state, IrisFeatureTarget<PlatformBlock> target) {
public void generate(Engine engine, TerrainFeatureState state, IrisFeatureTarget<PlatformBlock> target) {
for(int x : target.localX()) {
for(int z : target.localZ()) {
int h = state.getNoise().get(x, z);

58
engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java Normal file
View File

@@ -0,0 +1,58 @@
package com.volmit.iris.engine.optimizer;
import art.arcane.amulet.range.IntegerRange;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
@Data
@AllArgsConstructor
public class HunkSlizeConfiguration {
private final int verticalSlice;
private final int horizontalSlize;
public static List<HunkSlizeConfiguration> generateConfigurations(IntegerRange vertical, IntegerRange horizontal)
{
List<HunkSlizeConfiguration> configurations = new ArrayList<>();
for(int i : slice(vertical))
{
for(int j : slice(horizontal))
{
configurations.add(new HunkSlizeConfiguration(i, j));
}
}
return configurations;
}
public static List<HunkSlizeConfiguration> generateConfigurations(int vertical, IntegerRange horizontal)
{
List<HunkSlizeConfiguration> configurations = new ArrayList<>();
for(int j : slice(horizontal))
{
configurations.add(new HunkSlizeConfiguration(vertical, j));
}
return configurations;
}
private static List<Integer> slice(IntegerRange range)
{
List<Integer> v = new ArrayList<>();
v.add(range.getRightEndpoint());
v.add(range.getLeftEndpoint());
int i = (int) (range.getRightEndpoint() / 1.25);
while(i > range.getLeftEndpoint() && i >= 1)
{
v.add(i);
i /= 1.25;
}
return v.withoutDuplicates();
}
}

37
engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java Normal file
View File

@@ -0,0 +1,37 @@
package com.volmit.iris.engine.optimizer;
import art.arcane.amulet.metric.Average;
import lombok.Data;
import java.util.concurrent.atomic.AtomicInteger;
@Data
public class IrisOptimizationAttempt<T> {
private final Average average;
private final AtomicInteger runs;
private final int testRuns;
private final T parameters;
public IrisOptimizationAttempt(T parameters, int testRuns)
{
this.parameters = parameters;
this.testRuns = testRuns;
this.average = new Average(testRuns);
this.runs = new AtomicInteger(0);
}
public double getAverageTime()
{
return average.getAverage();
}
public boolean isComplete()
{
return runs.get() >= testRuns;
}
public void report(double ms) {
average.put(ms);
runs.incrementAndGet();
}
}

72
engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java Normal file
View File

@@ -0,0 +1,72 @@
package com.volmit.iris.engine.optimizer;
import lombok.Builder;
import lombok.Data;
import lombok.Singular;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Data
public class IrisOptimizer<T> {
private final int testRuns;
private final List<T> options;
private final Map<T, IrisOptimizationAttempt<T>> attempts = new ConcurrentHashMap<>();
private T defaultOption;
private final double chanceToTest;
private double bestTime;
public IrisOptimizer(int testRuns, List<T> options, T defaultOption, double chanceToTest)
{
this.bestTime = Double.MAX_VALUE;
this.testRuns = testRuns;
this.options = options;
this.defaultOption = defaultOption;
this.chanceToTest = chanceToTest;
for(T i : options)
{
attempts.put(i, new IrisOptimizationAttempt<>(i, testRuns));
}
}
public String toString()
{
return "optimizer";
}
public synchronized void report(T parameters, double ms)
{
IrisOptimizationAttempt<T> attempt = attempts.get(parameters);
if(attempt != null)
{
attempt.report(ms);
if(attempt.isComplete())
{
attempts.remove(parameters);
double result = attempt.getAverageTime();
if(result < bestTime)
{
bestTime = result;
defaultOption = attempt.getParameters();
}
}
}
}
public T nextParameters()
{
if(!attempts.isEmpty() && Math.r(chanceToTest))
{
return attempts.k().popRandom();
}
return defaultOption;
}
}

6
engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePipeline.java
View File

@@ -1,14 +1,12 @@
package com.volmit.iris.engine.pipeline;
import com.volmit.iris.engine.EngineExecutor;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.Singular;
import java.util.ArrayList;
import java.util.List;
@Data
@@ -19,7 +17,7 @@ public class EnginePipeline
@Singular
private final List<PipelinePhase> phases;
public void generate(IrisEngine engine,IrisFeatureSizedTarget target, PipedHunkStack stack)
public void generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
{
for(PipelinePhase i : phases)
{

8
engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java
View File

@@ -1,25 +1,23 @@
package com.volmit.iris.engine.pipeline;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
import com.volmit.iris.engine.pipeline.EnginePipeline;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.Singular;
import java.util.ArrayList;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
public class EnginePlumbing {
private final IrisEngine engine;
private final Engine engine;
@Singular
private final List<EnginePipeline> pipelines;
public void generate(IrisEngine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
public void generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
{
for(EnginePipeline i : pipelines)
{

10
engine/src/main/java/com/volmit/iris/engine/pipeline/PipedHunkStack.java
View File

@@ -1,27 +1,27 @@
package com.volmit.iris.engine.pipeline;
import art.arcane.amulet.collections.hunk.Hunk;
import com.volmit.iris.engine.feature.IrisFeatureTarget;
import com.volmit.iris.platform.PlatformNamespaced;
import java.util.HashMap;
import java.util.Map;
public class PipedHunkStack {
private final Map<Class<? extends PlatformNamespaced>, Hunk<? extends PlatformNamespaced>> hunks;
private final Map<Class<? extends PlatformNamespaced>, IrisFeatureTarget<? extends PlatformNamespaced>> hunks;
public PipedHunkStack()
{
this.hunks = new HashMap<>();
}
public void register(Class<? extends PlatformNamespaced> clazz, Hunk<? extends PlatformNamespaced> hunk)
public void register(Class<? extends PlatformNamespaced> clazz, IrisFeatureTarget<? extends PlatformNamespaced> hunk)
{
hunks.put(clazz, hunk);
}
@SuppressWarnings("unchecked")
public <T extends PlatformNamespaced> Hunk<T> hunk(Class<?> hunk)
public <T extends PlatformNamespaced> IrisFeatureTarget<T> hunk(Class<?> hunk)
{
return (Hunk<T>) hunks.get(hunk);
return (IrisFeatureTarget<T>) hunks.get(hunk);
}
}

21
engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java
View File

@@ -1,23 +1,16 @@
package com.volmit.iris.engine.pipeline;
import art.arcane.amulet.collections.ObjectBiset;
import art.arcane.amulet.collections.hunk.Hunk;
import com.volmit.iris.engine.IrisEngine;
import com.volmit.iris.engine.feature.IrisFeature;
import com.volmit.iris.engine.Engine;
import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
import com.volmit.iris.engine.feature.IrisFeatureTarget;
import com.volmit.iris.engine.feature.IrisFeatureTask;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.Singular;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import static art.arcane.amulet.MagicalSugar.*;
@Data
@Builder
@@ -27,20 +20,14 @@ public class PipelinePhase
@Singular
private final List<PipelineTask<?>> tasks;
@SuppressWarnings({"unchecked"})
public void generate(IrisEngine engine, IrisFeatureSizedTarget target, PipedHunkStack stack) {
List<IrisFeatureTarget<?>> targets = engine.getExecutor().getForks().invokeAll(tasks.stream().map(i -> i.task(target)).collect(Collectors.toList())).stream().map(i -> {
public List<IrisFeatureTarget<?>> generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack) {
return engine.getExecutor().getForks().invokeAll(tasks.stream().map(i -> i.task(target, stack.hunk(i.getTarget())))
.collect(Collectors.toList())).stream().map(i -> {
try {
return i.get();
} catch(InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
}).collect(Collectors.toList());
for(int i : index targets)
{
IrisFeatureTarget<?> targetResult = targets[i];
stack.hunk(tasks[i].getTarget()).insert((Hunk<PlatformNamespaced>) targetResult.getHunk());
}
}
}

34
engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java
View File

@@ -1,22 +1,48 @@
package com.volmit.iris.engine.pipeline;
import art.arcane.amulet.range.IntegerRange;
import com.volmit.iris.engine.optimizer.HunkSlizeConfiguration;
import com.volmit.iris.engine.feature.IrisFeature;
import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
import com.volmit.iris.engine.feature.IrisFeatureTarget;
import com.volmit.iris.engine.feature.IrisFeatureTask;
import com.volmit.iris.engine.optimizer.IrisOptimizer;
import com.volmit.iris.platform.PlatformNamespaced;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import java.util.List;
import static art.arcane.amulet.MagicalSugar.*;
@AllArgsConstructor
@Builder
@Data
public class PipelineTask<T extends PlatformNamespaced>
{
private final IrisFeature<T, ?> feature;
private final Class<T> target;
private final IntegerRange verticalEnvelope;
private final IntegerRange horizontalEnvelope;
private final IrisOptimizer<HunkSlizeConfiguration> optimizer;
public IrisFeatureTask<T, ?> task(IrisFeatureSizedTarget target){
return feature.task(target, 1000, 4);
public PipelineTask(IrisFeature<T, ?> feature, Class<T> target, IntegerRange verticalEnvelope, IntegerRange horizontalEnvelope)
{
this.feature = feature;
this.target = target;
this.verticalEnvelope = verticalEnvelope;
this.horizontalEnvelope = horizontalEnvelope;
List<HunkSlizeConfiguration> configurations = feature.isHeightAgnostic() ? HunkSlizeConfiguration.generateConfigurations(Integer.MAX_VALUE, horizontalEnvelope)
: HunkSlizeConfiguration.generateConfigurations(verticalEnvelope, horizontalEnvelope);
this.optimizer = new IrisOptimizer<>(256, configurations, configurations[0], 0.75);
}
public PipelineTask(IrisFeature<T, ?> feature, Class<T> target)
{
this(feature, target, 1 to 16, 1 to 16);
}
public IrisFeatureTask<T, ?> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin){
HunkSlizeConfiguration configuration = optimizer.nextParameters();
return feature.task(target, origin,configuration.getVerticalSlice(), configuration.getHorizontalSlize(), (ms) -> optimizer.report(configuration, ms));
}
}