Backups/Bliss-Shader
1
0
Fork 0
mirror of https://github.com/X0nk/Bliss-Shader.git synced 2025-06-23 01:02:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

intial changes for commit #495

Browse Source
This commit is contained in:
Xonk
2024-11-15 17:54:18 -05:00
parent b32041d4fc
commit b93d6f1a12
56 changed files with 3550 additions and 2274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
shaders/lib/overworld_fog.glsl
View File

@ -44,7 +44,7 @@ float cloudVol(in vec3 pos, float maxDistance ){
FogDensities(medium_gradientFog, cloudyFog, rainyFog, maxDistance, dailyWeatherParams0.a, dailyWeatherParams1.a);
return uniformFog + medium_gradientFog + cloudyFog + rainyFog;
return uniformFog + medium_gradientFog + cloudyFog;
}
float phaseRayleigh(float cosTheta) {
@ -52,23 +52,29 @@ float phaseRayleigh(float cosTheta) {
return cosTheta * mul_add.x + mul_add.y; // optimized version from [Elek09], divided by 4 pi for energy conservation
}
float fogPhase(float lightPoint){
float linear = 1.0 - clamp(lightPoint*0.5+0.5,0.0,1.0);
float linear = clamp(-lightPoint*0.5+0.5,0.0,1.0);
float linear2 = 1.0 - clamp(lightPoint,0.0,1.0);
float exponential = exp2(pow(linear,0.3) * -15.0 ) * 1.5;
exponential += sqrt(exp2(sqrt(linear) * -12.5));
// float exponential = 1.0 / (linear * 10.0 + 0.05);
return exponential;
}
float phaseCloudFog(float x, float g){
float gg = g * g;
return (gg * -0.25 + 0.25) * pow(-2.0 * (g * x) + (gg + 1.0), -1.5) / 3.14;
}
uniform ivec2 eyeBrightness;
vec4 GetVolumetricFog(
vec3 viewPosition,
vec2 dither,
vec3 LightColor,
vec3 AmbientColor,
vec3 AveragedAmbientColor,
inout float atmosphereAlpha
in vec3 viewPosition,
in vec2 dither,
in vec3 LightColor,
in vec3 AmbientColor,
in vec3 AveragedAmbientColor,
inout float atmosphereAlpha,
inout vec3 sceneColor
){
#ifndef TOGGLE_VL_FOG
return vec4(0.0,0.0,0.0,1.0);
@ -101,8 +107,7 @@ vec4 GetVolumetricFog(
dV *= maxLength;
dVWorld *= maxLength;
float dL_alternate = length(dVWorld);
float dL = dL_alternate/8.0;
float dL = length(dVWorld)/8.0;
vec3 progress = start.xyz;
vec3 progressW = vec3(0.0);
@ -111,17 +116,23 @@ vec4 GetVolumetricFog(
/// ------------- COLOR/LIGHTING STUFF ------------- \\\
vec3 color = vec3(0.0);
float totalAbsorbance = 1.0;
vec3 finalAbsorbance = vec3(1.0);
// float totalAbsorbance = 1.0;
vec3 totalAbsorbance = vec3(1.0);
float fogAbsorbance = 1.0;
float atmosphereAbsorbance = 1.0;
// float atmosphereAbsorbance = 1.0;
vec3 atmosphereAbsorbance = vec3(1.0);
vec3 WsunVec = mat3(gbufferModelViewInverse) * sunVec;
float SdotV = dot(sunVec, normalize(viewPosition))*lightCol.a;
///// ----- fog lighting
//Mie phase + somewhat simulates multiple scattering (Horizon zero down cloud approx)
float sunPhase = fogPhase(SdotV) * 5.0;
float skyPhase = pow(clamp(normalize(wpos).y*0.5+0.5,0.0,1.0),4.0)*5.0;
float sunPhase = fogPhase(SdotV)*5.0;// phaseCloudFog(SdotV, 0.9) + phaseCloudFog(SdotV, 0.85) + phaseCloudFog(SdotV, 0.5) * 5.0;
float sunPhase2 = (phaseCloudFog(SdotV, 0.85) + phaseCloudFog(SdotV, 0.5)) * 5.0;
float skyPhase = 2.0 + pow(1.0-pow(1.0-clamp(normalize(wpos).y*0.5+0.5,0.0,1.0),2.0),5.0)*2.0 ;//pow(clamp(normalize(wpos).y*0.5+0.5,0.0,1.0),4.0)*5.0;
float rayL = phaseRayleigh(SdotV);
vec3 rC = vec3(sky_coefficientRayleighR*1e-6, sky_coefficientRayleighG*1e-5, sky_coefficientRayleighB*1e-5) ;
@ -130,7 +141,7 @@ vec4 GetVolumetricFog(
vec3 skyLightPhased = AmbientColor;
vec3 LightSourcePhased = LightColor;
skyLightPhased *= 1.0 + skyPhase;
skyLightPhased *= skyPhase;
LightSourcePhased *= sunPhase;
#ifdef ambientLight_only
@ -143,12 +154,6 @@ vec4 GetVolumetricFog(
float inBiome = BiomeVLFogColors(biomeDirect, biomeIndirect);
#endif
#ifdef DISTANT_HORIZONS
float atmosphereMult = 1.0;
#else
float atmosphereMult = 1.5;
#endif
#ifdef RAYMARCH_CLOUDS_WITH_FOG
vec3 SkyLightColor = AmbientColor;
vec3 LightSourceColor = LightColor;
@ -174,14 +179,16 @@ vec4 GetVolumetricFog(
float lightLevelZero = pow(clamp(eyeBrightnessSmooth.y/240.0 ,0.0,1.0),3.0);
// SkyLightColor *= lightLevelZero*0.9 + 0.1;
vec3 finalsceneColor = vec3(0.0);
for (int i = 0; i < SAMPLECOUNT; i++) {
float d = (pow(expFactor, float(i+dither.x)/float(SAMPLECOUNT))/expFactor - 1.0/expFactor)/(1-1.0/expFactor);
float dd = pow(expFactor, float(i+dither.x)/float(SAMPLECOUNT)) * log(expFactor) / float(SAMPLECOUNT)/(expFactor-1.0);
float dd = pow(expFactor, float(i+dither.y)/float(SAMPLECOUNT)) * log(expFactor) / float(SAMPLECOUNT)/(expFactor-1.0);
progress = start.xyz + d*dV;
progressW = gbufferModelViewInverse[3].xyz + cameraPosition + d*dVWorld;
// if(length(progressW-cameraPosition) > cloudDepth) break;
//------------------------------------
//------ SAMPLE SHADOWS FOR FOG EFFECTS
//------------------------------------
@ -212,7 +219,7 @@ vec4 GetVolumetricFog(
#endif
#ifdef VL_CLOUDS_SHADOWS
sh *= GetCloudShadow_VLFOG(progressW, WsunVec * lightCol.a);
sh *= GetCloudShadow(progressW, WsunVec*lightCol.a);
#endif
#ifdef PER_BIOME_ENVIRONMENT
@ -237,10 +244,9 @@ vec4 GetVolumetricFog(
#endif
vec3 Lightning = Iris_Lightningflash_VLfog(progressW-cameraPosition, lightningBoltPosition.xyz);
vec3 lighting = DirectLight + indirectLight * (lightLevelZero*0.99 + 0.01) + Lightning;
color += (lighting - lighting * fogVolumeCoeff) * fogAbsorbance;
fogAbsorbance *= fogVolumeCoeff;
vec3 lighting = DirectLight + indirectLight;// * (lightLevelZero*0.99 + 0.01) + Lightning;
color += (lighting - lighting * fogVolumeCoeff) * totalAbsorbance;
// kill fog absorbance when in caves.
totalAbsorbance *= mix(1.0, fogVolumeCoeff, lightLevelZero);
@ -252,26 +258,32 @@ vec4 GetVolumetricFog(
#else
float cloudPlaneCutoff = 1.0;
#endif
// maximum range for atmosphere haze, basically.
float planetVolume = 1.0 - exp(clamp(1.0 - length(progressW-cameraPosition) / (16*150), 0.0,1.0) * -10);
// just air
vec2 airCoef = exp2(-max(progressW.y-SEA_LEVEL,0.0)/vec2(8.0e3, 1.2e3)*vec2(6.,7.0)) * (24.0 * atmosphereMult) * Haze_amount * cloudPlaneCutoff;
vec2 airCoef = (exp2(-max(progressW.y-SEA_LEVEL,0.0)/vec2(8.0e3, 1.2e3)*vec2(6.,7.0)) * 192.0 * Haze_amount) * cloudPlaneCutoff * planetVolume;
// Pbr for air, yolo mix between mie and rayleigh for water droplets
vec3 rL = rC*airCoef.x;
vec3 m = mC*(airCoef.y+densityVol*300.0);
// calculate the atmosphere haze seperately and purely additive to color, do not contribute to absorbtion.
vec3 atmosphereVolumeCoeff = exp(-(rL+m)*dd*dL_alternate);
vec3 atmosphereVolumeCoeff = exp(-(rL+m)*dd*dL);
// vec3 Atmosphere = LightSourcePhased * sh * (rayL*rL + sunPhase*m) + AveragedAmbientColor * (rL+m);
vec3 Atmosphere = (LightSourcePhased * sh * (rayL*rL + sunPhase*m) + AveragedAmbientColor * (rL+m) * (lightLevelZero*0.99 + 0.01)) * inACave;
color += (Atmosphere - Atmosphere * atmosphereVolumeCoeff) / (rL+m+1e-6) * atmosphereAbsorbance * totalAbsorbance;
atmosphereAbsorbance *= dot(atmosphereVolumeCoeff, vec3(0.33333));
color += (Atmosphere - Atmosphere * atmosphereVolumeCoeff) / (rL+m+1e-6) * atmosphereAbsorbance;
// finalsceneColor = sceneColor * totalAbsorbance;
atmosphereAbsorbance *= atmosphereVolumeCoeff*fogVolumeCoeff;
//------------------------------------
//------ LPV FOG EFFECT
//------------------------------------
#if defined LPV_VL_FOG_ILLUMINATION && defined EXCLUDE_WRITE_TO_LUT
color += LPV_FOG_ILLUMINATION(progressW-cameraPosition, dd, dL) * TorchBrightness_autoAdjust * totalAbsorbance;
color += LPV_FOG_ILLUMINATION(progressW-cameraPosition, dd, dL) * totalAbsorbance;
#endif
//------------------------------------
//------ STUPID RENDER CLOUDS AS FOG EFFECT
@ -333,271 +345,13 @@ vec4 GetVolumetricFog(
}
}
#else
if (totalAbsorbance < 1e-5) break;
// if (totalAbsorbance < 1e-5) break;
#endif
}
atmosphereAlpha = atmosphereAbsorbance;
// sceneColor = finalsceneColor;
// atmosphereAlpha = atmosphereAbsorbance;
return vec4(color, totalAbsorbance);
}
// vec4 GetVolumetricFog(
// vec3 viewPosition,
// vec2 dither,
// vec3 LightColor,
// vec3 AmbientColor
// ){
// #ifndef TOGGLE_VL_FOG
// return vec4(0.0,0.0,0.0,1.0);
// #endif
// int SAMPLECOUNT = VL_SAMPLES;
// /// ------------- RAYMARCHING STUFF ------------- \\\
// //project pixel position into projected shadowmap space
// vec3 wpos = mat3(gbufferModelViewInverse) * viewPosition + gbufferModelViewInverse[3].xyz;
// vec3 fragposition = mat3(shadowModelView) * wpos + shadowModelView[3].xyz;
// fragposition = diagonal3(shadowProjection) * fragposition + shadowProjection[3].xyz;
// //project view origin into projected shadowmap space
// vec3 start = toShadowSpaceProjected(vec3(0.0));
// //rayvector into projected shadow map space
// //we can use a projected vector because its orthographic projection
// //however we still have to send it to curved shadow map space every step
// vec3 dV = fragposition - start;
// vec3 dVWorld = (wpos-gbufferModelViewInverse[3].xyz);
// #ifdef DISTANT_HORIZONS
// float maxLength = min(length(dVWorld), max(dhFarPlane-1000,0.0))/length(dVWorld);
// SAMPLECOUNT += SAMPLECOUNT;
// #else
// float maxLength = min(length(dVWorld), far)/length(dVWorld);
// #endif
// dV *= maxLength;
// dVWorld *= maxLength;
// float dL = length(dVWorld);
// float mult = length(dVWorld)/25;
// vec3 progress = start.xyz;
// vec3 progressW = gbufferModelViewInverse[3].xyz + cameraPosition;
// vec3 WsunVec = mat3(gbufferModelViewInverse) * sunVec * lightCol.a;
// float SdotV = dot(sunVec,normalize(viewPosition))*lightCol.a;
// /// ------------- COLOR/LIGHTING STUFF ------------- \\\
// vec3 color = vec3(0.0);
// vec3 absorbance = vec3(1.0);
// ///// ----- fog lighting
// //Mie phase + somewhat simulates multiple scattering (Horizon zero down cloud approx)
// float mie = fogPhase(SdotV) * 5.0;
// float rayL = phaseRayleigh(SdotV);
// vec3 rC = vec3(sky_coefficientRayleighR*1e-6, sky_coefficientRayleighG*1e-5, sky_coefficientRayleighB*1e-5);
// vec3 mC = vec3(fog_coefficientMieR*1e-6, fog_coefficientMieG*1e-6, fog_coefficientMieB*1e-6);
// vec3 skyLightPhased = AmbientColor;
// vec3 LightSourcePhased = LightColor;
// #ifdef ambientLight_only
// LightSourcePhased = vec3(0.0);
// #endif
// #ifdef PER_BIOME_ENVIRONMENT
// vec3 biomeDirect = LightSourcePhased;
// vec3 biomeIndirect = skyLightPhased;
// float inBiome = BiomeVLFogColors(biomeDirect, biomeIndirect);
// #endif
// skyLightPhased = max(skyLightPhased + skyLightPhased*(normalize(wpos).y*0.9+0.1),0.0);
// LightSourcePhased *= mie;
// // float lightleakfix = clamp(pow(eyeBrightnessSmooth.y/240.,2) ,0.0,1.0);
// float lightleakfix = 1.0 - caveDetection;
// #ifdef RAYMARCH_CLOUDS_WITH_FOG
// vec3 SkyLightColor = AmbientColor;
// vec3 LightSourceColor = LightColor;
// #ifdef ambientLight_only
// LightSourceColor = vec3(0.0);
// #endif
// float shadowStep = 200.0;
// vec3 dV_Sun = WsunVec*shadowStep;
// float mieDay = phaseg(SdotV, 0.75);
// float mieDayMulti = (phaseg(SdotV, 0.35) + phaseg(-SdotV, 0.35) * 0.5) ;
// vec3 directScattering = LightSourceColor * mieDay * 3.14;
// vec3 directMultiScattering = LightSourceColor * mieDayMulti * 3.14;
// vec3 sunIndirectScattering = LightSourceColor * phaseg(dot(mat3(gbufferModelView)*vec3(0,1,0),normalize(viewPosition)), 0.5) * 3.14;
// #endif
// #ifdef DISTANT_HORIZONS
// float atmosphereMult = 1.0;
// #else
// float atmosphereMult = 1.5;
// #endif
// float expFactor = 11.0;
// for (int i=0;i<SAMPLECOUNT;i++) {
// float d = (pow(expFactor, float(i+dither.x)/float(SAMPLECOUNT))/expFactor - 1.0/expFactor)/(1-1.0/expFactor);
// float dd = pow(expFactor, float(i+dither.x)/float(SAMPLECOUNT)) * log(expFactor) / float(SAMPLECOUNT)/(expFactor-1.0);
// progress = start.xyz + d*dV;
// progressW = gbufferModelViewInverse[3].xyz+cameraPosition + d*dVWorld;
// // float curvature = 1-exp(-25*pow(clamp(1.0 - length(progressW - cameraPosition)/(32*80),0.0,1.0),2));
// //project into biased shadowmap space
// #ifdef DISTORT_SHADOWMAP
// float distortFactor = calcDistort(progress.xy);
// #else
// float distortFactor = 1.0;
// #endif
// vec3 pos = vec3(progress.xy*distortFactor, progress.z);
// vec3 sh = vec3(1.0);
// if (abs(pos.x) < 1.0-0.5/2048. && abs(pos.y) < 1.0-0.5/2048){
// pos = pos*vec3(0.5,0.5,0.5/6.0)+0.5;
// #ifdef TRANSLUCENT_COLORED_SHADOWS
// sh = vec3(shadow2D(shadowtex0, pos).x);
// if(shadow2D(shadowtex1, pos).x > pos.z && sh.x < 1.0){
// vec4 translucentShadow = texture2D(shadowcolor0, pos.xy);
// if(translucentShadow.a < 0.9) sh = normalize(translucentShadow.rgb+0.0001);
// }
// #else
// sh = vec3(shadow2D(shadow, pos).x);
// #endif
// }
// vec3 sh2 = sh;
// #ifdef VL_CLOUDS_SHADOWS
// // if(clamp(progressW.y - CloudLayer1_height,0.0,1.0) < 1.0 && clamp(progressW.y-50,0.0,1.0) > 0.0)
// sh *= GetCloudShadow_VLFOG(progressW, WsunVec);
// #endif
// #ifdef PER_BIOME_ENVIRONMENT
// float maxDistance = inBiome * min(max(1.0 - length(d*dVWorld.xz)/(32*8),0.0)*2.0,1.0);
// float densityVol = cloudVol(progressW, maxDistance) * lightleakfix;
// #else
// float densityVol = cloudVol(progressW, 0.0) * lightleakfix;
// #endif
// //Water droplets(fog)
// float density = densityVol*300.0;
// ///// ----- main fog lighting
// //Just air
// vec2 airCoef = exp(-max(progressW.y - SEA_LEVEL, 0.0) / vec2(8.0e3, 1.2e3) * vec2(6.,7.0)) * (atmosphereMult * 24.0) * Haze_amount * clamp(CloudLayer0_height - progressW.y + max(eyeAltitude-(CloudLayer0_height-50),0),0.0,1.0);
// //Pbr for air, yolo mix between mie and rayleigh for water droplets
// vec3 rL = rC*airCoef.x;
// vec3 m = (airCoef.y+density) * mC;
// #ifdef PER_BIOME_ENVIRONMENT
// vec3 Atmosphere = mix(skyLightPhased, biomeDirect, maxDistance) * (rL + m); // not pbr so just make the atmosphere also dense fog heh
// vec3 DirectLight = mix(LightSourcePhased, biomeIndirect, maxDistance) * sh * (rL*rayL + m);
// #else
// vec3 Atmosphere = skyLightPhased * (rL + m); // not pbr so just make the atmosphere also dense fog heh
// vec3 DirectLight = LightSourcePhased * sh * (rL*rayL + m);
// #endif
// vec3 Lightning = Iris_Lightningflash_VLfog(progressW-cameraPosition, lightningBoltPosition.xyz) * (rL + m);
// vec3 foglighting = (Atmosphere + DirectLight + Lightning) * lightleakfix;
// color += (foglighting - foglighting * exp(-(rL+m)*dd*dL)) / ((rL+m)+0.00000001)*absorbance;
// absorbance *= clamp(exp(-(rL+m)*dd*dL),0.0,1.0);
// #ifdef RAYMARCH_CLOUDS_WITH_FOG
// //////////////////////////////////////////
// ///// ----- cloud part
// //////////////////////////////////////////
// // curvature = clamp(1.0 - length(progressW - cameraPosition)/(32*128),0.0,1.0);
// float otherlayer = max(progressW.y - (CloudLayer0_height+99.5), 0.0) > 0.0 ? 0.0 : 1.0;
// float DUAL_MIN_HEIGHT = otherlayer > 0.0 ? CloudLayer0_height : CloudLayer1_height;
// float DUAL_MAX_HEIGHT = DUAL_MIN_HEIGHT + 100.0;
// float DUAL_DENSITY = otherlayer > 0.0 ? CloudLayer0_density : CloudLayer1_density;
// if(clamp(progressW.y - DUAL_MAX_HEIGHT,0.0,1.0) < 1.0 && clamp(progressW.y - DUAL_MIN_HEIGHT,0.0,1.0) > 0.0){
// float DUAL_MIN_HEIGHT_2 = otherlayer > 0.0 ? CloudLayer0_height : CloudLayer1_height;
// float DUAL_MAX_HEIGHT_2 = DUAL_MIN_HEIGHT + 100.0;
// float cumulus = GetCumulusDensity(-1, progressW, 1, CloudLayer0_height, CloudLayer1_height);
// float fadedDensity = DUAL_DENSITY * clamp(exp( (progressW.y - (DUAL_MAX_HEIGHT - 75)) / 9.0 ),0.0,1.0);
// float muE = cumulus*fadedDensity;
// float directLight = 0.0;
// for (int j=0; j < 3; j++){
// vec3 shadowSamplePos = progressW + dV_Sun * (0.1 + j * (0.1 + dither.y*0.05));
// float shadow = GetCumulusDensity(-1, shadowSamplePos, 0, DUAL_MIN_HEIGHT, DUAL_MAX_HEIGHT) * DUAL_DENSITY;
// directLight += shadow;
// }
// /// shadows cast from one layer to another
// /// large cumulus -> small cumulus
// #if defined CloudLayer1 && defined CloudLayer0
// if(otherlayer > 0.0) directLight += LAYER1_DENSITY * 2.0 * GetCumulusDensity(1, progressW + dV_Sun/abs(dV_Sun.y) * max((LAYER1_minHEIGHT+70*dither.y) - progressW.y,0.0), 0, LAYER1_minHEIGHT, LAYER1_maxHEIGHT);
// #endif
// // // altostratus -> cumulus
// // #ifdef CloudLayer2
// // vec3 HighAlt_shadowPos = rayProgress + dV_Sun/abs(dV_Sun.y) * max(LAYER2_HEIGHT - rayProgress.y,0.0);
// // float HighAlt_shadow = GetAltostratusDensity(HighAlt_shadowPos) * CloudLayer2_density;
// // directLight += HighAlt_shadow;
// // #endif
// float skyScatter = clamp(((DUAL_MAX_HEIGHT - 20 - progressW.y) / 275.0) * (0.5+DUAL_DENSITY),0.0,1.0);
// float distantfade = 1- exp( -10*pow(clamp(1.0 - length(progressW - cameraPosition)/(32*65),0.0,1.0),2));
// vec3 cloudlighting = DoCloudLighting(cloudDensity * cumulus, SkyLightColor, skyScatter, directLight, directScattering*sh2, directMultiScattering*sh2, 1);
// color += max(cloudlighting - cloudlighting*exp(-muE*dd*dL),0.0) * absorbance;
// absorbance *= max(exp(-muE*dd*dL),0.0);
// }
// #endif
// if (min(dot(absorbance,vec3(0.335)),1.0) < 1e-5) break;
// }
// return vec4(color, min(dot(absorbance,vec3(0.335)),1.0));
// }
}