Scribd
Upload
4 views322 pages

Log

The document provides technical details about the Ren'Py 8.3.7.25031702 software running on a Samsung SM-X210 device with Android version 15. It includes information on initialization times, loading processes, and rendering details, including OpenGL ES specifications. Additionally, it outlines various shader programs used for rendering graphics in the application.

Uploaded by

issacdavidvitolayepes
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
4 views322 pages

Log

The document provides technical details about the Ren'Py 8.3.7.25031702 software running on a Samsung SM-X210 device with Android version 15. It includes information on initialization times, loading processes, and rendering details, including OpenGL ES specifications. Additionally, it outlines various shader programs used for rendering graphics in the application.

Uploaded by

issacdavidvitolayepes
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 322

2025-08-13 19:49:58 UTC

Alternative_Saves_Android_Port
Ren'Py 8.3.7.25031702

Manufacturer samsung Model SM-X210


Android Version: 15
Device Arch: android-arm64_v8a

Screen diagonal is 9.2033961123055 inches.


Version: Ren'Py 8.3.7.25031702
Mobile search paths: /data/user/0/averyfullhouse.tioeroge.com/files/game
/storage/emulated/0/Android/data/averyfullhouse.tioeroge.com/files/game
/storage/emulated/0/Android/data/averyfullhouse.tioeroge.com/files/../../../../
Documents/TioEroge/averyfullhouse.tioeroge.com/game
Early init took 0.20s
Early init took 0.20s
Loading error handling took 0.38s
Loading error handling took 0.38s
Loading script took 2.71s
Loading script took 2.71s
Saving to
/storage/emulated/0/Android/data/averyfullhouse.tioeroge.com/files/../../../../
Documents/TioEroge/averyfullhouse.tioeroge.com
Loading save slot metadata took 0.49s
Loading save slot metadata took 0.49s
Loading persistent took 0.01s
Loading persistent took 0.01s
Set script version to: (8, 4, 1)
Last session ended ungracefully. Hard crash?
- Init at Locations/minor_locations.rpyc:1 took 0.25538 s.
Unable to get height for _mom. Using default 1.0.
Unable to get height for _cheerleader. Using default 1.0.
Unable to get height for _firebrand. Using default 1.0.
Unable to get height for _jock. Using default 1.0.
Unable to get height for _nerd. Using default 1.0.
Unable to get height for _slacker. Using default 1.0.
Running init code took 5.00s
Running init code took 5.00s
Loading analysis data took 0.04s
Loading analysis data took 0.04s
Analyze and compile ATL took 0.03s
Analyze and compile ATL took 0.03s
Reloading save slot metadata took 0.30s
Reloading save slot metadata took 0.30s
Index archives took 0.00s
Index archives took 0.00s
Dump and make backups took 0.00s
Dump and make backups took 0.00s
Cleaning cache took 0.00s
Cleaning cache took 0.00s
Making clean stores took 0.00s
Making clean stores took 0.00s
Initial gc took 0.24s
Initial gc took 0.24s
DPI scale factor: 1.000000
Creating interface object took 0.03s
Creating interface object took 0.03s
Cleaning stores took 0.00s
Cleaning stores took 0.00s
Init translation took 0.00s
Init translation took 0.00s
Build styles took 0.00s
Build styles took 0.00s
Load screen analysis took 0.08s
Load screen analysis took 0.08s
Analyze screens took 0.00s
Analyze screens took 0.00s
Save screen analysis took 0.00s
Save screen analysis took 0.00s
Prepare screens took 0.20s
Prepare screens took 0.20s
Save pyanalysis. took 0.00s
Save pyanalysis. took 0.00s
Save bytecode. took 0.00s
Save bytecode. took 0.00s
Running _start took 0.00s
Running _start took 0.00s
Interface start took 1.22s
Interface start took 1.22s

Initializing gles2 renderer:


primary display bounds: (0, 0, 1920, 1092)
swap interval: 1 frames
Fullscreen mode.
Vendor: "b'Qualcomm'"
Renderer: b'Adreno (TM) 619'
Version: b'OpenGL ES 3.2 V@0530.55 (GIT@923a446bf8, I23d7d7df15, 1725536844)
(Date:09/05/24)'
Display Info: None
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}
--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}
--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,
u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;
void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Total time until interface ready: 11.407229900360107s.
Hid presplash.
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2

Full traceback:
File "script.rpyc", line 510, in script call
File "script.rpyc", line 506, in script call
File "script.rpyc", line 547, in script call
File "script.rpyc", line 727, in script call
File "tl/SpanishTE/Locations/Home/Jock_Bedroom/jock_bed_events.rpyc", line 8, in
script
File "renpy/ast.py", line 2586, in execute
File "renpy/ast.py", line 623, in execute
File "renpy/exports\sayexports.py", line 132, in say
File "game/Classes/Logic_Classes/Person.rpy", line 385, in __call__
File "renpy/character.py", line 1377, in __call__
File "renpy/character.py", line 1456, in __call__
File "renpy/character.py", line 1369, in prefix_suffix
File "renpy/character.py", line 1349, in sub
File "renpy/substitutions.py", line 373, in substitute
File "renpy/substitutions.py", line 86, in interpolate
File "renpy/substitutions.py", line 78, in interpolate
File "renpy/python.py", line 1216, in py_eval
File "renpy/python.py", line 1153, in py_compile
File "renpy/python.py", line 1090, in py_compile
File "renpy/python.py", line 1082, in py_compile
SyntaxError: invalid syntax (<none>, line 1)

