SHS/qglengine
4
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
c3bb81f72d66ae8aad57b4d0da7f948e8572cb31
qglengine/shaders/ds_light.glsl
peri4 c179bc95cf miss shader
2023-03-16 12:12:36 +03:00

391 lines
13 KiB
GLSL
Raw Blame History

// vert //
out vec3 view_dir, world_dir;
uniform vec4 view_corners[4], world_corners[4];
void main(void) {
qgl_FragTexture = qgl_Texture;
gl_Position = qgl_ftransform();
view_dir = view_corners [gl_VertexID].xyz;
world_dir = world_corners[gl_VertexID].xyz;
}
// frag //
in vec3 view_dir, world_dir;
uniform vec2 dt;
uniform float z_near;
uniform sampler2D tex_coeff_brdf, tex_noise;
uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4, tex_5, tex_sh;
//uniform sampler2DShadow tex_shadow[16];
uniform vec2 shadow_size;
uniform sampler2DArrayShadow tex_shadows_cone;
uniform sampler2DArray tex_depths_cone;
uniform samplerCubeArrayShadow tex_shadows_omni;
uniform samplerCubeArray tex_depths_omni;
uniform bool soft_shadows_enabled = false, shadows_enabled = false;
uniform float soft_shadows_quality = 1.;
uniform int soft_shadows_samples = 16, noise_size = 64;
uniform samplerCube tex_env;
uniform int lights_start, lights_count;
uniform vec4 fog_color = vec4(0.5, 0.5, 0.5, 1.);
uniform float fog_decay = 10., fog_density = 0.;
uniform mat3 view_mat;
const float _pe = 2.4e-7;
const vec3 luma = vec3(0.299, 0.587, 0.114);
const float _min_rough = 1.e-8, max_lod = 8.;
const float PI = 3.1416;
ivec2 tc;
vec4 pos, lpos, shp;
vec3 li, si, ldir, halfV, bn, bn2, lwdir;
vec3 normal, geom_normal, vds, vds2;
float rough_diff, rough_spec, dist, NdotL, NdotH, spot, ldist, diff, spec, sdist;
uint flags;
vec4 mapScreenToShadow(in int light_index, in vec3 offset) {
vec4 shp = qgl_light_position[light_index].shadow_matrix * (pos + vec4(offset, 0));
//shp.z += 0.5;
return shp;
}
#ifdef SPOT
float getShadowCone(in vec3 uvz, in int layer) {
/*vec2 uvpix = uvz.xy * shadow_size + vec2(0.5f);
vec2 uvp = fract(uvpix), iuvp = vec2(1.f) - uvp;
vec4 gt = textureGather(tex_shadows_cone, vec3(floor(uvpix.xy) / shadow_size, layer), 0);
vec4 uvv;
uvv[0] = iuvp.x * uvp.y;
uvv[1] = uvp.x * uvp.y;
uvv[2] = uvp.x * iuvp.y;
uvv[3] = iuvp.x * iuvp.y;
shadow_dz = max(max(uvz.z - gt[0], uvz.z - gt[1]), max(uvz.z - gt[2], uvz.z - gt[3]));
return clamp(dot(step(vec4(uvz.z), gt), uvv), 0, 1);*/
float z = 1. - 1. / (uvz.z - z_near + 1.);
return texture(tex_shadows_cone, vec4(uvz.xy, layer, z));
}
#else
float getShadowOmni(in vec4 uvwz, in int layer) {
/*vec3 uvpix = uvwz.xyz * vec3(shadow_size.x) + vec3(0.5f);
vec3 uvp = fract(uvpix), iuvp = vec3(1.f) - uvp;
vec4 gt = textureGather(tex_shadows_omni, vec4(floor(uvpix.xyz) / vec3(shadow_size.x), layer), 0);
vec4 uvv;
uvv[0] = iuvp.y * uvp.z;
uvv[1] = uvp.y * uvp.z;
uvv[2] = uvp.y * iuvp.z;
uvv[3] = iuvp.y * iuvp.z;
return clamp(dot(step(vec4(uvwz.w), gt), uvv), 0, 1);*/
float d = 1. - 1. / (uvwz.w - z_near + 1.);
return texture(tex_shadows_omni, vec4(uvwz.xyz, layer), d);
//return step(uvwz.w, gt[3]);
}
#endif
uint hash(uint x) {
x += (x << 10u);
x ^= (x >> 6u);
x += (x << 3u);
x ^= (x >> 11u);
x += (x << 15u);
return x;
}
uint hash( uvec2 v ) { return hash( v.x ^ hash(v.y) ); }
uint hash( uvec3 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ); }
uint hash( uvec4 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ^ hash(v.w) ); }
float floatConstruct( uint m ) {
const uint ieeeMantissa = 0x007FFFFFu; // binary32 mantissa bitmask
const uint ieeeOne = 0x3F800000u; // 1.0 in IEEE binary32
m &= ieeeMantissa; // Keep only mantissa bits (fractional part)
m |= ieeeOne; // Add fractional part to 1.0
float f = uintBitsToFloat( m ); // Range [1:2]
return f - 1.; // Range [0:1]
}
float random( float x ) { return floatConstruct(hash(floatBitsToUint(x))); }
float random( vec2 v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec3 v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec4 v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( int x ) { return floatConstruct(hash(x)); }
float random( ivec2 v ) { return floatConstruct(hash(v)); }
float random( ivec3 v ) { return floatConstruct(hash(v)); }
float random( ivec4 v ) { return floatConstruct(hash(v)); }
uvec2 noise_hash;
void noise2init(vec2 v) {
noise_hash = uvec2(hash(uint(v.x + 1)), hash(uint(v.y - 1)));
}
vec2 noise2() {
noise2init(vec2(noise_hash));
//return vec2(floatConstruct(noise_hash.x), floatConstruct(noise_hash.y)) * 2 - vec2(1.);
float r = floatConstruct(noise_hash.x);
float a = floatConstruct(noise_hash.y) * 2 * PI;
return r * vec2(cos(a), sin(a));
}
float rand(vec2 co) {
float a = 12.9898;
float b = 78.233;
float c = 43758.5453;
float d = dot(co.xy, vec2(a, b));
float e = sin(mod(d, 3.14)) * c;
return fract(e) - 0.5;
}
vec4 qgl_lightTexture(int index, vec2 coord, vec4 tex_shift) {
coord *= qgl_light_parameter[index].map.scale;
vec4 t = texture(qgl_texture_array[qgl_light_parameter[index].map.array_index],
vec3(coord, qgl_light_parameter[index].map.map_index));
t += tex_shift;
t.rgb *= qgl_light_parameter[index].map.amount + qgl_light_parameter[index].map.offset;
return t;
}
void calcLight(in int index, in vec3 n, in vec3 v) {
lpos = qgl_light_position[index].position;
ldir = lpos.xyz - (pos.xyz * lpos.w);
ldist = length(ldir);
ldir = normalize(ldir);
//ldir = vec3(0,0,1);
halfV = normalize(ldir + v);
NdotL = max(dot(n, ldir), 1E-8);
NdotH = max(dot(n, halfV), 1E-8);
spot = step(1.001E-8, NdotL) * qgl_light_parameter[index].decay_intensity.w;
vec3 light_color = qgl_light_parameter[index].color.rgb;
#ifdef SPOT
float scos = max(dot(-ldir, qgl_light_position[index].direction.xyz), 0.);
spot *= scos * step(qgl_light_parameter[index].angles.w, scos);
spot *= smoothstep(qgl_light_parameter[index].angles.w, qgl_light_parameter[index].angles.y, scos);
vec4 shp = mapScreenToShadow(index, vec3(0));
shp.xy /= shp.w;
vec4 light_map_pix = qgl_lightTexture(index, shp.xy, vec4(0));
light_color *= light_map_pix.rgb;
spot *= light_map_pix.a;
#endif
if (shadows_enabled && (int(round(qgl_light_parameter[index].flags)) == 1) && (bitfieldExtract(flags, 3, 1) == 1) && (spot > 1E-4)) {
#ifndef SPOT
vec3 odir = -(view_mat * ldir);
#endif
int layer = index - lights_start;
float shadow = 0.;
//float bias = abs(tan(PI/2.*(1 - abs(dot(normal, ldir)))) + 1) * z_near * 1;
float bias = (1. + 1. / abs(dot(geom_normal, ldir))) * z_near * 2.;
//bias = bias * bias + z_near;
if (soft_shadows_enabled) {
float depth = 1.;
#ifdef SPOT
const int gm_size = 2;
for (int i = -gm_size; i <= gm_size; ++i) {
for (int j = -gm_size; j <= gm_size; ++j) {
//depth = min(depth, textureOffset(tex_depths_cone, vec3(shp.xy, layer), ivec2(i, j)).x);
depth = min(depth, texture(tex_depths_cone, vec3(shp.xy + vec2(i, j) / vec2(shadow_size.x), layer)).x);
}
}
#else
const int gm_size = 2;
for (int i = -gm_size; i <= gm_size; ++i) {
for (int j = -gm_size; j <= gm_size; ++j) {
for (int k = -gm_size; k <= gm_size; ++k) {
depth = min(depth, texture(tex_depths_omni, vec4(odir + vec3(i, j, k) / vec3(shadow_size.x), layer)).r);
}
}
}
shp.z = ldist;
#endif
depth = 1. / (1. - depth) - 1. + z_near;
float dz = max(0., shp.z - depth);
float ds = qgl_light_parameter[index].size * dz / (ldist - dz);
//float ds = (ldist / 2.) / qgl_light_parameter[index].size;
float srate = abs(ds / pos.z) * 10. * soft_shadows_quality;
//qgl_FragColor.rgb = vec3(srate);
int samples = clamp(int(round(srate * float(soft_shadows_samples))), 1, soft_shadows_samples);
vds = ds * bn.xyz;
vds2 = ds * bn2.xyz;
vec2 so;
ivec2 sotc = tc;
noise2init(vec2(hash(ivec2(tc.x * 2. + 1., tc.y)), hash(ivec2(tc.x, (tc.y * 2. + 1.)))));
for (int i = 0; i < samples; ++i) {
so = noise2();
#ifdef SPOT
//vec4 nc = texelFetch(tex_noise, sotc % noise_size, 0);
//sotc += ivec2(nc.ba * 256) % noise_size;
//so = (nc.rg - vec2(0.5));
//so = vec2(rand(vec2(shp.x + i, shp.y)), rand(vec2(shp.x + i + 1, shp.y)));
vec4 shp = mapScreenToShadow(index, vds * so.x + vds2 * so.y);
shp.xy /= shp.w;
shp.z -= bias;
shadow += getShadowCone(shp.xyz, layer);
#else
//so = vec2(rand(vec2(odir.x + i, odir.y)), rand(vec2(odir.x + i + 1, odir.y)))*1.25;
vec3 old = lpos.xyz - ((pos.xyz + vec3(vds * so.x + vds2 * so.y)) * lpos.w);
odir = -(view_mat * old);
shadow += getShadowOmni(vec4(odir, length(old) - bias), layer);
#endif
}
spot *= min(1., 2. * shadow / samples);
//spot *= shadow / soft_shadows_samples;
//spot *= shadow / soft_shadows_samples + 1;
} else {
#ifdef SPOT
shp.xy;
shp.z -= bias;
spot *= getShadowCone(shp.xyz, layer);
#else
spot *= getShadowOmni(vec4(odir, ldist - bias), layer);
#endif
}
//shp.z -= bias;
//shadow += getShadowCone(shp.xyz, layer, vec2(0));
}
vec3 dist_decay = vec3(1., ldist, ldist*ldist);
spot /= dot(qgl_light_parameter[index].decay_intensity.xyz, dist_decay);
float NdotLs = NdotL*NdotL;
float NdotHs = NdotH*NdotH;
float ndlc = (1. - NdotLs) / NdotLs;
diff = 2. / (1. + sqrt(1. + (1. - rough_diff) * ndlc));
//diff = texture(tex_coeffs[0], vec2(roughness, (NdotLs))).r;
li += spot * diff * light_color;
ndlc = (1. - NdotHs) / NdotHs;
float der = NdotHs * (rough_spec + ndlc);
spec = rough_spec / (der*der) / PI;
//spec = texture(tex_coeffs[1], vec2(roughness, (NdotHs))).r;
si += spot * spec * light_color;
}
void main(void) {
tc = ivec2(gl_FragCoord.xy);
vec4 v1 = texelFetch(tex_1, tc, 0);
float z = v1.w;
if (z == 1.) {
discard;
}
pos.w = 1.;
pos.xyz = view_dir * z;
vec3 v = normalize(-pos.xyz);
vec4 v0 = texelFetch(tex_0, tc, 0),
v2 = texelFetch(tex_2, tc, 0),
v3 = texelFetch(tex_3, tc, 0),
v4 = texelFetch(tex_4, tc, 0),
v5 = texelFetch(tex_5, tc, 0);
vec3 diffuse = v0.rgb;
normal = v1.xyz;
geom_normal = v5.xyz;
vec3 emission = v3.rgb;
float alpha = v0.a;
float metalness = v2.r;
float roughness = v2.g;
float reflectivity = v2.b;
float NdotV = dot(normal, v);
float roughness3 = roughness*roughness*roughness;
bn = normalize(cross(normal, vec3(1.,0.,0.)) + cross(normal, vec3(0.,1.,0.)));
bn2 = normalize(cross(normal, bn));
bn = cross(normal, bn2);
rough_diff = max(roughness, _min_rough);
rough_spec = max(roughness3, _min_rough);
float shlick = clamp(metalness + (1. - metalness) * pow(1. - NdotV, 5.), 0., 1.);
flags = uint(round(v2.w));
//qgl_FragColor.rgba = vec4(0);
li = vec3(0.);//qgl_AmbientLight.color.rgb * qgl_AmbientLight.intensity;
si = vec3(0.);
if (bitfieldExtract(flags, 0, 1) == 1) {
for (int i = 0; i < lights_count; ++i)
calcLight(lights_start + i, normal, v);
} else {
li = vec3(1.);
}
si *= shlick;
li *= (1. - shlick);
alpha = min(1., alpha * (1. + shlick));
vec2 brdf = texture(tex_coeff_brdf, vec2(NdotV*0.99, roughness*0.995)).rg;
float env_spec = shlick * brdf.x + brdf.y;
vec3 spec_col = mix(vec3(1.), diffuse, metalness);
vec3 env_dir = view_mat * reflect(-v, normal);
vec3 env_col = textureLod(tex_env, env_dir, sqrt(roughness) * max_lod).rgb * spec_col;
vec3 res_col = max(vec3(0.), li * diffuse + si * spec_col + emission);
res_col = mix(res_col, env_col, env_spec * reflectivity);
if (bitfieldExtract(flags, 1, 1) == 1) {
float plen = length(pos.xyz);
float fog = 1. - exp(-plen / fog_decay);
fog = clamp(fog * fog_color.a * fog_density, 0., 1.);
res_col = mix(res_col, fog_color.rgb, fog);
}
qgl_FragColor = vec4(res_col, alpha);
//qgl_FragColor = vec4(diffuse.rgb, 0.25);
//qgl_FragColor.a = alpha;
//qgl_FragColor.rgb = vec3(geom_normal.rgb);
//qgl_FragColor.rgba = vec4(vec3(0), 0.5);
#ifdef SPOT
//vec4 shp = mapScreenToShadow(0, vec3(0));
//shp.xy /= shp.w;
//float depth = texture(tex_depths_cone, vec3(shp.xy, 0)).r;
////depth = 1 / (1 - depth) - 1 + z_near;
//float dz = max(0, shp.z - depth);
//shp.z -= bias;
//for (int xi = -2; xi <= 2; ++xi) {
// for (int yi = -2; yi <= 2; ++yi) {
//qgl_FragColor.rgb = vec3(step(shp.z, texture(tex_shadows_cone, vec3(shp.xy, 0)).r));
//qgl_FragColor.r = texture(tex_shadows_cone, vec3(0)).r;
//qgl_FragColor.rgb = vec3(abs(depth) + 1);
//float _d = texture(tex_depths_cone, vec3(shp.xy, 0)).r;
//_d = 1 / (1 - _d) - 1 + z_near;
//qgl_FragColor.rgb = vec3(texelFetch(tex_noise, tc % noise_size, 0).b);//vec4(res_col, alpha);
//shp.z += 0.095;
//qgl_FragColor.rgb = vec3(texture(tex_sh, shp.xy).rgb);
//qgl_FragColor.rgb = vec3(textureProj(tex_shadow[0], shp));
//vec4 rp = qgl_ViewProjMatrix*vec4(qgl_FragTexture.xy,z,1);
//qgl_FragColor.rgb = vec3(texture(tex_shadows_cone, vec3(gl_FragCoord.xy/1000, 0)).r);
#else
//vec3 odir = -(view_mat * ldir);
//float otex = texture(tex_shadows_omni, vec4(odir, 0), 0.8);
//qgl_FragColor.rgb = vec3(otex);
//qgl_FragColor.rgb = vec3(ldist/50);
//qgl_FragColor.rgb = vec3(abs(otex - ldist) * 1.);
//qgl_FragColor.rgb = vec3(tan((1-abs(dot(view_mat*normal, odir)))));
#endif
//vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y);
//qgl_FragColor.rgb = vec3(shlick * brdf.x + brdf.y);
//qgl_FragColor.rgb = vec3(alpha);
//qgl_FragColor.rgb = vec3(textureLod(tex_env, world_dir, 0).rgb);
//qgl_FragColor.a = 1.;
}
Reference in New Issue View Git Blame Copy Permalink