WIP checkin - new requirements system?

Author: robotgryphon

spatial/src/main/java/dev/compactmods/spatial/aabb/AABBAligner.java

@@ -17,14 +17,14 @@ public abstract class AABBAligner {
     /**
      * How large the AABB instance to be aligned is.
      */
-    protected final Vector3d size;
+    protected final Vector3dc size;
 
     /**
      * Where the center of the AABB instance will be after alignment.
      */
     protected Vector3d center;
 
-    private AABBAligner(Vector3d center, Vector3d size) {
+    private AABBAligner(Vector3d center, Vector3dc size) {
         this.size = size;
         this.center = center;
     }
@@ -38,17 +38,17 @@ public static AABBAligner.Unbounded create(AABB original) {
     }
 
     public AABB align() {
-        return AABB.ofSize(VectorUtils.convert3d(center), size.x, size.y, size.z);
+        return AABB.ofSize(VectorUtils.convert3d(center), size.x(), size.y(), size.z());
     }
 
     public static AABB center(AABB source, Vec3 center) {
         final var size = AABBHelper.sizeOf(source);
-        return AABB.ofSize(center, size.x, size.y, size.z);
+        return AABB.ofSize(center, size.x(), size.y(), size.z());
     }
 
     public static AABB center(AABB source, Vector3dc center) {
         final var size = AABBHelper.sizeOf(source);
-        return AABB.ofSize(VectorUtils.convert3d(center), size.x, size.y, size.z);
+        return AABB.ofSize(VectorUtils.convert3d(center), size.x(), size.y(), size.z());
     }
 
     public static AABB floor(AABB source, AABB within) {
@@ -79,13 +79,13 @@ public static class Bounded extends AABBAligner {
          */
         private final AABB targetBoundaries;
 
-        private Bounded(AABB outerBounds, Vector3d center, Vector3d size) {
+        private Bounded(AABB outerBounds, Vector3d center, Vector3dc size) {
             super(center, size);
             this.targetBoundaries = outerBounds;
         }
 
         /**
-         * Changes the center point of the AABB to the centerpoint of the boundaries.
+         * Changes the center vector3d of the AABB to the centerpoint of the boundaries.
          *
          * @return Aligner instance, for chaining
          */
@@ -95,7 +95,7 @@ public AABBAligner.Bounded center() {
         }
 
         /**
-         * Changes the center point of the AABB to an exact location.
+         * Changes the center vector3d of the AABB to an exact location.
          * Must be within the outer boundaries.
          *
          * @param center The position to align on.
@@ -107,7 +107,7 @@ public AABBAligner.Bounded center(Vector3dc center) {
         }
 
         /**
-         * Changes the center point of the AABB to an exact location.
+         * Changes the center vector3d of the AABB to an exact location.
          * Must be within the outer boundaries.
          *
          * @param center The position to align on.
@@ -121,9 +121,10 @@ public AABBAligner.Bounded center(Vec3 center) {
 
         public AABBAligner.Bounded normalize() {
             final var corner = new Vector3d();
+            final var offset = new Vector3d(size).mul(0.5d);
             corner.sub(AABBHelper.minCorner(targetBoundaries))
                 .negate()
-                .add(new Vector3d(size.x / 2, size.y / 2, size.z / 2));
+                .add(offset);
 
             return this.center(corner);
         }
@@ -139,7 +140,7 @@ public AABBAligner.Bounded boundedDirection(Direction direction) {
             var outerEdge = DirectionalMath.directionalEdge(direction, targetBoundaries);
             var targetPoint = DirectionalMath.directionalEdge(direction, center, size);
 
-            var offset = outerEdge.sub(targetPoint);
+            var offset = new Vector3d(outerEdge).sub(targetPoint);
             center.add(offset);
 
             return this;
@@ -162,7 +163,7 @@ public AABBAligner.Unbounded center(Vec3 center) {
         }
 
         /**
-         * Sets the center point to the center of a given block position.
+         * Sets the center vector3d to the center of a given block position.
          *
          * @param center The block position to center on.
          * @return The aligner, for chaining.

spatial/src/main/java/dev/compactmods/spatial/aabb/AABBHelper.java

@@ -2,17 +2,20 @@
 
 import dev.compactmods.spatial.vector.VectorUtils;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.Vec3;
+import org.joml.Vector2d;
+import org.joml.Vector2dc;
 import org.joml.Vector3d;
 import org.joml.Vector3dc;
 
 import java.util.stream.Stream;
 
 public abstract class AABBHelper {
 
-    public static Vector3d sizeOf(AABB aabb) {
+    public static Vector3dc sizeOf(AABB aabb) {
         return new Vector3d(aabb.getXsize(), aabb.getYsize(), aabb.getZsize());
     }
 
@@ -24,6 +27,11 @@ public static AABB zeroOriginSized(Vector3dc size) {
         return AABB.ofSize(Vec3.ZERO, size.x(), size.y(), size.z());
     }
 
+    public static AABB fullWidthSlice(AABB original, int yStart, int height) {
+        final var size = sizeOf(original);
+        return AABB.ofSize(Vec3.ZERO.add(0, yStart, 0), size.x(), height, size.z());
+    }
+
     public static boolean fitsInside(AABB aabb, Vec3 dimensions) {
         return fitsInside(aabb, VectorUtils.convert3d(dimensions));
     }
@@ -35,30 +43,17 @@ public static boolean fitsInside(AABB aabb, Vector3dc dimensions) {
     }
 
     public static boolean fitsInside(AABB outer, AABB inner) {
-        if(!fitsInside(inner, sizeOf(outer))) return false;
-        return outer.contains(VectorUtils.convert3d(minCorner(inner))) &&
-            outer.contains(VectorUtils.convert3d(maxCorner(outer)));
+        if (!fitsInside(inner, sizeOf(outer))) return false;
+        return outer.contains(inner.getMinPosition()) &&
+                outer.contains(inner.getMaxPosition());
     }
 
     public static Stream<BlockPos> blocksInside(AABB bounds) {
         return BlockPos.betweenClosedStream(bounds.contract(1, 1, 1));
     }
 
-    public static Stream<BlockPos> allCorners(AABB bounds) {
-        Stream.Builder<BlockPos> stream = Stream.builder();
-        stream.add(BlockPos.containing(bounds.maxX - 1, bounds.maxY - 1, bounds.maxZ - 1));
-        stream.add(BlockPos.containing(bounds.minX, bounds.maxY - 1, bounds.maxZ - 1));
-        stream.add(BlockPos.containing(bounds.maxX - 1, bounds.minY, bounds.maxZ - 1));
-        stream.add(BlockPos.containing(bounds.minX, bounds.minY, bounds.maxZ - 1));
-        stream.add(BlockPos.containing(bounds.maxX - 1, bounds.maxY - 1, bounds.minZ));
-        stream.add(BlockPos.containing(bounds.minX, bounds.maxY - 1, bounds.minZ));
-        stream.add(BlockPos.containing(bounds.maxX - 1, bounds.minY, bounds.minZ));
-        stream.add(BlockPos.containing(bounds.minX, bounds.minY, bounds.minZ));
-        return stream.build();
-    }
-
     public static Vector3dc minCorner(AABB aabb) {
-        return new Vector3d(aabb.minX, aabb.minY, aabb.minZ);
+        return VectorUtils.convert3d(aabb.getMinPosition());
     }
 
     public static ChunkPos minCornerChunk(AABB aabb) {
@@ -67,7 +62,7 @@ public static ChunkPos minCornerChunk(AABB aabb) {
     }
 
     public static Vector3dc maxCorner(AABB aabb) {
-        return new Vector3d(aabb.maxX, aabb.maxY, aabb.maxZ);
+        return VectorUtils.convert3d(aabb.getMaxPosition());
     }
 
     public static ChunkPos maxCornerChunk(AABB aabb) {

spatial/src/main/java/dev/compactmods/spatial/aabb/AABBPositionHelper.java

@@ -0,0 +1,57 @@
+package dev.compactmods.spatial.aabb;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Direction8;
+import net.minecraft.world.phys.AABB;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector3d;
+import org.joml.Vector3dc;
+
+import java.util.stream.Stream;
+
+public record AABBPositionHelper(AABB boundaries) {
+
+    @NotNull
+    public Stream<BlockPos> blocks() {
+        return BlockPos.betweenClosedStream(boundaries.contract(1, 1, 1));
+    }
+
+    public Vector3dc center() {
+        return new Vector3d(boundaries.getCenter().toVector3f());
+    }
+
+    public Vector3dc planarLocation(Direction8 direction, double y) {
+        final var center = boundaries.getCenter();
+        Vector3d point = new Vector3d(0, y, 0);
+        int stepX = direction.getStepX();
+        int stepZ = direction.getStepZ();
+
+        switch (stepX) {
+            case -1 -> point.x = boundaries.minX;
+            case 0 -> point.x = center.x;
+            case 1 -> point.x = boundaries.maxX;
+        }
+
+        switch (stepZ) {
+            case -1 -> point.z = boundaries.minZ;
+            case 0 -> point.z = center.z;
+            case 1 -> point.z = boundaries.maxZ;
+        }
+
+        return point;
+    }
+
+    public double axisLength(Direction.Axis axis) {
+        // pick X Y or Z size from directional AXIS
+        // offset = AXIS --> BOUNDARY SIZE
+        return axis.choose(boundaries.getXsize(), boundaries.getYsize(), boundaries.getZsize());
+    }
+
+    public double centerToEdgeLength(Direction direction) {
+        var axisSize = axisLength(direction.getAxis());
+
+        // Half the axis size so we measure center to edge
+        return axisSize / 2d;
+    }
+}

spatial/src/main/java/dev/compactmods/spatial/aabb/BlockSpaceUtil.java

@@ -0,0 +1,26 @@
+package dev.compactmods.spatial.aabb;
+
+import net.minecraft.core.Direction;
+import net.minecraft.core.Vec3i;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+
+public class BlockSpaceUtil {
+
+    public static AABB getPlanarNormal(Direction direction) {
+        if (direction.getAxis().isHorizontal())
+            return getPlanarNormal(Direction.UP, direction.getCounterClockWise());
+        else
+            return getPlanarNormal(direction == Direction.UP ? Direction.SOUTH : Direction.NORTH,
+                    direction.getClockWise(Direction.Axis.Z));
+    }
+
+    public static AABB getPlanarNormal(Direction up, Direction right) {
+        Vec3i rightNorm = right.getNormal();
+        Vec3i upNorm = up.getNormal();
+
+        return AABB.ofSize(Vec3.ZERO, rightNorm.getX() + upNorm.getX(),
+                rightNorm.getY() + upNorm.getY(),
+                rightNorm.getZ() + upNorm.getZ());
+    }
+}

spatial/src/main/java/dev/compactmods/spatial/blocks/FilterableBlockContext.java

@@ -0,0 +1,11 @@
+package dev.compactmods.spatial.blocks;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public interface FilterableBlockContext {
+    Stream<BlockPos> matchingState(Predicate<BlockState> filter);
+}

spatial/src/main/java/dev/compactmods/spatial/blocks/ResolvableBlockPalette.java

@@ -0,0 +1,12 @@
+package dev.compactmods.spatial.blocks;
+
+import net.minecraft.core.HolderLookup;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.Set;
+import java.util.function.Predicate;
+
+public interface ResolvableBlockPalette extends Predicate<BlockState> {
+    Set<BlockState> resolve(HolderLookup.RegistryLookup<Block> blockRegistry);
+}

spatial/src/main/java/dev/compactmods/spatial/blocks/context/BlockContext.java

@@ -0,0 +1,18 @@
+package dev.compactmods.spatial.blocks.context;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public interface BlockContext {
+    boolean isEmpty();
+
+    Stream<BlockPos> blockPositions();
+
+    BlockState getBlockState(BlockPos pos);
+
+    Optional<BlockEntity> getBlockEntity(BlockPos pos);
+}

spatial/src/main/java/dev/compactmods/spatial/blocks/context/BoundedBlockContext.java

@@ -0,0 +1,16 @@
+package dev.compactmods.spatial.blocks.context;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.levelgen.structure.BoundingBox;
+
+import java.util.stream.Stream;
+
+public interface BoundedBlockContext extends BlockContext {
+
+    BoundingBox bounds();
+
+    @Override
+    default Stream<BlockPos> blockPositions() {
+        return BlockPos.betweenClosedStream(bounds());
+    }
+}

spatial/src/main/java/dev/compactmods/spatial/blocks/context/FixedBoxBoundariesBlockContext.java

@@ -0,0 +1,70 @@
+package dev.compactmods.spatial.blocks.context;
+
+import dev.compactmods.spatial.blocks.FilterableBlockContext;
+import dev.compactmods.spatial.blocks.filters.EmptyBlockFilter;
+import dev.compactmods.spatial.blocks.snapshot.LevelBlockSnapshot;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.structure.BoundingBox;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.ref.WeakReference;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public record FixedBoxBoundariesBlockContext(
+        WeakReference<LevelReader> levelReader,
+        LevelBlockSnapshot snapshot
+) implements BlockContext, FilterableBlockContext, AutoCloseable {
+
+    @NotNull
+    public static FixedBoxBoundariesBlockContext create(LevelReader levelReader, BoundingBox bounds) {
+        final var ref = new WeakReference<>(levelReader);
+        final var snapshot = LevelBlockSnapshot.from(levelReader, bounds);
+        return new FixedBoxBoundariesBlockContext(ref, snapshot);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        final var filter = EmptyBlockFilter.INSTANCE.negate();
+        return snapshot.matchingState(filter)
+                .findAny()
+                .isPresent();
+    }
+
+    @Override
+    public Stream<BlockPos> blockPositions() {
+        return snapshot.positions();
+    }
+
+    @Override
+    public BlockState getBlockState(BlockPos pos) {
+        return snapshot.getBlockState(pos);
+    }
+
+    @Override
+    public Optional<BlockEntity> getBlockEntity(BlockPos pos) {
+        return snapshot.getBlockEntityData(pos).map(data -> {
+            final var state = getBlockState(pos);
+            if(levelReader.get() instanceof LevelReader reader) {
+                final var provider = reader.registryAccess();
+                return BlockEntity.loadStatic(pos, state, data, provider);
+            } else {
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public Stream<BlockPos> matchingState(Predicate<BlockState> filter) {
+        return snapshot.matchingState(filter);
+    }
+
+    @Override
+    public void close() {
+        levelReader.clear();
+    }
+}