Default Shader Parts

Shader parts are used by Model-Based Rendering and Text Shaders. This file contains an index of parts by priority, and the source of each shader part.

Warning

The default shader parts may change between versions of Ren'Py. A part may gain additional parameters, or have its implementation changed, while producing similar output. A game that depends on the exact behavior of a shader part should copy the part, register the copy under a new name with renpy.register_shader(), and use that name instead.

Vertex Part Priorities

How Ren'Py uses vertex part priorities:

  • Priority 0 sets up gl_Position.

  • Priority 10 is used to capture gl_Position in virtual or drawable coordinates before adjustment.

  • Priorities 20-80 adjust gl_Position in virtual or drawable coordinates.

  • Priority 90 is used to capture gl_Position in virtual or drawable coordinates after adjustment.

  • Priority 100 transforms gl_Position to viewport coordinates.

  • Priority 200 stores more information in the variables passed to the fragment shader, without touching gl_Position.

In order:

Fragment Part Priorities

How Ren'Py uses fragment part priorities:

  • Priority 200 determines an original color and stores it in the fragment output (fragment_color in GLSL ES 3.00 or gl_FragColor in GLSL ES 1.00).

  • Priority 300 multiplies that color with a second texture.

  • Priority 325 stores alpha before the text shaders adjust it.

  • Priority 350 applies text shaders that adjust alpha.

  • Priority 375 can undo part of the effect of these text shaders.

  • Priority 400 adjusts the color, applying Transform and displayable-based changes.

  • Priority 450 converts color to alpha.

  • Priority 500 adjusts the alpha channel, applying Transform and displayable-based changes.

In order:

renpy.alpha

Variables:

uniform float u_renpy_alpha;
uniform float u_renpy_over;

Fragment shader (priority 500):

fragment_color *= u_renpy_alpha * vec4(1.0, 1.0, 1.0, u_renpy_over);

renpy.alpha_mask

Variables:

uniform sampler2D tex0;
uniform sampler2D tex1;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 500):

// The mask is in the red channel, and the result is premultiplied.
float l_renpy_alpha_mask_mask = texture(tex1, v_tex_coord).r;

fragment_color = vec4(texture(tex0, v_tex_coord).rgb * l_renpy_alpha_mask_mask, l_renpy_alpha_mask_mask);

renpy.blur

Variables:

uniform sampler2D tex0;
uniform vec2 res0;
uniform float u_renpy_blur_log2;
uniform float u_pixels_per_unit;
uniform float u_renpy_blur_virtual_pixels;

in vec2 a_tex_coord;
out vec2 v_tex_coord;

Defaults:

u_renpy_blur_virtual_pixels = <lambda>()

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment functions:

vec4 l_renpy_blur_cubic(float value) {
    vec2 n = vec2(1.0 - value, value);
    vec2 s = n * n;
    vec2 outer = s * n * (1.0 / 6.0);
    vec2 inner = vec2(2.0 / 3.0) - s * (2.0 - n) * 0.5;

    return vec4(outer.x, inner.y, inner.x, outer.y);
}

vec4 l_renpy_blur_sample_bicubic(sampler2D tex, vec2 uv, vec4 size, float lod) {
    vec2 tex_coords = uv * size.xy - 0.5;
    vec2 fraction = fract(tex_coords);
    tex_coords -= fraction;

    vec4 xcubic = l_renpy_blur_cubic(fraction.x);
    vec4 ycubic = l_renpy_blur_cubic(fraction.y);

    vec4 c = tex_coords.xxyy + vec2(-0.5, 1.5).xyxy;
    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
    vec4 offset = c + vec4(xcubic.yw, ycubic.yw) / s;

    offset *= size.zzww;

    vec4 sample0 = textureLod(tex, offset.xz, lod);
    vec4 sample1 = textureLod(tex, offset.yz, lod);
    vec4 sample2 = textureLod(tex, offset.xw, lod);
    vec4 sample3 = textureLod(tex, offset.yw, lod);

    return mix(mix(sample3, sample2, s.x), mix(sample1, sample0, s.x), s.z);
}

