reduce some object churn in rendertickhandler

thiakil · thiakil · commit bddc40f31860 · 2024-04-08T20:21:07.000+08:00
diff --git a/src/main/java/mekanism/client/render/RenderTickHandler.java b/src/main/java/mekanism/client/render/RenderTickHandler.java
@@ -93,6 +93,7 @@
 import net.neoforged.neoforge.common.util.Lazy;
 import net.neoforged.neoforge.event.TickEvent.ClientTickEvent;
 import net.neoforged.neoforge.event.TickEvent.Phase;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Matrix4f;
 import org.joml.Vector3f;
@@ -104,7 +105,7 @@ public class RenderTickHandler {
 
     private static final Map<BlockState, List<Vertex[]>> cachedWireFrames = new HashMap<>();
     private static final Map<Direction, Map<TransmissionType, Model3D>> cachedOverlays = new EnumMap<>(Direction.class);
-    private static final Map<RenderType, List<LazyRender>> transparentRenderers = new HashMap<>();
+    private static final List<LazyRender> transparentRenderers = new ArrayList<>();
     private static final BoltRenderer boltRenderer = new BoltRenderer();
 
     private boolean outliningArea = false;
@@ -144,8 +145,8 @@ public static void guiOpening(ScreenEvent.Opening event) {
         }
     }
 
