Added VFEZ

VFEZ/Shaders/Effects/vfez_alpha_clip.gdshaderinc

@@ -0,0 +1,25 @@
+group_uniforms alpha_clip;
+uniform float alpha_clip_left: hint_range(0.0, 1.0) = 0;
+uniform float alpha_clip_right: hint_range(0.0, 1.0) = 0;
+uniform float alpha_clip_up: hint_range(0.0, 1.0) = 0;
+uniform float alpha_clip_down: hint_range(0.0, 1.0) = 0;
+group_uniforms;
+
+float alpha_clip(float alpha, vec2 uv, vec2 main_texture_scale)
+{
+	vec2 norm_uv = uv / main_texture_scale;
+	
+	if (1. - alpha_clip_up - norm_uv.y < 0.)
+		return 0.;
+		
+	if (norm_uv.y - alpha_clip_down < 0.)
+		return 0.;
+	
+	if (1. - alpha_clip_right - norm_uv.x < 0.)
+		return 0.;
+	
+	if (norm_uv.x - alpha_clip_left < 0.)
+		return 0.;
+		
+	return alpha;
+}

VFEZ/Shaders/Effects/vfez_alpha_cutoff.gdshaderinc

@@ -0,0 +1,15 @@
+group_uniforms alpha_cutoff;
+uniform float alpha_cuttof_value: hint_range(0.001, 1.) = 0.5;
+group_uniforms;
+
+float alpha_cutoff(float alpha)
+{
+	if (((1. - alpha_cuttof_value) - (1. - alpha) - 0.01) < 0.)
+	{
+		return 0.;
+	}
+	else
+	{
+		return alpha;
+	}
+}

VFEZ/Shaders/Effects/vfez_alpha_disolve.gdshaderinc

@@ -0,0 +1,67 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms alpha_disolve;
+uniform sampler2D alpha_disolve_texture: source_color;
+uniform vec2 alpha_disolve_texture_scale = vec2(1.);
+uniform vec2 alpha_disolve_texture_offset = vec2(0.);
+uniform float alpha_disolve_amount: hint_range(-0.1, 1) = -0.1;
+uniform float alpha_disolve_transition: hint_range(0.01, 0.75)= 0.075;
+uniform float alpha_disolve_power: hint_range(0.001, 10) = 1;
+uniform vec2 alpha_disolve_scroll_speed;
+group_uniforms;
+
+// disolve burn
+group_uniforms alpha_disolve.disolve_burn;
+uniform bool use_alpha_disolve_burn = false;
+uniform sampler2D alpha_disolve_burn_texture: source_color;
+uniform vec3 alpha_disolve_burn_color: source_color = vec3(1., 1., 0.);
+uniform float alpha_disolve_burn_width: hint_range(0.0, 0.2) = 0.01;
+uniform float alpha_disolve_burn_glow: hint_range(1, 250) = 5;
+group_uniforms;
+
+vec4 alpha_disolve(
+	vec4 color,
+	float pre_disolve_alpha,
+	float base_a,
+	vec2 uv,
+	bool fract_uv)
+{
+	vec2 disolve_uv = transform_uv(uv, alpha_disolve_texture_scale, alpha_disolve_texture_offset, fract_uv);
+
+	float disolve_amount = clamp(alpha_disolve_amount + (1. - base_a), 0., 1.);
+	float disolve_transition = max(0.01, alpha_disolve_transition * ease_out_quint(disolve_amount));
+	disolve_uv += mod(TIME * alpha_disolve_scroll_speed, 1.0);
+	disolve_amount = clamp(pow(disolve_amount, alpha_disolve_power), 0., 1.);
+	float disolve_sample = texture(alpha_disolve_texture, disolve_uv).r;
+	float disolve = clamp(
+		smoothstep(
+				0.0,
+				disolve_transition,
+				remap_float(1.0 - disolve_amount, 0.0, 1.0, -1.0, 1.0) + disolve_sample
+		), 0., 1.);
+
+	color.a *= disolve;
+
+	if (use_alpha_disolve_burn)
+	{
+		float disolve_burn = clamp(
+				smoothstep(
+					0.,
+					disolve_transition + alpha_disolve_burn_width,
+					remap_float(1.0 - disolve_amount, 0.0, 1.0, -1.0, 1.0) + disolve_sample
+				), 0., 1.
+			);
+
+		disolve_burn = disolve - disolve_burn;
+		vec3 disolve_burn_color = alpha_disolve_burn_color.rgb * alpha_disolve_burn_glow;
+
+		color.rgb += disolve_burn *
+				texture(alpha_disolve_burn_texture, disolve_uv).rgb
+				* disolve_burn_color.rgb
+				* pre_disolve_alpha;
+	}
+	return color;
+}

VFEZ/Shaders/Effects/vfez_alpha_flicker.gdshaderinc

@@ -0,0 +1,13 @@
+group_uniforms alpha_flicker;
+uniform float alpha_flicker_percent: hint_range(0., 1.) = 0.05;
+uniform float alpha_flicker_frequency: hint_range(0., 5.) = 0.2;
+uniform float alpha_flicker_value: hint_range(0.0, 1.0) = 0.;
+group_uniforms;
+
+float alpha_flicker(float alpha)
+{
+	alpha *= clamp(
+		alpha * step(fract(0.05 + TIME * alpha_flicker_frequency),
+		1. - alpha_flicker_percent) + alpha_flicker_value, 0., 1.);
+	return alpha;
+}

VFEZ/Shaders/Effects/vfez_alpha_mask.gdshaderinc

@@ -0,0 +1,23 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms alpha_mask;
+uniform sampler2D alpha_mask_texture: source_color;
+uniform vec2 alpha_mask_scale = vec2(1.);
+uniform vec2 alpha_mask_offset = vec2(0.);
+uniform float alpha_mask_power: hint_range(0.001, 10.) = 1;
+group_uniforms;
+
+float alpha_mask(
+	float alpha,
+	vec2 uv,
+	bool fract_uv)
+{
+	vec2 alpha_mask_uv = transform_uv(uv, alpha_mask_scale, alpha_mask_offset, fract_uv);
+	vec4 alpha_mask_sample = texture(alpha_mask_texture, alpha_mask_uv);
+	float mask = pow(min(alpha_mask_sample.r, alpha_mask_sample.a), alpha_mask_power);
+	alpha *= mask;
+	return alpha;
+}

VFEZ/Shaders/Effects/vfez_alpha_radial_clip.gdshaderinc

