asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Style: Fix code formatting in GLES3 shaders

Browse source
This commit is contained in:
Rémi Verschelde 2018-08-24 13:42:18 +02:00
parent f123694b4e
commit 1b6d75a599
17 changed files with 1552 additions and 1923 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
drivers/gles3/shaders/blend_shape.glsl
View file

@ -1,6 +1,5 @@
[vertex]
/*
from VisualServer:
@ -23,56 +22,56 @@ ARRAY_INDEX=8,
/* INPUT ATTRIBS */
layout(location=0) in highp VFORMAT vertex_attrib;
layout(location=1) in vec3 normal_attrib;
layout(location = 0) in highp VFORMAT vertex_attrib;
layout(location = 1) in vec3 normal_attrib;
#ifdef ENABLE_TANGENT
layout(location=2) in vec4 tangent_attrib;
layout(location = 2) in vec4 tangent_attrib;
#endif
#ifdef ENABLE_COLOR
layout(location=3) in vec4 color_attrib;
layout(location = 3) in vec4 color_attrib;
#endif
#ifdef ENABLE_UV
layout(location=4) in vec2 uv_attrib;
layout(location = 4) in vec2 uv_attrib;
#endif
#ifdef ENABLE_UV2
layout(location=5) in vec2 uv2_attrib;
layout(location = 5) in vec2 uv2_attrib;
#endif
#ifdef ENABLE_SKELETON
layout(location=6) in ivec4 bone_attrib;
layout(location=7) in vec4 weight_attrib;
layout(location = 6) in ivec4 bone_attrib;
layout(location = 7) in vec4 weight_attrib;
#endif
/* BLEND ATTRIBS */
#ifdef ENABLE_BLEND
layout(location=8) in highp VFORMAT vertex_attrib_blend;
layout(location=9) in vec3 normal_attrib_blend;
layout(location = 8) in highp VFORMAT vertex_attrib_blend;
layout(location = 9) in vec3 normal_attrib_blend;
#ifdef ENABLE_TANGENT
layout(location=10) in vec4 tangent_attrib_blend;
layout(location = 10) in vec4 tangent_attrib_blend;
#endif
#ifdef ENABLE_COLOR
layout(location=11) in vec4 color_attrib_blend;
layout(location = 11) in vec4 color_attrib_blend;
#endif
#ifdef ENABLE_UV
layout(location=12) in vec2 uv_attrib_blend;
layout(location = 12) in vec2 uv_attrib_blend;
#endif
#ifdef ENABLE_UV2
layout(location=13) in vec2 uv2_attrib_blend;
layout(location = 13) in vec2 uv2_attrib_blend;
#endif
#ifdef ENABLE_SKELETON
layout(location=14) in ivec4 bone_attrib_blend;
layout(location=15) in vec4 weight_attrib_blend;
layout(location = 14) in ivec4 bone_attrib_blend;
layout(location = 15) in vec4 weight_attrib_blend;
#endif
#endif
@ -110,7 +109,6 @@ uniform float blend_amount;
void main() {
#ifdef ENABLE_BLEND
vertex_out = vertex_attrib_blend + vertex_attrib * blend_amount;
@ -140,7 +138,6 @@ void main() {
uv2_out = uv2_attrib_blend + uv2_attrib * blend_amount;
#endif
#ifdef ENABLE_SKELETON
bone_out = bone_attrib_blend;
@ -149,7 +146,6 @@ void main() {
#else //ENABLE_BLEND
vertex_out = vertex_attrib * blend_amount;
#ifdef ENABLE_NORMAL
@ -177,7 +173,6 @@ void main() {
uv2_out = uv2_attrib * blend_amount;
#endif
#ifdef ENABLE_SKELETON
bone_out = bone_attrib;
@ -190,8 +185,6 @@ void main() {
[fragment]
void main() {
}

374
drivers/gles3/shaders/canvas.glsl
View file

@ -1,12 +1,11 @@
[vertex]
layout(location=0) in highp vec2 vertex;
layout(location=3) in vec4 color_attrib;
layout(location = 0) in highp vec2 vertex;
layout(location = 3) in vec4 color_attrib;
#ifdef USE_SKELETON
layout(location=6) in uvec4 bone_indices; // attrib:6
layout(location=7) in vec4 bone_weights; // attrib:7
layout(location = 6) in uvec4 bone_indices; // attrib:6
layout(location = 7) in vec4 bone_weights; // attrib:7
#endif
#ifdef USE_TEXTURE_RECT
@ -18,25 +17,24 @@ uniform vec4 src_rect;
#ifdef USE_INSTANCING
layout(location=8) in highp vec4 instance_xform0;
layout(location=9) in highp vec4 instance_xform1;
layout(location=10) in highp vec4 instance_xform2;
layout(location=11) in lowp vec4 instance_color;
layout(location = 8) in highp vec4 instance_xform0;
layout(location = 9) in highp vec4 instance_xform1;
layout(location = 10) in highp vec4 instance_xform2;
layout(location = 11) in lowp vec4 instance_color;
#ifdef USE_INSTANCE_CUSTOM
layout(location=12) in highp vec4 instance_custom_data;
layout(location = 12) in highp vec4 instance_custom_data;
#endif
#endif
layout(location=4) in highp vec2 uv_attrib;
layout(location = 4) in highp vec2 uv_attrib;
//skeletn
// skeleton
#endif
uniform highp vec2 color_texpixel_size;
layout(std140) uniform CanvasItemData { //ubo:0
highp mat4 projection_matrix;
@ -46,7 +44,6 @@ layout(std140) uniform CanvasItemData { //ubo:0
uniform highp mat4 modelview_matrix;
uniform highp mat4 extra_matrix;
out highp vec2 uv_interp;
out mediump vec4 color_interp;
@ -55,7 +52,6 @@ out mediump vec4 color_interp;
out highp vec2 pixel_size_interp;
#endif
#ifdef USE_SKELETON
uniform mediump sampler2D skeleton_texture; // texunit:-1
uniform highp mat4 skeleton_transform;
@ -66,7 +62,7 @@ uniform highp mat4 skeleton_transform_inverse;
layout(std140) uniform LightData { //ubo:1
//light matrices
// light matrices
highp mat4 light_matrix;
highp mat4 light_local_matrix;
highp mat4 shadow_matrix;
@ -80,11 +76,9 @@ layout(std140) uniform LightData { //ubo:1
highp float shadow_distance_mult;
};
out vec4 light_uv_interp;
out vec2 transformed_light_uv;
out vec4 local_rot;
#ifdef USE_SHADOWS
@ -101,7 +95,6 @@ uniform int h_frames;
uniform int v_frames;
#endif
#if defined(USE_MATERIAL)
layout(std140) uniform UniformData { //ubo:2
@ -112,7 +105,6 @@ MATERIAL_UNIFORMS
#endif
VERTEX_SHADER_GLOBALS
void main() {
@ -120,8 +112,8 @@ void main() {
vec4 color = color_attrib;
#ifdef USE_INSTANCING
mat4 extra_matrix2 = extra_matrix * transpose(mat4(instance_xform0,instance_xform1,instance_xform2,vec4(0.0,0.0,0.0,1.0)));
color*=instance_color;
mat4 extra_matrix2 = extra_matrix * transpose(mat4(instance_xform0, instance_xform1, instance_xform2, vec4(0.0, 0.0, 0.0, 1.0)));
color *= instance_color;
vec4 instance_custom = instance_custom_data;
#else
@ -136,29 +128,27 @@ void main() {
} else {
uv_interp = src_rect.xy + abs(src_rect.zw) * vertex;
}
highp vec4 outvec = vec4(dst_rect.xy + abs(dst_rect.zw) * mix(vertex,vec2(1.0,1.0)-vertex,lessThan(src_rect.zw,vec2(0.0,0.0))),0.0,1.0);
highp vec4 outvec = vec4(dst_rect.xy + abs(dst_rect.zw) * mix(vertex, vec2(1.0, 1.0) - vertex, lessThan(src_rect.zw, vec2(0.0, 0.0))), 0.0, 1.0);
#else
uv_interp = uv_attrib;
highp vec4 outvec = vec4(vertex,0.0,1.0);
highp vec4 outvec = vec4(vertex, 0.0, 1.0);
#endif
#ifdef USE_PARTICLES
//scale by texture size
outvec.xy/=color_texpixel_size;
outvec.xy /= color_texpixel_size;
//compute h and v frames and adjust UV interp for animation
int total_frames = h_frames * v_frames;
int frame = min(int(float(total_frames) *instance_custom.z),total_frames-1);
float frame_w = 1.0/float(h_frames);
float frame_h = 1.0/float(v_frames);
int frame = min(int(float(total_frames) * instance_custom.z), total_frames - 1);
float frame_w = 1.0 / float(h_frames);
float frame_h = 1.0 / float(v_frames);
uv_interp.x = uv_interp.x * frame_w + frame_w * float(frame % h_frames);
uv_interp.y = uv_interp.y * frame_h + frame_h * float(frame / h_frames);
#endif
#define extra_matrix extra_matrix2
{
@ -167,10 +157,9 @@ VERTEX_SHADER_CODE
}
#ifdef USE_NINEPATCH
pixel_size_interp=abs(dst_rect.zw) * vertex;
pixel_size_interp = abs(dst_rect.zw) * vertex;
#endif
#if !defined(SKIP_TRANSFORM_USED)
@ -184,47 +173,46 @@ VERTEX_SHADER_CODE
#ifdef USE_PIXEL_SNAP
outvec.xy=floor(outvec+0.5).xy;
outvec.xy = floor(outvec + 0.5).xy;
#endif
#ifdef USE_SKELETON
if (bone_weights!=vec4(0.0)){ //must be a valid bone
if (bone_weights != vec4(0.0)) { //must be a valid bone
//skeleton transform
ivec4 bone_indicesi = ivec4(bone_indices);
ivec2 tex_ofs = ivec2( bone_indicesi.x%256, (bone_indicesi.x/256)*2 );
ivec2 tex_ofs = ivec2(bone_indicesi.x % 256, (bone_indicesi.x / 256) * 2);
highp mat2x4 m = mat2x4(
texelFetch(skeleton_texture,tex_ofs,0),
texelFetch(skeleton_texture,tex_ofs+ivec2(0,1),0)
) * bone_weights.x;
highp mat2x4 m;
m = mat2x4(
texelFetch(skeleton_texture, tex_ofs, 0),
texelFetch(skeleton_texture, tex_ofs + ivec2(0, 1), 0))
* bone_weights.x;
tex_ofs = ivec2( bone_indicesi.y%256, (bone_indicesi.y/256)*2 );
tex_ofs = ivec2(bone_indicesi.y % 256, (bone_indicesi.y / 256) * 2);
m+= mat2x4(
texelFetch(skeleton_texture,tex_ofs,0),
texelFetch(skeleton_texture,tex_ofs+ivec2(0,1),0)
) * bone_weights.y;
m += mat2x4(
texelFetch(skeleton_texture, tex_ofs, 0),
texelFetch(skeleton_texture, tex_ofs + ivec2(0, 1), 0))
* bone_weights.y;
tex_ofs = ivec2( bone_indicesi.z%256, (bone_indicesi.z/256)*2 );
tex_ofs = ivec2(bone_indicesi.z % 256, (bone_indicesi.z / 256) * 2);
m+= mat2x4(
texelFetch(skeleton_texture,tex_ofs,0),
texelFetch(skeleton_texture,tex_ofs+ivec2(0,1),0)
) * bone_weights.z;
m += mat2x4(
texelFetch(skeleton_texture, tex_ofs, 0),
texelFetch(skeleton_texture, tex_ofs + ivec2(0, 1), 0))
* bone_weights.z;
tex_ofs = ivec2(bone_indicesi.w % 256, (bone_indicesi.w / 256) * 2);
tex_ofs = ivec2( bone_indicesi.w%256, (bone_indicesi.w/256)*2 );
m += mat2x4(
texelFetch(skeleton_texture, tex_ofs, 0),
texelFetch(skeleton_texture, tex_ofs + ivec2(0, 1), 0))
* bone_weights.w;
m+= mat2x4(
texelFetch(skeleton_texture,tex_ofs,0),
texelFetch(skeleton_texture,tex_ofs+ivec2(0,1),0)
) * bone_weights.w;
mat4 bone_matrix = skeleton_transform * transpose(mat4(m[0],m[1],vec4(0.0,0.0,1.0,0.0),vec4(0.0,0.0,0.0,1.0))) * skeleton_transform_inverse;
mat4 bone_matrix = skeleton_transform * transpose(mat4(m[0], m[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))) * skeleton_transform_inverse;
outvec = bone_matrix * outvec;
}
@ -236,45 +224,37 @@ VERTEX_SHADER_CODE
#ifdef USE_LIGHTING
light_uv_interp.xy = (light_matrix * outvec).xy;
light_uv_interp.zw =(light_local_matrix * outvec).xy;
light_uv_interp.zw = (light_local_matrix * outvec).xy;
mat3 inverse_light_matrix = mat3(inverse(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]);
transformed_light_uv = (inverse_light_matrix * vec3(light_uv_interp.zw,0.0)).xy; //for normal mapping
transformed_light_uv = (inverse_light_matrix * vec3(light_uv_interp.zw, 0.0)).xy; //for normal mapping
#ifdef USE_SHADOWS
pos=outvec.xy;
pos = outvec.xy;
#endif
local_rot.xy=normalize( (modelview_matrix * ( extra_matrix * vec4(1.0,0.0,0.0,0.0) )).xy );
local_rot.zw=normalize( (modelview_matrix * ( extra_matrix * vec4(0.0,1.0,0.0,0.0) )).xy );
local_rot.xy = normalize((modelview_matrix * (extra_matrix * vec4(1.0, 0.0, 0.0, 0.0))).xy);
local_rot.zw = normalize((modelview_matrix * (extra_matrix * 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);
local_rot.xy *= sign(src_rect.z);
local_rot.zw *= sign(src_rect.w);
#endif
#endif
}
[fragment]
uniform mediump sampler2D color_texture; // texunit:0
uniform highp vec2 color_texpixel_size;
uniform mediump sampler2D normal_texture; // texunit:1
in highp vec2 uv_interp;
in mediump vec4 color_interp;
#if defined(SCREEN_TEXTURE_USED)
uniform sampler2D screen_texture; // texunit:-3
@ -292,7 +272,6 @@ layout(std140) uniform CanvasItemData {
highp float time;
};
#ifdef USE_LIGHTING
layout(std140) uniform LightData {
@ -314,10 +293,8 @@ uniform lowp sampler2D light_texture; // texunit:-1
in vec4 light_uv_interp;
in vec2 transformed_light_uv;
in vec4 local_rot;
#ifdef USE_SHADOWS
uniform highp sampler2D shadow_texture; // texunit:-2
@ -332,11 +309,7 @@ const bool at_light_pass = false;
uniform mediump vec4 final_modulate;
layout(location=0) out mediump vec4 frag_color;
layout(location = 0) out mediump vec4 frag_color;
#if defined(USE_MATERIAL)
@ -369,7 +342,6 @@ void light_compute(
LIGHT_SHADER_CODE
#endif
}
#ifdef USE_TEXTURE_RECT
@ -385,48 +357,44 @@ in highp vec2 pixel_size_interp;
uniform int np_repeat_v;
uniform int np_repeat_h;
uniform bool np_draw_center;
//left top right bottom in pixel coordinates
// left top right bottom in pixel coordinates
uniform vec4 np_margins;
float map_ninepatch_axis(float pixel, float draw_size, float tex_pixel_size, float margin_begin, float margin_end, int np_repeat, inout int draw_center) {
float map_ninepatch_axis(float pixel, float draw_size,float tex_pixel_size,float margin_begin,float margin_end,int np_repeat,inout int draw_center) {
float tex_size = 1.0/tex_pixel_size;
float tex_size = 1.0 / tex_pixel_size;
if (pixel < margin_begin) {
return pixel * tex_pixel_size;
} else if (pixel >= draw_size-margin_end) {
return (tex_size-(draw_size-pixel)) * tex_pixel_size;
} else if (pixel >= draw_size - margin_end) {
return (tex_size - (draw_size - pixel)) * tex_pixel_size;
} else {
if (!np_draw_center){
if (!np_draw_center) {
draw_center--;
}
if (np_repeat==0) { //stretch
if (np_repeat == 0) { //stretch
//convert to ratio
float ratio = (pixel - margin_begin) / (draw_size - margin_begin - margin_end);
//scale to source texture
return (margin_begin + ratio * (tex_size - margin_begin - margin_end)) * tex_pixel_size;
} else if (np_repeat==1) { //tile
} else if (np_repeat == 1) { //tile
//convert to ratio
float ofs = mod((pixel - margin_begin), tex_size - margin_begin - margin_end);
//scale to source texture
return (margin_begin + ofs) * tex_pixel_size;
} else if (np_repeat==2) { //tile fit
} else if (np_repeat == 2) { //tile fit
//convert to ratio
float src_area = draw_size - margin_begin - margin_end;
float dst_area = tex_size - margin_begin - margin_end;
float scale = max(1.0,floor(src_area / max(dst_area,0.0000001) + 0.5));
float scale = max(1.0, floor(src_area / max(dst_area, 0.0000001) + 0.5));
//convert to ratio
float ratio = (pixel - margin_begin) / src_area;
ratio = mod(ratio * scale,1.0);
ratio = mod(ratio * scale, 1.0);
return (margin_begin + ratio * dst_area) * tex_pixel_size;
}
}
}
#endif
@ -443,42 +411,39 @@ void main() {
#ifdef USE_NINEPATCH
int draw_center=2;
int draw_center = 2;
uv = vec2(
map_ninepatch_axis(pixel_size_interp.x,abs(dst_rect.z),color_texpixel_size.x,np_margins.x,np_margins.z,np_repeat_h,draw_center),
map_ninepatch_axis(pixel_size_interp.y,abs(dst_rect.w),color_texpixel_size.y,np_margins.y,np_margins.w,np_repeat_v,draw_center)
);
map_ninepatch_axis(pixel_size_interp.x, abs(dst_rect.z), color_texpixel_size.x, np_margins.x, np_margins.z, np_repeat_h, draw_center),
map_ninepatch_axis(pixel_size_interp.y, abs(dst_rect.w), color_texpixel_size.y, np_margins.y, np_margins.w, np_repeat_v, draw_center));
if (draw_center==0) {
color.a=0.0;
if (draw_center == 0) {
color.a = 0.0;
}
uv = uv*src_rect.zw+src_rect.xy; //apply region if needed
uv = uv * src_rect.zw + src_rect.xy; //apply region if needed
#endif
if (clip_rect_uv) {
uv = clamp(uv,src_rect.xy,src_rect.xy+abs(src_rect.zw));
uv = clamp(uv, src_rect.xy, src_rect.xy + abs(src_rect.zw));
}
#endif
#if !defined(COLOR_USED)
//default behavior, texture by color
//default behavior, texture by color
#ifdef USE_DISTANCE_FIELD
const float smoothing = 1.0/32.0;
float distance = textureLod(color_texture, uv,0.0).a;
const float smoothing = 1.0 / 32.0;
float distance = textureLod(color_texture, uv, 0.0).a;
color.a = smoothstep(0.5 - smoothing, 0.5 + smoothing, distance) * color.a;
#else
color *= texture( color_texture, uv );
color *= texture(color_texture, uv);
#endif
#endif
vec3 normal;
#if defined(NORMAL_USED)
@ -489,59 +454,52 @@ void main() {
#endif
if (use_default_normal) {
normal.xy = textureLod(normal_texture, uv,0.0).xy * 2.0 - 1.0;
normal.z = sqrt(1.0-dot(normal.xy,normal.xy));
normal_used=true;
normal.xy = textureLod(normal_texture, uv, 0.0).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);
normal = vec3(0.0, 0.0, 1.0);
}
#if defined(SCREEN_UV_USED)
vec2 screen_uv = gl_FragCoord.xy*screen_pixel_size;
vec2 screen_uv = gl_FragCoord.xy * screen_pixel_size;
#endif
{
float normal_depth=1.0;
{
float normal_depth = 1.0;
#if defined(NORMALMAP_USED)
vec3 normal_map=vec3(0.0,0.0,1.0);
vec3 normal_map = vec3(0.0, 0.0, 1.0);
#endif
FRAGMENT_SHADER_CODE
#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 );
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 DEBUG_ENCODED_32
highp float enc32 = dot( color,highp vec4(1.0 / (256.0 * 256.0 * 256.0),1.0 / (256.0 * 256.0),1.0 / 256.0,1) );
color = vec4(vec3(enc32),1.0);
highp float enc32 = dot(color, highp vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1));
color = vec4(vec3(enc32), 1.0);
#endif
color*=final_modulate;
color *= final_modulate;
#ifdef USE_LIGHTING
vec2 light_vec = transformed_light_uv;
if (normal_used) {
normal.xy = mat2(local_rot.xy,local_rot.zw) * normal.xy;
normal.xy = mat2(local_rot.xy, local_rot.zw) * normal.xy;
}
float att=1.0;
float att = 1.0;
vec2 light_uv = light_uv_interp.xy;
vec4 light = texture(light_texture,light_uv);
vec4 light = texture(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
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;
@ -549,7 +507,7 @@ FRAGMENT_SHADER_CODE
vec4 real_light_shadow_color = light_shadow_color;
#if defined(USE_LIGHT_SHADER_CODE)
//light is written by the light shader
//light is written by the light shader
light_compute(
light,
light_vec,
@ -568,159 +526,157 @@ FRAGMENT_SHADER_CODE
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);
vec3 light_normal = normalize(vec3(light_vec, -real_light_height));
light *= max(dot(-light_normal, normal), 0.0);
}
color*=light;
color *= light;
#ifdef USE_SHADOWS
light_vec = light_uv_interp.zw; //for shadows
float angle_to_light = -atan(light_vec.x,light_vec.y);
float angle_to_light = -atan(light_vec.x, light_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 su, sz;
float abs_angle = abs(angle_to_light);
vec2 point;
float sh;
if (abs_angle<45.0*PI/180.0) {
if (abs_angle < 45.0 * PI / 180.0) {
point = light_vec;
sh=0.0+(1.0/8.0);
} else if (abs_angle>135.0*PI/180.0) {
sh = 0.0 + (1.0 / 8.0);
} else if (abs_angle > 135.0 * PI / 180.0) {
point = -light_vec;
sh = 0.5+(1.0/8.0);
} else if (angle_to_light>0.0) {
sh = 0.5 + (1.0 / 8.0);
} else if (angle_to_light > 0.0) {
point = vec2(light_vec.y,-light_vec.x);
sh = 0.25+(1.0/8.0);
point = vec2(light_vec.y, -light_vec.x);
sh = 0.25 + (1.0 / 8.0);
} else {
point = vec2(-light_vec.y,light_vec.x);
sh = 0.75+(1.0/8.0);
point = vec2(-light_vec.y, light_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;
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;
highp float shadow_attenuation = 0.0;
#ifdef USE_RGBA_SHADOWS
#define SHADOW_DEPTH(m_tex,m_uv) dot(texture((m_tex),(m_uv)),vec4(1.0 / (256.0 * 256.0 * 256.0),1.0 / (256.0 * 256.0),1.0 / 256.0,1) )
#define SHADOW_DEPTH(m_tex, m_uv) dot(texture((m_tex), (m_uv)), vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1))
#else
#define SHADOW_DEPTH(m_tex,m_uv) (texture((m_tex),(m_uv)).r)
#define SHADOW_DEPTH(m_tex, m_uv) (texture((m_tex), (m_uv)).r)
#endif
#ifdef SHADOW_USE_GRADIENT
#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); }
#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); }
#define SHADOW_TEST(m_ofs) \
{ \
highp float sd = SHADOW_DEPTH(shadow_texture, vec2(m_ofs, sh)); \
shadow_attenuation += step(sz, sd); \
}
#endif
#ifdef SHADOW_FILTER_NEAREST
SHADOW_TEST(su);
#endif
#ifdef SHADOW_FILTER_PCF3
SHADOW_TEST(su+shadowpixel_size);
SHADOW_TEST(su + shadowpixel_size);
SHADOW_TEST(su);
SHADOW_TEST(su-shadowpixel_size);
shadow_attenuation/=3.0;
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 + 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;
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 + 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;
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 + 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;
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 + 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;
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);
//color *= shadow_attenuation;
color = mix(real_light_shadow_color, color, shadow_attenuation);
//use shadows
#endif
}
//use lighting
#endif
//color.rgb*=color.a;
//color.rgb *= color.a;
frag_color = color;
}

24
drivers/gles3/shaders/canvas_shadow.glsl
View file

@ -1,20 +1,18 @@
[vertex]
uniform highp mat4 projection_matrix;
uniform highp mat4 light_matrix;
uniform highp mat4 world_matrix;
uniform highp float distance_norm;
layout(location=0) in highp vec3 vertex;
layout(location = 0) in highp vec3 vertex;
out highp vec4 position_interp;
void main() {
gl_Position = projection_matrix * (light_matrix * (world_matrix * vec4(vertex,1.0)));
position_interp=gl_Position;
gl_Position = projection_matrix * (light_matrix * (world_matrix * vec4(vertex, 1.0)));
position_interp = gl_Position;
}
[fragment]
@ -22,28 +20,22 @@ void main() {
in highp vec4 position_interp;
#ifdef USE_RGBA_SHADOWS
layout(location=0) out lowp vec4 distance_buf;
layout(location = 0) out lowp vec4 distance_buf;
#else
layout(location=0) out highp float distance_buf;
layout(location = 0) out highp float distance_buf;
#endif
void main() {
highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0;//bias;
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(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0));
comp -= comp.xxyz * vec4(0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
distance_buf=comp;
distance_buf = comp;
#else
distance_buf=depth;
distance_buf = depth;
#endif
}

88
drivers/gles3/shaders/copy.glsl
View file

@ -1,13 +1,12 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location = 0) in highp vec4 vertex_attrib;
#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
layout(location=4) in vec3 cube_in;
layout(location = 4) in vec3 cube_in;
#else
layout(location=4) in vec2 uv_in;
layout(location = 4) in vec2 uv_in;
#endif
layout(location=5) in vec2 uv2_in;
layout(location = 5) in vec2 uv2_in;
#if defined(USE_CUBEMAP) || defined(USE_PANORAMA)
out vec3 cube_interp;
@ -32,7 +31,7 @@ void main() {
#else
uv_interp = uv_in;
#ifdef V_FLIP
uv_interp.y = 1.0-uv_interp.y;
uv_interp.y = 1.0 - uv_interp.y;
#endif
#endif
@ -44,7 +43,6 @@ void main() {
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;
#endif
}
[fragment]
@ -72,38 +70,33 @@ uniform samplerCube source_cube; //texunit:0
uniform sampler2D source; //texunit:0
#endif
#ifdef USE_MULTIPLIER
uniform float multiplier;
#endif
#if defined(USE_PANORAMA) || defined(USE_ASYM_PANO)
vec4 texturePanorama(vec3 normal,sampler2D pano ) {
vec4 texturePanorama(vec3 normal, sampler2D pano) {
vec2 st = vec2(
atan(normal.x, normal.z),
acos(normal.y)
);
acos(normal.y));
if(st.x < 0.0)
st.x += M_PI*2.0;
if (st.x < 0.0)
st.x += M_PI * 2.0;
st/=vec2(M_PI*2.0,M_PI);
return textureLod(pano,st,0.0);
st /= vec2(M_PI * 2.0, M_PI);
return textureLod(pano, st, 0.0);
}
#endif
uniform float stuff;
uniform vec2 pixel_size;
in vec2 uv2_interp;
#ifdef USE_BCS
uniform vec3 bcs;
@ -118,16 +111,13 @@ uniform sampler2D color_correction; //texunit:1
layout(location = 0) out vec4 frag_color;
void main() {
//vec4 color = color_interp;
#ifdef USE_PANORAMA
vec4 color = texturePanorama( normalize(cube_interp), source );
vec4 color = texturePanorama(normalize(cube_interp), source);
#elif defined(USE_ASYM_PANO)
@ -142,72 +132,68 @@ void main() {
cube_normal = mat3(pano_transform) * cube_normal;
cube_normal.z = -cube_normal.z;
vec4 color = texturePanorama( normalize(cube_normal.xyz), source );
vec4 color = texturePanorama(normalize(cube_normal.xyz), source);
#elif defined(USE_CUBEMAP)
vec4 color = texture( source_cube, normalize(cube_interp) );
vec4 color = texture(source_cube, normalize(cube_interp));
#else
vec4 color = textureLod( source, uv_interp,0.0 );
vec4 color = textureLod(source, uv_interp, 0.0);
#endif
#ifdef LINEAR_TO_SRGB
//regular Linear -> SRGB conversion
vec3 a = vec3(0.055);
color.rgb = mix( (vec3(1.0)+a)*pow(color.rgb,vec3(1.0/2.4))-a , 12.92*color.rgb , lessThan(color.rgb,vec3(0.0031308)));
color.rgb = mix((vec3(1.0) + a) * pow(color.rgb, vec3(1.0 / 2.4)) - a, 12.92 * color.rgb, lessThan(color.rgb, vec3(0.0031308)));
#endif
#ifdef SRGB_TO_LINEAR
color.rgb = mix(pow((color.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)),vec3(2.4)),color.rgb * (1.0 / 12.92),lessThan(color.rgb,vec3(0.04045)));
color.rgb = mix(pow((color.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), color.rgb * (1.0 / 12.92), lessThan(color.rgb, vec3(0.04045)));
#endif
#ifdef DEBUG_GRADIENT
color.rg=uv_interp;
color.b=0.0;
color.rg = uv_interp;
color.b = 0.0;
#endif
#ifdef DISABLE_ALPHA
color.a=1.0;
color.a = 1.0;
#endif
#ifdef GAUSSIAN_HORIZONTAL
color*=0.38774;
color+=texture( source, uv_interp+vec2( 1.0, 0.0)*pixel_size )*0.24477;
color+=texture( source, uv_interp+vec2( 2.0, 0.0)*pixel_size )*0.06136;
color+=texture( source, uv_interp+vec2(-1.0, 0.0)*pixel_size )*0.24477;
color+=texture( source, uv_interp+vec2(-2.0, 0.0)*pixel_size )*0.06136;
color *= 0.38774;
color += texture(source, uv_interp + vec2(1.0, 0.0) * pixel_size) * 0.24477;
color += texture(source, uv_interp + vec2(2.0, 0.0) * pixel_size) * 0.06136;
color += texture(source, uv_interp + vec2(-1.0, 0.0) * pixel_size) * 0.24477;
color += texture(source, uv_interp + vec2(-2.0, 0.0) * pixel_size) * 0.06136;
#endif
#ifdef GAUSSIAN_VERTICAL
color*=0.38774;
color+=texture( source, uv_interp+vec2( 0.0, 1.0)*pixel_size )*0.24477;
color+=texture( source, uv_interp+vec2( 0.0, 2.0)*pixel_size )*0.06136;
color+=texture( source, uv_interp+vec2( 0.0,-1.0)*pixel_size )*0.24477;
color+=texture( source, uv_interp+vec2( 0.0,-2.0)*pixel_size )*0.06136;
color *= 0.38774;
color += texture(source, uv_interp + vec2(0.0, 1.0) * pixel_size) * 0.24477;
color += texture(source, uv_interp + vec2(0.0, 2.0) * pixel_size) * 0.06136;
color += texture(source, uv_interp + vec2(0.0, -1.0) * pixel_size) * 0.24477;
color += texture(source, uv_interp + vec2(0.0, -2.0) * pixel_size) * 0.06136;
#endif
#ifdef USE_BCS
color.rgb = mix(vec3(0.0),color.rgb,bcs.x);
color.rgb = mix(vec3(0.5),color.rgb,bcs.y);
color.rgb = mix(vec3(dot(vec3(1.0),color.rgb)*0.33333),color.rgb,bcs.z);
color.rgb = mix(vec3(0.0), color.rgb, bcs.x);
color.rgb = mix(vec3(0.5), color.rgb, bcs.y);
color.rgb = mix(vec3(dot(vec3(1.0), color.rgb) * 0.33333), color.rgb, bcs.z);
#endif
#ifdef USE_COLOR_CORRECTION
color.r = texture(color_correction,vec2(color.r,0.0)).r;
color.g = texture(color_correction,vec2(color.g,0.0)).g;
color.b = texture(color_correction,vec2(color.b,0.0)).b;
color.r = texture(color_correction, vec2(color.r, 0.0)).r;
color.g = texture(color_correction, vec2(color.g, 0.0)).g;
color.b = texture(color_correction, vec2(color.b, 0.0)).b;
#endif
#ifdef USE_MULTIPLIER
color.rgb*=multiplier;
color.rgb *= multiplier;
#endif
frag_color = color;
}

58
drivers/gles3/shaders/cube_to_dp.glsl
View file

@ -1,8 +1,7 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location=4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
@ -14,7 +13,6 @@ void main() {
[fragment]
uniform highp samplerCube source_cube; //texunit:0
in vec2 uv_interp;
@ -25,55 +23,53 @@ 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));
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 = -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 = 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.z = 0.5 - 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
normal = normalize(normal);
/*
normal.z = 0.5;
normal = normalize(normal);
*/
/*
normal.z=0.5;
normal=normalize(normal);
*/
if (!z_flip) {
normal.z=-normal.z;
normal.z = -normal.z;
}
//normal = normalize(vec3( uv_interp * 2.0 - 1.0, 1.0 ));
float depth = texture(source_cube,normal).r;
//normal = normalize(vec3(uv_interp * 2.0 - 1.0, 1.0));
float depth = texture(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) ) {
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) ) {
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) ) {
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 ) ;
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 );
unorm = vec3(1.0, 0.0, 0.0);
}
float depth_fix = 1.0 / dot(normal,unorm);
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;
gl_FragDepth = (linear_depth * depth_fix + bias) / z_far;
}

101
drivers/gles3/shaders/cubemap_filter.glsl
View file

@ -1,21 +1,19 @@
[vertex]
layout(location = 0) in highp vec2 vertex;
layout(location=0) in highp vec2 vertex;
layout(location=4) in highp vec2 uv;
layout(location = 4) in highp vec2 uv;
out highp vec2 uv_interp;
void main() {
uv_interp=uv;
gl_Position=vec4(vertex,0,1);
uv_interp = uv;
gl_Position = vec4(vertex, 0, 1);
}
[fragment]
precision highp float;
precision highp int;
@ -36,17 +34,13 @@ uniform int face_id;
uniform float roughness;
in highp vec2 uv_interp;
layout(location = 0) out vec4 frag_color;
#define M_PI 3.14159265359
vec3 texelCoordToVec(vec2 uv, int faceID)
{
vec3 texelCoordToVec(vec2 uv, int faceID) {
mat3 faceUvVectors[6];
/*
/*
// -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
@ -76,7 +70,7 @@ vec3 texelCoordToVec(vec2 uv, int faceID)
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
*/
*/
// -x
faceUvVectors[0][0] = vec3(0.0, 0.0, 1.0); // u -> +z
@ -113,13 +107,12 @@ vec3 texelCoordToVec(vec2 uv, int faceID)
return normalize(result);
}
vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N)
{
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 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
@ -137,15 +130,13 @@ vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N)
}
// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
float GGX(float NdotV, float a)
{
float GGX(float NdotV, float a) {
float k = a / 2.0;
return NdotV / (NdotV * (1.0 - k) + k);
}
// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
float G_Smith(float a, float nDotV, float nDotL)
{
float G_Smith(float a, float nDotV, float nDotL) {
return GGX(nDotL, a * a) * GGX(nDotV, a * a);
}
@ -159,11 +150,9 @@ float radicalInverse_VdC(uint bits) {
}
vec2 Hammersley(uint i, uint N) {
return vec2(float(i)/float(N), radicalInverse_VdC(i));
return vec2(float(i) / float(N), radicalInverse_VdC(i));
}
#ifdef LOW_QUALITY
#define SAMPLE_COUNT 64u
@ -178,37 +167,33 @@ uniform bool z_flip;
#ifdef USE_SOURCE_PANORAMA
vec4 texturePanorama(vec3 normal,sampler2D pano ) {
vec4 texturePanorama(vec3 normal, sampler2D pano) {
vec2 st = vec2(
atan(normal.x, normal.z),
acos(normal.y)
);
acos(normal.y));
if(st.x < 0.0)
st.x += M_PI*2.0;
if (st.x < 0.0)
st.x += M_PI * 2.0;
st/=vec2(M_PI*2.0,M_PI);
return textureLod(pano,st,0.0);
st /= vec2(M_PI * 2.0, M_PI);
return textureLod(pano, st, 0.0);
}
#endif
#ifdef USE_SOURCE_DUAL_PARABOLOID_ARRAY
vec4 textureDualParaboloidArray(vec3 normal) {
vec3 norm = normalize(normal);
norm.xy/=1.0+abs(norm.z);
norm.xy=norm.xy * vec2(0.5,0.25) + vec2(0.5,0.25);
if (norm.z<0.0) {
norm.y=0.5-norm.y+0.5;
norm.xy /= 1.0 + abs(norm.z);
norm.xy = norm.xy * vec2(0.5, 0.25) + vec2(0.5, 0.25);
if (norm.z < 0.0) {
norm.y = 0.5 - norm.y + 0.5;
}
return textureLod(source_dual_paraboloid_array, vec3(norm.xy, float(source_array_index) ), 0.0);
return textureLod(source_dual_paraboloid_array, vec3(norm.xy, float(source_array_index)), 0.0);
}
#endif
@ -217,16 +202,15 @@ void main() {
#ifdef USE_DUAL_PARABOLOID
vec3 N = vec3( uv_interp * 2.0 - 1.0, 0.0 );
N.z = 0.5 - 0.5*((N.x * N.x) + (N.y * N.y));
vec3 N = vec3(uv_interp * 2.0 - 1.0, 0.0);
N.z = 0.5 - 0.5 * ((N.x * N.x) + (N.y * N.y));
N = normalize(N);
if (z_flip) {
N.y=-N.y; //y is flipped to improve blending between both sides
N.z=-N.z;
N.y = -N.y; //y is flipped to improve blending between both sides
N.z = -N.z;
}
#else
vec2 uv = (uv_interp * 2.0) - 1.0;
vec3 N = texelCoordToVec(uv, face_id);
@ -237,49 +221,46 @@ void main() {
#ifdef USE_SOURCE_PANORAMA
frag_color=vec4(texturePanorama(N,source_panorama).rgb,1.0);
frag_color = vec4(texturePanorama(N, source_panorama).rgb, 1.0);
#endif
#ifdef USE_SOURCE_DUAL_PARABOLOID_ARRAY
frag_color=vec4(textureDualParaboloidArray(N).rgb,1.0);
frag_color = vec4(textureDualParaboloidArray(N).rgb, 1.0);
#endif
#if !defined(USE_SOURCE_DUAL_PARABOLOID_ARRAY) && !defined(USE_SOURCE_PANORAMA)
N.y=-N.y;
frag_color=vec4(texture(N,source_cube).rgb,1.0);
N.y = -N.y;
frag_color = vec4(texture(N, source_cube).rgb, 1.0);
#endif
#else
vec4 sum = vec4(0.0, 0.0, 0.0, 0.0);
for(uint sampleNum = 0u; sampleNum < SAMPLE_COUNT; sampleNum++) {
for (uint sampleNum = 0u; sampleNum < SAMPLE_COUNT; sampleNum++) {
vec2 xi = Hammersley(sampleNum, SAMPLE_COUNT);
vec3 H = ImportanceSampleGGX( xi, roughness, N );
vec3 H = ImportanceSampleGGX(xi, roughness, N);
vec3 V = N;
vec3 L = normalize(2.0 * dot( V, H ) * H - V);
vec3 L = normalize(2.0 * dot(V, H) * H - V);
float ndotl = clamp(dot(N, L),0.0,1.0);
float ndotl = clamp(dot(N, L), 0.0, 1.0);
if (ndotl>0.0) {
if (ndotl > 0.0) {
#ifdef USE_SOURCE_PANORAMA
sum.rgb += texturePanorama(H,source_panorama).rgb *ndotl;
sum.rgb += texturePanorama(H, source_panorama).rgb * ndotl;
#endif
#ifdef USE_SOURCE_DUAL_PARABOLOID_ARRAY
sum.rgb += textureDualParaboloidArray(H).rgb *ndotl;
sum.rgb += textureDualParaboloidArray(H).rgb * ndotl;
#endif
#if !defined(USE_SOURCE_DUAL_PARABOLOID_ARRAY) && !defined(USE_SOURCE_PANORAMA)
H.y=-H.y;
sum.rgb += textureLod(source_cube, H, 0.0).rgb *ndotl;
H.y = -H.y;
sum.rgb += textureLod(source_cube, H, 0.0).rgb * ndotl;
#endif
sum.a += ndotl;
}
@ -289,6 +270,4 @@ void main() {
frag_color = vec4(sum.rgb, 1.0);
#endif
}

176
drivers/gles3/shaders/effect_blur.glsl
View file

@ -1,8 +1,7 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location=4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
@ -39,7 +38,6 @@ uniform sampler2D source_ssao; //texunit:1
uniform float lod;
uniform vec2 pixel_size;
layout(location = 0) out vec4 frag_color;
#ifdef SSAO_MERGE
@ -48,31 +46,31 @@ uniform vec4 ssao_color;
#endif
#if defined (GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
#if defined(GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
uniform float glow_strength;
#endif
#if defined(DOF_FAR_BLUR) || defined (DOF_NEAR_BLUR)
#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;
const float dof_kernel[5] = float[] (0.153388,0.221461,0.250301,0.221461,0.153388);
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);
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);
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
uniform sampler2D dof_source_depth; //texunit:1
@ -88,7 +86,6 @@ uniform sampler2D source_dof_original; //texunit:2
#endif
#ifdef GLOW_FIRST_PASS
uniform float exposure;
@ -112,53 +109,51 @@ uniform float camera_z_near;
void main() {
#ifdef GAUSSIAN_HORIZONTAL
vec2 pix_size = pixel_size;
pix_size*=0.5; //reading from larger buffer, so use more samples
vec4 color =textureLod( source_color, uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.214607;
color+=textureLod( source_color, uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.189879;
color+=textureLod( source_color, uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.157305;
color+=textureLod( source_color, uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.071303;
color+=textureLod( source_color, uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.189879;
color+=textureLod( source_color, uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.157305;
color+=textureLod( source_color, uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.071303;
pix_size *= 0.5; //reading from larger buffer, so use more samples
vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pix_size, lod) * 0.214607;
color += textureLod(source_color, uv_interp + vec2(1.0, 0.0) * pix_size, lod) * 0.189879;
color += textureLod(source_color, uv_interp + vec2(2.0, 0.0) * pix_size, lod) * 0.157305;
color += textureLod(source_color, uv_interp + vec2(3.0, 0.0) * pix_size, lod) * 0.071303;
color += textureLod(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size, lod) * 0.189879;
color += textureLod(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size, lod) * 0.157305;
color += textureLod(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size, lod) * 0.071303;
frag_color = color;
#endif
#ifdef GAUSSIAN_VERTICAL
vec4 color =textureLod( source_color, uv_interp+vec2( 0.0, 0.0)*pixel_size,lod )*0.38774;
color+=textureLod( source_color, uv_interp+vec2( 0.0, 1.0)*pixel_size,lod )*0.24477;
color+=textureLod( source_color, uv_interp+vec2( 0.0, 2.0)*pixel_size,lod )*0.06136;
color+=textureLod( source_color, uv_interp+vec2( 0.0,-1.0)*pixel_size,lod )*0.24477;
color+=textureLod( source_color, uv_interp+vec2( 0.0,-2.0)*pixel_size,lod )*0.06136;
vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pixel_size, lod) * 0.38774;
color += textureLod(source_color, uv_interp + vec2(0.0, 1.0) * pixel_size, lod) * 0.24477;
color += textureLod(source_color, uv_interp + vec2(0.0, 2.0) * pixel_size, lod) * 0.06136;
color += textureLod(source_color, uv_interp + vec2(0.0, -1.0) * pixel_size, lod) * 0.24477;
color += textureLod(source_color, uv_interp + vec2(0.0, -2.0) * pixel_size, lod) * 0.06136;
frag_color = color;
#endif
//glow uses larger sigma for a more rounded blur effect
//glow uses larger sigma for a more rounded blur effect
#ifdef GLOW_GAUSSIAN_HORIZONTAL
vec2 pix_size = pixel_size;
pix_size*=0.5; //reading from larger buffer, so use more samples
vec4 color =textureLod( source_color, uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.174938;
color+=textureLod( source_color, uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.165569;
color+=textureLod( source_color, uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.140367;
color+=textureLod( source_color, uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.106595;
color+=textureLod( source_color, uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.165569;
color+=textureLod( source_color, uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.140367;
color+=textureLod( source_color, uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.106595;
color*=glow_strength;
pix_size *= 0.5; //reading from larger buffer, so use more samples
vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pix_size, lod) * 0.174938;
color += textureLod(source_color, uv_interp + vec2(1.0, 0.0) * pix_size, lod) * 0.165569;
color += textureLod(source_color, uv_interp + vec2(2.0, 0.0) * pix_size, lod) * 0.140367;
color += textureLod(source_color, uv_interp + vec2(3.0, 0.0) * pix_size, lod) * 0.106595;
color += textureLod(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size, lod) * 0.165569;
color += textureLod(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size, lod) * 0.140367;
color += textureLod(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size, lod) * 0.106595;
color *= glow_strength;
frag_color = color;
#endif
#ifdef GLOW_GAUSSIAN_VERTICAL
vec4 color =textureLod( source_color, uv_interp+vec2(0.0, 0.0)*pixel_size,lod )*0.288713;
color+=textureLod( source_color, uv_interp+vec2(0.0, 1.0)*pixel_size,lod )*0.233062;
color+=textureLod( source_color, uv_interp+vec2(0.0, 2.0)*pixel_size,lod )*0.122581;
color+=textureLod( source_color, uv_interp+vec2(0.0,-1.0)*pixel_size,lod )*0.233062;
color+=textureLod( source_color, uv_interp+vec2(0.0,-2.0)*pixel_size,lod )*0.122581;
color*=glow_strength;
vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pixel_size, lod) * 0.288713;
color += textureLod(source_color, uv_interp + vec2(0.0, 1.0) * pixel_size, lod) * 0.233062;
color += textureLod(source_color, uv_interp + vec2(0.0, 2.0) * pixel_size, lod) * 0.122581;
color += textureLod(source_color, uv_interp + vec2(0.0, -1.0) * pixel_size, lod) * 0.233062;
color += textureLod(source_color, uv_interp + vec2(0.0, -2.0) * pixel_size, lod) * 0.122581;
color *= glow_strength;
frag_color = color;
#endif
@ -166,47 +161,45 @@ void main() {
vec4 color_accum = vec4(0.0);
float depth = textureLod( dof_source_depth, uv_interp, 0.0).r;
float depth = textureLod(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;
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;
float amount = smoothstep(dof_begin, dof_end, depth);
float k_accum = 0.0;
for(int i=0;i<dof_kernel_size;i++) {
for (int i = 0; i < dof_kernel_size; i++) {
int int_ofs = i-dof_kernel_from;
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 = texture( dof_source_depth, tap_uv, 0.0).r;
float tap_depth = texture(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;
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 = mix(smoothstep(dof_begin,dof_end,tap_depth),1.0,int_ofs==0);
tap_amount*=tap_amount*tap_amount; //prevent undesired glow effect
vec4 tap_color = textureLod( source_color, tap_uv, 0.0) * tap_k;
k_accum+=tap_k*tap_amount;
color_accum+=tap_color*tap_amount;
float tap_amount = mix(smoothstep(dof_begin, dof_end, tap_depth), 1.0, int_ofs == 0);
tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
vec4 tap_color = textureLod(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;
if (k_accum > 0.0) {
color_accum /= k_accum;
}
frag_color = color_accum;///k_accum;
frag_color = color_accum; ///k_accum;
#endif
@ -214,47 +207,45 @@ void main() {
vec4 color_accum = vec4(0.0);
float max_accum=0.0;
float max_accum = 0.0;
for(int i=0;i<dof_kernel_size;i++) {
for (int i = 0; i < dof_kernel_size; i++) {
int int_ofs = i-dof_kernel_from;
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-float(abs(int_ofs))/float(dof_kernel_from));
float ofs_influence = max(0.0, 1.0 - float(abs(int_ofs)) / float(dof_kernel_from));
float tap_k = dof_kernel[i];
vec4 tap_color = textureLod( source_color, tap_uv, 0.0);
vec4 tap_color = textureLod(source_color, tap_uv, 0.0);
float tap_depth = texture( dof_source_depth, tap_uv, 0.0).r;
float tap_depth = texture(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;
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
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);
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;
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));
color_accum.a = max(color_accum.a, sqrt(max_accum));
#ifdef DOF_NEAR_BLUR_MERGE
vec4 original = textureLod( source_dof_original, uv_interp, 0.0);
color_accum = mix(original,color_accum,color_accum.a);
vec4 original = textureLod(source_dof_original, uv_interp, 0.0);
color_accum = mix(original, color_accum, color_accum.a);
#endif
@ -265,37 +256,32 @@ void main() {
#endif
#ifdef GLOW_FIRST_PASS
#ifdef GLOW_USE_AUTO_EXPOSURE
frag_color/=texelFetch(source_auto_exposure,ivec2(0,0),0).r/auto_exposure_grey;
frag_color /= texelFetch(source_auto_exposure, ivec2(0, 0), 0).r / auto_exposure_grey;
#endif
frag_color*=exposure;
frag_color *= exposure;
float luminance = max(frag_color.r,max(frag_color.g,frag_color.b));
float feedback = max( smoothstep(glow_hdr_threshold,glow_hdr_threshold+glow_hdr_scale,luminance), glow_bloom );
float luminance = max(frag_color.r, max(frag_color.g, frag_color.b));
float feedback = max(smoothstep(glow_hdr_threshold, glow_hdr_threshold + glow_hdr_scale, luminance), glow_bloom);
frag_color *= feedback;
#endif
#ifdef SIMPLE_COPY
vec4 color =textureLod( source_color, uv_interp,0.0);
vec4 color = textureLod(source_color, uv_interp, 0.0);
frag_color = color;
#endif
#ifdef SSAO_MERGE
vec4 color =textureLod( source_color, uv_interp,0.0);
float ssao =textureLod( source_ssao, uv_interp,0.0).r;
vec4 color = textureLod(source_color, uv_interp, 0.0);
float ssao = textureLod(source_ssao, uv_interp, 0.0).r;
frag_color = vec4( mix(color.rgb,color.rgb*mix(ssao_color.rgb,vec3(1.0),ssao),color.a), 1.0 );
frag_color = vec4(mix(color.rgb, color.rgb * mix(ssao_color.rgb, vec3(1.0), ssao), color.a), 1.0);
#endif
}

60
drivers/gles3/shaders/exposure.glsl
View file

@ -1,18 +1,14 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location = 0) in highp vec4 vertex_attrib;
void main() {
gl_Position = vertex_attrib;
}
[fragment]
uniform highp sampler2D source_exposure; //texunit:0
#ifdef EXPOSURE_BEGIN
@ -33,66 +29,56 @@ uniform highp float max_luminance;
layout(location = 0) out highp float exposure;
void main() {
#ifdef EXPOSURE_BEGIN
ivec2 src_pos = ivec2(gl_FragCoord.xy)*source_render_size/target_size;
ivec2 src_pos = ivec2(gl_FragCoord.xy) * source_render_size / target_size;
#if 1
//more precise and expensive, but less jittery
ivec2 next_pos = ivec2(gl_FragCoord.xy+ivec2(1))*source_render_size/target_size;
next_pos = max(next_pos,src_pos+ivec2(1)); //so it at least reads one pixel
highp vec3 source_color=vec3(0.0);
for(int i=src_pos.x;i<next_pos.x;i++) {
for(int j=src_pos.y;j<next_pos.y;j++) {
source_color += texelFetch(source_exposure,ivec2(i,j),0).rgb;
ivec2 next_pos = ivec2(gl_FragCoord.xy + ivec2(1)) * source_render_size / target_size;
next_pos = max(next_pos, src_pos + ivec2(1)); //so it at least reads one pixel
highp vec3 source_color = vec3(0.0);
for (int i = src_pos.x; i < next_pos.x; i++) {
for (int j = src_pos.y; j < next_pos.y; j++) {
source_color += texelFetch(source_exposure, ivec2(i, j), 0).rgb;
}
}
source_color/=float( (next_pos.x-src_pos.x)*(next_pos.y-src_pos.y) );
source_color /= float((next_pos.x - src_pos.x) * (next_pos.y - src_pos.y));
#else
highp vec3 source_color = texelFetch(source_exposure,src_pos,0).rgb;
highp vec3 source_color = texelFetch(source_exposure, src_pos, 0).rgb;
#endif
exposure = max(source_color.r,max(source_color.g,source_color.b));
exposure = max(source_color.r, max(source_color.g, source_color.b));
#else
ivec2 coord = ivec2(gl_FragCoord.xy);
exposure = texelFetch(source_exposure,coord*3+ivec2(0,0),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(1,0),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(2,0),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(0,1),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(1,1),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(2,1),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(0,2),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(1,2),0).r;
exposure += texelFetch(source_exposure,coord*3+ivec2(2,2),0).r;
exposure *= (1.0/9.0);
exposure = texelFetch(source_exposure, coord * 3 + ivec2(0, 0), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 0), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 0), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(0, 1), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 1), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 1), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(0, 2), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 2), 0).r;
exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 2), 0).r;
exposure *= (1.0 / 9.0);
#ifdef EXPOSURE_END
#ifdef EXPOSURE_FORCE_SET
//will stay as is
#else
highp float prev_lum = texelFetch(prev_exposure,ivec2(0,0),0).r; //1 pixel previous exposure
exposure = clamp( prev_lum + (exposure-prev_lum)*exposure_adjust,min_luminance,max_luminance);
highp float prev_lum = texelFetch(prev_exposure, ivec2(0, 0), 0).r; //1 pixel previous exposure
exposure = clamp(prev_lum + (exposure - prev_lum) * exposure_adjust, min_luminance, max_luminance);
#endif //EXPOSURE_FORCE_SET
#endif //EXPOSURE_END
#endif //EXPOSURE_BEGIN
}

109
drivers/gles3/shaders/particles.glsl
View file

@ -1,14 +1,11 @@
[vertex]
layout(location=0) in highp vec4 color;
layout(location=1) in highp vec4 velocity_active;
layout(location=2) in highp vec4 custom;
layout(location=3) in highp vec4 xform_1;
layout(location=4) in highp vec4 xform_2;
layout(location=5) in highp vec4 xform_3;
layout(location = 0) in highp vec4 color;
layout(location = 1) in highp vec4 velocity_active;
layout(location = 2) in highp vec4 custom;
layout(location = 3) in highp vec4 xform_1;
layout(location = 4) in highp vec4 xform_2;
layout(location = 5) in highp vec4 xform_3;
struct Attractor {
@ -39,7 +36,6 @@ uniform float lifetime;
uniform mat4 emission_transform;
uniform uint random_seed;
out highp vec4 out_color; //tfb:
out highp vec4 out_velocity_active; //tfb:
out highp vec4 out_custom; //tfb:
@ -47,7 +43,6 @@ out highp vec4 out_xform_1; //tfb:
out highp vec4 out_xform_2; //tfb:
out highp vec4 out_xform_3; //tfb:
#if defined(USE_MATERIAL)
layout(std140) uniform UniformData { //ubo:0
@ -58,7 +53,6 @@ MATERIAL_UNIFORMS
#endif
VERTEX_SHADER_GLOBALS
uint hash(uint x) {
@ -69,13 +63,12 @@ uint hash(uint x) {
return x;
}
void main() {
#ifdef PARTICLES_COPY
out_color=color;
out_velocity_active=velocity_active;
out_color = color;
out_velocity_active = velocity_active;
out_custom = custom;
out_xform_1 = xform_1;
out_xform_2 = xform_2;
@ -83,47 +76,47 @@ void main() {
#else
bool apply_forces=true;
bool apply_velocity=true;
float local_delta=delta;
bool apply_forces = true;
bool apply_velocity = true;
float local_delta = delta;
float mass = 1.0;
float restart_phase = float(gl_VertexID)/float(total_particles);
float restart_phase = float(gl_VertexID) / float(total_particles);
if (randomness>0.0) {
if (randomness > 0.0) {
uint seed = cycle;
if (restart_phase >= system_phase) {
seed-=uint(1);
seed -= uint(1);
}
seed*=uint(total_particles);
seed+=uint(gl_VertexID);
seed *= uint(total_particles);
seed += uint(gl_VertexID);
float random = float(hash(seed) % uint(65536)) / 65536.0;
restart_phase+=randomness * random * 1.0 / float(total_particles);
restart_phase += randomness * random * 1.0 / float(total_particles);
}
restart_phase*= (1.0-explosiveness);
bool restart=false;
restart_phase *= (1.0 - explosiveness);
bool restart = false;
bool shader_active = velocity_active.a > 0.5;
if (system_phase > prev_system_phase) {
// restart_phase >= prev_system_phase is used so particles emit in the first frame they are processed
if (restart_phase >= prev_system_phase && restart_phase < system_phase ) {
restart=true;
if (restart_phase >= prev_system_phase && restart_phase < system_phase) {
restart = true;
#ifdef USE_FRACTIONAL_DELTA
local_delta = (system_phase - restart_phase) * lifetime;
#endif
}
} else if(delta > 0.0) {
} else if (delta > 0.0) {
if (restart_phase >= prev_system_phase) {
restart=true;
restart = true;
#ifdef USE_FRACTIONAL_DELTA
local_delta = (1.0 - restart_phase + system_phase) * lifetime;
#endif
} else if (restart_phase < system_phase ) {
restart=true;
} else if (restart_phase < system_phase) {
restart = true;
#ifdef USE_FRACTIONAL_DELTA
local_delta = (system_phase - restart_phase) * lifetime;
#endif
@ -133,14 +126,14 @@ void main() {
uint current_cycle = cycle;
if (system_phase < restart_phase) {
current_cycle-=uint(1);
current_cycle -= uint(1);
}
uint particle_number = current_cycle * uint(total_particles) + uint(gl_VertexID);
int index = int(gl_VertexID);
if (restart) {
shader_active=emitting;
shader_active = emitting;
}
mat4 xform;
@ -150,23 +143,22 @@ void main() {
#else
if (clear || restart) {
#endif
out_color=vec4(1.0);
out_velocity_active=vec4(0.0);
out_custom=vec4(0.0);
out_color = vec4(1.0);
out_velocity_active = vec4(0.0);
out_custom = vec4(0.0);
if (!restart)
shader_active=false;
shader_active = false;
xform = mat4(
vec4(1.0,0.0,0.0,0.0),
vec4(0.0,1.0,0.0,0.0),
vec4(0.0,0.0,1.0,0.0),
vec4(0.0,0.0,0.0,1.0)
);
vec4(1.0, 0.0, 0.0, 0.0),
vec4(0.0, 1.0, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(0.0, 0.0, 0.0, 1.0));
} else {
out_color=color;
out_velocity_active=velocity_active;
out_custom=custom;
xform = transpose(mat4(xform_1,xform_2,xform_3,vec4(vec3(0.0),1.0)));
out_color = color;
out_velocity_active = velocity_active;
out_custom = custom;
xform = transpose(mat4(xform_1, xform_2, xform_3, vec4(vec3(0.0), 1.0)));
}
if (shader_active) {
@ -181,26 +173,25 @@ VERTEX_SHADER_CODE
if (false) {
vec3 force = vec3(0.0);
for(int i=0;i<attractor_count;i++) {
for (int i = 0; i < attractor_count; i++) {
vec3 rel_vec = xform[3].xyz - attractors[i].pos;
float dist = length(rel_vec);
if (attractors[i].radius < dist)
continue;
if (attractors[i].eat_radius>0.0 && attractors[i].eat_radius > dist) {
out_velocity_active.a=0.0;
if (attractors[i].eat_radius > 0.0 && attractors[i].eat_radius > dist) {
out_velocity_active.a = 0.0;
}
rel_vec = normalize(rel_vec);
float attenuation = pow(dist / attractors[i].radius,attractors[i].attenuation);
float attenuation = pow(dist / attractors[i].radius, attractors[i].attenuation);
if (attractors[i].dir==vec3(0.0)) {
if (attractors[i].dir == vec3(0.0)) {
//towards center
force+=attractors[i].strength * rel_vec * attenuation * mass;
force += attractors[i].strength * rel_vec * attenuation * mass;
} else {
force+=attractors[i].strength * attractors[i].dir * attenuation *mass;
force += attractors[i].strength * attractors[i].dir * attenuation * mass;
}
}
@ -216,25 +207,23 @@ VERTEX_SHADER_CODE
}
#endif
} else {
xform=mat4(0.0);
xform = mat4(0.0);
}
xform = transpose(xform);
out_velocity_active.a = mix(0.0,1.0,shader_active);
out_velocity_active.a = mix(0.0, 1.0, shader_active);
out_xform_1 = xform[0];
out_xform_2 = xform[1];
out_xform_3 = xform[2];
#endif //PARTICLES_COPY
}
[fragment]
//any code here is never executed, stuff is filled just so it works
// any code here is never executed, stuff is filled just so it works
#if defined(USE_MATERIAL)

20
drivers/gles3/shaders/resolve.glsl
View file

@ -1,12 +1,10 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location=4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
void main() {
uv_interp = uv_in;
@ -20,8 +18,8 @@ precision mediump float;
#endif
in vec2 uv_interp;
uniform sampler2D source_specular; //texunit:0
uniform sampler2D source_ssr; //texunit:1
uniform sampler2D source_specular; // texunit:0
uniform sampler2D source_ssr; // texunit:1
uniform vec2 pixel_size;
@ -31,14 +29,12 @@ layout(location = 0) out vec4 frag_color;
void main() {
vec4 specular = texture( source_specular, uv_interp );
vec4 specular = texture(source_specular, uv_interp);
#ifdef USE_SSR
vec4 ssr = textureLod(source_ssr,uv_interp,0.0);
specular.rgb = mix(specular.rgb,ssr.rgb*specular.a,ssr.a);
vec4 ssr = textureLod(source_ssr, uv_interp, 0.0);
specular.rgb = mix(specular.rgb, ssr.rgb * specular.a, ssr.a);
#endif
frag_color = vec4(specular.rgb,1.0);
frag_color = vec4(specular.rgb, 1.0);
}

1171
drivers/gles3/shaders/scene.glsl
View file

File diff suppressed because it is too large Load diff

232
drivers/gles3/shaders/screen_space_reflection.glsl
View file

@ -1,8 +1,7 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location=4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
out vec2 pos_interp;
@ -11,12 +10,11 @@ void main() {
uv_interp = uv_in;
gl_Position = vertex_attrib;
pos_interp.xy=gl_Position.xy;
pos_interp.xy = gl_Position.xy;
}
[fragment]
in vec2 uv_interp;
in vec2 pos_interp;
@ -40,81 +38,67 @@ uniform float depth_tolerance;
uniform float distance_fade;
uniform float curve_fade_in;
layout(location = 0) out vec4 frag_color;
vec2 view_to_screen(vec3 view_pos,out float w) {
vec2 view_to_screen(vec3 view_pos, out float w) {
vec4 projected = projection * vec4(view_pos, 1.0);
projected.xyz /= projected.w;
projected.xy = projected.xy * 0.5 + 0.5;
w=projected.w;
w = projected.w;
return projected.xy;
}
#define M_PI 3.14159265359
void main() {
////
vec4 diffuse = texture( source_diffuse, uv_interp );
vec4 normal_roughness = texture( source_normal_roughness, uv_interp);
vec4 diffuse = texture(source_diffuse, uv_interp);
vec4 normal_roughness = texture(source_normal_roughness, uv_interp);
vec3 normal;
normal = normal_roughness.xyz*2.0-1.0;
normal = normal_roughness.xyz * 2.0 - 1.0;
float roughness = normal_roughness.w;
float depth_tex = texture(source_depth,uv_interp).r;
float depth_tex = texture(source_depth, uv_interp).r;
vec4 world_pos = inverse_projection * vec4( uv_interp*2.0-1.0, depth_tex*2.0-1.0, 1.0 );
vec3 vertex = world_pos.xyz/world_pos.w;
vec4 world_pos = inverse_projection * vec4(uv_interp * 2.0 - 1.0, depth_tex * 2.0 - 1.0, 1.0);
vec3 vertex = world_pos.xyz / world_pos.w;
vec3 view_dir = normalize(vertex);
vec3 ray_dir = normalize(reflect(view_dir, normal));
if (dot(ray_dir,normal)<0.001) {
frag_color=vec4(0.0);
if (dot(ray_dir, normal) < 0.001) {
frag_color = vec4(0.0);
return;
}
//ray_dir = normalize(view_dir - normal * dot(normal,view_dir) * 2.0);
//ray_dir = normalize(vec3(1,1,-1));
//ray_dir = normalize(vec3(1, 1, -1));
////////////////
//make ray length and clip it against the near plane (don't want to trace beyond visible)
// make ray length and clip it against the near plane (don't want to trace beyond visible)
float ray_len = (vertex.z + ray_dir.z * camera_z_far) > -camera_z_near ? (-camera_z_near - vertex.z) / ray_dir.z : camera_z_far;
vec3 ray_end = vertex + ray_dir*ray_len;
vec3 ray_end = vertex + ray_dir * ray_len;
float w_begin;
vec2 vp_line_begin = view_to_screen(vertex,w_begin);
vec2 vp_line_begin = view_to_screen(vertex, w_begin);
float w_end;
vec2 vp_line_end = view_to_screen( ray_end, w_end);
vec2 vp_line_dir = vp_line_end-vp_line_begin;
vec2 vp_line_end = view_to_screen(ray_end, w_end);
vec2 vp_line_dir = vp_line_end - vp_line_begin;
//we need to interpolate w along the ray, to generate perspective correct reflections
// we need to interpolate w along the ray, to generate perspective correct reflections
w_begin = 1.0 / w_begin;
w_end = 1.0 / w_end;
w_begin = 1.0/w_begin;
w_end = 1.0/w_end;
float z_begin = vertex.z * w_begin;
float z_end = ray_end.z * w_end;
float z_begin = vertex.z*w_begin;
float z_end = ray_end.z*w_end;
vec2 line_begin = vp_line_begin/pixel_size;
vec2 line_dir = vp_line_dir/pixel_size;
vec2 line_begin = vp_line_begin / pixel_size;
vec2 line_dir = vp_line_dir / pixel_size;
float z_dir = z_end - z_begin;
float w_dir = w_end - w_begin;
// clip the line to the viewport edges
float scale_max_x = min(1.0, 0.99 * (1.0 - vp_line_begin.x) / max(1e-5, vp_line_dir.x));
@ -124,126 +108,114 @@ void main() {
float line_clip = min(scale_max_x, scale_max_y) * min(scale_min_x, scale_min_y);
line_dir *= line_clip;
z_dir *= line_clip;
w_dir *=line_clip;
w_dir *= line_clip;
//clip z and w advance to line advance
vec2 line_advance = normalize(line_dir); //down to pixel
float step_size = length(line_advance)/length(line_dir);
float z_advance = z_dir*step_size; // adapt z advance to line advance
float w_advance = w_dir*step_size; // adapt w advance to line advance
// clip z and w advance to line advance
vec2 line_advance = normalize(line_dir); // down to pixel
float step_size = length(line_advance) / length(line_dir);
float z_advance = z_dir * step_size; // adapt z advance to line advance
float w_advance = w_dir * step_size; // adapt w advance to line advance
//make line advance faster if direction is closer to pixel edges (this avoids sampling the same pixel twice)
float advance_angle_adj = 1.0/max(abs(line_advance.x),abs(line_advance.y));
line_advance*=advance_angle_adj; // adapt z advance to line advance
z_advance*=advance_angle_adj;
w_advance*=advance_angle_adj;
// make line advance faster if direction is closer to pixel edges (this avoids sampling the same pixel twice)
float advance_angle_adj = 1.0 / max(abs(line_advance.x), abs(line_advance.y));
line_advance *= advance_angle_adj; // adapt z advance to line advance
z_advance *= advance_angle_adj;
w_advance *= advance_angle_adj;
vec2 pos = line_begin;
float z = z_begin;
float w = w_begin;
float z_from=z/w;
float z_to=z_from;
float z_from = z / w;
float z_to = z_from;
float depth;
vec2 prev_pos=pos;
vec2 prev_pos = pos;
bool found=false;
bool found = false;
float steps_taken=0.0;
float steps_taken = 0.0;
for(int i=0;i<num_steps;i++) {
for (int i = 0; i < num_steps; i++) {
pos+=line_advance;
z+=z_advance;
w+=w_advance;
pos += line_advance;
z += z_advance;
w += w_advance;
//convert to linear depth
// convert to linear depth
depth = texture(source_depth, pos*pixel_size).r * 2.0 - 1.0;
depth = texture(source_depth, pos * pixel_size).r * 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;
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
depth=-depth;
depth = -depth;
z_from = z_to;
z_to = z/w;
z_to = z / w;
if (depth>z_to) {
//if depth was surpassed
if (depth<=max(z_to,z_from)+depth_tolerance) {
//check the depth tolerance
found=true;
if (depth > z_to) {
// if depth was surpassed
if (depth <= max(z_to, z_from) + depth_tolerance) {
// check the depth tolerance
found = true;
}
break;
}
steps_taken+=1.0;
prev_pos=pos;
steps_taken += 1.0;
prev_pos = pos;
}
if (found) {
float margin_blend=1.0;
float margin_blend = 1.0;
vec2 margin = vec2((viewport_size.x+viewport_size.y)*0.5*0.05); //make a uniform margin
if (any(bvec4(lessThan(pos,-margin),greaterThan(pos,viewport_size+margin)))) {
//clip outside screen + margin
frag_color=vec4(0.0);
vec2 margin = vec2((viewport_size.x + viewport_size.y) * 0.5 * 0.05); // make a uniform margin
if (any(bvec4(lessThan(pos, -margin), greaterThan(pos, viewport_size + margin)))) {
// clip outside screen + margin
frag_color = vec4(0.0);
return;
}
{
//blend fading out towards external margin
vec2 margin_grad = mix(pos-viewport_size,-pos,lessThan(pos,vec2(0.0)));
margin_blend = 1.0-smoothstep(0.0,margin.x,max(margin_grad.x,margin_grad.y));
//margin_blend=1.0;
vec2 margin_grad = mix(pos - viewport_size, -pos, lessThan(pos, vec2(0.0)));
margin_blend = 1.0 - smoothstep(0.0, margin.x, max(margin_grad.x, margin_grad.y));
//margin_blend = 1.0;
}
vec2 final_pos;
float grad;
grad=steps_taken/float(num_steps);
float initial_fade = curve_fade_in==0.0 ? 1.0 : pow(clamp(grad,0.0,1.0),curve_fade_in);
float fade = pow(clamp(1.0-grad,0.0,1.0),distance_fade)*initial_fade;
final_pos=pos;
grad = steps_taken / float(num_steps);
float initial_fade = curve_fade_in == 0.0 ? 1.0 : pow(clamp(grad, 0.0, 1.0), curve_fade_in);
float fade = pow(clamp(1.0 - grad, 0.0, 1.0), distance_fade) * initial_fade;
final_pos = pos;
#ifdef REFLECT_ROUGHNESS
vec4 final_color;
//if roughness is enabled, do screen space cone tracing
// if roughness is enabled, do screen space cone tracing
if (roughness > 0.001) {
///////////////////////////////////////////////////////////////////////////////////////
//use a blurred version (in consecutive mipmaps) of the screen to simulate roughness
// use a blurred version (in consecutive mipmaps) of the screen to simulate roughness
float gloss = 1.0-roughness;
float gloss = 1.0 - roughness;
float cone_angle = roughness * M_PI * 0.5;
vec2 cone_dir = final_pos - line_begin;
float cone_len = length(cone_dir);
cone_dir = normalize(cone_dir); //will be used normalized from now on
cone_dir = normalize(cone_dir); // will be used normalized from now on
float max_mipmap = filter_mipmap_levels - 1.0;
float gloss_mult=gloss;
float gloss_mult = gloss;
float rem_alpha=1.0;
float rem_alpha = 1.0;
final_color = vec4(0.0);
for(int i=0;i<7;i++) {
for (int i = 0; i < 7; i++) {
float op_len = 2.0 * tan(cone_angle) * cone_len; //opposite side of iso triangle
float op_len = 2.0 * tan(cone_angle) * cone_len; // opposite side of iso triangle
float radius;
{
//fit to sphere inside cone (sphere ends at end of cone), something like this:
// fit to sphere inside cone (sphere ends at end of cone), something like this:
// ___
// \O/
// V
@ -257,31 +229,31 @@ void main() {
radius = (a * (sqrt(a2 + fh2) - a)) / (4.0f * h);
}
//find the place where screen must be sampled
vec2 sample_pos = ( line_begin + cone_dir * (cone_len - radius) ) * pixel_size;
//radius is in pixels, so it's natural that log2(radius) maps to the right mipmap for the amount of pixels
float mipmap = clamp( log2( radius ), 0.0, max_mipmap );
// find the place where screen must be sampled
vec2 sample_pos = (line_begin + cone_dir * (cone_len - radius)) * pixel_size;
// radius is in pixels, so it's natural that log2(radius) maps to the right mipmap for the amount of pixels
float mipmap = clamp(log2(radius), 0.0, max_mipmap);
//mipmap = max(mipmap - 1.0, 0.0);
//mipmap = max(mipmap-1.0,0.0);
//do sampling
// do sampling
vec4 sample_color;
{
sample_color = textureLod(source_diffuse,sample_pos,mipmap);
sample_color = textureLod(source_diffuse, sample_pos, mipmap);
}
//multiply by gloss
sample_color.rgb*=gloss_mult;
sample_color.a=gloss_mult;
// multiply by gloss
sample_color.rgb *= gloss_mult;
sample_color.a = gloss_mult;
rem_alpha -= sample_color.a;
if(rem_alpha < 0.0) {
if (rem_alpha < 0.0) {
sample_color.rgb *= (1.0 - abs(rem_alpha));
}
final_color+=sample_color;
final_color += sample_color;
if (final_color.a>=0.95) {
if (final_color.a >= 0.95) {
// This code of accumulating gloss and aborting on near one
// makes sense when you think of cone tracing.
// Think of it as if roughness was 0, then we could abort on the first
@ -290,29 +262,21 @@ void main() {
break;
}
cone_len-=radius*2.0; //go to next (smaller) circle.
gloss_mult*=gloss;
cone_len -= radius * 2.0; // go to next (smaller) circle.
gloss_mult *= gloss;
}
} else {
final_color = textureLod(source_diffuse,final_pos*pixel_size,0.0);
final_color = textureLod(source_diffuse, final_pos * pixel_size, 0.0);
}
frag_color = vec4(final_color.rgb,fade*margin_blend);
frag_color = vec4(final_color.rgb, fade * margin_blend);
#else
frag_color = vec4(textureLod(source_diffuse,final_pos*pixel_size,0.0).rgb,fade*margin_blend);
frag_color = vec4(textureLod(source_diffuse, final_pos * pixel_size, 0.0).rgb, fade * margin_blend);
#endif
} else {
frag_color = vec4(0.0,0.0,0.0,0.0);
frag_color = vec4(0.0, 0.0, 0.0, 0.0);
}
}

83
drivers/gles3/shaders/ssao.glsl
View file

@ -1,12 +1,11 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location = 0) in highp vec4 vertex_attrib;
void main() {
gl_Position = vertex_attrib;
gl_Position.z=1.0;
gl_Position.z = 1.0;
}
[fragment]
@ -14,21 +13,15 @@ void main() {
#define TWO_PI 6.283185307179586476925286766559
#ifdef SSAO_QUALITY_HIGH
#define NUM_SAMPLES (80)
#endif
#ifdef SSAO_QUALITY_LOW
#define NUM_SAMPLES (15)
#endif
#if !defined(SSAO_QUALITY_LOW) && !defined(SSAO_QUALITY_HIGH)
#define NUM_SAMPLES (40)
#endif
// If using depth mip levels, the log of the maximum pixel offset before we need to switch to a lower
@ -43,19 +36,21 @@ void main() {
// This is the number of turns around the circle that the spiral pattern makes. This should be prime to prevent
// taps from lining up. This particular choice was tuned for NUM_SAMPLES == 9
const int ROTATIONS[] = int[]( 1, 1, 2, 3, 2, 5, 2, 3, 2,
3, 3, 5, 5, 3, 4, 7, 5, 5, 7,
9, 8, 5, 5, 7, 7, 7, 8, 5, 8,
11, 12, 7, 10, 13, 8, 11, 8, 7, 14,
11, 11, 13, 12, 13, 19, 17, 13, 11, 18,
19, 11, 11, 14, 17, 21, 15, 16, 17, 18,
13, 17, 11, 17, 19, 18, 25, 18, 19, 19,
29, 21, 19, 27, 31, 29, 21, 18, 17, 29,
31, 31, 23, 18, 25, 26, 25, 23, 19, 34,
19, 27, 21, 25, 39, 29, 17, 21, 27 );
const int ROTATIONS[] = int[](
1, 1, 2, 3, 2, 5, 2, 3, 2,
3, 3, 5, 5, 3, 4, 7, 5, 5, 7,
9, 8, 5, 5, 7, 7, 7, 8, 5, 8,
11, 12, 7, 10, 13, 8, 11, 8, 7, 14,
11, 11, 13, 12, 13, 19, 17, 13, 11, 18,
19, 11, 11, 14, 17, 21, 15, 16, 17, 18,
13, 17, 11, 17, 19, 18, 25, 18, 19, 19,
29, 21, 19, 27, 31, 29, 21, 18, 17, 29,
31, 31, 23, 18, 25, 26, 25, 23, 19, 34,
19, 27, 21, 25, 39, 29, 17, 21, 27
);
//#define NUM_SPIRAL_TURNS (7)
const int NUM_SPIRAL_TURNS = ROTATIONS[NUM_SAMPLES-1];
const int NUM_SPIRAL_TURNS = ROTATIONS[NUM_SAMPLES - 1];
uniform sampler2D source_depth; //texunit:0
uniform highp usampler2D source_depth_mipmaps; //texunit:1
@ -95,7 +90,7 @@ vec3 getPosition(ivec2 ssP) {
P.z = P.z * 2.0 - 1.0;
#ifdef USE_ORTHOGONAL_PROJECTION
P.z = ((P.z + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
P.z = ((P.z + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
#else
P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
#endif
@ -111,10 +106,8 @@ vec3 reconstructCSFaceNormal(vec3 C) {
return normalize(cross(dFdy(C), dFdx(C)));
}
/** Returns a unit vector and a screen-space radius for the tap on a unit disk (the caller should scale by the actual disk radius) */
vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR){
vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR) {
// Radius relative to ssR
float alpha = (float(sampleNumber) + 0.5) * (1.0 / float(NUM_SAMPLES));
float angle = alpha * (float(NUM_SPIRAL_TURNS) * 6.28) + spinAngle;
@ -123,7 +116,6 @@ vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR){
return vec2(cos(angle), sin(angle));
}
/** Read the camera-space position of the point at screen-space pixel ssP + unitOffset * ssR. Assumes length(unitOffset) == 1 */
vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
// Derivation:
@ -138,34 +130,29 @@ vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
// Manually clamp to the texture size because texelFetch bypasses the texture unit
ivec2 mipP = clamp(ssP >> mipLevel, ivec2(0), (screen_size >> mipLevel) - ivec2(1));
if (mipLevel < 1) {
//read from depth buffer
P.z = texelFetch(source_depth, mipP, 0).r;
P.z = P.z * 2.0 - 1.0;
#ifdef USE_ORTHOGONAL_PROJECTION
P.z = ((P.z + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
P.z = ((P.z + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
#else
P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
#endif
P.z = -P.z;
} else {
//read from mipmaps
uint d = texelFetch(source_depth_mipmaps, mipP, mipLevel-1).r;
P.z = -(float(d)/65535.0)*camera_z_far;
uint d = texelFetch(source_depth_mipmaps, mipP, mipLevel - 1).r;
P.z = -(float(d) / 65535.0) * camera_z_far;
}
// Offset to pixel center
P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
return P;
}
/** Compute the occlusion due to sample with index \a i about the pixel at \a ssC that corresponds
to camera-space point \a C with unit normal \a n_C, using maximum screen-space sampling radius \a ssDiskRadius
@ -175,7 +162,7 @@ vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
Four versions of the falloff function are implemented below
*/
float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius,in float p_radius, in int tapIndex, in float randomPatternRotationAngle) {
float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius, in float p_radius, in int tapIndex, in float randomPatternRotationAngle) {
// Offset on the unit disk, spun for this pixel
float ssR;
vec2 unitOffset = tapLocation(tapIndex, randomPatternRotationAngle, ssR);
@ -190,14 +177,14 @@ float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius,in fl
float vn = dot(v, n_C);
const float epsilon = 0.01;
float radius2 = p_radius*p_radius;
float radius2 = p_radius * p_radius;
// A: From the HPG12 paper
// Note large epsilon to avoid overdarkening within cracks
//return float(vv < radius2) * max((vn - bias) / (epsilon + vv), 0.0) * radius2 * 0.6;
// B: Smoother transition to zero (lowers contrast, smoothing out corners). [Recommended]
float f=max(radius2 - vv, 0.0);
float f = max(radius2 - vv, 0.0);
return f * f * f * max((vn - bias) / (epsilon + vv), 0.0);
// C: Medium contrast (which looks better at high radii), no division. Note that the
@ -209,27 +196,25 @@ float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius,in fl
// return 2.0 * float(vv < radius * radius) * max(vn - bias, 0.0);
}
void main() {
// Pixel being shaded
ivec2 ssC = ivec2(gl_FragCoord.xy);
// World space point being shaded
vec3 C = getPosition(ssC);
/* if (C.z <= -camera_z_far*0.999) {
/*
if (C.z <= -camera_z_far * 0.999) {
// We're on the skybox
visibility=1.0;
return;
}*/
}
*/
//visibility=-C.z/camera_z_far;
//visibility = -C.z / camera_z_far;
//return;
#if 0
vec3 n_C = texelFetch(source_normal,ssC,0).rgb * 2.0 - 1.0;
vec3 n_C = texelFetch(source_normal, ssC, 0).rgb * 2.0 - 1.0;
#else
vec3 n_C = reconstructCSFaceNormal(C);
n_C = -n_C;
@ -251,7 +236,7 @@ void main() {
#endif
float sum = 0.0;
for (int i = 0; i < NUM_SAMPLES; ++i) {
sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius,i, randomPatternRotationAngle);
sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius, i, randomPatternRotationAngle);
}
float A = max(0.0, 1.0 - sum * intensity_div_r6 * (5.0 / float(NUM_SAMPLES)));
@ -271,10 +256,10 @@ void main() {
sum = 0.0;
for (int i = 0; i < NUM_SAMPLES; ++i) {
sum += sampleAO(ssC, C, n_C, ssDiskRadius,radius2, i, randomPatternRotationAngle);
sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius2, i, randomPatternRotationAngle);
}
A= min(A,max(0.0, 1.0 - sum * intensity_div_r62 * (5.0 / float(NUM_SAMPLES))));
A = min(A, max(0.0, 1.0 - sum * intensity_div_r62 * (5.0 / float(NUM_SAMPLES))));
#endif
// Bilateral box-filter over a quad for free, respecting depth edges
// (the difference that this makes is subtle)
@ -286,8 +271,4 @@ void main() {
}
visibility = A;
}

31
drivers/gles3/shaders/ssao_blur.glsl
View file

@ -1,26 +1,21 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location = 0) in highp vec4 vertex_attrib;
void main() {
gl_Position = vertex_attrib;
gl_Position.z=1.0;
gl_Position.z = 1.0;
}
[fragment]
uniform sampler2D source_ssao; //texunit:0
uniform sampler2D source_depth; //texunit:1
uniform sampler2D source_normal; //texunit:3
layout(location = 0) out float visibility;
//////////////////////////////////////////////////////////////////////////////////////////////
// Tunable Parameters:
@ -52,7 +47,7 @@ const float gaussian[R + 1] =
float[](0.153170, 0.144893, 0.122649, 0.092902, 0.062970); // stddev = 2.0
// float[](0.111220, 0.107798, 0.098151, 0.083953, 0.067458, 0.050920, 0.036108); // stddev = 3.0
/** (1, 0) or (0, 1)*/
/** (1, 0) or (0, 1) */
uniform ivec2 axis;
uniform float camera_z_far;
@ -65,18 +60,18 @@ void main() {
ivec2 ssC = ivec2(gl_FragCoord.xy);
float depth = texelFetch(source_depth, ssC, 0).r;
//vec3 normal = texelFetch(source_normal,ssC,0).rgb * 2.0 - 1.0;
//vec3 normal = texelFetch(source_normal, ssC, 0).rgb * 2.0 - 1.0;
depth = depth * 2.0 - 1.0;
depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
float depth_divide = 1.0 / camera_z_far;
// depth*=depth_divide;
//depth *= depth_divide;
/*
if (depth > camera_z_far*0.999) {
discard;//skybox
if (depth > camera_z_far * 0.999) {
discard; //skybox
}
*/
@ -96,23 +91,21 @@ void main() {
if (r != 0) {
ivec2 ppos = ssC + axis * (r * filter_scale);
float value = texelFetch(source_ssao, clamp(ppos,ivec2(0),clamp_limit), 0).r;
ivec2 rpos = clamp(ppos,ivec2(0),clamp_limit);
float value = texelFetch(source_ssao, clamp(ppos, ivec2(0), clamp_limit), 0).r;
ivec2 rpos = clamp(ppos, ivec2(0), clamp_limit);
float temp_depth = texelFetch(source_depth, rpos, 0).r;
//vec3 temp_normal = texelFetch(source_normal, rpos, 0).rgb * 2.0 - 1.0;
temp_depth = temp_depth * 2.0 - 1.0;
temp_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - temp_depth * (camera_z_far - camera_z_near));
// temp_depth *= depth_divide;
//temp_depth *= depth_divide;
// spatial domain: offset gaussian tap
float weight = 0.3 + gaussian[abs(r)];
//weight *= max(0.0,dot(temp_normal,normal));
//weight *= max(0.0, dot(temp_normal, normal));
// range domain (the "bilateral" weight). As depth difference increases, decrease weight.
weight *= max(0.0, 1.0
- edge_sharpness * abs(temp_depth - depth)
);
weight *= max(0.0, 1.0 - edge_sharpness * abs(temp_depth - depth));
sum += value * weight;
totalWeight += weight;

13
drivers/gles3/shaders/ssao_minify.glsl
View file

@ -1,7 +1,6 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location = 0) in highp vec4 vertex_attrib;
void main() {
@ -10,7 +9,6 @@ void main() {
[fragment]
#ifdef MINIFY_START
#define SDEPTH_TYPE highp sampler2D
@ -32,7 +30,6 @@ layout(location = 0) out mediump uint depth;
void main() {
ivec2 ssP = ivec2(gl_FragCoord.xy);
// Rotated grid subsampling to avoid XY directional bias or Z precision bias while downsampling.
@ -42,18 +39,14 @@ void main() {
float fdepth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
fdepth = fdepth * 2.0 - 1.0;
#ifdef USE_ORTHOGONAL_PROJECTION
fdepth = ((fdepth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
fdepth = ((fdepth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
#else
fdepth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - fdepth * (camera_z_far - camera_z_near));
#endif
fdepth /= camera_z_far;
depth = uint(clamp(fdepth*65535.0,0.0,65535.0));
depth = uint(clamp(fdepth * 65535.0, 0.0, 65535.0));
#else
depth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
#endif
}

56
drivers/gles3/shaders/subsurf_scattering.glsl
View file

@ -1,12 +1,10 @@
[vertex]
layout(location=0) in highp vec4 vertex_attrib;
layout(location=4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
void main() {
uv_interp = uv_in;
@ -19,8 +17,7 @@ void main() {
#define QUALIFIER const
#ifdef USE_25_SAMPLES
const int kernel_size=25;
const int kernel_size = 25;
QUALIFIER vec2 kernel[25] = vec2[] (
vec2(0.530605, 0.0),
vec2(0.000973794, -3.0),
@ -48,13 +45,10 @@ QUALIFIER vec2 kernel[25] = vec2[] (
vec2(0.00333804, 2.52083),
vec2(0.000973794, 3.0)
);
#endif //USE_25_SAMPLES
#ifdef USE_17_SAMPLES
const int kernel_size=17;
const int kernel_size = 17;
QUALIFIER vec2 kernel[17] = vec2[](
vec2(0.536343, 0.0),
vec2(0.00317394, -2.0),
@ -72,16 +66,13 @@ QUALIFIER vec2 kernel[17] = vec2[](
vec2(0.0216301, 0.78125),
vec2(0.0144609, 1.125),
vec2(0.0100386, 1.53125),
vec2(0.00317394,2.0)
vec2(0.00317394, 2.0)
);
#endif //USE_17_SAMPLES
#ifdef USE_11_SAMPLES
const int kernel_size=11;
const int kernel_size = 11;
QUALIFIER vec2 kernel[11] = vec2[](
vec2(0.560479, 0.0),
vec2(0.00471691, -2.0),
@ -93,13 +84,10 @@ QUALIFIER vec2 kernel[11] = vec2[](
vec2(0.0821904, 0.32),
vec2(0.03639, 0.72),
vec2(0.0192831, 1.28),
vec2(0.00471691,2.0)
vec2(0.00471691, 2.0)
);
#endif //USE_11_SAMPLES
uniform float max_radius;
uniform float camera_z_far;
uniform float camera_z_near;
@ -115,28 +103,24 @@ layout(location = 0) out vec4 frag_color;
void main() {
float strength = texture(source_sss,uv_interp).r;
strength*=strength; //stored as sqrt
float strength = texture(source_sss, uv_interp).r;
strength *= strength; //stored as sqrt
// Fetch color of current pixel:
vec4 base_color = texture(source_diffuse, uv_interp);
if (strength>0.0) {
if (strength > 0.0) {
// Fetch linear depth of current pixel:
float depth = texture(source_depth, uv_interp).r * 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;
depth = ((depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
float scale = unit_size; //remember depth is negative by default in OpenGL
#else
depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
float scale = unit_size / depth; //remember depth is negative by default in OpenGL
#endif
// Calculate the final step to fetch the surrounding pixels:
vec2 step = max_radius * scale * dir;
step *= strength; // Modulate it using the alpha channel.
@ -157,35 +141,33 @@ void main() {
#ifdef ENABLE_FOLLOW_SURFACE
// If the difference in depth is huge, we lerp color back to "colorM":
float depth_cmp = texture(source_depth, offset).r *2.0 - 1.0;
float depth_cmp = texture(source_depth, offset).r * 2.0 - 1.0;
#ifdef USE_ORTHOGONAL_PROJECTION
depth_cmp = ((depth_cmp + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
depth_cmp = ((depth_cmp + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
#else
depth_cmp = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth_cmp * (camera_z_far - camera_z_near));
#endif
float s = clamp(300.0f * scale *
max_radius * abs(depth - depth_cmp),0.0,1.0);
float s = clamp(300.0f * scale * max_radius * abs(depth - depth_cmp), 0.0, 1.0);
color = mix(color, base_color.rgb, s);
#endif
// Accumulate:
color*=kernel[i].x;
color *= kernel[i].x;
#ifdef ENABLE_STRENGTH_WEIGHTING
float color_s = texture(source_sss, offset).r;
color_weight+=color_s * kernel[i].x;
color*=color_s;
color_weight += color_s * kernel[i].x;
color *= color_s;
#endif
color_accum += color;
}
#ifdef ENABLE_STRENGTH_WEIGHTING
color_accum/=color_weight;
color_accum /= color_weight;
#endif
frag_color = vec4(color_accum,base_color.a); //keep alpha (used for SSAO)
frag_color = vec4(color_accum, base_color.a); //keep alpha (used for SSAO)
} else {
frag_color = base_color;
}

202
drivers/gles3/shaders/tonemap.glsl
View file

@ -1,25 +1,24 @@
[vertex]
layout (location = 0) in highp vec4 vertex_attrib;
layout (location = 4) in vec2 uv_in;
layout(location = 0) in highp vec4 vertex_attrib;
layout(location = 4) in vec2 uv_in;
out vec2 uv_interp;
void main()
{
void main() {
gl_Position = vertex_attrib;
uv_interp = uv_in;
#ifdef V_FLIP
#ifdef V_FLIP
uv_interp.y = 1.0f - uv_interp.y;
#endif
#endif
}
[fragment]
#if !defined(GLES_OVER_GL)
precision mediump float;
precision mediump float;
#endif
in vec2 uv_interp;
@ -30,75 +29,66 @@ uniform float exposure;
uniform float white;
#ifdef USE_AUTO_EXPOSURE
uniform highp sampler2D source_auto_exposure; //texunit:1
uniform highp float auto_exposure_grey;
uniform highp sampler2D source_auto_exposure; //texunit:1
uniform highp float auto_exposure_grey;
#endif
#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
#define USING_GLOW // only use glow when at least one glow level is selected
uniform highp sampler2D source_glow; //texunit:2
uniform highp float glow_intensity;
uniform highp sampler2D source_glow; //texunit:2
uniform highp float glow_intensity;
#endif
#ifdef USE_BCS
uniform vec3 bcs;
uniform vec3 bcs;
#endif
#ifdef USE_COLOR_CORRECTION
uniform sampler2D color_correction; //texunit:3
uniform sampler2D color_correction; //texunit:3
#endif
layout (location = 0) out vec4 frag_color;
layout(location = 0) out vec4 frag_color;
#ifdef USE_GLOW_FILTER_BICUBIC
// w0, w1, w2, and w3 are the four cubic B-spline basis functions
float w0(float a)
{
// w0, w1, w2, and w3 are the four cubic B-spline basis functions
float w0(float a) {
return (1.0f / 6.0f) * (a * (a * (-a + 3.0f) - 3.0f) + 1.0f);
}
}
float w1(float a)
{
float w1(float a) {
return (1.0f / 6.0f) * (a * a * (3.0f * a - 6.0f) + 4.0f);
}
}
float w2(float a)
{
float w2(float a) {
return (1.0f / 6.0f) * (a * (a * (-3.0f * a + 3.0f) + 3.0f) + 1.0f);
}
}
float w3(float a)
{
float w3(float a) {
return (1.0f / 6.0f) * (a * a * a);
}
}
// g0 and g1 are the two amplitude functions
float g0(float a)
{
// g0 and g1 are the two amplitude functions
float g0(float a) {
return w0(a) + w1(a);
}
}
float g1(float a)
{
float g1(float a) {
return w2(a) + w3(a);
}
}
// h0 and h1 are the two offset functions
float h0(float a)
{
// h0 and h1 are the two offset functions
float h0(float a) {
return -1.0f + w1(a) / (w0(a) + w1(a));
}
}
float h1(float a)
{
float h1(float a) {
return 1.0f + w3(a) / (w2(a) + w3(a));
}
}
uniform ivec2 glow_texture_size;
uniform ivec2 glow_texture_size;
vec4 texture2D_bicubic(sampler2D tex, vec2 uv, int p_lod)
{
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 pixel_size = vec2(1.0f) / tex_size;
@ -120,19 +110,18 @@ layout (location = 0) out vec4 frag_color;
vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - vec2(0.5f)) * pixel_size;
vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - vec2(0.5f)) * pixel_size;
return g0(fuv.y) * (g0x * textureLod(tex, p0,lod) +
g1x * textureLod(tex, p1,lod)) +
g1(fuv.y) * (g0x * textureLod(tex, p2,lod) +
g1x * textureLod(tex, p3,lod));
}
return g0(fuv.y) * (g0x * textureLod(tex, p0, lod) +
g1x * textureLod(tex, p1, lod)) +
g1(fuv.y) * (g0x * textureLod(tex, p2, lod) +
g1x * textureLod(tex, p3, lod));
}
#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2D_bicubic(m_tex, m_uv, m_lod)
#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2D_bicubic(m_tex, m_uv, m_lod)
#else
#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) textureLod(m_tex, m_uv, float(m_lod))
#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) textureLod(m_tex, m_uv, float(m_lod))
#endif
vec3 tonemap_filmic(vec3 color, float white)
{
vec3 tonemap_filmic(vec3 color, float white) {
const float A = 0.15f;
const float B = 0.50f;
const float C = 0.10f;
@ -147,8 +136,7 @@ vec3 tonemap_filmic(vec3 color, float white)
return clamp(color_tonemapped / white_tonemapped, vec3(0.0f), vec3(1.0f));
}
vec3 tonemap_aces(vec3 color, float white)
{
vec3 tonemap_aces(vec3 color, float white) {
const float A = 2.51f;
const float B = 0.03f;
const float C = 2.43f;
@ -161,96 +149,90 @@ vec3 tonemap_aces(vec3 color, float white)
return clamp(color_tonemapped / white_tonemapped, vec3(0.0f), vec3(1.0f));
}
vec3 tonemap_reindhart(vec3 color, float white)
{
vec3 tonemap_reindhart(vec3 color, float white) {
return clamp((color) / (1.0f + color) * (1.0f + (color / (white))), vec3(0.0f), vec3(1.0f)); // whitepoint is probably not in linear space here!
}
vec3 linear_to_srgb(vec3 color) // convert linear rgb to srgb, assumes clamped input in range [0;1]
{
vec3 linear_to_srgb(vec3 color) { // convert linear rgb to srgb, assumes clamped input in range [0;1]
const vec3 a = vec3(0.055f);
return mix((vec3(1.0f) + a) * pow(color.rgb, vec3(1.0f / 2.4f)) - a, 12.92f * color.rgb, lessThan(color.rgb, vec3(0.0031308f)));
}
vec3 apply_tonemapping(vec3 color, float white) // inputs are LINEAR, always outputs clamped [0;1] color
{
#ifdef USE_REINDHART_TONEMAPPER
vec3 apply_tonemapping(vec3 color, float white) { // inputs are LINEAR, always outputs clamped [0;1] color
#ifdef USE_REINDHART_TONEMAPPER
return tonemap_reindhart(color, white);
#endif
#endif
#ifdef USE_FILMIC_TONEMAPPER
#ifdef USE_FILMIC_TONEMAPPER
return tonemap_filmic(color, white);
#endif
#endif
#ifdef USE_ACES_TONEMAPPER
#ifdef USE_ACES_TONEMAPPER
return tonemap_aces(color, white);
#endif
#endif
return clamp(color, vec3(0.0f), vec3(1.0f)); // no other seleced -> linear
}
vec3 gather_glow(sampler2D tex, vec2 uv) // sample all selected glow levels
{
vec3 gather_glow(sampler2D tex, vec2 uv) { // sample all selected glow levels
vec3 glow = vec3(0.0f);
#ifdef USE_GLOW_LEVEL1
#ifdef USE_GLOW_LEVEL1
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 1).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL2
#ifdef USE_GLOW_LEVEL2
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 2).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL3
#ifdef USE_GLOW_LEVEL3
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 3).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL4
#ifdef USE_GLOW_LEVEL4
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 4).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL5
#ifdef USE_GLOW_LEVEL5
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 5).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL6
#ifdef USE_GLOW_LEVEL6
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 6).rgb;
#endif
#endif
#ifdef USE_GLOW_LEVEL7
#ifdef USE_GLOW_LEVEL7
glow += GLOW_TEXTURE_SAMPLE(tex, uv, 7).rgb;
#endif
#endif
return glow;
}
vec3 apply_glow(vec3 color, vec3 glow) // apply glow using the selected blending mode
{
#ifdef USE_GLOW_REPLACE
vec3 apply_glow(vec3 color, vec3 glow) { // apply glow using the selected blending mode
#ifdef USE_GLOW_REPLACE
color = glow;
#endif
#endif
#ifdef USE_GLOW_SCREEN
#ifdef USE_GLOW_SCREEN
color = max((color + glow) - (color * glow), vec3(0.0));
#endif
#endif
#ifdef USE_GLOW_SOFTLIGHT
#ifdef USE_GLOW_SOFTLIGHT
glow = glow * vec3(0.5f) + vec3(0.5f);
color.r = (glow.r <= 0.5f) ? (color.r - (1.0f - 2.0f * glow.r) * color.r * (1.0f - color.r)) : (((glow.r > 0.5f) && (color.r <= 0.25f)) ? (color.r + (2.0f * glow.r - 1.0f) * (4.0f * color.r * (4.0f * color.r + 1.0f) * (color.r - 1.0f) + 7.0f * color.r)) : (color.r + (2.0f * glow.r - 1.0f) * (sqrt(color.r) - color.r)));
color.g = (glow.g <= 0.5f) ? (color.g - (1.0f - 2.0f * glow.g) * color.g * (1.0f - color.g)) : (((glow.g > 0.5f) && (color.g <= 0.25f)) ? (color.g + (2.0f * glow.g - 1.0f) * (4.0f * color.g * (4.0f * color.g + 1.0f) * (color.g - 1.0f) + 7.0f * color.g)) : (color.g + (2.0f * glow.g - 1.0f) * (sqrt(color.g) - color.g)));
color.b = (glow.b <= 0.5f) ? (color.b - (1.0f - 2.0f * glow.b) * color.b * (1.0f - color.b)) : (((glow.b > 0.5f) && (color.b <= 0.25f)) ? (color.b + (2.0f * glow.b - 1.0f) * (4.0f * color.b * (4.0f * color.b + 1.0f) * (color.b - 1.0f) + 7.0f * color.b)) : (color.b + (2.0f * glow.b - 1.0f) * (sqrt(color.b) - color.b)));
#endif
#endif
#if !defined(USE_GLOW_SCREEN) && !defined(USE_GLOW_SOFTLIGHT) && !defined(USE_GLOW_REPLACE) // no other selected -> additive
#if !defined(USE_GLOW_SCREEN) && !defined(USE_GLOW_SOFTLIGHT) && !defined(USE_GLOW_REPLACE) // no other selected -> additive
color += glow;
#endif
#endif
return color;
}
vec3 apply_bcs(vec3 color, vec3 bcs)
{
vec3 apply_bcs(vec3 color, vec3 bcs) {
color = mix(vec3(0.0f), color, bcs.x);
color = mix(vec3(0.5f), color, bcs.y);
color = mix(vec3(dot(vec3(1.0f), color) * 0.33333f), color, bcs.z);
@ -258,8 +240,7 @@ vec3 apply_bcs(vec3 color, vec3 bcs)
return color;
}
vec3 apply_color_correction(vec3 color, sampler2D correction_tex)
{
vec3 apply_color_correction(vec3 color, sampler2D correction_tex) {
color.r = texture(correction_tex, vec2(color.r, 0.0f)).r;
color.g = texture(correction_tex, vec2(color.g, 0.0f)).g;
color.b = texture(correction_tex, vec2(color.b, 0.0f)).b;
@ -267,15 +248,14 @@ vec3 apply_color_correction(vec3 color, sampler2D correction_tex)
return color;
}
void main()
{
void main() {
vec3 color = textureLod(source, uv_interp, 0.0f).rgb;
// Exposure
#ifdef USE_AUTO_EXPOSURE
#ifdef USE_AUTO_EXPOSURE
color /= texelFetch(source_auto_exposure, ivec2(0, 0), 0).r / auto_exposure_grey;
#endif
#endif
color *= exposure;
@ -283,15 +263,15 @@ void main()
color = apply_tonemapping(color, white);
#ifdef KEEP_3D_LINEAR
#ifdef KEEP_3D_LINEAR
// leave color as is (-> don't convert to SRGB)
#else
#else
color = linear_to_srgb(color); // regular linear -> SRGB conversion
#endif
#endif
// Glow
#ifdef USING_GLOW
#ifdef USING_GLOW
vec3 glow = gather_glow(source_glow, uv_interp) * glow_intensity;
// high dynamic range -> SRGB
@ -299,17 +279,17 @@ void main()
glow = linear_to_srgb(glow);
color = apply_glow(color, glow);
#endif
#endif
// Additional effects
#ifdef USE_BCS
#ifdef USE_BCS
color = apply_bcs(color, bcs);
#endif
#endif
#ifdef USE_COLOR_CORRECTION
#ifdef USE_COLOR_CORRECTION
color = apply_color_correction(color, color_correction);
#endif
#endif
frag_color = vec4(color, 1.0f);
}