cir) {
+ if (fogType == FogRenderer.FogType.WORLD && NoRender.INSTANCE.isEnabled() && NoRender.getNoTerrainFog())
+ cir.setReturnValue(emptyBuffer.slice(0L, FOG_UBO_SIZE));
+ }
+}
diff --git a/src/main/java/com/lambda/mixin/render/GameRendererMixin.java b/src/main/java/com/lambda/mixin/render/GameRendererMixin.java
index 42cb9ace5..98cf293e7 100644
--- a/src/main/java/com/lambda/mixin/render/GameRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/GameRendererMixin.java
@@ -20,12 +20,14 @@
import com.lambda.event.EventFlow;
import com.lambda.event.events.RenderEvent;
import com.lambda.graphics.RenderMain;
+import com.lambda.gui.DearImGui;
import com.lambda.module.modules.render.NoRender;
import com.lambda.module.modules.render.Zoom;
import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
import com.llamalad7.mixinextras.injector.ModifyReturnValue;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.mojang.blaze3d.buffers.GpuBufferSlice;
import net.minecraft.client.render.Camera;
import net.minecraft.client.render.GameRenderer;
import net.minecraft.client.render.RenderTickCounter;
@@ -33,6 +35,7 @@
import net.minecraft.client.util.ObjectAllocator;
import net.minecraft.item.ItemStack;
import org.joml.Matrix4f;
+import org.joml.Vector4f;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
@@ -47,21 +50,9 @@ private void updateTargetedEntityInvoke(float tickDelta, CallbackInfo info) {
}
}
- /**
- * Begins our 3d render after the game has rendered the world
- * {@code
- * float m = Math.max(h, (float)(Integer)this.client.options.getFov().getValue());
- * Matrix4f matrix4f2 = this.getBasicProjectionMatrix(m);
- * RenderSystem.setProjectionMatrix(matrix4f, ProjectionType.PERSPECTIVE);
- * Quaternionf quaternionf = camera.getRotation().conjugate(new Quaternionf());
- * Matrix4f matrix4f3 = (new Matrix4f()).rotation(quaternionf);
- * this.client.worldRenderer.setupFrustum(camera.getPos(), matrix4f3, matrix4f2);
- * this.client.worldRenderer.render(this.pool, renderTickCounter, bl, camera, this, matrix4f3, matrix4f);
- * }
- */
- @WrapOperation(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;render(Lnet/minecraft/client/util/ObjectAllocator;Lnet/minecraft/client/render/RenderTickCounter;ZLnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/GameRenderer;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;)V"))
- void onRenderWorld(WorldRenderer instance, ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, Matrix4f positionMatrix, Matrix4f projectionMatrix, Operation original) {
- original.call(instance, allocator, tickCounter, renderBlockOutline, camera, gameRenderer, positionMatrix, projectionMatrix);
+ @WrapOperation(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;render(Lnet/minecraft/client/util/ObjectAllocator;Lnet/minecraft/client/render/RenderTickCounter;ZLnet/minecraft/client/render/Camera;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;Lcom/mojang/blaze3d/buffers/GpuBufferSlice;Lorg/joml/Vector4f;Z)V"))
+ void onRenderWorld(WorldRenderer instance, ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, Matrix4f positionMatrix, Matrix4f basicProjectionMatrix, Matrix4f projectionMatrix, GpuBufferSlice fogBuffer, Vector4f fogColor, boolean renderSky, Operation original) {
+ original.call(instance, allocator, tickCounter, renderBlockOutline, camera, positionMatrix, basicProjectionMatrix, projectionMatrix, fogBuffer, fogColor, renderSky);
RenderMain.render3D(positionMatrix, projectionMatrix);
}
@@ -80,4 +71,9 @@ private void injectShowFloatingItem(ItemStack floatingItem, CallbackInfo ci) {
private float modifyGetFov(float original) {
return original / Zoom.getLerpedZoom();
}
+
+ @Inject(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/render/GuiRenderer;render(Lcom/mojang/blaze3d/buffers/GpuBufferSlice;)V", shift = At.Shift.AFTER))
+ private void onGuiRenderComplete(RenderTickCounter tickCounter, boolean tick, CallbackInfo ci) {
+ DearImGui.INSTANCE.render();
+ }
}
diff --git a/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java b/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java
index 193cdc516..3c66e9c53 100644
--- a/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java
+++ b/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java
@@ -18,6 +18,7 @@
package com.lambda.mixin.render;
import com.lambda.module.modules.render.ContainerPreview;
+import net.minecraft.client.gui.Click;
import net.minecraft.client.gui.screen.ingame.HandledScreen;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@@ -27,18 +28,18 @@
@Mixin(HandledScreen.class)
public class HandledScreenMixin {
@Inject(method = "mouseClicked", at = @At("HEAD"), cancellable = true)
- private void onMouseClicked(double mouseX, double mouseY, int button, CallbackInfoReturnable cir) {
+ private void onMouseClicked(Click click, boolean doubled, CallbackInfoReturnable cir) {
if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isLocked()) {
- if (ContainerPreview.isMouseOverLockedTooltip((int) mouseX, (int) mouseY)) {
+ if (ContainerPreview.isMouseOverLockedTooltip((int) click.x(), (int) click.y())) {
cir.setReturnValue(true);
}
}
}
@Inject(method = "mouseReleased", at = @At("HEAD"), cancellable = true)
- private void onMouseReleased(double mouseX, double mouseY, int button, CallbackInfoReturnable cir) {
+ private void onMouseReleased(Click click, CallbackInfoReturnable cir) {
if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isLocked()) {
- if (ContainerPreview.isMouseOverLockedTooltip((int) mouseX, (int) mouseY)) {
+ if (ContainerPreview.isMouseOverLockedTooltip((int) click.x(), (int) click.y())) {
cir.setReturnValue(true);
}
}
diff --git a/src/main/java/com/lambda/mixin/render/HeadFeatureRendererMixin.java b/src/main/java/com/lambda/mixin/render/HeadFeatureRendererMixin.java
index 38834b1ac..bb8416614 100644
--- a/src/main/java/com/lambda/mixin/render/HeadFeatureRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/HeadFeatureRendererMixin.java
@@ -19,7 +19,9 @@
import com.lambda.module.modules.render.NoRender;
import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
import net.minecraft.client.render.entity.feature.HeadFeatureRenderer;
+import net.minecraft.client.render.entity.state.EntityRenderState;
import net.minecraft.client.render.entity.state.LivingEntityRenderState;
import net.minecraft.client.util.math.MatrixStack;
import org.spongepowered.asm.mixin.Mixin;
@@ -29,8 +31,8 @@
@Mixin(HeadFeatureRenderer.class)
public class HeadFeatureRendererMixin {
- @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/client/render/entity/state/LivingEntityRenderState;FF)V", at = @At("HEAD"), cancellable = true)
- private void injectRender(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntityRenderState livingEntityRenderState, float f, float g, CallbackInfo ci) {
+ @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;ILnet/minecraft/client/render/entity/state/EntityRenderState;FF)V", at = @At("HEAD"), cancellable = true)
+ private void injectRender(MatrixStack matrices, OrderedRenderCommandQueue queue, int light, EntityRenderState state, float limbAngle, float limbDistance, CallbackInfo ci) {
if (NoRender.INSTANCE.isEnabled() && NoRender.getNoArmor() && NoRender.getIncludeNoOtherHeadItems()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/HeldItemRendererMixin.java b/src/main/java/com/lambda/mixin/render/HeldItemRendererMixin.java
index 48d965c1a..0be8b99b8 100644
--- a/src/main/java/com/lambda/mixin/render/HeldItemRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/HeldItemRendererMixin.java
@@ -20,9 +20,10 @@
import com.google.common.base.MoreObjects;
import com.lambda.Lambda;
import com.lambda.module.modules.render.ViewModel;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.network.AbstractClientPlayerEntity;
-import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
import net.minecraft.client.render.item.HeldItemRenderer;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.item.ItemStack;
@@ -33,7 +34,6 @@
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(HeldItemRenderer.class)
@@ -44,18 +44,14 @@ public class HeldItemRendererMixin {
@Shadow private float equipProgressMainHand;
@Shadow private float equipProgressOffHand;
- @Inject(method = "renderFirstPersonItem", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/item/HeldItemRenderer;renderArmHoldingItem(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IFFLnet/minecraft/util/Arm;)V"))
- private void onRenderArmHoldingItem(AbstractClientPlayerEntity player, float tickDelta, float pitch, Hand hand, float swingProgress, ItemStack itemStack, float equipProgress, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, CallbackInfo ci) {
- if (!ViewModel.INSTANCE.isEnabled()) return;
-
- ViewModel.INSTANCE.transform(itemStack, hand, matrices);
+ @Inject(method = "renderFirstPersonItem", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/item/HeldItemRenderer;renderItem(Lnet/minecraft/entity/LivingEntity;Lnet/minecraft/item/ItemStack;Lnet/minecraft/item/ItemDisplayContext;Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;I)V"))
+ private void injectRenderFirstPersonItem(AbstractClientPlayerEntity player, float tickProgress, float pitch, Hand hand, float swingProgress, ItemStack item, float equipProgress, MatrixStack matrices, OrderedRenderCommandQueue orderedRenderCommandQueue, int light, CallbackInfo ci) {
+ if (ViewModel.INSTANCE.isEnabled()) ViewModel.INSTANCE.transform(item, hand, matrices);
}
- @Inject(method = "renderFirstPersonItem", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/item/HeldItemRenderer;renderItem(Lnet/minecraft/entity/LivingEntity;Lnet/minecraft/item/ItemStack;Lnet/minecraft/item/ItemDisplayContext;Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;I)V", ordinal = 1))
- private void onRenderFirstPersonItem(AbstractClientPlayerEntity player, float tickDelta, float pitch, Hand hand, float swingProgress, ItemStack itemStack, float equipProgress, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, CallbackInfo ci) {
- if (!ViewModel.INSTANCE.isEnabled()) return;
-
- ViewModel.INSTANCE.transform(itemStack, hand, matrices);
+ @Inject(method = "renderFirstPersonItem", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/item/HeldItemRenderer;renderArmHoldingItem(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;IFFLnet/minecraft/util/Arm;)V"))
+ private void injectRenderArmHoldingItem(AbstractClientPlayerEntity player, float tickProgress, float pitch, Hand hand, float swingProgress, ItemStack item, float equipProgress, MatrixStack matrices, OrderedRenderCommandQueue orderedRenderCommandQueue, int light, CallbackInfo ci) {
+ if (ViewModel.INSTANCE.isEnabled()) ViewModel.INSTANCE.transform(item, hand, matrices);
}
@ModifyArg(method = "updateHeldItems", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/MathHelper;clamp(FFF)F", ordinal = 2), index = 0)
@@ -68,7 +64,7 @@ private float modifyEquipProgressMainHand(float value) {
mainHand = currentStack;
}
- float progress = config.getOldAnimations() ? 1 : (float) Math.pow(client.player.getAttackCooldownProgress(1), 3);
+ float progress = config.getOldAnimations() ? 1 : (float) Math.pow(client.player.getHandEquippingProgress(1), 3);
return (ItemStack.areEqual(mainHand, currentStack) ? progress : 0) - equipProgressMainHand;
}
@@ -87,7 +83,7 @@ private float modifyEquipProgressOffHand(float value) {
return (ItemStack.areEqual(offHand, currentStack) ? 1 : 0) - equipProgressOffHand;
}
- @ModifyVariable(method = "renderItem(FLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider$Immediate;Lnet/minecraft/client/network/ClientPlayerEntity;I)V", at = @At(value = "STORE", ordinal = 0), index = 6)
+ @ModifyExpressionValue(method = "renderItem(FLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;Lnet/minecraft/client/network/ClientPlayerEntity;I)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;getHandSwingProgress(F)F"))
private float modifySwing(float swingProgress) {
ViewModel config = ViewModel.INSTANCE;
MinecraftClient mc = Lambda.getMc();
diff --git a/src/main/java/com/lambda/mixin/render/InGameHudMixin.java b/src/main/java/com/lambda/mixin/render/InGameHudMixin.java
index 407ef5998..d6ca4f2ca 100644
--- a/src/main/java/com/lambda/mixin/render/InGameHudMixin.java
+++ b/src/main/java/com/lambda/mixin/render/InGameHudMixin.java
@@ -35,13 +35,6 @@
@Mixin(InGameHud.class)
public class InGameHudMixin {
- /**
- * Begins our 2d render after the game has rendered all 2d elements
- */
- @Inject(method = "render", at = @At("TAIL"))
- private void onRender(DrawContext context, RenderTickCounter tickCounter, CallbackInfo ci) {
- DearImGui.INSTANCE.render();
- }
@Inject(method = "renderNauseaOverlay", at = @At("HEAD"), cancellable = true)
private void injectRenderNauseaOverlay(DrawContext context, float nauseaStrength, CallbackInfo ci) {
diff --git a/src/main/java/com/lambda/mixin/render/InGameOverlayRendererMixin.java b/src/main/java/com/lambda/mixin/render/InGameOverlayRendererMixin.java
index 49412089b..956abd82e 100644
--- a/src/main/java/com/lambda/mixin/render/InGameOverlayRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/InGameOverlayRendererMixin.java
@@ -32,9 +32,9 @@
@Mixin(InGameOverlayRenderer.class)
public class InGameOverlayRendererMixin {
@WrapMethod(method = "renderFireOverlay")
- private static void wrapRenderFireOverlay(MatrixStack matrices, VertexConsumerProvider vertexConsumers, Operation original) {
+ private static void wrapRenderFireOverlay(MatrixStack matrices, VertexConsumerProvider vertexConsumers, Sprite sprite, Operation original) {
if (!(NoRender.INSTANCE.isEnabled() && NoRender.getNoFireOverlay())) {
- original.call(matrices, vertexConsumers);
+ original.call(matrices, vertexConsumers, sprite);
}
}
diff --git a/src/main/java/com/lambda/mixin/render/LightmapTextureManagerMixin.java b/src/main/java/com/lambda/mixin/render/LightmapTextureManagerMixin.java
index 849a9b297..48dec03ed 100644
--- a/src/main/java/com/lambda/mixin/render/LightmapTextureManagerMixin.java
+++ b/src/main/java/com/lambda/mixin/render/LightmapTextureManagerMixin.java
@@ -35,19 +35,25 @@
import java.util.OptionalInt;
+/**
+ * Mixin to override lightmap for Fullbright/XRay and disable darkness effect.
+ *
+ * Note: In 1.21.11, the lightmap rendering was rewritten to use RenderPass with shaders.
+ * We override the texture after normal rendering completes.
+ */
@Mixin(LightmapTextureManager.class)
public class LightmapTextureManagerMixin {
@Shadow @Final private GpuTexture glTexture;
@Inject(method = "update", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/profiler/Profiler;pop()V", shift = At.Shift.BEFORE))
- private void injectUpdate(CallbackInfo ci) {
+ private void injectUpdate(float tickProgress, CallbackInfo ci) {
if (Fullbright.INSTANCE.isEnabled() || XRay.INSTANCE.isEnabled()) {
- RenderSystem.getDevice().createCommandEncoder().createRenderPass(glTexture, OptionalInt.of(ColorHelper.getArgb(255, 255, 255, 255))).close();
+ RenderSystem.getDevice().createCommandEncoder().clearColorTexture(glTexture, ColorHelper.fullAlpha(ColorHelper.getWhite(1.0f)));
}
}
@ModifyReturnValue(method = "getDarkness", at = @At("RETURN"))
- private float modifyGetDarkness(float original) {
+ private float modifyGetDarkness(float original, LivingEntity entity, float factor, float tickProgress) {
if (NoRender.getNoDarkness() && NoRender.INSTANCE.isEnabled()) return 0.0f;
return original;
}
diff --git a/src/main/java/com/lambda/mixin/render/ParticleManagerMixin.java b/src/main/java/com/lambda/mixin/render/ParticleManagerMixin.java
deleted file mode 100644
index 654e32316..000000000
--- a/src/main/java/com/lambda/mixin/render/ParticleManagerMixin.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2025 Lambda
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-package com.lambda.mixin.render;
-
-import com.lambda.module.modules.render.NoRender;
-import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.client.particle.Particle;
-import net.minecraft.client.particle.ParticleManager;
-import net.minecraft.client.particle.ParticleTextureSheet;
-import net.minecraft.client.render.Camera;
-import net.minecraft.client.render.VertexConsumerProvider;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Unique;
-import org.spongepowered.asm.mixin.injection.At;
-
-import java.util.LinkedList;
-import java.util.Queue;
-import java.util.stream.Collectors;
-
-@Mixin(ParticleManager.class)
-public class ParticleManagerMixin {
- // prevents the particles from being stored and potential overhead. Downside being they need to spawn back in rather than just enabling rendering again
-// @Inject(method = "addParticle(Lnet/minecraft/client/particle/Particle;)V", at = @At("HEAD"), cancellable = true)
-// private void injectAddParticle(Particle particle, CallbackInfo ci) {
-// if (NoRender.shouldOmitParticle(particle)) ci.cancel();
-// }
-
- @WrapOperation(method = "renderParticles(Lnet/minecraft/client/render/Camera;FLnet/minecraft/client/render/VertexConsumerProvider$Immediate;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/ParticleManager;renderParticles(Lnet/minecraft/client/render/Camera;FLnet/minecraft/client/render/VertexConsumerProvider$Immediate;Lnet/minecraft/client/particle/ParticleTextureSheet;Ljava/util/Queue;)V"))
- private void wrapRenderParticles(Camera camera, float tickProgress, VertexConsumerProvider.Immediate vertexConsumers, ParticleTextureSheet sheet, Queue particles, Operation original) {
- original.call(camera, tickProgress, vertexConsumers, sheet, filterParticles(particles));
- }
-
- @WrapOperation(method = "renderParticles(Lnet/minecraft/client/render/Camera;FLnet/minecraft/client/render/VertexConsumerProvider$Immediate;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/ParticleManager;renderCustomParticles(Lnet/minecraft/client/render/Camera;FLnet/minecraft/client/render/VertexConsumerProvider$Immediate;Ljava/util/Queue;)V"))
- private void wrapRenderParticles(Camera camera, float tickProgress, VertexConsumerProvider.Immediate vertexConsumers, Queue particles, Operation original) {
- original.call(camera, tickProgress, vertexConsumers, filterParticles(particles));
- }
-
- @Unique
- private Queue filterParticles(Queue particles) {
- return particles.stream().filter(particle ->
- !NoRender.shouldOmitParticle(particle)).collect(Collectors.toCollection(LinkedList::new)
- );
- }
-}
diff --git a/src/main/java/com/lambda/mixin/render/PlayerListHudMixin.java b/src/main/java/com/lambda/mixin/render/PlayerListHudMixin.java
index be408d7ef..30f55c6a8 100644
--- a/src/main/java/com/lambda/mixin/render/PlayerListHudMixin.java
+++ b/src/main/java/com/lambda/mixin/render/PlayerListHudMixin.java
@@ -17,15 +17,29 @@
package com.lambda.mixin.render;
+import com.lambda.friend.FriendManager;
import com.lambda.module.modules.render.ExtraTab;
+import com.lambda.util.text.TextBuilder;
+import com.lambda.util.text.TextDslKt;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import kotlin.Unit;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gui.hud.PlayerListHud;
import net.minecraft.client.network.PlayerListEntry;
+import net.minecraft.scoreboard.Team;
+import net.minecraft.text.MutableText;
+import net.minecraft.text.Text;
+import net.minecraft.util.Nullables;
+import net.minecraft.world.GameMode;
+import org.jetbrains.annotations.Nullable;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Constant;
import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyConstant;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
import java.util.Comparator;
@@ -34,6 +48,12 @@
@Mixin(PlayerListHud.class)
public class PlayerListHudMixin {
@Shadow @Final private static Comparator ENTRY_ORDERING;
+ @Unique private static final Comparator FRIENDS_FIRST_ENTRY_ORDERING = Comparator
+ .comparingInt((PlayerListEntry entry) -> FriendManager.INSTANCE.isFriend(entry.getProfile().name()) ? 0 : 1)
+ .thenComparingInt(entry -> -entry.getListOrder())
+ .thenComparingInt((entry) -> entry.getGameMode() == GameMode.SPECTATOR ? 1 : 0)
+ .thenComparing((entry) -> Nullables.mapOrElse(entry.getScoreboardTeam(), Team::getName, ""))
+ .thenComparing((entry) -> entry.getProfile().name(), String::compareToIgnoreCase);
@Shadow @Final private MinecraftClient client;
@@ -45,9 +65,35 @@ private void onCollectPlayerEntriesHead(CallbackInfoReturnable !ExtraTab.getFriendsOnly() || FriendManager.INSTANCE.isFriend(entry.getProfile()))
+ .sorted(ExtraTab.getSortFriendsFirst() ? FRIENDS_FIRST_ENTRY_ORDERING : ENTRY_ORDERING)
.limit(ExtraTab.getTabEntries())
.toList()
);
}
+
+ @ModifyConstant(method = "render", constant = @Constant(intValue = 20))
+ private int modifyRowLimit(int original) {
+ return ExtraTab.INSTANCE.isEnabled() ? ExtraTab.getRows() : original;
+ }
+
+ @ModifyExpressionValue(method = "getPlayerName", at = @At(value = "INVOKE", target = "Lnet/minecraft/text/Text;copy()Lnet/minecraft/text/MutableText;"))
+ private MutableText modifyPlayerName(MutableText original) { return modifyName(original); }
+
+ @ModifyExpressionValue(method = "getPlayerName", at = @At(value = "INVOKE", target = "Lnet/minecraft/scoreboard/Team;decorateName(Lnet/minecraft/scoreboard/AbstractTeam;Lnet/minecraft/text/Text;)Lnet/minecraft/text/MutableText;"))
+ private MutableText modifyDecorateName(MutableText original) { return modifyName(original); }
+
+ @Unique
+ private @Nullable MutableText modifyName(Text original) {
+ if (ExtraTab.INSTANCE.isDisabled() ||
+ !ExtraTab.getHighlightFriends() ||
+ !FriendManager.INSTANCE.isFriend(original.getString())) return original.copy();
+ var newText = original.copy();
+ var textBuilder = new TextBuilder();
+ TextDslKt.color(textBuilder, ExtraTab.getFriendColor(), builder -> {
+ builder.styleAndAppend(newText);
+ return Unit.INSTANCE;
+ });
+ return textBuilder.getText();
+ }
}
diff --git a/src/main/java/com/lambda/mixin/render/RenderLayersMixin.java b/src/main/java/com/lambda/mixin/render/RenderLayersMixin.java
index 0b4d622dd..96e786e33 100644
--- a/src/main/java/com/lambda/mixin/render/RenderLayersMixin.java
+++ b/src/main/java/com/lambda/mixin/render/RenderLayersMixin.java
@@ -19,28 +19,34 @@
import com.lambda.module.modules.render.XRay;
import net.minecraft.block.BlockState;
-import net.minecraft.client.render.RenderLayer;
-import net.minecraft.client.render.RenderLayers;
+import net.minecraft.client.render.BlockRenderLayer;
+import net.minecraft.client.render.BlockRenderLayers;
import net.minecraft.fluid.FluidState;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-@Mixin(RenderLayers.class)
+/**
+ * Mixin to make blocks render as translucent for XRay functionality.
+ *
+ * Note: In 1.21.11, RenderLayers was split - BlockRenderLayers now handles
+ * block/fluid layer determination and returns BlockRenderLayer enum instead of RenderLayer.
+ */
+@Mixin(BlockRenderLayers.class)
public class RenderLayersMixin {
@Inject(method = "getBlockLayer", at = @At("HEAD"), cancellable = true)
- private static void injectGetBlockLayer(BlockState state, CallbackInfoReturnable cir) {
+ private static void injectGetBlockLayer(BlockState state, CallbackInfoReturnable cir) {
if (XRay.INSTANCE.isDisabled()) return;
final var opacity = XRay.getOpacity();
if (opacity <= 0 || opacity >= 100) return;
- if (!XRay.isSelected(state)) cir.setReturnValue(RenderLayer.getTranslucent());
+ if (!XRay.isSelected(state)) cir.setReturnValue(BlockRenderLayer.TRANSLUCENT);
}
@Inject(method = "getFluidLayer", at = @At("HEAD"), cancellable = true)
- private static void injectGetFluidLayer(FluidState state, CallbackInfoReturnable cir) {
+ private static void injectGetFluidLayer(FluidState state, CallbackInfoReturnable cir) {
if (XRay.INSTANCE.isDisabled()) return;
final var opacity = XRay.getOpacity();
- if (opacity > 0 && opacity < 100) cir.setReturnValue(RenderLayer.getTranslucent());
+ if (opacity > 0 && opacity < 100) cir.setReturnValue(BlockRenderLayer.TRANSLUCENT);
}
}
diff --git a/src/main/java/com/lambda/mixin/render/ScreenMixin.java b/src/main/java/com/lambda/mixin/render/ScreenMixin.java
index 9c4972653..6ed4f2c53 100644
--- a/src/main/java/com/lambda/mixin/render/ScreenMixin.java
+++ b/src/main/java/com/lambda/mixin/render/ScreenMixin.java
@@ -25,6 +25,7 @@
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gui.DrawContext;
import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.input.KeyInput;
import org.lwjgl.glfw.GLFW;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@@ -35,8 +36,8 @@
@Mixin(Screen.class)
public class ScreenMixin {
@Inject(method = "keyPressed", at = @At("HEAD"), cancellable = true)
- private void onKeyPressed(int keyCode, int scanCode, int modifiers, CallbackInfoReturnable cir) {
- if (keyCode == GLFW.GLFW_KEY_ESCAPE && QuickSearch.INSTANCE.isOpen()) {
+ private void onKeyPressed(KeyInput input, CallbackInfoReturnable cir) {
+ if (input.key() == GLFW.GLFW_KEY_ESCAPE && QuickSearch.INSTANCE.isOpen()) {
QuickSearch.INSTANCE.close();
cir.setReturnValue(true);
}
diff --git a/src/main/java/com/lambda/mixin/render/SodiumWorldRendererMixin.java b/src/main/java/com/lambda/mixin/render/SodiumWorldRendererMixin.java
new file mode 100644
index 000000000..892984062
--- /dev/null
+++ b/src/main/java/com/lambda/mixin/render/SodiumWorldRendererMixin.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.mixin.render;
+
+import com.lambda.module.modules.render.NoRender;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.caffeinemc.mods.sodium.client.render.SodiumWorldRenderer;
+import net.caffeinemc.mods.sodium.client.util.FogParameters;
+import org.objectweb.asm.Opcodes;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(SodiumWorldRenderer.class)
+public class SodiumWorldRendererMixin {
+ @Unique
+ private final FogParameters NO_FOG = new FogParameters(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f);
+
+ @ModifyExpressionValue(method = "drawChunkLayer(Lnet/minecraft/client/render/BlockRenderLayerGroup;Lnet/caffeinemc/mods/sodium/client/render/chunk/ChunkRenderMatrices;DDDLnet/minecraft/client/gl/GpuSampler;)V", at = @At(value = "FIELD", target = "Lnet/caffeinemc/mods/sodium/client/render/SodiumWorldRenderer;lastFogParameters:Lnet/caffeinemc/mods/sodium/client/util/FogParameters;", opcode = Opcodes.GETFIELD))
+ private FogParameters modifyFogParameters(FogParameters original) {
+ if (NoRender.INSTANCE.isEnabled() && NoRender.getNoTerrainFog()) return NO_FOG;
+ return original;
+ }
+}
diff --git a/src/main/java/com/lambda/mixin/render/WorldBorderRenderingMixin.java b/src/main/java/com/lambda/mixin/render/WorldBorderRenderingMixin.java
index a5e6f9269..9553a39a5 100644
--- a/src/main/java/com/lambda/mixin/render/WorldBorderRenderingMixin.java
+++ b/src/main/java/com/lambda/mixin/render/WorldBorderRenderingMixin.java
@@ -19,6 +19,7 @@
import com.lambda.module.modules.render.NoRender;
import net.minecraft.client.render.WorldBorderRendering;
+import net.minecraft.client.render.state.WorldBorderRenderState;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.border.WorldBorder;
import org.spongepowered.asm.mixin.Mixin;
@@ -29,7 +30,7 @@
@Mixin(WorldBorderRendering.class)
public class WorldBorderRenderingMixin {
@Inject(method = "render", at = @At("HEAD"), cancellable = true)
- private void injectRender(WorldBorder border, Vec3d cameraPos, double viewDistanceBlocks, double farPlaneDistance, CallbackInfo ci) {
+ private void injectRender(WorldBorderRenderState state, Vec3d cameraPos, double viewDistanceBlocks, double farPlaneDistance, CallbackInfo ci) {
if (NoRender.INSTANCE.isEnabled() && NoRender.getNoWorldBorder()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java b/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java
index d8eb33e08..313cb6ddd 100644
--- a/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java
@@ -34,23 +34,6 @@
@Mixin(WorldRenderer.class)
public class WorldRendererMixin {
- @ModifyExpressionValue(method = "getEntitiesToRender(Lnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/Frustum;Ljava/util/List;)Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/Camera;isThirdPerson()Z"))
- private boolean renderIsThirdPerson(boolean original) {
- return Freecam.INSTANCE.isEnabled() || original;
- }
-
- @ModifyArg(method = "render(Lnet/minecraft/client/util/ObjectAllocator;Lnet/minecraft/client/render/RenderTickCounter;ZLnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/GameRenderer;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;setupTerrain(Lnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/Frustum;ZZ)V"), index = 3)
- private boolean renderSetupTerrainModifyArg(boolean hasForcedFrustum) {
- return Freecam.INSTANCE.isEnabled() || CameraTweaks.INSTANCE.isEnabled() || hasForcedFrustum;
- }
-
- @ModifyArg(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/BackgroundRenderer;applyFog(Lnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/BackgroundRenderer$FogType;Lorg/joml/Vector4f;FZF)Lnet/minecraft/client/render/Fog;", ordinal = 0), index = 3)
- private float modifyApplyFogRenderDistance(float viewDistance) {
- return NoRender.INSTANCE.isEnabled() && NoRender.getNoTerrainFog()
- ? Float.MAX_VALUE
- : viewDistance;
- }
-
@Inject(method = "hasBlindnessOrDarkness(Lnet/minecraft/client/render/Camera;)Z", at = @At(value = "HEAD"), cancellable = true)
private void modifyEffectCheck(Camera camera, CallbackInfoReturnable cir) {
Entity entity = camera.getFocusedEntity();
@@ -60,4 +43,14 @@ private void modifyEffectCheck(Camera camera, CallbackInfoReturnable ci
cir.setReturnValue(blind || dark);
}
}
+
+ @ModifyArg(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;updateCamera(Lnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/Frustum;Z)V"), index = 2)
+ private boolean renderSetupTerrainModifyArg(boolean spectator) {
+ return Freecam.INSTANCE.isEnabled() || CameraTweaks.INSTANCE.isEnabled() || spectator;
+ }
+
+ @ModifyExpressionValue(method = "fillEntityRenderStates", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/Camera;isThirdPerson()Z"))
+ private boolean modifyIsThirdPerson(boolean original) {
+ return Freecam.INSTANCE.isEnabled() || original;
+ }
}
diff --git a/src/main/java/com/lambda/mixin/render/AbstractSignBlockEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/blockentity/AbstractSignBlockEntityRendererMixin.java
similarity index 77%
rename from src/main/java/com/lambda/mixin/render/AbstractSignBlockEntityRendererMixin.java
rename to src/main/java/com/lambda/mixin/render/blockentity/AbstractSignBlockEntityRendererMixin.java
index 6f1d4c5c5..9d6232c03 100644
--- a/src/main/java/com/lambda/mixin/render/AbstractSignBlockEntityRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/blockentity/AbstractSignBlockEntityRendererMixin.java
@@ -15,14 +15,13 @@
* along with this program. If not, see .
*/
-package com.lambda.mixin.render;
+package com.lambda.mixin.render.blockentity;
import com.lambda.module.modules.render.NoRender;
-import net.minecraft.block.entity.SignText;
-import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.render.block.entity.AbstractSignBlockEntityRenderer;
+import net.minecraft.client.render.block.entity.state.SignBlockEntityRenderState;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.BlockPos;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
@@ -31,7 +30,7 @@
@Mixin(AbstractSignBlockEntityRenderer.class)
public class AbstractSignBlockEntityRendererMixin {
@Inject(method = "renderText", at = @At("HEAD"), cancellable = true)
- private void injectRenderText(BlockPos pos, SignText text, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int textLineHeight, int maxTextWidth, boolean front, CallbackInfo ci) {
+ private void injectRenderText(SignBlockEntityRenderState renderState, MatrixStack matrices, OrderedRenderCommandQueue queue, boolean front, CallbackInfo ci) {
if (NoRender.INSTANCE.isEnabled() && NoRender.getNoSignText()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/BeaconBlockEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/blockentity/BeaconBlockEntityRendererMixin.java
similarity index 61%
rename from src/main/java/com/lambda/mixin/render/BeaconBlockEntityRendererMixin.java
rename to src/main/java/com/lambda/mixin/render/blockentity/BeaconBlockEntityRendererMixin.java
index a3d4b5e38..8ad9a6d83 100644
--- a/src/main/java/com/lambda/mixin/render/BeaconBlockEntityRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/blockentity/BeaconBlockEntityRendererMixin.java
@@ -15,14 +15,14 @@
* along with this program. If not, see .
*/
-package com.lambda.mixin.render;
+package com.lambda.mixin.render.blockentity;
import com.lambda.module.modules.render.NoRender;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.render.block.entity.BeaconBlockEntityRenderer;
+import net.minecraft.client.render.block.entity.state.BeaconBlockEntityRenderState;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
+import net.minecraft.client.render.state.CameraRenderState;
import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.Vec3d;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
@@ -30,8 +30,8 @@
@Mixin(BeaconBlockEntityRenderer.class)
public class BeaconBlockEntityRendererMixin {
- @Inject(method = "render", at = @At("HEAD"), cancellable = true)
- private void injectRender(BlockEntity entity, float tickProgress, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, Vec3d cameraPos, CallbackInfo ci) {
+ @Inject(method = "render(Lnet/minecraft/client/render/block/entity/state/BeaconBlockEntityRenderState;Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;Lnet/minecraft/client/render/state/CameraRenderState;)V", at = @At("HEAD"), cancellable = true)
+ private void injectRender(BeaconBlockEntityRenderState beaconBlockEntityRenderState, MatrixStack matrixStack, OrderedRenderCommandQueue orderedRenderCommandQueue, CameraRenderState cameraRenderState, CallbackInfo ci) {
if (NoRender.INSTANCE.isEnabled() && NoRender.getNoBeaconBeams()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/BlockEntityRenderDispatcherMixin.java b/src/main/java/com/lambda/mixin/render/blockentity/BlockEntityRenderDispatcherMixin.java
similarity index 52%
rename from src/main/java/com/lambda/mixin/render/BlockEntityRenderDispatcherMixin.java
rename to src/main/java/com/lambda/mixin/render/blockentity/BlockEntityRenderDispatcherMixin.java
index 268b07043..784faeee0 100644
--- a/src/main/java/com/lambda/mixin/render/BlockEntityRenderDispatcherMixin.java
+++ b/src/main/java/com/lambda/mixin/render/blockentity/BlockEntityRenderDispatcherMixin.java
@@ -15,24 +15,33 @@
* along with this program. If not, see .
*/
-package com.lambda.mixin.render;
+package com.lambda.mixin.render.blockentity;
import com.lambda.module.modules.render.NoRender;
import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.client.render.VertexConsumerProvider;
-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;
+import net.minecraft.client.render.block.entity.BlockEntityRenderManager;
+import net.minecraft.client.render.block.entity.state.BlockEntityRenderState;
+import net.minecraft.client.render.command.ModelCommandRenderer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.jspecify.annotations.Nullable;
-@Mixin(BlockEntityRenderDispatcher.class)
+/**
+ * Mixin to disable block entity rendering when NoRender is enabled.
+ *
+ * Note: In 1.21.11, BlockEntityRenderDispatcher was renamed to BlockEntityRenderManager
+ * and uses a render state system. Returning null from getRenderState prevents rendering.
+ */
+@Mixin(BlockEntityRenderManager.class)
public class BlockEntityRenderDispatcherMixin {
- @Inject(method = "render(Lnet/minecraft/client/render/block/entity/BlockEntityRenderer;Lnet/minecraft/block/entity/BlockEntity;FLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;Lnet/minecraft/util/math/Vec3d;)V", at = @At("HEAD"), cancellable = true)
- private static void injectRender(BlockEntityRenderer renderer, BlockEntity blockEntity, float tickProgress, MatrixStack matrices, VertexConsumerProvider vertexConsumers, Vec3d cameraPos, CallbackInfo ci) {
- if (NoRender.shouldOmitBlockEntity(blockEntity)) ci.cancel();
+ @Inject(method = "getRenderState", at = @At("HEAD"), cancellable = true)
+ private void injectGetRenderState(
+ E blockEntity, float tickProgress, ModelCommandRenderer.@Nullable CrumblingOverlayCommand crumblingOverlay,
+ CallbackInfoReturnable cir) {
+ if (NoRender.shouldOmitBlockEntity(blockEntity)) {
+ cir.setReturnValue(null);
+ }
}
}
diff --git a/src/main/java/com/lambda/mixin/render/EnchantingTableBlockEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/blockentity/EnchantingTableBlockEntityRendererMixin.java
similarity index 51%
rename from src/main/java/com/lambda/mixin/render/EnchantingTableBlockEntityRendererMixin.java
rename to src/main/java/com/lambda/mixin/render/blockentity/EnchantingTableBlockEntityRendererMixin.java
index f80ca373d..f0e5b02dd 100644
--- a/src/main/java/com/lambda/mixin/render/EnchantingTableBlockEntityRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/blockentity/EnchantingTableBlockEntityRendererMixin.java
@@ -15,21 +15,23 @@
* along with this program. If not, see .
*/
-package com.lambda.mixin.render;
+package com.lambda.mixin.render.blockentity;
import com.lambda.module.modules.render.NoRender;
-import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
-import net.minecraft.client.render.VertexConsumer;
import net.minecraft.client.render.block.entity.EnchantingTableBlockEntityRenderer;
-import net.minecraft.client.render.entity.model.BookModel;
+import net.minecraft.client.render.block.entity.state.EnchantingTableBlockEntityRenderState;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
+import net.minecraft.client.render.state.CameraRenderState;
import net.minecraft.client.util.math.MatrixStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(EnchantingTableBlockEntityRenderer.class)
public class EnchantingTableBlockEntityRendererMixin {
- @WrapWithCondition(method = "render(Lnet/minecraft/block/entity/EnchantingTableBlockEntity;FLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/util/math/Vec3d;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/entity/model/BookModel;render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumer;II)V"))
- private boolean wrapRender(BookModel instance, MatrixStack matrixStack, VertexConsumer vertexConsumer, int i, int j) {
- return NoRender.INSTANCE.isDisabled() || !NoRender.getNoEnchantingTableBook();
+ @Inject(method = "render(Lnet/minecraft/client/render/block/entity/state/EnchantingTableBlockEntityRenderState;Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;Lnet/minecraft/client/render/state/CameraRenderState;)V", at = @At("HEAD"), cancellable = true)
+ private void injectRender(EnchantingTableBlockEntityRenderState renderState, MatrixStack matrices, OrderedRenderCommandQueue queue, CameraRenderState cameraRenderState, CallbackInfo ci) {
+ if (NoRender.INSTANCE.isEnabled() && NoRender.getNoEnchantingTableBook()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/MobSpawnerBlockEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/blockentity/MobSpawnerBlockEntityRendererMixin.java
similarity index 66%
rename from src/main/java/com/lambda/mixin/render/MobSpawnerBlockEntityRendererMixin.java
rename to src/main/java/com/lambda/mixin/render/blockentity/MobSpawnerBlockEntityRendererMixin.java
index e2233bf31..f47e9d2c0 100644
--- a/src/main/java/com/lambda/mixin/render/MobSpawnerBlockEntityRendererMixin.java
+++ b/src/main/java/com/lambda/mixin/render/blockentity/MobSpawnerBlockEntityRendererMixin.java
@@ -15,14 +15,15 @@
* along with this program. If not, see .
*/
-package com.lambda.mixin.render;
+package com.lambda.mixin.render.blockentity;
import com.lambda.module.modules.render.NoRender;
-import net.minecraft.block.entity.MobSpawnerBlockEntity;
-import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.render.block.entity.MobSpawnerBlockEntityRenderer;
+import net.minecraft.client.render.command.OrderedRenderCommandQueue;
+import net.minecraft.client.render.entity.EntityRenderManager;
+import net.minecraft.client.render.entity.state.EntityRenderState;
+import net.minecraft.client.render.state.CameraRenderState;
import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.Vec3d;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
@@ -30,8 +31,8 @@
@Mixin(MobSpawnerBlockEntityRenderer.class)
public class MobSpawnerBlockEntityRendererMixin {
- @Inject(method = "render(Lnet/minecraft/block/entity/MobSpawnerBlockEntity;FLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/util/math/Vec3d;)V", at = @At("HEAD"), cancellable = true)
- private void injectRender(MobSpawnerBlockEntity mobSpawnerBlockEntity, float f, MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, int j, Vec3d vec3d, CallbackInfo ci) {
+ @Inject(method = "renderDisplayEntity", at = @At("HEAD"), cancellable = true)
+ private static void injectRender(MatrixStack matrices, OrderedRenderCommandQueue queue, EntityRenderState state, EntityRenderManager entityRenderDispatcher, float rotation, float scale, CameraRenderState cameraRenderState, CallbackInfo ci) {
if (NoRender.INSTANCE.isEnabled() && NoRender.getNoSpawnerMob()) ci.cancel();
}
}
diff --git a/src/main/java/com/lambda/mixin/render/particle/BillboardParticleMixin.java b/src/main/java/com/lambda/mixin/render/particle/BillboardParticleMixin.java
new file mode 100644
index 000000000..06faa1a5d
--- /dev/null
+++ b/src/main/java/com/lambda/mixin/render/particle/BillboardParticleMixin.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.mixin.render.particle;
+
+import com.lambda.module.modules.render.NoRender;
+import net.minecraft.client.particle.BillboardParticle;
+import net.minecraft.client.particle.BillboardParticleSubmittable;
+import net.minecraft.client.particle.Particle;
+import net.minecraft.client.render.Camera;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(BillboardParticle.class)
+public class BillboardParticleMixin {
+ @Inject(method = "render(Lnet/minecraft/client/particle/BillboardParticleSubmittable;Lnet/minecraft/client/render/Camera;F)V", at = @At("HEAD"), cancellable = true)
+ private void injectRender(BillboardParticleSubmittable submittable, Camera camera, float tickDelta, CallbackInfo ci) {
+ if (NoRender.shouldOmitParticle((Particle) ((Object) this))) ci.cancel();
+ }
+}
diff --git a/src/main/java/com/lambda/mixin/render/particle/ElderGuardianParticleRendererMixin.java b/src/main/java/com/lambda/mixin/render/particle/ElderGuardianParticleRendererMixin.java
new file mode 100644
index 000000000..cc7b2e818
--- /dev/null
+++ b/src/main/java/com/lambda/mixin/render/particle/ElderGuardianParticleRendererMixin.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.mixin.render.particle;
+
+import com.lambda.module.modules.render.NoRender;
+import net.minecraft.client.particle.ElderGuardianParticle;
+import net.minecraft.client.particle.ElderGuardianParticleRenderer;
+import net.minecraft.client.particle.NoRenderParticleRenderer;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.client.render.Submittable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ElderGuardianParticleRenderer.class)
+public class ElderGuardianParticleRendererMixin {
+ @Inject(method = "render", at = @At("HEAD"), cancellable = true)
+ private void injectRender(Frustum frustum, Camera camera, float tickProgress, CallbackInfoReturnable cir) {
+ if (NoRender.shouldOmitParticle(ElderGuardianParticle.class)) cir.setReturnValue(NoRenderParticleRenderer.EMPTY);
+ }
+}
diff --git a/src/main/java/com/lambda/mixin/render/particle/ItemPickupParticleRendererMixin.java b/src/main/java/com/lambda/mixin/render/particle/ItemPickupParticleRendererMixin.java
new file mode 100644
index 000000000..509b3323c
--- /dev/null
+++ b/src/main/java/com/lambda/mixin/render/particle/ItemPickupParticleRendererMixin.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.mixin.render.particle;
+
+import com.lambda.module.modules.render.NoRender;
+import net.minecraft.client.particle.ItemPickupParticle;
+import net.minecraft.client.particle.ItemPickupParticleRenderer;
+import net.minecraft.client.particle.NoRenderParticleRenderer;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.client.render.Submittable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ItemPickupParticleRenderer.class)
+public class ItemPickupParticleRendererMixin {
+ @Inject(method = "render", at = @At("HEAD"), cancellable = true)
+ private void injectRender(Frustum frustum, Camera camera, float tickProgress, CallbackInfoReturnable cir) {
+ if (NoRender.shouldOmitParticle(ItemPickupParticle.class)) cir.setReturnValue(NoRenderParticleRenderer.EMPTY);
+ }
+}
diff --git a/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java b/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java
index d98e1efb3..5b86cf797 100644
--- a/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java
+++ b/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java
@@ -46,21 +46,21 @@ private void onRemoveEntity(int entityId, Entity.RemovalReason removalReason, Ca
EventFlow.post(new EntityEvent.Removal(entity, removalReason));
}
- @ModifyReturnValue(method = "getCloudsColor", at = @At("RETURN"))
- private int modifyGetCloudsColor(int original) {
- if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomClouds()) {
- return WorldColors.getCloudColor().getRGB() & 0xFFFFFF;
- }
- return original;
- }
-
- @ModifyReturnValue(method = "getSkyColor", at = @At("RETURN"))
- private int modifyGetSkyColor(int original) {
- if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomSky()) {
- return WorldColors.getSkyColor().getRGB() & 0xFFFFFF;
- }
- return original;
- }
+// @ModifyReturnValue(method = "getCloudsColor", at = @At("RETURN"))
+// private int modifyGetCloudsColor(int original) {
+// if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomClouds()) {
+// return WorldColors.getCloudColor().getRGB() & 0xFFFFFF;
+// }
+// return original;
+// }
+//
+// @ModifyReturnValue(method = "getSkyColor", at = @At("RETURN"))
+// private int modifyGetSkyColor(int original) {
+// if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomSky()) {
+// return WorldColors.getSkyColor().getRGB() & 0xFFFFFF;
+// }
+// return original;
+// }
@Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)
diff --git a/src/main/java/com/lambda/mixin/world/DirectionMixin.java b/src/main/java/com/lambda/mixin/world/DirectionMixin.java
new file mode 100644
index 000000000..b3e1c770a
--- /dev/null
+++ b/src/main/java/com/lambda/mixin/world/DirectionMixin.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.mixin.world;
+
+import com.lambda.interaction.managers.rotating.RotationManager;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.Direction;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+import static com.lambda.Lambda.getMc;
+
+@Mixin(Direction.class)
+public class DirectionMixin {
+ @ModifyExpressionValue(method = "getEntityFacingOrder", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw(F)F"))
+ private static float modifyGetYaw(float original, Entity entity) {
+ return entity == getMc().player ? RotationManager.getServerRotation().getYawF() : original;
+ }
+
+ @ModifyExpressionValue(method = "getEntityFacingOrder", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getPitch(F)F"))
+ private static float modifyGetPitch(float original, Entity entity) {
+ return entity == getMc().player ? RotationManager.getServerRotation().getPitchF() : original;
+ }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/Lambda.kt b/src/main/kotlin/com/lambda/Lambda.kt
index c8242977d..d90bbbaad 100644
--- a/src/main/kotlin/com/lambda/Lambda.kt
+++ b/src/main/kotlin/com/lambda/Lambda.kt
@@ -27,6 +27,7 @@ import com.lambda.config.serializer.ItemCodec
import com.lambda.config.serializer.ItemStackCodec
import com.lambda.config.serializer.KeyCodeCodec
import com.lambda.config.serializer.OptionalCodec
+import com.lambda.config.serializer.TextCodec
import com.lambda.core.Loader
import com.lambda.event.events.ClientEvent
import com.lambda.event.listener.UnsafeListener.Companion.listenOnceUnsafe
@@ -79,7 +80,7 @@ object Lambda : ClientModInitializer {
.registerTypeAdapter(GameProfile::class.java, GameProfileCodec)
.registerTypeAdapter(Optional::class.java, OptionalCodec)
.registerTypeAdapter(ItemStack::class.java, ItemStackCodec)
- .registerTypeAdapter(Text::class.java, Text.Serializer(DynamicRegistryManager.EMPTY))
+ .registerTypeAdapter(Text::class.java, TextCodec) // ToDo: Find out if needed
.registerTypeAdapter(Item::class.java, ItemCodec)
.registerTypeAdapter(BlockItem::class.java, ItemCodec)
.registerTypeAdapter(ArrowItem::class.java, ItemCodec)
diff --git a/src/main/kotlin/com/lambda/brigadier/argument/PlayerArguments.kt b/src/main/kotlin/com/lambda/brigadier/argument/PlayerArguments.kt
index 7c6ef926b..bdaae0d48 100644
--- a/src/main/kotlin/com/lambda/brigadier/argument/PlayerArguments.kt
+++ b/src/main/kotlin/com/lambda/brigadier/argument/PlayerArguments.kt
@@ -35,6 +35,7 @@ import net.minecraft.command.argument.EntityArgumentType
import net.minecraft.command.argument.GameProfileArgumentType
import net.minecraft.command.argument.TeamArgumentType
import net.minecraft.scoreboard.Team
+import net.minecraft.server.PlayerConfigEntry
import net.minecraft.server.command.ServerCommandSource
import net.minecraft.server.network.ServerPlayerEntity
@@ -69,7 +70,7 @@ fun ArgumentReader<
DefaultArgumentDescriptor<
GameProfileArgumentType
>
- >.value(): Collection {
+ >.value(): Collection {
return GameProfileArgumentType.getProfileArgument(context, name)
}
diff --git a/src/main/kotlin/com/lambda/command/CommandManager.kt b/src/main/kotlin/com/lambda/command/CommandManager.kt
index 2344c4259..960d83a92 100644
--- a/src/main/kotlin/com/lambda/command/CommandManager.kt
+++ b/src/main/kotlin/com/lambda/command/CommandManager.kt
@@ -73,7 +73,7 @@ object CommandManager {
canRead() && peek() == prefix
}
- fun currentDispatcher(message: String): CommandDispatcher {
+ fun currentDispatcher(message: String): CommandDispatcher {
return if (message.isLambdaCommand()) {
dispatcher
} else {
diff --git a/src/main/kotlin/com/lambda/command/commands/FriendCommand.kt b/src/main/kotlin/com/lambda/command/commands/FriendCommand.kt
index 37384b666..45545877d 100644
--- a/src/main/kotlin/com/lambda/command/commands/FriendCommand.kt
+++ b/src/main/kotlin/com/lambda/command/commands/FriendCommand.kt
@@ -42,12 +42,12 @@ import java.awt.Color
object FriendCommand : LambdaCommand(
name = "friends",
- usage = "friends ",
+ usage = "friends | add-uuid | remove >",
description = "Add or remove a friend"
) {
override fun CommandBuilder.create() {
execute {
- this@FriendCommand.info(
+ info(
buildText {
if (FriendManager.friends.isEmpty()) {
literal("You have no friends yet. Go make some! :3\n")
@@ -55,7 +55,13 @@ object FriendCommand : LambdaCommand(
literal("Your friends (${FriendManager.friends.size}):\n")
FriendManager.friends.forEachIndexed { index, gameProfile ->
- literal(" ${index + 1}. ${gameProfile.name}\n")
+ literal(" ${index + 1}. ${gameProfile.name} ")
+ styled(
+ color = Color.RED,
+ clickEvent = ClickEvents.suggestCommand(";friends remove ${gameProfile.name}")
+ ) {
+ literal("x\n")
+ }
}
}
@@ -84,11 +90,15 @@ object FriendCommand : LambdaCommand(
}
executeWithResult {
- runBlocking {
- val name = player().value()
+ val name = player().value()
+
+ if (FriendManager.isFriend(name))
+ return@executeWithResult failure("This player is already in your friend list")
- if (mc.gameProfile.name == name) return@runBlocking failure("You can't befriend yourself")
+ if (mc.gameProfile.name == name)
+ return@executeWithResult failure("You can't befriend yourself")
+ runBlocking {
val profile = mc.networkHandler
?.playerList
?.map { it.profile }
@@ -96,16 +106,16 @@ object FriendCommand : LambdaCommand(
?: getProfile(name)
.getOrElse { return@runBlocking failure("Could not find the player") }
- return@runBlocking if (FriendManager.befriend(profile)) {
- info(FriendManager.befriendedText(profile.name))
- success()
- } else {
- failure("This player is already in your friend list")
- }
+ FriendManager.befriend(profile)
+
+ info(FriendManager.befriendedText(profile.name))
+ success()
}
}
}
+ }
+ required(literal("add-uuid")) {
required(uuid("player uuid")) { player ->
suggests { _, builder ->
mc.networkHandler
@@ -118,11 +128,15 @@ object FriendCommand : LambdaCommand(
}
executeWithResult {
- runBlocking {
- val uuid = player().value()
+ val uuid = player().value()
- if (mc.gameProfile.id == uuid) return@runBlocking failure("You can't befriend yourself")
+ if (FriendManager.isFriend(uuid))
+ return@executeWithResult failure("This player is already in your friend list")
+ if (mc.gameProfile.id == uuid)
+ return@executeWithResult failure("You can't befriend yourself")
+
+ runBlocking {
val profile = mc.networkHandler
?.playerList
?.map { it.profile }
@@ -130,12 +144,10 @@ object FriendCommand : LambdaCommand(
?: getProfile(uuid)
.getOrElse { return@runBlocking failure("Could not find the player") }
- return@runBlocking if (FriendManager.befriend(profile)) {
- this@FriendCommand.info(FriendManager.befriendedText(profile.name))
- success()
- } else {
- failure("This player is already in your friend list")
- }
+ FriendManager.befriend(profile)
+
+ info(FriendManager.befriendedText(profile.name))
+ success()
}
}
}
@@ -155,12 +167,10 @@ object FriendCommand : LambdaCommand(
val profile = FriendManager.gameProfile(name)
?: return@executeWithResult failure("This player is not in your friend list")
- return@executeWithResult if (FriendManager.unfriend(profile)) {
- this@FriendCommand.info(FriendManager.unfriendedText(name))
- success()
- } else {
- failure("This player is not in your friend list")
- }
+ FriendManager.unfriend(profile)
+
+ info(FriendManager.unfriendedText(name))
+ success()
}
}
}
diff --git a/src/main/kotlin/com/lambda/command/commands/PrefixCommand.kt b/src/main/kotlin/com/lambda/command/commands/PrefixCommand.kt
new file mode 100644
index 000000000..57444d190
--- /dev/null
+++ b/src/main/kotlin/com/lambda/command/commands/PrefixCommand.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.command.commands
+
+import com.lambda.brigadier.CommandResult.Companion.failure
+import com.lambda.brigadier.CommandResult.Companion.success
+import com.lambda.brigadier.argument.greedyString
+import com.lambda.brigadier.argument.string
+import com.lambda.brigadier.argument.value
+import com.lambda.brigadier.execute
+import com.lambda.brigadier.executeWithResult
+import com.lambda.brigadier.required
+import com.lambda.command.CommandRegistry
+import com.lambda.command.LambdaCommand
+import com.lambda.config.Configuration
+import com.lambda.config.Setting
+import com.lambda.util.Communication.info
+import com.lambda.util.extension.CommandBuilder
+import com.lambda.util.text.buildText
+import com.lambda.util.text.literal
+
+object PrefixCommand : LambdaCommand(
+ "prefix",
+ usage = "prefix ",
+ description = "Sets the prefix for Lambda commands. If the prefix does not seem to work, try putting it in double quotes."
+) {
+ // i have no idea why someone would want to use some of these as a prefix
+ // but ig the people who run 20 clients at once could benefit from this
+ val ptrn = Regex("^[!\"#$%&'()*+,\\-./:;<=>?@\\[\\\\\\]^_`{|}~]$")
+
+ override fun CommandBuilder.create() {
+ required(greedyString("prefix")) { prefixStr ->
+ executeWithResult {
+ val prefix = prefixStr().value()
+ if (!ptrn.matches(prefix)) {
+ return@executeWithResult failure("Prefix must be a single non-alphanumeric ASCII character, excluding spaces.")
+ }
+ val prefixChar = prefix.first()
+ val configurable = Configuration.configurableByName("command") ?: return@executeWithResult failure("No command configurable found.")
+ val setting = configurable.settings.find { it.name == "prefix" } as? Setting<*, Char>
+ ?: return@executeWithResult failure("Prefix setting is not a Char or can not be found.")
+ setting.trySetValue(prefixChar)
+ return@executeWithResult success()
+ }
+ }
+
+ execute {
+ info(
+ buildText {
+ literal("The prefix is currently: ${CommandRegistry.prefix}")
+ }
+ )
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt b/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt
index 6172879df..3df05168a 100644
--- a/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt
+++ b/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt
@@ -32,9 +32,9 @@ import com.lambda.interaction.material.StackSelection.Companion.selectStack
import com.lambda.interaction.material.container.ContainerManager
import com.lambda.interaction.material.container.ContainerManager.findContainersWithMaterial
import com.lambda.interaction.material.container.ContainerManager.findContainersWithSpace
-import com.lambda.interaction.material.transfer.TransferResult
-import com.lambda.task.RootTask.run
-import com.lambda.threading.runSafe
+import com.lambda.task.RootTask
+import com.lambda.task.Task
+import com.lambda.threading.runSafeAutomated
import com.lambda.util.Communication.info
import com.lambda.util.extension.CommandBuilder
@@ -43,7 +43,7 @@ object TransferCommand : LambdaCommand(
usage = "transfer - ",
description = "Transfer items from anywhere to anywhere",
) {
- private var lastContainerTransfer: TransferResult.ContainerTransfer? = null
+ private var lastContainerTransfer: Task<*>? = null
override fun CommandBuilder.create() {
required(itemStack("stack", registry)) { stack ->
@@ -54,12 +54,10 @@ object TransferCommand : LambdaCommand(
val selection = selectStack(count) {
isItem(stack(ctx).value().item)
}
- with(AutomationConfig.Companion.DEFAULT) {
- runSafe {
- selection.findContainersWithMaterial().forEachIndexed { i, container ->
- builder.suggest("\"${i + 1}. ${container.name}\"", container.description(selection))
- }
- }
+ AutomationConfig.Companion.DEFAULT.runSafeAutomated {
+ selection.findContainersWithMaterial().forEachIndexed { i, container ->
+ builder.suggest("\"${i + 1}. ${container.name}\"", container.description(selection))
+ }
}
builder.buildFuture()
}
@@ -68,11 +66,9 @@ object TransferCommand : LambdaCommand(
val selection = selectStack(amount(ctx).value()) {
isItem(stack(ctx).value().item)
}
- with(AutomationConfig.Companion.DEFAULT) {
- runSafe {
- findContainersWithSpace(selection).forEachIndexed { i, container ->
- builder.suggest("\"${i + 1}. ${container.name}\"", container.description(selection))
- }
+ AutomationConfig.Companion.DEFAULT.runSafeAutomated {
+ selection.findContainersWithSpace().forEachIndexed { i, container ->
+ builder.suggest("\"${i + 1}. ${container.name}\"", container.description(selection))
}
}
builder.buildFuture()
@@ -81,35 +77,17 @@ object TransferCommand : LambdaCommand(
val selection = selectStack(amount().value()) {
isItem(stack().value().item)
}
- val fromContainer = ContainerManager.containers().find {
- it.name == from().value().split(".").last().trim()
- } ?: return@executeWithResult failure("From container not found")
+ AutomationConfig.Companion.DEFAULT.runSafeAutomated {
+ val fromContainer = ContainerManager.containers().find {
+ it.name == from().value().split(".").last().trim()
+ } ?: return@executeWithResult failure("From container not found")
- val toContainer = ContainerManager.containers().find {
- it.name == to().value().split(".").last().trim()
- } ?: return@executeWithResult failure("To container not found")
+ val toContainer = ContainerManager.containers().find {
+ it.name == to().value().split(".").last().trim()
+ } ?: return@executeWithResult failure("To container not found")
- with(AutomationConfig.Companion.DEFAULT) {
- when (val transaction = fromContainer.transfer(selection, toContainer)) {
- is TransferResult.ContainerTransfer -> {
- info("${transaction.name} started.")
- lastContainerTransfer = transaction
- transaction.finally {
- info("${transaction.name} completed.")
- }.run()
- return@executeWithResult success()
- }
-
- is TransferResult.MissingItems -> {
- return@executeWithResult failure("Missing items: ${transaction.missing}")
- }
-
- is TransferResult.NoSpace -> {
- return@executeWithResult failure("No space in ${toContainer.name}")
- }
- }
+ fromContainer.transferByTask(selection, toContainer).execute(RootTask)
}
-
return@executeWithResult success()
}
}
diff --git a/src/main/kotlin/com/lambda/config/AutomationConfig.kt b/src/main/kotlin/com/lambda/config/AutomationConfig.kt
index 56e986838..c32f0677f 100644
--- a/src/main/kotlin/com/lambda/config/AutomationConfig.kt
+++ b/src/main/kotlin/com/lambda/config/AutomationConfig.kt
@@ -85,9 +85,9 @@ open class AutomationConfig(
var drawables = listOf()
init {
- onStaticRender {
- if (renders)
- with(it) { drawables.forEach { with(it) { buildRenderer() } } }
+ onStaticRender { esp ->
+ if (renders)
+ drawables.forEach { it.render(esp) }
}
}
}
diff --git a/src/main/kotlin/com/lambda/config/ConfigEditor.kt b/src/main/kotlin/com/lambda/config/ConfigEditor.kt
index 4a9e168b9..2e74a71b1 100644
--- a/src/main/kotlin/com/lambda/config/ConfigEditor.kt
+++ b/src/main/kotlin/com/lambda/config/ConfigEditor.kt
@@ -38,11 +38,11 @@ open class SettingGroupEditor(open val c: T) {
throw IllegalStateException("Could not access delegate for property $name", e)
}
- fun KProperty0.setting() =
+ fun KProperty0.setting() =
this.delegate as? Setting, T>
?: throw IllegalStateException("Setting delegate did not match current value's type")
- fun KProperty0.settingCore() = setting().core
+ fun KProperty0.settingCore() = setting().core
@SettingEditorDsl
inline fun KProperty0.edit(edits: TypedEditBuilder.(SettingCore) -> Unit) {
@@ -60,14 +60,14 @@ open class SettingGroupEditor(open val c: T) {
fun edit(
vararg settings: KProperty0<*>,
edits: BasicEditBuilder.() -> Unit
- ) = BasicEditBuilder(this, settings.map { it.setting() }).apply(edits)
+ ) = BasicEditBuilder(this, settings.map { (it as KProperty0).setting() }).apply(edits)
@SettingEditorDsl
inline fun editWith(
vararg settings: KProperty0<*>,
other: KProperty0,
edits: BasicEditBuilder.(SettingCore) -> Unit
- ) = BasicEditBuilder(this, settings.map { it.setting() }).edits(other.settingCore())
+ ) = BasicEditBuilder(this, settings.map { (it as KProperty0).setting() }).edits(other.settingCore())
@SettingEditorDsl
inline fun editTyped(
@@ -89,7 +89,7 @@ open class SettingGroupEditor(open val c: T) {
@SettingEditorDsl
fun hide(vararg settings: KProperty0<*>) =
- hide(settings.map { it.setting() })
+ hide(settings.map { (it as KProperty0).setting() })
open class BasicEditBuilder(val c: SettingGroupEditor<*>, open val settings: Collection>) {
@SettingEditorDsl
@@ -123,8 +123,10 @@ class ConfigurableEditor(override val c: T) : SettingGroupEdit
fun hideGroup(settingGroup: ISettingGroup) = hide(settingGroup.settings)
@SettingEditorDsl
- fun hideGroupExcept(settingGroup: ISettingGroup, vararg except: KProperty0<*>) =
- hide(*((settingGroup.settings as List>) - except.toSet()).toTypedArray())
+ fun hideGroupExcept(settingGroup: ISettingGroup, vararg except: KProperty0<*>) {
+ val exceptSettings = except.map { (it as KProperty0).setting() }.toSet()
+ hide(settingGroup.settings.filter { it !in exceptSettings })
+ }
@SettingEditorDsl
fun hideGroups(vararg settingGroups: ISettingGroup) =
diff --git a/src/main/kotlin/com/lambda/config/Configurable.kt b/src/main/kotlin/com/lambda/config/Configurable.kt
index ba1cb14f7..e7e5932d2 100644
--- a/src/main/kotlin/com/lambda/config/Configurable.kt
+++ b/src/main/kotlin/com/lambda/config/Configurable.kt
@@ -36,12 +36,13 @@ import com.lambda.config.settings.complex.Bind
import com.lambda.config.settings.complex.BlockPosSetting
import com.lambda.config.settings.complex.BlockSetting
import com.lambda.config.settings.complex.ColorSetting
-import com.lambda.config.settings.complex.KeybindSettingCore
+import com.lambda.config.settings.complex.KeybindSetting
import com.lambda.config.settings.complex.Vec3dSetting
import com.lambda.config.settings.numeric.DoubleSetting
import com.lambda.config.settings.numeric.FloatSetting
import com.lambda.config.settings.numeric.IntegerSetting
import com.lambda.config.settings.numeric.LongSetting
+import com.lambda.event.Muteable
import com.lambda.util.Communication.logError
import com.lambda.util.KeyCode
import com.lambda.util.Nameable
@@ -151,33 +152,23 @@ abstract class Configurable(
) = Setting(name, description, ItemCollectionSetting(immutableCollection, defaultValue.toMutableList()), this, visibility).register()
@JvmName("collectionSetting3")
- inline fun > setting(
+ inline fun setting(
name: String,
defaultValue: Collection,
immutableList: Collection = defaultValue,
description: String = "",
+ displayClassName: Boolean = false,
+ serialize: Boolean = false,
noinline visibility: () -> Boolean = { true },
) = Setting(
name,
description,
- CollectionSetting(
- defaultValue.toMutableList(),
- immutableList,
- TypeToken.getParameterized(Collection::class.java, T::class.java).type
- ),
+ if (displayClassName) ClassCollectionSetting(immutableList, defaultValue.toMutableList())
+ else CollectionSetting(defaultValue.toMutableList(), immutableList, TypeToken.getParameterized(Collection::class.java, T::class.java).type, serialize),
this,
visibility
).register()
- @JvmName("collectionSetting4")
- inline fun setting(
- name: String,
- defaultValue: Collection,
- immutableList: Collection = defaultValue,
- description: String = "",
- noinline visibility: () -> Boolean = { true },
- ) = Setting(name, description, ClassCollectionSetting(immutableList, defaultValue.toMutableList()), this, visibility).register()
-
// ToDo: Actually implement maps
inline fun setting(
name: String,
@@ -239,15 +230,19 @@ abstract class Configurable(
name: String,
defaultValue: Bind,
description: String = "",
+ alwaysListening: Boolean = false,
+ screenCheck: Boolean = true,
visibility: () -> Boolean = { true },
- ) = Setting(name, description, KeybindSettingCore(defaultValue), this, visibility).register()
+ ) = Setting(name, description, KeybindSetting(defaultValue, this as? Muteable, alwaysListening, screenCheck), this, visibility).register()
fun setting(
name: String,
defaultValue: KeyCode,
description: String = "",
+ alwaysListening: Boolean = false,
+ screenCheck: Boolean = true,
visibility: () -> Boolean = { true },
- ) = Setting(name, description, KeybindSettingCore(defaultValue), this, visibility).register()
+ ) = Setting(name, description, KeybindSetting(defaultValue, this as? Muteable, alwaysListening, screenCheck), this, visibility).register()
fun setting(
name: String,
diff --git a/src/main/kotlin/com/lambda/config/Setting.kt b/src/main/kotlin/com/lambda/config/Setting.kt
index 9f16d53c4..75f9ed688 100644
--- a/src/main/kotlin/com/lambda/config/Setting.kt
+++ b/src/main/kotlin/com/lambda/config/Setting.kt
@@ -94,7 +94,7 @@ import kotlin.reflect.KProperty
* @property type The type reflection of the setting.
* @property visibility A function that determines whether the setting is visible.
*/
-abstract class SettingCore(
+abstract class SettingCore(
var defaultValue: T,
val type: Type
) {
@@ -150,7 +150,7 @@ abstract class SettingCore(
}
}
-class Setting, R : Any>(
+class Setting, R>(
override val name: String,
override val description: String,
var core: T,
diff --git a/src/main/kotlin/com/lambda/config/groups/ActionConfig.kt b/src/main/kotlin/com/lambda/config/groups/ActionConfig.kt
index 8851ac52c..78a6c6ffc 100644
--- a/src/main/kotlin/com/lambda/config/groups/ActionConfig.kt
+++ b/src/main/kotlin/com/lambda/config/groups/ActionConfig.kt
@@ -22,17 +22,17 @@ import com.lambda.util.Describable
import com.lambda.util.NamedEnum
interface ActionConfig {
- val sorter: SortMode
- val tickStageMask: Collection
+ val sorter: SortMode
+ val tickStageMask: Collection
- enum class SortMode(
- override val displayName: String,
- override val description: String
- ) : NamedEnum, Describable {
- Closest("Closest", "Breaks blocks closest to the player eye position"),
- Farthest("Farthest", "Breaks blocks farthest from the player eye position"),
- Tool("Tool", "Breaks blocks with priority given to those with tools matching the current selected"),
- Rotation("Rotation", "Breaks blocks closest to the player rotation"),
- Random("Random", "Breaks blocks in a random order")
- }
+ enum class SortMode(
+ override val displayName: String,
+ override val description: String
+ ) : NamedEnum, Describable {
+ Closest("Closest", "Breaks blocks closest to the player eye position"),
+ Farthest("Farthest", "Breaks blocks farthest from the player eye position"),
+ Tool("Tool", "Breaks blocks with priority given to those with tools matching the current selected"),
+ Rotation("Rotation", "Breaks blocks closest to the player rotation"),
+ Random("Random", "Breaks blocks in a random order")
+ }
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt b/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
index f7769bd3f..f4986db31 100644
--- a/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
@@ -31,87 +31,87 @@ import net.minecraft.block.Block
import java.awt.Color
open class BreakSettings(
- c: Configurable,
- baseGroup: NamedEnum
+ c: Configurable,
+ baseGroup: NamedEnum
) : SettingGroup(c), BreakConfig {
- private enum class Group(override val displayName: String) : NamedEnum {
- General("General"),
- Cosmetic("Cosmetic")
- }
-
- // General
- override val breakMode by c.setting("Break Mode", BreakMode.Packet).group(baseGroup, Group.General).index()
- override val sorter by c.setting("Break Sorter", ActionConfig.SortMode.Tool, "The order in which breaks are performed").group(baseGroup, Group.General).index()
- override val rebreak by c.setting("Rebreak", true, "Re-breaks blocks after they've been broken once").group(baseGroup, Group.General).index()
-
- // Double break
- override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once").group(baseGroup, Group.General).index()
- override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { doubleBreak }.group(baseGroup, Group.General).index()
-
- // Fixes / Delays
- override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken").group(baseGroup, Group.General).index()
- override val fudgeFactor by c.setting("Fudge Factor", 1, 0..5, 1, "The number of ticks to add to the break time, usually to account for server lag").group(baseGroup, Group.General).index()
- override val serverSwapTicks by c.setting("Server Swap", 0, 0..5, 1, "The number of ticks to give the server time to recognize the player attributes on the swapped item", " tick(s)").group(baseGroup, Group.General).index()
-
- // override val desyncFix by c.setting("Desync Fix", false, "Predicts if the players breaking will be slowed next tick as block break packets are processed using the players next position") { vis() && page == Page.General }
- override val breakDelay by c.setting("Break Delay", 0, 0..5, 1, "The delay between breaking blocks", " tick(s)").group(baseGroup, Group.General).index()
-
- // Timing
- override val tickStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which break actions can be performed").group(baseGroup, Group.General).index()
-
- // Swap
- override val swapMode by c.setting("Break Swap Mode", BreakConfig.SwapMode.End, "Decides when to swap to the best suited tool when breaking a block").group(baseGroup, Group.General).index()
-
- // Swing
- override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand").group(baseGroup, Group.General).index()
- override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { swing != SwingMode.None }.group(baseGroup, Group.General).index()
-
- // Rotate
- override val rotate by c.setting("Rotate For Break", false, "Rotate towards block while breaking").group(baseGroup, Group.General).index()
-
- // Pending / Post
- override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking").group(baseGroup, Group.General).index()
- override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick").group(baseGroup, Group.General).index()
-
- // Block
- override val ignoredBlocks by c.setting("Ignored Blocks", emptySet(), description = "Blocks that wont be broken").group(baseGroup, Group.General).index()
- override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill").group(baseGroup, Group.General).index()
- override val avoidSupporting by c.setting("Avoid Supporting", true, "Avoids breaking the block supporting the player").group(baseGroup, Group.General).index()
-
- // Tool
- override val efficientOnly by c.setting("Efficient Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val suitableToolsOnly by c.setting("Suitable Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { swapMode.isEnabled() && forceFortunePickaxe }.group(baseGroup, Group.General).index()
- override val useWoodenTools by c.setting("Use Wooden Tools", true, "Use wooden tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val useStoneTools by c.setting("Use Stone Tools", true, "Use stone tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val useIronTools by c.setting("Use Iron Tools", true, "Use iron tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val useDiamondTools by c.setting("Use Diamond Tools", true, "Use diamond tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val useGoldTools by c.setting("Use Gold Tools", true, "Use gold tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
- override val useNetheriteTools by c.setting("Use Netherite Tools", true, "Use netherite tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
-
- // Cosmetics
- override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds").group(baseGroup, Group.Cosmetic).index()
- override val particles by c.setting("Particles", true, "Renders the breaking particles").group(baseGroup, Group.Cosmetic).index()
- override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages").group(baseGroup, Group.Cosmetic).index()
-
- // Modes
- override val renders by c.setting("Renders", true, "Enables the render settings for breaking progress").group(baseGroup, Group.Cosmetic).index()
- override val animation by c.setting("Animation", AnimationMode.Out, "The style of animation used for the box") { renders }.group(baseGroup, Group.Cosmetic).index()
-
- // Fill
- override val fill by c.setting("Fill", true, "Renders the sides of the box to display break progress") { renders }.group(baseGroup, Group.Cosmetic).index()
- override val dynamicFillColor by c.setting("Dynamic Colour", true, "Enables fill color interpolation from start to finish for fill when breaking a block") { renders && fill }.group(baseGroup, Group.Cosmetic).index()
- override val staticFillColor by c.setting("Fill Color", Color(255, 0, 0, 60).brighter(), "The color of the fill") { renders && !dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
- override val startFillColor by c.setting("Start Fill Color", Color(255, 0, 0, 60).brighter(), "The color of the fill at the start of breaking") { renders && dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
- override val endFillColor by c.setting("End Fill Color", Color(0, 255, 0, 60).brighter(), "The color of the fill at the end of breaking") { renders && dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
-
- // Outline
- override val outline by c.setting("Outline", true, "Renders the lines of the box to display break progress") { renders }.group(baseGroup, Group.Cosmetic).index()
- override val outlineWidth by c.setting("Outline Width", 2, 0..5, 1, "The width of the outline") { renders && outline }.group(baseGroup, Group.Cosmetic).index()
- override val dynamicOutlineColor by c.setting("Dynamic Outline Color", true, "Enables color interpolation from start to finish for the outline when breaking a block") { renders && outline }.group(baseGroup, Group.Cosmetic).index()
- override val staticOutlineColor by c.setting("Outline Color", Color.RED.brighter(), "The Color of the outline at the start of breaking") { renders && !dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
- override val startOutlineColor by c.setting("Start Outline Color", Color.RED.brighter(), "The color of the outline at the start of breaking") { renders && dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
- override val endOutlineColor by c.setting("End Outline Color", Color.GREEN.brighter(), "The color of the outline at the end of breaking") { renders && dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
+ private enum class Group(override val displayName: String) : NamedEnum {
+ General("General"),
+ Cosmetic("Cosmetic")
+ }
+
+ // General
+ override val breakMode by c.setting("Break Mode", BreakMode.Packet).group(baseGroup, Group.General).index()
+ override val sorter by c.setting("Break Sorter", ActionConfig.SortMode.Tool, "The order in which breaks are performed").group(baseGroup, Group.General).index()
+ override val rebreak by c.setting("Rebreak", true, "Re-breaks blocks after they've been broken once").group(baseGroup, Group.General).index()
+
+ // Double break
+ override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once").group(baseGroup, Group.General).index()
+ override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { doubleBreak }.group(baseGroup, Group.General).index()
+
+ // Fixes / Delays
+ override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken").group(baseGroup, Group.General).index()
+ override val fudgeFactor by c.setting("Fudge Factor", 1, 0..5, 1, "The number of ticks to add to the break time, usually to account for server lag").group(baseGroup, Group.General).index()
+ override val serverSwapTicks by c.setting("Server Swap", 0, 0..5, 1, "The number of ticks to give the server time to recognize the player attributes on the swapped item", " tick(s)").group(baseGroup, Group.General).index()
+
+ // override val desyncFix by c.setting("Desync Fix", false, "Predicts if the players breaking will be slowed next tick as block break packets are processed using the players next position") { vis() && page == Page.General }
+ override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " tick(s)").group(baseGroup, Group.General).index()
+
+ // Timing
+ override val tickStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), "The sub-tick timing at which break actions can be performed", displayClassName = true).group(baseGroup, Group.General).index()
+
+ // Swap
+ override val swapMode by c.setting("Break Swap Mode", BreakConfig.SwapMode.End, "Decides when to swap to the best suited tool when breaking a block").group(baseGroup, Group.General).index()
+
+ // Swing
+ override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand").group(baseGroup, Group.General).index()
+ override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { swing != SwingMode.None }.group(baseGroup, Group.General).index()
+
+ // Rotate
+ override val rotate by c.setting("Rotate For Break", false, "Rotate towards block while breaking").group(baseGroup, Group.General).index()
+
+ // Pending / Post
+ override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking").group(baseGroup, Group.General).index()
+ override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick").group(baseGroup, Group.General).index()
+
+ // Block
+ override val ignoredBlocks by c.setting("Ignored Blocks", emptySet(), description = "Blocks that wont be broken").group(baseGroup, Group.General).index()
+ override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill").group(baseGroup, Group.General).index()
+ override val avoidSupporting by c.setting("Avoid Supporting", true, "Avoids breaking the block supporting the player").group(baseGroup, Group.General).index()
+
+ // Tool
+ override val efficientOnly by c.setting("Efficient Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val suitableToolsOnly by c.setting("Suitable Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { swapMode.isEnabled() && forceFortunePickaxe }.group(baseGroup, Group.General).index()
+ override val useWoodenTools by c.setting("Use Wooden Tools", true, "Use wooden tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val useStoneTools by c.setting("Use Stone Tools", true, "Use stone tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val useIronTools by c.setting("Use Iron Tools", true, "Use iron tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val useDiamondTools by c.setting("Use Diamond Tools", true, "Use diamond tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val useGoldTools by c.setting("Use Gold Tools", true, "Use gold tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+ override val useNetheriteTools by c.setting("Use Netherite Tools", true, "Use netherite tools when breaking blocks") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
+
+ // Cosmetics
+ override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds").group(baseGroup, Group.Cosmetic).index()
+ override val particles by c.setting("Particles", true, "Renders the breaking particles").group(baseGroup, Group.Cosmetic).index()
+ override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages").group(baseGroup, Group.Cosmetic).index()
+
+ // Modes
+ override val renders by c.setting("Renders", true, "Enables the render settings for breaking progress").group(baseGroup, Group.Cosmetic).index()
+ override val animation by c.setting("Animation", AnimationMode.Out, "The style of animation used for the box") { renders }.group(baseGroup, Group.Cosmetic).index()
+
+ // Fill
+ override val fill by c.setting("Fill", true, "Renders the sides of the box to display break progress") { renders }.group(baseGroup, Group.Cosmetic).index()
+ override val dynamicFillColor by c.setting("Dynamic Colour", true, "Enables fill color interpolation from start to finish for fill when breaking a block") { renders && fill }.group(baseGroup, Group.Cosmetic).index()
+ override val staticFillColor by c.setting("Fill Color", Color(255, 0, 0, 60).brighter(), "The color of the fill") { renders && !dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
+ override val startFillColor by c.setting("Start Fill Color", Color(255, 0, 0, 60).brighter(), "The color of the fill at the start of breaking") { renders && dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
+ override val endFillColor by c.setting("End Fill Color", Color(0, 255, 0, 60).brighter(), "The color of the fill at the end of breaking") { renders && dynamicFillColor && fill }.group(baseGroup, Group.Cosmetic).index()
+
+ // Outline
+ override val outline by c.setting("Outline", true, "Renders the lines of the box to display break progress") { renders }.group(baseGroup, Group.Cosmetic).index()
+ override val outlineWidth by c.setting("Outline Width", 2, 0..5, 1, "The width of the outline") { renders && outline }.group(baseGroup, Group.Cosmetic).index()
+ override val dynamicOutlineColor by c.setting("Dynamic Outline Color", true, "Enables color interpolation from start to finish for the outline when breaking a block") { renders && outline }.group(baseGroup, Group.Cosmetic).index()
+ override val staticOutlineColor by c.setting("Outline Color", Color.RED.brighter(), "The Color of the outline at the start of breaking") { renders && !dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
+ override val startOutlineColor by c.setting("Start Outline Color", Color.RED.brighter(), "The color of the outline at the start of breaking") { renders && dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
+ override val endOutlineColor by c.setting("End Outline Color", Color.GREEN.brighter(), "The color of the outline at the end of breaking") { renders && dynamicOutlineColor && outline }.group(baseGroup, Group.Cosmetic).index()
}
diff --git a/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt b/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt
index 323161174..9c4cad6ca 100644
--- a/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt
+++ b/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt
@@ -23,7 +23,9 @@ import com.lambda.util.Describable
import com.lambda.util.NamedEnum
interface BuildConfig : ISettingGroup {
- // General
+ val breakBlocks: Boolean
+ val interactBlocks: Boolean
+
val pathing: Boolean
val stayInRange: Boolean
val collectDrops: Boolean
@@ -32,8 +34,8 @@ interface BuildConfig : ISettingGroup {
val actionTimeout: Int
val maxBuildDependencies: Int
- val entityReach: Double
val blockReach: Double
+ val entityReach: Double
val scanReach: Double
val checkSideVisibility: Boolean
diff --git a/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt b/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt
index 1a7632bd7..e1fa36913 100644
--- a/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt
@@ -33,17 +33,19 @@ class BuildSettings(
Scan("Scan")
}
- // General
- override val pathing by c.setting("Pathing", true, "Path to blocks").group(baseGroup, Group.General).index()
- override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks").group(baseGroup, Group.General).index()
+ override val breakBlocks by c.setting("Break", true, "Break blocks").group(baseGroup, Group.General).index()
+ override val interactBlocks by c.setting("Place / Interact", true, "Interact blocks").group(baseGroup, Group.General).index()
+
+ override val pathing by c.setting("Pathing", false, "Path to blocks").group(baseGroup, Group.General).index()
+ override val stayInRange by c.setting("Stay In Range", false, "Stay in range of blocks").group(baseGroup, Group.General).index()
override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks").group(baseGroup, Group.General).index()
override val spleefEntities by c.setting("Spleef Entities", false, "Breaks blocks beneath entities blocking placements to get them out of the way").group(baseGroup, Group.General).index()
override val maxPendingActions by c.setting("Max Pending Actions", 15, 1..30, 1, "The maximum count of pending interactions to allow before pausing future interactions").group(baseGroup, Group.General).index()
override val actionTimeout by c.setting("Action Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks").group(baseGroup, Group.General).index()
override val maxBuildDependencies by c.setting("Max Sim Dependencies", 3, 0..10, 1, "Maximum dependency build results").group(baseGroup, Group.General).index()
- override var entityReach by c.setting("Attack Reach", 3.0, 1.0..7.0, 0.01, "Maximum entity interaction distance").group(baseGroup, Group.Reach).index()
override var blockReach by c.setting("Interact Reach", 4.5, 1.0..7.0, 0.01, "Maximum block interaction distance").group(baseGroup, Group.Reach).index()
+ override var entityReach by c.setting("Attack Reach", 3.0, 1.0..7.0, 0.01, "Maximum entity interaction distance").group(baseGroup, Group.Reach).index()
override val scanReach: Double get() = max(entityReach, blockReach)
override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible").group(baseGroup, Group.Scan).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt b/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt
index 295c4db21..1d53a3d72 100644
--- a/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt
@@ -23,22 +23,22 @@ import com.lambda.util.NamedEnum
class FormatterSettings(
c: Configurable,
- baseGroup: NamedEnum,
+ vararg baseGroup: NamedEnum,
) : FormatterConfig, SettingGroup(c) {
- val localeEnum by c.setting("Locale", FormatterConfig.Locales.US, "The regional formatting used for numbers").group(baseGroup).index()
+ val localeEnum by c.setting("Locale", FormatterConfig.Locales.US, "The regional formatting used for numbers").group(*baseGroup).index()
override val locale get() = localeEnum.locale
- val sep by c.setting("Separator", FormatterConfig.TupleSeparator.Comma, "Separator for string serialization of tuple data structures").group(baseGroup).index()
- val customSep by c.setting("Custom Separator", "") { sep == FormatterConfig.TupleSeparator.Custom }.group(baseGroup).index()
+ val sep by c.setting("Separator", FormatterConfig.TupleSeparator.Comma, "Separator for string serialization of tuple data structures").group(*baseGroup).index()
+ val customSep by c.setting("Custom Separator", "") { sep == FormatterConfig.TupleSeparator.Custom }.group(*baseGroup).index()
override val separator get() = if (sep == FormatterConfig.TupleSeparator.Custom) customSep else sep.separator
- val group by c.setting("Tuple Prefix", FormatterConfig.TupleGrouping.Parentheses).group(baseGroup).index()
+ val group by c.setting("Tuple Prefix", FormatterConfig.TupleGrouping.Parentheses).group(*baseGroup).index()
override val prefix get() = group.prefix
override val postfix get() = group.postfix
- val floatingPrecision by c.setting("Floating Precision", 3, 0..6, 1, "Precision for floating point numbers").group(baseGroup).index()
+ val floatingPrecision by c.setting("Floating Precision", 3, 0..6, 1, "Precision for floating point numbers").group(*baseGroup).index()
override val precision get() = floatingPrecision
- val timeFormat by c.setting("Time Format", FormatterConfig.Time.IsoDateTime).group(baseGroup).index()
+ val timeFormat by c.setting("Time Format", FormatterConfig.Time.IsoDateTime).group(*baseGroup).index()
override val format get() = timeFormat.format
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt b/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt
index 618e6c10e..34baab4e8 100644
--- a/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt
@@ -33,5 +33,5 @@ class HotbarSettings(
override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks").group(baseGroup).index()
override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 }.group(baseGroup).index()
override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks").group(baseGroup).index()
- override val tickStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which hotbar actions are performed").group(baseGroup).index()
+ override val tickStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), "The sub-tick timing at which hotbar actions are performed", displayClassName = true).group(baseGroup).index()
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt b/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt
index 9704a6d8b..90fc0b8be 100644
--- a/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt
@@ -34,7 +34,7 @@ class InteractSettings(
override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces").group(baseGroup).index()
override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { airPlace.isEnabled }.group(baseGroup).index()
override val sorter by c.setting("Interaction Sorter", ActionConfig.SortMode.Tool, "The order in which placements are performed").group(baseGroup).index()
- override val tickStageMask by c.setting("Interaction Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which place actions are performed").group(baseGroup).index()
+ override val tickStageMask by c.setting("Interaction Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), "The sub-tick timing at which place actions are performed", displayClassName = true).group(baseGroup).index()
override val interactConfirmationMode by c.setting("Interact Confirmation", InteractConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation").group(baseGroup).index()
override val interactDelay by c.setting("Interact Delay", 0, 0..3, 1, "Tick delay between interacting with another block").group(baseGroup).index()
override val interactionsPerTick by c.setting("Interactions Per Tick", 1, 1..30, 1, "Maximum instant block places per tick").group(baseGroup).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt b/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt
index 9d67ff369..2dc25e38a 100644
--- a/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt
+++ b/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt
@@ -35,15 +35,14 @@ class InventorySettings(
}
override val actionsPerSecond by c.setting("Actions Per Second", 100, 0..100, 1, "How many inventory actions can be performed per tick").group(baseGroup, Group.General).index()
- override val tickStageMask by c.setting("Inventory Stage Mask", ALL_STAGES.toSet(), description = "The sub-tick timing at which inventory actions are performed").group(baseGroup, Group.General).index()
+ override val tickStageMask by c.setting("Inventory Stage Mask", ALL_STAGES.toSet(), description = "The sub-tick timing at which inventory actions are performed", displayClassName = true).group(baseGroup, Group.General).index()
override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, description = "Items that will be ignored when checking for a free slot").group(baseGroup, Group.Container).index()
override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones").group(baseGroup, Group.Container).index()
override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from").group(baseGroup, Group.Container).index()
override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to").group(baseGroup, Group.Container).index()
- override val immediateAccessOnly by c.setting("Immediate Access Only", false, "Only allow access to inventories that can be accessed immediately").group(baseGroup, Group.Access).index()
- override val accessShulkerBoxes by c.setting("Access Shulker Boxes", true, "Allow access to the player's shulker boxes").group(baseGroup, Group.Access).index()
- override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest").group(baseGroup, Group.Access).index()
+ override val accessShulkerBoxes by c.setting("Access Shulker Boxes", false, "Allow access to the player's shulker boxes").group(baseGroup, Group.Access).index()
override val accessChests by c.setting("Access Chests", false, "Allow access to the player's normal chests").group(baseGroup, Group.Access).index()
+ override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest").group(baseGroup, Group.Access).index()
override val accessStashes by c.setting("Access Stashes", false, "Allow access to the player's stashes").group(baseGroup, Group.Access).index()
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/groups/ReplaceConfig.kt b/src/main/kotlin/com/lambda/config/groups/ReplaceConfig.kt
new file mode 100644
index 000000000..f67407d17
--- /dev/null
+++ b/src/main/kotlin/com/lambda/config/groups/ReplaceConfig.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.config.groups
+
+import com.lambda.util.Describable
+
+interface ReplaceConfig {
+ val action: ActionStrategy
+ val replace: ReplaceStrategy
+
+ val enabled: Boolean get() = action != ActionStrategy.None
+
+ enum class ActionStrategy(override val description: String) : Describable {
+ Hide("Hides the message. Will override other strategies."),
+ Delete("Deletes the matching part off the message."),
+ Replace("Replace the matching string in the message with one of the following replace strategy."),
+ None("Don't do anything."),
+ }
+
+ enum class ReplaceStrategy(val block: (String) -> String) {
+ CensorAll({ it.replaceRange(0.. if (i % 2 == 0) acc + char else "$acc*" } }),
+ KeepFirst({ if (it.length <= 1) it else it.replaceRange(1, it.length, "*".repeat(it.length - 1)) }),
+ }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/groups/Targeting.kt b/src/main/kotlin/com/lambda/config/groups/Targeting.kt
index a50753e8b..a82766c1c 100644
--- a/src/main/kotlin/com/lambda/config/groups/Targeting.kt
+++ b/src/main/kotlin/com/lambda/config/groups/Targeting.kt
@@ -115,8 +115,8 @@ abstract class Targeting(
* @return `true` if the entity is valid for targeting, `false` otherwise.
*/
open fun validate(player: ClientPlayerEntity, entity: LivingEntity) = when {
+ !friends && entity is OtherClientPlayerEntity && entity.isFriend -> false
!players && entity is OtherClientPlayerEntity -> false
- players && entity is OtherClientPlayerEntity && entity.isFriend -> false
!animals && entity is PassiveEntity -> false
!hostiles && entity is HostileEntity -> false
entity is ArmorStandEntity -> false
diff --git a/src/main/kotlin/com/lambda/config/serializer/TextCodec.kt b/src/main/kotlin/com/lambda/config/serializer/TextCodec.kt
new file mode 100644
index 000000000..629e3ebb6
--- /dev/null
+++ b/src/main/kotlin/com/lambda/config/serializer/TextCodec.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.config.serializer
+
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonElement
+import com.google.gson.JsonSerializationContext
+import com.lambda.config.Codec
+import com.mojang.serialization.JsonOps
+import net.minecraft.text.Text
+import net.minecraft.text.TextCodecs
+import java.lang.reflect.Type
+import kotlin.jvm.optionals.getOrElse
+
+object TextCodec : Codec {
+ override fun serialize(
+ src: Text,
+ typeOfSrc: Type,
+ context: JsonSerializationContext,
+ ): JsonElement =
+ TextCodecs.CODEC.encodeStart(JsonOps.INSTANCE, src)
+ .orThrow
+
+ override fun deserialize(
+ json: JsonElement?,
+ typeOfT: Type?,
+ context: JsonDeserializationContext?,
+ ): Text =
+ TextCodecs.CODEC.parse(JsonOps.INSTANCE, json)
+ .result()
+ .getOrElse { Text.empty() }
+}
diff --git a/src/main/kotlin/com/lambda/config/settings/collections/BlockCollectionSetting.kt b/src/main/kotlin/com/lambda/config/settings/collections/BlockCollectionSetting.kt
index 223f25e2c..7d7c66f79 100644
--- a/src/main/kotlin/com/lambda/config/settings/collections/BlockCollectionSetting.kt
+++ b/src/main/kotlin/com/lambda/config/settings/collections/BlockCollectionSetting.kt
@@ -17,9 +17,7 @@
package com.lambda.config.settings.collections
-import com.google.gson.JsonElement
import com.google.gson.reflect.TypeToken
-import com.lambda.Lambda.gson
import com.lambda.config.Setting
import com.lambda.config.serializer.BlockCodec
import com.lambda.gui.dsl.ImGuiBuilder
@@ -31,17 +29,9 @@ class BlockCollectionSetting(
) : CollectionSetting(
defaultValue,
immutableCollection,
- TypeToken.getParameterized(Collection::class.java, Block::class.java).type
+ TypeToken.getParameterized(Collection::class.java, Block::class.java).type,
+ serialize = true,
) {
context(setting: Setting<*, MutableCollection>)
override fun ImGuiBuilder.buildLayout() = buildComboBox("block") { BlockCodec.stringify(it) }
-
- context(setting: Setting<*, MutableCollection>)
- override fun toJson(): JsonElement = gson.toJsonTree(value, type)
-
- context(setting: Setting<*, MutableCollection>)
- override fun loadFromJson(serialized: JsonElement) {
- value = gson.fromJson>(serialized, type)
- .toMutableList()
- }
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/settings/collections/ClassCollectionSetting.kt b/src/main/kotlin/com/lambda/config/settings/collections/ClassCollectionSetting.kt
index 054808251..218c29673 100644
--- a/src/main/kotlin/com/lambda/config/settings/collections/ClassCollectionSetting.kt
+++ b/src/main/kotlin/com/lambda/config/settings/collections/ClassCollectionSetting.kt
@@ -34,7 +34,8 @@ class ClassCollectionSetting(
) : CollectionSetting(
defaultValue,
immutableCollection,
- TypeToken.getParameterized(Collection::class.java, Any::class.java).type
+ TypeToken.getParameterized(Collection::class.java, Any::class.java).type,
+ serialize = false,
) {
context(setting: Setting<*, MutableCollection>)
override fun ImGuiBuilder.buildLayout() = buildComboBox("item") { it.className }
diff --git a/src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt b/src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt
index 812ccb90a..b092b38ee 100644
--- a/src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt
+++ b/src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt
@@ -46,7 +46,8 @@ import java.lang.reflect.Type
open class CollectionSetting(
defaultValue: MutableCollection,
private var immutableCollection: Collection,
- type: Type
+ type: Type,
+ private val serialize: Boolean,
) : SettingCore>(
defaultValue,
type
@@ -106,16 +107,18 @@ open class CollectionSetting(
context(setting: Setting<*, MutableCollection>)
override fun toJson(): JsonElement =
- gson.toJsonTree(value.map { it.toString() })
+ gson.toJsonTree(value, type)
context(setting: Setting<*, MutableCollection>)
override fun loadFromJson(serialized: JsonElement) {
- val strList = gson.fromJson>(serialized, strListType)
- .mapNotNull { str -> immutableCollection.find { it.toString() == str } }
- .toMutableList()
+ val strList =
+ if (serialize) gson.fromJson(serialized, type)
+ else gson.fromJson>(serialized, strListType)
+ .mapNotNull { str -> immutableCollection.find { it.toString() == str } }
+ .toMutableList()
- value = strList
- }
+ value = strList
+ }
companion object {
fun , R : Any> Setting>.onSelect(block: SafeContext.(R) -> Unit) = apply {
diff --git a/src/main/kotlin/com/lambda/config/settings/collections/ItemCollectionSetting.kt b/src/main/kotlin/com/lambda/config/settings/collections/ItemCollectionSetting.kt
index 967f4c82c..c5caab002 100644
--- a/src/main/kotlin/com/lambda/config/settings/collections/ItemCollectionSetting.kt
+++ b/src/main/kotlin/com/lambda/config/settings/collections/ItemCollectionSetting.kt
@@ -17,9 +17,7 @@
package com.lambda.config.settings.collections
-import com.google.gson.JsonElement
import com.google.gson.reflect.TypeToken
-import com.lambda.Lambda.gson
import com.lambda.config.Setting
import com.lambda.config.serializer.ItemCodec
import com.lambda.gui.dsl.ImGuiBuilder
@@ -31,17 +29,9 @@ class ItemCollectionSetting(
) : CollectionSetting
- (
defaultValue,
immutableCollection,
- TypeToken.getParameterized(Collection::class.java, Item::class.java).type
+ TypeToken.getParameterized(Collection::class.java, Item::class.java).type,
+ serialize = true,
) {
context(setting: Setting<*, MutableCollection
- >)
override fun ImGuiBuilder.buildLayout() = buildComboBox("item") { ItemCodec.stringify(it) }
-
- context(setting: Setting<*, MutableCollection
- >)
- override fun toJson(): JsonElement = gson.toJsonTree(value, type)
-
- context(setting: Setting<*, MutableCollection
- >)
- override fun loadFromJson(serialized: JsonElement) {
- value = gson.fromJson>(serialized, type)
- .toMutableList()
- }
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/config/settings/complex/KeybindSetting.kt b/src/main/kotlin/com/lambda/config/settings/complex/KeybindSetting.kt
index 1e8c11993..dd5e9663e 100644
--- a/src/main/kotlin/com/lambda/config/settings/complex/KeybindSetting.kt
+++ b/src/main/kotlin/com/lambda/config/settings/complex/KeybindSetting.kt
@@ -28,6 +28,10 @@ import com.lambda.brigadier.optional
import com.lambda.brigadier.required
import com.lambda.config.Setting
import com.lambda.config.SettingCore
+import com.lambda.context.SafeContext
+import com.lambda.event.Muteable
+import com.lambda.event.events.ButtonEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
import com.lambda.gui.dsl.ImGuiBuilder
import com.lambda.util.InputUtils
import com.lambda.util.KeyCode
@@ -48,14 +52,43 @@ import org.lwjgl.glfw.GLFW.GLFW_MOD_NUM_LOCK
import org.lwjgl.glfw.GLFW.GLFW_MOD_SHIFT
import org.lwjgl.glfw.GLFW.GLFW_MOD_SUPER
-class KeybindSettingCore(defaultValue: Bind) : SettingCore(
+class KeybindSetting(
+ defaultValue: Bind,
+ private val muteable: Muteable?,
+ private val alwaysListening: Boolean,
+ private val screenCheck: Boolean
+) : SettingCore(
defaultValue,
TypeToken.get(Bind::class.java).type
-) {
- constructor(defaultValue: KeyCode) : this(Bind(defaultValue.code, 0, -1))
+), Muteable {
+ constructor(defaultValue: KeyCode, muteable: Muteable?, alwaysListen: Boolean, screenCheck: Boolean)
+ : this(Bind(defaultValue.code, 0, -1), muteable, alwaysListen, screenCheck)
+
+ private val pressListeners = mutableListOf Unit>()
+ private val repeatListeners = mutableListOf Unit>()
+ private val releaseListeners = mutableListOf Unit>()
private var listening = false
+ override val isMuted
+ get() = muteable?.isMuted == true && !alwaysListening
+
+ init {
+ listen { event -> onButtonEvent(event) }
+ listen { event -> onButtonEvent(event) }
+ }
+
+ private fun SafeContext.onButtonEvent(event: ButtonEvent) {
+ if (mc.options.commandKey.isPressed ||
+ (screenCheck && mc.currentScreen != null) ||
+ !event.satisfies(value)) return
+
+ if (event.isPressed) {
+ if (event.isRepeated) repeatListeners.forEach { it(event) }
+ else pressListeners.forEach { it(event) }
+ } else if (event.isReleased) releaseListeners.forEach { it(event) }
+ }
+
context(setting: Setting<*, Bind>)
override fun ImGuiBuilder.buildLayout() {
text(setting.name)
@@ -66,16 +99,18 @@ class KeybindSettingCore(defaultValue: Bind) : SettingCore(
if (listening) "Press any key…"
else bind.name
- if (listening) {
- withStyleColor(ImGuiCol.Button, 0.20f, 0.50f, 1.00f, 1.00f) {
- withStyleColor(ImGuiCol.ButtonHovered, 0.25f, 0.60f, 1.00f, 1.00f) {
- withStyleColor(ImGuiCol.ButtonActive, 0.20f, 0.50f, 0.95f, 1.00f) {
- button(preview)
+ withId("##Bind-${this@KeybindSetting.hashCode()}") {
+ if (listening) {
+ withStyleColor(ImGuiCol.Button, 0.20f, 0.50f, 1.00f, 1.00f) {
+ withStyleColor(ImGuiCol.ButtonHovered, 0.25f, 0.60f, 1.00f, 1.00f) {
+ withStyleColor(ImGuiCol.ButtonActive, 0.20f, 0.50f, 0.95f, 1.00f) {
+ button(preview)
+ }
}
}
+ } else {
+ button(preview) { listening = true }
}
- } else {
- button(preview) { listening = true }
}
lambdaTooltip {
@@ -88,9 +123,11 @@ class KeybindSettingCore(defaultValue: Bind) : SettingCore(
}
sameLine()
- smallButton("Unbind") {
- value = Bind.EMPTY
- listening = false
+ withId("##Unbind-${this@KeybindSetting.hashCode()}") {
+ smallButton("Unbind") {
+ value = Bind.EMPTY
+ listening = false
+ }
}
onItemHover(ImGuiHoveredFlags.Stationary) {
lambdaTooltip("Clear binding")
@@ -157,6 +194,20 @@ class KeybindSettingCore(defaultValue: Bind) : SettingCore(
}
}
}
+
+ companion object {
+ fun Setting.onPress(block: SafeContext.(ButtonEvent) -> Unit) = apply {
+ core.pressListeners.add(block)
+ }
+
+ fun Setting.onRepeat(block: SafeContext.(ButtonEvent) -> Unit) = apply {
+ core.repeatListeners.add(block)
+ }
+
+ fun Setting.onRelease(block: SafeContext.(ButtonEvent) -> Unit) = apply {
+ core.releaseListeners.add(block)
+ }
+ }
}
data class Bind(
diff --git a/src/main/kotlin/com/lambda/context/Automated.kt b/src/main/kotlin/com/lambda/context/Automated.kt
index 8cabc8128..a4ba9309e 100644
--- a/src/main/kotlin/com/lambda/context/Automated.kt
+++ b/src/main/kotlin/com/lambda/context/Automated.kt
@@ -26,11 +26,11 @@ import com.lambda.interaction.managers.inventory.InventoryConfig
import com.lambda.interaction.managers.rotating.RotationConfig
interface Automated {
- val buildConfig: BuildConfig
- val breakConfig: BreakConfig
- val interactConfig: InteractConfig
- val rotationConfig: RotationConfig
- val inventoryConfig: InventoryConfig
- val hotbarConfig: HotbarConfig
- val eatConfig: EatConfig
+ val buildConfig: BuildConfig
+ val breakConfig: BreakConfig
+ val interactConfig: InteractConfig
+ val rotationConfig: RotationConfig
+ val inventoryConfig: InventoryConfig
+ val hotbarConfig: HotbarConfig
+ val eatConfig: EatConfig
}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/context/AutomatedSafeContext.kt b/src/main/kotlin/com/lambda/context/AutomatedSafeContext.kt
index f69e58460..f0bd51ed5 100644
--- a/src/main/kotlin/com/lambda/context/AutomatedSafeContext.kt
+++ b/src/main/kotlin/com/lambda/context/AutomatedSafeContext.kt
@@ -18,6 +18,6 @@
package com.lambda.context
class AutomatedSafeContext(
- safeContext: SafeContext,
- automated: Automated
+ safeContext: SafeContext,
+ automated: Automated
) : IAutomatedSafeContext, SafeContext by safeContext, Automated by automated
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/context/AutomationConfig.kt b/src/main/kotlin/com/lambda/context/AutomationConfig.kt
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/main/kotlin/com/lambda/context/SafeContext.kt b/src/main/kotlin/com/lambda/context/SafeContext.kt
index 379c40bb6..2cfb6d78d 100644
--- a/src/main/kotlin/com/lambda/context/SafeContext.kt
+++ b/src/main/kotlin/com/lambda/context/SafeContext.kt
@@ -49,25 +49,25 @@ import net.minecraft.client.world.ClientWorld
* @property connection The network handler for the player.
**/
interface SafeContext {
- val mc: MinecraftClient
- val world: ClientWorld
- val player: ClientPlayerEntity
- val interaction: ClientPlayerInteractionManager
- val connection: ClientPlayNetworkHandler
+ val mc: MinecraftClient
+ val world: ClientWorld
+ val player: ClientPlayerEntity
+ val interaction: ClientPlayerInteractionManager
+ val connection: ClientPlayNetworkHandler
- companion object {
- fun create(): SafeContext? {
- val world = mc.world ?: return null
- val player = mc.player ?: return null
- val interaction = mc.interactionManager ?: return null
- val connection = mc.networkHandler ?: return null
- return object : SafeContext {
- override val mc = Lambda.mc
- override val world = world
- override val player = player
- override val interaction = interaction
- override val connection = connection
- }
- }
- }
+ companion object {
+ fun create(): SafeContext? {
+ val world = mc.world ?: return null
+ val player = mc.player ?: return null
+ val interaction = mc.interactionManager ?: return null
+ val connection = mc.networkHandler ?: return null
+ return object : SafeContext {
+ override val mc = Lambda.mc
+ override val world = world
+ override val player = player
+ override val interaction = interaction
+ override val connection = connection
+ }
+ }
+ }
}
diff --git a/src/main/kotlin/com/lambda/event/EventFlow.kt b/src/main/kotlin/com/lambda/event/EventFlow.kt
index 5fbdabbcd..ef18705cd 100644
--- a/src/main/kotlin/com/lambda/event/EventFlow.kt
+++ b/src/main/kotlin/com/lambda/event/EventFlow.kt
@@ -290,8 +290,8 @@ object EventFlow {
* @return `true` if the listener should not be notified, `false` otherwise.
*/
private fun shouldNotNotify(listener: Listener, event: Event) =
- listener.owner is Muteable
- && (listener.owner as Muteable).isMuted
- && !listener.alwaysListen
- || event is ICancellable && event.isCanceled()
+ (listener.owner is Muteable &&
+ (listener.owner as Muteable).isMuted &&
+ !listener.alwaysListen) ||
+ (event is ICancellable && event.isCanceled())
}
diff --git a/src/main/kotlin/com/lambda/event/events/ButtonEvent.kt b/src/main/kotlin/com/lambda/event/events/ButtonEvent.kt
new file mode 100644
index 000000000..034de460c
--- /dev/null
+++ b/src/main/kotlin/com/lambda/event/events/ButtonEvent.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.event.events
+
+import com.lambda.config.settings.complex.Bind
+import com.lambda.event.Event
+import com.lambda.event.callback.Cancellable
+import com.lambda.event.callback.ICancellable
+import com.lambda.util.KeyCode
+import com.lambda.util.math.Vec2d
+import org.lwjgl.glfw.GLFW.GLFW_PRESS
+import org.lwjgl.glfw.GLFW.GLFW_RELEASE
+import org.lwjgl.glfw.GLFW.GLFW_REPEAT
+
+sealed class ButtonEvent : ICancellable by Cancellable() {
+ abstract val action: Int
+ abstract val modifiers: Int
+
+ val isPressed get() = action >= GLFW_PRESS
+ val isReleased get() = action == GLFW_RELEASE
+ val isRepeated get() = action == GLFW_REPEAT
+
+ abstract fun satisfies(bind: Bind): Boolean
+
+ sealed class Mouse {
+ /**
+ * Represents a mouse click event
+ *
+ * @property button The button that was clicked
+ * @property action The action performed (e.g., press or release)
+ * @property modifiers An integer representing any modifiers (e.g., shift or ctrl) active during the event
+ */
+ data class Click(
+ val button: Int,
+ override val action: Int,
+ override val modifiers: Int,
+ ) : ButtonEvent() {
+ override fun satisfies(bind: Bind) = bind.modifiers and modifiers == bind.modifiers && bind.mouse == button
+ }
+
+ /**
+ * Represents a mouse scroll event
+ *
+ * @property delta The amount of scrolling in the x and y directions
+ */
+ data class Scroll(
+ val delta: Vec2d,
+ ) : ICancellable by Cancellable()
+
+ /**
+ * Represents a mouse move event.
+ *
+ * @property position The x and y position of the mouse on the screen.
+ */
+ data class Move(
+ val position: Vec2d,
+ ) : ICancellable by Cancellable()
+ }
+
+ sealed class Keyboard {
+ /**
+ * Represents a key press
+ *
+ * @property keyCode The key code of the key that was pressed
+ * @property scanCode The scan code of the key that was pressed
+ * @property action The action that was performed on the key (Pressed, Released)
+ * @property modifiers The modifiers that were active when the key was pressed
+ *
+ * @see About Keyboards
+ */
+ data class Press(
+ val keyCode: Int,
+ val scanCode: Int,
+ override val action: Int,
+ override val modifiers: Int,
+ ) : ButtonEvent() {
+ val bind: Bind
+ get() = Bind(translated.code, modifiers, -1)
+
+ val translated: KeyCode
+ get() = KeyCode.virtualMapUS(keyCode, scanCode)
+
+ override fun satisfies(bind: Bind) = bind.key == translated.code && bind.modifiers and modifiers == bind.modifiers
+ }
+
+ /**
+ * Represents glfwSetCharCallback events
+ *
+ * Keys and characters do not map 1:1.
+ * A single key press may produce several characters, and a single
+ * character may require several keys to produce
+ */
+ data class Char(val char: kotlin.Char) : Event
+ }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/event/events/ChatEvent.kt b/src/main/kotlin/com/lambda/event/events/ChatEvent.kt
new file mode 100644
index 000000000..aed5d57fe
--- /dev/null
+++ b/src/main/kotlin/com/lambda/event/events/ChatEvent.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.event.events
+
+import com.lambda.event.Event
+import com.lambda.event.callback.Cancellable
+import net.minecraft.client.gui.hud.MessageIndicator
+import net.minecraft.network.message.MessageSignatureData
+import net.minecraft.text.Text
+
+sealed class ChatEvent {
+ class Send(var message: String) : Event, Cancellable()
+
+ class Receive(
+ var message: Text,
+ var signature: MessageSignatureData?,
+ var indicator: MessageIndicator?,
+ ) : Event, Cancellable()
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/event/events/ContainerEvent.kt b/src/main/kotlin/com/lambda/event/events/ContainerEvent.kt
new file mode 100644
index 000000000..2c0031cb1
--- /dev/null
+++ b/src/main/kotlin/com/lambda/event/events/ContainerEvent.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.event.events
+
+import com.lambda.event.callback.Cancellable
+import com.lambda.event.callback.ICancellable
+import com.lambda.interaction.material.container.MaterialContainer
+import net.minecraft.screen.slot.Slot
+
+sealed class ContainerEvent {
+ data class Transfer(
+ val fromSlot: Slot,
+ val toSlot: Slot,
+ val from: MaterialContainer,
+ val to: MaterialContainer
+ ) : ICancellable by Cancellable()
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/lambda/event/events/InventoryEvent.kt b/src/main/kotlin/com/lambda/event/events/InventoryEvent.kt
index d8b277457..10d1e53b6 100644
--- a/src/main/kotlin/com/lambda/event/events/InventoryEvent.kt
+++ b/src/main/kotlin/com/lambda/event/events/InventoryEvent.kt
@@ -20,7 +20,6 @@ package com.lambda.event.events
import com.lambda.event.Event
import com.lambda.event.callback.Cancellable
import com.lambda.event.callback.ICancellable
-import com.lambda.interaction.managers.hotbar.HotbarRequest
import net.minecraft.item.ItemStack
import net.minecraft.screen.ScreenHandler
@@ -84,22 +83,12 @@ sealed class InventoryEvent {
) : Event
abstract class HotbarSlot : Event {
-
- data class Request(var request: HotbarRequest? = null) : HotbarSlot()
-
/**
* Represents an event triggered when the client attempts to send slot update to the server.
*
* Updated slot id will come to the server if it defers from last reported slot.
*/
- data class Update(var slot: Int) : HotbarSlot()
-
- /**
- * Represents an event triggered when the client sends slot update to the server.
- *
- * This event happens when last slot defers from the previous one
- */
- data class Changed(var slot: Int) : HotbarSlot()
+ data class Update(val slot: Int) : HotbarSlot()
/**
* Represents an event triggered when the server forces the player to change active hotbar slot.
diff --git a/src/main/kotlin/com/lambda/event/events/KeyboardEvent.kt b/src/main/kotlin/com/lambda/event/events/KeyboardEvent.kt
deleted file mode 100644
index d496c3fc0..000000000
--- a/src/main/kotlin/com/lambda/event/events/KeyboardEvent.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2025 Lambda
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-package com.lambda.event.events
-
-import com.lambda.config.settings.complex.Bind
-import com.lambda.event.Event
-import com.lambda.util.KeyCode
-import org.lwjgl.glfw.GLFW.GLFW_PRESS
-import org.lwjgl.glfw.GLFW.GLFW_RELEASE
-import org.lwjgl.glfw.GLFW.GLFW_REPEAT
-
-sealed class KeyboardEvent {
- /**
- * Represents a key press
- *
- * @property keyCode The key code of the key that was pressed
- * @property scanCode The scan code of the key that was pressed
- * @property action The action that was performed on the key (Pressed, Released)
- * @property modifiers The modifiers that were active when the key was pressed
- *
- * @see About Keyboards
- */
- data class Press(
- val keyCode: Int,
- val scanCode: Int,
- val action: Int,
- val modifiers: Int,
- ) : Event {
- val bind: Bind
- get() = Bind(translated.code, modifiers, -1)
-
- val translated: KeyCode
- get() = KeyCode.virtualMapUS(keyCode, scanCode)
-
- val isPressed = action >= GLFW_PRESS
- val isReleased = action == GLFW_RELEASE
- val isRepeated = action == GLFW_REPEAT
-
- fun satisfies(bind: Bind) = bind.key == translated.code && bind.modifiers and modifiers == bind.modifiers
- }
-
- /**
- * Represents glfwSetCharCallback events
- *
- * Keys and characters do not map 1:1.
- * A single key press may produce several characters, and a single
- * character may require several keys to produce
- */
- data class Char(val char: kotlin.Char) : Event
-}
diff --git a/src/main/kotlin/com/lambda/event/events/MouseEvent.kt b/src/main/kotlin/com/lambda/event/events/MouseEvent.kt
deleted file mode 100644
index 427969e39..000000000
--- a/src/main/kotlin/com/lambda/event/events/MouseEvent.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2025 Lambda
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-package com.lambda.event.events
-
-import com.lambda.config.settings.complex.Bind
-import com.lambda.event.callback.Cancellable
-import com.lambda.event.callback.ICancellable
-import com.lambda.util.math.Vec2d
-
-sealed class MouseEvent {
- /**
- * Represents a mouse click event
- *
- * @property button The button that was clicked
- * @property action The action performed (e.g., press or release)
- * @property modifiers An integer representing any modifiers (e.g., shift or ctrl) active during the event
- */
- data class Click(
- val button: Int,
- val action: Int,
- val modifiers: Int,
- ) : ICancellable by Cancellable() {
- val isReleased = action == 0
- val isPressed = action == 1
-
- fun satisfies(bind: Bind) = bind.modifiers and modifiers == bind.modifiers && bind.mouse == button
- }
-
- /**
- * Represents a mouse scroll event
- *
- * @property delta The amount of scrolling in the x and y directions
- */
- data class Scroll(
- val delta: Vec2d,
- ) : ICancellable by Cancellable()
-
- /**
- * Represents a mouse move event.
- *
- * @property position The x and y position of the mouse on the screen.
- */
- data class Move(
- val position: Vec2d,
- ) : ICancellable by Cancellable()
-}
diff --git a/src/main/kotlin/com/lambda/event/events/PlayerPacketEvent.kt b/src/main/kotlin/com/lambda/event/events/PlayerPacketEvent.kt
index fc3d5a8a2..58e767623 100644
--- a/src/main/kotlin/com/lambda/event/events/PlayerPacketEvent.kt
+++ b/src/main/kotlin/com/lambda/event/events/PlayerPacketEvent.kt
@@ -31,11 +31,11 @@ sealed class PlayerPacketEvent {
var onGround: Boolean,
var isSprinting: Boolean,
var isCollidingHorizontally: Boolean,
- ) : ICancellable by Cancellable()
-
- class Post : Event
+ ) : Event
data class Send(
val packet: PlayerMoveC2SPacket,
) : ICancellable by Cancellable()
+
+ class Post : Event
}
diff --git a/src/main/kotlin/com/lambda/event/events/RenderEvent.kt b/src/main/kotlin/com/lambda/event/events/RenderEvent.kt
index 812979bfa..36e2dbe37 100644
--- a/src/main/kotlin/com/lambda/event/events/RenderEvent.kt
+++ b/src/main/kotlin/com/lambda/event/events/RenderEvent.kt
@@ -22,13 +22,14 @@ import com.lambda.event.Event
import com.lambda.event.callback.Cancellable
import com.lambda.event.callback.ICancellable
import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.graphics.renderer.esp.ShapeBuilder
-import com.lambda.graphics.renderer.esp.Treed
+import com.lambda.graphics.RenderMain
+import com.lambda.graphics.mc.TransientRegionESP
-fun Any.onStaticRender(block: SafeContext.(ShapeBuilder) -> Unit) =
- listen { block(ShapeBuilder(Treed.Static.faceBuilder, Treed.Static.edgeBuilder)) }
-fun Any.onDynamicRender(block: SafeContext.(ShapeBuilder) -> Unit) =
- listen { block(ShapeBuilder(Treed.Dynamic.faceBuilder, Treed.Dynamic.edgeBuilder)) }
+fun Any.onStaticRender(block: SafeContext.(TransientRegionESP) -> Unit) =
+ listen { block(RenderMain.StaticESP) }
+
+fun Any.onDynamicRender(block: SafeContext.(TransientRegionESP) -> Unit) =
+ listen { block(RenderMain.DynamicESP) }
sealed class RenderEvent {
object Upload : Event
diff --git a/src/main/kotlin/com/lambda/friend/FriendManager.kt b/src/main/kotlin/com/lambda/friend/FriendManager.kt
index bceafea0d..171d99527 100644
--- a/src/main/kotlin/com/lambda/friend/FriendManager.kt
+++ b/src/main/kotlin/com/lambda/friend/FriendManager.kt
@@ -41,9 +41,9 @@ import java.util.*
// - Improve save file structure.
object FriendManager : Configurable(FriendConfig), Loadable {
override val name = "friends"
- val friends by setting("friends", emptySet())
+ val friends by setting("friends", emptySet(), serialize = true)
- fun befriend(profile: GameProfile) = friends.add(profile)
+ fun befriend(profile: GameProfile) = if (!isFriend(profile)) friends.add(profile) else false
fun unfriend(profile: GameProfile): Boolean = friends.remove(profile)
fun gameProfile(name: String) = friends.firstOrNull { it.name == name }
diff --git a/src/main/kotlin/com/lambda/graphics/RenderMain.kt b/src/main/kotlin/com/lambda/graphics/RenderMain.kt
index 3668298f2..1353fec6e 100644
--- a/src/main/kotlin/com/lambda/graphics/RenderMain.kt
+++ b/src/main/kotlin/com/lambda/graphics/RenderMain.kt
@@ -22,55 +22,90 @@ import com.lambda.event.EventFlow.post
import com.lambda.event.events.RenderEvent
import com.lambda.event.events.TickEvent
import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.graphics.gl.GlStateUtils.setupGL
import com.lambda.graphics.gl.Matrices
import com.lambda.graphics.gl.Matrices.resetMatrices
-import com.lambda.graphics.renderer.esp.Treed
-import com.lambda.util.math.Vec2d
-import com.mojang.blaze3d.opengl.GlStateManager
-import com.mojang.blaze3d.systems.RenderSystem
-import net.minecraft.client.gl.GlBackend
-import net.minecraft.client.texture.GlTexture
+import com.lambda.graphics.mc.TransientRegionESP
+import net.minecraft.util.math.Vec3d
import org.joml.Matrix4f
-import org.lwjgl.opengl.GL30.GL_FRAMEBUFFER
+import org.joml.Vector2f
+import org.joml.Vector4f
object RenderMain {
+ @JvmStatic
+ val StaticESP = TransientRegionESP("Static")
+
+ @JvmStatic
+ val DynamicESP = TransientRegionESP("Dynamic")
+
val projectionMatrix = Matrix4f()
- val modelViewMatrix get() = Matrices.peek()
- val projModel: Matrix4f get() = Matrix4f(projectionMatrix).mul(modelViewMatrix)
+ val modelViewMatrix
+ get() = Matrices.peek()
+ val projModel: Matrix4f
+ get() = Matrix4f(projectionMatrix).mul(modelViewMatrix)
+
+ /**
+ * Project a world position to screen coordinates. Returns null if the position is behind the
+ * camera or off-screen.
+ *
+ * @param worldPos The world position to project
+ * @return Screen coordinates (x, y) in pixels, or null if not visible
+ */
+ fun worldToScreen(worldPos: Vec3d): Vector2f? {
+ val camera = mc.gameRenderer?.camera ?: return null
+ val cameraPos = camera.pos
+
+ // Camera-relative position
+ val relX = (worldPos.x - cameraPos.x).toFloat()
+ val relY = (worldPos.y - cameraPos.y).toFloat()
+ val relZ = (worldPos.z - cameraPos.z).toFloat()
+
+ // Apply projection * modelview matrix
+ val vec = Vector4f(relX, relY, relZ, 1f)
+ projModel.transform(vec)
+
+ // Behind camera check
+ if (vec.w <= 0) return null
- var screenSize = Vec2d.ZERO
+ // Perspective divide to get NDC
+ val ndcX = vec.x / vec.w
+ val ndcY = vec.y / vec.w
+ val ndcZ = vec.z / vec.w
+
+ // Off-screen check (NDC is -1 to 1)
+ if (ndcZ < -1 || ndcZ > 1) return null
+
+ // NDC to screen coordinates (Y is flipped in screen space)
+ val window = mc.window
+ val screenX = (ndcX + 1f) * 0.5f * window.framebufferWidth
+ val screenY = (1f - ndcY) * 0.5f * window.framebufferHeight
+
+ return Vector2f(screenX, screenY)
+ }
+
+ /** Check if a world position is visible on screen. */
+ fun isOnScreen(worldPos: Vec3d): Boolean = worldToScreen(worldPos) != null
@JvmStatic
fun render3D(positionMatrix: Matrix4f, projMatrix: Matrix4f) {
resetMatrices(positionMatrix)
projectionMatrix.set(projMatrix)
- setupGL {
- val framebuffer = mc.framebuffer
- val prevFramebuffer = (framebuffer.getColorAttachment() as GlTexture).getOrCreateFramebuffer(
- (RenderSystem.getDevice() as GlBackend).framebufferManager,
- null
- )
-
- GlStateManager._glBindFramebuffer(GL_FRAMEBUFFER, prevFramebuffer)
+ // Render transient ESPs using the new pipeline
+ StaticESP.render() // Uses internal depthTest flag (true)
+ DynamicESP.render() // Uses internal depthTest flag (false)
- Treed.Static.render()
- Treed.Dynamic.render()
-
- RenderEvent.Render.post()
- }
+ RenderEvent.Render.post()
}
init {
listen {
- Treed.Static.clear()
- Treed.Dynamic.clear()
+ StaticESP.clear()
+ DynamicESP.clear()
RenderEvent.Upload.post()
- Treed.Static.upload()
- Treed.Dynamic.upload()
+ StaticESP.upload()
+ DynamicESP.upload()
}
}
}
diff --git a/src/main/kotlin/com/lambda/graphics/renderer/gui/font/core/LambdaFont.kt b/src/main/kotlin/com/lambda/graphics/esp/EspDsl.kt
similarity index 64%
rename from src/main/kotlin/com/lambda/graphics/renderer/gui/font/core/LambdaFont.kt
rename to src/main/kotlin/com/lambda/graphics/esp/EspDsl.kt
index dd08deb2c..0c0a19a3f 100644
--- a/src/main/kotlin/com/lambda/graphics/renderer/gui/font/core/LambdaFont.kt
+++ b/src/main/kotlin/com/lambda/graphics/esp/EspDsl.kt
@@ -15,16 +15,18 @@
* along with this program. If not, see .
*/
-package com.lambda.graphics.renderer.gui.font.core
+package com.lambda.graphics.esp
-import com.lambda.graphics.renderer.gui.font.core.LambdaAtlas.buildBuffer
+import com.lambda.graphics.mc.ChunkedRegionESP
+import com.lambda.module.Module
-enum class LambdaFont(val fontName: String) {
- FiraSansRegular("FiraSans-Regular"),
- FiraSansBold("FiraSans-Bold");
+@DslMarker
+annotation class EspDsl
- fun load(): String {
- entries.forEach { it.buildBuffer() }
- return "Loaded ${entries.size} fonts"
- }
+fun Module.chunkedEsp(
+ name: String,
+ depthTest: Boolean = false,
+ update: ShapeScope.(net.minecraft.world.World, com.lambda.util.world.FastVector) -> Unit
+): ChunkedRegionESP {
+ return ChunkedRegionESP(this, name, depthTest, update)
}
diff --git a/src/main/kotlin/com/lambda/graphics/esp/RegionESP.kt b/src/main/kotlin/com/lambda/graphics/esp/RegionESP.kt
new file mode 100644
index 000000000..b32e03755
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/esp/RegionESP.kt
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.esp
+
+import com.lambda.Lambda.mc
+import com.lambda.graphics.mc.LambdaRenderPipelines
+import com.lambda.graphics.mc.RegionRenderer
+import com.lambda.graphics.mc.RenderRegion
+import com.lambda.util.extension.tickDelta
+import com.mojang.blaze3d.systems.RenderSystem
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.floor
+import org.joml.Matrix4f
+import org.joml.Vector3f
+import org.joml.Vector4f
+
+/**
+ * Base class for region-based ESP systems. Provides unified rendering logic and region management.
+ */
+abstract class RegionESP(val name: String, val depthTest: Boolean) {
+ protected val renderers = ConcurrentHashMap()
+
+ /** Get or create a ShapeScope for a specific world position. */
+ open fun shapes(x: Double, y: Double, z: Double, block: ShapeScope.() -> Unit) {}
+
+ /** Upload collected geometry to GPU. Must be called on main thread. */
+ open fun upload() {}
+
+ /** Clear all geometry data. */
+ abstract fun clear()
+
+ /** Close and release all GPU resources. */
+ open fun close() {
+ renderers.values.forEach { it.close() }
+ renderers.clear()
+ clear()
+ }
+
+ /**
+ * Render all active regions.
+ * @param tickDelta Progress within current tick (used for interpolation)
+ */
+ open fun render(tickDelta: Float = mc.tickDelta) {
+ val camera = mc.gameRenderer?.camera ?: return
+ val cameraPos = camera.pos
+
+ val activeRenderers = renderers.values.filter { it.hasData() }
+ if (activeRenderers.isEmpty()) return
+
+ val modelViewMatrix = com.lambda.graphics.RenderMain.modelViewMatrix
+ val transforms = activeRenderers.map { renderer ->
+ val offset = renderer.region.computeCameraRelativeOffset(cameraPos)
+ val modelView = Matrix4f(modelViewMatrix).translate(offset)
+
+ val dynamicTransform = RenderSystem.getDynamicUniforms()
+ .write(
+ modelView,
+ Vector4f(1f, 1f, 1f, 1f),
+ Vector3f(0f, 0f, 0f),
+ Matrix4f()
+ )
+ renderer to dynamicTransform
+ }
+
+ // Render Faces
+ RegionRenderer.createRenderPass("$name Faces")?.use { pass ->
+ val pipeline =
+ if (depthTest) LambdaRenderPipelines.ESP_QUADS
+ else LambdaRenderPipelines.ESP_QUADS_THROUGH
+ pass.setPipeline(pipeline)
+ RenderSystem.bindDefaultUniforms(pass)
+ transforms.forEach { (renderer, transform) ->
+ pass.setUniform("DynamicTransforms", transform)
+ renderer.renderFaces(pass)
+ }
+ }
+
+ // Render Edges
+ RegionRenderer.createRenderPass("$name Edges")?.use { pass ->
+ val pipeline =
+ if (depthTest) LambdaRenderPipelines.ESP_LINES
+ else LambdaRenderPipelines.ESP_LINES_THROUGH
+ pass.setPipeline(pipeline)
+ RenderSystem.bindDefaultUniforms(pass)
+ transforms.forEach { (renderer, transform) ->
+ pass.setUniform("DynamicTransforms", transform)
+ renderer.renderEdges(pass)
+ }
+ }
+ }
+
+ /**
+ * Compute a unique key for a region based on its coordinates. Prevents collisions between
+ * regions at different Y levels.
+ */
+ protected fun getRegionKey(x: Double, y: Double, z: Double): Long {
+ val rx = (RenderRegion.REGION_SIZE * floor(x / RenderRegion.REGION_SIZE)).toInt()
+ val ry = (RenderRegion.REGION_SIZE * floor(y / RenderRegion.REGION_SIZE)).toInt()
+ val rz = (RenderRegion.REGION_SIZE * floor(z / RenderRegion.REGION_SIZE)).toInt()
+
+ return getRegionKey(rx, ry, rz)
+ }
+
+ protected fun getRegionKey(rx: Int, ry: Int, rz: Int): Long {
+ // 20 bits for X, 20 bits for Z, 24 bits for Y (total 64)
+ // This supports +- 500k blocks in X/Z and full Y range
+ return (rx.toLong() and 0xFFFFF) or
+ ((rz.toLong() and 0xFFFFF) shl 20) or
+ ((ry.toLong() and 0xFFFFFF) shl 40)
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/esp/ShapeScope.kt b/src/main/kotlin/com/lambda/graphics/esp/ShapeScope.kt
new file mode 100644
index 000000000..14ab277f5
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/esp/ShapeScope.kt
@@ -0,0 +1,416 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.esp
+
+import com.lambda.graphics.mc.RegionShapeBuilder
+import com.lambda.graphics.mc.RegionVertexCollector
+import com.lambda.graphics.mc.RenderRegion
+import com.lambda.graphics.renderer.esp.DirectionMask
+import com.lambda.graphics.renderer.esp.DynamicAABB
+import net.minecraft.block.BlockState
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
+import net.minecraft.util.math.MathHelper
+import net.minecraft.util.math.Vec3d
+import net.minecraft.util.shape.VoxelShape
+import java.awt.Color
+
+@EspDsl
+class ShapeScope(val region: RenderRegion, val collectShapes: Boolean = false) {
+ internal val builder = RegionShapeBuilder(region)
+ internal val shapes = if (collectShapes) mutableListOf() else null
+
+ /** Start building a box. */
+ fun box(box: Box, id: Any? = null, block: BoxScope.() -> Unit) {
+ val scope = BoxScope(box, this)
+ scope.apply(block)
+ if (collectShapes) {
+ shapes?.add(
+ EspShape.BoxShape(
+ id?.hashCode() ?: box.hashCode(),
+ box,
+ scope.filledColor,
+ scope.outlineColor,
+ scope.sides,
+ scope.outlineMode,
+ scope.thickness
+ )
+ )
+ }
+ }
+
+ /** Draw a line between two points. */
+ fun line(start: Vec3d, end: Vec3d, color: Color, width: Float = 1.0f, id: Any? = null) {
+ builder.line(start, end, color, width)
+ if (collectShapes) {
+ shapes?.add(
+ EspShape.LineShape(
+ id?.hashCode() ?: (start.hashCode() xor end.hashCode()),
+ start,
+ end,
+ color,
+ width
+ )
+ )
+ }
+ }
+
+ /** Draw a tracer. */
+ fun tracer(from: Vec3d, to: Vec3d, id: Any? = null, block: LineScope.() -> Unit = {}) {
+ val scope = LineScope(from, to, this)
+ scope.apply(block)
+ scope.draw()
+ if (collectShapes) {
+ shapes?.add(
+ EspShape.LineShape(
+ id?.hashCode() ?: (from.hashCode() xor to.hashCode()),
+ from,
+ to,
+ scope.lineColor,
+ scope.lineWidth,
+ scope.lineDashLength,
+ scope.lineGapLength
+ )
+ )
+ }
+ }
+
+ /** Draw a simple filled box. */
+ fun filled(box: Box, color: Color, sides: Int = DirectionMask.ALL) {
+ builder.filled(box, color, sides)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(box.hashCode(), box, color, null, sides))
+ }
+ }
+
+ /** Draw a simple outlined box. */
+ fun outline(box: Box, color: Color, sides: Int = DirectionMask.ALL, thickness: Float = builder.lineWidth) {
+ builder.outline(box, color, sides, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(box.hashCode(), box, null, color, sides, thickness = thickness))
+ }
+ }
+
+ fun filled(box: DynamicAABB, color: Color, sides: Int = DirectionMask.ALL) {
+ builder.filled(box, color, sides)
+ if (collectShapes) {
+ box.pair?.second?.let {
+ shapes?.add(EspShape.BoxShape(it.hashCode(), it, color, null, sides))
+ }
+ }
+ }
+
+ fun outline(box: DynamicAABB, color: Color, sides: Int = DirectionMask.ALL, thickness: Float = builder.lineWidth) {
+ builder.outline(box, color, sides, thickness = thickness)
+ if (collectShapes) {
+ box.pair?.second?.let {
+ shapes?.add(EspShape.BoxShape(it.hashCode(), it, null, color, sides, thickness = thickness))
+ }
+ }
+ }
+
+ fun filled(pos: BlockPos, color: Color, sides: Int = DirectionMask.ALL) {
+ builder.filled(pos, color, sides)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), color, null, sides))
+ }
+ }
+
+ fun outline(pos: BlockPos, color: Color, sides: Int = DirectionMask.ALL, thickness: Float = builder.lineWidth) {
+ builder.outline(pos, color, sides, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), null, color, sides, thickness = thickness))
+ }
+ }
+
+ fun filled(pos: BlockPos, state: BlockState, color: Color, sides: Int = DirectionMask.ALL) {
+ builder.filled(pos, state, color, sides)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), color, null, sides))
+ }
+ }
+
+ fun outline(pos: BlockPos, state: BlockState, color: Color, sides: Int = DirectionMask.ALL, thickness: Float = builder.lineWidth) {
+ builder.outline(pos, state, color, sides, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), null, color, sides, thickness = thickness))
+ }
+ }
+
+ fun filled(shape: VoxelShape, color: Color, sides: Int = DirectionMask.ALL) {
+ builder.filled(shape, color, sides)
+ if (collectShapes) {
+ shape.boundingBoxes.forEach {
+ shapes?.add(EspShape.BoxShape(it.hashCode(), it, color, null, sides))
+ }
+ }
+ }
+
+ fun outline(shape: VoxelShape, color: Color, sides: Int = DirectionMask.ALL, thickness: Float = builder.lineWidth) {
+ builder.outline(shape, color, sides, thickness = thickness)
+ if (collectShapes) {
+ shape.boundingBoxes.forEach {
+ shapes?.add(EspShape.BoxShape(it.hashCode(), it, null, color, sides, thickness = thickness))
+ }
+ }
+ }
+
+ fun box(
+ pos: BlockPos,
+ state: BlockState,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(pos, state, filled, outline, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), filled, outline, sides, mode, thickness = thickness))
+ }
+ }
+
+ fun box(
+ pos: BlockPos,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(pos, filled, outline, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(pos.hashCode(), Box(pos), filled, outline, sides, mode, thickness = thickness))
+ }
+ }
+
+ fun box(
+ box: Box,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(box, filledColor, outlineColor, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(EspShape.BoxShape(box.hashCode(), box, filledColor, outlineColor, sides, mode, thickness = thickness))
+ }
+ }
+
+ fun box(
+ box: DynamicAABB,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(box, filledColor, outlineColor, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ box.pair?.second?.let {
+ shapes?.add(
+ EspShape.BoxShape(it.hashCode(), it, filledColor, outlineColor, sides, mode, thickness = thickness)
+ )
+ }
+ }
+ }
+
+ fun box(
+ entity: net.minecraft.block.entity.BlockEntity,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(entity, filled, outline, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(
+ EspShape.BoxShape(
+ entity.pos.hashCode(),
+ Box(entity.pos),
+ filled,
+ outline,
+ sides,
+ mode,
+ thickness = thickness
+ )
+ )
+ }
+ }
+
+ fun box(
+ entity: net.minecraft.entity.Entity,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = builder.lineWidth
+ ) {
+ builder.box(entity, filled, outline, sides, mode, thickness = thickness)
+ if (collectShapes) {
+ shapes?.add(
+ EspShape.BoxShape(
+ entity.hashCode(),
+ entity.boundingBox,
+ filled,
+ outline,
+ sides,
+ mode,
+ thickness = thickness
+ )
+ )
+ }
+ }
+}
+
+@EspDsl
+class BoxScope(val box: Box, val parent: ShapeScope) {
+ internal var filledColor: Color? = null
+ internal var outlineColor: Color? = null
+ internal var sides: Int = DirectionMask.ALL
+ internal var outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And
+ internal var thickness: Float = parent.builder.lineWidth
+
+ fun filled(color: Color, sides: Int = DirectionMask.ALL) {
+ this.filledColor = color
+ this.sides = sides
+ parent.builder.filled(box, color, sides)
+ }
+
+ fun outline(
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = parent.builder.lineWidth
+ ) {
+ this.outlineColor = color
+ this.sides = sides
+ this.outlineMode = mode
+ this.thickness = thickness
+ parent.builder.outline(box, color, sides, mode, thickness = thickness)
+ }
+}
+
+@EspDsl
+class LineScope(val from: Vec3d, val to: Vec3d, val parent: ShapeScope) {
+ internal var lineColor: Color = Color.WHITE
+ internal var lineWidth: Float = 1.0f
+ internal var lineDashLength: Double? = null
+ internal var lineGapLength: Double? = null
+
+ fun color(color: Color) {
+ this.lineColor = color
+ }
+
+ fun width(width: Float) {
+ this.lineWidth = width
+ }
+
+ fun dashed(dashLength: Double = 0.5, gapLength: Double = 0.25) {
+ this.lineDashLength = dashLength
+ this.lineGapLength = gapLength
+ }
+
+ internal fun draw() {
+ val dLen = lineDashLength
+ val gLen = lineGapLength
+
+ if (dLen != null && gLen != null) {
+ parent.builder.dashedLine(from, to, lineColor, dLen, gLen, lineWidth)
+ } else {
+ parent.builder.line(from, to, lineColor, lineWidth)
+ }
+ }
+}
+
+sealed class EspShape(val id: Int) {
+ abstract fun renderInterpolated(
+ prev: EspShape,
+ tickDelta: Float,
+ collector: RegionVertexCollector,
+ region: RenderRegion
+ )
+
+ class BoxShape(
+ id: Int,
+ val box: Box,
+ val filledColor: Color?,
+ val outlineColor: Color?,
+ val sides: Int = DirectionMask.ALL,
+ val outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ val thickness: Float = 1.0f
+ ) : EspShape(id) {
+ override fun renderInterpolated(
+ prev: EspShape,
+ tickDelta: Float,
+ collector: RegionVertexCollector,
+ region: RenderRegion
+ ) {
+ val interpBox =
+ if (prev is BoxShape) {
+ Box(
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.minX, box.minX),
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.minY, box.minY),
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.minZ, box.minZ),
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.maxX, box.maxX),
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.maxY, box.maxY),
+ MathHelper.lerp(tickDelta.toDouble(), prev.box.maxZ, box.maxZ)
+ )
+ } else box
+
+ val shapeBuilder = RegionShapeBuilder(region)
+ filledColor?.let { shapeBuilder.filled(interpBox, it, sides) }
+ outlineColor?.let { shapeBuilder.outline(interpBox, it, sides, outlineMode, thickness = thickness) }
+
+ collector.faceVertices.addAll(shapeBuilder.collector.faceVertices)
+ collector.edgeVertices.addAll(shapeBuilder.collector.edgeVertices)
+ }
+ }
+
+ class LineShape(
+ id: Int,
+ val from: Vec3d,
+ val to: Vec3d,
+ val color: Color,
+ val width: Float,
+ val dashLength: Double? = null,
+ val gapLength: Double? = null
+ ) : EspShape(id) {
+ override fun renderInterpolated(
+ prev: EspShape,
+ tickDelta: Float,
+ collector: RegionVertexCollector,
+ region: RenderRegion
+ ) {
+ val iFrom = if (prev is LineShape) prev.from.lerp(from, tickDelta.toDouble()) else from
+ val iTo = if (prev is LineShape) prev.to.lerp(to, tickDelta.toDouble()) else to
+
+ val shapeBuilder = RegionShapeBuilder(region)
+ if (dashLength != null && gapLength != null) {
+ shapeBuilder.dashedLine(iFrom, iTo, color, dashLength, gapLength, width)
+ } else {
+ shapeBuilder.line(iFrom, iTo, color, width)
+ }
+
+ collector.faceVertices.addAll(shapeBuilder.collector.faceVertices)
+ collector.edgeVertices.addAll(shapeBuilder.collector.edgeVertices)
+ }
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/gl/GlStateUtils.kt b/src/main/kotlin/com/lambda/graphics/gl/GlStateUtils.kt
index 77b830aca..c8e57ef5f 100644
--- a/src/main/kotlin/com/lambda/graphics/gl/GlStateUtils.kt
+++ b/src/main/kotlin/com/lambda/graphics/gl/GlStateUtils.kt
@@ -30,6 +30,7 @@ import org.lwjgl.opengl.GL30C.glDisable
import org.lwjgl.opengl.GL30C.glEnable
import org.lwjgl.opengl.GL30C.glLineWidth
+// ToDo: Migrate particle system so we can remove this
object GlStateUtils {
private var depthTestState = true
private var blendState = false
diff --git a/src/main/kotlin/com/lambda/graphics/mc/ChunkedRegionESP.kt b/src/main/kotlin/com/lambda/graphics/mc/ChunkedRegionESP.kt
new file mode 100644
index 000000000..d367694a5
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/ChunkedRegionESP.kt
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.event.events.RenderEvent
+import com.lambda.event.events.TickEvent
+import com.lambda.event.events.WorldEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.event.listener.SafeListener.Companion.listenConcurrently
+import com.lambda.graphics.esp.RegionESP
+import com.lambda.graphics.esp.ShapeScope
+import com.lambda.module.Module
+import com.lambda.module.modules.client.StyleEditor
+import com.lambda.threading.runSafe
+import com.lambda.util.world.FastVector
+import com.lambda.util.world.fastVectorOf
+import net.minecraft.world.World
+import net.minecraft.world.chunk.WorldChunk
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedDeque
+
+/**
+ * Region-based chunked ESP system using MC 1.21.11's new render pipeline.
+ *
+ * This system:
+ * - Uses region-relative coordinates for precision-safe rendering
+ * - Maintains per-chunk geometry for efficient updates
+ *
+ * @param owner The module that owns this ESP system
+ * @param name The name of the ESP system
+ * @param depthTest Whether to use depth testing
+ * @param update The update function called for each block position
+ */
+class ChunkedRegionESP(
+ owner: Module,
+ name: String,
+ depthTest: Boolean = false,
+ private val update: ShapeScope.(World, FastVector) -> Unit
+) : RegionESP(name, depthTest) {
+ private val chunkMap = ConcurrentHashMap()
+
+ private val WorldChunk.regionChunk
+ get() = chunkMap.getOrPut(getRegionKey(pos.x shl 4, bottomY, pos.z shl 4)) {
+ RegionChunk(this)
+ }
+
+ private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
+ private val rebuildQueue = ConcurrentLinkedDeque()
+
+ /** Mark all tracked chunks for rebuild. */
+ fun rebuild() {
+ rebuildQueue.clear()
+ rebuildQueue.addAll(chunkMap.values)
+ }
+
+ /**
+ * Load all currently loaded world chunks and mark them for rebuild. Call this when the module
+ * is enabled to populate initial chunks.
+ */
+ fun rebuildAll() {
+ runSafe {
+ val chunksArray = world.chunkManager.chunks.chunks
+ (0 until chunksArray.length()).forEach { i ->
+ chunksArray.get(i)?.regionChunk?.markDirty()
+ }
+ }
+ }
+
+ override fun clear() {
+ chunkMap.values.forEach { it.close() }
+ chunkMap.clear()
+ rebuildQueue.clear()
+ uploadQueue.clear()
+ }
+
+ init {
+ owner.listen { event ->
+ val pos = event.pos
+ world.getWorldChunk(pos)?.regionChunk?.markDirty()
+
+ val xInChunk = pos.x and 15
+ val zInChunk = pos.z and 15
+
+ if (xInChunk == 0) world.getWorldChunk(pos.west())?.regionChunk?.markDirty()
+ if (xInChunk == 15) world.getWorldChunk(pos.east())?.regionChunk?.markDirty()
+ if (zInChunk == 0) world.getWorldChunk(pos.north())?.regionChunk?.markDirty()
+ if (zInChunk == 15) world.getWorldChunk(pos.south())?.regionChunk?.markDirty()
+ }
+
+ owner.listen { event -> event.chunk.regionChunk.markDirty() }
+
+ owner.listen {
+ val pos = getRegionKey(it.chunk.pos.x shl 4, it.chunk.bottomY, it.chunk.pos.z shl 4)
+ chunkMap.remove(pos)?.close()
+ }
+
+ owner.listenConcurrently {
+ val queueSize = rebuildQueue.size
+ val polls = minOf(StyleEditor.rebuildsPerTick, queueSize)
+ repeat(polls) { rebuildQueue.poll()?.rebuild() }
+ }
+
+ owner.listen {
+ val polls = minOf(StyleEditor.uploadsPerTick, uploadQueue.size)
+ repeat(polls) { uploadQueue.poll()?.invoke() }
+ }
+
+ owner.listen { render() }
+ }
+
+ /** Per-chunk rendering data. */
+ private inner class RegionChunk(val chunk: WorldChunk) {
+ val region = RenderRegion.forChunk(chunk.pos.x, chunk.pos.z, chunk.bottomY)
+ private val key = getRegionKey(chunk.pos.x shl 4, chunk.bottomY, chunk.pos.z shl 4)
+
+ private var isDirty = false
+
+ fun markDirty() {
+ isDirty = true
+ if (!rebuildQueue.contains(this)) {
+ rebuildQueue.add(this)
+ }
+ }
+
+ fun rebuild() {
+ if (!isDirty) return
+ val scope = ShapeScope(region)
+
+ for (x in chunk.pos.startX..chunk.pos.endX) {
+ for (z in chunk.pos.startZ..chunk.pos.endZ) {
+ for (y in chunk.bottomY..chunk.height) {
+ update(scope, chunk.world, fastVectorOf(x, y, z))
+ }
+ }
+ }
+
+ uploadQueue.add {
+ val renderer = renderers.getOrPut(key) { RegionRenderer(region) }
+ renderer.upload(scope.builder.collector)
+ isDirty = false
+ }
+ }
+
+ fun close() {
+ renderers.remove(key)?.close()
+ }
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/CurveUtils.kt b/src/main/kotlin/com/lambda/graphics/mc/CurveUtils.kt
new file mode 100644
index 000000000..2cf2b1ddc
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/CurveUtils.kt
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import net.minecraft.util.math.MathHelper
+import net.minecraft.util.math.Vec3d
+
+/**
+ * Utility functions for curve and spline calculations.
+ *
+ * Provides Bezier curves and Catmull-Rom splines for smooth
+ * trajectory rendering and path visualization.
+ */
+object CurveUtils {
+
+ /**
+ * Linear interpolation between two points.
+ */
+ fun lerp(t: Double, p0: Vec3d, p1: Vec3d): Vec3d {
+ return Vec3d(
+ MathHelper.lerp(t, p0.x, p1.x),
+ MathHelper.lerp(t, p0.y, p1.y),
+ MathHelper.lerp(t, p0.z, p1.z)
+ )
+ }
+
+ /**
+ * Quadratic Bezier curve.
+ *
+ * B(t) = (1-t)²P0 + 2(1-t)tP1 + t²P2
+ *
+ * @param t Parameter from 0.0 to 1.0
+ * @param p0 Start point
+ * @param p1 Control point
+ * @param p2 End point
+ */
+ fun quadraticBezier(t: Double, p0: Vec3d, p1: Vec3d, p2: Vec3d): Vec3d {
+ val mt = 1.0 - t
+ val mt2 = mt * mt
+ val t2 = t * t
+
+ return Vec3d(
+ mt2 * p0.x + 2 * mt * t * p1.x + t2 * p2.x,
+ mt2 * p0.y + 2 * mt * t * p1.y + t2 * p2.y,
+ mt2 * p0.z + 2 * mt * t * p1.z + t2 * p2.z
+ )
+ }
+
+ /**
+ * Cubic Bezier curve.
+ *
+ * B(t) = (1-t)³P0 + 3(1-t)²tP1 + 3(1-t)t²P2 + t³P3
+ *
+ * @param t Parameter from 0.0 to 1.0
+ * @param p0 Start point
+ * @param p1 First control point
+ * @param p2 Second control point
+ * @param p3 End point
+ */
+ fun cubicBezier(t: Double, p0: Vec3d, p1: Vec3d, p2: Vec3d, p3: Vec3d): Vec3d {
+ val mt = 1.0 - t
+ val mt2 = mt * mt
+ val mt3 = mt2 * mt
+ val t2 = t * t
+ val t3 = t2 * t
+
+ return Vec3d(
+ mt3 * p0.x + 3 * mt2 * t * p1.x + 3 * mt * t2 * p2.x + t3 * p3.x,
+ mt3 * p0.y + 3 * mt2 * t * p1.y + 3 * mt * t2 * p2.y + t3 * p3.y,
+ mt3 * p0.z + 3 * mt2 * t * p1.z + 3 * mt * t2 * p2.z + t3 * p3.z
+ )
+ }
+
+ /**
+ * Catmull-Rom spline interpolation.
+ *
+ * Unlike Bezier curves, Catmull-Rom splines pass through all control points.
+ * Uses MC's built-in catmullRom function.
+ *
+ * @param t Parameter from 0.0 to 1.0 (interpolates between p1 and p2)
+ * @param p0 Point before the segment
+ * @param p1 Start of segment
+ * @param p2 End of segment
+ * @param p3 Point after the segment
+ */
+ fun catmullRom(t: Float, p0: Vec3d, p1: Vec3d, p2: Vec3d, p3: Vec3d): Vec3d {
+ return Vec3d(
+ MathHelper.catmullRom(t, p0.x.toFloat(), p1.x.toFloat(), p2.x.toFloat(), p3.x.toFloat()).toDouble(),
+ MathHelper.catmullRom(t, p0.y.toFloat(), p1.y.toFloat(), p2.y.toFloat(), p3.y.toFloat()).toDouble(),
+ MathHelper.catmullRom(t, p0.z.toFloat(), p1.z.toFloat(), p2.z.toFloat(), p3.z.toFloat()).toDouble()
+ )
+ }
+
+ /**
+ * Generate points along a quadratic Bezier curve.
+ *
+ * @param p0 Start point
+ * @param p1 Control point
+ * @param p2 End point
+ * @param segments Number of line segments
+ * @return List of points along the curve
+ */
+ fun quadraticBezierPoints(p0: Vec3d, p1: Vec3d, p2: Vec3d, segments: Int): List {
+ return (0..segments).map { i ->
+ val t = i.toDouble() / segments
+ quadraticBezier(t, p0, p1, p2)
+ }
+ }
+
+ /**
+ * Generate points along a cubic Bezier curve.
+ *
+ * @param p0 Start point
+ * @param p1 First control point
+ * @param p2 Second control point
+ * @param p3 End point
+ * @param segments Number of line segments
+ * @return List of points along the curve
+ */
+ fun cubicBezierPoints(p0: Vec3d, p1: Vec3d, p2: Vec3d, p3: Vec3d, segments: Int): List {
+ return (0..segments).map { i ->
+ val t = i.toDouble() / segments
+ cubicBezier(t, p0, p1, p2, p3)
+ }
+ }
+
+ /**
+ * Generate points along a Catmull-Rom spline that passes through all control points.
+ *
+ * @param controlPoints List of points the spline should pass through (minimum 4)
+ * @param segmentsPerSection Number of segments between each pair of control points
+ * @return List of points along the spline
+ */
+ fun catmullRomSplinePoints(controlPoints: List, segmentsPerSection: Int): List {
+ if (controlPoints.size < 4) return controlPoints
+
+ val result = mutableListOf()
+
+ for (i in 1 until controlPoints.size - 2) {
+ val p0 = controlPoints[i - 1]
+ val p1 = controlPoints[i]
+ val p2 = controlPoints[i + 1]
+ val p3 = controlPoints[i + 2]
+
+ for (j in 0 until segmentsPerSection) {
+ val t = j.toFloat() / segmentsPerSection
+ result.add(catmullRom(t, p0, p1, p2, p3))
+ }
+ }
+
+ // Add the last point
+ result.add(controlPoints[controlPoints.size - 2])
+
+ return result
+ }
+
+ /**
+ * Estimate the arc length of a cubic Bezier curve using subdivision.
+ *
+ * @param p0 Start point
+ * @param p1 First control point
+ * @param p2 Second control point
+ * @param p3 End point
+ * @param subdivisions Number of subdivisions for estimation
+ */
+ fun cubicBezierLength(p0: Vec3d, p1: Vec3d, p2: Vec3d, p3: Vec3d, subdivisions: Int = 32): Double {
+ var length = 0.0
+ var prev = p0
+
+ for (i in 1..subdivisions) {
+ val t = i.toDouble() / subdivisions
+ val curr = cubicBezier(t, p0, p1, p2, p3)
+ length += prev.distanceTo(curr)
+ prev = curr
+ }
+
+ return length
+ }
+
+ /**
+ * Calculate the tangent (direction) at a point on a cubic Bezier curve.
+ *
+ * B'(t) = 3(1-t)²(P1-P0) + 6(1-t)t(P2-P1) + 3t²(P3-P2)
+ *
+ * @param t Parameter from 0.0 to 1.0
+ * @param p0 Start point
+ * @param p1 First control point
+ * @param p2 Second control point
+ * @param p3 End point
+ * @return Normalized tangent vector
+ */
+ fun cubicBezierTangent(t: Double, p0: Vec3d, p1: Vec3d, p2: Vec3d, p3: Vec3d): Vec3d {
+ val mt = 1.0 - t
+ val mt2 = mt * mt
+ val t2 = t * t
+
+ val d1 = p1.subtract(p0)
+ val d2 = p2.subtract(p1)
+ val d3 = p3.subtract(p2)
+
+ return Vec3d(
+ 3 * mt2 * d1.x + 6 * mt * t * d2.x + 3 * t2 * d3.x,
+ 3 * mt2 * d1.y + 6 * mt * t * d2.y + 3 * t2 * d3.y,
+ 3 * mt2 * d1.z + 6 * mt * t * d2.z + 3 * t2 * d3.z
+ ).normalize()
+ }
+
+ /**
+ * Create a smooth path through waypoints using Catmull-Rom splines.
+ * Automatically handles the first and last points by duplicating them.
+ *
+ * @param waypoints List of points to pass through (minimum 2)
+ * @param segmentsPerSection Smoothness (higher = smoother)
+ */
+ fun smoothPath(waypoints: List, segmentsPerSection: Int = 16): List {
+ if (waypoints.size < 2) return waypoints
+ if (waypoints.size == 2) return listOf(waypoints[0], waypoints[1])
+
+ // Extend with phantom points for natural curve at endpoints
+ val extended = buildList {
+ // Mirror first point
+ add(waypoints[0].add(waypoints[0].subtract(waypoints[1])))
+ addAll(waypoints)
+ // Mirror last point
+ val last = waypoints.last()
+ val secondLast = waypoints[waypoints.size - 2]
+ add(last.add(last.subtract(secondLast)))
+ }
+
+ return catmullRomSplinePoints(extended, segmentsPerSection)
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/ImGuiWorldText.kt b/src/main/kotlin/com/lambda/graphics/mc/ImGuiWorldText.kt
new file mode 100644
index 000000000..735f17de1
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/ImGuiWorldText.kt
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.graphics.RenderMain
+import imgui.ImGui
+import imgui.ImVec2
+import net.minecraft.util.math.Vec3d
+import java.awt.Color
+
+/**
+ * ImGUI-based world text renderer.
+ * Projects world coordinates to screen space and draws text using ImGUI.
+ *
+ * Usage:
+ * ```kotlin
+ * // In a GuiEvent.NewFrame listener
+ * ImGuiWorldText.drawText(entity.pos, "Label", Color.WHITE)
+ * ```
+ */
+object ImGuiWorldText {
+
+ /**
+ * Draw text at a world position using ImGUI.
+ *
+ * @param worldPos World position for the text
+ * @param text The text to render
+ * @param color Text color
+ * @param centered Whether to center the text horizontally
+ * @param offsetY Vertical offset in screen pixels (negative = up)
+ */
+ fun drawText(
+ worldPos: Vec3d,
+ text: String,
+ color: Color = Color.WHITE,
+ centered: Boolean = true,
+ offsetY: Float = 0f
+ ) {
+ val screen = RenderMain.worldToScreen(worldPos) ?: return
+
+ val drawList = ImGui.getBackgroundDrawList()
+ val colorInt = colorToImGui(color)
+
+ val x = if (centered) {
+ val textSize = ImVec2()
+ ImGui.calcTextSize(textSize, text)
+ screen.x - textSize.x / 2f
+ } else {
+ screen.x
+ }
+
+ drawList.addText(x, screen.y + offsetY, colorInt, text)
+ }
+
+ /**
+ * Draw text with a shadow/outline effect.
+ */
+ fun drawTextWithShadow(
+ worldPos: Vec3d,
+ text: String,
+ color: Color = Color.WHITE,
+ shadowColor: Color = Color.BLACK,
+ centered: Boolean = true,
+ offsetY: Float = 0f
+ ) {
+ val screen = RenderMain.worldToScreen(worldPos) ?: return
+
+ val drawList = ImGui.getBackgroundDrawList()
+ val textSize = ImVec2()
+ ImGui.calcTextSize(textSize, text)
+
+ val x = if (centered) screen.x - textSize.x / 2f else screen.x
+ val y = screen.y + offsetY
+
+ // Draw shadow (offset by 1 pixel)
+ val shadowInt = colorToImGui(shadowColor)
+ drawList.addText(x + 1f, y + 1f, shadowInt, text)
+
+ // Draw main text
+ val colorInt = colorToImGui(color)
+ drawList.addText(x, y, colorInt, text)
+ }
+
+ /**
+ * Draw multiple lines of text stacked vertically.
+ */
+ fun drawMultilineText(
+ worldPos: Vec3d,
+ lines: List,
+ color: Color = Color.WHITE,
+ centered: Boolean = true,
+ lineSpacing: Float = 12f,
+ offsetY: Float = 0f
+ ) {
+ val screen = RenderMain.worldToScreen(worldPos) ?: return
+
+ val drawList = ImGui.getBackgroundDrawList()
+ val colorInt = colorToImGui(color)
+
+ lines.forEachIndexed { index, line ->
+ val textSize = ImVec2()
+ ImGui.calcTextSize(textSize, line)
+
+ val x = if (centered) screen.x - textSize.x / 2f else screen.x
+ val y = screen.y + offsetY + (index * lineSpacing)
+
+ drawList.addText(x, y, colorInt, line)
+ }
+ }
+
+ /**
+ * Draw text with a background box.
+ */
+ fun drawTextWithBackground(
+ worldPos: Vec3d,
+ text: String,
+ textColor: Color = Color.WHITE,
+ backgroundColor: Color = Color(0, 0, 0, 128),
+ centered: Boolean = true,
+ padding: Float = 4f,
+ offsetY: Float = 0f
+ ) {
+ val screen = RenderMain.worldToScreen(worldPos) ?: return
+
+ val drawList = ImGui.getBackgroundDrawList()
+ val textSize = ImVec2()
+ ImGui.calcTextSize(textSize, text)
+
+ val x = if (centered) screen.x - textSize.x / 2f else screen.x
+ val y = screen.y + offsetY
+
+ // Draw background
+ val bgInt = colorToImGui(backgroundColor)
+ drawList.addRectFilled(
+ x - padding,
+ y - padding,
+ x + textSize.x + padding,
+ y + textSize.y + padding,
+ bgInt,
+ 2f // corner rounding
+ )
+
+ // Draw text
+ val colorInt = colorToImGui(textColor)
+ drawList.addText(x, y, colorInt, text)
+ }
+
+ /**
+ * Convert java.awt.Color to ImGui color format (ABGR)
+ */
+ private fun colorToImGui(color: Color): Int {
+ return (color.alpha shl 24) or
+ (color.blue shl 16) or
+ (color.green shl 8) or
+ color.red
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/InterpolatedRegionESP.kt b/src/main/kotlin/com/lambda/graphics/mc/InterpolatedRegionESP.kt
new file mode 100644
index 000000000..8b2b0b4b7
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/InterpolatedRegionESP.kt
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.graphics.esp.RegionESP
+import com.lambda.graphics.esp.ShapeScope
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.floor
+
+/**
+ * Interpolated region-based ESP system for smooth entity rendering.
+ *
+ * Unlike TransientRegionESP which rebuilds every tick, this system stores both previous and current
+ * frame data and interpolates between them during rendering for smooth movement at any framerate.
+ */
+class InterpolatedRegionESP(name: String, depthTest: Boolean = false) : RegionESP(name, depthTest) {
+ // Current frame builders (being populated this tick)
+ private val currBuilders = ConcurrentHashMap()
+
+ // Previous frame data (uploaded last tick)
+ private val prevBuilders = ConcurrentHashMap()
+
+ // Interpolated collectors for rendering (computed each frame)
+ private val interpolatedCollectors =
+ ConcurrentHashMap()
+
+ // Track if we need to re-interpolate
+ private var lastTickDelta = -1f
+ private var needsInterpolation = true
+
+ override fun shapes(x: Double, y: Double, z: Double, block: ShapeScope.() -> Unit) {
+ val key = getRegionKey(x, y, z)
+ val scope =
+ currBuilders.getOrPut(key) {
+ val size = RenderRegion.REGION_SIZE
+ val rx = (size * floor(x / size)).toInt()
+ val ry = (size * floor(y / size)).toInt()
+ val rz = (size * floor(z / size)).toInt()
+ ShapeScope(RenderRegion(rx, ry, rz), collectShapes = true)
+ }
+ scope.apply(block)
+ }
+
+ override fun clear() {
+ prevBuilders.clear()
+ currBuilders.clear()
+ interpolatedCollectors.clear()
+ }
+
+ fun tick() {
+ prevBuilders.clear()
+ prevBuilders.putAll(currBuilders)
+ currBuilders.clear()
+ needsInterpolation = true
+ }
+
+ override fun upload() {
+ needsInterpolation = true
+ }
+
+ override fun render(tickDelta: Float) {
+ if (needsInterpolation || lastTickDelta != tickDelta) {
+ interpolate(tickDelta)
+ uploadInterpolated()
+ lastTickDelta = tickDelta
+ needsInterpolation = false
+ }
+ super.render(tickDelta)
+ }
+
+ private fun interpolate(tickDelta: Float) {
+ interpolatedCollectors.clear()
+ (prevBuilders.keys + currBuilders.keys).toSet().forEach { key ->
+ val prevScope = prevBuilders[key]
+ val currScope = currBuilders[key]
+ val collector = RegionVertexCollector()
+ val region = currScope?.region ?: prevScope?.region ?: return@forEach
+
+ val prevShapes = prevScope?.shapes?.associateBy { it.id } ?: emptyMap()
+ val currShapes = currScope?.shapes?.associateBy { it.id } ?: emptyMap()
+
+ val allIds = (prevShapes.keys + currShapes.keys).toSet()
+
+ for (id in allIds) {
+ val prev = prevShapes[id]
+ val curr = currShapes[id]
+
+ when {
+ prev != null && curr != null -> {
+ curr.renderInterpolated(prev, tickDelta, collector, region)
+ }
+ curr != null -> {
+ // New shape - just render
+ curr.renderInterpolated(curr, 1.0f, collector, region)
+ }
+ prev != null -> {
+ // Disappeared - render at previous position
+ prev.renderInterpolated(prev, 1.0f, collector, region)
+ }
+ }
+ }
+
+ if (collector.faceVertices.isNotEmpty() || collector.edgeVertices.isNotEmpty()) {
+ interpolatedCollectors[key] = collector
+ }
+ }
+ }
+
+ private fun uploadInterpolated() {
+ val activeKeys = interpolatedCollectors.keys.toSet()
+ interpolatedCollectors.forEach { (key, collector) ->
+ val region = currBuilders[key]?.region ?: prevBuilders[key]?.region ?: return@forEach
+
+ val renderer = renderers.getOrPut(key) { RegionRenderer(region) }
+ renderer.upload(collector)
+ }
+
+ renderers.forEach { (key, renderer) ->
+ if (key !in activeKeys) {
+ renderer.clearData()
+ }
+ }
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/LambdaRenderPipelines.kt b/src/main/kotlin/com/lambda/graphics/mc/LambdaRenderPipelines.kt
new file mode 100644
index 000000000..350a40a77
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/LambdaRenderPipelines.kt
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.core.Loadable
+import com.mojang.blaze3d.pipeline.BlendFunction
+import com.mojang.blaze3d.pipeline.RenderPipeline
+import com.mojang.blaze3d.platform.DepthTestFunction
+import com.mojang.blaze3d.vertex.VertexFormat
+import net.minecraft.client.gl.RenderPipelines
+import net.minecraft.client.render.VertexFormats
+import net.minecraft.util.Identifier
+
+object LambdaRenderPipelines : Loadable {
+ override val priority: Int
+ get() = 100 // High priority to ensure pipelines are ready early
+
+ /**
+ * Base snippet for Lambda ESP rendering. Includes transforms, projection, and a custom
+ * per-region uniform.
+ */
+ private val LAMBDA_ESP_SNIPPET =
+ RenderPipeline.builder(RenderPipelines.TRANSFORMS_AND_PROJECTION_SNIPPET).buildSnippet()
+
+ /**
+ * Pipeline for ESP lines/outlines.
+ * - Uses MC's line rendering with per-vertex line width
+ * - No depth write for overlapping
+ * - No culling
+ */
+ val ESP_LINES: RenderPipeline =
+ RenderPipelines.register(
+ RenderPipeline.builder(LAMBDA_ESP_SNIPPET, RenderPipelines.GLOBALS_SNIPPET)
+ .withLocation(Identifier.of("lambda", "pipeline/esp_lines"))
+ .withVertexShader(Identifier.of("lambda", "core/advanced_lines"))
+ .withFragmentShader(Identifier.of("lambda", "core/advanced_lines"))
+ .withBlend(BlendFunction.TRANSLUCENT)
+ .withDepthWrite(false)
+ .withDepthTestFunction(DepthTestFunction.LEQUAL_DEPTH_TEST)
+ .withCull(false)
+ .withVertexFormat(
+ VertexFormats.POSITION_COLOR_NORMAL_LINE_WIDTH,
+ VertexFormat.DrawMode.QUADS
+ )
+ .build()
+ )
+
+ /** Pipeline for ESP lines that render through walls. */
+ val ESP_LINES_THROUGH: RenderPipeline =
+ RenderPipelines.register(
+ RenderPipeline.builder(LAMBDA_ESP_SNIPPET, RenderPipelines.GLOBALS_SNIPPET)
+ .withLocation(Identifier.of("lambda", "pipeline/esp_lines_through"))
+ .withVertexShader(Identifier.of("lambda", "core/advanced_lines"))
+ .withFragmentShader(Identifier.of("lambda", "core/advanced_lines"))
+ .withBlend(BlendFunction.TRANSLUCENT)
+ .withDepthWrite(false)
+ .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
+ .withCull(false)
+ .withVertexFormat(
+ VertexFormats.POSITION_COLOR_NORMAL_LINE_WIDTH,
+ VertexFormat.DrawMode.QUADS
+ )
+ .build()
+ )
+
+ /**
+ * Pipeline for quad-based ESP (compatible with existing shape building). Uses QUADS draw mode
+ * which MC converts to triangles internally.
+ */
+ val ESP_QUADS: RenderPipeline =
+ RenderPipelines.register(
+ RenderPipeline.builder(LAMBDA_ESP_SNIPPET)
+ .withLocation(Identifier.of("lambda", "pipeline/esp_quads"))
+ .withVertexShader(Identifier.ofVanilla("core/position_color"))
+ .withFragmentShader(Identifier.ofVanilla("core/position_color"))
+ .withBlend(BlendFunction.TRANSLUCENT)
+ .withDepthWrite(false)
+ .withDepthTestFunction(DepthTestFunction.LEQUAL_DEPTH_TEST)
+ .withCull(false)
+ .withVertexFormat(
+ VertexFormats.POSITION_COLOR,
+ VertexFormat.DrawMode.QUADS
+ )
+ .build()
+ )
+
+ /** Pipeline for quad-based ESP that renders through walls. */
+ val ESP_QUADS_THROUGH: RenderPipeline =
+ RenderPipelines.register(
+ RenderPipeline.builder(LAMBDA_ESP_SNIPPET)
+ .withLocation(Identifier.of("lambda", "pipeline/esp_quads_through"))
+ .withVertexShader(Identifier.ofVanilla("core/position_color"))
+ .withFragmentShader(Identifier.ofVanilla("core/position_color"))
+ .withBlend(BlendFunction.TRANSLUCENT)
+ .withDepthWrite(false)
+ .withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST)
+ .withCull(false)
+ .withVertexFormat(
+ VertexFormats.POSITION_COLOR,
+ VertexFormat.DrawMode.QUADS
+ )
+ .build()
+ )
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/RegionRenderer.kt b/src/main/kotlin/com/lambda/graphics/mc/RegionRenderer.kt
new file mode 100644
index 000000000..8d7f36f4a
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/RegionRenderer.kt
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.Lambda.mc
+import com.mojang.blaze3d.buffers.GpuBuffer
+import com.mojang.blaze3d.systems.RenderPass
+import com.mojang.blaze3d.systems.RenderSystem
+import com.mojang.blaze3d.vertex.VertexFormat
+import java.util.*
+
+/**
+ * Region-based renderer for ESP rendering using MC 1.21.11's new render pipeline.
+ *
+ * This renderer manages the lifecycle of dedicated GPU buffers for a specific region and provides
+ * methods to render them within a RenderPass.
+ *
+ * @param region The render region this renderer is associated with
+ */
+class RegionRenderer(val region: RenderRegion) {
+
+ // Dedicated GPU buffers for faces and edges
+ private var faceVertexBuffer: GpuBuffer? = null
+ private var edgeVertexBuffer: GpuBuffer? = null
+
+ // Index counts for draw calls
+ private var faceIndexCount = 0
+ private var edgeIndexCount = 0
+
+ // State tracking
+ private var hasData = false
+
+ /**
+ * Upload collected vertices from an external collector. This must be called on the main/render
+ * thread.
+ *
+ * @param collector The collector containing the geometry to upload
+ */
+ fun upload(collector: RegionVertexCollector) {
+ val result = collector.upload()
+
+ // Cleanup old buffers
+ faceVertexBuffer?.close()
+ edgeVertexBuffer?.close()
+
+ // Assign new buffers and counts
+ faceVertexBuffer = result.faces?.buffer
+ faceIndexCount = result.faces?.indexCount ?: 0
+
+ edgeVertexBuffer = result.edges?.buffer
+ edgeIndexCount = result.edges?.indexCount ?: 0
+
+ hasData = faceVertexBuffer != null || edgeVertexBuffer != null
+ }
+
+ /**
+ * Render faces using the given render pass.
+ *
+ * @param renderPass The active RenderPass to record commands into
+ */
+ fun renderFaces(renderPass: RenderPass) {
+ val vb = faceVertexBuffer ?: return
+ if (faceIndexCount == 0) return
+
+ renderPass.setVertexBuffer(0, vb)
+ // Use vanilla's sequential index buffer for quads
+ val shapeIndexBuffer = RenderSystem.getSequentialBuffer(VertexFormat.DrawMode.QUADS)
+ val indexBuffer = shapeIndexBuffer.getIndexBuffer(faceIndexCount)
+
+ renderPass.setIndexBuffer(indexBuffer, shapeIndexBuffer.indexType)
+ renderPass.drawIndexed(0, 0, faceIndexCount, 1)
+ }
+
+ /**
+ * Render edges using the given render pass.
+ *
+ * @param renderPass The active RenderPass to record commands into
+ */
+ fun renderEdges(renderPass: RenderPass) {
+ val vb = edgeVertexBuffer ?: return
+ if (edgeIndexCount == 0) return
+
+ renderPass.setVertexBuffer(0, vb)
+ // Use vanilla's sequential index buffer for quads
+ val shapeIndexBuffer = RenderSystem.getSequentialBuffer(VertexFormat.DrawMode.QUADS)
+ val indexBuffer = shapeIndexBuffer.getIndexBuffer(edgeIndexCount)
+
+ renderPass.setIndexBuffer(indexBuffer, shapeIndexBuffer.indexType)
+ renderPass.drawIndexed(0, 0, edgeIndexCount, 1)
+ }
+
+ /** Clear all geometry data and release GPU resources. */
+ fun clearData() {
+ faceVertexBuffer?.close()
+ edgeVertexBuffer?.close()
+ faceVertexBuffer = null
+ edgeVertexBuffer = null
+ faceIndexCount = 0
+ edgeIndexCount = 0
+ hasData = false
+ }
+
+ /** Check if this renderer has any data to render. */
+ fun hasData(): Boolean = hasData
+
+ /** Clean up all resources. */
+ fun close() {
+ clearData()
+ }
+
+ companion object {
+ /** Helper to create a render pass targeting the main framebuffer. */
+ fun createRenderPass(label: String): RenderPass? {
+ val framebuffer = mc.framebuffer ?: return null
+ return RenderSystem.getDevice()
+ .createCommandEncoder()
+ .createRenderPass(
+ { label },
+ framebuffer.colorAttachmentView,
+ OptionalInt.empty(),
+ framebuffer.depthAttachmentView,
+ OptionalDouble.empty()
+ )
+ }
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/RegionShapeBuilder.kt b/src/main/kotlin/com/lambda/graphics/mc/RegionShapeBuilder.kt
new file mode 100644
index 000000000..8b33498be
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/RegionShapeBuilder.kt
@@ -0,0 +1,758 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.Lambda.mc
+import com.lambda.graphics.renderer.esp.DirectionMask
+import com.lambda.graphics.renderer.esp.DirectionMask.hasDirection
+import com.lambda.graphics.renderer.esp.DynamicAABB
+import com.lambda.module.modules.client.StyleEditor
+import com.lambda.threading.runSafe
+import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.extension.partialTicks
+import net.minecraft.block.BlockState
+import net.minecraft.block.entity.BlockEntity
+import net.minecraft.entity.Entity
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
+import net.minecraft.util.math.MathHelper.lerp
+import net.minecraft.util.math.Vec3d
+import net.minecraft.util.shape.VoxelShape
+import java.awt.Color
+import kotlin.math.min
+import kotlin.math.sqrt
+
+/**
+ * Shape builder for region-based rendering. All coordinates are automatically converted to
+ * region-relative positions.
+ *
+ * This class provides drawing primitives for region-based rendering and collects vertex data in thread-safe collections
+ * for later upload to MC's BufferBuilder.
+ *
+ * @param region The render region (provides origin for coordinate conversion)
+ */
+class RegionShapeBuilder(val region: RenderRegion) {
+ val collector = RegionVertexCollector()
+
+ val lineWidth: Float
+ get() = StyleEditor.outlineWidth.toFloat()
+
+ fun box(
+ entity: BlockEntity,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And
+ ) = box(entity.pos, entity.cachedState, filled, outline, sides, mode)
+
+ fun box(
+ entity: Entity,
+ filled: Color,
+ outline: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And
+ ) = box(entity.boundingBox, filled, outline, sides, mode)
+
+ /** Convert world coordinates to region-relative. */
+ private fun toRelative(x: Double, y: Double, z: Double) =
+ Triple(
+ (x - region.originX).toFloat(),
+ (y - region.originY).toFloat(),
+ (z - region.originZ).toFloat()
+ )
+
+ /** Add a colored quad face (filled rectangle). */
+ fun filled(
+ box: Box,
+ bottomColor: Color,
+ topColor: Color = bottomColor,
+ sides: Int = DirectionMask.ALL
+ ) {
+ val (x1, y1, z1) = toRelative(box.minX, box.minY, box.minZ)
+ val (x2, y2, z2) = toRelative(box.maxX, box.maxY, box.maxZ)
+
+ // Bottom-left-back, bottom-left-front, etc.
+ if (sides.hasDirection(DirectionMask.EAST)) {
+ // East face (+X)
+ faceVertex(x2, y1, z1, bottomColor)
+ faceVertex(x2, y2, z1, topColor)
+ faceVertex(x2, y2, z2, topColor)
+ faceVertex(x2, y1, z2, bottomColor)
+ }
+ if (sides.hasDirection(DirectionMask.WEST)) {
+ // West face (-X)
+ faceVertex(x1, y1, z1, bottomColor)
+ faceVertex(x1, y1, z2, bottomColor)
+ faceVertex(x1, y2, z2, topColor)
+ faceVertex(x1, y2, z1, topColor)
+ }
+ if (sides.hasDirection(DirectionMask.UP)) {
+ // Top face (+Y)
+ faceVertex(x1, y2, z1, topColor)
+ faceVertex(x1, y2, z2, topColor)
+ faceVertex(x2, y2, z2, topColor)
+ faceVertex(x2, y2, z1, topColor)
+ }
+ if (sides.hasDirection(DirectionMask.DOWN)) {
+ // Bottom face (-Y)
+ faceVertex(x1, y1, z1, bottomColor)
+ faceVertex(x2, y1, z1, bottomColor)
+ faceVertex(x2, y1, z2, bottomColor)
+ faceVertex(x1, y1, z2, bottomColor)
+ }
+ if (sides.hasDirection(DirectionMask.SOUTH)) {
+ // South face (+Z)
+ faceVertex(x1, y1, z2, bottomColor)
+ faceVertex(x2, y1, z2, bottomColor)
+ faceVertex(x2, y2, z2, topColor)
+ faceVertex(x1, y2, z2, topColor)
+ }
+ if (sides.hasDirection(DirectionMask.NORTH)) {
+ // North face (-Z)
+ faceVertex(x1, y1, z1, bottomColor)
+ faceVertex(x1, y2, z1, topColor)
+ faceVertex(x2, y2, z1, topColor)
+ faceVertex(x2, y1, z1, bottomColor)
+ }
+ }
+
+ fun filled(box: Box, color: Color, sides: Int = DirectionMask.ALL) =
+ filled(box, color, color, sides)
+
+ fun filled(box: DynamicAABB, color: Color, sides: Int = DirectionMask.ALL) {
+ val pair = box.pair ?: return
+ val prev = pair.first
+ val curr = pair.second
+ val tickDelta = mc.partialTicks
+ val interpolated = Box(
+ lerp(tickDelta, prev.minX, curr.minX),
+ lerp(tickDelta, prev.minY, curr.minY),
+ lerp(tickDelta, prev.minZ, curr.minZ),
+ lerp(tickDelta, prev.maxX, curr.maxX),
+ lerp(tickDelta, prev.maxY, curr.maxY),
+ lerp(tickDelta, prev.maxZ, curr.maxZ)
+ )
+ filled(interpolated, color, sides)
+ }
+
+ fun filled(
+ pos: BlockPos,
+ state: BlockState,
+ color: Color,
+ sides: Int = DirectionMask.ALL
+ ) = runSafe {
+ val shape = state.getOutlineShape(world, pos)
+ if (shape.isEmpty) {
+ filled(Box(pos), color, sides)
+ } else {
+ filled(shape.offset(pos.x.toDouble(), pos.y.toDouble(), pos.z.toDouble()), color, sides)
+ }
+ }
+
+ fun filled(pos: BlockPos, color: Color, sides: Int = DirectionMask.ALL) = runSafe {
+ filled(pos, blockState(pos), color, sides)
+ }
+
+ fun filled(pos: BlockPos, entity: BlockEntity, color: Color, sides: Int = DirectionMask.ALL) =
+ filled(pos, entity.cachedState, color, sides)
+
+ fun filled(shape: VoxelShape, color: Color, sides: Int = DirectionMask.ALL) {
+ shape.boundingBoxes.forEach { filled(it, color, color, sides) }
+ }
+
+ /** Add outline (lines) for a box. */
+ fun outline(
+ box: Box,
+ bottomColor: Color,
+ topColor: Color = bottomColor,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) {
+ val (x1, y1, z1) = toRelative(box.minX, box.minY, box.minZ)
+ val (x2, y2, z2) = toRelative(box.maxX, box.maxY, box.maxZ)
+
+ val hasEast = sides.hasDirection(DirectionMask.EAST)
+ val hasWest = sides.hasDirection(DirectionMask.WEST)
+ val hasUp = sides.hasDirection(DirectionMask.UP)
+ val hasDown = sides.hasDirection(DirectionMask.DOWN)
+ val hasSouth = sides.hasDirection(DirectionMask.SOUTH)
+ val hasNorth = sides.hasDirection(DirectionMask.NORTH)
+
+ // Top edges
+ if (mode.check(hasUp, hasNorth)) line(x1, y2, z1, x2, y2, z1, topColor, topColor, thickness)
+ if (mode.check(hasUp, hasSouth)) line(x1, y2, z2, x2, y2, z2, topColor, topColor, thickness)
+ if (mode.check(hasUp, hasWest)) line(x1, y2, z1, x1, y2, z2, topColor, topColor, thickness)
+ if (mode.check(hasUp, hasEast)) line(x2, y2, z2, x2, y2, z1, topColor, topColor, thickness)
+
+ // Bottom edges
+ if (mode.check(hasDown, hasNorth)) line(x1, y1, z1, x2, y1, z1, bottomColor, bottomColor, thickness)
+ if (mode.check(hasDown, hasSouth)) line(x1, y1, z2, x2, y1, z2, bottomColor, bottomColor, thickness)
+ if (mode.check(hasDown, hasWest)) line(x1, y1, z1, x1, y1, z2, bottomColor, bottomColor, thickness)
+ if (mode.check(hasDown, hasEast)) line(x2, y1, z1, x2, y1, z2, bottomColor, bottomColor, thickness)
+
+ // Vertical edges
+ if (mode.check(hasWest, hasNorth)) line(x1, y2, z1, x1, y1, z1, topColor, bottomColor, thickness)
+ if (mode.check(hasNorth, hasEast)) line(x2, y2, z1, x2, y1, z1, topColor, bottomColor, thickness)
+ if (mode.check(hasEast, hasSouth)) line(x2, y2, z2, x2, y1, z2, topColor, bottomColor, thickness)
+ if (mode.check(hasSouth, hasWest)) line(x1, y2, z2, x1, y1, z2, topColor, bottomColor, thickness)
+ }
+
+ fun outline(
+ box: Box,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = outline(box, color, color, sides, mode, thickness)
+
+ fun outline(
+ box: DynamicAABB,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) {
+ val pair = box.pair ?: return
+ val prev = pair.first
+ val curr = pair.second
+ val tickDelta = mc.partialTicks
+ val interpolated = Box(
+ lerp(tickDelta, prev.minX, curr.minX),
+ lerp(tickDelta, prev.minY, curr.minY),
+ lerp(tickDelta, prev.minZ, curr.minZ),
+ lerp(tickDelta, prev.maxX, curr.maxX),
+ lerp(tickDelta, prev.maxY, curr.maxY),
+ lerp(tickDelta, prev.maxZ, curr.maxZ)
+ )
+ outline(interpolated, color, sides, mode, thickness)
+ }
+
+ fun outline(
+ pos: BlockPos,
+ state: BlockState,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe {
+ val shape = state.getOutlineShape(world, pos)
+ if (shape.isEmpty) {
+ outline(Box(pos), color, sides, mode, thickness)
+ } else {
+ outline(shape.offset(pos.x.toDouble(), pos.y.toDouble(), pos.z.toDouble()), color, sides, mode, thickness)
+ }
+ }
+
+ fun outline(
+ pos: BlockPos,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe { outline(pos, blockState(pos), color, sides, mode, thickness) }
+
+ fun outline(
+ pos: BlockPos,
+ entity: BlockEntity,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe { outline(pos, entity.cachedState, color, sides, mode, thickness) }
+
+ fun outline(
+ shape: VoxelShape,
+ color: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) {
+ shape.boundingBoxes.forEach { outline(it, color, sides, mode, thickness) }
+ }
+
+ /** Add both filled and outline for a box. */
+ fun box(
+ pos: BlockPos,
+ state: BlockState,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe {
+ filled(pos, state, filledColor, sides)
+ outline(pos, state, outlineColor, sides, mode, thickness)
+ }
+
+ fun box(
+ pos: BlockPos,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe {
+ filled(pos, filledColor, sides)
+ outline(pos, outlineColor, sides, mode, thickness)
+ }
+
+ fun box(
+ box: Box,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) {
+ filled(box, filledColor, sides)
+ outline(box, outlineColor, sides, mode, thickness)
+ }
+
+ fun box(
+ box: DynamicAABB,
+ filledColor: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) {
+ filled(box, filledColor, sides)
+ outline(box, outlineColor, sides, mode, thickness)
+ }
+
+ fun box(
+ entity: BlockEntity,
+ filled: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe {
+ filled(entity.pos, entity, filled, sides)
+ outline(entity.pos, entity, outlineColor, sides, mode, thickness)
+ }
+
+ fun box(
+ entity: Entity,
+ filled: Color,
+ outlineColor: Color,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And,
+ thickness: Float = lineWidth
+ ) = runSafe {
+ filled(entity.boundingBox, filled, sides)
+ outline(entity.boundingBox, outlineColor, sides, mode, thickness)
+ }
+
+ private fun faceVertex(x: Float, y: Float, z: Float, color: Color) {
+ collector.addFaceVertex(x, y, z, color)
+ }
+
+ private fun line(
+ x1: Float,
+ y1: Float,
+ z1: Float,
+ x2: Float,
+ y2: Float,
+ z2: Float,
+ color: Color,
+ width: Float = lineWidth
+ ) {
+ line(x1, y1, z1, x2, y2, z2, color, color, width)
+ }
+
+ private fun line(
+ x1: Float,
+ y1: Float,
+ z1: Float,
+ x2: Float,
+ y2: Float,
+ z2: Float,
+ color1: Color,
+ color2: Color,
+ width: Float = lineWidth
+ ) {
+ // Calculate segment vector (dx, dy, dz)
+ val dx = x2 - x1
+ val dy = y2 - y1
+ val dz = z2 - z1
+
+ // Quad-based lines need 4 vertices per segment
+ // We pass the full vector as 'Normal' so the shader knows where the other end is
+ collector.addEdgeVertex(x1, y1, z1, color1, dx, dy, dz, width)
+ collector.addEdgeVertex(x1, y1, z1, color1, dx, dy, dz, width)
+ collector.addEdgeVertex(x2, y2, z2, color2, dx, dy, dz, width)
+ collector.addEdgeVertex(x2, y2, z2, color2, dx, dy, dz, width)
+ }
+
+ /**
+ * Draw a dashed line between two world positions.
+ *
+ * @param start Start position in world coordinates
+ * @param end End position in world coordinates
+ * @param color Line color
+ * @param dashLength Length of each dash in blocks
+ * @param gapLength Length of each gap in blocks
+ * @param width Line width (uses default if null)
+ */
+ fun dashedLine(
+ start: Vec3d,
+ end: Vec3d,
+ color: Color,
+ dashLength: Double = 0.5,
+ gapLength: Double = 0.25,
+ width: Float = lineWidth
+ ) {
+ val direction = end.subtract(start)
+ val totalLength = direction.length()
+ if (totalLength < 0.001) return
+
+ val normalizedDir = direction.normalize()
+ var pos = 0.0
+ var isDash = true
+
+ while (pos < totalLength) {
+ val segmentLength = if (isDash) dashLength else gapLength
+ val segmentEnd = min(pos + segmentLength, totalLength)
+
+ if (isDash) {
+ val segStart = start.add(normalizedDir.multiply(pos))
+ val segEnd = start.add(normalizedDir.multiply(segmentEnd))
+
+ val (x1, y1, z1) = toRelative(segStart.x, segStart.y, segStart.z)
+ val (x2, y2, z2) = toRelative(segEnd.x, segEnd.y, segEnd.z)
+
+ lineWithWidth(x1, y1, z1, x2, y2, z2, color, width)
+ }
+
+ pos = segmentEnd
+ isDash = !isDash
+ }
+ }
+
+ /** Draw a dashed outline for a box. */
+ fun dashedOutline(
+ box: Box,
+ color: Color,
+ dashLength: Double = 0.5,
+ gapLength: Double = 0.25,
+ sides: Int = DirectionMask.ALL,
+ mode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.And
+ ) {
+ val hasEast = sides.hasDirection(DirectionMask.EAST)
+ val hasWest = sides.hasDirection(DirectionMask.WEST)
+ val hasUp = sides.hasDirection(DirectionMask.UP)
+ val hasDown = sides.hasDirection(DirectionMask.DOWN)
+ val hasSouth = sides.hasDirection(DirectionMask.SOUTH)
+ val hasNorth = sides.hasDirection(DirectionMask.NORTH)
+
+ // Top edges
+ if (mode.check(hasUp, hasNorth))
+ dashedLine(
+ Vec3d(box.minX, box.maxY, box.minZ),
+ Vec3d(box.maxX, box.maxY, box.minZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasUp, hasSouth))
+ dashedLine(
+ Vec3d(box.minX, box.maxY, box.maxZ),
+ Vec3d(box.maxX, box.maxY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasUp, hasWest))
+ dashedLine(
+ Vec3d(box.minX, box.maxY, box.minZ),
+ Vec3d(box.minX, box.maxY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasUp, hasEast))
+ dashedLine(
+ Vec3d(box.maxX, box.maxY, box.maxZ),
+ Vec3d(box.maxX, box.maxY, box.minZ),
+ color,
+ dashLength,
+ gapLength
+ )
+
+ // Bottom edges
+ if (mode.check(hasDown, hasNorth))
+ dashedLine(
+ Vec3d(box.minX, box.minY, box.minZ),
+ Vec3d(box.maxX, box.minY, box.minZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasDown, hasSouth))
+ dashedLine(
+ Vec3d(box.minX, box.minY, box.maxZ),
+ Vec3d(box.maxX, box.minY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasDown, hasWest))
+ dashedLine(
+ Vec3d(box.minX, box.minY, box.minZ),
+ Vec3d(box.minX, box.minY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasDown, hasEast))
+ dashedLine(
+ Vec3d(box.maxX, box.minY, box.minZ),
+ Vec3d(box.maxX, box.minY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+
+ // Vertical edges
+ if (mode.check(hasWest, hasNorth))
+ dashedLine(
+ Vec3d(box.minX, box.maxY, box.minZ),
+ Vec3d(box.minX, box.minY, box.minZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasNorth, hasEast))
+ dashedLine(
+ Vec3d(box.maxX, box.maxY, box.minZ),
+ Vec3d(box.maxX, box.minY, box.minZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasEast, hasSouth))
+ dashedLine(
+ Vec3d(box.maxX, box.maxY, box.maxZ),
+ Vec3d(box.maxX, box.minY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ if (mode.check(hasSouth, hasWest))
+ dashedLine(
+ Vec3d(box.minX, box.maxY, box.maxZ),
+ Vec3d(box.minX, box.minY, box.maxZ),
+ color,
+ dashLength,
+ gapLength
+ )
+ }
+
+ /** Draw a line between two world positions. */
+ fun line(start: Vec3d, end: Vec3d, color: Color, width: Float = lineWidth) {
+ val (x1, y1, z1) = toRelative(start.x, start.y, start.z)
+ val (x2, y2, z2) = toRelative(end.x, end.y, end.z)
+ lineWithWidth(x1, y1, z1, x2, y2, z2, color, width)
+ }
+
+ /** Draw a polyline through a list of points. */
+ fun polyline(points: List, color: Color, width: Float = lineWidth) {
+ if (points.size < 2) return
+ for (i in 0 until points.size - 1) {
+ line(points[i], points[i + 1], color, width)
+ }
+ }
+
+ /** Draw a dashed polyline through a list of points. */
+ fun dashedPolyline(
+ points: List,
+ color: Color,
+ dashLength: Double = 0.5,
+ gapLength: Double = 0.25,
+ width: Float = lineWidth
+ ) {
+ if (points.size < 2) return
+ for (i in 0 until points.size - 1) {
+ dashedLine(points[i], points[i + 1], color, dashLength, gapLength, width)
+ }
+ }
+
+ /**
+ * Draw a quadratic Bezier curve.
+ *
+ * @param p0 Start point
+ * @param p1 Control point
+ * @param p2 End point
+ * @param color Line color
+ * @param segments Number of line segments (higher = smoother)
+ */
+ fun quadraticBezier(
+ p0: Vec3d,
+ p1: Vec3d,
+ p2: Vec3d,
+ color: Color,
+ segments: Int = 16,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.quadraticBezierPoints(p0, p1, p2, segments)
+ polyline(points, color, width)
+ }
+
+ /**
+ * Draw a cubic Bezier curve.
+ *
+ * @param p0 Start point
+ * @param p1 First control point
+ * @param p2 Second control point
+ * @param p3 End point
+ * @param color Line color
+ * @param segments Number of line segments (higher = smoother)
+ */
+ fun cubicBezier(
+ p0: Vec3d,
+ p1: Vec3d,
+ p2: Vec3d,
+ p3: Vec3d,
+ color: Color,
+ segments: Int = 32,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.cubicBezierPoints(p0, p1, p2, p3, segments)
+ polyline(points, color, width)
+ }
+
+ /**
+ * Draw a Catmull-Rom spline that passes through all control points.
+ *
+ * @param controlPoints List of points the spline should pass through (minimum 4)
+ * @param color Line color
+ * @param segmentsPerSection Segments between each pair of control points
+ */
+ fun catmullRomSpline(
+ controlPoints: List,
+ color: Color,
+ segmentsPerSection: Int = 16,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.catmullRomSplinePoints(controlPoints, segmentsPerSection)
+ polyline(points, color, width)
+ }
+
+ /**
+ * Draw a smooth path through waypoints using Catmull-Rom splines. Handles endpoints
+ * naturally by mirroring.
+ *
+ * @param waypoints List of points to pass through (minimum 2)
+ * @param color Line color
+ * @param segmentsPerSection Smoothness (higher = smoother)
+ */
+ fun smoothPath(
+ waypoints: List,
+ color: Color,
+ segmentsPerSection: Int = 16,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.smoothPath(waypoints, segmentsPerSection)
+ polyline(points, color, width)
+ }
+
+ /** Draw a dashed Bezier curve. */
+ fun dashedCubicBezier(
+ p0: Vec3d,
+ p1: Vec3d,
+ p2: Vec3d,
+ p3: Vec3d,
+ color: Color,
+ segments: Int = 32,
+ dashLength: Double = 0.5,
+ gapLength: Double = 0.25,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.cubicBezierPoints(p0, p1, p2, p3, segments)
+ dashedPolyline(points, color, dashLength, gapLength, width)
+ }
+
+ /** Draw a dashed smooth path. */
+ fun dashedSmoothPath(
+ waypoints: List,
+ color: Color,
+ segmentsPerSection: Int = 16,
+ dashLength: Double = 0.5,
+ gapLength: Double = 0.25,
+ width: Float = lineWidth
+ ) {
+ val points = CurveUtils.smoothPath(waypoints, segmentsPerSection)
+ dashedPolyline(points, color, dashLength, gapLength, width)
+ }
+
+ /**
+ * Draw a circle in a plane.
+ *
+ * @param center Center of the circle
+ * @param radius Radius of the circle
+ * @param normal Normal vector of the plane (determines orientation)
+ * @param color Line color
+ * @param segments Number of segments
+ */
+ fun circle(
+ center: Vec3d,
+ radius: Double,
+ normal: Vec3d = Vec3d(0.0, 1.0, 0.0),
+ color: Color,
+ segments: Int = 32,
+ width: Float = lineWidth
+ ) {
+ // Create basis vectors perpendicular to normal
+ val up =
+ if (kotlin.math.abs(normal.y) < 0.99) Vec3d(0.0, 1.0, 0.0)
+ else Vec3d(1.0, 0.0, 0.0)
+ val u = normal.crossProduct(up).normalize()
+ val v = u.crossProduct(normal).normalize()
+
+ val points =
+ (0..segments).map { i ->
+ val angle = 2.0 * Math.PI * i / segments
+ val x = kotlin.math.cos(angle) * radius
+ val y = kotlin.math.sin(angle) * radius
+ center.add(u.multiply(x)).add(v.multiply(y))
+ }
+
+ polyline(points, color, width)
+ }
+
+ private fun lineWithWidth(
+ x1: Float,
+ y1: Float,
+ z1: Float,
+ x2: Float,
+ y2: Float,
+ z2: Float,
+ color: Color,
+ width: Float
+ ) {
+ val dx = x2 - x1
+ val dy = y2 - y1
+ val dz = z2 - z1
+ collector.addEdgeVertex(x1, y1, z1, color, dx, dy, dz, width)
+ collector.addEdgeVertex(x1, y1, z1, color, dx, dy, dz, width)
+ collector.addEdgeVertex(x2, y2, z2, color, dx, dy, dz, width)
+ collector.addEdgeVertex(x2, y2, z2, color, dx, dy, dz, width)
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/RegionVertexCollector.kt b/src/main/kotlin/com/lambda/graphics/mc/RegionVertexCollector.kt
new file mode 100644
index 000000000..c82347817
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/RegionVertexCollector.kt
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.mojang.blaze3d.buffers.GpuBuffer
+import com.mojang.blaze3d.systems.RenderSystem
+import com.mojang.blaze3d.vertex.VertexFormat
+import net.minecraft.client.render.BufferBuilder
+import net.minecraft.client.render.VertexFormats
+import net.minecraft.client.util.BufferAllocator
+import java.awt.Color
+import java.util.concurrent.ConcurrentLinkedDeque
+
+/**
+ * Thread-safe vertex collector for region-based rendering.
+ *
+ * Collects vertex data on background threads using thread-safe collections, then writes to MC's
+ * BufferBuilder and uploads on the main thread.
+ */
+class RegionVertexCollector {
+ val faceVertices = ConcurrentLinkedDeque()
+ val edgeVertices = ConcurrentLinkedDeque()
+
+ /** Face vertex data (position + color). */
+ data class FaceVertex(
+ val x: Float,
+ val y: Float,
+ val z: Float,
+ val r: Int,
+ val g: Int,
+ val b: Int,
+ val a: Int
+ )
+
+ /** Edge vertex data (position + color + normal + line width). */
+ data class EdgeVertex(
+ val x: Float,
+ val y: Float,
+ val z: Float,
+ val r: Int,
+ val g: Int,
+ val b: Int,
+ val a: Int,
+ val nx: Float,
+ val ny: Float,
+ val nz: Float,
+ val lineWidth: Float
+ )
+
+ /** Add a face vertex. */
+ fun addFaceVertex(x: Float, y: Float, z: Float, color: Color) {
+ faceVertices.add(FaceVertex(x, y, z, color.red, color.green, color.blue, color.alpha))
+ }
+
+ /** Add an edge vertex. */
+ fun addEdgeVertex(
+ x: Float,
+ y: Float,
+ z: Float,
+ color: Color,
+ nx: Float,
+ ny: Float,
+ nz: Float,
+ lineWidth: Float
+ ) {
+ edgeVertices.add(
+ EdgeVertex(x, y, z, color.red, color.green, color.blue, color.alpha, nx, ny, nz, lineWidth)
+ )
+ }
+
+ /**
+ * Upload collected data to GPU buffers. Must be called on the main/render thread.
+ *
+ * @return Pair of (faceBuffer, edgeBuffer) and their index counts, or null if no data
+ */
+ fun upload(): UploadResult {
+ val faces = uploadFaces()
+ val edges = uploadEdges()
+ return UploadResult(faces, edges)
+ }
+
+ private fun uploadFaces(): BufferResult {
+ if (faceVertices.isEmpty()) return BufferResult(null, 0)
+
+ val vertices = faceVertices.toList()
+ faceVertices.clear()
+
+ var result: BufferResult? = null
+ BufferAllocator(vertices.size * 16).use { allocator ->
+ val builder =
+ BufferBuilder(
+ allocator,
+ VertexFormat.DrawMode.QUADS,
+ VertexFormats.POSITION_COLOR
+ )
+
+ vertices.forEach { v -> builder.vertex(v.x, v.y, v.z).color(v.r, v.g, v.b, v.a) }
+
+ builder.endNullable()?.let { built ->
+ val gpuDevice = RenderSystem.getDevice()
+ val buffer =
+ gpuDevice.createBuffer(
+ { "Lambda ESP Face Buffer" },
+ GpuBuffer.USAGE_VERTEX,
+ built.buffer
+ )
+ result = BufferResult(buffer, built.drawParameters.indexCount())
+ built.close()
+ }
+ }
+ return result ?: BufferResult(null, 0)
+ }
+
+ private fun uploadEdges(): BufferResult {
+ if (edgeVertices.isEmpty()) return BufferResult(null, 0)
+
+ val vertices = edgeVertices.toList()
+ edgeVertices.clear()
+
+ var result: BufferResult? = null
+ BufferAllocator(vertices.size * 32).use { allocator ->
+ val builder =
+ BufferBuilder(
+ allocator,
+ VertexFormat.DrawMode.QUADS,
+ VertexFormats.POSITION_COLOR_NORMAL_LINE_WIDTH
+ )
+
+ vertices.forEach { v ->
+ builder.vertex(v.x, v.y, v.z)
+ .color(v.r, v.g, v.b, v.a)
+ .normal(v.nx, v.ny, v.nz)
+ .lineWidth(v.lineWidth)
+ }
+
+ builder.endNullable()?.let { built ->
+ val gpuDevice = RenderSystem.getDevice()
+ val buffer =
+ gpuDevice.createBuffer(
+ { "Lambda ESP Edge Buffer" },
+ GpuBuffer.USAGE_VERTEX,
+ built.buffer
+ )
+ result = BufferResult(buffer, built.drawParameters.indexCount())
+ built.close()
+ }
+ }
+ return result ?: BufferResult(null, 0)
+ }
+
+ data class BufferResult(val buffer: GpuBuffer?, val indexCount: Int)
+ data class UploadResult(val faces: BufferResult?, val edges: BufferResult?)
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/RenderRegion.kt b/src/main/kotlin/com/lambda/graphics/mc/RenderRegion.kt
new file mode 100644
index 000000000..6687aa44e
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/RenderRegion.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import net.minecraft.util.math.Vec3d
+import org.joml.Vector3f
+
+/**
+ * A render region represents a chunk-sized area in the world where vertices are stored relative to
+ * the region's origin. This solves floating-point precision issues at large world coordinates.
+ *
+ * @param originX The X coordinate of the region's origin (typically chunk corner)
+ * @param originY The Y coordinate of the region's origin
+ * @param originZ The Z coordinate of the region's origin
+ */
+class RenderRegion(val originX: Int, val originY: Int, val originZ: Int) {
+ /**
+ * Compute the camera-relative offset for this region. This is done in double precision to
+ * maintain accuracy at large coordinates.
+ *
+ * @param cameraPos The camera's world position (double precision)
+ * @return The offset from camera to region origin (small float, high precision)
+ */
+ fun computeCameraRelativeOffset(cameraPos: Vec3d): Vector3f {
+ val offsetX = originX.toDouble() - cameraPos.x
+ val offsetY = originY.toDouble() - cameraPos.y
+ val offsetZ = originZ.toDouble() - cameraPos.z
+ return Vector3f(offsetX.toFloat(), offsetY.toFloat(), offsetZ.toFloat())
+ }
+
+ companion object {
+ /** Standard size of a render region (matches Minecraft chunk size). */
+ const val REGION_SIZE = 16
+
+ /**
+ * Create a region for a chunk position.
+ *
+ * @param chunkX Chunk X coordinate
+ * @param chunkZ Chunk Z coordinate
+ * @param bottomY World bottom Y coordinate (typically -64)
+ */
+ fun forChunk(chunkX: Int, chunkZ: Int, bottomY: Int) =
+ RenderRegion(chunkX * 16, bottomY, chunkZ * 16)
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/TransientRegionESP.kt b/src/main/kotlin/com/lambda/graphics/mc/TransientRegionESP.kt
new file mode 100644
index 000000000..bc1cd812c
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/TransientRegionESP.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.graphics.esp.RegionESP
+import com.lambda.graphics.esp.ShapeScope
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.floor
+
+/**
+ * Modern replacement for the legacy Treed system. Handles geometry that is cleared and rebuilt
+ * every tick. Uses region-based rendering for precision.
+ */
+class TransientRegionESP(name: String, depthTest: Boolean = false) : RegionESP(name, depthTest) {
+ private val builders = ConcurrentHashMap()
+
+ /** Get or create a builder for a specific region. */
+ override fun shapes(x: Double, y: Double, z: Double, block: ShapeScope.() -> Unit) {
+ val key = getRegionKey(x, y, z)
+ val scope =
+ builders.getOrPut(key) {
+ val size = RenderRegion.REGION_SIZE
+ val rx = (size * floor(x / size)).toInt()
+ val ry = (size * floor(y / size)).toInt()
+ val rz = (size * floor(z / size)).toInt()
+ ShapeScope(RenderRegion(rx, ry, rz))
+ }
+ scope.apply(block)
+ }
+
+ /** Clear all current builders. Call this at the end of every tick. */
+ override fun clear() {
+ builders.clear()
+ }
+
+ /** Upload collected geometry to GPU. Must be called on main thread. */
+ override fun upload() {
+ val activeKeys = builders.keys().asSequence().toSet()
+
+ builders.forEach { (key, scope) ->
+ val renderer = renderers.getOrPut(key) { RegionRenderer(scope.region) }
+ renderer.upload(scope.builder.collector)
+ }
+
+ renderers.forEach { (key, renderer) ->
+ if (key !in activeKeys) {
+ renderer.clearData()
+ }
+ }
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/mc/WorldTextRenderer.kt b/src/main/kotlin/com/lambda/graphics/mc/WorldTextRenderer.kt
new file mode 100644
index 000000000..9aa34034d
--- /dev/null
+++ b/src/main/kotlin/com/lambda/graphics/mc/WorldTextRenderer.kt
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.Lambda.mc
+import net.minecraft.client.font.TextRenderer
+import net.minecraft.client.render.LightmapTextureManager
+import net.minecraft.client.util.math.MatrixStack
+import net.minecraft.text.Text
+import net.minecraft.util.math.Vec3d
+import java.awt.Color
+
+/**
+ * Utility for rendering text in 3D world space.
+ *
+ * Uses Minecraft's TextRenderer to draw text that faces the camera (billboard style) at any world
+ * position. Handles Unicode, formatting codes, and integrates with MC's rendering system.
+ *
+ * Usage:
+ * ```kotlin
+ * // In your render event
+ * WorldTextRenderer.drawText(
+ * pos = entity.pos.add(0.0, entity.height + 0.5, 0.0),
+ * text = entity.name,
+ * color = Color.WHITE,
+ * scale = 0.025f
+ * )
+ * ```
+ */
+object WorldTextRenderer {
+
+ /** Default scale for world text (MC uses 0.025f for name tags) */
+ const val DEFAULT_SCALE = 0.025f
+
+ /** Maximum light level for full brightness */
+ private const val FULL_BRIGHT = LightmapTextureManager.MAX_LIGHT_COORDINATE
+
+ /**
+ * Draw text at a world position, facing the camera.
+ *
+ * @param pos World position for the text
+ * @param text The text to render
+ * @param color Text color (ARGB)
+ * @param scale Text scale (0.025f is default name tag size)
+ * @param shadow Whether to draw drop shadow
+ * @param seeThrough Whether text should be visible through blocks
+ * @param centered Whether to center the text horizontally
+ * @param backgroundColor Background color (0 for no background)
+ * @param light Light level (uses full bright by default)
+ */
+ fun drawText(
+ pos: Vec3d,
+ text: Text,
+ color: Color = Color.WHITE,
+ scale: Float = DEFAULT_SCALE,
+ shadow: Boolean = true,
+ seeThrough: Boolean = false,
+ centered: Boolean = true,
+ backgroundColor: Int = 0,
+ light: Int = FULL_BRIGHT
+ ) {
+ val client = mc
+ val camera = client.gameRenderer?.camera ?: return
+ val textRenderer = client.textRenderer ?: return
+ val immediate = client.bufferBuilders?.entityVertexConsumers ?: return
+
+ val cameraPos = camera.pos
+
+ val matrices = MatrixStack()
+ matrices.push()
+
+ // Translate to world position relative to camera
+ matrices.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z)
+
+ // Billboard - face camera using camera rotation directly (same as MC's LabelCommandRenderer)
+ matrices.multiply(camera.rotation)
+
+ // Scale with negative Y to flip text vertically (matches MC's 0.025, -0.025, 0.025)
+ matrices.scale(scale, -scale, scale)
+
+ // Calculate text position
+ val textWidth = textRenderer.getWidth(text)
+ val x = if (centered) -textWidth / 2f else 0f
+
+ val layerType =
+ if (seeThrough) TextRenderer.TextLayerType.SEE_THROUGH
+ else TextRenderer.TextLayerType.NORMAL
+
+ // Draw text
+ textRenderer.draw(
+ text,
+ x,
+ 0f,
+ color.rgb,
+ shadow,
+ matrices.peek().positionMatrix,
+ immediate,
+ layerType,
+ backgroundColor,
+ light
+ )
+
+ matrices.pop()
+
+ // Flush immediately for world rendering
+ immediate.draw()
+ }
+
+ /**
+ * Draw text at a world position with an outline effect.
+ *
+ * @param pos World position for the text
+ * @param text The text to render
+ * @param color Text color
+ * @param outlineColor Outline color
+ * @param scale Text scale
+ * @param centered Whether to center the text horizontally
+ * @param light Light level
+ */
+ fun drawTextWithOutline(
+ pos: Vec3d,
+ text: Text,
+ color: Color = Color.WHITE,
+ outlineColor: Color = Color.BLACK,
+ scale: Float = DEFAULT_SCALE,
+ centered: Boolean = true,
+ light: Int = FULL_BRIGHT
+ ) {
+ val client = mc
+ val camera = client.gameRenderer?.camera ?: return
+ val textRenderer = client.textRenderer ?: return
+ val immediate = client.bufferBuilders?.entityVertexConsumers ?: return
+
+ val cameraPos = camera.pos
+
+ val matrices = MatrixStack()
+ matrices.push()
+
+ matrices.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z)
+
+ // Billboard - face camera using camera rotation directly (same as MC's LabelCommandRenderer)
+ matrices.multiply(camera.rotation)
+ matrices.scale(scale, -scale, scale)
+
+ val textWidth = textRenderer.getWidth(text)
+ val x = if (centered) -textWidth / 2f else 0f
+
+ textRenderer.drawWithOutline(
+ text.asOrderedText(),
+ x,
+ 0f,
+ color.rgb,
+ outlineColor.rgb,
+ matrices.peek().positionMatrix,
+ immediate,
+ light
+ )
+
+ matrices.pop()
+ immediate.draw()
+ }
+
+ /** Draw a simple string at a world position. */
+ fun drawString(
+ pos: Vec3d,
+ text: String,
+ color: Color = Color.WHITE,
+ scale: Float = DEFAULT_SCALE,
+ shadow: Boolean = true,
+ seeThrough: Boolean = false,
+ centered: Boolean = true
+ ) {
+ drawText(pos, Text.literal(text), color, scale, shadow, seeThrough, centered)
+ }
+
+ /**
+ * Draw multiple lines of text stacked vertically.
+ *
+ * @param pos World position for the top line
+ * @param lines List of text lines to render
+ * @param color Text color
+ * @param scale Text scale
+ * @param lineSpacing Spacing between lines in scaled units (default 10)
+ */
+ fun drawMultilineText(
+ pos: Vec3d,
+ lines: List,
+ color: Color = Color.WHITE,
+ scale: Float = DEFAULT_SCALE,
+ lineSpacing: Float = 10f,
+ shadow: Boolean = true,
+ seeThrough: Boolean = false,
+ centered: Boolean = true
+ ) {
+ val client = mc
+ val camera = client.gameRenderer?.camera ?: return
+ val textRenderer = client.textRenderer ?: return
+ val immediate = client.bufferBuilders?.entityVertexConsumers ?: return
+
+ val cameraPos = camera.pos
+
+ val matrices = MatrixStack()
+ matrices.push()
+
+ matrices.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z)
+
+ // Billboard - face camera using camera rotation directly (same as MC's LabelCommandRenderer)
+ matrices.multiply(camera.rotation)
+ matrices.scale(scale, -scale, scale)
+
+ val layerType =
+ if (seeThrough) TextRenderer.TextLayerType.SEE_THROUGH
+ else TextRenderer.TextLayerType.NORMAL
+
+ lines.forEachIndexed { index, text ->
+ val textWidth = textRenderer.getWidth(text)
+ val x = if (centered) -textWidth / 2f else 0f
+ val y = index * lineSpacing
+
+ textRenderer.draw(
+ text,
+ x,
+ y,
+ color.rgb,
+ shadow,
+ matrices.peek().positionMatrix,
+ immediate,
+ layerType,
+ 0,
+ FULL_BRIGHT
+ )
+ }
+
+ matrices.pop()
+ immediate.draw()
+ }
+
+ /**
+ * Draw text with a background box.
+ *
+ * @param pos World position
+ * @param text Text to render
+ * @param textColor Text color
+ * @param backgroundColor Background color (with alpha)
+ * @param scale Text scale
+ * @param padding Padding around text in pixels
+ */
+ fun drawTextWithBackground(
+ pos: Vec3d,
+ text: Text,
+ textColor: Color = Color.WHITE,
+ backgroundColor: Color = Color(0, 0, 0, 128),
+ scale: Float = DEFAULT_SCALE,
+ padding: Int = 2,
+ shadow: Boolean = false,
+ seeThrough: Boolean = false,
+ centered: Boolean = true
+ ) {
+ val client = mc
+ client.textRenderer ?: return
+
+ // Calculate background color as ARGB int
+ val bgColorInt =
+ (backgroundColor.alpha shl 24) or
+ (backgroundColor.red shl 16) or
+ (backgroundColor.green shl 8) or
+ backgroundColor.blue
+
+ drawText(
+ pos = pos,
+ text = text,
+ color = textColor,
+ scale = scale,
+ shadow = shadow,
+ seeThrough = seeThrough,
+ centered = centered,
+ backgroundColor = bgColorInt
+ )
+ }
+
+ /** Calculate the width of text in world units at a given scale. */
+ fun getTextWidth(text: Text, scale: Float = DEFAULT_SCALE): Float {
+ val textRenderer = mc.textRenderer ?: return 0f
+ return textRenderer.getWidth(text) * scale
+ }
+
+ /** Calculate the height of text in world units at a given scale. */
+ fun getTextHeight(scale: Float = DEFAULT_SCALE): Float {
+ val textRenderer = mc.textRenderer ?: return 0f
+ return textRenderer.fontHeight * scale
+ }
+}
diff --git a/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt b/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt
deleted file mode 100644
index 03cf28c85..000000000
--- a/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright 2025 Lambda
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-package com.lambda.graphics.renderer.esp
-
-import com.lambda.event.events.RenderEvent
-import com.lambda.event.events.TickEvent
-import com.lambda.event.events.WorldEvent
-import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.event.listener.SafeListener.Companion.listenConcurrently
-import com.lambda.module.Module
-import com.lambda.module.modules.client.StyleEditor
-import com.lambda.threading.awaitMainThread
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.fastVectorOf
-import net.minecraft.world.World
-import net.minecraft.world.chunk.WorldChunk
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.ConcurrentLinkedDeque
-
-class ChunkedESP private constructor(
- owner: Module,
- private val update: ShapeBuilder.(World, FastVector) -> Unit
-) {
- private val rendererMap = ConcurrentHashMap()
- private val WorldChunk.renderer
- get() = rendererMap.getOrPut(pos.toLong()) { EspChunk(this, this@ChunkedESP) }
-
- private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
- private val rebuildQueue = ConcurrentLinkedDeque()
-
- private var ticks = 0
-
- fun rebuild() {
- rebuildQueue.clear()
- rebuildQueue.addAll(rendererMap.values)
- }
-
- init {
- listen { event ->
- world.getWorldChunk(event.pos).renderer.notifyChunks()
- }
-
- listen { event ->
- event.chunk.renderer.notifyChunks()
- }
-
- listen {
- val pos = it.chunk.pos.toLong()
- rendererMap.remove(pos)?.notifyChunks()
- }
-
- owner.listenConcurrently {
- val polls = minOf(StyleEditor.rebuildsPerTick, rebuildQueue.size)
- repeat(polls) { rebuildQueue.poll()?.rebuild() }
- }
-
- owner.listen
-
+
+
-
+
@@ -32,7 +33,7 @@ Find our backup matrix space at [\#lambda-client:matrix.org](https://app.element
### Automation Engine
* **Build Engine:** Full integration with **Litematica** and schematic files for seamless automated building.
-* **Block State Handling:** The build engine natively supports special block states including rotations, attachments (doors, signs, bells), half-slabs, stairs, repeater delay, and even edge cases like flower pots with plants.
+* **Block State Handling:** The build engine natively supports special block states including rotations, attachments (doors, signs, bells), slabs, stairs, repeater delay, and even edge cases like flower pots with plants.
* **Conflict-Free Orchestration:** A centralized manager system handles all core interactions (placing, breaking, rotating, inventory) to ensure zero conflicts between concurrently running modules.
### Unmatched Performance
@@ -55,10 +56,13 @@ Find our backup matrix space at [\#lambda-client:matrix.org](https://app.element
## Installation