Shader

Shaders are used to define the game's rendering of certain elements.

in Java Edition, two distinct kinds of shaders are used: core shaders and post-processing shaders. Core shaders are used to render fundamental parts of the game such as entities and terrain, while post-processing shaders are used to apply visual effects to the screen after core shaders have ran.

Examples of post-processing shaders include the menu background blur, certain mob vision types as seen in spectator, the Fabulous! graphics setting's fixed handling of translucent object, and the glowing status effect.

Shaders are written in the OpenGL Shading Language (GLSL). Each shader program^{[note 1]} comes in two parts, the vertex and fragment shader. Vertex shaders define the positions of individual vertices, whereas fragment shaders define the final color of a single render fragment. For example, vertex shaders are often used to create waving foliage and water, and fragment shaders can be used to add effects like bloom, god rays, and blur. In Minecraft, vertex shaders must use the extension .vsh, and fragment shaders .fsh.

Shader programs are stored in the assets/minecraft/shaders directory of client.jar, and can be replaced with a resource pack. Note that if any error occurs when loading the shaders, the resource pack is disabled and fabulous graphics mode is turned off.

Core shaders are used to render almost everything in the game, including terrain, entities, GUI elements, etc. The shader programs for core shaders are located in the assets/<namespace>/shaders/core directory of a resource pack.

Some objects are not drawn using shaders, this includes:

• The sky in the nether and bottom half of the overworld. These are the OpenGL clear color which is set to the same value as the FogColor uniform

A list of all core shaders can be found by expanding the header below, listing descriptions of what each shader is responsible for, as well as what uniforms, samplers, and define directives are available to each shader.

Include shaders (stored in assets/<namespace>/shaders/include) contain helper functions and variables that can be used in multiple shader programs. These must have the .glsl, .vsh, or .fsh file extensions.

To import an include shader, add one of the following import directives anywhere in a vertex or fragment shader program

• #moj_import <filepath.glsl> imports a file from assets/minecraft/shaders/include/<filepath>.glsl
• #moj_import <namespace:path.glsl> imports a file from assets/<namespace>/shaders/include/<path>.glsl
• #moj_import "filepath.glsl" imports a file from assets/minecraft/shaders/core/<filepath>.glsl

When importing an include shader, the game replaces the import directive with the contents of the include shader. The imported file needs to end with an empty line, otherwise the shader does not load.

Vanilla include shaders

The following include shaders are used throughout the vanilla resource pack

As mentioned previously, post-processing effects are used in menu backgrounds, when spectating certain mobs to create vision effects, the Fabulous! graphics setting, and when rendering the glowing effect.

Post-processing effects are made up of multiple passes and render targets. A target is a buffer that can be read from and written to. The game provides some built-in targets that contain certain parts of the game world (particles, water, etc), and you can define your own to read and write data to. A pass can have multiple inputs from png textures or render targets.

Post-processing effects are defined in assets/<namespace>/post_effect/<post effect>.json. Note that post-processing effects are applied before the HUD and GUI elements are rendered

There are currently six post-processing effects used in the game:

Each frame is rendered in the following order​^{[more information needed]}

• The world, including entities, blocks, the sky, items, etc is rendered (by core shaders)
• Any Post effects are applied as necessary
• The GUI and HUD elements are rendered (by core shaders)

When the game draws an item or entity in a GUI the following process occurs:

• The item or entity is pre-rendered to an internal texture. For items, this may be an atlas of all currently visible items ("GUI items atlas") or a single texture for that item. This depends on if the oversized_in_gui field is set to true or false in the items model definition. For entities, each one always has a unique texture that it gets rendered to
• For each item or entity, a quad is drawn to the screen which samples from either the GUI items atlas or individual texture for the corresponding item or entity

The game can skip rendering an item when necessary and will use whatever was drawn on the previous frame. An item is only re-rendered if one of the following conditions is met:

• The item has an animated texture somewhere on its model
• The item has an enchantment glint
• The GUI items atlas fills up, in this case it is cleared and all currently visible GUI items are redrawn
• The GUI scale is changed, in this case the GUI items atlas is cleared and all currently visible GUI items are redrawn
• The item data is changed in a way that would cause a visual update. This includes but is not limited to: changing the item_model, custom_model_data, or profile data components

Uniforms blocks use the std140 layout. All uniforms must be specified and in the correct order and with the correct type, otherwise weird and undefined behavior will occur. For convenience, some uniform blocks are pre-defined in include shaders, see the include shaders section for more information.

Some shaders may not use all uniforms in a given uniform block, in this case the unused uniforms will have a 'default' value. For example, while the rendertype_lines core shader will have the proper value for the LineWidth uniform, other shaders will have a "default value" for which will likely not be useful.

The following uniform blocks are available in both post-processing and core shaders.

Globals

This uniform block is always bound and has proper values in all shaders.

