mirror of
https://github.com/X0nk/Bliss-Shader.git
synced 2024-12-23 01:59:39 +08:00
2ee6634935
new stuff reworked clouds, general lighting, end and nether shaders still WIP lighting is more balanced in general.
263 lines
9.3 KiB
GLSL
263 lines
9.3 KiB
GLSL
// this file contains all things for seasons, weather, and biome specific settings.
|
|
// i gotta start centralizing shit someday.
|
|
|
|
|
|
uniform float Day;
|
|
uniform float worldDay;
|
|
|
|
// it's so symmetrical~
|
|
|
|
float day0 = clamp(clamp(Day, 0.0,1.0)*clamp(2-Day, 0.0,1.0),0.0,1.0);
|
|
float day1 = clamp(clamp(Day-1, 0.0,1.0)*clamp(3-Day, 0.0,1.0),0.0,1.0);
|
|
float day2 = clamp(clamp(Day-2, 0.0,1.0)*clamp(4-Day, 0.0,1.0),0.0,1.0);
|
|
float day3 = clamp(clamp(Day-3, 0.0,1.0)*clamp(5-Day, 0.0,1.0),0.0,1.0);
|
|
float day4 = clamp(clamp(Day-4, 0.0,1.0)*clamp(6-Day, 0.0,1.0),0.0,1.0);
|
|
float day5 = clamp(clamp(Day-5, 0.0,1.0)*clamp(7-Day, 0.0,1.0),0.0,1.0);
|
|
float day6 = clamp(clamp(Day-6, 0.0,1.0)*clamp(8-Day, 0.0,1.0),0.0,1.0);
|
|
float day7 = clamp(clamp(Day-7, 0.0,1.0)*clamp(9-Day, 0.0,1.0),0.0,1.0);
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////// SEASONS /////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////// VERTEX SHADER
|
|
#ifdef Seasons
|
|
#ifdef SEASONS_VSH
|
|
|
|
varying vec4 seasonColor;
|
|
|
|
void YearCycleColor (
|
|
inout vec3 FinalColor,
|
|
vec3 glcolor
|
|
){
|
|
// colors for things that arent leaves and using the tint index.
|
|
vec3 SummerCol = vec3(Summer_R, Summer_G, Summer_B);
|
|
vec3 AutumnCol = vec3(Fall_R, Fall_G, Fall_B);
|
|
vec3 WinterCol = vec3(Winter_R, Winter_G, Winter_B) ;
|
|
vec3 SpringCol = vec3(Spring_R, Spring_G, Spring_B);
|
|
|
|
// decide if you want to replace biome colors or tint them.
|
|
SummerCol *= glcolor;
|
|
AutumnCol *= glcolor;
|
|
WinterCol *= glcolor;
|
|
SpringCol *= glcolor;
|
|
|
|
// do leaf colors different because thats cool and i like it
|
|
if(mc_Entity.x == 10003){
|
|
SummerCol = vec3(Summer_Leaf_R, Summer_Leaf_G, Summer_Leaf_B);
|
|
AutumnCol = vec3(Fall_Leaf_R, Fall_Leaf_G, Fall_Leaf_B);
|
|
WinterCol = vec3(Winter_Leaf_R, Winter_Leaf_G, Winter_Leaf_B);
|
|
SpringCol = vec3(Spring_Leaf_R, Spring_Leaf_G, Spring_Leaf_B);
|
|
|
|
SummerCol *= glcolor;
|
|
AutumnCol *= glcolor;
|
|
WinterCol *= glcolor;
|
|
SpringCol *= glcolor;
|
|
}
|
|
|
|
// length of each season in minecraft days
|
|
int SeasonLength = Season_Length;
|
|
|
|
// loop the year. multiply the season length by the 4 seasons to create a years time.
|
|
float YearLoop = mod(worldDay, SeasonLength * 4);
|
|
|
|
// the time schedule for each season
|
|
float SummerTime = clamp(YearLoop ,0, SeasonLength) / SeasonLength;
|
|
float AutumnTime = clamp(YearLoop - SeasonLength ,0, SeasonLength) / SeasonLength;
|
|
float WinterTime = clamp(YearLoop - SeasonLength*2 ,0, SeasonLength) / SeasonLength;
|
|
float SpringTime = clamp(YearLoop - SeasonLength*3 ,0, SeasonLength) / SeasonLength;
|
|
|
|
// lerp all season colors together
|
|
vec3 SummerToFall = mix(SummerCol, AutumnCol, SummerTime);
|
|
vec3 FallToWinter = mix(SummerToFall, WinterCol, AutumnTime);
|
|
vec3 WinterToSpring = mix(FallToWinter, SpringCol, WinterTime);
|
|
vec3 SpringToSummer = mix(WinterToSpring, SummerCol, SpringTime);
|
|
|
|
// make it so that you only have access to parts of the texture that use the tint index
|
|
bool IsTintIndex = floor(dot(glcolor,vec3(0.5))) < 1.0;
|
|
|
|
// multiply final color by the final lerped color, because it contains all the other colors.
|
|
FinalColor = SpringToSummer;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////// DAILY WEATHER //////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#ifdef WEATHERCLOUDS
|
|
uniform float CumulusCoverage;
|
|
uniform float CirrusCoverage;
|
|
uniform float CirrusThickness;
|
|
|
|
float DailyWeather_LowAltitude(
|
|
float Coverage
|
|
){
|
|
|
|
// #ifdef Daily_Weather
|
|
// int W_DAY = WeatherDay;
|
|
|
|
// if(W_DAY > -1) {
|
|
// if(W_DAY == 0) Coverage += 0.1;
|
|
// if(W_DAY == 1) Coverage += 0.5;
|
|
// if(W_DAY == 2) Coverage += 0.2;
|
|
// if(W_DAY == 3) Coverage += 0.8;
|
|
// if(W_DAY == 4) Coverage += 0.1;
|
|
// if(W_DAY == 5) Coverage += 0.6;
|
|
// if(W_DAY == 6) Coverage += 0.0;
|
|
// if(W_DAY == 7) Coverage += 1.0;
|
|
// }else{
|
|
// Coverage += mix(CumulusCoverage, Rain_coverage, rainStrength);
|
|
// }
|
|
// #else
|
|
// Coverage += mix(cloudCoverage, Rain_coverage, rainStrength);
|
|
// #endif
|
|
|
|
#ifdef Daily_Weather
|
|
Coverage += day0 * 0.3 + day1 * 0.8 + day2 * 0.2 + day3 * 0.0 + day4 * 0.8 + day5 * 0.5 + day6 * -0.5 + day7 * 0.6;
|
|
#else
|
|
Coverage += mix(Cumulus_coverage, Rain_coverage, rainStrength);
|
|
// Coverage = mix(Coverage, Rain_coverage, rainStrength);
|
|
#endif
|
|
|
|
return Coverage;
|
|
|
|
|
|
}
|
|
|
|
void DailyWeather_HighAltitude(
|
|
inout float Coverage,
|
|
inout float Thickness
|
|
){
|
|
|
|
#ifdef Daily_Weather
|
|
float W_DAY = WeatherDay;
|
|
|
|
if(W_DAY > -1) {
|
|
if(W_DAY == 0){ Coverage = 0.8; Thickness = 0.5; }
|
|
if(W_DAY == 1){ Coverage = 0.8; Thickness = 0.5; }
|
|
if(W_DAY == 2){ Coverage = 0.0; Thickness = 0.5; }
|
|
if(W_DAY == 3){ Coverage = 0.0; Thickness = 0.5; }
|
|
if(W_DAY == 4){ Coverage = 0.0; Thickness = 0.5; }
|
|
if(W_DAY == 5){ Coverage = 0.0; Thickness = 0.5; }
|
|
if(W_DAY == 6){ Coverage = 0.0; Thickness = 0.5; }
|
|
if(W_DAY == 7){ Coverage = 0.0; Thickness = 0.5; }
|
|
}else{
|
|
Coverage = CirrusCoverage;
|
|
Thickness = CirrusThickness;
|
|
}
|
|
#else
|
|
Coverage = 0.7;
|
|
Thickness = 0.05;
|
|
#endif
|
|
|
|
Coverage = pow(1.0-Coverage,3) * 50;
|
|
Thickness = Thickness * 10;
|
|
}
|
|
#endif
|
|
|
|
#ifdef Daily_Weather
|
|
|
|
void DailyWeather_FogDensity(
|
|
inout vec4 UniformDensity,
|
|
inout vec4 CloudyDensity
|
|
){
|
|
|
|
// set fog Profiles for each of the 8 days in the cycle.
|
|
// U = uniform fog || C = cloudy fog
|
|
vec4 MistyDay_U = vec4(5);
|
|
|
|
vec4 FoggyDay_U = vec4(5);
|
|
vec4 FoggyDay_C = vec4(25);
|
|
|
|
|
|
UniformDensity += FoggyDay_U*day1 + MistyDay_U*day4;
|
|
CloudyDensity += FoggyDay_C*day1;
|
|
}
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////// BIOME SPECIFICS /////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef Biome_specific_environment
|
|
uniform float isJungles;
|
|
uniform float isSwamps;
|
|
uniform float isLush;
|
|
uniform float isDeserts;
|
|
|
|
void BiomeFogColor(
|
|
inout vec3 FinalFogColor
|
|
){
|
|
// this is a little complicated? lmao
|
|
vec3 BiomeColors;
|
|
BiomeColors.r = isSwamps*0.7 + isJungles*0.5;
|
|
BiomeColors.g = isSwamps*1.0 + isJungles*1.0;
|
|
BiomeColors.b = isSwamps*0.35 + isJungles*0.8;
|
|
|
|
// insure the biome colors are locked to the fog shape and lighting, but not its orignal color.
|
|
BiomeColors *= dot(FinalFogColor,vec3(0.33));
|
|
|
|
// these range 0.0-1.0. they will never overlap.
|
|
float Inbiome = isJungles+isSwamps;
|
|
|
|
// interpoloate between normal fog colors and biome colors. the transition speeds are conrolled by the biome uniforms.
|
|
FinalFogColor = mix(FinalFogColor, BiomeColors, Inbiome);
|
|
}
|
|
|
|
void BiomeFogDensity(
|
|
inout vec4 UniformDensity,
|
|
inout vec4 CloudyDensity
|
|
){
|
|
// these range 0.0-1.0. they will never overlap.
|
|
float Inbiome = isJungles+isSwamps;
|
|
|
|
vec2 BiomeFogDensity; // x = uniform || y = cloudy
|
|
BiomeFogDensity.x = isSwamps*1 + isJungles*5;
|
|
BiomeFogDensity.y = isSwamps*5 + isJungles*2;
|
|
|
|
UniformDensity = mix(UniformDensity, vec4(BiomeFogDensity.x), Inbiome);
|
|
CloudyDensity = mix(CloudyDensity, vec4(BiomeFogDensity.y), Inbiome);
|
|
}
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////// FOG CONTROLLER /////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef TIMEOFDAYFOG
|
|
uniform int worldTime;
|
|
void TimeOfDayFog(inout float Uniform, inout float Cloudy) {
|
|
|
|
float Time = (worldTime%24000)*1.0;
|
|
|
|
// set schedules for fog to appear at specific ranges of time in the day.
|
|
float Morning = clamp((Time-22000)/2000,0,1) + clamp((2000-Time)/2000,0,1);
|
|
float Noon = clamp(Time/2000,0,1) * clamp((12000-Time)/2000,0,1);
|
|
float Evening = clamp((Time-10000)/2000,0,1) * clamp((14000-Time)/2000,0,1) ;
|
|
float Night = clamp((Time-13000)/2000,0,1) * clamp((23000-Time)/2000,0,1) ;
|
|
|
|
// set densities. morn, noon, even, night
|
|
vec4 UniformDensity = TOD_Fog_mult * vec4(Morning_Uniform_Fog, Noon_Uniform_Fog, Evening_Uniform_Fog, Night_Uniform_Fog);
|
|
vec4 CloudyDensity = TOD_Fog_mult * vec4(Morning_Cloudy_Fog, Noon_Cloudy_Fog, Evening_Cloudy_Fog, Night_Cloudy_Fog);
|
|
|
|
|
|
#ifdef Daily_Weather
|
|
DailyWeather_FogDensity(UniformDensity, CloudyDensity); // let daily weather influence fog densities.
|
|
#endif
|
|
|
|
#ifdef Biome_specific_environment
|
|
BiomeFogDensity(UniformDensity, CloudyDensity); // let biome fog hijack to control densities, and overrride any other density controller...
|
|
#endif
|
|
|
|
Uniform *= Morning*UniformDensity.r + Noon*UniformDensity.g + Evening*UniformDensity.b + Night*UniformDensity.a;
|
|
Cloudy *= Morning*CloudyDensity.r + Noon*CloudyDensity.g + Evening*CloudyDensity.b + Night*CloudyDensity.a;
|
|
}
|
|
#endif
|