2020-05-18 08:56:22 +00:00
#[vertex]
2019-06-16 02:45:24 +00:00
#version 450
2021-04-13 20:01:43 +00:00
#VERSION_DEFINES
2019-06-16 02:45:24 +00:00
2019-06-24 19:13:06 +00:00
#ifdef USE_ATTRIBUTES
2019-06-16 02:45:24 +00:00
layout(location = 0) in vec2 vertex_attrib;
layout(location = 3) in vec4 color_attrib;
layout(location = 4) in vec2 uv_attrib;
2020-12-02 01:40:47 +00:00
layout(location = 10) in uvec4 bone_attrib;
layout(location = 11) in vec4 weight_attrib;
2019-06-24 19:13:06 +00:00
2019-06-16 02:45:24 +00:00
#endif
#include "canvas_uniforms_inc.glsl"
2019-11-05 11:01:00 +00:00
layout(location = 0) out vec2 uv_interp;
layout(location = 1) out vec4 color_interp;
layout(location = 2) out vec2 vertex_interp;
2019-06-16 02:45:24 +00:00
#ifdef USE_NINEPATCH
2019-11-05 11:01:00 +00:00
layout(location = 3) out vec2 pixel_size_interp;
2019-06-16 02:45:24 +00:00
#endif
2021-04-13 20:01:43 +00:00
#ifdef MATERIAL_UNIFORMS_USED
2020-10-24 15:15:43 +00:00
layout(set = 1, binding = 0, std140) uniform MaterialUniforms{
2021-04-13 20:01:43 +00:00
#MATERIAL_UNIFORMS
2019-07-21 14:31:30 +00:00
} material;
#endif
2019-06-16 02:45:24 +00:00
2021-04-13 20:01:43 +00:00
#GLOBALS
2019-06-16 02:45:24 +00:00
void main() {
vec4 instance_custom = vec4(0.0);
2019-06-24 19:13:06 +00:00
#ifdef USE_PRIMITIVE
2019-11-05 11:01:00 +00:00
//weird bug,
//this works
2019-06-24 19:13:06 +00:00
vec2 vertex;
vec2 uv;
vec4 color;
2019-11-05 11:01:00 +00:00
if (gl_VertexIndex == 0) {
2019-06-24 19:13:06 +00:00
vertex = draw_data.points[0];
uv = draw_data.uvs[0];
2019-11-05 11:01:00 +00:00
color = vec4(unpackHalf2x16(draw_data.colors[0]), unpackHalf2x16(draw_data.colors[1]));
} else if (gl_VertexIndex == 1) {
2019-06-24 19:13:06 +00:00
vertex = draw_data.points[1];
uv = draw_data.uvs[1];
2019-11-05 11:01:00 +00:00
color = vec4(unpackHalf2x16(draw_data.colors[2]), unpackHalf2x16(draw_data.colors[3]));
2019-06-26 18:11:52 +00:00
} else {
2019-06-24 19:13:06 +00:00
vertex = draw_data.points[2];
uv = draw_data.uvs[2];
2019-11-05 11:01:00 +00:00
color = vec4(unpackHalf2x16(draw_data.colors[4]), unpackHalf2x16(draw_data.colors[5]));
2019-06-24 19:13:06 +00:00
}
2019-11-05 11:01:00 +00:00
uvec4 bones = uvec4(0, 0, 0, 0);
2020-12-02 01:40:47 +00:00
vec4 bone_weights = vec4(0.0);
2019-06-24 19:13:06 +00:00
#elif defined(USE_ATTRIBUTES)
2019-06-16 02:45:24 +00:00
vec2 vertex = vertex_attrib;
2021-06-23 15:38:31 +00:00
vec4 color = color_attrib * draw_data.modulation;
2019-06-16 02:45:24 +00:00
vec2 uv = uv_attrib;
2019-06-24 19:13:06 +00:00
2020-12-02 01:40:47 +00:00
uvec4 bones = bone_attrib;
vec4 bone_weights = weight_attrib;
2019-06-16 02:45:24 +00:00
#else
2019-11-05 11:01:00 +00:00
vec2 vertex_base_arr[4] = vec2[](vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0));
2019-06-16 02:45:24 +00:00
vec2 vertex_base = vertex_base_arr[gl_VertexIndex];
2019-11-05 11:01:00 +00:00
vec2 uv = draw_data.src_rect.xy + abs(draw_data.src_rect.zw) * ((draw_data.flags & FLAGS_TRANSPOSE_RECT) != 0 ? vertex_base.yx : vertex_base.xy);
2019-06-24 19:13:06 +00:00
vec4 color = draw_data.modulation;
2019-06-16 02:45:24 +00:00
vec2 vertex = draw_data.dst_rect.xy + abs(draw_data.dst_rect.zw) * mix(vertex_base, vec2(1.0, 1.0) - vertex_base, lessThan(draw_data.src_rect.zw, vec2(0.0, 0.0)));
2019-11-05 11:01:00 +00:00
uvec4 bones = uvec4(0, 0, 0, 0);
2019-06-16 02:45:24 +00:00
#endif
2022-03-18 09:10:55 +00:00
mat4 model_matrix = mat4(vec4(draw_data.world_x, 0.0, 0.0), vec4(draw_data.world_y, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(draw_data.world_ofs, 0.0, 1.0));
2019-06-24 19:13:06 +00:00
2021-05-10 16:12:44 +00:00
#define FLAGS_INSTANCING_MASK 0x7F
#define FLAGS_INSTANCING_HAS_COLORS (1 << 7)
#define FLAGS_INSTANCING_HAS_CUSTOM_DATA (1 << 8)
uint instancing = draw_data.flags & FLAGS_INSTANCING_MASK;
#ifdef USE_ATTRIBUTES
if (instancing > 1) {
// trails
uint stride = 2 + 1 + 1; //particles always uses this format
uint trail_size = instancing;
2019-06-16 02:45:24 +00:00
2021-05-10 16:12:44 +00:00
uint offset = trail_size * stride * gl_InstanceIndex;
vec4 pcolor;
2021-05-20 14:25:06 +00:00
vec2 new_vertex;
2021-05-10 16:12:44 +00:00
{
uint boffset = offset + bone_attrib.x * stride;
2021-05-20 14:25:06 +00:00
new_vertex = (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.x;
pcolor = transforms.data[boffset + 2] * weight_attrib.x;
2021-05-10 16:12:44 +00:00
}
if (weight_attrib.y > 0.001) {
uint boffset = offset + bone_attrib.y * stride;
2021-05-20 14:25:06 +00:00
new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.y;
pcolor += transforms.data[boffset + 2] * weight_attrib.y;
2021-05-10 16:12:44 +00:00
}
if (weight_attrib.z > 0.001) {
uint boffset = offset + bone_attrib.z * stride;
2021-05-20 14:25:06 +00:00
new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.z;
pcolor += transforms.data[boffset + 2] * weight_attrib.z;
2019-06-16 02:45:24 +00:00
}
2021-05-10 16:12:44 +00:00
if (weight_attrib.w > 0.001) {
uint boffset = offset + bone_attrib.w * stride;
2021-05-20 14:25:06 +00:00
new_vertex += (vec4(vertex, 0.0, 1.0) * mat4(transforms.data[boffset + 0], transforms.data[boffset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy * weight_attrib.w;
pcolor += transforms.data[boffset + 2] * weight_attrib.w;
2021-05-10 16:12:44 +00:00
}
2021-05-20 14:25:06 +00:00
instance_custom = transforms.data[offset + 3];
2021-05-10 16:12:44 +00:00
2021-05-20 14:25:06 +00:00
vertex = new_vertex;
2021-05-10 16:12:44 +00:00
color *= pcolor;
} else
#endif // USE_ATTRIBUTES
2021-10-28 13:43:36 +00:00
{
if (instancing == 1) {
uint stride = 2;
{
if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_COLORS)) {
stride += 1;
}
if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_CUSTOM_DATA)) {
stride += 1;
}
}
uint offset = stride * gl_InstanceIndex;
mat4 matrix = mat4(transforms.data[offset + 0], transforms.data[offset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0));
offset += 2;
2021-05-10 16:12:44 +00:00
if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_COLORS)) {
2021-10-28 13:43:36 +00:00
color *= transforms.data[offset];
offset += 1;
2021-05-10 16:12:44 +00:00
}
2021-10-28 13:43:36 +00:00
2021-05-10 16:12:44 +00:00
if (bool(draw_data.flags & FLAGS_INSTANCING_HAS_CUSTOM_DATA)) {
2021-10-28 13:43:36 +00:00
instance_custom = transforms.data[offset];
2019-06-16 02:45:24 +00:00
}
2021-05-10 16:12:44 +00:00
2021-10-28 13:43:36 +00:00
matrix = transpose(matrix);
2022-03-18 09:10:55 +00:00
model_matrix = model_matrix * matrix;
2021-05-10 16:12:44 +00:00
}
}
2019-06-16 02:45:24 +00:00
2019-06-24 19:13:06 +00:00
#if !defined(USE_ATTRIBUTES) && !defined(USE_PRIMITIVE)
2019-11-05 11:01:00 +00:00
if (bool(draw_data.flags & FLAGS_USING_PARTICLES)) {
2019-06-16 02:45:24 +00:00
//scale by texture size
vertex /= draw_data.color_texture_pixel_size;
}
2019-06-24 19:13:06 +00:00
#endif
2019-06-16 02:45:24 +00:00
#ifdef USE_POINT_SIZE
float point_size = 1.0;
#endif
{
2021-04-13 20:01:43 +00:00
#CODE : VERTEX
2019-06-16 02:45:24 +00:00
}
#ifdef USE_NINEPATCH
2019-06-19 20:03:19 +00:00
pixel_size_interp = abs(draw_data.dst_rect.zw) * vertex_base;
2019-06-16 02:45:24 +00:00
#endif
#if !defined(SKIP_TRANSFORM_USED)
2022-03-18 09:10:55 +00:00
vertex = (model_matrix * vec4(vertex, 0.0, 1.0)).xy;
2019-06-16 02:45:24 +00:00
#endif
color_interp = color;
2020-10-29 21:09:16 +00:00
if (canvas_data.use_pixel_snap) {
2019-06-16 02:45:24 +00:00
vertex = floor(vertex + 0.5);
// precision issue on some hardware creates artifacts within texture
// offset uv by a small amount to avoid
uv += 1e-5;
}
2019-11-05 11:01:00 +00:00
vertex = (canvas_data.canvas_transform * vec4(vertex, 0.0, 1.0)).xy;
2019-07-05 01:54:32 +00:00
vertex_interp = vertex;
2019-06-19 20:03:19 +00:00
uv_interp = uv;
2019-07-05 01:54:32 +00:00
2019-11-05 11:01:00 +00:00
gl_Position = canvas_data.screen_transform * vec4(vertex, 0.0, 1.0);
2019-06-16 02:45:24 +00:00
#ifdef USE_POINT_SIZE
2019-11-05 11:01:00 +00:00
gl_PointSize = point_size;
2019-06-16 02:45:24 +00:00
#endif
}
2020-05-18 08:56:22 +00:00
#[fragment]
2019-06-16 02:45:24 +00:00
#version 450
2021-04-13 20:01:43 +00:00
#VERSION_DEFINES
2019-06-16 02:45:24 +00:00
#include "canvas_uniforms_inc.glsl"
2019-11-05 11:01:00 +00:00
layout(location = 0) in vec2 uv_interp;
layout(location = 1) in vec4 color_interp;
layout(location = 2) in vec2 vertex_interp;
2019-06-16 02:45:24 +00:00
#ifdef USE_NINEPATCH
2019-11-05 11:01:00 +00:00
layout(location = 3) in vec2 pixel_size_interp;
2019-06-16 02:45:24 +00:00
#endif
layout(location = 0) out vec4 frag_color;
2021-04-13 20:01:43 +00:00
#ifdef MATERIAL_UNIFORMS_USED
2020-10-24 15:15:43 +00:00
layout(set = 1, binding = 0, std140) uniform MaterialUniforms{
2021-04-13 20:01:43 +00:00
#MATERIAL_UNIFORMS
2019-07-21 14:31:30 +00:00
} material;
#endif
2019-06-16 02:45:24 +00:00
2020-11-26 12:50:21 +00:00
vec2 screen_uv_to_sdf(vec2 p_uv) {
return canvas_data.screen_to_sdf * p_uv;
}
float texture_sdf(vec2 p_sdf) {
vec2 uv = p_sdf * canvas_data.sdf_to_tex.xy + canvas_data.sdf_to_tex.zw;
float d = texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv).r;
2021-05-20 14:25:06 +00:00
d *= SDF_MAX_LENGTH;
2020-11-26 12:50:21 +00:00
return d * canvas_data.tex_to_sdf;
}
vec2 texture_sdf_normal(vec2 p_sdf) {
vec2 uv = p_sdf * canvas_data.sdf_to_tex.xy + canvas_data.sdf_to_tex.zw;
const float EPSILON = 0.001;
return normalize(vec2(
texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv + vec2(EPSILON, 0.0)).r - texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv - vec2(EPSILON, 0.0)).r,
texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv + vec2(0.0, EPSILON)).r - texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv - vec2(0.0, EPSILON)).r));
}
vec2 sdf_to_screen_uv(vec2 p_sdf) {
return p_sdf * canvas_data.sdf_to_screen;
}
2021-04-13 20:01:43 +00:00
#GLOBALS
2019-06-16 02:45:24 +00:00
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2019-06-16 02:45:24 +00:00
2019-07-21 14:31:30 +00:00
vec4 light_compute(
vec3 light_vertex,
vec3 light_position,
2019-06-16 02:45:24 +00:00
vec3 normal,
2019-07-21 14:31:30 +00:00
vec4 light_color,
float light_energy,
vec4 specular_shininess,
inout vec4 shadow_modulate,
2019-06-16 02:45:24 +00:00
vec2 screen_uv,
2019-07-21 14:31:30 +00:00
vec2 uv,
2020-11-03 19:51:53 +00:00
vec4 color, bool is_directional) {
2019-07-21 14:31:30 +00:00
vec4 light = vec4(0.0);
2022-09-28 18:45:08 +00:00
vec3 light_direction = vec3(0.0);
if (is_directional) {
light_direction = normalize(mix(vec3(light_position.xy, 0.0), vec3(0, 0, 1), light_position.z));
light_position = vec3(0.0);
} else {
light_direction = normalize(light_position - light_vertex);
}
2021-04-13 20:01:43 +00:00
#CODE : LIGHT
2019-07-21 14:31:30 +00:00
return light;
2019-06-16 02:45:24 +00:00
}
2019-07-21 14:31:30 +00:00
#endif
2019-06-16 02:45:24 +00:00
#ifdef USE_NINEPATCH
float map_ninepatch_axis(float pixel, float draw_size, float tex_pixel_size, float margin_begin, float margin_end, int np_repeat, inout int draw_center) {
float tex_size = 1.0 / tex_pixel_size;
if (pixel < margin_begin) {
return pixel * tex_pixel_size;
} else if (pixel >= draw_size - margin_end) {
return (tex_size - (draw_size - pixel)) * tex_pixel_size;
} else {
2019-11-05 11:01:00 +00:00
if (!bool(draw_data.flags & FLAGS_NINEPACH_DRAW_CENTER)) {
2019-06-16 02:45:24 +00:00
draw_center--;
}
2020-01-01 10:58:02 +00:00
// np_repeat is passed as uniform using NinePatchRect::AxisStretchMode enum.
if (np_repeat == 0) { // Stretch.
// Convert to ratio.
2019-06-16 02:45:24 +00:00
float ratio = (pixel - margin_begin) / (draw_size - margin_begin - margin_end);
2020-01-01 10:58:02 +00:00
// Scale to source texture.
2019-06-16 02:45:24 +00:00
return (margin_begin + ratio * (tex_size - margin_begin - margin_end)) * tex_pixel_size;
2020-01-01 10:58:02 +00:00
} else if (np_repeat == 1) { // Tile.
// Convert to offset.
2019-06-16 02:45:24 +00:00
float ofs = mod((pixel - margin_begin), tex_size - margin_begin - margin_end);
2020-01-01 10:58:02 +00:00
// Scale to source texture.
2019-06-16 02:45:24 +00:00
return (margin_begin + ofs) * tex_pixel_size;
2020-01-01 10:58:02 +00:00
} else if (np_repeat == 2) { // Tile Fit.
// Calculate scale.
2019-06-16 02:45:24 +00:00
float src_area = draw_size - margin_begin - margin_end;
float dst_area = tex_size - margin_begin - margin_end;
float scale = max(1.0, floor(src_area / max(dst_area, 0.0000001) + 0.5));
2020-01-01 10:58:02 +00:00
// Convert to ratio.
2019-06-16 02:45:24 +00:00
float ratio = (pixel - margin_begin) / src_area;
ratio = mod(ratio * scale, 1.0);
2020-01-01 10:58:02 +00:00
// Scale to source texture.
2019-06-16 02:45:24 +00:00
return (margin_begin + ratio * dst_area) * tex_pixel_size;
2020-01-01 10:58:02 +00:00
} else { // Shouldn't happen, but silences compiler warning.
return 0.0;
2019-06-16 02:45:24 +00:00
}
}
}
#endif
2020-11-03 19:51:53 +00:00
#ifdef USE_LIGHTING
vec3 light_normal_compute(vec3 light_vec, vec3 normal, vec3 base_color, vec3 light_color, vec4 specular_shininess, bool specular_shininess_used) {
float cNdotL = max(0.0, dot(normal, light_vec));
if (specular_shininess_used) {
//blinn
vec3 view = vec3(0.0, 0.0, 1.0); // not great but good enough
vec3 half_vec = normalize(view + light_vec);
float cNdotV = max(dot(normal, view), 0.0);
float cNdotH = max(dot(normal, half_vec), 0.0);
float cVdotH = max(dot(view, half_vec), 0.0);
float cLdotH = max(dot(light_vec, half_vec), 0.0);
float shininess = exp2(15.0 * specular_shininess.a + 1.0) * 0.25;
float blinn = pow(cNdotH, shininess);
blinn *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
float s = (blinn) / max(4.0 * cNdotV * cNdotL, 0.75);
return specular_shininess.rgb * light_color * s + light_color * base_color * cNdotL;
} else {
return light_color * base_color * cNdotL;
}
}
//float distance = length(shadow_pos);
vec4 light_shadow_compute(uint light_base, vec4 light_color, vec4 shadow_uv
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2020-11-03 19:51:53 +00:00
,
vec3 shadow_modulate
#endif
) {
float shadow;
uint shadow_mode = light_array.data[light_base].flags & LIGHT_FLAGS_FILTER_MASK;
if (shadow_mode == LIGHT_FLAGS_SHADOW_NEAREST) {
shadow = textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv, 0.0).x;
} else if (shadow_mode == LIGHT_FLAGS_SHADOW_PCF5) {
vec4 shadow_pixel_size = vec4(light_array.data[light_base].shadow_pixel_size, 0.0, 0.0, 0.0);
shadow = 0.0;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 2.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 2.0, 0.0).x;
shadow /= 5.0;
} else { //PCF13
vec4 shadow_pixel_size = vec4(light_array.data[light_base].shadow_pixel_size, 0.0, 0.0, 0.0);
shadow = 0.0;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 6.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 5.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 4.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 3.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size * 2.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv - shadow_pixel_size, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 2.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 3.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 4.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 5.0, 0.0).x;
shadow += textureProjLod(sampler2DShadow(shadow_atlas_texture, shadow_sampler), shadow_uv + shadow_pixel_size * 6.0, 0.0).x;
shadow /= 13.0;
}
vec4 shadow_color = unpackUnorm4x8(light_array.data[light_base].shadow_color);
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2021-01-09 19:45:03 +00:00
shadow_color.rgb *= shadow_modulate;
2020-11-03 19:51:53 +00:00
#endif
shadow_color.a *= light_color.a; //respect light alpha
return mix(light_color, shadow_color, shadow);
}
void light_blend_compute(uint light_base, vec4 light_color, inout vec3 color) {
uint blend_mode = light_array.data[light_base].flags & LIGHT_FLAGS_BLEND_MASK;
switch (blend_mode) {
case LIGHT_FLAGS_BLEND_MODE_ADD: {
color.rgb += light_color.rgb * light_color.a;
} break;
case LIGHT_FLAGS_BLEND_MODE_SUB: {
color.rgb -= light_color.rgb * light_color.a;
} break;
case LIGHT_FLAGS_BLEND_MODE_MIX: {
color.rgb = mix(color.rgb, light_color.rgb, light_color.a);
} break;
}
}
#endif
2020-12-27 13:30:33 +00:00
float msdf_median(float r, float g, float b, float a) {
return min(max(min(r, g), min(max(r, g), b)), a);
}
2019-06-16 02:45:24 +00:00
void main() {
vec4 color = color_interp;
vec2 uv = uv_interp;
2019-07-05 01:54:32 +00:00
vec2 vertex = vertex_interp;
2019-06-16 02:45:24 +00:00
2019-06-24 19:13:06 +00:00
#if !defined(USE_ATTRIBUTES) && !defined(USE_PRIMITIVE)
2019-06-16 02:45:24 +00:00
#ifdef USE_NINEPATCH
int draw_center = 2;
uv = vec2(
2019-11-05 11:01:00 +00:00
map_ninepatch_axis(pixel_size_interp.x, abs(draw_data.dst_rect.z), draw_data.color_texture_pixel_size.x, draw_data.ninepatch_margins.x, draw_data.ninepatch_margins.z, int(draw_data.flags >> FLAGS_NINEPATCH_H_MODE_SHIFT) & 0x3, draw_center),
map_ninepatch_axis(pixel_size_interp.y, abs(draw_data.dst_rect.w), draw_data.color_texture_pixel_size.y, draw_data.ninepatch_margins.y, draw_data.ninepatch_margins.w, int(draw_data.flags >> FLAGS_NINEPATCH_V_MODE_SHIFT) & 0x3, draw_center));
2019-06-16 02:45:24 +00:00
if (draw_center == 0) {
color.a = 0.0;
}
uv = uv * draw_data.src_rect.zw + draw_data.src_rect.xy; //apply region if needed
2019-06-19 20:03:19 +00:00
2019-11-05 11:01:00 +00:00
#endif
if (bool(draw_data.flags & FLAGS_CLIP_RECT_UV)) {
2019-06-16 02:45:24 +00:00
uv = clamp(uv, draw_data.src_rect.xy, draw_data.src_rect.xy + abs(draw_data.src_rect.zw));
}
#endif
2020-12-27 13:30:33 +00:00
#ifndef USE_PRIMITIVE
if (bool(draw_data.flags & FLAGS_USE_MSDF)) {
float px_range = draw_data.ninepatch_margins.x;
float outline_thickness = draw_data.ninepatch_margins.y;
//float reserved1 = draw_data.ninepatch_margins.z;
//float reserved2 = draw_data.ninepatch_margins.w;
vec4 msdf_sample = texture(sampler2D(color_texture, texture_sampler), uv);
vec2 msdf_size = vec2(textureSize(sampler2D(color_texture, texture_sampler), 0));
vec2 dest_size = vec2(1.0) / fwidth(uv);
float px_size = max(0.5 * dot((vec2(px_range) / msdf_size), dest_size), 1.0);
float d = msdf_median(msdf_sample.r, msdf_sample.g, msdf_sample.b, msdf_sample.a) - 0.5;
if (outline_thickness > 0) {
float cr = clamp(outline_thickness, 0.0, px_range / 2) / px_range;
float a = clamp((d + cr) * px_size, 0.0, 1.0);
color.a = a * color.a;
} else {
float a = clamp(d * px_size + 0.5, 0.0, 1.0);
color.a = a * color.a;
}
2022-08-12 11:03:28 +00:00
} else if (bool(draw_data.flags & FLAGS_USE_LCD)) {
vec4 lcd_sample = texture(sampler2D(color_texture, texture_sampler), uv);
if (lcd_sample.a == 1.0) {
color.rgb = lcd_sample.rgb * color.a;
} else {
color = vec4(0.0, 0.0, 0.0, 0.0);
}
2020-12-27 13:30:33 +00:00
} else {
#else
{
#endif
color *= texture(sampler2D(color_texture, texture_sampler), uv);
}
2019-07-05 01:54:32 +00:00
2019-11-05 11:01:00 +00:00
uint light_count = (draw_data.flags >> FLAGS_LIGHT_COUNT_SHIFT) & 0xF; //max 16 lights
2020-11-03 19:51:53 +00:00
bool using_light = light_count > 0 || canvas_data.directional_light_count > 0;
2019-06-16 02:45:24 +00:00
vec3 normal;
#if defined(NORMAL_USED)
bool normal_used = true;
#else
bool normal_used = false;
#endif
2020-11-03 19:51:53 +00:00
if (normal_used || (using_light && bool(draw_data.flags & FLAGS_DEFAULT_NORMAL_MAP_USED))) {
2019-11-05 11:01:00 +00:00
normal.xy = texture(sampler2D(normal_texture, texture_sampler), uv).xy * vec2(2.0, -2.0) - vec2(1.0, -1.0);
2023-01-14 06:20:42 +00:00
if (bool(draw_data.flags & FLAGS_FLIP_H)) {
normal.x = -normal.x;
}
if (bool(draw_data.flags & FLAGS_FLIP_V)) {
normal.y = -normal.y;
}
2023-04-19 00:26:17 +00:00
normal.z = sqrt(max(0.0, 1.0 - dot(normal.xy, normal.xy)));
2019-06-16 02:45:24 +00:00
normal_used = true;
} else {
normal = vec3(0.0, 0.0, 1.0);
}
2019-07-05 01:54:32 +00:00
vec4 specular_shininess;
#if defined(SPECULAR_SHININESS_USED)
bool specular_shininess_used = true;
#else
bool specular_shininess_used = false;
2019-06-16 02:45:24 +00:00
#endif
2020-11-03 19:51:53 +00:00
if (specular_shininess_used || (using_light && normal_used && bool(draw_data.flags & FLAGS_DEFAULT_SPECULAR_MAP_USED))) {
2019-11-05 11:01:00 +00:00
specular_shininess = texture(sampler2D(specular_texture, texture_sampler), uv);
2019-07-05 01:54:32 +00:00
specular_shininess *= unpackUnorm4x8(draw_data.specular_shininess);
2019-11-05 11:01:00 +00:00
specular_shininess_used = true;
2019-07-05 01:54:32 +00:00
} else {
specular_shininess = vec4(1.0);
}
2019-06-16 02:45:24 +00:00
#if defined(SCREEN_UV_USED)
2019-07-27 13:23:24 +00:00
vec2 screen_uv = gl_FragCoord.xy * canvas_data.screen_pixel_size;
2019-07-21 14:31:30 +00:00
#else
vec2 screen_uv = vec2(0.0);
2019-06-16 02:45:24 +00:00
#endif
2019-11-05 11:01:00 +00:00
vec3 light_vertex = vec3(vertex, 0.0);
2019-07-21 14:31:30 +00:00
vec2 shadow_vertex = vertex;
2019-06-16 02:45:24 +00:00
{
2021-01-04 13:08:01 +00:00
float normal_map_depth = 1.0;
2019-06-16 02:45:24 +00:00
2020-12-23 09:34:26 +00:00
#if defined(NORMAL_MAP_USED)
2019-06-16 02:45:24 +00:00
vec3 normal_map = vec3(0.0, 0.0, 1.0);
normal_used = true;
#endif
2021-04-13 20:01:43 +00:00
#CODE : FRAGMENT
2019-06-16 02:45:24 +00:00
2020-12-23 09:34:26 +00:00
#if defined(NORMAL_MAP_USED)
2021-01-04 13:08:01 +00:00
normal = mix(vec3(0.0, 0.0, 1.0), normal_map * vec3(2.0, -2.0, 1.0) - vec3(1.0, -1.0, 0.0), normal_map_depth);
2019-06-16 02:45:24 +00:00
#endif
}
2019-07-05 01:54:32 +00:00
if (normal_used) {
//convert by item transform
normal.xy = mat2(normalize(draw_data.world_x), normalize(draw_data.world_y)) * normal.xy;
//convert by canvas transform
2019-11-05 11:01:00 +00:00
normal = normalize((canvas_data.canvas_normal_transform * vec4(normal, 0.0)).xyz);
2019-07-05 01:54:32 +00:00
}
2019-06-16 02:45:24 +00:00
2022-10-13 00:55:01 +00:00
vec4 base_color = color;
2019-11-05 11:01:00 +00:00
if (bool(draw_data.flags & FLAGS_USING_LIGHT_MASK)) {
2020-03-11 17:59:18 +00:00
color = vec4(0.0); //invisible by default due to using light mask
2019-06-16 02:45:24 +00:00
}
2019-07-05 01:54:32 +00:00
2020-11-26 12:50:21 +00:00
#ifdef MODE_LIGHT_ONLY
color = vec4(0.0);
2022-09-25 11:13:46 +00:00
#elif !defined(MODE_UNSHADED)
2019-11-05 11:01:00 +00:00
color *= canvas_data.canvas_modulation;
2020-11-26 12:50:21 +00:00
#endif
#if defined(USE_LIGHTING) && !defined(MODE_UNSHADED)
2020-11-03 19:51:53 +00:00
// Directional Lights
for (uint i = 0; i < canvas_data.directional_light_count; i++) {
uint light_base = i;
vec2 direction = light_array.data[light_base].position;
vec4 light_color = light_array.data[light_base].color;
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2020-11-03 19:51:53 +00:00
vec4 shadow_modulate = vec4(1.0);
2022-10-13 00:55:01 +00:00
light_color = light_compute(light_vertex, vec3(direction, light_array.data[light_base].height), normal, light_color, light_color.a, specular_shininess, shadow_modulate, screen_uv, uv, base_color, true);
2020-11-03 19:51:53 +00:00
#else
if (normal_used) {
vec3 light_vec = normalize(mix(vec3(direction, 0.0), vec3(0, 0, 1), light_array.data[light_base].height));
2022-10-13 00:55:01 +00:00
light_color.rgb = light_normal_compute(light_vec, normal, base_color.rgb, light_color.rgb, specular_shininess, specular_shininess_used);
} else {
light_color.rgb *= base_color.rgb;
2020-11-03 19:51:53 +00:00
}
#endif
if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW)) {
vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
vec4 shadow_uv = vec4(shadow_pos.x, light_array.data[light_base].shadow_y_ofs, shadow_pos.y * light_array.data[light_base].shadow_zfar_inv, 1.0);
light_color = light_shadow_compute(light_base, light_color, shadow_uv
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2020-11-03 19:51:53 +00:00
,
2021-01-09 19:45:03 +00:00
shadow_modulate.rgb
2020-11-03 19:51:53 +00:00
#endif
);
}
light_blend_compute(light_base, light_color, color.rgb);
}
// Positional Lights
2020-10-24 15:15:43 +00:00
for (uint i = 0; i < MAX_LIGHTS_PER_ITEM; i++) {
2019-11-05 11:01:00 +00:00
if (i >= light_count) {
2019-07-10 20:44:55 +00:00
break;
}
2022-10-05 08:56:19 +00:00
uint light_base = draw_data.lights[i >> 2];
2019-11-05 11:01:00 +00:00
light_base >>= (i & 3) * 8;
light_base &= 0xFF;
2019-07-05 01:54:32 +00:00
2019-11-14 23:32:54 +00:00
vec2 tex_uv = (vec4(vertex, 0.0, 1.0) * mat4(light_array.data[light_base].texture_matrix[0], light_array.data[light_base].texture_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
2020-10-24 15:15:43 +00:00
vec2 tex_uv_atlas = tex_uv * light_array.data[light_base].atlas_rect.zw + light_array.data[light_base].atlas_rect.xy;
vec4 light_color = textureLod(sampler2D(atlas_texture, texture_sampler), tex_uv_atlas, 0.0);
2019-07-05 01:54:32 +00:00
vec4 light_base_color = light_array.data[light_base].color;
2019-07-21 14:31:30 +00:00
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2019-07-21 14:31:30 +00:00
vec4 shadow_modulate = vec4(1.0);
2019-11-05 11:01:00 +00:00
vec3 light_position = vec3(light_array.data[light_base].position, light_array.data[light_base].height);
2019-07-21 14:31:30 +00:00
2019-11-05 11:01:00 +00:00
light_color.rgb *= light_base_color.rgb;
2022-10-13 00:55:01 +00:00
light_color = light_compute(light_vertex, light_position, normal, light_color, light_base_color.a, specular_shininess, shadow_modulate, screen_uv, uv, base_color, false);
2019-07-21 14:31:30 +00:00
#else
2019-11-05 11:01:00 +00:00
light_color.rgb *= light_base_color.rgb * light_base_color.a;
2019-07-05 01:54:32 +00:00
if (normal_used) {
2019-11-05 11:01:00 +00:00
vec3 light_pos = vec3(light_array.data[light_base].position, light_array.data[light_base].height);
2019-07-21 14:31:30 +00:00
vec3 pos = light_vertex;
2019-11-05 11:01:00 +00:00
vec3 light_vec = normalize(light_pos - pos);
2019-07-05 01:54:32 +00:00
2022-10-13 00:55:01 +00:00
light_color.rgb = light_normal_compute(light_vec, normal, base_color.rgb, light_color.rgb, specular_shininess, specular_shininess_used);
} else {
light_color.rgb *= base_color.rgb;
2019-07-05 01:54:32 +00:00
}
2019-07-21 14:31:30 +00:00
#endif
2019-07-05 01:54:32 +00:00
if (any(lessThan(tex_uv, vec2(0.0, 0.0))) || any(greaterThanEqual(tex_uv, vec2(1.0, 1.0)))) {
//if outside the light texture, light color is zero
light_color.a = 0.0;
}
2019-11-05 11:01:00 +00:00
if (bool(light_array.data[light_base].flags & LIGHT_FLAGS_HAS_SHADOW)) {
vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.
2019-07-07 04:49:40 +00:00
vec2 pos_norm = normalize(shadow_pos);
vec2 pos_abs = abs(pos_norm);
2019-11-05 11:01:00 +00:00
vec2 pos_box = pos_norm / max(pos_abs.x, pos_abs.y);
vec2 pos_rot = pos_norm * mat2(vec2(0.7071067811865476, -0.7071067811865476), vec2(0.7071067811865476, 0.7071067811865476)); //is there a faster way to 45 degrees rot?
2019-07-07 04:49:40 +00:00
float tex_ofs;
float distance;
2019-11-05 11:01:00 +00:00
if (pos_rot.y > 0) {
if (pos_rot.x > 0) {
tex_ofs = pos_box.y * 0.125 + 0.125;
distance = shadow_pos.x;
2019-07-07 04:49:40 +00:00
} else {
2019-11-05 11:01:00 +00:00
tex_ofs = pos_box.x * -0.125 + (0.25 + 0.125);
distance = shadow_pos.y;
2019-07-07 04:49:40 +00:00
}
} else {
2019-11-05 11:01:00 +00:00
if (pos_rot.x < 0) {
tex_ofs = pos_box.y * -0.125 + (0.5 + 0.125);
distance = -shadow_pos.x;
2019-07-07 04:49:40 +00:00
} else {
2019-11-05 11:01:00 +00:00
tex_ofs = pos_box.x * 0.125 + (0.75 + 0.125);
distance = -shadow_pos.y;
2019-07-07 04:49:40 +00:00
}
}
2020-10-24 15:15:43 +00:00
distance *= light_array.data[light_base].shadow_zfar_inv;
2019-07-07 04:49:40 +00:00
//float distance = length(shadow_pos);
2020-10-24 15:15:43 +00:00
vec4 shadow_uv = vec4(tex_ofs, light_array.data[light_base].shadow_y_ofs, distance, 1.0);
2019-07-08 12:53:40 +00:00
2020-11-03 19:51:53 +00:00
light_color = light_shadow_compute(light_base, light_color, shadow_uv
2021-04-13 20:01:43 +00:00
#ifdef LIGHT_CODE_USED
2020-11-03 19:51:53 +00:00
,
2021-01-09 19:45:03 +00:00
shadow_modulate.rgb
2019-07-21 14:31:30 +00:00
#endif
2020-11-03 19:51:53 +00:00
);
2019-07-07 04:49:40 +00:00
}
2020-11-03 19:51:53 +00:00
light_blend_compute(light_base, light_color, color.rgb);
2019-07-05 01:54:32 +00:00
}
2019-07-10 20:44:55 +00:00
#endif
2019-07-05 01:54:32 +00:00
2019-06-16 02:45:24 +00:00
frag_color = color;
}