Fragment shader (priority 200):

// Like a bias added to the hardware's choice of mipmap, the blur is offset by the level that matches how
// many texels are drawn to each pixel. This keeps a blur the same number of pixels on screen however
// large the displayable is drawn, as it was in Ren'Py 8.5.
vec2 l_renpy_blur_texels = v_tex_coord * res0;
vec2 l_renpy_blur_dx = dFdx(l_renpy_blur_texels);
vec2 l_renpy_blur_dy = dFdy(l_renpy_blur_texels);
float l_renpy_blur_base_lod = 0.5 * log2(max(max(dot(l_renpy_blur_dx, l_renpy_blur_dx), dot(l_renpy_blur_dy, l_renpy_blur_dy)), 1.0e-8));

// The blur is given in units of what's being drawn into (virtual pixels for the screen), so it's scaled
// by the number of pixels in each one. This keeps it the same strength relative to the game when the
// window is resized. When config.blur_virtual_pixels is False, as for games made for Ren'Py 8.5 and
// earlier, the blur is given in pixels of what's being drawn into instead.
float l_renpy_blur_target_lod = u_renpy_blur_virtual_pixels * log2(max(u_pixels_per_unit, 1.0e-8));

float l_renpy_blur_level = u_renpy_blur_log2 + l_renpy_blur_base_lod + l_renpy_blur_target_lod;
float l_renpy_blur_lod = floor(l_renpy_blur_level);
float l_renpy_blur_blend = l_renpy_blur_level - l_renpy_blur_lod;

vec2 l_renpy_blur_floor_size = max(vec2(1.0), floor(res0 / exp2(l_renpy_blur_lod)));
vec2 l_renpy_blur_ceil_size = max(vec2(1.0), floor(l_renpy_blur_floor_size * 0.5));

fragment_color = l_renpy_blur_sample_bicubic(tex0, v_tex_coord, vec4(l_renpy_blur_floor_size, 1.0 / l_renpy_blur_floor_size), l_renpy_blur_lod);

if (l_renpy_blur_blend > 0.0) {
    vec4 l_renpy_blur_next_mip = l_renpy_blur_sample_bicubic(tex0, v_tex_coord, vec4(l_renpy_blur_ceil_size, 1.0 / l_renpy_blur_ceil_size), l_renpy_blur_lod + 1.0);
    fragment_color = mix(fragment_color, l_renpy_blur_next_mip, l_renpy_blur_blend);
}

float l_renpy_blur_noise = (fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715)))) - 0.5) * (2.0 / 255.0);

fragment_color.rgb = clamp(fragment_color.rgb + vec3(l_renpy_blur_noise * fragment_color.a), vec3(0.0), vec3(fragment_color.a));

renpy.dissolve

Variables:

uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform float u_renpy_dissolve;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 200):

fragment_color = mix(
    texture(tex0, v_tex_coord, u_lod_bias),
    texture(tex1, v_tex_coord, u_lod_bias),
    u_renpy_dissolve);

renpy.geometry

Variables:

uniform mat4 u_transform;
in vec4 a_position;

Vertex shader (priority 0):

gl_Position = a_position;

Vertex shader (priority 100):

gl_Position = u_transform * gl_Position;

renpy.imagedissolve

Variables:

uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
uniform float u_renpy_dissolve_offset;
uniform float u_renpy_dissolve_multiplier;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 200):

float l_renpy_imagedissolve_done = clamp(
    (texture(tex0, v_tex_coord, u_lod_bias).a + u_renpy_dissolve_offset) * u_renpy_dissolve_multiplier,
    0.0, 1.0);

fragment_color = mix(
    texture(tex1, v_tex_coord, u_lod_bias),
    texture(tex2, v_tex_coord, u_lod_bias),
    l_renpy_imagedissolve_done);

renpy.mask

Variables:

uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 200):

float l_renpy_mask_mask = texture(tex1, v_tex_coord, u_lod_bias).a;

fragment_color = texture(tex0, v_tex_coord, u_lod_bias)
    * (l_renpy_mask_mask * u_renpy_mask_multiplier + u_renpy_mask_offset);