@@ -0,0 +1,28 @@
+group_uniforms alpha_radial_clip;
+uniform float alpha_radial_clip_start_angle: hint_range(0.0, 360., 1.);
+uniform float alpha_radial_clip_one: hint_range(0.0, 360., 1.);
+uniform float alpha_radial_clip_two: hint_range(0.0, 360., 1.);
+group_uniforms;
+
+float alpha_radial_clip(float alpha, vec2 uv, vec2 main_texture_scale)
+{
+	vec2 norm_uv = uv / main_texture_scale;
+	float start_angle = alpha_radial_clip_start_angle - alpha_radial_clip_one;
+    float end_angle = alpha_radial_clip_start_angle + alpha_radial_clip_two;
+    float offset_0 = clamp(0., 360., start_angle + 360.);
+    float offset_360 = clamp(0., 360., end_angle - 360.);
+    vec2 atan2Coord = vec2(mix(-1., 1., norm_uv.x), mix(-1., 1., norm_uv.y));
+    float a_tan_angle = atan(atan2Coord.y, atan2Coord.x) * 57.3;
+	if (a_tan_angle < 0.) 
+		a_tan_angle = 360. + a_tan_angle;
+	
+	if (a_tan_angle >= start_angle && a_tan_angle <= end_angle)
+		return 0.;
+	
+	if (a_tan_angle <= offset_360)
+		return 0.;		
+	
+	if (a_tan_angle >= offset_0)
+		return 0.;
+	return alpha;
+}

VFEZ/Shaders/Effects/vfez_alpha_remap.gdshaderinc

@@ -0,0 +1,10 @@
+group_uniforms alpha_remap;
+uniform float alpha_remap_min: hint_range(0.0, 1.0) = 0;
+uniform float alpha_remap_max: hint_range(0.0, 1.0) = 0.075;
+group_uniforms;
+
+float alpha_remap(float alpha)
+{
+	alpha = smoothstep(alpha_remap_min, alpha_remap_max, alpha);
+	return alpha;
+}

VFEZ/Shaders/Effects/vfez_chromatic_aberration.gdshaderinc

