From 53e1f0f416b347a6ef2465a2e53335783ad242bf Mon Sep 17 00:00:00 2001 From: grimmauld Date: Sat, 17 Apr 2021 21:24:38 +0200 Subject: [PATCH] VERY crude rendering of mirror beams (A LOT of things are broken!) --- src/generated/resources/.cache/cache | 2 +- .../data/create/advancements/aesthetics.json | 4 +- .../curiosities/ChromaticCompoundItem.java | 36 +------ .../create/content/optics/BeamSegment.java | 39 +++++++ .../create/content/optics/ILightHandler.java | 34 ++++++ .../mirror/BeaconSegmentListWrapper.java | 5 + .../content/optics/mirror/MirrorRenderer.java | 101 ++++++++++++++++-- .../optics/mirror/MirrorTileEntity.java | 66 +++++++++++- .../foundation/utility/BeaconHelper.java | 66 ++++++++++++ .../create/foundation/utility/VecHelper.java | 11 ++ .../create/models/block/mirror/block.json | 4 +- 11 files changed, 315 insertions(+), 53 deletions(-) create mode 100644 src/main/java/com/simibubi/create/content/optics/BeamSegment.java create mode 100644 src/main/java/com/simibubi/create/content/optics/ILightHandler.java create mode 100644 src/main/java/com/simibubi/create/content/optics/mirror/BeaconSegmentListWrapper.java create mode 100644 src/main/java/com/simibubi/create/foundation/utility/BeaconHelper.java diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache index bfd4e3ad8..d7e153d8f 100644 --- a/src/generated/resources/.cache/cache +++ b/src/generated/resources/.cache/cache @@ -1651,7 +1651,7 @@ d080b1b25e5bc8baf5aee68691b08c7f12ece3b0 assets/create/models/item/windmill_bear a80fb25a0b655e76be986b5b49fcb0f03461a1ab assets/create/models/item/zinc_nugget.json b1689617190c05ef34bd18456b0c7ae09bb3210f assets/create/models/item/zinc_ore.json f98bf9f870ac5ee5b31c12a20739773c5fee4949 assets/create/sounds.json -0f1b4b980afba9bf2caf583b88e261bba8b10313 data/create/advancements/aesthetics.json +5d0cc4c0255dc241e61c173b31ddca70c88d08e4 data/create/advancements/aesthetics.json 187921fa131b06721bfaf63f2623a28c141aae9a data/create/advancements/andesite_alloy.json 0ea2db7173b5be28b289ea7c9a6a0cf5805c60c7 data/create/advancements/andesite_casing.json 83c046bd200623933545c9e4326f782fb02c87fa data/create/advancements/arm_blaze_burner.json diff --git a/src/generated/resources/data/create/advancements/aesthetics.json b/src/generated/resources/data/create/advancements/aesthetics.json index d723cbe38..59a86f429 100644 --- a/src/generated/resources/data/create/advancements/aesthetics.json +++ b/src/generated/resources/data/create/advancements/aesthetics.json @@ -28,8 +28,8 @@ "trigger": "create:bracket_apply", "conditions": { "accepted_entries": [ - "create:cogwheel", - "create:large_cogwheel" + "create:large_cogwheel", + "create:cogwheel" ] } }, diff --git a/src/main/java/com/simibubi/create/content/curiosities/ChromaticCompoundItem.java b/src/main/java/com/simibubi/create/content/curiosities/ChromaticCompoundItem.java index 3b7d0ae2d..aa695607b 100644 --- a/src/main/java/com/simibubi/create/content/curiosities/ChromaticCompoundItem.java +++ b/src/main/java/com/simibubi/create/content/curiosities/ChromaticCompoundItem.java @@ -5,6 +5,7 @@ import java.util.Random; import com.simibubi.create.AllItems; import com.simibubi.create.foundation.config.AllConfigs; import com.simibubi.create.foundation.config.CRecipes; +import com.simibubi.create.foundation.utility.BeaconHelper; import com.simibubi.create.foundation.utility.ColorHelper; import com.simibubi.create.foundation.utility.VecHelper; @@ -15,17 +16,12 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompoundNBT; import net.minecraft.particles.ParticleTypes; -import net.minecraft.tileentity.BeaconTileEntity; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.Direction; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.RayTraceContext; import net.minecraft.util.math.RayTraceContext.BlockMode; import net.minecraft.util.math.RayTraceContext.FluidMode; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; -import net.minecraft.world.gen.Heightmap; public class ChromaticCompoundItem extends Item { @@ -114,35 +110,7 @@ public class ChromaticCompoundItem extends Item { } // Is inside beacon beam? - boolean isOverBeacon = false; - int entityX = MathHelper.floor(entity.getX()); - int entityZ = MathHelper.floor(entity.getZ()); - int localWorldHeight = world.getHeight(Heightmap.Type.WORLD_SURFACE, entityX, entityZ); - - BlockPos.Mutable testPos = - new BlockPos.Mutable(entityX, Math.min(MathHelper.floor(entity.getY()), localWorldHeight), entityZ); - - while (testPos.getY() > 0) { - testPos.move(Direction.DOWN); - BlockState state = world.getBlockState(testPos); - if (state.getOpacity(world, testPos) >= 15 && state.getBlock() != Blocks.BEDROCK) - break; - if (state.getBlock() == Blocks.BEACON) { - TileEntity te = world.getTileEntity(testPos); - - if (!(te instanceof BeaconTileEntity)) - break; - - BeaconTileEntity bte = (BeaconTileEntity) te; - - if (bte.getLevels() != 0 && !bte.beamSegments.isEmpty()) - isOverBeacon = true; - - break; - } - } - - if (isOverBeacon) { + if (BeaconHelper.isAboveActiveBeacon(entity.getPositionVec(), world)) { ItemStack newStack = AllItems.REFINED_RADIANCE.asStack(); newStack.setCount(stack.getCount()); data.putBoolean("JustCreated", true); diff --git a/src/main/java/com/simibubi/create/content/optics/BeamSegment.java b/src/main/java/com/simibubi/create/content/optics/BeamSegment.java new file mode 100644 index 000000000..30ce14023 --- /dev/null +++ b/src/main/java/com/simibubi/create/content/optics/BeamSegment.java @@ -0,0 +1,39 @@ +package com.simibubi.create.content.optics; + +import javax.annotation.Nonnull; + +import net.minecraft.util.math.vector.Vector3d; + +public class BeamSegment { + public final float[] colors; + private final Vector3d direction; + private final Vector3d start; + private int length; + + public BeamSegment(@Nonnull float[] color, Vector3d start, Vector3d direction) { + this.colors = color; + this.direction = direction; + this.start = start; + this.length = 1; + } + + public void incrementLength() { + ++this.length; + } + + public float[] getColors() { + return this.colors; + } + + public int getLength() { + return this.length; + } + + public Vector3d getDirection() { + return direction; + } + + public Vector3d getStart() { + return start; + } +} diff --git a/src/main/java/com/simibubi/create/content/optics/ILightHandler.java b/src/main/java/com/simibubi/create/content/optics/ILightHandler.java new file mode 100644 index 000000000..d4f60191f --- /dev/null +++ b/src/main/java/com/simibubi/create/content/optics/ILightHandler.java @@ -0,0 +1,34 @@ +package com.simibubi.create.content.optics; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.BlockRayTraceResult; +import net.minecraft.util.math.RayTraceContext; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.world.World; + +public interface ILightHandler> { + Vector3d getBeamDirection(); + + default double getBeamLenght() { + T te = getTile(); + World world = te.getWorld(); + BlockPos pos = te.getPos(); + if (pos == BlockPos.ZERO || world == null) + return 0; + + Vector3d direction = getBeamDirection(); + BlockRayTraceResult raytrace = world + .rayTraceBlocks(new RayTraceContext(Vector3d.of(pos).add(direction), + direction.normalize() + .scale(128) + .add(Vector3d.of(pos)), + RayTraceContext.BlockMode.OUTLINE, RayTraceContext.FluidMode.NONE, null)); + + return Vector3d.of(raytrace.getPos() + .subtract(pos)) + .length(); + } + + T getTile(); +} diff --git a/src/main/java/com/simibubi/create/content/optics/mirror/BeaconSegmentListWrapper.java b/src/main/java/com/simibubi/create/content/optics/mirror/BeaconSegmentListWrapper.java new file mode 100644 index 000000000..077708019 --- /dev/null +++ b/src/main/java/com/simibubi/create/content/optics/mirror/BeaconSegmentListWrapper.java @@ -0,0 +1,5 @@ +package com.simibubi.create.content.optics.mirror; + +public class BeaconSegmentListWrapper { + +} diff --git a/src/main/java/com/simibubi/create/content/optics/mirror/MirrorRenderer.java b/src/main/java/com/simibubi/create/content/optics/mirror/MirrorRenderer.java index f690bc5a9..afab9a294 100644 --- a/src/main/java/com/simibubi/create/content/optics/mirror/MirrorRenderer.java +++ b/src/main/java/com/simibubi/create/content/optics/mirror/MirrorRenderer.java @@ -1,23 +1,62 @@ package com.simibubi.create.content.optics.mirror; +import static net.minecraft.client.renderer.tileentity.BeaconTileEntityRenderer.TEXTURE_BEACON_BEAM; + +import javax.annotation.ParametersAreNonnullByDefault; + import com.mojang.blaze3d.matrix.MatrixStack; +import com.mojang.blaze3d.vertex.IVertexBuilder; import com.simibubi.create.AllBlockPartials; import com.simibubi.create.content.contraptions.base.KineticTileEntity; import com.simibubi.create.content.contraptions.base.KineticTileEntityRenderer; +import com.simibubi.create.content.optics.BeamSegment; import com.simibubi.create.foundation.render.SuperByteBuffer; import com.simibubi.create.foundation.utility.AngleHelper; import net.minecraft.client.renderer.IRenderTypeBuffer; import net.minecraft.client.renderer.RenderType; +import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; import net.minecraft.state.properties.BlockStateProperties; import net.minecraft.util.Direction; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.Matrix3f; +import net.minecraft.util.math.vector.Matrix4f; +import net.minecraft.util.math.vector.Vector3f; +@ParametersAreNonnullByDefault public class MirrorRenderer extends KineticTileEntityRenderer { public MirrorRenderer(TileEntityRendererDispatcher dispatcher) { super(dispatcher); } + private static void method_22741(MatrixStack ms, IVertexBuilder builder, float[] colors, float p_228840_5_, int p_228840_6_, int p_228840_7_, float p_228840_8_, float p_228840_9_, float p_228840_10_, float p_228840_11_, float p_228840_12_, float p_228840_13_, float p_228840_14_, float p_228840_15_, float p_228840_16_, float p_228840_17_, float p_228840_18_, float p_228840_19_) { + MatrixStack.Entry matrixstack$entry = ms.peek(); + Matrix4f matrix4f = matrixstack$entry.getModel(); + Matrix3f matrix3f = matrixstack$entry.getNormal(); + method_22740(matrix4f, matrix3f, builder, colors[0], colors[1], colors[2], p_228840_5_, p_228840_6_, p_228840_7_, p_228840_8_, p_228840_9_, p_228840_10_, p_228840_11_, p_228840_16_, p_228840_17_, p_228840_18_, p_228840_19_); + method_22740(matrix4f, matrix3f, builder, colors[0], colors[1], colors[2], p_228840_5_, p_228840_6_, p_228840_7_, p_228840_14_, p_228840_15_, p_228840_12_, p_228840_13_, p_228840_16_, p_228840_17_, p_228840_18_, p_228840_19_); + method_22740(matrix4f, matrix3f, builder, colors[0], colors[1], colors[2], p_228840_5_, p_228840_6_, p_228840_7_, p_228840_10_, p_228840_11_, p_228840_14_, p_228840_15_, p_228840_16_, p_228840_17_, p_228840_18_, p_228840_19_); + method_22740(matrix4f, matrix3f, builder, colors[0], colors[1], colors[2], p_228840_5_, p_228840_6_, p_228840_7_, p_228840_12_, p_228840_13_, p_228840_8_, p_228840_9_, p_228840_16_, p_228840_17_, p_228840_18_, p_228840_19_); + } + + private static void method_22740(Matrix4f matrix, Matrix3f p_228839_1_, IVertexBuilder builder, float p_228839_3_, float p_228839_4_, float p_228839_5_, float p_228839_6_, int p_228839_7_, int p_228839_8_, float p_228839_9_, float p_228839_10_, float p_228839_11_, float p_228839_12_, float p_228839_13_, float p_228839_14_, float p_228839_15_, float p_228839_16_) { + method_23076(matrix, p_228839_1_, builder, p_228839_3_, p_228839_4_, p_228839_5_, p_228839_6_, p_228839_8_, p_228839_9_, p_228839_10_, p_228839_14_, p_228839_15_); + method_23076(matrix, p_228839_1_, builder, p_228839_3_, p_228839_4_, p_228839_5_, p_228839_6_, p_228839_7_, p_228839_9_, p_228839_10_, p_228839_14_, p_228839_16_); + method_23076(matrix, p_228839_1_, builder, p_228839_3_, p_228839_4_, p_228839_5_, p_228839_6_, p_228839_7_, p_228839_11_, p_228839_12_, p_228839_13_, p_228839_16_); + method_23076(matrix, p_228839_1_, builder, p_228839_3_, p_228839_4_, p_228839_5_, p_228839_6_, p_228839_8_, p_228839_11_, p_228839_12_, p_228839_13_, p_228839_15_); + } + + private static void method_23076(Matrix4f p_228838_0_, Matrix3f p_228838_1_, IVertexBuilder builder, float p_228838_3_, float p_228838_4_, float p_228838_5_, float p_228838_6_, int p_228838_7_, float p_228838_8_, float p_228838_9_, float p_228838_10_, float p_228838_11_) { + builder.vertex(p_228838_0_, p_228838_8_, (float) p_228838_7_, p_228838_9_) + .color(p_228838_3_, p_228838_4_, p_228838_5_, p_228838_6_) + .texture(p_228838_10_, p_228838_11_) + .overlay(OverlayTexture.DEFAULT_UV) + .light(15728880) + .normal(p_228838_1_, 0.0F, 1.0F, 0.0F) + .endVertex(); + } + @Override protected void renderSafe(KineticTileEntity te, float partialTicks, MatrixStack ms, IRenderTypeBuffer buffer, int light, int overlay) { @@ -25,24 +64,66 @@ public class MirrorRenderer extends KineticTileEntityRenderer { // if (FastRenderDispatcher.available(te.getWorld())) return; super.renderSafe(te, partialTicks, ms, buffer, light, overlay); + MirrorTileEntity mirrorTe = (MirrorTileEntity) te; + + renderMirror(mirrorTe, partialTicks, ms, buffer, light); + renderOutBeam(mirrorTe, partialTicks, ms, buffer, light); + } + + private void renderOutBeam(MirrorTileEntity mirrorTe, float partialTicks, MatrixStack ms, IRenderTypeBuffer buffer, int light) { + + int start = 0; + + for (int k = 0; k < mirrorTe.beam.size(); k++) { + BeamSegment beamSegment = mirrorTe.beam.get(k); + renderSegment(beamSegment, ms, buffer, partialTicks, mirrorTe.getWorld() + .getGameTime(), + beamSegment.getDirection() + .scale(start + beamSegment.getLength()) + .length()); + start += beamSegment.getLength(); + } + } + + private void renderSegment(BeamSegment beamSegment, MatrixStack ms, IRenderTypeBuffer buffer, float partialTicks, long gameTime, double length) { + float adjustedGameTime = (float) Math.floorMod(gameTime, 40L) + partialTicks; + ms.push(); + ms.translate(0.5D, 0.0D, 0.5D); + ms.push(); + ms.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(adjustedGameTime * 2.25F - 45.0F)); + float f2 = MathHelper.fractionalPart(-adjustedGameTime * 0.2F - (float) MathHelper.floor(-adjustedGameTime * 0.1F)); + float f15 = f2 - 1; + float f16 = (float) beamSegment.getLength() * 1F * (0.5F / 0.2F) + f15; + method_22741(ms, buffer.getBuffer(RenderType.getBeaconBeam(TEXTURE_BEACON_BEAM, true)), beamSegment.colors, 1F, MathHelper.floor(length - beamSegment.getLength()), MathHelper.floor(length), 0F, 0.2F, .2F, 0F, -.2f, 0f, 0f, -.2f, 0f, 1f, f16, f15); + ms.pop(); + ms.pop(); + } + + private void renderMirror(MirrorTileEntity te, float partialTicks, MatrixStack ms, IRenderTypeBuffer buffer, int light) { - MirrorTileEntity bearingTe = (MirrorTileEntity) te; final Direction.Axis facing = te.getBlockState() .get(BlockStateProperties.AXIS); SuperByteBuffer superBuffer = AllBlockPartials.MIRROR_PLANE.renderOn(te.getBlockState()); - float interpolatedAngle = bearingTe.getInterpolatedAngle(partialTicks - 1); + float interpolatedAngle = te.getInterpolatedAngle(partialTicks - 1); kineticRotationTransform(superBuffer, te, facing, (float) (interpolatedAngle / 180 * Math.PI), light); - if (facing == Direction.Axis.X) { - superBuffer.rotateCentered(Direction.UP, AngleHelper.rad(90)); - } - if (facing == Direction.Axis.Y) { - superBuffer.rotateCentered(Direction.EAST, AngleHelper.rad(90)); - } - if (facing == Direction.Axis.Z) { - superBuffer.rotateCentered(Direction.UP, AngleHelper.rad(180)); + switch (facing) { + case X: + superBuffer.rotateCentered(Direction.UP, AngleHelper.rad(90)); + break; + case Y: + superBuffer.rotateCentered(Direction.EAST, AngleHelper.rad(90)); + break; + default: + superBuffer.rotateCentered(Direction.UP, AngleHelper.rad(180)); } + superBuffer.renderInto(ms, buffer.getBuffer(RenderType.getSolid())); } + + @Override + public boolean isGlobalRenderer(KineticTileEntity tileEntity) { + return true; + } } diff --git a/src/main/java/com/simibubi/create/content/optics/mirror/MirrorTileEntity.java b/src/main/java/com/simibubi/create/content/optics/mirror/MirrorTileEntity.java index e9c7f7660..28cd14238 100644 --- a/src/main/java/com/simibubi/create/content/optics/mirror/MirrorTileEntity.java +++ b/src/main/java/com/simibubi/create/content/optics/mirror/MirrorTileEntity.java @@ -1,21 +1,39 @@ package com.simibubi.create.content.optics.mirror; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + import com.simibubi.create.content.contraptions.base.KineticTileEntity; +import com.simibubi.create.content.optics.BeamSegment; +import com.simibubi.create.content.optics.ILightHandler; +import com.simibubi.create.foundation.utility.BeaconHelper; import com.simibubi.create.foundation.utility.ServerSpeedProvider; +import com.simibubi.create.foundation.utility.VecHelper; import net.minecraft.block.BlockState; +import net.minecraft.item.DyeColor; import net.minecraft.nbt.CompoundNBT; +import net.minecraft.tileentity.BeaconTileEntity; import net.minecraft.tileentity.TileEntityType; +import net.minecraft.util.Direction; import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.Vector3d; -public class MirrorTileEntity extends KineticTileEntity { +public class MirrorTileEntity extends KineticTileEntity implements ILightHandler { + public final List beam; protected float angle; protected float clientAngleDiff; private float prevAngle; + private double length; + private Optional beacon; public MirrorTileEntity(TileEntityType typeIn) { super(typeIn); - setLazyTickRate(3); + beacon = Optional.empty(); + beam = new ArrayList<>(); + setLazyTickRate(20); } @Override @@ -45,7 +63,7 @@ public class MirrorTileEntity extends KineticTileEntity { float speed = getSpeed() * 3 / 10f; if (getSpeed() == 0) speed = 0; - if (world.isRemote) { + if (world != null && world.isRemote) { speed *= ServerSpeedProvider.get(); speed += clientAngleDiff / 3f; } @@ -57,7 +75,7 @@ public class MirrorTileEntity extends KineticTileEntity { super.tick(); prevAngle = angle; - if (world.isRemote) + if (world != null && world.isRemote) clientAngleDiff /= 2; float angularSpeed = getAngularSpeed(); @@ -65,6 +83,35 @@ public class MirrorTileEntity extends KineticTileEntity { angle = newAngle % 360; } + @Override + public void lazyTick() { + super.lazyTick(); + beacon = BeaconHelper.getBeaconTE(pos, world); + length = getBeamLenght(); + + if (length < 1) + return; + Vector3d direction = VecHelper.step(getBeamDirection()); + Vector3d startPos = VecHelper.getCenterOf(getPos()); + beam.clear(); + + float[] startColor = DyeColor.WHITE.getColorComponentValues(); // TODO: Add mirroring of color + BeamSegment segment = new BeamSegment(startColor, startPos, direction); + + for (int i = 0; i < length; i++) { + startPos = startPos.add(direction); // check next block + float[] newColor = BeaconHelper.getBeaconColorAt(startPos, world); + if (newColor != null && !Arrays.equals(startColor, newColor)) { + beam.add(segment); + startColor = new float[]{(segment.colors[0] + newColor[0]) / 2.0F, (segment.colors[1] + newColor[1]) / 2.0F, (segment.colors[2] + newColor[2]) / 2.0F}; + segment = new BeamSegment(newColor, startPos, direction); + } else { + segment.incrementLength(); + } + } + beam.add(segment); + } + @Override public boolean shouldRenderAsTE() { return true; @@ -73,4 +120,15 @@ public class MirrorTileEntity extends KineticTileEntity { public void setAngle(float forcedAngle) { angle = forcedAngle; } + + @Override + public Vector3d getBeamDirection() { + // TODO: Implement properly + return VecHelper.step(Vector3d.of(Direction.SOUTH.getDirectionVec())); + } + + @Override + public MirrorTileEntity getTile() { + return this; + } } diff --git a/src/main/java/com/simibubi/create/foundation/utility/BeaconHelper.java b/src/main/java/com/simibubi/create/foundation/utility/BeaconHelper.java new file mode 100644 index 000000000..6d753f3dd --- /dev/null +++ b/src/main/java/com/simibubi/create/foundation/utility/BeaconHelper.java @@ -0,0 +1,66 @@ +package com.simibubi.create.foundation.utility; + +import java.util.Optional; + +import javax.annotation.Nullable; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.block.IBeaconBeamColorProvider; +import net.minecraft.tileentity.BeaconTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.world.IBlockReader; +import net.minecraft.world.World; +import net.minecraft.world.gen.Heightmap; + +public class BeaconHelper { + private BeaconHelper() { + } + + public static Optional getBeaconTE(@Nullable BlockPos testPos, @Nullable IBlockReader world) { + if (testPos == null || world == null) + return Optional.empty(); + while (testPos.getY() > 0) { + testPos = testPos.down(); + BlockState state = world.getBlockState(testPos); + if (state.getOpacity(world, testPos) >= 15 && state.getBlock() != Blocks.BEDROCK) + break; + if (state.getBlock() == Blocks.BEACON) { + TileEntity te = world.getTileEntity(testPos); + + if (!(te instanceof BeaconTileEntity)) + break; + return Optional.of((BeaconTileEntity) te); + } + } + return Optional.empty(); + } + + public static Optional getBeaconTE(Vector3d pos, World world) { + int testX = MathHelper.floor(pos.getX()); + int testZ = MathHelper.floor(pos.getZ()); + int localWorldHeight = world.getHeight(Heightmap.Type.WORLD_SURFACE, testX, testZ); + return getBeaconTE(new BlockPos(testX, Math.min(MathHelper.floor(pos.getY()), localWorldHeight), testZ), world); + } + + public static boolean isAboveActiveBeacon(Vector3d pos, World world) { + return getBeaconTE(pos, world).filter(bte -> bte.getLevels() != 0 && !bte.beamSegments.isEmpty()) + .isPresent(); + } + + @Nullable + public static float[] getBeaconColorAt(Vector3d pos, @Nullable IBlockReader world) { + if (world == null) + return null; + Block block = world.getBlockState(new BlockPos(pos.x, pos.y, pos.z)) + .getBlock(); + if (!(block instanceof IBeaconBeamColorProvider)) + return null; + return ((IBeaconBeamColorProvider) block).getColor() + .getColorComponentValues(); + } +} diff --git a/src/main/java/com/simibubi/create/foundation/utility/VecHelper.java b/src/main/java/com/simibubi/create/foundation/utility/VecHelper.java index 665ed1796..dd222108b 100644 --- a/src/main/java/com/simibubi/create/foundation/utility/VecHelper.java +++ b/src/main/java/com/simibubi/create/foundation/utility/VecHelper.java @@ -214,4 +214,15 @@ public class VecHelper { return new Vector3d(-result3f.getX() * scale_factor, result3f.getY() * scale_factor, result3f.getZ()); } + public static Vector3d step(Vector3d direction) { + return direction.scale(1 / varMax(Math.abs(direction.x), Math.abs(direction.y), Math.abs(direction.z))); + } + + private static double varMax(double n, double ... numbers) { + for (double test : numbers) { + if (test > n) + n = test; + } + return n; + } } diff --git a/src/main/resources/assets/create/models/block/mirror/block.json b/src/main/resources/assets/create/models/block/mirror/block.json index 7614462a2..0160bb244 100644 --- a/src/main/resources/assets/create/models/block/mirror/block.json +++ b/src/main/resources/assets/create/models/block/mirror/block.json @@ -21,8 +21,8 @@ }, { "name": "side", - "from": [2, 0, 2], - "to": [14, 1, 14], + "from": [2, 1, 2], + "to": [14, 2, 14], "rotation": {"angle": 0, "axis": "x", "origin": [8, -10, 8]}, "faces": { "north": {"uv": [2, 11, 14, 12], "rotation": 180, "texture": "#4"},