• (ivec3) CameraBlockPos Block position of the camera in world-space coordinates.
• (vec3) CameraOffset Fractional position of the camera in world-space coordinates.
• (vec2) ScreenSize The width and height of the current framebuffer in pixels.
• (float) GlintAlpha The value of the Glint Strength accessibility setting in a 0-1 range.
• (float) GameTime A value that constantly increases from 0-1 over the span of roughly 20 minutes, then resets to 0. The exact formula for this is (<age of the world> modulo 24000) / 24000.
• (int) MenuBlurRadius The value of the Menu Background Blur accessibility setting in a 0-10 range.
• (int) UseRgss A "boolean" value. Value is 1 if the texture filtering video setting is set to RGSS, otherwise 0.

The following uniform blocks are only available in core shaders.

Fog

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

• (vec4) FogColor Color of the fog.
• (float) FogEnvironmentalStart Starting distance of environmental fog.
• (float) FogEnvironmentalEnd Ending distance of environmental fog.
• (float) FogRenderDistanceStart Starting distance of render distance fog.
• (float) FogRenderDistanceEnd Ending distance of render distance fog.
• (float) FogSkyEnd Ending distance of fog for the upper portion of the sky.
• (float) FogCloudsEnd Ending distance for clouds fog.

DynamicTransforms

• (mat4) ModelViewMat The model-view matrix.
• (vec4) ColorModulator A color multiplier that can be set in game code to modify the final color of objects.
• (vec3) ModelOffset The offset of the model being rendered.
• (mat4) TextureMat A 4D matrix used to transform UV's for some animated effects, such as the enchantment glint, breeze and wind charge wind, world border, etc.

Lighting

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

• (vec3) Light0_Direction First light direction. Used to calculate directional entity shading.
• (vec3) Light1_Direction Second light direction. Used to calculate directional entity shading.

Projection

This uniform block is always bound, however may not have proper values if used outside shaders which support it.

• (mat4) ProjMat The projection matrix

LightmapInfo

• (float) SkyFactor A value that specifies how much to brighten the lightmap by when the sky flashes, typically when a lightning strike occurs. This value comes from the minecraft:visual/sky_light_factor environment attribute.
• (float) BlockFactor A value that fluctuates randomly, used in the vanilla shader for block light flickering.
• (float) NightVisionFactor A value in a 0-1 range that specifies how much the Night Vision status effect should brighten the lightmap by.
• (float) DarknessScale A value in a 0-1 range that specifies how much the Darkness status effect should darken the lightmap by.
• (float) BossOverlayWorldDarkeningFactor A value that specifies how much to darken the lightmap by when a bossbar is visible. This is seemingly only used in the ender dragon fight ​^{[more information needed]}.
• (float) BrightnessFactor The value of the brightness video setting in a 0-1 range.
• (vec3) BlockLightTint The color of block light. This value comes from the minecraft:visual/block_light_tint environment attribute.
• (vec3) SkyLightColor The color of sky light. This value comes from the minecraft:visual/sky_light_color environment attribute.
• (vec3) AmbientColor The ambient light color. This value comes from the minecraft:visual/ambient_light_color environment attribute.
• (vec3) NightVisionColor The color of the Night Vision status effect. This value comes from the minecraft:visual/night_vision_color environment attribute.

CloudInfo

• (vec4) CloudColor The color of the clouds.
• (vec3) CloudOffset Offset of the clouds ​^{[more information needed]}.
• (vec3) CellSize Size of each individual cloud ​^{[more information needed]}.

ChunkSection

• (mat4) ModelViewMat The model-view matrix.
• (float) ChunkVisibility Value that increments from 0 to 1 once a chunk section has been displayed. The amount of time this takes is dependent on the "Chunk Fade" video setting
• (ivec2) TextureSize ​^{[more information needed]}
• (ivec3) ChunkPosition ​^{[more information needed]}

SpriteAnimationInfo

• (mat4) ProjectionMatrix The projection matrix
• (mat4) SpriteMatrix ​^{[more information needed]}
• (float) UPadding ​^{[more information needed]}
• (float) VPadding ​^{[more information needed]}
• (int) MipMapLevel ​^{[more information needed]}

The following uniform blocks are only available in post-processing shaders.

SamplerInfo

• (vec2) OutSize The width and height of the output buffer in pixels.
• (vec2) All other inputs specified in the same order as the post-effect definition. These are named as <sampler_name>Size, for example, MainSize for an input with a name of "Main"

Since Bedrock Edition 1.18.30, third-party shader in resource packs are no longer supported on all devices due to the implementation of RenderDragon.

The deferred rendering pipeline is an alternative rendering pipeline which can be customized via resource packs and is used in the vanilla game for the Vibrant Visuals graphics mode.

Although it doesn't directly support custom shaders, it offers ways to define properties about light, fog, atmosphere, and PBR texture materials. This can be used to create lighting effects similar to those seen in Java Edition's shader packs.

• 👁 The creeper vision shader
  
  The creeper vision shader
• 👁 The enderman vision shader
  
  The enderman vision shader
• 👁 The spider vision shader
  
  The spider vision shader

Issues relating to "Shader" are maintained on the bug tracker. Issues should be reported and viewed there.

• Vanilla Shaders Wiki
• Minecraft Vanilla Shaders Guide
• OpenGL Shading Language on the OpenGL Wiki
• The Book of Shaders
• Learn OpenGL
• Minecraft Post-Processing Shaders Guide
• Bedrock Edition Deferred Rendering Pipeline Documentation