Backups/Eclipse-Shader
1
0
Fork 0
mirror of https://github.com/Merlin1809/Eclipse-Shader.git synced 2026-10-10 04:53:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
ff4b14fac008cf7fc1d2adf89f1e5a7047d6c4c8
Eclipse-Shader/shaders/dimensions/composite1.fsh
T
Merlin1809 ff4b14fac0 remove handheld reflections on shader grass
2026-04-04 14:04:19 +02:00

1929 lines
64 KiB
GLSL
Raw Blame History

#include "/lib/settings.glsl"
#include "/lib/SSBOs.glsl"
#ifdef CUSTOM_MOON_ROTATION
uniform sampler2D CoronaTex;
#endif
// #if defined END_SHADER || defined NETHER_SHADER
// #undef IS_LPV_ENABLED
// #endifs
#ifdef IS_LPV_ENABLED
#extension GL_ARB_shader_image_load_store: enable
#extension GL_ARB_shading_language_packing: enable
#endif
#include "/lib/util.glsl"
#include "/lib/res_params.glsl"
#define diagonal3_old(m) vec3((m)[0].x, (m)[1].y, m[2].z)
#define projMAD_old(m, v) (diagonal3_old(m) * (v) + (m)[3].xyz)
const bool colortex5MipmapEnabled = true;
uniform float nightVision;
uniform float frameTimeCounter;
uniform float rainStrength;
#define PHOTONICS_LIGHT_PASS
#if defined OVERWORLD_SHADER || (defined END_ISLAND_LIGHT && defined END_SHADER)
const bool shadowHardwareFiltering = true;
uniform sampler2DShadow shadowtex0HW;
#ifdef TRANSLUCENT_COLORED_SHADOWS
uniform sampler2D shadowcolor0;
uniform sampler2DShadow shadowtex1HW;
#endif
#if ShaderSnow > 0
uniform sampler2D snowTexA;
uniform sampler2D snowTexN;
#endif
#if ShaderSnow > 0 || PUDDLE_MODE > 0
uniform sampler2D snowTexR;
#endif
#if defined RIPPLE_PUDDLES && PUDDLE_MODE > 0
#include "/lib/ripples.glsl"
uniform float rippleAmount;
#endif
#include "/lib/stars.glsl"
#ifdef REALMOON
uniform sampler2D moon;
#ifdef MOON_NORMALS
uniform sampler2D moonN;
#endif
#endif
#if SUN_SPECULAR_MULT != 0
#define LIGHTSOURCE_REFLECTION
#endif
#include "/lib/lightning_stuff.glsl"
#endif
#ifdef NETHER_SHADER
const bool colortex4MipmapEnabled = true;
uniform vec3 lightningEffect;
#undef LIGHTSOURCE_REFLECTION
#endif
#ifdef END_SHADER
uniform float worldTimeSmooth;
#ifndef END_ISLAND_LIGHT
uniform vec3 lightningEffect;
#include "/lib/stars.glsl"
#endif
#undef LIGHTSOURCE_REFLECTION
#endif
uniform int hideGUI;
uniform sampler2D noisetex; //noise
uniform sampler2D depthtex0;
uniform sampler2D depthtex1;
uniform sampler2D depthtex2;
#ifdef DISTANT_HORIZONS
uniform sampler2D dhDepthTex;
uniform sampler2D dhDepthTex1;
#define dhVoxyDepthTex dhDepthTex
#define dhVoxyDepthTex1 dhDepthTex1
#endif
#ifdef VOXY
uniform sampler2D vxDepthTexOpaque;
uniform sampler2D vxDepthTexTrans;
#define dhVoxyDepthTex vxDepthTexTrans
#define dhVoxyDepthTex1 vxDepthTexOpaque
#endif
uniform sampler2D colortex0; //clouds
uniform sampler2D colortex1; //albedo(rgb),material(alpha) RGBA16
uniform sampler2D colortex2; //translucents(rgba)
uniform sampler2D colortex3; //filtered shadowmap(VPS)
uniform sampler2D colortex4; //LUT(rgb), quarter res depth(alpha)
uniform sampler2D colortex5; //TAA buffer/previous frame
uniform sampler2D colortex6; //Noise
uniform sampler2D colortex7; //water?
uniform sampler2D colortex8; //Specular
uniform sampler2D colortex9;
uniform sampler2D colortex10;
uniform sampler2D colortex11;
uniform sampler2D colortex12;
uniform sampler2D colortex13;
uniform sampler2D colortex14;
uniform sampler2D colortex15;
uniform sampler2D colortex17;
uniform sampler2D colortex18;
in DATA {
flat vec2 TAA_Offset;
#if !defined END_ISLAND_LIGHT || !defined END_SHADER
flat vec3 WsunVec;
#endif
flat vec3 unsigned_WsunVec;
flat vec3 WmoonVec;
};
uniform float sunElevation;
#if defined IS_LPV_ENABLED || defined PHOTONICS
uniform usampler1D texBlockData;
uniform sampler3D texLpv1;
uniform sampler3D texLpv2;
#endif
uniform mat4 gbufferPreviousModelView;
// uniform vec3 cameraPosition;
uniform vec3 previousCameraPosition;
uniform float updateFadeTime;
// uniform float centerDepthSmooth;
uniform bool firstPersonCamera;
// uniform float far;
uniform float near;
uniform float farPlane;
uniform float dhVoxyFarPlane;
uniform float dhVoxyNearPlane;
uniform vec2 texelSize;
uniform float viewWidth;
uniform float viewHeight;
uniform float aspectRatio;
uniform float eyeAltitude;
uniform int frameCounter;
uniform int isEyeInWater;
uniform ivec2 eyeBrightnessSmooth;
uniform vec3 sunVec;
#define VOXEL_REFLECTIONS_SOLID
#ifdef VOXEL_REFLECTIONS_SOLID
#define VOXEL_REFLECTIONS
#endif
#ifdef PHOTONICS
#define PHOTONICS_INCLUDED
#include "/photonics/photonics.glsl"
#endif
#if defined IS_LPV_ENABLED || defined PHOTONICS && defined PHOTONICS && !defined PH_ENABLE_HANDHELD_LIGHT
uniform int heldItemId;
uniform int heldItemId2;
#endif
uniform float waterEnteredAltitude;
void convertHandDepth(inout float depth) {
float ndcDepth = depth * 2.0 - 1.0;
ndcDepth /= MC_HAND_DEPTH;
depth = ndcDepth * 0.5 + 0.5;
}
float convertHandDepth_2(in float depth, bool hand) {
if(!hand) return depth;
float ndcDepth = depth * 2.0 - 1.0;
ndcDepth /= MC_HAND_DEPTH;
return ndcDepth * 0.5 + 0.5;
}
#include "/lib/projections.glsl"
#include "/lib/DistantHorizons_projections.glsl"
#include "/lib/color_transforms.glsl"
#include "/lib/waterBump.glsl"
#include "/lib/Shadow_Params.glsl"
#include "/lib/Shadows.glsl"
#include "/lib/sky_gradient.glsl"
#ifdef OVERWORLD_SHADER
#include "/lib/scene_controller.glsl"
#define CLOUDSHADOWSONLY
#include "/lib/volumetricClouds.glsl"
#endif
#if defined IS_LPV_ENABLED || defined PHOTONICS && defined PHOTONICS && !defined PH_ENABLE_HANDHELD_LIGHT
uniform vec3 relativeEyePosition;
#include "/lib/hsv.glsl"
#include "/lib/lpv_common.glsl"
#include "/lib/lpv_render.glsl"
#include "/lib/blocks.glsl"
#include "/lib/lpv_blocks.glsl"
#endif
#define DEFERRED_SPECULAR
#define DEFERRED_SSR_QUALITY 30 // [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 200 300 400 500]
#define DEFERRED_BACKGROUND_REFLECTION
#define DEFERRED_ROUGH_REFLECTION
#ifdef DEFERRED_SPECULAR
#endif
#if DEFERRED_SSR_QUALITY > -1
#endif
#ifdef DEFERRED_BACKGROUND_REFLECTION
#endif
#ifdef DEFERRED_ROUGH_REFLECTION
#endif
#ifndef DEFERRED_ROUGH_REFLECTION
#undef DENOISED_REFLECTIONS
#endif
#define MAIN_SHADOW_PASS
#define FULLRESDEPTH
vec2 decodeVec2(float a){
const vec2 constant1 = 65535. / vec2( 256., 65536.);
const float constant2 = 256. / 255.;
return fract( a * constant1 ) * constant2 ;
}
#if defined VIVECRAFT
uniform bool vivecraftIsVR;
uniform vec3 vivecraftRelativeMainHandPos;
uniform vec3 vivecraftRelativeOffHandPos;
uniform mat4 vivecraftRelativeMainHandRot;
uniform mat4 vivecraftRelativeOffHandRot;
#endif
#include "/lib/diffuse_lighting.glsl"
#include "/lib/specular.glsl"
#ifdef END_SHADER
#include "/lib/end_fog.glsl"
#endif
float ld(float dist) {
return (2.0 * near) / (far + near - dist * (far - near));
}
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);
}
float DH_ld(float dist) {
return (2.0 * dhVoxyNearPlane) / (dhVoxyFarPlane + dhVoxyNearPlane - dist * (dhVoxyFarPlane - dhVoxyNearPlane));
}
float DH_inv_ld (float lindepth){
return -((2.0*dhVoxyNearPlane/lindepth)-dhVoxyFarPlane-dhVoxyNearPlane)/(dhVoxyFarPlane-dhVoxyNearPlane);
}
float linearizeDepthFast(const in float depth, const in float near, const in float far) {
return (near * far) / (depth * (near - far) + far);
// return (2.0 * near) / (far + near - depth * (far - near));
}
float invertlinearDepthFast(const in float depth, const in float near, const in float far) {
return ((2.0*near/depth)-far-near)/(far-near);
}
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 interleaved_gradientNoise_temporal(){
// #ifdef TAA
// return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y ) + 1.0/1.6180339887 * frameCounter);
// #else
// return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y ) + 1.0/1.6180339887);
// #endif
vec2 coord = gl_FragCoord.xy;
#ifdef TAA
coord += (frameCounter%40000) * 2.0;
#endif
return fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y ) + 1.0/1.6180339887);
}
float interleaved_gradientNoise(){
vec2 coord = gl_FragCoord.xy;
float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y));
return noise;
}
float R2_dither(){
vec2 coord = gl_FragCoord.xy ;
#ifdef TAA
coord += (frameCounter%40000) * 2.0;
#endif
vec2 alpha = vec2(0.75487765, 0.56984026);
return fract(alpha.x * coord.x + alpha.y * coord.y ) ;
}
float R2_dither2(){
vec2 coord = gl_FragCoord.xy ;
#ifdef TAA
coord += (frameCounter*8)%40000;
#endif
vec2 alpha = vec2(0.75487765, 0.56984026);
return fract(alpha.x * coord.x + alpha.y * coord.y ) ;
}
float blueNoise(){
#ifdef TAA
return fract(texelFetch(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
#else
return fract(texelFetch(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887);
#endif
}
vec4 blueNoise(vec2 coord){
return texelFetch(colortex6, ivec2(coord)%512 , 0) ;
}
vec2 CleanSample(
int samples, float totalSamples, float noise
){
// this will be used to make 1 full rotation of the spiral. the mulitplication is so it does nearly a single rotation, instead of going past where it started
float variance = noise * 0.897;
// for every sample input, it will have variance applied to it.
float variedSamples = float(samples) + variance;
// for every sample, the sample position must change its distance from the origin.
// otherwise, you will just have a circle.
float spiralShape = sqrt(variedSamples / (totalSamples + variance));
float shape = 2.26; // this is very important. 2.26 is very specific
float theta = variedSamples * (PI * shape);
float x = cos(theta) * spiralShape;
float y = sin(theta) * spiralShape;
return vec2(x, y);
}
vec3 viewToWorld(vec3 viewPos) {
vec4 pos;
pos.xyz = viewPos;
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;
}
float swapperlinZ(float depth, float _near, float _far) {
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)
}
// vec2 SSRT_Shadows(vec3 viewPos, bool depthCheck, vec3 lightDir, float noise, bool isSSS, bool hand){
// float handSwitch = hand ? 1.0 : 0.0;
// float steps = 16.0;
// float Shadow = 1.0;
// float SSS = 0.0;
// // isSSS = true;
// float _near = near; float _far = far*4.0;
// if (depthCheck) {
// _near = dhVoxyNearPlane;
// _far = dhVoxyFarPlane;
// }
// vec3 clipPosition = toClipSpace3_DH(viewPos, depthCheck);
// //prevents the ray from going behind the camera
// float rayLength = ((viewPos.z + lightDir.z * _far*sqrt(3.)) > -_near) ?
// (-_near -viewPos.z) / lightDir.z : _far*sqrt(3.);
// vec3 direction = toClipSpace3_DH(viewPos + lightDir*rayLength, depthCheck) - clipPosition; //convert to clip space
// direction.xyz = direction.xyz / max(abs(direction.x)/0.0005, abs(direction.y)/0.0005); //fixed step size
// // float Stepmult = depthCheck ? (isSSS ? 1.0 : 3.0) : (isSSS ? 1.0 : 3.0);
// float Stepmult = isSSS ? 3.0 : 6.0;
// vec3 rayDir = direction * Stepmult * vec3(RENDER_SCALE,1.0);
// vec3 screenPos = clipPosition * vec3(RENDER_SCALE,1.0) + rayDir*noise - (isSSS ? rayDir*0.9 : vec3(0.0));
// float minZ = screenPos.z - 1.0;
// float maxZ = screenPos.z;
// // as distance increases, add larger values to the SSS value. this scales the "density" with distance, as far things should appear denser.
// float dist = 1.0 + length(mat3(gbufferModelViewInverse) * viewPos) / 500.0;
// for (int i = 0; i < int(steps); i++) {
// float samplePos = convertHandDepth_2(texture(depthtex1, screenPos.xy).x, hand);
// #ifdef DISTANT_HORIZONS
// if(depthCheck) samplePos = texture(dhDepthTex1, screenPos.xy).x;
// #endif
// if(samplePos < screenPos.z && (samplePos <= max(minZ,maxZ) && samplePos >= min(minZ,maxZ))){
// vec2 linearZ = vec2(swapperlinZ(screenPos.z, _near, _far), swapperlinZ(samplePos, _near, _far));
// float calcthreshold = abs(linearZ.x - linearZ.y) / linearZ.x;
// if (calcthreshold < 0.035) Shadow = 0.0;
// SSS += dist;
// }
// minZ = maxZ - (isSSS ? 1.0 : 0.0001) / swapperlinZ(samplePos, _near, _far);
// maxZ += rayDir.z;
// screenPos += rayDir;
// }
// return vec2(Shadow, SSS / steps);
// }
vec2 SSRT_Shadows(vec3 viewPos, bool depthCheck, vec3 lightDir, float noise, bool isSSS, bool hand){
// return 1.0;
float shadows = 1.0;
float samples = 16.0;
float SSS = 0.0;
float _near = near; float _far = far*4.0;
#if defined DISTANT_HORIZONS || defined VOXY
if (depthCheck) {
_near = dhVoxyNearPlane;
_far = dhVoxyFarPlane;
}
#endif
vec3 position = toClipSpace3_DH(viewPos, depthCheck) ;
//prevents the ray from going behind the camera
float rayLength = ((viewPos.z + lightDir.z * _far * sqrt(3.)) > -_near) ? (-_near - viewPos.z) / lightDir.z : _far * sqrt(3.);
vec3 direction = toClipSpace3_DH(viewPos + lightDir*rayLength, depthCheck) - position;
direction.xyz = direction.xyz / max(max(abs(direction.x)/0.0005, abs(direction.y)/0.0005),400.0); //fixed step size
direction *= 6.0;
position.xy *= RENDER_SCALE;
direction.xy *= RENDER_SCALE;
vec3 newPos = position + direction*noise;
// literally shadow bias to fight shadow acne due to precision problems when comparing sampled depth and marched position
newPos += direction*0.3;
float SSSdistanceScale = 1.0 / (1.0 + swapperlinZ(position.z, _near, _far)*32.0);
float distanceScale2 = 1.0 + length(mat3(gbufferModelViewInverse) * viewPos) / 150.0;
for (int i = 0; i < int(samples); i++) {
if (newPos.x < 0.0 || newPos.y < 0.0 || newPos.x > 1.0 || newPos.y > 1.0) break;
float sampleDepth = 0.0;
#if defined DISTANT_HORIZONS || defined VOXY
if(depthCheck) {
sampleDepth = texelFetch(dhVoxyDepthTex1, ivec2(newPos.xy/texelSize),0).x;
} else
#endif
{
if(hand) {
sampleDepth = texelFetch(depthtex1, ivec2(newPos.xy/texelSize),0).x;
convertHandDepth(sampleDepth);
} else {
sampleDepth = texelFetch(depthtex2, ivec2(newPos.xy/texelSize),0).x;
}
}
if(sampleDepth < newPos.z){
float linearCurrentPos = swapperlinZ(newPos.z, _near, _far);
float linearSampledDepth = swapperlinZ(sampleDepth, _near, _far);
float dist = abs(linearSampledDepth - linearCurrentPos) / linearCurrentPos;
// if (dist < 0.035){
if (dist < 0.035/(1.0+linearCurrentPos)) shadows = 0.0;
// if (dist < 0.3/(1.0+linearCurrentPos)) SSS += distanceScale2;
if (dist < SSSdistanceScale) SSS += distanceScale2;
}
newPos += direction;
}
return vec2(shadows, SSS / samples );
}
#if defined FLASHLIGHT_SHADOWS && defined FLASHLIGHT
float SSRT_FlashLight_Shadows(vec3 viewPos, bool depthCheck, vec3 lightDir, float noise, vec3 normals, bool hand){
if(hand || !firstPersonCamera) return 1.0;
vec3 WlightDir = normalize((gbufferModelViewInverse*vec4(lightDir, 1.0)).xyz);
float NdotL = dot(normals, WlightDir);
NdotL = smoothstep(0.0, 0.2, abs(NdotL));
float shadows = 1.0;
float samples = 16.0;
float _near = near; float _far = far*4.0;
if (depthCheck) {
_near = dhVoxyNearPlane;
_far = dhVoxyFarPlane;
}
vec3 position = toClipSpace3_DH(viewPos, depthCheck) ;
//prevents the ray from going behind the camera
float rayLength = ((viewPos.z + lightDir.z * _far * sqrt(3.)) > -_near) ? (-_near - viewPos.z) / lightDir.z : _far * sqrt(3.);
vec3 direction = toClipSpace3_DH(viewPos + lightDir*rayLength, depthCheck) - position;
direction.xyz = direction.xyz / max(max(abs(direction.x)/0.0005, abs(direction.y)/0.0005),400.0); //fixed step size
direction *= 6.0;
position.xy *= RENDER_SCALE;
direction.xy *= RENDER_SCALE;
vec3 newPos = position + direction*noise;
// literally shadow bias to fight shadow acne due to precision problems when comparing sampled depth and marched position
//newPos += direction*0.3;
for (int i = 0; i < int(samples); i++) {
float samplePos;
#if defined DISTANT_HORIZONS || defined VOXY
if(depthCheck) {
samplePos = texelFetch(dhVoxyDepthTex1, ivec2(newPos.xy/texelSize),0).x;
} else
#endif
{
samplePos = texelFetch(depthtex2, ivec2(newPos.xy/texelSize),0).x,hand;
}
if(samplePos < newPos.z && samplePos > 0.0){// && (samplePos <= max(minZ,maxZ) && samplePos >= min(minZ,maxZ))){
shadows = 0.0;
break;
}
newPos += direction;
}
return clamp(shadows*NdotL, 1.0-FLASHLIGHT_SHADOWS_STRENGTH, 1.0);
}
#endif
void Emission(
inout vec3 Lighting,
vec3 Albedo,
float Emission
){
if( Emission < 254.5/255.0) Lighting = mix(Lighting, Albedo * 5.0 * Emissive_Brightness, pow(Emission, Emissive_Curve));
}
#include "/lib/indirect_lighting_effects.glsl"
#include "/lib/PhotonGTAO.glsl"
void doEdgeAwareBlur(
sampler2D tex1, sampler2D tex2, sampler2D depth,
float referenceDepth, bool hand,
inout vec2 ambientEffects, inout vec3 filteredShadow
){
float threshold = clamp(referenceDepth*referenceDepth*0.5,0.0001,0.005);
vec3 shadow_RESULT = vec3(0.0);
vec2 ssao_RESULT = vec2(0.0);
float edgeSum = 0.0;
vec2 coord = gl_FragCoord.xy - 1.5;
ivec2 UV = ivec2(coord);
ivec2 UV_NOISE = ivec2(gl_FragCoord.xy*texelSize + 1);
ivec2 OFFSET[4] = ivec2[](
ivec2(-1,-1),
ivec2( 1, 1),
ivec2(-1, 1),
ivec2( 1,-1)
);
for(int i = 0; i < 4; i++) {
#if defined DISTANT_HORIZONS || defined VOXY
float offsetDepth = sqrt(texelFetch(depth, UV + OFFSET[i] + UV_NOISE,0).z);
#else
float offsetDepth = ld(convertHandDepth_2(texelFetch(depth, UV + OFFSET[i] + UV_NOISE, 0).r,hand));
#endif
float edgeDiff = abs(offsetDepth - referenceDepth) < threshold ? 1.0 : 1e-7;
#ifdef Variable_Penumbra_Shadows
shadow_RESULT += texelFetch(tex1, UV + OFFSET[i] + UV_NOISE, 0).rgb*edgeDiff;
#endif
#if indirect_effect == SSAO_FILTERED
ssao_RESULT += texelFetch(tex2, UV + OFFSET[i] + UV_NOISE, 0).rg*edgeDiff;
#endif
edgeSum += edgeDiff;
}
// sample without an offset with texture filtering to get a slightly blurred sample. make sure to average without skewing the rest of the average.
filteredShadow = shadow_RESULT/edgeSum * 0.8 + 0.2 * texture(tex1, texelSize*gl_FragCoord.xy).rgb;
#if indirect_effect == SSAO_FILTERED
ambientEffects = ssao_RESULT/edgeSum * 0.8 + 0.2 * texture(tex2, texelSize*gl_FragCoord.xy).rg;
#endif
#if indirect_effect == SSAO_HQ
ambientEffects = texture(tex2, texelSize*gl_FragCoord.xy).rg;
#endif
}
vec4 BilateralUpscale_VLFOG(sampler2D tex, sampler2D depth, float referenceDepth){
vec4 colorSum = vec4(0.0);
float edgeSum = 0.0;
#if defined DISTANT_HORIZONS || defined VOXY
float threshold = referenceDepth * mix(0.5, 0.05, min(max(0.1 - referenceDepth,0)/0.1,1));
#else
float threshold = referenceDepth * 0.05;
#endif
#ifdef HQ_CLOUD_UPSAMPLE
const int samples = 9;
#else
const int samples = 5;
#endif
vec2 coord = gl_FragCoord.xy - 1.5;
vec2 UV = coord;
const ivec2 SCALE = ivec2(1.0/VL_RENDER_SCALE);
ivec2 UV_DEPTH = ivec2(UV*VL_RENDER_SCALE)*SCALE;
ivec2 UV_COLOR = ivec2(UV*VL_RENDER_SCALE);
ivec2 UV_NOISE = ivec2(gl_FragCoord.xy*texelSize + 1);
ivec2 OFFSET[9] = ivec2[](
ivec2(-1,-1),
ivec2( 1, 1),
ivec2(-1, 1),
ivec2( 1,-1),
ivec2( 0, 0),
ivec2( 0, 1),
ivec2( 0,-1),
ivec2( 1, 0),
ivec2(-1, 0)
);
for(int i = 0; i < samples; i++) {
#if defined DISTANT_HORIZONS || defined VOXY
float offsetDepth = sqrt(texelFetch(depth, UV_DEPTH + (OFFSET[i] + UV_NOISE) * SCALE,0).a);
#else
float offsetDepth = ld(texelFetch(depth, UV_DEPTH + (OFFSET[i] + UV_NOISE) * SCALE, 0).r);
#endif
float edgeDiff = abs(offsetDepth - referenceDepth) < threshold ? 1.0 : 0.0;
vec4 offsetColor = texelFetch(tex, UV_COLOR + OFFSET[i] + UV_NOISE, 0).rgba;
colorSum += offsetColor*edgeDiff;
edgeSum += edgeDiff;
}
if (edgeSum == 0.0) return vec4(0.0);
return colorSum/edgeSum;
}
#if defined OVERWORLD_SHADER || (defined END_ISLAND_LIGHT && defined END_SHADER)
vec3 ComputeShadowMap_COLOR(in vec3 projectedShadowPosition, float distortFactor, float noise, float shadowBlockerDepth, float NdotL, float maxDistFade, vec3 directLightColor, inout float FUNNYSHADOW, inout vec3 tintedSunlight, bool isSSS ,inout float shadowDebug){
// if(maxDistFade <= 0.0) return 1.0;
float backface = NdotL <= 0.0 ? 1.0 : 0.0;
vec3 shadowColor = vec3(0.0);
vec3 translucentTint = vec3(0.0);
#ifdef BASIC_SHADOW_FILTER
int samples = SHADOW_FILTER_SAMPLE_COUNT;
float rdMul = (shadowBlockerDepth*distortFactor*d0k) * 0.3;
for(int i = 0; i < samples; i++){
vec2 offsetS = CleanSample(i, samples - 1, noise) * rdMul;
projectedShadowPosition.xy += offsetS;
#else
int samples = 1;
#endif
#ifdef TRANSLUCENT_COLORED_SHADOWS
float opaqueShadow = texture(shadowtex0HW, projectedShadowPosition).x;
float opaqueShadowT = texture(shadowtex1HW, projectedShadowPosition).x;
vec4 translucentShadow = texture(shadowcolor0, projectedShadowPosition.xy);
float shadowAlpha = pow(1.0-pow(1.0-translucentShadow.a,2.0),5.0);
translucentShadow.rgb = normalize(translucentShadow.rgb*translucentShadow.rgb + 0.0001) * (1.0-shadowAlpha);
// translucentTint += mix(translucentShadow.rgb * mix(opaqueShadowT, 1.0, backface), vec3(1.0), max(opaqueShadow, backface * (shadowAlpha < 1.0 ? 0.0 : 1.0)));
// shadowColor += directLightColor * mix(translucentShadow.rgb * opaqueShadowT, vec3(1.0), opaqueShadow);
shadowColor += mix(translucentShadow.rgb * opaqueShadowT, vec3(1.0), opaqueShadow);
translucentTint += mix(translucentShadow.rgb, vec3(1.0), max(opaqueShadow, backface * (shadowAlpha < 1.0 ? 0.0 : 1.0)));
FUNNYSHADOW += ((1.0-shadowAlpha) * opaqueShadowT)/samples;
#else
// shadowColor += directLightColor * texture(shadowtex0HW, projectedShadowPosition).x;
shadowColor += vec3(1.0) * texture(shadowtex0HW, projectedShadowPosition).x;
#endif
#ifdef BASIC_SHADOW_FILTER
}
#endif
#if DEBUG_VIEW == debug_SHADOWMAP
shadowDebug = texture(shadowtex0HW, projectedShadowPosition).x;
#endif
// #ifdef TRANSLUCENT_COLORED_SHADOWS
// // directLightColor *= mix(vec3(1.0), translucentTint.rgb / samples, maxDistFade);
// tintedSunlight *= translucentTint.rgb / samples;
// #endif
return shadowColor.rgb / samples;
// return mix(directLightColor, shadowColor.rgb / samples, maxDistFade);
}
#endif
float CustomPhase(float LightPos){
float PhaseCurve = 1.0 - LightPos;
float Final = exp2(sqrt(PhaseCurve) * -25.0);
Final += exp(PhaseCurve * -10.0)*0.5;
return Final;
}
vec3 SubsurfaceScattering_sun(vec3 albedo, float Scattering, float Density, float lightPos, float SS_shadows, float distantSSS, bool hand){
// Density = 1.0;
Scattering *= sss_density_multiplier;
float density = 1e-6 + Density * 1.5;
float scatterDepth = max(1.0 - Scattering/density, 0.0);
scatterDepth *= exp(-7.0 * (1.0-scatterDepth));
SS_shadows = exp(-7.0 * SS_shadows)*0.7;
scatterDepth = scatterDepth * mix(SS_shadows, 1.0, (1.0-SCREENSPACE_DIRECT_SSS_BLENDING) * scatterDepth * distantSSS);
if(hand) scatterDepth = max(1.0 - Scattering*10.0, 0.0) * SS_shadows;
vec3 absorbColor = exp(max(luma(albedo) - albedo*vec3(1.0,1.1,1.2), 0.0) * -20.0 * sss_absorbance_multiplier);
vec3 scatter = scatterDepth * mix(absorbColor, vec3(1.0), scatterDepth);
#if SSS_TYPE == 3
scatter *= pow(Density, LabSSS_Curve);
#else
if(Density < 0.01) scatter = vec3(0.0);
#endif
scatter *= 1.0 + CustomPhase(lightPos)*20.0;
return scatter;
}
vec3 SubsurfaceScattering_sky(vec3 albedo, float Scattering, float Density){
// Density = 1.0;
float scatterDepth = pow(Scattering,3.5);
scatterDepth = 1.0-pow(1.0-scatterDepth,5.0);
vec3 absorbColor = exp(max(luma(albedo) - albedo*vec3(1.0,1.1,1.2), 0.0) * -20.0 * sss_absorbance_multiplier);
vec3 scatter = scatterDepth * mix(absorbColor, vec3(1.0), scatterDepth) * pow(Density, LabSSS_Curve);
// scatter *= 1.0 + exp(-7.0*(-playerPosNormalized.y*0.5+0.5));
return scatter;
}
uniform float wetnessAmount;
uniform float snowAmount;
uniform float wetness;
#ifdef OVERWORLD_SHADER
void applyPuddles(
in vec3 worldPos, in vec3 flatNormals, in float lightmap, in bool eyeInWater, inout vec3 albedo, inout vec3 normals, inout float roughness, inout float f0, in bool isShaderGrass, in float porosity
){
/* PUDDLE_MODE
0 = OFF, NO WETNESS
1 = puddles + full wetness
2 = only puddles
3 = only full wetness
*/
float effectStrength = smoothstep(0.85, 1.0, lightmap);
//float effectStrength = smoothstep(0.85, 1.0, max(lightmap.y-step(1.0,lightmap.x), 0.0));
vec2 snowCoords = worldPos.xz*0.1;
#if ShaderSnow > 0 || PUDDLE_MODE > 0
float snowR = texture(snowTexR, snowCoords).g;
#endif
#if PUDDLE_MODE > 0
if (wetnessAmount > 0.01) {
float halfWet = min(wetnessAmount,1.0);
float fullWet = clamp(wetnessAmount - 2.0,0.0,1.0);
vec2 driprate = vec2(0.0,frameTimeCounter)*0.05;
vec2 UV = mix(worldPos.xz, worldPos.xy*vec2(2.0, 0.5)+driprate, abs(flatNormals.z));
UV = mix(UV, worldPos.zy*vec2(2.0, 0.5)+driprate, abs(flatNormals.x));
#ifdef SHADER_GRASS
if(isShaderGrass) UV = worldPos.xz;
#endif
float noise = texture(noisetex, UV * 0.02).b;
#if PUDDLE_MODE == 1
float puddles = max(halfWet - noise,0.0);
puddles = clamp(halfWet - exp(-25.0 * puddles*puddles*puddles*puddles*puddles*Puddle_Size),0.0,1.0);
float wetnessStages = max(puddles, fullWet) * lightmap;
fullWet = fullWet + porosity * fullWet;
float wetnessDarkening = max(puddles, fullWet*0.5) * lightmap;
#endif
#if PUDDLE_MODE == 2
float puddles = max(halfWet - noise,0.0);
puddles = clamp(halfWet - exp(-25.0 * puddles*puddles*puddles*puddles*puddles*Puddle_Size),0.0,1.0);
float wetnessStages = puddles * lightmap;
float wetnessDarkening = min(wetnessStages + porosity * fullWet, 1.0);
#endif
#if PUDDLE_MODE == 3
float puddles = 0.0;
float wetnessStages = fullWet * lightmap;
fullWet = fullWet + porosity * fullWet;
float wetnessDarkening = fullWet*0.5*lightmap;
#endif
wetnessStages *= effectStrength;
#ifdef SHADER_GRASS
if(!isShaderGrass)
#endif
{
#ifdef RIPPLE_PUDDLES
float viewDist = length(worldPos - cameraPosition);
vec3 rippleNormal = flatNormals;
if(viewDist < 35 && rainStrength > 0.0 && rippleAmount > 0.01 && snowAmount < 0.01) {
vec3 ripple = ripples(1.2 * worldPos.xz);
ripple = ripple.xzy;
rippleNormal = mix(flatNormals, ripple, smoothstep(35., 10., viewDist) * rainStrength * smoothstep(0.0, 1.0, rippleAmount));
}
normals = mix(normals, rippleNormal, wetnessStages * clamp(flatNormals.y,0.0,1.0));
#else
normals = mix(normals, flatNormals, wetnessStages * clamp(flatNormals.y,0.0,1.0));
#endif
}
roughness = mix(roughness, 0.5*(1.0+snowR), wetnessStages * Puddle_Reflection_Sharpness);
if(f0 < 229.5/255.0 ) albedo = pow(albedo * (1.0 - 0.08*wetnessDarkening), vec3(1.0 + 0.7*wetnessDarkening));
}
#endif
#if ShaderSnow > 0
if (snowAmount > 0.01) {
float minClamp = 0.72;
#ifdef SHADER_GRASS
if(isShaderGrass) minClamp = 0.5;
#endif
float upnormal = clamp(-(normals / dot(abs(normals),vec3(1.0))).y+clamp(normals.y,minClamp,1.0),0.,1.);
float snow = clamp(1.0 - 2.*upnormal - (1.0-effectStrength),0.0,1.0);
if(f0 > 229.5/255.0 || eyeInWater) snow = 0.0;
vec3 snowA = pow(texture(snowTexA, snowCoords).rgb, vec3(2.0/(ShaderSnowStrength-0.1)));
#ifdef SHADER_GRASS
if(!isShaderGrass)
#endif
{
snowA = mix(snowA, vec3(0.8, 0.75, 0.85), 1.0-abs(flatNormals.y));
}
vec3 snowN = 2.*texture(snowTexN, snowCoords).rgb - 1.;
snowN = snowN.xzy;
float omSA = 1.-snowAmount;
float textureMult = smoothstep(0.1+0.5*omSA, 0.5+0.9*omSA, length(snowA)*snow*snowAmount);
normals = mix(normals, normalize(snowN), textureMult);
roughness = mix(roughness, snowR, sqrt(textureMult));
albedo = mix(albedo, 2.5*snowA, textureMult);
// let it melt
roughness = mix(roughness, 0.75*snowR, smoothstep(0.15, 0.7, snowAmount)*smoothstep(1.0, 0.8, snowAmount)*effectStrength);
}
#endif
}
#endif
//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));
}
vec2 encodeNormal(vec3 n){
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 encn;
}
void main() {
#if defined DEFERRED_SPECULAR && defined DENOISED_REFLECTIONS
gl_FragData[1] = vec4(0.0);
gl_FragData[2] = vec4(0.0);
gl_FragData[3] = vec4(0.0);
#endif
vec3 DEBUG = vec3(1.0);
////// --------------- SETUP STUFF --------------- //////
vec2 texcoord = (gl_FragCoord.xy*texelSize);
float noise_2 = R2_dither();
vec2 bnoise = blueNoise(gl_FragCoord.xy).rg;
float ig_noise = interleaved_gradientNoise_temporal();
#ifdef TAA
int seed = frameCounter*8%40000;
#else
int seed = 600;
#endif
vec2 r2_sequence = R2_samples(seed).xy;
vec2 BN = fract(r2_sequence + bnoise);
float noise = BN.y;
// float z0 = texture(depthtex0,texcoord).x;
// float z = texture(depthtex1,texcoord).x;
float z0 = texelFetch(depthtex0, ivec2(gl_FragCoord.xy), 0).x;
float z = texelFetch(depthtex1, ivec2(gl_FragCoord.xy), 0).x;
float swappedDepth = z;
#if defined DISTANT_HORIZONS || defined VOXY
bool isDHrange = z >= 1.0;
float DH_mixedLinearZ = sqrt(texelFetch(colortex9,ivec2(gl_FragCoord.xy), 0).z);
float DH_depth0 = 0.0;
if(isDHrange) DH_depth0 = texelFetch(dhVoxyDepthTex,ivec2(gl_FragCoord.xy), 0).x;
float DH_depth1 = texelFetch(dhVoxyDepthTex1,ivec2(gl_FragCoord.xy), 0).x;
float depthOpaque = z;
float depthOpaqueL = linearizeDepthFast(depthOpaque, near, farPlane);
float dhDepthOpaque = DH_depth1;
float dhDepthOpaqueL = linearizeDepthFast(dhDepthOpaque, dhVoxyNearPlane, dhVoxyFarPlane);
if (isDHrange || (dhDepthOpaqueL < depthOpaqueL && dhDepthOpaque > 0.0)){
depthOpaque = dhDepthOpaque;
depthOpaqueL = dhDepthOpaqueL;
}
swappedDepth = depthOpaque;
#else
const bool isDHrange = false;
const float DH_depth0 = 0.0;
const float DH_depth1 = 0.0;
#endif
bool eyeInWater = isEyeInWater == 1;
bool isSky = swappedDepth >= 1.0;
////// --------------- UNPACK OPAQUE GBUFFERS --------------- //////
vec4 data = texelFetch(colortex1, ivec2(gl_FragCoord.xy), 0);
vec3 skyboxCol = data.rgb;
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));
vec3 normal = decode(dataUnpacked0.yw);
vec2 lightmap = dataUnpacked1.yz;
// special curve to give more precision on high/low values of the gradient. this curve will be inverted after sampling and decoding.
// lightmap = 1.0-pow(1.0-pow(lightmap,vec2(2)),vec2(2));
// small offset to hide flickering from precision error in the encoding/decoding on values close to 1.0 or 0.0
lightmap.xy = min(max(lightmap.xy - 0.05,0.0)*1.06,1.0);
#if MC_VERSION < 12109
#if !defined OVERWORLD_SHADER
lightmap.y = 1.0;
#endif
#else
#if !defined OVERWORLD_SHADER && !defined END_SHADER
lightmap.y = 1.0;
#endif
#endif
////// --------------- UNPACK MISC --------------- //////
vec4 SpecularData = texelFetch(colortex8, ivec2(gl_FragCoord.xy), 0);
vec4 specdataUnpacked0 = vec4(decodeVec2(SpecularData.x),decodeVec2(SpecularData.y));
vec4 specdataUnpacked1 = vec4(decodeVec2(SpecularData.z),decodeVec2(SpecularData.w));
vec4 SpecularTex = vec4(specdataUnpacked0.xz, specdataUnpacked1.xz);
vec3 FlatNormals = normalize(vec3(specdataUnpacked0.yw,specdataUnpacked1.y) * 2.0 - 1.0);
float vanilla_AO = min(max(specdataUnpacked1.w-0.005,0.0)/0.995,1.0);
float LabSSS = clamp((-65.0 + SpecularTex.z * 255.0) / 190.0 ,0.0,1.0);
float labPorosity = SpecularTex.z * 255.0 <= 64.5 ? clamp(SpecularTex.z * 255.0, 0.0, 64.5)/64.5 : 0.0;
vec3 slopednormal = normal;
if(isDHrange){
FlatNormals = normal;
}
////// --------------- MASKS/BOOLEANS --------------- //////
// 1.0-0.8 ???
// 0.75 = hand mask
// 0.60 = grass mask
// 0.55 = leaf mask (for ssao-sss)
// 0.50 = lightning bolt mask
// 0.45 = entity mask
float opaqueMasks = dataUnpacked1.w;
// 1.0 = water mask
// 0.9 = entity mask
// 0.8 = reflective entities
// 0.7 = reflective blocks
float translucentMasks = texelFetch(colortex7, ivec2(gl_FragCoord.xy), 0).a;
bool isWater = translucentMasks > 0.99;
// bool isReflectiveEntity = abs(translucentMasks - 0.8) < 0.01;
// bool isReflective = abs(translucentMasks - 0.7) < 0.01 || isWater || isReflectiveEntity;
// bool isEntity = abs(translucentMasks - 0.9) < 0.01 || isReflectiveEntity;
// bool lightningBolt = abs(opaqueMasks-0.5) <0.01;
// bool isLeaf = abs(opaqueMasks-0.55) <0.01;
bool entities = abs(opaqueMasks-0.45) < 0.01;
bool isGrass = abs(opaqueMasks-0.60) < 0.01;
bool hand = abs(opaqueMasks-0.75) < 0.01 && z < 1.0;
#ifdef SHADER_GRASS
bool isShaderGrass = abs(opaqueMasks-0.80) < 0.01;
#else
const bool isShaderGrass = false;
#endif
#if defined POM_OFFSET_SHADOW_BIAS
float POM_DEEPNESS = opaqueMasks < 0.44 ? min(max(opaqueMasks/0.44,0.0)*3.0,1.0) : 0.0;
#else
const float POM_DEEPNESS = 0.0;
#endif
// bool handwater = abs(translucentMasks-0.3) < 0.01 ;
// bool blocklights = abs(opaqueMasks-0.8) <0.01;
if(hand){
convertHandDepth(z);
convertHandDepth(z0);
}
#if defined DISTANT_HORIZONS || defined VOXY
vec3 viewPos = toScreenSpace_DH(texcoord/RENDER_SCALE - TAA_Offset*texelSize*0.5, z, DH_depth1);
#else
vec3 viewPos = toScreenSpace(vec3(texcoord/RENDER_SCALE - TAA_Offset*texelSize*0.5, z));
#endif
vec3 feetPlayerPos = mat3(gbufferModelViewInverse) * viewPos;
vec3 feetPlayerPos_normalized = normalize(feetPlayerPos);
vec3 worldPos = feetPlayerPos + cameraPosition;
#ifdef POM
#ifdef Horrible_slope_normals
vec3 ApproximatedFlatNormal = normalize(cross(dFdx(feetPlayerPos), dFdy(feetPlayerPos))); // 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
#if defined END_SHADER && defined END_ISLAND_LIGHT
vec3 WsunVec = normalize(END_LIGHT_POS-worldPos);
#endif
////// --------------- COLORS --------------- //////
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 = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B);
vec3 scatterCoef = Dirt_Amount * vec3(Dirt_Scatter_R, Dirt_Scatter_G, Dirt_Scatter_B) / 3.14;
vec3 Absorbtion = vec3(1.0);
vec3 AmbientLightColor = vec3(0.0);
vec3 MinimumLightColor = vec3(1.0);
vec3 Indirect_lighting = vec3(0.0);
vec3 Indirect_SSS = vec3(0.0);
vec2 SSAO_SSS = vec2(1.0);
vec3 DirectLightColor = vec3(0.0);
vec3 Direct_lighting = vec3(0.0);
vec3 Direct_SSS = vec3(0.0);
float cloudShadow = 1.0;
float Shadows = 1.0;
vec3 shadowColor = vec3(1.0);
vec3 SSSColor = vec3(0.0);
#if defined END_ISLAND_LIGHT && defined END_SHADER
vec3 filteredShadow = vec3(Min_Shadow_Filter_Radius_END,1.0,0.0);
#else
vec3 filteredShadow = vec3(Min_Shadow_Filter_Radius,1.0,0.0);
#endif
float NdotL = 1.0;
float lightLeakFix = clamp(pow(eyeBrightnessSmooth.y/240. + lightmap.y,2.0) ,0.0,1.0);
#ifdef OVERWORLD_SHADER
DirectLightColor = lightSourceColorSSBO / 2400.0;
AmbientLightColor = averageSkyCol_CloudsSSBO / 900.0;
#if defined CUSTOM_MOON_ROTATION && LIGHTNING_SHADOWS > 0
#if LIGHTNING_SHADOWS < 2
if (lightningBoltPosition.w > 0.0 && sunElevation < 0.0)
#else
if (lightningBoltPosition.w > 0.0)
#endif
{
vec3 lightningColor = vec3(2.0, 4.5, 6.6) * lightningFlash;
DirectLightColor += 0.5 * lightningColor * smoothstep(300.0, 0.0, length(feetPlayerPos-lightningBoltPosition.xyz));
}
#endif
#ifdef USE_CUSTOM_DIFFUSE_LIGHTING_COLORS
DirectLightColor = luma(DirectLightColor) * vec3(DIRECTLIGHT_DIFFUSE_R,DIRECTLIGHT_DIFFUSE_G,DIRECTLIGHT_DIFFUSE_B);
AmbientLightColor = luma(AmbientLightColor) * vec3(INDIRECTLIGHT_DIFFUSE_R,INDIRECTLIGHT_DIFFUSE_G,INDIRECTLIGHT_DIFFUSE_B);
#endif
shadowColor = DirectLightColor;
//bool inShadowmapBounds = false;
#endif
#if defined END_SHADER && defined END_ISLAND_LIGHT
DirectLightColor = vec3(VORTEX_LIGHT_COL_R,VORTEX_LIGHT_COL_G,VORTEX_LIGHT_COL_B);
shadowColor = DirectLightColor;
#endif
////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////// UNDER WATER SHADING ////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
if ((isEyeInWater == 0 && isWater) || (eyeInWater && !isWater)){
feetPlayerPos += gbufferModelViewInverse[3].xyz;
worldPos = feetPlayerPos + cameraPosition;
#if defined DISTANT_HORIZONS || defined VOXY
vec3 playerPos0 = mat3(gbufferModelViewInverse) * toScreenSpace_DH(texcoord/RENDER_SCALE-TAA_Offset*texelSize*0.5, z0, DH_depth0) + gbufferModelViewInverse[3].xyz;
#else
vec3 playerPos0 = mat3(gbufferModelViewInverse) * toScreenSpace(vec3(texcoord/RENDER_SCALE-TAA_Offset*texelSize*0.5,z0)) + gbufferModelViewInverse[3].xyz;
#endif
float Vdiff = distance(feetPlayerPos, playerPos0);
float estimatedDepth = Vdiff * abs(feetPlayerPos_normalized.y);// assuming water plane
// force the absorbance to start way closer to the water surface in low light areas, so the water is visible in caves and such.
#if MINIMUM_WATER_ABSORBANCE > -1
float minimumAbsorbance = MINIMUM_WATER_ABSORBANCE*0.1;
#else
float minimumAbsorbance = (1.0 - lightLeakFix);
#endif
Absorbtion = exp(-totEpsilon * max(Vdiff, minimumAbsorbance));
if(!isSky) {
// things to note about sunlight in water
// sunlight gets absorbed by water on the way down to the floor, and on the way back up to your eye. im gonna ingore the latter part lol
// based on the angle of the sun, sunlight will travel through more/less water to reach the same spot. scale absorbtion depth accordingly
vec3 sunlightAbsorbtion = exp(-totEpsilon * (estimatedDepth/abs(WsunVec.y)));
float percievedWaterDepth = estimatedDepth;
if (eyeInWater){
estimatedDepth = 1.0;
// viewerWaterDepth = max(0.9-lightmap.y,0.0)*3.0;
float distanceFromWaterSurface = -(worldPos.y - waterEnteredAltitude);//max(-(feetPlayerPos.y + (cameraPosition.y - waterEnteredAltitude)),0.0) ;
percievedWaterDepth = distanceFromWaterSurface;
distanceFromWaterSurface = max(distanceFromWaterSurface,0.0);
Absorbtion = exp(-totEpsilon * distanceFromWaterSurface);
sunlightAbsorbtion = exp(-totEpsilon * (distanceFromWaterSurface/abs(WsunVec.y)));
} else {
// use hardcoded gradient position if the water surface normal does not face upwards.
vec3 waterNormal = clamp(normalize(cross(dFdx(playerPos0), dFdy(playerPos0))),0,1); // it uses depth that has POM written to it.
percievedWaterDepth = mix(-(feetPlayerPos.y + cameraPosition.y), percievedWaterDepth, waterNormal.y);
}
DirectLightColor *= sunlightAbsorbtion;
if( nightVision > 0.0 ) Absorbtion += exp(-totEpsilon * 25.0) * nightVision;
// vec2 causticPos = pos.xz;
// causticPos = mix(causticPos, pos.xz, max(FlatNormals.y,0));
// causticPos = mix(causticPos, pos.xy, max(-FlatNormals.y,0));
// causticPos = mix(causticPos, pos.zy, max(FlatNormals.x,0));
// causticPos = mix(causticPos, pos.xy, max(-FlatNormals.z,0));
// causticPos = mix(causticPos, pos.xy, max(FlatNormals.x,0));
// causticPos = mix(causticPos, pos.xy, max(-FlatNormals.x,0));
// apply caustics to the lighting, and make sure they dont look weird
DirectLightColor *= pow(mix(1.0, waterCaustics(worldPos, WsunVec, percievedWaterDepth)*WATER_CAUSTICS_BRIGHTNESS, clamp(estimatedDepth,0,1)), WATER_CAUSTICS_POWER);
}
}
if (!isSky) {
MinimumLightColor = MinimumLightColor + 0.7 * MinimumLightColor * dot(slopednormal, feetPlayerPos_normalized);
// idk why this do
// this seems to be compensating view bobbing, but why not do this when calculating feetPlayerPos? hmmm
feetPlayerPos += gbufferModelViewInverse[3].xyz;
float viewDist = length(feetPlayerPos);
worldPos = feetPlayerPos + cameraPosition;
////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////// FILTER STUFF //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
#if (defined DISTANT_HORIZONS && defined DH_AMBIENT_OCCLUSION) || (defined VOXY && defined VOXY_AMBIENT_OCCLUSION)
doEdgeAwareBlur(colortex3, colortex14, colortex9, DH_mixedLinearZ, hand, SSAO_SSS, filteredShadow);
#else
doEdgeAwareBlur(colortex3, colortex14, depthtex0, ld(z0), hand, SSAO_SSS, filteredShadow);
#endif
float ShadowBlockerDepth = filteredShadow.y;
////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// MAJOR LIGHTSOURCE STUFF ////////////////////////
////////////////////////////////////////////////////////////////////////////////////
#if defined OVERWORLD_SHADER || (defined END_ISLAND_LIGHT && defined END_SHADER)
// float LM_shadowMapFallback = clamp(lightmap.y, 0.0,1.0);
//float LightningPhase = 0.0;
//vec3 LightningFlashLighting = Iris_Lightningflash(feetPlayerPos, lightningBoltPosition.xyz, slopednormal, LightningPhase) * pow(lightmap.y,10);
NdotL = clamp((-15 + dot(slopednormal, WsunVec)*255.0) / 240.0 ,0.0,1.0);
// NdotL = 1;
float flatNormNdotL = clamp((-15 + dot((FlatNormals), WsunVec)*255.0) / 240.0 ,0.0,1.0);
//////////////////////////////// SHADOWMAP ////////////////////////////////
// setup shadow projection
float shadowMapFalloff = smoothstep(0.0, 1.0, min(max(1.0 - viewDist / (shadowDistance+32.0),0.0)*5.0,1.0));
#if defined DISTANT_HORIZONS || defined VOXY
float shadowMapFalloff2 = smoothstep(0.0, 1.0, min(max(1.0 - viewDist / min(shadowDistance, max(far-32.0,32.0)),0.0)*5.0,1.0));
#else
float shadowMapFalloff2 = smoothstep(0.0, 1.0, min(max(1.0 - viewDist / shadowDistance,0.0)*5.0,1.0));
#endif
if(eyeInWater){
shadowMapFalloff = 1.0;
shadowMapFalloff2 = 1.0;
}
vec3 shadowPlayerPos = feetPlayerPos;
#if LIGHTLEAKFIX_MODE == 1
if(!hand) GriAndEminShadowFix(shadowPlayerPos, FlatNormals, lightLeakFix);
#endif
#ifdef OVERWORLD_SHADER
#ifdef CUSTOM_MOON_ROTATION
vec3 projectedShadowPosition = mat3(customShadowMatrixSSBO) * shadowPlayerPos + customShadowMatrixSSBO[3].xyz;
#else
vec3 projectedShadowPosition = mat3(shadowModelView) * shadowPlayerPos + shadowModelView[3].xyz;
#endif
applyShadowBias(projectedShadowPosition, shadowPlayerPos, FlatNormals);
projectedShadowPosition = diagonal3_old(shadowProjection) * projectedShadowPosition + shadowProjection[3].xyz;
// Calclulate distortion factor before bias application
#ifdef DISTORT_SHADOWMAP
float distortFactor = calcDistort(projectedShadowPosition.xy);
projectedShadowPosition.xy *= distortFactor;
#else
float distortFactor = 1.0;
#endif
#if defined POM_OFFSET_SHADOW_BIAS && defined POM
projectedShadowPosition.z += shadowProjection[3].z * (0.0012 + POM_DEEPNESS * mix(0.25,1.0,POM_DEPTH) * 0.025);
#else
projectedShadowPosition.z += shadowProjection[3].z * 0.0012;
#endif
#else
float distortFactor = 1.0;
#endif
#if defined END_ISLAND_LIGHT && defined END_SHADER
vec4 shadowPos = customShadowMatrixSSBO * (gbufferModelViewInverse * vec4(viewPos, 1.0));
applyShadowBias(shadowPos.xyz, shadowPlayerPos, FlatNormals);
shadowPos = customShadowPerspectiveSSBO * shadowPos;
vec3 projectedShadowPosition = shadowPos.xyz / shadowPos.w;
#endif
projectedShadowPosition = projectedShadowPosition * vec3(0.5,0.5,0.5/6.0) + vec3(0.5,0.5,0.5) ;
float ShadowAlpha = 0.0; // this is for subsurface scattering later.
vec3 tintedSunlight = DirectLightColor; // this is for subsurface scattering later.
// nobody cares, it makes zero difference
#if defined END_ISLAND_LIGHT && defined END_SHADER
// make light fade out
float r = length(projectedShadowPosition.xy - vec2(0.5));
if (r < 0.5 && abs(projectedShadowPosition.z) < 1.0) {
shadowColor = ComputeShadowMap_COLOR(projectedShadowPosition, distortFactor, noise_2, filteredShadow.x, flatNormNdotL, shadowMapFalloff, DirectLightColor, ShadowAlpha, tintedSunlight, LabSSS > 0.0,Shadows);
shadowColor *= smoothstep(0.5, 0.25, r);
} else {
shadowColor = vec3(0.0);
}
#else
shadowColor = ComputeShadowMap_COLOR(projectedShadowPosition, distortFactor, noise_2, filteredShadow.x, flatNormNdotL, shadowMapFalloff, DirectLightColor, ShadowAlpha, tintedSunlight, LabSSS > 0.0,Shadows);
#endif
// transition to fallback lightmap shadow mask.
// shadowColor *= mix(isWater ? lightLeakFix : LM_shadowMapFallback, 1.0, shadowMapFalloff2);
#if LIGHTLEAKFIX_MODE == 2
if(!eyeInWater) shadowColor *= lightLeakFix; // light leak fix
#endif
//////////////////////////////// SUN SSS ////////////////////////////////
#if SSS_TYPE != 0
float sunSSS_density = LabSSS;
float SSS_shadow = ShadowAlpha;
#ifndef RENDER_ENTITY_SHADOWS
if(entities) sunSSS_density = 0.0;
#endif
#if SCREENSPACE_CONTACT_SHADOWS > 0 && !defined END_SHADER
vec2 SS_directLight = SSRT_Shadows(toScreenSpace_DH(texcoord/RENDER_SCALE, z, DH_depth1), isDHrange, normalize(WsunVec*mat3(gbufferModelViewInverse)), ig_noise, sunSSS_density > 0.0 && shadowMapFalloff2 < 1.0, hand);
// combine shadowmap with screenspace shadows.
#if SCREENSPACE_CONTACT_SHADOWS == 1
SS_directLight.r = mix(1.0, SS_directLight.r, 1.0-shadowMapFalloff);
#endif
shadowColor *= SS_directLight.r;
#else
vec2 SS_directLight = vec2(1,0);
ShadowBlockerDepth = max(ShadowBlockerDepth, (1.0-shadowMapFalloff2) * 10.0);
#endif
// #ifdef TRANSLUCENT_COLORED_SHADOWS
// SSSColor = tintedSunlight;
// #else
// SSSColor = DirectLightColor;
// #endif
// TODO CHECK IF *= OR =
// *= looks better idk
// = is nice too though ???
SSSColor = SubsurfaceScattering_sun(albedo, ShadowBlockerDepth, sunSSS_density, clamp(dot(feetPlayerPos_normalized, WsunVec),0.0,1.0), SS_directLight.g, shadowMapFalloff2, hand);
if(!eyeInWater) SSSColor *= lightLeakFix;
#if defined END_ISLAND_LIGHT && defined END_SHADER
float fade = 0.0;
if (r < 0.5 && abs(projectedShadowPosition.z) < 1.0) fade = smoothstep(0.25, 0.2, r*r);
SSSColor *= fade;
#ifdef SHADER_GRASS
if(isShaderGrass) SSSColor *= 0.3;
#endif
#endif
#endif
#ifndef END_SHADER
float cloudShadows = GetCloudShadow(worldPos, WsunVec);
shadowColor *= cloudShadows;
SSSColor *= cloudShadow*cloudShadows;
#endif
#endif
#ifdef END_SHADER
#ifdef END_LIGHTNING
float vortexBounds = clamp(vortexBoundRange - length(worldPos), 0.0,1.0);
#else
float vortexBounds = 1.0;
#endif
vec3 lightPos = LightSourcePosition(worldPos, cameraPosition,vortexBounds);
float lightningflash = texelFetch(colortex4,ivec2(1,1),0).x/150.0;
vec3 lightColors = pow(lightmap.y,8) * LightSourceColors(vortexBounds, lightningflash);
float end_NdotL = clamp(dot(slopednormal, normalize(-lightPos))*0.5+0.5,0.0,1.0);
end_NdotL *= end_NdotL;
float fogShadow = GetEndFogShadow(worldPos, lightPos);
float endPhase = endFogPhase(lightPos);
Direct_lighting += lightColors * endPhase * end_NdotL * fogShadow;
#endif
/////////////////////////////////////////////////////////////////////////////////
///////////////////////////// INDIRECT LIGHTING /////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
#if defined OVERWORLD_SHADER
float skylight = 1.0;
#if indirect_effect == VANILLA_AO || indirect_effect == SSAO_FILTERED || indirect_effect == SSAO_HQ || indirect_effect == GTAO
vec3 indirectNormal = slopednormal / dot(abs(slopednormal),vec3(1.0));
float SkylightDir = indirectNormal.y;
if(isGrass) SkylightDir = 1.0;
SkylightDir = clamp(SkylightDir*0.7+0.3, 0.0, pow(1-pow(1-SSAO_SSS.x, 0.5),4.0) * 0.7 + 0.3);
skylight = mix(0.08 + 0.92*(1.0-lightmap.y), 1.0, SkylightDir);
// skylight = 1.0;
#endif
#if indirect_effect == SSRT_AO || indirect_effect == SSRT_AO_GI
skylight = 1.0;
#endif
Indirect_lighting += doIndirectLighting(AmbientLightColor * skylight, MinimumLightColor, lightmap.y);
#if defined PH_ENABLE_GI && defined PHOTONICS && defined ENABLE_PHOTONICS_GI
#if defined DISTANT_HORIZONS || defined VOXY
float photonicsFalloff = smoothstep(min(far, 128.0), min(0.9*far, 114.0), viewDist);
#else
float photonicsFalloff = smoothstep(128.0, 114.0, viewDist);
#endif
vec3 gi_color = texture(colortex15, texcoord).xyz*2.0*PHOTONICS_INDIRECT_BRIGHTNESS* skylight;
gi_color += mix(MinimumLightColor * (MIN_LIGHT_AMOUNT * 0.004 + nightVision*0.02), MinimumLightColor * (MIN_LIGHT_AMOUNT_INSIDE * 0.004 + nightVision*0.02), 1.0-lightmap.y);
Indirect_lighting = mix(Indirect_lighting, gi_color, photonicsFalloff);
#endif
#endif
#ifdef NETHER_SHADER
Indirect_lighting = volumetricsFromTex(normalize(normal), colortex4, 6).rgb / 1200.0;
vec3 up = volumetricsFromTex(vec3(0.0,1.0,0.0), colortex4, 6).rgb / 1200.0;
#if indirect_effect == SSAO_FILTERED || indirect_effect == SSAO_HQ
Indirect_lighting = mix(up, Indirect_lighting, clamp(pow(1.0-pow(1.0-SSAO_SSS.x, 0.5),2.0),0.0,1.0));
#endif
AmbientLightColor = Indirect_lighting;
#endif
#ifdef END_SHADER
Indirect_lighting = vec3(AmbientLightEnd_R,AmbientLightEnd_G,AmbientLightEnd_B);
Indirect_lighting = Indirect_lighting + 0.7*mix(-Indirect_lighting, Indirect_lighting * dot(slopednormal, feetPlayerPos_normalized), clamp(pow(1.0-pow(1.0-SSAO_SSS.x, 0.5),2.0),0.0,1.0));
Indirect_lighting *= 0.05 * lightmap.y*lightmap.y;
Indirect_lighting += lightColors * (endPhase*endPhase) * (1.0-exp(vec3(0.6,2.0,2.0) * -(endPhase*0.01))) /1000.0;
// float minimumLightAmount = 0.02*nightVision + 0.005 * mix(MINIMUM_INDOOR_LIGHT, MINIMUM_OUTDOOR_LIGHT, clamp(eyeBrightnessSmooth.y/240.0 + lightmap.y,0.0,1.0));
// Indirect_lighting += MinimumLightColor * minimumLightAmount;
Indirect_lighting += MinimumLightColor * (MIN_LIGHT_AMOUNT * 0.02 * 0.2 + nightVision*0.02);
#endif
#ifdef IS_LPV_ENABLED
vec3 normalOffset = vec3(0.0);
if (any(greaterThan(abs(FlatNormals), vec3(1.0e-6))))
normalOffset = 0.5*(FlatNormals);
#if LPV_NORMAL_STRENGTH > 0
vec3 texNormalOffset = -normalOffset + slopednormal;
normalOffset = mix(normalOffset, texNormalOffset, (LPV_NORMAL_STRENGTH*0.01));
#endif
vec3 lpvPos = GetLpvPosition(feetPlayerPos) + normalOffset;
#else
const vec3 lpvPos = vec3(0.0);
#endif
vec3 blockLightColor = doBlockLightLighting(vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, feetPlayerPos, lpvPos, viewPos, isDHrange, blueNoise(), FlatNormals, hand);
Indirect_lighting += blockLightColor;
vec4 flashLightSpecularData = vec4(0.0);
#ifdef FLASHLIGHT
#ifdef FLASHLIGHT_SHADOWS
vec3 newViewPos = viewPos + vec3(-0.25, 0.2, 0.0);
float flashlightshadows = SSRT_FlashLight_Shadows(toScreenSpace_DH(texcoord/RENDER_SCALE, z, DH_depth1), isDHrange, -newViewPos, blueNoise(), FlatNormals, hand);
#else
const float flashlightshadows = 1.0;
#endif
Indirect_lighting += flashlightshadows*calculateFlashlight(texcoord, viewPos, albedoSmoothSSBO, slopednormal, flashLightSpecularData, hand);
#endif
/////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// EFFECTS FOR INDIRECT /////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
float SkySSS = SSAO_SSS.y;
vec3 AO = vec3(1.0);
#if indirect_effect == 0
AO = vec3(pow(1.0 - vanilla_AO*vanilla_AO,5.0));
Indirect_lighting *= AO;
#endif
#if indirect_effect == SSAO_FILTERED || indirect_effect == SSAO_HQ
SkySSS = SSAO_SSS.y;
float vanillaAO_curve = pow(1.0 - vanilla_AO*vanilla_AO,5.0);
float SSAO_curve = pow(SSAO_SSS.x,4.0);
// use the min of vanilla ao so they dont overdarken eachother
// AO = vec3( min(vanillaAO_curve, SSAO_curve) );
AO = vec3( SSAO_curve );
Indirect_lighting *= AO;
#endif
// // GTAO... this is so dumb but whatevverrr
#if indirect_effect == GTAO
float vanillaAO_curve = pow(1.0 - vanilla_AO*vanilla_AO,5.0);
vec2 r2 = fract(R2_samples((frameCounter%40000) + frameCounter*2) + bnoise);
float getGTAO = !hand ? ambient_occlusion(vec3(texcoord/RENDER_SCALE-TAA_Offset*texelSize*0.5, z), viewPos, worldToView(slopednormal), r2) : 1.0;
AO = vec3(min(vanillaAO_curve,getGTAO));
Indirect_lighting *= AO;
#endif
// RTAO and/or SSGI
#if indirect_effect == SSRT_AO || indirect_effect == SSRT_AO_GI
if(!hand) Indirect_lighting = ApplySSRT(Indirect_lighting, blockLightColor, MinimumLightColor, viewPos, normal, vec3(bnoise, noise_2), lightmap.y, isGrass, isDHrange);
#endif
////////////////////////////////////////////////////////////////////////////////
///////////////////////// SUB SURFACE SCATTERING ////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////// SKY SSS /////////////////////////////
#if defined Ambient_SSS && defined OVERWORLD_SHADER && (indirect_effect == SSAO_FILTERED || indirect_effect == SSAO_HQ)
vec3 ambientColor = AmbientLightColor * ambientsss_brightness * ambient_brightness;
Indirect_SSS = SubsurfaceScattering_sky(albedo, SkySSS, LabSSS);
Indirect_SSS *= lightmap.y;
// float thingy = SkySSS;
// thingy = pow(thingy,3.5);
// thingy = 1-pow(1-thingy,5);
Indirect_lighting += Indirect_SSS * ambientColor;
#endif
/////////////////////////////////////////////////////////////////////////
///////////////////////////// FINALIZE /////////////////////////////
/////////////////////////////////////////////////////////////////////////
// shadowColor *= 0.0;
// SSSColor *= 0.0;
#ifdef SSS_view
albedo = vec3(1);
NdotL = 0;
#endif
#if defined END_SHADER
Direct_lighting *= AO;
#endif
#if defined OVERWORLD_SHADER || (defined END_ISLAND_LIGHT && defined END_SHADER)
#ifdef AO_in_sunlight
// Direct_lighting = shadowColor*NdotL*(AO*0.7+0.3) + SSSColor * (1.0-NdotL);
Direct_lighting = DirectLightColor * mix(SSSColor, vec3(1.0), NdotL*shadowColor * (AO*0.7+0.3));
#else
// Direct_lighting = shadowColor*NdotL + SSSColor * (1.0-NdotL);
Direct_lighting = DirectLightColor * mix(SSSColor, vec3(1.0), NdotL*shadowColor);
#endif
#endif
#if defined OVERWORLD_SHADER && defined DEFERRED_SPECULAR && (PUDDLE_MODE > 0 || ShaderSnow > 0)
if(!hand && !entities && !isWater) applyPuddles(worldPos, FlatNormals, lightmap.y, eyeInWater, albedo, normal, SpecularTex.r, SpecularTex.g, isShaderGrass, labPorosity);
#endif
vec3 FINAL_COLOR = (Indirect_lighting + Direct_lighting) * albedo;
Emission(FINAL_COLOR, albedo, SpecularTex.a);
// if(lightningBolt) FINAL_COLOR = vec3(77.0, 153.0, 255.0);
#if defined DEFERRED_SPECULAR
vec2 specularNoises = vec2(blueNoise(), ig_noise);
vec3 specularNormal = normal;
if (dot(normal, (feetPlayerPos_normalized)) > 0.0) specularNormal = FlatNormals;
vec4 reflections = vec4(0.0,0.0,0.0,1.0);
float SunReflectionAlpha = 0.0;
FINAL_COLOR = specularReflections(viewPos, feetPlayerPos, feetPlayerPos_normalized, WsunVec, specularNoises, FlatNormals, specularNormal, SpecularTex.r, SpecularTex.g, albedo, FINAL_COLOR, DirectLightColor*shadowColor*shadowColor, lightmap.y, hand, reflections, SunReflectionAlpha, isShaderGrass, flashLightSpecularData);
#if defined DEFERRED_SPECULAR && defined DENOISED_REFLECTIONS
gl_FragData[1] = reflections;
gl_FragData[2].rgb = DirectLightColor*shadowColor*shadowColor*SunReflectionAlpha;
gl_FragData[3] = vec4(encodeNormal(specularNormal), SpecularTex.r, SpecularTex.g);
#endif
#endif
gl_FragData[0].rgb = FINAL_COLOR;
}else{
vec3 Background = vec3(0.0);
#ifdef OVERWORLD_SHADER
float atmosphereGround = 1.0 - exp2(-50.0 * pow(clamp(feetPlayerPos_normalized.y+0.025,0.0,1.0),2.0) ); // darken the ground in the sky.
#if RESOURCEPACK_SKY == 1 || RESOURCEPACK_SKY == 0 || RESOURCEPACK_SKY == 3
// vec3 orbitstar = vec3(feetPlayerPos_normalized.x,abs(feetPlayerPos_normalized.y),feetPlayerPos_normalized.z); orbitstar.x -= WsunVec.x*0.2;
vec3 worldDir = normalize(mat3(gbufferModelViewInverse) * toScreenSpace(vec3(texcoord/RENDER_SCALE,1.0)));
#if RESOURCEPACK_SKY == 0 || RESOURCEPACK_SKY == 3
vec3 orbitstar = customRotation(sunPathRotation, worldTimeSmooth) * worldDir;
vec3 starColor = vec3(1.0);
#if defined OVERWORLD_SHADER && defined TWILIGHT_FOREST_FLAG
float stars = stars(orbitstar, starColor) * 100.0;
Background += stars * starColor;
#else
float stars = stars(orbitstar, starColor) * 10.0;
Background += stars * starColor * mix(clamp(-unsigned_WsunVec.y*2.0,0.0,1.0), 1.0, clamp(cameraPosition.y-15000.0, 0.0, 45000.0)/45000.0);
#endif
#endif
#if !defined AMBIENT_LIGHT_ONLY && (RESOURCEPACK_SKY == 1 || RESOURCEPACK_SKY == 0)
#ifdef CUSTOM_MOON_ROTATION
float sunMoonDist = length(unsigned_WsunVec - WmoonVec);
if (sunMoonDist < 0.004){
vec3 tangent2 = normalize(cross(unsigned_WsunVec, vec3(0.0, 1.0, 0.0)));
vec3 binormal2 = cross(unsigned_WsunVec, tangent2);
vec3 dirDiff2 = worldDir - unsigned_WsunVec;
float u2 = dot(dirDiff2, tangent2);
float v2 = dot(dirDiff2, binormal2);
float sunAngularRadius = acos(0.9984);
u2 = u2 / (2.0 * sunAngularRadius) + 0.5;
v2 = -v2 / (1.96 * sunAngularRadius) + 0.505;
if (u2 > 0.0 && u2 < 1.0 && v2 > 0.0 && v2 < 1.0) {
vec2 coronaUV = vec2(u2, v2);
vec3 coronaTex = texture(CoronaTex, coronaUV).rgb;
Background += 0.5 * coronaTex * coronaTex * coronaTex * coronaTex * coronaTex * smoothstep(0.004, 0.0002, sunMoonDist);
}
}
#endif
#ifdef SMOOTH_SUN_ROTATION
vec3 sunVec = WsunVecSmooth;
#else
vec3 sunVec = unsigned_WsunVec;
#endif
Background += drawSun(dot(sunVec, feetPlayerPos_normalized), sunColorSSBO / 2400.0);
#ifdef REALMOON
vec3 tangent = normalize(cross(WmoonVec, vec3(0.0, 1.0, 0.0)));
vec3 binormal = cross(WmoonVec, tangent);
vec3 dirDiff = worldDir - WmoonVec;
float u = dot(dirDiff, tangent);
float v = dot(dirDiff, binormal);
float moonSize = MOON_SIZE;
float moonAngularRadius = acos(moonSize);
u = u / (2.0 * moonAngularRadius) + 0.5;
v = -v / (2.0 * moonAngularRadius) + 0.5;
vec2 moonUV = vec2(u, v);
vec2 moonSphericalUV = sphereMap(moonUV);
#ifdef CUSTOM_MOON_ROTATION
vec3 moonTex = texture(moon, moonSphericalUV).rgb;
float moonVis = smoothstep(0.08, -0.03, WmoonVec.y);
vec2 pos = 2.0 * moonUV - 1.0;
float r2 = dot(pos, pos); // we got 'em r2
vec3 moonDirLocal = normalize(vec3(pos.x, pos.y, sqrt(1.0 - r2)));
vec3 moonDirWorld = moonDirLocal.x * tangent - moonDirLocal.y * binormal - moonDirLocal.z * WmoonVec;
float sunLight = dot(normalize(moonDirWorld), unsigned_WsunVec);
#ifdef MOON_NORMALS
float mask = smoothstep(-0.25, 0.12, sunLight);
vec3 normalTex = texture(moonN, moonSphericalUV).xyz;
normalTex = normalTex * 2.0 - 1.0;
mat3 TBN = mat3(tangent, binormal, normalize(moonDirWorld));
vec3 worldNormal = normalize(TBN * normalTex);
float normalSunLight = dot(worldNormal, unsigned_WsunVec);
// smoothstep to boost contrast
mask *= smoothstep(-0.5, 0.5, normalSunLight);
#else
float mask = smoothstep(-0.2, 0.12, sunLight);
#endif
moonTex *= (1.0 - vec3(0.0, 0.5, 0.7)*clamp((1.0-0.5*v)*moonVis, 0.0, 1.0)) * mask;
#else
float moonVis = smoothstep(0.12, -0.03, -moonElevation);
float moonphaseMult = 1.0;
#ifdef MOONPHASE_BASED_MOONLIGHT
float[8] phase = float[8](
1.0,
smoothstep(0.85, 0.65, u + pow(abs(0.8*(v-0.5)), 2.0)),
smoothstep(0.6, 0.4, u),
smoothstep(0.35, 0.15, u - pow(abs(0.8*(v-0.5)), 2.0)),
0.0,
smoothstep(0.65, 0.85, u + pow(abs(0.8*(v-0.5)), 2.0)),
smoothstep(0.4, 0.6, u),
smoothstep(0.15, 0.35, u - pow(abs(0.8*(v-0.5)), 2.0))
);
moonphaseMult = phase[moonPhase];
#endif
vec3 moonTex = (1.0 - vec3(0.0, 0.5, 0.7)*clamp((1-0.5*v)*moonVis, 0.0, 1.0)) * moonphaseMult * texture(moon, moonSphericalUV).rgb;
#endif
vec3 moonLightCol = moonColorBase2;
Background += pow(moonTex, vec3(3.2)) * 12.0 * drawRealMoon(feetPlayerPos_normalized, WmoonVec, moonLightCol, Background, moonSize);
#else
vec3 moonLightCol = moonColorSSBO / 2400.0;
Background += drawMoon(feetPlayerPos_normalized, WmoonVec, moonLightCol, Background);
#endif
#endif
Background *= atmosphereGround;
#endif
#ifndef ISOLATE_RESOURCEPACK_SKY
vec3 Sky = skyFromTex(feetPlayerPos_normalized, colortex4)/1200.0 * Sky_Brightness;
Background += Sky;
#endif
#if RESOURCEPACK_SKY == 1 || RESOURCEPACK_SKY == 2 || RESOURCEPACK_SKY == 3
vec3 resourcePackskyBox = skyboxCol * 50.0 * clamp(unsigned_WsunVec.y*255.0,0.1,1.0);
#if defined SKY_GROUND && !defined ISOLATE_RESOURCEPACK_SKY
resourcePackskyBox *= atmosphereGround;
#endif
Background += resourcePackskyBox;
#endif
#endif
#ifdef END_SHADER
vec3 starColor = vec3(1.0);
Background += stars(normalize(mat3(gbufferModelViewInverse) * toScreenSpace(vec3(texcoord/RENDER_SCALE,1.0))), starColor) * 5.0;
#endif
gl_FragData[0].rgb = clamp(fp10Dither(Background, triangularize(noise_2)), 0.0, 65000.);
}
if(translucentMasks > 0.0 && !hand){
// water absorbtion will impact ALL light coming up from terrain underwater.
gl_FragData[0].rgb *= Absorbtion;
}
////// DEBUG VIEW STUFF
#if DEBUG_VIEW == debug_SHADOWMAP
gl_FragData[0].rgb = vec3(1.0) * (Shadows * NdotL * 0.9 + 0.1);
if(dot(feetPlayerPos_normalized, unsigned_WsunVec) > 0.999 ) gl_FragData[0].rgb = vec3(10,10,0);
if(dot(feetPlayerPos_normalized, WmoonVec) > 0.999 ) gl_FragData[0].rgb = vec3(1,1,10);
#endif
#if DEBUG_VIEW == debug_NORMALS
if(swappedDepth >= 1.0) Direct_lighting = vec3(1.0);
gl_FragData[0].rgb = normal ;
#endif
#if DEBUG_VIEW == debug_SPECULAR
if(swappedDepth >= 1.0) Direct_lighting = vec3(1.0);
gl_FragData[0].rgb = SpecularTex.rgb;
#endif
#if DEBUG_VIEW == debug_INDIRECT
if(swappedDepth >= 1.0) Direct_lighting = vec3(5.0);
gl_FragData[0].rgb = Indirect_lighting;
#endif
#if DEBUG_VIEW == debug_DIRECT
if(swappedDepth < 1.0) gl_FragData[0].rgb = Direct_lighting;
#endif
#if DEBUG_VIEW == debug_VIEW_POSITION
gl_FragData[0].rgb = viewPos * 0.001;
#endif
#if DEBUG_VIEW == debug_FILTERED_STUFF
// if(hideGUI == 0){
float value = SSAO_SSS.y;
value = pow(value,3.5);
value = 1-pow(1-value,5);
if(hideGUI == 1) value = pow(SSAO_SSS.x,6);
gl_FragData[0].rgb = vec3(value);
if(swappedDepth >= 1.0) gl_FragData[0].rgb = vec3(1.0);
// }
#endif
#if defined DEFERRED_SPECULAR && defined DENOISED_REFLECTIONS
/* RENDERTARGETS:3,0,15,8 */
#else
/* RENDERTARGETS:3 */
#endif
}
Reference in New Issue View Git Blame Copy Permalink