net.fabricmc.fabric.api.client.rendering.v1

Class WorldRenderEvents

java.lang.Object

net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents

@Environment(value=CLIENT)
public final class WorldRenderEvents
extends Object

Mods should use these events to introduce custom rendering during WorldRenderer.render(net.minecraft.client.util.math.MatrixStack, float, long, boolean, net.minecraft.client.render.Camera, net.minecraft.client.render.GameRenderer, net.minecraft.client.render.LightmapTextureManager, net.minecraft.util.math.Matrix4f) without adding complicated and conflict-prone injections there. Using these events also enables 3rd-party renderers that make large-scale changes to rendering maintain compatibility by calling any broken event invokers directly.

The order of events each frame is as follows:

• START
• AFTER_SETUP
• BEFORE_ENTITIES
• AFTER_ENTITIES
• BEFORE_BLOCK_OUTLINE
• BLOCK_OUTLINE (If not cancelled in BEFORE_BLOCK_OUTLINE)
• BEFORE_DEBUG_RENDER
• AFTER_TRANSLUCENT
• LAST
• END

These events are not dependent on the Fabric rendering API or Indigo but work when those are present.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	WorldRenderEvents.AfterEntities
static interface	WorldRenderEvents.AfterSetup
static interface	WorldRenderEvents.AfterTranslucent
static interface	WorldRenderEvents.BeforeBlockOutline
static interface	WorldRenderEvents.BeforeEntities
static interface	WorldRenderEvents.BlockOutline
static interface	WorldRenderEvents.DebugRender
static interface	WorldRenderEvents.End
static interface	WorldRenderEvents.Last
static interface	WorldRenderEvents.Start

Field Summary

Fields

Modifier and Type	Field and Description
static Event<WorldRenderEvents.AfterEntities>	AFTER_ENTITIES Called after entities are rendered and solid entity layers have been drawn to the main frame buffer target, before block entity rendering begins.
static Event<WorldRenderEvents.AfterSetup>	AFTER_SETUP Called after view Frustum is computed and all render chunks to be rendered are identified and rebuilt but before chunks are uploaded to GPU.
static Event<WorldRenderEvents.AfterTranslucent>	AFTER_TRANSLUCENT Called after entity, terrain, and particle translucent layers have been drawn to the framebuffer but before translucency combine has happened in fabulous mode.
static Event<WorldRenderEvents.BeforeBlockOutline>	BEFORE_BLOCK_OUTLINE Called before default block outline rendering and before checks are done to determine if it should happen.
static Event<WorldRenderEvents.DebugRender>	BEFORE_DEBUG_RENDER Called before vanilla debug renderers are output to the framebuffer.
static Event<WorldRenderEvents.BeforeEntities>	BEFORE_ENTITIES Called after the Solid, Cutout and Cutout Mipped terrain layers have been output to the framebuffer.
static Event<WorldRenderEvents.BlockOutline>	BLOCK_OUTLINE Called after block outline render checks are made and before the default block outline render runs.
static Event<WorldRenderEvents.End>	END Called after all world rendering is complete and changes to GL state are unwound.
static Event<WorldRenderEvents.Last>	LAST Called after all framebuffer writes are complete but before all world rendering is torn down.
static Event<WorldRenderEvents.Start>	START Called before world rendering executes.

Method Summary

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

START

public static final Event<WorldRenderEvents.Start> START

Called before world rendering executes. Input parameters are available but frustum is not. Use this event instead of injecting to the HEAD of WorldRenderer.render(net.minecraft.client.util.math.MatrixStack, float, long, boolean, net.minecraft.client.render.Camera, net.minecraft.client.render.GameRenderer, net.minecraft.client.render.LightmapTextureManager, net.minecraft.util.math.Matrix4f) to avoid compatibility problems with 3rd-party renderer implementations.

Use for setup of state that is needed during the world render call that does not depend on the view frustum.

AFTER_SETUP

public static final Event<WorldRenderEvents.AfterSetup> AFTER_SETUP

Called after view Frustum is computed and all render chunks to be rendered are identified and rebuilt but before chunks are uploaded to GPU.

Use for setup of state that depends on view frustum.

BEFORE_ENTITIES

public static final Event<WorldRenderEvents.BeforeEntities> BEFORE_ENTITIES

Called after the Solid, Cutout and Cutout Mipped terrain layers have been output to the framebuffer.

Use to render non-translucent terrain to the framebuffer.

Note that 3rd-party renderers may combine these passes or otherwise alter the rendering pipeline for sake of performance or features. This can break direct writes to the framebuffer. Use this event for cases that cannot be satisfied by FabricBakedModel, BlockEntityRenderer or other existing abstraction. If at all possible, use an existing terrain RenderLayer instead of outputting to the framebuffer directly with GL calls.

