Shader

This feature is exclusive to Java Edition.

This page describes content that has been removed from Bedrock Edition.

This feature was present in earlier versions of Bedrock Edition, but has since been removed.

It has been suggested that this page be split into Post effect.

^[discuss^]

If this split affects many pages, or may potentially be controversial, do not split until a consensus has been reached.
Reason: compiling everything shader-related onto this page makes it bulky and difficult to read. I think that having a smaller, dedicated page specifically for post effects would help with that specifically

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

Java Edition

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

Although core shaders can be replaced with a resource pack, this isn't an intended or supported feature and may change at any time.

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

List of core shaders

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.

Name	Used for	Sample images	Available uniforms blocks	Available samplers. All samplers are of type `sampler2d` unless otherwise specified	Define directives
animate_sprite_blit	Renders non-interpolated texture animations, as well as any non-animated sprite to a texture atlas. Uses the `core/animate_sprite.vsh` vertex program.		`SpriteAnimationInfo`	`Sprite` - The next animation frame	None present.
animate_sprite_interpolate	Renders interpolated texture animations to a texture atlas. Uses the `core/animate_sprite.vsh` vertex program.		`SpriteAnimationInfo`	`CurrentSprite` - The current animation frame `NextSprite` - The next animation frame	None present.
blit_clouds ^{[upcoming: JE 26.4]}	Renders clouds from an offscreen target when Improved Transparency is enabled Uses the `core/screenquad.vsh` vertex program.		None present.	`InSampler` - The texture containing the already rendered clouds. `InDepthSampler` - The texture clouds depth.	None present.
blit_depth	Copies one depth buffer to another. Uses the `core/screenquad.vsh` vertex program.		None present.	`InSampler` - The buffer to copy from.	None present.
blit_screen	Copies one buffer to another. Used for the Glowing effect. Uses the `core/screenquad.vsh` vertex program.		None present.	`InSampler` - The buffer to copy from.	None present.
block	Renders blocks that aren't part of chunk meshes such as falling sand, blocks being moved by a piston, or pistons while moving a block.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The blocks atlas. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded. This is defined as `0.5` for cutout textures, `0.1` for translucent textures, and not defined for solid textures.
debug_point	Used for some debug renderers Uses the `core/position_color.fsh` fragment program.		`DynamicTransforms` `Projection`	None present.	None present.
entity	Renders most entities including but not limited to: Mobs End crystal beams Block entities that use special rendering such as banners and chests, both in the world and in guis Equipment and other overlays such as the charged creeper energy swirls Experience orbs		`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The base texture of the entity. `Sampler1` - The red damage indicator overlay. `Sampler2` - The lightmap. `DissolveMaskSampler` - An alpha mask to use when the `DISSOLVE` define is set.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded. This is defined as `0.1` for cutout and translucent textures, and not defined for solid textures. `APPLY_TEXTURE_MATRIX` - Whether or not the uv should be offset by the `TextureMat` uniform. `EMISSIVE` - Whether or not lighting should be applied to the entity. `NO_CARDINAL_LIGHTING` - Whether or not directional shading should be applied. `NO_OVERLAY` - Whether or not the red damage tint should be applied. `PER_FACE_LIGHTING` - Whether or not lighting should be calculated seperately for the front and back quad faces. `DISSOLVE` - Whether or not the `DissolveMaskSampler` should be used as an alpha mask.
glint	Renders the enchantment glint on items, equipment, etc.		`DynamicTransforms` `Fog` `Globals` `Projection`	`Sampler0` - The enchantment glint texture.	None present.
gui	Renders flat colored gui elements including but not limited to: Chat and F3 screen text background Advancement screen lines and background darken effect Background of resource/datapack screen items Background of selected world/server in world/server screens Loading screen background Selected language in language menu Selected statistic in statistics menu Inventory screen backgrounds World loading progress Text background on "Saving world" and similar screens		`DynamicTransforms` `Projection`	None present.	None present.
item	Renders item models in various contexts, such as when dropped on the ground, held in an entities hand, in a display entity, etc		`DynamicTransforms` `Fog` `Lighting` `Projection`	`Sampler0` - The items or blocks atlas depending on the model currently being rendered. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded. This is defined as `0.1` for cutout and translucent textures, and not defined for solid textures.
lightmap	Renders the lightmap which is used by other shaders to determine how bright or dark parts of the world should be. Uses the `core/screenquad.vsh` vertex program.	In this image the lightmap shader outputs a horizontal gradient from black to red Here the lightmap has been modified to output a gradient from black to red horizontally, and black to green vertically. A mod has been used to display the output of this shader to the top left of the screen for a clearer visualisation	`LightmapInfo`	None present.	None present.
oit_composite	Responsible for composisiting OIT coefficients when Improved Transparency is enabled. Uses the `core/screenquad.vsh` vertex program.		`Projection`	`Sampler0` `Sampler2` `DepthBoundsSampler`	None present.
panorama	Renders the title screen panorama cubemap.		`DynamicTransforms` `Projection`	`Sampler0` (samplerCube) - A cubemap sampler containing all 6 panorama images.	None present.
particle	Renders all particle effects. Also renders the rain and snow weather effects.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The particles or blocks atlas, depending on the particle that is being rendered. If rendering a weather effect then this is the corresponding texture for that effect. `Sampler2` - The lightmap.	None present.
position_color	Renders the lower half of the sky at sunrise and sunset. Also renders the F3 debug pie and chunk borders.		`DynamicTransforms` `Projection`	None present.	None present.
position_tex_color	Renders some miscellaneous textured things including but not limited to: The end sky GUI buttons, backgrounds, tooltips, icons etc Pre-rendered items and entities in GUIs (see the Render process section for more information) World icons, server icons, resourcepack icons, datapack icons, etc HUD elements such as the hotbar, crosshair, health hearts, tab list heads, etc The Mojang and Minecraft logos Fire overlay Camera overlay effects such as the vignette, pumpkin blur, freezing effect, etc	In this image, the square to the right is a prerendered item being drawn onto a quad	`DynamicTransforms` `Projection`	`Sampler0` - For most gui widgets and icons, this is the gui atlas. For world, resourcepack, etc icons, mojang logo, camera overlays, or other non-gui things this is the texture of the object being rendered.	None present.
position_tex	Renders celestial bodies including the sun, moon, and end flashes.		`DynamicTransforms` `Projection`	`Sampler0` - The celestials atlas	None present.
position	Handles depth for the ender dragon's death rays.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_beacon_beam	Renders the beacon and end gateway beams.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The texture of the current part of the beam being rendered.	None present.
clouds	Renders the clouds.		`CloudInfo` `DynamicTransforms` `Fog` `Projection`	`CloudFaces` (isamplerBuffer) - Data about cloud faces	None present.
rendertype_crumbling	Renders the block breaking animation.		`DynamicTransforms` `Fog` - Although not explicitly defined in the code this can be used `Projection`	`Sampler0` - The texture for current stage of the block breaking animation.	None present
rendertype_end_portal	Renders starfield objects		`DynamicTransforms` `Fog` `Globals` `Projection`	`Sampler0` - The end sky texture `textures/environment/end_sky.png`. `Sampler1` - The end portal stars texture `textures/entity/end_portal.png`.	`PORTAL_LAYERS` - The amount of star layers to render.
rendertype_entity_shadow	Renders the shadow that appears under most entities.	Highlighted in orange is where the shadow is normally visible in vanilla	`DynamicTransforms` `Fog` `Projection`	`Sampler0` - The shadow texture `textures/misc/shadow.png`.	None present.
rendertype_leash	Renders leads that are attached to entities in the world.		`DynamicTransforms` `Fog` `Projection`	`Sampler2` - The lightmap.	None present.
rendertype_lightning	Renders lightning bolts and the ender dragon's death rays.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_lines	Renders all types of lines including: The block outline Entity debug hitboxes The F3 screen crosshair Structure and test block bounding boxes		`DynamicTransforms` `Fog` `Globals` `Projection`	None present.	None present.
rendertype_outline	Renders a flat colored outline of entities which have the glowing effect. The color of this is based on the team the entity is in, or the glow color override for display entities, which is passed to the shader via the `Color` vertex attribute. The output of this shader is saved to a buffer and then later used in the `entity_outline` post effect to create the full glowing effect.	In this image, the entity_outline post effect has been disabled to clearly show what this shader outputs	`DynamicTransforms` `Projection`	`Sampler0` - The base texture of the object being rendered.	None present.
rendertype_text_background_see_through	Renders the background of text display entities that are set to render through blocks.		`DynamicTransforms` `Projection`	None present.	None present.
rendertype_text_background	Renders the background of text display entities that are not set to render through blocks.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
rendertype_text_see_through rendertype_text_intensity_see_through	Renders text that is visible through blocks. Also renders the background of player and entity nameplates. Note: rendertype_text_intensity_see_through is identical, however it is only used to render ttf fonts.		`DynamicTransforms` `Projection`	`Sampler0` - An automatically generated 256x256 atlas which contains the current character that is being rendered.	None present.
rendertype_text rendertype_text_intensity	Renders text in the world and in GUIs. Also renders maps in item frames or when held in first person. Note: rendertype_text_intensity is identical, however it is only used to render ttf fonts.		`DynamicTransforms` `Fog` `Projection`	`Sampler0` - An automatically generated 256x256 atlas which contains the current character that is being rendered. For maps, this is the map background texture, map_decorations atlas, or the map itself depending on which part is currently being rendered. `Sampler2` - The lightmap.	None present.
rendertype_water_mask	A mask used to hide water inside boats.	In this image the shader has been edited to discard all pixels on the right half of the screen	`DynamicTransforms` `Projection`	None present.	None present.
world_border	Renders the world border.		`DynamicTransforms` `Projection`	`Sampler0` - The world border texture `textures/misc/forcefield.png`.	None present.
sky	Renders the upper half of the overworld skybox.		`DynamicTransforms` `Fog` `Projection`	None present.	None present.
sky_occluder ^{[upcoming: JE 26.4]}	Renders the lower half of the overworld skybox which occludes stars and celestials.		`DynamicTransforms` `Fog` `Projection` `SkyOccluderInfo`	None present.	None present.
stars	Renders the stars in the overworld sky at night.		`DynamicTransforms` `Projection`	None present.	None present.
terrain	Renders all blocks and fluids in the world.		`ChunkSection` `Fog` `Projection`	`Sampler0` - The blocks atlas. `Sampler2` - The lightmap.	`ALPHA_CUTOUT` - Minimum opacity before pixels are discarded, if not defined no pixels get discarded. This is defined as `0.5` for cutout textures, `0.1` for translucent textures, and not defined for solid textures.
text	Renders text in the world and in GUIs. Also renders maps in item frames or when held in first person.		`DynamicTransforms` `Fog` (only when `IS_GUI` is not defined) `Projection`	`Sampler0` - An automatically generated 256x256 atlas which contains the current character that is being rendered. For maps, this is the map background texture, map_decorations atlas, or the map itself depending on which part is currently being rendered. `Sampler2` - The lightmap (only when `IS_GUI` is not defined)	`IS_GRAYSCALE` - Defined if the shader should treat the font texture as an intensity texture for TTF font rendering. `IS_SEE_THROUGH` - Defined if the shader has no depth test and can be seen through other objects. `IS_GUI` - Defined if the shader handles text for the gui.

Include shaders

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 you can use the #include directive with an identifier pointing to a shader. For example:

#include <filepath.glsl> imports a file from assets/minecraft/shaders/include/<filepath>.glsl
#include <namespace:path.glsl> imports a file from assets/<namespace>/shaders/include/<path>.glsl
#include "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

Name	Description
fog.glsl	Contains the `linear_fog` function to calculate the color based on the vertex distance. Contains a definition of the `Fog` uniform block
light.glsl	Contains the `minecraft_mix_light` function, used to calculate face lighting in entity shaders. Contains a definition of the `Lighting` uniform block
matrix.glsl	Contains the `mat2_rotate_z` function that returns the rotation matrix for a vec2 around the z-axis.
projection.glsl	Contains the `projection_from_position` function. Contains a definition of the `Projection` uniform block
globals.glsl	Contains a definition of the `Globals` uniform block.
dynamictransforms.glsl	Contains a definition of the `DynamicTransforms` uniform block.
chunksection.glsl	Contains a definition of the `ChunkSection` uniform block.
animation_sprite.glsl	Contains a definition of the `SpriteAnimationInfo` uniform block.
sample_lightmap.glsl	Contains the `sample_lightmap` function, used by various shaders to sample the lightmap texture.
oit.glsl
oit_add_transmittance.glsl
oit_common.glsl
oit_depth_bounds.glsl
oit_depth_sample.glsl
oit_sample.glsl
fullscreen_triangle.glsl	Contains a function called `fullscreen_triangle_position` which returns vertex coordinates to position a triangle in a way that covers the entire screen.

Post-processing effects

As mentioned previously, post-processing effects are used in menu backgrounds, when spectating certain mobs to create vision effects, and when rendering the glowing effect. Custom post effects can also be defined and displayed using the /posteffect command.

Post-effect file format

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

[NBT Compound / JSON Object]: The root tag
- [NBT Compound / JSON Object] targets: Custom render targets to be used by render passes
  - [NBT Compound / JSON Object] target definition: The key is the name of the target
    - [Int] width: Defaults to the current viewport width. The width of the target
    - [Int] height: Defaults to the current viewport height. The height of the target
    - [Boolean] persistent: Defaults to false. If true, this target is not cleared between frames. It is still cleared when the game window is resized, however.
    - [NBT List / JSON Array][Int] clear_color Defaults to [0, 0, 0, 0]. The color this target is filled with when it is created or cleared. Supports two formats. A list of floats in 0-1 range [R, G, B, A], or a color in decimal format calculated from the red, green and blue components using this formula:
      (Alpha << 24) + (Red << 16) + (Green << 8) + Blue
- [NBT List / JSON Array] passes: Render passes
  - [NBT Compound / JSON Object] pass: A render pass
    - [String] vertex_shader: The namespaced id of a vertex shader to use for this pass, relative to the shaders folder. minecraft:post/blit resolves to assets/minecraft/shaders/post/blit.vsh
    - [String] fragment_shader: The namespaced id of a fragment shader to use for this pass, relative to the shaders folder. minecraft:post/box_blur resolves to assets/minecraft/shaders/post/box_blur.fsh
    - [NBT List / JSON Array] inputs: A list of render target inputs and / or texture inputs
      - [NBT Compound / JSON Object] render target input
        [String] sampler_name: The name of the sampler uniform
        Setting this to MainDepth, for example, makes a sampler2D uniform called MainDepthSampler available to the shader program for this pass. This also provides an additional vec2 to the SamplerInfo uniform block called <sampler_name>Size, for example MainDepthSize
        
        [Boolean] bilinear: Default: false. If set to true, the sampler uses bilinear filtering instead of nearest neighbor
        
        [String] target: The name of the target. Can either be a custom target as specified in targets above, or one of the following built in targets: minecraft:main, minecraft:translucent, minecraft:item_entity, minecraft:particles, minecraft:weather, minecraft:clouds, or minecraft:entity_outline
        
        [Boolean] use_depth_buffer: Default: false. If set to true, it samples from the depth texture instead of the color texture.
      - [NBT Compound / JSON Object] texture input
        [String] sampler_name: The name of the sampler uniform
        Setting this to MyTexture, for example, makes a sampler2D uniform called MyTextureSampler available to the shader program for this pass. This also provides an additional vec2 to the SamplerInfo uniform block called <sampler_name>Size, for example MyTextureSize
        
        [Boolean] bilinear: Default: false. If set to true, the sampler uses bilinear filtering instead of nearest neighbor
        
        [String] location: The resource location of the texture. my_namespace:post_texture resolves to assets/my_namespace/textures/effect/post_texture.png
        
        [Int] width: The width of the texture in pixels
        
        [Int] height: The height of the texture in pixels
    - [String] output: The target to output to. Can either be a custom target as specified in targets above or minecraft:main. Note: you cannot read and write to the same target in the same pass
    - [NBT Compound / JSON Object] uniforms: An object of uniform blocks to pass to the vertex and fragment shaders. For example, uniforms: { "UniformBlockName": [ { "type": "vec2", "value": [...] } ] }
      - [NBT List / JSON Array] uniform block: The key is what this uniform block is called when referenced in a shader
        [NBT Compound / JSON Object] uniform definition
        [String] name: The name of the uniform. This is unused by the game, however it is recommended to set it for organizational purposes
        
        [String] type: The type of the uniform, can be any of: int, float, ivec3, vec2, vec3, vec4, and matrix4x4
        
        [Int][Float][NBT List / JSON Array] value: Uniform values. The amount and format of this depends on what the type field is set to
        int requires a single int
        
        float requires a single float
        
        ivec3 requires list of 3 ints
        
        vec2 requires list of 2 floats
        
        vec3 requires list of 3 floats
        
        vec4 requires list of 4 floats
        
        matrix4x4 requires 16 floats

List of post-processing effects

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

Name	Used for	Sample images
blur	Used for the blur effect in the background of most menus in-game and on the title screen. This post effect is not used when the "Menu Background Blur" accessibility setting is set to 0.
creeper	Adds a green filter over the screen and give the appearance of a reduced resolution. Used when spectating a creeper.
entity_outline	Applies a blur over a solid color silhouette of an entity. Used when an entity with the glowing effect is on-screen.	Left side is the "minecraft:entity_outline" target before the post effect is applied, right side is the final image with the post effect applied
invert	Inverts the colors of the screen. Used when spectating an enderman.
spider	Renders a blurred version of the screen with 5 additional copies overlapped on top with blurred edges. Used when spectating a spider.
end_of_frame	Runs after the world is rendered and before the gui and other post effects . By default this post effect is unused, however a resourcepack can define it in which case it cannot be disabled in any way besides removing the resourcepack again.

Render process

General game rendering

Each frame is rendered in the following order

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)

GUI item and entity rendering

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 uses 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

Vanilla uniform blocks

Using uniform blocks outside supported shaders may work in some cases, however this is undefined behavior and may cause unexpected results or crashes. Refer to the list of core shaders for more info

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 occurs. 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 have a 'default' value. For example, while the rendertype_lines core shader has the proper value for the LineWidth uniform, other shaders have a "default value" that is unlikely to be useful.

Common blocks

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.

Core blocks

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 .
(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 .
(vec3) CellSize Size of each individual cloud .

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
(ivec3) ChunkPosition

SpriteAnimationInfo

(mat4) ProjectionMatrix The projection matrix
(mat4) SpriteMatrix
(float) UPadding
(float) VPadding
(int) MipMapLevel

SkyOccluderInfo

(float) OcclusionStartAngle
(float) OcclusionEndAngle

Post-processing blocks

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"

Bedrock Edition

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.

Deferred rendering pipeline

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.

[note 1]

Java Edition
1.7.2	13w38a	Post-processing shaders were added, accessible via the Super Secret Settings button.
1.8	14w05a	The `creeper` and `spider` shaders were added. Shaders are automatically applied in spectator mode when viewing the world as a creeper, spider, cave spider or enderman.
	14w05b	Shaders have been removed from view when changing perspective while spectating a mob.^[1]
	14w05b	`F4` now toggles different shaders rather than turning them off.^[1]
	14w06a	The `entity_outline` post effect shader was added for the player highlighting feature in spectator mode.
1.9	15w31a	Removed the Super Secret Settings button for an internal rewrite.^[2]
1.11.1	16w50a	Something changed about fog such that end portal blocks are no longer affected atypically intensely by it.
1.15	19w40a	End gateways are now affected by fog correctly. In all prior versions, they completely ignored fog regardless of distance.
1.15	19w41a	End portal and end gateway blocks now completely ignore fog.
1.16	20w22a	The `transparency` post effect shader was added for Fabulous! graphics mode.
1.17	21w10a	Added core shaders.
		Added the `fog.glsl`, `light.glsl`, `matrix.glsl`, and `projection.glsl` include shaders
		The game now requires OpenGL 3.2 Core Profile.
		Upgraded the existing shader programs for post processing effects from glsl version `110` to `150`
		As a result of the starfield effect being converted into a shader, it looks slightly different than previous snapshots. The most notable difference is each layer looks about twice as big compared to previous versions.
	21w11a	The layers in the starfield effect have been made smaller to make the effect look more similar to older versions.
1.18.1	?	The `fog.glsl` include shader now has a `cylindrical_distance` function. All core shaders that previously used the builtin `length` function to calculate vertex distance use this.
1.18.2	?	In `fog.glsl` the `cylindrical_distance` function has been renamed to `fog_distance`. It also takes an additional int parameter for fog shape.
1.18.2	?	Added the `FogShape` uniform for core shaders.
1.19	22w12a	There are now shader files for translucent entity rendering.
1.20.5	24w05a	The attributes array in core shader definitions has been removed. All attributes are now always bound for a given shader.
		The unused `position_color_normal` and `position_tex_lightmap_color` core shaders have been removed
		The `position_tex_color_normal` core shader has been renamed to `rendertype_clouds`
		The `IViewRotMat` uniform has been removed, and the Position attribute for entities is now in (camera relative) world space
		Light direction uniforms are no longer premultiplied by the view matrix
	24w09a	A box blur effect is now used behind menu screens, the intensity of which can be configured. This is implemented with a post processing effect called `blur`.
	24w11a	The `blur` post processing effect now does multiple box blur passes per direction instead of 1, resulting in a blur that looks closer to a gaussian blur.
	24w11a	All unused post-processing shaders that were used for Super Secret Settings have been removed.
	?	Setting the menu background blur slider to 0 now entirely disables the blur post shader, rather than simply giving it an intensity of zero.
1.21.2	24w34a	Shader program configurations can now specify preprocessor define directives to apply to their linked shaders.
		Various individual shader programs have been merged into one with the shader program configuration files defining preprocessor directives for specific behaviour. For example the `core/rendertype_solid.json`, `core/rendertype_translucent.json`, `core/rendertype_cutout.json`, `core/rendertype_cutout_mipped.json`, and `core/rendertype_tripwire.json` program configurations all point to the `core/terrain` fragment and vertex programs, with some defining an `ALPHA_CUTOUT` directive.
		The `fragment` and `vertex` fields in shader program configurations can now include a namespaces instead of being hardcoded to `minecraft`. Additionally, the paths are now relative to the `assets/namespace/shaders/` directory instead of `assets/minecraft/shaders/core/`.
		The format of post-processing effects has changed and are now located under the `assets/namespace/post_effects/` directory.
		The `rendertype_entity_glint_direct` core shader has been removed and replaced by `rendertype_entity_glint`.
		The `rendertype_entity_translucent_cull` shader has been removed and replaced by `rendertype_item_entity_translucent_cull`.
		The `ChunkOffset` uniform has been renamed to `ModelOffset`.
	?	Most textured gui elements now use the `core/position_tex_color` shader instead of `core/position_tex`
1.21.4	?	The sun and moon now use the `core/position_tex_color` shaders instead of `core/position_tex`
1.21.5	25w06a	Added a new core shader, `rendertype_world_border`, which is used to render the world border
	25w07a	Shader program configuration files have been removed. The shader programs are still present, however the only uniforms available to them are the default ones that are used in the vanilla rendering.
		In post-processing effects, the field `program` was replaced with `vertex_shader` and `fragment_shader` which resolve to `assets/<namespace>/shaders/<path>.<vsh or fsh>`
		In post-processing effects, `type` is now a required field for each `uniform`, with the possible values being `int`, `ivec3`, `float`, `vec2`, `vec3`, `vec4` and `matrix4x4`
		In post-processing effects, the `values` field is now option for each `uniform`. Leaving it unset is not recommended because this results in undefined behavior. Leaving it unset is only used for runtime configuration of the blur post-processing effect in the vanilla rendering
		The `EndPortalLayers` uniform has been removed and replaced by a pre-processor define called `PORTAL_LAYERS`
		Fog now affects end portal and end gateway blocks like all other blocks.
	25w10a	"Global" uniforms can now be defined in shader programs. If a uniform is not usually available to that shader, or the type of the uniform is not defined as what it would normally be, undefined behavior occurs
	25w10a	Currently, the "global" uniforms are: `ModelViewMat`, `ProjMat`, `TextureMat`, `ScreenSize`, `ColorModulator`, `Light0_Direction`, `Light1_Direction`, `GlintAlpha`, `FogStart`, `FogEnd`, `FogColor`, `FogShape`, `LineWidth`, `GameTime`, and `ModelOffset`. Note that this is not the same as the `Globals` uniform block added in 1.21.6, these are individual uniforms that must be declared individually. There is also no `globals.glsl` include shader which was also added in 1.21.6
1.21.6	25w16a	All built-in uniforms are now uniform blocks instead of opaque loose uniforms
		Custom uniforms provided to post-process shaders are now uniform blocks
		In post-processing effects, `targets` now supports two new optional fields: `persistent` and `clear_color`
		In post-processing effects, the `uniforms` field is now a list of uniform blocks, example: `{ "UniformBlockName": [ { "type": "vec2", "value": [...] } ] }`.
		In post-processing effect uniform definitions, the `name` field is now unused by the game but still present. The `values` field has been replaced with `value`, behaving largely the same but for the `int` and `float` uniform types this field accepts a single number instead of a list with 1 entry.
		In post-processing effects, the list of size (all vec2 *Size) uniforms have been replaced with a single `SamplerInfo` uniform block.
		The main menu panorama now uses a new fragment program, `core/panorama.fsh`.
		The `core/position_tex.fsh` program is now unused.
		The `position` core shader can now have a `FOG_IS_SKY` define directive.
		The `minecraft_sample_lightmap` has been removed from the `light.glsl` include shader. All shaders that previously used this function now instead sample the lightmap texture directly.
	25w17a	Added two new core shaders; `stars`, and `sky` which are used to render the stars and upper portion of the sky respectively.
	25w17a	Removed the `FOG_IS_SKY` define directive, as the sky now uses a separate shader.
	25w19a	The main menu panorama now uses a new vertex program, `core/panorama.vsh`.
		The `core/position_tex.vsh` program is now unused.
		Added four new uniforms, `FogEnvironmentalStart`, `FogEnvironmentalEnd`, `FogRenderDistanceStart` and `FogRenderDistanceEnd`.
		The `FogShape`, `FogStart` and `FogEnd` uniforms have been removed.
1.21.9	25w31a	Removed the `post/blit.vsh`, `post/blur.vsh`, `post/invert.vsh`, `post/sobel.vsh`, `post/screenquad.vsh`, and `core/blit_screen.vsh` shader programs and replaced them with `core/screenquad.vsh`.
	25w31a	Vertex shaders for post-processing effects and full screen blits are no longer are passed a `Position` attribute. Instead these must assign vertex coordinates using `gl_VertexID`. Additionally, these shaders are only executed with 3 vertices instead of a full quad like they were previously.
	25w33a	In the `LightmapInfo` uniform block, the `int UseBrightLightmap` uniform has been removed, and `vec3 AmbientColor` has been added.
	25w33a	The `core/lightmap.fsh` shader has been modified for the new end flashes.
	25w35a	The `core/lightmap.fsh` shader has been modified slightly to fix some issues with end flashes. The darkness effect pulsing is no longer applied in the end as part of these changes.
	25w36a	Removed the unused `core/position_color_lightmap.fsh`, `core/position_color_lightmap.vsh`, `core/position_color_tex_lightmap.fsh`, and `core/position_color_tex_lightmap.vsh` shader programs.
	25w36a	Minor change to uv calculations in the `minecraft_sample_lightmap` function in the `core/terrain.vsh` program.
	25w37a	The `core/entity` shader can now have a `PER_FACE_LIGHTING` flag. When set, cardinal lighting is computed separately for front and back faces of each quad.
		The game now requires OpenGL 3.3 Core Profile.
		Upgraded all shader programs from glsl version `150` to `330`
		Split the logic for `minecraft_mix_light` function in `include/light.glsl` into two additional functions: `minecraft_compute_light` and `minecraft_mix_light_separate`
	?	The sun and moon now use the `core/position_tex` shaders instead of `core/position_tex_color`
1.21.11	25w41a	Added a new shader program `core/debug_point.vsh`
	25w41a	Removed the `LineWidth` uniform from the `DynamicTransforms` uniform block. Line width is now passed as a vertex attribute to the `core/rendertype_lines` and `core/debug_point` shaders instead.
	25w44a	Added new shader programs `core/animate_sprite.vsh`, `core/animate_sprite_blit.fsh`, and `core/animate_sprite_interpolate.fsh` for rendering texture animations.
		Changes have been made to the `core/terrain` shader for texel antialiasing and chunk fade animations.
		The `Sampler0` uniform in the `core/terrain` shader now uses linear filtering instead of nearest.
		Added new shader programs `core/block.vsh` and `core/block.fsh` for rendering non-chunk-meshed blocks such as falling sand or blocks being moved by a piston.
		Added new include shaders `include/animation_sprite.glsl` and `include/chunksection.glsl` which contain definitions for new `SpriteAnimationInfo` and `ChunkSection` uniform blocks respectively.
		Added two new uniforms, `ivec3 CameraBlockPos` and `vec3 CameraOffset`, to the `Globals` uniform block.
	pre1	The `core/terrain.fsh` shader has been modified to implement RGSS texture filtering.
	pre1	Added a new uniform, `int UseRgss`, to the `Globals` uniforms block.
26.1	snap1	The `core/lightmap.fsh` shader has been mostly rewritten
		Added two new uniforms to the `LightmapInfo` uniform block: `vec3 BlockLightTint` and `vec3 NightVisionColor`.
		The `float AmbientLightFactor` uniform has been removed from the `LightmapInfo` uniform block. It is now pre-multiplied into the `vec3 AmbientColor` uniform.
		The `float DarkenWorldFactor` uniform in the `LightmapInfo` uniform block has been renamed to `float BossOverlayWorldDarkeningFactor`
		Added a new `include/smooth_lighting.glsl` shader. Contains a function called `minecraft_sample_lightmap` used by various shaders to sample the lightmap texture.
	snap5	Various shaders now sample the lightmap texture using the `texture` function instead of `texelFetch`. This includes `core/entity.vsh`, `core/rendertype_entity_decal.vsh`, `core/rendertype_item_entity_translucent_cull.vsh`, `core/rendertype_leash.vsh`, `core/rendertype_text.vsh`, `core/rendertype_text_background.vsh`, `core/rendertype_text_intensity.vsh`, and `core/rendertype_translucent_moving_block.vsh`.
	snap6	The `core/rendertype_item_entity_translucent_cull` shader has been removed, most things that were previously handled by this shader are now handled by `core/entity`.
		The `core/rendertype_entity_alpha` and `core/rendertype_entity_decal` shaders have been removed and replaced by a `DISSOLVE` define directive in `core/entity`
		All item models are now rendered using a new `core/item` shader instead of `core/entity`, with the exception of special model renderers which still use `core/entity`
	snap7	The `core/terrain.vsh` and `core/block.vsh` shaders no longer have the `Normal` vertex attribute
	snap7	Some small changes were to how various shaders sample the lightmap texture. This includes `core/entity.vsh`, `core/item.vsh`, `core/rendertype_leash.vsh`, `core/rendertype_text.vsh`, `core/rendertype_text_background.vsh`, `core/rendertype_text_intensity.vsh`, and `core/rendertype_translucent_moving_block.vsh`.
	snap10	The `include/smooth_lighting.glsl` shader has been removed and replaced by a new `include/sample_lightmap.glsl` shader. This contains a function called `sample_lightmap` used by various shaders to sample the lightmap texture.
		The following shaders; `core/block.vsh`, `core/entity.vsh`, `core/item.vsh`, `core/particle.vsh`, `core/rendertype_leash.vsh`, `core/rendertype_text.vsh`, `core/rendertype_text_background.vsh`, `core/rendertype_text_intensity.vsh`, `core/rendertype_translucent_moving_block.vsh`, and `core/terrain.vsh`, now sample the lightmap texture using the helper function declared in `include/sample_lightmap.glsl`.
		`core/rendertype_crumbling.vsh` no longer defines a varying named `texCoord2`
	pre1	The `core/rendertype_translucent_moving_block` shaders have been removed. Objects which were previously rendered by this shader are now handled by `core/block`
26.2	snap1	The game now uses a reversed depth buffer. The `post/transparency.fsh` shader has had its depth logic reversed to account for this.
		The `core/rendertype_text`, `core/rendertype_text_see_through`, `core/rendertype_text_intensity`, and `core/rendertype_text_intensity_see_through` shaders have been merged into new `core/text` shaders. Three defines are available for handling variants of text; `IS_GUI`, `IS_SEE_THROUGH`, and `IS_GRAYSCALE`.
		The `core/rendertype_text_background` and `core/rendertype_text_background_see_through` shaders have been merged into new `core/text_background` shaders. The `IS_SEE_THROUGH` define is availble for handling see-through backgrounds.
		When the games graphics api is set to Vulkan, some minor pre-processing is now done to shaders. Notably, `gl_VertexID` is replaced with `gl_VertexIndex` and `gl_InstanceID` is replaced with `gl_InstanceIndex`.
		The `core/rendertype_crumbling.vsh` no longer has a `vec3 Normal` vertex attribute.
		The `core/item` shaders have been updated slightly. The item pipelines now have an overlay texture similar to entity pipelines; `sampler2d Sampler1`. The vertex program now defines two varyings `vec4 lightMapColor` and `vec4 overlayColor`. These are then mixed and multiplied onto the base texture color in the fragment program.
		The `core/entity.vsh` shader no longer imports the `minecraft:light.glsl` include when both `PER_FACE_LIGHTING` and `NO_CARDINAL_LIGHTING` are not defined.
		This snapshot has a bug which prevents the game from loading any shaders from resourcepack after the initial resource load. This only applies when the graphics api is set to Vulkan MC-307311.
	snap2	MC-307311 has been fixed, allowing shaders to be loaded from resourcepacks properly again.
	snap2	The `core/rendertype_beacon_beam.fsh` has been updated slightly to account for the reversed depth buffer, as it was missed in 26.1-snapshot-1.
	pre3	The `ALPHA_CUTOUT` define in the `core/terrain` shader is now defined as `0.1` for translucent quads instead of `0.01` as a fix for MC-308245
26.3	snap2	Replaced old "Improved Transparency" approach with a new Order-independent Transparency (OIT) algorithm which is expected to be much better at solving translucency issues.
		The `transparency` post effect and `post/transparency.fsh` shader have been removed.
		Added new includes with various utilities for OIT `include/oit.glsl`, `include/oit_add_transmittance.glsl`, `include/oit_common.glsl`, `include/oit_depth_bounds.glsl`, `include/oit_depth_sample.glsl`, and `include/oit_sample.glsl`.
		Added a `core/oit_composite.fsh` shader responsible for normalising and outputting accumulated rgb values when OIT is enabled.
		Various new defines have been added to support OIT: `OIT` - A boolean indicating if OIT is enabled `OIT_DEPTH_BOUNDS` - A boolean indicating if the depth bounds pass is being executed `OIT_TRANSMITTANCE` - A boolean indicating if the transmittance pass is being executed `OIT_ACCUMULATE` - A boolean indicating if the accumulate pass is being executed `OIT_ALPHA_ONLY` - A boolean indicating if either the depth bounds or transmittance pass is being executed `OIT_ADDITIVE` - A boolean indicating that the OIT algorithm should emulate additive blending for the executing pipeline `OIT_OPAQUE_PARTS_THRESHOLD` - A float determining above which alpha threshold a fragment should be considered solid and not go through OIT `WAVELET_RANK` - An integer internal to the OIT algorithm `COEFF_COUNT` - An integer internal to the OIT algorithm `COEFF_ATTACHMENT_COUNT` - An integer internal to the OIT algorithm As a result of this, many core shaders have been updated to make use of these for OIT including: `core/block.fsh` `core/block.vsh` `core/clouds.fsh` `core/clouds.vsh` `core/entity.fsh` `core/entity.vsh` `core/item.fsh` `core/item.vsh` `core/particle.fsh` `core/position_color.fsh` `core/rendertype_beacon_beam.fsh` `core/rendertype_crumbling.fsh` `core/rendertype_entity_shadow.fsh` `core/rendertype_lightning.fsh` `core/rendertype_lines.fsh` `core/terrain.fsh` `core/terrain.vsh` `core/text.fsh` `core/text_background.fsh` `core/world_border.fsh` `core/world_border.vsh`
		Added a new `B3D_IS_ZERO_TO_ONE` define - A boolean indicating if the current rendering backend uses the depth range of [0, 1], it is available globally to all shaders
		Extracted the texture sampling logic from `core/terrain.fsh` into a new `include/texture_sampling.glsl` include shader.
		Renamed `core/rendertype_clouds` shaders to `core/clouds`
		Renamed `core/rendertype_world_border` shaders to `core/world_border`
	snap3	Added a new `minecraft:end_of_frame` post effect. When defined by a resourcepack this post effect runs after the world and before the gui and other post effects. It cannot be disabled in any way other than removing the resourcepack
	snap3	Added a way to display custom post effects with a new /posteffect command.
	snap4	Added a new shader for OIT: `core/oit_depth_bounds_cull.fsh`.
		Various OIT-related include shaders have been uptated slightly. As a result of this, `core/entity.fsh` and `core/item.fshM` no longer call the `handleOpaquePartDiscards(float)` function.
		Added a new define for OIT; `OIT_ALWAYS_WRITE_DEPTH` - A boolean indicating that the OIT algorithm should always write depth for the executing pipeline during the depth bounds stage
		Added a new `core/integrate_depth.fsh` shader that is used to integrate the "3d hud" and always-on-top gizmo depth buffers into the main depth buffer.
	snap5	On OpenGL, shaders are now compiled using ShaderC, identically to Vulkan. This means shader compilation on OpenGL is more strict in some cases, for example, the `#version` define must be the first line of a shader
		Shader includes are now handled by ShaderC using `#include` instead of `#moj_import`
		Shader `in`s and `out`s now require a location to be specified. Vertex input names must still match expected names. Vertex outputs are matched to fragment inputs solely by location, the name is now ignored.
		The `GL_ARB_separate_shader_objects` extension must now be enabled in shaders for compilation.
		Renamed the `B3D_DEPTH_IS_ZERO_TO_ONE` define to `RENDERPEARL_DEPTH_IS_ZERO_TO_ONE`.
	snap6	The `core/terrain.vsh` and `core/terrain.fsh` shaders have been refactored to support multi-draw. There is now a define in these shaders if the multi-draw path is being used called `MULTIDRAW_TERRAIN`.
		Members in the `Globals` uniform block have been re-ordered to use less memory. New order: `ivec3 CameraBlockPos`, `float GlintAlpha`, `vec3 CameraOffset`, `float GameTime`, `vec2 ScreenSize`, `int MenuBlurRadius`, `int UseRgss`. Old order: `ivec3 CameraBlockPos`, `vec3 CameraOffset`, `vec2 ScreenSize`, `float GlintAlpha`, `float GameTime`, `int MenuBlurRadius`, `int UseRgss`.
		Members in the `DynamicTransforms` uniform block have been re-ordered to use less memory. New order: `mat4 ModelViewMat`, `mat4 TextureMat`, `vec4 ColorModulator`, `vec3 ModelOffset`. Old order: `mat4 ModelViewMat`, `vec4 ColorModulator`, `vec3 ModelOffset`, `mat4 TextureMat`.
		Introduced new define: `RENDERPEARL_EXPLICIT_DEPTH_INVARIANCE` – if present, indicates that an OIT shader should explicitly output a depth value because a device it is running on can produce a slightly different implicit value.
	snap7	Some OIT related defines have been renamed: `OIT_WAVELET_RANK` - was previously `WAVELET_RANK` `OIT_COEFF_COUNT` - was previously `COEFF_COUNT` `OIT_COEFF_ATTACHMENT_COUNT` - was previously `COEFF_ATTACHMENT_COUNT`
	snap8	Removed `core/text_background.fsh` and `core/text_background.vsh`.
	snap8	Removed `OIT_FORCE_ZERO_DEPTH` shader define.
	pre1	Added the `core/blit_depth.fsh` shader which is used to contents of depth textures as an alternative to the rendering backend-based copying methods that do not work on some devices
	pre3	All vanilla include shaders now have define guards to prevent accidentally including them twice.