@@ -0,0 +1,18 @@
+group_uniforms chromatic_aberration;
+uniform float chromatic_aberration_amount: hint_range(0.0, 1.0) = 1.;
+uniform float chromatic_aberration_alpha: hint_range(0.0, 1.0) = 0.4;
+group_uniforms;
+
+vec4 chromatic_aberration(vec4 color, vec2 uv, sampler2D main_texture)
+{
+	vec4 r = texture(main_texture, 
+		uv + vec2(chromatic_aberration_amount / 10., 0.));
+
+	vec4 b = texture(main_texture, 
+		uv + vec2(-chromatic_aberration_amount / 10., 0.));
+	
+	color = vec4(r.r * r.a, color.g, b.b * b.a, 
+		max(max(r.a, b.a) * chromatic_aberration_alpha, color.a));
+	
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_change.gdshaderinc

@@ -0,0 +1,71 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+
+group_uniforms color_change.color1;
+uniform bool change_color_1;
+uniform vec3 color_1_to_change: source_color;
+uniform vec3 color_1_to_replace: source_color;
+uniform float color_1_change_tolerance: hint_range(0.0, 1.0) = 0.1;
+group_uniforms;
+
+group_uniforms color_change.color2;
+uniform bool change_color_2;
+uniform vec3 color_2_to_change: source_color;
+uniform vec3 color_2_to_replace: source_color;
+uniform float color_2_change_tolerance: hint_range(0.0, 1.0) = 0.1;
+group_uniforms;
+
+group_uniforms color_change.color3;
+uniform bool change_color_3;
+uniform vec3 color_3_to_change: source_color;
+uniform vec3 color_3_to_replace: source_color;
+uniform float color_3_change_tolerance: hint_range(0.0, 1.0) = 0.1;
+group_uniforms;
+
+vec3 change_single_color(
+	vec3 color,
+	vec3 color_to_change,
+	vec3 color_to_replace,
+	float color_change_tolerance)
+{
+	vec3 dif = abs(color - color_to_change.rgb);
+	color.rgb = mix(color, color_to_replace.rgb,
+		max(sign(color_change_tolerance * 3. - dif.x - dif.y - dif.z), 0.0));
+	return color;
+}
+
+vec3 color_change(vec3 color)
+{
+	color = clamp(color, 0., 1.);
+	
+	if (change_color_1)
+	{
+		color = change_single_color(
+			color,
+			color_1_to_change,
+			color_1_to_replace,
+			color_1_change_tolerance);
+	}
+
+	if (change_color_2)
+	{
+		color = change_single_color(
+			color,
+			color_2_to_change,
+			color_2_to_replace,
+			color_2_change_tolerance);
+	}
+
+	if (change_color_3)
+	{
+		color = change_single_color(
+			color,
+			color_3_to_change,
+			color_3_to_replace,
+			color_3_change_tolerance);
+	}
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_face_tint.gdshaderinc

@@ -0,0 +1,16 @@
+group_uniforms color_face_tint;
+uniform vec3 backface_tint_color: source_color = vec3(0.5);
+uniform vec3 frontface_tint_color: source_color = vec3(1.);
+group_uniforms;
+
+vec3 color_face_tint(
+	vec3 color, 
+	vec3 world_normal,
+	vec3 view_direction)
+{
+	color.rgb = mix(
+		color.rgb * backface_tint_color,
+		color.rgb * frontface_tint_color,
+		step(0, dot(world_normal, view_direction)));
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_ghost.gdshaderinc

@@ -0,0 +1,20 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_ghost;
+uniform float color_ghost_boost: hint_range(0.0, 5.) = 1.;
+uniform float color_ghost_transparency: hint_range(0.0, 1.0) = 0.;
+uniform float color_ghost_blend: hint_range(0.0, 1.0) = 1.;
+group_uniforms;
+
+vec4 color_ghost(vec4 color)
+{
+	float luminance = get_color_luminance(color);
+	vec4 ghost;
+	ghost.a = clamp(luminance - color_ghost_transparency, 0., 1.) * color.a;
+	ghost.rgb = color.rgb * (luminance + color_ghost_boost);
+	color = mix(color, ghost, color_ghost_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_glow.gdshaderinc

@@ -0,0 +1,23 @@
+group_uniforms color_glow;
+uniform vec4 glow_color: source_color = vec4(1.);
+uniform float glow_intensity = 0;
+uniform float glow_intensity_global = 1;
+uniform bool use_glow_texture = false;
+uniform sampler2D glow_texture: source_color;
+group_uniforms;
+
+vec3 color_glow(
+	vec4 color,
+	vec2 uv,
+	float glow_mult)
+{
+	float glow_mask = 1.;
+	if (use_glow_texture)
+	{
+		glow_mask = texture(glow_texture, uv).r;
+	}
+
+	color.rgb *= glow_intensity_global * glow_mask;
+	color.rgb += glow_color.rgb * glow_intensity * glow_mask * color.a * glow_mult;
+	return color.rgb;
+}

VFEZ/Shaders/Effects/vfez_color_gradient.gdshaderinc

@@ -0,0 +1,32 @@
+group_uniforms color_gradient;
+uniform float color_gradient_blend: hint_range(0., 1.) = 0.5;
+uniform float color_gradient_boost_x: hint_range(0., 1.) = 0.5;
+uniform float color_gradient_boost_y: hint_range(0., 1.) = 0.5;
+uniform vec4 color_gradient_top_right_color: source_color = vec4(1,0,0,1);
+uniform vec4 color_gradient_bottom_right_color: source_color = vec4(0,1,0,1);
+uniform vec4 color_gradient_top_left_color: source_color = vec4(0,0,1,1);
+uniform vec4 color_gradient_bottom_left_color: source_color = vec4(1,1,0,1);
+group_uniforms;
+
+vec4 color_gradient(vec4 color, vec2 uv, vec2 main_texture_scale)
+{
+	vec2 norm_uv = uv / main_texture_scale;
+	float grad_x_mix_factor = clamp(pow(norm_uv.x, color_gradient_boost_x), 0., 1.);
+	float grad_y_mix_factor = clamp(pow(norm_uv.y, color_gradient_boost_y), 0., 1.);
+	vec4 grad_result = mix(
+		mix(
+			color_gradient_bottom_left_color,
+			color_gradient_bottom_right_color,
+			grad_x_mix_factor),
+		mix(
+			color_gradient_top_left_color,
+			color_gradient_top_right_color,
+			grad_x_mix_factor),
+			grad_y_mix_factor
+			);
+
+	grad_result = mix(color, grad_result, color_gradient_blend);
+	color.rgb = grad_result.rgb * color.a;
+	color.a *= grad_result.a;
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_greyscale.gdshaderinc

@@ -0,0 +1,18 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_greyscale;
+uniform float color_greyscale_luminosity: hint_range(-1., 1.) = 0;
+uniform float color_greyscale_blend: hint_range(0., 1.) = 1.;
+uniform vec3 color_greyscale_tint: source_color = vec3(1.);
+group_uniforms;
+
+vec3 color_greyscale(vec3 color)
+{
+	float luminance = get_color_luminance(vec4(color, 1.));
+	luminance = clamp(luminance + color_greyscale_luminosity, 0., 1.);
+	color = mix(color, vec3(luminance) * color_greyscale_tint, color_greyscale_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_hologram.gdshaderinc

@@ -0,0 +1,34 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_hologram;
+uniform vec3 color_hologram_stripes_color: source_color = vec3(0,1,1);
+uniform float color_hologram_stripes_amount: hint_range(0.0, 1.0) = 0.1;
+uniform float color_hologram_unchanged_amount: hint_range(0.0, 1.0) = 0.0;
+uniform float color_hologram_stripes_speed: hint_range(-20., 20.) = 4.5;
+uniform float color_hologram_min_alpha: hint_range(0.0, 1.0) = 0.1;
+uniform float color_hologram_max_alpha: hint_range(0.0, 1.0) = 0.75;
+uniform float color_hologram_blend: hint_range(0.0, 1.0) = 1.;
+group_uniforms;
+
+vec4 color_hologram(vec4 color, vec2 uv)
+{
+	float total_hologram = color_hologram_stripes_amount +
+						color_hologram_unchanged_amount;
+
+	float hologram_y_coord = mod(uv.y + mod(TIME, 1.) * color_hologram_stripes_speed, total_hologram) / total_hologram;
+	hologram_y_coord = abs(hologram_y_coord);
+	float alpha = remap_float(
+		clamp(hologram_y_coord - color_hologram_unchanged_amount / total_hologram, 0., 1.),
+		0., 1., color_hologram_min_alpha, color_hologram_max_alpha);
+	float hologram_mask = max(sign(color_hologram_unchanged_amount / total_hologram - hologram_y_coord), 0.0);
+	vec4 hologram_result = color;
+	hologram_result.a *= mix(alpha, 1., hologram_mask);
+	hologram_result.rgb *= max(1., color_hologram_max_alpha * max (sign (hologram_y_coord - color_hologram_unchanged_amount / total_hologram), 0.0));
+	hologram_mask = 1. - step(0.01, hologram_mask);
+	hologram_result.rgb += hologram_mask * color_hologram_stripes_color.rgb * color.a;
+	color = mix(color, hologram_result, color_hologram_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_negative.gdshaderinc

@@ -0,0 +1,9 @@
+group_uniforms color_negative;
+uniform float color_negative_blend: hint_range(0.0, 1.0) = 1.0;
+group_uniforms;
+
+vec3 color_negative(vec3 color)
+{
+	color = mix(color, 1. - color, color_negative_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_overlay_texture.gdshaderinc

@@ -0,0 +1,40 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_overlay_texture;
+uniform sampler2D color_overlay_tex: source_color;
+uniform vec2 color_overlay_tex_scale = vec2(1.);
+uniform vec2 color_overlay_tex_offset = vec2(0.);
+uniform vec4 color_overlay_color: source_color = vec4(1.);
+uniform float color_overlay_glow: hint_range(0.0, 25) = 1.;
+uniform float color_overlay_blend: hint_range(0.0, 1.0) = 1.;
+uniform float color_overlay_tex_scroll_x: hint_range(-5, 5) = 0.25;
+uniform float color_overlay_tex_scroll_y: hint_range(-5, 5) = 0.25;
+uniform bool color_overlay_mult;
+group_uniforms;
+
+vec4 color_overlay_texture(vec4 color, vec2 uv)
+{
+	vec2 overlay_uv = uv;
+	overlay_uv.x += TIME * color_overlay_tex_scroll_x;
+	overlay_uv.y += TIME * color_overlay_tex_scroll_y;
+	overlay_uv = fract(overlay_uv);
+	overlay_uv = transform_uv(overlay_uv, color_overlay_tex_scale, color_overlay_tex_offset, true);
+	vec4 final_overlay_color = texture(color_overlay_tex, overlay_uv);
+	final_overlay_color.rgb *= color_overlay_color.rgb * color_overlay_glow;
+
+	if (color_overlay_mult)
+	{
+		final_overlay_color.a *= color_overlay_color.a;
+		color = mix(color, color * final_overlay_color, color_overlay_blend);
+	}
+	else
+	{
+		final_overlay_color.rgb *= final_overlay_color.a * color_overlay_color.rgb * color_overlay_color.a * color_overlay_blend;
+		color.rgb += final_overlay_color.rgb;
+	}
+
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_posterize.gdshaderinc

@@ -0,0 +1,9 @@
+group_uniforms color_posterize;
+uniform float color_posterize_num_colors: hint_range(0.0, 30.) = 5.;
+group_uniforms;
+
+vec3 color_posterize(vec3 color)
+{
+	color = floor(color.rgb / (1.0 / color_posterize_num_colors)) * (1.0 / color_posterize_num_colors);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_radial_gradient.gdshaderinc

@@ -0,0 +1,24 @@
+group_uniforms color_radial_gradient;
+uniform vec2 color_radial_gradient_center = vec2(0.5);
+uniform float color_radial_gradient_blend: hint_range(0., 1.) = 0.5;
+uniform float color_radial_gradient_boost: hint_range(0., 1.) = 0.5;
+uniform vec4 color_radial_gradient_color_one: source_color = vec4(1,0,0,1);
+uniform vec4 color_radial_gradient_color_two: source_color = vec4(0,1,0,1);
+group_uniforms;
+
+vec4 color_radial_gradient(vec4 color, vec2 uv, vec2 main_texture_scale, vec2 viewport_size)
+{
+	vec2 norm_uv = uv / main_texture_scale;
+	float radial_dist = 1. - length(norm_uv - color_radial_gradient_center);
+	radial_dist*= viewport_size.x / viewport_size.y;
+	radial_dist = clamp(color_radial_gradient_boost * radial_dist, 0., 1.);
+	vec4 grad_result = mix(
+		color_radial_gradient_color_one, 
+		color_radial_gradient_color_two, 
+		radial_dist);
+	
+	grad_result = mix(color, grad_result, color_radial_gradient_blend);
+	color.rgb = grad_result.rgb * color.a;
+	color.a *= grad_result.a;
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_ramp.gdshaderinc

@@ -0,0 +1,21 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_ramp;
+uniform vec4 color_ramp_albedo: source_color = vec4(1.);
+uniform sampler2D color_ramp_texture: source_color, repeat_disable;
+uniform float color_ramp_luminosity: hint_range(-1., 1.) = 0.;
+uniform float color_ramp_blend: hint_range(0.0, 1.0) = 1.;
+group_uniforms;
+
+vec4 color_ramp(vec4 color)
+{
+	float luminance = get_color_luminance(color);
+	float color_ramp_luminance = clamp(luminance + color_ramp_luminosity, 0., 1.);
+	vec4 color_ramp_res = texture(color_ramp_texture, vec2(color_ramp_luminance)) * color_ramp_albedo;
+	color.rgb = mix(color.rgb, color_ramp_res.rgb, color_ramp_blend);
+	color.a = mix(color.a, clamp(color.a * color_ramp_res.a, 0., 1.), color_ramp_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_rim.gdshaderinc

@@ -0,0 +1,31 @@
+group_uniforms color_rim;
+uniform vec4 rim_color: source_color = vec4(1.);
+uniform float rim_bias: hint_range(0.0, 1.0) = 0.;
+uniform float rim_scale: hint_range(0.0, 25.0) = 1.;
+uniform float rim_power: hint_range(0.1, 20.0) = 5.;
+uniform float rim_intensity: hint_range(0.1, 50.0) = 1.;
+uniform float rim_add_amount: hint_range(0.1, 1.0) = 1.;
+uniform float rim_erodes_alpha: hint_range(0.1, 2.0) = 0.;
+group_uniforms;
+
+vec4 color_rim(
+	vec4 color, 
+	vec3 normal, 
+	vec3 view)
+{
+	float ndv = 1. - abs(dot(normal, view));
+   	float rim_factor = clamp(
+		rim_bias + rim_scale * pow(ndv, rim_power), 0., 1.);
+    vec4 final_rim_color = rim_color * rim_factor;
+    final_rim_color.rgb *= rim_intensity;
+   	color.rgb = mix(
+		color.rgb * (final_rim_color.rgb + vec3(1.)),
+		color.rgb + final_rim_color.rgb,
+		rim_add_amount);
+   	color.a = clamp(
+		color.a * (1. - rim_factor * rim_erodes_alpha),
+		0.,
+		1.);
+	
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_shadow.gdshaderinc

@@ -0,0 +1,17 @@
+group_uniforms color_shadow;
+uniform float color_shadow_x: hint_range(-0.5, 0.5) = 0.1;
+uniform float color_shadow_y: hint_range(-0.5, 0.5) = 0.1;
+uniform float color_shadow_alpha: hint_range(0., 1.) = 0.5;
+uniform vec3 color_shadow_color: source_color = vec3(0.);
+group_uniforms;
+
+vec4 shadow(vec4 color, sampler2D tex, vec2 uv)
+{
+	vec2 shadowOffset = vec2(color_shadow_x, color_shadow_y);
+	float shadowA = texture(tex, uv + shadowOffset).a;
+	color.rgb *= 1. - (shadowA - color.a) * (1. - color.a);
+	color.rgb += color_shadow_color * shadowA * (1. - color.a);
+	color = clamp(color, 0., 1.);
+	color.a = max(shadowA * color_shadow_alpha, color.a);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_shine.gdshaderinc

@@ -0,0 +1,48 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_shine;
+uniform vec4 color_shine_color: source_color = vec4(1.);
+uniform float color_shine_location: hint_range(0., 1.) = 0.5;
+uniform float color_shine_angle: hint_range(0.0, 6.2831) = 0.;
+uniform float color_shine_width: hint_range(0.0, 2.0) = 0.1;
+uniform float color_shine_glow: hint_range(0., 100., 1.) = 1.;
+uniform sampler2D color_shine_mask: source_color;
+uniform bool color_shine_mask_red_as_alpha;
+group_uniforms;
+
+vec4 color_shine(vec4 color, vec2 uv)
+{
+	if (color_shine_width == 0.)
+		return color;
+		
+	vec2 shine_uv = uv;
+	shine_uv = rotate_uvs(shine_uv, color_shine_angle, vec2(1.), vec2(0.));
+
+	float shine_mask;
+		
+	if (color_shine_mask_red_as_alpha)
+	{
+		shine_mask = texture(color_shine_mask, uv).r;	
+	}
+	else
+	{
+		shine_mask = texture(color_shine_mask, uv).a;	
+	}
+	
+	float current_distance_proj = (shine_uv.x + shine_uv.y) / 2.;
+	float white_power = 1. - 
+		abs(current_distance_proj - color_shine_location) / color_shine_width;
+
+	
+	vec4 shine_color = color + color.a * white_power * color_shine_glow
+		* max(sign(current_distance_proj - (color_shine_location - color_shine_width)), 0.)
+		* max(sign(color_shine_location + color_shine_width - current_distance_proj), 0.)
+		* color_shine_color * shine_mask;
+	
+	color.rgb = shine_color.rgb;
+	
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_single.gdshaderinc

@@ -0,0 +1,10 @@
+group_uniforms color_single;
+uniform vec3 color_single_color: source_color = vec3(1.);
+uniform float color_single_blend: hint_range(0.0, 1.0) = 1.0;
+group_uniforms;
+
+vec3 color_single(vec3 color)
+{
+	color = mix(color, color_single_color, color_single_blend);
+	return color;
+}

VFEZ/Shaders/Effects/vfez_color_toning.gdshaderinc

@@ -0,0 +1,36 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms color_toning;
+uniform vec3 color_grading_light_tone: source_color;
+uniform vec3 color_grading_mid_tone: source_color;
+uniform vec3 color_grading_dark_tone: source_color;
+uniform float color_grading_mid_point: hint_range(0.0, 1.0) = 0.5;
+group_uniforms;
+
+vec3 color_toning(vec4 color)
+{
+	float luminance = get_color_luminance(color);
+	
+	vec3 color_grading_dark_middle_mix = mix(
+		color_grading_dark_tone,
+		color_grading_mid_tone,
+		luminance / color_grading_mid_point
+	);
+
+	vec3 color_grading_middle_light_mix = mix(
+		color_grading_mid_tone,
+		color_grading_light_tone,
+		(luminance - color_grading_mid_point) / (1.0 - color_grading_mid_point)
+	);
+
+	color.rgb *= mix(
+		color_grading_dark_middle_mix,
+		color_grading_middle_light_mix,
+		step(color_grading_mid_point, luminance)
+	);
+	
+	return color.rgb;
+}

VFEZ/Shaders/Effects/vfez_glitch.gdshaderinc

@@ -0,0 +1,20 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms glitch;
+uniform float glitch_amount: hint_range(0.0, 20.) = 3.;
+uniform float glitch_size: hint_range(0.25, 5.) = 1.;
+group_uniforms;
+
+vec3 glitch(vec3 color, vec2 uv, sampler2D main_texture)
+{
+	vec2 glitch_uv = uv - 0.5;
+	float line_noise =
+		pow(rand(floor(glitch_uv * vec2(24., 19.) * glitch_size) * 4.0, TIME), 3.0) * glitch_amount
+		* pow(rand(floor(glitch_uv * vec2(38., 14.) * glitch_size) * 4.0, TIME), 3.0);
+
+	color = texture(main_texture, uv + vec2(line_noise * 0.02 * rand(vec2(2.0, 1.), TIME), 0)).rgb;
+	return color;
+}

VFEZ/Shaders/Effects/vfez_hsv_shift.gdshaderinc

@@ -0,0 +1,23 @@
+group_uniforms color_hsv_shift;
+uniform float h_shift: hint_range(0.0, 360.0) = 180;
+uniform float s_shift:  hint_range(0.0, 2.) = 1.;
+uniform float v_shift: hint_range(0.0, 2.) = 1.;
+group_uniforms;
+
+vec3 hsv_shift(vec3 color)
+{
+	vec3 result_hsv = vec3(color.rgb);
+	float cos_hsv = v_shift * s_shift * cos(h_shift * PI / 180.);
+	float sin_hsv = v_shift * s_shift * sin(h_shift * PI / 180.);
+	result_hsv.x = (.299 * v_shift + .701 * cos_hsv + .168 * sin_hsv) * color.x
+		+ (.587 * v_shift - .587 * cos_hsv + .330 * sin_hsv) * color.y
+		+ (.114 * v_shift - .114 * cos_hsv - .497 * sin_hsv) * color.z;
+	result_hsv.y = (.299 * v_shift - .299 * cos_hsv - .328 * sin_hsv) *color.x
+		+ (.587 * v_shift + .413 * cos_hsv + .035 * sin_hsv) * color.y
+		+ (.114 * v_shift - .114 * cos_hsv + .292 * sin_hsv) * color.z;
+	result_hsv.z = (.299 * v_shift - .3 * cos_hsv + 1.25 * sin_hsv) * color.x
+		+ (.587 * v_shift - .588 * cos_hsv - 1.05 * sin_hsv) * color.y
+		+ (.114 * v_shift + .886 * cos_hsv - .203 * sin_hsv) * color.z;
+	color.rgb = result_hsv;
+	return color.rgb;
+}

VFEZ/Shaders/Effects/vfez_motion_blur.gdshaderinc

@@ -0,0 +1,35 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms motion_blur;
+uniform float motion_blur_angle: hint_range(-1., 1.) = 0.1;
+uniform float motion_blur_dist: hint_range(-3., 3.) = 1.25;
+group_uniforms;
+
+vec3 motion_blur(vec3 color, vec2 uv, sampler2D main_texture)
+{
+	float angle = motion_blur_angle * PI;
+	float dist = motion_blur_dist * 0.005;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(-dist, -dist), angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(-dist, -dist) * 2., angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(-dist, -dist) * 3., angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(-dist, -dist) * 4., angle)).rgb;
+
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(dist, dist), angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(dist, dist) * 2., angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(dist, dist) * 3., angle)).rgb;
+	color.rgb += texture(main_texture,
+		uv + rotate_vec2(vec2(dist, dist) * 4., angle)).rgb;
+
+	color.rgb /= 9.;
+	return color;
+}

VFEZ/Shaders/Effects/vfez_outline.gdshaderinc

@@ -0,0 +1,101 @@
+#ifndef VFEZ_UTILS
+	#include "vfez_utils.gdshaderinc"
+	#define VFEZ_UTILS
+#endif
+
+group_uniforms outline;
+uniform vec3 outline_color: source_color;
+uniform float outline_alpha: hint_range(0.0, 1.0) = 1.0;
+uniform float outline_glow: hint_range(1., 100, 1.) = 1.0;
+uniform float outline_width;
+uniform bool only_render_outline;
+group_uniforms;
+
+group_uniforms outline.pixel_perfect;
+uniform bool use_pixel_perfect_outline;
+uniform int outline_pixel_width;
+group_uniforms;
+
+group_uniforms outline.texture;
+uniform bool use_outline_texture;
+uniform sampler2D outline_texture;
+uniform vec2 outline_texture_scale = vec2(1.);
+uniform vec2 outline_texture_offset = vec2(0.);
+uniform vec2 outline_texture_scroll_speed = vec2(0.);
+group_uniforms;
+
+group_uniforms outline.distortion;
+uniform bool use_outline_distortion;
+uniform sampler2D outline_distortion_texture;
+uniform vec2 outline_distortion_texture_scale = vec2(1.);
+uniform vec2 outline_distortion_texture_offset = vec2(0.);
+uniform vec2 outline_distortion_texture_scroll_speed = vec2(0.);
+uniform float outline_distortion_amount;
+group_uniforms;
+
+vec4 outline(vec4 color, vec2 texture_pixel_size, vec2 uv, sampler2D tex)
+{   
+    float base_tex_a = texture(tex, uv).a;;
+
+    vec2 destUV;
+    if (use_pixel_perfect_outline)
+    {
+        destUV = texture_pixel_size * float(outline_pixel_width);
+    }
+    else
+    {
+        destUV = texture_pixel_size * float(outline_width) * 200.;
+    }
+
+    if (use_outline_distortion)
+    {
+        vec2 outlineDistUV = transform_uv(
+            uv,
+            outline_distortion_texture_scale,
+            outline_distortion_texture_offset,
+            true);
+        
+        destUV = uv_distortion(destUV, outline_distortion_texture, outlineDistUV, 
+            outline_distortion_amount, outline_distortion_texture_scroll_speed, true);;
+
+    }
+
+    float left = texture(tex, uv + vec2(destUV.x, 0.)).a;
+    float right = texture(tex, uv - vec2(destUV.x, 0.)).a;
+    float bottom = texture(tex, uv + vec2(0., destUV.y)).a;
+    float top = texture(tex, uv - vec2(0., destUV.y)).a;
+    float result = left + right + bottom + top;
+
+    result = step(0.05, clamp(result, 0., 1.));
+
+    vec4 final_outline_color = vec4(outline_color, 1.0);
+
+    if (use_outline_texture)
+    {
+        vec2 outlineTexUV = transform_uv(
+            uv,
+            outline_texture_scale,
+            outline_texture_offset,
+            true);
+
+        outlineTexUV += mod(TIME * outline_texture_scroll_speed,vec2(1.));
+        outlineTexUV = fract(outlineTexUV);
+        final_outline_color *= texture(outline_texture, outlineTexUV);
+    }
+
+    result *= (1. - color.a) * outline_alpha;
+    vec4 outline = final_outline_color;
+    outline.rgb *= outline_glow;
+    outline.a = result;
+
+    if (only_render_outline)
+    {
+        color = outline;
+    }
+    else
+    {
+        color = mix(color, outline, result);
+    }
+	
+	return color;
+}

VFEZ/Shaders/Effects/vfez_outline_inner.gdshaderinc

@@ -0,0 +1,40 @@
+group_uniforms outline_inner;
+uniform bool only_render_inner_outline;
+uniform vec3 outline_inner_color: source_color;
+uniform float outline_inner_thickness: hint_range(0., 5.) = 1.;
+uniform float outline_inner_alpha: hint_range(0., 1.) = 1.;
+uniform float ouline_inner_glow: hint_range(1., 10.) = 1.;
+group_uniforms;
+
+vec3 get_pixel(float offsetX, float offsetY, vec2 uv, sampler2D tex, vec2 texture_pixel_size)
+{
+	return texture(tex, (uv + vec2(offsetX * texture_pixel_size.x, offsetY * texture_pixel_size.y))).rgb;
+}
+
+
+vec4 outline_inner(vec4 color, vec2 texture_pixel_size, vec2 uv, sampler2D tex)
+{
+	vec3 innerT = abs(
+			get_pixel(0., outline_inner_thickness, uv, tex, texture_pixel_size) - 
+			get_pixel(0., - outline_inner_thickness, uv, tex, texture_pixel_size)
+	);
+	
+	innerT += abs(
+		get_pixel(outline_inner_thickness, 0., uv, tex, texture_pixel_size) - 
+		get_pixel(-outline_inner_thickness, 0., uv, tex, texture_pixel_size)
+	);
+	
+	if (only_render_inner_outline)
+	{
+		innerT *= color.a * outline_inner_alpha;
+		color.rgb = length(innerT) * outline_inner_color * ouline_inner_glow;
+		color.a = step(0.3, color.r + color.g + color.b);
+	}
+	else
+	{
+		innerT = innerT / 2.0 * color.a * outline_inner_alpha;
+		color.rgb += length(innerT) * outline_inner_color * ouline_inner_glow;
+	}
+	
+	return color;
+}	

VFEZ/Shaders/Effects/vfez_particle_anim.gdshaderinc

@@ -0,0 +1,21 @@
+group_uniforms particle.particle_anim;
+uniform int particles_anim_h_frames : hint_range(1, 128) = 1;
+uniform int particles_anim_v_frames : hint_range(1, 128) = 1;
+uniform bool particles_anim_loop;
+group_uniforms;
+
+vec2 particle_anim(float instance_custom_z, vec2 uv)
+{
+    float h_frames = float(particles_anim_h_frames);
+    float v_frames = float(particles_anim_v_frames);
+    float particle_total_frames = float(particles_anim_h_frames * particles_anim_v_frames);
+    float particle_frame = floor(instance_custom_z * float(particle_total_frames));
+    if (!particles_anim_loop) {
+        particle_frame = clamp(particle_frame, 0.0, particle_total_frames - 1.0);
+    } else {
+        particle_frame = mod(particle_frame, particle_total_frames);
+    }
+    uv /= vec2(h_frames, v_frames);
+    uv += vec2(mod(particle_frame, h_frames) / h_frames, floor((particle_frame + 0.5) / h_frames) / v_frames);
+    return uv;
+}

VFEZ/Shaders/Effects/vfez_utils.gdshaderinc

@@ -0,0 +1,96 @@
+// helper functions ------------------------------------------
+vec2 transform_uv(vec2 uv, vec2 scale, vec2 offset, bool fract_result)
+{
+	uv = uv * scale + offset;
+	if (fract_result)
+		uv = fract(uv);
+	return uv;
+}
+
+vec2 uv_distortion(
+	vec2 uv,
+	sampler2D distortion_texture,
+	vec2 distortion_uv,
+	float distortion_amount,
+	vec2 distortion_speed,
+	bool fract_result)
+{
+	distortion_uv += mod(TIME * distortion_speed, vec2(1.));
+	if (fract_result)
+	{
+		distortion_uv = fract(distortion_uv);
+	}
+
+	float distortAmount =
+		(texture(distortion_texture, distortion_uv).r - 0.5) * 0.2 * distortion_amount;
+	uv += vec2(1.) * distortAmount;
+	return uv;
+}
+
+vec2 uv_polar(vec2 uv, vec2 center)
+{
+	vec2 dir = uv - center;
+	float radius = length(dir) * 2.;
+	float angle = atan(dir.y, dir.x) / (2. * PI);
+	vec2 polarUV = vec2(angle, radius);
+	//baseUV = mod(vec2(radius, angle), 1.0);
+	return polarUV;
+}
+
+vec2 rotate_vec2(vec2 vector, float angle)
+{
+	float cosAngle = cos(angle);
+	float sinAngle = sin(angle);
+	vector = mat2(vec2(cosAngle, -sinAngle), vec2(sinAngle, cosAngle)) * vector;
+	return vector;
+}
+
+vec2 rotate_uvs(vec2 uv, float rotation, vec2 scale, vec2 offset)
+{
+	vec2 center = vec2(0.5 * scale.x + offset.x, 0.5 * scale.y + offset.y);
+	uv -= center;
+	uv = rotate_vec2(uv, rotation);
+	uv += center;
+	return uv;
+}
+
+vec4 sample_texture_with_scroll(sampler2D tex, vec2 uv, vec2 scroll_speed, float time)
+{
+	uv.x += mod(time * scroll_speed.x, 1);
+	uv.y += mod(time * scroll_speed.y, 1);
+	if (scroll_speed != vec2(0.))
+		uv = fract(uv);
+	return texture(tex, uv);
+}
+
+float rand(vec2 seed, float offset) {
+	return mod(fract(sin(dot(seed, vec2(12.9898, 78.233))) * 43758.5453) + offset, 1.0);
+}
+
+float rand_uncapped(vec2 seed, float offset) {
+	return fract(sin(dot(seed, vec2(12.9898, 78.233))) * 43758.5453) + offset;
+}
+
+float rand2(vec2 seed, float offset, float time) {
+	return mod(
+			fract(
+				sin(
+					dot(seed * floor(50. + mod(time, 1.0) * 12.), vec2(127.1, 311.7))
+				) * 43758.5453123
+			) + offset, 1.0);
+}
+
+float remap_float(float inValue, float inMin, float inMax, float outMin, float outMax){
+	return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
+}
+
+float ease_out_quint(float x) {
+	return 1. - pow(1. - x, 5.);
+}
+
+float get_color_luminance(vec4 color)
+{
+	float luminance = 0.3 * color.r + 0.59 * color.g + 0.11 * color.b;
+	luminance *= color.a;
+	return luminance;
+}

VFEZ/Shaders/Effects/vfez_uv_fisheye.gdshaderinc

@@ -0,0 +1,18 @@
+group_uniforms uv_fisheye;
+uniform float uv_fisheye_center_x: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_fisheye_center_y: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_fisheye_amount = 0.1;
+group_uniforms;
+
+vec2 uv_fisheye(vec2 uv, vec2 main_texture_scale)
+{
+	vec2 center = vec2(uv_fisheye_center_x * main_texture_scale.x,
+					uv_fisheye_center_y * main_texture_scale.y);
+
+	float bind = length(center);
+	vec2 dF = uv - center;
+	float dFlen = length(dF);
+	float fishInt = (PI / bind) * (uv_fisheye_amount + 0.001);
+	uv = center + (dF / max(0.0001, dFlen)) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_handrawn.gdshaderinc

@@ -0,0 +1,15 @@
+group_uniforms uv_handrawn;
+uniform float uv_handrawn_amount: hint_range(0.0, 40.0) = 10.;
+uniform float uv_handrawn_speed: hint_range(0.0, 30.0) = 5.;
+group_uniforms;
+
+vec2 uv_handrawn(vec2 uv)
+{
+	vec2 handrawnUV = uv;
+	float handrawn_speed =
+		floor(TIME * 20. * uv_handrawn_speed);
+	handrawnUV.x = sin((handrawnUV.x * uv_handrawn_amount + handrawn_speed / 2.) * 4.);
+	handrawnUV.y = sin((handrawnUV.y * uv_handrawn_amount + handrawn_speed / 2.) * 4.);
+	uv = mix(uv, uv + handrawnUV, 0.0005 * uv_handrawn_amount);
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_pinch.gdshaderinc

@@ -0,0 +1,16 @@
+group_uniforms uv_pinch;
+uniform float uv_pinch_center_x: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_pinch_center_y: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_pinch_amount;
+group_uniforms;
+
+vec2 uv_pinch(vec2 uv, vec2 main_texture_scale)
+{
+	vec2 center = vec2(uv_pinch_center_x * main_texture_scale.x,
+		uv_pinch_center_y * main_texture_scale.y);
+	vec2 dP = uv - center;
+	float pinchInt = (PI / length(center)) * (-uv_pinch_amount + 0.001);
+	uv = center + normalize(dP) * atan(-length(dP) * pinchInt * 10.0)
+		* 0.5 / atan(-pinchInt * 5.);
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_pixelate.gdshaderinc

@@ -0,0 +1,11 @@
+group_uniforms uv_pixelate;
+uniform int uv_pixelate_size: hint_range(4, 512) = 32;
+group_uniforms;
+
+vec2 uv_pixelate(vec2 uv, vec2 viewport_size)
+{
+	float aspect_ratio = viewport_size.x / viewport_size.y;
+	vec2 pixel_size = vec2(float(uv_pixelate_size), float(uv_pixelate_size) * aspect_ratio);
+	uv = floor(uv * pixel_size) / pixel_size;
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_round_wave.gdshaderinc

@@ -0,0 +1,18 @@
+group_uniforms uv_round_wave;
+uniform float uv_round_wave_strength: hint_range(0.0, 1.0) = 0.7;
+uniform float uv_round_wave_speed: hint_range(0.0, 5.0) = 2.;
+group_uniforms;
+
+vec2 uv_round_wave(
+	vec2 uv,
+	vec2 main_texture_size,
+	vec2 main_texture_scale)
+{
+	float round_wave_x = 0.5 * main_texture_scale.x - uv.x;
+	float round_wave_y = (0.5 * main_texture_scale.y - uv.y) *
+		 main_texture_size.y / main_texture_size.x;
+	float ripple = -sqrt(round_wave_x * round_wave_x + round_wave_y * round_wave_y);
+	uv += mod(sin((ripple + TIME * (uv_round_wave_speed/10.0)) / 0.015)
+		* (uv_round_wave_strength /10.0), 1.0);
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_shake.gdshaderinc

@@ -0,0 +1,14 @@
+group_uniforms uv_shake;
+uniform float uv_shake_speed: hint_range(0.0, 50.0) = 20.;
+uniform float uv_shake_x: hint_range(-15., 15) = 5;
+uniform float uv_shake_y: hint_range(-15., 15) = 4;
+group_uniforms;
+
+vec2 uv_shake(
+	vec2 uv)
+{
+	float x_shake = sin(TIME * uv_shake_speed * 50.) * uv_shake_x;
+	float y_shake = cos(TIME * uv_shake_speed * 50.) * uv_shake_y;
+	uv += vec2(x_shake * 0.012, y_shake * 0.01);
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_twist.gdshaderinc

@@ -0,0 +1,26 @@
+group_uniforms uv_twist;
+uniform float uv_twist_amount: hint_range(0.0, 3.1415) = 1.;
+uniform float uv_twist_pos_x: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_twist_pos_y: hint_range(0.0, 1.0) = 0.5;
+uniform float uv_twist_radius: hint_range(0.0, 3.0) = 0.75;
+group_uniforms;
+
+vec2 uv_twist(
+	vec2 uv, 
+	vec2 main_texture_scale)
+{
+	vec2 twistUV = uv - vec2(uv_twist_pos_x * main_texture_scale.x,
+								uv_twist_pos_y * main_texture_scale.y);
+	float twist_radius = uv_twist_radius *
+			(main_texture_scale.x + main_texture_scale.y) / 2.;
+	float percent = (twist_radius - length(twistUV)) / twist_radius;
+	float theta = percent * percent * (2.0 * sin(uv_twist_amount)) * 8.0;
+	float s = sin(theta);
+	float c = cos(theta);
+	float beta = max(sign(twist_radius - length(twistUV)), 0.);
+	twistUV = vec2(dot(twistUV, vec2(c, -s)), dot(twistUV, vec2(s, c))) * beta + twistUV * (1. - beta);
+	twistUV += vec2(uv_twist_pos_x * main_texture_scale.x,
+					uv_twist_pos_y * main_texture_scale.y);
+	uv = twistUV;
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_wave.gdshaderinc

@@ -0,0 +1,22 @@
+group_uniforms uv_wave;
+uniform float uv_wave_amount: hint_range(0.0, 25.0) = 7.;
+uniform float uv_wave_speed: hint_range(0.0, 25.0) = 10.;
+uniform float uv_wave_strength: hint_range(0.0, 25.0) = 7.5;
+uniform float uv_wave_x: hint_range(0.0, 1.0) = 0.;
+uniform float uv_wave_y: hint_range(0.0, 1.0) = 0.5;
+group_uniforms;
+
+vec2 uv_wave(
+	vec2 uv, 
+	vec2 viewport_size,
+	vec2 main_texture_scale)
+{
+	vec2 waveUV = vec2(uv_wave_x * main_texture_scale.x,
+					uv_wave_y * main_texture_scale.y) - uv;
+	waveUV.x *= viewport_size.x / viewport_size.y;
+	float ang_wave =
+		(sqrt(dot(waveUV, waveUV)) * uv_wave_amount)
+		- mod(TIME * uv_wave_speed, 360.0);
+	uv = uv + normalize(waveUV) * sin(ang_wave) * (uv_wave_strength / 1000.);
+	return uv;	
+}

VFEZ/Shaders/Effects/vfez_uv_wind.gdshaderinc

@@ -0,0 +1,31 @@
+group_uniforms uv_wind;
+uniform float uv_wind_speed: hint_range(0., 50.) = 2.;
+uniform float uv_wind_amount: hint_range(0, 50) = 20;
+uniform float uv_wind_vertical_ratio: hint_range(0.0, 1.0) = 1.;
+uniform vec2 uv_radial_bend_center = vec2(0.5, 0.9);
+uniform bool uv_wind_animate_manual;
+uniform float uv_wind_manual_anim: hint_range(-1, 1) = 1;
+uniform float uv_wind_radial_bend: hint_range(0.0, 5.0) = 0.1;
+group_uniforms;
+
+vec2 uv_wind(vec2 uv)
+{
+	float wind_offset;
+	if (uv_wind_animate_manual)
+	{
+		wind_offset = uv_wind_manual_anim;
+	}
+	else
+	{
+		wind_offset = sin(TIME * uv_wind_speed * 10.);
+	}
+	
+	uv.x = mix(uv.x, uv.x + uv_wind_amount * 0.01 * wind_offset, 
+				abs(uv_wind_vertical_ratio - uv.y));
+	
+	vec2 delta = uv - uv_radial_bend_center;
+	float delta2 = dot(delta, delta);
+	float delta_offset = delta2 * wind_offset;
+	uv = uv + vec2(delta.y, - delta.x) * delta_offset * uv_wind_radial_bend;
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_wrap.gdshaderinc

@@ -0,0 +1,15 @@
+group_uniforms uv_wrap;
+uniform float uv_wrap_strength: hint_range(0.0, 0.1) = 0.025;
+uniform float uv_wrap_speed: hint_range(0.0, 25.) = 8;
+uniform float uv_wrap_scale: hint_range(0.05, 3.) = 0.5;
+group_uniforms;
+
+vec2 uv_wrap(vec2 uv, vec2 main_texture_scale)
+{
+	vec2 norm_uv = uv / main_texture_scale;
+	float x_wrap = TIME * uv_wrap_speed + norm_uv.x * TAU / uv_wrap_scale;
+	float y_wrap = TIME * uv_wrap_speed + norm_uv.y * TAU / uv_wrap_scale;
+	vec2 wrap = vec2(sin(x_wrap), cos(y_wrap)) * uv_wrap_strength;
+	uv += wrap;
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_uv_zoom.gdshaderinc

@@ -0,0 +1,13 @@
+group_uniforms uv_zoom;
+uniform vec2 uv_zoom_center = vec2(0.5);
+uniform float uv_zoom_amount: hint_range(0.1, 5.) = 0.5;
+group_uniforms;
+
+vec2 uv_zoom(vec2 uv, vec2 main_texture_scale)
+{
+	vec2 norm_center = uv_zoom_center / main_texture_scale;
+	uv -= norm_center;
+	uv = uv * uv_zoom_amount;
+	uv += norm_center;
+	return uv;
+}

VFEZ/Shaders/Effects/vfez_vertex_expand.gdshaderinc

@@ -0,0 +1,18 @@
+group_uniforms vertex_expand;
+uniform vec3 vertex_expand_center = vec3(0.);
+uniform bool vertex_expand_ignore_center_vertical = false;
+uniform float vertex_expand_amount: hint_range(0.0, 10.) = 0.5;
+group_uniforms;
+
+vec3 vertex_expand(
+	vec3 vertex)
+{
+	vec3 final_expand_center = vertex_expand_center;
+	if (vertex_expand_ignore_center_vertical)
+	{
+		final_expand_center.z = vertex.z;
+	}
+	vec3 expand_dir = normalize(vertex - final_expand_center);
+	vertex += expand_dir * vertex_expand_amount;
+	return vertex;
+}

VFEZ/Shaders/Effects/vfez_vertex_offset.gdshaderinc

@@ -0,0 +1,18 @@
+group_uniforms vertex_offset;
+uniform sampler2D vertex_offset_texture: source_color;
+uniform float vertex_offset_amount: hint_range(0.0, 2.) = 0.5;
+uniform float vertex_offset_power: hint_range(0.01, 10.) = 1.;
+uniform vec2 vertex_offset_speed;
+group_uniforms;
+
+vec3 vertex_offset(
+	vec3 vertex, 
+	vec3 normal, 
+	vec2 uv)
+{
+	vec2 offsetUV = uv;
+	offsetUV += mod(TIME * vertex_offset_speed, 1.0);
+	float offset = textureLod(vertex_offset_texture, offsetUV, 0.).r;
+	vertex = vertex + normal * vertex_offset_amount * pow(offset, vertex_offset_power);
+	return vertex;
+}