mirror of
https://github.com/X0nk/Bliss-Shader.git
synced 2024-12-23 01:59:39 +08:00
2ee6634935
new stuff reworked clouds, general lighting, end and nether shaders still WIP lighting is more balanced in general.
197 lines
6.2 KiB
GLSL
197 lines
6.2 KiB
GLSL
#version 120
|
|
#extension GL_EXT_gpu_shader4 : enable
|
|
|
|
#include "/lib/settings.glsl"
|
|
|
|
flat varying vec3 ambientUp;
|
|
flat varying vec3 ambientLeft;
|
|
flat varying vec3 ambientRight;
|
|
flat varying vec3 ambientB;
|
|
flat varying vec3 ambientF;
|
|
flat varying vec3 ambientDown;
|
|
flat varying vec3 zenithColor;
|
|
flat varying vec3 sunColor;
|
|
flat varying vec3 sunColorCloud;
|
|
flat varying vec3 moonColor;
|
|
flat varying vec3 moonColorCloud;
|
|
flat varying vec3 lightSourceColor;
|
|
flat varying vec3 avgSky;
|
|
flat varying vec2 tempOffsets;
|
|
flat varying float exposure;
|
|
flat varying float avgBrightness;
|
|
flat varying float exposureF;
|
|
flat varying float rodExposure;
|
|
flat varying float fogAmount;
|
|
flat varying float VFAmount;
|
|
|
|
uniform sampler2D colortex4;
|
|
uniform sampler2D colortex6;
|
|
|
|
uniform mat4 gbufferModelViewInverse;
|
|
uniform vec3 sunPosition;
|
|
uniform vec2 texelSize;
|
|
uniform float rainStrength;
|
|
uniform float sunElevation;
|
|
uniform float nightVision;
|
|
uniform float frameTime;
|
|
uniform float eyeAltitude;
|
|
uniform int frameCounter;
|
|
uniform int worldTime;
|
|
vec3 sunVec = vec3(0.0,1.0,0.0);
|
|
|
|
|
|
|
|
#include "/lib/sky_gradient.glsl"
|
|
#include "/lib/util.glsl"
|
|
#include "/lib/ROBOBO_sky.glsl"
|
|
|
|
|
|
vec3 rodSample(vec2 Xi)
|
|
{
|
|
float r = sqrt(1.0f - Xi.x*Xi.y);
|
|
float phi = 2 * 3.14159265359 * Xi.y;
|
|
|
|
return normalize(vec3(cos(phi) * r, sin(phi) * r, Xi.x)).xzy;
|
|
}
|
|
vec3 cosineHemisphereSample(vec2 Xi)
|
|
{
|
|
float r = sqrt(Xi.x);
|
|
float theta = 2.0 * 3.14159265359 * Xi.y;
|
|
|
|
float x = r * cos(theta);
|
|
float y = r * sin(theta);
|
|
|
|
return vec3(x, y, sqrt(clamp(1.0 - Xi.x,0.,1.)));
|
|
}
|
|
|
|
float luma(vec3 color) {
|
|
return dot(color,vec3(0.21, 0.72, 0.07));
|
|
}
|
|
vec3 toLinear(vec3 sRGB){
|
|
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
|
|
}
|
|
|
|
|
|
vec2 tapLocation(int sampleNumber,int nb, float nbRot,float jitter)
|
|
{
|
|
float alpha = float(sampleNumber+jitter)/nb;
|
|
float angle = (jitter+alpha) * (nbRot * 6.28);
|
|
|
|
float ssR = alpha;
|
|
float sin_v, cos_v;
|
|
|
|
sin_v = sin(angle);
|
|
cos_v = cos(angle);
|
|
|
|
return vec2(cos_v, sin_v)*ssR;
|
|
}
|
|
//Low discrepancy 2D sequence, integration error is as low as sobol but easier to compute : http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
|
|
vec2 R2_samples(int n){
|
|
vec2 alpha = vec2(0.75487765, 0.56984026);
|
|
return fract(alpha * n);
|
|
}
|
|
void main() {
|
|
|
|
gl_Position = ftransform()*0.5+0.5;
|
|
gl_Position.xy = gl_Position.xy*vec2(18.+258*2,258.)*texelSize;
|
|
gl_Position.xy = gl_Position.xy*2.-1.0;
|
|
|
|
// tempOffsets = R2_samples(frameCounter%10000);
|
|
|
|
// ambientUp = vec3(0.0);
|
|
// ambientDown = vec3(0.0);
|
|
// ambientLeft = vec3(0.0);
|
|
// ambientRight = vec3(0.0);
|
|
// ambientB = vec3(0.0);
|
|
// ambientF = vec3(0.0);
|
|
// avgSky = vec3(0.0);
|
|
|
|
|
|
|
|
// //Fake bounced sunlight
|
|
// vec3 bouncedSun = clamp(gl_Fog.color.rgb*pow(luma(gl_Fog.color.rgb),-0.75)*0.65,0.0,1.0)/4000.*0.08;
|
|
// ambientUp += bouncedSun*clamp(-sunVec.y+5.,0.,6.0);
|
|
// ambientLeft += bouncedSun*clamp(sunVec.x+5.,0.0,6.);
|
|
// ambientRight += bouncedSun*clamp(-sunVec.x+5.,0.0,6.);
|
|
// ambientB += bouncedSun*clamp(-sunVec.z+5.,0.0,6.);
|
|
// ambientF += bouncedSun*clamp(sunVec.z+5.,0.0,6.);
|
|
// ambientDown += bouncedSun*clamp(sunVec.y+5.,0.0,6.);
|
|
|
|
|
|
// float avgLuma = 0.0;
|
|
// float m2 = 0.0;
|
|
// int n=100;
|
|
// vec2 clampedRes = max(1.0/texelSize,vec2(1920.0,1080.));
|
|
// float avgExp = 0.0;
|
|
// vec2 resScale = vec2(1920.,1080.)/clampedRes;
|
|
// float v[25];
|
|
// float temp;
|
|
// // 5x5 Median filter by morgan mcguire
|
|
// // We take the median value of the most blurred bloom buffer
|
|
// #define s2(a, b) temp = a; a = min(a, b); b = max(temp, b);
|
|
// #define t2(a, b) s2(v[a], v[b]);
|
|
// #define t24(a, b, c, d, e, f, g, h) t2(a, b); t2(c, d); t2(e, f); t2(g, h);
|
|
// #define t25(a, b, c, d, e, f, g, h, i, j) t24(a, b, c, d, e, f, g, h); t2(i, j);
|
|
// for (int i = 0; i < 5; i++){
|
|
// for (int j = 0; j < 5; j++){
|
|
// vec2 tc = 0.5 + vec2(i-2,j-2)/2.0 * 0.35;
|
|
// v[i+j*5] = luma(texture2D(colortex6,tc/128. * resScale+vec2(0.484375*resScale.x+10.5*texelSize.x,.0)).rgb);
|
|
// }
|
|
// }
|
|
// t25(0, 1, 3, 4, 2, 4, 2, 3, 6, 7);
|
|
// t25(5, 7, 5, 6, 9, 7, 1, 7, 1, 4);
|
|
// t25(12, 13, 11, 13, 11, 12, 15, 16, 14, 16);
|
|
// t25(14, 15, 18, 19, 17, 19, 17, 18, 21, 22);
|
|
// t25(20, 22, 20, 21, 23, 24, 2, 5, 3, 6);
|
|
// t25(0, 6, 0, 3, 4, 7, 1, 7, 1, 4);
|
|
// t25(11, 14, 8, 14, 8, 11, 12, 15, 9, 15);
|
|
// t25(9, 12, 13, 16, 10, 16, 10, 13, 20, 23);
|
|
// t25(17, 23, 17, 20, 21, 24, 18, 24, 18, 21);
|
|
// t25(19, 22, 8, 17, 9, 18, 0, 18, 0, 9);
|
|
// t25(10, 19, 1, 19, 1, 10, 11, 20, 2, 20);
|
|
// t25(2, 11, 12, 21, 3, 21, 3, 12, 13, 22);
|
|
// t25(4, 22, 4, 13, 14, 23, 5, 23, 5, 14);
|
|
// t25(15, 24, 6, 24, 6, 15, 7, 16, 7, 19);
|
|
// t25(3, 11, 5, 17, 11, 17, 9, 17, 4, 10);
|
|
// t25(6, 12, 7, 14, 4, 6, 4, 7, 12, 14);
|
|
// t25(10, 14, 6, 7, 10, 12, 6, 10, 6, 17);
|
|
// t25(12, 17, 7, 17, 7, 10, 12, 18, 7, 12);
|
|
// t24(10, 18, 12, 20, 10, 20, 10, 12);
|
|
// avgExp = v[12]; // Median value
|
|
|
|
|
|
// avgBrightness = clamp(mix(avgExp,texelFetch2D(colortex4,ivec2(10,37),0).g,0.95),0.00003051757,65000.0);
|
|
|
|
// float currentExposure = texelFetch2D(colortex4,ivec2(10,37),0).b;
|
|
// float L = max(avgBrightness,1e-8);
|
|
// float keyVal = 1.03-2.0/(log(L+1.0)/log(10.0)+2.0);
|
|
// float targetExposure = 1.0*keyVal/L;
|
|
|
|
// float targetrodExposure = clamp(log(targetExposure*2.0+1.0)-0.1,0.0,2.0);
|
|
// float currentrodExposure = texelFetch2D(colortex4,ivec2(14,37),0).r;
|
|
|
|
// targetExposure = clamp(targetExposure,2.0,3.0);
|
|
// float rad = sqrt(currentExposure);
|
|
// float rtarget = sqrt(targetExposure);
|
|
// float dir = sign(rtarget-rad);
|
|
// float dist = abs(rtarget-rad);
|
|
// float maxApertureChange = 0.0032*frameTime/0.016666*Exposure_Speed * exp2(max(rad,rtarget)*0.5);
|
|
|
|
// maxApertureChange *= 1.0+nightVision*4.;
|
|
// rad = rad+dir*min(dist,maxApertureChange);
|
|
|
|
// exposureF = rad*rad;
|
|
// exposure=exposureF*EXPOSURE_MULTIPLIER;
|
|
|
|
|
|
// dir = sign(targetrodExposure-currentrodExposure);
|
|
// dist = abs(targetrodExposure-currentrodExposure);
|
|
// maxApertureChange = 0.0032*frameTime/0.016666*Exposure_Speed * exp2(max(rad,rtarget)*0.5);
|
|
|
|
// rodExposure = currentrodExposure + dir * min(dist,maxApertureChange);
|
|
|
|
exposure = 1.0;
|
|
rodExposure = clamp(log(1.0*2.0+1.0)-0.1,0.0,2.0);
|
|
|
|
}
|