From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: 2No2Name <2No2Name@web.de> Date: Fri, 21 Jan 2022 08:41:34 -0500 Subject: [PATCH] lithium: block.moving_block_shapes Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0 You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings) diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java index 7c59d44a3bafdc65f453d77ff3e25cffb742ad6c..636721a111cad13e7329f1157981ca03a8f339b3 100644 --- a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java +++ b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java @@ -52,6 +52,74 @@ public class PistonMovingBlockEntity extends BlockEntity { this.extending = extending; this.isSourcePiston = source; } + // JettPack start - lithium: block.moving_block_shapes + private static final VoxelShape[] PISTON_BASE_WITH_MOVING_HEAD_SHAPES = precomputePistonBaseWithMovingHeadShapes(); + + /** + * We cache the offset and simplified VoxelShapes that are otherwise constructed on every call of getCollisionShape. + * For each offset direction and distance (6 directions, 2 distances each, and no direction with 0 distance) we + * store the offset and simplified VoxelShapes in the original VoxelShape when they are accessed the first time. + * We use safe publication, because both the Render and Server thread are using the cache. + * + * @param blockShape the original shape, must not be modified after passing it as an argument to this method + * @param offset the offset distance + * @param direction the offset direction + * @return blockShape offset and simplified + */ + private static VoxelShape getOffsetAndSimplified(VoxelShape blockShape, float offset, Direction direction) { + VoxelShape offsetSimplifiedShape = blockShape.getOffsetSimplifiedShape(offset, direction); + if (offsetSimplifiedShape == null) { + //create the offset shape and store it for later use + offsetSimplifiedShape = blockShape.move(direction.getStepX() * offset, direction.getStepY() * offset, direction.getStepZ() * offset).optimize(); + blockShape.setShape(offset, direction, offsetSimplifiedShape); + } + return offsetSimplifiedShape; + } + + /** + * Precompute all 18 possible configurations for the merged piston base and head shape. + * + * @return The array of the merged VoxelShapes, indexed by {@link PistonBlockEntityMixin#getIndexForMergedShape(float, Direction)} + */ + private static VoxelShape[] precomputePistonBaseWithMovingHeadShapes() { + float[] offsets = {0f, 0.5f, 1f}; + Direction[] directions = Direction.values(); + + VoxelShape[] mergedShapes = new VoxelShape[offsets.length * directions.length]; + + for (Direction facing : directions) { + VoxelShape baseShape = Blocks.PISTON.defaultBlockState().setValue(PistonBaseBlock.EXTENDED, true) + .setValue(PistonBaseBlock.FACING, facing).getCollisionShape(null, null); + for (float offset : offsets) { + //this cache is only required for the merged piston head + base shape. + //this shape is only used when !this.extending + //here: isShort = this.extending != 1.0F - this.progress < 0.25F can be simplified to: + //isShort = f < 0.25F , because f = getAmountExtended(this.progress) can be simplified to f == 1.0F - this.progress + //therefore isShort is dependent on the offset: + boolean isShort = offset < 0.25f; + + VoxelShape headShape = (Blocks.PISTON_HEAD.defaultBlockState().setValue(PistonHeadBlock.FACING, facing)) + .setValue(PistonHeadBlock.SHORT, isShort).getCollisionShape(null, null); + + VoxelShape offsetHead = headShape.move(facing.getStepX() * offset, + facing.getStepY() * offset, + facing.getStepZ() * offset); + mergedShapes[getIndexForMergedShape(offset, facing)] = Shapes.or(baseShape, offsetHead); + } + + } + + return mergedShapes; + } + + private static int getIndexForMergedShape(float offset, Direction direction) { + if (offset != 0f && offset != 0.5f && offset != 1f) { + return -1; + } + //shape of offset 0 is still dependent on the direction, due to piston head and base being directional blocks + return (int) (2 * offset) + (3 * direction.get3DDataValue()); + } + // JettPack end @Override public CompoundTag getUpdateTag() { @@ -351,10 +419,27 @@ public class PistonMovingBlockEntity extends BlockEntity { } float f = this.getExtendedProgress(this.progress); + // JettPack start - lithium: block.moving_block_shapes + if (this.extending || !this.isSourcePiston || !(this.movedState.getBlock() instanceof PistonBaseBlock)) { + //here voxelShape2.isEmpty() is guaranteed, vanilla code would call union() which calls simplify() + VoxelShape blockShape = blockState.getCollisionShape(world, pos); + + //we cache the simplified shapes, as the simplify() method costs a lot of CPU time and allocates several objects + VoxelShape offsetAndSimplified = getOffsetAndSimplified(blockShape, Math.abs(f), f < 0f ? this.direction.getOpposite() : this.direction); + return offsetAndSimplified; + } else { + //retracting piston heads have to act like their base as well, as the base block is replaced with the moving block + //f >= 0f is guaranteed (assuming no other mod interferes) + int index = getIndexForMergedShape(f, this.direction); + return PISTON_BASE_WITH_MOVING_HEAD_SHAPES[index]; + } + /* double d = (double)((float)this.direction.getStepX() * f); double e = (double)((float)this.direction.getStepY() * f); double g = (double)((float)this.direction.getStepZ() * f); return Shapes.or(voxelShape, blockState.getCollisionShape(world, pos).move(d, e, g)); + */ + // JettPack end } } diff --git a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java index 2182afd1b95acf14c55bddfeec17dae0a63e1f00..461ac9a464c4a66e302798032c6019bb60f6862b 100644 --- a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java +++ b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java @@ -26,6 +26,44 @@ public abstract class VoxelShape { } // Paper end + // JettPack start - lithium: block.moving_block_shapes + private volatile VoxelShape[] offsetAndSimplified; + + public void setShape(float offset, Direction direction, VoxelShape offsetShape) { + if (offsetShape == null) { + throw new IllegalArgumentException("offsetShape must not be null!"); + } + int index = getIndexForOffsetSimplifiedShapes(offset, direction); + VoxelShape[] offsetAndSimplifiedShapes = this.offsetAndSimplified; + if (offsetAndSimplifiedShapes == null) { + offsetAndSimplifiedShapes = new VoxelShape[1 + 2 * 6]; + } else { + offsetAndSimplifiedShapes = offsetAndSimplifiedShapes.clone(); + } + offsetAndSimplifiedShapes[index] = offsetShape; + this.offsetAndSimplified = offsetAndSimplifiedShapes; + } + + public VoxelShape getOffsetSimplifiedShape(float offset, Direction direction) { + VoxelShape[] offsetAndSimplified = this.offsetAndSimplified; + if (offsetAndSimplified == null) { + return null; + } + int index = getIndexForOffsetSimplifiedShapes(offset, direction); + return offsetAndSimplified[index]; + } + + private static int getIndexForOffsetSimplifiedShapes(float offset, Direction direction) { + if (offset != 0f && offset != 0.5f && offset != 1f) { + throw new IllegalArgumentException("offset must be one of {0f, 0.5f, 1f}"); + } + if (offset == 0f) { + return 0; //can treat offsetting by 0 in all directions the same + } + return (int) (2 * offset) + 2 * direction.get3DDataValue(); + } + // JettPack end + protected VoxelShape(DiscreteVoxelShape voxels) { // Paper - protected this.shape = voxels; }