renpy.matrixcolor

Variables:

uniform mat4 u_renpy_matrixcolor;

Fragment shader (priority 400):

fragment_color = u_renpy_matrixcolor * fragment_color;

renpy.movie_yuv

Variables:

uniform sampler2D tex0;
uniform sampler2D tex1;
uniform mat3 u_movie_yuv_matrix;
uniform vec3 u_movie_yuv_offset;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 200):

float l_renpy_movie_yuv_luma = texture(tex0, v_tex_coord).r;
vec2 l_renpy_movie_yuv_chroma = texture(tex1, v_tex_coord).ra;

vec3 l_renpy_movie_yuv_yuv = vec3(l_renpy_movie_yuv_luma, l_renpy_movie_yuv_chroma);
vec3 l_renpy_movie_yuv_rgb = u_movie_yuv_matrix * l_renpy_movie_yuv_yuv + u_movie_yuv_offset;

fragment_color = vec4(clamp(l_renpy_movie_yuv_rgb, 0.0, 1.0), 1.0);

renpy.red_to_alpha

Fragment shader (priority 450):

fragment_color = vec4(fragment_color.r);

renpy.solid

Variables:

uniform vec4 u_renpy_solid_color;

Fragment shader (priority 200):

fragment_color = u_renpy_solid_color;

renpy.texture

Variables:

uniform float u_lod_bias;
uniform sampler2D tex0;
in vec2 a_tex_coord;
out vec2 v_tex_coord;

Vertex shader (priority 200):

v_tex_coord = a_tex_coord;

Fragment shader (priority 200):

fragment_color = texture(tex0, v_tex_coord, u_lod_bias);

textshader.dissolve

Variables:

uniform float u_textshader_dissolve_duration;
uniform float u_text_slow_duration;
uniform float u_text_slow_time;
in float a_text_time;
out float v_text_time;

Vertex shader (priority 200):

v_text_time = a_text_time;

Fragment shader (priority 350):

float l_textshader_dissolve_duration = u_textshader_dissolve_duration * u_text_slow_duration;
float l_textshader_dissolve_done = step(v_text_time, u_text_slow_time);

if (l_textshader_dissolve_duration > 0.0) {
    l_textshader_dissolve_done = clamp((u_text_slow_time - v_text_time) / l_textshader_dissolve_duration, 0.0, 1.0);
}

fragment_color *= l_textshader_dissolve_done;

textshader.flip

Variables:

uniform float u_textshader_flip_duration;
uniform float u_text_slow_duration;
uniform float u_text_slow_time;
in vec2 a_text_center;
in float a_text_min_time;

Vertex shader (priority 20):

float l_textshader_flip_duration = u_textshader_flip_duration * u_text_slow_duration;
float l_textshader_flip_done = step(a_text_min_time, u_text_slow_time);

if (l_textshader_flip_duration > 0.0) {
    l_textshader_flip_done = clamp((u_text_slow_time - a_text_min_time) / l_textshader_flip_duration, 0.0, 1.0);
}

gl_Position.x = mix(2.0 * a_text_center.x - gl_Position.x, gl_Position.x, l_textshader_flip_done);

textshader.jitter

Variables:

uniform vec2 u_textshader_jitter_jitter;
uniform float u_textshader_jitter_duration;
uniform float u_textshader_jitter_individual;
uniform vec4 u_random;
uniform float u_text_time;
uniform float u_text_to_drawable;
in float a_text_index;

Vertex shader (priority 30):

if (u_textshader_jitter_duration <= 0.0 || u_text_time < u_textshader_jitter_duration) {
    vec2 l_textshader_jitter_random = u_random.xy;

    if (u_textshader_jitter_individual != 0.0) {
        vec2 l_textshader_jitter_seed = vec2(a_text_index, a_text_index + 1.0) + u_random.xy;
        l_textshader_jitter_random = fract(sin(vec2(
            dot(l_textshader_jitter_seed, vec2(12.9898, 78.233)),
            dot(l_textshader_jitter_seed, vec2(39.3468, 11.135))
        )) * 43758.5453);
    }

    vec2 l_textshader_jitter_jitter = u_textshader_jitter_jitter * u_text_to_drawable;
    gl_Position.xy += l_textshader_jitter_jitter * l_textshader_jitter_random - l_textshader_jitter_jitter / 2.0;
}