The consumer is responsible for setup and tear down of GL state appropriate for the intended output.

Because solid and cutout quads are depth-tested, order of output does not matter except to improve culling performance, which should not be significant after primary terrain rendering. This means mods that currently hook calls to individual render layers can simply execute them all at once when the event is called.

This event fires before entities and block entities are rendered and may be useful to prepare them.

AFTER_ENTITIES

public static final Event<WorldRenderEvents.AfterEntities> AFTER_ENTITIES

Called after entities are rendered and solid entity layers have been drawn to the main frame buffer target, before block entity rendering begins.

Use for global block entity render setup, or to append block-related quads to the entity consumers using the from the provided context. This will generally give better (if not perfect) results for non-terrain translucency vs. drawing directly later on.

BEFORE_BLOCK_OUTLINE

public static final Event<WorldRenderEvents.BeforeBlockOutline> BEFORE_BLOCK_OUTLINE

Called before default block outline rendering and before checks are done to determine if it should happen. Can optionally cancel the default rendering but all event handlers will always be called.

Use this to decorate or replace the default block outline rendering for specific modded blocks or when the need for a block outline render would not be detected. Normally, outline rendering will not happen for entities, fluids, or other game objects that do not register a block-type hit.

Returning false from any event subscriber will cancel the default block outline render and suppress the BLOCK_RENDER event. This has no effect on other subscribers to this event - all subscribers will always be called. Canceling here is appropriate when there is still a valid block hit (with a fluid, for example) and you don't want the block outline render to appear.

This event should NOT be used for general-purpose replacement of the default block outline rendering because it will interfere with mod-specific renders. Mods that replace the default block outline for specific blocks should instead subscribe to BLOCK_OUTLINE.

BLOCK_OUTLINE

public static final Event<WorldRenderEvents.BlockOutline> BLOCK_OUTLINE

Called after block outline render checks are made and before the default block outline render runs. Will NOT be called if the default outline render was cancelled in BEFORE_BLOCK_OUTLINE.

Use this to replace the default block outline rendering for specific blocks that need special outline rendering or to add information that doesn't replace the block outline. Subscribers cannot affect each other or detect if another subscriber is also handling a specific block. If two subscribers render for the same block, both renders will appear.

Returning false from any event subscriber will cancel the default block outline render. This has no effect on other subscribers to this event - all subscribers will always be called. Canceling is appropriate when the subscriber replacing the default block outline render for a specific block.

This event is not appropriate for mods that replace the default block outline render for all blocks because all event subscribers will always render - only the default outline render can be cancelled. That should be accomplished by mixin to the block outline render routine itself, typically by targeting WorldRenderer.drawShapeOutline(net.minecraft.client.util.math.MatrixStack, net.minecraft.client.render.VertexConsumer, net.minecraft.util.shape.VoxelShape, double, double, double, float, float, float, float).

BEFORE_DEBUG_RENDER

public static final Event<WorldRenderEvents.DebugRender> BEFORE_DEBUG_RENDER

Called before vanilla debug renderers are output to the framebuffer. This happens very soon after entities, block breaking and most other non-translucent renders but before translucency is drawn.

Unlike most other events, renders in this event are expected to be drawn directly and immediately to the framebuffer. The OpenGL render state view matrix will be transformed to match the camera view before the event is called.

Use to drawn lines, overlays and other content similar to vanilla debug renders.

AFTER_TRANSLUCENT

public static final Event<WorldRenderEvents.AfterTranslucent> AFTER_TRANSLUCENT

Called after entity, terrain, and particle translucent layers have been drawn to the framebuffer but before translucency combine has happened in fabulous mode.

Use for drawing overlays or other effects on top of those targets (or the main target when fabulous isn't active) before clouds and weather are drawn. However, note that WorldRenderPostEntityCallback will offer better results in most use cases.

Vertex consumers are not available in this event because all buffered quads are drawn before this event is called. Any rendering here must be drawn directly to the frame buffer. The render state matrix will not include camera transformation, so LAST may be preferable if that is wanted.

LAST

public static final Event<WorldRenderEvents.Last> LAST

Called after all framebuffer writes are complete but before all world rendering is torn down.

Unlike most other events, renders in this event are expected to be drawn directly and immediately to the framebuffer. The OpenGL render state view matrix will be transformed to match the camera view before the event is called.

Use to draw content that should appear on top of the world before hand and GUI rendering occur.

END

public static final Event<WorldRenderEvents.End> END

Called after all world rendering is complete and changes to GL state are unwound.

Use to draw overlays that handle GL state management independently or to tear down transient state in event handlers or as a hook that precedes hand/held item and GUI rendering.