init
This commit is contained in:
snusxd
@@ -0,0 +1,411 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
flat in float vlFactor;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float vlTime = min(abs(SdotU) - 0.05, 0.15) / 0.15;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
float GetLinearDepth(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near));
|
||||
}
|
||||
|
||||
// vec2 Reprojection(vec3 pos) {
|
||||
// pos = pos * 2.0 - 1.0;
|
||||
|
||||
// vec4 viewPosPrev = gbufferProjectionInverse * vec4(pos, 1.0);
|
||||
// viewPosPrev /= viewPosPrev.w;
|
||||
// viewPosPrev = gbufferModelViewInverse * viewPosPrev;
|
||||
|
||||
// vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
// cameraOffset *= float(pos.z > 0.56);
|
||||
|
||||
// vec4 previousPosition = viewPosPrev + vec4(cameraOffset, 0.0);
|
||||
// previousPosition = gbufferPreviousModelView * previousPosition;
|
||||
// previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
// return previousPosition.xy / previousPosition.w * 0.5 + 0.5;
|
||||
// } // will leave it in here because not 100% sure if float(z * 2.0 - 1.0 > 0.56); is correct or if it doesn't need the * 2.0 - 1.0 conversion
|
||||
|
||||
vec2 OffsetDist(float x) {
|
||||
float n = fract(x * 16.2) * 2 * pi;
|
||||
return vec2(cos(n), sin(n)) * x;
|
||||
}
|
||||
|
||||
vec3 GetMultiColoredBlocklight(vec2 coord, float z, float dither) {
|
||||
vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
cameraOffset *= float(z * 2.0 - 1.0 > 0.56);
|
||||
|
||||
vec2 prevCoord = Reprojection(vec3(coord, z), cameraOffset);
|
||||
float lz = GetLinearDepth(z);
|
||||
|
||||
float distScale = clamp((far - near) * lz + near, 4.0, 128.0);
|
||||
float fovScale = gbufferProjection[1][1] / 1.37;
|
||||
|
||||
vec2 blurstr = vec2(1.0 / (viewWidth / viewHeight), 1.0) * fovScale / distScale;
|
||||
vec3 lightAlbedo = texture2D(colortex8, coord).rgb;
|
||||
vec3 previousColoredLight = vec3(0.0);
|
||||
|
||||
float mask = clamp(2.0 - 2.0 * max(abs(prevCoord.x - 0.5), abs(prevCoord.y - 0.5)), 0.0, 1.0);
|
||||
|
||||
vec2 offset = OffsetDist(dither) * blurstr;
|
||||
|
||||
vec2 sampleZPos = coord + offset;
|
||||
float sampleZ0 = texture2D(depthtex0, sampleZPos).r;
|
||||
float sampleZ1 = texture2D(depthtex1, sampleZPos).r;
|
||||
float linearSampleZ = GetLinearDepth(sampleZ1 >= 1.0 ? sampleZ0 : sampleZ1);
|
||||
|
||||
float sampleWeight = clamp(abs(lz - linearSampleZ) * far / 16.0, 0.0, 1.0);
|
||||
sampleWeight = 1.0 - sampleWeight * sampleWeight;
|
||||
|
||||
previousColoredLight += texture2D(colortex9, prevCoord.xy + offset).rgb * sampleWeight;
|
||||
previousColoredLight *= previousColoredLight * mask;
|
||||
|
||||
if (lightAlbedo.g + lightAlbedo.b < 0.05) lightAlbedo.r *= 0.45; // red color reduction to prevent redstone from overpowering everything
|
||||
|
||||
return sqrt(mix(previousColoredLight, lightAlbedo * lightAlbedo / clamp(previousColoredLight.r + previousColoredLight.g + previousColoredLight.b, 0.01, 1.0), 0.01));
|
||||
}
|
||||
#endif
|
||||
|
||||
//Includes//
|
||||
#include "/lib/atmospherics/fog/waterFog.glsl"
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE
|
||||
#include "/lib/atmospherics/fog/bloomFog.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
#if defined END && defined END_BEAMS
|
||||
#include "/lib/atmospherics/enderBeams.glsl"
|
||||
#elif defined OVERWORLD && defined OVERWORLD_BEAMS
|
||||
#include "/lib/atmospherics/overworldBeams.glsl"
|
||||
#endif
|
||||
#include "/lib/atmospherics/volumetricLight.glsl"
|
||||
#endif
|
||||
|
||||
#if WATER_MAT_QUALITY >= 3 || defined NETHER_STORM || defined COLORED_LIGHT_FOG || END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#endif
|
||||
|
||||
#if WATER_MAT_QUALITY >= 3
|
||||
#include "/lib/materials/materialMethods/refraction.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_STORM
|
||||
#include "/lib/atmospherics/netherStorm.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#if RAINBOWS > 0 && defined OVERWORLD && !defined SPOOKY
|
||||
#include "/lib/atmospherics/rainbow.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLORED_LIGHT_FOG
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#include "/lib/atmospherics/fog/coloredLightFog.glsl"
|
||||
#endif
|
||||
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#include "/lib/atmospherics/endCrystalVortex.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
#include "/lib/atmospherics/endPortalBeam.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex0, texelCoord, 0).rgb;
|
||||
float z0 = texelFetch(depthtex0, texelCoord, 0).r;
|
||||
float z1 = texelFetch(depthtex1, texelCoord, 0).r;
|
||||
|
||||
vec4 screenPos = vec4(texCoord, z0, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos.xyz);
|
||||
|
||||
#if defined DISTANT_HORIZONS && !defined OVERWORLD
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPos = min(lViewPos, length(viewPosDH.xyz));
|
||||
#endif
|
||||
|
||||
float dither = texture2D(noisetex, texCoord * view / 128.0).b;
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
float lightZ = z1 >= 1.0 ? z0 : z1;
|
||||
vec3 coloredLight = GetMultiColoredBlocklight(texCoord, lightZ, dither);
|
||||
#endif
|
||||
|
||||
/* TM5723: The "1.0 - translucentMult" trick is done because of the default color attachment
|
||||
value being vec3(0.0). This makes it vec3(1.0) to avoid issues especially on improved glass */
|
||||
vec3 translucentMult = 1.0 - texelFetch(colortex3, texelCoord, 0).rgb; //TM5723
|
||||
vec4 volumetricEffect = vec4(0.0);
|
||||
|
||||
#if WATER_MAT_QUALITY >= 3
|
||||
DoRefraction(color, z0, z1, viewPos.xyz, lViewPos);
|
||||
#endif
|
||||
|
||||
vec4 screenPos1 = vec4(texCoord, z1, 1.0);
|
||||
vec4 viewPos1 = gbufferProjectionInverse * (screenPos1 * 2.0 - 1.0);
|
||||
viewPos1 /= viewPos1.w;
|
||||
float lViewPos1 = length(viewPos1.xyz);
|
||||
|
||||
#if defined DISTANT_HORIZONS && !defined OVERWORLD
|
||||
float z1DH = texelFetch(dhDepthTex1, texelCoord, 0).r;
|
||||
vec4 screenPos1DH = vec4(texCoord, z1DH, 1.0);
|
||||
vec4 viewPos1DH = dhProjectionInverse * (screenPos1DH * 2.0 - 1.0);
|
||||
viewPos1DH /= viewPos1DH.w;
|
||||
lViewPos1 = min(lViewPos1, length(viewPos1DH.xyz));
|
||||
#endif
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE || RAINBOWS > 0 && defined OVERWORLD
|
||||
vec3 nViewPos = normalize(viewPos1.xyz);
|
||||
float VdotL = dot(nViewPos, lightVec);
|
||||
#endif
|
||||
|
||||
#if defined NETHER_STORM || defined COLORED_LIGHT_FOG || END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
vec3 playerPos = ViewToPlayer(viewPos1.xyz);
|
||||
vec3 nPlayerPos = normalize(playerPos);
|
||||
#endif
|
||||
|
||||
#if RAINBOWS > 0 && defined OVERWORLD && !defined SPOOKY
|
||||
if (isEyeInWater == 0) color += GetRainbow(translucentMult, z0, z1, lViewPos, lViewPos1, VdotL, dither);
|
||||
#endif
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
float vlFactorM = vlFactor;
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
|
||||
volumetricEffect = GetVolumetricLight(color, vlFactorM, translucentMult, lViewPos, lViewPos1, nViewPos, VdotL, VdotU, texCoord, z0, z1, dither);
|
||||
#endif
|
||||
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
volumetricEffect = sqrt(pow2(volumetricEffect) + pow2(EndCrystalVortices(vec3(0.0), playerPos, dither)));
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_STORM
|
||||
volumetricEffect = GetNetherStorm(color, translucentMult, nPlayerPos, playerPos, lViewPos, lViewPos1, dither);
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
volumetricEffect.rgb *= GetAtmColorMult();
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
volumetricEffect.rgb *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
volumetricEffect = sqrt(pow2(volumetricEffect) + pow2(GetEndPortalBeam(vec3(0.0), playerPos)));
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_STORM
|
||||
color = mix(color, volumetricEffect.rgb, volumetricEffect.a);
|
||||
#endif
|
||||
|
||||
float lightFogLength = 0.0;
|
||||
#ifdef COLORED_LIGHT_FOG
|
||||
vec3 lightFog = GetColoredLightFog(nPlayerPos, translucentMult, lViewPos, lViewPos1, dither);
|
||||
float lightFogMult = COLORED_LIGHT_FOG_I;
|
||||
//if (heldItemId == 40000 && heldItemId2 != 40000) lightFogMult = 0.0; // Hold spider eye to disable light fog
|
||||
|
||||
#ifdef OVERWORLD
|
||||
lightFogMult *= 0.2 + 0.6 * mix(1.0, 1.0 - sunFactor * invRainFactor, eyeBrightnessM);
|
||||
#endif
|
||||
|
||||
color /= 1.0 + pow2(GetLuminance(lightFog)) * lightFogMult * 2.0;
|
||||
color += lightFog * lightFogMult * 0.5;
|
||||
lightFogLength = pow3(length(lightFog));
|
||||
// color = vec3(lightFogLength);
|
||||
#endif
|
||||
|
||||
if (isEyeInWater == 1) {
|
||||
if (z0 == 1.0) color.rgb = waterFogColor;
|
||||
|
||||
vec3 underwaterMult = vec3(0.80, 0.87, 0.97);
|
||||
#ifdef DARKER_DEPTH_OCEANS
|
||||
float renderDistanceFade = lViewPos * 5.0 / renderDistance;
|
||||
vec4 texture6 = texelFetch(colortex6, texelCoord, 0);
|
||||
|
||||
float lightSourceFactor = pow3(1.0 - texture6.a);
|
||||
lightSourceFactor += renderDistanceFade;
|
||||
lightSourceFactor = clamp01(lightSourceFactor);
|
||||
|
||||
float heldLight = max(heldBlockLightValue, heldBlockLightValue2);
|
||||
if (heldLight > 0){
|
||||
if (heldItemId == 45032 || heldItemId2 == 45032) heldLight = 15; // Lava Bucket
|
||||
heldLight = clamp(heldLight, 0.0, 15.0);
|
||||
heldLight = sqrt2(heldLight / 15.0) * -1.0 + 1.0; // Normalize and invert
|
||||
heldLight = mix(heldLight, 1.0, clamp01((lViewPos) * 35.0 / renderDistance)); // Only do it around the player
|
||||
} else {
|
||||
heldLight = 1.0;
|
||||
}
|
||||
float mixFactor = heldLight * lightSourceFactor * (1.0 - nightVision);
|
||||
|
||||
float waterDepthStart = waterAltitude + 10;
|
||||
float depthFactor = clamp01(10.0 / abs(min(cameraPosition.y, waterDepthStart + 0.001) - waterDepthStart));
|
||||
float depthDarkness = clamp(abs(1.0 - (1.0 - depthFactor) * (1.0 - depthFactor)), 0.33, 1.0);
|
||||
|
||||
underwaterMult *= mix(1.0, depthDarkness, mixFactor);
|
||||
#endif
|
||||
color.rgb *= underwaterMult * 0.85;
|
||||
volumetricEffect.rgb *= pow2(underwaterMult * 0.71);
|
||||
} else {
|
||||
if (isEyeInWater == 2) {
|
||||
if (z1 == 1.0) color.rgb = fogColor * 5.0;
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 1.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 1.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
|
||||
volumetricEffect.rgb *= 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
// #if TONEMAP > 0
|
||||
// // convert rgb to linear:
|
||||
// const vec3 a = vec3(0.055f);
|
||||
// color = mix(pow((color.rgb + a)/(vec3(1.0f) + a), vec3(2.4)), color.rgb / 12.92f, lessThan(color.rgb, vec3(0.04045f)));
|
||||
// #else
|
||||
color = pow(color, vec3(2.2));
|
||||
// #endif
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE || defined END_PORTAL_BEAM_INTERNAL
|
||||
#ifdef END
|
||||
volumetricEffect.rgb *= volumetricEffect.rgb;
|
||||
#endif
|
||||
|
||||
color += volumetricEffect.rgb;
|
||||
#endif
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE
|
||||
color *= GetBloomFog(lViewPos); // Reminder: Bloom Fog can move between composite1-2-3
|
||||
#endif
|
||||
|
||||
#if RETRO_LOOK == 1
|
||||
color.rgb *= vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.5 * RETRO_LOOK_I;
|
||||
#elif RETRO_LOOK == 2
|
||||
color.rgb *= mix(vec3(1.0), vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.5, nightVision) * RETRO_LOOK_I;
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
|
||||
// supposed to be #if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
#if LIGHTSHAFT_QUALI_DEFINE > 0 && LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 && defined OVERWORLD || defined END
|
||||
#if LENSFLARE_MODE > 0 || defined ENTITY_TAA_NOISY_CLOUD_FIX
|
||||
if (viewWidth + viewHeight - gl_FragCoord.x - gl_FragCoord.y > 1.5)
|
||||
vlFactorM = texelFetch(colortex4, texelCoord, 0).r;
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:04 */
|
||||
gl_FragData[1] = vec4(vlFactorM, 0.0, 0.0, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:049 */
|
||||
gl_FragData[2] = vec4(coloredLight, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:09 */
|
||||
gl_FragData[1] = vec4(coloredLight, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
flat out float vlFactor;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#ifdef LIGHTSHAFTS_ACTIVE
|
||||
#if LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END
|
||||
vlFactor = texelFetch(colortex4, ivec2(viewWidth-1, viewHeight-1), 0).r;
|
||||
#else
|
||||
#if LIGHTSHAFT_BEHAVIOUR == 2
|
||||
vlFactor = 0.0;
|
||||
#elif LIGHTSHAFT_BEHAVIOUR == 3
|
||||
vlFactor = 1.0;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,142 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
#ifdef MOTION_BLURRING
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE2
|
||||
flat in vec3 upVec, sunVec;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
#if defined MOTION_BLURRING && defined BLOOM_FOG_COMPOSITE2
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
#ifdef MOTION_BLURRING
|
||||
vec3 MotionBlur(vec3 color, float z, float dither) {
|
||||
if (z > 0.56) {
|
||||
float mbwg = 0.0;
|
||||
vec2 doublePixel = 2.0 / vec2(viewWidth, viewHeight);
|
||||
vec3 mblur = vec3(0.0);
|
||||
|
||||
vec4 currentPosition = vec4(texCoord, z, 1.0) * 2.0 - 1.0;
|
||||
|
||||
vec4 viewPos = gbufferProjectionInverse * currentPosition;
|
||||
viewPos = gbufferModelViewInverse * viewPos;
|
||||
viewPos /= viewPos.w;
|
||||
|
||||
vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
|
||||
vec4 previousPosition = viewPos + vec4(cameraOffset, 0.0);
|
||||
previousPosition = gbufferPreviousModelView * previousPosition;
|
||||
previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
previousPosition /= previousPosition.w;
|
||||
|
||||
vec2 velocity = (currentPosition - previousPosition).xy;
|
||||
velocity = velocity / (1.0 + length(velocity)) * MOTION_BLURRING_STRENGTH * 0.02;
|
||||
|
||||
vec2 coord = texCoord - velocity * (3.5 + dither);
|
||||
for (int i = 0; i < 9; i++, coord += velocity) {
|
||||
vec2 coordb = clamp(coord, doublePixel, 1.0 - doublePixel);
|
||||
mblur += texture2DLod(colortex0, coordb, 0).rgb;
|
||||
mbwg += 1.0;
|
||||
}
|
||||
mblur /= mbwg;
|
||||
|
||||
return mblur;
|
||||
} else return color;
|
||||
}
|
||||
#endif
|
||||
|
||||
//Includes//
|
||||
#ifdef MOTION_BLURRING
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE2
|
||||
#include "/lib/atmospherics/fog/bloomFog.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex0, texelCoord, 0).rgb;
|
||||
|
||||
#ifdef MOTION_BLURRING
|
||||
float z = texture2D(depthtex1, texCoord).x;
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
|
||||
color = MotionBlur(color, z, dither);
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE2
|
||||
float z0 = texelFetch(depthtex0, texelCoord, 0).r;
|
||||
vec4 screenPos = vec4(texCoord, z0, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos.xyz);
|
||||
|
||||
#if defined DISTANT_HORIZONS && defined NETHER
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPos = min(lViewPos, length(viewPosDH.xyz));
|
||||
#endif
|
||||
|
||||
color *= GetBloomFog(lViewPos); // Reminder: Bloom Fog can move between composite1-2-3
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
#ifdef MOTION_BLURRING
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE2
|
||||
flat out vec3 upVec, sunVec;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
#ifdef MOTION_BLURRING
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE2
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,224 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
const bool colortex0MipmapEnabled = true;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
#if (WORLD_BLUR == 2 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0) && WB_DOF_FOCUS >= 0
|
||||
#if WB_DOF_FOCUS == 0
|
||||
uniform float centerDepthSmooth;
|
||||
#else
|
||||
float centerDepthSmooth = (far * (WB_DOF_FOCUS - near)) / (WB_DOF_FOCUS * (far - near));
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
|
||||
vec2 dofOffsets[18] = vec2[18](
|
||||
vec2( 0.0 , 0.25 ),
|
||||
vec2(-0.2165 , 0.125 ),
|
||||
vec2(-0.2165 , -0.125 ),
|
||||
vec2( 0 , -0.25 ),
|
||||
vec2( 0.2165 , -0.125 ),
|
||||
vec2( 0.2165 , 0.125 ),
|
||||
vec2( 0 , 0.5 ),
|
||||
vec2(-0.25 , 0.433 ),
|
||||
vec2(-0.433 , 0.25 ),
|
||||
vec2(-0.5 , 0 ),
|
||||
vec2(-0.433 , -0.25 ),
|
||||
vec2(-0.25 , -0.433 ),
|
||||
vec2( 0 , -0.5 ),
|
||||
vec2( 0.25 , -0.433 ),
|
||||
vec2( 0.433 , -0.2 ),
|
||||
vec2( 0.5 , 0 ),
|
||||
vec2( 0.433 , 0.25 ),
|
||||
vec2( 0.25 , 0.433 )
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
void DoWorldBlur(inout vec3 color, float z1, float lViewPos0) {
|
||||
if (z1 < 0.56) return;
|
||||
vec3 dof = vec3(0.0);
|
||||
vec3 cocColor = vec3(1, 0, 0.8) * 10.0;
|
||||
vec2 dofScale = vec2(1.0, aspectRatio);
|
||||
|
||||
#if WORLD_BLUR == 1 // Distance Blur
|
||||
#ifdef OVERWORLD
|
||||
float dbMult;
|
||||
if (isEyeInWater == 0) {
|
||||
dbMult = mix(WB_DB_NIGHT_I, WB_DB_DAY_I, sunFactor * eyeBrightnessM);
|
||||
dbMult = mix(dbMult, WB_DB_RAIN_I, rainFactor * eyeBrightnessM);
|
||||
} else dbMult = WB_DB_WATER_I;
|
||||
#elif defined NETHER
|
||||
float dbMult = WB_DB_NETHER_I;
|
||||
#elif defined END
|
||||
float dbMult = WB_DB_END_I;
|
||||
#endif
|
||||
float coc = clamp(lViewPos0 * 0.001, 0.0, 0.1) * dbMult * 0.03;
|
||||
#elif WORLD_BLUR == 2 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0 // Depth Of Field
|
||||
#if TILT_SHIFT != 0
|
||||
float tiltOffset = texCoord.y * 2.0 - 1.0;
|
||||
tiltOffset *= 0.0007 * TILT_SHIFT;
|
||||
#else
|
||||
float tiltOffset = 0.0;
|
||||
#endif
|
||||
#if TILT_SHIFT2 != 0
|
||||
float shiftOffset = texCoord.x * 2.0 - 1.0;
|
||||
shiftOffset *= 0.0007 * TILT_SHIFT2;
|
||||
#else
|
||||
float shiftOffset = 0.0;
|
||||
#endif
|
||||
#if WB_DOF_FOCUS >= 0
|
||||
float coc = max(abs(z1 - centerDepthSmooth + tiltOffset + shiftOffset) * 0.125 * WB_DOF_I - 0.0001, 0.0);
|
||||
#elif WB_DOF_FOCUS == -1
|
||||
float coc = clamp(abs(lViewPos0 * 0.005 - pow2(vsBrightness) + tiltOffset + shiftOffset), 0.0, 0.1) * WB_DOF_I * 0.03;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef DOF_VIEW_FOCUS_NEW
|
||||
float cocView = float(coc < 0.005 + 0.001 * abs(max(float(TILT_SHIFT), float(TILT_SHIFT2))) && coc > 0 && hideGUI == 0);
|
||||
#endif
|
||||
#if TILT_SHIFT == 0 && TILT_SHIFT2 == 0
|
||||
coc = coc / sqrt(coc * coc + 0.1);
|
||||
#endif
|
||||
|
||||
#ifdef WB_FOV_SCALED
|
||||
coc *= gbufferProjection[1][1] * 0.8;
|
||||
#endif
|
||||
#ifdef WB_CHROMATIC
|
||||
float midDistX = texCoord.x - 0.5;
|
||||
float midDistY = texCoord.y - 0.5;
|
||||
vec2 chromaticScale = vec2(midDistX, midDistY);
|
||||
chromaticScale = sign(chromaticScale) * sqrt(abs(chromaticScale));
|
||||
chromaticScale *= vec2(1.0, viewHeight / viewWidth);
|
||||
vec2 aberration = (15.0 / vec2(viewWidth, viewHeight)) * chromaticScale * coc;
|
||||
#endif
|
||||
#ifdef WB_ANAMORPHIC
|
||||
dofScale *= vec2(0.5, 1.5);
|
||||
#endif
|
||||
|
||||
if (coc * 0.5 > 1.0 / max(viewWidth, viewHeight)) {
|
||||
for (int i = 0; i < 18; i++) {
|
||||
vec2 offset = dofOffsets[i] * coc * 0.0085 * dofScale;
|
||||
float lod = log2(viewHeight * aspectRatio * coc * 0.75 / 320.0);
|
||||
#ifndef WB_CHROMATIC
|
||||
dof += texture2DLod(colortex0, texCoord + offset, lod).rgb;
|
||||
#else
|
||||
dof += vec3(texture2DLod(colortex0, texCoord + offset + aberration, lod).r,
|
||||
texture2DLod(colortex0, texCoord + offset , lod).g,
|
||||
texture2DLod(colortex0, texCoord + offset - aberration, lod).b);
|
||||
#endif
|
||||
}
|
||||
dof /= 18.0;
|
||||
#ifdef WORLD_BLUR_SNEAK
|
||||
color = mix(color, dof, isSneaking);
|
||||
#else
|
||||
color = dof;
|
||||
#endif
|
||||
}
|
||||
#ifdef DOF_VIEW_FOCUS_NEW
|
||||
#ifdef WORLD_BLUR_SNEAK
|
||||
color = mix(color, cocColor, cocView * isSneaking);
|
||||
#else
|
||||
color = mix(color, cocColor, cocView);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
//Includes//
|
||||
#if (WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0) && defined BLOOM_FOG_COMPOSITE3
|
||||
#include "/lib/atmospherics/fog/bloomFog.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex0, texelCoord, 0).rgb;
|
||||
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
float z1 = texelFetch(depthtex1, texelCoord, 0).r;
|
||||
float z0 = texelFetch(depthtex0, texelCoord, 0).r;
|
||||
|
||||
vec4 screenPos = vec4(texCoord, z0, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos.xyz);
|
||||
|
||||
#if defined DISTANT_HORIZONS && defined NETHER
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPos = min(lViewPos, length(viewPosDH.xyz));
|
||||
#endif
|
||||
|
||||
// #ifdef WORLD_BLUR_SNEAK
|
||||
// if (isSneaking > 0.01) {
|
||||
// #endif
|
||||
DoWorldBlur(color, z1, lViewPos);
|
||||
// #ifdef WORLD_BLUR_SNEAK
|
||||
// }
|
||||
// #endif
|
||||
|
||||
#ifdef BLOOM_FOG_COMPOSITE3
|
||||
color *= GetBloomFog(lViewPos); // Reminder: Bloom Fog can move between composite1-2-3
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
#if WORLD_BLUR > 0 || TILT_SHIFT != 0 || TILT_SHIFT2 != 0
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,97 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//Varyings//
|
||||
varying vec2 texCoord;
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
//Pipeline Constants//
|
||||
const bool colortex0MipmapEnabled = true;
|
||||
|
||||
//Common Variables//
|
||||
float weight[7] = float[7](1.0, 6.0, 15.0, 20.0, 15.0, 6.0, 1.0);
|
||||
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
|
||||
//Common Functions//
|
||||
vec3 BloomTile(float lod, vec2 offset, vec2 scaledCoord) {
|
||||
vec3 bloom = vec3(0.0);
|
||||
float scale = exp2(lod);
|
||||
vec2 coord = (scaledCoord - offset) * scale;
|
||||
float padding = 0.5 + 0.005 * scale;
|
||||
|
||||
if (abs(coord.x - 0.5) < padding && abs(coord.y - 0.5) < padding) {
|
||||
for (int i = -3; i <= 3; i++) {
|
||||
for (int j = -3; j <= 3; j++) {
|
||||
float wg = weight[i + 3] * weight[j + 3];
|
||||
vec2 pixelOffset = vec2(i, j) / view;
|
||||
vec2 bloomCoord = (scaledCoord - offset + pixelOffset) * scale;
|
||||
bloom += texture2D(colortex0, bloomCoord).rgb * wg;
|
||||
}
|
||||
}
|
||||
bloom /= 4096.0;
|
||||
}
|
||||
|
||||
return pow(bloom / 128.0, vec3(0.25));
|
||||
}
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 blur = vec3(0.0);
|
||||
|
||||
#ifdef BLOOM
|
||||
vec2 scaledCoord = texCoord * max(vec2(viewWidth, viewHeight) / vec2(1920.0, 1080.0), vec2(1.0));
|
||||
|
||||
#if defined OVERWORLD || defined END
|
||||
blur += BloomTile(2.0, vec2(0.0 , 0.0 ), scaledCoord);
|
||||
blur += BloomTile(3.0, vec2(0.0 , 0.26 ), scaledCoord);
|
||||
blur += BloomTile(4.0, vec2(0.135 , 0.26 ), scaledCoord);
|
||||
blur += BloomTile(5.0, vec2(0.2075 , 0.26 ), scaledCoord) * 0.8;
|
||||
blur += BloomTile(6.0, vec2(0.135 , 0.3325), scaledCoord) * 0.8;
|
||||
blur += BloomTile(7.0, vec2(0.160625 , 0.3325), scaledCoord) * 0.6;
|
||||
blur += BloomTile(8.0, vec2(0.1784375, 0.3325), scaledCoord) * 0.4;
|
||||
#else
|
||||
blur += BloomTile(2.0, vec2(0.0 , 0.0 ), scaledCoord);
|
||||
blur += BloomTile(3.0, vec2(0.0 , 0.26 ), scaledCoord);
|
||||
blur += BloomTile(4.0, vec2(0.135 , 0.26 ), scaledCoord);
|
||||
blur += BloomTile(5.0, vec2(0.2075 , 0.26 ), scaledCoord);
|
||||
blur += BloomTile(6.0, vec2(0.135 , 0.3325), scaledCoord);
|
||||
blur += BloomTile(7.0, vec2(0.160625 , 0.3325), scaledCoord);
|
||||
blur += BloomTile(8.0, vec2(0.1784375, 0.3325), scaledCoord) * 0.6;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:3 */
|
||||
gl_FragData[0] = vec4(blur, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
texCoord = gl_MultiTexCoord0.xy;
|
||||
|
||||
gl_Position = ftransform();
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,726 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
#if defined BLOOM_FOG || LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
flat in vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float pw = 1.0 / viewWidth;
|
||||
float ph = 1.0 / viewHeight;
|
||||
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
|
||||
#if defined BLOOM_FOG || LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
vec3 DoBSLTonemap(vec3 color) {
|
||||
color = T_EXPOSURE * color;
|
||||
color = color / pow(pow(color, vec3(TM_WHITE_CURVE)) + 1.0, vec3(1.0 / TM_WHITE_CURVE));
|
||||
color = pow(color, mix(vec3(T_LOWER_CURVE), vec3(T_UPPER_CURVE), sqrt(color)));
|
||||
|
||||
return pow(color, vec3(1.0 / 2.2));
|
||||
}
|
||||
|
||||
void linearToRGB(inout vec3 color) {
|
||||
const vec3 k = vec3(0.055);
|
||||
color = mix((vec3(1.0) + k) * pow(color, vec3(1.0 / 2.4)) - k, 12.92 * color, lessThan(color, vec3(0.0031308)));
|
||||
}
|
||||
|
||||
void doColorAdjustments(inout vec3 color) {
|
||||
color = (T_EXPOSURE - 0.40) * color;
|
||||
// color = color / pow(pow(color, vec3(TM_WHITE_CURVE * 0.5)) + 1.0, vec3(1.0 / (TM_WHITE_CURVE * 0.5)));
|
||||
color = pow(color, mix(vec3(T_LOWER_CURVE - 0.20), vec3(T_UPPER_CURVE - 0.30), sqrt(color)));
|
||||
}
|
||||
|
||||
float saturationTM = T_SATURATION;
|
||||
|
||||
vec3 LottesTonemap(vec3 color) {
|
||||
// Lottes 2016, "Advanced Techniques and Optimization of HDR Color Pipelines"
|
||||
// http://32ipi028l5q82yhj72224m8j.wpengine.netdna-cdn.com/wp-content/uploads/2016/03/GdcVdrLottes.pdf
|
||||
const vec3 a = vec3(1.3);
|
||||
const vec3 d = vec3(0.95);
|
||||
const vec3 hdrMax = vec3(8.0);
|
||||
const vec3 midIn = vec3(0.25);
|
||||
const vec3 midOut = vec3(0.25);
|
||||
|
||||
const vec3 a_d = a * d;
|
||||
const vec3 hdrMaxA = pow(hdrMax, a);
|
||||
const vec3 hdrMaxAD = pow(hdrMax, a_d);
|
||||
const vec3 midInA = pow(midIn, a);
|
||||
const vec3 midInAD = pow(midIn, a_d);
|
||||
const vec3 HM1 = hdrMaxA * midOut;
|
||||
const vec3 HM2 = hdrMaxAD - midInAD;
|
||||
|
||||
const vec3 b = (-midInA + HM1) / (HM2 * midOut);
|
||||
const vec3 c = (hdrMaxAD * midInA - HM1 * midInAD) / (HM2 * midOut);
|
||||
|
||||
color = pow(color, a) / (pow(color, a_d) * b + c);
|
||||
|
||||
doColorAdjustments(color);
|
||||
|
||||
linearToRGB(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
// From https://github.com/godotengine/godot/blob/master/servers/rendering/renderer_rd/shaders/effects/tonemap.glsl
|
||||
// Adapted from https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
|
||||
// (MIT License).
|
||||
vec3 ACESTonemap(vec3 color) {
|
||||
float white = ACES_WHITE;
|
||||
const float exposure_bias = ACES_EXPOSURE;
|
||||
const float A = 0.0245786f;
|
||||
const float B = 0.000090537f;
|
||||
const float C = 0.983729f;
|
||||
const float D = 0.432951f;
|
||||
const float E = 0.238081f;
|
||||
|
||||
const mat3 rgb_to_rrt = mat3(
|
||||
vec3(0.59719f * exposure_bias, 0.35458f * exposure_bias, 0.04823f * exposure_bias),
|
||||
vec3(0.07600f * exposure_bias, 0.90834f * exposure_bias, 0.01566f * exposure_bias),
|
||||
vec3(0.02840f * exposure_bias, 0.13383f * exposure_bias, 0.83777f * exposure_bias));
|
||||
|
||||
const mat3 odt_to_rgb = mat3(
|
||||
vec3(1.60475f, -0.53108f, -0.07367f),
|
||||
vec3(-0.10208f, 1.10813f, -0.00605f),
|
||||
vec3(-0.00327f, -0.07276f, 1.07602f));
|
||||
color *= rgb_to_rrt;
|
||||
vec3 color_tonemapped = (color * (color + A) - B) / (color * (C * color + D) + E);
|
||||
color_tonemapped *= odt_to_rgb;
|
||||
|
||||
white *= exposure_bias;
|
||||
float white_tonemapped = (white * (white + A) - B) / (white * (C * white + D) + E);
|
||||
|
||||
color = color_tonemapped / white_tonemapped;
|
||||
color = clamp(color, vec3(0.0), vec3(1.0));
|
||||
doColorAdjustments(color);
|
||||
linearToRGB(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
vec3 ACESRedModified(vec3 color) {
|
||||
float white = ACES_WHITE;
|
||||
const float exposure_bias = ACES_EXPOSURE;
|
||||
const float A = 0.0245786f;
|
||||
const float B = 0.000090537f;
|
||||
const float C = 0.983729f;
|
||||
const float D = 0.432951f;
|
||||
const float E = 0.238081f;
|
||||
|
||||
const mat3 rgb_to_rrt = mat3(
|
||||
vec3(0.50719f * exposure_bias, 0.40458f * exposure_bias, 0.03823f * exposure_bias),
|
||||
vec3(0.00700f * exposure_bias, 0.95834f * exposure_bias, 0.00966f * exposure_bias),
|
||||
vec3(0.00200f * exposure_bias, 0.15383f * exposure_bias, 0.83777f * exposure_bias));
|
||||
|
||||
const mat3 odt_to_rgb = mat3(
|
||||
vec3(1.60475f, -0.53108f, -0.07367f),
|
||||
vec3(-0.10208f, 1.10813f, -0.00605f),
|
||||
vec3(-0.00327f, -0.07276f, 1.07602f));
|
||||
color *= rgb_to_rrt;
|
||||
vec3 color_tonemapped = (color * (color + A) - B) / (color * (C * color + D) + E);
|
||||
color_tonemapped *= odt_to_rgb;
|
||||
|
||||
white *= exposure_bias;
|
||||
float white_tonemapped = (white * (white + A) - B) / (white * (C * white + D) + E);
|
||||
|
||||
color = color_tonemapped / white_tonemapped;
|
||||
color = clamp(color, vec3(0.0), vec3(1.0));
|
||||
doColorAdjustments(color);
|
||||
linearToRGB(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
// Filmic tonemapping operator made by Jim Hejl and Richard Burgess
|
||||
// Modified by Tech to not lose color information below 0.004
|
||||
vec3 BurgessTonemap(vec3 rgb) {
|
||||
rgb = rgb * min(vec3(1.0), 1.0 - 0.8 * exp(1.0/-0.004 * rgb));
|
||||
rgb = (rgb * (6.2 * rgb + 0.5)) / (rgb * (6.2 * rgb + 1.7) + 0.06);
|
||||
doColorAdjustments(rgb);
|
||||
return rgb;
|
||||
}
|
||||
|
||||
// Filmic tonemapping operator made by John Hable for Uncharted 2
|
||||
vec3 uncharted2_tonemap_partial(vec3 color) {
|
||||
const float a = 0.15;
|
||||
const float b = 0.50;
|
||||
const float c = 0.10;
|
||||
const float d = 0.20;
|
||||
const float e = 0.02;
|
||||
const float f = 0.30;
|
||||
color = ((color * (a * color + (c * b)) + (d * e)) / (color * (a * color + b) + d * f)) - e / f;
|
||||
doColorAdjustments(color);
|
||||
linearToRGB(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
vec3 uncharted2_filmic(vec3 v) {
|
||||
float exposure_bias = 1.0f;
|
||||
vec3 curr = uncharted2_tonemap_partial(v * exposure_bias);
|
||||
|
||||
vec3 W = vec3(11.2f);
|
||||
vec3 white_scale = vec3(1.0f) / uncharted2_tonemap_partial(W);
|
||||
v = curr * white_scale;
|
||||
doColorAdjustments(v);
|
||||
linearToRGB(v);
|
||||
return v;
|
||||
}
|
||||
|
||||
vec3 reinhard2(vec3 x) {
|
||||
const float L_white = 4.0;
|
||||
linearToRGB(x);
|
||||
x = (x * (1.1 + x / (L_white * L_white))) / (1.0 + x);
|
||||
doColorAdjustments(x);
|
||||
return x;
|
||||
}
|
||||
|
||||
vec3 filmic(vec3 x) {
|
||||
linearToRGB(x);
|
||||
vec3 X = max(vec3(0.0), x - 0.004);
|
||||
vec3 result = (X * (6.2 * X + 0.5)) / (X * (6.2 * X + 1.7) + 0.06);
|
||||
x = pow(result, vec3(2.2));
|
||||
doColorAdjustments(x);
|
||||
return x;
|
||||
}
|
||||
|
||||
float GTTonemap(float x) { // source https://gist.github.com/shakesoda/1dcb3e159f586995ca076c8b21f05a67
|
||||
float m = 0.22; // linear section start
|
||||
float a = 1.0; // contrast
|
||||
float c = 1.33; // black brightness
|
||||
float P = 1.0; // maximum brightness
|
||||
float l = 0.4; // linear section length
|
||||
float l0 = ((P-m)*l) / a; // 0.312
|
||||
float S0 = m + l0; // 0.532
|
||||
float S1 = m + a * l0; // 0.532
|
||||
float C2 = (a*P) / (P - S1); // 2.13675213675
|
||||
float L = m + a * (x - m);
|
||||
float T = m * pow(x/m, c);
|
||||
float S = P - (P - S1) * exp(-C2*(x - S0)/P);
|
||||
float w0 = 1 - smoothstep(0.0, m, x);
|
||||
float w2 = (x < m+l)?0:1;
|
||||
float w1 = 1 - w0 - w2;
|
||||
return float(T * w0 + L * w1 + S * w2);
|
||||
}
|
||||
|
||||
// this costs about 0.2-0.3ms more than aces, as-is
|
||||
vec3 GTTonemap(vec3 x) {
|
||||
linearToRGB(x);
|
||||
x = vec3(GTTonemap(x.r), GTTonemap(x.g), GTTonemap(x.b));
|
||||
doColorAdjustments(x);
|
||||
return x;
|
||||
}
|
||||
|
||||
vec3 uchimura(vec3 x, float P, float a, float m, float l, float c, float b) { //Uchimura, H. (2017). HDR Theory and practice. https://www.slideshare.net/nikuque/hdr-theory-and-practicce-jp; https://github.com/dmnsgn/glsl-tone-map/blob/main/uchimura.glsl
|
||||
float l0 = ((P - m) * l) / a;
|
||||
float L0 = m - m / a;
|
||||
float L1 = m + (1.0 - m) / a;
|
||||
float S0 = m + l0;
|
||||
float S1 = m + a * l0;
|
||||
float C2 = (a * P) / (P - S1);
|
||||
float CP = -C2 / P;
|
||||
|
||||
vec3 w0 = vec3(1.0 - smoothstep(0.0, m, x));
|
||||
vec3 w2 = vec3(step(m + l0, x));
|
||||
vec3 w1 = vec3(1.0 - w0 - w2);
|
||||
|
||||
vec3 T = vec3(m * pow(x / m, vec3(c)) + b);
|
||||
vec3 S = vec3(P - (P - S1) * exp(CP * (x - S0)));
|
||||
vec3 L = vec3(m + a * (x - m));
|
||||
|
||||
return T * w0 + L * w1 + S * w2;
|
||||
}
|
||||
|
||||
vec3 uchimura(vec3 color) {
|
||||
const float P = 1.0; // max display brightness
|
||||
const float a = 1.0; // contrast
|
||||
const float m = 0.22; // linear section start
|
||||
const float l = 0.4; // linear section length
|
||||
const float c = 1.33; // black
|
||||
const float b = 0.0; // pedestal
|
||||
linearToRGB(color);
|
||||
color = uchimura(color, P, a, m, l, c, b);
|
||||
doColorAdjustments(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
// const mat3 agxTransform = mat3(
|
||||
// 0.842479062253094 , 0.0423282422610123, 0.0423756549057051,
|
||||
// 0.0784335999999992, 0.878468636469772 , 0.0784336,
|
||||
// 0.0792237451477643, 0.0791661274605434, 0.879142973793104
|
||||
// );
|
||||
|
||||
// const mat3 agxTransformInverse = mat3(
|
||||
// 1.19687900512017 , -0.0528968517574562, -0.0529716355144438,
|
||||
// -0.0980208811401368, 1.15190312990417 , -0.0980434501171241,
|
||||
// -0.0990297440797205, -0.0989611768448433, 1.15107367264116
|
||||
// );
|
||||
|
||||
// vec3 agxDefaultContrastApproximation(vec3 x) {
|
||||
// vec3 x2 = x * x;
|
||||
// vec3 x4 = x2 * x2;
|
||||
|
||||
// return + 15.5 * x4 * x2
|
||||
// - 40.14 * x4 * x
|
||||
// + 31.96 * x4
|
||||
// - 6.868 * x2 * x
|
||||
// + 0.4298 * x2
|
||||
// + 0.1191 * x
|
||||
// - 0.00232;
|
||||
// }
|
||||
|
||||
// void agx(inout vec3 color) {
|
||||
// const float minEv = -12.47393;
|
||||
// const float maxEv = 4.026069;
|
||||
|
||||
// color = agxTransform * color;
|
||||
// color = clamp(log2(color), minEv, maxEv);
|
||||
// color = (color - minEv) / (maxEv - minEv);
|
||||
// color = agxDefaultContrastApproximation(color);
|
||||
// }
|
||||
|
||||
// void agxEotf(inout vec3 color) {
|
||||
// color = agxTransformInverse * color;
|
||||
// }
|
||||
|
||||
// void agxLook(inout vec3 color) {
|
||||
// #if AGX_LOOK == 0 // Default
|
||||
// const vec3 slope = vec3(1.0);
|
||||
// const vec3 power = vec3(1.0);
|
||||
// #elif AGX_LOOK == 1 // Golden
|
||||
// const vec3 slope = vec3(1.0, 0.9, 0.5);
|
||||
// const vec3 power = vec3(0.8);
|
||||
// saturationTM *= 0.8;
|
||||
// #elif AGX_LOOK == 2 // Punchy
|
||||
// const vec3 slope = vec3(1.1);
|
||||
// const vec3 power = vec3(1.2);
|
||||
// saturationTM *= 1.2;
|
||||
// #else
|
||||
// const vec3 slope = vec3(AGX_R, AGX_G, AGX_B) / 256;
|
||||
// const vec3 power = vec3(AGX_POWER);
|
||||
// #endif
|
||||
|
||||
// color = pow(color * slope, power);
|
||||
// }
|
||||
|
||||
// vec3 agxTonemap(vec3 color) { // Minimal version of Troy Sobotka's AgX by bwrensch https://www.shadertoy.com/view/cd3XWr
|
||||
// agx(color);
|
||||
// agxLook(color);
|
||||
// agxEotf(color);
|
||||
// doColorAdjustments(color);
|
||||
// return color;
|
||||
// }
|
||||
|
||||
vec3 agxDefaultContrastApprox(vec3 x) {
|
||||
vec3 x2 = x * x;
|
||||
vec3 x4 = x2 * x2;
|
||||
|
||||
return x*(+0.12410293f
|
||||
+x*(+0.2078625f
|
||||
+x*(-5.9293431f
|
||||
+x*(+30.376821f
|
||||
+x*(-38.901506f
|
||||
+x*(+15.122061f))))));
|
||||
}
|
||||
|
||||
vec3 agx(vec3 val) {
|
||||
const mat3 agx_mat = mat3(
|
||||
0.842479062253094, 0.0423282422610123, 0.0423756549057051,
|
||||
0.0784335999999992, 0.878468636469772, 0.0784336,
|
||||
0.0792237451477643, 0.0791661274605434, 0.879142973793104);
|
||||
const float minEv = -12.47393f;
|
||||
const float maxEv = 4.026069f;
|
||||
|
||||
// Input transform
|
||||
val = agx_mat * val;
|
||||
|
||||
// Log2 space encoding
|
||||
val = clamp(log2(val), minEv, maxEv);
|
||||
val = (val - minEv) / (maxEv - minEv);
|
||||
|
||||
// Apply sigmoid function approximation
|
||||
val = agxDefaultContrastApprox(val);
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
vec3 inv_agx(vec3 val) {
|
||||
const mat3 inv_agx_mat = mat3(
|
||||
1.1968790051201738155, -0.052896851757456180321, -0.052971635514443794537,
|
||||
-0.098020881140136776078, 1.1519031299041727435, -0.098043450117124120312,
|
||||
-0.099029744079720471434, -0.098961176844843346553, 1.1510736726411610622);
|
||||
|
||||
// Input transform
|
||||
val = inv_agx_mat * val;
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
vec3 agxLook(vec3 val) {
|
||||
const vec3 lw = vec3(0.2126, 0.7152, 0.0722);
|
||||
float luma = dot(val, lw);
|
||||
|
||||
vec3 offset = vec3(0.0);
|
||||
|
||||
#if AGX_LOOK == 0
|
||||
// Default
|
||||
const vec3 slope = vec3(1.0);
|
||||
const vec3 power = vec3(1.0);
|
||||
const float sat = 1.0;
|
||||
#elif AGX_LOOK == 1
|
||||
// Golden
|
||||
const vec3 slope = vec3(1.0, 0.9, 0.5);
|
||||
const vec3 power = vec3(0.8);
|
||||
const float sat = 0.8;
|
||||
#elif AGX_LOOK == 2
|
||||
// Punchy
|
||||
const vec3 slope = vec3(1.0);
|
||||
const vec3 power = vec3(1.35, 1.35, 1.35);
|
||||
const float sat = 1.4;
|
||||
#else
|
||||
const vec3 slope = vec3(AGX_R, AGX_G, AGX_B) / 256;
|
||||
const vec3 power = vec3(AGX_POWER);
|
||||
const float sat = AGX_SATURATION;
|
||||
#endif
|
||||
|
||||
// ASC CDL
|
||||
val = pow(val * slope + offset, power);
|
||||
return luma + sat * (val - luma);
|
||||
}
|
||||
|
||||
vec3 agxTonemap(vec3 color) { // Minimal version of Troy Sobotka's AgX by bwrensch https://www.shadertoy.com/view/mdcSDH
|
||||
color = agx(color);
|
||||
color = agxLook(color);
|
||||
color = inv_agx(color);
|
||||
doColorAdjustments(color);
|
||||
return color;
|
||||
}
|
||||
|
||||
void DoBSLColorSaturation(inout vec3 color) {
|
||||
float grayVibrance = (color.r + color.g + color.b) / 3.0;
|
||||
float graySaturation = grayVibrance;
|
||||
if (saturationTM < 1.00) graySaturation = dot(color, vec3(0.299, 0.587, 0.114));
|
||||
|
||||
float mn = min(color.r, min(color.g, color.b));
|
||||
float mx = max(color.r, max(color.g, color.b));
|
||||
float sat = (1.0 - (mx - mn)) * (1.0 - mx) * grayVibrance * 5.0;
|
||||
vec3 lightness = vec3((mn + mx) * 0.5);
|
||||
|
||||
color = mix(color, mix(color, lightness, 1.0 - T_VIBRANCE), sat);
|
||||
color = mix(color, lightness, (1.0 - lightness) * (2.0 - T_VIBRANCE) / 2.0 * abs(T_VIBRANCE - 1.0));
|
||||
color = color * saturationTM - graySaturation * (saturationTM - 1.0);
|
||||
}
|
||||
|
||||
#ifdef BLOOM
|
||||
vec2 rescale = max(vec2(viewWidth, viewHeight) / vec2(1920.0, 1080.0), vec2(1.0));
|
||||
vec3 GetBloomTile(float lod, vec2 coord, vec2 offset) {
|
||||
float scale = exp2(lod);
|
||||
vec2 bloomCoord = coord / scale + offset;
|
||||
bloomCoord = clamp(bloomCoord, offset, 1.0 / scale + offset);
|
||||
|
||||
vec3 bloom = texture2D(colortex3, bloomCoord / rescale).rgb;
|
||||
bloom *= bloom;
|
||||
bloom *= bloom;
|
||||
return bloom * 128.0;
|
||||
}
|
||||
|
||||
void DoBloom(inout vec3 color, vec2 coord, float dither, float lViewPos) {
|
||||
vec3 blur1 = GetBloomTile(2.0, coord, vec2(0.0 , 0.0 ));
|
||||
vec3 blur2 = GetBloomTile(3.0, coord, vec2(0.0 , 0.26 ));
|
||||
vec3 blur3 = GetBloomTile(4.0, coord, vec2(0.135 , 0.26 ));
|
||||
vec3 blur4 = GetBloomTile(5.0, coord, vec2(0.2075 , 0.26 ));
|
||||
vec3 blur5 = GetBloomTile(6.0, coord, vec2(0.135 , 0.3325));
|
||||
vec3 blur6 = GetBloomTile(7.0, coord, vec2(0.160625 , 0.3325));
|
||||
vec3 blur7 = GetBloomTile(8.0, coord, vec2(0.1784375, 0.3325));
|
||||
|
||||
vec3 blur = (blur1 + blur2 + blur3 + blur4 + blur5 + blur6 + blur7) * 0.14;
|
||||
|
||||
float bloomStrength = BLOOM_STRENGTH + 0.2 * darknessFactor;
|
||||
|
||||
#if defined BLOOM_FOG && defined NETHER && defined BORDER_FOG
|
||||
float farM = min(renderDistance, NETHER_VIEW_LIMIT); // consistency9023HFUE85JG
|
||||
float netherBloom = lViewPos / clamp(farM, 96.0, 256.0);
|
||||
netherBloom *= netherBloom;
|
||||
netherBloom *= netherBloom;
|
||||
netherBloom = 1.0 - exp(-8.0 * netherBloom);
|
||||
netherBloom *= 1.0 - maxBlindnessDarkness;
|
||||
bloomStrength = mix(bloomStrength * 0.7, bloomStrength * 1.8, netherBloom);
|
||||
#endif
|
||||
|
||||
color = mix(color, blur, bloomStrength);
|
||||
//color += blur * bloomStrength * (ditherFactor.x + ditherFactor.y);
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "/lib/util/colorConversion.glsl"
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#endif
|
||||
|
||||
// http://www.diva-portal.org/smash/get/diva2:24136/FULLTEXT01.pdf
|
||||
// The MIT License
|
||||
// Copyright © 2024 Benjamin Stott "sixthsurge"
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
vec3 purkinjeShift(vec3 rgb, vec4 texture6, vec3 playerPos, float lViewPos, float purkinjeOverwrite) {
|
||||
#ifdef NETHER
|
||||
#define PURKINKE_INTENSITY NIGHT_DESATURATION_NETHER
|
||||
#elif defined END
|
||||
#define PURKINKE_INTENSITY NIGHT_DESATURATION_END
|
||||
nightFactor = 1.0;
|
||||
#else
|
||||
#define PURKINKE_INTENSITY NIGHT_DESATURATION_OW
|
||||
#endif
|
||||
|
||||
float renderDistanceFade = mix(0, lViewPos * 2.5 / renderDistance, PURKINJE_RENDER_DISTANCE_FADE);
|
||||
float nightCaveDesaturation = NIGHT_CAVE_DESATURATION * 0.1;
|
||||
|
||||
float interiorFactor = isEyeInWater == 1 ? 0.0 : pow2(1.0 - texture6.b);
|
||||
interiorFactor = mix(interiorFactor, 0, renderDistanceFade);
|
||||
interiorFactor -= sqrt2(eyeBrightnessM) * 0.66;
|
||||
interiorFactor = smoothstep(0.0, 1.0, interiorFactor);
|
||||
|
||||
// return vec3(interiorFactor);
|
||||
|
||||
float lightSourceFactor = 1.0;
|
||||
#ifdef NIGHT_DESATURATION_REMOVE_NEAR_LIGHTS
|
||||
lightSourceFactor = pow3(1.0 - texture6.a);
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
vec3 voxelPos = SceneToVoxel(playerPos);
|
||||
|
||||
vec4 lightVolume = vec4(0.0);
|
||||
if (CheckInsideVoxelVolume(voxelPos)) {
|
||||
vec3 voxelPosM = clamp01(voxelPos / vec3(voxelVolumeSize));
|
||||
lightVolume = GetLightVolume(voxelPosM);
|
||||
lightVolume = sqrt(lightVolume);
|
||||
}
|
||||
lightSourceFactor *= pow6(1.0 - lightVolume.a * 3); // Remove purkinje shift in ACL light
|
||||
#endif
|
||||
lightSourceFactor += renderDistanceFade;
|
||||
lightSourceFactor = clamp01(lightSourceFactor);
|
||||
#endif
|
||||
|
||||
float heldLight = 1.0;
|
||||
#ifdef NIGHT_DESATURATION_REMOVE_LIGHTS_IN_HAND
|
||||
heldLight = max(heldBlockLightValue, heldBlockLightValue2);
|
||||
if (heldLight > 0){
|
||||
if (heldItemId == 45032 || heldItemId2 == 45032) heldLight = 15; // Lava Bucket
|
||||
heldLight = clamp(heldLight, 0.0, 15.0);
|
||||
heldLight = sqrt2(heldLight / 15.0) * -1.0 + 1.0; // Normalize and invert
|
||||
heldLight = mix(heldLight, 1.0, clamp01(lViewPos * 15 / renderDistance)); // Only do it around the player
|
||||
} else {
|
||||
heldLight = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
float nightVisionFactor = 1.0;
|
||||
#ifdef NIGHT_DESATURATION_REMOVE_NIGHT_VISION
|
||||
nightVisionFactor = nightVision * -1.0 + 1.0;
|
||||
#endif
|
||||
|
||||
float purkinjeIntensity = 0.004 * purkinjeOverwrite * PURKINKE_INTENSITY;
|
||||
purkinjeIntensity = purkinjeIntensity * fuzzyOr(interiorFactor, sqrt2(nightFactor)); // No purkinje shift in daylight
|
||||
purkinjeIntensity *= lightSourceFactor; // Reduce purkinje intensity in blocklight
|
||||
purkinjeIntensity *= clamp01(nightCaveDesaturation + (1.0 - nightCaveDesaturation) * pow3(1.0 - interiorFactor)); // Reduce purkinje intensity underground
|
||||
purkinjeIntensity *= clamp01(heldLight); // Reduce purkinje intensity when holding light sources
|
||||
purkinjeIntensity *= nightVisionFactor * (1.0 - isLightningActive()); // Reduce purkinje intensity when using night vision or during lightning
|
||||
purkinjeIntensity = clamp(purkinjeIntensity, 0.01, 1.0); // prevent it going to 0 to avoid NaNs
|
||||
|
||||
#if PURKINKE_INTENSITY < 300
|
||||
const vec3 purkinjeTint = vec3(0.5, 0.7, 1.0) * rec709ToRec2020;
|
||||
const vec3 rodResponse = vec3(7.15e-5, 4.81e-1, 3.28e-1) * rec709ToRec2020;
|
||||
|
||||
vec3 xyz = rgb * rec2020ToXyz;
|
||||
|
||||
vec3 scotopicLuminance = xyz * (1.33 * (1.0 + (xyz.y + xyz.z) / xyz.x) - 0.5);
|
||||
|
||||
float purkinje = dot(rodResponse, scotopicLuminance * xyzToRec2020) * 0.45;
|
||||
|
||||
rgb = mix(rgb, purkinje * purkinjeTint, exp2(-rcp(purkinjeIntensity) * purkinje));
|
||||
#else
|
||||
rgb = mix(rgb, vec3(GetLuminance(rgb) * 0.9), clamp01(purkinjeIntensity));
|
||||
#endif
|
||||
|
||||
// return vec3(purkinjeIntensity);
|
||||
|
||||
return max0(rgb);
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#ifdef BLOOM_FOG
|
||||
#include "/lib/atmospherics/fog/bloomFog.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef BLOOM
|
||||
#include "/lib/util/dither.glsl"
|
||||
#endif
|
||||
|
||||
#if LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
#include "/lib/misc/lensFlare.glsl"
|
||||
#endif
|
||||
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texture2D(colortex0, texCoord).rgb;
|
||||
|
||||
#if defined BLOOM_FOG || LENSFLARE_MODE > 0 && defined OVERWORLD || defined NIGHT_DESATURATION
|
||||
float z0 = texture2D(depthtex0, texCoord).r;
|
||||
|
||||
vec4 screenPos = vec4(texCoord, z0, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos.xyz);
|
||||
|
||||
vec3 playerPos = ViewToPlayer(viewPos.xyz);
|
||||
|
||||
#if defined DISTANT_HORIZONS && defined NETHER
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPos = min(lViewPos, length(viewPosDH.xyz));
|
||||
#endif
|
||||
#else
|
||||
float lViewPos = 0.0;
|
||||
#endif
|
||||
|
||||
float dither = texture2D(noisetex, texCoord * view / 128.0).b;
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#ifdef BLOOM_FOG
|
||||
color /= GetBloomFog(lViewPos);
|
||||
#endif
|
||||
|
||||
#ifdef BLOOM
|
||||
DoBloom(color, texCoord, dither, lViewPos);
|
||||
#endif
|
||||
|
||||
#ifdef COLORGRADING
|
||||
color =
|
||||
pow(color.r, GR_RC) * vec3(GR_RR, GR_RG, GR_RB) +
|
||||
pow(color.g, GR_GC) * vec3(GR_GR, GR_GG, GR_GB) +
|
||||
pow(color.b, GR_BC) * vec3(GR_BR, GR_BG, GR_BB);
|
||||
color *= 0.01;
|
||||
#endif
|
||||
|
||||
#ifdef TONEMAP_COMPARISON
|
||||
color = texCoord.x < mix(0.5, 0.0, isSneaking) ? tonemap_left(color) : tonemap_right(color); // Thanks to SixthSurge
|
||||
#else
|
||||
#ifndef SPOOKY
|
||||
color = tonemap(color);
|
||||
#else
|
||||
color = LottesTonemap(color);
|
||||
#endif
|
||||
#endif
|
||||
color = clamp01(color);
|
||||
|
||||
#if defined GREEN_SCREEN_LIME || defined BLUE_SCREEN || SELECT_OUTLINE == 4 || defined NIGHT_DESATURATION
|
||||
vec4 texture6 = texelFetch(colortex6, texelCoord, 0);
|
||||
int materialMaskInt = int(texture6.g * 255.1);
|
||||
#endif
|
||||
float purkinjeOverwrite = 1.0;
|
||||
|
||||
#ifdef GREEN_SCREEN_LIME
|
||||
if (materialMaskInt == 240) { // Green Screen Lime Blocks
|
||||
color = vec3(0.0, 1.0, 0.0);
|
||||
purkinjeOverwrite = 0.0;
|
||||
}
|
||||
#endif
|
||||
#ifdef BLUE_SCREEN
|
||||
if (materialMaskInt == 239) { // Blue Screen Blue Blocks
|
||||
color = vec3(0.0, 0.0, 1.0);
|
||||
purkinjeOverwrite = 0.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SELECT_OUTLINE == 4 || defined NIGHT_DESATURATION
|
||||
if (materialMaskInt == 252) { // Selection Outline
|
||||
#if SELECT_OUTLINE == 4 // Versatile Selection Outline
|
||||
float colorMF = 1.0 - dot(color, vec3(0.25, 0.45, 0.1));
|
||||
colorMF = smoothstep1(smoothstep1(smoothstep1(smoothstep1(smoothstep1(colorMF)))));
|
||||
color = mix(color, 3.0 * (color + 0.2) * vec3(colorMF * SELECT_OUTLINE_I), 0.3);
|
||||
#endif
|
||||
purkinjeOverwrite = 0.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
DoLensFlare(color, viewPos.xyz, dither);
|
||||
#endif
|
||||
|
||||
DoBSLColorSaturation(color);
|
||||
|
||||
#ifdef VIGNETTE_R
|
||||
vec2 texCoordMin = texCoord.xy - 0.5;
|
||||
float vignette = 1.0 - dot(texCoordMin, texCoordMin) * (1.0 - GetLuminance(color));
|
||||
color *= vignette;
|
||||
#endif
|
||||
|
||||
float filmGrain = dither;
|
||||
color += vec3((filmGrain - 0.25) / 128.0);
|
||||
|
||||
#ifdef NIGHT_DESATURATION
|
||||
color.rgb = purkinjeShift(color.rgb, texture6, playerPos, lViewPos, purkinjeOverwrite);
|
||||
#endif
|
||||
|
||||
// vec4 texture6 = texelFetch(colortex6, texelCoord, 0).rgba;
|
||||
// float interiorFactor = texture6.b;
|
||||
|
||||
// color = vec3(interiorFactor);
|
||||
|
||||
/* DRAWBUFFERS:3 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
#if defined BLOOM_FOG || LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
flat out vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
|
||||
#if defined BLOOM_FOG || LENSFLARE_MODE > 0 && defined OVERWORLD
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,86 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
//Pipeline Constants//
|
||||
#include "/lib/pipelineSettings.glsl"
|
||||
|
||||
const bool colortex3MipmapEnabled = true;
|
||||
|
||||
//Common Variables//
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
|
||||
//Common Functions//
|
||||
float GetLinearDepth(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near));
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/taa.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex3, texelCoord, 0).rgb;
|
||||
|
||||
#ifdef RENKO_CUT
|
||||
float cutData = texelFetch(colortex1, texelCoord, 0).g;
|
||||
#else
|
||||
#define cutData 1.0
|
||||
#endif
|
||||
|
||||
vec3 temp = vec3(0.0);
|
||||
float z1 = 0.0;
|
||||
|
||||
#if defined TAA || defined TEMPORAL_FILTER
|
||||
z1 = texelFetch(depthtex1, texelCoord, 0).r;
|
||||
#endif
|
||||
|
||||
#ifdef TAA
|
||||
DoTAA(color, temp, z1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:32 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
gl_FragData[1] = vec4(temp, 1.0);
|
||||
|
||||
// Supposed to be #ifdef TEMPORAL_FILTER but Optifine bad
|
||||
#if BLOCK_REFLECT_QUALITY >= 3 && RP_MODE >= 1
|
||||
/* DRAWBUFFERS:321 */
|
||||
gl_FragData[2] = vec4(z1, ivec2(texCoord * vec2(viewWidth, viewHeight)) == ivec2(0) ? texture2D(colortex1, texCoord).g : cutData, 1.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,59 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#if FXAA_DEFINE == 1
|
||||
#include "/lib/antialiasing/fxaa.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex3, texelCoord, 0).rgb;
|
||||
|
||||
#if FXAA_DEFINE == 1
|
||||
FXAA311(color);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:3 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,179 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
#ifdef FRAGMENT_SHADER
|
||||
in vec2 knifePos;
|
||||
in vec2 knifeDir;
|
||||
in float isKnifeDown;
|
||||
in vec2 texelPos;
|
||||
in float healing;
|
||||
|
||||
void drawKnife(inout vec3 color, vec2 uv, vec2 pos, vec2 dir, float scale) {
|
||||
vec2 localUV = mat2(vec2(1, -1) * dir, dir.yx) * (uv - pos) / scale;
|
||||
|
||||
const float knifeRot0 = 0.3;
|
||||
const vec2 knifeOffset = vec2(0.3, -0.05);
|
||||
const mat2 knifeRotMat0 = mat2(cos(knifeRot0), sin(knifeRot0), -sin(knifeRot0), cos(knifeRot0));
|
||||
localUV = knifeRotMat0 * localUV + knifeOffset;
|
||||
float bladeLen0 = length(localUV * vec2(1, 2) - vec2(0.2, 0.5));
|
||||
|
||||
float bladeLen1 = length(localUV - vec2(0.9, 1.5));
|
||||
float bladeLen2 = length(localUV - vec2(-0.8, 6.0));
|
||||
if (bladeLen0 < 0.6 && bladeLen1 > 1.3 && bladeLen2 > 5.8) {
|
||||
color = vec3(0.7);
|
||||
if (bladeLen0 > 0.5) color = vec3(0.9);
|
||||
}
|
||||
vec2 handleMidCoord = vec2(-0.6, 0.13);
|
||||
vec2 handleScale = vec2(2.0, 5.0);
|
||||
float handleDist = length(pow(abs(localUV - handleMidCoord) * handleScale, vec2(3)));
|
||||
if (handleDist < 1.0) {
|
||||
color = vec3(0.6,0.2,0.0);
|
||||
color += 0.1 * (localUV.y * handleScale.y - handleMidCoord.y + 0.5);
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
#ifdef RENKO_CUT
|
||||
vec4 cutData = texelFetch(colortex1, texelCoord, 0);
|
||||
vec4 color = texelFetch(colortex3, texelCoord, 0);
|
||||
vec2 relPos = texelPos - knifePos;
|
||||
float projW = dot(relPos, knifeDir);
|
||||
float error = length(relPos - projW * knifeDir);
|
||||
if (isKnifeDown > 0.5 && error < 0.01 * (0.6 - 70.0 * projW * projW)) {
|
||||
cutData.g = 1.0;
|
||||
} else if (healing > 0.5) {
|
||||
float aroundHealthy = 0;
|
||||
for (int k = 0; k < 4; k++) {
|
||||
ivec2 offset = (k/2*2-1) * ivec2(k%2, (k+1)%2);
|
||||
aroundHealthy += texelFetch(colortex1, texelCoord + offset, 0).g;
|
||||
}
|
||||
if (aroundHealthy < 3.5) cutData.g = 0.0;
|
||||
}
|
||||
if (cutData.g > 0.5) {
|
||||
color = vec4(0, 0, 0, 1);
|
||||
}
|
||||
drawKnife(color.rgb, texelPos, knifePos, -knifeDir, 0.2);
|
||||
if (frameCounter < 10) {
|
||||
cutData.g = 0.0;
|
||||
}
|
||||
/* DRAWBUFFERS:31 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = cutData;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#ifdef VERTEX_SHADER
|
||||
out vec2 knifePos;
|
||||
out vec2 knifeDir;
|
||||
out float isKnifeDown;
|
||||
out vec2 texelPos;
|
||||
out float healing;
|
||||
|
||||
vec3 knifePosList[84] = vec3[84](
|
||||
vec3(0.1, 0.7, 1),
|
||||
vec3(0.1, 0.5, 1),
|
||||
vec3(0.1, 0.3, 1),
|
||||
vec3(0.15, 0.3, 1),
|
||||
vec3(0.15, 0.45, 1),
|
||||
vec3(0.2, 0.45, 1),
|
||||
vec3(0.27, 0.3, 1),
|
||||
vec3(0.32, 0.3, 1),
|
||||
vec3(0.25, 0.47, 1),
|
||||
vec3(0.3, 0.55, 1),
|
||||
vec3(0.3, 0.62, 1),
|
||||
vec3(0.25, 0.7, 1),
|
||||
vec3(0.1, 0.7, 0),
|
||||
vec3(0.4, 0.7, 1),
|
||||
vec3(0.4, 0.5, 1),
|
||||
vec3(0.4, 0.3, 1),
|
||||
vec3(0.53, 0.3, 1),
|
||||
vec3(0.65, 0.3, 1),
|
||||
vec3(0.65, 0.35, 1),
|
||||
vec3(0.45, 0.35, 1),
|
||||
vec3(0.45, 0.475, 1),
|
||||
vec3(0.6, 0.475, 1),
|
||||
vec3(0.6, 0.525, 1),
|
||||
vec3(0.45, 0.525, 1),
|
||||
vec3(0.45, 0.65, 1),
|
||||
vec3(0.65, 0.65, 1),
|
||||
vec3(0.65, 0.7, 1),
|
||||
vec3(0.4, 0.7, 0),
|
||||
vec3(0.7, 0.7, 1),
|
||||
vec3(0.7, 0.5, 1),
|
||||
vec3(0.7, 0.3, 1),
|
||||
vec3(0.75, 0.3, 1),
|
||||
vec3(0.75, 0.45, 1),
|
||||
vec3(0.75, 0.6, 1),
|
||||
vec3(0.825, 0.45, 1),
|
||||
vec3(0.9, 0.3, 1),
|
||||
vec3(0.95, 0.3, 1),
|
||||
vec3(0.95, 0.5, 1),
|
||||
vec3(0.95, 0.7, 1),
|
||||
vec3(0.9, 0.7, 1),
|
||||
vec3(0.9, 0.55, 1),
|
||||
vec3(0.9, 0.4, 1),
|
||||
vec3(0.825, 0.55, 1),
|
||||
vec3(0.75, 0.7, 1),
|
||||
vec3(0.7, 0.7, 0),
|
||||
vec3(1.0, 0.7, 1),
|
||||
vec3(1.0, 0.5, 1),
|
||||
vec3(1.0, 0.3, 1),
|
||||
vec3(1.05, 0.3, 1),
|
||||
vec3(1.05, 0.5, 1),
|
||||
vec3(1.15, 0.4, 1),
|
||||
vec3(1.23, 0.3, 1),
|
||||
vec3(1.29, 0.3, 1),
|
||||
vec3(1.2, 0.42, 1),
|
||||
vec3(1.13, 0.48, 1),
|
||||
vec3(1.2, 0.59, 1),
|
||||
vec3(1.28, 0.7, 1),
|
||||
vec3(1.22, 0.7, 1),
|
||||
vec3(1.15, 0.61, 1),
|
||||
vec3(1.1, 0.56, 1),
|
||||
vec3(1.05, 0.6, 1),
|
||||
vec3(1.05, 0.7, 1),
|
||||
vec3(1.0, 0.7, 0),
|
||||
vec3(1.35, 0.6, 1),
|
||||
vec3(1.35, 0.4, 1),
|
||||
vec3(1.43, 0.3, 1),
|
||||
vec3(1.52, 0.3, 1),
|
||||
vec3(1.6, 0.4, 1),
|
||||
vec3(1.6, 0.6, 1),
|
||||
vec3(1.52, 0.7, 1),
|
||||
vec3(1.43, 0.7, 1),
|
||||
vec3(1.35, 0.6, 0),
|
||||
vec3(1.4, 0.55, 1),
|
||||
vec3(1.4, 0.45, 1),
|
||||
vec3(1.475, 0.38, 1),
|
||||
vec3(1.55, 0.45, 1),
|
||||
vec3(1.55, 0.55, 1),
|
||||
vec3(1.475, 0.62, 1),
|
||||
vec3(1.4, 0.55, 0),
|
||||
vec3(1.2, 0.7, 0),
|
||||
vec3(0.8, 0.8, 0),
|
||||
vec3(0.5, 0.8, 0),
|
||||
vec3(0.2, 0.75, 0),
|
||||
vec3(0.1, 0.7, 0)
|
||||
);
|
||||
|
||||
void main() {
|
||||
#ifdef RENKO_CUT
|
||||
gl_Position = ftransform();
|
||||
texelPos = 0.5 * gl_Position.xy + 0.5;
|
||||
texelPos.x *= aspectRatio;
|
||||
float cutProgress = max(0, frameTimeCounter * 2 - 40.0);
|
||||
int thisIndex = int(cutProgress) % knifePosList.length();
|
||||
healing = float(thisIndex > knifePosList.length() - 5);
|
||||
int nextIndex = (thisIndex+1) % knifePosList.length();
|
||||
knifePos = mix(
|
||||
knifePosList[thisIndex].xy,
|
||||
knifePosList[nextIndex].xy,
|
||||
mod(cutProgress, float(knifePosList.length())) - thisIndex);
|
||||
knifeDir = normalize(knifePosList[nextIndex].xy - knifePosList[thisIndex].xy);
|
||||
isKnifeDown = knifePosList[thisIndex].z;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,74 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#if LONG_EXPOSURE > 0
|
||||
vec4 color = vec4(0.0);
|
||||
|
||||
float counter = texture2D(colortex1, ivec2(0)).g;
|
||||
counter += 0.00001;
|
||||
if(hideGUI == 0 || isViewMoving()) counter = 0.0; // reset counter when GUI visible OR when moving
|
||||
|
||||
if (hideGUI == 1 && !isViewMoving()) { // accumulate ONLY when GUI hidden AND not moving otherwise use colortex7 as normal
|
||||
vec4 currentFrame = texture2D(colortex3, texCoord);
|
||||
vec4 previousFrame = texture2D(colortex7, texCoord);
|
||||
if (counter == 0.00001) previousFrame = currentFrame; // to fix the first frame as it still has info from colortex7 from deferred1
|
||||
#if LONG_EXPOSURE == 1
|
||||
color = max(currentFrame, previousFrame);
|
||||
#else
|
||||
float luma = dot(currentFrame.rgb, vec3(3.0)); // do luma weighting to preserve bright pixels for longer
|
||||
float mixAmount = 1.0 / (counter * 100000.0 + 1.0);
|
||||
color = mix(previousFrame, currentFrame, mixAmount * luma);
|
||||
#endif
|
||||
} else {
|
||||
color = texture2D(colortex7, texCoord);
|
||||
}
|
||||
|
||||
/* DRAWBUFFERS:71 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(texture2D(colortex1, texCoord).r, ivec2(texCoord * vec2(viewWidth, viewHeight)) == ivec2(0) ? counter : texture2D(colortex1, texCoord).g, texture2D(colortex1, texCoord).ba);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,606 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
flat in float vlFactor;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
const bool colortex0MipmapEnabled = true;
|
||||
|
||||
//Common Variables//
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float farMinusNear = far - near;
|
||||
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
#else
|
||||
float vlFactor = 0.0;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
float GetLinearDepth(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * farMinusNear);
|
||||
}
|
||||
|
||||
#if SSAO_QUALI > 0
|
||||
vec2 OffsetDist(float x, int s) {
|
||||
float n = fract(x * 1.414) * 3.1415;
|
||||
return pow2(vec2(cos(n), sin(n)) * x / s);
|
||||
}
|
||||
|
||||
float DoAmbientOcclusion(float z0, float linearZ0, float dither, vec3 playerPos) {
|
||||
if (z0 < 0.56) return 1.0;
|
||||
float ao = 0.0;
|
||||
|
||||
#if SSAO_QUALI == 2
|
||||
int samples = 4;
|
||||
float scm = 0.4;
|
||||
#elif SSAO_QUALI == 3
|
||||
int samples = 12;
|
||||
float scm = 0.6;
|
||||
#endif
|
||||
|
||||
#define SSAO_I_FACTOR 0.004
|
||||
|
||||
float sampleDepth = 0.0, angle = 0.0, dist = 0.0;
|
||||
float fovScale = gbufferProjection[1][1];
|
||||
float distScale = max(farMinusNear * linearZ0 + near, 3.0);
|
||||
vec2 scale = vec2(scm / aspectRatio, scm) * fovScale / distScale;
|
||||
|
||||
for (int i = 1; i <= samples; i++) {
|
||||
vec2 offset = OffsetDist(i + dither, samples) * scale;
|
||||
if (i % 2 == 0) offset.y = -offset.y;
|
||||
|
||||
vec2 coord1 = texCoord + offset;
|
||||
vec2 coord2 = texCoord - offset;
|
||||
|
||||
sampleDepth = GetLinearDepth(texture2D(depthtex0, coord1).r);
|
||||
float aosample = farMinusNear * (linearZ0 - sampleDepth) * 2.0;
|
||||
angle = clamp(0.5 - aosample, 0.0, 1.0);
|
||||
dist = clamp(0.5 * aosample - 1.0, 0.0, 1.0);
|
||||
|
||||
sampleDepth = GetLinearDepth(texture2D(depthtex0, coord2).r);
|
||||
aosample = farMinusNear * (linearZ0 - sampleDepth) * 2.0;
|
||||
angle += clamp(0.5 - aosample, 0.0, 1.0);
|
||||
dist += clamp(0.5 * aosample - 1.0, 0.0, 1.0);
|
||||
|
||||
ao += clamp(angle + dist, 0.0, 1.0);
|
||||
}
|
||||
ao /= samples;
|
||||
|
||||
#define SSAO_IM SSAO_I * SSAO_I_FACTOR
|
||||
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
vec3 lightningPos = getLightningPos(playerPos, lightningBoltPosition.xyz, false);
|
||||
vec2 lightningAdd = lightningFlashEffect(lightningPos, vec3(0), 550.0, 0, 0) * isLightningActive() * 0.5;
|
||||
ao += lightningAdd.y;
|
||||
#endif
|
||||
|
||||
return pow(ao, SSAO_IM);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef TEMPORAL_FILTER
|
||||
float GetApproxDistance(float depth) {
|
||||
return near * far / (far - depth * far);
|
||||
}
|
||||
|
||||
vec3 FHalfReprojection(vec3 pos) {
|
||||
pos = pos * 2.0 - 1.0;
|
||||
|
||||
vec4 viewPosPrev = gbufferProjectionInverse * vec4(pos, 1.0);
|
||||
viewPosPrev /= viewPosPrev.w;
|
||||
viewPosPrev = gbufferModelViewInverse * viewPosPrev;
|
||||
|
||||
return viewPosPrev.xyz;
|
||||
}
|
||||
|
||||
vec2 SHalfReprojection(vec3 playerPos, vec3 cameraOffset) {
|
||||
vec4 proPos = vec4(playerPos + cameraOffset, 1.0);
|
||||
vec4 previousPosition = gbufferPreviousModelView * proPos;
|
||||
previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
return previousPosition.xy / previousPosition.w * 0.5 + 0.5;
|
||||
}
|
||||
#endif
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/atmospherics/fog/mainFog.glsl"
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
|
||||
#if AURORA_STYLE > 0
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef NETHER_NOISE
|
||||
#include "/lib/atmospherics/netherNoise.glsl"
|
||||
#endif
|
||||
|
||||
#if defined NIGHT_NEBULA || defined BEDROCK_NOISE
|
||||
#include "/lib/atmospherics/stars.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef NIGHT_NEBULA
|
||||
#include "/lib/atmospherics/nightNebula.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
#include "/lib/atmospherics/clouds/mainClouds.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
#include "/lib/materials/materialMethods/reflections.glsl"
|
||||
#endif
|
||||
|
||||
#if defined END && defined END_STARS
|
||||
#include "/lib/atmospherics/enderStars.glsl"
|
||||
#endif
|
||||
|
||||
#if defined WORLD_OUTLINE || RETRO_LOOK == 1 || RETRO_LOOK == 2
|
||||
#include "/lib/misc/worldOutline.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef DARK_OUTLINE
|
||||
#include "/lib/misc/darkOutline.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef DISTANT_LIGHT_BOKEH
|
||||
#include "/lib/misc/distantLightBokeh.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef BEDROCK_NOISE
|
||||
#include "/lib/atmospherics/bedrockNoise.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = texelFetch(colortex0, texelCoord, 0).rgb;
|
||||
float z0 = texelFetch(depthtex0, texelCoord, 0).r;
|
||||
|
||||
vec4 screenPos = vec4(texCoord, z0, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos);
|
||||
vec3 nViewPos = normalize(viewPos.xyz);
|
||||
vec3 playerPos = ViewToPlayer(viewPos.xyz);
|
||||
|
||||
float dither = texture2D(noisetex, texCoord * vec2(viewWidth, viewHeight) / 128.0).b;
|
||||
#if defined TAA || defined TEMPORAL_FILTER
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
atmColorMult = GetAtmColorMult();
|
||||
sqrtAtmColorMult = sqrt(atmColorMult);
|
||||
#endif
|
||||
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
float skyFade = 0.0;
|
||||
vec3 waterRefColor = vec3(0.0);
|
||||
vec3 auroraBorealis = vec3(0.0);
|
||||
vec3 nightNebula = vec3(0.0);
|
||||
vec3 netherNoise = vec3(0.0);
|
||||
vec3 bedrockNoise = vec3(0.0);
|
||||
|
||||
vec4 refToWrite = vec4(0.0);
|
||||
|
||||
if (z0 < 1.0) {
|
||||
#ifdef DISTANT_LIGHT_BOKEH
|
||||
int dlbo = 1;
|
||||
vec3 dlbColor = color;
|
||||
dlbColor += texelFetch(colortex0, texelCoord + ivec2( 0, dlbo), 0).rgb;
|
||||
dlbColor += texelFetch(colortex0, texelCoord + ivec2( 0,-dlbo), 0).rgb;
|
||||
dlbColor += texelFetch(colortex0, texelCoord + ivec2( dlbo, 0), 0).rgb;
|
||||
dlbColor += texelFetch(colortex0, texelCoord + ivec2(-dlbo, 0), 0).rgb;
|
||||
dlbColor = max(color, dlbColor * 0.2);
|
||||
float dlbMix = GetDistantLightBokehMix(lViewPos);
|
||||
color = mix(color, dlbColor, dlbMix);
|
||||
#endif
|
||||
|
||||
#if SSAO_QUALI > 0 || defined WORLD_OUTLINE || defined TEMPORAL_FILTER || RETRO_LOOK == 1 || RETRO_LOOK == 2
|
||||
float linearZ0 = GetLinearDepth(z0);
|
||||
#endif
|
||||
|
||||
#if SSAO_QUALI > 0
|
||||
float ssao = DoAmbientOcclusion(z0, linearZ0, dither, playerPos);
|
||||
#else
|
||||
float ssao = 1.0;
|
||||
#endif
|
||||
vec4 texture6 = texelFetch(colortex6, texelCoord, 0).rgba;
|
||||
int materialMaskInt = int(texture6.g * 255.1);
|
||||
bool entityOrHand = z0 < 0.56;
|
||||
float intenseFresnel = 0.0;
|
||||
float smoothnessD = texture6.r;
|
||||
vec3 reflectColor = vec3(1.0);
|
||||
|
||||
#ifdef IPBR
|
||||
#include "/lib/materials/materialHandling/deferredMaterials.glsl"
|
||||
#else
|
||||
if (materialMaskInt <= 240) {
|
||||
#ifdef CUSTOM_PBR
|
||||
#if RP_MODE == 2 // seuspbr
|
||||
float metalness = materialMaskInt / 240.0;
|
||||
|
||||
intenseFresnel = metalness;
|
||||
#elif RP_MODE == 3 // labPBR
|
||||
float metalness = float(materialMaskInt >= 230);
|
||||
|
||||
intenseFresnel = materialMaskInt / 240.0;
|
||||
#endif
|
||||
reflectColor = mix(reflectColor, color.rgb / max(color.r + 0.00001, max(color.g, color.b)), metalness);
|
||||
#endif
|
||||
} else {
|
||||
if (materialMaskInt == 254) // No SSAO, No TAA
|
||||
ssao = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
color.rgb *= ssao;
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
float skyLightFactor = texture6.b;
|
||||
vec3 texture5 = texelFetch(colortex5, texelCoord, 0).rgb;
|
||||
vec3 normalM = mat3(gbufferModelView) * texture5;
|
||||
|
||||
float fresnel = clamp(1.0 + dot(normalM, nViewPos), 0.0, 1.0);
|
||||
|
||||
float fresnelFactor = (1.0 - smoothnessD) * 0.7;
|
||||
float fresnelM = max(fresnel - fresnelFactor, 0.0) / (1.0 - fresnelFactor);
|
||||
#ifdef IPBR
|
||||
fresnelM = mix(pow2(fresnelM), fresnelM * 0.75 + 0.25, intenseFresnel);
|
||||
#else
|
||||
fresnelM = mix(pow2(fresnelM), fresnelM * 0.5 + 0.5, intenseFresnel);
|
||||
#endif
|
||||
fresnelM = fresnelM * sqrt1(smoothnessD) - dither * 0.001;
|
||||
|
||||
if (fresnelM > 0.0) {
|
||||
vec2 roughCoord = gl_FragCoord.xy / 128.0;
|
||||
#ifdef TAA
|
||||
float noiseMult = 0.3;
|
||||
#else
|
||||
float noiseMult = 0.1;
|
||||
#endif
|
||||
#ifdef TEMPORAL_FILTER
|
||||
float blendFactor = 1.0;
|
||||
float writeFactor = 1.0;
|
||||
#endif
|
||||
#if defined CUSTOM_PBR || defined IPBR && defined IS_IRIS
|
||||
if (entityOrHand) {
|
||||
noiseMult *= 0.1;
|
||||
#ifdef TEMPORAL_FILTER
|
||||
blendFactor = 0.0;
|
||||
writeFactor = 0.0;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
noiseMult *= pow2(1.0 - smoothnessD);
|
||||
|
||||
vec3 roughNoise = vec3(texture2D(noisetex, roughCoord).r, texture2D(noisetex, roughCoord + 0.1).r, texture2D(noisetex, roughCoord + 0.2).r);
|
||||
roughNoise = fract(roughNoise + vec3(dither, dither * goldenRatio, dither * pow2(goldenRatio)));
|
||||
roughNoise = noiseMult * (roughNoise - vec3(0.5));
|
||||
|
||||
normalM += roughNoise;
|
||||
|
||||
vec4 reflection = GetReflection(normalM, viewPos.xyz, nViewPos, playerPos, lViewPos, z0,
|
||||
depthtex0, dither, skyLightFactor, fresnel,
|
||||
smoothnessD, vec3(0.0), vec3(0.0), vec3(0.0), 0.0);
|
||||
|
||||
vec3 colorAdd = reflection.rgb * reflectColor;
|
||||
//float colorMultInv = (0.75 - intenseFresnel * 0.5) * max(reflection.a, skyLightFactor);
|
||||
//float colorMultInv = max(reflection.a, skyLightFactor);
|
||||
float colorMultInv = 1.0;
|
||||
|
||||
vec3 colorP = color;
|
||||
|
||||
#ifdef TEMPORAL_FILTER
|
||||
#if LONG_EXPOSURE > 0
|
||||
if (hideGUI == 0 || isViewMoving()){ // when GUI is visible OR moving do temporal filter, otherwise skip so colortex7 is free
|
||||
#endif
|
||||
vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
vec2 prvCoord = SHalfReprojection(playerPos, cameraOffset);
|
||||
#if defined IPBR && !defined GENERATED_NORMALS
|
||||
vec2 prvRefCoord = Reprojection(vec3(texCoord, max(refPos.z, z0)), cameraOffset);
|
||||
vec4 oldRef = texture2D(colortex7, prvRefCoord);
|
||||
#else
|
||||
vec2 prvRefCoord = Reprojection(vec3(texCoord, z0), cameraOffset);
|
||||
vec2 prvRefCoord2 = Reprojection(vec3(texCoord, max(refPos.z, z0)), cameraOffset);
|
||||
vec4 oldRef1 = texture2D(colortex7, prvRefCoord);
|
||||
vec4 oldRef2 = texture2D(colortex7, prvRefCoord2);
|
||||
vec3 dif1 = colorAdd - oldRef1.rgb;
|
||||
vec3 dif2 = colorAdd - oldRef2.rgb;
|
||||
float dotDif1 = dot(dif1, dif1);
|
||||
float dotDif2 = dot(dif2, dif2);
|
||||
|
||||
float oldRefMixer = clamp01((dotDif1 - dotDif2) * 500.0);
|
||||
vec4 oldRef = mix(oldRef1, oldRef2, oldRefMixer);
|
||||
#endif
|
||||
|
||||
vec4 newRef = vec4(colorAdd, colorMultInv);
|
||||
vec2 oppositePreCoord = texCoord - 2.0 * (prvCoord - texCoord);
|
||||
|
||||
// Reduce blending at speed
|
||||
blendFactor *= float(prvCoord.x > 0.0 && prvCoord.x < 1.0 && prvCoord.y > 0.0 && prvCoord.y < 1.0);
|
||||
float velocity = length(cameraOffset) * max(16.0 - lViewPos / gbufferProjection[1][1], 3.0);
|
||||
blendFactor *= mix(1.0, exp(-velocity) * 0.5 + 0.5, smoothnessD);
|
||||
|
||||
// Reduce blending if depth changed
|
||||
float linearZDif = abs(GetLinearDepth(texture2D(colortex1, oppositePreCoord).r) - linearZ0) * far;
|
||||
blendFactor *= max0(2.0 - linearZDif) * 0.5;
|
||||
//color = mix(vec3(1,1,0), color, max0(2.0 - linearZDif) * 0.5);
|
||||
|
||||
// Reduce blending if normal changed
|
||||
vec3 texture5P = texture2D(colortex5, oppositePreCoord, 0).rgb;
|
||||
vec3 texture5Dif = abs(texture5 - texture5P);
|
||||
if (texture5Dif != clamp(texture5Dif, vec3(-0.004), vec3(0.004))) {
|
||||
blendFactor = 0.0;
|
||||
//color.rgb = vec3(1,0,1);
|
||||
}
|
||||
|
||||
blendFactor = max0(blendFactor); // Prevent first frame NaN
|
||||
newRef = max(newRef, vec4(0.0)); // Prevent random NaNs from persisting
|
||||
refToWrite = mix(newRef, oldRef, blendFactor * 0.95);
|
||||
refToWrite = mix(max(refToWrite, newRef), refToWrite, pow2(pow2(pow2(refToWrite.a))));
|
||||
|
||||
color.rgb *= 1.0 - refToWrite.a * fresnelM;
|
||||
color.rgb += refToWrite.rgb * fresnelM;
|
||||
refToWrite *= writeFactor;
|
||||
#if LONG_EXPOSURE > 0
|
||||
} else {
|
||||
color *= 1.0 - colorMultInv * fresnelM;
|
||||
color += colorAdd * fresnelM;
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
color *= 1.0 - colorMultInv * fresnelM;
|
||||
color += colorAdd * fresnelM;
|
||||
#endif
|
||||
|
||||
color = max(colorP * max(intenseFresnel, 1.0 - pow2(smoothnessD)) * 0.9, color);
|
||||
|
||||
// if (gl_FragCoord.x > 960) color = vec3(5.25,0,5.25);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined WORLD_OUTLINE || RETRO_LOOK == 1 || RETRO_LOOK == 2
|
||||
#ifndef WORLD_OUTLINE_ON_ENTITIES
|
||||
if (!entityOrHand)
|
||||
#endif
|
||||
DoWorldOutline(color, linearZ0);
|
||||
#endif
|
||||
|
||||
#ifndef SKY_EFFECT_REFLECTION
|
||||
waterRefColor = sqrt(color) - 1.0;
|
||||
#else
|
||||
waterRefColor = color;
|
||||
#endif
|
||||
|
||||
DoFog(color, skyFade, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
|
||||
} else { // Sky
|
||||
#ifdef DISTANT_HORIZONS
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
if (z0DH < 1.0) { // Distant Horizons Chunks
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPos = length(viewPosDH.xyz);
|
||||
playerPos = ViewToPlayer(viewPosDH.xyz);
|
||||
|
||||
#ifndef SKY_EFFECT_REFLECTION
|
||||
waterRefColor = sqrt(color) - 1.0;
|
||||
#else
|
||||
waterRefColor = color;
|
||||
#endif
|
||||
|
||||
DoFog(color.rgb, skyFade, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
} else { // Start of Actual Sky
|
||||
#endif
|
||||
|
||||
skyFade = 1.0;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#if AURORA_STYLE > 0
|
||||
auroraBorealis = GetAuroraBorealis(viewPos.xyz, VdotU, dither);
|
||||
color.rgb += auroraBorealis;
|
||||
#endif
|
||||
#ifdef NIGHT_NEBULA
|
||||
nightNebula += GetNightNebula(viewPos.xyz, VdotU, VdotS);
|
||||
color.rgb += nightNebula;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef NETHER
|
||||
color.rgb = netherColor * (1.0 - maxBlindnessDarkness);
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
color.rgb *= atmColorMult;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef END
|
||||
color.rgb = endSkyColor;
|
||||
#ifdef END_STARS
|
||||
vec3 starColor = GetEnderStars(viewPos.xyz, VdotU, 1.0, 0.0);
|
||||
|
||||
#define ADD_STAR_LAYER_END1 (STAR_LAYER_END == 1 || STAR_LAYER_END == 3)
|
||||
#define ADD_STAR_LAYER_END2 (STAR_LAYER_END == 2 || STAR_LAYER_END == 3)
|
||||
|
||||
#if ADD_STAR_LAYER_END1
|
||||
starColor = max(starColor, GetEnderStars(viewPos.xyz, VdotU, 0.66, 0.0));
|
||||
#endif
|
||||
|
||||
#if ADD_STAR_LAYER_END2
|
||||
starColor = max(starColor, GetEnderStars(viewPos.xyz, VdotU, 2.2, 0.33));
|
||||
#endif
|
||||
|
||||
color.rgb += starColor;
|
||||
|
||||
color.rgb *= 1.0 - maxBlindnessDarkness;
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
color.rgb *= atmColorMult;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DISTANT_HORIZONS
|
||||
} // End of Actual Sky
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#ifdef NETHER
|
||||
#ifdef NETHER_NOISE
|
||||
netherNoise = GetNetherNoise(viewPos.xyz, VdotU, dither);
|
||||
color.rgb += pow4(skyFade) * netherNoise;
|
||||
#endif
|
||||
#endif
|
||||
#if defined OVERWORLD || defined NETHER
|
||||
#ifdef BEDROCK_NOISE
|
||||
bedrockNoise = GetBedrockNoise(viewPos.xyz, VdotU, dither);
|
||||
color.rgb += pow4(skyFade) * bedrockNoise;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef END
|
||||
#ifdef END_SMOKE
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos.xyz * 1000.0, 1.0)).xyz);
|
||||
vec3 endSmoke = texture2D(noisetex, (wpos.xz / wpos.y) * 0.5 + frameTimeCounter * 0.004).g * abs(VdotU) * endSkyColor * 1.5;
|
||||
color.rgb += pow4(skyFade) * endSmoke * (1.0 - maxBlindnessDarkness);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float cloudLinearDepth = 1.0;
|
||||
vec4 clouds = vec4(0.0);
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
float cloudZCheck = 0.56;
|
||||
|
||||
if (z0 > cloudZCheck) {
|
||||
clouds = GetClouds(cloudLinearDepth, skyFade, cameraPosition, playerPos, viewPos.xyz,
|
||||
lViewPos, VdotS, VdotU, dither, auroraBorealis, nightNebula);
|
||||
|
||||
color = mix(color, clouds.rgb, clouds.a);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SKY_EFFECT_REFLECTION
|
||||
waterRefColor = mix(waterRefColor, clouds.rgb, clouds.a);
|
||||
waterRefColor = sqrt(waterRefColor) - 1.0;
|
||||
#endif
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
if (viewWidth + viewHeight - gl_FragCoord.x - gl_FragCoord.y < 1.5)
|
||||
cloudLinearDepth = vlFactor;
|
||||
#endif
|
||||
|
||||
#if defined OVERWORLD && defined ATMOSPHERIC_FOG && (defined SPECIAL_BIOME_WEATHER || RAIN_STYLE == 2)
|
||||
float altitudeFactorRaw = GetAtmFogAltitudeFactor(playerPos.y + cameraPosition.y);
|
||||
vec3 atmFogColor = GetAtmFogColor(altitudeFactorRaw, VdotS);
|
||||
|
||||
#if RAIN_STYLE == 2
|
||||
float factor = 1.0;
|
||||
#else
|
||||
float factor = max(inSnowy, inDry);
|
||||
#endif
|
||||
|
||||
color = mix(color, atmFogColor, 0.5 * rainFactor * factor * sqrt1(skyFade));
|
||||
#endif
|
||||
|
||||
#ifdef DARK_OUTLINE
|
||||
if (clouds.a < 0.5) DoDarkOutline(color, skyFade, z0, dither);
|
||||
#endif
|
||||
|
||||
#if LONG_EXPOSURE > 0
|
||||
if (hideGUI == 1 && !isViewMoving()) { // GUI not visible AND not moving
|
||||
refToWrite = texture2D(colortex7, texCoord);
|
||||
}
|
||||
#endif
|
||||
/*DRAWBUFFERS:054*/
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
gl_FragData[1] = vec4(waterRefColor, 1.0 - skyFade);
|
||||
gl_FragData[2] = vec4(cloudLinearDepth, 0.0, 0.0, 1.0);
|
||||
#ifdef TEMPORAL_FILTER
|
||||
/*DRAWBUFFERS:0547*/
|
||||
gl_FragData[3] = refToWrite;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
flat out float vlFactor;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && (LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1 || defined END)
|
||||
vlFactor = texelFetch(colortex4, ivec2(viewWidth-1, viewHeight-1), 0).r;
|
||||
|
||||
#ifdef END
|
||||
if (frameCounter % int(0.06666 / frameTimeSmooth + 0.5) == 0) { // Change speed is not too different above 10 fps
|
||||
vec2 absCamPosXZ = abs(cameraPosition.xz);
|
||||
float maxCamPosXZ = max(absCamPosXZ.x, absCamPosXZ.y);
|
||||
|
||||
if (gl_Fog.start / far > 0.5 || maxCamPosXZ > 350.0) vlFactor = max(vlFactor - OSIEBCA*2, 0.0);
|
||||
else vlFactor = min(vlFactor + OSIEBCA*2, 1.0);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,284 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in int mat;
|
||||
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
in vec3 playerPos;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
vec2 lmCoordM = lmCoord;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#define GBUFFERS_TERRAIN
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
#undef GBUFFERS_TERRAIN
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
#include "/lib/materials/materialMethods/snowyWorld.glsl"
|
||||
#endif
|
||||
#if SEASONS > 0 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoise.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = vec4(glColor.rgb, 1.0);
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
float lViewPos = length(playerPos);
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
vec3 beforeTransformPos = playerPos;
|
||||
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
atmColorMult = GetAtmColorMult();
|
||||
#endif
|
||||
|
||||
bool noSmoothLighting = false, noDirectionalShading = false, noVanillaAO = false, centerShadowBias = false;
|
||||
int subsurfaceMode = 0;
|
||||
float smoothnessG = 0.0, smoothnessD = 0.0, highlightMult = 1.0, emission = 0.0, snowFactor = 1.0, snowMinNdotU = 0.0;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseTransparentOverwrite = 0.0;
|
||||
float overlayNoiseEmission = 1.0;
|
||||
float IPBRMult = 1.0;
|
||||
bool isFoliage = false;
|
||||
vec3 dhColor = color.rgb;
|
||||
float purkinjeOverwrite = 0.0;
|
||||
|
||||
float lavaNoiseIntensity = LAVA_NOISE_INTENSITY;
|
||||
|
||||
if (mat == DH_BLOCK_LEAVES) {
|
||||
#include "/lib/materials/specificMaterials/terrain/leaves.glsl"
|
||||
isFoliage = true;
|
||||
mossNoiseIntensity = 0.0;
|
||||
sandNoiseIntensity = 0.3;
|
||||
#ifdef SPOOKY
|
||||
int seed = worldDay / 2; // Thanks to Bálint
|
||||
int currTime = (worldDay % 2) * 24000 + worldTime; // Effect happens every 2 minecraft days
|
||||
float randomTime = 24000 * hash1(worldDay * 5); // Effect happens randomly throughout the day
|
||||
int timeWhenItHappens = (int(hash1(seed)) % (2 * 24000)) + int(randomTime);
|
||||
if (currTime > timeWhenItHappens && currTime < timeWhenItHappens + 100) { // 100 in ticks - 5s, how long the effect will be on, aka leaves are gone
|
||||
discard; // disable leaves
|
||||
}
|
||||
#endif
|
||||
} else if (mat == DH_BLOCK_GRASS) {
|
||||
smoothnessG = pow2(color.g) * 0.85;
|
||||
} else if (mat == DH_BLOCK_ILLUMINATED) {
|
||||
emission = 2.5;
|
||||
snowNoiseIntensity = 0.0;
|
||||
sandNoiseIntensity = 0.2;
|
||||
mossNoiseIntensity = 0.2;
|
||||
} else if (mat == DH_BLOCK_SNOW) {
|
||||
overlayNoiseIntensity = 0.0;
|
||||
#ifdef SSS_SNOW_ICE
|
||||
subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#endif
|
||||
} else if (mat == DH_BLOCK_LAVA) {
|
||||
overlayNoiseIntensity = 0.0;
|
||||
emission = 1.5;
|
||||
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
color.rgb = mix(color.rgb, (color.rgb - 0.5) * 1.35 + 0.5, inSoulValley); // increase contrast
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.5, colorEndBreath * 1.4, 1.0);
|
||||
color.rgb = (color.rgb - 0.5) * 1.3 + 0.5;
|
||||
#endif
|
||||
|
||||
vec3 lavaNoiseColor = color.rgb;
|
||||
#if LAVA_VARIATION > 0
|
||||
vec2 lavaPos = (floor(worldPos.xz * 16.0) + worldPos.y * 32.0) * 0.000666;
|
||||
vec2 wind = vec2(frameTimeCounter * 0.012, 0.0);
|
||||
#ifndef IPBR
|
||||
lavaNoiseIntensity *= 0.95;
|
||||
#endif
|
||||
#include "/lib/materials/specificMaterials/terrain/lavaNoise.glsl"
|
||||
color.rgb = lavaNoiseColor;
|
||||
#else
|
||||
if (LAVA_TEMPERATURE != 0.0) color.rgb += LAVA_TEMPERATURE * 0.3;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
DoSnowyWorld(color, smoothnessG, highlightMult, smoothnessD, emission,
|
||||
playerPos, lmCoord, snowFactor, snowMinNdotU, NdotU, subsurfaceMode);
|
||||
#endif
|
||||
|
||||
float lengthCylinder = max(length(playerPos.xz), abs(playerPos.y));
|
||||
highlightMult *= 0.5 + 0.5 * pow2(1.0 - smoothstep(far, far * 1.5, lengthCylinder));
|
||||
color.a *= smoothstep(far * 0.5, far * 0.7, lengthCylinder);
|
||||
if (color.a < dither) discard;
|
||||
|
||||
vec3 noisePos = floor((playerPos + cameraPosition) * 4.0 + 0.001) / 32.0;
|
||||
float noiseTexture = Noise3D(noisePos) + 0.5;
|
||||
float noiseFactor = max0(1.0 - 0.3 * dot(color.rgb, color.rgb));
|
||||
color.rgb *= pow(noiseTexture, 0.6 * noiseFactor);
|
||||
|
||||
#if defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#define GBUFFERS_TERRAIN
|
||||
#include "/lib/materials/overlayNoiseApply.glsl"
|
||||
#undef GBUFFERS_TERRAIN
|
||||
#endif
|
||||
#if SEASONS > 0
|
||||
#define GBUFFERS_TERRAIN
|
||||
#include "/lib/materials/seasons.glsl"
|
||||
#undef GBUFFERS_TERRAIN
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, noDirectionalShading, noVanillaAO,
|
||||
centerShadowBias, subsurfaceMode, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out int mat;
|
||||
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
out vec3 playerPos;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
mat = dhMaterialId;
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
playerPos = (gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,280 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in int mat;
|
||||
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
in vec3 playerPos;
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
vec2 lmCoordM = lmCoord;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if WATER_STYLE >= 2 || RAIN_PUDDLES >= 1 && WATER_STYLE == 1 && WATER_MAT_QUALITY >= 2 || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
eastVec.x, northVec.x, normal.x,
|
||||
eastVec.y, northVec.y, normal.y,
|
||||
eastVec.z, northVec.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
#include "/lib/atmospherics/fog/mainFog.glsl"
|
||||
|
||||
float vlFactor = 0.0;
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
#endif
|
||||
|
||||
#if WATER_REFLECT_QUALITY >= 0
|
||||
#if (defined SKY_EFFECT_REFLECTION || defined AURORA_INFLUENCE) && defined OVERWORLD
|
||||
#if AURORA_STYLE > 0 || defined AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#include "/lib/atmospherics/stars.glsl"
|
||||
#ifdef NIGHT_NEBULA
|
||||
#include "/lib/atmospherics/nightNebula.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
#include "/lib/atmospherics/clouds/mainClouds.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "/lib/materials/materialMethods/reflections.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef ATM_COLOR_MULTS
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
#if PIXEL_WATER > 0
|
||||
#include "/lib/materials/materialMethods/waterProcedureTexture.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 colorP = vec4(vec3(0.85), glColor.a);
|
||||
vec4 color = glColor;
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
if (texture2D(depthtex1, screenPos.xy).r < 1.0) discard;
|
||||
float lViewPos = length(playerPos);
|
||||
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#ifdef ATM_COLOR_MULTS
|
||||
atmColorMult = GetAtmColorMult();
|
||||
sqrtAtmColorMult = sqrt(atmColorMult);
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
float cloudLinearDepth = texelFetch(gaux1, texelCoord, 0).r;
|
||||
|
||||
if (pow2(cloudLinearDepth + OSIEBCA * dither) * renderDistance < min(lViewPos, renderDistance)) discard;
|
||||
#endif
|
||||
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
|
||||
bool noSmoothLighting = false, noDirectionalShading = false, noVanillaAO = false, centerShadowBias = false;
|
||||
#ifdef GENERATED_NORMALS
|
||||
bool noGeneratedNormals = false;
|
||||
#endif
|
||||
int subsurfaceMode = 0;
|
||||
float smoothnessG = 0.0, highlightMult = 0.0, emission = 0.0, materialMask = 0.0, reflectMult = 0.0;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
float fresnel = clamp(1.0 + dot(normalM, nViewPos), 0.0, 1.0);
|
||||
float purkinjeOverwrite = 0.0;
|
||||
|
||||
if (mat == DH_BLOCK_WATER) {
|
||||
#include "/lib/materials/specificMaterials/translucents/water.glsl"
|
||||
}
|
||||
|
||||
float lengthCylinder = max(length(playerPos.xz), abs(playerPos.y) * 2.0);
|
||||
color.a *= smoothstep(far * 0.5, far * 0.7, lengthCylinder);
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, noDirectionalShading, noVanillaAO,
|
||||
centerShadowBias, subsurfaceMode, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
// Reflections
|
||||
#if WATER_REFLECT_QUALITY >= 0
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
highlightColor *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_REFLECTION
|
||||
highlightColor *= pow2(moonPhaseInfluence);
|
||||
#endif
|
||||
|
||||
float fresnelM = (pow3(fresnel) * 0.85 + 0.15) * reflectMult;
|
||||
|
||||
float skyLightFactor = pow2(max(lmCoordM.y - 0.7, 0.0) * 3.33333);
|
||||
#if SHADOW_QUALITY > -1 && WATER_REFLECT_QUALITY >= 2 && WATER_MAT_QUALITY >= 2
|
||||
skyLightFactor = max(skyLightFactor, min1(dot(shadowMult, shadowMult)));
|
||||
#endif
|
||||
|
||||
vec4 reflection = GetReflection(normalM, viewPos.xyz, nViewPos, playerPos, lViewPos, -1.0,
|
||||
dhDepthTex1, dither, skyLightFactor, fresnel,
|
||||
smoothnessG, geoNormal, color.rgb, shadowMult, highlightMult);
|
||||
|
||||
color.rgb = mix(color.rgb, reflection.rgb, fresnelM);
|
||||
#endif
|
||||
////
|
||||
|
||||
float sky = 0.0;
|
||||
DoFog(color.rgb, sky, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
color.a *= 1.0 - sky;
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out int mat;
|
||||
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
out vec3 playerPos;
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
attribute vec4 at_tangent;
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
mat = dhMaterialId;
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
playerPos = (gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
mat3 tbnMatrix = mat3(
|
||||
eastVec.x, northVec.x, normal.x,
|
||||
eastVec.y, northVec.y, normal.y,
|
||||
eastVec.z, northVec.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,447 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
noperspective in vec2 texCoord;
|
||||
|
||||
//Pipeline Constants//
|
||||
#include "/lib/pipelineSettings.glsl"
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
#if IMAGE_SHARPENING > 0
|
||||
vec2 viewD = 1.0 / vec2(viewWidth, viewHeight);
|
||||
|
||||
vec2 sharpenOffsets[4] = vec2[4](
|
||||
vec2( viewD.x, 0.0),
|
||||
vec2( 0.0, viewD.x),
|
||||
vec2(-viewD.x, 0.0),
|
||||
vec2( 0.0, -viewD.x)
|
||||
);
|
||||
|
||||
void SharpenImage(inout vec3 color, vec2 texCoordM) {
|
||||
#ifdef TAA
|
||||
float sharpenMult = IMAGE_SHARPENING;
|
||||
#else
|
||||
float sharpenMult = IMAGE_SHARPENING * 0.5;
|
||||
#endif
|
||||
float mult = 0.0125 * sharpenMult;
|
||||
color *= 1.0 + 0.05 * sharpenMult;
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
color -= texture2D(colortex3, texCoordM + sharpenOffsets[i]).rgb * mult;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
float retroNoise (vec2 noise) {
|
||||
return fract(sin(dot(noise.xy,vec2(10.998,98.233)))*12433.14159265359);
|
||||
}
|
||||
|
||||
vec2 curveDisplay(vec2 texCoord, float curvatureAmount, int screenRoundness) {
|
||||
texCoord = texCoord * 2.0 - 1.0;
|
||||
vec2 offset = abs(texCoord.yx) * curvatureAmount * 0.5;
|
||||
|
||||
if (screenRoundness == 1) {
|
||||
offset *= offset;
|
||||
} else if (screenRoundness == 2) {
|
||||
offset *= pow2(offset);
|
||||
} else if (screenRoundness == 3) {
|
||||
offset *= pow3(offset);
|
||||
}
|
||||
texCoord += texCoord * offset;
|
||||
return texCoord * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec2 border(vec2 texCoord) {
|
||||
const float borderAmount = 2.0 + BORDER_AMOUNT * 0.1;
|
||||
texCoord = texCoord * borderAmount - borderAmount * 0.5;
|
||||
return texCoord * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec3 scanline(vec2 texCoord, vec3 color, float frequency, float intensity, float speed, float amount, vec3 scanlineRGB, bool monochrome, bool flipDirection) {
|
||||
if (flipDirection) {
|
||||
texCoord = texCoord.yx;
|
||||
}
|
||||
|
||||
float count = viewHeight * amount;
|
||||
vec2 scanlineColor = vec2(
|
||||
sin(mod(texCoord.y + frameTimeCounter * 0.2 * speed, frequency) * count),
|
||||
cos(mod(texCoord.y + frameTimeCounter * 0.5 * speed, 0.7 * frequency) * count)
|
||||
);
|
||||
|
||||
vec3 scanlines;
|
||||
if (monochrome) {
|
||||
scanlines = vec3(scanlineColor.y + scanlineColor.x * 0.2);
|
||||
} else {
|
||||
scanlines = vec3(scanlineColor.x * scanlineRGB.r, scanlineColor.y * scanlineRGB.g, scanlineColor.x * scanlineRGB.b);
|
||||
}
|
||||
|
||||
return color += color * scanlines * intensity * 0.1;
|
||||
}
|
||||
|
||||
|
||||
vec4 samplePixelatedBuffer(sampler2D tex, vec2 coords, int size) { // thanks to belmu for the code (mine had edge artifacts) https://github.com/BelmuTM/Noble/tree/master
|
||||
vec2 aspectCorrectedSize = size * vec2(aspectRatio, 1.0);
|
||||
return texelFetch(tex, ivec2((floor(coords * aspectCorrectedSize) / aspectCorrectedSize) * viewSize), 0);
|
||||
}
|
||||
|
||||
float halftones(vec2 texCoord, float angle, float scale) { // Thanks to https://www.shadertoy.com/view/4sBBDK by starea
|
||||
vec2 coord = texCoord * viewSize;
|
||||
vec2 dots = rotate(angle) * coord * scale;
|
||||
return sin(dots.x) * sin(dots.y) * 4.0;
|
||||
}
|
||||
|
||||
float noiseSpeedLines(float a, float p, float s) {
|
||||
float p1 = hash11Modified(mod(floor(a), p), s);
|
||||
float p2 = hash11Modified(mod(floor(a) + 2.0, p), s);
|
||||
return smoothstep(0.0, 0.1, mix(p1, p2, smoothstep(0.0, 1.0, fract(a))) - 0.3);
|
||||
}
|
||||
|
||||
float layeredNoiseSpeedLines(float a, float s) {
|
||||
return noiseSpeedLines(a, 20.0, s) + noiseSpeedLines(a * 5.0, 20.0 * 5.0, s);
|
||||
}
|
||||
|
||||
float speedLines(vec2 uv) { // Thanks to https://www.shadertoy.com/view/NldyDn by HalbFettKaese - modified a bit
|
||||
uv = uv * 2.0 - 1.0;
|
||||
float a = atan(uv.x, uv.y) / pi;
|
||||
float value = layeredNoiseSpeedLines((a * 17 + velocity * 7.0) * SPEED_LINE_THICKNESS * 1.5, (floor(frameTimeCounter * 10.0 * SPEED_LINES_SPEED) / 10.0 + velocity * 0.1) * 2.0);
|
||||
value -= 1.0 / length(uv) * 0.9 * (1.0 - clamp(velocity, 0.0, 0.4));
|
||||
return clamp(value, 0.0, 0.1);
|
||||
}
|
||||
|
||||
float randomNoiseOverlay1(vec2 st) {
|
||||
return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
|
||||
}
|
||||
|
||||
float grid(float uv) {
|
||||
float mainLine = smoothstep(0.9995 * (1.0 - MAIN_GRID_INTERVAL * 0.00005), 1.0, cos(uv * tau / (1.0 / MAIN_GRID_INTERVAL))) * 0.3;
|
||||
float subLine = smoothstep(0.9998 * (1.0 - SUB_GRID_INTERVAL * 0.00075), 1.0, cos(uv * tau * SUB_GRID_INTERVAL / (1.0 / MAIN_GRID_INTERVAL))) * 0.1;
|
||||
return mainLine + subLine;
|
||||
}
|
||||
|
||||
// Function to apply horizontal noise
|
||||
vec2 applyHorizontalNoise(vec2 texCoordM, float resolution, float intensity, float speed) {
|
||||
float horizontalNoiseResolution = resolution * 100.0;
|
||||
float horizontalNoiseIntensity = intensity * 0.002;
|
||||
float horizontalNoiseSpeed = speed * 0.0001;
|
||||
|
||||
texCoordM.y *= horizontalNoiseResolution;
|
||||
texCoordM.y = float(int(texCoordM.y)) * (1.0 / horizontalNoiseResolution);
|
||||
float noise = retroNoise(vec2(frameTimeCounter * horizontalNoiseSpeed, texCoordM.y));
|
||||
texCoordM.x += noise * horizontalNoiseIntensity;
|
||||
return texCoordM;
|
||||
}
|
||||
|
||||
// Function to apply vertical screen displacement
|
||||
void applyVerticalScreenDisplacement(inout vec2 texCoordM, inout float verticalOffset, float verticalScrollSpeed, float verticalStutterSpeed, float verticalEdgeGlitch, bool isVertical) {
|
||||
float displaceEffectOn = 1.0;
|
||||
#if defined SPOOKY && (!defined RETRO_ON || !defined VERTICAL_SCREEN_DISPLACEMENT)
|
||||
float randomShutterTime = 24000.0 * hash1(worldDay * 5);
|
||||
int displaceEffect = int(hash1(worldDay / 2)) % (2 * 24000) + int(randomShutterTime);
|
||||
displaceEffectOn = 0.0;
|
||||
if (worldTime > displaceEffect && worldTime < displaceEffect + 100.0) {
|
||||
displaceEffectOn = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
float scrollSpeed = verticalScrollSpeed * 2.0;
|
||||
float stutterSpeed = verticalStutterSpeed * 0.2;
|
||||
float scroll = (1.0 - step(retroNoise(vec2(frameTimeCounter * 0.00002, 8.0)), 0.9 * (1.0 - VERTICAL_SCROLL_FREQUENCY * 0.3))) * scrollSpeed;
|
||||
float stutter = (1.0 - step(retroNoise(vec2(frameTimeCounter * 0.00005, 9.0)), 0.8 * (1.0 - VERTICAL_STUTTER_FREQUENCY * 0.3))) * stutterSpeed;
|
||||
float stutter2 = (1.0 - step(retroNoise(vec2(frameTimeCounter * 0.00003, 5.0)), 0.7 * (1.0 - VERTICAL_STUTTER_FREQUENCY * 0.3))) * stutterSpeed;
|
||||
verticalOffset = sin(frameTimeCounter) * scroll + stutter * stutter2;
|
||||
if(isVertical) texCoordM.y = mix(texCoordM.y, mod(texCoordM.y + verticalOffset, verticalEdgeGlitch), displaceEffectOn);
|
||||
else texCoordM.x = mix(texCoordM.x, mod(texCoordM.x + verticalOffset, verticalEdgeGlitch), displaceEffectOn);
|
||||
}
|
||||
|
||||
vec4 waterMarkFunction(ivec2 pixelSize, vec2 textCoord, vec2 screenUV, float watermarkSizeMult, bool hideWatermark){
|
||||
float watermarkAspectRatio = float(pixelSize.x) / pixelSize.y;
|
||||
float watermarkSize = 1 / watermarkSizeMult;
|
||||
|
||||
if (aspectRatio < 3) textCoord += vec2(3 * screenUV.x * watermarkSize * 1.5 - 3 * watermarkSize * 1.5, 1.0 - 3 * watermarkAspectRatio * screenUV.y * watermarkSize * 1.5 / aspectRatio);
|
||||
else textCoord += vec2(screenUV.x * aspectRatio - aspectRatio, 1.0 - watermarkAspectRatio * screenUV.y);
|
||||
|
||||
// Only sample texture if we're in the valid range
|
||||
if (textCoord.x > -1 && textCoord.x < 0 && textCoord.y > 0 && textCoord.y < 1) {
|
||||
vec2 texCoordMapped = fract(textCoord);
|
||||
ivec2 fetchCoord = ivec2(texCoordMapped * pixelSize);
|
||||
vec4 EuphoriaPatchesText = texelFetch(depthtex2, fetchCoord, 0);
|
||||
|
||||
float guiIsNotHidden = 1.0;
|
||||
if (hideWatermark) {
|
||||
#if WATERMARK == 2
|
||||
if (hideGUI == 0) guiIsNotHidden = 0.0;
|
||||
#elif WATERMARK == 3
|
||||
if (hideGUI == 0 || heldItemId != 40000 && heldItemId2 != 40000) guiIsNotHidden = 0.0;
|
||||
#endif
|
||||
}
|
||||
return vec4(EuphoriaPatchesText.rgb, EuphoriaPatchesText.a * guiIsNotHidden);
|
||||
}
|
||||
return vec4(0.0); // Transparent
|
||||
}
|
||||
|
||||
vec3 staticColor(vec3 color, float staticIntensity, float minStaticStrength, float maxStaticStrength, float staticSpeed) { // credit to arananderson https://www.shadertoy.com/view/tsX3RN
|
||||
float maxStrength = max(minStaticStrength, maxStaticStrength);
|
||||
float minStrength = min(minStaticStrength, maxStaticStrength);
|
||||
float speed = staticSpeed * 10.0;
|
||||
|
||||
vec2 fractCoord = fract(texCoord * fract(sin(frameTimeCounter * speed)));
|
||||
|
||||
maxStrength = clamp(sin(frameTimeCounter * 0.5), minStrength, maxStrength);
|
||||
|
||||
vec3 staticColor = vec3(retroNoise(fractCoord)) * maxStrength;
|
||||
return mix(vec3(1.0), color - staticColor, staticIntensity);
|
||||
}
|
||||
|
||||
#include "/lib/textRendering/textRenderer.glsl"
|
||||
|
||||
void beginTextM(int textSize, vec2 offset) {
|
||||
float scale = 860;
|
||||
beginText(ivec2(vec2(scale * viewWidth / viewHeight, scale) * texCoord) / textSize, ivec2(0 + offset.x, scale / textSize - offset.y));
|
||||
text.bgCol = vec4(0.0);
|
||||
}
|
||||
|
||||
#include "/lib/misc/potato.glsl"
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 color = vec3(0.0);
|
||||
float viewWidthM = viewWidth;
|
||||
float viewHeightM = viewHeight;
|
||||
|
||||
#if BORDER_AMOUNT != 0
|
||||
vec2 texCoordM = border(texCoord);
|
||||
#else
|
||||
vec2 texCoordM = texCoord;
|
||||
#endif
|
||||
|
||||
#ifdef CURVE_DISPLAY
|
||||
texCoordM = curveDisplay(texCoordM, CURVATURE_AMOUNT, SCREEN_ROUNDNESS);
|
||||
#endif
|
||||
|
||||
vec2 texCoordBorder = texCoordM;
|
||||
|
||||
#if CAMERA_NOISE_OVERLAY == 1
|
||||
texCoordM += vec2(randomNoiseOverlay1(texCoordM + vec2(0.0, 0.0)), randomNoiseOverlay1(texCoordM + vec2(1.0, 1.0))) * 0.01 * CAMERA_NOISE_OVERLAY_INTENSITY;
|
||||
#endif
|
||||
|
||||
#if HORIZONTAL_NOISE > 0 && defined RETRO_ON
|
||||
texCoordM = applyHorizontalNoise(texCoordM, HORIZONTAL_NOISE, HORIZONTAL_NOISE_INTENSITY, HORIZONTAL_NOISE_SPEED);
|
||||
#endif
|
||||
|
||||
#if (defined VERTICAL_SCREEN_DISPLACEMENT && defined RETRO_ON) || defined SPOOKY
|
||||
float verticalOffset = 0.0;
|
||||
applyVerticalScreenDisplacement(texCoordM, verticalOffset, VERTICAL_SCROLL_SPEED, VERTICAL_STUTTER_SPEED, VERTICAL_EDGE_GLITCH, true);
|
||||
#endif
|
||||
|
||||
#if WATERMARK > 0
|
||||
vec4 watermarkColor = waterMarkFunction(ivec2(100, 29), vec2(0.05), texCoordM.xy, WATERMARK_SIZE, true);
|
||||
#endif
|
||||
|
||||
#ifdef UNDERWATER_DISTORTION
|
||||
if (isEyeInWater == 1)
|
||||
texCoordM += WATER_REFRACTION_INTENSITY * 0.00035 * sin((texCoord.x + texCoord.y) * 25.0 + frameTimeCounter * UNDERWATER_DISTORTION_STRENGTH);
|
||||
#endif
|
||||
|
||||
#if defined PIXELATE_SCREEN && defined RETRO_ON
|
||||
#if LONG_EXPOSURE > 0
|
||||
if(hideGUI == 0 || isViewMoving()){ // GUI visible OR moving
|
||||
#endif
|
||||
color = samplePixelatedBuffer(colortex3, texCoordM, PIXEL_SIZE_SCREEN).rgb;
|
||||
#if LONG_EXPOSURE > 0
|
||||
} else {
|
||||
color = samplePixelatedBuffer(colortex7, texCoordM, PIXEL_SIZE_SCREEN).rgb;
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
#if LONG_EXPOSURE > 0
|
||||
if(hideGUI == 0 || isViewMoving()){ // GUI visible OR moving
|
||||
#endif
|
||||
color = texture2D(colortex3, texCoordM).rgb;
|
||||
#if LONG_EXPOSURE > 0
|
||||
} else { // this is the accumulated one
|
||||
color = texture2D(colortex7, texCoordM).rgb;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if CHROMA_ABERRATION > 0 || defined SPOOKY
|
||||
vec2 scale = vec2(1.0, viewHeight / viewWidth);
|
||||
#ifdef SPOOKY
|
||||
float aberrationStrength = max(CHROMA_ABERRATION, playerMood * 10.0);
|
||||
#else
|
||||
float aberrationStrength = CHROMA_ABERRATION;
|
||||
#endif
|
||||
vec2 aberration = (texCoordM - 0.5) * (2.0 / vec2(viewWidth, viewHeight)) * scale * aberrationStrength;
|
||||
color.rb = vec2(texture2D(colortex3, texCoordM + aberration).r, texture2D(colortex3, texCoordM - aberration).b);
|
||||
#endif
|
||||
|
||||
#if LETTERBOXING > 0
|
||||
#if BORDER_AMOUNT > 0
|
||||
viewWidthM = viewWidth - viewWidth * BORDER_AMOUNT * 0.04;
|
||||
#endif
|
||||
float letterboxMargin = 0.5 - viewWidthM / (2 * viewHeightM * ASPECT_RATIO);
|
||||
#if LETTERBOXING == 2
|
||||
letterboxMargin = mix(0.0, letterboxMargin, isSneaking);
|
||||
#endif
|
||||
|
||||
if (texCoord.y > 1.0 - letterboxMargin || texCoord.y < letterboxMargin) {
|
||||
#ifdef EXCLUDE_ENTITIES
|
||||
if (int(texelFetch(colortex6, texelCoord, 0).g * 255.1) != 254) color *= 0.0;
|
||||
#else
|
||||
color *= mix(0.0, 1.0, LETTERBOXING_TRANSPARENCY);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BAD_APPLE
|
||||
color = vec3((int(texelFetch(colortex6, texelCoord, 0).g * 255.1) != 254) ? 0.0 : 1.0);
|
||||
#endif
|
||||
|
||||
#if DELTARUNE_BATTLE_BACKGROUND > 0
|
||||
vec3 deltaruneColor = movingCheckerboard(texCoord, 100.0, 1.0, vec2(0.05, -0.05), vec3(1.0, 0.0, 1.0));
|
||||
deltaruneColor += movingCheckerboard(texCoord, 100.0, 1.0, vec2(-0.025, 0.025), vec3(1.0, 0.0, 1.0) * 0.5);
|
||||
#if DELTARUNE_BATTLE_BACKGROUND == 1
|
||||
if (texture2D(depthtex0, texCoord).r == 1.0) color = deltaruneColor;
|
||||
#elif DELTARUNE_BATTLE_BACKGROUND == 2
|
||||
if ((int(texelFetch(colortex6, texelCoord, 0).g * 255.1) != 254)) {
|
||||
color = deltaruneColor;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if IMAGE_SHARPENING > 0
|
||||
#if LONG_EXPOSURE > 0
|
||||
if(hideGUI == 0 || isViewMoving()){ // GUI visible OR moving
|
||||
#endif
|
||||
SharpenImage(color, texCoordM);
|
||||
#if LONG_EXPOSURE > 0
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*ivec2 boxOffsets[8] = ivec2[8](
|
||||
ivec2( 1, 0),
|
||||
ivec2( 0, 1),
|
||||
ivec2(-1, 0),
|
||||
ivec2( 0,-1),
|
||||
ivec2( 1, 1),
|
||||
ivec2( 1,-1),
|
||||
ivec2(-1, 1),
|
||||
ivec2(-1,-1)
|
||||
);
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
color = max(color, texelFetch(colortex3, texelCoord + boxOffsets[i], 0).rgb);
|
||||
}*/
|
||||
|
||||
#if WATERMARK > 0
|
||||
color.rgb = mix(color.rgb, watermarkColor.rgb, watermarkColor.a);
|
||||
#endif
|
||||
|
||||
#ifdef LET_THERE_BE_COLORS
|
||||
color = hash33(color * frameTimeCounter);
|
||||
#endif
|
||||
|
||||
#if (STATIC_NOISE > 0 && defined RETRO_ON) || defined SPOOKY
|
||||
float staticIntensity = 0.0;
|
||||
#ifdef SPOOKY
|
||||
if (playerMood > 0.9) staticIntensity = (playerMood * 10.0 - 9.0) * 0.75;
|
||||
#else
|
||||
staticIntensity = STATIC_NOISE * 0.1;
|
||||
#endif
|
||||
color *= staticColor(color, staticIntensity, MIN_STATIC_STRENGTH, MAX_STATIC_STRENGTH, STATIC_SPEED);
|
||||
#endif
|
||||
|
||||
#if SCANLINE > 0 && defined RETRO_ON
|
||||
color = scanline(texCoord, color, SCANLINE_FREQUENCY, SCANLINE, SCANLINE_SPEED, SCANLINE_AMOUNT, vec3(SCANLINE_R, SCANLINE_G, SCANLINE_B), SCANLINE_NEW_MONOCHROME, SCANLINE_NEW_DIRECTION);
|
||||
#endif
|
||||
|
||||
#ifdef HALFTONE
|
||||
#ifdef HALFTONE_MONOCHROME
|
||||
float colorOld = GetLuminance(color);
|
||||
#else
|
||||
vec3 colorOld = color;
|
||||
#endif
|
||||
const float dotAngle = HALFTONE_ANGLE * pi * 0.5;
|
||||
const float dotScale = HALFTONE_SCALE;
|
||||
const float dotBrightness = HALFTONE_BRIGHTNESS * 2.0;
|
||||
color = vec3(colorOld * dotBrightness * 5.0 - 5.0 + halftones(texCoordM, dotAngle, dotScale));
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
color.rgb = mix(color.rgb, color.rgb * GetLuminance(color), 0.60);
|
||||
#endif
|
||||
|
||||
#if SPEED_LINES > 0
|
||||
float speedLines = speedLines(texCoordM);
|
||||
speedLines = mix(0.0, speedLines, SPEED_LINES_TRANSPARENCY);
|
||||
#if SPEED_LINES == 1
|
||||
color += vec3(mix(0.0, speedLines, isSprinting));
|
||||
#else
|
||||
color += vec3(speedLines);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if MAIN_GRID_INTERVAL > 1
|
||||
float grid = max(grid(texCoordM.x), grid(texCoordM.y));
|
||||
#if GRID_CONDITION == 0
|
||||
color += grid;
|
||||
#elif GRID_CONDITION == 1
|
||||
color += mix(0.0, grid, isSneaking);
|
||||
#elif GRID_CONDITION == 2
|
||||
float isHoldingSpyglass = 0.0;
|
||||
if (heldItemId == 45013 || heldItemId2 == 45013) isHoldingSpyglass = 1.0; //holding spyglass
|
||||
color += mix(0.0, grid, isHoldingSpyglass);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined CURVE_DISPLAY || BORDER_AMOUNT != 0
|
||||
if (texCoordBorder.x < 0.0 || texCoordBorder.x > 1.0) color = vec3(0.0);
|
||||
if (texCoordBorder.y < 0.0 || texCoordBorder.y > 1.0) color = vec3(0.0);
|
||||
#endif
|
||||
|
||||
ivec2 pixelToCheck = ivec2(42, 30);
|
||||
vec3 potatoColor = vec3(0.0);
|
||||
// beginTextM(8, vec2(6, 10)); printVec3(vec3(getPotatoColorInt(pixelToCheck))); endText(color.rgb);
|
||||
bool isPotato = checkPotatoPixel(pixelToCheck, ivec3(235, 191, 121), 0.1, potatoColor);
|
||||
if(!isPotato) color.rgb = potatoError();
|
||||
// color.rgb = potatoColor;
|
||||
|
||||
#include "/lib/textRendering/all_error_messages.glsl"
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = vec4(color, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
noperspective out vec2 texCoord;
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,102 @@
|
||||
//////////////////////////////////
|
||||
// Complementary Base by EminGT //
|
||||
//////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
color *= glColor;
|
||||
|
||||
color.rgb *= glColor.a; // Needed for Minecraft's "Glint Strength" apparently
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
#if defined ATLAS_ROTATION || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
vec2 lmCoord = GetLightMapCoordinates();
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
#if HAND_SWAYING > 0
|
||||
if (gl_ProjectionMatrix[2][2] > -0.5) {
|
||||
#include "/lib/misc/handSway.glsl"
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,223 @@
|
||||
//////////////////////////////////
|
||||
// Complementary Base by EminGT //
|
||||
//////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = glColor;
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
float lViewPos = length(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
|
||||
float materialMask = 0.0;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
float purkinjeOverwrite = 0.0, emission = 0.0;
|
||||
|
||||
#ifndef GBUFFERS_LINE
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoord, false, false, false,
|
||||
false, 0, 0.0, 0.0, 0.0, purkinjeOverwrite);
|
||||
#endif
|
||||
|
||||
#if SELECT_OUTLINE != 1 || defined SELECT_OUTLINE_AUTO_HIDE
|
||||
if (abs(color.a - 0.4) + dot(color.rgb, color.rgb) < 0.01) {
|
||||
#if SELECT_OUTLINE == 0
|
||||
discard;
|
||||
#elif SELECT_OUTLINE == 2 // Rainbow
|
||||
float posFactor = playerPos.x + playerPos.y + playerPos.z + cameraPosition.x + cameraPosition.y + cameraPosition.z;
|
||||
color.rgb = clamp(abs(mod(fract(frameTimeCounter*0.25 + posFactor*0.2) * 6.0 + vec3(0.0,4.0,2.0), 6.0) - 3.0) - 1.0,
|
||||
0.0, 1.0) * vec3(3.0, 2.0, 3.0) * SELECT_OUTLINE_I;
|
||||
#elif SELECT_OUTLINE == 3 // Select Color
|
||||
color.rgb = vec3(SELECT_OUTLINE_R, SELECT_OUTLINE_G, SELECT_OUTLINE_B) * SELECT_OUTLINE_I;
|
||||
#elif SELECT_OUTLINE == 4 // Versatile
|
||||
color.a = 0.1;
|
||||
#endif
|
||||
materialMask = OSIEBCA * 252.0; // Selection Outline
|
||||
|
||||
#ifdef SELECT_OUTLINE_AUTO_HIDE
|
||||
if (heldItemId == 40008 && (
|
||||
heldItemId2 == 40008 ||
|
||||
heldItemId2 == 45060 ||
|
||||
heldItemId2 == 45108 ||
|
||||
heldItemId2 >= 44000 &&
|
||||
heldItemId2 < 45000)) {
|
||||
// Both hands hold nothing or only a light/totem/shield in off-hand
|
||||
discard;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0 && defined NETHER
|
||||
if (gl_FragCoord.x < 0.0)
|
||||
color = shadow2D(shadowtex0, vec3(0.5)); // To Activate Shadowmap in Nether
|
||||
#endif
|
||||
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0 && !defined GBUFFERS_LINE
|
||||
if (color.a == 1.0 && GetLuminance(color.rgb) > 0.9999 && color.g > 0.9999 && color.b > 0.9999) {
|
||||
discard;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(0.0, materialMask, 0.0, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
#ifdef WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#ifndef GBUFFERS_LINE
|
||||
gl_Position = ftransform();
|
||||
#else
|
||||
float lineWidth = 2.0;
|
||||
vec2 screenSize = vec2(viewWidth, viewHeight);
|
||||
const mat4 VIEW_SCALE = mat4(mat3(1.0 - (1.0 / 256.0)));
|
||||
vec4 linePosStart = projectionMatrix * VIEW_SCALE * modelViewMatrix * vec4(vaPosition, 1.0);
|
||||
vec4 linePosEnd = projectionMatrix * VIEW_SCALE * modelViewMatrix * (vec4(vaPosition + vaNormal, 1.0));
|
||||
vec3 ndc1 = linePosStart.xyz / linePosStart.w;
|
||||
vec3 ndc2 = linePosEnd.xyz / linePosEnd.w;
|
||||
vec2 lineScreenDirection = normalize((ndc2.xy - ndc1.xy) * screenSize);
|
||||
vec2 lineOffset = vec2(-lineScreenDirection.y, lineScreenDirection.x) * lineWidth / screenSize;
|
||||
if (lineOffset.x < 0.0)
|
||||
lineOffset *= -1.0;
|
||||
if (gl_VertexID % 2 == 0)
|
||||
gl_Position = vec4((ndc1 + vec3(lineOffset, 0.0)) * linePosStart.w, linePosStart.w);
|
||||
else
|
||||
gl_Position = vec4((ndc1 - vec3(lineOffset, 0.0)) * linePosStart.w, linePosStart.w);
|
||||
#endif
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
#if !defined GBUFFERS_LINE && (defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING)
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,149 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
vec3 colorP = color.rgb;
|
||||
color *= glColor;
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
|
||||
#ifdef DISTANT_HORIZONS
|
||||
vec3 screenPosDH = vec3(screenPos.xy, texture2D(dhDepthTex, screenPos.xy).r);
|
||||
#ifdef TAA
|
||||
vec3 viewPosDH = ScreenToViewDH(vec3(TAAJitter(screenPosDH.xy, -0.5), screenPosDH.z));
|
||||
#else
|
||||
vec3 viewPosDH = ScreenToViewDH(screenPosDH);
|
||||
#endif
|
||||
|
||||
if (viewPos.z < viewPosDH.z)
|
||||
discard;
|
||||
#endif
|
||||
|
||||
float lViewPos = length(viewPos);
|
||||
|
||||
#ifdef IPBR
|
||||
float emission = dot(colorP, colorP);
|
||||
|
||||
if (color.a < 0.5) {
|
||||
color.a = 0.101;
|
||||
emission = pow2(pow2(emission)) * 0.1;
|
||||
}
|
||||
|
||||
emission *= BEACON_BEAM_EMISSION;
|
||||
|
||||
color.rgb *= color.rgb * emission * 1.75;
|
||||
color.rgb += emission * 0.05;
|
||||
#else
|
||||
color.rgb *= color.rgb * 4.0 * BEACON_BEAM_EMISSION;
|
||||
#endif
|
||||
|
||||
color.rgb *= 0.5 + 0.5 * exp(-lViewPos * 0.04);
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
|
||||
#if defined ATLAS_ROTATION || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
vec2 lmCoord = GetLightMapCoordinates();
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
|
||||
glColor = gl_Color;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,449 @@
|
||||
//////////////////////////////////
|
||||
// Complementary Base by EminGT //
|
||||
//////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in int mat;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
in vec3 atMidBlock;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || SHOCKWAVE > 0
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat in ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES
|
||||
#include "/lib/util/miplevel.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
#include "/lib/materials/materialMethods/generatedNormals.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
#include "/lib/materials/materialMethods/coatedTextures.glsl"
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#if SEASONS > 0 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoise.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef PORTAL_EDGE_EFFECT
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#endif
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
#include "/lib/misc/shockwave.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
float lViewPos = length(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
vec4 color = doShockwave(playerPos + relativeEyePosition, texCoord);
|
||||
#else
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
#endif
|
||||
#if defined GENERATED_NORMALS || PIXEL_WATER == 1
|
||||
vec3 colorP = color.rgb;
|
||||
#endif
|
||||
color *= glColor;
|
||||
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseTransparentOverwrite = 0.0;
|
||||
float IPBRMult = 1.0;
|
||||
int subsurfaceMode = 0;
|
||||
bool isFoliage = false;
|
||||
vec3 dhColor = vec3(1.0);
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
atmColorMult = GetAtmColorMult();
|
||||
sqrtAtmColorMult = sqrt(atmColorMult);
|
||||
#endif
|
||||
|
||||
bool noSmoothLighting = false, noDirectionalShading = false;
|
||||
float smoothnessD = 0.0, skyLightFactor = 0.0, materialMask = 0.0;
|
||||
float smoothnessG = 0.0, highlightMult = 1.0, emission = 0.0, noiseFactor = 1.0;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
float purkinjeOverwrite = 0.0;
|
||||
|
||||
if (lmCoord.x > 0.99) { // Mod support for light level 15 (and all light levels with iris 1.7) light sources
|
||||
if (blockEntityId == 0) {
|
||||
emission = DoAutomaticEmission(noSmoothLighting, noDirectionalShading, color.rgb, 1.0, 15);
|
||||
}
|
||||
overlayNoiseIntensity = 0.0;
|
||||
}
|
||||
|
||||
if (blockEntityId < 21025 && blockEntityId > 20999){
|
||||
emission = DoAutomaticEmission(noSmoothLighting, noDirectionalShading, color.rgb, 1.0, 15);
|
||||
}
|
||||
|
||||
#ifdef IPBR
|
||||
#include "/lib/materials/materialHandling/blockEntityMaterials.glsl"
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
emission = GetCustomEmissionForIPBR(color, emission);
|
||||
#endif
|
||||
#else
|
||||
#ifdef CUSTOM_PBR
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMask, viewPos, lViewPos);
|
||||
#endif
|
||||
|
||||
if (blockEntityId == 60025) { // End Portal, End Gateway
|
||||
#ifdef SPECIAL_PORTAL_EFFECTS
|
||||
#include "/lib/materials/specificMaterials/others/endPortalEffect.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
} else if (blockEntityId == 60004) { // Signs
|
||||
noSmoothLighting = true;
|
||||
if (glColor.r + glColor.g + glColor.b <= 2.99 || lmCoord.x > 0.999) { // Sign Text
|
||||
#include "/lib/materials/specificMaterials/others/signText.glsl"
|
||||
}
|
||||
} else if (blockEntityId == 60020) { // Conduit
|
||||
overlayNoiseIntensity = 0.3;
|
||||
} else if (blockEntityId == 60012) {
|
||||
overlayNoiseIntensity = 0.5;
|
||||
} else {
|
||||
noSmoothLighting = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoiseApply.glsl"
|
||||
#endif
|
||||
#if SEASONS > 0
|
||||
#include "/lib/materials/seasons.glsl"
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
GenerateNormals(normalM, colorP);
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
CoatTextures(color.rgb, noiseFactor, playerPos, false);
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, noDirectionalShading, false,
|
||||
false, 0, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
vec3 lightAlbedo = normalize(color.rgb) * min1(emission);
|
||||
|
||||
if (blockEntityId == 60000) lightAlbedo = color.rgb;
|
||||
if (blockEntityId == 60004) lightAlbedo = vec3(0.0); // fix glowing sign text affecting blocklight color
|
||||
#endif
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
#ifdef OVERWORLD
|
||||
skyLightFactor = clamp01(pow2(max(lmCoord.y - 0.7, 0.0) * 3.33333) + 0.0 + 0.0);
|
||||
#else
|
||||
skyLightFactor = dot(shadowMult, shadowMult) / 3.0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, blockEntityId);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(smoothnessD, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && RP_MODE != 0
|
||||
/* DRAWBUFFERS:065 */
|
||||
gl_FragData[2] = vec4(mat3(gbufferModelViewInverse) * normalM, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0658 */
|
||||
gl_FragData[3] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
#extension GL_ARB_shader_image_load_store : enable
|
||||
layout(r32i) uniform iimage2D endcrystal_img;
|
||||
#endif
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out int mat;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
out vec3 atMidBlock;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat out ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || SHOCKWAVE > 0
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || SHOCKWAVE > 0
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
attribute vec4 at_tangent;
|
||||
#endif
|
||||
|
||||
attribute vec4 at_midBlock;
|
||||
attribute vec4 mc_Entity;
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.1, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
mat = int(mc_Entity.x + 0.5);
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
atMidBlock = at_midBlock.xyz;
|
||||
|
||||
if (normal != normal) normal = -upVec; // Mod Fix: Fixes Better Nether Fireflies
|
||||
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
if (blockEntityId == 60025 && length((gl_ModelViewMatrix * gl_Vertex).xyz) < 28) // end portal
|
||||
imageStore(endcrystal_img, ivec2(35, 4), ivec4(1));
|
||||
#endif
|
||||
|
||||
#ifdef IPBR
|
||||
/*if (blockEntityId == 60025) { // End Portal, End Gateway
|
||||
gl_Position.z -= 0.002;
|
||||
}*/
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || SHOCKWAVE > 0
|
||||
if (blockEntityId == 60008) { // Chest
|
||||
float fractWorldPosY = fract((gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex).y + cameraPosition.y);
|
||||
if (fractWorldPosY > 0.56 && 0.57 > fractWorldPosY) gl_Position.z -= 0.0001;
|
||||
}
|
||||
|
||||
vec2 midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
#endif
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// ivec2 pixelTexSize = ivec2(absMidCoordPos * 2.0 * atlasSize);
|
||||
// #endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
vTexCoordAM.zw = abs(texMinMidCoord) * 2;
|
||||
vTexCoordAM.xy = min(texCoord, midCoord - texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,175 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
#if CLOUD_STYLE_DEFINE == 50
|
||||
// We use CLOUD_STYLE_DEFINE instead of CLOUD_STYLE in this file because Optifine can't use generated defines for pipeline stuff
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
|
||||
in vec4 glColor;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
#if CLOUD_STYLE_DEFINE == 50
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#if CLOUD_STYLE_DEFINE == 50
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
|
||||
#if defined TAA && (defined BORDER_FOG || RAINBOW_CLOUD != 0 || defined AURORA_INFLUENCE)
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#if CLOUD_STYLE_DEFINE != 50
|
||||
discard;
|
||||
#else
|
||||
vec4 color = texture2D(tex, texCoord) * glColor;
|
||||
|
||||
vec4 translucentMult = vec4(mix(vec3(0.666), color.rgb * (1.0 - pow2(pow2(color.a))), color.a), 1.0);
|
||||
|
||||
#if defined BORDER_FOG && !defined DREAM_TWEAKED_BORDERFOG || RAINBOW_CLOUD != 0 || defined AURORA_INFLUENCE
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
#if defined BORDER_FOG && !defined DREAM_TWEAKED_BORDERFOG
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
|
||||
float xzMaxDistance = max(abs(playerPos.x), abs(playerPos.z));
|
||||
float cloudDistance = 375.0;
|
||||
cloudDistance = clamp((cloudDistance - xzMaxDistance) / cloudDistance, 0.0, 1.0);
|
||||
color.a *= clamp01(cloudDistance * 3.0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 cloudLight = mix(vec3(0.8, 1.6, 1.5) * sqrt1(nightFactor), mix(dayDownSkyColor, dayMiddleSkyColor, 0.1), sunFactor);
|
||||
#if RAINBOW_CLOUD != 0
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz);
|
||||
wpos /= (abs(wpos.y) + length(wpos.xz));
|
||||
|
||||
cloudLight *= getRainbowColor(wpos.xz * rainbowCloudDistribution * 0.3, 0.05);
|
||||
#endif
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
cloudLight *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
cloudLight = mix(AuroraAmbientColor(cloudLight, viewPos), cloudLight, auroraSpookyMix);
|
||||
#endif
|
||||
#ifdef SPOOKY
|
||||
color.rgb *= 0.5;
|
||||
#endif
|
||||
color.rgb *= sqrt(cloudLight) * (1.2 + 0.4 * noonFactor * invRainFactor);
|
||||
|
||||
#if CLOUD_R != 100 || CLOUD_G != 100 || CLOUD_B != 100
|
||||
color.rgb *= vec3(CLOUD_R, CLOUD_G, CLOUD_B) * 0.01;
|
||||
#endif
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
color.rgb *= sqrt(GetAtmColorMult()); // C72380KD - Reduced atmColorMult impact on things
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
color.rgb *= moonPhaseInfluence;
|
||||
#endif
|
||||
#endif
|
||||
color.a *= CLOUD_TRANSPARENCY;
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:063 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
gl_FragData[2] = vec4(1.0 - translucentMult.rgb, translucentMult.a);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
#if CLOUD_STYLE_DEFINE == 50
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
|
||||
out vec4 glColor;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#if CLOUD_STYLE_DEFINE == 50
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#if CLOUD_STYLE_DEFINE != 50
|
||||
gl_Position = vec4(-1.0);
|
||||
#else
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,93 @@
|
||||
//////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
//////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
color.rgb *= glColor.rgb;
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
#if defined ATLAS_ROTATION || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
vec2 lmCoord = GetLightMapCoordinates();
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
glColor = gl_Color;
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,438 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
flat in vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float skyLightCheck = 0.0;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES
|
||||
#include "/lib/util/miplevel.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
#include "/lib/materials/materialMethods/generatedNormals.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
#include "/lib/materials/materialMethods/coatedTextures.glsl"
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
#include "/lib/misc/shockwave.glsl"
|
||||
#endif
|
||||
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
float lViewPos = length(viewPos);
|
||||
float purkinjeOverwrite = 0.0, emission = 0.0;
|
||||
|
||||
if (glColor.a < 0.0) discard;
|
||||
skyLightCheck = pow2(1.0 - min1(lmCoord.y * 2.9 * sunVisibility));
|
||||
#if SHOCKWAVE > 0
|
||||
vec4 color = doShockwave(playerPos + relativeEyePosition, texCoord);
|
||||
#else
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
#endif
|
||||
#if defined GENERATED_NORMALS || PIXEL_WATER == 1
|
||||
vec3 colorP = color.rgb;
|
||||
#endif
|
||||
color *= glColor;
|
||||
|
||||
float smoothnessD = 0.0, skyLightFactor = 0.0, materialMask = OSIEBCA * 254.0; // No SSAO, No TAA
|
||||
vec3 normalM = normal;
|
||||
|
||||
float luminance = GetLuminance(color.rgb);
|
||||
|
||||
if (color.a > 0.001) {
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseEmission = 1.0;
|
||||
float overlayNoiseTransparentOverwrite = 0.0;
|
||||
bool isFoliage = false;
|
||||
vec3 dhColor = vec3(1.0);
|
||||
|
||||
#if SEASONS > 0
|
||||
#include "/lib/materials/seasons.glsl"
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, entityColor.rgb, entityColor.a);
|
||||
|
||||
bool noSmoothLighting = atlasSize.x < 600.0; // To fix fire looking too dim
|
||||
bool noGeneratedNormals = false;
|
||||
float smoothnessG = 0.0, highlightMult = 0.0, noiseFactor = 0.75;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 shadowMult = vec3(1.0);
|
||||
#ifdef IPBR
|
||||
#include "/lib/materials/materialHandling/entityMaterials.glsl"
|
||||
|
||||
#ifdef IS_IRIS
|
||||
vec3 maRecolor = vec3(0.0);
|
||||
#include "/lib/materials/materialHandling/irisMaterials.glsl"
|
||||
#endif
|
||||
|
||||
if (materialMask != OSIEBCA * 254.0) materialMask += OSIEBCA * 100.0; // Entity Reflection Handling
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
if (!noGeneratedNormals) GenerateNormals(normalM, colorP);
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
CoatTextures(color.rgb, noiseFactor, playerPos, false);
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
emission = GetCustomEmissionForIPBR(color, emission);
|
||||
#endif
|
||||
#else
|
||||
#ifdef CUSTOM_PBR
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMask, viewPos, lViewPos);
|
||||
#endif
|
||||
|
||||
if (entityId == 50004) { // Lightning Bolt
|
||||
#include "/lib/materials/specificMaterials/entities/lightningBolt.glsl"
|
||||
} else if (entityId == 50008) { // Item Frame, Glow Item Frame
|
||||
noSmoothLighting = true;
|
||||
} else if (entityId == 50076) { // Boats
|
||||
playerPos.y += 0.38; // to avoid water shadow and the black inner shadow bug
|
||||
}
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
if (entityId == 50020) { // blaze
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
} else if (entityId == 50052) { // Magma Cube
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
} else if (entityId == 50088) { // Entity Flame
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
} else if (entityId == 50092 || entityId == 50093) { // fireball, small fireball
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, entityColor.rgb, entityColor.a);
|
||||
|
||||
normalM = gl_FrontFacing ? normalM : -normalM; // Inverted Normal Workaround
|
||||
vec3 geoNormal = normalM;
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, false, false,
|
||||
true, 0, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#if defined IPBR && defined IS_IRIS
|
||||
color.rgb += maRecolor;
|
||||
#endif
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
#ifdef OVERWORLD
|
||||
skyLightFactor = clamp01(pow2(max(lmCoord.y - 0.7, 0.0) * 3.33333) + 0.0 + 0.0);
|
||||
#else
|
||||
skyLightFactor = dot(shadowMult, shadowMult) / 3.0;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(smoothnessD, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && RP_MODE >= 1
|
||||
/* DRAWBUFFERS:065 */
|
||||
gl_FragData[2] = vec4(mat3(gbufferModelViewInverse) * normalM, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0658 */
|
||||
gl_FragData[3] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
flat out vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || (defined IPBR && defined IS_IRIS) || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
attribute vec4 at_tangent;
|
||||
#endif
|
||||
|
||||
attribute vec4 at_midBlock;
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
lmCoord.x = min(lmCoord.x, 0.9);
|
||||
//Fixes some servers/mods making entities insanely bright, while also slightly reducing the max blocklight on a normal entity
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
vTexCoordAM.zw = abs(texMinMidCoord) * 2;
|
||||
vTexCoordAM.xy = min(texCoord, midCoord - texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES_GLOWING
|
||||
if (glColor.a > 0.99) gl_Position.z *= 0.01;
|
||||
#endif
|
||||
|
||||
#ifdef EMIN_BOAT
|
||||
if (entityId == 50076) {
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
position.y += 1.25;
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FLICKERING_FIX
|
||||
if (entityId == 50008 || entityId == 50012) { // Item Frame, Glow Item Frame
|
||||
if (dot(normal, upVec) > 0.99) {
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
vec3 comPos = fract(position.xyz + cameraPosition);
|
||||
comPos = abs(comPos - vec3(0.5));
|
||||
if ((comPos.y > 0.437 && comPos.y < 0.438) || (comPos.y > 0.468 && comPos.y < 0.469)) {
|
||||
gl_Position.z += 0.0001;
|
||||
}
|
||||
}
|
||||
if (gl_Normal.y == 1.0) { // Maps
|
||||
normal = upVec * 2.0;
|
||||
}
|
||||
} else if (entityId == 50084) { // Slime, Chicken
|
||||
gl_Position.z -= 0.00015;
|
||||
}
|
||||
|
||||
#if SHADOW_QUALITY == -1
|
||||
#ifdef VANILLA_ENTITY_SHADOWS
|
||||
if (glColor.a < 0.5) gl_Position.z -= 0.0005;
|
||||
#else
|
||||
if (glColor.a < 0.5) gl_Position.z += 0.0005;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
if (entityId == 50200) {
|
||||
gl_Position = vec4(-1);
|
||||
}
|
||||
#endif
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0 && !defined IRIS_TAG_SUPPORT
|
||||
if (entityId == 0 && gl_Color.a < 0.2 && abs(normal.y) < 0.2) {
|
||||
glColor.a = -100000.0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,343 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
flat in vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, vec3(0.0, 1.0, 0.0)); // NdotU is different here to improve held map visibility
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float skyLightCheck = 0.0;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES
|
||||
#include "/lib/util/miplevel.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
#include "/lib/materials/materialMethods/generatedNormals.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
#include "/lib/materials/materialMethods/coatedTextures.glsl"
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
skyLightCheck = pow2(1.0 - min1(lmCoord.y * 2.9 * sunVisibility));
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
float purkinjeOverwrite = 0.0, emission = 0.0;
|
||||
|
||||
float smoothnessD = 0.0, skyLightFactor = 0.0, materialMask = OSIEBCA * 254.0; // No SSAO, No TAA
|
||||
vec3 normalM = normal;
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
vec3 lightAlbedo = vec3(0.0);
|
||||
#endif
|
||||
|
||||
if (color.a > 0.00001) {
|
||||
#if defined GENERATED_NORMALS || PIXEL_WATER == 1
|
||||
vec3 colorP = color.rgb;
|
||||
#endif
|
||||
color *= glColor;
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z + 0.38);
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
|
||||
float luminance = GetLuminance(color.rgb);
|
||||
|
||||
if (color.a < 0.75) materialMask = 0.0;
|
||||
|
||||
bool noSmoothLighting = true, noGeneratedNormals = false;
|
||||
float smoothnessG = 0.0, highlightMult = 1.0, noiseFactor = 0.6;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 geoNormal = normalM;
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
vec3 shadowMult = vec3(0.4);
|
||||
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseEmission = 1.0;
|
||||
bool isFoliage = false;
|
||||
|
||||
#ifdef IPBR
|
||||
#ifdef IS_IRIS
|
||||
vec3 maRecolor = vec3(0.0);
|
||||
#include "/lib/materials/materialHandling/irisMaterials.glsl"
|
||||
|
||||
if (materialMask != OSIEBCA * 254.0) materialMask += OSIEBCA * 100.0; // Entity Reflection Handling
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
if (!noGeneratedNormals) GenerateNormals(normalM, colorP);
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
CoatTextures(color.rgb, noiseFactor, playerPos, false);
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
emission = GetCustomEmissionForIPBR(color, emission);
|
||||
#endif
|
||||
#else
|
||||
#ifdef CUSTOM_PBR
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMask, viewPos, 0.0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Support for modded light sources and blockID set by the user
|
||||
#if defined IS_IRIS && !defined MC_OS_MAC
|
||||
if (currentRenderedItemId == 0) {
|
||||
float screenWidth = viewPos.x;
|
||||
float region1End = -0.1; // End of the first 2/5 region
|
||||
float region2Start = 0.1; // Start of the last 2/5 region
|
||||
int heldBlockLight = 0;
|
||||
if (screenWidth <= region1End || screenWidth >= region2Start) {
|
||||
heldBlockLight = (viewPos.x > 0.0 ^^ isRightHanded) ? heldBlockLightValue2 : heldBlockLightValue;
|
||||
}
|
||||
|
||||
if (heldBlockLight > 0) {
|
||||
bool doesNothing;
|
||||
emission = DoAutomaticEmission(noSmoothLighting, doesNothing, color.rgb, 0.0, heldBlockLight);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, 0.0, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, false, false,
|
||||
false, 0, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
lightAlbedo = normalize(color.rgb) * min1(emission);
|
||||
#endif
|
||||
|
||||
#if defined IPBR && defined IS_IRIS
|
||||
color.rgb += maRecolor;
|
||||
#endif
|
||||
|
||||
#if (defined CUSTOM_PBR || defined IPBR && defined IS_IRIS) && defined PBR_REFLECTIONS
|
||||
#ifdef OVERWORLD
|
||||
skyLightFactor = clamp01(pow2(max(lmCoord.y - 0.7, 0.0) * 3.33333) + 0.0 + 0.0);
|
||||
#else
|
||||
skyLightFactor = dot(shadowMult, shadowMult) / 3.0;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(smoothnessD, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && (RP_MODE >= 2 || defined IS_IRIS)
|
||||
/* DRAWBUFFERS:065 */
|
||||
gl_FragData[2] = vec4(mat3(gbufferModelViewInverse) * normalM, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0658 */
|
||||
gl_FragData[3] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
flat out vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
attribute vec4 at_tangent;
|
||||
#endif
|
||||
|
||||
attribute vec4 at_midBlock;
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
vTexCoordAM.zw = abs(texMinMidCoord) * 2;
|
||||
vTexCoordAM.xy = min(texCoord, midCoord - texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if HAND_SWAYING > 0
|
||||
#include "/lib/misc/handSway.glsl"
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,296 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
flat in vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float skyLightCheck = 0.0;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
if (glColor.a < 0.0) discard;
|
||||
skyLightCheck = pow2(1.0 - min1(lmCoord.y * 2.9 * sunVisibility));
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
#if defined GENERATED_NORMALS || PIXEL_WATER == 1
|
||||
vec3 colorP = color.rgb;
|
||||
#endif
|
||||
color *= glColor;
|
||||
|
||||
float smoothnessD = 0.0, skyLightFactor = 0.0, materialMask = OSIEBCA * 254.0; // No SSAO, No TAA
|
||||
vec3 normalM = normal;
|
||||
float purkinjeOverwrite = 0.0, emission = 0.0;
|
||||
|
||||
float luminance = GetLuminance(color.rgb);
|
||||
|
||||
if (color.a > 0.001) {
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
float lViewPos = length(viewPos);
|
||||
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseEmission = 1.0;
|
||||
float overlayNoiseTransparentOverwrite = 0.0;
|
||||
bool isFoliage = false;
|
||||
vec3 dhColor = vec3(1.0);
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, entityColor.rgb, entityColor.a);
|
||||
|
||||
bool noSmoothLighting = atlasSize.x < 600.0; // To fix fire looking too dim
|
||||
bool noGeneratedNormals = false;
|
||||
float smoothnessG = 0.0, highlightMult = 0.0, noiseFactor = 0.75;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 shadowMult = vec3(1.0);
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMask, viewPos, lViewPos);
|
||||
#endif
|
||||
|
||||
if (entityId == 50004) { // Lightning Bolt
|
||||
#include "/lib/materials/specificMaterials/entities/lightningBolt.glsl"
|
||||
}
|
||||
|
||||
normalM = gl_FrontFacing ? normalM : -normalM; // Inverted Normal Workaround
|
||||
vec3 geoNormal = normalM;
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, false, false,
|
||||
true, 0, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
#ifdef OVERWORLD
|
||||
skyLightFactor = clamp01(pow2(max(lmCoord.y - 0.7, 0.0) * 3.33333) + 0.0 + 0.0);
|
||||
#else
|
||||
skyLightFactor = dot(shadowMult, shadowMult) / 3.0;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(smoothnessD, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && RP_MODE >= 1
|
||||
/* DRAWBUFFERS:065 */
|
||||
gl_FragData[2] = vec4(mat3(gbufferModelViewInverse) * normalM, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0658 */
|
||||
gl_FragData[3] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
flat out vec2 midCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#extension GL_ARB_shader_image_load_store : enable
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || (defined IPBR && defined IS_IRIS) || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
attribute vec4 at_tangent;
|
||||
#endif
|
||||
|
||||
attribute vec4 at_midBlock;
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#include "/lib/misc/endCrystalVoxelization.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
lmCoord.x = min(lmCoord.x, 0.9);
|
||||
//Fixes some servers/mods making entities insanely bright, while also slightly reducing the max blocklight on a normal entity
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || defined POM || defined IPBR && defined IS_IRIS
|
||||
midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
if (entityId == 0 && gl_Color.a < 0.5) { // Only lightning bolts and dragon death effect run in this program, lightning has an entity ID assigned
|
||||
glColor.a = -100000.0;
|
||||
SetEndDragonDeath();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,268 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
flat in float vanillaStars;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
#include "/lib/atmospherics/stars.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#if SUN_MOON_STYLE >= 2
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = vec4(glColor.rgb, 1.0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
if (vanillaStars > 0.5) {
|
||||
discard;
|
||||
}
|
||||
|
||||
#if IRIS_VERSION >= 10800 && IRIS_VERSION < 10805
|
||||
if (renderStage == MC_RENDER_STAGE_MOON) {
|
||||
discard; // Fixes the vanilla sky gradient causing the sun to disappear
|
||||
}
|
||||
#endif
|
||||
|
||||
vec4 screenPos = vec4(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
vec3 nViewPos = normalize(viewPos.xyz);
|
||||
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
float dither = Bayer8(gl_FragCoord.xy);
|
||||
|
||||
color.rgb = GetSky(VdotU, VdotS, dither, true, false);
|
||||
|
||||
#ifdef ATM_COLOR_MULTS
|
||||
color.rgb *= GetAtmColorMult();
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
color.rgb *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
vec2 starCoord = GetStarCoord(viewPos.xyz, 0.5);
|
||||
#if STAR_BRIGHTNESS != 3
|
||||
vec3 starColor = GetStars(starCoord, VdotU, VdotS, 1.0, 0.0);
|
||||
|
||||
#define ADD_STAR_LAYER_OW1 (STAR_LAYER_OW == 1 || STAR_LAYER_OW == 3)
|
||||
#define ADD_STAR_LAYER_OW2 (STAR_LAYER_OW == 2 || STAR_LAYER_OW == 3)
|
||||
|
||||
#if ADD_STAR_LAYER_OW1
|
||||
starColor = max(starColor, GetStars(starCoord, VdotU, VdotS, 0.66, 0.0));
|
||||
#endif
|
||||
|
||||
#if ADD_STAR_LAYER_OW2
|
||||
starColor = max(starColor, GetStars(starCoord, VdotU, VdotS, 2.2, 0.45));
|
||||
#endif
|
||||
|
||||
color.rgb += starColor;
|
||||
#endif
|
||||
|
||||
#if SUN_MOON_STYLE >= 2
|
||||
float absVdotS = abs(VdotS);
|
||||
#if SUN_MOON_STYLE == 2
|
||||
float sunSizeFactor1 = 0.9975;
|
||||
float sunSizeFactor2 = 400.0;
|
||||
float moonCrescentOffset = 0.0055;
|
||||
float moonPhaseFactor1 = 2.45;
|
||||
float moonPhaseFactor2 = 750.0;
|
||||
#else
|
||||
float sunSizeFactor1 = 0.9983;
|
||||
float sunSizeFactor2 = 588.235;
|
||||
float moonCrescentOffset = 0.0042;
|
||||
float moonPhaseFactor1 = 2.2;
|
||||
float moonPhaseFactor2 = 1000.0;
|
||||
#endif
|
||||
if (absVdotS > sunSizeFactor1) {
|
||||
float sunMoonMixer = sqrt1(sunSizeFactor2 * (absVdotS - sunSizeFactor1));
|
||||
|
||||
#ifdef SUN_MOON_DURING_RAIN
|
||||
sunMoonMixer *= 1.0 - 0.4 * rainFactor2;
|
||||
#else
|
||||
sunMoonMixer *= 1.0 - rainFactor2;
|
||||
#endif
|
||||
|
||||
if (VdotS > 0.0) {
|
||||
sunMoonMixer = pow2(sunMoonMixer) * GetHorizonFactor(SdotU);
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
sunMoonMixer *= 1.0 - 0.65 * GetCaveFactor();
|
||||
#endif
|
||||
|
||||
float sunBrightness = 10.0;
|
||||
#ifdef SPOOKY
|
||||
sunBrightness = 7.0;
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, vec3(0.9, 0.5, 0.3) * sunBrightness, sunMoonMixer);
|
||||
} else {
|
||||
float horizonFactor = GetHorizonFactor(-SdotU);
|
||||
sunMoonMixer = max0(sunMoonMixer - 0.25) * 1.33333 * horizonFactor;
|
||||
|
||||
starCoord = GetStarCoord(viewPos.xyz, 1.0) * 0.5 + 0.617;
|
||||
float moonNoise = texture2D(noisetex, starCoord).g
|
||||
+ texture2D(noisetex, starCoord * 2.5).g * 0.7
|
||||
+ texture2D(noisetex, starCoord * 5.0).g * 0.5;
|
||||
moonNoise = max0(moonNoise - 0.75) * 1.7;
|
||||
float moonNoiseIntensity = 1.0;
|
||||
vec3 moonColorSpooky = vec3(0.38, 0.4, 0.5);
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
moonNoiseIntensity = mix(1.0, 1.5, getBloodMoon(moonPhase, sunVisibility));
|
||||
moonColorSpooky = mix(vec3(0.38, 0.4, 0.5), vec3(1.0, 0.0, 0.0), getBloodMoon(moonPhase, sunVisibility));
|
||||
#endif
|
||||
vec3 moonColor = moonColorSpooky * (1.2 - (0.2 + 0.2 * sqrt1(nightFactor)) * moonNoise * moonNoiseIntensity);
|
||||
|
||||
if (moonPhase >= 1) {
|
||||
float moonPhaseOffset = 0.0;
|
||||
if (moonPhase != 4) {
|
||||
moonPhaseOffset = moonCrescentOffset;
|
||||
moonColor *= 8.5;
|
||||
} else moonColor *= 10.0;
|
||||
if (moonPhase > 4) {
|
||||
moonPhaseOffset = -moonPhaseOffset;
|
||||
}
|
||||
|
||||
float ang = fract(timeAngle - (0.25 + moonPhaseOffset));
|
||||
ang = (ang + (cos(ang * 3.14159265358979) * -0.5 + 0.5 - ang) / 3.0) * 6.28318530717959;
|
||||
vec2 sunRotationData2 = vec2(cos(sunPathRotation * 0.01745329251994), -sin(sunPathRotation * 0.01745329251994));
|
||||
vec3 rawSunVec2 = (gbufferModelView * vec4(vec3(-sin(ang), cos(ang) * sunRotationData2) * 2000.0, 1.0)).xyz;
|
||||
|
||||
float moonPhaseVdosS = dot(nViewPos, normalize(rawSunVec2.xyz));
|
||||
|
||||
sunMoonMixer *= pow2(1.0 - min1(pow(abs(moonPhaseVdosS), moonPhaseFactor2) * moonPhaseFactor1));
|
||||
} else moonColor *= 4.0;
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
sunMoonMixer *= 1.0 - 0.5 * GetCaveFactor();
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, moonColor, sunMoonMixer);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
color.rgb *= 1.0 - maxBlindnessDarkness;
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
flat out float vanillaStars;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
vec2 lmCoord = GetLightMapCoordinates();
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#ifdef OVERWORLD
|
||||
//Vanilla Star Dedection by Builderb0y
|
||||
vanillaStars = float(glColor.r == glColor.g && glColor.g == glColor.b && glColor.r > 0.0 && glColor.r < 0.51);
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,177 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
flat in vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
#ifdef OVERWORLD
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
#ifdef END
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#ifdef OVERWORLD
|
||||
vec2 tSize = textureSize(tex, 0);
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
color.rgb *= glColor.rgb;
|
||||
|
||||
vec4 screenPos = vec4(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z, 1.0);
|
||||
vec4 viewPos = gbufferProjectionInverse * (screenPos * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
vec3 nViewPos = normalize(viewPos.xyz);
|
||||
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
|
||||
#ifdef IS_IRIS
|
||||
bool isSun = renderStage == MC_RENDER_STAGE_SUN;
|
||||
bool isMoon = renderStage == MC_RENDER_STAGE_MOON;
|
||||
#else
|
||||
bool tSizeCheck = abs(tSize.y - 264.0) < 248.5; //tSize.y must range from 16 to 512
|
||||
bool sunSideCheck = VdotS > 0.0;
|
||||
bool isSun = tSizeCheck && sunSideCheck;
|
||||
bool isMoon = tSizeCheck && !sunSideCheck;
|
||||
#endif
|
||||
|
||||
if (isSun || isMoon) {
|
||||
#if SUN_MOON_STYLE >= 2
|
||||
discard;
|
||||
#endif
|
||||
|
||||
if (isSun) {
|
||||
float sunBrightness = 3.2;
|
||||
#ifdef SPOOKY
|
||||
sunBrightness = 0.5;
|
||||
#endif
|
||||
color.rgb *= dot(color.rgb, color.rgb) * normalize(lightColor) * sunBrightness;
|
||||
color.rgb *= 0.25 + (0.75 - 0.25 * rainFactor) * sunVisibility2;
|
||||
}
|
||||
|
||||
if (isMoon) {
|
||||
color.rgb *= smoothstep1(min1(length(color.rgb))) * 1.3;
|
||||
#ifdef SPOOKY
|
||||
color.rgb = mix(color.rgb, GetLuminance(color.rgb) * vec3(1.0, 0.0, 0.0) * 1.5, getBloodMoon(moonPhase, sunVisibility));
|
||||
#endif
|
||||
}
|
||||
|
||||
color.rgb *= GetHorizonFactor(VdotU);
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
color.rgb *= 1.0 - 0.75 * GetCaveFactor();
|
||||
#endif
|
||||
} else { // Custom Sky
|
||||
#if MC_VERSION >= 11300
|
||||
color.rgb *= color.rgb * smoothstep1(sqrt1(max0(VdotU)));
|
||||
#else
|
||||
discard;
|
||||
// Old mc custom skyboxes are weirdly broken, so we discard.
|
||||
#endif
|
||||
}
|
||||
|
||||
if (isEyeInWater == 1) color.rgb *= 0.25;
|
||||
|
||||
// Reduced visibility in rain
|
||||
float rainFactorM = rainFactor;
|
||||
#ifdef SUN_MOON_DURING_RAIN
|
||||
rainFactorM *= 0.8;
|
||||
#endif
|
||||
#if defined CLEAR_SKY_WHEN_RAINING || defined NO_RAIN_ABOVE_CLOUDS
|
||||
rainFactorM *= heightRelativeToCloud;
|
||||
#endif
|
||||
color.a *= 1.0 - rainFactorM;
|
||||
#endif
|
||||
|
||||
#ifdef NETHER
|
||||
vec4 color = vec4(0.0);
|
||||
#endif
|
||||
|
||||
#ifdef END
|
||||
vec4 color = vec4(endSkyColor, 1.0);
|
||||
#endif
|
||||
|
||||
#if RETRO_LOOK == 1
|
||||
color.rgb = GetLuminance(color.rgb) * vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.3 * RETRO_LOOK_I;
|
||||
#elif RETRO_LOOK == 2
|
||||
color.rgb = mix(color.rgb, GetLuminance(color.rgb) * vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.3 * RETRO_LOOK_I, nightVision);
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
flat out vec3 upVec, sunVec;
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,112 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord) * glColor;
|
||||
|
||||
#ifdef IPBR
|
||||
if (CheckForColor(color.rgb, vec3(224, 121, 250))) { // Enderman Eye Edges
|
||||
color.rgb = vec3(0.8, 0.25, 0.8);
|
||||
}
|
||||
#endif
|
||||
#ifdef INTENSE_DEEP_DARK
|
||||
if (color.b > 0.1 && color.r < 0.5) { // Warden
|
||||
color.rgb = mix(color.rgb, color.rgb + 0.3, darknessFactor);
|
||||
}
|
||||
#endif
|
||||
|
||||
color.rgb *= 1.0 - 0.6 * pow2(pow2(min1(GetLuminance(color.rgb) * 1.2))); // Fixes ultra bright Breeze
|
||||
|
||||
color.rgb = pow1_5(color.rgb);
|
||||
color.rgb *= pow2(1.0 + color.b + 0.5 * color.g) * 1.5;
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(0, 0, 0, 1);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
|
||||
#if defined ATLAS_ROTATION || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
vec2 lmCoord = GetLightMapCoordinates();
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,762 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in int mat;
|
||||
flat in int blockLightEmission;
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
flat in vec2 midCoord;
|
||||
in vec3 blockUV;
|
||||
in vec3 atMidBlock;
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat in ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 normal;
|
||||
|
||||
in vec4 glColorRaw;
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec3 viewVector;
|
||||
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
#if ANISOTROPIC_FILTER > 0
|
||||
in vec4 spriteBounds;
|
||||
#endif
|
||||
|
||||
in vec4 beforeTransformPos;
|
||||
|
||||
//Pipeline Constants//
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
const float voxelDistance = 128.0;
|
||||
#elif COLORED_LIGHTING_INTERNAL > 0
|
||||
const float voxelDistance = 32.0;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
float skyLightCheck = 0.0;
|
||||
|
||||
vec4 glColor = glColorRaw;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
void DoFoliageColorTweaks(inout vec3 color, inout vec3 shadowMult, inout float snowMinNdotU, vec3 viewPos, vec3 nViewPos, float lViewPos, float dither) {
|
||||
#ifdef DREAM_TWEAKED_LIGHTING
|
||||
return;
|
||||
#endif
|
||||
float factor = max(80.0 - lViewPos, 0.0);
|
||||
shadowMult *= 1.0 + 0.004 * noonFactor * factor;
|
||||
|
||||
if (signMidCoordPos.x < 0.0) color.rgb *= 1.08;
|
||||
else color.rgb *= 0.93;
|
||||
|
||||
#ifdef FOLIAGE_ALT_SUBSURFACE
|
||||
float edgeSize = 0.12;
|
||||
float edgeEffectFactor = 0.75;
|
||||
|
||||
edgeEffectFactor *= (sqrt1(abs(dot(nViewPos, normal))) - 0.1) * 1.111;
|
||||
|
||||
vec2 texCoordM = texCoord;
|
||||
texCoordM.y -= edgeSize * pow2(dither) * absMidCoordPos.y;
|
||||
texCoordM.y = max(texCoordM.y, midCoord.y - absMidCoordPos.y);
|
||||
vec4 colorSample = texture2DLod(tex, texCoordM, 0);
|
||||
|
||||
if (colorSample.a < 0.5) {
|
||||
float edgeFactor = dot(nViewPos, lightVec);
|
||||
shadowMult *= 1.0 + edgeEffectFactor * (1.0 + edgeFactor);
|
||||
}
|
||||
|
||||
shadowMult *= 1.0 + 0.2333 * edgeEffectFactor * (dot(normal, lightVec) - 1.0);
|
||||
#endif
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
if (glColor.g - glColor.b > 0.01)
|
||||
snowMinNdotU = min(pow2(pow2(max0(color.g * 2.0 - color.r - color.b))) * 5.0, 0.1);
|
||||
else
|
||||
snowMinNdotU = min(pow2(pow2(max0(color.g * 2.0 - color.r - color.b))) * 3.0, 0.1) * 0.25;
|
||||
|
||||
#ifdef DISTANT_HORIZONS
|
||||
// DH chunks don't have foliage. The border looks too noticeable without this tweak
|
||||
snowMinNdotU = mix(snowMinNdotU, 0.09, smoothstep(far * 0.5, far, lViewPos));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void DoBrightBlockTweaks(vec3 color, float minLight, inout vec3 shadowMult, inout float highlightMult) {
|
||||
float factor = mix(minLight, 1.0, pow2(pow2(color.r)));
|
||||
shadowMult = vec3(factor);
|
||||
highlightMult /= factor;
|
||||
}
|
||||
|
||||
void DoOceanBlockTweaks(inout float smoothnessD) {
|
||||
smoothnessD *= max0(lmCoord.y - 0.95) * 20.0;
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || ANISOTROPIC_FILTER > 0 || defined DISTANT_LIGHT_BOKEH
|
||||
#include "/lib/util/miplevel.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
#include "/lib/materials/materialMethods/generatedNormals.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
#include "/lib/materials/materialMethods/coatedTextures.glsl"
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#if ANISOTROPIC_FILTER > 0
|
||||
#include "/lib/materials/materialMethods/anisotropicFiltering.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef PUDDLE_VOXELIZATION
|
||||
#include "/lib/misc/puddleVoxelization.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
#include "/lib/materials/materialMethods/snowyWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef DISTANT_LIGHT_BOKEH
|
||||
#include "/lib/misc/distantLightBokeh.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#if SEASONS > 0 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoise.glsl"
|
||||
#endif
|
||||
|
||||
#if PIXEL_WATER > 0
|
||||
#include "/lib/materials/materialMethods/waterProcedureTexture.glsl"
|
||||
#endif
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
#include "/lib/misc/shockwave.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
skyLightCheck = pow2(1.0 - min1(lmCoord.y * 2.9 * sunVisibility));
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
float lViewPos = length(viewPos);
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
vec4 color = doShockwave(playerPos + relativeEyePosition, texCoord);
|
||||
#else
|
||||
#if ANISOTROPIC_FILTER == 0
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
#else
|
||||
vec4 color = textureAF(tex, texCoord);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float smoothnessD = 0.0, materialMask = 0.0, skyLightFactor = 0.0;
|
||||
|
||||
#if !defined POM || !defined POM_ALLOW_CUTOUT
|
||||
if (color.a <= 0.00001) discard;
|
||||
#endif
|
||||
|
||||
vec3 colorP = color.rgb;
|
||||
color.rgb *= glColor.rgb;
|
||||
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
float luminance = GetLuminance(color.rgb);
|
||||
|
||||
int subsurfaceMode = 0;
|
||||
bool noSmoothLighting = false, noDirectionalShading = false, noVanillaAO = false, centerShadowBias = false, noGeneratedNormals = false, doTileRandomisation = true, isFoliage = false;
|
||||
float smoothnessG = 0.0, highlightMult = 1.0, emission = 0.0, noiseFactor = 1.0, snowFactor = 1.0, snowMinNdotU = 0.0, noPuddles = 0.0, overlayNoiseIntensity = 1.0, snowNoiseIntensity = 1.0, sandNoiseIntensity = 1.0, mossNoiseIntensity = 1.0, overlayNoiseTransparentOverwrite = 0.0, overlayNoiseEmission = 1.0, IPBRMult = 1.0, lavaNoiseIntensity = LAVA_NOISE_INTENSITY;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
vec3 dhColor = vec3(1.0);
|
||||
float purkinjeOverwrite = 0.0;
|
||||
|
||||
|
||||
if (lmCoord.x > 0.99 || blockLightEmission > 0) { // Mod support for light level 15 (and all light levels with iris 1.7) light sources
|
||||
if (mat == 0) {
|
||||
emission = DoAutomaticEmission(noSmoothLighting, noDirectionalShading, color.rgb, lmCoord.x, blockLightEmission);
|
||||
}
|
||||
overlayNoiseIntensity = 0.0;
|
||||
}
|
||||
|
||||
if (length(abs(worldGeoNormal.xz) - vec2(sqrt(0.5))) < 0.01) { // Auto SSS on unknown cross model blocks (modded)
|
||||
if (mat == 0) {
|
||||
subsurfaceMode = 1;
|
||||
noSmoothLighting = true, noDirectionalShading = true;
|
||||
}
|
||||
isFoliage = true;
|
||||
sandNoiseIntensity = 0.3, mossNoiseIntensity = 0.0;
|
||||
}
|
||||
|
||||
#if defined SPOOKY && defined EYES
|
||||
vec3 eyes1 = vec3(0.0);
|
||||
vec3 eyes2 = vec3(0.0);
|
||||
float sideRandom = hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.00001, vec3(100)));
|
||||
vec3 blockUVEyes = blockUV;
|
||||
if (step(0.5, sideRandom) > 0.0) { // Randomly make eyes visible only on either the x or z axis
|
||||
blockUVEyes.x = 0.0;
|
||||
} else {
|
||||
blockUVEyes.z = 0.0;
|
||||
}
|
||||
float spookyEyesFrequency = EYE_FREQUENCY;
|
||||
float spookyEyesSpeed = EYE_SPEED;
|
||||
|
||||
float randomEyesTime = 24000 * hash1(worldDay * 3); // Effect happens randomly throughout the day
|
||||
int moreEyesEffect = (int(hash1(worldDay / 2)) % (2 * 24000)) + int(randomEyesTime);
|
||||
if (worldTime > moreEyesEffect && worldTime < moreEyesEffect + 30) { // 30 in ticks - 1.5s, how long the effect will be on
|
||||
spookyEyesFrequency = 20.0; // make eyes appear everywhere
|
||||
}
|
||||
if ((blockUVEyes.x > 0.15 && blockUVEyes.x < 0.43 || blockUVEyes.x < 0.85 && blockUVEyes.x > 0.57 || blockUVEyes.z > 0.15 && blockUVEyes.z < 0.43 || blockUVEyes.z < 0.85 && blockUVEyes.z > 0.57) && blockUVEyes.y > 0.42 && blockUVEyes.y < 0.58 && abs(clamp01(dot(normal, upVec))) < 0.99) eyes1 = vec3(1.0); // Eye Shape 1 Horizontal
|
||||
if ((blockUVEyes.x > 0.65 && blockUVEyes.x < 0.8 || blockUVEyes.x < 0.35 && blockUVEyes.x > 0.2 || blockUVEyes.z > 0.65 && blockUVEyes.z < 0.8 || blockUVEyes.z < 0.35 && blockUVEyes.z > 0.2) && blockUVEyes.y > 0.3 && blockUVEyes.y < 0.7 && abs(clamp01(dot(normal, upVec))) < 0.99) eyes2 = vec3(1.0); // Eye Shape 2 Vertical
|
||||
vec3 spookyEyes = mix(eyes1, eyes2, step(0.75, hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.00005, vec3(100))))); // have either eye shape 1 or 2 randomly, the horizontal ones have a 0.75 to 0.25 higher probability of appearing
|
||||
spookyEyes *= vec3(step(1.0075 - spookyEyesFrequency * 0.01, hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.0000005 * spookyEyesSpeed, vec3(100))))); // Make them appear randomly and much less
|
||||
#endif
|
||||
|
||||
#ifdef IPBR
|
||||
vec3 maRecolor = vec3(0.0);
|
||||
#include "/lib/materials/materialHandling/terrainMaterials.glsl"
|
||||
#ifdef REFLECTIVE_WORLD
|
||||
smoothnessD = 1.0;
|
||||
smoothnessG = 1.0;
|
||||
#endif
|
||||
|
||||
//int blockEntityId = mat;
|
||||
//#include "/lib/materials/materialHandling/blockEntityMaterials.glsl"
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
if (!noGeneratedNormals) GenerateNormals(normalM, colorP);
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
CoatTextures(color.rgb, noiseFactor, playerPos, doTileRandomisation);
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
emission = GetCustomEmissionForIPBR(color, emission);
|
||||
#endif
|
||||
#else
|
||||
#ifdef CUSTOM_PBR
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMask, viewPos, lViewPos);
|
||||
#endif
|
||||
|
||||
if (mat == 10001) { // No directional shading
|
||||
noDirectionalShading = true;
|
||||
} else if (mat == 10003 || mat == 10005 || mat == 10029) { // Grounded Waving Foliage
|
||||
subsurfaceMode = 1, noSmoothLighting = true, noDirectionalShading = true, isFoliage = true;
|
||||
DoFoliageColorTweaks(color.rgb, shadowMult, snowMinNdotU, viewPos, nViewPos, lViewPos, dither);
|
||||
sandNoiseIntensity = 0.3, mossNoiseIntensity = 0.0;
|
||||
} else if (mat == 10007 || mat == 10009 || mat == 10011) { // Leaves
|
||||
#include "/lib/materials/specificMaterials/terrain/leaves.glsl"
|
||||
} else if (mat == 10013 || mat == 10923) { // Vine
|
||||
subsurfaceMode = 3, centerShadowBias = true; noSmoothLighting = true, isFoliage = true;
|
||||
sandNoiseIntensity = 0.3, mossNoiseIntensity = 0.0;
|
||||
} else if (mat == 10015 || mat == 10017 || mat == 10019) { // Non-waving Foliage
|
||||
subsurfaceMode = 1, noSmoothLighting = true, noDirectionalShading = true, isFoliage = true;
|
||||
sandNoiseIntensity = 0.3, mossNoiseIntensity = 0.0;
|
||||
} else if (mat == 10021 || mat == 10023) { // Upper Waving Foliage
|
||||
subsurfaceMode = 1, noSmoothLighting = true, noDirectionalShading = true, isFoliage = true;
|
||||
sandNoiseIntensity = 0.3, mossNoiseIntensity = 0.0;
|
||||
DoFoliageColorTweaks(color.rgb, shadowMult, snowMinNdotU, viewPos, nViewPos, lViewPos, dither);
|
||||
} else if (mat == 10068 || mat == 10070){ // Lava
|
||||
vec3 previousLavaColor = color.rgb;
|
||||
if (emission < 1.0) emission = max(2.0, emission);
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
vec3 lavaNoiseColor = color.rgb;
|
||||
#if LAVA_VARIATION > 0
|
||||
vec2 lavaPos = (floor(worldPos.xz * 16.0) + worldPos.y * 32.0) * 0.000666;
|
||||
vec2 wind = vec2(frameTimeCounter * 0.012, 0.0);
|
||||
lavaNoiseIntensity *= 0.95;
|
||||
#include "/lib/materials/specificMaterials/terrain/lavaNoise.glsl"
|
||||
color.rgb = lavaNoiseColor;
|
||||
#else
|
||||
if (LAVA_TEMPERATURE != 0.0) color.rgb += LAVA_TEMPERATURE * 0.3;
|
||||
#endif
|
||||
vec3 maxLavaColor = max(previousLavaColor, lavaNoiseColor);
|
||||
#if RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
noPuddles = 1.0;
|
||||
#endif
|
||||
|
||||
#include "/lib/materials/specificMaterials/terrain/lavaEdge.glsl"
|
||||
|
||||
emission *= LAVA_EMISSION;
|
||||
} else if (mat > 20999 && mat < 21025){
|
||||
emission = DoAutomaticEmission(noSmoothLighting, noDirectionalShading, color.rgb, lmCoord.x, blockLightEmission);
|
||||
}
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
else if (mat == 10132) { // Grass Block:Normal
|
||||
if (glColor.b < 0.999) { // Grass Block:Normal:Grass Part
|
||||
snowMinNdotU = min(pow2(pow2(color.g)) * 1.9, 0.1);
|
||||
color.rgb = color.rgb * 0.5 + 0.5 * (color.rgb / glColor.rgb);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
else if (lmCoord.x > 0.99999) lmCoordM.x = 0.95;
|
||||
#endif
|
||||
|
||||
if (mat == 10572) { // Dragon Egg
|
||||
overlayNoiseIntensity = 0.0;
|
||||
#ifndef EMISSIVE_DRAGON_EGG
|
||||
emission *= 0.0;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
DoSnowyWorld(color, smoothnessG, highlightMult, smoothnessD, emission,
|
||||
playerPos, lmCoord, snowFactor, snowMinNdotU, NdotU, subsurfaceMode);
|
||||
#endif
|
||||
|
||||
#if defined NETHER && defined BIOME_COLORED_NETHER_PORTALS && !defined IPBR
|
||||
if (mat == 10476 || mat == 10588 || mat == 10592) { // Crying Obsidian, Respawn Anchor lit and unlit
|
||||
emission = sqrt(luminance * luminance) * 10.0;
|
||||
color.a *= luminance;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SEASONS > 0
|
||||
#include "/lib/materials/seasons.glsl"
|
||||
#endif
|
||||
#if defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoiseApply.glsl"
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
float puddleLightFactor = max0(lmCoord.y * 32.0 - 31.0) * clamp((1.0 - 1.15 * lmCoord.x) * 10.0, 0.0, 1.0);
|
||||
float puddleNormalFactor = pow2(max0(NdotUmax0 - 0.5) * 2.0);
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
puddleNormalFactor *= mix(0.0, 1.0, heightRelativeToCloud);
|
||||
#endif
|
||||
float puddleMixer = puddleLightFactor * inRainy * puddleNormalFactor;
|
||||
#if RAIN_PUDDLES < 3
|
||||
float wetnessM = wetness;
|
||||
#else
|
||||
float wetnessM = 1.0;
|
||||
#endif
|
||||
#ifdef PUDDLE_VOXELIZATION
|
||||
vec3 voxelPos = SceneToPuddleVoxel(playerPos);
|
||||
vec3 voxel_sample_pos = clamp01(voxelPos / vec3(puddle_voxelVolumeSize));
|
||||
if (CheckInsidePuddleVoxelVolume(voxelPos)) {
|
||||
noPuddles += texture2D(puddle_sampler, voxel_sample_pos.xz).r;
|
||||
}
|
||||
#endif
|
||||
if (pow2(pow2(wetnessM)) * puddleMixer - noPuddles > 0.00001) {
|
||||
vec2 worldPosXZ = playerPos.xz + cameraPosition.xz;
|
||||
vec2 puddleWind = vec2(frameTimeCounter) * 0.03;
|
||||
#if WATER_STYLE == 1
|
||||
vec2 puddlePosNormal = floor(worldPosXZ * 16.0) * 0.0625;
|
||||
#else
|
||||
vec2 puddlePosNormal = worldPosXZ;
|
||||
#endif
|
||||
|
||||
puddlePosNormal *= 0.1;
|
||||
vec2 pNormalCoord1 = puddlePosNormal + vec2(puddleWind.x, puddleWind.y);
|
||||
vec2 pNormalCoord2 = puddlePosNormal + vec2(puddleWind.x * -1.5, puddleWind.y * -1.0);
|
||||
vec3 pNormalNoise1 = texture2D(noisetex, pNormalCoord1).rgb;
|
||||
vec3 pNormalNoise2 = texture2D(noisetex, pNormalCoord2).rgb;
|
||||
float pNormalMult = 0.03;
|
||||
|
||||
vec3 puddleNormal = vec3((pNormalNoise1.xy + pNormalNoise2.xy - vec2(1.0)) * pNormalMult, 1.0);
|
||||
puddleNormal = clamp(normalize(puddleNormal * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
|
||||
#if RAIN_PUDDLES == 1 || RAIN_PUDDLES == 3 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
vec2 puddlePosForm = puddlePosNormal * 0.05;
|
||||
float pFormNoise = texture2D(noisetex, puddlePosForm).b * 3.0;
|
||||
pFormNoise += texture2D(noisetex, puddlePosForm * 0.5).b * 5.0;
|
||||
pFormNoise += texture2D(noisetex, puddlePosForm * 0.25).b * 8.0;
|
||||
pFormNoise *= sqrt1(wetnessM) * 0.5625 + 0.4375;
|
||||
pFormNoise = clamp(pFormNoise - 7.0, 0.0, 1.0);
|
||||
#else
|
||||
float pFormNoise = wetnessM;
|
||||
#endif
|
||||
puddleMixer *= pFormNoise;
|
||||
|
||||
float puddleSmoothnessG = 0.7 - rainFactor * 0.3;
|
||||
float puddleHighlight = (1.5 - subsurfaceMode * 0.6 * invNoonFactor);
|
||||
smoothnessG = mix(smoothnessG, puddleSmoothnessG, puddleMixer);
|
||||
highlightMult = mix(highlightMult, puddleHighlight, puddleMixer);
|
||||
smoothnessD = mix(smoothnessD, 1.0, sqrt1(puddleMixer));
|
||||
normalM = mix(normalM, puddleNormal, puddleMixer * rainFactor);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SHOW_LIGHT_LEVEL > 0
|
||||
#include "/lib/misc/showLightLevels.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
if (mat != 10068 && mat != 10070) { // Lava
|
||||
float noiseAdd = hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.000001, vec3(100)));
|
||||
emission *= mix(clamp(noiseAdd * 1.5, 0.1, 2.0), 1.0, smoothstep(0.1, 0.11, texture2D(noisetex, vec2(frameTimeCounter * 0.008 + noiseAdd)).r));
|
||||
}
|
||||
#endif
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, noDirectionalShading, noVanillaAO,
|
||||
centerShadowBias, subsurfaceMode, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
vec3 lightAlbedo = normalize(color.rgb) * min1(emission);
|
||||
|
||||
#ifdef COLORED_CANDLE_LIGHT
|
||||
if (mat == 10584) { // Candles:Lit
|
||||
lightAlbedo = normalize(color.rgb) * lmCoord.x;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef IPBR
|
||||
color.rgb += maRecolor;
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && defined EYES
|
||||
vec2 flickerEyeNoise = texture2D(noisetex, vec2(frameTimeCounter * 0.025 + hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.000001, vec3(100))))).rb;
|
||||
if (length(playerPos) > 8.0) {
|
||||
vec3 eyesColor = mix(vec3(1.0), vec3(3.0, 0.0, 0.0), vec3(step(1.0 - EYE_RED_PROBABILITY * mix(1.0, 2.0, getBloodMoon(moonPhase, sunVisibility)), hash13(mod(floor(worldPos + atMidBlock / 64) + frameTimeCounter * 0.0000002, vec3(500)))))); // Make Red eyes appear rarely, 7% chance
|
||||
color.rgb += spookyEyes * 3.0 * skyLightCheck * min1(max(flickerEyeNoise.r, flickerEyeNoise.g)) * clamp((1.0 - 1.15 * lmCoord.x) * 10.0, 0.0, 1.0) * eyesColor;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef PBR_REFLECTIONS
|
||||
#ifdef OVERWORLD
|
||||
skyLightFactor = clamp01(pow2(max(lmCoord.y - 0.7, 0.0) * 3.33333) + 0.0 + 0.0);
|
||||
#else
|
||||
skyLightFactor = dot(shadowMult, shadowMult) / 3.0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, mat);
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
int seed = worldDay / 2; // Thanks to Bálint
|
||||
int currTime = (worldDay % 2) * 24000 + worldTime; // Effect happens every 2 minecraft days
|
||||
float randomTime = 24000 * hash1(worldDay * 5); // Effect happens randomly throughout the day
|
||||
int timeWhenItHappens = (int(hash1(seed)) % (2 * 24000)) + int(randomTime);
|
||||
if (currTime > timeWhenItHappens && currTime < timeWhenItHappens + 100) { // 100 in ticks - 5s, how long the effect will be on, aka leaves are gone
|
||||
if (mat == 10007 || mat == 10009 || mat == 10011) discard; // Disable leaves
|
||||
}
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:06 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(smoothnessD, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && RP_MODE != 0
|
||||
/* DRAWBUFFERS:065 */
|
||||
gl_FragData[2] = vec4(mat3(gbufferModelViewInverse) * normalM, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0658 */
|
||||
gl_FragData[3] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:068 */
|
||||
gl_FragData[2] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out int mat;
|
||||
flat out int blockLightEmission;
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
flat out vec2 midCoord;
|
||||
out vec3 blockUV; // useful to hardcode something to a specific pixel coordinate of a block
|
||||
out vec3 atMidBlock;
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat out ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 normal;
|
||||
|
||||
out vec4 glColorRaw;
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined GENERATED_NORMALS || defined CUSTOM_PBR || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec3 viewVector;
|
||||
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
#if ANISOTROPIC_FILTER > 0
|
||||
out vec4 spriteBounds;
|
||||
#endif
|
||||
|
||||
out vec4 beforeTransformPos;
|
||||
|
||||
//Attributes//
|
||||
attribute vec4 mc_Entity;
|
||||
attribute vec4 mc_midTexCoord;
|
||||
attribute vec4 at_midBlock;
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined GENERATED_NORMALS || defined CUSTOM_PBR || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
attribute vec4 at_tangent;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
vec4 glColor = vec4(1.0);
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined WAVING_ANYTHING_TERRAIN || defined INTERACTIVE_FOLIAGE || defined WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.1, vec3(100.0))));
|
||||
#endif
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
blockUV = 0.5 - at_midBlock.xyz / 64.0;
|
||||
atMidBlock = at_midBlock.xyz;
|
||||
|
||||
glColorRaw = gl_Color;
|
||||
if (glColorRaw.a < 0.1) glColorRaw.a = 1.0;
|
||||
glColor = glColorRaw;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// pixelTexSize = ivec2(absMidCoordPos * 2.0 * atlasSize);
|
||||
// #endif
|
||||
|
||||
mat = int(mc_Entity.x + 0.5);
|
||||
|
||||
#if ANISOTROPIC_FILTER > 0
|
||||
if (mc_Entity.y > 0.5 && dot(normal, upVec) < 0.999) absMidCoordPos = vec2(0.0); // Fix257062
|
||||
#endif
|
||||
|
||||
blockLightEmission = 0;
|
||||
#ifdef IRIS_FEATURE_BLOCK_EMISSION_ATTRIBUTE
|
||||
blockLightEmission = clamp(int(at_midBlock.w + 0.5), 0, 15);
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVING_ANYTHING_TERRAIN || defined WAVE_EVERYTHING || defined INTERACTIVE_FOLIAGE
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
beforeTransformPos = position;
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVING_ANYTHING_TERRAIN
|
||||
DoWave(position.xyz, mat);
|
||||
#endif
|
||||
#ifdef INTERACTIVE_FOLIAGE
|
||||
if (mat == 10003 || mat == 10005 || mat == 10015 || mat == 10021 || mat == 10029 || mat == 10023 || mat == 10629 || mat == 10632 || mat == 10777 || mat == 10025 || mat == 10027 || mat == 10923) {
|
||||
vec3 playerPosM = position.xyz + relativeEyePosition;
|
||||
DoInteractiveWave(playerPosM, mat);
|
||||
position.xyz = playerPosM - relativeEyePosition;
|
||||
}
|
||||
#endif
|
||||
// #ifdef SPOOKY
|
||||
// if (mat == 10744) { // Cobweb Thanks to gri
|
||||
// vec3 irisThirdPersonPull = vec3(0.0);
|
||||
// #ifdef IS_IRIS
|
||||
// irisThirdPersonPull = eyePosition - cameraPosition;
|
||||
// #endif
|
||||
// vec3 pullCenter = vec3(0.1, -0.1, -0.05) - irisThirdPersonPull;
|
||||
// float pullFactor = pow(min(abs(sin(1.81 * frameTimeCounter) + cos(0.9124 * frameTimeCounter)), 1.0), 10.0) * 4.0 / (length(position.xyz) + max(20 * texture2D(noisetex, vec2(frameTimeCounter * 0.1)).r, 10.0));
|
||||
// vec3 pullDir = pullCenter - position.xyz - at_midBlock.xyz / 64.0;
|
||||
// position.xyz += pullDir * pullFactor;
|
||||
// }
|
||||
// #endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#else
|
||||
gl_Position = ftransform();
|
||||
|
||||
beforeTransformPos = vec4(0.0);
|
||||
|
||||
#ifndef WAVING_LAVA
|
||||
if (mat == 10068 || mat == 10070) { // Lava
|
||||
// G8FL735 Fixes Optifine-Iris parity. Optifine has 0.9 gl_Color.rgb on a lot of versions
|
||||
glColorRaw.rgb = min(glColorRaw.rgb, vec3(0.9));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef FLICKERING_FIX
|
||||
if (mat == 10257) gl_Position.z -= 0.00001; // Iron Bars
|
||||
#endif
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
|
||||
#if RAIN_PUDDLES >= 1 || defined GENERATED_NORMALS || defined CUSTOM_PBR || defined SPOOKY_RAIN_PUDDLE_OVERRIDE
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
vTexCoordAM.zw = abs(texMinMidCoord) * 2;
|
||||
vTexCoordAM.xy = min(texCoord, midCoord - texMinMidCoord);
|
||||
#endif
|
||||
|
||||
#if ANISOTROPIC_FILTER > 0
|
||||
vec2 spriteRadius = abs(texCoord - mc_midTexCoord.xy);
|
||||
vec2 bottomLeft = mc_midTexCoord.xy - spriteRadius;
|
||||
vec2 topRight = mc_midTexCoord.xy + spriteRadius;
|
||||
spriteBounds = vec4(bottomLeft, topRight);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,382 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
in vec3 normal;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
#ifdef CLOUD_SHADOWS
|
||||
flat in vec3 eastVec;
|
||||
|
||||
#if SUN_ANGLE != 0
|
||||
flat in vec3 northVec;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
#if MC_VERSION >= 11500
|
||||
#include "/lib/atmospherics/fog/mainFog.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#if defined BIOME_COLORED_NETHER_PORTALS && !defined BORDER_FOG
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef AURORA_INFLUENCE
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
vec4 colorP = color;
|
||||
color *= glColor;
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
float lViewPos = length(viewPos);
|
||||
vec3 playerPos = ViewToPlayer(viewPos);
|
||||
|
||||
float dither = texture2D(noisetex, gl_FragCoord.xy / 128.0).b;
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
atmColorMult = GetAtmColorMult();
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
float cloudLinearDepth = texelFetch(gaux1, texelCoord, 0).r;
|
||||
|
||||
if (cloudLinearDepth > 0.0) // Because Iris changes the pipeline position of opaque particles
|
||||
if (pow2(cloudLinearDepth + OSIEBCA * dither) * renderDistance < min(lViewPos, renderDistance)) discard;
|
||||
#endif
|
||||
|
||||
float emission = 0.0, materialMask = OSIEBCA * 254.0; // No SSAO, No TAA
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 normalM = normal, geoNormal = normal, shadowMult = vec3(1.0);
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
float purkinjeOverwrite = 0.0;
|
||||
#if defined IPBR && defined IPBR_PARTICLE_FEATURES
|
||||
// We don't want to detect particles from the block atlas
|
||||
#if MC_VERSION >= 12000
|
||||
float atlasCheck = 1100.0; // I think texture atlas got bigger in newer mc
|
||||
#else
|
||||
float atlasCheck = 900.0;
|
||||
#endif
|
||||
|
||||
if (atlasSize.x < atlasCheck) {
|
||||
if (color.b > 1.15 * (color.r + color.g) && color.g > color.r * 1.25 && color.g < 0.425 && color.b > 0.75) { // Water Particle
|
||||
materialMask = 0.0;
|
||||
color.rgb = sqrt3(color.rgb);
|
||||
color.rgb *= 0.7;
|
||||
if (dither > 0.4) discard;
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
#ifdef OVERWORLD
|
||||
} else if (color.b > 0.7 && color.r < 0.28 && color.g < 0.425 && color.g > color.r * 1.4) { // physics mod rain
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
if (color.a < 0.1 || isEyeInWater == 3) discard;
|
||||
color.a *= rainTexOpacity;
|
||||
color.rgb = sqrt2(color.rgb) * (blocklightCol * 2.0 * lmCoord.x + ambientColor * lmCoord.y * (0.7 + 0.35 * sunFactor));
|
||||
} else if (color.rgb == vec3(1.0) && color.a < 0.765 && color.a > 0.605) { // physics mod snow (default snow opacity only)
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
if (color.a < 0.1 || isEyeInWater == 3) discard;
|
||||
color.a *= snowTexOpacity;
|
||||
color.rgb = sqrt2(color.rgb) * (blocklightCol * 2.0 * lmCoord.x + lmCoord.y * (0.7 + 0.35 * sunFactor) + ambientColor * 0.2);
|
||||
#endif
|
||||
} else if (color.r == 1.0 && color.b < 0.778 && color.g < 0.97) { // Fire Particle
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
emission = 2.0;
|
||||
} else if (color.r == color.g && color.r - 0.5 * color.b < 0.06) { // Underwater Particle
|
||||
if (isEyeInWater == 1) {
|
||||
color.rgb = sqrt2(color.rgb) * 0.35;
|
||||
if (fract(playerPos.y + cameraPosition.y) > 0.25) discard;
|
||||
}
|
||||
} else if (color.a < 0.99 && dot(color.rgb, color.rgb) < 1.0) { // Campfire Smoke
|
||||
color.a *= 0.5;
|
||||
materialMask = 0.0;
|
||||
} else if (max(abs(colorP.r - colorP.b), abs(colorP.b - colorP.g)) < 0.001) { // Grayscale Particles
|
||||
float dotColor = dot(color.rgb, color.rgb);
|
||||
if (dotColor > 0.25 && color.g < 0.5 && (color.b > color.r * 1.1 && color.r > 0.3 || color.r > (color.g + color.b) * 3.0)) {
|
||||
// Ender Particle, Crying Obsidian Particle, Redstone Particle
|
||||
emission = clamp(color.r * 8.0, 1.6, 5.0);
|
||||
color.rgb = pow1_5(color.rgb);
|
||||
lmCoordM = vec2(0.0);
|
||||
#if defined NETHER && defined BIOME_COLORED_NETHER_PORTALS
|
||||
if (color.b > color.r * color.r && color.g < 0.16 && color.r > 0.2) color.rgb = changeColorFunction(color.rgb, 10.0, netherColor, 1.0); // Nether Portal
|
||||
#endif
|
||||
} else if (color.r > 0.83 && color.g > 0.23 && color.b < 0.4) {
|
||||
// Lava Particles
|
||||
emission = 2.0;
|
||||
color.b *= 0.5;
|
||||
color.r *= 1.2;
|
||||
color.rgb += vec3(min(pow2(pow2(emission * 0.35)), 0.4)) * LAVA_TEMPERATURE * 0.5;
|
||||
emission *= LAVA_EMISSION;
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.5, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.5, colorEndBreath, 1.0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
bool noSmoothLighting = false;
|
||||
#else
|
||||
#if defined OVERWORLD && defined NO_RAIN_ABOVE_CLOUDS || defined NETHER && (defined BIOME_COLORED_NETHER_PORTALS || defined SOUL_SAND_VALLEY_OVERHAUL_INTERNAL)
|
||||
if (atlasSize.x < 900.0) {
|
||||
if (color.b > 1.15 * (color.r + color.g) && color.g > color.r * 1.25 && color.g < 0.425 && color.b > 0.75) { // Water Particle
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
}
|
||||
#ifdef OVERWORLD
|
||||
if (color.b > 0.7 && color.r < 0.28 && color.g < 0.425 && color.g > color.r * 1.4) { // physics mod rain
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
if (color.a < 0.1 || isEyeInWater == 3) discard;
|
||||
color.a *= rainTexOpacity;
|
||||
color.rgb = sqrt2(color.rgb) * (blocklightCol * 2.0 * lmCoord.x + ambientColor * lmCoord.y * (0.7 + 0.35 * sunFactor));
|
||||
color.rgb *= vec3(WEATHER_TEX_R, WEATHER_TEX_G, WEATHER_TEX_B);
|
||||
} else if (color.rgb == vec3(1.0) && color.a < 0.765 && color.a > 0.605) { // physics mod snow (default snow opacity only)
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
if (color.a < 0.1 || isEyeInWater == 3) discard;
|
||||
color.a *= snowTexOpacity;
|
||||
color.rgb = sqrt2(color.rgb) * (blocklightCol * 2.0 * lmCoord.x + lmCoord.y * (0.7 + 0.35 * sunFactor) + ambientColor * 0.2);
|
||||
color.rgb *= vec3(WEATHER_TEX_R, WEATHER_TEX_G, WEATHER_TEX_B);
|
||||
}
|
||||
#endif
|
||||
if (color.r == 1.0 && color.b < 0.778 && color.g < 0.97) { // Fire Particle
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
emission = 2.0;
|
||||
}
|
||||
if (max(abs(colorP.r - colorP.b), abs(colorP.b - colorP.g)) < 0.001) {
|
||||
if (dot(color.rgb, color.rgb) > 0.25 && color.g < 0.5 && (color.b > color.r * 1.1 && color.r > 0.3 || color.r > (color.g + color.b) * 3.0)) {
|
||||
#if defined NETHER && defined BIOME_COLORED_NETHER_PORTALS
|
||||
vec3 color2 = pow1_5(color.rgb);
|
||||
if (color2.b > color2.r * color2.r && color2.g < 0.16 && color2.r > 0.2) {
|
||||
emission = clamp(color2.r * 8.0, 1.6, 5.0);
|
||||
color.rgb = color.rgb = changeColorFunction(color.rgb, 10.0, netherColor, 1.0);
|
||||
lmCoordM = vec2(0.0);
|
||||
}
|
||||
#endif
|
||||
} else if (color.r > 0.83 && color.g > 0.23 && color.b < 0.4) {
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.5, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.5, colorEndBreath, 1.0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
bool noSmoothLighting = true;
|
||||
#endif
|
||||
|
||||
#ifdef REDUCE_CLOSE_PARTICLES
|
||||
if (lViewPos - 1.0 < dither) discard;
|
||||
#endif
|
||||
|
||||
#ifdef GLOWING_COLORED_PARTICLES
|
||||
if (atlasSize.x < 900.0) {
|
||||
if (dot(glColor.rgb, vec3(1.0)) < 2.99) {
|
||||
emission = 5.0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
float auroraSpookyMix = 0.0;
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
ambientColor *= mix(vec3(1.0), vec3(1.0, 0.0, 0.0) * 3.0, getBloodMoon(moonPhase, sunVisibility));
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, false, true,
|
||||
false, 0, 0.0, 1.0, emission, purkinjeOverwrite);
|
||||
|
||||
#if MC_VERSION >= 11500
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
float sky = 0.0;
|
||||
|
||||
DoFog(color.rgb, sky, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
#endif
|
||||
|
||||
vec3 translucentMult = mix(vec3(0.666), color.rgb * (1.0 - pow2(pow2(color.a))), color.a);
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:063 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(0.0, materialMask, 0.0, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
gl_FragData[2] = vec4(1.0 - translucentMult, 1.0);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0638 */
|
||||
gl_FragData[3] = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
out vec3 normal;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
#ifdef CLOUD_SHADOWS
|
||||
flat out vec3 eastVec;
|
||||
|
||||
#if SUN_ANGLE != 0
|
||||
flat out vec3 northVec;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
|
||||
#if defined WAVE_EVERYTHING || defined ATLAS_ROTATION
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
gl_Position = ftransform();
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
#ifdef FLICKERING_FIX
|
||||
gl_Position.z -= 0.000002;
|
||||
#endif
|
||||
|
||||
#ifdef CLOUD_SHADOWS
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
|
||||
#if SUN_ANGLE != 0
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,532 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in int mat;
|
||||
flat in int blockLightEmission;
|
||||
|
||||
in vec2 texCoord;
|
||||
in vec2 lmCoord;
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
|
||||
flat in vec3 upVec, sunVec, northVec, eastVec;
|
||||
in vec3 playerPos;
|
||||
in vec3 normal;
|
||||
in vec3 viewVector;
|
||||
in vec3 atMidBlock;
|
||||
|
||||
in vec4 glColor;
|
||||
|
||||
#if WATER_STYLE >= 2 || (RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE) && WATER_STYLE == 1 && WATER_MAT_QUALITY >= 2 || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat in vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
in vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat in ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float NdotU = dot(normal, upVec);
|
||||
float NdotUmax0 = max(NdotU, 0.0);
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
float shadowTimeVar1 = abs(sunVisibility - 0.5) * 2.0;
|
||||
float shadowTimeVar2 = shadowTimeVar1 * shadowTimeVar1;
|
||||
float shadowTime = shadowTimeVar2 * shadowTimeVar2;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 lightVec = sunVec * ((timeAngle < 0.5325 || timeAngle > 0.9675) ? 1.0 : -1.0);
|
||||
#else
|
||||
vec3 lightVec = sunVec;
|
||||
#endif
|
||||
|
||||
#if WATER_STYLE >= 2 || (RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE) && WATER_STYLE == 1 && WATER_MAT_QUALITY >= 2 || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
float GetLinearDepth(float depth) {
|
||||
return (2.0 * near) / (far + near - depth * (far - near));
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/dither.glsl"
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
#include "/lib/lighting/mainLighting.glsl"
|
||||
#include "/lib/atmospherics/fog/mainFog.glsl"
|
||||
|
||||
#if defined OVERWORLD_BEAMS && defined OVERWORLD
|
||||
float vlFactor = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
#endif
|
||||
|
||||
#if !defined ATMOSPHERIC_FOG && !defined BORDER_FOG
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
#endif
|
||||
|
||||
#if defined AURORA_INFLUENCE || (WATER_REFLECT_QUALITY >= 0 && defined SKY_EFFECT_REFLECTION && defined OVERWORLD && AURORA_STYLE > 0)
|
||||
#include "/lib/atmospherics/auroraBorealis.glsl"
|
||||
#endif
|
||||
|
||||
#if WATER_REFLECT_QUALITY >= 0
|
||||
#if defined SKY_EFFECT_REFLECTION && defined OVERWORLD
|
||||
#include "/lib/atmospherics/stars.glsl"
|
||||
#ifdef NIGHT_NEBULA
|
||||
#include "/lib/atmospherics/nightNebula.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
#include "/lib/atmospherics/clouds/mainClouds.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "/lib/materials/materialMethods/reflections.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined GENERATED_NORMALS || defined COATED_TEXTURES || WATER_STYLE >= 2
|
||||
#include "/lib/util/miplevel.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
#include "/lib/materials/materialMethods/generatedNormals.glsl"
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_PBR
|
||||
#include "/lib/materials/materialHandling/customMaterials.glsl"
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef PORTAL_EDGE_EFFECT
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
#include "/lib/materials/materialMethods/connectedGlass.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
#include "/lib/lighting/coloredBlocklight.glsl"
|
||||
#endif
|
||||
|
||||
#if SEASONS > 0 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoise.glsl"
|
||||
#endif
|
||||
|
||||
#if PIXEL_WATER > 0
|
||||
#include "/lib/materials/materialMethods/waterProcedureTexture.glsl"
|
||||
#endif
|
||||
|
||||
#if SHOCKWAVE > 0
|
||||
#include "/lib/misc/shockwave.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#if SHOCKWAVE > 0
|
||||
vec4 colorP = doShockwave(playerPos + relativeEyePosition, texCoord);
|
||||
#else
|
||||
vec4 colorP = texture2D(tex, texCoord);
|
||||
#endif
|
||||
vec4 color = colorP * vec4(glColor.rgb, 1.0);
|
||||
|
||||
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
|
||||
#ifdef TAA
|
||||
vec3 viewPos = ScreenToView(vec3(TAAJitter(screenPos.xy, -0.5), screenPos.z));
|
||||
#else
|
||||
vec3 viewPos = ScreenToView(screenPos);
|
||||
#endif
|
||||
float lViewPos = length(viewPos);
|
||||
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
lightColorMult = GetLightColorMult();
|
||||
#endif
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
atmColorMult = GetAtmColorMult();
|
||||
sqrtAtmColorMult = sqrt(atmColorMult);
|
||||
#endif
|
||||
|
||||
float overlayNoiseIntensity = 1.0;
|
||||
float snowNoiseIntensity = 1.0;
|
||||
float sandNoiseIntensity = 1.0;
|
||||
float mossNoiseIntensity = 1.0;
|
||||
float overlayNoiseTransparentOverwrite = 0.0;
|
||||
float overlayNoiseAlpha = 1.0;
|
||||
float overlayNoiseFresnelMult = 1.0;
|
||||
float IPBRMult = 1.0;
|
||||
bool isFoliage = false;
|
||||
vec3 dhColor = vec3(1.0);
|
||||
float purkinjeOverwrite = 0.0;
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
float cloudLinearDepth = texelFetch(gaux1, texelCoord, 0).r;
|
||||
|
||||
if (pow2(cloudLinearDepth + OSIEBCA * dither) * renderDistance < min(lViewPos, renderDistance)) discard;
|
||||
#endif
|
||||
|
||||
#if WATER_MAT_QUALITY >= 3
|
||||
float materialMask = 0.0;
|
||||
#endif
|
||||
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
float VdotN = dot(nViewPos, normal);
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
|
||||
// Materials
|
||||
vec4 translucentMult = vec4(1.0);
|
||||
bool noSmoothLighting = false, noDirectionalShading = false, translucentMultCalculated = false, noGeneratedNormals = false;
|
||||
int subsurfaceMode = 0;
|
||||
float smoothnessG = 0.0, highlightMult = 1.0, reflectMult = 0.0, emission = 0.0;
|
||||
vec2 lmCoordM = lmCoord;
|
||||
vec3 normalM = VdotN > 0.0 ? -normal : normal; // Inverted Iris Water Normal Workaround
|
||||
vec3 geoNormal = normalM;
|
||||
vec3 worldGeoNormal = normalize(ViewToPlayer(geoNormal * 10000.0));
|
||||
vec3 shadowMult = vec3(1.0);
|
||||
float fresnel = clamp(1.0 + dot(normalM, nViewPos), 0.0, 1.0);
|
||||
#ifdef IPBR
|
||||
#include "/lib/materials/materialHandling/translucentMaterials.glsl"
|
||||
|
||||
#ifdef GENERATED_NORMALS
|
||||
if (!noGeneratedNormals) GenerateNormals(normalM, colorP.rgb * colorP.a * 1.5);
|
||||
#endif
|
||||
|
||||
#if IPBR_EMISSIVE_MODE != 1
|
||||
emission = GetCustomEmissionForIPBR(color, emission);
|
||||
#endif
|
||||
#else
|
||||
#ifdef CUSTOM_PBR
|
||||
float smoothnessD = 0.0;
|
||||
float materialMaskPh = 0.0;
|
||||
GetCustomMaterials(color, normalM, lmCoordM, NdotU, shadowMult, smoothnessG, smoothnessD, highlightMult, emission, materialMaskPh, viewPos, lViewPos);
|
||||
reflectMult = smoothnessD;
|
||||
#endif
|
||||
|
||||
if (mat == 32000) { // Water
|
||||
#ifdef SHADER_WATER
|
||||
#include "/lib/materials/specificMaterials/translucents/water.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
overlayNoiseFresnelMult = 0.0;
|
||||
IPBRMult = 0.0;
|
||||
overlayNoiseAlpha = 0.0;
|
||||
} else if (mat == 30020) { // Nether Portal
|
||||
#ifdef SPECIAL_PORTAL_EFFECTS
|
||||
#include "/lib/materials/specificMaterials/translucents/netherPortal.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
} else if (mat == 32016) { // Beacon
|
||||
overlayNoiseAlpha = 0.8;
|
||||
mossNoiseIntensity = 0.5;
|
||||
sandNoiseIntensity = 0.5;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if WATER_MAT_QUALITY >= 3 && SELECT_OUTLINE == 4
|
||||
int materialMaskInt = int(texelFetch(colortex6, texelCoord, 0).g * 255.1);
|
||||
if (materialMaskInt == 252) {
|
||||
materialMask = OSIEBCA * 252.0; // Versatile Selection Outline
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
#include "/lib/materials/overlayNoiseApply.glsl"
|
||||
#endif
|
||||
#if SEASONS > 0
|
||||
#include "/lib/materials/seasons.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef REFLECTIVE_WORLD
|
||||
smoothnessG = 1.0;
|
||||
#endif
|
||||
|
||||
#if MONOTONE_WORLD > 0
|
||||
#if MONOTONE_WORLD == 1
|
||||
color.rgb = vec3(1.0);
|
||||
#elif MONOTONE_WORLD == 2
|
||||
color.rgb = vec3(0.0);
|
||||
#else
|
||||
color.rgb = vec3(0.5);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Blending
|
||||
if (!translucentMultCalculated)
|
||||
translucentMult = vec4(mix(vec3(0.666), color.rgb * (1.0 - pow2(pow2(color.a))), color.a), 1.0);
|
||||
|
||||
translucentMult.rgb = mix(translucentMult.rgb, vec3(1.0), min1(pow2(pow2(lViewPos / far))));
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
blocklightCol = ApplyMultiColoredBlocklight(blocklightCol, screenPos);
|
||||
#endif
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
ambientColor *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
ambientColor = mix(AuroraAmbientColor(ambientColor, viewPos), ambientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
if (lmCoord.x > 0.99 || blockLightEmission > 0) { // Mod support for light level 15 (and all light levels with iris 1.7) light sources and blockID set by user
|
||||
if (mat == 0) {
|
||||
emission = DoAutomaticEmission(noSmoothLighting, noDirectionalShading, color.rgb, lmCoord.x, blockLightEmission);
|
||||
}
|
||||
overlayNoiseIntensity = 0.0;
|
||||
}
|
||||
|
||||
emission *= EMISSION_MULTIPLIER;
|
||||
|
||||
// Lighting
|
||||
DoLighting(color, shadowMult, playerPos, viewPos, lViewPos, geoNormal, normalM,
|
||||
worldGeoNormal, lmCoordM, noSmoothLighting, noDirectionalShading, false,
|
||||
false, subsurfaceMode, smoothnessG, highlightMult, emission, purkinjeOverwrite);
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
vec3 normalizedColor = normalize(color.rgb);
|
||||
|
||||
vec3 opaquelightAlbedo = texture2D(colortex8, screenPos.xy).rgb;
|
||||
opaquelightAlbedo *= normalizedColor;
|
||||
|
||||
if (mat == 30012 || mat == 30016 || mat >= 31000 && mat < 32000 || mat >= 32004 && mat < 32016 ) // Slime, Honey, Glass, Ice
|
||||
opaquelightAlbedo = mix(normalizedColor, opaquelightAlbedo, min1(GetLuminance(opaquelightAlbedo)));
|
||||
|
||||
vec3 lightAlbedo = normalizedColor * min1(emission);
|
||||
|
||||
lightAlbedo = mix(opaquelightAlbedo, lightAlbedo, color.a);
|
||||
#endif
|
||||
|
||||
float skyLightFactor = pow2(max(lmCoordM.y - 0.7, 0.0) * 3.33333);
|
||||
// Reflections
|
||||
#if WATER_REFLECT_QUALITY >= 0
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
highlightColor *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_REFLECTION
|
||||
highlightColor *= pow2(moonPhaseInfluence);
|
||||
#endif
|
||||
#ifdef SPOOKY
|
||||
highlightColor *= 0.3;
|
||||
#endif
|
||||
|
||||
float fresnelM = (pow3(fresnel) * 0.85 + 0.15) * reflectMult;
|
||||
|
||||
#if SHADOW_QUALITY > -1 && WATER_REFLECT_QUALITY >= 2 && WATER_MAT_QUALITY >= 2
|
||||
skyLightFactor = max(skyLightFactor, min1(dot(shadowMult, shadowMult)));
|
||||
#endif
|
||||
|
||||
vec4 reflection = GetReflection(normalM, viewPos.xyz, nViewPos, playerPos, lViewPos, -1.0,
|
||||
depthtex1, dither, skyLightFactor, fresnel,
|
||||
smoothnessG, geoNormal, color.rgb, shadowMult, highlightMult);
|
||||
|
||||
color.rgb = mix(color.rgb, reflection.rgb, fresnelM);
|
||||
#endif
|
||||
////
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, mat);
|
||||
#endif
|
||||
|
||||
float sky = 0.0;
|
||||
DoFog(color.rgb, sky, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
color.a *= 1.0 - sky;
|
||||
|
||||
/* DRAWBUFFERS:03 */
|
||||
gl_FragData[0] = color;
|
||||
gl_FragData[1] = vec4(1.0 - translucentMult.rgb, translucentMult.a);
|
||||
|
||||
// supposed to be #if WATER_MAT_QUALITY >= 3 but optifine bad
|
||||
#if DETAIL_QUALITY >= 3
|
||||
/* DRAWBUFFERS:036 */
|
||||
gl_FragData[2] = vec4(0.0, materialMask, skyLightFactor, lmCoord.x + purkinjeOverwrite + clamp01(emission));
|
||||
|
||||
#ifdef SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:0368 */
|
||||
gl_FragData[3] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
#elif defined SS_BLOCKLIGHT
|
||||
/* DRAWBUFFERS:038 */
|
||||
gl_FragData[2] = vec4(lightAlbedo, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out int mat;
|
||||
flat out int blockLightEmission;
|
||||
|
||||
out vec2 texCoord;
|
||||
out vec2 lmCoord;
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
|
||||
flat out vec3 upVec, sunVec, northVec, eastVec;
|
||||
out vec3 playerPos;
|
||||
out vec3 normal;
|
||||
out vec3 viewVector;
|
||||
out vec3 atMidBlock;
|
||||
|
||||
out vec4 glColor;
|
||||
|
||||
#if WATER_STYLE >= 2 || (RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE) && WATER_STYLE == 1 && WATER_MAT_QUALITY >= 2 || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
flat out vec3 binormal, tangent;
|
||||
#endif
|
||||
|
||||
#ifdef POM
|
||||
out vec4 vTexCoordAM;
|
||||
#endif
|
||||
|
||||
// #if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
// flat out ivec2 pixelTexSize;
|
||||
// #endif
|
||||
|
||||
//Attributes//
|
||||
attribute vec4 mc_Entity;
|
||||
attribute vec4 at_midBlock;
|
||||
attribute vec4 mc_midTexCoord;
|
||||
attribute vec4 at_tangent;
|
||||
|
||||
//Common Variables//
|
||||
#if WATER_STYLE >= 2 || (RAIN_PUDDLES >= 1 || defined SPOOKY_RAIN_PUDDLE_OVERRIDE) && WATER_STYLE == 1 && WATER_MAT_QUALITY >= 2 || defined GENERATED_NORMALS || defined CUSTOM_PBR
|
||||
#else
|
||||
vec3 binormal;
|
||||
vec3 tangent;
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#ifdef TAA
|
||||
#include "/lib/antialiasing/jitter.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#if defined WAVE_EVERYTHING || defined WAVING_WATER_VERTEX
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.1, vec3(100.0))));
|
||||
#endif
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
glColor = gl_Color;
|
||||
|
||||
mat = int(mc_Entity.x + 0.5);
|
||||
|
||||
blockLightEmission = 0;
|
||||
#ifdef IRIS_FEATURE_BLOCK_EMISSION_ATTRIBUTE
|
||||
blockLightEmission = clamp(int(at_midBlock.w + 0.5), 0, 15);
|
||||
#endif
|
||||
|
||||
normal = normalize(gl_NormalMatrix * gl_Normal);
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
eastVec = normalize(gbufferModelView[0].xyz);
|
||||
northVec = normalize(gbufferModelView[2].xyz);
|
||||
sunVec = GetSunVector();
|
||||
atMidBlock = at_midBlock.xyz;
|
||||
|
||||
binormal = normalize(gl_NormalMatrix * cross(at_tangent.xyz, gl_Normal.xyz) * at_tangent.w);
|
||||
tangent = normalize(gl_NormalMatrix * at_tangent.xyz);
|
||||
|
||||
mat3 tbnMatrix = mat3(
|
||||
tangent.x, binormal.x, normal.x,
|
||||
tangent.y, binormal.y, normal.y,
|
||||
tangent.z, binormal.z, normal.z
|
||||
);
|
||||
|
||||
viewVector = tbnMatrix * (gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
vec2 midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
|
||||
#ifdef POM
|
||||
vTexCoordAM.zw = abs(texMinMidCoord) * 2;
|
||||
vTexCoordAM.xy = min(texCoord, midCoord - texMinMidCoord);
|
||||
#endif
|
||||
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
playerPos = position.xyz;
|
||||
|
||||
#ifdef WAVING_WATER_VERTEX
|
||||
DoWave(position.xyz, mat);
|
||||
#endif
|
||||
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
|
||||
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
|
||||
#ifdef TAA
|
||||
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,150 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in vec2 lmCoord;
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec3 upVec, sunVec;
|
||||
|
||||
in vec3 playerPos;
|
||||
|
||||
flat in vec4 glColor;
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunFactor = SdotU < 0.0 ? clamp(SdotU + 0.375, 0.0, 0.75) / 0.75 : clamp(SdotU + 0.03125, 0.0, 0.0625) / 0.0625;
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
float sunVisibility2 = sunVisibility * sunVisibility;
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
#include "/lib/misc/colorCodedPrograms.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, texCoord);
|
||||
color *= glColor;
|
||||
|
||||
if (color.a < 0.1 || isEyeInWater == 3) discard;
|
||||
|
||||
#ifdef NO_RAIN_ABOVE_CLOUDS
|
||||
if (cameraPosition.y > maximumCloudsHeight) discard;
|
||||
#endif
|
||||
|
||||
if (color.r + color.g < 1.5) color.a *= rainTexOpacity;
|
||||
else color.a *= snowTexOpacity;
|
||||
|
||||
color.rgb = sqrt3(color.rgb) * (blocklightCol * 2.0 * lmCoord.x + (ambientColor + 0.2 * lightColor) * lmCoord.y * (0.6 + 0.3 * sunFactor));
|
||||
|
||||
color.rgb *= vec3(WEATHER_TEX_R, WEATHER_TEX_G, WEATHER_TEX_B);
|
||||
|
||||
#if GLITTER_RAIN > 0
|
||||
float rainbowGlitterOn = 1.0;
|
||||
#if GLITTER_RAIN == 1
|
||||
rainbowGlitterOn = 0.0;
|
||||
float randomRainbowGlitterTime = 24000 * hash1(worldDay * 3); // Effect happens randomly throughout the day
|
||||
int rainbowGlitterEffect = (int(hash1(worldDay / 2)) % (2 * 24000)) + int(randomRainbowGlitterTime);
|
||||
if (worldTime > rainbowGlitterEffect && worldTime < rainbowGlitterEffect + 400) { // 400 in ticks - 20s, how long the effect will be on
|
||||
rainbowGlitterOn = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
color.rgb = mix(color.rgb, vec3(0.752, 0.752, 0.752) * 5.0, mix(0.0, step(0.7, Noise3D((playerPos + cameraPosition) * 0.004 + frameTimeCounter * 0.02)), rainbowGlitterOn * rainFactor));
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_CODED_PROGRAMS
|
||||
ColorCodeProgram(color, -1);
|
||||
#endif
|
||||
|
||||
/* DRAWBUFFERS:0 */
|
||||
gl_FragData[0] = color;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out vec2 lmCoord;
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec3 upVec, sunVec;
|
||||
|
||||
out vec3 playerPos;
|
||||
|
||||
flat out vec4 glColor;
|
||||
|
||||
//Attributes//
|
||||
|
||||
#if defined ATLAS_ROTATION || defined WAVE_EVERYTHING
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef WAVE_EVERYTHING
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 position = gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
glColor = gl_Color;
|
||||
|
||||
#ifdef WAVING_RAIN
|
||||
float rainWavingFactor = eyeBrightnessM2; // Prevents clipping inside interiors
|
||||
position.xz += rainWavingFactor * (0.4 * position.y + 0.2) * vec2(sin(frameTimeCounter * 0.3) + 0.5, sin(frameTimeCounter * 0.5) * 0.5);
|
||||
position.xz *= 1.0 - 0.08 * position.y * rainWavingFactor;
|
||||
#endif
|
||||
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
|
||||
texCoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
|
||||
#ifdef ATLAS_ROTATION
|
||||
texCoord += texCoord * float(hash33(mod(cameraPosition * 0.5, vec3(100.0))));
|
||||
#endif
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
sunVec = GetSunVector();
|
||||
|
||||
playerPos = (gbufferModelViewInverse * gl_ModelViewMatrix * gl_Vertex).xyz;
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVE_EVERYTHING
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
gl_Position = gl_ProjectionMatrix * gbufferModelView * position;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,188 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
discard;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
//Pipeline Constants//
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
#extension GL_ARB_shader_image_load_store : enable
|
||||
#endif
|
||||
|
||||
//Uniforms//
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
layout(r32i) uniform iimage2D endcrystal_img;
|
||||
#endif
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
vec4 position0 = ftransform();
|
||||
if (position0.x < 0.0 && position0.y > 0.0) {
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL % 2 == 1
|
||||
// update temporally stable end crystal data
|
||||
for (int index = 0; index < 20; index++) {
|
||||
int state = imageLoad(endcrystal_img, ivec2(index, 8)).r;
|
||||
state -= max(1, int(10000 * frameTime));
|
||||
if (state < 0) {
|
||||
for (int i = 0; i < 5; i++) {
|
||||
imageStore(endcrystal_img, ivec2(index, i+5), ivec4(0));
|
||||
}
|
||||
} else {
|
||||
ivec4 writeData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 5)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 6)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 7)).r,
|
||||
state
|
||||
);
|
||||
writeData.xyz += ivec3(10000 * (previousCameraPosition - cameraPosition));
|
||||
for (int i = 0; i < 4; i++) {
|
||||
imageStore(endcrystal_img, ivec2(index, i+5), ivec4(writeData[i]));
|
||||
}
|
||||
imageStore(endcrystal_img, ivec2(index, 9), ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 9)).r + int(10000 * frameTime)
|
||||
));
|
||||
}
|
||||
}
|
||||
// crystals
|
||||
for (int index = 0; index < 20; index++) {
|
||||
ivec4 newData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 1)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 2)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 3)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 4)).r
|
||||
);
|
||||
if (newData.w > 0) {
|
||||
vec3 pos = vec3(newData.xyz) / newData.w;
|
||||
int temporalIndex = -1;
|
||||
for (int k = 0; k < 20; k++) {
|
||||
ivec4 temporalData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(k, 5)).r,
|
||||
imageLoad(endcrystal_img, ivec2(k, 6)).r,
|
||||
imageLoad(endcrystal_img, ivec2(k, 7)).r,
|
||||
imageLoad(endcrystal_img, ivec2(k, 8)).r
|
||||
);
|
||||
vec3 temporalPos = 0.0001 * temporalData.xyz;
|
||||
if (temporalData.w > 0 && length((temporalPos - pos) * vec3(1.0, 0.3, 1.0)) < 1.0) {
|
||||
temporalIndex = k;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (temporalIndex == -1) {
|
||||
for (int k = 0; k < 20; k++) {
|
||||
int previousWeight = imageAtomicCompSwap(endcrystal_img, ivec2(k, 8), 0, -1);
|
||||
if (previousWeight == 0) {
|
||||
temporalIndex = k;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (temporalIndex >= 0) {
|
||||
ivec4 storeData = ivec4(10000 * pos, 16000);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
imageStore(endcrystal_img, ivec2(temporalIndex, i+5), ivec4(storeData[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
// healing beams
|
||||
for (int index = 20; index < 35; index++) {
|
||||
ivec4 writeData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 1)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 2)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 3)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 4)).r
|
||||
);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
imageStore(endcrystal_img, ivec2(index, i + 5), ivec4(writeData[i]));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
// dragon position
|
||||
{
|
||||
const int index = 35;
|
||||
int isDying = imageLoad(endcrystal_img, ivec2(index, 0)).r;
|
||||
// if (isDying == 0) isDying = 10000; // Helpful for debugging
|
||||
ivec4 readData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 1)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 2)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 3)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 4)).r
|
||||
);
|
||||
ivec4 temporalData = ivec4(
|
||||
imageLoad(endcrystal_img, ivec2(index, 5)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 6)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 7)).r,
|
||||
imageLoad(endcrystal_img, ivec2(index, 8)).r
|
||||
);
|
||||
ivec4 writeData = ivec4(
|
||||
readData.w > 0 ? 10000.0 * readData.xyz / readData.w : temporalData.xyz + ivec3(10000 * (previousCameraPosition - cameraPosition)),
|
||||
isDying > 0 ? temporalData.w + int(10000 * frameTime) : 0
|
||||
);
|
||||
imageStore(endcrystal_img, ivec2(index, 0), ivec4(max(0, isDying - int(1000 * frameTime))));
|
||||
for (int i = 0; i < 4; i++) {
|
||||
imageStore(endcrystal_img, ivec2(index, i + 1), ivec4(0));
|
||||
imageStore(endcrystal_img, ivec2(index, i + 5), ivec4(writeData[i]));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
for (int k = 0; k < 4; k++) {
|
||||
imageStore(
|
||||
endcrystal_img,
|
||||
ivec2(35, k+5),
|
||||
imageLoad(endcrystal_img, ivec2(35, k))
|
||||
);
|
||||
}
|
||||
#endif
|
||||
// clear temporally unstable data
|
||||
for (int index = 0; index < 36; index++) {
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
if (index == 35) {
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
for (int i = 0; i < 5; i++) {
|
||||
imageStore(endcrystal_img, ivec2(index, i), ivec4(0));
|
||||
}
|
||||
}
|
||||
}
|
||||
gl_Position = vec4(-1);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,416 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
flat in int mat;
|
||||
|
||||
in vec2 texCoord;
|
||||
|
||||
flat in vec3 sunVec, upVec;
|
||||
|
||||
in vec4 position;
|
||||
flat in vec4 glColor;
|
||||
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
in vec2 signMidCoordPos;
|
||||
flat in vec2 absMidCoordPos;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
float SdotU = dot(sunVec, upVec);
|
||||
float sunVisibility = clamp(SdotU + 0.0625, 0.0, 0.125) / 0.125;
|
||||
|
||||
//Common Functions//
|
||||
void DoNaturalShadowCalculation(inout vec4 color1, inout vec4 color2) {
|
||||
color1.rgb *= glColor.rgb;
|
||||
color1.rgb = mix(vec3(1.0), color1.rgb, pow(color1.a, (1.0 - color1.a) * 0.5) * 1.05);
|
||||
color1.rgb *= 1.0 - pow(color1.a, 64.0);
|
||||
color1.rgb *= 0.2; // Natural Strength
|
||||
|
||||
color2.rgb = normalize(color1.rgb) * 0.5;
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
#include "/lib/materials/materialMethods/connectedGlass.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
vec4 color1 = texture2DLod(tex, texCoord, 0); // Shadow Color
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
vec4 color2 = color1; // Light Shaft Color
|
||||
|
||||
color2.rgb *= 0.25; // Natural Strength
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
float positionYM = position.y;
|
||||
#endif
|
||||
|
||||
if (mat < 32008) {
|
||||
if (mat < 32000) {
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
if (mat == 30008) { // Tinted Glass
|
||||
DoSimpleConnectedGlass(color1);
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
positionYM = 0.0; // 86AHGA: For scene-aware light shafts to be less prone to get extreme under large glass planes
|
||||
#endif
|
||||
}
|
||||
if (mat >= 31000) { // Stained Glass, Stained Glass Pane
|
||||
DoSimpleConnectedGlass(color1);
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
positionYM = 0.0; // 86AHGA
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
DoNaturalShadowCalculation(color1, color2);
|
||||
} else {
|
||||
if (mat == 32000) { // Water
|
||||
vec3 worldPos = position.xyz + cameraPosition;
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
// For scene-aware light shafts to be more prone to get extreme near water
|
||||
positionYM += 3.5;
|
||||
#endif
|
||||
|
||||
// Water Caustics
|
||||
#if WATER_CAUSTIC_STYLE < 3 && PIXEL_WATER == 0
|
||||
#if MC_VERSION >= 11300
|
||||
float wcl = GetLuminance(color1.rgb);
|
||||
color1.rgb = color1.rgb * pow2(wcl) * 1.2;
|
||||
#else
|
||||
color1.rgb = mix(color1.rgb, vec3(GetLuminance(color1.rgb)), 0.88);
|
||||
color1.rgb = pow2(color1.rgb) * vec3(2.5, 3.0, 3.0) * 0.96;
|
||||
#endif
|
||||
#else
|
||||
#define WATER_SPEED_MULT_M WATER_SPEED_MULT * 0.035
|
||||
vec2 causticWind = vec2(frameTimeCounter * WATER_SPEED_MULT_M, 0.0);
|
||||
#if PIXEL_WATER == 1
|
||||
causticWind *= 2.0;
|
||||
#endif
|
||||
vec2 cPos1 = worldPos.xz * 0.10 - causticWind;
|
||||
vec2 cPos2 = worldPos.xz * 0.05 + causticWind;
|
||||
|
||||
float cMult = 14.0;
|
||||
float offset = 0.001;
|
||||
|
||||
float caustic = 0.0;
|
||||
caustic += dot(texture2D(gaux4, cPos1 + vec2(offset, 0.0)).rg, vec2(cMult))
|
||||
- dot(texture2D(gaux4, cPos1 - vec2(offset, 0.0)).rg, vec2(cMult));
|
||||
caustic += dot(texture2D(gaux4, cPos2 + vec2(0.0, offset)).rg, vec2(cMult))
|
||||
- dot(texture2D(gaux4, cPos2 - vec2(0.0, offset)).rg, vec2(cMult));
|
||||
#if PIXEL_WATER == 1
|
||||
vec2 uv = worldPos.xz + (vec2(frameTimeCounter) * 0.004);
|
||||
uv = (uv - 0.5) * 0.25 + 0.5;
|
||||
float pixelWaterSize = 16;
|
||||
uv = floor(uv * (pixelWaterSize * 4)) / (pixelWaterSize * 4);
|
||||
float foamNoise = step(texture2D(noisetex, uv + 0.004).y, 0.38);
|
||||
caustic = clamp01(caustic);
|
||||
caustic *= foamNoise * 10;
|
||||
#endif
|
||||
color1.rgb = vec3(max0(min1(caustic * 0.8 + 0.35)) * 0.65 + 0.35);
|
||||
|
||||
#if MC_VERSION < 11300
|
||||
color1.rgb *= vec3(0.3, 0.45, 0.9);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if MC_VERSION >= 11300
|
||||
#if WATERCOLOR_MODE >= 2
|
||||
color1.rgb *= glColor.rgb;
|
||||
#else
|
||||
color1.rgb *= vec3(0.3, 0.45, 0.9);
|
||||
#endif
|
||||
#endif
|
||||
color1.rgb *= vec3(0.6, 0.8, 1.1);
|
||||
////
|
||||
|
||||
// Underwater Light Shafts
|
||||
vec3 worldPosM = worldPos;
|
||||
|
||||
#if WATER_FOG_MULT > 100
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
worldPosM *= WATER_FOG_MULT_M;
|
||||
#endif
|
||||
|
||||
vec2 waterWind = vec2(syncedTime * 0.01, 0.0);
|
||||
float waterNoise = texture2D(noisetex, worldPosM.xz * 0.012 - waterWind).g;
|
||||
waterNoise += texture2D(noisetex, worldPosM.xz * 0.05 + waterWind).g;
|
||||
|
||||
float factor = max(2.5 - 0.025 * length(position.xz), 0.8333) * 1.3;
|
||||
waterNoise = pow(waterNoise * 0.5, factor) * factor * 1.3;
|
||||
|
||||
#if MC_VERSION >= 11300 && WATERCOLOR_MODE >= 2
|
||||
color2.rgb = normalize(sqrt1(glColor.rgb)) * vec3(0.24, 0.22, 0.26);
|
||||
#else
|
||||
color2.rgb = vec3(0.08, 0.12, 0.195);
|
||||
#endif
|
||||
color2.rgb *= waterNoise * (1.0 + sunVisibility - rainFactor);
|
||||
////
|
||||
|
||||
#ifdef UNDERWATERCOLOR_CHANGED
|
||||
color1.rgb *= vec3(UNDERWATERCOLOR_RM, UNDERWATERCOLOR_GM, UNDERWATERCOLOR_BM);
|
||||
color2.rgb *= vec3(UNDERWATERCOLOR_RM, UNDERWATERCOLOR_GM, UNDERWATERCOLOR_BM);
|
||||
#endif
|
||||
} else /*if (mat == 32004)*/ { // Ice
|
||||
color1.rgb *= color1.rgb;
|
||||
color1.rgb *= color1.rgb;
|
||||
color1.rgb = mix(vec3(1.0), color1.rgb, pow(color1.a, (1.0 - color1.a) * 0.5) * 1.05);
|
||||
color1.rgb *= 1.0 - pow(color1.a, 64.0);
|
||||
color1.rgb *= 0.28;
|
||||
|
||||
color2.rgb = normalize(pow(color1.rgb, vec3(0.25))) * 0.5;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 32020) { // Glass, Glass Pane, Beacon (32008, 32012, 32016)
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
if (mat == 32008) { // Glass
|
||||
DoSimpleConnectedGlass(color1);
|
||||
}
|
||||
if (mat == 32012) { // Glass Pane
|
||||
DoSimpleConnectedGlass(color1);
|
||||
}
|
||||
#endif
|
||||
if (color1.a > 0.5) color1 = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
else color1 = vec4(vec3(0.2 * (1.0 - GLASS_OPACITY)), 1.0);
|
||||
color2.rgb = vec3(0.3);
|
||||
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
positionYM = 0.0; // 86AHGA
|
||||
#endif
|
||||
} else {
|
||||
DoNaturalShadowCalculation(color1, color2);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
if (entityId == 50004) discard; //remove lightning shadows
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
int seed = worldDay / 2; // Thanks to Bálint
|
||||
int currTime = (worldDay % 2) * 24000 + worldTime; // Effect happens every 2 minecraft days
|
||||
float randomTime = 24000 * hash1(worldDay * 5); // Effect happens randomly throughout the day
|
||||
int timeWhenItHappens = (int(hash1(seed)) % (2 * 24000)) + int(randomTime);
|
||||
if (currTime > timeWhenItHappens && currTime < timeWhenItHappens + 100) { // 100 in ticks - 5s, how long the effect will be on, aka leaves are gone
|
||||
if (mat == 10007 || mat == 10009 || mat == 10011) discard; // disable leaves
|
||||
}
|
||||
#endif
|
||||
|
||||
gl_FragData[0] = color1; // Shadow Color
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
#if defined LIGHTSHAFTS_ACTIVE && LIGHTSHAFT_BEHAVIOUR == 1 && defined OVERWORLD
|
||||
color2.a = 0.25 + max0(positionYM * 0.05); // consistencyMEJHRI7DG
|
||||
#endif
|
||||
|
||||
gl_FragData[1] = color2; // Light Shaft Color
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
flat out int mat;
|
||||
|
||||
out vec2 texCoord;
|
||||
|
||||
flat out vec3 sunVec, upVec;
|
||||
|
||||
out vec4 position;
|
||||
flat out vec4 glColor;
|
||||
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
out vec2 signMidCoordPos;
|
||||
flat out vec2 absMidCoordPos;
|
||||
#endif
|
||||
|
||||
//Pipeline Constants//
|
||||
#if COLORED_LIGHTING_INTERNAL > 0 || END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
#extension GL_ARB_shader_image_load_store : enable
|
||||
#endif
|
||||
|
||||
//Attributes//
|
||||
attribute vec4 mc_Entity;
|
||||
|
||||
#if defined PERPENDICULAR_TWEAKS || defined WAVING_ANYTHING_TERRAIN || defined WAVING_WATER_VERTEX || defined CONNECTED_GLASS_EFFECT
|
||||
attribute vec4 mc_midTexCoord;
|
||||
#endif
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0 || defined IRIS_FEATURE_BLOCK_EMISSION_ATTRIBUTE
|
||||
attribute vec4 at_midBlock;
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
vec2 lmCoord;
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
writeonly uniform uimage3D voxel_img;
|
||||
|
||||
#ifdef PUDDLE_VOXELIZATION
|
||||
writeonly uniform uimage2D puddle_img;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
#include "/lib/util/spaceConversion.glsl"
|
||||
|
||||
#if defined WAVING_ANYTHING_TERRAIN || defined WAVE_EVERYTHING || defined WAVING_WATER_VERTEX
|
||||
#include "/lib/materials/materialMethods/wavingBlocks.glsl"
|
||||
#endif
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
|
||||
#ifdef PUDDLE_VOXELIZATION
|
||||
#include "/lib/misc/puddleVoxelization.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE
|
||||
#include "/lib/misc/distortWorld.glsl"
|
||||
#endif
|
||||
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0 || defined END_PORTAL_BEAM_INTERNAL
|
||||
#include "/lib/misc/endCrystalVoxelization.glsl"
|
||||
#endif
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
texCoord = gl_MultiTexCoord0.xy;
|
||||
lmCoord = GetLightMapCoordinates();
|
||||
glColor = gl_Color;
|
||||
sunVec = GetSunVector();
|
||||
upVec = normalize(gbufferModelView[1].xyz);
|
||||
mat = int(mc_Entity.x + 0.5);
|
||||
|
||||
#if defined WORLD_CURVATURE || defined MIRROR_DIMENSION
|
||||
position = shadowModelViewInverse * gl_ModelViewMatrix * gl_Vertex;
|
||||
#else
|
||||
position = shadowModelViewInverse * shadowProjectionInverse * ftransform();
|
||||
#endif
|
||||
|
||||
#ifdef WORLD_CURVATURE
|
||||
position.y += doWorldCurvature(position.xz);
|
||||
#endif
|
||||
|
||||
#ifdef MIRROR_DIMENSION
|
||||
doMirrorDimension(position);
|
||||
#endif
|
||||
|
||||
#if defined WAVING_ANYTHING_TERRAIN || defined WAVING_WATER_VERTEX || defined WAVE_EVERYTHING
|
||||
DoWave(position.xyz, mat);
|
||||
#ifdef WAVE_EVERYTHING
|
||||
DoWaveEverything(position.xyz);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
vec2 midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
signMidCoordPos = sign(texMinMidCoord);
|
||||
absMidCoordPos = abs(texMinMidCoord);
|
||||
#endif
|
||||
|
||||
// #ifdef SPOOKY
|
||||
// if (mat == 10744) { // Cobweb Thanks to gri
|
||||
// vec3 irisThirdPersonPull = vec3(0.0);
|
||||
// #ifdef IS_IRIS
|
||||
// irisThirdPersonPull = eyePosition - cameraPosition;
|
||||
// #endif
|
||||
// vec3 pullCenter = vec3(0.1, -0.1, -0.05) - irisThirdPersonPull;
|
||||
// float pullFactor = pow(min(abs(sin(1.81 * frameTimeCounter) + cos(0.9124 * frameTimeCounter)), 1.0), 10.0) * 4.0 / (length(position.xyz) + max(20 * texture2D(noisetex, vec2(frameTimeCounter * 0.1)).r, 10.0));
|
||||
// vec3 pullDir = pullCenter - position.xyz - at_midBlock.xyz / 64.0;
|
||||
// position.xyz += pullDir * pullFactor;
|
||||
// }
|
||||
// #endif
|
||||
|
||||
#ifdef PERPENDICULAR_TWEAKS
|
||||
if (mat == 10003 || mat == 10005 || mat == 10015 || mat == 10017 || mat == 10019 || mat == 10029) { // Foliage
|
||||
#ifndef CONNECTED_GLASS_EFFECT
|
||||
vec2 midCoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
|
||||
vec2 texMinMidCoord = texCoord - midCoord;
|
||||
#endif
|
||||
if (texMinMidCoord.y < 0.0) {
|
||||
vec3 normal = gl_NormalMatrix * gl_Normal;
|
||||
position.xyz += normal * 0.35;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (mat == 32000) { // Water
|
||||
position.y += 0.015 * max0(length(position.xyz) - 50.0);
|
||||
}
|
||||
|
||||
vec3 normal = mat3(shadowModelViewInverse) * gl_NormalMatrix * gl_Normal;
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
if (gl_VertexID % 4 == 0) {
|
||||
UpdateVoxelMap(mat, normal);
|
||||
#ifdef PUDDLE_VOXELIZATION
|
||||
UpdatePuddleVoxelMap(mat);
|
||||
#endif
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
if (mat == 10556 && normal.y > 0.99 && length(position.xyz) < 32) SetEndPortalLoc(position.xyz);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL % 2 == 1
|
||||
if (entityId == 50000 && abs(normal.y) > 0.5 && abs(normal.y) < 0.8) { // End Crystal
|
||||
UpdateEndCrystalMap(position.xyz);
|
||||
}
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
if (entityId == 50200) { // end crystal beam
|
||||
UpdateBeamMap(position.xyz);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
if (entityId == 50204) { // ender dragon
|
||||
UpdateDragonPos(position.xyz);
|
||||
}
|
||||
#endif
|
||||
|
||||
gl_Position = shadowProjection * shadowModelView * position;
|
||||
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#if MC_VERSION >= 12100
|
||||
#define VALUE == 1.0
|
||||
#else
|
||||
#define VALUE < 0.5
|
||||
#endif
|
||||
if (entityId == 0 && gl_Color.a VALUE && renderStage == MC_RENDER_STAGE_ENTITIES && abs(normal.y) > 0.999 && abs(normal.y) < 1.0) {
|
||||
gl_Position = vec4(0);
|
||||
#ifndef IRIS_TAG_SUPPORT
|
||||
SetEndDragonDeath();
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
float lVertexPos = sqrt(gl_Position.x * gl_Position.x + gl_Position.y * gl_Position.y);
|
||||
float distortFactor = lVertexPos * shadowMapBias + (1.0 - shadowMapBias);
|
||||
gl_Position.xy *= 1.0 / distortFactor;
|
||||
gl_Position.z = gl_Position.z * 0.2;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,138 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Shadowcomp 1//////////Shadowcomp 1//////////Shadowcomp 1//////////
|
||||
#ifdef SHADOWCOMP
|
||||
|
||||
#define OPTIMIZATION_ACL_HALF_RATE_UPDATES
|
||||
#define OPTIMIZATION_ACL_BEHIND_PLAYER
|
||||
|
||||
layout (local_size_x = 8, local_size_y = 8, local_size_z = 8) in;
|
||||
#if COLORED_LIGHTING_INTERNAL == 128
|
||||
const ivec3 workGroups = ivec3(16, 8, 16);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 192
|
||||
const ivec3 workGroups = ivec3(24, 12, 24);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 256
|
||||
const ivec3 workGroups = ivec3(32, 16, 32);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 384
|
||||
const ivec3 workGroups = ivec3(48, 24, 48);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 512
|
||||
const ivec3 workGroups = ivec3(64, 32, 64);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 768
|
||||
const ivec3 workGroups = ivec3(96, 32, 96);
|
||||
#elif COLORED_LIGHTING_INTERNAL == 1024
|
||||
const ivec3 workGroups = ivec3(128, 32, 128);
|
||||
#endif
|
||||
|
||||
//Common Variables//
|
||||
ivec3[6] face_offsets = ivec3[6](
|
||||
ivec3( 1, 0, 0),
|
||||
ivec3( 0, 1, 0),
|
||||
ivec3( 0, 0, 1),
|
||||
ivec3(-1, 0, 0),
|
||||
ivec3( 0, -1, 0),
|
||||
ivec3( 0, 0, -1)
|
||||
);
|
||||
|
||||
writeonly uniform image3D floodfill_img;
|
||||
writeonly uniform image3D floodfill_img_copy;
|
||||
|
||||
//Common Functions//
|
||||
vec4 GetLightSample(sampler3D lightSampler, ivec3 pos) {
|
||||
return texelFetch(lightSampler, pos, 0);
|
||||
}
|
||||
|
||||
vec4 GetLightAverage(sampler3D lightSampler, ivec3 pos, ivec3 voxelVolumeSize) {
|
||||
vec4 light_old = GetLightSample(lightSampler, pos);
|
||||
vec4 light_px = GetLightSample(lightSampler, clamp(pos + face_offsets[0], ivec3(0), voxelVolumeSize - 1));
|
||||
vec4 light_py = GetLightSample(lightSampler, clamp(pos + face_offsets[1], ivec3(0), voxelVolumeSize - 1));
|
||||
vec4 light_pz = GetLightSample(lightSampler, clamp(pos + face_offsets[2], ivec3(0), voxelVolumeSize - 1));
|
||||
vec4 light_nx = GetLightSample(lightSampler, clamp(pos + face_offsets[3], ivec3(0), voxelVolumeSize - 1));
|
||||
vec4 light_ny = GetLightSample(lightSampler, clamp(pos + face_offsets[4], ivec3(0), voxelVolumeSize - 1));
|
||||
vec4 light_nz = GetLightSample(lightSampler, clamp(pos + face_offsets[5], ivec3(0), voxelVolumeSize - 1));
|
||||
|
||||
vec4 light = light_old + light_px + light_py + light_pz + light_nx + light_ny + light_nz;
|
||||
return light / 7.2; // Slightly higher than 7 to prevent the light from travelling too far
|
||||
}
|
||||
|
||||
//Includes//
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
ivec3 pos = ivec3(gl_GlobalInvocationID);
|
||||
vec3 posM = vec3(pos) / vec3(voxelVolumeSize);
|
||||
vec3 posOffset = floor(previousCameraPosition) - floor(cameraPosition);
|
||||
ivec3 previousPos = ivec3(vec3(pos) - posOffset);
|
||||
|
||||
ivec3 absPosFromCenter = abs(pos - voxelVolumeSize / 2);
|
||||
if (absPosFromCenter.x + absPosFromCenter.y + absPosFromCenter.z > 16) {
|
||||
#ifdef OPTIMIZATION_ACL_BEHIND_PLAYER
|
||||
vec4 viewPos = gbufferProjectionInverse * vec4(0.0, 0.0, 1.0, 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
vec3 nPlayerPos = normalize(mat3(gbufferModelViewInverse) * viewPos.xyz);
|
||||
if (dot(normalize(posM - 0.5), nPlayerPos) < 0.0) {
|
||||
#ifdef COLORED_LIGHT_FOG
|
||||
if ((frameCounter & 1) == 0) {
|
||||
imageStore(floodfill_img_copy, pos, GetLightSample(floodfill_sampler, previousPos));
|
||||
} else {
|
||||
imageStore(floodfill_img, pos, GetLightSample(floodfill_sampler_copy, previousPos));
|
||||
}
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
vec4 light = vec4(0.0);
|
||||
uint voxel = texelFetch(voxel_sampler, pos, 0).x;
|
||||
|
||||
if ((frameCounter & 1) == 0) {
|
||||
if (voxel == 1u) {
|
||||
imageStore(floodfill_img_copy, pos, vec4(0.0));
|
||||
return;
|
||||
}
|
||||
#ifdef OPTIMIZATION_ACL_HALF_RATE_UPDATES
|
||||
if (posM.x < 0.5) {
|
||||
imageStore(floodfill_img_copy, pos, GetLightSample(floodfill_sampler, previousPos));
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
light = GetLightAverage(floodfill_sampler, previousPos, voxelVolumeSize);
|
||||
} else {
|
||||
if (voxel == 1u) {
|
||||
imageStore(floodfill_img, pos, vec4(0.0));
|
||||
return;
|
||||
}
|
||||
#ifdef OPTIMIZATION_ACL_HALF_RATE_UPDATES
|
||||
if (posM.x > 0.5) {
|
||||
imageStore(floodfill_img, pos, GetLightSample(floodfill_sampler_copy, previousPos));
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
light = GetLightAverage(floodfill_sampler_copy, previousPos, voxelVolumeSize);
|
||||
}
|
||||
|
||||
if (voxel == 0u || voxel >= 200u) {
|
||||
if (voxel >= 200u) {
|
||||
vec3 tint = specialTintColor[min(voxel - 200u, specialTintColor.length() - 1u)];
|
||||
light.rgb *= tint;
|
||||
}
|
||||
} else {
|
||||
vec4 color = GetSpecialBlocklightColor(int(voxel));
|
||||
light = max(light, vec4(pow2(color.rgb), color.a));
|
||||
}
|
||||
|
||||
if ((frameCounter & 1) == 0) {
|
||||
imageStore(floodfill_img_copy, pos, light);
|
||||
} else {
|
||||
imageStore(floodfill_img, pos, light);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
/////////////////////////////////////
|
||||
// Complementary Shaders by EminGT //
|
||||
// With Euphoria Patches by SpacEagle17 //
|
||||
/////////////////////////////////////
|
||||
|
||||
//Common//
|
||||
#include "/lib/common.glsl"
|
||||
|
||||
//////////Fragment Shader//////////Fragment Shader//////////Fragment Shader//////////
|
||||
#ifdef FRAGMENT_SHADER
|
||||
|
||||
//Pipeline Constants//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////Vertex Shader//////////Vertex Shader//////////Vertex Shader//////////
|
||||
#ifdef VERTEX_SHADER
|
||||
|
||||
//Attributes//
|
||||
|
||||
//Common Variables//
|
||||
|
||||
//Common Functions//
|
||||
|
||||
//Includes//
|
||||
|
||||
//Program//
|
||||
void main() {
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user