While running game code:


File "game/Classes/Logic_Classes/Person.rpy", line 385, in __call__
SyntaxError: invalid syntax (<none>, line 1)
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);
gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +
u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;
void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}
--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;
gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}
--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}
--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;
void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGirl2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Unable to predict textures for images/Models/CrowdModels/CrowdGirl2
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy3
Unable to predict textures for images/Models/CrowdModels/CrowdGuy2
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;
gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {


if (i >= u_renpy_blur_log2 + 5.) {
break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,
u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);
gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +
u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;
void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}
--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;
gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}
--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}
--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;
void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Scry for path *Spam chat* went wrong: name 'succubus_boss' is not defined
Scry for path *Spam chat* went wrong: name 'succubus_boss' is not defined
Scry for path *Lure companions with [mom_cog.character_name]'s armour* went wrong:
name 'succubus_boss' is not defined
Scry for path *Lure companions with [mom_cog.character_name]'s armour* went wrong:
name 'succubus_boss' is not defined
Scry for path *Have [nerd.first_name] help you* went wrong: name 'succubus_boss' is
not defined
Scry for path *Have [nerd.first_name] help you* went wrong: name 'succubus_boss' is
not defined
Scry for path *Nevermind* went wrong: name 'succubus_boss' is not defined
Scry for path *Nevermind* went wrong: name 'succubus_boss' is not defined
Scry for path *Party up with [the_companion.character_power_name]* went wrong: name
'succubus_boss' is not defined
Scry for path *Party up with [the_companion.character_power_name]* went wrong: name
'succubus_boss' is not defined
Scry for path *Work alone* went wrong: name 'succubus_boss' is not defined
Scry for path *Work alone* went wrong: name 'succubus_boss' is not defined
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Scry for path *Adventure into the forest* went wrong: name 'succubus_boss' is not
defined
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}
if (renpy_blur_norm > 0.0) {
gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}
--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);


for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;
gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}
--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}
--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}
--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {


if (i >= u_renpy_blur_log2 + 5.) {
break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
gl_FragColor = u_renpy_matrixcolor * gl_FragColor;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);
float a = clamp((color0.a + u_renpy_dissolve_offset) *
u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;
void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;
void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;
gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}
--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}
--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;
gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;

void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;
void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,
u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;
void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------
Entering foreground. -------------------------------------------
Screen sizes: virtual=(2560, 1440) physical=(1920, 1200) drawable=(1920, 1200)
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.texture -----
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.texture ------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.texture ----------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.alpha, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry ----------------------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry --------------------------------------------------------
#version 100
precision mediump float;

void main() {
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor ----------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.texture ------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.texture ----------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.texture -------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}
--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask --------------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor, renpy.solid --------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor, renpy.solid ------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}
--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.alpha, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.texture -------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.texture -----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor --------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry, renpy.matrixcolor ------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture -----------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.matrixcolor, renpy.texture ---------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.mask, renpy.geometry, renpy.matrixcolor,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve -------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve -----------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture ---
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.imagedissolve, renpy.matrixcolor, renpy.texture -
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve_multiplier;
uniform float u_renpy_dissolve_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);
vec4 color2 = texture2D(tex2, v_tex_coord.st, u_lod_bias);

float a = clamp((color0.a + u_renpy_dissolve_offset) *


u_renpy_dissolve_multiplier, 0.0, 1.0);
gl_FragColor = mix(color1, color2, a);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.geometry, renpy.solid --------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}
--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.geometry, renpy.solid ------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.solid ---------------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.solid -------------------------------------------
#version 100
precision mediump float;
uniform vec4 u_renpy_solid_color;

void main() {

gl_FragColor = u_renpy_solid_color;
}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.matrixcolor ---------------------------------------
#version 100
attribute vec4 a_position;
uniform mat4 u_transform;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;


}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.matrixcolor -------------------------------------
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;

void main() {

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.alpha, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,
u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}
--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry, renpy.matrixcolor
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex renpy.ftl ---------------------------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
varying vec2 v_tex_coord;
void main() {

v_tex_coord = a_tex_coord;
gl_Position = a_position;
}

--------------------------------------------------------------------------------
fragment renpy.ftl -------------------------------------------------------------
#version 100
precision mediump float;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, -1.0);


}

