mirror of
https://github.com/X0nk/Bliss-Shader.git
synced 2025-06-22 08:42:50 +08:00
combine end and nether shaders into one group of programs. for my own ease of use.
This commit is contained in:
Xonk
94
shaders/dimensions/all_particles.fsh
Normal file
94
shaders/dimensions/all_particles.fsh
Normal file
@ -0,0 +1,94 @@
|
||||
// #version 120
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 color;
|
||||
|
||||
uniform sampler2D texture;
|
||||
|
||||
uniform sampler2D noisetex;
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
|
||||
|
||||
uniform mat4 gbufferProjectionInverse;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 shadowModelView;
|
||||
uniform mat4 shadowProjection;
|
||||
uniform vec3 cameraPosition;
|
||||
|
||||
uniform float frameTimeCounter;
|
||||
|
||||
uniform vec2 texelSize;
|
||||
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
uniform float rainStrength;
|
||||
|
||||
#include "/lib/settings.glsl"
|
||||
#include "/lib/diffuse_lighting.glsl"
|
||||
#include "/lib/sky_gradient.glsl"
|
||||
|
||||
vec3 toLinear(vec3 sRGB){
|
||||
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
|
||||
}
|
||||
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
|
||||
vec3 toScreenSpace(vec3 p) {
|
||||
vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
|
||||
vec3 p3 = p * 2. - 1.;
|
||||
vec4 fragposition = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
|
||||
return fragposition.xyz / fragposition.w;
|
||||
}
|
||||
|
||||
uniform int framemod8;
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
vec3 normVec (vec3 vec){
|
||||
return vec*inversesqrt(dot(vec,vec));
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
/* DRAWBUFFERS:2 */
|
||||
void main() {
|
||||
|
||||
gl_FragData[0] = texture2D(texture, lmtexcoord.xy)*color;
|
||||
|
||||
vec3 Albedo = toLinear(gl_FragData[0].rgb);
|
||||
|
||||
vec2 tempOffset = offsets[framemod8];
|
||||
vec3 fragpos = toScreenSpace(gl_FragCoord.xyz*vec3(texelSize,1.0)-vec3(vec2(tempOffset)*texelSize*0.5,0.0));
|
||||
vec3 p3 = mat3(gbufferModelViewInverse) * fragpos;
|
||||
vec3 np3 = normVec(p3);
|
||||
|
||||
vec3 Indirect_lighting = vec3(1.0);
|
||||
float lightmap = lmtexcoord.z;
|
||||
vec3 nothing = vec3(0.0);
|
||||
|
||||
#ifdef END_SHADER
|
||||
float TorchLM = 10.0 - ( 1.0 / (pow(exp(-0.5*inversesqrt(lightmap)),5.0)+0.1));
|
||||
TorchLM = pow(TorchLM/4,10) + pow(lightmap,1.5)*0.5;
|
||||
vec3 TorchLight = (vec3(TORCH_R,TORCH_G,TORCH_B) * TorchLM * 0.75) * TORCH_AMOUNT;
|
||||
|
||||
Indirect_lighting = max(vec3(0.5,0.75,1.0) * 0.1, (MIN_LIGHT_AMOUNT*0.01 + nightVision*0.5) ) + TorchLight;
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_SHADER
|
||||
vec3 AmbientLightColor = skyCloudsFromTexLOD2(vec3( 0, 1, 0), colortex4, 6).rgb / 10;
|
||||
|
||||
Indirect_lighting = DoAmbientLighting_Nether(AmbientLightColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap, nothing, nothing, nothing);
|
||||
#endif
|
||||
|
||||
gl_FragData[0].rgb = Indirect_lighting * Albedo;
|
||||
}
|
||||
45
shaders/dimensions/all_particles.vsh
Normal file
45
shaders/dimensions/all_particles.vsh
Normal file
@ -0,0 +1,45 @@
|
||||
// #version 120
|
||||
//#extension GL_EXT_gpu_shader4 : disable
|
||||
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
/*
|
||||
!! DO NOT REMOVE !!
|
||||
This code is from Chocapic13' shaders
|
||||
Read the terms of modification and sharing before changing something below please !
|
||||
!! DO NOT REMOVE !!
|
||||
*/
|
||||
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 color;
|
||||
uniform vec2 texelSize;
|
||||
uniform int framemod8;
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
lmtexcoord.xy = (gl_MultiTexCoord0).xy;
|
||||
vec2 lmcoord = gl_MultiTexCoord1.xy/255.;
|
||||
lmtexcoord.zw = lmcoord;
|
||||
|
||||
color = gl_Color;
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize;
|
||||
#endif
|
||||
}
|
||||
400
shaders/dimensions/all_solid.fsh
Normal file
400
shaders/dimensions/all_solid.fsh
Normal file
@ -0,0 +1,400 @@
|
||||
//#extension GL_EXT_gpu_shader4 : disable
|
||||
//#extension GL_ARB_shader_texture_lod : disable
|
||||
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
|
||||
flat varying int NameTags;
|
||||
|
||||
#ifndef USE_LUMINANCE_AS_HEIGHTMAP
|
||||
#ifndef MC_NORMAL_MAP
|
||||
#undef POM
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
#define MC_NORMAL_MAP
|
||||
#endif
|
||||
|
||||
|
||||
varying float VanillaAO;
|
||||
|
||||
const float mincoord = 1.0/4096.0;
|
||||
const float maxcoord = 1.0-mincoord;
|
||||
|
||||
const float MAX_OCCLUSION_DISTANCE = MAX_DIST;
|
||||
const float MIX_OCCLUSION_DISTANCE = MAX_DIST*0.9;
|
||||
const int MAX_OCCLUSION_POINTS = MAX_ITERATIONS;
|
||||
|
||||
uniform vec2 texelSize;
|
||||
uniform int framemod8;
|
||||
|
||||
// #ifdef POM
|
||||
varying vec4 vtexcoordam; // .st for add, .pq for mul
|
||||
varying vec4 vtexcoord;
|
||||
|
||||
vec2 dcdx = dFdx(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
|
||||
vec2 dcdy = dFdy(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
|
||||
// #endif
|
||||
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 color;
|
||||
varying vec4 NoSeasonCol;
|
||||
varying vec4 seasonColor;
|
||||
uniform float far;
|
||||
varying vec4 normalMat;
|
||||
|
||||
#ifdef MC_NORMAL_MAP
|
||||
varying vec4 tangent;
|
||||
uniform sampler2D normals;
|
||||
varying vec3 FlatNormals;
|
||||
#endif
|
||||
|
||||
uniform sampler2D specular;
|
||||
|
||||
flat varying int lightningBolt;
|
||||
uniform sampler2D texture;
|
||||
uniform sampler2D colortex1;//albedo(rgb),material(alpha) RGBA16
|
||||
uniform float frameTimeCounter;
|
||||
uniform int frameCounter;
|
||||
uniform mat4 gbufferProjectionInverse;
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 gbufferProjection;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform vec3 cameraPosition;
|
||||
uniform float rainStrength;
|
||||
uniform sampler2D noisetex;//depth
|
||||
uniform sampler2D depthtex0;
|
||||
uniform vec4 entityColor;
|
||||
|
||||
flat varying float blockID;
|
||||
|
||||
flat varying float SSSAMOUNT;
|
||||
flat varying float EMISSIVE;
|
||||
flat varying int LIGHTNING;
|
||||
flat varying int SIGN;
|
||||
|
||||
flat varying float HELD_ITEM_BRIGHTNESS;
|
||||
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
|
||||
|
||||
mat3 inverse(mat3 m) {
|
||||
float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];
|
||||
float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];
|
||||
float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];
|
||||
|
||||
float b01 = a22 * a11 - a12 * a21;
|
||||
float b11 = -a22 * a10 + a12 * a20;
|
||||
float b21 = a21 * a10 - a11 * a20;
|
||||
|
||||
float det = a00 * b01 + a01 * b11 + a02 * b21;
|
||||
|
||||
return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),
|
||||
b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),
|
||||
b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;
|
||||
}
|
||||
|
||||
|
||||
#ifdef MC_NORMAL_MAP
|
||||
vec3 applyBump(mat3 tbnMatrix, vec3 bump, float puddle_values){
|
||||
float bumpmult = clamp(puddle_values,0.0,1.0);
|
||||
bump = bump * vec3(bumpmult, bumpmult, bumpmult) + vec3(0.0f, 0.0f, 1.0f - bumpmult);
|
||||
return normalize(bump*tbnMatrix);
|
||||
}
|
||||
#endif
|
||||
|
||||
vec3 viewToWorld(vec3 viewPosition) {
|
||||
vec4 pos;
|
||||
pos.xyz = viewPosition;
|
||||
pos.w = 0.0;
|
||||
pos = gbufferModelViewInverse * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
|
||||
vec3 worldToView(vec3 worldPos) {
|
||||
vec4 pos = vec4(worldPos, 0.0);
|
||||
pos = gbufferModelView * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
|
||||
vec4 encode (vec3 n, vec2 lightmaps){
|
||||
n.xy = n.xy / dot(abs(n), vec3(1.0));
|
||||
n.xy = n.z <= 0.0 ? (1.0 - abs(n.yx)) * sign(n.xy) : n.xy;
|
||||
vec2 encn = clamp(n.xy * 0.5 + 0.5,-1.0,1.0);
|
||||
|
||||
return vec4(encn,vec2(lightmaps.x,lightmaps.y));
|
||||
}
|
||||
|
||||
//encoding by jodie
|
||||
float encodeVec2(vec2 a){
|
||||
const vec2 constant1 = vec2( 1., 256.) / 65535.;
|
||||
vec2 temp = floor( a * 255. );
|
||||
return temp.x*constant1.x+temp.y*constant1.y;
|
||||
}
|
||||
float encodeVec2(float x,float y){
|
||||
return encodeVec2(vec2(x,y));
|
||||
}
|
||||
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
|
||||
|
||||
vec3 toScreenSpace(vec3 p) {
|
||||
vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
|
||||
vec3 p3 = p * 2. - 1.;
|
||||
vec4 fragposition = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
|
||||
return fragposition.xyz / fragposition.w;
|
||||
}
|
||||
vec3 toClipSpace3(vec3 viewSpacePosition) {
|
||||
return projMAD(gbufferProjection, viewSpacePosition) / -viewSpacePosition.z * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
#ifdef POM
|
||||
vec4 readNormal(in vec2 coord)
|
||||
{
|
||||
return texture2DGradARB(normals,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy);
|
||||
}
|
||||
vec4 readTexture(in vec2 coord)
|
||||
{
|
||||
return texture2DGradARB(texture,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy);
|
||||
}
|
||||
#endif
|
||||
|
||||
float luma(vec3 color) {
|
||||
return dot(color,vec3(0.21, 0.72, 0.07));
|
||||
}
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
float bias(){
|
||||
return Texture_MipMap_Bias + (blueNoise()-0.5)*0.5;
|
||||
}
|
||||
|
||||
vec4 texture2D_POMSwitch(
|
||||
sampler2D sampler,
|
||||
vec2 lightmapCoord,
|
||||
vec4 dcdxdcdy,
|
||||
bool ifPOM
|
||||
){
|
||||
if(ifPOM){
|
||||
return texture2DGradARB(sampler, lightmapCoord, dcdxdcdy.xy, dcdxdcdy.zw);
|
||||
}else{
|
||||
return texture2D(sampler, lightmapCoord, bias());
|
||||
}
|
||||
}
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
/* RENDERTARGETS: 1,7,8,15 */
|
||||
void main() {
|
||||
|
||||
|
||||
bool ifPOM = false;
|
||||
|
||||
#ifdef POM
|
||||
ifPOM = true;
|
||||
#endif
|
||||
|
||||
if(SIGN > 0) ifPOM = false;
|
||||
|
||||
vec3 normal = normalMat.xyz;
|
||||
|
||||
#ifdef MC_NORMAL_MAP
|
||||
vec3 tangent2 = normalize(cross(tangent.rgb,normal)*tangent.w);
|
||||
mat3 tbnMatrix = mat3(tangent.x, tangent2.x, normal.x,
|
||||
tangent.y, tangent2.y, normal.y,
|
||||
tangent.z, tangent2.z, normal.z);
|
||||
#endif
|
||||
|
||||
vec2 tempOffset=offsets[framemod8];
|
||||
|
||||
vec3 fragpos = toScreenSpace(gl_FragCoord.xyz*vec3(texelSize,1.0)-vec3(vec2(tempOffset)*texelSize*0.5,0.0));
|
||||
vec3 worldpos = mat3(gbufferModelViewInverse) * fragpos + gbufferModelViewInverse[3].xyz + cameraPosition;
|
||||
|
||||
|
||||
float torchlightmap = lmtexcoord.z;
|
||||
|
||||
#ifdef Hand_Held_lights
|
||||
if(HELD_ITEM_BRIGHTNESS > 0.0) torchlightmap = max(torchlightmap, HELD_ITEM_BRIGHTNESS * clamp( pow(max(1.0-length(fragpos)/10,0.0),1.5),0.0,1.0));
|
||||
#endif
|
||||
|
||||
float lightmap = clamp( (lmtexcoord.w-0.8) * 10.0,0.,1.);
|
||||
|
||||
|
||||
vec2 adjustedTexCoord = lmtexcoord.xy;
|
||||
|
||||
#ifdef POM
|
||||
|
||||
adjustedTexCoord = fract(vtexcoord.st)*vtexcoordam.pq+vtexcoordam.st;
|
||||
|
||||
vec3 viewVector = normalize(tbnMatrix*fragpos);
|
||||
float dist = length(fragpos);
|
||||
|
||||
gl_FragDepth = gl_FragCoord.z;
|
||||
|
||||
#ifdef WORLD
|
||||
if (dist < MAX_OCCLUSION_DISTANCE) {
|
||||
|
||||
float depthmap = readNormal(vtexcoord.st).a;
|
||||
float used_POM_DEPTH = 1.0;
|
||||
|
||||
if ( viewVector.z < 0.0 && depthmap < 0.9999 && depthmap > 0.00001) {
|
||||
|
||||
#ifdef Adaptive_Step_length
|
||||
vec3 interval = (viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS * POM_DEPTH) * clamp(1.0-pow(depthmap,2),0.1,1.0) ;
|
||||
used_POM_DEPTH = 1.0;
|
||||
#else
|
||||
vec3 interval = viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS*POM_DEPTH;
|
||||
#endif
|
||||
vec3 coord = vec3(vtexcoord.st, 1.0);
|
||||
|
||||
coord += interval * used_POM_DEPTH;
|
||||
|
||||
float sumVec = 0.5;
|
||||
for (int loopCount = 0; (loopCount < MAX_OCCLUSION_POINTS) && (1.0 - POM_DEPTH + POM_DEPTH * readNormal(coord.st).a ) < coord.p && coord.p >= 0.0; ++loopCount) {
|
||||
coord = coord+interval * used_POM_DEPTH;
|
||||
sumVec += 1.0 * used_POM_DEPTH;
|
||||
}
|
||||
|
||||
if (coord.t < mincoord) {
|
||||
if (readTexture(vec2(coord.s,mincoord)).a == 0.0) {
|
||||
coord.t = mincoord;
|
||||
discard;
|
||||
}
|
||||
}
|
||||
adjustedTexCoord = mix(fract(coord.st)*vtexcoordam.pq+vtexcoordam.st, adjustedTexCoord, max(dist-MIX_OCCLUSION_DISTANCE,0.0)/(MAX_OCCLUSION_DISTANCE-MIX_OCCLUSION_DISTANCE));
|
||||
|
||||
vec3 truePos = fragpos + sumVec*inverse(tbnMatrix)*interval;
|
||||
|
||||
gl_FragDepth = toClipSpace3(truePos).z;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if(!ifPOM) adjustedTexCoord = lmtexcoord.xy;
|
||||
|
||||
////////////////////////////////
|
||||
//////////////////////////////// ALBEDO
|
||||
////////////////////////////////
|
||||
|
||||
vec4 Albedo = texture2D_POMSwitch(texture, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM) * color;
|
||||
if(LIGHTNING > 0) Albedo = vec4(1);
|
||||
|
||||
#ifdef WORLD
|
||||
if (Albedo.a > 0.1) Albedo.a = normalMat.a;
|
||||
else Albedo.a = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef HAND
|
||||
if (Albedo.a > 0.1) Albedo.a = 0.75;
|
||||
else Albedo.a = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef WhiteWorld
|
||||
Albedo.rgb = vec3(1.0);
|
||||
#endif
|
||||
|
||||
////////////////////////////////
|
||||
//////////////////////////////// NORMAL
|
||||
////////////////////////////////
|
||||
|
||||
#ifdef WORLD
|
||||
#ifdef MC_NORMAL_MAP
|
||||
|
||||
vec4 NormalTex = texture2D_POMSwitch(normals, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM);
|
||||
NormalTex.xy = NormalTex.xy*2.0-1.0;
|
||||
NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)),0.0,1.0) ;
|
||||
|
||||
normal = applyBump(tbnMatrix, NormalTex.xyz, 1.0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
////////////////////////////////
|
||||
//////////////////////////////// SPECULAR
|
||||
////////////////////////////////
|
||||
|
||||
#ifdef WORLD
|
||||
vec4 SpecularTex = texture2D_POMSwitch(specular, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM);
|
||||
|
||||
gl_FragData[2].rg = SpecularTex.rg;
|
||||
|
||||
#if EMISSIVE_TYPE == 0
|
||||
gl_FragData[2].a = 0.0;
|
||||
#endif
|
||||
|
||||
#if EMISSIVE_TYPE == 1
|
||||
gl_FragData[2].a = EMISSIVE;
|
||||
#endif
|
||||
|
||||
#if EMISSIVE_TYPE == 2
|
||||
gl_FragData[2].a = SpecularTex.a;
|
||||
if(SpecularTex.a <= 0.0) gl_FragData[2].a = EMISSIVE;
|
||||
#endif
|
||||
|
||||
#if EMISSIVE_TYPE == 3
|
||||
gl_FragData[2].a = SpecularTex.a;
|
||||
#endif
|
||||
|
||||
#if SSS_TYPE == 0
|
||||
gl_FragData[2].b = 0.0;
|
||||
#endif
|
||||
|
||||
#if SSS_TYPE == 1
|
||||
gl_FragData[2].b = SSSAMOUNT;
|
||||
#endif
|
||||
|
||||
#if SSS_TYPE == 2
|
||||
gl_FragData[2].b = SpecularTex.b;
|
||||
if(SpecularTex.b < 65.0/255.0) gl_FragData[2].b = SSSAMOUNT;
|
||||
#endif
|
||||
|
||||
#if SSS_TYPE == 3
|
||||
gl_FragData[2].b = SpecularTex.b;
|
||||
#endif
|
||||
|
||||
// hit glow effect...
|
||||
#ifdef ENTITIES
|
||||
Albedo.rgb = mix(Albedo.rgb, entityColor.rgb, entityColor.a);
|
||||
gl_FragData[2].a = mix(gl_FragData[2].a, 0.9, entityColor.a);;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////////////
|
||||
//////////////////////////////// FINALIZE
|
||||
////////////////////////////////
|
||||
|
||||
vec4 data1 = clamp( encode(viewToWorld(normal), (blueNoise()*vec2(torchlightmap,lmtexcoord.w) / (30.0 * (1+ (1-RENDER_SCALE.x))) ) + vec2(torchlightmap,lmtexcoord.w)), 0.0, 1.0);
|
||||
gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x), encodeVec2(Albedo.y,data1.y), encodeVec2(Albedo.z,data1.z), encodeVec2(data1.w,Albedo.w));
|
||||
|
||||
gl_FragData[1].a = 0.0;
|
||||
|
||||
////////////////////////////////
|
||||
//////////////////////////////// OTHER STUFF
|
||||
////////////////////////////////
|
||||
|
||||
#ifdef WORLD
|
||||
gl_FragData[3] = vec4(FlatNormals * 0.5 + 0.5,VanillaAO);
|
||||
#endif
|
||||
|
||||
// gl_FragData[4].x = 0;
|
||||
|
||||
// #ifdef ENTITIES
|
||||
// gl_FragData[4].x = 1;
|
||||
// #endif
|
||||
}
|
||||
317
shaders/dimensions/all_solid.vsh
Normal file
317
shaders/dimensions/all_solid.vsh
Normal file
@ -0,0 +1,317 @@
|
||||
//#extension GL_EXT_gpu_shader4 : disable
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
/*
|
||||
!! DO NOT REMOVE !!
|
||||
This code is from Chocapic13' shaders
|
||||
Read the terms of modification and sharing before changing something below please !
|
||||
!! DO NOT REMOVE !!
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAND
|
||||
#undef POM
|
||||
#endif
|
||||
|
||||
#ifndef USE_LUMINANCE_AS_HEIGHTMAP
|
||||
#ifndef MC_NORMAL_MAP
|
||||
#undef POM
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
#define MC_NORMAL_MAP
|
||||
#endif
|
||||
|
||||
|
||||
varying vec4 color;
|
||||
varying float VanillaAO;
|
||||
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 normalMat;
|
||||
|
||||
// #ifdef POM
|
||||
varying vec4 vtexcoordam; // .st for add, .pq for mul
|
||||
varying vec4 vtexcoord;
|
||||
// #endif
|
||||
|
||||
#ifdef MC_NORMAL_MAP
|
||||
varying vec4 tangent;
|
||||
attribute vec4 at_tangent;
|
||||
varying vec3 FlatNormals;
|
||||
#endif
|
||||
|
||||
uniform float frameTimeCounter;
|
||||
const float PI48 = 150.796447372*WAVY_SPEED;
|
||||
float pi2wt = PI48*frameTimeCounter;
|
||||
|
||||
attribute vec4 mc_Entity;
|
||||
uniform int blockEntityId;
|
||||
uniform int entityId;
|
||||
flat varying float blockID;
|
||||
|
||||
uniform int heldItemId;
|
||||
uniform int heldItemId2;
|
||||
flat varying float HELD_ITEM_BRIGHTNESS;
|
||||
|
||||
|
||||
|
||||
flat varying int PHYSICSMOD_SNOW;
|
||||
flat varying int NameTags;
|
||||
|
||||
flat varying float SSSAMOUNT;
|
||||
flat varying float EMISSIVE;
|
||||
flat varying int LIGHTNING;
|
||||
flat varying int PORTAL;
|
||||
flat varying int SIGN;
|
||||
|
||||
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
attribute vec4 mc_midTexCoord;
|
||||
uniform vec3 cameraPosition;
|
||||
uniform vec2 texelSize;
|
||||
uniform int framemod8;
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
|
||||
vec4 toClipSpace3(vec3 viewSpacePosition) {
|
||||
return vec4(projMAD(gl_ProjectionMatrix, viewSpacePosition),-viewSpacePosition.z);
|
||||
}
|
||||
|
||||
vec2 calcWave(in vec3 pos) {
|
||||
|
||||
float magnitude = abs(sin(dot(vec4(frameTimeCounter, pos),vec4(1.0,0.005,0.005,0.005)))*0.5+0.72)*0.013;
|
||||
vec2 ret = (sin(pi2wt*vec2(0.0063,0.0015)*4. - pos.xz + pos.y*0.05)+0.1)*magnitude;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec3 calcMovePlants(in vec3 pos) {
|
||||
vec2 move1 = calcWave(pos );
|
||||
float move1y = -length(move1);
|
||||
return vec3(move1.x,move1y,move1.y)*5.*WAVY_STRENGTH;
|
||||
}
|
||||
|
||||
vec3 calcWaveLeaves(in vec3 pos, in float fm, in float mm, in float ma, in float f0, in float f1, in float f2, in float f3, in float f4, in float f5) {
|
||||
|
||||
float magnitude = abs(sin(dot(vec4(frameTimeCounter, pos),vec4(1.0,0.005,0.005,0.005)))*0.5+0.72)*0.013;
|
||||
vec3 ret = (sin(pi2wt*vec3(0.0063,0.0224,0.0015)*1.5 - pos))*magnitude;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec3 calcMoveLeaves(in vec3 pos, in float f0, in float f1, in float f2, in float f3, in float f4, in float f5, in vec3 amp1, in vec3 amp2) {
|
||||
vec3 move1 = calcWaveLeaves(pos , 0.0054, 0.0400, 0.0400, 0.0127, 0.0089, 0.0114, 0.0063, 0.0224, 0.0015) * amp1;
|
||||
return move1*5.*WAVY_STRENGTH;
|
||||
}
|
||||
vec3 srgbToLinear2(vec3 srgb){
|
||||
return mix(
|
||||
srgb / 12.92,
|
||||
pow(.947867 * srgb + .0521327, vec3(2.4) ),
|
||||
step( .04045, srgb )
|
||||
);
|
||||
}
|
||||
vec3 blackbody2(float Temp)
|
||||
{
|
||||
float t = pow(Temp, -1.5);
|
||||
float lt = log(Temp);
|
||||
|
||||
vec3 col = vec3(0.0);
|
||||
col.x = 220000.0 * t + 0.58039215686;
|
||||
col.y = 0.39231372549 * lt - 2.44549019608;
|
||||
col.y = Temp > 6500. ? 138039.215686 * t + 0.72156862745 : col.y;
|
||||
col.z = 0.76078431372 * lt - 5.68078431373;
|
||||
col = clamp(col,0.0,1.0);
|
||||
col = Temp < 1000. ? col * Temp * 0.001 : col;
|
||||
|
||||
return srgbToLinear2(col);
|
||||
}
|
||||
// float luma(vec3 color) {
|
||||
// return dot(color,vec3(0.21, 0.72, 0.07));
|
||||
// }
|
||||
|
||||
#define SEASONS_VSH
|
||||
#include "/lib/climate_settings.glsl"
|
||||
|
||||
|
||||
uniform sampler2D noisetex;//depth
|
||||
float densityAtPos(in vec3 pos){
|
||||
pos /= 18.;
|
||||
pos.xz *= 0.5;
|
||||
vec3 p = floor(pos);
|
||||
vec3 f = fract(pos);
|
||||
vec2 uv = p.xz + f.xz + p.y * vec2(0.0,193.0);
|
||||
vec2 coord = uv / 512.0;
|
||||
|
||||
//The y channel has an offset to avoid using two textures fetches
|
||||
vec2 xy = texture2D(noisetex, coord).yx;
|
||||
|
||||
return mix(xy.r,xy.g, f.y);
|
||||
}
|
||||
float luma(vec3 color) {
|
||||
return dot(color,vec3(0.21, 0.72, 0.07));
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
|
||||
void main() {
|
||||
|
||||
gl_Position = ftransform();
|
||||
|
||||
vec3 position = mat3(gl_ModelViewMatrix) * vec3(gl_Vertex) + gl_ModelViewMatrix[3].xyz;
|
||||
|
||||
|
||||
|
||||
/////// ----- COLOR STUFF ----- ///////
|
||||
color = gl_Color;
|
||||
|
||||
VanillaAO = 1.0 - clamp(color.a,0,1);
|
||||
if (color.a < 0.3) color.a = 1.0; // fix vanilla ao on some custom block models.
|
||||
|
||||
|
||||
|
||||
|
||||
/////// ----- RANDOM STUFF ----- ///////
|
||||
|
||||
lmtexcoord.xy = (gl_MultiTexCoord0).xy;
|
||||
|
||||
// #ifdef POM
|
||||
vec2 midcoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texcoordminusmid = lmtexcoord.xy-midcoord;
|
||||
vtexcoordam.pq = abs(texcoordminusmid)*2;
|
||||
vtexcoordam.st = min(lmtexcoord.xy,midcoord-texcoordminusmid);
|
||||
vtexcoord.xy = sign(texcoordminusmid)*0.5+0.5;
|
||||
// #endif
|
||||
|
||||
vec2 lmcoord = gl_MultiTexCoord1.xy / 255.0; // is this even correct? lol'
|
||||
lmtexcoord.zw = lmcoord;
|
||||
|
||||
|
||||
|
||||
#ifdef MC_NORMAL_MAP
|
||||
tangent = vec4(normalize(gl_NormalMatrix *at_tangent.rgb),at_tangent.w);
|
||||
#endif
|
||||
|
||||
normalMat = vec4(normalize(gl_NormalMatrix *gl_Normal), 1.0);
|
||||
FlatNormals = normalMat.xyz;
|
||||
|
||||
blockID = mc_Entity.x;
|
||||
|
||||
|
||||
SIGN = 0;
|
||||
#ifdef WORLD
|
||||
// disallow POM to work on signs.
|
||||
if(blockEntityId == 2200) SIGN = 1;
|
||||
#endif
|
||||
|
||||
NameTags = 0;
|
||||
PHYSICSMOD_SNOW = 0;
|
||||
|
||||
#ifdef ENTITIES
|
||||
// disallow POM to work on item frames.
|
||||
if(entityId == 2300) SIGN = 1;
|
||||
|
||||
#ifdef ENTITY_PHYSICSMOD_SNOW
|
||||
if(entityId == 829925) PHYSICSMOD_SNOW = 1;
|
||||
#endif
|
||||
|
||||
|
||||
// try and single out nametag text and then discard nametag background
|
||||
// if( dot(gl_Color.rgb, vec3(1.0/3.0)) < 1.0) NameTags = 1;
|
||||
// if(gl_Color.a < 1.0) NameTags = 1;
|
||||
// if(gl_Color.a >= 0.24 && gl_Color.a <= 0.25 ) gl_Position = vec4(10,10,10,1);
|
||||
|
||||
if(entityId == 1100 || entityId == 1200 || entityId == 2468) normalMat.a = 0.45;
|
||||
|
||||
#endif
|
||||
|
||||
if(mc_Entity.x == 10003) normalMat.a = 0.55;
|
||||
|
||||
/////// ----- EMISSIVE STUFF ----- ///////
|
||||
EMISSIVE = 0.0;
|
||||
LIGHTNING = 0;
|
||||
// if(NameTags > 0) EMISSIVE = 0.9;
|
||||
|
||||
// normal block lightsources
|
||||
if(mc_Entity.x == 10005) EMISSIVE = 0.5;
|
||||
|
||||
// special cases light lightning and beacon beams...
|
||||
#ifdef ENTITIES
|
||||
if(entityId == 12345){
|
||||
LIGHTNING = 1;
|
||||
normalMat.a = 0.5;
|
||||
}
|
||||
#endif
|
||||
|
||||
/////// ----- SSS STUFF ----- ///////
|
||||
SSSAMOUNT = 0.0;
|
||||
|
||||
HELD_ITEM_BRIGHTNESS = 0.0;
|
||||
|
||||
#ifdef Hand_Held_lights
|
||||
if(heldItemId == 100 || heldItemId2 == 100) HELD_ITEM_BRIGHTNESS = 0.9;
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef WORLD
|
||||
|
||||
/////// ----- SSS ON BLOCKS ----- ///////
|
||||
// strong
|
||||
if(mc_Entity.x == 10001 || mc_Entity.x == 10003 || mc_Entity.x == 10004) SSSAMOUNT = 1.0;
|
||||
|
||||
// medium
|
||||
if(mc_Entity.x == 10006 || mc_Entity.x == 200) SSSAMOUNT = 0.75;
|
||||
|
||||
// low
|
||||
if(mc_Entity.x == 10007 || mc_Entity.x == 10008) SSSAMOUNT = 0.5;
|
||||
|
||||
#ifdef ENTITIES
|
||||
/////// ----- SSS ON MOBS----- ///////
|
||||
// strong
|
||||
if(entityId == 1100) SSSAMOUNT = 0.75;
|
||||
|
||||
// medium
|
||||
|
||||
// low
|
||||
if(entityId == 1200) SSSAMOUNT = 0.3;
|
||||
#endif
|
||||
|
||||
#ifdef BLOCKENTITIES
|
||||
/////// ----- SSS ON BLOCK ENTITIES----- ///////
|
||||
// strong
|
||||
|
||||
// medium
|
||||
if(blockEntityId == 10010) SSSAMOUNT = 0.4;
|
||||
|
||||
// low
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
gl_Position = toClipSpace3(position);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy += offsets[framemod8] * gl_Position.w * texelSize;
|
||||
#endif
|
||||
}
|
||||
443
shaders/dimensions/all_translucent.fsh
Normal file
443
shaders/dimensions/all_translucent.fsh
Normal file
@ -0,0 +1,443 @@
|
||||
// #version 120
|
||||
//#extension GL_EXT_gpu_shader4 : disable
|
||||
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 color;
|
||||
|
||||
|
||||
uniform sampler2D normals;
|
||||
varying vec4 tangent;
|
||||
|
||||
varying vec4 normalMat;
|
||||
varying vec3 binormal;
|
||||
|
||||
|
||||
varying vec3 viewVector;
|
||||
|
||||
#include "/lib/settings.glsl"
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
|
||||
uniform sampler2D texture;
|
||||
uniform sampler2D noisetex;
|
||||
uniform sampler2DShadow shadow;
|
||||
// uniform sampler2D gaux2;
|
||||
// uniform sampler2D gaux1;
|
||||
|
||||
uniform sampler2D colortex5;
|
||||
uniform sampler2D depthtex1;
|
||||
|
||||
|
||||
const bool colortex4MipmapEnabled = true;
|
||||
|
||||
uniform vec3 sunVec;
|
||||
uniform float frameTimeCounter;
|
||||
uniform float lightSign;
|
||||
uniform float near;
|
||||
uniform float far;
|
||||
uniform float moonIntensity;
|
||||
uniform float sunIntensity;
|
||||
uniform vec3 sunColor;
|
||||
uniform vec3 nsunColor;
|
||||
uniform vec3 upVec;
|
||||
uniform float sunElevation;
|
||||
uniform float fogAmount;
|
||||
uniform vec2 texelSize;
|
||||
uniform float rainStrength;
|
||||
uniform float skyIntensityNight;
|
||||
uniform float skyIntensity;
|
||||
flat varying vec3 WsunVec;
|
||||
uniform mat4 gbufferPreviousModelView;
|
||||
uniform vec3 previousCameraPosition;
|
||||
uniform int framemod8;
|
||||
uniform sampler2D specular;
|
||||
uniform int frameCounter;
|
||||
uniform int isEyeInWater;
|
||||
uniform ivec2 eyeBrightness;
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
|
||||
|
||||
flat varying vec4 lightCol; //main light source color (rgb),used light source(1=sun,-1=moon)
|
||||
|
||||
flat varying vec3 averageSkyCol_Clouds;
|
||||
// flat varying vec3 averageSkyCol;
|
||||
|
||||
|
||||
|
||||
#include "/lib/Shadow_Params.glsl"
|
||||
#include "/lib/color_transforms.glsl"
|
||||
#include "/lib/projections.glsl"
|
||||
#include "/lib/sky_gradient.glsl"
|
||||
#include "/lib/waterBump.glsl"
|
||||
#include "/lib/clouds.glsl"
|
||||
#include "/lib/stars.glsl"
|
||||
#include "/lib/volumetricClouds.glsl"
|
||||
#define OVERWORLD_SHADER
|
||||
#include "/lib/diffuse_lighting.glsl"
|
||||
|
||||
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
float R2_dither(){
|
||||
vec2 alpha = vec2(0.75487765, 0.56984026);
|
||||
return fract(alpha.x * gl_FragCoord.x + alpha.y * gl_FragCoord.y + 1.0/1.6180339887 * frameCounter) ;
|
||||
}
|
||||
float interleaved_gradientNoise(){
|
||||
vec2 coord = gl_FragCoord.xy + (frameCounter%40000);
|
||||
// vec2 coord = gl_FragCoord.xy + frameTimeCounter;
|
||||
// vec2 coord = gl_FragCoord.xy;
|
||||
float noise = fract( 52.9829189 * fract( (coord.x * 0.06711056) + (coord.y * 0.00583715)) );
|
||||
return noise ;
|
||||
}
|
||||
float interleaved_gradientNoise(float temporal){
|
||||
vec2 coord = gl_FragCoord.xy;
|
||||
float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y)+temporal);
|
||||
return noise;
|
||||
}
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define PW_DEPTH 1.0 //[0.5 1.0 1.5 2.0 2.5 3.0]
|
||||
#define PW_POINTS 1 //[2 4 6 8 16 32]
|
||||
|
||||
vec3 getParallaxDisplacement(vec3 posxz, float iswater,float bumpmult,vec3 viewVec) {
|
||||
float waveZ = mix(20.0,0.25,iswater);
|
||||
float waveM = mix(0.0,4.0,iswater);
|
||||
|
||||
vec3 parallaxPos = posxz;
|
||||
vec2 vec = viewVector.xy * (1.0 / float(PW_POINTS)) * 22.0 * PW_DEPTH;
|
||||
float waterHeight = getWaterHeightmap(posxz.xz, waveM, waveZ, iswater) ;
|
||||
|
||||
parallaxPos.xz += waterHeight * vec;
|
||||
|
||||
return parallaxPos;
|
||||
|
||||
}
|
||||
|
||||
vec3 applyBump(mat3 tbnMatrix, vec3 bump, float puddle_values){
|
||||
float bumpmult = 1;
|
||||
bump = bump * vec3(bumpmult, bumpmult, bumpmult) + vec3(0.0f, 0.0f, 1.0f - bumpmult);
|
||||
return normalize(bump*tbnMatrix);
|
||||
}
|
||||
|
||||
vec2 tapLocation(int sampleNumber,int nb, float nbRot,float jitter,float distort)
|
||||
{
|
||||
float alpha = (sampleNumber+jitter)/nb;
|
||||
float angle = jitter*6.28 + alpha * nbRot * 6.28;
|
||||
|
||||
float sin_v, cos_v;
|
||||
|
||||
sin_v = sin(angle);
|
||||
cos_v = cos(angle);
|
||||
|
||||
return vec2(cos_v, sin_v)*sqrt(alpha);
|
||||
}
|
||||
|
||||
|
||||
vec3 viewToWorld(vec3 viewPosition) {
|
||||
vec4 pos;
|
||||
pos.xyz = viewPosition;
|
||||
pos.w = 0.0;
|
||||
pos = gbufferModelViewInverse * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
|
||||
vec3 worldToView(vec3 worldPos) {
|
||||
vec4 pos = vec4(worldPos, 0.0);
|
||||
pos = gbufferModelView * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
vec4 encode (vec3 n, vec2 lightmaps){
|
||||
n.xy = n.xy / dot(abs(n), vec3(1.0));
|
||||
n.xy = n.z <= 0.0 ? (1.0 - abs(n.yx)) * sign(n.xy) : n.xy;
|
||||
vec2 encn = clamp(n.xy * 0.5 + 0.5,-1.0,1.0);
|
||||
|
||||
return vec4(encn,vec2(lightmaps.x,lightmaps.y));
|
||||
}
|
||||
|
||||
//encoding by jodie
|
||||
float encodeVec2(vec2 a){
|
||||
const vec2 constant1 = vec2( 1., 256.) / 65535.;
|
||||
vec2 temp = floor( a * 255. );
|
||||
return temp.x*constant1.x+temp.y*constant1.y;
|
||||
}
|
||||
float encodeVec2(float x,float y){
|
||||
return encodeVec2(vec2(x,y));
|
||||
}
|
||||
|
||||
|
||||
float invLinZ (float lindepth){
|
||||
return -((2.0*near/lindepth)-far-near)/(far-near);
|
||||
}
|
||||
float ld(float dist) {
|
||||
return (2.0 * near) / (far + near - dist * (far - near));
|
||||
}
|
||||
|
||||
vec3 rayTrace(vec3 dir,vec3 position,float dither, float fresnel, bool inwater){
|
||||
|
||||
float quality = mix(15,SSR_STEPS,fresnel);
|
||||
vec3 clipPosition = toClipSpace3(position);
|
||||
float rayLength = ((position.z + dir.z * far*sqrt(3.)) > -near) ?
|
||||
(-near -position.z) / dir.z : far*sqrt(3.);
|
||||
vec3 direction = normalize(toClipSpace3(position+dir*rayLength)-clipPosition); //convert to clip space
|
||||
direction.xy = normalize(direction.xy);
|
||||
|
||||
//get at which length the ray intersects with the edge of the screen
|
||||
vec3 maxLengths = (step(0.,direction)-clipPosition) / direction;
|
||||
float mult = min(min(maxLengths.x,maxLengths.y),maxLengths.z);
|
||||
|
||||
|
||||
vec3 stepv = direction * mult / quality*vec3(RENDER_SCALE,1.0);
|
||||
|
||||
|
||||
vec3 spos = clipPosition*vec3(RENDER_SCALE,1.0) + stepv*dither;
|
||||
float minZ = clipPosition.z;
|
||||
float maxZ = spos.z+stepv.z*0.5;
|
||||
|
||||
spos.xy += offsets[framemod8]*texelSize*0.5/RENDER_SCALE;
|
||||
|
||||
float dist = 1.0 + clamp(position.z*position.z/50.0,0,2); // shrink sample size as distance increases
|
||||
for (int i = 0; i <= int(quality); i++) {
|
||||
#ifdef USE_QUARTER_RES_DEPTH
|
||||
// decode depth buffer
|
||||
float sp = sqrt(texelFetch2D(colortex4,ivec2(spos.xy/texelSize/4),0).w/65000.0);
|
||||
sp = invLinZ(sp);
|
||||
|
||||
if(sp <= max(maxZ,minZ) && sp >= min(maxZ,minZ)) return vec3(spos.xy/RENDER_SCALE,sp);
|
||||
#else
|
||||
float sp = texelFetch2D(depthtex1,ivec2(spos.xy/texelSize),0).r;
|
||||
if(sp <= max(maxZ,minZ) && sp >= min(maxZ,minZ)) return vec3(spos.xy/RENDER_SCALE,sp);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
spos += stepv;
|
||||
//small bias
|
||||
minZ = maxZ-(0.0001/dist)/ld(spos.z);
|
||||
if(inwater) minZ = maxZ-0.0004/ld(spos.z);
|
||||
maxZ += stepv.z;
|
||||
}
|
||||
|
||||
return vec3(1.1);
|
||||
}
|
||||
|
||||
vec3 GGX (vec3 n, vec3 v, vec3 l, float r, vec3 F0) {
|
||||
r = pow(r,2.5);
|
||||
// r*=r;
|
||||
|
||||
vec3 h = l + v;
|
||||
float hn = inversesqrt(dot(h, h));
|
||||
|
||||
float dotLH = clamp(dot(h,l)*hn,0.,1.);
|
||||
float dotNH = clamp(dot(h,n)*hn,0.,1.) ;
|
||||
float dotNL = clamp(dot(n,l),0.,1.);
|
||||
float dotNHsq = dotNH*dotNH;
|
||||
|
||||
float denom = dotNHsq * r - dotNHsq + 1.;
|
||||
float D = r / (3.141592653589793 * denom * denom);
|
||||
vec3 F = F0 + (1. - F0) * exp2((-5.55473*dotLH-6.98316)*dotLH);
|
||||
float k2 = .25 * r;
|
||||
|
||||
return dotNL * D * F / (dotLH*dotLH*(1.0-k2)+k2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define PHYSICSMOD_FRAGMENT
|
||||
#include "/lib/oceans.glsl"
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
/* RENDERTARGETS:2,7,11,14 */
|
||||
void main() {
|
||||
if (gl_FragCoord.x * texelSize.x < RENDER_SCALE.x && gl_FragCoord.y * texelSize.y < RENDER_SCALE.y ) {
|
||||
vec2 tempOffset = offsets[framemod8];
|
||||
vec3 fragpos = toScreenSpace(gl_FragCoord.xyz*vec3(texelSize/RENDER_SCALE,1.0)-vec3(vec2(tempOffset)*texelSize*0.5,0.0));
|
||||
|
||||
gl_FragData[0] = texture2D(texture, lmtexcoord.xy, Texture_MipMap_Bias) * color;
|
||||
vec3 Albedo = toLinear(gl_FragData[0].rgb);
|
||||
|
||||
float UnchangedAlpha = gl_FragData[0].a;
|
||||
|
||||
float iswater = normalMat.w;
|
||||
|
||||
#ifdef HAND
|
||||
iswater = 0.1;
|
||||
#endif
|
||||
|
||||
#ifdef Vanilla_like_water
|
||||
if (iswater > 0.5) {
|
||||
gl_FragData[0].a = luma(Albedo.rgb);
|
||||
Albedo = color.rgb * sqrt(luma(Albedo.rgb));
|
||||
}
|
||||
#else
|
||||
if (iswater > 0.9) {
|
||||
Albedo = vec3(0.0);
|
||||
gl_FragData[0] = vec4(vec3(0.0),1.0/255.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
vec4 COLORTEST = vec4(Albedo,UnchangedAlpha);
|
||||
|
||||
vec3 p3 = mat3(gbufferModelViewInverse) * fragpos + gbufferModelViewInverse[3].xyz;
|
||||
|
||||
vec3 normal = normalMat.xyz;
|
||||
vec2 TangentNormal = vec2(0); // for refractions
|
||||
|
||||
vec3 tangent2 = normalize(cross(tangent.rgb,normal)*tangent.w);
|
||||
mat3 tbnMatrix = mat3(tangent.x, tangent2.x, normal.x,
|
||||
tangent.y, tangent2.y, normal.y,
|
||||
tangent.z, tangent2.z, normal.z);
|
||||
|
||||
/// ------ NORMALS ------ ///
|
||||
|
||||
vec4 NormalTex = texture2D(normals, lmtexcoord.xy, Texture_MipMap_Bias).rgba;
|
||||
NormalTex.xy = NormalTex.xy*2.0-1.0;
|
||||
NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)),0.0,1.0) ;
|
||||
TangentNormal = NormalTex.xy*0.5+0.5;
|
||||
|
||||
normal = applyBump(tbnMatrix, NormalTex.xyz, 1.0);
|
||||
|
||||
if (iswater > 0.95){
|
||||
float bumpmult = 1.0;
|
||||
vec3 bump = vec3(0);
|
||||
vec3 posxz = p3+cameraPosition;
|
||||
|
||||
posxz.xz -= posxz.y;
|
||||
posxz.xyz = getParallaxDisplacement(posxz,iswater,bumpmult,normalize(tbnMatrix*fragpos)) ;
|
||||
|
||||
bump = normalize(getWaveHeight(posxz.xz,iswater));
|
||||
|
||||
TangentNormal = bump.xy*0.5+0.5; // tangent space normals for refraction
|
||||
|
||||
bump = bump * vec3(bumpmult, bumpmult, bumpmult) + vec3(0.0f, 0.0f, 1.0f - bumpmult);
|
||||
normal = normalize(bump * tbnMatrix);
|
||||
}
|
||||
|
||||
gl_FragData[2] = vec4(encodeVec2(TangentNormal), encodeVec2(COLORTEST.rg), encodeVec2(COLORTEST.ba), UnchangedAlpha);
|
||||
|
||||
|
||||
vec3 WS_normal = viewToWorld(normal);
|
||||
|
||||
vec2 lightmaps2 = lmtexcoord.zw;
|
||||
vec3 Indirect_lighting = vec3(0.0);
|
||||
|
||||
#ifdef NETHER_SHADER
|
||||
WS_normal.xz = -WS_normal.xz;
|
||||
vec3 AmbientLightColor = skyCloudsFromTexLOD2(WS_normal, colortex4, 6).rgb / 15;
|
||||
|
||||
vec3 up = skyCloudsFromTexLOD2(vec3( 0, 1, 0), colortex4, 6).rgb / 15;
|
||||
vec3 down = skyCloudsFromTexLOD2(vec3( 0,-1, 0), colortex4, 6).rgb / 15;
|
||||
|
||||
|
||||
up *= pow( max( WS_normal.y, 0), 2);
|
||||
down *= pow( max(-WS_normal.y, 0), 2);
|
||||
AmbientLightColor += up + down;
|
||||
|
||||
// do all ambient lighting stuff
|
||||
Indirect_lighting = DoAmbientLighting_Nether(AmbientLightColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmaps2.x, vec3(0.0), vec3(0.0), vec3(0.0));
|
||||
#endif
|
||||
|
||||
#ifdef END_SHADER
|
||||
// do all ambient lighting stuff
|
||||
Indirect_lighting = DoAmbientLighting_End(gl_Fog.color.rgb, vec3(TORCH_R,TORCH_G,TORCH_B), lightmaps2.x, normal, p3 );
|
||||
#endif
|
||||
|
||||
vec3 FinalColor = Indirect_lighting * Albedo;
|
||||
|
||||
#ifdef Glass_Tint
|
||||
float alphashit = min(pow(gl_FragData[0].a,2.0),1.0);
|
||||
FinalColor *= alphashit;
|
||||
#endif
|
||||
|
||||
#ifdef WATER_REFLECTIONS
|
||||
vec2 SpecularTex = texture2D(specular, lmtexcoord.xy, Texture_MipMap_Bias).rg;
|
||||
|
||||
SpecularTex = (iswater > 0.0 && iswater < 0.9) && SpecularTex.r > 0.0 && SpecularTex.g < 0.9 ? SpecularTex : vec2(1.0,0.1);
|
||||
|
||||
float roughness = max(pow(1.0-SpecularTex.r,2.0),0.05);
|
||||
float f0 = SpecularTex.g;
|
||||
|
||||
if (iswater > 0.0){
|
||||
vec3 Reflections_Final = vec3(0.0);
|
||||
vec4 Reflections = vec4(0.0);
|
||||
vec3 SkyReflection = vec3(0.0);
|
||||
|
||||
|
||||
vec3 reflectedVector = reflect(normalize(fragpos), normal);
|
||||
float normalDotEye = dot(normal, normalize(fragpos));
|
||||
float fresnel = pow(clamp(1.0 + normalDotEye,0.0,1.0), 5.0);
|
||||
|
||||
// snells window looking thing
|
||||
if(isEyeInWater == 1 ) fresnel = pow(clamp(1.66 + normalDotEye,0.0,1.0), 25.0);
|
||||
|
||||
fresnel = mix(f0, 1.0, fresnel);
|
||||
|
||||
vec3 wrefl = mat3(gbufferModelViewInverse)*reflectedVector;
|
||||
|
||||
// SSR, Sky, and Sun reflections
|
||||
#ifdef WATER_BACKGROUND_SPECULAR
|
||||
SkyReflection = skyCloudsFromTexLOD2(wrefl, colortex4, 0).rgb / 30.0;
|
||||
if(isEyeInWater == 1) SkyReflection = vec3(0.0);
|
||||
#endif
|
||||
|
||||
#ifdef SCREENSPACE_REFLECTIONS
|
||||
if(iswater > 0.0){
|
||||
vec3 rtPos = rayTrace(reflectedVector,fragpos.xyz, interleaved_gradientNoise(), fresnel, isEyeInWater == 1);
|
||||
if (rtPos.z < 1.){
|
||||
vec3 previousPosition = mat3(gbufferModelViewInverse) * toScreenSpace(rtPos) + gbufferModelViewInverse[3].xyz + cameraPosition-previousCameraPosition;
|
||||
previousPosition = mat3(gbufferPreviousModelView) * previousPosition + gbufferPreviousModelView[3].xyz;
|
||||
previousPosition.xy = projMAD(gbufferPreviousProjection, previousPosition).xy / -previousPosition.z * 0.5 + 0.5;
|
||||
if (previousPosition.x > 0.0 && previousPosition.y > 0.0 && previousPosition.x < 1.0 && previousPosition.x < 1.0) {
|
||||
Reflections.a = 1.0;
|
||||
Reflections.rgb = texture2D(colortex5,previousPosition.xy).rgb;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
float visibilityFactor = clamp(exp2((pow(roughness,3.0) / f0) * -4),0,1);
|
||||
|
||||
Reflections_Final = mix(SkyReflection, Reflections.rgb, Reflections.a);
|
||||
Reflections_Final = mix(FinalColor, Reflections_Final, fresnel * visibilityFactor);
|
||||
|
||||
gl_FragData[0].rgb = Reflections_Final;
|
||||
|
||||
//correct alpha channel with fresnel
|
||||
gl_FragData[0].a = mix(gl_FragData[0].a, 1.0, fresnel);
|
||||
|
||||
if (gl_FragData[0].r > 65000.) gl_FragData[0].rgba = vec4(0.);
|
||||
|
||||
} else {
|
||||
gl_FragData[0].rgb = FinalColor;
|
||||
}
|
||||
#else
|
||||
gl_FragData[0].rgb = FinalColor;
|
||||
#endif
|
||||
|
||||
#ifndef HAND
|
||||
gl_FragData[1] = vec4(Albedo,iswater);
|
||||
#endif
|
||||
|
||||
gl_FragData[3].a = max(lmtexcoord.w*blueNoise()*0.05 + lmtexcoord.w,0.0);
|
||||
}
|
||||
}
|
||||
127
shaders/dimensions/all_translucent.vsh
Normal file
127
shaders/dimensions/all_translucent.vsh
Normal file
@ -0,0 +1,127 @@
|
||||
// #version 120
|
||||
//#extension GL_EXT_gpu_shader4 : disable
|
||||
#include "/lib/settings.glsl"
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
|
||||
/*
|
||||
!! DO NOT REMOVE !!
|
||||
This code is from Chocapic13' shaders
|
||||
Read the terms of modification and sharing before changing something below please !
|
||||
!! DO NOT REMOVE !!
|
||||
*/
|
||||
|
||||
varying vec4 lmtexcoord;
|
||||
varying vec4 color;
|
||||
varying vec4 normalMat;
|
||||
varying vec3 binormal;
|
||||
varying vec3 tangent;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
varying vec3 viewVector;
|
||||
|
||||
flat varying int glass;
|
||||
|
||||
attribute vec4 at_tangent;
|
||||
attribute vec4 mc_Entity;
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
|
||||
uniform vec3 sunPosition;
|
||||
flat varying vec3 WsunVec;
|
||||
uniform float sunElevation;
|
||||
|
||||
varying vec4 tangent_other;
|
||||
|
||||
flat varying vec4 lightCol; //main light source color (rgb),used light source(1=sun,-1=moon)
|
||||
flat varying vec3 avgAmbient;
|
||||
|
||||
|
||||
uniform vec2 texelSize;
|
||||
uniform int framemod8;
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
|
||||
vec4 toClipSpace3(vec3 viewSpacePosition) {
|
||||
return vec4(projMAD(gl_ProjectionMatrix, viewSpacePosition),-viewSpacePosition.z);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
|
||||
vec4 Swtich_gl_vertex = gl_Vertex;
|
||||
|
||||
lmtexcoord.xy = (gl_MultiTexCoord0).xy;
|
||||
vec2 lmcoord = gl_MultiTexCoord1.xy/255.;
|
||||
lmtexcoord.zw = lmcoord;
|
||||
|
||||
vec3 position = mat3(gl_ModelViewMatrix) * vec3(Swtich_gl_vertex) + gl_ModelViewMatrix[3].xyz;
|
||||
gl_Position = toClipSpace3(position);
|
||||
color = gl_Color;
|
||||
float mat = 0.0;
|
||||
|
||||
if(mc_Entity.x == 8.0 || mc_Entity.x == 9.0) {
|
||||
mat = 1.0;
|
||||
|
||||
gl_Position.z -= 1e-4;
|
||||
}
|
||||
|
||||
if (mc_Entity.x == 10002) mat = 0.2;
|
||||
if (mc_Entity.x == 72) mat = 0.5;
|
||||
|
||||
// if (mc_Entity.x == 8) mat = 0.1;
|
||||
|
||||
normalMat = vec4(normalize( gl_NormalMatrix*gl_Normal),mat);
|
||||
|
||||
|
||||
|
||||
tangent_other = vec4(normalize(gl_NormalMatrix * at_tangent.rgb),normalMat.a);
|
||||
|
||||
tangent = normalize( gl_NormalMatrix *at_tangent.rgb);
|
||||
binormal = normalize(cross(tangent.rgb,normalMat.xyz)*at_tangent.w);
|
||||
|
||||
mat3 tbnMatrix = mat3(tangent.x, binormal.x, normalMat.x,
|
||||
tangent.y, binormal.y, normalMat.y,
|
||||
tangent.z, binormal.z, normalMat.z);
|
||||
|
||||
viewVector = ( gl_ModelViewMatrix * Swtich_gl_vertex).xyz;
|
||||
viewVector = normalize(tbnMatrix * viewVector);
|
||||
|
||||
|
||||
|
||||
// #ifdef TAA_UPSCALING
|
||||
// gl_Position.xy = gl_Position.xy * RENDER_SCALE + RENDER_SCALE * gl_Position.w - gl_Position.w;
|
||||
// #endif
|
||||
#ifdef TAA
|
||||
gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize;
|
||||
#endif
|
||||
|
||||
vec3 sc = texelFetch2D(colortex4,ivec2(6,37),0).rgb;
|
||||
|
||||
|
||||
lightCol.a = float(sunElevation > 1e-5)*2-1.;
|
||||
lightCol.rgb = sc;
|
||||
|
||||
WsunVec = lightCol.a*normalize(mat3(gbufferModelViewInverse) *sunPosition);
|
||||
|
||||
avgAmbient = texelFetch2D(colortex4,ivec2(0,37),0).rgb;
|
||||
}
|
||||
669
shaders/dimensions/composite.fsh
Normal file
669
shaders/dimensions/composite.fsh
Normal file
@ -0,0 +1,669 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
#include "/lib/diffuse_lighting.glsl"
|
||||
|
||||
|
||||
varying vec2 texcoord;
|
||||
|
||||
|
||||
|
||||
const bool colortex5MipmapEnabled = true;
|
||||
const bool colortex4MipmapEnabled = true;
|
||||
|
||||
uniform sampler2D noisetex;//depth
|
||||
|
||||
uniform sampler2D depthtex1;//depth
|
||||
uniform sampler2D depthtex0;//depth
|
||||
|
||||
uniform sampler2D colortex0;//clouds
|
||||
uniform sampler2D colortex1;//albedo(rgb),material(alpha) RGBA16
|
||||
uniform sampler2D colortex2;
|
||||
uniform sampler2D colortex3;
|
||||
uniform sampler2D colortex4;//Skybox
|
||||
uniform sampler2D colortex5;
|
||||
uniform sampler2D colortex6;//Skybox
|
||||
uniform sampler2D colortex7;
|
||||
uniform sampler2D colortex8;
|
||||
uniform sampler2D colortex10;
|
||||
uniform sampler2D colortex15;
|
||||
|
||||
|
||||
uniform mat4 shadowModelView;
|
||||
uniform mat4 shadowModelViewInverse;
|
||||
uniform mat4 shadowProjection;
|
||||
uniform mat4 shadowProjectionInverse;
|
||||
uniform mat4 gbufferProjection;
|
||||
uniform mat4 gbufferProjectionInverse;
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform mat4 gbufferPreviousProjection;
|
||||
uniform mat4 gbufferPreviousModelView;
|
||||
|
||||
uniform vec3 cameraPosition;
|
||||
uniform vec3 previousCameraPosition;
|
||||
|
||||
uniform float far;
|
||||
uniform float near;
|
||||
|
||||
uniform vec2 texelSize;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
uniform float aspectRatio;
|
||||
|
||||
flat varying vec2 TAA_Offset;
|
||||
|
||||
uniform int frameCounter;
|
||||
uniform float frameTimeCounter;
|
||||
|
||||
uniform float rainStrength;
|
||||
uniform int isEyeInWater;
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
|
||||
uniform vec3 sunVec;
|
||||
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
|
||||
|
||||
vec3 toScreenSpace(vec3 p) {
|
||||
vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
|
||||
vec3 p3 = p * 2. - 1.;
|
||||
vec4 fragposition = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
|
||||
return fragposition.xyz / fragposition.w;
|
||||
}
|
||||
|
||||
#include "/lib/color_transforms.glsl"
|
||||
#include "/lib/waterBump.glsl"
|
||||
#include "/lib/sky_gradient.glsl"
|
||||
|
||||
|
||||
float ld(float dist) {
|
||||
return (2.0 * near) / (far + near - dist * (far - near));
|
||||
}
|
||||
|
||||
vec2 RENDER_SCALE = vec2(1.0);
|
||||
|
||||
#include "/lib/end_fog.glsl"
|
||||
|
||||
#undef LIGHTSOURCE_REFLECTION
|
||||
#define ENDSPECULAR
|
||||
#include "/lib/specular.glsl"
|
||||
|
||||
|
||||
vec3 normVec (vec3 vec){
|
||||
return vec*inversesqrt(dot(vec,vec));
|
||||
}
|
||||
float lengthVec (vec3 vec){
|
||||
return sqrt(dot(vec,vec));
|
||||
}
|
||||
#define fsign(a) (clamp((a)*1e35,0.,1.)*2.-1.)
|
||||
float triangularize(float dither)
|
||||
{
|
||||
float center = dither*2.0-1.0;
|
||||
dither = center*inversesqrt(abs(center));
|
||||
return clamp(dither-fsign(center),0.0,1.0);
|
||||
}
|
||||
|
||||
vec3 fp10Dither(vec3 color,float dither){
|
||||
const vec3 mantissaBits = vec3(6.,6.,5.);
|
||||
vec3 exponent = floor(log2(color));
|
||||
return color + dither*exp2(-mantissaBits)*exp2(exponent);
|
||||
}
|
||||
|
||||
|
||||
|
||||
float facos(float sx){
|
||||
float x = clamp(abs( sx ),0.,1.);
|
||||
return sqrt( 1. - x ) * ( -0.16882 * x + 1.56734 );
|
||||
}
|
||||
vec3 decode (vec2 encn){
|
||||
vec3 n = vec3(0.0);
|
||||
encn = encn * 2.0 - 1.0;
|
||||
n.xy = abs(encn);
|
||||
n.z = 1.0 - n.x - n.y;
|
||||
n.xy = n.z <= 0.0 ? (1.0 - n.yx) * sign(encn) : encn;
|
||||
return clamp(normalize(n.xyz),-1.0,1.0);
|
||||
}
|
||||
vec2 decodeVec2(float a){
|
||||
const vec2 constant1 = 65535. / vec2( 256., 65536.);
|
||||
const float constant2 = 256. / 255.;
|
||||
return fract( a * constant1 ) * constant2 ;
|
||||
}
|
||||
// float linZ(float depth) {
|
||||
// return (2.0 * near) / (far + near - depth * (far - near));
|
||||
// // l = (2*n)/(f+n-d(f-n))
|
||||
// // f+n-d(f-n) = 2n/l
|
||||
// // -d(f-n) = ((2n/l)-f-n)
|
||||
// // d = -((2n/l)-f-n)/(f-n)
|
||||
|
||||
// }
|
||||
// float invLinZ (float lindepth){
|
||||
// return -((2.0*near/lindepth)-far-near)/(far-near);
|
||||
// }
|
||||
|
||||
// vec3 toClipSpace3(vec3 viewSpacePosition) {
|
||||
// return projMAD(gbufferProjection, viewSpacePosition) / -viewSpacePosition.z * 0.5 + 0.5;
|
||||
// }
|
||||
|
||||
|
||||
|
||||
|
||||
vec2 tapLocation(int sampleNumber,int nb, float nbRot,float jitter,float distort)
|
||||
{
|
||||
float alpha0 = sampleNumber/nb;
|
||||
float alpha = (sampleNumber+jitter)/nb;
|
||||
float angle = jitter*6.28 + alpha * 4.0 * 6.28;
|
||||
|
||||
float sin_v, cos_v;
|
||||
|
||||
sin_v = sin(angle);
|
||||
cos_v = cos(angle);
|
||||
|
||||
return vec2(cos_v, sin_v)*sqrt(alpha);
|
||||
}
|
||||
|
||||
|
||||
|
||||
vec3 BilateralFiltering(sampler2D tex, sampler2D depth,vec2 coord,float frDepth,float maxZ){
|
||||
vec4 sampled = vec4(texelFetch2D(tex,ivec2(coord),0).rgb,1.0);
|
||||
|
||||
return vec3(sampled.x,sampled.yz/sampled.w);
|
||||
}
|
||||
float interleaved_gradientNoise(){
|
||||
// vec2 coord = gl_FragCoord.xy + (frameCounter%40000);
|
||||
vec2 coord = gl_FragCoord.xy + frameTimeCounter;
|
||||
// vec2 coord = gl_FragCoord.xy;
|
||||
float noise = fract( 52.9829189 * fract( (coord.x * 0.06711056) + (coord.y * 0.00583715)) );
|
||||
return noise ;
|
||||
}
|
||||
|
||||
vec2 R2_dither(){
|
||||
vec2 alpha = vec2(0.75487765, 0.56984026);
|
||||
return vec2(fract(alpha.x * gl_FragCoord.x + alpha.y * gl_FragCoord.y + 1.0/1.6180339887 * frameCounter), fract((1.0-alpha.x) * gl_FragCoord.x + (1.0-alpha.y) * gl_FragCoord.y + 1.0/1.6180339887 * frameCounter));
|
||||
}
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * (frameCounter*0.5+0.5) );
|
||||
}
|
||||
vec4 blueNoise(vec2 coord){
|
||||
return texelFetch2D(colortex6, ivec2(coord)%512 , 0) ;
|
||||
}
|
||||
vec3 toShadowSpaceProjected(vec3 p3){
|
||||
p3 = mat3(gbufferModelViewInverse) * p3 + gbufferModelViewInverse[3].xyz;
|
||||
p3 = mat3(shadowModelView) * p3 + shadowModelView[3].xyz;
|
||||
p3 = diagonal3(shadowProjection) * p3 + shadowProjection[3].xyz;
|
||||
|
||||
return p3;
|
||||
}
|
||||
vec2 tapLocation(int sampleNumber, float spinAngle,int nb, float nbRot,float r0)
|
||||
{
|
||||
float alpha = (float(sampleNumber*1.0f + r0) * (1.0 / (nb)));
|
||||
float angle = alpha * (nbRot * 6.28) + spinAngle*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;
|
||||
}
|
||||
|
||||
|
||||
float ssao(vec3 fragpos, float dither,vec3 normal)
|
||||
{
|
||||
float mulfov = 1.0;
|
||||
ivec2 pos = ivec2(gl_FragCoord.xy);
|
||||
const float tan70 = tan(70.*3.14/180.);
|
||||
float mulfov2 = gbufferProjection[1][1]/tan70;
|
||||
|
||||
const float PI = 3.14159265;
|
||||
const float samplingRadius = 0.712;
|
||||
float angle_thresh = 0.05;
|
||||
|
||||
|
||||
|
||||
|
||||
float rd = mulfov2*0.05;
|
||||
//pre-rotate direction
|
||||
float n = 0.;
|
||||
|
||||
float occlusion = 0.0;
|
||||
|
||||
vec2 acc = -vec2(TAA_Offset)*texelSize*0.5;
|
||||
float mult = (dot(normal,normalize(fragpos))+1.0)*0.5+0.5;
|
||||
|
||||
vec2 v = fract(vec2(dither,interleaved_gradientNoise()) + (frameCounter%10000) * vec2(0.75487765, 0.56984026));
|
||||
for (int j = 0; j < 7+2 ;j++) {
|
||||
vec2 sp = tapLocation(j,v.x,7+2,2.,v.y);
|
||||
vec2 sampleOffset = sp*rd;
|
||||
ivec2 offset = ivec2(gl_FragCoord.xy + sampleOffset*vec2(viewWidth,viewHeight));
|
||||
if (offset.x >= 0 && offset.y >= 0 && offset.x < viewWidth && offset.y < viewHeight ) {
|
||||
vec3 t0 = toScreenSpace(vec3(offset*texelSize+acc+0.5*texelSize,texelFetch2D(depthtex1,offset,0).x));
|
||||
|
||||
vec3 vec = t0.xyz - fragpos;
|
||||
float dsquared = dot(vec,vec);
|
||||
if (dsquared > 1e-5){
|
||||
if (dsquared < fragpos.z*fragpos.z*0.05*0.05*mulfov2*2.*1.412){
|
||||
float NdotV = clamp(dot(vec*inversesqrt(dsquared), normalize(normal)),0.,1.);
|
||||
occlusion += NdotV;
|
||||
}
|
||||
n += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
return clamp(1.0-occlusion/n*2.0,0.,1.0);
|
||||
}
|
||||
vec3 viewToWorld(vec3 viewPosition) {
|
||||
vec4 pos;
|
||||
pos.xyz = viewPosition;
|
||||
pos.w = 0.0;
|
||||
pos = gbufferModelViewInverse * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
vec3 worldToView(vec3 worldPos) {
|
||||
vec4 pos = vec4(worldPos, 0.0);
|
||||
pos = gbufferModelView * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
void waterVolumetrics(inout vec3 inColor, vec3 rayStart, vec3 rayEnd, float estEndDepth, float estSunDepth, float rayLength, float dither, vec3 waterCoefs, vec3 scatterCoef, vec3 ambient){
|
||||
inColor *= exp(-rayLength * waterCoefs); //No need to take the integrated value
|
||||
int spCount = rayMarchSampleCount;
|
||||
vec3 start = toShadowSpaceProjected(rayStart);
|
||||
vec3 end = toShadowSpaceProjected(rayEnd);
|
||||
vec3 dV = (end-start);
|
||||
//limit ray length at 32 blocks for performance and reducing integration error
|
||||
//you can't see above this anyway
|
||||
float maxZ = min(rayLength,12.0)/(1e-8+rayLength);
|
||||
dV *= maxZ;
|
||||
vec3 dVWorld = -mat3(gbufferModelViewInverse) * (rayEnd - rayStart) * maxZ;
|
||||
rayLength *= maxZ;
|
||||
float dY = normalize(mat3(gbufferModelViewInverse) * rayEnd).y * rayLength;
|
||||
estEndDepth *= maxZ;
|
||||
estSunDepth *= maxZ;
|
||||
vec3 absorbance = vec3(1.0);
|
||||
vec3 vL = vec3(0.0);
|
||||
|
||||
|
||||
float expFactor = 11.0;
|
||||
vec3 progressW = gbufferModelViewInverse[3].xyz+cameraPosition;
|
||||
for (int i=0;i<spCount;i++) {
|
||||
float d = (pow(expFactor, float(i+dither)/float(spCount))/expFactor - 1.0/expFactor)/(1-1.0/expFactor);
|
||||
float dd = pow(expFactor, float(i+dither)/float(spCount)) * log(expFactor) / float(spCount)/(expFactor-1.0);
|
||||
vec3 spPos = start.xyz + dV*d;
|
||||
progressW = gbufferModelViewInverse[3].xyz+cameraPosition + d*dVWorld;
|
||||
|
||||
vec3 ambientMul = exp(-max(estEndDepth * d,0.0) * waterCoefs);
|
||||
|
||||
vec3 light = (ambientMul*ambient) * scatterCoef;
|
||||
|
||||
vL += (light - light * exp(-waterCoefs * dd * rayLength)) / waterCoefs *absorbance;
|
||||
absorbance *= exp(-dd * rayLength * waterCoefs);
|
||||
}
|
||||
inColor += vL;
|
||||
}
|
||||
|
||||
void Emission(
|
||||
inout vec3 Lighting,
|
||||
vec3 Albedo,
|
||||
float Emission
|
||||
){
|
||||
// if( Emission < 255.0/255.0 ) Lighting = mix(Lighting, Albedo * Emissive_Brightness, pow(Emission, Emissive_Curve)); // old method.... idk why
|
||||
if( Emission < 255.0/255.0 ) Lighting += (Albedo * Emissive_Brightness * 0.25) * pow(Emission, Emissive_Curve);
|
||||
}
|
||||
|
||||
float rayTraceShadow(vec3 dir,vec3 position,float dither){
|
||||
const float quality = 16.;
|
||||
vec3 clipPosition = toClipSpace3(position);
|
||||
//prevents the ray from going behind the camera
|
||||
float rayLength = ((position.z + dir.z * far*sqrt(3.)) > -near) ?
|
||||
(-near -position.z) / dir.z : far*sqrt(3.) ;
|
||||
vec3 direction = toClipSpace3(position+dir*rayLength)-clipPosition; //convert to clip space
|
||||
direction.xyz = direction.xyz/max(abs(direction.x)/texelSize.x,abs(direction.y)/texelSize.y); //fixed step size
|
||||
vec3 stepv = direction * 3.0 * clamp(MC_RENDER_QUALITY,1.,2.0);
|
||||
|
||||
vec3 spos = clipPosition;
|
||||
spos += stepv*dither ;
|
||||
|
||||
for (int i = 0; i < int(quality); i++) {
|
||||
spos += stepv;
|
||||
|
||||
float sp = texture2D(depthtex1,spos.xy).x;
|
||||
|
||||
if( sp < spos.z) {
|
||||
float dist = abs(linZ(sp)-linZ(spos.z))/linZ(spos.z);
|
||||
if (dist < 0.015 ) return i / quality;
|
||||
}
|
||||
}
|
||||
return 1.0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
vec3 rayTrace_GI(vec3 dir,vec3 position,float dither, float quality){
|
||||
|
||||
vec3 clipPosition = toClipSpace3(position);
|
||||
float rayLength = ((position.z + dir.z * far*sqrt(3.)) > -near) ?
|
||||
(-near -position.z) / dir.z : far*sqrt(3.);
|
||||
vec3 direction = normalize(toClipSpace3(position+dir*rayLength)-clipPosition); //convert to clip space
|
||||
direction.xy = normalize(direction.xy);
|
||||
|
||||
//get at which length the ray intersects with the edge of the screen
|
||||
vec3 maxLengths = (step(0.,direction)-clipPosition) / direction;
|
||||
float mult = maxLengths.y;
|
||||
|
||||
vec3 stepv = direction * mult / quality*vec3(RENDER_SCALE,1.0) * dither;
|
||||
vec3 spos = clipPosition*vec3(RENDER_SCALE,1.0) ;
|
||||
|
||||
spos.xy += TAA_Offset*texelSize*0.5/RENDER_SCALE;
|
||||
|
||||
float biasdist = clamp(position.z*position.z/50.0,1,2); // shrink sample size as distance increases
|
||||
|
||||
for(int i = 0; i < int(quality); i++){
|
||||
spos += stepv;
|
||||
float sp = sqrt(texelFetch2D(colortex4,ivec2(spos.xy/texelSize/4),0).w/65000.0);
|
||||
float currZ = linZ(spos.z);
|
||||
|
||||
if( sp < currZ) {
|
||||
float dist = abs(sp-currZ)/currZ;
|
||||
if (abs(dist) < biasdist*0.05) return vec3(spos.xy, invLinZ(sp))/vec3(RENDER_SCALE,1.0);
|
||||
}
|
||||
spos += stepv;
|
||||
}
|
||||
return vec3(1.1);
|
||||
}
|
||||
vec3 RT(vec3 dir, vec3 position, float noise, float stepsizes){
|
||||
float dist = 1.0 + clamp(position.z*position.z/50.0,0,2); // shrink sample size as distance increases
|
||||
|
||||
float stepSize = stepsizes / dist;
|
||||
int maxSteps = STEPS;
|
||||
vec3 clipPosition = toClipSpace3(position);
|
||||
float rayLength = ((position.z + dir.z * sqrt(3.0)*far) > -sqrt(3.0)*near) ?
|
||||
(-sqrt(3.0)*near -position.z) / dir.z : sqrt(3.0)*far;
|
||||
vec3 end = toClipSpace3(position+dir*rayLength) ;
|
||||
vec3 direction = end-clipPosition ; //convert to clip space
|
||||
|
||||
float len = max(abs(direction.x)/texelSize.x,abs(direction.y)/texelSize.y)/stepSize;
|
||||
//get at which length the ray intersects with the edge of the screen
|
||||
vec3 maxLengths = (step(0.,direction)-clipPosition) / direction;
|
||||
|
||||
float mult = min(min(maxLengths.x,maxLengths.y),maxLengths.z)*2000.0;
|
||||
|
||||
vec3 stepv = direction/len;
|
||||
|
||||
int iterations = min(int(min(len, mult*len)-2), maxSteps);
|
||||
|
||||
//Do one iteration for closest texel (good contact shadows)
|
||||
vec3 spos = clipPosition*vec3(RENDER_SCALE,1.0) ;
|
||||
spos.xy += TAA_Offset*texelSize*0.5*RENDER_SCALE;
|
||||
spos += stepv/(stepSize/2);
|
||||
|
||||
float distancered = 1.0 + clamp(position.z*position.z/50.0,0,2); // shrink sample size as distance increases
|
||||
|
||||
for(int i = 0; i < iterations; i++){
|
||||
if (spos.x < 0.0 || spos.y < 0.0 || spos.z < 0.0 || spos.x > 1.0 || spos.y > 1.0 || spos.z > 1.0) return vec3(1.1);
|
||||
spos += stepv*noise;
|
||||
|
||||
float sp = sqrt(texelFetch2D(colortex4,ivec2(spos.xy/ texelSize/4),0).w/65000.0);
|
||||
float currZ = linZ(spos.z);
|
||||
|
||||
if( sp < currZ) {
|
||||
float dist = abs(sp-currZ)/currZ;
|
||||
if (dist <= 0.1) return vec3(spos.xy, invLinZ(sp))/vec3(RENDER_SCALE,1.0);
|
||||
}
|
||||
}
|
||||
return vec3(1.1);
|
||||
}
|
||||
|
||||
vec3 cosineHemisphereSample(vec2 Xi, float roughness){
|
||||
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.)));
|
||||
}
|
||||
|
||||
vec3 TangentToWorld(vec3 N, vec3 H, float roughness){
|
||||
vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
|
||||
vec3 T = normalize(cross(UpVector, N));
|
||||
vec3 B = cross(N, T);
|
||||
|
||||
return vec3((T * H.x) + (B * H.y) + (N * H.z));
|
||||
}
|
||||
vec2 R2_samples(int n){
|
||||
vec2 alpha = vec2(0.75487765, 0.56984026);
|
||||
return fract(alpha * n);
|
||||
}
|
||||
|
||||
void ApplySSRT(inout vec3 lighting, vec3 normal,vec2 noise,vec3 fragpos, float lightmaps, vec3 torchcolor){
|
||||
int nrays = RAY_COUNT;
|
||||
|
||||
vec3 radiance = vec3(0.0);
|
||||
vec3 occlusion = vec3(0.0);
|
||||
vec3 skycontribution = vec3(0.0);
|
||||
|
||||
// float skyLM = 0.0;
|
||||
// vec3 torchlight = vec3(0.0);
|
||||
// vec3 blank = vec3(0.0);
|
||||
// DoRTAmbientLighting(torchcolor, vec2(lightmaps,1.0), skyLM, torchlight, blank);
|
||||
|
||||
for (int i = 0; i < nrays; i++){
|
||||
int seed = (frameCounter%40000)*nrays+i;
|
||||
vec2 ij = fract(R2_samples(seed) + noise );
|
||||
|
||||
vec3 rayDir = TangentToWorld(normal, normalize(cosineHemisphereSample(ij,1.0)) ,1.0);
|
||||
|
||||
#ifdef HQ_SSGI
|
||||
vec3 rayHit = rayTrace_GI( mat3(gbufferModelView) * rayDir, fragpos, blueNoise(), 50.); // ssr rt
|
||||
#else
|
||||
vec3 rayHit = RT(mat3(gbufferModelView)*rayDir, fragpos, blueNoise(), 30.); // choc sspt
|
||||
#endif
|
||||
|
||||
skycontribution = lighting;
|
||||
|
||||
if (rayHit.z < 1.){
|
||||
|
||||
#if indirect_effect == 4
|
||||
vec3 previousPosition = mat3(gbufferModelViewInverse) * toScreenSpace(rayHit) + gbufferModelViewInverse[3].xyz + cameraPosition-previousCameraPosition;
|
||||
previousPosition = mat3(gbufferPreviousModelView) * previousPosition + gbufferPreviousModelView[3].xyz;
|
||||
previousPosition.xy = projMAD(gbufferPreviousProjection, previousPosition).xy / -previousPosition.z * 0.5 + 0.5;
|
||||
if (previousPosition.x > 0.0 && previousPosition.y > 0.0 && previousPosition.x < 1.0 && previousPosition.x < 1.0){
|
||||
radiance += (texture2D(colortex5,previousPosition.xy).rgb + skycontribution) * GI_Strength;
|
||||
}else{
|
||||
radiance += skycontribution;
|
||||
}
|
||||
#else
|
||||
radiance += skycontribution;
|
||||
#endif
|
||||
|
||||
occlusion += skycontribution * GI_Strength;
|
||||
|
||||
} else {
|
||||
radiance += skycontribution;
|
||||
}
|
||||
}
|
||||
|
||||
occlusion *= AO_Strength;
|
||||
|
||||
lighting = max(radiance/nrays - occlusion/nrays, 0.0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
|
||||
////// --------------- SETUP COORDINATE SPACES --------------- //////
|
||||
|
||||
float z0 = texture2D(depthtex0,texcoord).x;
|
||||
float z = texture2D(depthtex1,texcoord).x;
|
||||
|
||||
vec2 tempOffset=TAA_Offset;
|
||||
float noise = blueNoise();
|
||||
|
||||
vec3 fragpos = toScreenSpace(vec3(texcoord-vec2(tempOffset)*texelSize*0.5,z));
|
||||
vec3 p3 = mat3(gbufferModelViewInverse) * fragpos;
|
||||
vec3 np3 = normVec(p3);
|
||||
|
||||
////// --------------- UNPACK OPAQUE GBUFFERS --------------- //////
|
||||
|
||||
vec4 data = texture2D(colortex1,texcoord);
|
||||
vec4 dataUnpacked0 = vec4(decodeVec2(data.x),decodeVec2(data.y)); // albedo, masks
|
||||
vec4 dataUnpacked1 = vec4(decodeVec2(data.z),decodeVec2(data.w)); // normals, lightmaps
|
||||
// vec4 dataUnpacked2 = vec4(decodeVec2(data.z),decodeVec2(data.w));
|
||||
|
||||
vec3 albedo = toLinear(vec3(dataUnpacked0.xz,dataUnpacked1.x));
|
||||
vec2 lightmap = dataUnpacked1.yz;
|
||||
vec3 normal = decode(dataUnpacked0.yw);
|
||||
|
||||
////// --------------- UNPACK MISC --------------- //////
|
||||
|
||||
vec4 SpecularTex = texture2D(colortex8,texcoord);
|
||||
float LabSSS = clamp((-65.0 + SpecularTex.z * 255.0) / 190.0 ,0.0,1.0);
|
||||
|
||||
vec4 normalAndAO = texture2D(colortex15,texcoord);
|
||||
vec3 FlatNormals = normalAndAO.rgb * 2.0 - 1.0;
|
||||
vec3 slopednormal = normal;
|
||||
|
||||
#ifdef POM
|
||||
#ifdef Horrible_slope_normals
|
||||
vec3 ApproximatedFlatNormal = normalize(cross(dFdx(p3), dFdy(p3))); // it uses depth that has POM written to it.
|
||||
slopednormal = normalize(clamp(normal, ApproximatedFlatNormal*2.0 - 1.0, ApproximatedFlatNormal*2.0 + 1.0) );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float vanilla_AO = clamp(normalAndAO.a,0,1);
|
||||
normalAndAO.a = clamp(pow(normalAndAO.a*5,4),0,1);
|
||||
|
||||
|
||||
////// --------------- MASKS/BOOLEANS --------------- //////
|
||||
|
||||
bool iswater = texture2D(colortex7,texcoord).a > 0.99;
|
||||
bool lightningBolt = abs(dataUnpacked1.w-0.5) <0.01;
|
||||
bool isLeaf = abs(dataUnpacked1.w-0.55) <0.01;
|
||||
bool entities = abs(dataUnpacked1.w-0.45) < 0.01;
|
||||
bool hand = abs(dataUnpacked1.w-0.75) < 0.01;
|
||||
// bool blocklights = abs(dataUnpacked1.w-0.8) <0.01;
|
||||
|
||||
|
||||
////// --------------- COLORS --------------- //////
|
||||
|
||||
float dirtAmount = Dirt_Amount;
|
||||
vec3 waterEpsilon = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B);
|
||||
vec3 dirtEpsilon = vec3(Dirt_Absorb_R, Dirt_Absorb_G, Dirt_Absorb_B);
|
||||
vec3 totEpsilon = dirtEpsilon*dirtAmount + waterEpsilon;
|
||||
vec3 scatterCoef = dirtAmount * vec3(Dirt_Scatter_R, Dirt_Scatter_G, Dirt_Scatter_B) / 3.14;
|
||||
|
||||
vec3 Indirect_lighting = vec3(1.0);
|
||||
vec3 Direct_lighting = vec3(0.0);
|
||||
|
||||
///////////////////////////// start drawin :D
|
||||
|
||||
if (z >= 1.0) {
|
||||
|
||||
gl_FragData[0].rgb = vec3(0.0);
|
||||
|
||||
} else {
|
||||
|
||||
p3 += gbufferModelViewInverse[3].xyz;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// MAJOR LIGHTSOURCE STUFF ////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef END_SHADER
|
||||
vec3 LightColor = LightSourceColor(clamp(sqrt(length(p3+cameraPosition) / 150.0 - 1.0) ,0.0,1.0));
|
||||
vec3 LightPos = LightSourcePosition(p3+cameraPosition, cameraPosition);
|
||||
|
||||
float LightFalloff = max(exp2(4.0 + length(LightPos) / -25),0.0);
|
||||
|
||||
float NdotL = clamp( dot(normal,normalize(-LightPos)),0.0,1.0);
|
||||
NdotL = clamp((-15 + NdotL*255.0) / 240.0 ,0.0,1.0);
|
||||
|
||||
float fogshadow = GetCloudShadow(p3+cameraPosition, LightPos, blueNoise());
|
||||
Direct_lighting = (LightColor * max(LightColor - (1-fogshadow) ,0.0)) * LightFalloff * NdotL;
|
||||
// vec3 LightSource = LightColor * fogshadow * LightFalloff * NdotL ;
|
||||
|
||||
|
||||
|
||||
float LightFalloff2 = max(1.0-length(LightPos)/120,0.0);
|
||||
LightFalloff2 = pow(1.0-pow(1.0-LightFalloff2,0.5),2.0);
|
||||
LightFalloff2 *= 25;
|
||||
|
||||
Direct_lighting += (LightColor * max(LightColor - 0.6,0.0)) * vec3(1.0,1.3,1.0) * LightFalloff2 * (NdotL*0.7+0.3);
|
||||
|
||||
// float RT_Shadows = rayTraceShadow(worldToView(normalize(-LightPos)), fragpos_RTSHADOW, blueNoise());
|
||||
// if(!hand) LightSource *= RT_Shadows*RT_Shadows;
|
||||
#endif
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// INDIRECT LIGHTING /////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef END_SHADER
|
||||
Indirect_lighting = DoAmbientLighting_End(gl_Fog.color.rgb, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3);
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_SHADER
|
||||
vec3 AmbientLightColor = skyCloudsFromTexLOD2(normal, colortex4, 6).rgb / 10;
|
||||
|
||||
vec3 up = skyCloudsFromTexLOD2(vec3( 0, 1, 0), colortex4, 6).rgb / 10;
|
||||
vec3 down = skyCloudsFromTexLOD2(vec3( 0,-1, 0), colortex4, 6).rgb / 10;
|
||||
|
||||
up *= pow( max( slopednormal.y, 0), 2);
|
||||
down *= pow( max(-slopednormal.y, 0), 2);
|
||||
AmbientLightColor += up + down;
|
||||
|
||||
// do all ambient lighting stuff
|
||||
Indirect_lighting = DoAmbientLighting_Nether(AmbientLightColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3, p3 );
|
||||
#endif
|
||||
/////////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// EFFECTS FOR INDIRECT /////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if indirect_effect == 0
|
||||
vec3 AO = vec3( exp( (vanilla_AO*vanilla_AO) * -5) ) ;
|
||||
if(!hand) Indirect_lighting *= AO;
|
||||
#endif
|
||||
|
||||
#if indirect_effect == 1
|
||||
vec3 AO = vec3( exp( (vanilla_AO*vanilla_AO) * -5) ) ;
|
||||
if(!hand) Indirect_lighting *= ssao(fragpos,noise,FlatNormals) * AO;
|
||||
#endif
|
||||
|
||||
// RTAO and/or SSGI
|
||||
#if indirect_effect == 3 || indirect_effect == 4
|
||||
if (!hand) ApplySSRT(Indirect_lighting, normal, blueNoise(gl_FragCoord.xy).rg, fragpos, lightmap.x,vec3(TORCH_R,TORCH_G,TORCH_B));
|
||||
#endif
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// FINALIZE /////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
gl_FragData[0].rgb = (Indirect_lighting + Direct_lighting) * albedo;
|
||||
|
||||
#ifdef Specular_Reflections
|
||||
vec3 specNoise = vec3(blueNoise(gl_FragCoord.xy).rg, interleaved_gradientNoise());
|
||||
DoSpecularReflections(gl_FragData[0].rgb, fragpos, np3, vec3(0.0), specNoise, normal, SpecularTex.r, SpecularTex.g, albedo, vec3(0.0), 1.0, hand);
|
||||
#endif
|
||||
|
||||
Emission(gl_FragData[0].rgb, albedo, SpecularTex.a);
|
||||
|
||||
if(lightningBolt) gl_FragData[0].rgb = vec3(1);
|
||||
|
||||
}
|
||||
|
||||
if (iswater && isEyeInWater == 0){
|
||||
vec3 fragpos0 = toScreenSpace(vec3(texcoord/RENDER_SCALE-TAA_Offset*texelSize*0.5,z0));
|
||||
float Vdiff = distance(fragpos,fragpos0);
|
||||
float VdotU = np3.y;
|
||||
float estimatedDepth = Vdiff * abs(VdotU) ; //assuming water plane
|
||||
|
||||
vec3 ambientColVol = max(vec3(1.0,0.5,1.0) * 0.3, vec3(0.2,0.4,1.0) * (MIN_LIGHT_AMOUNT*0.01 + nightVision));
|
||||
|
||||
waterVolumetrics(gl_FragData[0].rgb, fragpos0, fragpos, estimatedDepth , estimatedDepth, Vdiff, noise, totEpsilon, scatterCoef, ambientColVol);
|
||||
}
|
||||
|
||||
/* DRAWBUFFERS:3 */
|
||||
}
|
||||
49
shaders/dimensions/composite.vsh
Normal file
49
shaders/dimensions/composite.vsh
Normal file
@ -0,0 +1,49 @@
|
||||
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
varying vec2 texcoord;
|
||||
|
||||
flat varying vec3 avgAmbient;
|
||||
|
||||
flat varying float tempOffsets;
|
||||
flat varying vec2 TAA_Offset;
|
||||
flat varying vec3 zMults;
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
|
||||
uniform float far;
|
||||
uniform float near;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform vec3 sunPosition;
|
||||
uniform float rainStrength;
|
||||
uniform float sunElevation;
|
||||
uniform int frameCounter;
|
||||
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
|
||||
#include "/lib/util.glsl"
|
||||
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
texcoord = gl_MultiTexCoord0.xy;
|
||||
|
||||
tempOffsets = HaltonSeq2(frameCounter%10000);
|
||||
|
||||
TAA_Offset = offsets[frameCounter%8];
|
||||
|
||||
#ifndef TAA
|
||||
TAA_Offset = vec2(0.0);
|
||||
#endif
|
||||
|
||||
|
||||
avgAmbient = texelFetch2D(colortex4,ivec2(0,37),0).rgb;
|
||||
zMults = vec3((far * near)*2.0,far+near,far-near);
|
||||
}
|
||||
129
shaders/dimensions/composite1.fsh
Normal file
129
shaders/dimensions/composite1.fsh
Normal file
@ -0,0 +1,129 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
|
||||
uniform sampler2D noisetex;
|
||||
uniform sampler2D depthtex0;
|
||||
|
||||
uniform sampler2D colortex2;
|
||||
uniform sampler2D colortex3;
|
||||
// uniform sampler2D colortex4;
|
||||
|
||||
uniform vec3 sunVec;
|
||||
uniform float sunElevation;
|
||||
uniform float far;
|
||||
|
||||
uniform int frameCounter;
|
||||
uniform float frameTimeCounter;
|
||||
|
||||
varying vec2 texcoord;
|
||||
uniform vec2 texelSize;
|
||||
flat varying vec2 TAA_Offset;
|
||||
|
||||
uniform int isEyeInWater;
|
||||
uniform float rainStrength;
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
|
||||
#include "/lib/color_transforms.glsl"
|
||||
#include "/lib/color_dither.glsl"
|
||||
#include "/lib/projections.glsl"
|
||||
|
||||
#ifdef END_SHADER
|
||||
#include "/lib/end_fog.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_SHADER
|
||||
#include "/lib/nether_fog.glsl"
|
||||
#endif
|
||||
|
||||
#define fsign(a) (clamp((a)*1e35,0.,1.)*2.-1.)
|
||||
|
||||
float interleaved_gradientNoise(){
|
||||
return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y)+TAA_Offset.x);
|
||||
}
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
|
||||
void waterVolumetrics(inout vec3 inColor, vec3 rayStart, vec3 rayEnd, float estEndDepth, float estSunDepth, float rayLength, float dither, vec3 waterCoefs, vec3 scatterCoef, vec3 ambient){
|
||||
inColor *= exp(-rayLength * waterCoefs); //No need to take the integrated value
|
||||
|
||||
int spCount = rayMarchSampleCount;
|
||||
vec3 start = toShadowSpaceProjected(rayStart);
|
||||
vec3 end = toShadowSpaceProjected(rayEnd);
|
||||
vec3 dV = (end-start);
|
||||
//limit ray length at 32 blocks for performance and reducing integration error
|
||||
//you can't see above this anyway
|
||||
float maxZ = min(rayLength,12.0)/(1e-8+rayLength);
|
||||
dV *= maxZ;
|
||||
|
||||
|
||||
rayLength *= maxZ;
|
||||
|
||||
float dY = normalize(mat3(gbufferModelViewInverse) * rayEnd).y * rayLength;
|
||||
estEndDepth *= maxZ;
|
||||
estSunDepth *= maxZ;
|
||||
|
||||
vec3 wpos = mat3(gbufferModelViewInverse) * rayStart + gbufferModelViewInverse[3].xyz;
|
||||
vec3 dVWorld = (wpos-gbufferModelViewInverse[3].xyz);
|
||||
|
||||
vec3 absorbance = vec3(1.0);
|
||||
vec3 vL = vec3(0.0);
|
||||
|
||||
float expFactor = 11.0;
|
||||
for (int i=0;i<spCount;i++) {
|
||||
float d = (pow(expFactor, float(i+dither)/float(spCount))/expFactor - 1.0/expFactor)/(1-1.0/expFactor);
|
||||
float dd = pow(expFactor, float(i+dither)/float(spCount)) * log(expFactor) / float(spCount)/(expFactor-1.0);
|
||||
vec3 spPos = start.xyz + dV*d;
|
||||
|
||||
vec3 progressW = start.xyz+cameraPosition+dVWorld;
|
||||
|
||||
vec3 ambientMul = exp(-max(estEndDepth * d,0.0) * waterCoefs );
|
||||
vec3 Indirectlight = ambientMul*ambient;
|
||||
|
||||
vec3 light = Indirectlight * scatterCoef;
|
||||
|
||||
vL += (light - light * exp(-waterCoefs * dd * rayLength)) / waterCoefs * absorbance;
|
||||
absorbance *= exp(-dd * rayLength * waterCoefs);
|
||||
}
|
||||
inColor += vL;
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:0 */
|
||||
|
||||
vec2 tc = floor(gl_FragCoord.xy)*2.0*texelSize+0.5*texelSize;
|
||||
float z = texture2D(depthtex0,tc).x;
|
||||
vec3 fragpos = toScreenSpace(vec3(tc,z));
|
||||
|
||||
if (isEyeInWater == 0){
|
||||
|
||||
vec4 VolumetricFog = GetVolumetricFog(fragpos, blueNoise(), interleaved_gradientNoise());
|
||||
|
||||
gl_FragData[0] = clamp(VolumetricFog, 0.000001, 65000.0);
|
||||
}
|
||||
|
||||
if (isEyeInWater == 1){
|
||||
|
||||
float dirtAmount = Dirt_Amount;
|
||||
vec3 waterEpsilon = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B);
|
||||
vec3 dirtEpsilon = vec3(Dirt_Absorb_R, Dirt_Absorb_G, Dirt_Absorb_B);
|
||||
vec3 totEpsilon = dirtEpsilon*dirtAmount + waterEpsilon;
|
||||
vec3 scatterCoef = dirtAmount * vec3(Dirt_Scatter_R, Dirt_Scatter_G, Dirt_Scatter_B) / 3.14;
|
||||
|
||||
vec3 fragpos0 = toScreenSpace(vec3(texcoord - TAA_Offset*texelSize*0.5,z));
|
||||
|
||||
vec3 ambientColVol = max(vec3(1.0,0.5,1.0) * 0.6, vec3(0.2,0.4,1.0) * MIN_LIGHT_AMOUNT*0.01);
|
||||
|
||||
gl_FragData[0].a = 1;
|
||||
waterVolumetrics(gl_FragData[0].rgb, fragpos0, fragpos, 1 , 1, 1, blueNoise(), totEpsilon, scatterCoef, ambientColVol);
|
||||
|
||||
}
|
||||
}
|
||||
20
shaders/dimensions/composite1.vsh
Normal file
20
shaders/dimensions/composite1.vsh
Normal file
@ -0,0 +1,20 @@
|
||||
#include "/lib/util.glsl"
|
||||
|
||||
flat varying float tempOffsets;
|
||||
|
||||
uniform int frameCounter;
|
||||
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
tempOffsets = HaltonSeq2(frameCounter%10000);
|
||||
|
||||
gl_Position.xy = (gl_Position.xy*0.5+0.5)*0.51*2.0-1.0;
|
||||
}
|
||||
305
shaders/dimensions/composite2.fsh
Normal file
305
shaders/dimensions/composite2.fsh
Normal file
@ -0,0 +1,305 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
flat varying vec3 zMults;
|
||||
flat varying vec2 TAA_Offset;
|
||||
|
||||
|
||||
uniform sampler2D noisetex;
|
||||
uniform sampler2D depthtex0;
|
||||
uniform sampler2D depthtex1;
|
||||
uniform sampler2D colortex0;
|
||||
uniform sampler2D colortex1;
|
||||
uniform sampler2D colortex2;
|
||||
uniform sampler2D colortex3;
|
||||
// uniform sampler2D colortex4;
|
||||
uniform sampler2D colortex5;
|
||||
uniform sampler2D colortex6;
|
||||
uniform sampler2D colortex7;
|
||||
uniform sampler2D colortex8;
|
||||
uniform sampler2D colortex9;
|
||||
uniform sampler2D colortex11;
|
||||
uniform sampler2D colortex13;
|
||||
uniform sampler2D colortex15;
|
||||
uniform vec2 texelSize;
|
||||
|
||||
flat varying vec3 noooormal;
|
||||
flat varying vec4 lightCol; //main light source color (rgb),used light source(1=sun,-1=moon)
|
||||
flat varying vec3 WsunVec;
|
||||
|
||||
uniform vec3 sunVec;
|
||||
uniform float frameTimeCounter;
|
||||
uniform int frameCounter;
|
||||
uniform float far;
|
||||
uniform float near;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 gbufferPreviousModelView;
|
||||
uniform mat4 gbufferProjectionInverse;
|
||||
uniform mat4 gbufferProjection;
|
||||
uniform mat4 gbufferPreviousProjection;
|
||||
uniform vec3 cameraPosition;
|
||||
uniform vec3 previousCameraPosition;
|
||||
|
||||
uniform int isEyeInWater;
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
uniform float rainStrength;
|
||||
uniform float blindness;
|
||||
uniform float darknessFactor;
|
||||
uniform float darknessLightFactor;
|
||||
|
||||
|
||||
#include "/lib/waterBump.glsl"
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
#include "/lib/sky_gradient.glsl"
|
||||
#include "/lib/volumetricClouds.glsl"
|
||||
// #include "/lib/biome_specifics.glsl"
|
||||
|
||||
|
||||
|
||||
|
||||
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
|
||||
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
|
||||
|
||||
float ld(float depth) {
|
||||
return 1.0 / (zMults.y - depth * zMults.z); // (-depth * (far - near)) = (2.0 * near)/ld - far - near
|
||||
}
|
||||
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);
|
||||
}
|
||||
vec3 toScreenSpace(vec3 p) {
|
||||
vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
|
||||
vec3 p3 = p * 2. - 1.;
|
||||
vec4 fragposition = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
|
||||
return fragposition.xyz / fragposition.w;
|
||||
}
|
||||
|
||||
|
||||
// #include "/lib/specular.glsl"
|
||||
|
||||
|
||||
|
||||
|
||||
vec4 BilateralUpscale(sampler2D tex, sampler2D depth,vec2 coord,float frDepth, vec2 distort){
|
||||
coord = coord;
|
||||
vec4 vl = vec4(0.0);
|
||||
float sum = 0.0;
|
||||
mat3x3 weights;
|
||||
const ivec2 scaling = ivec2(1.0/VL_RENDER_RESOLUTION);
|
||||
ivec2 posD = ivec2(coord*VL_RENDER_RESOLUTION + distort)*scaling;
|
||||
ivec2 posVl = ivec2(coord*VL_RENDER_RESOLUTION + distort);
|
||||
float dz = zMults.x;
|
||||
ivec2 pos = (ivec2(gl_FragCoord.xy+frameCounter) % 2 )*2;
|
||||
|
||||
ivec2 tcDepth = posD + ivec2(-2,-2) * scaling + pos * scaling;
|
||||
float dsample = ld(texelFetch2D(depth,tcDepth,0).r);
|
||||
float w = abs(dsample-frDepth) < dz ? 1.0 : 1e-5;
|
||||
vl += texelFetch2D(tex,posVl+ivec2(-2)+pos,0)*w;
|
||||
sum += w;
|
||||
|
||||
tcDepth = posD + ivec2(-2,0) * scaling + pos * scaling;
|
||||
dsample = ld(texelFetch2D(depth,tcDepth,0).r);
|
||||
w = abs(dsample-frDepth) < dz ? 1.0 : 1e-5;
|
||||
vl += texelFetch2D(tex,posVl+ivec2(-2,0)+pos,0)*w;
|
||||
sum += w;
|
||||
|
||||
tcDepth = posD + ivec2(0) + pos * scaling;
|
||||
dsample = ld(texelFetch2D(depth,tcDepth,0).r);
|
||||
w = abs(dsample-frDepth) < dz ? 1.0 : 1e-5;
|
||||
vl += texelFetch2D(tex,posVl+ivec2(0)+pos,0)*w;
|
||||
sum += w;
|
||||
|
||||
tcDepth = posD + ivec2(0,-2) * scaling + pos * scaling;
|
||||
dsample = ld(texelFetch2D(depth,tcDepth,0).r);
|
||||
w = abs(dsample-frDepth) < dz ? 1.0 : 1e-5;
|
||||
vl += texelFetch2D(tex,posVl+ivec2(0,-2)+pos,0)*w;
|
||||
sum += w;
|
||||
|
||||
return vl/sum;
|
||||
}
|
||||
|
||||
vec3 decode (vec2 encn){
|
||||
vec3 n = vec3(0.0);
|
||||
encn = encn * 2.0 - 1.0;
|
||||
n.xy = abs(encn);
|
||||
n.z = 1.0 - n.x - n.y;
|
||||
n.xy = n.z <= 0.0 ? (1.0 - n.yx) * sign(encn) : encn;
|
||||
return clamp(normalize(n.xyz),-1.0,1.0);
|
||||
}
|
||||
vec2 decodeVec2(float a){
|
||||
const vec2 constant1 = 65535. / vec2( 256., 65536.);
|
||||
const float constant2 = 256. / 255.;
|
||||
return fract( a * constant1 ) * constant2 ;
|
||||
}
|
||||
|
||||
vec3 worldToView(vec3 worldPos) {
|
||||
vec4 pos = vec4(worldPos, 0.0);
|
||||
pos = gbufferModelView * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
vec4 blueNoise(vec2 coord){
|
||||
return texelFetch2D(colortex6, ivec2(coord )%512 , 0);
|
||||
}
|
||||
vec3 normVec (vec3 vec){
|
||||
return vec*inversesqrt(dot(vec,vec));
|
||||
}
|
||||
|
||||
float interleaved_gradientNoise(){
|
||||
vec2 coord = gl_FragCoord.xy;
|
||||
float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y));
|
||||
return noise;
|
||||
}
|
||||
vec3 viewToWorld(vec3 viewPosition) {
|
||||
vec4 pos;
|
||||
pos.xyz = viewPosition;
|
||||
pos.w = 0.0;
|
||||
pos = gbufferModelViewInverse * pos;
|
||||
return pos.xyz;
|
||||
}
|
||||
|
||||
/// thanks stackoverflow https://stackoverflow.com/questions/944713/help-with-pixel-shader-effect-for-brightness-and-contrast#3027595
|
||||
void applyContrast(inout vec3 color, float contrast){
|
||||
color = ((color - 0.5) * max(contrast, 0.0)) + 0.5;
|
||||
}
|
||||
void main() {
|
||||
/* DRAWBUFFERS:73 */
|
||||
|
||||
vec2 texcoord = gl_FragCoord.xy*texelSize;
|
||||
|
||||
vec4 trpData = texture2D(colortex7,texcoord);
|
||||
|
||||
bool iswater = trpData.a > 0.99;
|
||||
float translucentAlpha = trpData.a;
|
||||
|
||||
// vec4 speculartex = texture2D(colortex8,texcoord); // translucents
|
||||
// float sunlight = speculartex.b;
|
||||
|
||||
//3x3 bilateral upscale from half resolution
|
||||
float z = texture2D(depthtex0,texcoord).x;
|
||||
float z2 = texture2D(depthtex1,texcoord).x;
|
||||
float frDepth = ld(z2);
|
||||
|
||||
// vec4 vl = texture2D(colortex0,texcoord * 0.5);
|
||||
|
||||
////// --------------- UNPACK OPAQUE GBUFFERS --------------- //////
|
||||
vec4 data_opaque = texture2D(colortex1,texcoord);
|
||||
vec4 dataUnpacked1 = vec4(decodeVec2(data_opaque.z),decodeVec2(data_opaque.w)); // normals, lightmaps
|
||||
// vec4 dataUnpacked2 = vec4(decodeVec2(data.z),decodeVec2(data.w));
|
||||
|
||||
bool hand = abs(dataUnpacked1.w-0.75) < 0.01;
|
||||
vec2 lightmap = dataUnpacked1.yz;
|
||||
|
||||
////// --------------- UNPACK TRANSLUCENT GBUFFERS --------------- //////
|
||||
|
||||
vec3 data = texture2D(colortex11,texcoord).rgb;
|
||||
|
||||
vec4 unpack0 = vec4(decodeVec2(data.r),decodeVec2(data.g)) ;
|
||||
vec4 unpack1 = vec4(decodeVec2(data.b),0,0) ;
|
||||
|
||||
|
||||
|
||||
vec4 albedo = vec4(unpack0.ba,unpack1.rg);
|
||||
|
||||
vec2 tangentNormals = unpack0.xy*2.0-1.0;
|
||||
|
||||
if(albedo.a <= 0.0) tangentNormals = vec2(0.0);
|
||||
|
||||
vec4 TranslucentShader = texture2D(colortex2,texcoord);
|
||||
|
||||
float lightleakfix = clamp(pow(eyeBrightnessSmooth.y/240.,2) ,0.0,1.0);
|
||||
|
||||
|
||||
vec2 tempOffset = TAA_Offset;
|
||||
vec3 fragpos = toScreenSpace(vec3(texcoord/RENDER_SCALE-vec2(tempOffset)*texelSize*0.5,z));
|
||||
vec3 fragpos2 = toScreenSpace(vec3(texcoord/RENDER_SCALE-vec2(tempOffset)*texelSize*0.5,z2));
|
||||
|
||||
|
||||
vec3 p3 = mat3(gbufferModelViewInverse) * fragpos;
|
||||
vec3 np3 = normVec(p3);
|
||||
|
||||
|
||||
vec2 refractedCoord = texcoord;
|
||||
|
||||
/// --- REFRACTION --- ///
|
||||
#ifdef Refraction
|
||||
refractedCoord += (tangentNormals * clamp((ld(z2) - ld(z)) * 0.5,0.0,0.15)) * RENDER_SCALE;
|
||||
// refractedCoord += tangentNormals * 0.1 * RENDER_SCALE;
|
||||
|
||||
float refractedalpha = decodeVec2(texture2D(colortex11,refractedCoord).b).g;
|
||||
float refractedalpha2 = texture2D(colortex7,refractedCoord).a;
|
||||
if( refractedalpha <= 0.001 ||z < 0.56) refractedCoord = texcoord; // remove refracted coords on solids
|
||||
#endif
|
||||
|
||||
/// --- MAIN COLOR BUFFER --- ///
|
||||
// it is sampled with distorted texcoords
|
||||
vec3 color = texture2D(colortex3,refractedCoord).rgb;
|
||||
|
||||
vec4 vl = BilateralUpscale(colortex0, depthtex1, gl_FragCoord.xy, frDepth, vec2(0.0));
|
||||
float bloomyFogMult = 1.0;
|
||||
|
||||
if (TranslucentShader.a > 0.0){
|
||||
#ifdef Glass_Tint
|
||||
if(albedo.a > 0.2) color = color*albedo.rgb + color * clamp(pow(1.0-luma(albedo.rgb),20.),0.0,1.0);
|
||||
#endif
|
||||
|
||||
color = color*(1.0-TranslucentShader.a) + TranslucentShader.rgb;
|
||||
}
|
||||
|
||||
// underwater fog
|
||||
if (isEyeInWater == 1){
|
||||
float dirtAmount = Dirt_Amount;
|
||||
vec3 waterEpsilon = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B);
|
||||
vec3 dirtEpsilon = vec3(Dirt_Absorb_R, Dirt_Absorb_G, Dirt_Absorb_B);
|
||||
vec3 totEpsilon = dirtEpsilon*dirtAmount + waterEpsilon;
|
||||
|
||||
// float fogfade = clamp( exp(length(fragpos) / -20) ,0.0,1.0);
|
||||
// vec3 fogfade = clamp( exp( (length(fragpos) / -4) * totEpsilon ) ,0.0,1.0);
|
||||
vec3 fogfade = clamp( exp( (-length(fragpos)) * totEpsilon ) ,0.0,1.0);
|
||||
fogfade *= 1.0 - clamp( length(fragpos) / far,0.0,1.0);
|
||||
|
||||
color.rgb *= fogfade ;
|
||||
bloomyFogMult *= 0.4;
|
||||
}
|
||||
|
||||
// apply VL fog to the scene
|
||||
color *= vl.a;
|
||||
color += vl.rgb;
|
||||
|
||||
// bloomy rain effect
|
||||
float rainDrops = clamp(texture2D(colortex9,texcoord).a, 0.0,1.0);
|
||||
if(rainDrops > 0.0) bloomyFogMult *= clamp(1.0 - pow(rainDrops*5.0,2),0.0,1.0);
|
||||
|
||||
/// lava.
|
||||
if (isEyeInWater == 2){
|
||||
color.rgb = vec3(4.0,0.5,0.1);
|
||||
}
|
||||
|
||||
/// powdered snow
|
||||
if (isEyeInWater == 3){
|
||||
color.rgb = mix(color.rgb,vec3(10,15,20),clamp(length(fragpos)*0.5,0.,1.));
|
||||
bloomyFogMult = 0.0;
|
||||
}
|
||||
|
||||
// blidnesss
|
||||
color.rgb *= mix(1.0,clamp( exp(pow(length(fragpos)*(blindness*0.2),2) * -1),0.,1.) , blindness);
|
||||
|
||||
// darkness effect
|
||||
color.rgb *= mix(1.0, (1.0-darknessLightFactor*2.0) * clamp(1.0-pow(length(fragpos2)*(darknessFactor*0.07),2.0),0.0,1.0), darknessFactor);
|
||||
|
||||
#ifdef display_LUT
|
||||
vec2 movedTC = texcoord;
|
||||
vec3 thingy = texture2D(colortex4,movedTC).rgb / 150. * 5.0;
|
||||
if(luma(thingy) > 0.0 ) color.rgb = thingy;
|
||||
#endif
|
||||
|
||||
gl_FragData[0].r = vl.a * bloomyFogMult; // pass fog alpha so bloom can do bloomy fog
|
||||
|
||||
gl_FragData[1].rgb = clamp(color.rgb,0.0,68000.0);
|
||||
|
||||
}
|
||||
17
shaders/dimensions/composite2.vsh
Normal file
17
shaders/dimensions/composite2.vsh
Normal file
@ -0,0 +1,17 @@
|
||||
|
||||
varying vec2 texcoord;
|
||||
flat varying vec3 zMults;
|
||||
uniform float far;
|
||||
uniform float near;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
zMults = vec3(1.0/(far * near),far+near,far-near);
|
||||
gl_Position = ftransform();
|
||||
texcoord = gl_MultiTexCoord0.xy;
|
||||
|
||||
}
|
||||
350
shaders/dimensions/composite3.fsh
Normal file
350
shaders/dimensions/composite3.fsh
Normal file
@ -0,0 +1,350 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
const int noiseTextureResolution = 32;
|
||||
|
||||
|
||||
/*
|
||||
const int colortex0Format = RGBA16F; // low res clouds (deferred->composite2) + low res VL (composite5->composite15)
|
||||
const int colortex1Format = RGBA16; //terrain gbuffer (gbuffer->composite2)
|
||||
const int colortex2Format = RGBA16F; //forward + transparencies (gbuffer->composite4)
|
||||
const int colortex3Format = R11F_G11F_B10F; //frame buffer + bloom (deferred6->final)
|
||||
const int colortex4Format = RGBA16F; //light values and skyboxes (everything)
|
||||
const int colortex5Format = R11F_G11F_B10F; //TAA buffer (everything)
|
||||
const int colortex6Format = R11F_G11F_B10F; //additionnal buffer for bloom (composite3->final)
|
||||
const int colortex7Format = RGBA8; //Final output, transparencies id (gbuffer->composite4)
|
||||
*/
|
||||
//no need to clear the buffers, saves a few fps
|
||||
const bool colortex0Clear = false;
|
||||
const bool colortex1Clear = false;
|
||||
const bool colortex2Clear = true;
|
||||
const bool colortex3Clear = false;
|
||||
const bool colortex4Clear = false;
|
||||
const bool colortex5Clear = false;
|
||||
const bool colortex6Clear = false;
|
||||
const bool colortex7Clear = false;
|
||||
|
||||
varying vec2 texcoord;
|
||||
flat varying float exposureA;
|
||||
flat varying float tempOffsets;
|
||||
uniform sampler2D colortex3;
|
||||
uniform sampler2D colortex5;
|
||||
uniform sampler2D colortex10;
|
||||
uniform sampler2D depthtex0;
|
||||
|
||||
uniform vec2 texelSize;
|
||||
uniform float frameTimeCounter;
|
||||
uniform int framemod8;
|
||||
uniform float viewHeight;
|
||||
uniform float viewWidth;
|
||||
uniform vec3 previousCameraPosition;
|
||||
uniform mat4 gbufferPreviousModelView;
|
||||
|
||||
|
||||
|
||||
|
||||
#define fsign(a) (clamp((a)*1e35,0.,1.)*2.-1.)
|
||||
|
||||
#include "/lib/projections.glsl"
|
||||
|
||||
|
||||
float luma(vec3 color) {
|
||||
return dot(color,vec3(0.21, 0.72, 0.07));
|
||||
}
|
||||
float interleaved_gradientNoise(){
|
||||
return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y)+tempOffsets);
|
||||
}
|
||||
float triangularize(float dither)
|
||||
{
|
||||
float center = dither*2.0-1.0;
|
||||
dither = center*inversesqrt(abs(center));
|
||||
return clamp(dither-fsign(center),0.0,1.0);
|
||||
}
|
||||
vec3 fp10Dither(vec3 color,float dither){
|
||||
const vec3 mantissaBits = vec3(6.,6.,5.);
|
||||
vec3 exponent = floor(log2(color));
|
||||
return color + dither*exp2(-mantissaBits)*exp2(exponent);
|
||||
}
|
||||
|
||||
|
||||
//returns the projected coordinates of the closest point to the camera in the 3x3 neighborhood
|
||||
vec3 closestToCamera3x3()
|
||||
{
|
||||
vec2 du = vec2(texelSize.x, 0.0);
|
||||
vec2 dv = vec2(0.0, texelSize.y);
|
||||
|
||||
vec3 dtl = vec3(texcoord,0.) + vec3(-texelSize, texture2D(depthtex0, texcoord - dv - du).x);
|
||||
vec3 dtc = vec3(texcoord,0.) + vec3( 0.0, -texelSize.y, texture2D(depthtex0, texcoord - dv).x);
|
||||
vec3 dtr = vec3(texcoord,0.) + vec3( texelSize.x, -texelSize.y, texture2D(depthtex0, texcoord - dv + du).x);
|
||||
|
||||
vec3 dml = vec3(texcoord,0.) + vec3(-texelSize.x, 0.0, texture2D(depthtex0, texcoord - du).x);
|
||||
vec3 dmc = vec3(texcoord,0.) + vec3( 0.0, 0.0, texture2D(depthtex0, texcoord).x);
|
||||
vec3 dmr = vec3(texcoord,0.) + vec3( texelSize.x, 0.0, texture2D(depthtex0, texcoord + du).x);
|
||||
|
||||
vec3 dbl = vec3(texcoord,0.) + vec3(-texelSize.x, texelSize.y, texture2D(depthtex0, texcoord + dv - du).x);
|
||||
vec3 dbc = vec3(texcoord,0.) + vec3( 0.0, texelSize.y, texture2D(depthtex0, texcoord + dv).x);
|
||||
vec3 dbr = vec3(texcoord,0.) + vec3( texelSize.x, texelSize.y, texture2D(depthtex0, texcoord + dv + du).x);
|
||||
|
||||
vec3 dmin = dmc;
|
||||
|
||||
dmin = dmin.z > dtc.z? dtc : dmin;
|
||||
dmin = dmin.z > dtr.z? dtr : dmin;
|
||||
|
||||
dmin = dmin.z > dml.z? dml : dmin;
|
||||
dmin = dmin.z > dtl.z? dtl : dmin;
|
||||
dmin = dmin.z > dmr.z? dmr : dmin;
|
||||
|
||||
dmin = dmin.z > dbl.z? dbl : dmin;
|
||||
dmin = dmin.z > dbc.z? dbc : dmin;
|
||||
dmin = dmin.z > dbr.z? dbr : dmin;
|
||||
|
||||
return dmin;
|
||||
}
|
||||
|
||||
//Modified texture interpolation from inigo quilez
|
||||
vec4 smoothfilter(in sampler2D tex, in vec2 uv)
|
||||
{
|
||||
vec2 textureResolution = vec2(viewWidth,viewHeight);
|
||||
uv = uv*textureResolution + 0.5;
|
||||
vec2 iuv = floor( uv );
|
||||
vec2 fuv = fract( uv );
|
||||
#ifndef SMOOTHESTSTEP_INTERPOLATION
|
||||
uv = iuv + (fuv*fuv)*(3.0-2.0*fuv);
|
||||
#endif
|
||||
#ifdef SMOOTHESTSTEP_INTERPOLATION
|
||||
uv = iuv + fuv*fuv*fuv*(fuv*(fuv*6.0-15.0)+10.0);
|
||||
#endif
|
||||
uv = (uv - 0.5)/textureResolution;
|
||||
return texture2D( tex, uv);
|
||||
}
|
||||
//Due to low sample count we "tonemap" the inputs to preserve colors and smoother edges
|
||||
vec3 weightedSample(sampler2D colorTex, vec2 texcoord){
|
||||
vec3 wsample = texture2D(colorTex,texcoord).rgb*exposureA;
|
||||
return wsample/(1.0+luma(wsample));
|
||||
|
||||
}
|
||||
|
||||
|
||||
//from : https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
|
||||
vec4 SampleTextureCatmullRom(sampler2D tex, vec2 uv, vec2 texSize )
|
||||
{
|
||||
// We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
|
||||
// down the sample location to get the exact center of our "starting" texel. The starting texel will be at
|
||||
// location [1, 1] in the grid, where [0, 0] is the top left corner.
|
||||
vec2 samplePos = uv * texSize;
|
||||
vec2 texPos1 = floor(samplePos - 0.5) + 0.5;
|
||||
|
||||
// Compute the fractional offset from our starting texel to our original sample location, which we'll
|
||||
// feed into the Catmull-Rom spline function to get our filter weights.
|
||||
vec2 f = samplePos - texPos1;
|
||||
|
||||
// Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
|
||||
// These equations are pre-expanded based on our knowledge of where the texels will be located,
|
||||
// which lets us avoid having to evaluate a piece-wise function.
|
||||
vec2 w0 = f * ( -0.5 + f * (1.0 - 0.5*f));
|
||||
vec2 w1 = 1.0 + f * f * (-2.5 + 1.5*f);
|
||||
vec2 w2 = f * ( 0.5 + f * (2.0 - 1.5*f) );
|
||||
vec2 w3 = f * f * (-0.5 + 0.5 * f);
|
||||
|
||||
// Work out weighting factors and sampling offsets that will let us use bilinear filtering to
|
||||
// simultaneously evaluate the middle 2 samples from the 4x4 grid.
|
||||
vec2 w12 = w1 + w2;
|
||||
vec2 offset12 = w2 / (w1 + w2);
|
||||
|
||||
// Compute the final UV coordinates we'll use for sampling the texture
|
||||
vec2 texPos0 = texPos1 - vec2(1.0);
|
||||
vec2 texPos3 = texPos1 + vec2(2.0);
|
||||
vec2 texPos12 = texPos1 + offset12;
|
||||
|
||||
texPos0 *= texelSize;
|
||||
texPos3 *= texelSize;
|
||||
texPos12 *= texelSize;
|
||||
|
||||
vec4 result = vec4(0.0);
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos0.y)) * w0.x * w0.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos0.y)) * w12.x * w0.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos0.y)) * w3.x * w0.y;
|
||||
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos12.y)) * w0.x * w12.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos12.y)) * w12.x * w12.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos12.y)) * w3.x * w12.y;
|
||||
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos3.y)) * w0.x * w3.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos3.y)) * w12.x * w3.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos3.y)) * w3.x * w3.y;
|
||||
|
||||
return result;
|
||||
}
|
||||
//approximation from SMAA presentation from siggraph 2016
|
||||
vec3 FastCatmulRom(sampler2D colorTex, vec2 texcoord, vec4 rtMetrics, float sharpenAmount)
|
||||
{
|
||||
vec2 position = rtMetrics.zw * texcoord;
|
||||
vec2 centerPosition = floor(position - 0.5) + 0.5;
|
||||
vec2 f = position - centerPosition;
|
||||
vec2 f2 = f * f;
|
||||
vec2 f3 = f * f2;
|
||||
|
||||
float c = sharpenAmount;
|
||||
vec2 w0 = -c * f3 + 2.0 * c * f2 - c * f;
|
||||
vec2 w1 = (2.0 - c) * f3 - (3.0 - c) * f2 + 1.0;
|
||||
vec2 w2 = -(2.0 - c) * f3 + (3.0 - 2.0 * c) * f2 + c * f;
|
||||
vec2 w3 = c * f3 - c * f2;
|
||||
|
||||
vec2 w12 = w1 + w2;
|
||||
vec2 tc12 = rtMetrics.xy * (centerPosition + w2 / w12);
|
||||
vec3 centerColor = texture2D(colorTex, vec2(tc12.x, tc12.y)).rgb;
|
||||
|
||||
vec2 tc0 = rtMetrics.xy * (centerPosition - 1.0);
|
||||
vec2 tc3 = rtMetrics.xy * (centerPosition + 2.0);
|
||||
vec4 color = vec4(texture2D(colorTex, vec2(tc12.x, tc0.y )).rgb, 1.0) * (w12.x * w0.y ) +
|
||||
vec4(texture2D(colorTex, vec2(tc0.x, tc12.y)).rgb, 1.0) * (w0.x * w12.y) +
|
||||
vec4(centerColor, 1.0) * (w12.x * w12.y) +
|
||||
vec4(texture2D(colorTex, vec2(tc3.x, tc12.y)).rgb, 1.0) * (w3.x * w12.y) +
|
||||
vec4(texture2D(colorTex, vec2(tc12.x, tc3.y )).rgb, 1.0) * (w12.x * w3.y );
|
||||
return color.rgb/color.a;
|
||||
|
||||
}
|
||||
|
||||
vec3 clip_aabb(vec3 q,vec3 aabb_min, vec3 aabb_max)
|
||||
{
|
||||
vec3 p_clip = 0.5 * (aabb_max + aabb_min);
|
||||
vec3 e_clip = 0.5 * (aabb_max - aabb_min) + 0.00000001;
|
||||
|
||||
vec3 v_clip = q - vec3(p_clip);
|
||||
vec3 v_unit = v_clip.xyz / e_clip;
|
||||
vec3 a_unit = abs(v_unit);
|
||||
float ma_unit = max(a_unit.x, max(a_unit.y, a_unit.z));
|
||||
|
||||
if (ma_unit > 1.0)
|
||||
return vec3(p_clip) + v_clip / ma_unit;
|
||||
else
|
||||
return q;
|
||||
}
|
||||
vec3 toClipSpace3Prev(vec3 viewSpacePosition) {
|
||||
return projMAD(gbufferPreviousProjection, viewSpacePosition) / -viewSpacePosition.z * 0.5 + 0.5;
|
||||
}
|
||||
vec3 tonemap(vec3 col){
|
||||
return col/(1+luma(col));
|
||||
}
|
||||
vec3 invTonemap(vec3 col){
|
||||
return col/(1-luma(col));
|
||||
}
|
||||
vec3 closestToCamera5taps(vec2 texcoord, sampler2D depth)
|
||||
{
|
||||
vec2 du = vec2(texelSize.x*2., 0.0);
|
||||
vec2 dv = vec2(0.0, texelSize.y*2.);
|
||||
|
||||
vec3 dtl = vec3(texcoord,0.) + vec3(-texelSize, texture2D(depth, texcoord - dv - du).x);
|
||||
vec3 dtr = vec3(texcoord,0.) + vec3( texelSize.x, -texelSize.y, texture2D(depth, texcoord - dv + du).x);
|
||||
vec3 dmc = vec3(texcoord,0.) + vec3( 0.0, 0.0, texture2D(depth, texcoord).x);
|
||||
vec3 dbl = vec3(texcoord,0.) + vec3(-texelSize.x, texelSize.y, texture2D(depth, texcoord + dv - du).x);
|
||||
vec3 dbr = vec3(texcoord,0.) + vec3( texelSize.x, texelSize.y, texture2D(depth, texcoord + dv + du).x);
|
||||
|
||||
vec3 dmin = dmc;
|
||||
dmin = dmin.z > dtr.z? dtr : dmin;
|
||||
dmin = dmin.z > dtl.z? dtl : dmin;
|
||||
dmin = dmin.z > dbl.z? dbl : dmin;
|
||||
dmin = dmin.z > dbr.z? dbr : dmin;
|
||||
|
||||
return dmin;
|
||||
}
|
||||
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
|
||||
vec2(-1.,3.)/8.,
|
||||
vec2(5.0,1.)/8.,
|
||||
vec2(-3,-5.)/8.,
|
||||
vec2(-5.,5.)/8.,
|
||||
vec2(-7.,-1.)/8.,
|
||||
vec2(3,7.)/8.,
|
||||
vec2(7.,-7.)/8.);
|
||||
|
||||
vec3 TAA_hq(){
|
||||
|
||||
vec2 adjTC = texcoord;
|
||||
|
||||
|
||||
//use velocity from the nearest texel from camera in a 3x3 box in order to improve edge quality in motion
|
||||
#ifdef CLOSEST_VELOCITY
|
||||
vec3 closestToCamera = closestToCamera5taps(adjTC, depthtex0);
|
||||
#endif
|
||||
|
||||
#ifndef CLOSEST_VELOCITY
|
||||
vec3 closestToCamera = vec3(texcoord,texture2D(depthtex1,adjTC).x);
|
||||
#endif
|
||||
|
||||
//reproject previous frame
|
||||
vec3 fragposition = toScreenSpace(closestToCamera);
|
||||
fragposition = mat3(gbufferModelViewInverse) * fragposition + gbufferModelViewInverse[3].xyz + (cameraPosition - previousCameraPosition);
|
||||
vec3 previousPosition = mat3(gbufferPreviousModelView) * fragposition + gbufferPreviousModelView[3].xyz;
|
||||
previousPosition = toClipSpace3Prev(previousPosition);
|
||||
vec2 velocity = previousPosition.xy - closestToCamera.xy;
|
||||
previousPosition.xy = texcoord + velocity;
|
||||
|
||||
//reject history if off-screen and early exit
|
||||
if (previousPosition.x < 0.0 || previousPosition.y < 0.0 || previousPosition.x > 1.0 || previousPosition.y > 1.0)
|
||||
return smoothfilter(colortex3, adjTC + offsets[framemod8]*texelSize*0.5).xyz;
|
||||
|
||||
|
||||
vec3 albedoCurrent0 = texture2D(colortex3, adjTC).rgb;
|
||||
vec3 albedoCurrent1 = texture2D(colortex3, adjTC + vec2(texelSize.x,texelSize.y)).rgb;
|
||||
vec3 albedoCurrent2 = texture2D(colortex3, adjTC + vec2(texelSize.x,-texelSize.y)).rgb;
|
||||
vec3 albedoCurrent3 = texture2D(colortex3, adjTC + vec2(-texelSize.x,-texelSize.y)).rgb;
|
||||
vec3 albedoCurrent4 = texture2D(colortex3, adjTC + vec2(-texelSize.x,texelSize.y)).rgb;
|
||||
vec3 albedoCurrent5 = texture2D(colortex3, adjTC + vec2(0.0,texelSize.y)).rgb;
|
||||
vec3 albedoCurrent6 = texture2D(colortex3, adjTC + vec2(0.0,-texelSize.y)).rgb;
|
||||
vec3 albedoCurrent7 = texture2D(colortex3, adjTC + vec2(-texelSize.x,0.0)).rgb;
|
||||
vec3 albedoCurrent8 = texture2D(colortex3, adjTC + vec2(texelSize.x,0.0)).rgb;
|
||||
//Assuming the history color is a blend of the 3x3 neighborhood, we clamp the history to the min and max of each channel in the 3x3 neighborhood
|
||||
vec3 cMax = max(max(max(albedoCurrent0,albedoCurrent1),albedoCurrent2),max(albedoCurrent3,max(albedoCurrent4,max(albedoCurrent5,max(albedoCurrent6,max(albedoCurrent7,albedoCurrent8))))));
|
||||
vec3 cMin = min(min(min(albedoCurrent0,albedoCurrent1),albedoCurrent2),min(albedoCurrent3,min(albedoCurrent4,min(albedoCurrent5,min(albedoCurrent6,min(albedoCurrent7,albedoCurrent8))))));
|
||||
albedoCurrent0 = smoothfilter(colortex3, adjTC + offsets[framemod8]*texelSize*0.5).rgb;
|
||||
|
||||
|
||||
#ifndef NO_CLIP
|
||||
vec3 albedoPrev = max(FastCatmulRom(colortex5, previousPosition.xy,vec4(texelSize, 1.0/texelSize), 0.75).xyz, 0.0);
|
||||
vec3 finalcAcc = clamp(albedoPrev,cMin,cMax);
|
||||
|
||||
//Increases blending factor when far from AABB and in motion, reduces ghosting
|
||||
float isclamped = distance(albedoPrev,finalcAcc)/luma(albedoPrev) * 0.5;
|
||||
float movementRejection = (0.12+isclamped)*clamp(length(velocity/texelSize),0.0,1.0);
|
||||
|
||||
float test = 0.05;
|
||||
|
||||
bool isEntities = texture2D(colortex10,texcoord).x > 0.0;
|
||||
// if(isEntities) test = 0.15;
|
||||
// if(istranslucent) test = 0.1;
|
||||
|
||||
//Blend current pixel with clamped history, apply fast tonemap beforehand to reduce flickering
|
||||
// vec3 supersampled = invTonemap(mix(tonemap(finalcAcc),tonemap(albedoCurrent0),clamp(BLEND_FACTOR + movementRejection, min(luma(motionVector) *255,1.0),1.)));
|
||||
|
||||
vec3 supersampled = invTonemap(mix(tonemap(finalcAcc),tonemap(albedoCurrent0),clamp(BLEND_FACTOR + movementRejection, test,1.)));
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef NO_CLIP
|
||||
vec3 albedoPrev = texture2D(colortex5, previousPosition.xy).xyz;
|
||||
vec3 supersampled = mix(albedoPrev,albedoCurrent0,clamp(0.05,0.,1.));
|
||||
#endif
|
||||
|
||||
//De-tonemap
|
||||
return supersampled;
|
||||
}
|
||||
|
||||
void main() {
|
||||
|
||||
/* DRAWBUFFERS:5 */
|
||||
gl_FragData[0].a = 1.0;
|
||||
|
||||
#ifdef TAA
|
||||
vec3 color = TAA_hq();
|
||||
gl_FragData[0].rgb = clamp(fp10Dither(color,triangularize(interleaved_gradientNoise())),6.11*1e-5,65000.0);
|
||||
#endif
|
||||
|
||||
#ifndef TAA
|
||||
vec3 color = clamp(fp10Dither(texture2D(colortex3,texcoord).rgb,triangularize(interleaved_gradientNoise())),0.,65000.);
|
||||
gl_FragData[0].rgb = color;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
17
shaders/dimensions/composite3.vsh
Normal file
17
shaders/dimensions/composite3.vsh
Normal file
@ -0,0 +1,17 @@
|
||||
#include "/lib/util.glsl"
|
||||
|
||||
varying vec2 texcoord;
|
||||
flat varying float exposureA;
|
||||
flat varying float tempOffsets;
|
||||
uniform sampler2D colortex4;
|
||||
uniform int frameCounter;
|
||||
|
||||
|
||||
|
||||
void main() {
|
||||
|
||||
tempOffsets = HaltonSeq2(frameCounter%10000);
|
||||
gl_Position = ftransform();
|
||||
texcoord = gl_MultiTexCoord0.xy;
|
||||
exposureA = texelFetch2D(colortex4,ivec2(10,37),0).r;
|
||||
}
|
||||
42
shaders/dimensions/composite4.fsh
Normal file
42
shaders/dimensions/composite4.fsh
Normal file
@ -0,0 +1,42 @@
|
||||
uniform sampler2D colortex5;
|
||||
uniform vec2 texelSize;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
|
||||
/* DRAWBUFFERS:3 */
|
||||
vec2 resScale = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.))/vec2(1920.,1080.);
|
||||
vec2 quarterResTC = gl_FragCoord.xy*2.*resScale*texelSize;
|
||||
|
||||
//0.5
|
||||
gl_FragData[0] = texture2D(colortex5,quarterResTC-1.0*vec2(texelSize.x,texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+1.0*vec2(texelSize.x,texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+vec2(-1.0*texelSize.x,1.0*texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+vec2(1.0*texelSize.x,-1.0*texelSize.y))/4.*0.5;
|
||||
|
||||
//0.25
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC-2.0*vec2(texelSize.x,0.0))/2.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+2.0*vec2(0.0,texelSize.y))/2.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+2.0*vec2(0,-texelSize.y))/2*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+2.0*vec2(-texelSize.x,0.0))/2*0.125;
|
||||
|
||||
//0.125
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC-2.0*vec2(texelSize.x,texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+2.0*vec2(texelSize.x,texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+vec2(-2.0*texelSize.x,2.0*texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC+vec2(2.0*texelSize.x,-2.0*texelSize.y))/4.*0.125;
|
||||
|
||||
//0.125
|
||||
gl_FragData[0] += texture2D(colortex5,quarterResTC)*0.125;
|
||||
|
||||
gl_FragData[0].rgb = clamp(gl_FragData[0].rgb,0.0,65000.);
|
||||
if (quarterResTC.x > 1.0 - 3.5*texelSize.x || quarterResTC.y > 1.0 -3.5*texelSize.y || quarterResTC.x < 3.5*texelSize.x || quarterResTC.y < 3.5*texelSize.y) gl_FragData[0].rgb = vec3(0.0);
|
||||
|
||||
|
||||
}
|
||||
15
shaders/dimensions/composite4.vsh
Normal file
15
shaders/dimensions/composite4.vsh
Normal file
@ -0,0 +1,15 @@
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
//Improves performances and makes sure bloom radius stays the same at high resolution (>1080p)
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
gl_Position = ftransform();
|
||||
//*0.51 to avoid errors when sampling outside since clearing is disabled
|
||||
gl_Position.xy = (gl_Position.xy*0.5+0.5)*0.51/clampedRes*vec2(1920.0,1080.)*2.0-1.0;
|
||||
}
|
||||
42
shaders/dimensions/composite5.fsh
Normal file
42
shaders/dimensions/composite5.fsh
Normal file
@ -0,0 +1,42 @@
|
||||
uniform sampler2D colortex3;
|
||||
uniform vec2 texelSize;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
|
||||
/* DRAWBUFFERS:6 */
|
||||
vec2 resScale = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.))/vec2(1920.,1080.);
|
||||
vec2 quarterResTC = gl_FragCoord.xy*2.*texelSize;
|
||||
|
||||
//0.5
|
||||
gl_FragData[0] = texture2D(colortex3,quarterResTC-1.0*vec2(texelSize.x,texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+1.0*vec2(texelSize.x,texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+vec2(-1.0*texelSize.x,1.0*texelSize.y))/4.*0.5;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+vec2(1.0*texelSize.x,-1.0*texelSize.y))/4.*0.5;
|
||||
|
||||
//0.25
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC-2.0*vec2(texelSize.x,0.0))/2.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+2.0*vec2(0.0,texelSize.y))/2.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+2.0*vec2(0,-texelSize.y))/2*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+2.0*vec2(-texelSize.x,0.0))/2*0.125;
|
||||
|
||||
//0.125
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC-2.0*vec2(texelSize.x,texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+2.0*vec2(texelSize.x,texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+vec2(-2.0*texelSize.x,2.0*texelSize.y))/4.*0.125;
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC+vec2(2.0*texelSize.x,-2.0*texelSize.y))/4.*0.125;
|
||||
|
||||
//0.125
|
||||
gl_FragData[0] += texture2D(colortex3,quarterResTC)*0.125;
|
||||
|
||||
gl_FragData[0].rgb = clamp(gl_FragData[0].rgb,0.0,65000.);
|
||||
|
||||
|
||||
|
||||
}
|
||||
15
shaders/dimensions/composite5.vsh
Normal file
15
shaders/dimensions/composite5.vsh
Normal file
@ -0,0 +1,15 @@
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
//Improves performances and makes sure bloom radius stays the same at high resolution (>1080p)
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
gl_Position = ftransform();
|
||||
//*0.51 to avoid errors when sampling outside since clearing is disabled
|
||||
gl_Position.xy = (gl_Position.xy*0.5+0.5)*0.26/clampedRes*vec2(1920.0,1080.)*2-1.0;
|
||||
}
|
||||
57
shaders/dimensions/composite6.fsh
Normal file
57
shaders/dimensions/composite6.fsh
Normal file
@ -0,0 +1,57 @@
|
||||
uniform sampler2D colortex6;
|
||||
uniform vec2 texelSize;
|
||||
varying vec2 texcoord;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
vec2 resScale = vec2(1920.,1080.)/max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
vec3 gauss1D(vec2 coord,vec2 dir,float alpha,int maxIT){
|
||||
vec4 tot = vec4(0.);
|
||||
float maxTC = 0.25*resScale.x;
|
||||
float minTC = 0.;
|
||||
for (int i = -maxIT;i<maxIT+1;i++){
|
||||
float weight = exp(-i*i*alpha*4.0);
|
||||
//here we take advantage of bilinear filtering for 2x less sample, as a side effect the gaussian won't be totally centered for small blurs
|
||||
vec2 spCoord = coord+dir*texelSize*(2.0*i+0.5);
|
||||
tot += vec4(texture2D(colortex6,spCoord).rgb,1.0)*weight*float(spCoord.x > minTC && spCoord.x < maxTC);
|
||||
}
|
||||
return tot.rgb/max(1.0,tot.a);
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:6 */
|
||||
|
||||
vec2 texcoord = (gl_FragCoord.xy*vec2(2.0,4.0))*texelSize;
|
||||
vec2 gaussDir = vec2(1.0,0.0);
|
||||
gl_FragData[0].rgb = vec3(0.0);
|
||||
vec2 tc2 = texcoord*vec2(2.0,1.)/2.;
|
||||
if (tc2.x < 1.0*resScale.x && tc2.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc2/2,gaussDir,0.16,0);
|
||||
|
||||
vec2 tc4 = texcoord*vec2(4.0,1.)/2.-vec2(0.5*resScale.x+4.0*texelSize.x,0.)*2.0;
|
||||
if (tc4.x > 0.0 && tc4.y > 0.0 && tc4.x < 1.0*resScale.x && tc4.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc4/2,gaussDir,0.16,3);
|
||||
|
||||
vec2 tc8 = texcoord*vec2(8.0,1.)/2.-vec2(0.75*resScale.x+8.*texelSize.x,0.)*4.0;
|
||||
if (tc8.x > 0.0 && tc8.y > 0.0 && tc8.x < 1.0*resScale.x && tc8.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc8/2,gaussDir,0.035,6);
|
||||
|
||||
vec2 tc16 = texcoord*vec2(8.0,1./2.)-vec2(0.875*resScale.x+12.*texelSize.x,0.)*8.0;
|
||||
if (tc16.x > 0.0 && tc16.y > 0.0 && tc16.x < 1.0*resScale.x && tc16.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc16/2,gaussDir,0.0085,12);
|
||||
|
||||
vec2 tc32 = texcoord*vec2(16.0,1./2.)-vec2(0.9375*resScale.x+16.*texelSize.x,0.)*16.0;
|
||||
if (tc32.x > 0.0 && tc32.y > 0.0 && tc32.x < 1.0*resScale.x && tc32.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc32/2,gaussDir,0.002,28);
|
||||
|
||||
vec2 tc64 = texcoord*vec2(32.0,1./2.)-vec2(0.96875*resScale.x+20.*texelSize.x,0.)*32.0;
|
||||
if (tc64.x > 0.0 && tc64.y > 0.0 && tc64.x < 1.0*resScale.x && tc64.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(tc64/2,gaussDir,0.0005,60);
|
||||
|
||||
gl_FragData[0].rgb = clamp(gl_FragData[0].rgb,0.0,65000.);
|
||||
}
|
||||
18
shaders/dimensions/composite6.vsh
Normal file
18
shaders/dimensions/composite6.vsh
Normal file
@ -0,0 +1,18 @@
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
varying vec2 texcoord;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.0));
|
||||
gl_Position = ftransform();
|
||||
//0-0.25
|
||||
gl_Position.y = (gl_Position.y*0.5+0.5)*0.25/clampedRes.y*1080.0*2.0-1.0;
|
||||
//0-0.5
|
||||
gl_Position.x = (gl_Position.x*0.5+0.5)*0.5/clampedRes.x*1920.0*2.0-1.0;
|
||||
texcoord = gl_MultiTexCoord0.xy/clampedRes*vec2(1920.,1080.);
|
||||
}
|
||||
56
shaders/dimensions/composite7.fsh
Normal file
56
shaders/dimensions/composite7.fsh
Normal file
@ -0,0 +1,56 @@
|
||||
uniform sampler2D colortex6;
|
||||
uniform vec2 texelSize;
|
||||
varying vec2 texcoord;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
vec2 resScale = vec2(1920.,1080.)/max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
vec3 gauss1D(vec2 coord,vec2 dir,float alpha,int maxIT){
|
||||
vec4 tot = vec4(0.);
|
||||
float maxTC = 0.25*resScale.y;
|
||||
float minTC = 0.;
|
||||
for (int i = -maxIT;i<maxIT+1;i++){
|
||||
float weight = exp(-i*i*alpha*4.0);
|
||||
vec2 spCoord = coord+dir*texelSize*(2.0*i+0.5);
|
||||
tot += vec4(texture2D(colortex6,spCoord).rgb,1.0)*weight*float(spCoord.y > minTC && spCoord.y < maxTC);
|
||||
}
|
||||
return tot.rgb/max(1.0,tot.a);
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:6 */
|
||||
vec2 texcoord = (gl_FragCoord.xy*vec2(2.0,4.0))*texelSize;
|
||||
|
||||
vec2 gaussDir = vec2(0.0,1.0);
|
||||
gl_FragData[0].rgb = vec3(0.0);
|
||||
vec2 tc2 = texcoord*vec2(2.0,1.);
|
||||
if (tc2.x < 1.0*resScale.x && tc2.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord/vec2(2.0,4.0),gaussDir,0.16,0);
|
||||
|
||||
vec2 tc4 = texcoord*vec2(4.0,2.)-vec2(0.5*resScale.x+4.0*texelSize.x,0.)*4.0;
|
||||
if (tc4.x > 0.0 && tc4.y > 0.0 && tc4.x < 1.0*resScale.x && tc4.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord/vec2(2.0,2.0),gaussDir,0.16,3);
|
||||
|
||||
vec2 tc8 = texcoord*vec2(8.0,4.)-vec2(0.75*resScale.x+8.*texelSize.x,0.)*8.0;
|
||||
if (tc8.x > 0.0 && tc8.y > 0.0 && tc8.x < 1.0*resScale.x && tc8.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord*vec2(1.0,2.0)/vec2(2.0,2.0),gaussDir,0.035,6);
|
||||
|
||||
vec2 tc16 = texcoord*vec2(16.0,8.)-vec2(0.875*resScale.x+12.*texelSize.x,0.)*16.0;
|
||||
if (tc16.x > 0.0 && tc16.y > 0.0 && tc16.x < 1.0*resScale.x && tc16.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord*vec2(1.0,4.0)/vec2(2.0,2.0),gaussDir,0.0085,12);
|
||||
|
||||
vec2 tc32 = texcoord*vec2(32.0,16.)-vec2(0.9375*resScale.x+16.*texelSize.x,0.)*32.0;
|
||||
if (tc32.x > 0.0 && tc32.y > 0.0 && tc32.x < 1.0*resScale.x && tc32.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord*vec2(1.0,8.0)/vec2(2.0,2.0),gaussDir,0.002,30);
|
||||
|
||||
vec2 tc64 = texcoord*vec2(64.0,32.)-vec2(0.96875*resScale.x+20.*texelSize.x,0.)*64.0;
|
||||
if (tc64.x > 0.0 && tc64.y > 0.0 && tc64.x < 1.0*resScale.x && tc64.y <1.0*resScale.y)
|
||||
gl_FragData[0].xyz = gauss1D(texcoord*vec2(1.0,16.0)/vec2(2.0,2.0),gaussDir,0.0005,60);
|
||||
|
||||
gl_FragData[0].rgb = clamp(gl_FragData[0].rgb,0.0,65000.);
|
||||
}
|
||||
19
shaders/dimensions/composite7.vsh
Normal file
19
shaders/dimensions/composite7.vsh
Normal file
@ -0,0 +1,19 @@
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
varying vec2 texcoord;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.0));
|
||||
gl_Position = ftransform();
|
||||
//0-0.25
|
||||
gl_Position.y = (gl_Position.y*0.5+0.5)*0.25/clampedRes.y*1080.0*2.0-1.0;
|
||||
//0-0.5
|
||||
gl_Position.x = (gl_Position.x*0.5+0.5)*0.5/clampedRes.x*1920.0*2.0-1.0;
|
||||
texcoord = gl_MultiTexCoord0.xy/clampedRes*vec2(1920.,1080.);
|
||||
|
||||
}
|
||||
100
shaders/dimensions/composite8.fsh
Normal file
100
shaders/dimensions/composite8.fsh
Normal file
@ -0,0 +1,100 @@
|
||||
uniform sampler2D colortex3;
|
||||
uniform sampler2D colortex6;
|
||||
|
||||
uniform vec2 texelSize;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
|
||||
float w0(float a)
|
||||
{
|
||||
return (1.0/6.0)*(a*(a*(-a + 3.0) - 3.0) + 1.0);
|
||||
}
|
||||
|
||||
float w1(float a)
|
||||
{
|
||||
return (1.0/6.0)*(a*a*(3.0*a - 6.0) + 4.0);
|
||||
}
|
||||
|
||||
float w2(float a)
|
||||
{
|
||||
return (1.0/6.0)*(a*(a*(-3.0*a + 3.0) + 3.0) + 1.0);
|
||||
}
|
||||
|
||||
float w3(float a)
|
||||
{
|
||||
return (1.0/6.0)*(a*a*a);
|
||||
}
|
||||
|
||||
float g0(float a)
|
||||
{
|
||||
return w0(a) + w1(a);
|
||||
}
|
||||
|
||||
float g1(float a)
|
||||
{
|
||||
return w2(a) + w3(a);
|
||||
}
|
||||
|
||||
float h0(float a)
|
||||
{
|
||||
return -1.0 + w1(a) / (w0(a) + w1(a));
|
||||
}
|
||||
|
||||
float h1(float a)
|
||||
{
|
||||
return 1.0 + w3(a) / (w2(a) + w3(a));
|
||||
}
|
||||
|
||||
vec4 texture2D_bicubic(sampler2D tex, vec2 uv)
|
||||
{
|
||||
vec4 texelSize = vec4(texelSize,1.0/texelSize);
|
||||
uv = uv*texelSize.zw;
|
||||
vec2 iuv = floor( uv );
|
||||
vec2 fuv = fract( uv );
|
||||
|
||||
float g0x = g0(fuv.x);
|
||||
float g1x = g1(fuv.x);
|
||||
float h0x = h0(fuv.x);
|
||||
float h1x = h1(fuv.x);
|
||||
float h0y = h0(fuv.y);
|
||||
float h1y = h1(fuv.y);
|
||||
|
||||
vec2 p0 = (vec2(iuv.x + h0x, iuv.y + h0y) - 0.5) * texelSize.xy;
|
||||
vec2 p1 = (vec2(iuv.x + h1x, iuv.y + h0y) - 0.5) * texelSize.xy;
|
||||
vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - 0.5) * texelSize.xy;
|
||||
vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - 0.5) * texelSize.xy;
|
||||
|
||||
return g0(fuv.y) * (g0x * texture2D(tex, p0) +
|
||||
g1x * texture2D(tex, p1)) +
|
||||
g1(fuv.y) * (g0x * texture2D(tex, p2) +
|
||||
g1x * texture2D(tex, p3));
|
||||
}
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:3 */
|
||||
vec2 resScale = vec2(1920.,1080.)/max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
vec2 texcoord = ((gl_FragCoord.xy)*2.+0.5)*texelSize;
|
||||
vec3 bloom = texture2D_bicubic(colortex3,texcoord/2.0).rgb; //1/4 res
|
||||
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/4.).rgb; //1/8 res
|
||||
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/8.+vec2(0.25*resScale.x+2.5*texelSize.x,.0)).rgb; //1/16 res
|
||||
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/16.+vec2(0.375*resScale.x+4.5*texelSize.x,.0)).rgb; //1/32 res
|
||||
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/32.+vec2(0.4375*resScale.x+6.5*texelSize.x,.0)).rgb*1.0; //1/64 res
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/64.+vec2(0.46875*resScale.x+8.5*texelSize.x,.0)).rgb*1.0; //1/128 res
|
||||
bloom += texture2D_bicubic(colortex6,texcoord/128.+vec2(0.484375*resScale.x+10.5*texelSize.x,.0)).rgb*1.0; //1/256 res
|
||||
|
||||
//bloom = texture2D_bicubic(colortex6,texcoord).rgb*6.; //1/8 res
|
||||
|
||||
gl_FragData[0].rgb = bloom*2.;
|
||||
|
||||
gl_FragData[0].rgb = clamp(gl_FragData[0].rgb,0.0,65000.);
|
||||
}
|
||||
15
shaders/dimensions/composite8.vsh
Normal file
15
shaders/dimensions/composite8.vsh
Normal file
@ -0,0 +1,15 @@
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
//Improves performances and makes sure bloom radius stays the same at high resolution (>1080p)
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
gl_Position = ftransform();
|
||||
//*0.51 to avoid errors when sampling outside since clearing is disabled
|
||||
gl_Position.xy = (gl_Position.xy*0.5+0.5)*0.51/clampedRes*vec2(1920.0,1080.)*2.0-1.0;
|
||||
}
|
||||
473
shaders/dimensions/composite9.fsh
Normal file
473
shaders/dimensions/composite9.fsh
Normal file
@ -0,0 +1,473 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
#ifdef DOF
|
||||
//hexagon pattern
|
||||
const vec2 hex_offsets[60] = vec2[60] ( vec2( 0.2165, 0.1250 ),
|
||||
vec2( 0.0000, 0.2500 ),
|
||||
vec2( -0.2165, 0.1250 ),
|
||||
vec2( -0.2165, -0.1250 ),
|
||||
vec2( -0.0000, -0.2500 ),
|
||||
vec2( 0.2165, -0.1250 ),
|
||||
vec2( 0.4330, 0.2500 ),
|
||||
vec2( 0.0000, 0.5000 ),
|
||||
vec2( -0.4330, 0.2500 ),
|
||||
vec2( -0.4330, -0.2500 ),
|
||||
vec2( -0.0000, -0.5000 ),
|
||||
vec2( 0.4330, -0.2500 ),
|
||||
vec2( 0.6495, 0.3750 ),
|
||||
vec2( 0.0000, 0.7500 ),
|
||||
vec2( -0.6495, 0.3750 ),
|
||||
vec2( -0.6495, -0.3750 ),
|
||||
vec2( -0.0000, -0.7500 ),
|
||||
vec2( 0.6495, -0.3750 ),
|
||||
vec2( 0.8660, 0.5000 ),
|
||||
vec2( 0.0000, 1.0000 ),
|
||||
vec2( -0.8660, 0.5000 ),
|
||||
vec2( -0.8660, -0.5000 ),
|
||||
vec2( -0.0000, -1.0000 ),
|
||||
vec2( 0.8660, -0.5000 ),
|
||||
vec2( 0.2163, 0.3754 ),
|
||||
vec2( -0.2170, 0.3750 ),
|
||||
vec2( -0.4333, -0.0004 ),
|
||||
vec2( -0.2163, -0.3754 ),
|
||||
vec2( 0.2170, -0.3750 ),
|
||||
vec2( 0.4333, 0.0004 ),
|
||||
vec2( 0.4328, 0.5004 ),
|
||||
vec2( -0.2170, 0.6250 ),
|
||||
vec2( -0.6498, 0.1246 ),
|
||||
vec2( -0.4328, -0.5004 ),
|
||||
vec2( 0.2170, -0.6250 ),
|
||||
vec2( 0.6498, -0.1246 ),
|
||||
vec2( 0.6493, 0.6254 ),
|
||||
vec2( -0.2170, 0.8750 ),
|
||||
vec2( -0.8663, 0.2496 ),
|
||||
vec2( -0.6493, -0.6254 ),
|
||||
vec2( 0.2170, -0.8750 ),
|
||||
vec2( 0.8663, -0.2496 ),
|
||||
vec2( 0.2160, 0.6259 ),
|
||||
vec2( -0.4340, 0.5000 ),
|
||||
vec2( -0.6500, -0.1259 ),
|
||||
vec2( -0.2160, -0.6259 ),
|
||||
vec2( 0.4340, -0.5000 ),
|
||||
vec2( 0.6500, 0.1259 ),
|
||||
vec2( 0.4325, 0.7509 ),
|
||||
vec2( -0.4340, 0.7500 ),
|
||||
vec2( -0.8665, -0.0009 ),
|
||||
vec2( -0.4325, -0.7509 ),
|
||||
vec2( 0.4340, -0.7500 ),
|
||||
vec2( 0.8665, 0.0009 ),
|
||||
vec2( 0.2158, 0.8763 ),
|
||||
vec2( -0.6510, 0.6250 ),
|
||||
vec2( -0.8668, -0.2513 ),
|
||||
vec2( -0.2158, -0.8763 ),
|
||||
vec2( 0.6510, -0.6250 ),
|
||||
vec2( 0.8668, 0.2513 ));
|
||||
|
||||
const vec2 offsets[60] = vec2[60] ( vec2( 0.0000, 0.2500 ),
|
||||
vec2( -0.2165, 0.1250 ),
|
||||
vec2( -0.2165, -0.1250 ),
|
||||
vec2( -0.0000, -0.2500 ),
|
||||
vec2( 0.2165, -0.1250 ),
|
||||
vec2( 0.2165, 0.1250 ),
|
||||
vec2( 0.0000, 0.5000 ),
|
||||
vec2( -0.2500, 0.4330 ),
|
||||
vec2( -0.4330, 0.2500 ),
|
||||
vec2( -0.5000, 0.0000 ),
|
||||
vec2( -0.4330, -0.2500 ),
|
||||
vec2( -0.2500, -0.4330 ),
|
||||
vec2( -0.0000, -0.5000 ),
|
||||
vec2( 0.2500, -0.4330 ),
|
||||
vec2( 0.4330, -0.2500 ),
|
||||
vec2( 0.5000, -0.0000 ),
|
||||
vec2( 0.4330, 0.2500 ),
|
||||
vec2( 0.2500, 0.4330 ),
|
||||
vec2( 0.0000, 0.7500 ),
|
||||
vec2( -0.2565, 0.7048 ),
|
||||
vec2( -0.4821, 0.5745 ),
|
||||
vec2( -0.6495, 0.3750 ),
|
||||
vec2( -0.7386, 0.1302 ),
|
||||
vec2( -0.7386, -0.1302 ),
|
||||
vec2( -0.6495, -0.3750 ),
|
||||
vec2( -0.4821, -0.5745 ),
|
||||
vec2( -0.2565, -0.7048 ),
|
||||
vec2( -0.0000, -0.7500 ),
|
||||
vec2( 0.2565, -0.7048 ),
|
||||
vec2( 0.4821, -0.5745 ),
|
||||
vec2( 0.6495, -0.3750 ),
|
||||
vec2( 0.7386, -0.1302 ),
|
||||
vec2( 0.7386, 0.1302 ),
|
||||
vec2( 0.6495, 0.3750 ),
|
||||
vec2( 0.4821, 0.5745 ),
|
||||
vec2( 0.2565, 0.7048 ),
|
||||
vec2( 0.0000, 1.0000 ),
|
||||
vec2( -0.2588, 0.9659 ),
|
||||
vec2( -0.5000, 0.8660 ),
|
||||
vec2( -0.7071, 0.7071 ),
|
||||
vec2( -0.8660, 0.5000 ),
|
||||
vec2( -0.9659, 0.2588 ),
|
||||
vec2( -1.0000, 0.0000 ),
|
||||
vec2( -0.9659, -0.2588 ),
|
||||
vec2( -0.8660, -0.5000 ),
|
||||
vec2( -0.7071, -0.7071 ),
|
||||
vec2( -0.5000, -0.8660 ),
|
||||
vec2( -0.2588, -0.9659 ),
|
||||
vec2( -0.0000, -1.0000 ),
|
||||
vec2( 0.2588, -0.9659 ),
|
||||
vec2( 0.5000, -0.8660 ),
|
||||
vec2( 0.7071, -0.7071 ),
|
||||
vec2( 0.8660, -0.5000 ),
|
||||
vec2( 0.9659, -0.2588 ),
|
||||
vec2( 1.0000, -0.0000 ),
|
||||
vec2( 0.9659, 0.2588 ),
|
||||
vec2( 0.8660, 0.5000 ),
|
||||
vec2( 0.7071, 0.7071 ),
|
||||
vec2( 0.5000, 0.8660 ),
|
||||
vec2( 0.2588, 0.9659 ));
|
||||
|
||||
const vec2 shadow_offsets[209] = vec2[209](vec2(0.8886414f , 0.07936136f),
|
||||
vec2(0.8190064f , 0.1900164f),
|
||||
vec2(0.8614115f , -0.06991258f),
|
||||
vec2(0.7685533f , 0.03792081f),
|
||||
vec2(0.9970094f , 0.02585129f),
|
||||
vec2(0.9686818f , 0.1570935f),
|
||||
vec2(0.9854341f , -0.09172997f),
|
||||
vec2(0.9330608f , 0.3326486f),
|
||||
vec2(0.8329557f , -0.2438523f),
|
||||
vec2(0.664771f , -0.0837701f),
|
||||
vec2(0.7429124f , -0.1530652f),
|
||||
vec2(0.9506453f , -0.2174281f),
|
||||
vec2(0.8192949f , 0.3485171f),
|
||||
vec2(0.6851269f , 0.2711877f),
|
||||
vec2(0.7665657f , 0.5014166f),
|
||||
vec2(0.673241f , 0.3793408f),
|
||||
vec2(0.6981376f , 0.1465924f),
|
||||
vec2(0.6521665f , -0.2384985f),
|
||||
vec2(0.5145761f , -0.05752508f),
|
||||
vec2(0.5641244f , -0.169443f),
|
||||
vec2(0.5916035f , 0.06004957f),
|
||||
vec2(0.57079f , 0.234188f),
|
||||
vec2(0.509311f , 0.1523665f),
|
||||
vec2(0.4204576f , 0.05759521f),
|
||||
vec2(0.8200846f , -0.3601041f),
|
||||
vec2(0.6893264f , -0.3473432f),
|
||||
vec2(0.4775535f , -0.3062558f),
|
||||
vec2(0.438106f , -0.1796866f),
|
||||
vec2(0.4056528f , -0.08251233f),
|
||||
vec2(0.5771964f , 0.5502692f),
|
||||
vec2(0.5094061f , 0.4025192f),
|
||||
vec2(0.6908483f , 0.572951f),
|
||||
vec2(0.5379036f , -0.4542191f),
|
||||
vec2(0.8167359f , -0.4793735f),
|
||||
vec2(0.6829269f , -0.4557574f),
|
||||
vec2(0.5725697f , -0.3477072f),
|
||||
vec2(0.5767449f , -0.5782524f),
|
||||
vec2(0.3979413f , -0.4172934f),
|
||||
vec2(0.4282598f , -0.5145645f),
|
||||
vec2(0.938814f , -0.3239739f),
|
||||
vec2(0.702452f , -0.5662871f),
|
||||
vec2(0.2832307f , -0.1285671f),
|
||||
vec2(0.3230537f , -0.2691054f),
|
||||
vec2(0.2921676f , -0.3734582f),
|
||||
vec2(0.2534037f , -0.4906001f),
|
||||
vec2(0.4343273f , 0.5223463f),
|
||||
vec2(0.3605334f , 0.3151571f),
|
||||
vec2(0.3498518f , 0.451428f),
|
||||
vec2(0.3230703f , 0.00287089f),
|
||||
vec2(0.1049206f , -0.1476725f),
|
||||
vec2(0.2063161f , -0.2608192f),
|
||||
vec2(0.7266634f , 0.6725333f),
|
||||
vec2(0.4027067f , -0.6185485f),
|
||||
vec2(0.2655533f , -0.5912259f),
|
||||
vec2(0.4947965f , 0.3025357f),
|
||||
vec2(0.5760762f , 0.68844f),
|
||||
vec2(0.4909205f , -0.6975324f),
|
||||
vec2(0.8609334f , 0.4559f),
|
||||
vec2(0.1836646f , 0.03724086f),
|
||||
vec2(0.2878554f , 0.178938f),
|
||||
vec2(0.3948484f , 0.1618928f),
|
||||
vec2(0.3519658f , -0.7628763f),
|
||||
vec2(0.6338583f , -0.673193f),
|
||||
vec2(0.5511802f , -0.8283072f),
|
||||
vec2(0.4090595f , -0.8717521f),
|
||||
vec2(0.1482169f , -0.374728f),
|
||||
vec2(0.1050598f , -0.2613987f),
|
||||
vec2(0.4210334f , 0.6578422f),
|
||||
vec2(0.2430464f , 0.4383665f),
|
||||
vec2(0.3329675f , 0.5512741f),
|
||||
vec2(0.2147711f , 0.3245511f),
|
||||
vec2(0.1227196f , 0.2529026f),
|
||||
vec2(-0.03937457f , 0.156439f),
|
||||
vec2(0.05618772f , 0.06690486f),
|
||||
vec2(0.06519571f , 0.3974038f),
|
||||
vec2(0.1360903f , 0.1466078f),
|
||||
vec2(-0.00170609f , 0.3089452f),
|
||||
vec2(0.1357622f , -0.5088975f),
|
||||
vec2(0.1604694f , -0.7453476f),
|
||||
vec2(0.1245694f , -0.6337074f),
|
||||
vec2(0.02542936f , -0.3728781f),
|
||||
vec2(0.02222222f , -0.649554f),
|
||||
vec2(0.09870815f , 0.5357338f),
|
||||
vec2(0.2073958f , 0.5452989f),
|
||||
vec2(0.216654f , -0.8935689f),
|
||||
vec2(0.2422334f , 0.665805f),
|
||||
vec2(0.0574713f , 0.6742729f),
|
||||
vec2(0.2021346f , 0.8144029f),
|
||||
vec2(0.3086587f , 0.7504997f),
|
||||
vec2(0.02122174f , -0.7498575f),
|
||||
vec2(-0.1551729f , 0.1809731f),
|
||||
vec2(-0.1947583f , 0.06246066f),
|
||||
vec2(-0.05754202f , -0.03901273f),
|
||||
vec2(-0.1083095f , 0.2952235f),
|
||||
vec2(-0.03259534f , -0.492394f),
|
||||
vec2(-0.02488567f , -0.2081116f),
|
||||
vec2(-0.1820729f , -0.1829884f),
|
||||
vec2(-0.1674413f , -0.04529009f),
|
||||
vec2(0.04342153f , -0.0368562f),
|
||||
vec2(0.801399f , -0.5845526f),
|
||||
vec2(0.3158276f , -0.9124843f),
|
||||
vec2(-0.05945269f , 0.6727523f),
|
||||
vec2(0.07701834f , 0.8579889f),
|
||||
vec2(-0.05778154f , 0.5699022f),
|
||||
vec2(0.1191713f , 0.7542591f),
|
||||
vec2(-0.2578296f , 0.3630984f),
|
||||
vec2(-0.1428598f , 0.4557526f),
|
||||
vec2(-0.3304029f , 0.5055485f),
|
||||
vec2(-0.3227198f , 0.1847367f),
|
||||
vec2(-0.4183801f , 0.3412776f),
|
||||
vec2(0.2538475f , 0.9317476f),
|
||||
vec2(0.406249f , 0.8423664f),
|
||||
vec2(0.4718862f , 0.7592828f),
|
||||
vec2(0.168472f , -0.06605823f),
|
||||
vec2(0.2632498f , -0.7084918f),
|
||||
vec2(-0.2816192f , -0.1023492f),
|
||||
vec2(-0.3161443f , 0.02489911f),
|
||||
vec2(-0.4677814f , 0.08450397f),
|
||||
vec2(-0.4156994f , 0.2408664f),
|
||||
vec2(-0.237449f , 0.2605326f),
|
||||
vec2(-0.0912179f , 0.06491816f),
|
||||
vec2(0.01475127f , 0.7670643f),
|
||||
vec2(0.1216858f , -0.9368939f),
|
||||
vec2(0.07010741f , -0.841011f),
|
||||
vec2(-0.1708607f , -0.4152923f),
|
||||
vec2(-0.1345006f , -0.5842513f),
|
||||
vec2(-0.09419055f , -0.3213732f),
|
||||
vec2(-0.2149337f , 0.730642f),
|
||||
vec2(-0.1102187f , 0.8425013f),
|
||||
vec2(-0.1808572f , 0.6244397f),
|
||||
vec2(-0.2414505f , -0.7063725f),
|
||||
vec2(-0.2410318f , -0.537854f),
|
||||
vec2(-0.1005938f , -0.7635075f),
|
||||
vec2(0.1053517f , 0.9678772f),
|
||||
vec2(-0.3340288f , 0.6926677f),
|
||||
vec2(-0.2363931f , 0.8464488f),
|
||||
vec2(-0.4057773f , 0.7786722f),
|
||||
vec2(-0.5484858f , 0.1686208f),
|
||||
vec2(-0.64842f , 0.02256887f),
|
||||
vec2(-0.5544513f , -0.02348978f),
|
||||
vec2(-0.492855f , -0.1083694f),
|
||||
vec2(-0.4248196f , 0.4674786f),
|
||||
vec2(-0.5873146f , 0.4072608f),
|
||||
vec2(-0.6439911f , 0.3038489f),
|
||||
vec2(-0.6419188f , 0.1293737f),
|
||||
vec2(-0.005880734f , 0.4699725f),
|
||||
vec2(-0.4239455f , 0.6250131f),
|
||||
vec2(-0.1701273f , 0.9506347f),
|
||||
vec2(7.665656E-05f , 0.9941212f),
|
||||
vec2(-0.7070159f , 0.4426281f),
|
||||
vec2(-0.7481344f , 0.3139496f),
|
||||
vec2(-0.8330062f , 0.2472693f),
|
||||
vec2(-0.7271438f , 0.2024286f),
|
||||
vec2(-0.5179888f , 0.3149576f),
|
||||
vec2(-0.8258062f , 0.3779382f),
|
||||
vec2(-0.8063191f , 0.1262931f),
|
||||
vec2(-0.2690676f , -0.4360798f),
|
||||
vec2(-0.3714577f , -0.5887412f),
|
||||
vec2(-0.3736085f , -0.4018324f),
|
||||
vec2(-0.3228985f , -0.2063406f),
|
||||
vec2(-0.2414576f , -0.2875458f),
|
||||
vec2(-0.4720859f , -0.3823904f),
|
||||
vec2(-0.4937642f , -0.2686005f),
|
||||
vec2(-0.01500604f , -0.9587054f),
|
||||
vec2(-0.08535925f , -0.8820614f),
|
||||
vec2(-0.6436375f , -0.3157263f),
|
||||
vec2(-0.5736347f , -0.4224878f),
|
||||
vec2(-0.5026127f , -0.5516239f),
|
||||
vec2(-0.8200902f , 0.5370023f),
|
||||
vec2(-0.7196413f , 0.57133f),
|
||||
vec2(-0.5849072f , 0.5917885f),
|
||||
vec2(-0.1598758f , -0.9739854f),
|
||||
vec2(-0.4230629f , -0.01858409f),
|
||||
vec2(-0.9403627f , 0.2213769f),
|
||||
vec2(-0.685889f , -0.2192711f),
|
||||
vec2(-0.6693704f , -0.4884708f),
|
||||
vec2(-0.7967147f , -0.3078234f),
|
||||
vec2(-0.596441f , -0.1686891f),
|
||||
vec2(-0.7366468f , -0.3939891f),
|
||||
vec2(-0.7963406f , 0.02246814f),
|
||||
vec2(-0.9177913f , 0.0929693f),
|
||||
vec2(-0.9284672f , 0.3329005f),
|
||||
vec2(-0.6497722f , 0.6851863f),
|
||||
vec2(-0.496019f , 0.7013303f),
|
||||
vec2(-0.3930301f , -0.6892192f),
|
||||
vec2(-0.2122009f , -0.8777389f),
|
||||
vec2(-0.3660335f , -0.801644f),
|
||||
vec2(-0.386839f , -0.1191898f),
|
||||
vec2(-0.7020127f , -0.0776734f),
|
||||
vec2(-0.7760845f , -0.1566844f),
|
||||
vec2(-0.5444778f , -0.6516482f),
|
||||
vec2(-0.5331346f , 0.4946506f),
|
||||
vec2(-0.3288236f , 0.9408244f),
|
||||
vec2(0.5819826f , 0.8101937f),
|
||||
vec2(-0.4894184f , -0.8290837f),
|
||||
vec2(-0.5183194f , 0.8454953f),
|
||||
vec2(-0.7665774f , -0.5223897f),
|
||||
vec2(-0.6703191f , -0.6217513f),
|
||||
vec2(-0.8902924f , -0.2446688f),
|
||||
vec2(-0.8574848f , -0.09174173f),
|
||||
vec2(-0.3544409f , -0.9239591f),
|
||||
vec2(-0.969833f , -0.1172272f),
|
||||
vec2(-0.8968207f , -0.4079512f),
|
||||
vec2(-0.5891477f , 0.7724466f),
|
||||
vec2(-0.2146262f , 0.5286855f),
|
||||
vec2(-0.3762444f , -0.3014335f),
|
||||
vec2(-0.9466863f , -0.008970681f),
|
||||
vec2(-0.596356f , -0.7976127f),
|
||||
vec2(-0.8877738f , 0.4569088f));
|
||||
#endif
|
||||
flat varying vec4 exposure;
|
||||
flat varying float rodExposure;
|
||||
varying vec2 texcoord;
|
||||
uniform sampler2D colortex4;
|
||||
uniform sampler2D colortex5;
|
||||
uniform sampler2D colortex3;
|
||||
uniform sampler2D colortex7;
|
||||
uniform sampler2D depthtex0;
|
||||
uniform sampler2D noisetex;
|
||||
uniform vec2 texelSize;
|
||||
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
uniform float frameTimeCounter;
|
||||
uniform int frameCounter;
|
||||
uniform int isEyeInWater;
|
||||
uniform float near;
|
||||
uniform float aspectRatio;
|
||||
uniform float far;
|
||||
|
||||
|
||||
#include "/lib/color_transforms.glsl"
|
||||
#include "/lib/color_dither.glsl"
|
||||
|
||||
|
||||
|
||||
float cdist(vec2 coord) {
|
||||
return max(abs(coord.s-0.5),abs(coord.t-0.5))*2.0;
|
||||
}
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
float ld(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near)); // (-depth * (far - near)) = (2.0 * near)/ld - far - near
|
||||
}
|
||||
vec3 closestToCamera3x3()
|
||||
{
|
||||
vec2 du = vec2(texelSize.x, 0.0);
|
||||
vec2 dv = vec2(0.0, texelSize.y);
|
||||
|
||||
vec3 dtl = vec3(texcoord,0.) + vec3(-texelSize, texture2D(depthtex0, texcoord - dv - du).x);
|
||||
vec3 dtc = vec3(texcoord,0.) + vec3( 0.0, -texelSize.y, texture2D(depthtex0, texcoord - dv).x);
|
||||
vec3 dtr = vec3(texcoord,0.) + vec3( texelSize.x, -texelSize.y, texture2D(depthtex0, texcoord - dv + du).x);
|
||||
|
||||
vec3 dml = vec3(texcoord,0.) + vec3(-texelSize.x, 0.0, texture2D(depthtex0, texcoord - du).x);
|
||||
vec3 dmc = vec3(texcoord,0.) + vec3( 0.0, 0.0, texture2D(depthtex0, texcoord).x);
|
||||
vec3 dmr = vec3(texcoord,0.) + vec3( texelSize.x, 0.0, texture2D(depthtex0, texcoord + du).x);
|
||||
|
||||
vec3 dbl = vec3(texcoord,0.) + vec3(-texelSize.x, texelSize.y, texture2D(depthtex0, texcoord + dv - du).x);
|
||||
vec3 dbc = vec3(texcoord,0.) + vec3( 0.0, texelSize.y, texture2D(depthtex0, texcoord + dv).x);
|
||||
vec3 dbr = vec3(texcoord,0.) + vec3( texelSize.x, texelSize.y, texture2D(depthtex0, texcoord + dv + du).x);
|
||||
|
||||
vec3 dmin = dmc;
|
||||
|
||||
dmin = dmin.z > dtc.z? dtc : dmin;
|
||||
dmin = dmin.z > dtr.z? dtr : dmin;
|
||||
|
||||
dmin = dmin.z > dml.z? dml : dmin;
|
||||
dmin = dmin.z > dtl.z? dtl : dmin;
|
||||
dmin = dmin.z > dmr.z? dmr : dmin;
|
||||
|
||||
dmin = dmin.z > dbl.z? dbl : dmin;
|
||||
dmin = dmin.z > dbc.z? dbc : dmin;
|
||||
dmin = dmin.z > dbr.z? dbr : dmin;
|
||||
|
||||
return dmin;
|
||||
}
|
||||
void main() {
|
||||
/* DRAWBUFFERS:7 */
|
||||
float vignette = (1.5-dot(texcoord-0.5,texcoord-0.5)*2.5);
|
||||
vec3 col = texture2D(colortex5,texcoord).rgb;
|
||||
#ifdef DOF
|
||||
/*--------------------------------*/
|
||||
float z = ld(texture2D(depthtex0, texcoord.st).r)*far;
|
||||
#ifdef AUTOFOCUS
|
||||
float focus = ld(texture2D(depthtex0, vec2(0.5)).r)*far;
|
||||
#else
|
||||
float focus = MANUAL_FOCUS;
|
||||
#endif
|
||||
float pcoc = min(abs(aperture * (focal/100.0 * (z - focus)) / (z * (focus - focal/100.0))),texelSize.x*15.0);
|
||||
#ifdef FAR_BLUR_ONLY
|
||||
pcoc *= float(z > focus);
|
||||
#endif
|
||||
float noise = blueNoise()*6.28318530718;
|
||||
mat2 noiseM = mat2( cos( noise ), -sin( noise ),
|
||||
sin( noise ), cos( noise )
|
||||
);
|
||||
vec3 bcolor = vec3(0.);
|
||||
float nb = 0.0;
|
||||
vec2 bcoord = vec2(0.0);
|
||||
/*--------------------------------*/
|
||||
#ifndef HQ_DOF
|
||||
bcolor = col;
|
||||
#ifdef HEXAGONAL_BOKEH
|
||||
for ( int i = 0; i < 60; i++) {
|
||||
bcolor += texture2D(colortex5, texcoord.xy + hex_offsets[i]*pcoc*vec2(1.0,aspectRatio)).rgb;
|
||||
}
|
||||
col = bcolor/61.0;
|
||||
#else
|
||||
for ( int i = 0; i < 60; i++) {
|
||||
bcolor += texture2D(colortex5, texcoord.xy + offsets[i]*pcoc*vec2(1.0,aspectRatio)).rgb;
|
||||
}
|
||||
/*--------------------------------*/
|
||||
col = bcolor/61.0;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef HQ_DOF
|
||||
for ( int i = 0; i < 209; i++) {
|
||||
bcolor += texture2D(colortex5, texcoord.xy + noiseM*shadow_offsets[i]*pcoc*vec2(1.0,aspectRatio)).rgb;
|
||||
}
|
||||
col = bcolor/209.0;
|
||||
#endif
|
||||
#endif
|
||||
vec2 clampedRes = max(vec2(viewWidth,viewHeight),vec2(1920.0,1080.));
|
||||
|
||||
vec3 bloom = texture2D(colortex3,texcoord/clampedRes*vec2(1920.,1080.)*0.5).rgb/2./7.0;
|
||||
|
||||
float lightScat = clamp(BLOOM_STRENGTH * 0.05 * pow(exposure.a ,0.2) ,0.0,1.0)*vignette;
|
||||
|
||||
float VL_abs = texture2D(colortex7,texcoord).r;
|
||||
VL_abs = clamp((1.0-VL_abs*1.05)*BLOOMY_FOG*0.5,0.0,1.0)*clamp(1.0-pow(cdist(texcoord.xy),15.0),0.0,1.0);
|
||||
|
||||
col = ( mix(col, bloom, VL_abs) + bloom*lightScat) * exposure.rgb;
|
||||
|
||||
|
||||
#ifndef USE_ACES_COLORSPACE_APPROXIMATION
|
||||
col = LinearTosRGB(TONEMAP(col));
|
||||
#else
|
||||
col = col * ACESInputMat;
|
||||
col = TONEMAP(col);
|
||||
col = LinearTosRGB(clamp(col * ACESOutputMat, 0.0, 1.0));
|
||||
#endif
|
||||
//col = ACESFitted(texture2D(colortex4,texcoord/3.).rgb/500.);
|
||||
gl_FragData[0].rgb = clamp(int8Dither(col,texcoord),0.0,1.0);
|
||||
//if (nightMode < 0.99 && texcoord.x < 0.5) gl_FragData[0].rgb =vec3(0.0,1.0,0.0);
|
||||
|
||||
}
|
||||
20
shaders/dimensions/composite9.vsh
Normal file
20
shaders/dimensions/composite9.vsh
Normal file
@ -0,0 +1,20 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
varying vec2 texcoord;
|
||||
flat varying vec4 exposure;
|
||||
flat varying float rodExposure;
|
||||
uniform sampler2D colortex4;
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
|
||||
gl_Position = ftransform();
|
||||
texcoord = gl_MultiTexCoord0.xy;
|
||||
exposure=vec4(texelFetch2D(colortex4,ivec2(10,37),0).r*vec3(FinalR,FinalG,FinalB),texelFetch2D(colortex4,ivec2(10,37),0).r);
|
||||
rodExposure = texelFetch2D(colortex4,ivec2(14,37),0).r;
|
||||
}
|
||||
110
shaders/dimensions/deferred.fsh
Normal file
110
shaders/dimensions/deferred.fsh
Normal file
@ -0,0 +1,110 @@
|
||||
#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 lightSourceColor;
|
||||
flat varying vec3 sunColor;
|
||||
flat varying vec3 sunColorCloud;
|
||||
flat varying vec3 moonColor;
|
||||
flat varying vec3 moonColorCloud;
|
||||
flat varying vec3 zenithColor;
|
||||
flat varying vec3 avgSky;
|
||||
flat varying vec2 tempOffsets;
|
||||
flat varying float exposure;
|
||||
flat varying float rodExposure;
|
||||
flat varying float avgBrightness;
|
||||
flat varying float exposureF;
|
||||
flat varying float fogAmount;
|
||||
flat varying float VFAmount;
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
uniform sampler2D noisetex;
|
||||
|
||||
uniform int frameCounter;
|
||||
uniform float rainStrength;
|
||||
uniform float eyeAltitude;
|
||||
uniform vec3 sunVec;
|
||||
uniform vec2 texelSize;
|
||||
uniform float frameTimeCounter;
|
||||
uniform mat4 gbufferProjection;
|
||||
uniform mat4 gbufferProjectionInverse;
|
||||
uniform mat4 gbufferPreviousProjection;
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform mat4 gbufferModelView;
|
||||
uniform mat4 shadowModelView;
|
||||
uniform mat4 shadowProjection;
|
||||
uniform float sunElevation;
|
||||
uniform vec3 cameraPosition;
|
||||
uniform float far;
|
||||
uniform ivec2 eyeBrightnessSmooth;
|
||||
|
||||
#include "/lib/util.glsl"
|
||||
#include "/lib/ROBOBO_sky.glsl"
|
||||
|
||||
vec3 toShadowSpaceProjected(vec3 p3){
|
||||
p3 = mat3(gbufferModelViewInverse) * p3 + gbufferModelViewInverse[3].xyz;
|
||||
p3 = mat3(shadowModelView) * p3 + shadowModelView[3].xyz;
|
||||
p3 = diagonal3(shadowProjection) * p3 + shadowProjection[3].xyz;
|
||||
|
||||
return p3;
|
||||
}
|
||||
float interleaved_gradientNoise(){
|
||||
vec2 coord = gl_FragCoord.xy;
|
||||
float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y)+frameCounter/1.6180339887);
|
||||
return noise;
|
||||
}
|
||||
float blueNoise(){
|
||||
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef END_SHADER
|
||||
#include "/lib/end_fog.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_SHADER
|
||||
#include "/lib/nether_fog.glsl"
|
||||
#endif
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:4 */
|
||||
|
||||
gl_FragData[0] = vec4(0.0);
|
||||
|
||||
vec2 fogPos = vec2(256.0 - 256.0*0.12,1.0);
|
||||
|
||||
//Sky gradient with clouds
|
||||
if (gl_FragCoord.x > (fogPos.x - fogPos.x*0.22) && gl_FragCoord.y > 0.4 && gl_FragCoord.x < 535){
|
||||
// vec2 p = clamp(floor(gl_FragCoord.xy-vec2(18.+257,1.))/256.+tempOffsets/256.,0.0,1.0);
|
||||
vec2 p = clamp(floor(gl_FragCoord.xy-fogPos)/256.+tempOffsets/256.,-0.2,1.2);
|
||||
vec3 viewVector = cartToSphere(p);
|
||||
|
||||
vec3 BackgroundColor = vec3(0.0);
|
||||
|
||||
vec4 VL_Fog = GetVolumetricFog(mat3(gbufferModelView)*viewVector*256., fract(frameCounter/1.6180339887), fract(frameCounter/2.6180339887));
|
||||
|
||||
BackgroundColor += VL_Fog.rgb/5.0;
|
||||
|
||||
gl_FragData[0] = vec4(BackgroundColor, 1.0);
|
||||
|
||||
}
|
||||
|
||||
//Temporally accumulate sky and light values
|
||||
vec3 temp = texelFetch2D(colortex4,ivec2(gl_FragCoord.xy),0).rgb;
|
||||
vec3 curr = gl_FragData[0].rgb*150.;
|
||||
gl_FragData[0].rgb = clamp(mix(temp,curr,0.07),0.0,65000.);
|
||||
|
||||
//Exposure values
|
||||
if (gl_FragCoord.x > 10. && gl_FragCoord.x < 11. && gl_FragCoord.y > 19.+18. && gl_FragCoord.y < 19.+18.+1 )
|
||||
gl_FragData[0] = vec4(exposure,avgBrightness,exposureF,1.0);
|
||||
if (gl_FragCoord.x > 14. && gl_FragCoord.x < 15. && gl_FragCoord.y > 19.+18. && gl_FragCoord.y < 19.+18.+1 )
|
||||
gl_FragData[0] = vec4(rodExposure,0.0,0.0,1.0);
|
||||
|
||||
}
|
||||
104
shaders/dimensions/deferred.vsh
Normal file
104
shaders/dimensions/deferred.vsh
Normal file
@ -0,0 +1,104 @@
|
||||
#include "/lib/settings.glsl"
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
flat varying vec2 tempOffsets;
|
||||
flat varying float exposure;
|
||||
flat varying float avgBrightness;
|
||||
flat varying float rodExposure;
|
||||
flat varying float avgL2;
|
||||
flat varying float centerDepth;
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
uniform sampler2D colortex6;
|
||||
uniform sampler2D depthtex0;
|
||||
|
||||
uniform mat4 gbufferModelViewInverse;
|
||||
uniform vec3 sunPosition;
|
||||
uniform vec2 texelSize;
|
||||
uniform float sunElevation;
|
||||
uniform float eyeAltitude;
|
||||
uniform float near;
|
||||
uniform float far;
|
||||
uniform float frameTime;
|
||||
uniform int frameCounter;
|
||||
uniform float rainStrength;
|
||||
|
||||
// uniform int worldTime;
|
||||
vec3 sunVec = normalize(mat3(gbufferModelViewInverse) *sunPosition);
|
||||
|
||||
#include "/lib/sky_gradient.glsl"
|
||||
#include "/lib/util.glsl"
|
||||
#include "/lib/ROBOBO_sky.glsl"
|
||||
|
||||
float luma(vec3 color) {
|
||||
return dot(color,vec3(0.21, 0.72, 0.07));
|
||||
}
|
||||
|
||||
//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);
|
||||
}
|
||||
float tanh(float x){
|
||||
return (exp(x) - exp(-x))/(exp(x) + exp(-x));
|
||||
}
|
||||
float ld(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near)); // (-depth * (far - near)) = (2.0 * near)/ld - far - near
|
||||
}
|
||||
|
||||
uniform float nightVision;
|
||||
|
||||
|
||||
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;
|
||||
|
||||
//////////////////////////////
|
||||
/// --- EXPOSURE STUFF --- ///
|
||||
//////////////////////////////
|
||||
|
||||
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;
|
||||
float avgB = 0.0;
|
||||
vec2 resScale = vec2(1920.,1080.)/clampedRes;
|
||||
const int maxITexp = 50;
|
||||
float w = 0.0;
|
||||
for (int i = 0; i < maxITexp; i++){
|
||||
vec2 ij = R2_samples((frameCounter%2000)*maxITexp+i);
|
||||
vec2 tc = 0.5 + (ij-0.5) * 0.7;
|
||||
vec3 sp = texture2D(colortex6,tc/16. * resScale+vec2(0.375*resScale.x+4.5*texelSize.x,.0)).rgb;
|
||||
avgExp += log(luma(sp));
|
||||
avgB += log(min(dot(sp,vec3(0.07,0.22,0.71)),8e-2));
|
||||
}
|
||||
|
||||
avgExp = exp(avgExp/maxITexp);
|
||||
avgB = exp(avgB/maxITexp);
|
||||
|
||||
avgBrightness = clamp(mix(avgExp,texelFetch2D(colortex4,ivec2(10,37),0).g,0.95),0.00003051757,65000.0);
|
||||
|
||||
float L = max(avgBrightness,1e-8);
|
||||
float keyVal = 1.03-2.0/(log(L*4000/150.*8./3.0+1.0)/log(10.0)+2.0);
|
||||
float expFunc = 0.5+0.5*tanh(log(L));
|
||||
float targetExposure = 0.18/log2(L*2.5+1.045)*0.62;
|
||||
|
||||
avgL2 = clamp(mix(avgB,texelFetch2D(colortex4,ivec2(10,37),0).b,0.985),0.00003051757,65000.0);
|
||||
float targetrodExposure = max(0.012/log2(avgL2+1.002)-0.1,0.0)*1.2;
|
||||
|
||||
|
||||
exposure = max(targetExposure*EXPOSURE_MULTIPLIER, 0);
|
||||
float currCenterDepth = ld(texture2D(depthtex0, vec2(0.5)).r);
|
||||
centerDepth = mix(sqrt(texelFetch2D(colortex4,ivec2(14,37),0).g/65000.0), currCenterDepth, clamp(DoF_Adaptation_Speed*exp(-0.016/frameTime+1.0)/(6.0+currCenterDepth*far),0.0,1.0));
|
||||
centerDepth = centerDepth * centerDepth * 65000.0;
|
||||
|
||||
rodExposure = targetrodExposure;
|
||||
|
||||
#ifndef AUTO_EXPOSURE
|
||||
exposure = Manual_exposure_value;
|
||||
rodExposure = clamp(log(Manual_exposure_value*2.0+1.0)-0.1,0.0,2.0);
|
||||
#endif
|
||||
}
|
||||
28
shaders/dimensions/deferred1.fsh
Normal file
28
shaders/dimensions/deferred1.fsh
Normal file
@ -0,0 +1,28 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
uniform sampler2D colortex4;
|
||||
uniform sampler2D depthtex1;
|
||||
|
||||
uniform float near;
|
||||
uniform float far;
|
||||
|
||||
|
||||
float linZ(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near));
|
||||
}
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
/* DRAWBUFFERS:4 */
|
||||
vec3 oldTex = texelFetch2D(colortex4, ivec2(gl_FragCoord.xy), 0).xyz;
|
||||
float newTex = texelFetch2D(depthtex1, ivec2(gl_FragCoord.xy*4), 0).x;
|
||||
|
||||
if (newTex < 1.0)
|
||||
gl_FragData[0] = vec4(oldTex, linZ(newTex)*linZ(newTex)*65000.0);
|
||||
else
|
||||
gl_FragData[0] = vec4(oldTex, 2.0);
|
||||
}
|
||||
9
shaders/dimensions/deferred1.vsh
Normal file
9
shaders/dimensions/deferred1.vsh
Normal file
@ -0,0 +1,9 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
uniform vec2 texelSize;
|
||||
#include "/lib/res_params.glsl"
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
vec2 scaleRatio = max(vec2(0.25), vec2(18.+258*2,258.)*texelSize);
|
||||
gl_Position.xy = (gl_Position.xy*0.5+0.5)*clamp(scaleRatio+0.01,0.0,1.0)*2.0-1.0;
|
||||
}
|
||||
139
shaders/dimensions/final.fsh
Normal file
139
shaders/dimensions/final.fsh
Normal file
@ -0,0 +1,139 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
varying vec2 texcoord;
|
||||
|
||||
uniform sampler2D colortex7;
|
||||
// uniform sampler2D noisetex;
|
||||
uniform vec2 texelSize;
|
||||
uniform float viewWidth;
|
||||
uniform float viewHeight;
|
||||
uniform float aspectRatio;
|
||||
uniform float frameTimeCounter;
|
||||
uniform int frameCounter;
|
||||
uniform int isEyeInWater;
|
||||
|
||||
|
||||
#include "/lib/color_transforms.glsl"
|
||||
#include "/lib/color_dither.glsl"
|
||||
#include "/lib/res_params.glsl"
|
||||
|
||||
vec4 SampleTextureCatmullRom(sampler2D tex, vec2 uv, vec2 texSize )
|
||||
{
|
||||
// We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
|
||||
// down the sample location to get the exact center of our "starting" texel. The starting texel will be at
|
||||
// location [1, 1] in the grid, where [0, 0] is the top left corner.
|
||||
vec2 samplePos = uv * texSize;
|
||||
vec2 texPos1 = floor(samplePos - 0.5) + 0.5;
|
||||
|
||||
// Compute the fractional offset from our starting texel to our original sample location, which we'll
|
||||
// feed into the Catmull-Rom spline function to get our filter weights.
|
||||
vec2 f = samplePos - texPos1;
|
||||
|
||||
// Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
|
||||
// These equations are pre-expanded based on our knowledge of where the texels will be located,
|
||||
// which lets us avoid having to evaluate a piece-wise function.
|
||||
vec2 w0 = f * ( -0.5 + f * (1.0 - 0.5*f));
|
||||
vec2 w1 = 1.0 + f * f * (-2.5 + 1.5*f);
|
||||
vec2 w2 = f * ( 0.5 + f * (2.0 - 1.5*f) );
|
||||
vec2 w3 = f * f * (-0.5 + 0.5 * f);
|
||||
|
||||
// Work out weighting factors and sampling offsets that will let us use bilinear filtering to
|
||||
// simultaneously evaluate the middle 2 samples from the 4x4 grid.
|
||||
vec2 w12 = w1 + w2;
|
||||
vec2 offset12 = w2 / (w1 + w2);
|
||||
|
||||
// Compute the final UV coordinates we'll use for sampling the texture
|
||||
vec2 texPos0 = texPos1 - vec2(1.0);
|
||||
vec2 texPos3 = texPos1 + vec2(2.0);
|
||||
vec2 texPos12 = texPos1 + offset12;
|
||||
|
||||
texPos0 *= texelSize;
|
||||
texPos3 *= texelSize;
|
||||
texPos12 *= texelSize;
|
||||
|
||||
vec4 result = vec4(0.0);
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos0.y)) * w0.x * w0.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos0.y)) * w12.x * w0.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos0.y)) * w3.x * w0.y;
|
||||
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos12.y)) * w0.x * w12.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos12.y)) * w12.x * w12.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos12.y)) * w3.x * w12.y;
|
||||
|
||||
result += texture2D(tex, vec2(texPos0.x, texPos3.y)) * w0.x * w3.y;
|
||||
result += texture2D(tex, vec2(texPos12.x, texPos3.y)) * w12.x * w3.y;
|
||||
result += texture2D(tex, vec2(texPos3.x, texPos3.y)) * w3.x * w3.y;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/// thanks stackoverflow https://stackoverflow.com/questions/944713/help-with-pixel-shader-effect-for-brightness-and-contrast#3027595
|
||||
void applyContrast(inout vec3 color, float contrast){
|
||||
color = (color - 0.5) * contrast + 0.5;
|
||||
}
|
||||
|
||||
float lowerCurve(float x) {
|
||||
float y = 16 * x * (0.5 - x) * 0.1;
|
||||
return clamp(y, 0.0, 1.0);
|
||||
}
|
||||
float upperCurve(float x) {
|
||||
float y = 16 * (0.5 - x) * (x - 1.0) * 0.1;
|
||||
return clamp(y, 0.0, 1.0);
|
||||
}
|
||||
void applyLuminanceCurve(inout vec3 color, float darks, float brights){
|
||||
|
||||
// color.r = color.r < 0.5 ? pow(2.0 * color.r, darks) / 2.0 : 1.0 - (pow(2.0 - 2.0 * color.r, brights) / 2.0);
|
||||
// color.g = color.g < 0.5 ? pow(2.0 * color.g, darks) / 2.0 : 1.0 - (pow(2.0 - 2.0 * color.g, brights) / 2.0);
|
||||
// color.b = color.b < 0.5 ? pow(2.0 * color.b, darks) / 2.0 : 1.0 - (pow(2.0 - 2.0 * color.b, brights) / 2.0);
|
||||
|
||||
color.r += darks * lowerCurve(color.r) + brights * upperCurve(color.r);
|
||||
color.g += darks * lowerCurve(color.g) + brights * upperCurve(color.g);
|
||||
color.b += darks * lowerCurve(color.b) + brights * upperCurve(color.b);
|
||||
}
|
||||
|
||||
void applyColorCurve(inout vec3 color, vec4 darks, vec4 brights){
|
||||
|
||||
color.r += (darks.r + darks.a) * lowerCurve(color.r) + (brights.r + brights.a) * upperCurve(color.r);
|
||||
color.g += (darks.g + darks.a) * lowerCurve(color.g) + (brights.g + brights.a) * upperCurve(color.g);
|
||||
color.b += (darks.b + darks.a) * lowerCurve(color.b) + (brights.b + brights.a) * upperCurve(color.b);
|
||||
|
||||
}
|
||||
|
||||
void main() {
|
||||
#ifdef BICUBIC_UPSCALING
|
||||
vec3 col = SampleTextureCatmullRom(colortex7,texcoord,1.0/texelSize).rgb;
|
||||
#else
|
||||
vec3 col = texture2D(colortex7,texcoord).rgb;
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef CONTRAST_ADAPTATIVE_SHARPENING
|
||||
//Weights : 1 in the center, 0.5 middle, 0.25 corners
|
||||
vec3 albedoCurrent1 = texture2D(colortex7, texcoord + vec2(texelSize.x,texelSize.y)/MC_RENDER_QUALITY*0.5).rgb;
|
||||
vec3 albedoCurrent2 = texture2D(colortex7, texcoord + vec2(texelSize.x,-texelSize.y)/MC_RENDER_QUALITY*0.5).rgb;
|
||||
vec3 albedoCurrent3 = texture2D(colortex7, texcoord + vec2(-texelSize.x,-texelSize.y)/MC_RENDER_QUALITY*0.5).rgb;
|
||||
vec3 albedoCurrent4 = texture2D(colortex7, texcoord + vec2(-texelSize.x,texelSize.y)/MC_RENDER_QUALITY*0.5).rgb;
|
||||
|
||||
|
||||
vec3 m1 = -0.5/3.5*col + albedoCurrent1/3.5 + albedoCurrent2/3.5 + albedoCurrent3/3.5 + albedoCurrent4/3.5;
|
||||
vec3 std = abs(col - m1) + abs(albedoCurrent1 - m1) + abs(albedoCurrent2 - m1) +
|
||||
abs(albedoCurrent3 - m1) + abs(albedoCurrent3 - m1) + abs(albedoCurrent4 - m1);
|
||||
float contrast = 1.0 - luma(std)/5.0;
|
||||
col = col*(1.0+(SHARPENING+UPSCALING_SHARPNENING)*contrast)
|
||||
- (SHARPENING+UPSCALING_SHARPNENING)/(1.0-0.5/3.5)*contrast*(m1 - 0.5/3.5*col);
|
||||
#endif
|
||||
|
||||
float lum = luma(col);
|
||||
vec3 diff = col-lum;
|
||||
col = col + diff*(-lum*CROSSTALK + SATURATION);
|
||||
|
||||
vec3 FINAL_COLOR = clamp(int8Dither(col,texcoord),0.0,1.0);
|
||||
|
||||
#ifdef COLOR_CURVE
|
||||
applyColorCurve(FINAL_COLOR, vec4(R_LOWER_CURVE, G_LOWER_CURVE, B_LOWER_CURVE, LOWER_CURVE), vec4(R_UPPER_CURVE, G_UPPER_CURVE, B_UPPER_CURVE, UPPER_CURVE));
|
||||
#endif
|
||||
|
||||
applyContrast(FINAL_COLOR, CONTRAST); // for fun
|
||||
|
||||
gl_FragColor.rgb = FINAL_COLOR ;
|
||||
}
|
||||
18
shaders/dimensions/final.vsh
Normal file
18
shaders/dimensions/final.vsh
Normal file
@ -0,0 +1,18 @@
|
||||
#include "/lib/settings.glsl"
|
||||
|
||||
varying vec2 texcoord;
|
||||
flat varying vec4 exposure;
|
||||
uniform sampler2D colortex4;
|
||||
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
//////////////////////////////VOID MAIN//////////////////////////////
|
||||
|
||||
void main() {
|
||||
|
||||
gl_Position = ftransform();
|
||||
texcoord = gl_MultiTexCoord0.xy;
|
||||
exposure=vec4(texelFetch2D(colortex4,ivec2(10,37),0).r*vec3(FinalR,FinalG,FinalB),texelFetch2D(colortex4,ivec2(10,37),0).r);
|
||||
}
|
||||
Reference in New Issue
Block a user