-    public static void addTransparentRenderer(RenderType renderType, LazyRender render) {
-        transparentRenderers.computeIfAbsent(renderType, r -> new ArrayList<>()).add(render);
+    public static void addTransparentRenderer(LazyRender render) {
+        transparentRenderers.add(render);
     }
 
     @SubscribeEvent
@@ -162,31 +163,19 @@ public void renderWorld(RenderLevelStageEvent event) {
                 profiler.push(ProfilerConstants.DELAYED);
                 if (transparentRenderers.size() == 1) {
                     //If we only have one render type we don't need to bother calculating any distances
-                    for (Entry<RenderType, List<LazyRender>> entry : transparentRenderers.entrySet()) {
-                        doTransparentRender(entry.getKey(), entry.getValue(), camera, renderer, poseStack, renderTick, partialTick, profiler);
-                    }
+                    LazyRender lazyRender = transparentRenderers.get(0);
+                    doTransparentRender(lazyRender.getRenderType(), lazyRender, camera, renderer, poseStack, renderTick, partialTick, profiler);
                 } else {
-                    List<TransparentRenderInfo> toSort = new ArrayList<>(transparentRenderers.size());
-                    for (Entry<RenderType, List<LazyRender>> renderTypeListEntry : transparentRenderers.entrySet()) {
-                        List<LazyRender> renders = renderTypeListEntry.getValue();
-                        double closest = Double.MAX_VALUE;
-                        for (LazyRender render : renders) {
-                            Vec3 renderPos = render.getCenterPos(partialTick);
-                            if (renderPos != null) {
-                                //Note: We can just use the distance sqr as we use it for both things, so they compare the same anyway
-                                double distanceSqr = camera.getPosition().distanceToSqr(renderPos);
-                                if (distanceSqr < closest) {
-                                    closest = distanceSqr;
-                                }
-                            }
-                        }
-                        //Note: we remap it in order to keep track of the closest distance so that we only have to calculate it once
-                        toSort.add(new TransparentRenderInfo(renderTypeListEntry.getKey(), renders, closest));
+
+                    for (LazyRender render : transparentRenderers) {
+                        Vec3 renderPos = render.getCenterPos(partialTick);
+                        //Note: We can just use the distance sqr as we use it for both things, so they compare the same anyway
+                        render.distance = camera.getPosition().distanceToSqr(renderPos);
                     }
                     //Sort in the order of furthest to closest (reverse of by closest)
-                    toSort.sort(Comparator.comparingDouble(info -> -info.closest));
-                    for (TransparentRenderInfo apply : toSort) {
-                        apply.render(camera, renderer, poseStack, renderTick, partialTick, profiler);
+                    transparentRenderers.sort(Comparator.comparingDouble(info -> -info.distance));
+                    for (LazyRender render : transparentRenderers) {
+                        doTransparentRender(render.getRenderType(), render, camera, renderer, poseStack, renderTick, partialTick, profiler);
                     }
                 }
                 transparentRenderers.clear();
@@ -541,41 +530,32 @@ private Model3D getOverlayModel(Direction side, TransmissionType type) {
         return model;
     }
 
-    public interface LazyRender {
+    public static abstract class LazyRender {
 
-        void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler);
+        public double distance;
 
-        @Nullable
-        default Vec3 getCenterPos(float partialTick) {
-            return null;
-        }
+        public abstract void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler);
 
-        @Nullable
-        default String getProfilerSection() {
-            return null;
-        }
-    }
+        @NotNull
+        public abstract Vec3 getCenterPos(float partialTick);
 
-    private record TransparentRenderInfo(RenderType renderType, List<LazyRender> renders, double closest) {
-        private void render(Camera camera, MultiBufferSource.BufferSource renderer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
-            doTransparentRender(renderType, renders, camera, renderer, poseStack, renderTick, partialTick, profiler);
-        }
+        @NotNull
+        public abstract String getProfilerSection();
+
+        @NotNull
+        public abstract RenderType getRenderType();
     }
 
-    private static void doTransparentRender(RenderType renderType, List<LazyRender> renders, Camera camera, BufferSource renderer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
+    private static void doTransparentRender(RenderType renderType, LazyRender transparentRender, Camera camera, BufferSource renderer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
         //Batch all renders for a single render type into a single buffer addition
         VertexConsumer buffer = renderer.getBuffer(renderType);
-        for (LazyRender transparentRender : renders) {
-            String profilerSection = transparentRender.getProfilerSection();
-            if (profilerSection != null) {
-                profiler.push(profilerSection);
-            }
-            //Note: We don't bother sorting renders in a specific render type as we assume the render type has sortOnUpload as true
-            transparentRender.render(camera, buffer, poseStack, renderTick, partialTick, profiler);
-            if (profilerSection != null) {
-                profiler.pop();
-            }
-        }
+
+        String profilerSection = transparentRender.getProfilerSection();
+        profiler.push(profilerSection);
+        //Note: We don't bother sorting renders in a specific render type as we assume the render type has sortOnUpload as true
+        transparentRender.render(camera, buffer, poseStack, renderTick, partialTick, profiler);
+        profiler.pop();
+
         renderer.endBatch(renderType);
     }
 }
diff --git a/src/main/java/mekanism/client/render/lib/effect/BillboardingEffectRenderer.java b/src/main/java/mekanism/client/render/lib/effect/BillboardingEffectRenderer.java
@@ -8,9 +8,11 @@
 import mekanism.client.render.RenderTickHandler.LazyRender;
 import mekanism.common.lib.effect.CustomEffect;
 import net.minecraft.client.Camera;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.util.profiling.ProfilerFiller;
 import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
 import org.joml.Matrix4f;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
@@ -25,21 +27,29 @@ public static void render(CustomEffect effect, String profilerSection) {
     }
 
     public static void render(ResourceLocation texture, String profilerSection, Supplier<CustomEffect> lazyEffect) {
-        RenderTickHandler.addTransparentRenderer(MekanismRenderType.SPS.apply(texture), new LazyRender() {
+        RenderType renderType = MekanismRenderType.SPS.apply(texture);
+        RenderTickHandler.addTransparentRenderer(new LazyRender() {
             @Override
             public void render(Camera camera, VertexConsumer renderer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
                 BillboardingEffectRenderer.render(camera, renderer, poseStack, renderTick, partialTick, lazyEffect.get());
             }
 
             @Override
+            @NotNull
             public Vec3 getCenterPos(float partialTick) {
                 return lazyEffect.get().getPos(partialTick);
             }
 
             @Override
+            @NotNull
             public String getProfilerSection() {
                 return profilerSection;
             }
+
+            @Override
+            public @NotNull RenderType getRenderType() {
+                return renderType;
+            }
         });
     }
 
diff --git a/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java b/src/main/java/mekanism/client/render/tileentity/RenderEnergyCube.java
@@ -14,9 +14,11 @@
 import net.minecraft.client.Camera;
 import net.minecraft.client.renderer.LightTexture;
 import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
 import net.minecraft.util.profiling.ProfilerFiller;
 import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
 import org.joml.Vector3f;
 
 @NothingNullByDefault
@@ -33,7 +35,7 @@ protected void render(TileEntityEnergyCube tile, float partialTicks, PoseStack m
         float energyScale = tile.getEnergyScale();
         Vec3 renderPos = tile.getBlockPos().getCenter();
         BaseTier baseTier = tile.getTier().getBaseTier();
-        RenderTickHandler.addTransparentRenderer(ModelEnergyCore.BATCHED_RENDER_TYPE, new LazyRender() {
+        RenderTickHandler.addTransparentRenderer(new LazyRender() {
             @Override
             public void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
                 float ticks = renderTick + partialTick;
@@ -50,14 +52,22 @@ public void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, in
             }
 
             @Override
+            @NotNull
             public Vec3 getCenterPos(float partialTick) {
                 return renderPos;
             }
 
             @Override
+            @NotNull
             public String getProfilerSection() {
                 return ProfilerConstants.ENERGY_CUBE_CORE;
             }
+
+            @Override
+            @NotNull
+            public RenderType getRenderType() {
+                return ModelEnergyCore.BATCHED_RENDER_TYPE;
+            }
         });
     }
 
diff --git a/src/main/java/mekanism/client/render/tileentity/RenderIndustrialAlarm.java b/src/main/java/mekanism/client/render/tileentity/RenderIndustrialAlarm.java
@@ -12,9 +12,11 @@
 import net.minecraft.client.Camera;
 import net.minecraft.client.renderer.LightTexture;
 import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
 import net.minecraft.util.profiling.ProfilerFiller;
 import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
 
 @NothingNullByDefault
 public class RenderIndustrialAlarm extends ModelTileEntityRenderer<TileEntityIndustrialAlarm, ModelIndustrialAlarm> {
@@ -28,7 +30,7 @@ public RenderIndustrialAlarm(BlockEntityRendererProvider.Context context) {
     @Override
     protected void render(TileEntityIndustrialAlarm tile, float partialTicks, PoseStack matrix, MultiBufferSource renderer, int light, int overlayLight,
           ProfilerFiller profiler) {
-        RenderTickHandler.addTransparentRenderer(model.getRenderType(), new LazyRender() {
+        RenderTickHandler.addTransparentRenderer(new LazyRender() {
             @Override
             public void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, int renderTick, float partialTick, ProfilerFiller profiler) {
                 float rot = (renderTick + partialTick) * ROTATE_SPEED % 360;
@@ -63,15 +65,23 @@ public void render(Camera camera, VertexConsumer buffer, PoseStack poseStack, in
             }
 
             @Override
+            @NotNull
             public Vec3 getCenterPos(float partialTick) {
                 //Centered position, does not need to be cached as it is only called once
                 return tile.getBlockPos().getCenter();
             }
 
             @Override
+            @NotNull
             public String getProfilerSection() {
                 return ProfilerConstants.INDUSTRIAL_ALARM;
             }
+
+            @Override
+            @NotNull
+            public RenderType getRenderType() {
+                return model.getRenderType();
+            }
         });
     }
 
