Rename GLES2 driver to OpenGL to prepare for the upgrade to GLES3

- Use lowercase driver names for the `--rendering-driver`
  command line argument.

11 files changed, 4613 insertions, 0 deletions

diff --git a/drivers/opengl/shaders/SCsub b/drivers/opengl/shaders/SCsub
new file mode 100644
index 0000000000..dcd8bf6030
--- /dev/null
+++ b/drivers/opengl/shaders/SCsub
@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+Import("env")
+
+if "OpenGL_GLSL" in env["BUILDERS"]:
+    env.OpenGL_GLSL("copy.glsl")
+    env.OpenGL_GLSL("canvas.glsl")
+    env.OpenGL_GLSL("canvas_shadow.glsl")
+    env.OpenGL_GLSL("scene.glsl")
+    env.OpenGL_GLSL("cubemap_filter.glsl")
+    env.OpenGL_GLSL("cube_to_dp.glsl")
+    env.OpenGL_GLSL("effect_blur.glsl")
+    env.OpenGL_GLSL("tonemap.glsl")
+    env.OpenGL_GLSL("lens_distorted.glsl")
diff --git a/drivers/opengl/shaders/canvas.glsl b/drivers/opengl/shaders/canvas.glsl
new file mode 100644
index 0000000000..3dee2faa88
--- /dev/null
+++ b/drivers/opengl/shaders/canvas.glsl
@@ -0,0 +1,686 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+uniform highp mat4 projection_matrix;
+/* clang-format on */
+
+#include "stdlib.glsl"
+
+uniform highp mat4 modelview_matrix;
+uniform highp mat4 extra_matrix;
+attribute highp vec2 vertex; // attrib:0
+
+#ifdef USE_ATTRIB_LIGHT_ANGLE
+// shared with tangent, not used in canvas shader
+attribute highp float light_angle; // attrib:2
+#endif
+
+attribute vec4 color_attrib; // attrib:3
+attribute vec2 uv_attrib; // attrib:4
+
+#ifdef USE_ATTRIB_MODULATE
+attribute highp vec4 modulate_attrib; // attrib:5
+#endif
+
+#ifdef USE_ATTRIB_LARGE_VERTEX
+// shared with skeleton attributes, not used in batched shader
+attribute highp vec2 translate_attrib; // attrib:6
+attribute highp vec4 basis_attrib; // attrib:7
+#endif
+
+#ifdef USE_SKELETON
+attribute highp vec4 bone_indices; // attrib:6
+attribute highp vec4 bone_weights; // attrib:7
+#endif
+
+#ifdef USE_INSTANCING
+
+attribute highp vec4 instance_xform0; //attrib:8
+attribute highp vec4 instance_xform1; //attrib:9
+attribute highp vec4 instance_xform2; //attrib:10
+attribute highp vec4 instance_color; //attrib:11
+
+#ifdef USE_INSTANCE_CUSTOM
+attribute highp vec4 instance_custom_data; //attrib:12
+#endif
+
+#endif
+
+#ifdef USE_SKELETON
+uniform highp sampler2D skeleton_texture; // texunit:-3
+uniform highp ivec2 skeleton_texture_size;
+uniform highp mat4 skeleton_transform;
+uniform highp mat4 skeleton_transform_inverse;
+#endif
+
+varying vec2 uv_interp;
+varying vec4 color_interp;
+
+#ifdef USE_ATTRIB_MODULATE
+// modulate doesn't need interpolating but we need to send it to the fragment shader
+varying vec4 modulate_interp;
+#endif
+
+#ifdef MODULATE_USED
+uniform vec4 final_modulate;
+#endif
+
+uniform highp vec2 color_texpixel_size;
+
+#ifdef USE_TEXTURE_RECT
+
+uniform vec4 dst_rect;
+uniform vec4 src_rect;
+
+#endif
+
+uniform highp float time;
+
+#ifdef USE_LIGHTING
+
+// light matrices
+uniform highp mat4 light_matrix;
+uniform highp mat4 light_matrix_inverse;
+uniform highp mat4 light_local_matrix;
+uniform highp mat4 shadow_matrix;
+uniform highp vec4 light_color;
+uniform highp vec4 light_shadow_color;
+uniform highp vec2 light_pos;
+uniform highp float shadowpixel_size;
+uniform highp float shadow_gradient;
+uniform highp float light_height;
+uniform highp float light_outside_alpha;
+uniform highp float shadow_distance_mult;
+
+varying vec4 light_uv_interp;
+varying vec2 transformed_light_uv;
+varying vec4 local_rot;
+
+#ifdef USE_SHADOWS
+varying highp vec2 pos;
+#endif
+
+const bool at_light_pass = true;
+#else
+const bool at_light_pass = false;
+#endif
+
+/* clang-format off */
+
+VERTEX_SHADER_GLOBALS
+
+/* clang-format on */
+
+vec2 select(vec2 a, vec2 b, bvec2 c) {
+	vec2 ret;
+
+	ret.x = c.x ? b.x : a.x;
+	ret.y = c.y ? b.y : a.y;
+
+	return ret;
+}
+
+void main() {
+	vec4 color = color_attrib;
+	vec2 uv;
+
+#ifdef USE_INSTANCING
+	mat4 extra_matrix_instance = extra_matrix * transpose(mat4(instance_xform0, instance_xform1, instance_xform2, vec4(0.0, 0.0, 0.0, 1.0)));
+	color *= instance_color;
+
+#ifdef USE_INSTANCE_CUSTOM
+	vec4 instance_custom = instance_custom_data;
+#else
+	vec4 instance_custom = vec4(0.0);
+#endif
+
+#else
+	mat4 extra_matrix_instance = extra_matrix;
+	vec4 instance_custom = vec4(0.0);
+#endif
+
+#ifdef USE_TEXTURE_RECT
+
+	if (dst_rect.z < 0.0) { // Transpose is encoded as negative dst_rect.z
+		uv = src_rect.xy + abs(src_rect.zw) * vertex.yx;
+	} else {
+		uv = src_rect.xy + abs(src_rect.zw) * vertex;
+	}
+
+	vec4 outvec = vec4(0.0, 0.0, 0.0, 1.0);
+
+	// This is what is done in the GLES 3 bindings and should
+	// take care of flipped rects.
+	//
+	// But it doesn't.
+	// I don't know why, will need to investigate further.
+
+	outvec.xy = dst_rect.xy + abs(dst_rect.zw) * select(vertex, vec2(1.0, 1.0) - vertex, lessThan(src_rect.zw, vec2(0.0, 0.0)));
+
+	// outvec.xy = dst_rect.xy + abs(dst_rect.zw) * vertex;
+#else
+	vec4 outvec = vec4(vertex.xy, 0.0, 1.0);
+
+	uv = uv_attrib;
+#endif
+
+	float point_size = 1.0;
+
+	{
+		vec2 src_vtx = outvec.xy;
+		/* clang-format off */
+
+VERTEX_SHADER_CODE
+
+		/* clang-format on */
+	}
+
+	gl_PointSize = point_size;
+
+#ifdef USE_ATTRIB_MODULATE
+	// modulate doesn't need interpolating but we need to send it to the fragment shader
+	modulate_interp = modulate_attrib;
+#endif
+
+#ifdef USE_ATTRIB_LARGE_VERTEX
+	// transform is in attributes
+	vec2 temp;
+
+	temp = outvec.xy;
+	temp.x = (outvec.x * basis_attrib.x) + (outvec.y * basis_attrib.z);
+	temp.y = (outvec.x * basis_attrib.y) + (outvec.y * basis_attrib.w);
+
+	temp += translate_attrib;
+	outvec.xy = temp;
+
+#else
+
+	// transform is in uniforms
+#if !defined(SKIP_TRANSFORM_USED)
+	outvec = extra_matrix_instance * outvec;
+	outvec = modelview_matrix * outvec;
+#endif
+
+#endif // not large integer
+
+	color_interp = color;
+
+#ifdef USE_PIXEL_SNAP
+	outvec.xy = floor(outvec + 0.5).xy;
+	// precision issue on some hardware creates artifacts within texture
+	// offset uv by a small amount to avoid
+	uv += 1e-5;
+#endif
+
+#ifdef USE_SKELETON
+
+	// look up transform from the "pose texture"
+	if (bone_weights != vec4(0.0)) {
+		highp mat4 bone_transform = mat4(0.0);
+
+		for (int i = 0; i < 4; i++) {
+			ivec2 tex_ofs = ivec2(int(bone_indices[i]) * 2, 0);
+
+			highp mat4 b = mat4(
+					texel2DFetch(skeleton_texture, skeleton_texture_size, tex_ofs + ivec2(0, 0)),
+					texel2DFetch(skeleton_texture, skeleton_texture_size, tex_ofs + ivec2(1, 0)),
+					vec4(0.0, 0.0, 1.0, 0.0),
+					vec4(0.0, 0.0, 0.0, 1.0));
+
+			bone_transform += b * bone_weights[i];
+		}
+
+		mat4 bone_matrix = skeleton_transform * transpose(bone_transform) * skeleton_transform_inverse;
+
+		outvec = bone_matrix * outvec;
+	}
+
+#endif
+
+	uv_interp = uv;
+	gl_Position = projection_matrix * outvec;
+
+#ifdef USE_LIGHTING
+
+	light_uv_interp.xy = (light_matrix * outvec).xy;
+	light_uv_interp.zw = (light_local_matrix * outvec).xy;
+
+	transformed_light_uv = (mat3(light_matrix_inverse) * vec3(light_uv_interp.zw, 0.0)).xy; //for normal mapping
+
+#ifdef USE_SHADOWS
+	pos = outvec.xy;
+#endif
+
+#ifdef USE_ATTRIB_LIGHT_ANGLE
+	// we add a fixed offset because we are using the sign later,
+	// and don't want floating point error around 0.0
+	float la = abs(light_angle) - 1.0;
+
+	// vector light angle
+	vec4 vla;
+	vla.xy = vec2(cos(la), sin(la));
+	vla.zw = vec2(-vla.y, vla.x);
+
+	// vertical flip encoded in the sign
+	vla.zw *= sign(light_angle);
+
+	// apply the transform matrix.
+	// The rotate will be encoded in the transform matrix for single rects,
+	// and just the flips in the light angle.
+	// For batching we will encode the rotation and the flips
+	// in the light angle, and can use the same shader.
+	local_rot.xy = normalize((modelview_matrix * (extra_matrix_instance * vec4(vla.xy, 0.0, 0.0))).xy);
+	local_rot.zw = normalize((modelview_matrix * (extra_matrix_instance * vec4(vla.zw, 0.0, 0.0))).xy);
+#else
+	local_rot.xy = normalize((modelview_matrix * (extra_matrix_instance * vec4(1.0, 0.0, 0.0, 0.0))).xy);
+	local_rot.zw = normalize((modelview_matrix * (extra_matrix_instance * vec4(0.0, 1.0, 0.0, 0.0))).xy);
+#ifdef USE_TEXTURE_RECT
+	local_rot.xy *= sign(src_rect.z);
+	local_rot.zw *= sign(src_rect.w);
+#endif
+#endif // not using light angle
+
+#endif
+}
+
+/* clang-format off */
+[fragment]
+
+// texture2DLodEXT and textureCubeLodEXT are fragment shader specific.
+// Do not copy these defines in the vertex section.
+#ifndef USE_GLES_OVER_GL
+#ifdef GL_EXT_shader_texture_lod
+#extension GL_EXT_shader_texture_lod : enable
+#define texture2DLod(img, coord, lod) texture2DLodEXT(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCubeLodEXT(img, coord, lod)
+#endif
+#endif // !USE_GLES_OVER_GL
+
+#ifdef GL_ARB_shader_texture_lod
+#extension GL_ARB_shader_texture_lod : enable
+#endif
+
+#if !defined(GL_EXT_shader_texture_lod) && !defined(GL_ARB_shader_texture_lod)
+#define texture2DLod(img, coord, lod) texture2D(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCube(img, coord, lod)
+#endif
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+#include "stdlib.glsl"
+
+uniform sampler2D color_texture; // texunit:-1
+/* clang-format on */
+uniform highp vec2 color_texpixel_size;
+uniform mediump sampler2D normal_texture; // texunit:-2
+
+varying mediump vec2 uv_interp;
+varying mediump vec4 color_interp;
+
+#ifdef USE_ATTRIB_MODULATE
+varying mediump vec4 modulate_interp;
+#endif
+
+uniform highp float time;
+
+uniform vec4 final_modulate;
+
+#ifdef SCREEN_TEXTURE_USED
+
+uniform sampler2D screen_texture; // texunit:-4
+
+#endif
+
+#ifdef SCREEN_UV_USED
+
+uniform vec2 screen_pixel_size;
+
+#endif
+
+#ifdef USE_LIGHTING
+
+uniform highp mat4 light_matrix;
+uniform highp mat4 light_local_matrix;
+uniform highp mat4 shadow_matrix;
+uniform highp vec4 light_color;
+uniform highp vec4 light_shadow_color;
+uniform highp vec2 light_pos;
+uniform highp float shadowpixel_size;
+uniform highp float shadow_gradient;
+uniform highp float light_height;
+uniform highp float light_outside_alpha;
+uniform highp float shadow_distance_mult;
+
+uniform lowp sampler2D light_texture; // texunit:-6
+varying vec4 light_uv_interp;
+varying vec2 transformed_light_uv;
+
+varying vec4 local_rot;
+
+#ifdef USE_SHADOWS
+
+uniform highp sampler2D shadow_texture; // texunit:-5
+varying highp vec2 pos;
+
+#endif
+
+const bool at_light_pass = true;
+#else
+const bool at_light_pass = false;
+#endif
+
+uniform bool use_default_normal;
+
+/* clang-format off */
+
+FRAGMENT_SHADER_GLOBALS
+
+/* clang-format on */
+
+void light_compute(
+		inout vec4 light,
+		inout vec2 light_vec,
+		inout float light_height,
+		inout vec4 light_color,
+		vec2 light_uv,
+		inout vec4 shadow_color,
+		inout vec2 shadow_vec,
+		vec3 normal,
+		vec2 uv,
+#if defined(SCREEN_UV_USED)
+		vec2 screen_uv,
+#endif
+		vec4 color) {
+
+#if defined(USE_LIGHT_SHADER_CODE)
+
+	/* clang-format off */
+
+LIGHT_SHADER_CODE
+
+	/* clang-format on */
+
+#endif
+}
+
+void main() {
+	vec4 color = color_interp;
+	vec2 uv = uv_interp;
+#ifdef USE_FORCE_REPEAT
+	//needs to use this to workaround GLES2/WebGL1 forcing tiling that textures that don't support it
+	uv = mod(uv, vec2(1.0, 1.0));
+#endif
+
+#if !defined(COLOR_USED)
+	//default behavior, texture by color
+	color *= texture2D(color_texture, uv);
+#endif
+
+#ifdef SCREEN_UV_USED
+	vec2 screen_uv = gl_FragCoord.xy * screen_pixel_size;
+#endif
+
+	vec3 normal;
+
+#if defined(NORMAL_USED)
+
+	bool normal_used = true;
+#else
+	bool normal_used = false;
+#endif
+
+	if (use_default_normal) {
+		normal.xy = texture2D(normal_texture, uv).xy * 2.0 - 1.0;
+		normal.z = sqrt(1.0 - dot(normal.xy, normal.xy));
+		normal_used = true;
+	} else {
+		normal = vec3(0.0, 0.0, 1.0);
+	}
+
+	{
+		float normal_depth = 1.0;
+
+#if defined(NORMALMAP_USED)
+		vec3 normal_map = vec3(0.0, 0.0, 1.0);
+		normal_used = true;
+#endif
+
+		/* clang-format off */
+
+FRAGMENT_SHADER_CODE
+
+		/* clang-format on */
+
+#if defined(NORMALMAP_USED)
+		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_depth);
+#endif
+	}
+
+#ifdef USE_ATTRIB_MODULATE
+	color *= modulate_interp;
+#else
+#if !defined(MODULATE_USED)
+	color *= final_modulate;
+#endif
+#endif
+
+#ifdef USE_LIGHTING
+
+	vec2 light_vec = transformed_light_uv;
+	vec2 shadow_vec = transformed_light_uv;
+
+	if (normal_used) {
+		normal.xy = mat2(local_rot.xy, local_rot.zw) * normal.xy;
+	}
+
+	float att = 1.0;
+
+	vec2 light_uv = light_uv_interp.xy;
+	vec4 light = texture2D(light_texture, light_uv);
+
+	if (any(lessThan(light_uv_interp.xy, vec2(0.0, 0.0))) || any(greaterThanEqual(light_uv_interp.xy, vec2(1.0, 1.0)))) {
+		color.a *= light_outside_alpha; //invisible
+
+	} else {
+		float real_light_height = light_height;
+		vec4 real_light_color = light_color;
+		vec4 real_light_shadow_color = light_shadow_color;
+
+#if defined(USE_LIGHT_SHADER_CODE)
+		//light is written by the light shader
+		light_compute(
+				light,
+				light_vec,
+				real_light_height,
+				real_light_color,
+				light_uv,
+				real_light_shadow_color,
+				shadow_vec,
+				normal,
+				uv,
+#if defined(SCREEN_UV_USED)
+				screen_uv,
+#endif
+				color);
+#endif
+
+		light *= real_light_color;
+
+		if (normal_used) {
+			vec3 light_normal = normalize(vec3(light_vec, -real_light_height));
+			light *= max(dot(-light_normal, normal), 0.0);
+		}
+
+		color *= light;
+
+#ifdef USE_SHADOWS
+
+#ifdef SHADOW_VEC_USED
+		mat3 inverse_light_matrix = mat3(light_matrix);
+		inverse_light_matrix[0] = normalize(inverse_light_matrix[0]);
+		inverse_light_matrix[1] = normalize(inverse_light_matrix[1]);
+		inverse_light_matrix[2] = normalize(inverse_light_matrix[2]);
+		shadow_vec = (inverse_light_matrix * vec3(shadow_vec, 0.0)).xy;
+#else
+		shadow_vec = light_uv_interp.zw;
+#endif
+
+		float angle_to_light = -atan(shadow_vec.x, shadow_vec.y);
+		float PI = 3.14159265358979323846264;
+		/*int i = int(mod(floor((angle_to_light+7.0*PI/6.0)/(4.0*PI/6.0))+1.0, 3.0)); // +1 pq os indices estao em ordem 2,0,1 nos arrays
+		float ang*/
+
+		float su, sz;
+
+		float abs_angle = abs(angle_to_light);
+		vec2 point;
+		float sh;
+		if (abs_angle < 45.0 * PI / 180.0) {
+			point = shadow_vec;
+			sh = 0.0 + (1.0 / 8.0);
+		} else if (abs_angle > 135.0 * PI / 180.0) {
+			point = -shadow_vec;
+			sh = 0.5 + (1.0 / 8.0);
+		} else if (angle_to_light > 0.0) {
+			point = vec2(shadow_vec.y, -shadow_vec.x);
+			sh = 0.25 + (1.0 / 8.0);
+		} else {
+			point = vec2(-shadow_vec.y, shadow_vec.x);
+			sh = 0.75 + (1.0 / 8.0);
+		}
+
+		highp vec4 s = shadow_matrix * vec4(point, 0.0, 1.0);
+		s.xyz /= s.w;
+		su = s.x * 0.5 + 0.5;
+		sz = s.z * 0.5 + 0.5;
+		//sz=lightlength(light_vec);
+
+		highp float shadow_attenuation = 0.0;
+
+#ifdef USE_RGBA_SHADOWS
+#define SHADOW_DEPTH(m_tex, m_uv) dot(texture2D((m_tex), (m_uv)), vec4(1.0 / (255.0 * 255.0 * 255.0), 1.0 / (255.0 * 255.0), 1.0 / 255.0, 1.0))
+
+#else
+
+#define SHADOW_DEPTH(m_tex, m_uv) (texture2D((m_tex), (m_uv)).r)
+
+#endif
+
+#ifdef SHADOW_USE_GRADIENT
+
+		/* clang-format off */
+		/* GLSL es 100 doesn't support line continuation characters(backslashes) */
+#define SHADOW_TEST(m_ofs) { highp float sd = SHADOW_DEPTH(shadow_texture, vec2(m_ofs, sh)); shadow_attenuation += 1.0 - smoothstep(sd, sd + shadow_gradient, sz); }
+
+#else
+
+#define SHADOW_TEST(m_ofs) { highp float sd = SHADOW_DEPTH(shadow_texture, vec2(m_ofs, sh)); shadow_attenuation += step(sz, sd); }
+		/* clang-format on */
+
+#endif
+
+#ifdef SHADOW_FILTER_NEAREST
+
+		SHADOW_TEST(su);
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF3
+
+		SHADOW_TEST(su + shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su - shadowpixel_size);
+		shadow_attenuation /= 3.0;
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF5
+
+		SHADOW_TEST(su + shadowpixel_size * 2.0);
+		SHADOW_TEST(su + shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su - shadowpixel_size);
+		SHADOW_TEST(su - shadowpixel_size * 2.0);
+		shadow_attenuation /= 5.0;
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF7
+
+		SHADOW_TEST(su + shadowpixel_size * 3.0);
+		SHADOW_TEST(su + shadowpixel_size * 2.0);
+		SHADOW_TEST(su + shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su - shadowpixel_size);
+		SHADOW_TEST(su - shadowpixel_size * 2.0);
+		SHADOW_TEST(su - shadowpixel_size * 3.0);
+		shadow_attenuation /= 7.0;
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF9
+
+		SHADOW_TEST(su + shadowpixel_size * 4.0);
+		SHADOW_TEST(su + shadowpixel_size * 3.0);
+		SHADOW_TEST(su + shadowpixel_size * 2.0);
+		SHADOW_TEST(su + shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su - shadowpixel_size);
+		SHADOW_TEST(su - shadowpixel_size * 2.0);
+		SHADOW_TEST(su - shadowpixel_size * 3.0);
+		SHADOW_TEST(su - shadowpixel_size * 4.0);
+		shadow_attenuation /= 9.0;
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF13
+
+		SHADOW_TEST(su + shadowpixel_size * 6.0);
+		SHADOW_TEST(su + shadowpixel_size * 5.0);
+		SHADOW_TEST(su + shadowpixel_size * 4.0);
+		SHADOW_TEST(su + shadowpixel_size * 3.0);
+		SHADOW_TEST(su + shadowpixel_size * 2.0);
+		SHADOW_TEST(su + shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su - shadowpixel_size);
+		SHADOW_TEST(su - shadowpixel_size * 2.0);
+		SHADOW_TEST(su - shadowpixel_size * 3.0);
+		SHADOW_TEST(su - shadowpixel_size * 4.0);
+		SHADOW_TEST(su - shadowpixel_size * 5.0);
+		SHADOW_TEST(su - shadowpixel_size * 6.0);
+		shadow_attenuation /= 13.0;
+
+#endif
+
+		//color *= shadow_attenuation;
+		color = mix(real_light_shadow_color, color, shadow_attenuation);
+//use shadows
+#endif
+	}
+
+//use lighting
+#endif
+
+	gl_FragColor = color;
+}
diff --git a/drivers/opengl/shaders/canvas_shadow.glsl b/drivers/opengl/shaders/canvas_shadow.glsl
new file mode 100644
index 0000000000..2abcd5e67c
--- /dev/null
+++ b/drivers/opengl/shaders/canvas_shadow.glsl
@@ -0,0 +1,60 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute highp vec3 vertex; // attrib:0
+
+uniform highp mat4 projection_matrix;
+/* clang-format on */
+uniform highp mat4 light_matrix;
+uniform highp mat4 world_matrix;
+uniform highp float distance_norm;
+
+varying highp vec4 position_interp;
+
+void main() {
+	gl_Position = projection_matrix * (light_matrix * (world_matrix * vec4(vertex, 1.0)));
+	position_interp = gl_Position;
+}
+
+/* clang-format off */
+[fragment]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+varying highp vec4 position_interp;
+/* clang-format on */
+
+void main() {
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0; // bias
+
+#ifdef USE_RGBA_SHADOWS
+
+	highp vec4 comp = fract(depth * vec4(255.0 * 255.0 * 255.0, 255.0 * 255.0, 255.0, 1.0));
+	comp -= comp.xxyz * vec4(0.0, 1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0);
+	gl_FragColor = comp;
+#else
+
+	gl_FragColor = vec4(depth);
+#endif
+}
diff --git a/drivers/opengl/shaders/copy.glsl b/drivers/opengl/shaders/copy.glsl
new file mode 100644
index 0000000000..e833722ac3
--- /dev/null
+++ b/drivers/opengl/shaders/copy.glsl
@@ -0,0 +1,191 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute highp vec4 vertex_attrib; // attrib:0
+/* clang-format on */
+
+#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
+attribute vec3 cube_in; // attrib:4
+#else
+attribute vec2 uv_in; // attrib:4
+#endif
+
+attribute vec2 uv2_in; // attrib:5
+
+#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
+varying vec3 cube_interp;
+#else
+varying vec2 uv_interp;
+#endif
+varying vec2 uv2_interp;
+
+// These definitions are here because the shader-wrapper builder does
+// not understand `#elif defined()`
+#ifdef USE_DISPLAY_TRANSFORM
+#endif
+
+#ifdef USE_COPY_SECTION
+uniform highp vec4 copy_section;
+#elif defined(USE_DISPLAY_TRANSFORM)
+uniform highp mat4 display_transform;
+#endif
+
+void main() {
+#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
+	cube_interp = cube_in;
+#elif defined(USE_ASYM_PANO)
+	uv_interp = vertex_attrib.xy;
+#else
+	uv_interp = uv_in;
+#endif
+
+	uv2_interp = uv2_in;
+	gl_Position = vertex_attrib;
+
+#ifdef USE_COPY_SECTION
+	uv_interp = copy_section.xy + uv_interp * copy_section.zw;
+	gl_Position.xy = (copy_section.xy + (gl_Position.xy * 0.5 + 0.5) * copy_section.zw) * 2.0 - 1.0;
+#elif defined(USE_DISPLAY_TRANSFORM)
+	uv_interp = (display_transform * vec4(uv_in, 1.0, 1.0)).xy;
+#endif
+}
+
+/* clang-format off */
+[fragment]
+
+#define M_PI 3.14159265359
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
+varying vec3 cube_interp;
+#else
+varying vec2 uv_interp;
+#endif
+/* clang-format on */
+
+#ifdef USE_ASYM_PANO
+uniform highp mat4 pano_transform;
+uniform highp vec4 asym_proj;
+#endif
+
+#ifdef USE_CUBEMAP
+uniform samplerCube source_cube; // texunit:0
+#else
+uniform sampler2D source; // texunit:0
+#endif
+
+#ifdef SEP_CBCR_TEXTURE
+uniform sampler2D CbCr; //texunit:1
+#endif
+
+varying vec2 uv2_interp;
+
+#ifdef USE_MULTIPLIER
+uniform float multiplier;
+#endif
+
+#ifdef USE_CUSTOM_ALPHA
+uniform float custom_alpha;
+#endif
+
+#if defined(USE_PANORAMA) || defined(USE_ASYM_PANO)
+uniform highp mat4 sky_transform;
+
+vec4 texturePanorama(sampler2D pano, vec3 normal) {
+	vec2 st = vec2(
+			atan(normal.x, normal.z),
+			acos(normal.y));
+
+	if (st.x < 0.0)
+		st.x += M_PI * 2.0;
+
+	st /= vec2(M_PI * 2.0, M_PI);
+
+	return texture2D(pano, st);
+}
+
+#endif
+
+void main() {
+#ifdef USE_PANORAMA
+
+	vec3 cube_normal = normalize(cube_interp);
+	cube_normal.z = -cube_normal.z;
+	cube_normal = mat3(sky_transform) * cube_normal;
+	cube_normal.z = -cube_normal.z;
+
+	vec4 color = texturePanorama(source, cube_normal);
+
+#elif defined(USE_ASYM_PANO)
+
+	// When an asymmetrical projection matrix is used (applicable for stereoscopic rendering i.e. VR) we need to do this calculation per fragment to get a perspective correct result.
+	// Asymmetrical projection means the center of projection is no longer in the center of the screen but shifted.
+	// The Matrix[2][0] (= asym_proj.x) and Matrix[2][1] (= asym_proj.z) values are what provide the right shift in the image.
+
+	vec3 cube_normal;
+	cube_normal.z = -1.0;
+	cube_normal.x = (cube_normal.z * (-uv_interp.x - asym_proj.x)) / asym_proj.y;
+	cube_normal.y = (cube_normal.z * (-uv_interp.y - asym_proj.z)) / asym_proj.a;
+	cube_normal = mat3(sky_transform) * mat3(pano_transform) * cube_normal;
+	cube_normal.z = -cube_normal.z;
+
+	vec4 color = texturePanorama(source, normalize(cube_normal.xyz));
+
+#elif defined(USE_CUBEMAP)
+	vec4 color = textureCube(source_cube, normalize(cube_interp));
+#elif defined(SEP_CBCR_TEXTURE)
+	vec4 color;
+	color.r = texture2D(source, uv_interp).r;
+	color.gb = texture2D(CbCr, uv_interp).rg - vec2(0.5, 0.5);
+	color.a = 1.0;
+#else
+	vec4 color = texture2D(source, uv_interp);
+#endif
+
+#ifdef YCBCR_TO_RGB
+	// YCbCr -> RGB conversion
+
+	// Using BT.601, which is the standard for SDTV is provided as a reference
+	color.rgb = mat3(
+						vec3(1.00000, 1.00000, 1.00000),
+						vec3(0.00000, -0.34413, 1.77200),
+						vec3(1.40200, -0.71414, 0.00000)) *
+				color.rgb;
+#endif
+
+#ifdef USE_NO_ALPHA
+	color.a = 1.0;
+#endif
+
+#ifdef USE_CUSTOM_ALPHA
+	color.a = custom_alpha;
+#endif
+
+#ifdef USE_MULTIPLIER
+	color.rgb *= multiplier;
+#endif
+
+	gl_FragColor = color;
+}
diff --git a/drivers/opengl/shaders/cube_to_dp.glsl b/drivers/opengl/shaders/cube_to_dp.glsl
new file mode 100644
index 0000000000..1612ec3d5a
--- /dev/null
+++ b/drivers/opengl/shaders/cube_to_dp.glsl
@@ -0,0 +1,100 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision mediump float;
+precision mediump int;
+#endif
+
+attribute highp vec4 vertex_attrib; // attrib:0
+/* clang-format on */
+attribute vec2 uv_in; // attrib:4
+
+varying vec2 uv_interp;
+
+void main() {
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+}
+
+/* clang-format off */
+[fragment]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+uniform highp samplerCube source_cube; //texunit:0
+/* clang-format on */
+varying vec2 uv_interp;
+
+uniform bool z_flip;
+uniform highp float z_far;
+uniform highp float z_near;
+uniform highp float bias;
+
+void main() {
+	highp vec3 normal = vec3(uv_interp * 2.0 - 1.0, 0.0);
+	/*
+	if (z_flip) {
+		normal.z = 0.5 - 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
+	} else {
+		normal.z = -0.5 + 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
+	}
+	*/
+
+	//normal.z = sqrt(1.0 - dot(normal.xy, normal.xy));
+	//normal.xy *= 1.0 + normal.z;
+
+	normal.z = 0.5 - 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
+	normal = normalize(normal);
+	/*
+	normal.z = 0.5;
+	normal = normalize(normal);
+	*/
+
+	if (!z_flip) {
+		normal.z = -normal.z;
+	}
+
+	//normal = normalize(vec3( uv_interp * 2.0 - 1.0, 1.0 ));
+	float depth = textureCube(source_cube, normal).r;
+
+	// absolute values for direction cosines, bigger value equals closer to basis axis
+	vec3 unorm = abs(normal);
+
+	if ((unorm.x >= unorm.y) && (unorm.x >= unorm.z)) {
+		// x code
+		unorm = normal.x > 0.0 ? vec3(1.0, 0.0, 0.0) : vec3(-1.0, 0.0, 0.0);
+	} else if ((unorm.y > unorm.x) && (unorm.y >= unorm.z)) {
+		// y code
+		unorm = normal.y > 0.0 ? vec3(0.0, 1.0, 0.0) : vec3(0.0, -1.0, 0.0);
+	} else if ((unorm.z > unorm.x) && (unorm.z > unorm.y)) {
+		// z code
+		unorm = normal.z > 0.0 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 0.0, -1.0);
+	} else {
+		// oh-no we messed up code
+		// has to be
+		unorm = vec3(1.0, 0.0, 0.0);
+	}
+
+	float depth_fix = 1.0 / dot(normal, unorm);
+
+	depth = 2.0 * depth - 1.0;
+	float linear_depth = 2.0 * z_near * z_far / (z_far + z_near - depth * (z_far - z_near));
+	gl_FragDepth = (linear_depth * depth_fix + bias) / z_far;
+}
diff --git a/drivers/opengl/shaders/cubemap_filter.glsl b/drivers/opengl/shaders/cubemap_filter.glsl
new file mode 100644
index 0000000000..f5c91cc707
--- /dev/null
+++ b/drivers/opengl/shaders/cubemap_filter.glsl
@@ -0,0 +1,231 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute highp vec2 vertex; // attrib:0
+/* clang-format on */
+attribute highp vec2 uv; // attrib:4
+
+varying highp vec2 uv_interp;
+
+void main() {
+	uv_interp = uv;
+	gl_Position = vec4(vertex, 0, 1);
+}
+
+/* clang-format off */
+[fragment]
+
+// texture2DLodEXT and textureCubeLodEXT are fragment shader specific.
+// Do not copy these defines in the vertex section.
+#ifndef USE_GLES_OVER_GL
+#ifdef GL_EXT_shader_texture_lod
+#extension GL_EXT_shader_texture_lod : enable
+#define texture2DLod(img, coord, lod) texture2DLodEXT(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCubeLodEXT(img, coord, lod)
+#endif
+#endif // !USE_GLES_OVER_GL
+
+#ifdef GL_ARB_shader_texture_lod
+#extension GL_ARB_shader_texture_lod : enable
+#endif
+
+#if !defined(GL_EXT_shader_texture_lod) && !defined(GL_ARB_shader_texture_lod)
+#define texture2DLod(img, coord, lod) texture2D(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCube(img, coord, lod)
+#endif
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+
+#endif
+
+#ifdef USE_SOURCE_PANORAMA
+uniform sampler2D source_panorama; //texunit:0
+#else
+uniform samplerCube source_cube; //texunit:0
+#endif
+/* clang-format on */
+
+uniform int face_id;
+uniform float roughness;
+varying highp vec2 uv_interp;
+
+uniform sampler2D radical_inverse_vdc_cache; // texunit:1
+
+#define M_PI 3.14159265359
+
+#ifdef LOW_QUALITY
+
+#define SAMPLE_COUNT 64
+
+#else
+
+#define SAMPLE_COUNT 512
+
+#endif
+
+#ifdef USE_SOURCE_PANORAMA
+
+vec4 texturePanorama(sampler2D pano, vec3 normal) {
+	vec2 st = vec2(
+			atan(normal.x, normal.z),
+			acos(normal.y));
+
+	if (st.x < 0.0)
+		st.x += M_PI * 2.0;
+
+	st /= vec2(M_PI * 2.0, M_PI);
+
+	return texture2DLod(pano, st, 0.0);
+}
+
+#endif
+
+vec3 texelCoordToVec(vec2 uv, int faceID) {
+	mat3 faceUvVectors[6];
+
+	// -x
+	faceUvVectors[0][0] = vec3(0.0, 0.0, 1.0); // u -> +z
+	faceUvVectors[0][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+	faceUvVectors[0][2] = vec3(-1.0, 0.0, 0.0); // -x face
+
+	// +x
+	faceUvVectors[1][0] = vec3(0.0, 0.0, -1.0); // u -> -z
+	faceUvVectors[1][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+	faceUvVectors[1][2] = vec3(1.0, 0.0, 0.0); // +x face
+
+	// -y
+	faceUvVectors[2][0] = vec3(1.0, 0.0, 0.0); // u -> +x
+	faceUvVectors[2][1] = vec3(0.0, 0.0, -1.0); // v -> -z
+	faceUvVectors[2][2] = vec3(0.0, -1.0, 0.0); // -y face
+
+	// +y
+	faceUvVectors[3][0] = vec3(1.0, 0.0, 0.0); // u -> +x
+	faceUvVectors[3][1] = vec3(0.0, 0.0, 1.0); // v -> +z
+	faceUvVectors[3][2] = vec3(0.0, 1.0, 0.0); // +y face
+
+	// -z
+	faceUvVectors[4][0] = vec3(-1.0, 0.0, 0.0); // u -> -x
+	faceUvVectors[4][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+	faceUvVectors[4][2] = vec3(0.0, 0.0, -1.0); // -z face
+
+	// +z
+	faceUvVectors[5][0] = vec3(1.0, 0.0, 0.0); // u -> +x
+	faceUvVectors[5][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+	faceUvVectors[5][2] = vec3(0.0, 0.0, 1.0); // +z face
+
+	// out = u * s_faceUv[0] + v * s_faceUv[1] + s_faceUv[2].
+	vec3 result;
+	for (int i = 0; i < 6; i++) {
+		if (i == faceID) {
+			result = (faceUvVectors[i][0] * uv.x) + (faceUvVectors[i][1] * uv.y) + faceUvVectors[i][2];
+			break;
+		}
+	}
+	return normalize(result);
+}
+
+vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N) {
+	float a = Roughness * Roughness; // DISNEY'S ROUGHNESS [see Burley'12 siggraph]
+
+	// Compute distribution direction
+	float Phi = 2.0 * M_PI * Xi.x;
+	float CosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y));
+	float SinTheta = sqrt(1.0 - CosTheta * CosTheta);
+
+	// Convert to spherical direction
+	vec3 H;
+	H.x = SinTheta * cos(Phi);
+	H.y = SinTheta * sin(Phi);
+	H.z = CosTheta;
+
+	vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+	vec3 TangentX = normalize(cross(UpVector, N));
+	vec3 TangentY = cross(N, TangentX);
+
+	// Tangent to world space
+	return TangentX * H.x + TangentY * H.y + N * H.z;
+}
+
+float radical_inverse_VdC(int i) {
+	return texture2D(radical_inverse_vdc_cache, vec2(float(i) / 512.0, 0.0)).x;
+}
+
+vec2 Hammersley(int i, int N) {
+	return vec2(float(i) / float(N), radical_inverse_VdC(i));
+}
+
+uniform bool z_flip;
+
+void main() {
+	vec3 color = vec3(0.0);
+
+	vec2 uv = (uv_interp * 2.0) - 1.0;
+	vec3 N = texelCoordToVec(uv, face_id);
+
+#ifdef USE_DIRECT_WRITE
+
+#ifdef USE_SOURCE_PANORAMA
+
+	gl_FragColor = vec4(texturePanorama(source_panorama, N).rgb, 1.0);
+#else
+
+	gl_FragColor = vec4(textureCube(source_cube, N).rgb, 1.0);
+#endif //USE_SOURCE_PANORAMA
+
+#else
+
+	vec4 sum = vec4(0.0);
+
+	for (int sample_num = 0; sample_num < SAMPLE_COUNT; sample_num++) {
+		vec2 xi = Hammersley(sample_num, SAMPLE_COUNT);
+
+		vec3 H = ImportanceSampleGGX(xi, roughness, N);
+		vec3 V = N;
+		vec3 L = (2.0 * dot(V, H) * H - V);
+
+		float NdotL = clamp(dot(N, L), 0.0, 1.0);
+
+		if (NdotL > 0.0) {
+
+#ifdef USE_SOURCE_PANORAMA
+			vec3 val = texturePanorama(source_panorama, L).rgb;
+#else
+			vec3 val = textureCubeLod(source_cube, L, 0.0).rgb;
+#endif
+			//mix using Linear, to approximate high end back-end
+			val = mix(pow((val + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), val * (1.0 / 12.92), vec3(lessThan(val, vec3(0.04045))));
+
+			sum.rgb += val * NdotL;
+
+			sum.a += NdotL;
+		}
+	}
+
+	sum /= sum.a;
+
+	vec3 a = vec3(0.055);
+	sum.rgb = mix((vec3(1.0) + a) * pow(sum.rgb, vec3(1.0 / 2.4)) - a, 12.92 * sum.rgb, vec3(lessThan(sum.rgb, vec3(0.0031308))));
+
+	gl_FragColor = vec4(sum.rgb, 1.0);
+#endif
+}
diff --git a/drivers/opengl/shaders/effect_blur.glsl b/drivers/opengl/shaders/effect_blur.glsl
new file mode 100644
index 0000000000..7b607dd76a
--- /dev/null
+++ b/drivers/opengl/shaders/effect_blur.glsl
@@ -0,0 +1,308 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute vec2 vertex_attrib; // attrib:0
+/* clang-format on */
+attribute vec2 uv_in; // attrib:4
+
+varying vec2 uv_interp;
+
+#ifdef USE_BLUR_SECTION
+
+uniform vec4 blur_section;
+
+#endif
+
+void main() {
+	uv_interp = uv_in;
+	gl_Position = vec4(vertex_attrib, 0.0, 1.0);
+#ifdef USE_BLUR_SECTION
+
+	uv_interp = blur_section.xy + uv_interp * blur_section.zw;
+	gl_Position.xy = (blur_section.xy + (gl_Position.xy * 0.5 + 0.5) * blur_section.zw) * 2.0 - 1.0;
+#endif
+}
+
+/* clang-format off */
+[fragment]
+
+// texture2DLodEXT and textureCubeLodEXT are fragment shader specific.
+// Do not copy these defines in the vertex section.
+#ifndef USE_GLES_OVER_GL
+#ifdef GL_EXT_shader_texture_lod
+#extension GL_EXT_shader_texture_lod : enable
+#define texture2DLod(img, coord, lod) texture2DLodEXT(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCubeLodEXT(img, coord, lod)
+#endif
+#endif // !USE_GLES_OVER_GL
+
+#ifdef GL_ARB_shader_texture_lod
+#extension GL_ARB_shader_texture_lod : enable
+#endif
+
+#if !defined(GL_EXT_shader_texture_lod) && !defined(GL_ARB_shader_texture_lod)
+#define texture2DLod(img, coord, lod) texture2D(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCube(img, coord, lod)
+#endif
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+varying vec2 uv_interp;
+/* clang-format on */
+uniform sampler2D source_color; //texunit:0
+
+uniform float lod;
+uniform vec2 pixel_size;
+
+#if defined(GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
+
+uniform float glow_strength;
+
+#endif
+
+#if defined(DOF_FAR_BLUR) || defined(DOF_NEAR_BLUR)
+
+#ifdef USE_GLES_OVER_GL
+#ifdef DOF_QUALITY_LOW
+const int dof_kernel_size = 5;
+const int dof_kernel_from = 2;
+const float dof_kernel[5] = float[](0.153388, 0.221461, 0.250301, 0.221461, 0.153388);
+#endif
+
+#ifdef DOF_QUALITY_MEDIUM
+const int dof_kernel_size = 11;
+const int dof_kernel_from = 5;
+const float dof_kernel[11] = float[](0.055037, 0.072806, 0.090506, 0.105726, 0.116061, 0.119726, 0.116061, 0.105726, 0.090506, 0.072806, 0.055037);
+
+#endif
+
+#ifdef DOF_QUALITY_HIGH
+const int dof_kernel_size = 21;
+const int dof_kernel_from = 10;
+const float dof_kernel[21] = float[](0.028174, 0.032676, 0.037311, 0.041944, 0.046421, 0.050582, 0.054261, 0.057307, 0.059587, 0.060998, 0.061476, 0.060998, 0.059587, 0.057307, 0.054261, 0.050582, 0.046421, 0.041944, 0.037311, 0.032676, 0.028174);
+#endif
+#endif
+
+uniform sampler2D dof_source_depth; //texunit:1
+uniform float dof_begin;
+uniform float dof_end;
+uniform vec2 dof_dir;
+uniform float dof_radius;
+
+#endif
+
+#ifdef GLOW_FIRST_PASS
+
+uniform highp float luminance_cap;
+
+uniform float glow_bloom;
+uniform float glow_hdr_threshold;
+uniform float glow_hdr_scale;
+
+#endif
+
+uniform float camera_z_far;
+uniform float camera_z_near;
+
+void main() {
+#ifdef GLOW_GAUSSIAN_HORIZONTAL
+	vec2 pix_size = pixel_size;
+	pix_size *= 0.5; //reading from larger buffer, so use more samples
+	vec4 color = texture2DLod(source_color, uv_interp + vec2(0.0, 0.0) * pix_size, lod) * 0.174938;
+	color += texture2DLod(source_color, uv_interp + vec2(1.0, 0.0) * pix_size, lod) * 0.165569;
+	color += texture2DLod(source_color, uv_interp + vec2(2.0, 0.0) * pix_size, lod) * 0.140367;
+	color += texture2DLod(source_color, uv_interp + vec2(3.0, 0.0) * pix_size, lod) * 0.106595;
+	color += texture2DLod(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size, lod) * 0.165569;
+	color += texture2DLod(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size, lod) * 0.140367;
+	color += texture2DLod(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size, lod) * 0.106595;
+	color *= glow_strength;
+	gl_FragColor = color;
+#endif
+
+#ifdef GLOW_GAUSSIAN_VERTICAL
+	vec4 color = texture2DLod(source_color, uv_interp + vec2(0.0, 0.0) * pixel_size, lod) * 0.288713;
+	color += texture2DLod(source_color, uv_interp + vec2(0.0, 1.0) * pixel_size, lod) * 0.233062;
+	color += texture2DLod(source_color, uv_interp + vec2(0.0, 2.0) * pixel_size, lod) * 0.122581;
+	color += texture2DLod(source_color, uv_interp + vec2(0.0, -1.0) * pixel_size, lod) * 0.233062;
+	color += texture2DLod(source_color, uv_interp + vec2(0.0, -2.0) * pixel_size, lod) * 0.122581;
+	color *= glow_strength;
+	gl_FragColor = color;
+#endif
+
+#ifndef USE_GLES_OVER_GL
+#if defined(DOF_FAR_BLUR) || defined(DOF_NEAR_BLUR)
+
+#ifdef DOF_QUALITY_LOW
+	const int dof_kernel_size = 5;
+	const int dof_kernel_from = 2;
+	float dof_kernel[5];
+	dof_kernel[0] = 0.153388;
+	dof_kernel[1] = 0.221461;
+	dof_kernel[2] = 0.250301;
+	dof_kernel[3] = 0.221461;
+	dof_kernel[4] = 0.153388;
+#endif
+
+#ifdef DOF_QUALITY_MEDIUM
+	const int dof_kernel_size = 11;
+	const int dof_kernel_from = 5;
+	float dof_kernel[11];
+	dof_kernel[0] = 0.055037;
+	dof_kernel[1] = 0.072806;
+	dof_kernel[2] = 0.090506;
+	dof_kernel[3] = 0.105726;
+	dof_kernel[4] = 0.116061;
+	dof_kernel[5] = 0.119726;
+	dof_kernel[6] = 0.116061;
+	dof_kernel[7] = 0.105726;
+	dof_kernel[8] = 0.090506;
+	dof_kernel[9] = 0.072806;
+	dof_kernel[10] = 0.055037;
+#endif
+
+#ifdef DOF_QUALITY_HIGH
+	const int dof_kernel_size = 21;
+	const int dof_kernel_from = 10;
+	float dof_kernel[21];
+	dof_kernel[0] = 0.028174;
+	dof_kernel[1] = 0.032676;
+	dof_kernel[2] = 0.037311;
+	dof_kernel[3] = 0.041944;
+	dof_kernel[4] = 0.046421;
+	dof_kernel[5] = 0.050582;
+	dof_kernel[6] = 0.054261;
+	dof_kernel[7] = 0.057307;
+	dof_kernel[8] = 0.059587;
+	dof_kernel[9] = 0.060998;
+	dof_kernel[10] = 0.061476;
+	dof_kernel[11] = 0.060998;
+	dof_kernel[12] = 0.059587;
+	dof_kernel[13] = 0.057307;
+	dof_kernel[14] = 0.054261;
+	dof_kernel[15] = 0.050582;
+	dof_kernel[16] = 0.046421;
+	dof_kernel[17] = 0.041944;
+	dof_kernel[18] = 0.037311;
+	dof_kernel[19] = 0.032676;
+	dof_kernel[20] = 0.028174;
+#endif
+#endif
+#endif //!USE_GLES_OVER_GL
+
+#ifdef DOF_FAR_BLUR
+
+	vec4 color_accum = vec4(0.0);
+
+	float depth = texture2DLod(dof_source_depth, uv_interp, 0.0).r;
+	depth = depth * 2.0 - 1.0;
+#ifdef USE_ORTHOGONAL_PROJECTION
+	depth = ((depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
+#else
+	depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+#endif
+
+	float amount = smoothstep(dof_begin, dof_end, depth);
+	float k_accum = 0.0;
+
+	for (int i = 0; i < dof_kernel_size; i++) {
+		int int_ofs = i - dof_kernel_from;
+		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * amount * dof_radius;
+
+		float tap_k = dof_kernel[i];
+
+		float tap_depth = texture2D(dof_source_depth, tap_uv, 0.0).r;
+		tap_depth = tap_depth * 2.0 - 1.0;
+#ifdef USE_ORTHOGONAL_PROJECTION
+		tap_depth = ((tap_depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
+#else
+		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
+#endif
+		float tap_amount = int_ofs == 0 ? 1.0 : smoothstep(dof_begin, dof_end, tap_depth);
+		tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
+
+		vec4 tap_color = texture2DLod(source_color, tap_uv, 0.0) * tap_k;
+
+		k_accum += tap_k * tap_amount;
+		color_accum += tap_color * tap_amount;
+	}
+
+	if (k_accum > 0.0) {
+		color_accum /= k_accum;
+	}
+
+	gl_FragColor = color_accum; ///k_accum;
+
+#endif
+
+#ifdef DOF_NEAR_BLUR
+
+	vec4 color_accum = vec4(0.0);
+
+	float max_accum = 0.0;
+
+	for (int i = 0; i < dof_kernel_size; i++) {
+		int int_ofs = i - dof_kernel_from;
+		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * dof_radius;
+		float ofs_influence = max(0.0, 1.0 - abs(float(int_ofs)) / float(dof_kernel_from));
+
+		float tap_k = dof_kernel[i];
+
+		vec4 tap_color = texture2DLod(source_color, tap_uv, 0.0);
+
+		float tap_depth = texture2D(dof_source_depth, tap_uv, 0.0).r;
+		tap_depth = tap_depth * 2.0 - 1.0;
+#ifdef USE_ORTHOGONAL_PROJECTION
+		tap_depth = ((tap_depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
+#else
+		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
+#endif
+		float tap_amount = 1.0 - smoothstep(dof_end, dof_begin, tap_depth);
+		tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
+
+#ifdef DOF_NEAR_FIRST_TAP
+
+		tap_color.a = 1.0 - smoothstep(dof_end, dof_begin, tap_depth);
+
+#endif
+
+		max_accum = max(max_accum, tap_amount * ofs_influence);
+
+		color_accum += tap_color * tap_k;
+	}
+
+	color_accum.a = max(color_accum.a, sqrt(max_accum));
+
+	gl_FragColor = color_accum;
+
+#endif
+
+#ifdef GLOW_FIRST_PASS
+
+	float luminance = max(gl_FragColor.r, max(gl_FragColor.g, gl_FragColor.b));
+	float feedback = max(smoothstep(glow_hdr_threshold, glow_hdr_threshold + glow_hdr_scale, luminance), glow_bloom);
+
+	gl_FragColor = min(gl_FragColor * feedback, vec4(luminance_cap));
+
+#endif
+}
diff --git a/drivers/opengl/shaders/lens_distorted.glsl b/drivers/opengl/shaders/lens_distorted.glsl
new file mode 100644
index 0000000000..d568006ccc
--- /dev/null
+++ b/drivers/opengl/shaders/lens_distorted.glsl
@@ -0,0 +1,84 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute highp vec2 vertex; // attrib:0
+/* clang-format on */
+
+uniform vec2 offset;
+uniform vec2 scale;
+
+varying vec2 uv_interp;
+
+void main() {
+	uv_interp = vertex.xy * 2.0 - 1.0;
+
+	vec2 v = vertex.xy * scale + offset;
+	gl_Position = vec4(v, 0.0, 1.0);
+}
+
+/* clang-format off */
+[fragment]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+uniform sampler2D source; //texunit:0
+/* clang-format on */
+
+uniform vec2 eye_center;
+uniform float k1;
+uniform float k2;
+uniform float upscale;
+uniform float aspect_ratio;
+
+varying vec2 uv_interp;
+
+void main() {
+	vec2 coords = uv_interp;
+	vec2 offset = coords - eye_center;
+
+	// take aspect ratio into account
+	offset.y /= aspect_ratio;
+
+	// distort
+	vec2 offset_sq = offset * offset;
+	float radius_sq = offset_sq.x + offset_sq.y;
+	float radius_s4 = radius_sq * radius_sq;
+	float distortion_scale = 1.0 + (k1 * radius_sq) + (k2 * radius_s4);
+	offset *= distortion_scale;
+
+	// reapply aspect ratio
+	offset.y *= aspect_ratio;
+
+	// add our eye center back in
+	coords = offset + eye_center;
+	coords /= upscale;
+
+	// and check our color
+	if (coords.x < -1.0 || coords.y < -1.0 || coords.x > 1.0 || coords.y > 1.0) {
+		gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+	} else {
+		coords = (coords + vec2(1.0)) / vec2(2.0);
+		gl_FragColor = texture2D(source, coords);
+	}
+}
diff --git a/drivers/opengl/shaders/scene.glsl b/drivers/opengl/shaders/scene.glsl
new file mode 100644
index 0000000000..ba3a81a532
--- /dev/null
+++ b/drivers/opengl/shaders/scene.glsl
@@ -0,0 +1,2176 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+/* clang-format on */
+#include "stdlib.glsl"
+/* clang-format off */
+
+#define SHADER_IS_SRGB true
+
+#define M_PI 3.14159265359
+
+//
+// attributes
+//
+
+attribute highp vec4 vertex_attrib; // attrib:0
+/* clang-format on */
+attribute vec3 normal_attrib; // attrib:1
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+attribute vec4 tangent_attrib; // attrib:2
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+attribute vec4 color_attrib; // attrib:3
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+attribute vec2 uv_attrib; // attrib:4
+#endif
+
+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)
+attribute vec2 uv2_attrib; // attrib:5
+#endif
+
+#ifdef USE_SKELETON
+
+#ifdef USE_SKELETON_SOFTWARE
+
+attribute highp vec4 bone_transform_row_0; // attrib:13
+attribute highp vec4 bone_transform_row_1; // attrib:14
+attribute highp vec4 bone_transform_row_2; // attrib:15
+
+#else
+
+attribute vec4 bone_ids; // attrib:6
+attribute highp vec4 bone_weights; // attrib:7
+
+uniform highp sampler2D bone_transforms; // texunit:-1
+uniform ivec2 skeleton_texture_size;
+
+#endif
+
+#endif
+
+#ifdef USE_INSTANCING
+
+attribute highp vec4 instance_xform_row_0; // attrib:8
+attribute highp vec4 instance_xform_row_1; // attrib:9
+attribute highp vec4 instance_xform_row_2; // attrib:10
+
+attribute highp vec4 instance_color; // attrib:11
+attribute highp vec4 instance_custom_data; // attrib:12
+
+#endif
+
+//
+// uniforms
+//
+
+uniform highp mat4 camera_matrix;
+uniform highp mat4 camera_inverse_matrix;
+uniform highp mat4 projection_matrix;
+uniform highp mat4 projection_inverse_matrix;
+
+uniform highp mat4 world_transform;
+
+uniform highp float time;
+
+uniform highp vec2 viewport_size;
+
+#ifdef RENDER_DEPTH
+uniform float light_bias;
+uniform float light_normal_bias;
+#endif
+
+//
+// varyings
+//
+
+#if defined(RENDER_DEPTH) && defined(USE_RGBA_SHADOWS)
+varying highp vec4 position_interp;
+#endif
+
+varying highp vec3 vertex_interp;
+varying vec3 normal_interp;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+varying vec3 tangent_interp;
+varying vec3 binormal_interp;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+varying vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+varying vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)
+varying vec2 uv2_interp;
+#endif
+
+/* clang-format off */
+
+VERTEX_SHADER_GLOBALS
+
+/* clang-format on */
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+varying highp float dp_clip;
+uniform highp float shadow_dual_paraboloid_render_zfar;
+uniform highp float shadow_dual_paraboloid_render_side;
+
+#endif
+
+#if defined(USE_SHADOW) && defined(USE_LIGHTING)
+
+uniform highp mat4 light_shadow_matrix;
+varying highp vec4 shadow_coord;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+uniform highp mat4 light_shadow_matrix2;
+varying highp vec4 shadow_coord2;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+
+uniform highp mat4 light_shadow_matrix3;
+uniform highp mat4 light_shadow_matrix4;
+varying highp vec4 shadow_coord3;
+varying highp vec4 shadow_coord4;
+
+#endif
+
+#endif
+
+#if defined(USE_VERTEX_LIGHTING) && defined(USE_LIGHTING)
+
+varying highp vec3 diffuse_interp;
+varying highp vec3 specular_interp;
+
+// general for all lights
+uniform highp vec4 light_color;
+uniform highp vec4 shadow_color;
+uniform highp float light_specular;
+
+// directional
+uniform highp vec3 light_direction;
+
+// omni
+uniform highp vec3 light_position;
+
+uniform highp float light_range;
+uniform highp float light_attenuation;
+
+// spot
+uniform highp float light_spot_attenuation;
+uniform highp float light_spot_range;
+uniform highp float light_spot_angle;
+
+void light_compute(
+		vec3 N,
+		vec3 L,
+		vec3 V,
+		vec3 light_color,
+		vec3 attenuation,
+		float roughness) {
+//this makes lights behave closer to linear, but then addition of lights looks bad
+//better left disabled
+
+//#define SRGB_APPROX(m_var) m_var = pow(m_var,0.4545454545);
+/*
+#define SRGB_APPROX(m_var) {\
+	float S1 = sqrt(m_var);\
+	float S2 = sqrt(S1);\
+	float S3 = sqrt(S2);\
+	m_var = 0.662002687 * S1 + 0.684122060 * S2 - 0.323583601 * S3 - 0.0225411470 * m_var;\
+	}
+*/
+#define SRGB_APPROX(m_var)
+
+	float NdotL = dot(N, L);
+	float cNdotL = max(NdotL, 0.0); // clamped NdotL
+	float NdotV = dot(N, V);
+	float cNdotV = max(NdotV, 0.0);
+
+#if defined(DIFFUSE_OREN_NAYAR)
+	vec3 diffuse_brdf_NL;
+#else
+	float diffuse_brdf_NL; // BRDF times N.L for calculating diffuse radiance
+#endif
+
+#if defined(DIFFUSE_LAMBERT_WRAP)
+	// energy conserving lambert wrap shader
+	diffuse_brdf_NL = max(0.0, (NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
+
+#elif defined(DIFFUSE_OREN_NAYAR)
+
+	{
+		// see http://mimosa-pudica.net/improved-oren-nayar.html
+		float LdotV = dot(L, V);
+
+		float s = LdotV - NdotL * NdotV;
+		float t = mix(1.0, max(NdotL, NdotV), step(0.0, s));
+
+		float sigma2 = roughness * roughness; // TODO: this needs checking
+		vec3 A = 1.0 + sigma2 * (-0.5 / (sigma2 + 0.33) + 0.17 * diffuse_color / (sigma2 + 0.13));
+		float B = 0.45 * sigma2 / (sigma2 + 0.09);
+
+		diffuse_brdf_NL = cNdotL * (A + vec3(B) * s / t) * (1.0 / M_PI);
+	}
+#else
+	// lambert by default for everything else
+	diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
+#endif
+
+	SRGB_APPROX(diffuse_brdf_NL)
+
+	diffuse_interp += light_color * diffuse_brdf_NL * attenuation;
+
+	if (roughness > 0.0) {
+		// D
+		float specular_brdf_NL = 0.0;
+
+#if !defined(SPECULAR_DISABLED)
+		//normalized blinn always unless disabled
+		vec3 H = normalize(V + L);
+		float cNdotH = max(dot(N, H), 0.0);
+		float shininess = exp2(15.0 * (1.0 - roughness) + 1.0) * 0.25;
+		float blinn = pow(cNdotH, shininess) * cNdotL;
+		blinn *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
+		specular_brdf_NL = blinn;
+#endif
+
+		SRGB_APPROX(specular_brdf_NL)
+		specular_interp += specular_brdf_NL * light_color * attenuation * (1.0 / M_PI);
+	}
+}
+
+#endif
+
+#ifdef USE_VERTEX_LIGHTING
+
+#ifdef USE_REFLECTION_PROBE1
+
+uniform highp mat4 refprobe1_local_matrix;
+varying mediump vec4 refprobe1_reflection_normal_blend;
+uniform highp vec3 refprobe1_box_extents;
+
+#ifndef USE_LIGHTMAP
+varying mediump vec3 refprobe1_ambient_normal;
+#endif
+
+#endif //reflection probe1
+
+#ifdef USE_REFLECTION_PROBE2
+
+uniform highp mat4 refprobe2_local_matrix;
+varying mediump vec4 refprobe2_reflection_normal_blend;
+uniform highp vec3 refprobe2_box_extents;
+
+#ifndef USE_LIGHTMAP
+varying mediump vec3 refprobe2_ambient_normal;
+#endif
+
+#endif //reflection probe2
+
+#endif //vertex lighting for refprobes
+
+#if defined(FOG_DEPTH_ENABLED) || defined(FOG_HEIGHT_ENABLED)
+
+varying vec4 fog_interp;
+
+uniform mediump vec4 fog_color_base;
+#ifdef LIGHT_MODE_DIRECTIONAL
+uniform mediump vec4 fog_sun_color_amount;
+#endif
+
+uniform bool fog_transmit_enabled;
+uniform mediump float fog_transmit_curve;
+
+#ifdef FOG_DEPTH_ENABLED
+uniform highp float fog_depth_begin;
+uniform mediump float fog_depth_curve;
+uniform mediump float fog_max_distance;
+#endif
+
+#ifdef FOG_HEIGHT_ENABLED
+uniform highp float fog_height_min;
+uniform highp float fog_height_max;
+uniform mediump float fog_height_curve;
+#endif
+
+#endif //fog
+
+void main() {
+	highp vec4 vertex = vertex_attrib;
+
+	mat4 world_matrix = world_transform;
+
+#ifdef USE_INSTANCING
+	{
+		highp mat4 m = mat4(
+				instance_xform_row_0,
+				instance_xform_row_1,
+				instance_xform_row_2,
+				vec4(0.0, 0.0, 0.0, 1.0));
+		world_matrix = world_matrix * transpose(m);
+	}
+
+#endif
+
+	vec3 normal = normal_attrib;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+	vec3 tangent = tangent_attrib.xyz;
+	float binormalf = tangent_attrib.a;
+	vec3 binormal = normalize(cross(normal, tangent) * binormalf);
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+	color_interp = color_attrib;
+#ifdef USE_INSTANCING
+	color_interp *= instance_color;
+#endif
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+	uv_interp = uv_attrib;
+#endif
+
+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)
+	uv2_interp = uv2_attrib;
+#endif
+
+#if defined(OVERRIDE_POSITION)
+	highp vec4 position;
+#endif
+
+#if !defined(SKIP_TRANSFORM_USED) && defined(VERTEX_WORLD_COORDS_USED)
+	vertex = world_matrix * vertex;
+	normal = normalize((world_matrix * vec4(normal, 0.0)).xyz);
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+
+	tangent = normalize((world_matrix * vec4(tangent, 0.0)).xyz);
+	binormal = normalize((world_matrix * vec4(binormal, 0.0)).xyz);
+#endif
+#endif
+
+#ifdef USE_SKELETON
+
+	highp mat4 bone_transform = mat4(0.0);
+
+#ifdef USE_SKELETON_SOFTWARE
+	// passing the transform as attributes
+
+	bone_transform[0] = vec4(bone_transform_row_0.x, bone_transform_row_1.x, bone_transform_row_2.x, 0.0);
+	bone_transform[1] = vec4(bone_transform_row_0.y, bone_transform_row_1.y, bone_transform_row_2.y, 0.0);
+	bone_transform[2] = vec4(bone_transform_row_0.z, bone_transform_row_1.z, bone_transform_row_2.z, 0.0);
+	bone_transform[3] = vec4(bone_transform_row_0.w, bone_transform_row_1.w, bone_transform_row_2.w, 1.0);
+
+#else
+	// look up transform from the "pose texture"
+	{
+		for (int i = 0; i < 4; i++) {
+			ivec2 tex_ofs = ivec2(int(bone_ids[i]) * 3, 0);
+
+			highp mat4 b = mat4(
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(0, 0)),
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(1, 0)),
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(2, 0)),
+					vec4(0.0, 0.0, 0.0, 1.0));
+
+			bone_transform += transpose(b) * bone_weights[i];
+		}
+	}
+
+#endif
+
+	world_matrix = world_matrix * bone_transform;
+
+#endif
+
+#ifdef USE_INSTANCING
+	vec4 instance_custom = instance_custom_data;
+#else
+	vec4 instance_custom = vec4(0.0);
+
+#endif
+
+	mat4 local_projection_matrix = projection_matrix;
+
+	mat4 modelview = camera_inverse_matrix * world_matrix;
+	float roughness = 1.0;
+
+#define projection_matrix local_projection_matrix
+#define world_transform world_matrix
+
+	float point_size = 1.0;
+
+	{
+		/* clang-format off */
+
+VERTEX_SHADER_CODE
+
+		/* clang-format on */
+	}
+
+	gl_PointSize = point_size;
+	vec4 outvec = vertex;
+
+	// use local coordinates
+#if !defined(SKIP_TRANSFORM_USED) && !defined(VERTEX_WORLD_COORDS_USED)
+	vertex = modelview * vertex;
+	normal = normalize((modelview * vec4(normal, 0.0)).xyz);
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+	tangent = normalize((modelview * vec4(tangent, 0.0)).xyz);
+	binormal = normalize((modelview * vec4(binormal, 0.0)).xyz);
+#endif
+#endif
+
+#if !defined(SKIP_TRANSFORM_USED) && defined(VERTEX_WORLD_COORDS_USED)
+	vertex = camera_inverse_matrix * vertex;
+	normal = normalize((camera_inverse_matrix * vec4(normal, 0.0)).xyz);
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+	tangent = normalize((camera_inverse_matrix * vec4(tangent, 0.0)).xyz);
+	binormal = normalize((camera_inverse_matrix * vec4(binormal, 0.0)).xyz);
+#endif
+#endif
+
+	vertex_interp = vertex.xyz;
+	normal_interp = normal;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+	tangent_interp = tangent;
+	binormal_interp = binormal;
+#endif
+
+#ifdef RENDER_DEPTH
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	vertex_interp.z *= shadow_dual_paraboloid_render_side;
+	normal_interp.z *= shadow_dual_paraboloid_render_side;
+
+	dp_clip = vertex_interp.z; //this attempts to avoid noise caused by objects sent to the other parabolloid side due to bias
+
+	//for dual paraboloid shadow mapping, this is the fastest but least correct way, as it curves straight edges
+
+	highp vec3 vtx = vertex_interp + normalize(vertex_interp) * light_bias;
+	highp float distance = length(vtx);
+	vtx = normalize(vtx);
+	vtx.xy /= 1.0 - vtx.z;
+	vtx.z = (distance / shadow_dual_paraboloid_render_zfar);
+	vtx.z = vtx.z * 2.0 - 1.0;
+
+	vertex_interp = vtx;
+
+#else
+	float z_ofs = light_bias;
+	z_ofs += (1.0 - abs(normal_interp.z)) * light_normal_bias;
+
+	vertex_interp.z -= z_ofs;
+#endif //dual parabolloid
+
+#endif //depth
+
+//vertex lighting
+#if defined(USE_VERTEX_LIGHTING) && defined(USE_LIGHTING)
+	//vertex shaded version of lighting (more limited)
+	vec3 L;
+	vec3 light_att;
+
+#ifdef LIGHT_MODE_OMNI
+	vec3 light_vec = light_position - vertex_interp;
+	float light_length = length(light_vec);
+
+	float normalized_distance = light_length / light_range;
+
+	if (normalized_distance < 1.0) {
+		float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation);
+
+		vec3 attenuation = vec3(omni_attenuation);
+		light_att = vec3(omni_attenuation);
+	} else {
+		light_att = vec3(0.0);
+	}
+
+	L = normalize(light_vec);
+
+#endif
+
+#ifdef LIGHT_MODE_SPOT
+
+	vec3 light_rel_vec = light_position - vertex_interp;
+	float light_length = length(light_rel_vec);
+	float normalized_distance = light_length / light_range;
+
+	if (normalized_distance < 1.0) {
+		float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation);
+		vec3 spot_dir = light_direction;
+
+		float spot_cutoff = light_spot_angle;
+
+		float angle = dot(-normalize(light_rel_vec), spot_dir);
+
+		if (angle > spot_cutoff) {
+			float scos = max(angle, spot_cutoff);
+			float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));
+
+			spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);
+
+			light_att = vec3(spot_attenuation);
+		} else {
+			light_att = vec3(0.0);
+		}
+	} else {
+		light_att = vec3(0.0);
+	}
+
+	L = normalize(light_rel_vec);
+
+#endif
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+	vec3 light_vec = -light_direction;
+	light_att = vec3(1.0); //no base attenuation
+	L = normalize(light_vec);
+#endif
+
+	diffuse_interp = vec3(0.0);
+	specular_interp = vec3(0.0);
+	light_compute(normal_interp, L, -normalize(vertex_interp), light_color.rgb, light_att, roughness);
+
+#endif
+
+//shadows (for both vertex and fragment)
+#if defined(USE_SHADOW) && defined(USE_LIGHTING)
+
+	vec4 vi4 = vec4(vertex_interp, 1.0);
+	shadow_coord = light_shadow_matrix * vi4;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+	shadow_coord2 = light_shadow_matrix2 * vi4;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+	shadow_coord3 = light_shadow_matrix3 * vi4;
+	shadow_coord4 = light_shadow_matrix4 * vi4;
+
+#endif
+
+#endif //use shadow and use lighting
+
+#ifdef USE_VERTEX_LIGHTING
+
+#ifdef USE_REFLECTION_PROBE1
+	{
+		vec3 ref_normal = normalize(reflect(vertex_interp, normal_interp));
+		vec3 local_pos = (refprobe1_local_matrix * vec4(vertex_interp, 1.0)).xyz;
+		vec3 inner_pos = abs(local_pos / refprobe1_box_extents);
+		float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));
+
+		{
+			vec3 local_ref_vec = (refprobe1_local_matrix * vec4(ref_normal, 0.0)).xyz;
+			refprobe1_reflection_normal_blend.xyz = local_ref_vec;
+			refprobe1_reflection_normal_blend.a = blend;
+		}
+#ifndef USE_LIGHTMAP
+
+		refprobe1_ambient_normal = (refprobe1_local_matrix * vec4(normal_interp, 0.0)).xyz;
+#endif
+	}
+
+#endif //USE_REFLECTION_PROBE1
+
+#ifdef USE_REFLECTION_PROBE2
+	{
+		vec3 ref_normal = normalize(reflect(vertex_interp, normal_interp));
+		vec3 local_pos = (refprobe2_local_matrix * vec4(vertex_interp, 1.0)).xyz;
+		vec3 inner_pos = abs(local_pos / refprobe2_box_extents);
+		float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));
+
+		{
+			vec3 local_ref_vec = (refprobe2_local_matrix * vec4(ref_normal, 0.0)).xyz;
+			refprobe2_reflection_normal_blend.xyz = local_ref_vec;
+			refprobe2_reflection_normal_blend.a = blend;
+		}
+#ifndef USE_LIGHTMAP
+
+		refprobe2_ambient_normal = (refprobe2_local_matrix * vec4(normal_interp, 0.0)).xyz;
+#endif
+	}
+
+#endif //USE_REFLECTION_PROBE2
+
+#if defined(FOG_DEPTH_ENABLED) || defined(FOG_HEIGHT_ENABLED)
+
+	float fog_amount = 0.0;
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+
+	vec3 fog_color = mix(fog_color_base.rgb, fog_sun_color_amount.rgb, fog_sun_color_amount.a * pow(max(dot(normalize(vertex_interp), light_direction), 0.0), 8.0));
+#else
+	vec3 fog_color = fog_color_base.rgb;
+#endif
+
+#ifdef FOG_DEPTH_ENABLED
+
+	{
+		float fog_z = smoothstep(fog_depth_begin, fog_max_distance, length(vertex));
+
+		fog_amount = pow(fog_z, fog_depth_curve) * fog_color_base.a;
+	}
+#endif
+
+#ifdef FOG_HEIGHT_ENABLED
+	{
+		float y = (camera_matrix * vec4(vertex_interp, 1.0)).y;
+		fog_amount = max(fog_amount, pow(smoothstep(fog_height_min, fog_height_max, y), fog_height_curve));
+	}
+#endif
+	fog_interp = vec4(fog_color, fog_amount);
+
+#endif //fog
+
+#endif //use vertex lighting
+
+#if defined(OVERRIDE_POSITION)
+	gl_Position = position;
+#else
+	gl_Position = projection_matrix * vec4(vertex_interp, 1.0);
+#endif
+
+#if defined(RENDER_DEPTH) && defined(USE_RGBA_SHADOWS)
+	position_interp = gl_Position;
+#endif
+}
+
+/* clang-format off */
+[fragment]
+
+// texture2DLodEXT and textureCubeLodEXT are fragment shader specific.
+// Do not copy these defines in the vertex section.
+#ifndef USE_GLES_OVER_GL
+#ifdef GL_EXT_shader_texture_lod
+#extension GL_EXT_shader_texture_lod : enable
+#define texture2DLod(img, coord, lod) texture2DLodEXT(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCubeLodEXT(img, coord, lod)
+#endif
+#endif // !USE_GLES_OVER_GL
+
+#ifdef GL_ARB_shader_texture_lod
+#extension GL_ARB_shader_texture_lod : enable
+#endif
+
+#if !defined(GL_EXT_shader_texture_lod) && !defined(GL_ARB_shader_texture_lod)
+#define texture2DLod(img, coord, lod) texture2D(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCube(img, coord, lod)
+#endif
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+#include "stdlib.glsl"
+
+#define M_PI 3.14159265359
+#define SHADER_IS_SRGB true
+
+//
+// uniforms
+//
+
+uniform highp mat4 camera_matrix;
+/* clang-format on */
+uniform highp mat4 camera_inverse_matrix;
+uniform highp mat4 projection_matrix;
+uniform highp mat4 projection_inverse_matrix;
+
+uniform highp mat4 world_transform;
+
+uniform highp float time;
+
+uniform highp vec2 viewport_size;
+
+#if defined(SCREEN_UV_USED)
+uniform vec2 screen_pixel_size;
+#endif
+
+#if defined(SCREEN_TEXTURE_USED)
+uniform highp sampler2D screen_texture; //texunit:-4
+#endif
+#if defined(DEPTH_TEXTURE_USED)
+uniform highp sampler2D depth_texture; //texunit:-4
+#endif
+
+#ifdef USE_REFLECTION_PROBE1
+
+#ifdef USE_VERTEX_LIGHTING
+
+varying mediump vec4 refprobe1_reflection_normal_blend;
+#ifndef USE_LIGHTMAP
+varying mediump vec3 refprobe1_ambient_normal;
+#endif
+
+#else
+
+uniform bool refprobe1_use_box_project;
+uniform highp vec3 refprobe1_box_extents;
+uniform vec3 refprobe1_box_offset;
+uniform highp mat4 refprobe1_local_matrix;
+
+#endif //use vertex lighting
+
+uniform bool refprobe1_exterior;
+
+uniform highp samplerCube reflection_probe1; //texunit:-5
+
+uniform float refprobe1_intensity;
+uniform vec4 refprobe1_ambient;
+
+#endif //USE_REFLECTION_PROBE1
+
+#ifdef USE_REFLECTION_PROBE2
+
+#ifdef USE_VERTEX_LIGHTING
+
+varying mediump vec4 refprobe2_reflection_normal_blend;
+#ifndef USE_LIGHTMAP
+varying mediump vec3 refprobe2_ambient_normal;
+#endif
+
+#else
+
+uniform bool refprobe2_use_box_project;
+uniform highp vec3 refprobe2_box_extents;
+uniform vec3 refprobe2_box_offset;
+uniform highp mat4 refprobe2_local_matrix;
+
+#endif //use vertex lighting
+
+uniform bool refprobe2_exterior;
+
+uniform highp samplerCube reflection_probe2; //texunit:-6
+
+uniform float refprobe2_intensity;
+uniform vec4 refprobe2_ambient;
+
+#endif //USE_REFLECTION_PROBE2
+
+#define RADIANCE_MAX_LOD 6.0
+
+#if defined(USE_REFLECTION_PROBE1) || defined(USE_REFLECTION_PROBE2)
+
+void reflection_process(samplerCube reflection_map,
+#ifdef USE_VERTEX_LIGHTING
+		vec3 ref_normal,
+#ifndef USE_LIGHTMAP
+		vec3 amb_normal,
+#endif
+		float ref_blend,
+
+#else //no vertex lighting
+		vec3 normal, vec3 vertex,
+		mat4 local_matrix,
+		bool use_box_project, vec3 box_extents, vec3 box_offset,
+#endif //vertex lighting
+		bool exterior, float intensity, vec4 ref_ambient, float roughness, vec3 ambient, vec3 skybox, inout highp vec4 reflection_accum, inout highp vec4 ambient_accum) {
+	vec4 reflection;
+
+#ifdef USE_VERTEX_LIGHTING
+
+	reflection.rgb = textureCubeLod(reflection_map, ref_normal, roughness * RADIANCE_MAX_LOD).rgb;
+
+	float blend = ref_blend; //crappier blend formula for vertex
+	blend *= blend;
+	blend = max(0.0, 1.0 - blend);
+
+#else //fragment lighting
+
+	vec3 local_pos = (local_matrix * vec4(vertex, 1.0)).xyz;
+
+	if (any(greaterThan(abs(local_pos), box_extents))) { //out of the reflection box
+		return;
+	}
+
+	vec3 inner_pos = abs(local_pos / box_extents);
+	float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));
+	blend = mix(length(inner_pos), blend, blend);
+	blend *= blend;
+	blend = max(0.0, 1.0 - blend);
+
+	//reflect and make local
+	vec3 ref_normal = normalize(reflect(vertex, normal));
+	ref_normal = (local_matrix * vec4(ref_normal, 0.0)).xyz;
+
+	if (use_box_project) { //box project
+
+		vec3 nrdir = normalize(ref_normal);
+		vec3 rbmax = (box_extents - local_pos) / nrdir;
+		vec3 rbmin = (-box_extents - local_pos) / nrdir;
+
+		vec3 rbminmax = mix(rbmin, rbmax, vec3(greaterThan(nrdir, vec3(0.0, 0.0, 0.0))));
+
+		float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);
+		vec3 posonbox = local_pos + nrdir * fa;
+		ref_normal = posonbox - box_offset.xyz;
+	}
+
+	reflection.rgb = textureCubeLod(reflection_map, ref_normal, roughness * RADIANCE_MAX_LOD).rgb;
+#endif
+
+	if (exterior) {
+		reflection.rgb = mix(skybox, reflection.rgb, blend);
+	}
+	reflection.rgb *= intensity;
+	reflection.a = blend;
+	reflection.rgb *= blend;
+
+	reflection_accum += reflection;
+
+#ifndef USE_LIGHTMAP
+
+	vec4 ambient_out;
+#ifndef USE_VERTEX_LIGHTING
+
+	vec3 amb_normal = (local_matrix * vec4(normal, 0.0)).xyz;
+#endif
+
+	ambient_out.rgb = textureCubeLod(reflection_map, amb_normal, RADIANCE_MAX_LOD).rgb;
+	ambient_out.rgb = mix(ref_ambient.rgb, ambient_out.rgb, ref_ambient.a);
+	if (exterior) {
+		ambient_out.rgb = mix(ambient, ambient_out.rgb, blend);
+	}
+
+	ambient_out.a = blend;
+	ambient_out.rgb *= blend;
+	ambient_accum += ambient_out;
+
+#endif
+}
+
+#endif //use refprobe 1 or 2
+
+#ifdef USE_LIGHTMAP
+uniform mediump sampler2D lightmap; //texunit:-4
+uniform mediump float lightmap_energy;
+#endif
+
+#ifdef USE_LIGHTMAP_CAPTURE
+uniform mediump vec4[12] lightmap_captures;
+uniform bool lightmap_capture_sky;
+
+#endif
+
+#ifdef USE_RADIANCE_MAP
+
+uniform samplerCube radiance_map; // texunit:-2
+
+uniform mat4 radiance_inverse_xform;
+
+#endif
+
+uniform vec4 bg_color;
+uniform float bg_energy;
+
+uniform float ambient_sky_contribution;
+uniform vec4 ambient_color;
+uniform float ambient_energy;
+
+#ifdef USE_LIGHTING
+
+uniform highp vec4 shadow_color;
+
+#ifdef USE_VERTEX_LIGHTING
+
+//get from vertex
+varying highp vec3 diffuse_interp;
+varying highp vec3 specular_interp;
+
+uniform highp vec3 light_direction; //may be used by fog, so leave here
+
+#else
+//done in fragment
+// general for all lights
+uniform highp vec4 light_color;
+
+uniform highp float light_specular;
+
+// directional
+uniform highp vec3 light_direction;
+// omni
+uniform highp vec3 light_position;
+
+uniform highp float light_attenuation;
+
+// spot
+uniform highp float light_spot_attenuation;
+uniform highp float light_spot_range;
+uniform highp float light_spot_angle;
+#endif
+
+//this is needed outside above if because dual paraboloid wants it
+uniform highp float light_range;
+
+#ifdef USE_SHADOW
+
+uniform highp vec2 shadow_pixel_size;
+
+#if defined(LIGHT_MODE_OMNI) || defined(LIGHT_MODE_SPOT)
+uniform highp sampler2D light_shadow_atlas; //texunit:-3
+#endif
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+uniform highp sampler2D light_directional_shadow; // texunit:-3
+uniform highp vec4 light_split_offsets;
+#endif
+
+varying highp vec4 shadow_coord;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+varying highp vec4 shadow_coord2;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+
+varying highp vec4 shadow_coord3;
+varying highp vec4 shadow_coord4;
+
+#endif
+
+uniform vec4 light_clamp;
+
+#endif // light shadow
+
+// directional shadow
+
+#endif
+
+//
+// varyings
+//
+
+#if defined(RENDER_DEPTH) && defined(USE_RGBA_SHADOWS)
+varying highp vec4 position_interp;
+#endif
+
+varying highp vec3 vertex_interp;
+varying vec3 normal_interp;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+varying vec3 tangent_interp;
+varying vec3 binormal_interp;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+varying vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+varying vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)
+varying vec2 uv2_interp;
+#endif
+
+varying vec3 view_interp;
+
+vec3 F0(float metallic, float specular, vec3 albedo) {
+	float dielectric = 0.16 * specular * specular;
+	// use albedo * metallic as colored specular reflectance at 0 angle for metallic materials;
+	// see https://google.github.io/filament/Filament.md.html
+	return mix(vec3(dielectric), albedo, vec3(metallic));
+}
+
+/* clang-format off */
+
+FRAGMENT_SHADER_GLOBALS
+
+/* clang-format on */
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+varying highp float dp_clip;
+
+#endif
+
+#ifdef USE_LIGHTING
+
+// This returns the G_GGX function divided by 2 cos_theta_m, where in practice cos_theta_m is either N.L or N.V.
+// We're dividing this factor off because the overall term we'll end up looks like
+// (see, for example, the first unnumbered equation in B. Burley, "Physically Based Shading at Disney", SIGGRAPH 2012):
+//
+//   F(L.V) D(N.H) G(N.L) G(N.V) / (4 N.L N.V)
+//
+// We're basically regouping this as
+//
+//   F(L.V) D(N.H) [G(N.L)/(2 N.L)] [G(N.V) / (2 N.V)]
+//
+// and thus, this function implements the [G(N.m)/(2 N.m)] part with m = L or V.
+//
+// The contents of the D and G (G1) functions (GGX) are taken from
+// E. Heitz, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs", J. Comp. Graph. Tech. 3 (2) (2014).
+// Eqns 71-72 and 85-86 (see also Eqns 43 and 80).
+
+/*
+float G_GGX_2cos(float cos_theta_m, float alpha) {
+	// Schlick's approximation
+	// C. Schlick, "An Inexpensive BRDF Model for Physically-based Rendering", Computer Graphics Forum. 13 (3): 233 (1994)
+	// Eq. (19), although see Heitz (2014) the about the problems with his derivation.
+	// It nevertheless approximates GGX well with k = alpha/2.
+	float k = 0.5 * alpha;
+	return 0.5 / (cos_theta_m * (1.0 - k) + k);
+
+	// float cos2 = cos_theta_m * cos_theta_m;
+	// float sin2 = (1.0 - cos2);
+	// return 1.0 / (cos_theta_m + sqrt(cos2 + alpha * alpha * sin2));
+}
+*/
+
+// This approximates G_GGX_2cos(cos_theta_l, alpha) * G_GGX_2cos(cos_theta_v, alpha)
+// See Filament docs, Specular G section.
+float V_GGX(float cos_theta_l, float cos_theta_v, float alpha) {
+	return 0.5 / mix(2.0 * cos_theta_l * cos_theta_v, cos_theta_l + cos_theta_v, alpha);
+}
+
+float D_GGX(float cos_theta_m, float alpha) {
+	float alpha2 = alpha * alpha;
+	float d = 1.0 + (alpha2 - 1.0) * cos_theta_m * cos_theta_m;
+	return alpha2 / (M_PI * d * d);
+}
+
+/*
+float G_GGX_anisotropic_2cos(float cos_theta_m, float alpha_x, float alpha_y, float cos_phi, float sin_phi) {
+	float cos2 = cos_theta_m * cos_theta_m;
+	float sin2 = (1.0 - cos2);
+	float s_x = alpha_x * cos_phi;
+	float s_y = alpha_y * sin_phi;
+	return 1.0 / max(cos_theta_m + sqrt(cos2 + (s_x * s_x + s_y * s_y) * sin2), 0.001);
+}
+*/
+
+// This approximates G_GGX_anisotropic_2cos(cos_theta_l, ...) * G_GGX_anisotropic_2cos(cos_theta_v, ...)
+// See Filament docs, Anisotropic specular BRDF section.
+float V_GGX_anisotropic(float alpha_x, float alpha_y, float TdotV, float TdotL, float BdotV, float BdotL, float NdotV, float NdotL) {
+	float Lambda_V = NdotL * length(vec3(alpha_x * TdotV, alpha_y * BdotV, NdotV));
+	float Lambda_L = NdotV * length(vec3(alpha_x * TdotL, alpha_y * BdotL, NdotL));
+	return 0.5 / (Lambda_V + Lambda_L);
+}
+
+float D_GGX_anisotropic(float cos_theta_m, float alpha_x, float alpha_y, float cos_phi, float sin_phi, float NdotH) {
+	float alpha2 = alpha_x * alpha_y;
+	highp vec3 v = vec3(alpha_y * cos_phi, alpha_x * sin_phi, alpha2 * NdotH);
+	highp float v2 = dot(v, v);
+	float w2 = alpha2 / v2;
+	float D = alpha2 * w2 * w2 * (1.0 / M_PI);
+	return D;
+
+	/* float cos2 = cos_theta_m * cos_theta_m;
+	float sin2 = (1.0 - cos2);
+	float r_x = cos_phi / alpha_x;
+	float r_y = sin_phi / alpha_y;
+	float d = cos2 + sin2 * (r_x * r_x + r_y * r_y);
+	return 1.0 / max(M_PI * alpha_x * alpha_y * d * d, 0.001); */
+}
+
+float SchlickFresnel(float u) {
+	float m = 1.0 - u;
+	float m2 = m * m;
+	return m2 * m2 * m; // pow(m,5)
+}
+
+float GTR1(float NdotH, float a) {
+	if (a >= 1.0)
+		return 1.0 / M_PI;
+	float a2 = a * a;
+	float t = 1.0 + (a2 - 1.0) * NdotH * NdotH;
+	return (a2 - 1.0) / (M_PI * log(a2) * t);
+}
+
+void light_compute(
+		vec3 N,
+		vec3 L,
+		vec3 V,
+		vec3 B,
+		vec3 T,
+		vec3 light_color,
+		vec3 attenuation,
+		vec3 diffuse_color,
+		vec3 transmission,
+		float specular_blob_intensity,
+		float roughness,
+		float metallic,
+		float specular,
+		float rim,
+		float rim_tint,
+		float clearcoat,
+		float clearcoat_gloss,
+		float anisotropy,
+		inout vec3 diffuse_light,
+		inout vec3 specular_light,
+		inout float alpha) {
+//this makes lights behave closer to linear, but then addition of lights looks bad
+//better left disabled
+
+//#define SRGB_APPROX(m_var) m_var = pow(m_var,0.4545454545);
+/*
+#define SRGB_APPROX(m_var) {\
+	float S1 = sqrt(m_var);\
+	float S2 = sqrt(S1);\
+	float S3 = sqrt(S2);\
+	m_var = 0.662002687 * S1 + 0.684122060 * S2 - 0.323583601 * S3 - 0.0225411470 * m_var;\
+	}
+*/
+#define SRGB_APPROX(m_var)
+
+#if defined(USE_LIGHT_SHADER_CODE)
+	// light is written by the light shader
+
+	vec3 normal = N;
+	vec3 albedo = diffuse_color;
+	vec3 light = L;
+	vec3 view = V;
+
+	/* clang-format off */
+
+LIGHT_SHADER_CODE
+
+	/* clang-format on */
+
+#else
+	float NdotL = dot(N, L);
+	float cNdotL = max(NdotL, 0.0); // clamped NdotL
+	float NdotV = dot(N, V);
+	float cNdotV = max(abs(NdotV), 1e-6);
+
+#if defined(DIFFUSE_BURLEY) || defined(SPECULAR_BLINN) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_USE_CLEARCOAT)
+	vec3 H = normalize(V + L);
+#endif
+
+#if defined(SPECULAR_BLINN) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_USE_CLEARCOAT)
+	float cNdotH = max(dot(N, H), 0.0);
+#endif
+
+#if defined(DIFFUSE_BURLEY) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_USE_CLEARCOAT)
+	float cLdotH = max(dot(L, H), 0.0);
+#endif
+
+	if (metallic < 1.0) {
+#if defined(DIFFUSE_OREN_NAYAR)
+		vec3 diffuse_brdf_NL;
+#else
+		float diffuse_brdf_NL; // BRDF times N.L for calculating diffuse radiance
+#endif
+
+#if defined(DIFFUSE_LAMBERT_WRAP)
+		// energy conserving lambert wrap shader
+		diffuse_brdf_NL = max(0.0, (NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
+
+#elif defined(DIFFUSE_OREN_NAYAR)
+
+		{
+			// see http://mimosa-pudica.net/improved-oren-nayar.html
+			float LdotV = dot(L, V);
+
+			float s = LdotV - NdotL * NdotV;
+			float t = mix(1.0, max(NdotL, NdotV), step(0.0, s));
+
+			float sigma2 = roughness * roughness; // TODO: this needs checking
+			vec3 A = 1.0 + sigma2 * (-0.5 / (sigma2 + 0.33) + 0.17 * diffuse_color / (sigma2 + 0.13));
+			float B = 0.45 * sigma2 / (sigma2 + 0.09);
+
+			diffuse_brdf_NL = cNdotL * (A + vec3(B) * s / t) * (1.0 / M_PI);
+		}
+
+#elif defined(DIFFUSE_TOON)
+
+		diffuse_brdf_NL = smoothstep(-roughness, max(roughness, 0.01), NdotL);
+
+#elif defined(DIFFUSE_BURLEY)
+
+		{
+			float FD90_minus_1 = 2.0 * cLdotH * cLdotH * roughness - 0.5;
+			float FdV = 1.0 + FD90_minus_1 * SchlickFresnel(cNdotV);
+			float FdL = 1.0 + FD90_minus_1 * SchlickFresnel(cNdotL);
+			diffuse_brdf_NL = (1.0 / M_PI) * FdV * FdL * cNdotL;
+			/*
+			float energyBias = mix(roughness, 0.0, 0.5);
+			float energyFactor = mix(roughness, 1.0, 1.0 / 1.51);
+			float fd90 = energyBias + 2.0 * VoH * VoH * roughness;
+			float f0 = 1.0;
+			float lightScatter = f0 + (fd90 - f0) * pow(1.0 - cNdotL, 5.0);
+			float viewScatter = f0 + (fd90 - f0) * pow(1.0 - cNdotV, 5.0);
+
+			diffuse_brdf_NL = lightScatter * viewScatter * energyFactor;
+			*/
+		}
+#else
+		// lambert
+		diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
+#endif
+
+		SRGB_APPROX(diffuse_brdf_NL)
+
+		diffuse_light += light_color * diffuse_color * diffuse_brdf_NL * attenuation;
+
+#if defined(TRANSMISSION_USED)
+		diffuse_light += light_color * diffuse_color * (vec3(1.0 / M_PI) - diffuse_brdf_NL) * transmission * attenuation;
+#endif
+
+#if defined(LIGHT_USE_RIM)
+		float rim_light = pow(max(0.0, 1.0 - cNdotV), max(0.0, (1.0 - roughness) * 16.0));
+		diffuse_light += rim_light * rim * mix(vec3(1.0), diffuse_color, rim_tint) * light_color;
+#endif
+	}
+
+	if (roughness > 0.0) {
+
+#if defined(SPECULAR_SCHLICK_GGX)
+		vec3 specular_brdf_NL = vec3(0.0);
+#else
+		float specular_brdf_NL = 0.0;
+#endif
+
+#if defined(SPECULAR_BLINN)
+
+		//normalized blinn
+		float shininess = exp2(15.0 * (1.0 - roughness) + 1.0) * 0.25;
+		float blinn = pow(cNdotH, shininess) * cNdotL;
+		blinn *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
+		specular_brdf_NL = blinn;
+
+#elif defined(SPECULAR_PHONG)
+
+		vec3 R = normalize(-reflect(L, N));
+		float cRdotV = max(0.0, dot(R, V));
+		float shininess = exp2(15.0 * (1.0 - roughness) + 1.0) * 0.25;
+		float phong = pow(cRdotV, shininess);
+		phong *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
+		specular_brdf_NL = (phong) / max(4.0 * cNdotV * cNdotL, 0.75);
+
+#elif defined(SPECULAR_TOON)
+
+		vec3 R = normalize(-reflect(L, N));
+		float RdotV = dot(R, V);
+		float mid = 1.0 - roughness;
+		mid *= mid;
+		specular_brdf_NL = smoothstep(mid - roughness * 0.5, mid + roughness * 0.5, RdotV) * mid;
+
+#elif defined(SPECULAR_DISABLED)
+		// none..
+#elif defined(SPECULAR_SCHLICK_GGX)
+		// shlick+ggx as default
+
+#if defined(LIGHT_USE_ANISOTROPY)
+		float alpha_ggx = roughness * roughness;
+		float aspect = sqrt(1.0 - anisotropy * 0.9);
+		float ax = alpha_ggx / aspect;
+		float ay = alpha_ggx * aspect;
+		float XdotH = dot(T, H);
+		float YdotH = dot(B, H);
+		float D = D_GGX_anisotropic(cNdotH, ax, ay, XdotH, YdotH, cNdotH);
+		//float G = G_GGX_anisotropic_2cos(cNdotL, ax, ay, XdotH, YdotH) * G_GGX_anisotropic_2cos(cNdotV, ax, ay, XdotH, YdotH);
+		float G = V_GGX_anisotropic(ax, ay, dot(T, V), dot(T, L), dot(B, V), dot(B, L), cNdotV, cNdotL);
+
+#else
+		float alpha_ggx = roughness * roughness;
+		float D = D_GGX(cNdotH, alpha_ggx);
+		//float G = G_GGX_2cos(cNdotL, alpha_ggx) * G_GGX_2cos(cNdotV, alpha_ggx);
+		float G = V_GGX(cNdotL, cNdotV, alpha_ggx);
+#endif
+		// F
+		vec3 f0 = F0(metallic, specular, diffuse_color);
+		float cLdotH5 = SchlickFresnel(cLdotH);
+		vec3 F = mix(vec3(cLdotH5), vec3(1.0), f0);
+
+		specular_brdf_NL = cNdotL * D * F * G;
+
+#endif
+
+		SRGB_APPROX(specular_brdf_NL)
+		specular_light += specular_brdf_NL * light_color * specular_blob_intensity * attenuation;
+
+#if defined(LIGHT_USE_CLEARCOAT)
+
+#if !defined(SPECULAR_SCHLICK_GGX)
+		float cLdotH5 = SchlickFresnel(cLdotH);
+#endif
+		float Dr = GTR1(cNdotH, mix(.1, .001, clearcoat_gloss));
+		float Fr = mix(.04, 1.0, cLdotH5);
+		//float Gr = G_GGX_2cos(cNdotL, .25) * G_GGX_2cos(cNdotV, .25);
+		float Gr = V_GGX(cNdotL, cNdotV, 0.25);
+
+		float clearcoat_specular_brdf_NL = 0.25 * clearcoat * Gr * Fr * Dr * cNdotL;
+
+		specular_light += clearcoat_specular_brdf_NL * light_color * specular_blob_intensity * attenuation;
+#endif
+	}
+
+#ifdef USE_SHADOW_TO_OPACITY
+	alpha = min(alpha, clamp(1.0 - length(attenuation), 0.0, 1.0));
+#endif
+
+#endif //defined(USE_LIGHT_SHADER_CODE)
+}
+
+#endif
+// shadows
+
+#ifdef USE_SHADOW
+
+#ifdef USE_RGBA_SHADOWS
+
+#define SHADOW_DEPTH(m_val) dot(m_val, vec4(1.0 / (255.0 * 255.0 * 255.0), 1.0 / (255.0 * 255.0), 1.0 / 255.0, 1.0))
+
+#else
+
+#define SHADOW_DEPTH(m_val) (m_val).r
+
+#endif
+
+#define SAMPLE_SHADOW_TEXEL(p_shadow, p_pos, p_depth) step(p_depth, SHADOW_DEPTH(texture2D(p_shadow, p_pos)))
+#define SAMPLE_SHADOW_TEXEL_PROJ(p_shadow, p_pos) step(p_pos.z, SHADOW_DEPTH(texture2DProj(p_shadow, p_pos)))
+
+float sample_shadow(highp sampler2D shadow, highp vec4 spos) {
+#ifdef SHADOW_MODE_PCF_13
+
+	spos.xyz /= spos.w;
+	vec2 pos = spos.xy;
+	float depth = spos.z;
+
+	float avg = SAMPLE_SHADOW_TEXEL(shadow, pos, depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x * 2.0, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x * 2.0, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y * 2.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y * 2.0), depth);
+	return avg * (1.0 / 13.0);
+#endif
+
+#ifdef SHADOW_MODE_PCF_5
+
+	spos.xyz /= spos.w;
+	vec2 pos = spos.xy;
+	float depth = spos.z;
+
+	float avg = SAMPLE_SHADOW_TEXEL(shadow, pos, depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y), depth);
+	return avg * (1.0 / 5.0);
+
+#endif
+
+#if !defined(SHADOW_MODE_PCF_5) || !defined(SHADOW_MODE_PCF_13)
+
+	return SAMPLE_SHADOW_TEXEL_PROJ(shadow, spos);
+#endif
+}
+
+#endif
+
+#if defined(FOG_DEPTH_ENABLED) || defined(FOG_HEIGHT_ENABLED)
+
+#if defined(USE_VERTEX_LIGHTING)
+
+varying vec4 fog_interp;
+
+#else
+uniform mediump vec4 fog_color_base;
+#ifdef LIGHT_MODE_DIRECTIONAL
+uniform mediump vec4 fog_sun_color_amount;
+#endif
+
+uniform bool fog_transmit_enabled;
+uniform mediump float fog_transmit_curve;
+
+#ifdef FOG_DEPTH_ENABLED
+uniform highp float fog_depth_begin;
+uniform mediump float fog_depth_curve;
+uniform mediump float fog_max_distance;
+#endif
+
+#ifdef FOG_HEIGHT_ENABLED
+uniform highp float fog_height_min;
+uniform highp float fog_height_max;
+uniform mediump float fog_height_curve;
+#endif
+
+#endif //vertex lit
+#endif //fog
+
+void main() {
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	if (dp_clip > 0.0)
+		discard;
+#endif
+	highp vec3 vertex = vertex_interp;
+	vec3 view = -normalize(vertex_interp);
+	vec3 albedo = vec3(1.0);
+	vec3 transmission = vec3(0.0);
+	float metallic = 0.0;
+	float specular = 0.5;
+	vec3 emission = vec3(0.0);
+	float roughness = 1.0;
+	float rim = 0.0;
+	float rim_tint = 0.0;
+	float clearcoat = 0.0;
+	float clearcoat_gloss = 0.0;
+	float anisotropy = 0.0;
+	vec2 anisotropy_flow = vec2(1.0, 0.0);
+	float sss_strength = 0.0; //unused
+	// gl_FragDepth is not available in GLES2, so writing to DEPTH is not converted to gl_FragDepth by Godot compiler resulting in a
+	// compile error because DEPTH is not a variable.
+	float m_DEPTH = 0.0;
+
+	float alpha = 1.0;
+	float side = 1.0;
+
+	float specular_blob_intensity = 1.0;
+#if defined(SPECULAR_TOON)
+	specular_blob_intensity *= specular * 2.0;
+#endif
+
+#if defined(ENABLE_AO)
+	float ao = 1.0;
+	float ao_light_affect = 0.0;
+#endif
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
+	vec3 binormal = normalize(binormal_interp) * side;
+	vec3 tangent = normalize(tangent_interp) * side;
+#else
+	vec3 binormal = vec3(0.0);
+	vec3 tangent = vec3(0.0);
+#endif
+	vec3 normal = normalize(normal_interp) * side;
+
+#if defined(ENABLE_NORMALMAP)
+	vec3 normalmap = vec3(0.5);
+#endif
+	float normaldepth = 1.0;
+
+#if defined(ALPHA_SCISSOR_USED)
+	float alpha_scissor = 0.5;
+#endif
+
+#if defined(SCREEN_UV_USED)
+	vec2 screen_uv = gl_FragCoord.xy * screen_pixel_size;
+#endif
+
+	{
+		/* clang-format off */
+
+FRAGMENT_SHADER_CODE
+
+		/* clang-format on */
+	}
+
+#if defined(ENABLE_NORMALMAP)
+	normalmap.xy = normalmap.xy * 2.0 - 1.0;
+	normalmap.z = sqrt(max(0.0, 1.0 - dot(normalmap.xy, normalmap.xy)));
+
+	normal = normalize(mix(normal_interp, tangent * normalmap.x + binormal * normalmap.y + normal * normalmap.z, normaldepth)) * side;
+	//normal = normalmap;
+#endif
+
+	normal = normalize(normal);
+
+	vec3 N = normal;
+
+	vec3 specular_light = vec3(0.0, 0.0, 0.0);
+	vec3 diffuse_light = vec3(0.0, 0.0, 0.0);
+	vec3 ambient_light = vec3(0.0, 0.0, 0.0);
+
+	vec3 eye_position = view;
+
+#if !defined(USE_SHADOW_TO_OPACITY)
+
+#if defined(ALPHA_SCISSOR_USED)
+	if (alpha < alpha_scissor) {
+		discard;
+	}
+#endif // ALPHA_SCISSOR_USED
+
+#ifdef USE_DEPTH_PREPASS
+	if (alpha < 0.1) {
+		discard;
+	}
+#endif // USE_DEPTH_PREPASS
+
+#endif // !USE_SHADOW_TO_OPACITY
+
+#ifdef BASE_PASS
+
+	// IBL precalculations
+	float ndotv = clamp(dot(normal, eye_position), 0.0, 1.0);
+	vec3 f0 = F0(metallic, specular, albedo);
+	vec3 F = f0 + (max(vec3(1.0 - roughness), f0) - f0) * pow(1.0 - ndotv, 5.0);
+
+#ifdef AMBIENT_LIGHT_DISABLED
+	ambient_light = vec3(0.0, 0.0, 0.0);
+#else
+
+#ifdef USE_RADIANCE_MAP
+
+	vec3 ref_vec = reflect(-eye_position, N);
+	ref_vec = normalize((radiance_inverse_xform * vec4(ref_vec, 0.0)).xyz);
+
+	ref_vec.z *= -1.0;
+
+	specular_light = textureCubeLod(radiance_map, ref_vec, roughness * RADIANCE_MAX_LOD).xyz * bg_energy;
+#ifndef USE_LIGHTMAP
+	{
+		vec3 ambient_dir = normalize((radiance_inverse_xform * vec4(normal, 0.0)).xyz);
+		vec3 env_ambient = textureCubeLod(radiance_map, ambient_dir, 4.0).xyz * bg_energy;
+		env_ambient *= 1.0 - F;
+
+		ambient_light = mix(ambient_color.rgb, env_ambient, ambient_sky_contribution);
+	}
+#endif
+
+#else
+
+	ambient_light = ambient_color.rgb;
+	specular_light = bg_color.rgb * bg_energy;
+
+#endif
+#endif // AMBIENT_LIGHT_DISABLED
+	ambient_light *= ambient_energy;
+
+#if defined(USE_REFLECTION_PROBE1) || defined(USE_REFLECTION_PROBE2)
+
+	vec4 ambient_accum = vec4(0.0);
+	vec4 reflection_accum = vec4(0.0);
+
+#ifdef USE_REFLECTION_PROBE1
+
+	reflection_process(reflection_probe1,
+#ifdef USE_VERTEX_LIGHTING
+			refprobe1_reflection_normal_blend.rgb,
+#ifndef USE_LIGHTMAP
+			refprobe1_ambient_normal,
+#endif
+			refprobe1_reflection_normal_blend.a,
+#else
+			normal_interp, vertex_interp, refprobe1_local_matrix,
+			refprobe1_use_box_project, refprobe1_box_extents, refprobe1_box_offset,
+#endif
+			refprobe1_exterior, refprobe1_intensity, refprobe1_ambient, roughness,
+			ambient_light, specular_light, reflection_accum, ambient_accum);
+
+#endif // USE_REFLECTION_PROBE1
+
+#ifdef USE_REFLECTION_PROBE2
+
+	reflection_process(reflection_probe2,
+#ifdef USE_VERTEX_LIGHTING
+			refprobe2_reflection_normal_blend.rgb,
+#ifndef USE_LIGHTMAP
+			refprobe2_ambient_normal,
+#endif
+			refprobe2_reflection_normal_blend.a,
+#else
+			normal_interp, vertex_interp, refprobe2_local_matrix,
+			refprobe2_use_box_project, refprobe2_box_extents, refprobe2_box_offset,
+#endif
+			refprobe2_exterior, refprobe2_intensity, refprobe2_ambient, roughness,
+			ambient_light, specular_light, reflection_accum, ambient_accum);
+
+#endif // USE_REFLECTION_PROBE2
+
+	if (reflection_accum.a > 0.0) {
+		specular_light = reflection_accum.rgb / reflection_accum.a;
+	}
+
+#ifndef USE_LIGHTMAP
+	if (ambient_accum.a > 0.0) {
+		ambient_light = ambient_accum.rgb / ambient_accum.a;
+	}
+#endif
+
+#endif // defined(USE_REFLECTION_PROBE1) || defined(USE_REFLECTION_PROBE2)
+
+	// environment BRDF approximation
+	{
+#if defined(DIFFUSE_TOON)
+		//simplify for toon, as
+		specular_light *= specular * metallic * albedo * 2.0;
+#else
+
+		// scales the specular reflections, needs to be be computed before lighting happens,
+		// but after environment and reflection probes are added
+		//TODO: this curve is not really designed for gammaspace, should be adjusted
+		const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
+		const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
+		vec4 r = roughness * c0 + c1;
+		float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;
+		vec2 env = vec2(-1.04, 1.04) * a004 + r.zw;
+		specular_light *= env.x * F + env.y;
+
+#endif
+	}
+
+#ifdef USE_LIGHTMAP
+	//ambient light will come entirely from lightmap is lightmap is used
+	ambient_light = texture2D(lightmap, uv2_interp).rgb * lightmap_energy;
+#endif
+
+#ifdef USE_LIGHTMAP_CAPTURE
+	{
+		vec3 cone_dirs[12];
+		cone_dirs[0] = vec3(0.0, 0.0, 1.0);
+		cone_dirs[1] = vec3(0.866025, 0.0, 0.5);
+		cone_dirs[2] = vec3(0.267617, 0.823639, 0.5);
+		cone_dirs[3] = vec3(-0.700629, 0.509037, 0.5);
+		cone_dirs[4] = vec3(-0.700629, -0.509037, 0.5);
+		cone_dirs[5] = vec3(0.267617, -0.823639, 0.5);
+		cone_dirs[6] = vec3(0.0, 0.0, -1.0);
+		cone_dirs[7] = vec3(0.866025, 0.0, -0.5);
+		cone_dirs[8] = vec3(0.267617, 0.823639, -0.5);
+		cone_dirs[9] = vec3(-0.700629, 0.509037, -0.5);
+		cone_dirs[10] = vec3(-0.700629, -0.509037, -0.5);
+		cone_dirs[11] = vec3(0.267617, -0.823639, -0.5);
+
+		vec3 local_normal = normalize(camera_matrix * vec4(normal, 0.0)).xyz;
+		vec4 captured = vec4(0.0);
+		float sum = 0.0;
+		for (int i = 0; i < 12; i++) {
+			float amount = max(0.0, dot(local_normal, cone_dirs[i])); //not correct, but creates a nice wrap around effect
+			captured += lightmap_captures[i] * amount;
+			sum += amount;
+		}
+
+		captured /= sum;
+
+		if (lightmap_capture_sky) {
+			ambient_light = mix(ambient_light, captured.rgb, captured.a);
+		} else {
+			ambient_light = captured.rgb;
+		}
+	}
+#endif
+
+#endif //BASE PASS
+
+//
+// Lighting
+//
+#ifdef USE_LIGHTING
+
+#ifndef USE_VERTEX_LIGHTING
+	vec3 L;
+#endif
+	vec3 light_att = vec3(1.0);
+
+#ifdef LIGHT_MODE_OMNI
+
+#ifndef USE_VERTEX_LIGHTING
+	vec3 light_vec = light_position - vertex;
+	float light_length = length(light_vec);
+
+	float normalized_distance = light_length / light_range;
+	if (normalized_distance < 1.0) {
+		float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation);
+
+		light_att = vec3(omni_attenuation);
+	} else {
+		light_att = vec3(0.0);
+	}
+	L = normalize(light_vec);
+
+#endif
+
+#if !defined(SHADOWS_DISABLED)
+
+#ifdef USE_SHADOW
+	{
+		highp vec4 splane = shadow_coord;
+		float shadow_len = length(splane.xyz);
+
+		splane.xyz = normalize(splane.xyz);
+
+		vec4 clamp_rect = light_clamp;
+
+		if (splane.z >= 0.0) {
+			splane.z += 1.0;
+
+			clamp_rect.y += clamp_rect.w;
+		} else {
+			splane.z = 1.0 - splane.z;
+		}
+
+		splane.xy /= splane.z;
+		splane.xy = splane.xy * 0.5 + 0.5;
+		splane.z = shadow_len / light_range;
+
+		splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
+		splane.w = 1.0;
+
+		float shadow = sample_shadow(light_shadow_atlas, splane);
+
+		light_att *= mix(shadow_color.rgb, vec3(1.0), shadow);
+	}
+#endif
+
+#endif //SHADOWS_DISABLED
+
+#endif //type omni
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+
+#ifndef USE_VERTEX_LIGHTING
+	vec3 light_vec = -light_direction;
+	L = normalize(light_vec);
+#endif
+	float depth_z = -vertex.z;
+
+#if !defined(SHADOWS_DISABLED)
+
+#ifdef USE_SHADOW
+
+#ifdef USE_VERTEX_LIGHTING
+	//compute shadows in a mobile friendly way
+
+#ifdef LIGHT_USE_PSSM4
+	//take advantage of prefetch
+	float shadow1 = sample_shadow(light_directional_shadow, shadow_coord);
+	float shadow2 = sample_shadow(light_directional_shadow, shadow_coord2);
+	float shadow3 = sample_shadow(light_directional_shadow, shadow_coord3);
+	float shadow4 = sample_shadow(light_directional_shadow, shadow_coord4);
+
+	if (depth_z < light_split_offsets.w) {
+		float pssm_fade = 0.0;
+		float shadow_att = 1.0;
+#ifdef LIGHT_USE_PSSM_BLEND
+		float shadow_att2 = 1.0;
+		float pssm_blend = 0.0;
+		bool use_blend = true;
+#endif
+		if (depth_z < light_split_offsets.y) {
+			if (depth_z < light_split_offsets.x) {
+				shadow_att = shadow1;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+				shadow_att2 = shadow2;
+
+				pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+#endif
+			} else {
+				shadow_att = shadow2;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+				shadow_att2 = shadow3;
+
+				pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+#endif
+			}
+		} else {
+			if (depth_z < light_split_offsets.z) {
+				shadow_att = shadow3;
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+				shadow_att2 = shadow4;
+				pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
+#endif
+
+			} else {
+				shadow_att = shadow4;
+				pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+				use_blend = false;
+#endif
+			}
+		}
+#if defined(LIGHT_USE_PSSM_BLEND)
+		if (use_blend) {
+			shadow_att = mix(shadow_att, shadow_att2, pssm_blend);
+		}
+#endif
+		light_att *= mix(shadow_color.rgb, vec3(1.0), shadow_att);
+	}
+
+#endif //LIGHT_USE_PSSM4
+
+#ifdef LIGHT_USE_PSSM2
+
+	//take advantage of prefetch
+	float shadow1 = sample_shadow(light_directional_shadow, shadow_coord);
+	float shadow2 = sample_shadow(light_directional_shadow, shadow_coord2);
+
+	if (depth_z < light_split_offsets.y) {
+		float shadow_att = 1.0;
+		float pssm_fade = 0.0;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+		float shadow_att2 = 1.0;
+		float pssm_blend = 0.0;
+		bool use_blend = true;
+#endif
+		if (depth_z < light_split_offsets.x) {
+			float pssm_fade = 0.0;
+			shadow_att = shadow1;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+			shadow_att2 = shadow2;
+			pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+#endif
+		} else {
+			shadow_att = shadow2;
+			pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+#ifdef LIGHT_USE_PSSM_BLEND
+			use_blend = false;
+#endif
+		}
+#ifdef LIGHT_USE_PSSM_BLEND
+		if (use_blend) {
+			shadow_att = mix(shadow_att, shadow_att2, pssm_blend);
+		}
+#endif
+		light_att *= mix(shadow_color.rgb, vec3(1.0), shadow_att);
+	}
+
+#endif //LIGHT_USE_PSSM2
+
+#if !defined(LIGHT_USE_PSSM4) && !defined(LIGHT_USE_PSSM2)
+
+	light_att *= mix(shadow_color.rgb, vec3(1.0), sample_shadow(light_directional_shadow, shadow_coord));
+#endif //orthogonal
+
+#else //fragment version of pssm
+
+	{
+#ifdef LIGHT_USE_PSSM4
+		if (depth_z < light_split_offsets.w) {
+#elif defined(LIGHT_USE_PSSM2)
+		if (depth_z < light_split_offsets.y) {
+#else
+		if (depth_z < light_split_offsets.x) {
+#endif //pssm2
+
+			highp vec4 pssm_coord;
+			float pssm_fade = 0.0;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+			float pssm_blend;
+			highp vec4 pssm_coord2;
+			bool use_blend = true;
+#endif
+
+#ifdef LIGHT_USE_PSSM4
+
+			if (depth_z < light_split_offsets.y) {
+				if (depth_z < light_split_offsets.x) {
+					pssm_coord = shadow_coord;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+					pssm_coord2 = shadow_coord2;
+
+					pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+#endif
+				} else {
+					pssm_coord = shadow_coord2;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+					pssm_coord2 = shadow_coord3;
+
+					pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+#endif
+				}
+			} else {
+				if (depth_z < light_split_offsets.z) {
+					pssm_coord = shadow_coord3;
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+					pssm_coord2 = shadow_coord4;
+					pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
+#endif
+
+				} else {
+					pssm_coord = shadow_coord4;
+					pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+					use_blend = false;
+#endif
+				}
+			}
+
+#endif // LIGHT_USE_PSSM4
+
+#ifdef LIGHT_USE_PSSM2
+			if (depth_z < light_split_offsets.x) {
+				pssm_coord = shadow_coord;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+				pssm_coord2 = shadow_coord2;
+				pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+#endif
+			} else {
+				pssm_coord = shadow_coord2;
+				pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+#ifdef LIGHT_USE_PSSM_BLEND
+				use_blend = false;
+#endif
+			}
+
+#endif // LIGHT_USE_PSSM2
+
+#if !defined(LIGHT_USE_PSSM4) && !defined(LIGHT_USE_PSSM2)
+			{
+				pssm_coord = shadow_coord;
+			}
+#endif
+
+			float shadow = sample_shadow(light_directional_shadow, pssm_coord);
+
+#ifdef LIGHT_USE_PSSM_BLEND
+			if (use_blend) {
+				shadow = mix(shadow, sample_shadow(light_directional_shadow, pssm_coord2), pssm_blend);
+			}
+#endif
+
+			light_att *= mix(shadow_color.rgb, vec3(1.0), shadow);
+		}
+	}
+#endif //use vertex lighting
+
+#endif //use shadow
+
+#endif // SHADOWS_DISABLED
+
+#endif
+
+#ifdef LIGHT_MODE_SPOT
+
+	light_att = vec3(1.0);
+
+#ifndef USE_VERTEX_LIGHTING
+
+	vec3 light_rel_vec = light_position - vertex;
+	float light_length = length(light_rel_vec);
+	float normalized_distance = light_length / light_range;
+
+	if (normalized_distance < 1.0) {
+		float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation);
+		vec3 spot_dir = light_direction;
+
+		float spot_cutoff = light_spot_angle;
+		float angle = dot(-normalize(light_rel_vec), spot_dir);
+
+		if (angle > spot_cutoff) {
+			float scos = max(angle, spot_cutoff);
+			float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));
+			spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);
+
+			light_att = vec3(spot_attenuation);
+		} else {
+			light_att = vec3(0.0);
+		}
+	} else {
+		light_att = vec3(0.0);
+	}
+
+	L = normalize(light_rel_vec);
+
+#endif
+
+#if !defined(SHADOWS_DISABLED)
+
+#ifdef USE_SHADOW
+	{
+		highp vec4 splane = shadow_coord;
+
+		float shadow = sample_shadow(light_shadow_atlas, splane);
+		light_att *= mix(shadow_color.rgb, vec3(1.0), shadow);
+	}
+#endif
+
+#endif // SHADOWS_DISABLED
+
+#endif // LIGHT_MODE_SPOT
+
+#ifdef USE_VERTEX_LIGHTING
+	//vertex lighting
+
+	specular_light += specular_interp * specular_blob_intensity * light_att;
+	diffuse_light += diffuse_interp * albedo * light_att;
+
+#else
+	//fragment lighting
+	light_compute(
+			normal,
+			L,
+			eye_position,
+			binormal,
+			tangent,
+			light_color.xyz,
+			light_att,
+			albedo,
+			transmission,
+			specular_blob_intensity * light_specular,
+			roughness,
+			metallic,
+			specular,
+			rim,
+			rim_tint,
+			clearcoat,
+			clearcoat_gloss,
+			anisotropy,
+			diffuse_light,
+			specular_light,
+			alpha);
+
+#endif //vertex lighting
+
+#endif //USE_LIGHTING
+	//compute and merge
+
+#ifdef USE_SHADOW_TO_OPACITY
+
+	alpha = min(alpha, clamp(length(ambient_light), 0.0, 1.0));
+
+#if defined(ALPHA_SCISSOR_USED)
+	if (alpha < alpha_scissor) {
+		discard;
+	}
+#endif // ALPHA_SCISSOR_USED
+
+#ifdef USE_DEPTH_PREPASS
+	if (alpha < 0.1) {
+		discard;
+	}
+#endif // USE_DEPTH_PREPASS
+
+#endif // !USE_SHADOW_TO_OPACITY
+
+#ifndef RENDER_DEPTH
+
+#ifdef SHADELESS
+
+	gl_FragColor = vec4(albedo, alpha);
+#else
+
+	ambient_light *= albedo;
+
+#if defined(ENABLE_AO)
+	ambient_light *= ao;
+	ao_light_affect = mix(1.0, ao, ao_light_affect);
+	specular_light *= ao_light_affect;
+	diffuse_light *= ao_light_affect;
+#endif
+
+	diffuse_light *= 1.0 - metallic;
+	ambient_light *= 1.0 - metallic;
+
+	gl_FragColor = vec4(ambient_light + diffuse_light + specular_light, alpha);
+
+	//add emission if in base pass
+#ifdef BASE_PASS
+	gl_FragColor.rgb += emission;
+#endif
+	// gl_FragColor = vec4(normal, 1.0);
+
+//apply fog
+#if defined(FOG_DEPTH_ENABLED) || defined(FOG_HEIGHT_ENABLED)
+
+#if defined(USE_VERTEX_LIGHTING)
+
+#if defined(BASE_PASS)
+	gl_FragColor.rgb = mix(gl_FragColor.rgb, fog_interp.rgb, fog_interp.a);
+#else
+	gl_FragColor.rgb *= (1.0 - fog_interp.a);
+#endif // BASE_PASS
+
+#else //pixel based fog
+	float fog_amount = 0.0;
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+
+	vec3 fog_color = mix(fog_color_base.rgb, fog_sun_color_amount.rgb, fog_sun_color_amount.a * pow(max(dot(eye_position, light_direction), 0.0), 8.0));
+#else
+	vec3 fog_color = fog_color_base.rgb;
+#endif
+
+#ifdef FOG_DEPTH_ENABLED
+
+	{
+		float fog_z = smoothstep(fog_depth_begin, fog_max_distance, length(vertex));
+
+		fog_amount = pow(fog_z, fog_depth_curve) * fog_color_base.a;
+
+		if (fog_transmit_enabled) {
+			vec3 total_light = gl_FragColor.rgb;
+			float transmit = pow(fog_z, fog_transmit_curve);
+			fog_color = mix(max(total_light, fog_color), fog_color, transmit);
+		}
+	}
+#endif
+
+#ifdef FOG_HEIGHT_ENABLED
+	{
+		float y = (camera_matrix * vec4(vertex, 1.0)).y;
+		fog_amount = max(fog_amount, pow(smoothstep(fog_height_min, fog_height_max, y), fog_height_curve));
+	}
+#endif
+
+#if defined(BASE_PASS)
+	gl_FragColor.rgb = mix(gl_FragColor.rgb, fog_color, fog_amount);
+#else
+	gl_FragColor.rgb *= (1.0 - fog_amount);
+#endif // BASE_PASS
+
+#endif //use vertex lit
+
+#endif // defined(FOG_DEPTH_ENABLED) || defined(FOG_HEIGHT_ENABLED)
+
+#endif //unshaded
+
+#else // not RENDER_DEPTH
+//depth render
+#ifdef USE_RGBA_SHADOWS
+
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0; // bias
+	highp vec4 comp = fract(depth * vec4(255.0 * 255.0 * 255.0, 255.0 * 255.0, 255.0, 1.0));
+	comp -= comp.xxyz * vec4(0.0, 1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0);
+	gl_FragColor = comp;
+
+#endif
+#endif
+}
diff --git a/drivers/opengl/shaders/stdlib.glsl b/drivers/opengl/shaders/stdlib.glsl
new file mode 100644
index 0000000000..9c74418743
--- /dev/null
+++ b/drivers/opengl/shaders/stdlib.glsl
@@ -0,0 +1,420 @@
+
+vec2 select2(vec2 a, vec2 b, bvec2 c) {
+	vec2 ret;
+
+	ret.x = c.x ? b.x : a.x;
+	ret.y = c.y ? b.y : a.y;
+
+	return ret;
+}
+
+vec3 select3(vec3 a, vec3 b, bvec3 c) {
+	vec3 ret;
+
+	ret.x = c.x ? b.x : a.x;
+	ret.y = c.y ? b.y : a.y;
+	ret.z = c.z ? b.z : a.z;
+
+	return ret;
+}
+
+vec4 select4(vec4 a, vec4 b, bvec4 c) {
+	vec4 ret;
+
+	ret.x = c.x ? b.x : a.x;
+	ret.y = c.y ? b.y : a.y;
+	ret.z = c.z ? b.z : a.z;
+	ret.w = c.w ? b.w : a.w;
+
+	return ret;
+}
+
+highp vec4 texel2DFetch(highp sampler2D tex, ivec2 size, ivec2 coord) {
+	float x_coord = float(2 * coord.x + 1) / float(size.x * 2);
+	float y_coord = float(2 * coord.y + 1) / float(size.y * 2);
+
+	return texture2DLod(tex, vec2(x_coord, y_coord), 0.0);
+}
+
+#if defined(SINH_USED)
+
+highp float sinh(highp float x) {
+	return 0.5 * (exp(x) - exp(-x));
+}
+
+highp vec2 sinh(highp vec2 x) {
+	return 0.5 * vec2(exp(x.x) - exp(-x.x), exp(x.y) - exp(-x.y));
+}
+
+highp vec3 sinh(highp vec3 x) {
+	return 0.5 * vec3(exp(x.x) - exp(-x.x), exp(x.y) - exp(-x.y), exp(x.z) - exp(-x.z));
+}
+
+highp vec4 sinh(highp vec4 x) {
+	return 0.5 * vec4(exp(x.x) - exp(-x.x), exp(x.y) - exp(-x.y), exp(x.z) - exp(-x.z), exp(x.w) - exp(-x.w));
+}
+
+#endif
+
+#if defined(COSH_USED)
+
+highp float cosh(highp float x) {
+	return 0.5 * (exp(x) + exp(-x));
+}
+
+highp vec2 cosh(highp vec2 x) {
+	return 0.5 * vec2(exp(x.x) + exp(-x.x), exp(x.y) + exp(-x.y));
+}
+
+highp vec3 cosh(highp vec3 x) {
+	return 0.5 * vec3(exp(x.x) + exp(-x.x), exp(x.y) + exp(-x.y), exp(x.z) + exp(-x.z));
+}
+
+highp vec4 cosh(highp vec4 x) {
+	return 0.5 * vec4(exp(x.x) + exp(-x.x), exp(x.y) + exp(-x.y), exp(x.z) + exp(-x.z), exp(x.w) + exp(-x.w));
+}
+
+#endif
+
+#if defined(TANH_USED)
+
+highp float tanh(highp float x) {
+	highp float exp2x = exp(2.0 * x);
+	return (exp2x - 1.0) / (exp2x + 1.0);
+}
+
+highp vec2 tanh(highp vec2 x) {
+	highp float exp2x = exp(2.0 * x.x);
+	highp float exp2y = exp(2.0 * x.y);
+	return vec2((exp2x - 1.0) / (exp2x + 1.0), (exp2y - 1.0) / (exp2y + 1.0));
+}
+
+highp vec3 tanh(highp vec3 x) {
+	highp float exp2x = exp(2.0 * x.x);
+	highp float exp2y = exp(2.0 * x.y);
+	highp float exp2z = exp(2.0 * x.z);
+	return vec3((exp2x - 1.0) / (exp2x + 1.0), (exp2y - 1.0) / (exp2y + 1.0), (exp2z - 1.0) / (exp2z + 1.0));
+}
+
+highp vec4 tanh(highp vec4 x) {
+	highp float exp2x = exp(2.0 * x.x);
+	highp float exp2y = exp(2.0 * x.y);
+	highp float exp2z = exp(2.0 * x.z);
+	highp float exp2w = exp(2.0 * x.w);
+	return vec4((exp2x - 1.0) / (exp2x + 1.0), (exp2y - 1.0) / (exp2y + 1.0), (exp2z - 1.0) / (exp2z + 1.0), (exp2w - 1.0) / (exp2w + 1.0));
+}
+
+#endif
+
+#if defined(ASINH_USED)
+
+highp float asinh(highp float x) {
+	return sign(x) * log(abs(x) + sqrt(1.0 + x * x));
+}
+
+highp vec2 asinh(highp vec2 x) {
+	return vec2(sign(x.x) * log(abs(x.x) + sqrt(1.0 + x.x * x.x)), sign(x.y) * log(abs(x.y) + sqrt(1.0 + x.y * x.y)));
+}
+
+highp vec3 asinh(highp vec3 x) {
+	return vec3(sign(x.x) * log(abs(x.x) + sqrt(1.0 + x.x * x.x)), sign(x.y) * log(abs(x.y) + sqrt(1.0 + x.y * x.y)), sign(x.z) * log(abs(x.z) + sqrt(1.0 + x.z * x.z)));
+}
+
+highp vec4 asinh(highp vec4 x) {
+	return vec4(sign(x.x) * log(abs(x.x) + sqrt(1.0 + x.x * x.x)), sign(x.y) * log(abs(x.y) + sqrt(1.0 + x.y * x.y)), sign(x.z) * log(abs(x.z) + sqrt(1.0 + x.z * x.z)), sign(x.w) * log(abs(x.w) + sqrt(1.0 + x.w * x.w)));
+}
+
+#endif
+
+#if defined(ACOSH_USED)
+
+highp float acosh(highp float x) {
+	return log(x + sqrt(x * x - 1.0));
+}
+
+highp vec2 acosh(highp vec2 x) {
+	return vec2(log(x.x + sqrt(x.x * x.x - 1.0)), log(x.y + sqrt(x.y * x.y - 1.0)));
+}
+
+highp vec3 acosh(highp vec3 x) {
+	return vec3(log(x.x + sqrt(x.x * x.x - 1.0)), log(x.y + sqrt(x.y * x.y - 1.0)), log(x.z + sqrt(x.z * x.z - 1.0)));
+}
+
+highp vec4 acosh(highp vec4 x) {
+	return vec4(log(x.x + sqrt(x.x * x.x - 1.0)), log(x.y + sqrt(x.y * x.y - 1.0)), log(x.z + sqrt(x.z * x.z - 1.0)), log(x.w + sqrt(x.w * x.w - 1.0)));
+}
+
+#endif
+
+#if defined(ATANH_USED)
+
+highp float atanh(highp float x) {
+	return 0.5 * log((1.0 + x) / (1.0 - x));
+}
+
+highp vec2 atanh(highp vec2 x) {
+	return 0.5 * vec2(log((1.0 + x.x) / (1.0 - x.x)), log((1.0 + x.y) / (1.0 - x.y)));
+}
+
+highp vec3 atanh(highp vec3 x) {
+	return 0.5 * vec3(log((1.0 + x.x) / (1.0 - x.x)), log((1.0 + x.y) / (1.0 - x.y)), log((1.0 + x.z) / (1.0 - x.z)));
+}
+
+highp vec4 atanh(highp vec4 x) {
+	return 0.5 * vec4(log((1.0 + x.x) / (1.0 - x.x)), log((1.0 + x.y) / (1.0 - x.y)), log((1.0 + x.z) / (1.0 - x.z)), log((1.0 + x.w) / (1.0 - x.w)));
+}
+
+#endif
+
+#if defined(ROUND_USED)
+
+highp float round(highp float x) {
+	return floor(x + 0.5);
+}
+
+highp vec2 round(highp vec2 x) {
+	return floor(x + vec2(0.5));
+}
+
+highp vec3 round(highp vec3 x) {
+	return floor(x + vec3(0.5));
+}
+
+highp vec4 round(highp vec4 x) {
+	return floor(x + vec4(0.5));
+}
+
+#endif
+
+#if defined(ROUND_EVEN_USED)
+
+highp float roundEven(highp float x) {
+	highp float t = x + 0.5;
+	highp float f = floor(t);
+	highp float r;
+	if (t == f) {
+		if (x > 0)
+			r = f - mod(f, 2);
+		else
+			r = f + mod(f, 2);
+	} else
+		r = f;
+	return r;
+}
+
+highp vec2 roundEven(highp vec2 x) {
+	return vec2(roundEven(x.x), roundEven(x.y));
+}
+
+highp vec3 roundEven(highp vec3 x) {
+	return vec3(roundEven(x.x), roundEven(x.y), roundEven(x.z));
+}
+
+highp vec4 roundEven(highp vec4 x) {
+	return vec4(roundEven(x.x), roundEven(x.y), roundEven(x.z), roundEven(x.w));
+}
+
+#endif
+
+#if defined(IS_INF_USED)
+
+bool isinf(highp float x) {
+	return (2 * x == x) && (x != 0);
+}
+
+bvec2 isinf(highp vec2 x) {
+	return bvec2((2 * x.x == x.x) && (x.x != 0), (2 * x.y == x.y) && (x.y != 0));
+}
+
+bvec3 isinf(highp vec3 x) {
+	return bvec3((2 * x.x == x.x) && (x.x != 0), (2 * x.y == x.y) && (x.y != 0), (2 * x.z == x.z) && (x.z != 0));
+}
+
+bvec4 isinf(highp vec4 x) {
+	return bvec4((2 * x.x == x.x) && (x.x != 0), (2 * x.y == x.y) && (x.y != 0), (2 * x.z == x.z) && (x.z != 0), (2 * x.w == x.w) && (x.w != 0));
+}
+
+#endif
+
+#if defined(IS_NAN_USED)
+
+bool isnan(highp float x) {
+	return x != x;
+}
+
+bvec2 isnan(highp vec2 x) {
+	return bvec2(x.x != x.x, x.y != x.y);
+}
+
+bvec3 isnan(highp vec3 x) {
+	return bvec3(x.x != x.x, x.y != x.y, x.z != x.z);
+}
+
+bvec4 isnan(highp vec4 x) {
+	return bvec4(x.x != x.x, x.y != x.y, x.z != x.z, x.w != x.w);
+}
+
+#endif
+
+#if defined(TRUNC_USED)
+
+highp float trunc(highp float x) {
+	return x < 0 ? -floor(-x) : floor(x);
+}
+
+highp vec2 trunc(highp vec2 x) {
+	return vec2(x.x < 0 ? -floor(-x.x) : floor(x.x), x.y < 0 ? -floor(-x.y) : floor(x.y));
+}
+
+highp vec3 trunc(highp vec3 x) {
+	return vec3(x.x < 0 ? -floor(-x.x) : floor(x.x), x.y < 0 ? -floor(-x.y) : floor(x.y), x.z < 0 ? -floor(-x.z) : floor(x.z));
+}
+
+highp vec4 trunc(highp vec4 x) {
+	return vec4(x.x < 0 ? -floor(-x.x) : floor(x.x), x.y < 0 ? -floor(-x.y) : floor(x.y), x.z < 0 ? -floor(-x.z) : floor(x.z), x.w < 0 ? -floor(-x.w) : floor(x.w));
+}
+
+#endif
+
+#if defined(DETERMINANT_USED)
+
+highp float determinant(highp mat2 m) {
+	return m[0].x * m[1].y - m[1].x * m[0].y;
+}
+
+highp float determinant(highp mat3 m) {
+	return m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z);
+}
+
+highp float determinant(highp mat4 m) {
+	highp float s00 = m[2].z * m[3].w - m[3].z * m[2].w;
+	highp float s01 = m[2].y * m[3].w - m[3].y * m[2].w;
+	highp float s02 = m[2].y * m[3].z - m[3].y * m[2].z;
+	highp float s03 = m[2].x * m[3].w - m[3].x * m[2].w;
+	highp float s04 = m[2].x * m[3].z - m[3].x * m[2].z;
+	highp float s05 = m[2].x * m[3].y - m[3].x * m[2].y;
+	highp vec4 c = vec4((m[1].y * s00 - m[1].z * s01 + m[1].w * s02), -(m[1].x * s00 - m[1].z * s03 + m[1].w * s04), (m[1].x * s01 - m[1].y * s03 + m[1].w * s05), -(m[1].x * s02 - m[1].y * s04 + m[1].z * s05));
+	return m[0].x * c.x + m[0].y * c.y + m[0].z * c.z + m[0].w * c.w;
+}
+
+#endif
+
+#if defined(INVERSE_USED)
+
+highp mat2 inverse(highp mat2 m) {
+	highp float d = 1.0 / (m[0].x * m[1].y - m[1].x * m[0].y);
+	return mat2(
+			vec2(m[1].y * d, -m[0].y * d),
+			vec2(-m[1].x * d, m[0].x * d));
+}
+
+highp mat3 inverse(highp mat3 m) {
+	highp float d = 1.0 / (m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z));
+	return mat3(
+			vec3((m[1].y * m[2].z - m[2].y * m[1].z), -(m[1].x * m[2].z - m[2].x * m[1].z), (m[1].x * m[2].y - m[2].x * m[1].y)) * d,
+			vec3(-(m[0].y * m[2].z - m[2].y * m[0].z), (m[0].x * m[2].z - m[2].x * m[0].z), -(m[0].x * m[2].y - m[2].x * m[0].y)) * d,
+			vec3((m[0].y * m[1].z - m[1].y * m[0].z), -(m[0].x * m[1].z - m[1].x * m[0].z), (m[0].x * m[1].y - m[1].x * m[0].y)) * d);
+}
+
+highp mat4 inverse(highp mat4 m) {
+	highp float c00 = m[2].z * m[3].w - m[3].z * m[2].w;
+	highp float c02 = m[1].z * m[3].w - m[3].z * m[1].w;
+	highp float c03 = m[1].z * m[2].w - m[2].z * m[1].w;
+
+	highp float c04 = m[2].y * m[3].w - m[3].y * m[2].w;
+	highp float c06 = m[1].y * m[3].w - m[3].y * m[1].w;
+	highp float c07 = m[1].y * m[2].w - m[2].y * m[1].w;
+
+	highp float c08 = m[2].y * m[3].z - m[3].y * m[2].z;
+	highp float c10 = m[1].y * m[3].z - m[3].y * m[1].z;
+	highp float c11 = m[1].y * m[2].z - m[2].y * m[1].z;
+
+	highp float c12 = m[2].x * m[3].w - m[3].x * m[2].w;
+	highp float c14 = m[1].x * m[3].w - m[3].x * m[1].w;
+	highp float c15 = m[1].x * m[2].w - m[2].x * m[1].w;
+
+	highp float c16 = m[2].x * m[3].z - m[3].x * m[2].z;
+	highp float c18 = m[1].x * m[3].z - m[3].x * m[1].z;
+	highp float c19 = m[1].x * m[2].z - m[2].x * m[1].z;
+
+	highp float c20 = m[2].x * m[3].y - m[3].x * m[2].y;
+	highp float c22 = m[1].x * m[3].y - m[3].x * m[1].y;
+	highp float c23 = m[1].x * m[2].y - m[2].x * m[1].y;
+
+	vec4 f0 = vec4(c00, c00, c02, c03);
+	vec4 f1 = vec4(c04, c04, c06, c07);
+	vec4 f2 = vec4(c08, c08, c10, c11);
+	vec4 f3 = vec4(c12, c12, c14, c15);
+	vec4 f4 = vec4(c16, c16, c18, c19);
+	vec4 f5 = vec4(c20, c20, c22, c23);
+
+	vec4 v0 = vec4(m[1].x, m[0].x, m[0].x, m[0].x);
+	vec4 v1 = vec4(m[1].y, m[0].y, m[0].y, m[0].y);
+	vec4 v2 = vec4(m[1].z, m[0].z, m[0].z, m[0].z);
+	vec4 v3 = vec4(m[1].w, m[0].w, m[0].w, m[0].w);
+
+	vec4 inv0 = vec4(v1 * f0 - v2 * f1 + v3 * f2);
+	vec4 inv1 = vec4(v0 * f0 - v2 * f3 + v3 * f4);
+	vec4 inv2 = vec4(v0 * f1 - v1 * f3 + v3 * f5);
+	vec4 inv3 = vec4(v0 * f2 - v1 * f4 + v2 * f5);
+
+	vec4 sa = vec4(+1, -1, +1, -1);
+	vec4 sb = vec4(-1, +1, -1, +1);
+
+	mat4 inv = mat4(inv0 * sa, inv1 * sb, inv2 * sa, inv3 * sb);
+
+	vec4 r0 = vec4(inv[0].x, inv[1].x, inv[2].x, inv[3].x);
+	vec4 d0 = vec4(m[0] * r0);
+
+	highp float d1 = (d0.x + d0.y) + (d0.z + d0.w);
+	highp float d = 1.0 / d1;
+
+	return inv * d;
+}
+
+#endif
+
+#ifndef USE_GLES_OVER_GL
+
+#if defined(TRANSPOSE_USED)
+
+highp mat2 transpose(highp mat2 m) {
+	return mat2(
+			vec2(m[0].x, m[1].x),
+			vec2(m[0].y, m[1].y));
+}
+
+highp mat3 transpose(highp mat3 m) {
+	return mat3(
+			vec3(m[0].x, m[1].x, m[2].x),
+			vec3(m[0].y, m[1].y, m[2].y),
+			vec3(m[0].z, m[1].z, m[2].z));
+}
+
+#endif
+
+highp mat4 transpose(highp mat4 m) {
+	return mat4(
+			vec4(m[0].x, m[1].x, m[2].x, m[3].x),
+			vec4(m[0].y, m[1].y, m[2].y, m[3].y),
+			vec4(m[0].z, m[1].z, m[2].z, m[3].z),
+			vec4(m[0].w, m[1].w, m[2].w, m[3].w));
+}
+
+#if defined(OUTER_PRODUCT_USED)
+
+highp mat2 outerProduct(highp vec2 c, highp vec2 r) {
+	return mat2(c * r.x, c * r.y);
+}
+
+highp mat3 outerProduct(highp vec3 c, highp vec3 r) {
+	return mat3(c * r.x, c * r.y, c * r.z);
+}
+
+highp mat4 outerProduct(highp vec4 c, highp vec4 r) {
+	return mat4(c * r.x, c * r.y, c * r.z, c * r.w);
+}
+
+#endif
+
+#endif
diff --git a/drivers/opengl/shaders/tonemap.glsl b/drivers/opengl/shaders/tonemap.glsl
new file mode 100644
index 0000000000..0117bdb3d3
--- /dev/null
+++ b/drivers/opengl/shaders/tonemap.glsl
@@ -0,0 +1,343 @@
+/* clang-format off */
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+precision highp float;
+precision highp int;
+#endif
+
+attribute vec2 vertex_attrib; // attrib:0
+/* clang-format on */
+attribute vec2 uv_in; // attrib:4
+
+varying vec2 uv_interp;
+
+void main() {
+	gl_Position = vec4(vertex_attrib, 0.0, 1.0);
+
+	uv_interp = uv_in;
+}
+
+/* clang-format off */
+[fragment]
+
+// texture2DLodEXT and textureCubeLodEXT are fragment shader specific.
+// Do not copy these defines in the vertex section.
+#ifndef USE_GLES_OVER_GL
+#ifdef GL_EXT_shader_texture_lod
+#extension GL_EXT_shader_texture_lod : enable
+#define texture2DLod(img, coord, lod) texture2DLodEXT(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCubeLodEXT(img, coord, lod)
+#endif
+#endif // !USE_GLES_OVER_GL
+
+#ifdef GL_ARB_shader_texture_lod
+#extension GL_ARB_shader_texture_lod : enable
+#endif
+
+#if !defined(GL_EXT_shader_texture_lod) && !defined(GL_ARB_shader_texture_lod)
+#define texture2DLod(img, coord, lod) texture2D(img, coord, lod)
+#define textureCubeLod(img, coord, lod) textureCube(img, coord, lod)
+#endif
+
+// Allows the use of bitshift operators for bicubic upscale
+#ifdef GL_EXT_gpu_shader4
+#extension GL_EXT_gpu_shader4 : enable
+#endif
+
+#ifdef USE_GLES_OVER_GL
+#define lowp
+#define mediump
+#define highp
+#else
+#if defined(USE_HIGHP_PRECISION)
+precision highp float;
+precision highp int;
+#else
+precision mediump float;
+precision mediump int;
+#endif
+#endif
+
+#include "stdlib.glsl"
+
+varying vec2 uv_interp;
+/* clang-format on */
+
+uniform highp sampler2D source; //texunit:0
+
+#if defined(USE_GLOW_LEVEL1) || defined(USE_GLOW_LEVEL2) || defined(USE_GLOW_LEVEL3) || defined(USE_GLOW_LEVEL4) || defined(USE_GLOW_LEVEL5) || defined(USE_GLOW_LEVEL6) || defined(USE_GLOW_LEVEL7)
+#define USING_GLOW // only use glow when at least one glow level is selected
+
+#ifdef USE_MULTI_TEXTURE_GLOW
+uniform highp sampler2D source_glow1; //texunit:2
+uniform highp sampler2D source_glow2; //texunit:3
+uniform highp sampler2D source_glow3; //texunit:4
+uniform highp sampler2D source_glow4; //texunit:5
+uniform highp sampler2D source_glow5; //texunit:6
+uniform highp sampler2D source_glow6; //texunit:7
+#ifdef USE_GLOW_LEVEL7
+uniform highp sampler2D source_glow7; //texunit:8
+#endif
+#else
+uniform highp sampler2D source_glow; //texunit:2
+#endif
+uniform highp float glow_intensity;
+#endif
+
+#ifdef USE_BCS
+uniform vec3 bcs;
+#endif
+
+#ifdef USE_FXAA
+uniform vec2 pixel_size;
+#endif
+
+#ifdef USE_COLOR_CORRECTION
+uniform sampler2D color_correction; //texunit:1
+#endif
+
+#ifdef GL_EXT_gpu_shader4
+#ifdef USE_GLOW_FILTER_BICUBIC
+// w0, w1, w2, and w3 are the four cubic B-spline basis functions
+float w0(float a) {
+	return (1.0 / 6.0) * (a * (a * (-a + 3.0) - 3.0) + 1.0);
+}
+
+float w1(float a) {
+	return (1.0 / 6.0) * (a * a * (3.0 * a - 6.0) + 4.0);
+}
+
+float w2(float a) {
+	return (1.0 / 6.0) * (a * (a * (-3.0 * a + 3.0) + 3.0) + 1.0);
+}
+
+float w3(float a) {
+	return (1.0 / 6.0) * (a * a * a);
+}
+
+// g0 and g1 are the two amplitude functions
+float g0(float a) {
+	return w0(a) + w1(a);
+}
+
+float g1(float a) {
+	return w2(a) + w3(a);
+}
+
+// h0 and h1 are the two offset functions
+float h0(float a) {
+	return -1.0 + w1(a) / (w0(a) + w1(a));
+}
+
+float h1(float a) {
+	return 1.0 + w3(a) / (w2(a) + w3(a));
+}
+
+uniform ivec2 glow_texture_size;
+
+vec4 texture2D_bicubic(sampler2D tex, vec2 uv, int p_lod) {
+	float lod = float(p_lod);
+	vec2 tex_size = vec2(glow_texture_size >> p_lod);
+	vec2 texel_size = vec2(1.0) / tex_size;
+
+	uv = uv * tex_size + vec2(0.5);
+
+	vec2 iuv = floor(uv);
+	vec2 fuv = fract(uv);
+
+	float g0x = g0(fuv.x);
+	float g1x = g1(fuv.x);
+	float h0x = h0(fuv.x);
+	float h1x = h1(fuv.x);
+	float h0y = h0(fuv.y);
+	float h1y = h1(fuv.y);
+
+	vec2 p0 = (vec2(iuv.x + h0x, iuv.y + h0y) - vec2(0.5)) * texel_size;
+	vec2 p1 = (vec2(iuv.x + h1x, iuv.y + h0y) - vec2(0.5)) * texel_size;
+	vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - vec2(0.5)) * texel_size;
+	vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - vec2(0.5)) * texel_size;
+
+	return (g0(fuv.y) * (g0x * texture2DLod(tex, p0, lod) + g1x * texture2DLod(tex, p1, lod))) +
+		   (g1(fuv.y) * (g0x * texture2DLod(tex, p2, lod) + g1x * texture2DLod(tex, p3, lod)));
+}
+
+#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2D_bicubic(m_tex, m_uv, m_lod)
+#else //!USE_GLOW_FILTER_BICUBIC
+#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2DLod(m_tex, m_uv, float(m_lod))
+#endif //USE_GLOW_FILTER_BICUBIC
+
+#else //!GL_EXT_gpu_shader4
+#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2DLod(m_tex, m_uv, float(m_lod))
+#endif //GL_EXT_gpu_shader4
+
+vec3 apply_glow(vec3 color, vec3 glow) { // apply glow using the selected blending mode
+#ifdef USE_GLOW_REPLACE
+	color = glow;
+#endif
+
+#ifdef USE_GLOW_SCREEN
+	color = max((color + glow) - (color * glow), vec3(0.0));
+#endif
+
+#ifdef USE_GLOW_SOFTLIGHT
+	glow = glow * vec3(0.5) + vec3(0.5);
+
+	color.r = (glow.r <= 0.5) ? (color.r - (1.0 - 2.0 * glow.r) * color.r * (1.0 - color.r)) : (((glow.r > 0.5) && (color.r <= 0.25)) ? (color.r + (2.0 * glow.r - 1.0) * (4.0 * color.r * (4.0 * color.r + 1.0) * (color.r - 1.0) + 7.0 * color.r)) : (color.r + (2.0 * glow.r - 1.0) * (sqrt(color.r) - color.r)));
+	color.g = (glow.g <= 0.5) ? (color.g - (1.0 - 2.0 * glow.g) * color.g * (1.0 - color.g)) : (((glow.g > 0.5) && (color.g <= 0.25)) ? (color.g + (2.0 * glow.g - 1.0) * (4.0 * color.g * (4.0 * color.g + 1.0) * (color.g - 1.0) + 7.0 * color.g)) : (color.g + (2.0 * glow.g - 1.0) * (sqrt(color.g) - color.g)));
+	color.b = (glow.b <= 0.5) ? (color.b - (1.0 - 2.0 * glow.b) * color.b * (1.0 - color.b)) : (((glow.b > 0.5) && (color.b <= 0.25)) ? (color.b + (2.0 * glow.b - 1.0) * (4.0 * color.b * (4.0 * color.b + 1.0) * (color.b - 1.0) + 7.0 * color.b)) : (color.b + (2.0 * glow.b - 1.0) * (sqrt(color.b) - color.b)));
+#endif
+
+#if !defined(USE_GLOW_SCREEN) && !defined(USE_GLOW_SOFTLIGHT) && !defined(USE_GLOW_REPLACE) // no other selected -> additive
+	color += glow;
+#endif
+
+	return color;
+}
+
+vec3 apply_bcs(vec3 color, vec3 bcs) {
+	color = mix(vec3(0.0), color, bcs.x);
+	color = mix(vec3(0.5), color, bcs.y);
+	color = mix(vec3(dot(vec3(1.0), color) * 0.33333), color, bcs.z);
+
+	return color;
+}
+
+vec3 apply_color_correction(vec3 color, sampler2D correction_tex) {
+	color.r = texture2D(correction_tex, vec2(color.r, 0.0)).r;
+	color.g = texture2D(correction_tex, vec2(color.g, 0.0)).g;
+	color.b = texture2D(correction_tex, vec2(color.b, 0.0)).b;
+
+	return color;
+}
+
+vec3 apply_fxaa(vec3 color, vec2 uv_interp, vec2 pixel_size) {
+	const float FXAA_REDUCE_MIN = (1.0 / 128.0);
+	const float FXAA_REDUCE_MUL = (1.0 / 8.0);
+	const float FXAA_SPAN_MAX = 8.0;
+
+	vec3 rgbNW = texture2DLod(source, uv_interp + vec2(-1.0, -1.0) * pixel_size, 0.0).xyz;
+	vec3 rgbNE = texture2DLod(source, uv_interp + vec2(1.0, -1.0) * pixel_size, 0.0).xyz;
+	vec3 rgbSW = texture2DLod(source, uv_interp + vec2(-1.0, 1.0) * pixel_size, 0.0).xyz;
+	vec3 rgbSE = texture2DLod(source, uv_interp + vec2(1.0, 1.0) * pixel_size, 0.0).xyz;
+	vec3 rgbM = color;
+	vec3 luma = vec3(0.299, 0.587, 0.114);
+	float lumaNW = dot(rgbNW, luma);
+	float lumaNE = dot(rgbNE, luma);
+	float lumaSW = dot(rgbSW, luma);
+	float lumaSE = dot(rgbSE, luma);
+	float lumaM = dot(rgbM, luma);
+	float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+	float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+
+	vec2 dir;
+	dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+	dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+
+	float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) *
+								  (0.25 * FXAA_REDUCE_MUL),
+			FXAA_REDUCE_MIN);
+
+	float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);
+	dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),
+				  max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
+						  dir * rcpDirMin)) *
+		  pixel_size;
+
+	vec3 rgbA = 0.5 * (texture2DLod(source, uv_interp + dir * (1.0 / 3.0 - 0.5), 0.0).xyz + texture2DLod(source, uv_interp + dir * (2.0 / 3.0 - 0.5), 0.0).xyz);
+	vec3 rgbB = rgbA * 0.5 + 0.25 * (texture2DLod(source, uv_interp + dir * -0.5, 0.0).xyz +
+											texture2DLod(source, uv_interp + dir * 0.5, 0.0).xyz);
+
+	float lumaB = dot(rgbB, luma);
+	if ((lumaB < lumaMin) || (lumaB > lumaMax)) {
+		return rgbA;
+	} else {
+		return rgbB;
+	}
+}
+
+void main() {
+	vec3 color = texture2DLod(source, uv_interp, 0.0).rgb;
+
+#ifdef USE_FXAA
+	color = apply_fxaa(color, uv_interp, pixel_size);
+#endif
+
+	// Glow
+
+#ifdef USING_GLOW
+	vec3 glow = vec3(0.0);
+#ifdef USE_MULTI_TEXTURE_GLOW
+#ifdef USE_GLOW_LEVEL1
+	glow += GLOW_TEXTURE_SAMPLE(source_glow1, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL2
+	glow += GLOW_TEXTURE_SAMPLE(source_glow2, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL3
+	glow += GLOW_TEXTURE_SAMPLE(source_glow3, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL4
+	glow += GLOW_TEXTURE_SAMPLE(source_glow4, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL5
+	glow += GLOW_TEXTURE_SAMPLE(source_glow5, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL6
+	glow += GLOW_TEXTURE_SAMPLE(source_glow6, uv_interp, 0).rgb;
+#ifdef USE_GLOW_LEVEL7
+	glow += GLOW_TEXTURE_SAMPLE(source_glow7, uv_interp, 0).rgb;
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#else
+
+#ifdef USE_GLOW_LEVEL1
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 1).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL2
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 2).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL3
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 3).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL4
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 4).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL5
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 5).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL6
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 6).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL7
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 7).rgb;
+#endif
+#endif //USE_MULTI_TEXTURE_GLOW
+
+	glow *= glow_intensity;
+	color = apply_glow(color, glow);
+#endif
+
+	// Additional effects
+
+#ifdef USE_BCS
+	color = apply_bcs(color, bcs);
+#endif
+
+#ifdef USE_COLOR_CORRECTION
+	color = apply_color_correction(color, color_correction);
+#endif
+
+	gl_FragColor = vec4(color, 1.0);
+}