fix block entity esp not showing when out of block entity render distance and culling

beanbag44 · beanbag44 · commit 9bd8bf7798b5 · 2026-03-07T13:43:16.000Z
diff --git a/src/main/java/com/lambda/mixin/render/BlockEntityRenderManagerMixin.java b/src/main/java/com/lambda/mixin/render/BlockEntityRenderManagerMixin.java
@@ -30,19 +30,23 @@
 import net.minecraft.client.render.state.CameraRenderState;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 
 @Mixin(BlockEntityRenderManager.class)
 public class BlockEntityRenderManagerMixin {
     @WrapOperation(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/block/entity/BlockEntityRenderer;render(Lnet/minecraft/client/render/block/entity/state/BlockEntityRenderState;Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/command/OrderedRenderCommandQueue;Lnet/minecraft/client/render/state/CameraRenderState;)V"))
-    private <S extends BlockEntityRenderState> void wrapRenderQueue(BlockEntityRenderer<?, S> renderer, S renderState, MatrixStack matrices, OrderedRenderCommandQueue queue, CameraRenderState cameraState, Operation<Void> original) {
+    private <S extends BlockEntityRenderState> void wrapRenderQueue(BlockEntityRenderer<?, S> renderer, S renderState,
+            MatrixStack matrices, OrderedRenderCommandQueue queue, CameraRenderState cameraState,
+            Operation<Void> original) {
         BlockPos pos = renderState.pos;
 
-        if (pos != null && OutlineManager.shouldCapture(pos)) {
+        if (pos != null && OutlineManager.INSTANCE.shouldCapture(pos)) {
             VertexCapture.INSTANCE.beginCapture(pos);
 
-            OrderedRenderCommandQueueImpl wrappedQueue = new OutlineCapturingQueue((OrderedRenderCommandQueueImpl) queue, pos);
+            boolean outlineOnly = !Vec3d.ofCenter(pos).isInRange(cameraState.pos, renderer.getRenderDistance());
+            OrderedRenderCommandQueueImpl wrappedQueue = new OutlineCapturingQueue((OrderedRenderCommandQueueImpl) queue, pos, outlineOnly);
             original.call(renderer, renderState, matrices, wrappedQueue, cameraState);
 
             VertexCapture.INSTANCE.endCapture();
diff --git a/src/main/java/com/lambda/mixin/render/BlockEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/BlockEntityRendererMixin.java
@@ -0,0 +1,21 @@
+package com.lambda.mixin.render;
+
+import com.lambda.graphics.outline.OutlineManager;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.render.block.entity.BlockEntityRenderer;
+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;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(BlockEntityRenderer.class)
+public interface BlockEntityRendererMixin<T extends BlockEntity> {
+
+    @Inject(method = "isInRenderDistance", at = @At("HEAD"), cancellable = true)
+    default void forceOutlineRenderDistance(T blockEntity, Vec3d pos, CallbackInfoReturnable<Boolean> cir) {
+        if (OutlineManager.INSTANCE.shouldCapture(blockEntity.getPos())) {
+            cir.setReturnValue(true);
+        }
+    }
+}
diff --git a/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java b/src/main/java/com/lambda/mixin/render/WorldRendererMixin.java
@@ -17,13 +17,15 @@
 
 package com.lambda.mixin.render;
 
+import com.google.common.collect.Sets;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.RenderEvent;
 import com.lambda.graphics.RenderMain;
 import com.lambda.graphics.outline.OutlineManager;
 import com.lambda.module.modules.player.Freecam;
 import com.lambda.module.modules.render.CameraTweaks;
 import com.lambda.module.modules.render.NoRender;
+import net.minecraft.client.world.ClientWorld;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.llamalad7.mixinextras.injector.ModifyReturnValue;
 import net.minecraft.client.render.*;
@@ -46,17 +48,32 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.render.block.entity.BlockEntityRenderManager;
+import net.minecraft.client.render.block.entity.state.BlockEntityRenderState;
+import net.minecraft.util.math.BlockPos;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Shadow;
+import java.util.Set;
 
 import java.util.Iterator;
 
 @Mixin(WorldRenderer.class)
 public abstract class WorldRendererMixin {
+    @Shadow
+    @Final
+    private BlockEntityRenderManager blockEntityRenderManager;
+    @Shadow
+    private ClientWorld world;
+
     @Unique
     @Nullable
     private Entity lambda$currentEntity;
 
     @Inject(method = "render", at = @At("HEAD"))
-    private void onRender(ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, Matrix4f positionMatrix, Matrix4f basicProjectionMatrix, Matrix4f projectionMatrix, GpuBufferSlice fogBuffer, Vector4f fogColor, boolean renderSky, CallbackInfo ci) {
+    private void onRender(ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline,
+            Camera camera, Matrix4f positionMatrix, Matrix4f basicProjectionMatrix, Matrix4f projectionMatrix,
+            GpuBufferSlice fogBuffer, Vector4f fogColor, boolean renderSky, CallbackInfo ci) {
         RenderMain.updateState(positionMatrix, basicProjectionMatrix, projectionMatrix);
         EventFlow.post(RenderEvent.PreRenderWorld.INSTANCE);
     }
@@ -77,7 +94,9 @@ private boolean renderSetupTerrainModifyArg(boolean spectator) {
     }
 
     @Inject(method = "fillEntityRenderStates", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/entity/EntityRenderManager;shouldRender(Lnet/minecraft/entity/Entity;Lnet/minecraft/client/render/Frustum;DDD)Z", shift = At.Shift.BEFORE), locals = LocalCapture.CAPTURE_FAILHARD)
-    private void injectFillEntityRenderStates(Camera camera, Frustum frustum, RenderTickCounter tickCounter, WorldRenderState renderStates, CallbackInfo ci, Vec3d vec3d, double d, double e, double f, TickManager tickManager, boolean bl, Iterator var14, Entity entity) {
+    private void injectFillEntityRenderStates(Camera camera, Frustum frustum, RenderTickCounter tickCounter,
+            WorldRenderState renderStates, CallbackInfo ci, Vec3d vec3d, double d, double e, double f,
+            TickManager tickManager, boolean bl, Iterator var14, Entity entity) {
         this.lambda$currentEntity = entity;
     }
 
@@ -100,4 +119,25 @@ boolean modHasBlindnessOrDarkness(boolean original) {
 
         return original;
     }
+
+    @Inject(method = "fillBlockEntityRenderStates", at = @At("TAIL"))
+    private void injectOutlineBlockEntities(Camera camera, float tickProgress, WorldRenderState renderStates, CallbackInfo ci) {
+        if (!OutlineManager.INSTANCE.hasBlockOutlines()) return;
+
+        Set<BlockPos> xRayTargets = OutlineManager.INSTANCE.getXrayBlockStyles().keySet();
+        Set<BlockPos> depthTargets = OutlineManager.INSTANCE.getDepthTestedBlockStyles().keySet();
+
+        for (BlockPos target : Sets.union(xRayTargets, depthTargets)) {
+            if (!this.world.getChunkManager().isChunkLoaded(target.getX() >> 4, target.getZ() >> 4)) continue;
+            boolean alreadyCollected = renderStates.blockEntityRenderStates.stream()
+                    .anyMatch(state -> state.pos.equals(target));
+            if (alreadyCollected) continue;
+
+            BlockEntity blockEntity = this.world.getBlockEntity(target);
+            if (blockEntity != null && !blockEntity.isRemoved()) {
+                BlockEntityRenderState state = this.blockEntityRenderManager.getRenderState(blockEntity, tickProgress, null);
+                if (state != null) renderStates.blockEntityRenderStates.add(state);
+            }
+        }
+    }
 }
diff --git a/src/main/kotlin/com/lambda/config/groups/OutlineSettings.kt b/src/main/kotlin/com/lambda/config/groups/OutlineSettings.kt
@@ -40,7 +40,7 @@ class OutlineSettings(
 
 	val fill by c.setting("${prefix}Fill", true, "Fill the entity silhouette", visibility = visibility).group(*baseGroup).index()
 
-	val fillOpacitySetting by c.setting("${prefix}Fill Opacity", 40, 0..100, 1, "Opacity of the fill") { visibility() && fill }.group(*baseGroup).index()
+	val fillOpacitySetting by c.setting("${prefix}Fill Opacity", 10, 0..100, 1, "Opacity of the fill") { visibility() && fill }.group(*baseGroup).index()
 	val fillOpacity get() = fillOpacitySetting * 0.01f
 
 	fun toStyle(color: Color) = OutlineStyle(
diff --git a/src/main/kotlin/com/lambda/graphics/outline/OutlineCapturingQueue.kt b/src/main/kotlin/com/lambda/graphics/outline/OutlineCapturingQueue.kt
@@ -53,9 +53,10 @@ import net.minecraft.text.Text
 import org.joml.Matrix4fStack
 import org.joml.Quaternionf
 
-class OutlineCapturingQueue(
+class OutlineCapturingQueue @JvmOverloads constructor(
     private val delegate: OrderedRenderCommandQueueImpl,
-    private val entityId: Any
+    private val entityId: Any,
+    private val outlineOnly: Boolean = false
 ) : OrderedRenderCommandQueueImpl() {
     override fun clear() = delegate.clear()
     override fun onNextFrame() = delegate.onNextFrame()
@@ -102,30 +103,37 @@ class OutlineCapturingQueue(
             BlockModelRenderer.render(matrices.peek(), consumer, model, r, g, b, l, o)
             consumer.flush()
         }
-        delegate.submitBlockStateModel(matrices, layer, model, r, g, b, l, o, oc)
+        if (!outlineOnly) delegate.submitBlockStateModel(matrices, layer, model, r, g, b, l, o, oc)
     }
 
     override fun getBatchingQueue(i: Int): BatchingRenderCommandQueue =
-        OutlineCapturingBatchingQueue(delegate.getBatchingQueue(i), this)
+        OutlineCapturingBatchingQueue(delegate.getBatchingQueue(i), this, outlineOnly)
 
     private inner class OutlineCapturingBatchingQueue(
         private val batchedDelegate: BatchingRenderCommandQueue,
-        parent: OrderedRenderCommandQueueImpl
+        parent: OrderedRenderCommandQueueImpl,
+        private val outlineOnly: Boolean
     ) : BatchingRenderCommandQueue(parent) {
-        override fun submitShadowPieces(matrices: MatrixStack, radius: Float, pieces: List<EntityRenderState.ShadowPiece>) =
-            batchedDelegate.submitShadowPieces(matrices, radius, pieces)
 
-        override fun submitLabel(matrices: MatrixStack, pos: Vec3d?, y: Int, label: Text, ns: Boolean, l: Int, dist: Double, cam: CameraRenderState) =
-            batchedDelegate.submitLabel(matrices, pos, y, label, ns, l, dist, cam)
+        override fun submitShadowPieces(matrices: MatrixStack, radius: Float, pieces: List<EntityRenderState.ShadowPiece>) {
+            if (!outlineOnly) batchedDelegate.submitShadowPieces(matrices, radius, pieces)
+        }
+
+        override fun submitLabel(matrices: MatrixStack, pos: Vec3d?, y: Int, label: Text, ns: Boolean, l: Int, dist: Double, cam: CameraRenderState) {
+            if (!outlineOnly) batchedDelegate.submitLabel(matrices, pos, y, label, ns, l, dist, cam)
+        }
 
-        override fun submitText(matrices: MatrixStack, x: Float, y: Float, text: OrderedText, ds: Boolean, lt: TextRenderer.TextLayerType, l: Int, c: Int, bc: Int, oc: Int) =
-            batchedDelegate.submitText(matrices, x, y, text, ds, lt, l, c, bc, oc)
+        override fun submitText(matrices: MatrixStack, x: Float, y: Float, text: OrderedText, ds: Boolean, lt: TextRenderer.TextLayerType, l: Int, c: Int, bc: Int, oc: Int) {
+            if (!outlineOnly) batchedDelegate.submitText(matrices, x, y, text, ds, lt, l, c, bc, oc)
+        }
 
-        override fun submitFire(matrices: MatrixStack, state: EntityRenderState, rot: Quaternionf) =
-            batchedDelegate.submitFire(matrices, state, rot)
+        override fun submitFire(matrices: MatrixStack, state: EntityRenderState, rot: Quaternionf) {
+            if (!outlineOnly) batchedDelegate.submitFire(matrices, state, rot)
+        }
 
-        override fun submitLeash(matrices: MatrixStack, data: EntityRenderState.LeashData) =
-            batchedDelegate.submitLeash(matrices, data)
+        override fun submitLeash(matrices: MatrixStack, data: EntityRenderState.LeashData) {
+            if (!outlineOnly) batchedDelegate.submitLeash(matrices, data)
+        }
 
         override fun submitCustom(matrices: MatrixStack, layer: RenderLayer, renderer: OrderedRenderCommandQueue.Custom) {
             if (layer.isOutline || layer.affectedOutline.isPresent) {
@@ -134,11 +142,12 @@ class OutlineCapturingQueue(
                 renderer.render(matrices.peek(), baseConsumer)
                 baseConsumer.flush()
             }
-            batchedDelegate.submitCustom(matrices, layer, renderer)
+            if (!outlineOnly) batchedDelegate.submitCustom(matrices, layer, renderer)
         }
 
-        override fun submitCustom(renderer: OrderedRenderCommandQueue.LayeredCustom) =
-            batchedDelegate.submitCustom(renderer)
+        override fun submitCustom(renderer: OrderedRenderCommandQueue.LayeredCustom) {
+            if (!outlineOnly) batchedDelegate.submitCustom(renderer)
+        }
 
         override fun <S> submitModel(
             model: Model<in S>,
@@ -160,7 +169,7 @@ class OutlineCapturingQueue(
                 model.render(matrices, consumer, light, overlay, tintedColor)
                 baseConsumer.flush()
             }
-            batchedDelegate.submitModel(model, state, matrices, renderLayer, light, overlay, tintedColor, sprite, outlineColor, crumblingOverlay)
+            if (!outlineOnly) batchedDelegate.submitModel(model, state, matrices, renderLayer, light, overlay, tintedColor, sprite, outlineColor, crumblingOverlay)
         }
 
         override fun submitModelPart(
@@ -183,7 +192,7 @@ class OutlineCapturingQueue(
                 part.render(matrices, consumer, light, overlay, tintedColor)
                 baseConsumer.flush()
             }
-            batchedDelegate.submitModelPart(part, matrices, renderLayer, light, overlay, sprite, sheeted, hasGlint, tintedColor, crumblingOverlay, i)
+            if (!outlineOnly) batchedDelegate.submitModelPart(part, matrices, renderLayer, light, overlay, sprite, sheeted, hasGlint, tintedColor, crumblingOverlay, i)
         }
 
         override fun submitBlock(matrices: MatrixStack, state: BlockState, light: Int, overlay: Int, outlineColor: Int) {
@@ -193,7 +202,7 @@ class OutlineCapturingQueue(
             val consumer = CapturingConsumer(null)
             BlockModelRenderer.render(matrices.peek(), consumer, model, 1f, 1f, 1f, light, overlay)
             consumer.flush()
-            batchedDelegate.submitBlock(matrices, state, light, overlay, outlineColor)
+            if (!outlineOnly) batchedDelegate.submitBlock(matrices, state, light, overlay, outlineColor)
         }
 
         override fun submitMovingBlock(matrices: MatrixStack, state: MovingBlockRenderState) {
@@ -203,11 +212,12 @@ class OutlineCapturingQueue(
             val consumer = CapturingConsumer(null)
             BlockModelRenderer.render(matrices.peek(), consumer, model, 1f, 1f, 1f, 0, 0)
             consumer.flush()
-            batchedDelegate.submitMovingBlock(matrices, state)
+            if (!outlineOnly) batchedDelegate.submitMovingBlock(matrices, state)
         }
 
-        override fun submitBlockStateModel(matrices: MatrixStack, layer: RenderLayer, model: BlockStateModel, r: Float, g: Float, b: Float, l: Int, o: Int, oc: Int) =
-            batchedDelegate.submitBlockStateModel(matrices, layer, model, r, g, b, l, o, oc)
+        override fun submitBlockStateModel(matrices: MatrixStack, layer: RenderLayer, model: BlockStateModel, r: Float, g: Float, b: Float, l: Int, o: Int, oc: Int) {
+            if (!outlineOnly) batchedDelegate.submitBlockStateModel(matrices, layer, model, r, g, b, l, o, oc)
+        }
 
         override fun submitItem(
             matrices: MatrixStack,
@@ -242,7 +252,7 @@ class OutlineCapturingQueue(
                     }
                 }
             }
-            batchedDelegate.submitItem(matrices, displayContext, light, overlay, outlineColors, tintLayers, quads, renderLayer, glintType)
+            if (!outlineOnly) batchedDelegate.submitItem(matrices, displayContext, light, overlay, outlineColors, tintLayers, quads, renderLayer, glintType)
         }
 
         override fun getShadowPiecesCommands(): List<ShadowPiecesCommand?>? = batchedDelegate.shadowPiecesCommands
diff --git a/src/main/resources/lambda.mixins.json b/src/main/resources/lambda.mixins.json
@@ -45,6 +45,7 @@
         "render.EntityRenderManagerMixin",
         "render.ItemFrameEntityRendererMixin",
         "render.EntityRenderStateMixin",
+        "render.BlockEntityRendererMixin",
         "render.BlockEntityRenderManagerMixin",
         "render.FluidRendererMixin",
         "render.FogRendererMixin",