--------------------------------------------------------------------------------
vertex renpy.dissolve, renpy.geometry ------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.dissolve, renpy.geometry ----------------------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_dissolve;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 color0 = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 color1 = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = mix(color0, color1, u_renpy_dissolve);


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.alpha,
renpy.geometry
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_over;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex renpy.blur, renpy.geometry ----------------------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.blur, renpy.geometry --------------------------------------------
#version 100
precision mediump float;
uniform float u_renpy_blur_log2;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;
v_tex_coord.y = 1.0 - v_tex_coord.y;
}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, live2d.inverted_mask, renpy.geometry, renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex renpy.alpha, renpy.blur, renpy.geometry ---------------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.alpha, renpy.blur, renpy.geometry -------------------------------
#version 100
precision mediump float;
uniform float u_renpy_alpha;
uniform float u_renpy_blur_log2;
uniform float u_renpy_over;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = vec4(0.);
float renpy_blur_norm = 0.;

for (float i = -5.; i < 1.; i += 1.) {


float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));
renpy_blur_norm += renpy_blur_weight;
}

gl_FragColor += renpy_blur_norm * texture2D(tex0, v_tex_coord.xy, 0.);

for (float i = 1.; i < 14.; i += 1.) {

if (i >= u_renpy_blur_log2 + 5.) {


break;
}

float renpy_blur_weight = exp(-0.5 * pow(u_renpy_blur_log2 - i, 2.));


gl_FragColor += renpy_blur_weight * texture2D(tex0, v_tex_coord.xy, i);
renpy_blur_norm += renpy_blur_weight;
}

if (renpy_blur_norm > 0.0) {


gl_FragColor /= renpy_blur_norm;
} else {
gl_FragColor = texture2D(tex0, v_tex_coord.xy, 0.0);
}

gl_FragColor = gl_FragColor * vec4(u_renpy_alpha, u_renpy_alpha,


u_renpy_alpha, u_renpy_alpha * u_renpy_over);
}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.matrixcolor
#version 100
precision mediump float;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.inverted_mask, renpy.geometry,
renpy.texture
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);

vec4 color = texture2D(tex0, v_tex_coord);


vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * (1.0 - mask.a);

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
vertex live2d.flip_texture, renpy.geometry, renpy.texture ----------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.flip_texture, renpy.geometry, renpy.texture --------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform sampler2D tex0;
varying vec2 v_tex_coord;

void main() {

gl_FragColor = texture2D(tex0, v_tex_coord.xy, u_lod_bias);


}

--------------------------------------------------------------------------------
vertex renpy.geometry, renpy.mask, renpy.matrixcolor ---------------------------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform mat4 u_transform;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
}

--------------------------------------------------------------------------------
fragment renpy.geometry, renpy.mask, renpy.matrixcolor -------------------------
#version 100
precision mediump float;
uniform float u_lod_bias;
uniform float u_renpy_mask_multiplier;
uniform float u_renpy_mask_offset;
uniform mat4 u_renpy_matrixcolor;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 v_tex_coord;

void main() {

vec4 src = texture2D(tex0, v_tex_coord.st, u_lod_bias);


vec4 mask = texture2D(tex1, v_tex_coord.st, u_lod_bias);

gl_FragColor = src * (mask.a * u_renpy_mask_multiplier +


u_renpy_mask_offset);

gl_FragColor = u_renpy_matrixcolor * gl_FragColor;


}

--------------------------------------------------------------------------------
vertex live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry ---------
#version 100
attribute vec2 a_tex_coord;
attribute vec4 a_position;
uniform float u_live2d_ppu;
uniform mat4 u_transform;
uniform vec2 u_live2d_offset;
uniform vec2 u_model_size;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {

gl_Position = a_position;

gl_Position = u_transform * gl_Position;

v_tex_coord = a_tex_coord;
v_mask_coord = (a_position.xy * u_live2d_ppu + u_live2d_offset) /
u_model_size;
v_mask_coord.y = 1.0 - v_mask_coord.y;

v_tex_coord.y = 1.0 - v_tex_coord.y;


}

--------------------------------------------------------------------------------
fragment live2d.colors, live2d.flip_texture, live2d.mask, renpy.geometry -------
#version 100
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform vec4 u_multiply;
uniform vec4 u_screen;
varying vec2 v_mask_coord;
varying vec2 v_tex_coord;

void main() {
vec4 color = texture2D(tex0, v_tex_coord);
vec4 mask = texture2D(tex1, v_mask_coord);
gl_FragColor = color * mask.a;

gl_FragColor.rgb = gl_FragColor.rgb * u_multiply.rgb;


gl_FragColor.rgb = (gl_FragColor.rgb + u_screen.rgb * gl_FragColor.a) -
(gl_FragColor.rgb * u_screen.rgb);
}

--------------------------------------------------------------------------------
Maximum texture size: 2624x2048
Pausing audio.
Disabling periodic events.
Saving.
Freeing memory.
Releasing wakelock.
Entered background. --------------------------------------------

You might also like