Convert VolumeStream to use Vector3d's

There's effectively a problem with positions of blocks, they're
technically considered the corners of a dotted world, and since
transformations are performed on the double accuracy positioning, we
want to be able to retain those positions as much as possible throughout
however many transformations on a volume are made.

This is mostly to support the ability to rotate and mirror volumes in
their entirety. The implementations are already semi-functional, pending
 some off by one errors to be found and fixed.

Signed-off-by: Gabriel Harris-Rouquette <[email protected]>

Author: gabizou

src/main/java/org/spongepowered/api/world/volume/stream/VolumeApplicators.java

@@ -67,7 +67,7 @@ public final class VolumeApplicators {
      * @return A blockstate based VolumeApplicator
      */
     public static <M extends BlockVolume.Modifiable<M>> VolumeApplicator<M, BlockState, Boolean> applyBlocks() {
-        return ((volume, element) -> volume.setBlock(element.position(), element.type()));
+        return ((volume, element) -> volume.setBlock(element.position().round().toInt(), element.type()));
     }
 
     /**
@@ -82,7 +82,7 @@ public static <M extends BlockVolume.Modifiable<M>> VolumeApplicator<M, BlockSta
      */
     public static <M extends PhysicsAwareMutableBlockVolume<M>> VolumeApplicator<M, BlockState, Boolean> applyBlocks(final BlockChangeFlag flag) {
         Objects.requireNonNull(flag, "BlockChangeFlag cannot be null!");
-        return ((volume, element) -> volume.setBlock(element.position(), element.type(), flag));
+        return ((volume, element) -> volume.setBlock(element.position().round().toInt(), element.type(), flag));
     }
 
     /**
@@ -95,8 +95,8 @@ public static <M extends PhysicsAwareMutableBlockVolume<M>> VolumeApplicator<M,
      */
     public static <M extends BlockEntityVolume.Modifiable<M>> VolumeApplicator<M, BlockEntity, Boolean> applyBlockEntities() {
         return (volume, element) -> {
-            if (volume.setBlock(element.position(), element.type().block())) {
-                volume.addBlockEntity(element.position(), element.type());
+            if (volume.setBlock(element.position().round().toInt(), element.type().block())) {
+                volume.addBlockEntity(element.position().round().toInt(), element.type());
                 return true;
             }
             return false;
@@ -118,13 +118,13 @@ public static <M extends BlockEntityVolume.Modifiable<M>> VolumeApplicator<M, Op
             final Optional<? extends BlockEntity> blockEntityOpt = element.type();
             if (blockEntityOpt.isPresent()) {
                 final BlockEntity blockEntity = blockEntityOpt.get();
-                if (volume.setBlock(element.position(), blockEntity.block())) {
-                    volume.addBlockEntity(element.position(), blockEntity);
+                if (volume.setBlock(element.position().round().toInt(), blockEntity.block())) {
+                    volume.addBlockEntity(element.position().round().toInt(), blockEntity);
                     return true;
                 }
                 return false;
             } else {
-                return volume.removeBlock(element.position());
+                return volume.removeBlock(element.position().round().toInt());
             }
         };
     }
@@ -140,8 +140,8 @@ public static <M extends BlockEntityVolume.Modifiable<M>> VolumeApplicator<M, Op
      */
     public static <M extends BlockVolume.Modifiable<M>> VolumeApplicator<M, Optional<BlockState>, Boolean> applyOrRemoveBlockState() {
         return (volume, element) -> element.type()
-            .map(blockState -> volume.setBlock(element.position(), blockState))
-            .orElseGet(() -> volume.removeBlock(element.position()));
+            .map(blockState -> volume.setBlock(element.position().round().toInt(), blockState))
+            .orElseGet(() -> volume.removeBlock(element.position().round().toInt()));
     }
 
     /**
@@ -155,8 +155,8 @@ public static <M extends BlockVolume.Modifiable<M>> VolumeApplicator<M, Optional
      */
     public static <M extends PhysicsAwareMutableBlockVolume<M>> VolumeApplicator<M, Optional<BlockState>, Boolean> applyOrRemoveBlockState(final BlockChangeFlag flag) {
         return (volume, element) -> element.type()
-            .map(blockState -> volume.setBlock(element.position(), blockState, flag))
-            .orElseGet(() -> volume.removeBlock(element.position()));
+            .map(blockState -> volume.setBlock(element.position().round().toInt(), blockState, flag))
+            .orElseGet(() -> volume.removeBlock(element.position().round().toInt()));
     }
 
     /**
@@ -182,7 +182,7 @@ public static <M extends PhysicsAwareMutableBlockVolume<M>> VolumeApplicator<M,
      */
     public static <M extends BlockEntityArchetypeVolume.Modifiable<M>> VolumeApplicator<M, BlockEntityArchetype, Boolean> applyBlockEntityArchetypes() {
         return (volume, element) -> {
-            volume.addBlockEntity(element.position(), element.type());
+            volume.addBlockEntity(element.position().round().toInt(), element.type());
             return true;
         };
     }
@@ -208,7 +208,7 @@ public static <M extends EntityVolume.Modifiable<M>> VolumeApplicator<M, Entity,
      * @return A volume applicator that applies biomes to volumes
      */
     public static <M extends BiomeVolume.Modifiable<M>> VolumeApplicator<M, Biome, Boolean> applyBiomes() {
-        return (volume, element) -> volume.setBiome(element.position(), element.type());
+        return (volume, element) -> volume.setBiome(element.position().round().toInt(), element.type());
     }
 
     @SuppressWarnings("unchecked")

src/main/java/org/spongepowered/api/world/volume/stream/VolumeConsumer.java

@@ -29,5 +29,9 @@
 @FunctionalInterface
 public interface VolumeConsumer<V extends Volume, T> {
 
-    void consume(V volume, T type, int x, int y, int z);
+    default void consume(final V volume, final T type, final int x, final int y, final int z) {
+        this.consume(volume, type, x + 0.5, y + 0.5, z + 0.5);
+    }
+
+    void consume(V volume, T type, double x, double y, double z);
 }

src/main/java/org/spongepowered/api/world/volume/stream/VolumeElement.java

@@ -27,7 +27,7 @@
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.spongepowered.api.world.volume.Volume;
-import org.spongepowered.math.vector.Vector3i;
+import org.spongepowered.math.vector.Vector3d;
 
 import java.lang.ref.WeakReference;
 import java.util.Objects;
@@ -36,15 +36,15 @@
 
 public interface VolumeElement<V extends Volume, T> {
 
-    static <W extends Volume, T> VolumeElement<W, T> of(final Supplier<W> volume, final Supplier<? extends T> type, final Vector3i position) {
+    static <W extends Volume, T> VolumeElement<W, T> of(final Supplier<W> volume, final Supplier<? extends T> type, final Vector3d position) {
         return new VolumeElement<W, T>() {
             @Override
             public W volume() {
                 return volume.get();
             }
 
             @Override
-            public Vector3i position() {
+            public Vector3d position() {
                 return position;
             }
 
@@ -83,13 +83,13 @@ public int hashCode() {
         };
     }
 
-    static <V extends Volume, T> VolumeElement<V, T> of(final V volume, final Supplier<? extends T> type, final Vector3i position) {
+    static <V extends Volume, T> VolumeElement<V, T> of(final V volume, final Supplier<? extends T> type, final Vector3d position) {
         final WeakReference<V> volumeRef = new WeakReference<>(volume);
         final Supplier<V> volumeSupplier = () -> Objects.requireNonNull(volumeRef.get(), "Volume de-referenced");
         return VolumeElement.of(volumeSupplier, type, position);
     }
 
-    static <V extends Volume, T> VolumeElement<V, T> of(final V volume, final T type, final Vector3i position) {
+    static <V extends Volume, T> VolumeElement<V, T> of(final V volume, final T type, final Vector3d position) {
         final WeakReference<V> volumeRef = new WeakReference<>(volume);
         final Supplier<V> volumeSupplier = () -> Objects.requireNonNull(volumeRef.get(), "Volume de-referenced");
         final WeakReference<T> typeRef = new WeakReference<>(type);
@@ -106,7 +106,7 @@ static <V extends Volume, T> VolumeElement<V, T> of(final V volume, final T type
      */
     V volume();
 
-    Vector3i position();
+    Vector3d position();
 
     T type();
 

src/main/java/org/spongepowered/api/world/volume/stream/VolumeFlatMapper.java

@@ -32,5 +32,9 @@
 @FunctionalInterface
 public interface VolumeFlatMapper<V extends Volume, T> {
 
-    Optional<? extends T> map(V volume, Supplier<T> value, int x, int y, int z);
+    default Optional<? extends T> map(final V volume, final Supplier<T> value, final int x, final int y, final int z) {
+        return this.map(volume, value, x + 0.5, y + 0.5, z + 0.5);
+    }
+
+    Optional<? extends T> map(V volume, Supplier<T> value, double x, double y, double z);
 }

src/main/java/org/spongepowered/api/world/volume/stream/VolumeMapper.java

@@ -31,5 +31,9 @@
 @FunctionalInterface
 public interface VolumeMapper<V extends Volume, T, Out> {
 
-    Out map(V volume, Supplier<T> value, int x, int y, int z);
+    default Out map(final V volume, final Supplier<T> value, final int x, final int y, final int z) {
+        return this.map(volume, value, x + 0.5, y + 0.5, z + 0.5);
+    }
+
+    Out map(V volume, Supplier<T> value, double x, double y, double z);
 }

src/main/java/org/spongepowered/api/world/volume/stream/VolumePositionTranslators.java

@@ -37,6 +37,8 @@
 
 public final class VolumePositionTranslators {
 
+    public static final Vector3d BLOCK_OFFSET = new Vector3d(0.5, 0.5, 0.5);
+
     public static <W extends Volume, E> VolumePositionTranslator<W, E> identity() {
         return element -> element;
     }
@@ -46,24 +48,32 @@ public static <W extends Volume> VolumePositionTranslator<W, BlockState> rotateB
     }
 
     public static <W extends Volume, E> VolumePositionTranslator<W, E> rotateOn(final Vector3i start, final Vector3d center, final Rotation rotation,
-        final BiFunction<Vector3i, E, E> elementRotation
+        final BiFunction<Vector3d, E, E> elementRotation
     ) {
         return element -> {
             final Quaterniond q = Quaterniond.fromAngleDegAxis(rotation.angle().degrees(), 0, 1, 0);
-            final Vector3i v = q.rotate(center).add(element.position().toDouble().sub(start.toDouble())).round().toInt();
+            final Vector3d v = q.rotate(center).add(element.position().sub(start.toDouble()));
             return VolumeElement.of(element.volume(), elementRotation.apply(v, element.type()), v);
         };
     }
 
     public static <W extends Volume, E> VolumePositionTranslator<W, E> relativeTo(final Vector3i newOrigin) {
+        return VolumePositionTranslators.relativeTo(newOrigin.toDouble().add(VolumePositionTranslators.BLOCK_OFFSET));
+    }
+
+    public static <W extends Volume, E> VolumePositionTranslator<W, E> relativeTo(final Vector3d newOrigin) {
         return element -> VolumeElement.of(element.volume(), element.type(), element.position().add(newOrigin));
     }
 
     public static <W extends Volume, E> VolumePositionTranslator<W, E> offset(final Vector3i min) {
+        return VolumePositionTranslators.offset(min.toDouble().add(VolumePositionTranslators.BLOCK_OFFSET));
+    }
+
+    public static <W extends Volume, E> VolumePositionTranslator<W, E> offset(final Vector3d min) {
         return element -> VolumeElement.of(element.volume(), element.type(), element.position().sub(min));
     }
 
-    public static <W extends Volume, E> VolumePositionTranslator<W, E> position(final Function<Vector3i, Vector3i> func) {
+    public static <W extends Volume, E> VolumePositionTranslator<W, E> position(final Function<Vector3d, Vector3d> func) {
         Objects.requireNonNull(func, "Position function cannot be null!");
         return element -> VolumeElement.of(element.volume(), element.type(), func.apply(element.position()));
     }

src/main/java/org/spongepowered/api/world/volume/stream/VolumePredicate.java

@@ -31,7 +31,11 @@
 @FunctionalInterface
 public interface VolumePredicate<V extends Volume, T> {
 
-    boolean test(V volume, Supplier<T> element, int x, int y, int z);
+    boolean test(V volume, Supplier<T> element, double x, double y, double z);
+
+    default boolean test(final V volume, final Supplier<T> element, final int x, final int y, final int z) {
+        return this.test(volume, element, x + 0.5, y + 0.5, z + 0.5);
+    }
 
     default VolumePredicate<V, T> and(final VolumePredicate<V, T> other) {
         return (volume, element, x, y, z) -> this.test(volume, element, x, y, z) && other.test(volume, element, x, y, z);

src/main/java/org/spongepowered/api/world/volume/stream/VolumeStream.java

@@ -26,7 +26,7 @@
 
 import org.spongepowered.api.world.volume.MutableVolume;
 import org.spongepowered.api.world.volume.Volume;
-import org.spongepowered.math.vector.Vector3i;
+import org.spongepowered.math.vector.Vector3d;
 
 import java.util.Optional;
 import java.util.function.Consumer;
@@ -67,19 +67,19 @@ public interface VolumeStream<V extends Volume, T> {
     VolumeStream<V, T> filter(VolumePredicate<V, T> predicate);
 
     default VolumeStream<V, T> filter(final Predicate<VolumeElement<V, ? super T>> predicate) {
-        return this.filter((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3i(x, y, z))));
+        return this.filter((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3d(x, y, z))));
     }
 
     <Out> VolumeStream<V, Out> map(VolumeMapper<V, T, Out> mapper);
 
     default <Out> VolumeStream<V, Out> map(final Function<VolumeElement<V, T>, ? extends Out> mapper) {
-        return this.map((volume, value, x, y, z) -> mapper.apply(VolumeElement.of(volume, value, new Vector3i(x, y, z))));
+        return this.map((volume, value, x, y, z) -> mapper.apply(VolumeElement.of(volume, value, new Vector3d(x, y, z))));
     }
 
     VolumeStream<V, Optional<? extends T>> flatMap(VolumeFlatMapper<V, T> mapper);
 
     default VolumeStream<V, Optional<? extends T>> flatMap(final Function<VolumeElement<V, T>, Optional<? extends T>> mapper) {
-        return this.flatMap((volume, value, x, y, z) -> mapper.apply(VolumeElement.of(volume, value, new Vector3i(x, y, z))));
+        return this.flatMap((volume, value, x, y, z) -> mapper.apply(VolumeElement.of(volume, value, new Vector3d(x, y, z))));
     }
 
     VolumeStream<V, T> transform(VolumePositionTranslator<V, T> transformer);
@@ -89,19 +89,19 @@ default VolumeStream<V, Optional<? extends T>> flatMap(final Function<VolumeElem
     boolean allMatch(VolumePredicate<V, ? super T> predicate);
 
     default boolean allMatch(final Predicate<VolumeElement<V, ? super T>> predicate) {
-        return this.allMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3i(x, y, z))));
+        return this.allMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3d(x, y, z))));
     }
 
     boolean noneMatch(VolumePredicate<V, ? super T> predicate);
 
     default boolean noneMatch(final Predicate<VolumeElement<V, ? super T>> predicate) {
-        return this.noneMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3i(x, y, z))));
+        return this.noneMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3d(x, y, z))));
     }
 
     boolean anyMatch(VolumePredicate<V, ? super T> predicate);
 
     default boolean anyMatch(final Predicate<VolumeElement<V, ? super T>> predicate) {
-        return this.anyMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3i(x, y, z))));
+        return this.anyMatch((volume, element, x, y, z) -> predicate.test(VolumeElement.of(volume, element, new Vector3d(x, y, z))));
     }
 
     Optional<VolumeElement<V, T>> findFirst();
@@ -119,7 +119,7 @@ default <W extends MutableVolume> void apply(final VolumeCollector<W, T, ?> coll
     void forEach(VolumeConsumer<V, T> visitor);
 
     default void forEach(final Consumer<VolumeElement<V, T>> consumer) {
-        this.forEach((volume, type, x, y, z) -> consumer.accept(VolumeElement.of(volume, type, new Vector3i(x, y, z))));
+        this.forEach((volume, type, x, y, z) -> consumer.accept(VolumeElement.of(volume, type, new Vector3d(x, y, z))));
     }
 
 }