textshader.linetexture

Variables:

uniform sampler2D u_textshader_linetexture_texture;
uniform vec2 u_textshader_linetexture_scale;
uniform vec2 u_textshader_linetexture_texture_OP_virtual_size;

uniform float u_text_to_virtual;
uniform float u_text_main;

in vec2 a_text_center;
out vec2 v_textshader_linetexture_coord;

Vertex shader (priority 10):

v_textshader_linetexture_coord = vec2(gl_Position.x, gl_Position.y - a_text_center.y) / u_textshader_linetexture_scale * u_text_to_virtual / u_textshader_linetexture_texture_OP_virtual_size;
v_textshader_linetexture_coord.y += 0.5;

Fragment shader (priority 300):

if (u_text_main == 1.0) {
    fragment_color *= texture(u_textshader_linetexture_texture, v_textshader_linetexture_coord);
}

textshader.offset

Variables:

uniform vec2 u_textshader_offset_offset;
uniform float u_text_to_drawable;

Vertex shader (priority 35):

gl_Position.xy += u_textshader_offset_offset * u_text_to_drawable;

textshader.slowalpha

Variables:

uniform float u_textshader_slowalpha_alpha;

Fragment shader (priority 325):

vec4 l_textshader_slowalpha_color = fragment_color;

Fragment shader (priority 375):

fragment_color = mix(fragment_color, l_textshader_slowalpha_color, u_textshader_slowalpha_alpha);

textshader.texture

Variables:

uniform sampler2D u_textshader_texture_texture;
uniform vec2 u_textshader_texture_texture_OP_virtual_size;

uniform float u_text_to_virtual;
uniform float u_text_main;
out vec2 v_textshader_texture_coord;

Vertex shader (priority 10):

v_textshader_texture_coord = u_text_to_virtual * gl_Position.xy / u_textshader_texture_texture_OP_virtual_size;

Fragment shader (priority 300):

if (u_text_main == 1.0) {
    fragment_color *= texture(u_textshader_texture_texture, v_textshader_texture_coord);
}

textshader.typewriter

Variables:

uniform float u_text_slow_time;
in float a_text_min_time;
out float v_text_min_time;

Vertex shader (priority 200):

v_text_min_time = a_text_min_time;

Fragment shader (priority 350):

fragment_color *= step(v_text_min_time, u_text_slow_time);

textshader.wave

Variables:

uniform float u_textshader_wave_amplitude;
uniform float u_textshader_wave_frequency;
uniform float u_textshader_wave_wavelength;

uniform float u_time;
uniform float u_text_to_drawable;
in float a_text_index;

Vertex shader (priority 40):

const float l_textshader_wave_two_pi = 6.28318530718;

float l_textshader_wave_phase = a_text_index / u_textshader_wave_wavelength + u_time * u_textshader_wave_frequency;
gl_Position.y += cos(l_textshader_wave_two_pi * l_textshader_wave_phase) * u_textshader_wave_amplitude * u_text_to_drawable;

textshader.zoom

Variables:

uniform float u_textshader_zoom_zoom;
uniform float u_textshader_zoom_duration;
uniform float u_text_slow_duration;
uniform float u_text_slow_time;
in vec2 a_text_center;
in float a_text_min_time;

Vertex shader (priority 25):

float l_textshader_zoom_duration = u_textshader_zoom_duration * u_text_slow_duration;

if (l_textshader_zoom_duration > 0.0) {
    float l_textshader_zoom_done = clamp((u_text_slow_time - a_text_min_time) / l_textshader_zoom_duration, 0.0, 1.0);
    gl_Position.xy = mix(a_text_center + (gl_Position.xy - a_text_center) * u_textshader_zoom_zoom, gl_Position.xy, l_textshader_zoom_done);
}