Upcoming Java Edition
26.4	snap1	The OIT algorithm was simplified by replacing the wavelet-based mathematics with depth bin-based accumulation. As a result of this, the `include/oit_add_transmittance.glsl`, `include/oit_common.glsl`, and `include/oit_sample.glsl` shaders have been changed.
		The `post/bits.fsh` shader has been changed slightly to fix MC-310051
		The `core/position_tex_color` and `core/gui` shaders now use includes rather than copy-pasting the contents of them in the vanilla assets. This change does not affect resourcepacks as they could always use the includes within these shaders.
	snap2	Renamed `screenquad.vsh` to `screentriangle.vsh` as it was executed with 3 verticies for a couple of versions previously. All post effect definitions have been updated to use the new shader.
		Removed OIT support from the `core/clouds.fsh` shader. It is now used to render clouds when Improved Transparency is off and to render clouds to an offscreen target when Improved Transparency is on.
		Added the `core/blit_clouds.fsh` shader with OIT support that renders clouds from an offscreen target when Improved Transparency is enabled.
		Added the `core/sky_occluder.vsh` and `core/sky_occluder.vsh` shaders which render the lower portion of the overworld skybox.
		Added the `include/fullscreen_triangle.glsl` shader containing a function for positioning a triangle to fill the entire screen. This include is used by `core/sky_occluder.vsh` and `core/screentriangle.vsh`.
		Render distance fog now makes chunks progressively more translucent when Improved Transparency is enabled, rather than simply fading them to an opaque colour.
		The `core/terrain.fsh` shader has had some changes to support the new render distance fog: A new define `IMPROVED_FOG` which is defined when Improved Transparency is enabled 3 new texture samplers are available when `IMPROVED_FOG`is defined; `SkySampler`, `CloudsSampler`, and `CloudsDepthSampler`. These contain the pre-rendered sky, clouds, and clouds depth respectively.

Shader

Java Edition

Core shaders

List of core shaders

Include shaders

Post-processing effects

Post-effect file format

List of post-processing effects

Render process

General game rendering

GUI item and entity rendering

Vanilla uniform blocks

Common blocks

Core blocks

Post-processing blocks

Bedrock Edition

Deferred rendering pipeline

History

Gallery

Issues

Notes

References

External links

More in Java Edition

Related mods