diff --git a/build.gradle b/build.gradle index 7350b63..b8c8926 100644 --- a/build.gradle +++ b/build.gradle @@ -21,10 +21,6 @@ dependencies { mappings "net.fabricmc:yarn:${project.minecraft_version}+build.${project.yarn_build}:v2" modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" modImplementation "net.fabricmc.fabric-api:fabric-api:${project.api_version}" - //modImplementation "net.fabricmc.fabric-api:fabric-api-base:${project.base_version}" - //modImplementation "net.fabricmc.fabric-api:fabric-events-lifecycle-v0:${project.event_version}" - //modImplementation "net.fabricmc.fabric-api:fabric-commands-v0:${project.cmd_version}" - //modImplementation "net.fabricmc.fabric-api:fabric-dimensions-v1:${project.dim_version}" } processResources { diff --git a/gradle.properties b/gradle.properties index 9b16ed0..e4eb410 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,18 +2,14 @@ org.gradle.jvmargs=-Xmx2G # Fabric Properties -minecraft_version=1.15.1 -yarn_build=1 -loader_version=0.7.2+build.175 +minecraft_version=20w09a +yarn_build=6 +loader_version=0.7.8+build.184 # Mod Properties -mod_version = 0.3 +mod_version = 0.4 maven_group = dev.vatuu archives_base_name = tesseract # Dependencies -api_version=0.4.24+build.279-1.15 -event_version=0.1.2+b7f9825de8 -base_version=0.1.2+b7f9825de4 -cmd_version=0.1.2+b7f9825de4 -dim_version=0.2.2+b7f9825de4 +api_version=0.4.33+build.301-1.16 \ No newline at end of file diff --git a/src/main/java/dev/vatuu/tesseract/api/DimensionBuilder.java b/src/main/java/dev/vatuu/tesseract/api/DimensionBuilder.java index 3a93176..ac83c38 100644 --- a/src/main/java/dev/vatuu/tesseract/api/DimensionBuilder.java +++ b/src/main/java/dev/vatuu/tesseract/api/DimensionBuilder.java @@ -21,6 +21,8 @@ public interface DimensionBuilder { DimensionBuilder bedsExplode(boolean shouldExplode); + DimensionBuilder beesExplode(boolean shouldExplode); + DimensionBuilder visibleSky(boolean hasVisibleSky); DimensionBuilder vaporizeWater(boolean vaporizeWater); diff --git a/src/main/java/dev/vatuu/tesseract/api/extensions/FogColourFunction.java b/src/main/java/dev/vatuu/tesseract/api/extensions/FogColourFunction.java index 4d96acf..241c093 100644 --- a/src/main/java/dev/vatuu/tesseract/api/extensions/FogColourFunction.java +++ b/src/main/java/dev/vatuu/tesseract/api/extensions/FogColourFunction.java @@ -3,5 +3,5 @@ import net.minecraft.util.math.Vec3d; public interface FogColourFunction { - Vec3d apply(float skyAngle, float tickDelta); + Vec3d apply(Vec3d pos, float tickDelta); } diff --git a/src/main/java/dev/vatuu/tesseract/impl/Tesseract.java b/src/main/java/dev/vatuu/tesseract/impl/Tesseract.java index af88d56..d7b2bd9 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/Tesseract.java +++ b/src/main/java/dev/vatuu/tesseract/impl/Tesseract.java @@ -1,11 +1,27 @@ package dev.vatuu.tesseract.impl; +import dev.vatuu.tesseract.api.DimensionBuilder; +import dev.vatuu.tesseract.api.DimensionRegistry; import dev.vatuu.tesseract.impl.cmd.ChangeDimensionCommand; import dev.vatuu.tesseract.impl.cmd.RegisterTestCommand; import dev.vatuu.tesseract.impl.cmd.WorldResetCommand; +import dev.vatuu.tesseract.impl.extras.lil.LilTesseractBlockEntity; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.event.server.ServerStartCallback; +import net.fabricmc.fabric.api.registry.CommandRegistry; +import net.minecraft.block.Block; +import net.minecraft.block.entity.BlockEntityType; +import net.minecraft.item.Item; +import net.minecraft.util.Identifier; +import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; +import net.minecraft.world.biome.Biomes; +import net.minecraft.world.biome.VoidBiome; +import net.minecraft.world.biome.source.BiomeAccess; +import net.minecraft.world.biome.source.BiomeAccessType; +import net.minecraft.world.biome.source.FixedBiomeSource; +import net.minecraft.world.biome.source.VoronoiBiomeAccessType; +import net.minecraft.world.dimension.OverworldDimension; public class Tesseract implements ModInitializer { @@ -13,10 +29,18 @@ public class Tesseract implements ModInitializer { @Override public void onInitialize() { - ServerStartCallback.EVENT.register((ci) -> { - ChangeDimensionCommand.register(ci.getCommandManager().getDispatcher()); - RegisterTestCommand.register(ci.getCommandManager().getDispatcher()); - WorldResetCommand.register(ci.getCommandManager().getDispatcher()); + + DimensionRegistry.getInstance().registerDimensionType( + new Identifier(MOD_ID, "telesis"), + true, + (w, t) -> DimensionBuilder.create().bedsExplode(true).cloudHeight(40).forcedSpawnPoint(new BlockPos(0, 64, 0)).visibleSky(true).build(w, t), + VoronoiBiomeAccessType.INSTANCE + ); + + CommandRegistry.INSTANCE.register(false, ci -> { + ChangeDimensionCommand.register(ci); + RegisterTestCommand.register(ci); + WorldResetCommand.register(ci); }); } diff --git a/src/main/java/dev/vatuu/tesseract/impl/cmd/ChangeDimensionCommand.java b/src/main/java/dev/vatuu/tesseract/impl/cmd/ChangeDimensionCommand.java index edda120..b16185a 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/cmd/ChangeDimensionCommand.java +++ b/src/main/java/dev/vatuu/tesseract/impl/cmd/ChangeDimensionCommand.java @@ -4,12 +4,14 @@ import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.fabricmc.fabric.api.dimension.v1.FabricDimensions; +import net.minecraft.block.pattern.BlockPattern; import net.minecraft.command.arguments.BlockPosArgumentType; import net.minecraft.command.arguments.DimensionArgumentType; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.server.command.CommandManager; import net.minecraft.server.command.ServerCommandSource; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; import net.minecraft.world.dimension.DimensionType; public class ChangeDimensionCommand { @@ -29,7 +31,7 @@ public static void register(CommandDispatcher dispatcher){ private static int activate(CommandContext context, DimensionType type, BlockPos pos) throws CommandSyntaxException { PlayerEntity entity = context.getSource().getPlayer(); - FabricDimensions.teleport(entity, type); + FabricDimensions.teleport(entity, type, (e, w, dir, pitch, yaw) -> new BlockPattern.TeleportTarget(new Vec3d(pos).add(0.5d, 0d, 0.5d), Vec3d.ZERO, (int)yaw)); entity.teleport(pos.getX(), pos.getY(), pos.getZ()); return 0; } diff --git a/src/main/java/dev/vatuu/tesseract/impl/cmd/WorldResetCommand.java b/src/main/java/dev/vatuu/tesseract/impl/cmd/WorldResetCommand.java index 264cb8b..ea52d68 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/cmd/WorldResetCommand.java +++ b/src/main/java/dev/vatuu/tesseract/impl/cmd/WorldResetCommand.java @@ -34,7 +34,7 @@ public static void register(CommandDispatcher dispatcher){ private static int activate(CommandContext context, DimensionType type, boolean unregister) throws CommandSyntaxException{ if(!(type instanceof TesseractDimensionType)){ - throw INVALID_DIMENSION.create(Registry.DIMENSION.getId(type)); + throw INVALID_DIMENSION.create(Registry.DIMENSION_TYPE.getId(type)); } ServerWorld playerWorld = context.getSource().getPlayer().getServer().getWorld(type); diff --git a/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/BeeEntityMixin.java b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/BeeEntityMixin.java index 18d6be1..0ed01c7 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/BeeEntityMixin.java +++ b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/BeeEntityMixin.java @@ -20,6 +20,7 @@ public BeeEntityMixin(EntityType type, World world){ super(type, world); } + //BeeGoBoom @Inject(method = "damage", at = @At(value = "RETURN")) public void damage(DamageSource src, float amount, CallbackInfoReturnable info){ if(amount > 0 && src instanceof EntityDamageSource) diff --git a/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/EndPortalBlockEntityRendererAccessor.java b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/EndPortalBlockEntityRendererAccessor.java new file mode 100644 index 0000000..19d0d1e --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/EndPortalBlockEntityRendererAccessor.java @@ -0,0 +1,17 @@ +package dev.vatuu.tesseract.impl.extensions.mixins; + +import net.minecraft.client.render.RenderLayer; +import net.minecraft.client.render.block.entity.EndPortalBlockEntityRenderer; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Accessor; + +import java.util.List; + +@Mixin(EndPortalBlockEntityRenderer.class) +public interface EndPortalBlockEntityRendererAccessor { + + @Accessor(value = "field_21732") + static List getEndEffectRenderLayers() { + throw new IllegalStateException("Have you heard about Tessentials?"); + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/MinecraftServerMixin.java b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/MinecraftServerMixin.java index 090cc72..21a6e2e 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/MinecraftServerMixin.java +++ b/src/main/java/dev/vatuu/tesseract/impl/extensions/mixins/MinecraftServerMixin.java @@ -3,14 +3,12 @@ import dev.vatuu.tesseract.api.DimensionState; import dev.vatuu.tesseract.impl.world.DimensionRegistryImpl; import dev.vatuu.tesseract.impl.world.TesseractDimension; -import net.minecraft.entity.passive.BeeEntity; import net.minecraft.server.MinecraftServer; import net.minecraft.server.WorldGenerationProgressListener; import net.minecraft.server.world.SecondaryServerWorld; import net.minecraft.server.world.ServerWorld; import net.minecraft.util.ProgressListener; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.profiler.DisableableProfiler; import net.minecraft.world.SessionLockException; import net.minecraft.world.WorldSaveHandler; import net.minecraft.world.dimension.DimensionType; @@ -35,7 +33,6 @@ public abstract class MinecraftServerMixin { @Shadow @Final private Map worlds; - @Shadow @Final private DisableableProfiler profiler; @Mutable private WorldSaveHandler saveHandler; @Mutable private WorldGenerationProgressListener generationProgress; @@ -56,7 +53,7 @@ private void getWorld(DimensionType dimensionType, CallbackInfoReturnable> { + + public PlayerEntityRendererMixin(EntityRenderDispatcher dispatcher, PlayerEntityModel model, float shadowSize) { + super(dispatcher, model, shadowSize); + } + + @Inject(at = @At("RETURN"), method = "(Lnet/minecraft/client/render/entity/EntityRenderDispatcher;Z)V") + private void constructor(EntityRenderDispatcher entityRenderDispatcher, boolean bl, CallbackInfo ci) { + this.addFeature(new TesseractCapeFeatureRenderer(this)); + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/fancy/TesseractCapeFeatureRenderer.java b/src/main/java/dev/vatuu/tesseract/impl/extras/fancy/TesseractCapeFeatureRenderer.java new file mode 100644 index 0000000..414471d --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/fancy/TesseractCapeFeatureRenderer.java @@ -0,0 +1,96 @@ +package dev.vatuu.tesseract.impl.extras.fancy; + +import dev.vatuu.tesseract.impl.extensions.mixins.EndPortalBlockEntityRendererAccessor; +import dev.vatuu.tesseract.impl.extensions.mixins.PlayerEntityModelAccessor; +import net.minecraft.client.network.AbstractClientPlayerEntity; +import net.minecraft.client.render.OverlayTexture; +import net.minecraft.client.render.RenderLayer; +import net.minecraft.client.render.VertexConsumer; +import net.minecraft.client.render.VertexConsumerProvider; +import net.minecraft.client.render.block.entity.EndGatewayBlockEntityRenderer; +import net.minecraft.client.render.entity.PlayerModelPart; +import net.minecraft.client.render.entity.feature.FeatureRenderer; +import net.minecraft.client.render.entity.feature.FeatureRendererContext; +import net.minecraft.client.render.entity.model.PlayerEntityModel; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.client.util.math.Vector3f; +import net.minecraft.entity.EquipmentSlot; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.util.math.MathHelper; + +import java.util.List; +import java.util.Random; +import java.util.UUID; + +public class TesseractCapeFeatureRenderer extends FeatureRenderer> { + + private static final UUID YOURS_TRUELY = UUID.fromString("275df345-c3c5-4768-9af8-440d9cdf593e"); + + private static final Random RANDOM = new Random(31100L); + private static final int LAYER_COUNT = 15; + private static final float LAYER_0_INTENSITY = 0.15F; + private static final List RENDER_LAYERS = EndPortalBlockEntityRendererAccessor.getEndEffectRenderLayers(); + + public TesseractCapeFeatureRenderer(FeatureRendererContext> context) { + super(context); + } + + public void render(MatrixStack stack, VertexConsumerProvider provider, int light, AbstractClientPlayerEntity p, float limbAngle, float limbDistance, float tickDelta, float customAngle, float headYaw, float headPitch) { + if (p.getUuid().equals(YOURS_TRUELY) && p.canRenderCapeTexture() && !p.isInvisible() && p.isPartVisible(PlayerModelPart.CAPE)) { + ItemStack itemStack = p.getEquippedStack(EquipmentSlot.CHEST); + if (itemStack.getItem() != Items.ELYTRA) { + stack.push(); + stack.translate(0.0D, 0.0D, 0.125D); + double x = MathHelper.lerp(tickDelta, p.field_7524, p.field_7500) - MathHelper.lerp(tickDelta, p.prevX, p.getX()); + double y = MathHelper.lerp(tickDelta, p.field_7502, p.field_7521) - MathHelper.lerp(tickDelta, p.prevY, p.getY()); + double z = MathHelper.lerp(tickDelta, p.field_7522, p.field_7499) - MathHelper.lerp(tickDelta, p.prevZ, p.getZ()); + + double o = MathHelper.sin(p.bodyYaw * 0.017453292F); + double pold = (-MathHelper.cos(p.bodyYaw * 0.017453292F)); + + float rotXPositive = (float)y * 10.0F; + rotXPositive = MathHelper.clamp(rotXPositive, -6.0F, 32.0F); + + float rotXNegative = (float)(x * o + z * pold * 100.0F); + rotXNegative = MathHelper.clamp(rotXNegative, 0.0F, 150.0F); + + float s = (float)(x * pold - z * o) * 100.0F; + s = MathHelper.clamp(s, -20.0F, 20.0F); + + if (rotXNegative < 0.0F) { + rotXNegative = 0.0F; + } + + float t = MathHelper.lerp(tickDelta, p.field_7505, p.field_7483); + rotXPositive += MathHelper.sin(MathHelper.lerp(tickDelta, p.prevHorizontalSpeed, p.horizontalSpeed) * 6.0F) * 32.0F * t; + if (p.isInSneakingPose()) { + rotXPositive += 25.0F; + } + + stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(6.0F + rotXNegative / 2.0F + rotXPositive)); + stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(s / 2.0F)); + stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(180.0F - s / 2.0F)); + + RANDOM.setSeed(31100L); + + float r = (RANDOM.nextFloat() * 0.5F + 0.1F) * LAYER_0_INTENSITY; + float g = (RANDOM.nextFloat() * 0.5F + 0.4F) * LAYER_0_INTENSITY; + float b = (RANDOM.nextFloat() * 0.5F + 0.5F) * LAYER_0_INTENSITY; + ((PlayerEntityModelAccessor)getContextModel()).getPlayerCapeModelPart().render(stack, provider.getBuffer(RENDER_LAYERS.get(0)), light, OverlayTexture.DEFAULT_UV, r, g, b, 1.0F); + + for(int i = 1; i < LAYER_COUNT; i++) { + VertexConsumer consumer = provider.getBuffer(RENDER_LAYERS.get(i)); + float intensity = 2.0F / (float)(18 - i); + r = (RANDOM.nextFloat() * 0.5F + 0.1F) * intensity; + g = (RANDOM.nextFloat() * 0.5F + 0.4F) * intensity; + b = (RANDOM.nextFloat() * 0.5F + 0.5F) * intensity; + + ((PlayerEntityModelAccessor)getContextModel()).getPlayerCapeModelPart().render(stack, consumer, light, OverlayTexture.DEFAULT_UV, r, g, b, 1.0F); + } + + stack.pop(); + } + } + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilConfigScreen.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilConfigScreen.java new file mode 100644 index 0000000..626a6fd --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilConfigScreen.java @@ -0,0 +1,152 @@ +package dev.vatuu.tesseract.impl.extras.lil; + +import com.mojang.blaze3d.systems.RenderSystem; +import dev.vatuu.tesseract.impl.Tesseract; +import dev.vatuu.tesseract.impl.extras.lil.rendering.BooleanButtonWidget; +import dev.vatuu.tesseract.impl.extras.lil.rendering.TesseractRenderer; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.widget.AbstractButtonWidget; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.render.VertexConsumerProvider; +import net.minecraft.client.sound.SoundManager; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.client.util.math.Vector3f; +import net.minecraft.text.TranslatableText; +import net.minecraft.util.Identifier; +import net.minecraft.util.math.MathHelper; + +public class LilConfigScreen extends Screen { + + private TesseractSettings settings; + private TesseractRenderer renderer; + + private RotationSliderWidget rotateX, rotateY, rotateZ, rotateW; + private BooleanButtonWidget buttonWireframe; + + public LilConfigScreen(TesseractSettings settings) { + super(new TranslatableText("tesseract configuration")); + this.settings = settings; + this.renderer = new TesseractRenderer(settings); + } + + public void init(){ + this.rotateX = addButton(new RotationSliderWidget(width / 2 - 80, height / 2 - 49, 126, 20, settings.rotateX)); + this.rotateY = addButton(new RotationSliderWidget(width / 2 - 80, height / 2 - 24, 126, 20, settings.rotateY)); + this.rotateZ = addButton(new RotationSliderWidget(width / 2 - 80, height / 2 - 1, 126, 20, settings.rotateZ)); + this.rotateW = addButton(new RotationSliderWidget(width / 2 - 80, height / 2 + 24, 126, 20, settings.rotateW)); + this.buttonWireframe = addButton(new BooleanButtonWidget(width / 2 - 113, height / 2 + 50, settings.wireframe, (b) -> {})); + addButton(new ButtonWidget(width / 2 + 80, height / 2 + 50, font.getStringWidth("Apply") + 10, 20, "Apply", (b) -> { + this.settings.wireframe = buttonWireframe.currentState(); + this.settings.rotateX = (float)rotateX.getValue(); + this.settings.rotateY = (float)rotateY.getValue(); + this.settings.rotateZ = (float)rotateZ.getValue(); + this.settings.rotateW = (float)rotateW.getValue(); + })); + } + + public void render(int mouseX, int mouseY, float tickDelta) { + renderBackground(); + MinecraftClient.getInstance().getTextureManager().bindTexture(new Identifier(Tesseract.MOD_ID, "textures/gui/gui.png")); + + blit(width / 2 - 126, height / 2 - 83, 0, 0,256, 166); + blit(width / 2 - 113, height / 2 - 49, 60, 166, 20, 20); //X + blit(width / 2 - 113, height / 2 - 24, 80, 166, 20, 20); //Y + blit(width / 2 - 113, height / 2 - 1, 100, 166, 20, 20); //Z + blit(width / 2 - 113, height / 2 + 24, 120, 166, 20, 20); //W + + font.draw("'lil Tesseract Configuration", width / 2 - (font.getStringWidth("'lil Tesseract Configuration") / 2), height / 2 - 83 + 10, 0x404040); + font.draw("Wireframe", width / 2 - 88, height / 2 + 56, 0x404040); + + drawTesseract(width / 2 + 67,height / 2 - 25, 45); + super.render(mouseX, mouseY, tickDelta); + } + + private void drawTesseract(int x, int y, int size) { + RenderSystem.pushMatrix(); + RenderSystem.translatef((float)x, (float)y, 1100.0F); + RenderSystem.scalef(1.0F, 1.0F, -1.0F); + MatrixStack matrixStack = new MatrixStack(); + matrixStack.translate(0.0D, 0.0D, 1000.0D); + matrixStack.scale((float)size, (float)size, (float)size); + matrixStack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(45.0f)); + matrixStack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(22.5f)); + matrixStack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(22.5f)); + VertexConsumerProvider.Immediate immediate = MinecraftClient.getInstance().getBufferBuilders().getEntityVertexConsumers(); + renderer.render(matrixStack, immediate, 3); + immediate.draw(); + RenderSystem.popMatrix(); + } + + @Override + public boolean isPauseScreen() { + return true; + } + + private class RotationSliderWidget extends AbstractButtonWidget { + + protected double value; + + protected RotationSliderWidget(int x, int y, int width, int height, double progress) { + super(x, y, width, height, ""); + this.value = progress; + this.updateMessage(); + } + + public double getValue() { + return value; + } + + public int getYImage(boolean isHovered) { + return 0; + } + + public void renderBg(MinecraftClient client, int mouseX, int mouseY) { + client.getTextureManager().bindTexture(WIDGETS_LOCATION); + RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F); + int i = (this.isHovered() ? 2 : 1) * 20; + this.blit(this.x + (int)(this.value * (double)(this.width - 8)), this.y, 0, 46 + i, 4, 20); + this.blit(this.x + (int)(this.value * (double)(this.width - 8)) + 4, this.y, 196, 46 + i, 4, 20); + } + + public void onClick(double mouseX, double mouseY) { + this.setValueFromMouse(mouseX); + } + + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + boolean bl = keyCode == 263; + if (bl || keyCode == 262) { + float f = bl ? -1.0F : 1.0F; + this.setValue(this.value + (double)(f / (float)(this.width - 8))); + } + + return false; + } + + private void setValueFromMouse(double d) { + this.setValue((d - (double)(this.x + 4)) / (double)(this.width - 8)); + } + + private void setValue(double mouseX) { + double d = this.value; + this.value = MathHelper.clamp(mouseX, -1.0D, 1.0D); + this.updateMessage(); + } + + public void onDrag(double mouseX, double mouseY, double deltaX, double deltaY) { + this.setValueFromMouse(mouseX); + super.onDrag(mouseX, mouseY, deltaX, deltaY); + } + + public void playDownSound(SoundManager soundManager) { + } + + public void onRelease(double mouseX, double mouseY) { + super.playDownSound(MinecraftClient.getInstance().getSoundManager()); + } + + public void updateMessage() { + this.setMessage(String.format("%.3f", value)); + }; + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlock.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlock.java new file mode 100644 index 0000000..b856924 --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlock.java @@ -0,0 +1,62 @@ +package dev.vatuu.tesseract.impl.extras.lil; + +import dev.vatuu.tesseract.impl.Tesseract; +import net.minecraft.block.*; +import net.minecraft.client.MinecraftClient; +import net.minecraft.entity.EntityContext; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.BlockItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemGroup; +import net.minecraft.util.ActionResult; +import net.minecraft.util.Hand; +import net.minecraft.util.Identifier; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.registry.Registry; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.util.shape.VoxelShapes; +import net.minecraft.world.BlockView; +import net.minecraft.world.World; + +public class LilTesseractBlock extends Block implements BlockEntityProvider { + + private static LilTesseractBlock BLOCK_TYPE; + + public static LilTesseractBlock getBlockType(){ + if(BLOCK_TYPE == null) { + BLOCK_TYPE = Registry.register( + Registry.BLOCK, + new Identifier(Tesseract.MOD_ID, "lil_tesseract"), + new LilTesseractBlock(Block.Settings.of(Material.METAL)) + ); + Registry.register(Registry.ITEM, new Identifier(Tesseract.MOD_ID, "lil_tesseract"), new BlockItem(BLOCK_TYPE, new Item.Settings().group(ItemGroup.MISC))); + } + return BLOCK_TYPE; + } + + public LilTesseractBlock(Settings settings) { + super(settings); + } + + @Override + public LilTesseractBlockEntity createBlockEntity(BlockView view) { + return new LilTesseractBlockEntity(); + } + + @Override + public BlockRenderType getRenderType(BlockState state) { + return BlockRenderType.INVISIBLE; + } + + @Override + public VoxelShape getOutlineShape(BlockState state, BlockView view, BlockPos pos, EntityContext ctx){ + return VoxelShapes.cuboid(0.1875f, 0.1875f, 0.1875f, 0.8125f, 0.8125f, 0.8125f); + } + + @Override + public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) { + MinecraftClient.getInstance().openScreen(new LilConfigScreen(((LilTesseractBlockEntity)world.getBlockEntity(pos)).settings)); + return ActionResult.SUCCESS; + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlockEntity.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlockEntity.java new file mode 100644 index 0000000..586202f --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractBlockEntity.java @@ -0,0 +1,32 @@ +package dev.vatuu.tesseract.impl.extras.lil; + +import dev.vatuu.tesseract.impl.Tesseract; +import net.fabricmc.fabric.api.client.rendereregistry.v1.BlockEntityRendererRegistry; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.block.entity.BlockEntityType; +import net.minecraft.util.Identifier; +import net.minecraft.util.registry.Registry; + +public class LilTesseractBlockEntity extends BlockEntity { + + private static BlockEntityType BLOCK_ENTITY_TYPE; + + public TesseractSettings settings; + + public static BlockEntityType getBlockEntityType() { + if(BLOCK_ENTITY_TYPE == null) { + BLOCK_ENTITY_TYPE = Registry.register( + Registry.BLOCK_ENTITY_TYPE, + new Identifier(Tesseract.MOD_ID, "lil_tesseract"), + BlockEntityType.Builder.create(LilTesseractBlockEntity::new, LilTesseractBlock.getBlockType()).build(null) + ); + BlockEntityRendererRegistry.INSTANCE.register(BLOCK_ENTITY_TYPE, LilTesseractRenderer::new); + } + return BLOCK_ENTITY_TYPE; + } + + public LilTesseractBlockEntity() { + super(getBlockEntityType()); + this.settings = new TesseractSettings(); + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractRenderer.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractRenderer.java new file mode 100644 index 0000000..774243e --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/LilTesseractRenderer.java @@ -0,0 +1,26 @@ +package dev.vatuu.tesseract.impl.extras.lil; + +import dev.vatuu.tesseract.impl.extras.lil.rendering.TesseractRenderer; +import net.minecraft.client.render.*; +import net.minecraft.client.render.block.entity.BlockEntityRenderDispatcher; +import net.minecraft.client.render.block.entity.BlockEntityRenderer; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.util.math.Vec3d; + +public class LilTesseractRenderer extends BlockEntityRenderer{ + + private TesseractRenderer renderer; + + public LilTesseractRenderer(BlockEntityRenderDispatcher dispatcher) { + super(dispatcher); + this.renderer = new TesseractRenderer(new TesseractSettings()); + } + + @Override + public void render(LilTesseractBlockEntity blockEntity, float tickDelta, MatrixStack modelview, VertexConsumerProvider vertexConsumers, int light, int overlay) { + Vec3d pos = new Vec3d(blockEntity.getPos().getX(), blockEntity.getPos().getY(), blockEntity.getPos().getZ()); + float distance = (float)Math.sqrt(this.dispatcher.camera.getPos().squaredDistanceTo(pos)); + + renderer.render(modelview, vertexConsumers, distance); + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/TesseractSettings.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/TesseractSettings.java new file mode 100644 index 0000000..6fa1aeb --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/TesseractSettings.java @@ -0,0 +1,12 @@ +package dev.vatuu.tesseract.impl.extras.lil; + +public class TesseractSettings { + + public float rotateX, rotateY, rotateZ, rotateW; + public boolean wireframe; + + public TesseractSettings() { + this.rotateX = this.rotateY = this.rotateZ = this.rotateW = 0.0f; + wireframe = false; + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/BooleanButtonWidget.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/BooleanButtonWidget.java new file mode 100644 index 0000000..ccfec74 --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/BooleanButtonWidget.java @@ -0,0 +1,63 @@ +package dev.vatuu.tesseract.impl.extras.lil.rendering; + +import com.mojang.blaze3d.systems.RenderSystem; +import dev.vatuu.tesseract.impl.Tesseract; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.util.Identifier; + +public class BooleanButtonWidget extends ButtonWidget { + + private boolean state; + private ButtonIcon stateTex; + + public BooleanButtonWidget(int x, int y, boolean start, PressAction action){ + super(x, y, 20, 20, "", action); + this.state = start; + this.stateTex = state ? ButtonIcon.TRUE : ButtonIcon.FALSE; + } + + @Override + public void renderButton(int mouseX, int mouseY, float partialTicks){ + if (this.visible){ + MinecraftClient.getInstance().getTextureManager().bindTexture(new Identifier(Tesseract.MOD_ID, "textures/gui/gui.png")); + RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F); + int yt; + if (this.isHovered()) + yt = stateTex.yDifTex; + else + yt = stateTex.yTex; + + if(!active) + yt = stateTex.yDisTex; + + this.blit(x, y, stateTex.xTex, yt, 20, 20); + } + } + + @Override + public void onPress() { + this.state = !state; + this.stateTex = state ? ButtonIcon.TRUE : ButtonIcon.FALSE; + this.onPress.onPress(this); + } + + public boolean currentState(){ + return state; + } + + private enum ButtonIcon { + + TRUE(20, 166, 186, 206), + FALSE(0, 166, 186, 206); + + public int xTex, yTex, yDifTex, yDisTex; + + ButtonIcon(int x, int y, int yDif, int yDis) { + this.xTex = x; + this.yTex = y; + this.yDifTex = yDif; + this.yDisTex = yDis; + } + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/DrawUtils.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/DrawUtils.java new file mode 100644 index 0000000..85b9e3c --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/DrawUtils.java @@ -0,0 +1,64 @@ +package dev.vatuu.tesseract.impl.extras.lil.rendering; + +import net.minecraft.client.render.VertexConsumer; +import net.minecraft.client.util.math.Matrix4f; +import net.minecraft.util.math.Direction; +import net.minecraft.util.math.Vec3d; +import net.minecraft.util.math.Vec3i; + +import java.util.stream.Stream; + +public final class DrawUtils { + + public static void draw2Line(Vec3d[] points, int i, int j, int offset, VertexConsumer consumer, Matrix4f model) { + Vec3d p1 = points[i]; + Vec3d p2 = points[j]; + Vec3d p3 = points[i + offset]; + Vec3d p4 = points[j + offset]; + + consumer.vertex(model, (float)p1.x, (float)p1.y, (float)p1.z).color(0.0f, 0.0f, 1.0f, 1.0f).next(); + consumer.vertex(model, (float)p2.x, (float)p2.y, (float)p2.z).color(0.0f, 0.0f, 1.0f, 1.0f).next(); + + consumer.vertex(model, (float)p3.x, (float)p3.y, (float)p3.z).color(0.0f, 0.0f, 1.0f, 1.0f).next(); + consumer.vertex(model, (float)p4.x, (float)p4.y, (float)p4.z).color(0.0f, 0.0f, 1.0f, 1.0f).next(); + } + + public static void quadOffsetAxis(Vec3d pos, float radius, Direction dir, VertexConsumer consumer, Matrix4f model) { + Vec3i dirVector = dir.getVector(); + Vec3d offset = pos.add(new Vec3d(dirVector.getX() * radius, dirVector.getY() * radius, dirVector.getZ() * radius)); + Vec3d[] points = new Vec3d[4]; + switch(dir.getAxis()) { + case X: + points[0] = offset.add(new Vec3d(0, radius, radius)); + points[1] = offset.add(new Vec3d(0, -radius, radius)); + points[2] = offset.add(new Vec3d(0, -radius, -radius)); + points[3] = offset.add(new Vec3d(0, radius, -radius)); + break; + case Y: + points[0] = offset.add(new Vec3d(radius, 0, radius)); + points[1] = offset.add(new Vec3d(radius, 0, -radius)); + points[2] = offset.add(new Vec3d(-radius, 0, -radius)); + points[3] = offset.add(new Vec3d(-radius, 0, radius)); + break; + case Z: + points[0] = offset.add(new Vec3d(radius, radius, 0)); + points[1] = offset.add(new Vec3d(-radius, radius, 0)); + points[2] = offset.add(new Vec3d(-radius, -radius, 0)); + points[3] = offset.add(new Vec3d(radius, -radius, 0)); + break; + } + + if(dir.getDirection().offset() < 0) { + Vec3d t = points[1]; + points[1] = points[3]; + points[3] = t; + } + + for (Vec3d point : points) + consumer.vertex(model, (float) point.x, (float) point.y, (float) point.z).color(0.0f, 0.0f, 1.0f, 1f).next(); + } + + public static void renderCube(Vec3d pos, float radius, VertexConsumer consumer, Matrix4f model) { + Stream.of(Direction.values()).forEach(dir -> DrawUtils.quadOffsetAxis(pos, radius, dir, consumer, model)); + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderLayers.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderLayers.java new file mode 100644 index 0000000..ddd7e20 --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderLayers.java @@ -0,0 +1,62 @@ +package dev.vatuu.tesseract.impl.extras.lil.rendering; + +import com.google.common.collect.ImmutableList; +import net.minecraft.client.render.RenderLayer; +import net.minecraft.client.render.VertexFormat; +import net.minecraft.client.render.VertexFormatElement; +import net.minecraft.client.render.VertexFormats; +import org.lwjgl.opengl.GL11; + +import java.util.OptionalDouble; + +public class TesseractRenderLayers { + + public static RenderLayer TESSERACT_VERTEX = TesseractVertexRenderLayer.getLayer(); + public static RenderLayer TESSERACT_SIDE = TesseractConnectionRenderLayer.getLayer(); + + private static class TesseractVertexRenderLayer extends RenderLayer { + + private static final VertexFormat VERTEX_FORMAT = new VertexFormat(ImmutableList.builder() + .add(VertexFormats.POSITION_ELEMENT) + .add(VertexFormats.COLOR_ELEMENT) + .build() + ); + + private static final RenderLayer LAYER = RenderLayer.of("tesseract_vertex", VERTEX_FORMAT, GL11.GL_QUADS, 256, RenderLayer.MultiPhaseParameters.builder() + .transparency(TRANSLUCENT_TRANSPARENCY) + .build(true) + ); + + + private TesseractVertexRenderLayer(String name, VertexFormat vertexFormat, int drawMode, int expectedBufferSize, boolean hasCrumbling, boolean translucent, Runnable startAction, Runnable endAction) { + super(name, vertexFormat, drawMode, expectedBufferSize, hasCrumbling, translucent, startAction, endAction); + } + + public static RenderLayer getLayer() { + return LAYER; + } + } + + private static class TesseractConnectionRenderLayer extends RenderLayer { + + private static final VertexFormat VERTEX_FORMAT = new VertexFormat(ImmutableList.builder() + .add(VertexFormats.POSITION_ELEMENT) + .add(VertexFormats.COLOR_ELEMENT) + .build() + ); + + private static final RenderLayer LAYER = RenderLayer.of("tesseract_side", VERTEX_FORMAT, GL11.GL_LINES, 256, RenderLayer.MultiPhaseParameters.builder() + .transparency(TRANSLUCENT_TRANSPARENCY) + .lineWidth(new LineWidth(OptionalDouble.of(2))) + .build(true) + ); + + private TesseractConnectionRenderLayer(String name, VertexFormat vertexFormat, int drawMode, int expectedBufferSize, boolean hasCrumbling, boolean translucent, Runnable startAction, Runnable endAction) { + super(name, vertexFormat, drawMode, expectedBufferSize, hasCrumbling, translucent, startAction, endAction); + } + + public static RenderLayer getLayer() { + return LAYER; + } + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderer.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderer.java new file mode 100644 index 0000000..0b3a97c --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/TesseractRenderer.java @@ -0,0 +1,99 @@ +package dev.vatuu.tesseract.impl.extras.lil.rendering; + +import dev.vatuu.tesseract.impl.extras.lil.TesseractSettings; +import net.minecraft.client.render.VertexConsumer; +import net.minecraft.client.render.VertexConsumerProvider; +import net.minecraft.client.util.math.Matrix4f; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.util.math.Vec3d; + +import static dev.vatuu.tesseract.impl.extras.lil.rendering.DrawUtils.draw2Line; + +public class TesseractRenderer { + + public TesseractSettings settings; + + private float xAngle, yAngle, zAngle, wAngle; + + private Vector4[] vertices = new Vector4[] { + new Vector4(-1, -1, -1, 1), + new Vector4(1, -1, -1, 1), + new Vector4(1, 1, -1, 1), + new Vector4(-1, 1, -1, 1), + new Vector4(-1, -1, 1, 1), + new Vector4(1, -1, 1, 1), + new Vector4(1, 1, 1, 1), + new Vector4(-1, 1, 1, 1), + + new Vector4(-1, -1, -1, -1), + new Vector4(1, -1, -1, -1), + new Vector4(1, 1, -1, -1), + new Vector4(-1, 1, -1, -1), + new Vector4(-1, -1, 1, -1), + new Vector4(1, -1, 1, -1), + new Vector4(1, 1, 1, -1), + new Vector4(-1, 1, 1, -1), + }; + + public TesseractRenderer(TesseractSettings settings) { + this.settings = settings; + } + + public void render(MatrixStack modelview, VertexConsumerProvider vertexConsumers, float projectionDistance){ + VertexConsumer consumer = vertexConsumers.getBuffer(TesseractRenderLayers.TESSERACT_VERTEX); + + modelview.push(); + modelview.translate(0.5d, 0.5d, 0.5d); + Matrix4f model = modelview.peek().getModel(); + + Vec3d projectedPoints[] = new Vec3d[16]; + for (int i = 0; i < vertices.length; i++) + projectedPoints[i] = vertices[i] + .rotateX(xAngle) + .rotateY(yAngle) + .rotateZ(zAngle) + .rotateW(wAngle) + .projectTo3d(projectionDistance); + + for (int i = 0; i < vertices.length; i++) + DrawUtils.renderCube(projectedPoints[i], 0.025f, consumer, model); + + consumer = vertexConsumers.getBuffer(TesseractRenderLayers.TESSERACT_SIDE); + for(int i = 0; i < 4; i++) { + draw2Line(projectedPoints, i, (i + 1) % 4, 8, consumer, model); + draw2Line(projectedPoints, i + 4, ((i + 1) % 4) + 4, 8, consumer, model); + draw2Line(projectedPoints, i, i + 4, 8, consumer, model); + + draw2Line(projectedPoints, i, i + 8, 4, consumer, model); + } + modelview.pop(); + updateRotation(); + } + + private void updateRotation() { + this.xAngle += settings.rotateX; + this.yAngle += settings.rotateY; + this.zAngle += settings.rotateZ; + this.wAngle += settings.rotateW; + + if(xAngle > 360) + xAngle -= 360; + if(xAngle < -360) + xAngle += 360; + + if(yAngle > 360) + yAngle -= 360; + if(yAngle < -360) + yAngle += 360; + + if(zAngle > 360) + zAngle -= 360; + if(zAngle < -360) + zAngle += 360; + + if(wAngle > 360) + wAngle -= 360; + if(wAngle < -360) + wAngle += 360; + } +} diff --git a/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/Vector4.java b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/Vector4.java new file mode 100644 index 0000000..ba57e19 --- /dev/null +++ b/src/main/java/dev/vatuu/tesseract/impl/extras/lil/rendering/Vector4.java @@ -0,0 +1,86 @@ +package dev.vatuu.tesseract.impl.extras.lil.rendering; + +import net.minecraft.util.math.Vec3d; + +public class Vector4 { + + public float x, y, z, w; + + //Z-Axis Rotation + + public Vector4(float x, float y, float z, float w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + public Vec3d projectTo3d(float distance) { + float d = 1 / (distance - w); + + float[][] matrix = new float[][] { + {d, 0, 0}, + {0, d, 0}, + {0, 0, d}, + }; + + float xn = matrix[0][0] * x + matrix[1][0] * y + matrix[2][0] * z; + float yn = matrix[0][1] * x + matrix[1][1] * y + matrix[2][1] * z; + float zn = matrix[0][2] * x + matrix[1][2] * y + matrix[2][2] * z; + + return new Vec3d(xn, yn, zn); + } + + public Vector4 rotateX(float angle) { + float[][] rotateYZ = new float[][]{ + {1, 0, 0, 0}, + {0, (float) Math.cos(angle), (float) -Math.sin(angle), 0}, + {0, (float) Math.sin(angle), (float) Math.cos(angle), 0}, + {0, 0, 0, 1} + }; + + return matrixMultiplication4x4(rotateYZ); + } + + public Vector4 rotateY(float angle) { + float[][] rotateXZ = new float[][]{ + {(float) Math.cos(angle), 0, (float) -Math.sin(angle), 0}, + {0, 1, 0, 0}, + {(float) Math.sin(angle), 0, (float) Math.cos(angle), 0}, + {0, 0, 0, 1} + }; + + return matrixMultiplication4x4(rotateXZ); + } + + public Vector4 rotateZ(float angle) { + float[][] rotateXY = new float[][]{ + {(float) Math.cos(angle), (float) -Math.sin(angle), 0, 0}, + {(float) Math.sin(angle), (float) Math.cos(angle), 0, 0}, + {0, 0, 1, 0}, + {0, 0, 0, 1} + }; + + return matrixMultiplication4x4(rotateXY); + } + + public Vector4 rotateW(float angle) { + float[][] rotateZW = new float[][]{ + {1, 0, 0, 0}, + {0, 1, 0, 0}, + {0, 0, (float) Math.cos(angle), (float) -Math.sin(angle)}, + {0, 0, (float) Math.sin(angle), (float) Math.cos(angle)}, + }; + + return matrixMultiplication4x4(rotateZW); + } + + public Vector4 matrixMultiplication4x4(float[][] mat) { + float xn = mat[0][0] * x + mat[1][0] * y + mat[2][0] * z + mat[3][0] * w; + float yn = mat[0][1] * x + mat[1][1] * y + mat[2][1] * z + mat[3][1] * w; + float zn = mat[0][2] * x + mat[1][2] * y + mat[2][2] * z + mat[3][2] * w; + float wn = mat[0][3] * x + mat[1][3] * y + mat[2][3] * z + mat[3][3] * w; + + return new Vector4(xn, yn, zn, wn); + } +} \ No newline at end of file diff --git a/src/main/java/dev/vatuu/tesseract/impl/world/DimensionRegistryImpl.java b/src/main/java/dev/vatuu/tesseract/impl/world/DimensionRegistryImpl.java index 9fcb958..8f646c3 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/world/DimensionRegistryImpl.java +++ b/src/main/java/dev/vatuu/tesseract/impl/world/DimensionRegistryImpl.java @@ -32,10 +32,10 @@ public DimensionType registerDimensionType(Identifier name, boolean hasSkyLight, int id = 5 + registered.size(); TesseractDimensionType t = new TesseractDimensionType(id, name.getPath(), hasSkyLight, factory, biomeAccessor); registered.put(id, t); - return Registry.register(Registry.DIMENSION, id, name.toString(), t); + return Registry.register(Registry.DIMENSION_TYPE, id, name.toString(), t); } public static boolean unregister(DimensionType type){ - return ((SimpleRegistryMixin)Registry.DIMENSION).getEntries().values().remove(type); + return ((SimpleRegistryMixin)Registry.DIMENSION_TYPE).getEntries().values().remove(type); } } diff --git a/src/main/java/dev/vatuu/tesseract/impl/world/TesseractDimension.java b/src/main/java/dev/vatuu/tesseract/impl/world/TesseractDimension.java index 41b5077..74a7bea 100644 --- a/src/main/java/dev/vatuu/tesseract/impl/world/TesseractDimension.java +++ b/src/main/java/dev/vatuu/tesseract/impl/world/TesseractDimension.java @@ -36,7 +36,7 @@ public class TesseractDimension extends OverworldDimension { @Override public BlockPos getSpawningBlockInChunk(ChunkPos pos, boolean checkMobSpawnValidity) { return settings.spawningBlockChunk.apply(pos, checkMobSpawnValidity); } @Override public BlockPos getTopSpawningBlockPosition(int x, int z, boolean checkMobSpawnValidity) { return settings.topSpawningBlockPos.apply(x, z, checkMobSpawnValidity); } @Override public boolean hasVisibleSky() { return settings.hasVisibleSky; } - @Override public Vec3d getFogColor(float skyAngle, float tickDelta) { return settings.fogColour.apply(skyAngle, tickDelta); } + @Override public Vec3d modifyFogColor(Vec3d pos, float tickDelta) { return settings.fogColour.apply(pos, tickDelta); } @Override public boolean canPlayersSleep() { return !settings.shouldBedsExplode; } @Override public boolean isFogThick(int x, int iz) { return settings.isFogThick.apply(x, iz); } @Override public DimensionType getType() { return type; } diff --git a/src/main/resources/assets/tesseract/lang/en_US.json b/src/main/resources/assets/tesseract/lang/en_US.json new file mode 100644 index 0000000..4f6aad4 --- /dev/null +++ b/src/main/resources/assets/tesseract/lang/en_US.json @@ -0,0 +1,9 @@ +{ + "block.tesseract.lil_tesseract": "'lil Tesseract", + "gui.tesseract.lil_tesseract.title": "'lil Tesseract Configuration", + "gui.tesseract.lil_tesseract.x": "X Axis", + "gui.tesseract.lil_tesseract.y": "Y Axis", + "gui.tesseract.lil_tesseract.z": "Z Axis", + "gui.tesseract.lil_tesseract.w": "W Axis", + "gui.tesseract.lil_tesseract.wireframe": "Wireframe Mode" +} \ No newline at end of file diff --git a/src/main/resources/assets/tesseract/textures/blocks/lil_tesseract.png b/src/main/resources/assets/tesseract/textures/blocks/lil_tesseract.png new file mode 100644 index 0000000..ae72a71 Binary files /dev/null and b/src/main/resources/assets/tesseract/textures/blocks/lil_tesseract.png differ diff --git a/src/main/resources/assets/tesseract/textures/gui/gui.png b/src/main/resources/assets/tesseract/textures/gui/gui.png new file mode 100644 index 0000000..5e20b61 Binary files /dev/null and b/src/main/resources/assets/tesseract/textures/gui/gui.png differ diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json index 739e564..0b3591a 100644 --- a/src/main/resources/fabric.mod.json +++ b/src/main/resources/fabric.mod.json @@ -22,7 +22,7 @@ "main": [ "dev.vatuu.tesseract.impl.Tesseract" ] }, "mixins": [ - "tesseract.mixins.json" + "mixins.tesseract.json" ], "depends": { diff --git a/src/main/resources/tesseract.mixins.json b/src/main/resources/mixins.tesseract.json similarity index 72% rename from src/main/resources/tesseract.mixins.json rename to src/main/resources/mixins.tesseract.json index 7e59cb1..c23c274 100644 --- a/src/main/resources/tesseract.mixins.json +++ b/src/main/resources/mixins.tesseract.json @@ -5,6 +5,9 @@ "injectors": { "defaultRequire": 1 }, "mixins": [ + "EndPortalBlockEntityRendererAccessor", + "PlayerEntityModelAccessor", + "PlayerEntityRendererMixin", "MinecraftServerMixin", "SimpleRegistryMixin", "ServerChunkManagerMixin",