From 22a51250b88d8f4868bac279db310fce48ed84c9 Mon Sep 17 00:00:00 2001 From: Silver_David Date: Sun, 17 Jul 2022 10:33:26 -0400 Subject: [PATCH] [1.18.x] Add RenderLevelStageEvent to expand on and replace RenderLevelLastEvent (#8603) --- .../net/minecraft/client/Minecraft.java.patch | 7 +- .../client/renderer/LevelRenderer.java.patch | 33 ++- .../client/ForgeHooksClient.java | 17 ++ .../client/ForgeRenderTypes.java | 25 ++- .../client/event/RenderLevelLastEvent.java | 5 + .../client/event/RenderLevelStageEvent.java | 209 ++++++++++++++++++ .../client/rendering/RenderableTest.java | 111 ++++++++-- 7 files changed, 384 insertions(+), 23 deletions(-) create mode 100644 src/main/java/net/minecraftforge/client/event/RenderLevelStageEvent.java diff --git a/patches/minecraft/net/minecraft/client/Minecraft.java.patch b/patches/minecraft/net/minecraft/client/Minecraft.java.patch index 7172b87a9a..f5889b98d5 100644 --- a/patches/minecraft/net/minecraft/client/Minecraft.java.patch +++ b/patches/minecraft/net/minecraft/client/Minecraft.java.patch @@ -49,7 +49,12 @@ this.f_91038_.m_10506_(); this.f_91066_.m_92145_(this.f_91038_); this.f_91039_ = new LanguageManager(this.f_91066_.f_92075_); -@@ -504,6 +_,7 @@ +@@ -500,10 +_,12 @@ + this.f_91052_ = new BlockRenderDispatcher(this.f_91051_.m_119430_(), blockentitywithoutlevelrenderer, this.f_91040_); + this.f_91036_.m_7217_(this.f_91052_); + this.f_91060_ = new LevelRenderer(this, this.f_90993_); ++ net.minecraftforge.fml.ModLoader.get().postEvent(new net.minecraftforge.client.event.RenderLevelStageEvent.RegisterStageEvent()); + this.f_91036_.m_7217_(this.f_91060_); this.m_91271_(); this.f_91036_.m_7217_(this.f_90997_); this.f_91061_ = new ParticleEngine(this.f_91073_, this.f_90987_); diff --git a/patches/minecraft/net/minecraft/client/renderer/LevelRenderer.java.patch b/patches/minecraft/net/minecraft/client/renderer/LevelRenderer.java.patch index 6ca654e814..615c17762f 100644 --- a/patches/minecraft/net/minecraft/client/renderer/LevelRenderer.java.patch +++ b/patches/minecraft/net/minecraft/client/renderer/LevelRenderer.java.patch @@ -24,7 +24,7 @@ float f = this.f_109461_.f_91073_.m_46722_(1.0F) / (Minecraft.m_91405_() ? 1.0F : 2.0F); if (!(f <= 0.0F)) { Random random = new Random((long)this.f_109477_ * 312987231L); -@@ -1134,20 +_,23 @@ +@@ -1134,20 +_,24 @@ RenderSystem.m_69421_(16640, Minecraft.f_91002_); float f = p_109605_.m_109152_(); boolean flag2 = this.f_109461_.f_91073_.m_104583_().m_5781_(Mth.m_14107_(d0), Mth.m_14107_(d1)) || this.f_109461_.f_91065_.m_93090_().m_93715_(); @@ -35,6 +35,7 @@ - FogRenderer.m_109024_(p_109604_, FogRenderer.FogMode.FOG_SKY, f, flag2); + FogRenderer.setupFog(p_109604_, FogRenderer.FogMode.FOG_SKY, f, flag2, p_109601_); }); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(net.minecraftforge.client.event.RenderLevelStageEvent.Stage.AFTER_SKY, this, p_109600_, p_109607_, this.f_109477_, p_109604_, frustum); profilerfiller.m_6182_("fog"); - FogRenderer.m_109024_(p_109604_, FogRenderer.FogMode.FOG_TERRAIN, Math.max(f, 32.0F), flag2); + FogRenderer.setupFog(p_109604_, FogRenderer.FogMode.FOG_TERRAIN, Math.max(f, 32.0F), flag2, p_109601_); @@ -89,24 +90,50 @@ } PoseStack posestack = RenderSystem.m_157191_(); -@@ -1333,7 +_,7 @@ +@@ -1333,7 +_,8 @@ this.f_109415_.m_83945_(this.f_109461_.m_91385_()); RenderStateShard.f_110126_.m_110185_(); profilerfiller.m_6182_("particles"); - this.f_109461_.f_91061_.m_107336_(p_109600_, multibuffersource$buffersource, p_109606_, p_109604_, p_109601_); + this.f_109461_.f_91061_.render(p_109600_, multibuffersource$buffersource, p_109606_, p_109604_, p_109601_, frustum); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(net.minecraftforge.client.event.RenderLevelStageEvent.Stage.AFTER_PARTICLES, this, p_109600_, p_109607_, this.f_109477_, p_109604_, frustum); RenderStateShard.f_110126_.m_110188_(); } else { profilerfiller.m_6182_("translucent"); -@@ -1347,7 +_,7 @@ +@@ -1347,7 +_,8 @@ profilerfiller.m_6182_("string"); this.m_172993_(RenderType.m_110503_(), p_109600_, d0, d1, d2, p_109607_); profilerfiller.m_6182_("particles"); - this.f_109461_.f_91061_.m_107336_(p_109600_, multibuffersource$buffersource, p_109606_, p_109604_, p_109601_); + this.f_109461_.f_91061_.render(p_109600_, multibuffersource$buffersource, p_109606_, p_109604_, p_109601_, frustum); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(net.minecraftforge.client.event.RenderLevelStageEvent.Stage.AFTER_PARTICLES, this, p_109600_, p_109607_, this.f_109477_, p_109604_, frustum); } posestack.m_85836_(); +@@ -1371,6 +_,7 @@ + RenderStateShard.f_110127_.m_110185_(); + profilerfiller.m_6182_("weather"); + this.m_109703_(p_109606_, p_109601_, d0, d1, d2); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(net.minecraftforge.client.event.RenderLevelStageEvent.Stage.AFTER_WEATHER, this, p_109600_, p_109607_, this.f_109477_, p_109604_, frustum); + this.m_173012_(p_109604_); + RenderStateShard.f_110127_.m_110188_(); + this.f_109418_.m_110023_(p_109601_); +@@ -1379,6 +_,7 @@ + RenderSystem.m_69458_(false); + profilerfiller.m_6182_("weather"); + this.m_109703_(p_109606_, p_109601_, d0, d1, d2); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(net.minecraftforge.client.event.RenderLevelStageEvent.Stage.AFTER_WEATHER, this, p_109600_, p_109607_, this.f_109477_, p_109604_, frustum); + this.m_173012_(p_109604_); + RenderSystem.m_69458_(true); + } +@@ -1521,6 +_,7 @@ + VertexBuffer.m_85931_(); + VertexBuffer.m_166875_(); + this.f_109461_.m_91307_().m_7238_(); ++ net.minecraftforge.client.ForgeHooksClient.dispatchRenderStage(p_172994_, this, p_172995_, p_172999_, this.f_109477_, this.f_109461_.f_91063_.m_109153_(), this.f_109442_ != null ? this.f_109442_ : this.f_172938_); + p_172994_.m_110188_(); + } + @@ -1783,6 +_,11 @@ public void m_202423_(PoseStack p_202424_, Matrix4f p_202425_, float p_202426_, Camera p_202427_, boolean p_202428_, Runnable p_202429_) { diff --git a/src/main/java/net/minecraftforge/client/ForgeHooksClient.java b/src/main/java/net/minecraftforge/client/ForgeHooksClient.java index ba048d0dc1..63303b1bd2 100755 --- a/src/main/java/net/minecraftforge/client/ForgeHooksClient.java +++ b/src/main/java/net/minecraftforge/client/ForgeHooksClient.java @@ -54,6 +54,7 @@ import net.minecraft.client.color.item.ItemColors; import net.minecraft.client.model.HumanoidModel; import net.minecraft.client.resources.model.BakedModel; import net.minecraft.client.renderer.block.model.ItemTransforms; +import net.minecraft.client.renderer.culling.Frustum; import net.minecraft.client.resources.model.ModelManager; import net.minecraft.client.resources.model.Material; import net.minecraft.client.renderer.texture.TextureAtlas; @@ -224,11 +225,27 @@ public class ForgeHooksClient } } + @Deprecated(forRemoval = true, since = "1.18.2") public static void dispatchRenderLast(LevelRenderer context, PoseStack poseStack, float partialTick, Matrix4f projectionMatrix, long finishTimeNano) { MinecraftForge.EVENT_BUS.post(new RenderLevelLastEvent(context, poseStack, partialTick, projectionMatrix, finishTimeNano)); } + public static void dispatchRenderStage(RenderLevelStageEvent.Stage stage, LevelRenderer levelRenderer, PoseStack poseStack, Matrix4f projectionMatrix, int renderTick, Camera camera, Frustum frustum) + { + var profiler = Minecraft.getInstance().getProfiler(); + profiler.push(stage.toString()); + MinecraftForge.EVENT_BUS.post(new RenderLevelStageEvent(stage, levelRenderer, poseStack, projectionMatrix, renderTick, MinecraftForgeClient.getPartialTick(), camera, frustum)); + profiler.pop(); + } + + public static void dispatchRenderStage(RenderType renderType, LevelRenderer levelRenderer, PoseStack poseStack, Matrix4f projectionMatrix, int renderTick, Camera camera, Frustum frustum) + { + RenderLevelStageEvent.Stage stage = RenderLevelStageEvent.Stage.fromRenderType(renderType); + if (stage != null) + dispatchRenderStage(stage, levelRenderer, poseStack, projectionMatrix, renderTick, camera, frustum); + } + public static boolean renderSpecificFirstPersonHand(InteractionHand hand, PoseStack poseStack, MultiBufferSource bufferSource, int packedLight, float partialTick, float interpPitch, float swingProgress, float equipProgress, ItemStack stack) { return MinecraftForge.EVENT_BUS.post(new RenderHandEvent(hand, poseStack, bufferSource, packedLight, partialTick, interpPitch, swingProgress, equipProgress, stack)); diff --git a/src/main/java/net/minecraftforge/client/ForgeRenderTypes.java b/src/main/java/net/minecraftforge/client/ForgeRenderTypes.java index 7035a6aa95..27ecfba923 100644 --- a/src/main/java/net/minecraftforge/client/ForgeRenderTypes.java +++ b/src/main/java/net/minecraftforge/client/ForgeRenderTypes.java @@ -10,6 +10,7 @@ import com.mojang.datafixers.util.Pair; import net.minecraft.Util; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.RenderStateShard; +import net.minecraft.client.renderer.RenderStateShard.OutputStateShard; import net.minecraft.client.renderer.RenderStateShard.TextureStateShard; import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.ShaderInstance; @@ -20,6 +21,7 @@ import net.minecraft.client.renderer.texture.TextureManager; import net.minecraft.resources.ResourceLocation; import net.minecraft.server.packs.resources.ResourceManager; import net.minecraftforge.client.event.RegisterShadersEvent; +import net.minecraftforge.client.event.RenderLevelStageEvent; import net.minecraftforge.common.util.NonNullLazy; import net.minecraftforge.common.util.NonNullSupplier; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -42,7 +44,8 @@ public enum ForgeRenderTypes ITEM_LAYERED_TRANSLUCENT(()-> getItemLayeredTranslucent(TextureAtlas.LOCATION_BLOCKS)), ITEM_UNSORTED_TRANSLUCENT(()-> getUnsortedTranslucent(TextureAtlas.LOCATION_BLOCKS)), ITEM_UNLIT_TRANSLUCENT(()-> getUnlitTranslucent(TextureAtlas.LOCATION_BLOCKS)), - ITEM_UNSORTED_UNLIT_TRANSLUCENT(()-> getUnlitTranslucent(TextureAtlas.LOCATION_BLOCKS, false)); + ITEM_UNSORTED_UNLIT_TRANSLUCENT(()-> getUnlitTranslucent(TextureAtlas.LOCATION_BLOCKS, false)), + TRANSLUCENT_ON_PARTICLES_TARGET(() -> getTranslucentParticlesTarget(TextureAtlas.LOCATION_BLOCKS)); public static boolean enableTextTextureLinearFiltering = false; @@ -161,6 +164,14 @@ public enum ForgeRenderTypes return Internal.TEXT_INTENSITY_SEETHROUGH.apply(locationIn); } + /** + * @return A variation of {@link RenderType#translucent()} that uses {@link OutputStateShard#PARTICLES_TARGET} to allow fabulous transparency sorting when using {@link RenderLevelStageEvent} + */ + public static RenderType getTranslucentParticlesTarget(ResourceLocation locationIn) + { + return Internal.TRANSLUCENT_PARTICLES_TARGET.apply(locationIn); + } + // ---------------------------------------- // Implementation details below this line // ---------------------------------------- @@ -350,6 +361,18 @@ public enum ForgeRenderTypes .createCompositeState(false); return create("forge_text_see_through", DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP, VertexFormat.Mode.QUADS, 256, false, true, rendertype$state); } + + public static Function TRANSLUCENT_PARTICLES_TARGET = Util.memoize(Internal::getTranslucentParticlesTarget); + private static RenderType getTranslucentParticlesTarget(ResourceLocation locationIn) { + RenderType.CompositeState rendertype$state = RenderType.CompositeState.builder() + .setShaderState(RENDERTYPE_TRANSLUCENT_SHADER) + .setTextureState(new RenderStateShard.TextureStateShard(locationIn, false, true)) + .setTransparencyState(TRANSLUCENT_TRANSPARENCY) + .setLightmapState(LIGHTMAP) + .setOutputState(PARTICLES_TARGET) + .createCompositeState(true); + return create("forge_translucent_particles_target", DefaultVertexFormat.BLOCK, VertexFormat.Mode.QUADS, 2097152, true, true, rendertype$state); + } } private static class CustomizableTextureState extends TextureStateShard diff --git a/src/main/java/net/minecraftforge/client/event/RenderLevelLastEvent.java b/src/main/java/net/minecraftforge/client/event/RenderLevelLastEvent.java index 7ac4320132..68d036a22e 100644 --- a/src/main/java/net/minecraftforge/client/event/RenderLevelLastEvent.java +++ b/src/main/java/net/minecraftforge/client/event/RenderLevelLastEvent.java @@ -10,6 +10,11 @@ import com.mojang.blaze3d.vertex.PoseStack; import net.minecraft.client.renderer.LevelRenderer; import com.mojang.math.Matrix4f; +/** + * @deprecated Use {@link RenderLevelStageEvent} instead for more flexibility and improved compatibility with translucent objects. + * There is no {@link RenderLevelStageEvent.Stage} that directly replaces this event, instead you must decide which Stage best fits your use case. + */ +@Deprecated(forRemoval = true, since = "1.18.2") public class RenderLevelLastEvent extends net.minecraftforge.eventbus.api.Event { private final LevelRenderer levelRenderer; diff --git a/src/main/java/net/minecraftforge/client/event/RenderLevelStageEvent.java b/src/main/java/net/minecraftforge/client/event/RenderLevelStageEvent.java new file mode 100644 index 0000000000..93d70f40af --- /dev/null +++ b/src/main/java/net/minecraftforge/client/event/RenderLevelStageEvent.java @@ -0,0 +1,209 @@ +/* + * Copyright (c) Forge Development LLC and contributors + * SPDX-License-Identifier: LGPL-2.1-only + */ + +package net.minecraftforge.client.event; + +import java.util.HashMap; +import java.util.Map; + +import javax.annotation.Nullable; + +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.math.Matrix4f; + +import net.minecraft.client.Camera; +import net.minecraft.client.renderer.LevelRenderer; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.client.renderer.culling.Frustum; +import net.minecraft.resources.ResourceLocation; +import net.minecraftforge.client.ForgeRenderTypes; +import net.minecraftforge.eventbus.api.Event; +import net.minecraftforge.fml.event.IModBusEvent; + +/** + * Fires at various times during LevelRenderer.renderLevel. + * Check {@link #getStage} to render during the appropriate time for your use case. + */ +public class RenderLevelStageEvent extends Event +{ + private final Stage stage; + private final LevelRenderer levelRenderer; + private final PoseStack poseStack; + private final Matrix4f projectionMatrix; + private final int renderTick; + private final float partialTick; + private final Camera camera; + private final Frustum frustum; + + public RenderLevelStageEvent(Stage stage, LevelRenderer levelRenderer, PoseStack poseStack, Matrix4f projectionMatrix, int renderTick, float partialTick, Camera camera, Frustum frustum) + { + this.stage = stage; + this.levelRenderer = levelRenderer; + this.poseStack = poseStack; + this.projectionMatrix = projectionMatrix; + this.renderTick = renderTick; + this.partialTick = partialTick; + this.camera = camera; + this.frustum = frustum; + } + + /** + * {@return the current {@link Stage} that is being rendered. Check this before doing rendering to ensure + * that rendering happens at the appropriate time.} + */ + public Stage getStage() + { + return stage; + } + + public LevelRenderer getLevelRenderer() + { + return levelRenderer; + } + + public PoseStack getPoseStack() + { + return poseStack; + } + + public Matrix4f getProjectionMatrix() + { + return projectionMatrix; + } + + /** + * {@return the current "ticks" value in {@link LevelRenderer}} + */ + public int getRenderTick() + { + return renderTick; + } + + /** + * {@return the current partialTick value at the start of LevelRenderer.renderChunkLayer} + */ + public float getPartialTick() + { + return partialTick; + } + + public Camera getCamera() + { + return camera; + } + + public Frustum getFrustum() + { + return frustum; + } + + /** + * Use to create a custom {@link RenderLevelStageEvent.Stage}s. + * Fired after the LevelRenderer has been created. + * + * Fired on the Mod bus {@link IModBusEvent} + */ + public static class RegisterStageEvent extends Event implements IModBusEvent + { + /** + * @param name The name of your Stage. + * @param renderType + * If not null, called automatically by LevelRenderer.renderChunkLayer if the RenderType passed into it matches this one. + * If null, needs to be called manually by whoever implements it. + * + * @throws IllegalArgumentException if the RenderType passed is already mapped to a Stage. + */ + public Stage register(ResourceLocation name, @Nullable RenderType renderType) throws IllegalArgumentException + { + return Stage.register(name, renderType); + } + } + + /** + * A time during level rendering for you to render custom things into the world. + * @see RegisterStageEvent + */ + public static class Stage + { + private static final Map RENDER_TYPE_STAGES = new HashMap<>(); + + /** + * Use this to render custom objects into the skybox. + * Called regardless of if they sky actually renders or not. + */ + public static final Stage AFTER_SKY = register("after_sky", null); + /** + * Use this to render custom block-like geometry into the world. + */ + public static final Stage AFTER_SOLID_BLOCKS = register("after_solid_blocks", RenderType.solid()); + /** + * Use this to render custom block-like geometry into the world. + */ + public static final Stage AFTER_CUTOUT_MIPPED_BLOCKS_BLOCKS = register("after_cutout_mipped_blocks", RenderType.cutoutMipped()); + /** + * Use this to render custom block-like geometry into the world. + */ + public static final Stage AFTER_CUTOUT_BLOCKS = register("after_cutout_blocks", RenderType.cutout()); + /** + * Use this to render custom block-like geometry into the world. + * Due to how transparency sorting works, this stage may not work properly with translucency. If you intend to render translucency, + * try using {@link #AFTER_TRIPWIRE_BLOCKS} or {@link #AFTER_PARTICLES}. + * Although this is called within a fabulous graphics target, it does not function properly in many cases. + */ + public static final Stage AFTER_TRANSLUCENT_BLOCKS = register("after_translucent_blocks", RenderType.translucent()); + /** + * Use this to render custom block-like geometry into the world. + */ + public static final Stage AFTER_TRIPWIRE_BLOCKS = register("after_tripwire_blocks", RenderType.tripwire()); + /** + * Use this to render custom effects into the world, such as custom entity-like objects or special rendering effects. + * Called within a fabulous graphics target. + * Happens after entities render. + * + * @see ForgeRenderTypes#TRANSLUCENT_ON_PARTICLES_TARGET + */ + public static final Stage AFTER_PARTICLES = register("after_particles", null); + /** + * Use this to render custom weather effects into the world. + * Called within a fabulous graphics target. + */ + public static final Stage AFTER_WEATHER = register("after_weather", null); + + private final String name; + + private Stage(String name) + { + this.name = name; + } + + private static Stage register(ResourceLocation name, @Nullable RenderType renderType) throws IllegalArgumentException + { + Stage stage = new Stage(name.toString()); + if (renderType != null && RENDER_TYPE_STAGES.putIfAbsent(renderType, stage) != null) + throw new IllegalArgumentException("Attempted to replace an existing RenderLevelStageEvent.Stage for a RenderType: Stage = " + stage + ", RenderType = " + renderType); + return stage; + } + + private static Stage register(String name, @Nullable RenderType renderType) throws IllegalArgumentException + { + return register(new ResourceLocation(name), renderType); + } + + @Override + public String toString() + { + return this.name; + } + + /** + * {@return the Stage bound to the RenderType, or null if no value is present} + */ + @Nullable + public static Stage fromRenderType(RenderType renderType) + { + return RENDER_TYPE_STAGES.get(renderType); + } + } +} diff --git a/src/test/java/net/minecraftforge/debug/client/rendering/RenderableTest.java b/src/test/java/net/minecraftforge/debug/client/rendering/RenderableTest.java index 9388c67f12..df91c00766 100644 --- a/src/test/java/net/minecraftforge/debug/client/rendering/RenderableTest.java +++ b/src/test/java/net/minecraftforge/debug/client/rendering/RenderableTest.java @@ -5,21 +5,33 @@ package net.minecraftforge.debug.client.rendering; +import java.util.Map; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + import com.google.common.collect.ImmutableMap; +import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.math.Matrix4f; import com.mojang.math.Quaternion; + import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.LightTexture; import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.texture.OverlayTexture; +import net.minecraft.core.BlockPos; import net.minecraft.resources.ResourceLocation; import net.minecraft.server.packs.resources.ResourceManager; import net.minecraft.server.packs.resources.SimplePreparableReloadListener; import net.minecraft.util.profiling.ProfilerFiller; +import net.minecraft.world.phys.Vec3; import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.client.ForgeRenderTypes; import net.minecraftforge.client.event.ModelRegistryEvent; import net.minecraftforge.client.event.RegisterClientReloadListenersEvent; import net.minecraftforge.client.event.RenderLevelLastEvent; +import net.minecraftforge.client.event.RenderLevelStageEvent; +import net.minecraftforge.client.event.RenderLevelStageEvent.Stage; import net.minecraftforge.client.model.ForgeModelBakery; import net.minecraftforge.client.model.StandaloneModelConfiguration; import net.minecraftforge.client.model.data.EmptyModelData; @@ -30,19 +42,29 @@ import net.minecraftforge.client.model.renderable.BakedRenderable; import net.minecraftforge.client.model.renderable.IRenderable; import net.minecraftforge.client.model.renderable.MultipartTransforms; import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.eventbus.api.Event; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; import net.minecraftforge.fml.loading.FMLEnvironment; -import java.util.Map; - +/** + * This mod is testing the use of {@link RenderLevelStageEvent} and is a modifaction of a pre-existing test mod that used the old + * {@link RenderLevelLastEvent}. To restore the old behavior, set {@link #USE_LEVEL_RENDERER_STAGE} to false. + * + * When you enter a world, there should be 6 sugar gliders rendering at (0, 120, 0) that test the various stages in {@link RenderLevelStageEvent}. + * From left to right (with the sugar gliders facing you) they represent {@link Stage#AFTER_SKY}, {@link Stage#AFTER_SOLID_BLOCKS}, + * {@link Stage#AFTER_TRANSLUCENT_BLOCKS}, {@link Stage#AFTER_TRIPWIRE_BLOCKS}, {@link Stage#AFTER_PARTICLES}, and {@link Stage#AFTER_WEATHER}. + * Due to how weather modifies the projection matrix, it's sugar glider will be positioned weirdly. Below each sugar gliders is a render of + * blue stained glass to test translucency with fabulous graphics. {@link Stage#AFTER_PARTICLES} will render the stained glass using + * {@link ForgeRenderTypes#TRANSLUCENT_ON_PARTICLES_TARGET}. + */ @Mod(RenderableTest.MODID) public class RenderableTest { public static final String MODID = "renderable_test"; + private static final Logger LOGGER = LogManager.getLogger(); - public static final boolean ENABLED = false; + public static final boolean ENABLED = true; // Renders at (0, 120, 0) + public static final boolean USE_LEVEL_RENDERER_STAGE = true; // True when using RenderLevelStageEvent. False when using RenderLevelLastEvent public RenderableTest() { @@ -57,17 +79,24 @@ public class RenderableTest private static class Client { - private static ResourceLocation MODEL_LOC = new ResourceLocation("minecraft:block/diamond_block"); + private static ResourceLocation MODEL_LOC = new ResourceLocation("minecraft:block/blue_stained_glass"); private static IRenderable renderable; private static IRenderable bakedRenderable; public static void init() { - var bus = FMLJavaModLoadingContext.get().getModEventBus(); - bus.addListener(Client::registerModels); - bus.addListener(Client::registerReloadListeners); - MinecraftForge.EVENT_BUS.addListener(Client::renderLast); + var modBus = FMLJavaModLoadingContext.get().getModEventBus(); + var forgeBus = MinecraftForge.EVENT_BUS; + modBus.addListener(Client::registerModels); + modBus.addListener(Client::registerReloadListeners); + if (USE_LEVEL_RENDERER_STAGE) + { + modBus.addListener(Client::registerStage); + forgeBus.addListener(Client::renderStage); + } + else + forgeBus.addListener(Client::renderLast); } private static void registerModels(ModelRegistryEvent t) @@ -104,42 +133,88 @@ public class RenderableTest }); } - private static double time; + public static void registerStage(RenderLevelStageEvent.RegisterStageEvent event) + { + var stage = event.register(new ResourceLocation(MODID, "test_stage"), null); + LOGGER.info("Registered RenderLevelStageEvent.Stage: {}", stage); + } public static void renderLast(RenderLevelLastEvent event) { + Vec3 cam = Minecraft.getInstance().gameRenderer.getMainCamera().getPosition(); + render(Stage.AFTER_SKY, event.getPoseStack(), 0, event.getPartialTick(), cam.x, cam.y, cam.z, 0); + } + + private static void renderStage(RenderLevelStageEvent event) + { + int xOffset = -1; + var stage = event.getStage(); + if (stage == Stage.AFTER_SKY) + xOffset = 0; + else if (stage == Stage.AFTER_SOLID_BLOCKS) + xOffset = 1; + else if (stage == Stage.AFTER_TRANSLUCENT_BLOCKS) + xOffset = 2; + else if (stage == Stage.AFTER_TRIPWIRE_BLOCKS) + xOffset = 3; + else if (stage == Stage.AFTER_PARTICLES) + xOffset = 4; + else if (stage == Stage.AFTER_WEATHER) + xOffset = 5; + + Vec3 cam = event.getCamera().getPosition(); + if (xOffset > -1) + render(stage, event.getPoseStack(), event.getRenderTick(), event.getPartialTick(), cam.x, cam.y, cam.z, xOffset); + } + + private static void render(Stage stage, PoseStack poseStack, int renderTick, float partialTick, double camX, double camY, double camZ, int xOffset) + { + double x = camX, y = camY, z = camZ; + if (!new BlockPos(0, y, 0).closerThan(new BlockPos(x, y, z), 100)) + return; + + var profiler = Minecraft.getInstance().getProfiler(); + profiler.push("renderable_test"); if (bakedRenderable == null) { bakedRenderable = BakedRenderable.of(MODEL_LOC); } - var poseStack = event.getPoseStack(); var bufferSource = Minecraft.getInstance().renderBuffers().bufferSource(); - time += Minecraft.getInstance().getDeltaFrameTime(); + double time = renderTick + partialTick; var map = ImmutableMap.builder(); var left = new Matrix4f(); left.setIdentity(); - left.multiply(Quaternion.fromYXZ(0, 0, (float)Math.sin(time * 0.05) * 0.1f)); + left.multiply(Quaternion.fromYXZ(0, 0, (float)Math.sin(time * 0.4) * 0.1f)); map.put("object_1", left); var right = new Matrix4f(); right.setIdentity(); - right.multiply(Quaternion.fromYXZ(0, 0, -(float)Math.sin(time * 0.05) * 0.1f)); + right.multiply(Quaternion.fromYXZ(0, 0, -(float)Math.sin(time * 0.4) * 0.1f)); map.put("object_9", right); var transforms = MultipartTransforms.of(map.build()); - renderable.render(poseStack, bufferSource, RenderType::entitySolid, LightTexture.FULL_BRIGHT, OverlayTexture.NO_OVERLAY, event.getPartialTick(), transforms); - poseStack.pushPose(); - poseStack.translate(0,0.5f,0); - bakedRenderable.render(poseStack, bufferSource, RenderType::entitySolid, LightTexture.FULL_BRIGHT, OverlayTexture.NO_OVERLAY, event.getPartialTick(), EmptyModelData.INSTANCE); + poseStack.translate(0 - x + xOffset, 120 - y, 0 - z); + renderable.render(poseStack, bufferSource, RenderType::entitySolid, LightTexture.FULL_BRIGHT, OverlayTexture.NO_OVERLAY, partialTick, transforms); + + poseStack.translate(0, -1, 0); + bakedRenderable.render(poseStack, bufferSource, texture -> getRenderType(stage, texture), LightTexture.FULL_BRIGHT, OverlayTexture.NO_OVERLAY, partialTick, EmptyModelData.INSTANCE); poseStack.popPose(); bufferSource.endBatch(); + profiler.pop(); + } + + private static RenderType getRenderType(Stage stage, ResourceLocation texture) + { + if (stage == Stage.AFTER_PARTICLES) + return ForgeRenderTypes.TRANSLUCENT_ON_PARTICLES_TARGET.get(); + return RenderType.entityTranslucent(texture); } } }