Flesh Dimension now has spooky
ihfr:the_carnage < this dimension now uses the Spooklementary_1.1 nether shaders. this was surprisingly easy. will have to manually adjust settings via hard-coding them in
This commit is contained in:
@ -0,0 +1,183 @@
|
||||
//FXAA 3.11 from http://blog.simonrodriguez.fr/articles/30-07-2016_implementing_fxaa.html
|
||||
float quality[12] = float[12] (1.0, 1.0, 1.0, 1.0, 1.0, 1.5, 2.0, 2.0, 2.0, 2.0, 4.0, 8.0);
|
||||
|
||||
void FXAA311(inout vec3 color) {
|
||||
float edgeThresholdMin = 0.03125;
|
||||
float edgeThresholdMax = 0.0625;
|
||||
float subpixelQuality = 0.75;
|
||||
int iterations = 12;
|
||||
|
||||
vec2 view = 1.0 / vec2(viewWidth, viewHeight);
|
||||
|
||||
float lumaCenter = GetLuminance(color);
|
||||
#ifndef LIGHT_COLORING
|
||||
float lumaDown = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 0, -1), 0).rgb);
|
||||
float lumaUp = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 0, 1), 0).rgb);
|
||||
float lumaLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, 0), 0).rgb);
|
||||
float lumaRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, 0), 0).rgb);
|
||||
#else
|
||||
float lumaDown = GetLuminance(texelFetch(colortex8, texelCoord + ivec2( 0, -1), 0).rgb);
|
||||
float lumaUp = GetLuminance(texelFetch(colortex8, texelCoord + ivec2( 0, 1), 0).rgb);
|
||||
float lumaLeft = GetLuminance(texelFetch(colortex8, texelCoord + ivec2(-1, 0), 0).rgb);
|
||||
float lumaRight = GetLuminance(texelFetch(colortex8, texelCoord + ivec2( 1, 0), 0).rgb);
|
||||
#endif
|
||||
|
||||
float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight)));
|
||||
float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight)));
|
||||
|
||||
float lumaRange = lumaMax - lumaMin;
|
||||
|
||||
if (lumaRange > max(edgeThresholdMin, lumaMax * edgeThresholdMax)) {
|
||||
#ifndef LIGHT_COLORING
|
||||
float lumaDownLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, -1), 0).rgb);
|
||||
float lumaUpRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, 1), 0).rgb);
|
||||
float lumaUpLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, 1), 0).rgb);
|
||||
float lumaDownRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, -1), 0).rgb);
|
||||
#else
|
||||
float lumaDownLeft = GetLuminance(texelFetch(colortex8, texelCoord + ivec2(-1, -1), 0).rgb);
|
||||
float lumaUpRight = GetLuminance(texelFetch(colortex8, texelCoord + ivec2( 1, 1), 0).rgb);
|
||||
float lumaUpLeft = GetLuminance(texelFetch(colortex8, texelCoord + ivec2(-1, 1), 0).rgb);
|
||||
float lumaDownRight = GetLuminance(texelFetch(colortex8, texelCoord + ivec2( 1, -1), 0).rgb);
|
||||
#endif
|
||||
|
||||
float lumaDownUp = lumaDown + lumaUp;
|
||||
float lumaLeftRight = lumaLeft + lumaRight;
|
||||
|
||||
float lumaLeftCorners = lumaDownLeft + lumaUpLeft;
|
||||
float lumaDownCorners = lumaDownLeft + lumaDownRight;
|
||||
float lumaRightCorners = lumaDownRight + lumaUpRight;
|
||||
float lumaUpCorners = lumaUpRight + lumaUpLeft;
|
||||
|
||||
float edgeHorizontal = abs(-2.0 * lumaLeft + lumaLeftCorners ) +
|
||||
abs(-2.0 * lumaCenter + lumaDownUp ) * 2.0 +
|
||||
abs(-2.0 * lumaRight + lumaRightCorners);
|
||||
float edgeVertical = abs(-2.0 * lumaUp + lumaUpCorners ) +
|
||||
abs(-2.0 * lumaCenter + lumaLeftRight ) * 2.0 +
|
||||
abs(-2.0 * lumaDown + lumaDownCorners );
|
||||
|
||||
bool isHorizontal = (edgeHorizontal >= edgeVertical);
|
||||
|
||||
float luma1 = isHorizontal ? lumaDown : lumaLeft;
|
||||
float luma2 = isHorizontal ? lumaUp : lumaRight;
|
||||
float gradient1 = luma1 - lumaCenter;
|
||||
float gradient2 = luma2 - lumaCenter;
|
||||
|
||||
bool is1Steepest = abs(gradient1) >= abs(gradient2);
|
||||
float gradientScaled = 0.25 * max(abs(gradient1), abs(gradient2));
|
||||
|
||||
float stepLength = isHorizontal ? view.y : view.x;
|
||||
|
||||
float lumaLocalAverage = 0.0;
|
||||
|
||||
if (is1Steepest) {
|
||||
stepLength = - stepLength;
|
||||
lumaLocalAverage = 0.5 * (luma1 + lumaCenter);
|
||||
} else {
|
||||
lumaLocalAverage = 0.5 * (luma2 + lumaCenter);
|
||||
}
|
||||
|
||||
vec2 currentUv = texCoord;
|
||||
if (isHorizontal) {
|
||||
currentUv.y += stepLength * 0.5;
|
||||
} else {
|
||||
currentUv.x += stepLength * 0.5;
|
||||
}
|
||||
|
||||
vec2 offset = isHorizontal ? vec2(view.x, 0.0) : vec2(0.0, view.y);
|
||||
|
||||
vec2 uv1 = currentUv - offset;
|
||||
vec2 uv2 = currentUv + offset;
|
||||
|
||||
#ifndef LIGHT_COLORING
|
||||
float lumaEnd1 = GetLuminance(texture2D(colortex3, uv1).rgb);
|
||||
float lumaEnd2 = GetLuminance(texture2D(colortex3, uv2).rgb);
|
||||
#else
|
||||
float lumaEnd1 = GetLuminance(texture2D(colortex8, uv1).rgb);
|
||||
float lumaEnd2 = GetLuminance(texture2D(colortex8, uv2).rgb);
|
||||
#endif
|
||||
lumaEnd1 -= lumaLocalAverage;
|
||||
lumaEnd2 -= lumaLocalAverage;
|
||||
|
||||
bool reached1 = abs(lumaEnd1) >= gradientScaled;
|
||||
bool reached2 = abs(lumaEnd2) >= gradientScaled;
|
||||
bool reachedBoth = reached1 && reached2;
|
||||
|
||||
if (!reached1) {
|
||||
uv1 -= offset;
|
||||
}
|
||||
if (!reached2) {
|
||||
uv2 += offset;
|
||||
}
|
||||
|
||||
if (!reachedBoth) {
|
||||
for (int i = 2; i < iterations; i++) {
|
||||
if (!reached1) {
|
||||
#ifndef LIGHT_COLORING
|
||||
lumaEnd1 = GetLuminance(texture2D(colortex3, uv1).rgb);
|
||||
#else
|
||||
lumaEnd1 = GetLuminance(texture2D(colortex8, uv1).rgb);
|
||||
#endif
|
||||
lumaEnd1 = lumaEnd1 - lumaLocalAverage;
|
||||
}
|
||||
if (!reached2) {
|
||||
#ifndef LIGHT_COLORING
|
||||
lumaEnd2 = GetLuminance(texture2D(colortex3, uv2).rgb);
|
||||
#else
|
||||
lumaEnd2 = GetLuminance(texture2D(colortex8, uv2).rgb);
|
||||
#endif
|
||||
lumaEnd2 = lumaEnd2 - lumaLocalAverage;
|
||||
}
|
||||
|
||||
reached1 = abs(lumaEnd1) >= gradientScaled;
|
||||
reached2 = abs(lumaEnd2) >= gradientScaled;
|
||||
reachedBoth = reached1 && reached2;
|
||||
|
||||
if (!reached1) {
|
||||
uv1 -= offset * quality[i];
|
||||
}
|
||||
if (!reached2) {
|
||||
uv2 += offset * quality[i];
|
||||
}
|
||||
|
||||
if (reachedBoth) break;
|
||||
}
|
||||
}
|
||||
|
||||
float distance1 = isHorizontal ? (texCoord.x - uv1.x) : (texCoord.y - uv1.y);
|
||||
float distance2 = isHorizontal ? (uv2.x - texCoord.x) : (uv2.y - texCoord.y);
|
||||
|
||||
bool isDirection1 = distance1 < distance2;
|
||||
float distanceFinal = min(distance1, distance2);
|
||||
|
||||
float edgeThickness = (distance1 + distance2);
|
||||
|
||||
float pixelOffset = - distanceFinal / edgeThickness + 0.5;
|
||||
|
||||
bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage;
|
||||
|
||||
bool correctVariation = ((isDirection1 ? lumaEnd1 : lumaEnd2) < 0.0) != isLumaCenterSmaller;
|
||||
|
||||
float finalOffset = correctVariation ? pixelOffset : 0.0;
|
||||
|
||||
float lumaAverage = (1.0 / 12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners);
|
||||
float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter) / lumaRange, 0.0, 1.0);
|
||||
float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1;
|
||||
float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * subpixelQuality;
|
||||
|
||||
finalOffset = max(finalOffset, subPixelOffsetFinal);
|
||||
|
||||
// Compute the final UV coordinates.
|
||||
vec2 finalUv = texCoord;
|
||||
if (isHorizontal) {
|
||||
finalUv.y += finalOffset * stepLength;
|
||||
} else {
|
||||
finalUv.x += finalOffset * stepLength;
|
||||
}
|
||||
|
||||
#ifndef LIGHT_COLORING
|
||||
color = texture2D(colortex3, finalUv).rgb;
|
||||
#else
|
||||
color = texture2D(colortex8, finalUv).rgb;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,146 @@
|
||||
const float regularEdge = 20.0;
|
||||
const float extraEdgeMult = 3.0;
|
||||
|
||||
// Previous frame reprojection from Chocapic13
|
||||
vec2 Reprojection(vec3 pos, vec3 cameraOffset) {
|
||||
pos = pos * 2.0 - 1.0;
|
||||
|
||||
vec4 viewPosPrev = gbufferProjectionInverse * vec4(pos, 1.0);
|
||||
viewPosPrev /= viewPosPrev.w;
|
||||
viewPosPrev = gbufferModelViewInverse * viewPosPrev;
|
||||
|
||||
vec4 previousPosition = viewPosPrev + vec4(cameraOffset, 0.0);
|
||||
previousPosition = gbufferPreviousModelView * previousPosition;
|
||||
previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
return previousPosition.xy / previousPosition.w * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec3 RGBToYCoCg(vec3 col) {
|
||||
return vec3(
|
||||
col.r * 0.25 + col.g * 0.5 + col.b * 0.25,
|
||||
col.r * 0.5 - col.b * 0.5,
|
||||
col.r * -0.25 + col.g * 0.5 + col.b * -0.25
|
||||
);
|
||||
}
|
||||
|
||||
vec3 YCoCgToRGB(vec3 col) {
|
||||
float n = col.r - col.b;
|
||||
return vec3(n + col.g, col.r + col.b, n - col.g);
|
||||
}
|
||||
|
||||
vec3 ClipAABB(vec3 q,vec3 aabb_min, vec3 aabb_max){
|
||||
vec3 p_clip = 0.5 * (aabb_max + aabb_min);
|
||||
vec3 e_clip = 0.5 * (aabb_max - aabb_min) + 0.00000001;
|
||||
|
||||
vec3 v_clip = q - vec3(p_clip);
|
||||
vec3 v_unit = v_clip.xyz / e_clip;
|
||||
vec3 a_unit = abs(v_unit);
|
||||
float ma_unit = max(a_unit.x, max(a_unit.y, a_unit.z));
|
||||
|
||||
if (ma_unit > 1.0)
|
||||
return vec3(p_clip) + v_clip / ma_unit;
|
||||
else
|
||||
return q;
|
||||
}
|
||||
|
||||
ivec2 neighbourhoodOffsets[8] = ivec2[8](
|
||||
ivec2( 1, 1),
|
||||
ivec2( 1,-1),
|
||||
ivec2(-1, 1),
|
||||
ivec2(-1,-1),
|
||||
ivec2( 1, 0),
|
||||
ivec2( 0, 1),
|
||||
ivec2(-1, 0),
|
||||
ivec2( 0,-1)
|
||||
);
|
||||
|
||||
void NeighbourhoodClamping(vec3 color, inout vec3 tempColor, float depth, inout float edge) {
|
||||
vec3 minclr = RGBToYCoCg(color);
|
||||
vec3 maxclr = minclr;
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
ivec2 texelCoordM = texelCoord + neighbourhoodOffsets[i];
|
||||
|
||||
float depthCheck = texelFetch(depthtex1, texelCoordM, 0).r;
|
||||
if (abs(GetLinearDepth(depthCheck) - GetLinearDepth(depth)) > 0.09) {
|
||||
edge = regularEdge;
|
||||
|
||||
if (int(texelFetch(colortex1, texelCoordM, 0).g * 255.1) == 253) // Reduced Edge TAA
|
||||
edge *= extraEdgeMult;
|
||||
}
|
||||
|
||||
#ifndef LIGHT_COLORING
|
||||
vec3 clr = texelFetch(colortex3, texelCoordM, 0).rgb;
|
||||
#else
|
||||
vec3 clr = texelFetch(colortex8, texelCoordM, 0).rgb;
|
||||
#endif
|
||||
clr = RGBToYCoCg(clr);
|
||||
minclr = min(minclr, clr); maxclr = max(maxclr, clr);
|
||||
}
|
||||
|
||||
tempColor = RGBToYCoCg(tempColor);
|
||||
tempColor = ClipAABB(tempColor, minclr, maxclr);
|
||||
tempColor = YCoCgToRGB(tempColor);
|
||||
}
|
||||
|
||||
void DoTAA(inout vec3 color, inout vec3 temp, float depth) {
|
||||
int materialMask = int(texelFetch(colortex1, texelCoord, 0).g * 255.1);
|
||||
|
||||
if (materialMask == 254) { // No SSAO, No TAA
|
||||
int i = 0;
|
||||
while (i < 4) {
|
||||
int mms = int(texelFetch(colortex1, texelCoord + neighbourhoodOffsets[i], 0).g * 255.1);
|
||||
if (mms != materialMask) break;
|
||||
i++;
|
||||
} // Checking edge-pixels prevents flickering
|
||||
if (i == 4) return;
|
||||
}
|
||||
|
||||
#ifndef TEMPORAL_FILTER
|
||||
depth = texelFetch(depthtex1, texelCoord, 0).r;
|
||||
#endif
|
||||
|
||||
#if defined CUSTOM_PBR || defined IPBR && defined IS_IRIS
|
||||
if (depth <= 0.56) return; // materialMask might be occupied, so we do the check manually
|
||||
#endif
|
||||
|
||||
vec3 coord = vec3(texCoord, depth);
|
||||
vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
vec2 prvCoord = Reprojection(coord, cameraOffset);
|
||||
|
||||
vec2 view = vec2(viewWidth, viewHeight);
|
||||
vec3 tempColor = texture2D(colortex2, prvCoord).rgb;
|
||||
if (tempColor == vec3(0.0)) { // Fixes the first frame
|
||||
temp = color;
|
||||
return;
|
||||
}
|
||||
|
||||
float edge = 0.0;
|
||||
NeighbourhoodClamping(color, tempColor, depth, edge);
|
||||
|
||||
if (materialMask == 253) // Reduced Edge TAA
|
||||
edge *= extraEdgeMult;
|
||||
|
||||
vec2 velocity = (texCoord - prvCoord.xy) * view;
|
||||
float blendFactor = float(prvCoord.x > 0.0 && prvCoord.x < 1.0 &&
|
||||
prvCoord.y > 0.0 && prvCoord.y < 1.0);
|
||||
//float blendMinimum = 0.6;
|
||||
//float blendVariable = 0.5;
|
||||
//float blendConstant = 0.4;
|
||||
float blendMinimum = 0.3;
|
||||
float blendVariable = 0.2;
|
||||
float blendConstant = 0.7;
|
||||
float velocityFactor = dot(velocity, velocity) * 10.0;
|
||||
blendFactor *= max(exp(-velocityFactor) * blendVariable + blendConstant - length(cameraOffset) * edge, blendMinimum);
|
||||
|
||||
#ifdef IS_IRIS
|
||||
if (lightning > 0.0) blendFactor = 0.0;
|
||||
#else
|
||||
if (lightningFlashOptifine > 0.0) blendFactor = 0.0;
|
||||
#endif
|
||||
|
||||
color = mix(color, tempColor, blendFactor);
|
||||
temp = color;
|
||||
|
||||
//if (edge > 0.05) color.rgb = vec3(1.0, 0.0, 1.0);
|
||||
}
|
||||
@ -0,0 +1,65 @@
|
||||
vec3 GetAuroraBorealis(vec3 viewPos, float VdotU, float dither) {
|
||||
float visibility = sqrt1(clamp01(VdotU * 1.5 - 0.225)) - sunVisibility;
|
||||
visibility -= mix(0.0, rainFactor, heightRelativeToCloud);
|
||||
visibility *= 1.0 - VdotU * 0.9;
|
||||
|
||||
#if AURORA_CONDITION == 1 || AURORA_CONDITION == 3
|
||||
visibility -= moonPhase;
|
||||
#endif
|
||||
#if AURORA_CONDITION == 2 || AURORA_CONDITION == 3
|
||||
visibility *= inSnowy;
|
||||
#endif
|
||||
#if AURORA_CONDITION == 4
|
||||
visibility = max(visibility * inSnowy, visibility - moonPhase);
|
||||
#endif
|
||||
|
||||
if (visibility > 0.0) {
|
||||
if (max(blindness, darknessFactor) > 0.1) return vec3(0.0);
|
||||
|
||||
vec3 aurora = vec3(0.0);
|
||||
|
||||
vec3 wpos = (gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz;
|
||||
wpos.xz /= wpos.y;
|
||||
vec2 cameraPositionM = cameraPosition.xz * 0.0075;
|
||||
cameraPositionM.x += syncedTime * 0.04;
|
||||
|
||||
int sampleCount = 25;
|
||||
int sampleCountP = sampleCount + 5;
|
||||
float ditherM = dither + 5.0;
|
||||
float auroraAnimate = frameTimeCounter * 0.001;
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float current = pow2((i + ditherM) / sampleCountP);
|
||||
|
||||
vec2 planePos = wpos.xz * (0.8 + current) * 11.0 + cameraPositionM;
|
||||
#if AURORA_STYLE == 1
|
||||
planePos = floor(planePos) * 0.0007;
|
||||
|
||||
float noise = texture2D(noisetex, planePos).b;
|
||||
noise = pow2(pow2(pow2(pow2(1.0 - 2.0 * abs(noise - 0.5)))));
|
||||
|
||||
noise *= pow1_5(texture2D(noisetex, planePos * 100.0 + auroraAnimate).b);
|
||||
#else
|
||||
planePos *= 0.0007;
|
||||
|
||||
float noise = texture2D(noisetex, planePos).r;
|
||||
noise = pow2(pow2(pow2(pow2(1.0 - 2.0 * abs(noise - 0.5)))));
|
||||
|
||||
noise *= texture2D(noisetex, planePos * 3.0 + auroraAnimate).b;
|
||||
noise *= texture2D(noisetex, planePos * 5.0 - auroraAnimate).b;
|
||||
#endif
|
||||
|
||||
float currentM = 1.0 - current;
|
||||
aurora += noise * currentM * mix(vec3(0.0, 7.0, 7.0), vec3(20.0, 0.0, 0.0), pow2(pow2(currentM)));
|
||||
}
|
||||
|
||||
#if AURORA_STYLE == 1
|
||||
aurora *= 1.3;
|
||||
#else
|
||||
aurora *= 1.8;
|
||||
#endif
|
||||
|
||||
return aurora * visibility / sampleCount;
|
||||
}
|
||||
|
||||
return vec3(0.0);
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
const float cloudNarrowness = 0.05;
|
||||
|
||||
#ifdef DEFERRED1
|
||||
const float cloudRoundness = 0.125; // for clouds
|
||||
#else
|
||||
const float cloudRoundness = 0.35; // for cloud shadows
|
||||
#endif
|
||||
|
||||
vec2 GetRoundedCloudCoord(vec2 pos) { // Thanks to SixthSurge
|
||||
vec2 coord = pos.xy + 0.5;
|
||||
vec2 signCoord = sign(coord);
|
||||
coord = abs(coord) + 1.0;
|
||||
vec2 i, f = modf(coord, i);
|
||||
f = smoothstep(0.5 - cloudRoundness, 0.5 + cloudRoundness, f);
|
||||
coord = i + f;
|
||||
return (coord - 0.5) * signCoord / 256.0;
|
||||
}
|
||||
|
||||
vec3 ModifyTracePos(vec3 tracePos, int cloudAltitude) {
|
||||
#if CLOUD_SPEED_MULT == 100
|
||||
float wind = syncedTime;
|
||||
#else
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
float wind = frameTimeCounter * CLOUD_SPEED_MULT_M;
|
||||
#endif
|
||||
tracePos.x += wind;
|
||||
tracePos.z += cloudAltitude * 64.0;
|
||||
tracePos.xz *= cloudNarrowness;
|
||||
return tracePos.xyz;
|
||||
}
|
||||
@ -0,0 +1,90 @@
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/spookylib/colors/cloudColors.glsl"
|
||||
#include "/spookylib/atmospherics/sky.glsl"
|
||||
|
||||
float InterleavedGradientNoise() {
|
||||
float n = 52.9829189 * fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y);
|
||||
#ifdef TAA
|
||||
return fract(n + 1.61803398875 * mod(float(frameCounter), 3600.0));
|
||||
#else
|
||||
return fract(n);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef REALTIME_SHADOWS
|
||||
vec3 GetShadowOnCloudPosition(vec3 tracePos) {
|
||||
vec3 wpos = PlayerToShadow(tracePos - cameraPosition);
|
||||
float distb = sqrt(wpos.x * wpos.x + wpos.y * wpos.y);
|
||||
float distortFactor = 1.0 - shadowMapBias + distb * shadowMapBias;
|
||||
vec3 shadowPosition = vec3(vec2(wpos.xy / distortFactor), wpos.z * 0.2);
|
||||
return shadowPosition * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
bool GetShadowOnCloud(vec3 tracePos, int cloudAltitude, float lowerPlaneAltitude, float higherPlaneAltitude) {
|
||||
const float cloudShadowOffset = 0.5;
|
||||
|
||||
vec3 shadowPosition0 = GetShadowOnCloudPosition(tracePos);
|
||||
if (length(shadowPosition0.xy * 2.0 - 1.0) < 1.0) {
|
||||
float shadowsample0 = shadow2D(shadowtex0, shadowPosition0).z;
|
||||
|
||||
if (shadowsample0 == 0.0) return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
#include "/spookylib/atmospherics/clouds/reimaginedClouds.glsl"
|
||||
#endif
|
||||
#ifdef CLOUDS_UNBOUND
|
||||
#include "/spookylib/atmospherics/clouds/unboundClouds.glsl"
|
||||
#endif
|
||||
|
||||
vec4 GetClouds(inout float cloudLinearDepth, float skyFade, vec3 playerPos, vec3 viewPos, float lViewPos, float VdotS, float VdotU, float dither) {
|
||||
vec4 clouds = vec4(0.0);
|
||||
|
||||
vec3 nPlayerPos = normalize(playerPos);
|
||||
float lViewPosM = lViewPos < far * 1.5 ? lViewPos - 1.0 : 1000000000.0;
|
||||
float skyMult0 = pow2(skyFade * 3.333333 - 2.333333);
|
||||
#if BLOOD_MOON > 0
|
||||
cloudAmbientColor *= mix(vec3(1.0), vec3(1.0, 0.0, 0.0) * 20.0, getBloodMoon(moonPhase, sunVisibility));
|
||||
#endif
|
||||
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
cloudAmbientColor *= 1.0 - 0.25 * rainFactor;
|
||||
|
||||
const float threshold1 = 1000.0;
|
||||
const float threshold2 = 1000.0;
|
||||
|
||||
#ifndef DOUBLE_REIM_CLOUDS
|
||||
clouds =
|
||||
GetVolumetricClouds(cloudAlt1i, threshold1, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
#else
|
||||
int maxCloudAlt = max(cloudAlt1i, cloudAlt2i);
|
||||
int minCloudAlt = min(cloudAlt1i, cloudAlt2i);
|
||||
|
||||
if (abs(cameraPosition.y - minCloudAlt) < abs(cameraPosition.y - maxCloudAlt)) {
|
||||
clouds =
|
||||
GetVolumetricClouds(minCloudAlt, threshold1, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
if (clouds.a == 0.0) clouds =
|
||||
GetVolumetricClouds(maxCloudAlt, threshold2, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
} else {
|
||||
clouds =
|
||||
GetVolumetricClouds(maxCloudAlt, threshold2, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
if (clouds.a == 0.0) clouds =
|
||||
GetVolumetricClouds(minCloudAlt, threshold1, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef CLOUDS_UNBOUND
|
||||
float thresholdMix = pow2(clamp01(VdotU * 5.0));
|
||||
float thresholdF = mix(far, 1000.0, thresholdMix * 0.5 + 0.5);
|
||||
|
||||
clouds =
|
||||
GetVolumetricClouds(cloudAlt1i, thresholdF, cloudLinearDepth, skyFade, skyMult0, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
#endif
|
||||
|
||||
return clouds;
|
||||
}
|
||||
@ -0,0 +1,117 @@
|
||||
#include "/spookylib/atmospherics/clouds/cloudCoord.glsl"
|
||||
|
||||
const float cloudStretch = 5.5;
|
||||
const float cloudHeightShader = cloudStretch * 2.0;
|
||||
|
||||
bool GetCloudNoise(vec3 tracePos, inout vec3 tracePosM, int cloudAltitude) {
|
||||
tracePosM = ModifyTracePos(tracePos, cloudAltitude);
|
||||
vec2 coord = GetRoundedCloudCoord(tracePosM.xz);
|
||||
float noise = texture2D(colortex3, coord).b;
|
||||
|
||||
float threshold = clamp(abs(cloudAltitude - tracePos.y) / cloudStretch, 0.001, 0.999);
|
||||
threshold = pow2(pow2(pow2(threshold)));
|
||||
return noise > threshold * 0.5 + 0.25;
|
||||
}
|
||||
|
||||
vec4 GetVolumetricClouds(int cloudAltitude, float distanceThreshold, inout float cloudLinearDepth, float skyFade, float skyMult0, vec3 nPlayerPos, float lViewPosM, float VdotS, float VdotU, float dither) {
|
||||
vec4 volumetricClouds = vec4(0.0);
|
||||
|
||||
float higherPlaneAltitude = cloudAltitude + cloudStretch;
|
||||
float lowerPlaneAltitude = cloudAltitude - cloudStretch;
|
||||
|
||||
float lowerPlaneDistance = (lowerPlaneAltitude - cameraPosition.y) / nPlayerPos.y;
|
||||
float higherPlaneDistance = (higherPlaneAltitude - cameraPosition.y) / nPlayerPos.y;
|
||||
float minPlaneDistance = min(lowerPlaneDistance, higherPlaneDistance);
|
||||
minPlaneDistance = max(minPlaneDistance, 0.0);
|
||||
float maxPlaneDistance = max(lowerPlaneDistance, higherPlaneDistance);
|
||||
if (maxPlaneDistance < 0.0) return vec4(0.0);
|
||||
float planeDistanceDif = maxPlaneDistance - minPlaneDistance;
|
||||
|
||||
#if CLOUD_QUALITY == 1
|
||||
int sampleCount = max(int(planeDistanceDif) / 16, 6);
|
||||
#elif CLOUD_QUALITY == 2
|
||||
int sampleCount = max(int(planeDistanceDif) / 8, 12);
|
||||
#elif CLOUD_QUALITY == 3
|
||||
int sampleCount = max(int(planeDistanceDif), 12);
|
||||
#endif
|
||||
|
||||
float stepMult = planeDistanceDif / sampleCount;
|
||||
vec3 traceAdd = nPlayerPos * stepMult;
|
||||
vec3 tracePos = cameraPosition + minPlaneDistance * nPlayerPos;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos.y -= traceAdd.y;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
vec3 cloudPlayerPos = tracePos - cameraPosition;
|
||||
float lTracePos = length(cloudPlayerPos);
|
||||
float lTracePosXZ = length(cloudPlayerPos.xz);
|
||||
float cloudMult = 1.0;
|
||||
if (lTracePosXZ > distanceThreshold) break;
|
||||
if (lTracePos > lViewPosM) {
|
||||
if (skyFade < 0.7) continue;
|
||||
else cloudMult = skyMult0;
|
||||
}
|
||||
|
||||
vec3 tracePosM;
|
||||
if (GetCloudNoise(tracePos, tracePosM, cloudAltitude)) {
|
||||
float lightMult = 1.0;
|
||||
|
||||
#ifdef REALTIME_SHADOWS
|
||||
if (GetShadowOnCloud(tracePos, cloudAltitude, lowerPlaneAltitude, higherPlaneAltitude)) {
|
||||
#ifdef CLOUD_CLOSED_AREA_CHECK
|
||||
if (eyeBrightness.y != 240) continue;
|
||||
else
|
||||
#endif
|
||||
lightMult = 0.25;
|
||||
}
|
||||
#endif
|
||||
|
||||
float cloudShading = 1.0 - (higherPlaneAltitude - tracePos.y) / cloudHeightShader;
|
||||
float VdotSM1 = max0(sunVisibility > 0.5 ? VdotS : - VdotS);
|
||||
|
||||
#if CLOUD_QUALITY >= 2
|
||||
float cloudShadingM = 1.0 - pow2(cloudShading);
|
||||
|
||||
float gradientNoise = InterleavedGradientNoise();
|
||||
|
||||
vec3 cLightPos = tracePosM;
|
||||
vec3 cLightPosAdd = normalize(ViewToPlayer(lightVec * 1000000000.0)) * vec3(0.08);
|
||||
cLightPosAdd *= shadowTime;
|
||||
|
||||
float light = 2.0;
|
||||
cLightPos += (1.0 + gradientNoise) * cLightPosAdd;
|
||||
light -= texture2D(colortex3, GetRoundedCloudCoord(cLightPos.xz)).b * cloudShadingM;
|
||||
cLightPos += gradientNoise * cLightPosAdd;
|
||||
light -= texture2D(colortex3, GetRoundedCloudCoord(cLightPos.xz)).b * cloudShadingM;
|
||||
|
||||
float VdotSM2 = VdotSM1 * shadowTime * 0.25;
|
||||
VdotSM2 += 0.5 * cloudShading + 0.08;
|
||||
cloudShading = VdotSM2 * light * lightMult;
|
||||
#endif
|
||||
|
||||
vec3 colorSample = cloudAmbientColor + cloudLightColor * (0.07 + cloudShading);
|
||||
#ifdef IS_IRIS
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, lightningBoltPosition.xyz, vec3(1.0), 450.0) * lightningBoltPosition.w * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#else
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, vec3(0.0, exp(1.0) - 1000.0, 0.0), vec3(1.0), 450.0) * lightningFlashOptifine * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#endif
|
||||
vec3 cloudSkyColor = GetSky(VdotU, VdotS, dither, true, false);
|
||||
float cloudFogFactor = clamp((distanceThreshold - lTracePosXZ) / distanceThreshold, 0.0, 0.75);
|
||||
float skyMult1 = 1.0 - 0.2 * (1.0 - skyFade) * max(sunVisibility2, nightFactor);
|
||||
float skyMult2 = 1.0 - 0.33333 * skyFade;
|
||||
colorSample = mix(cloudSkyColor, colorSample * skyMult1, cloudFogFactor * skyMult2);
|
||||
colorSample *= pow2(1.0 - max(blindness, darknessFactor));
|
||||
|
||||
cloudLinearDepth = sqrt(lTracePos / far);
|
||||
volumetricClouds.a = pow(cloudFogFactor * 1.33333, 0.5 + 10.0 * pow(abs(VdotSM1), 90.0)) * cloudMult;
|
||||
volumetricClouds.rgb = colorSample;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return volumetricClouds;
|
||||
}
|
||||
@ -0,0 +1,191 @@
|
||||
#if CLOUD_UNBOUND_SIZE_MULT != 100
|
||||
#define CLOUD_UNBOUND_SIZE_MULT_M CLOUD_UNBOUND_SIZE_MULT * 0.01
|
||||
#endif
|
||||
|
||||
#if CLOUD_QUALITY == 1
|
||||
const float cloudStretchRaw = 11.0;
|
||||
#elif CLOUD_QUALITY == 2
|
||||
const float cloudStretchRaw = 16.0;
|
||||
#elif CLOUD_QUALITY == 3
|
||||
const float cloudStretchRaw = 18.0;
|
||||
#endif
|
||||
#if CLOUD_UNBOUND_SIZE_MULT <= 100
|
||||
const float cloudStretch = cloudStretchRaw;
|
||||
#else
|
||||
const float cloudStretch = cloudStretchRaw / float(CLOUD_UNBOUND_SIZE_MULT_M);
|
||||
#endif
|
||||
|
||||
const float cloudHeightShader = cloudStretch * 2.0;
|
||||
|
||||
float Noise3D(vec3 p) {
|
||||
p.z = fract(p.z) * 128.0;
|
||||
float iz = floor(p.z);
|
||||
float fz = fract(p.z);
|
||||
vec2 a_off = vec2(23.0, 29.0) * (iz) / 128.0;
|
||||
vec2 b_off = vec2(23.0, 29.0) * (iz + 1.0) / 128.0;
|
||||
float a = texture2D(noisetex, p.xy + a_off).r;
|
||||
float b = texture2D(noisetex, p.xy + b_off).r;
|
||||
return mix(a, b, fz);
|
||||
}
|
||||
|
||||
float GetCloudNoise(vec3 tracePos, int cloudAltitude, float lTracePosXZ, float cloudPlayerPosY) {
|
||||
vec3 tracePosM = tracePos.xyz * 0.00016;
|
||||
float wind = 0.0006;
|
||||
float noise = 0.0;
|
||||
float currentPersist = 1.0;
|
||||
float total = 0.0;
|
||||
|
||||
#if CLOUD_SPEED_MULT == 100
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
wind *= syncedTime;
|
||||
#else
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
wind *= frameTimeCounter * CLOUD_SPEED_MULT_M;
|
||||
#endif
|
||||
#if CLOUD_UNBOUND_SIZE_MULT != 100
|
||||
tracePosM *= CLOUD_UNBOUND_SIZE_MULT_M;
|
||||
wind *= CLOUD_UNBOUND_SIZE_MULT_M;
|
||||
#endif
|
||||
|
||||
#if CLOUD_QUALITY == 1
|
||||
int sampleCount = 2;
|
||||
float persistance = 0.6;
|
||||
float noiseMult = 0.95;
|
||||
tracePosM *= 0.5; wind *= 0.5;
|
||||
#elif CLOUD_QUALITY == 2
|
||||
int sampleCount = 4;
|
||||
float persistance = 0.5;
|
||||
float noiseMult = 1.07;
|
||||
#elif CLOUD_QUALITY == 3
|
||||
int sampleCount = 4;
|
||||
float persistance = 0.5;
|
||||
float noiseMult = 1.0;
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
#if CLOUD_QUALITY >= 2
|
||||
noise += Noise3D(tracePosM + vec3(wind, 0.0, 0.0)) * currentPersist;
|
||||
#else
|
||||
noise += texture2D(noisetex, tracePosM.xz + vec2(wind, 0.0)).b * currentPersist;
|
||||
#endif
|
||||
total += currentPersist;
|
||||
|
||||
tracePosM *= 3.0;
|
||||
wind *= 0.5;
|
||||
currentPersist *= persistance;
|
||||
}
|
||||
noise = pow2(noise / total);
|
||||
noiseMult *= 0.65 + 0.01 * sqrt(lTracePosXZ + 10.0) // more clouds far away
|
||||
+ 0.1 * clamp01(-cloudPlayerPosY / cloudHeightShader) // more clouds when camera is above them
|
||||
+ 0.4 * rainFactor + 0.5 ; // more clouds during rain
|
||||
noise *= noiseMult * CLOUD_UNBOUND_AMOUNT;
|
||||
|
||||
float threshold = clamp(abs(cloudAltitude - tracePos.y) / cloudStretch, 0.001, 0.999);
|
||||
threshold = pow2(pow2(pow2(threshold)));
|
||||
return noise - (threshold * 0.2 + 0.25);
|
||||
}
|
||||
|
||||
vec4 GetVolumetricClouds(int cloudAltitude, float distanceThreshold, inout float cloudLinearDepth, float skyFade, float skyMult0, vec3 nPlayerPos, float lViewPosM, float VdotS, float VdotU, float dither) {
|
||||
vec4 volumetricClouds = vec4(0.0);
|
||||
|
||||
float higherPlaneAltitude = cloudAltitude + cloudStretch;
|
||||
float lowerPlaneAltitude = cloudAltitude - cloudStretch;
|
||||
|
||||
float lowerPlaneDistance = (lowerPlaneAltitude - cameraPosition.y) / nPlayerPos.y;
|
||||
float higherPlaneDistance = (higherPlaneAltitude - cameraPosition.y) / nPlayerPos.y;
|
||||
float minPlaneDistance = min(lowerPlaneDistance, higherPlaneDistance);
|
||||
minPlaneDistance = max(minPlaneDistance, 0.0);
|
||||
float maxPlaneDistance = max(lowerPlaneDistance, higherPlaneDistance);
|
||||
if (maxPlaneDistance < 0.0) return vec4(0.0);
|
||||
float planeDistanceDif = maxPlaneDistance - minPlaneDistance;
|
||||
|
||||
#if CLOUD_QUALITY == 1
|
||||
float stepMult = 16.0;
|
||||
#elif CLOUD_QUALITY == 2
|
||||
float stepMult = 24.0;
|
||||
#elif CLOUD_QUALITY == 3
|
||||
float stepMult = 16.0;
|
||||
#endif
|
||||
|
||||
#if CLOUD_UNBOUND_SIZE_MULT > 100
|
||||
stepMult = stepMult / sqrt(float(CLOUD_UNBOUND_SIZE_MULT_M));
|
||||
#endif
|
||||
|
||||
int sampleCount = int(planeDistanceDif / stepMult + dither + 1);
|
||||
vec3 traceAdd = nPlayerPos * stepMult;
|
||||
vec3 tracePos = cameraPosition + minPlaneDistance * nPlayerPos;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos.y -= traceAdd.y;
|
||||
|
||||
float firstHitPos = 0.0;
|
||||
float VdotSM1 = max0(sunVisibility > 0.5 ? VdotS : - VdotS);
|
||||
float VdotSM1M = VdotSM1 * invRainFactor;
|
||||
float VdotSM2 = pow2(VdotSM1) * abs(sunVisibility - 0.5) * 2.0;
|
||||
float VdotSM3 = VdotSM2 * (2.5 + rainFactor) + 1.5 * rainFactor;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
if (abs(tracePos.y - cloudAltitude) > cloudStretch) break;
|
||||
|
||||
vec3 cloudPlayerPos = tracePos - cameraPosition;
|
||||
float lTracePos = length(cloudPlayerPos);
|
||||
float lTracePosXZ = length(cloudPlayerPos.xz);
|
||||
float cloudMult = 1.0;
|
||||
if (lTracePosXZ > distanceThreshold) break;
|
||||
if (lTracePos > lViewPosM) {
|
||||
if (skyFade < 0.7) continue;
|
||||
else cloudMult = skyMult0;
|
||||
}
|
||||
|
||||
float cloudNoise = GetCloudNoise(tracePos, cloudAltitude, lTracePosXZ, cloudPlayerPos.y);
|
||||
|
||||
if (cloudNoise > 0.00001) {
|
||||
#if defined CLOUD_CLOSED_AREA_CHECK && defined REALTIME_SHADOWS
|
||||
if (GetShadowOnCloud(tracePos, cloudAltitude, lowerPlaneAltitude, higherPlaneAltitude)) {
|
||||
if (eyeBrightness.y != 240) continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (firstHitPos < 1.0) {
|
||||
firstHitPos = lTracePos;
|
||||
#if CLOUD_QUALITY == 1
|
||||
tracePos.y += 4.0 * (texture2D(noisetex, tracePos.xz * 0.001).r - 0.5);
|
||||
#endif
|
||||
}
|
||||
|
||||
float opacityFactor = min1(cloudNoise * 8.0);
|
||||
|
||||
float cloudShading = 1.0 - (higherPlaneAltitude - tracePos.y) / cloudHeightShader;
|
||||
cloudShading *= 1.0 + 0.75 * VdotSM3 * (1.0 - opacityFactor);
|
||||
|
||||
vec3 colorSample = cloudAmbientColor * (0.7 + 0.3 * cloudShading) + cloudLightColor * cloudShading;
|
||||
//vec3 colorSample = 2.5 * cloudLightColor * pow2(cloudShading); // <-- Used this to take the Unbound logo
|
||||
#ifdef IS_IRIS
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, lightningBoltPosition.xyz, vec3(1.0), 400.0) * lightningBoltPosition.w * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#else
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, vec3(0.0, exp(1.0) - 1000.0, 0.0), vec3(1.0), 400.0) * lightningFlashOptifine * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#endif
|
||||
vec3 cloudSkyColor = GetSky(VdotU, VdotS, dither, true, false);
|
||||
float cloudFogFactor = clamp((distanceThreshold - lTracePosXZ) / distanceThreshold, 0.0, 0.8) * 1.25;
|
||||
float skyMult1 = 1.0 - 0.2 * (1.0 - skyFade) * max(sunVisibility2, nightFactor);
|
||||
float skyMult2 = 1.0 - 0.33333 * skyFade;
|
||||
colorSample = mix(cloudSkyColor, colorSample * skyMult1, cloudFogFactor * skyMult2 * 0.72);
|
||||
colorSample *= pow2(1.0 - max(blindness, darknessFactor));
|
||||
|
||||
volumetricClouds.rgb = mix(volumetricClouds.rgb, colorSample, 1.0 - min1(volumetricClouds.a));
|
||||
volumetricClouds.a += opacityFactor * pow(cloudFogFactor, 0.5 + 10.0 * pow(abs(VdotSM1M), 90.0)) * cloudMult;
|
||||
|
||||
if (volumetricClouds.a > 0.9) {
|
||||
volumetricClouds.a = 1.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (volumetricClouds.a > 0.5) cloudLinearDepth = sqrt(firstHitPos / far);
|
||||
|
||||
return volumetricClouds;
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
#ifndef INCLUDE_ENDERBEAMS
|
||||
#define INCLUDE_ENDERBEAMS
|
||||
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
vec3 endOrangeCol = vec3(1.0, 0.3, 0.0);
|
||||
vec3 beamPurple = normalize(ambientColor * ambientColor * ambientColor) * (2.5 - 1.0 * vlFactor);
|
||||
vec3 beamOrange = endOrangeCol * (300.0 + 700.0 * vlFactor);
|
||||
|
||||
vec2 wind = vec2(syncedTime * 0.00);
|
||||
|
||||
float BeamNoise(vec2 planeCoord, vec2 wind) {
|
||||
float noise = texture2D(noisetex, planeCoord * 0.175 - wind * 0.0625).b;
|
||||
noise+= texture2D(noisetex, planeCoord * 0.04375 + wind * 0.0375).b * 5.0;
|
||||
|
||||
return noise;
|
||||
}
|
||||
|
||||
vec3 DrawEnderBeams(float VdotU, vec3 playerPos) {
|
||||
int sampleCount = 8;
|
||||
|
||||
float VdotUM = 1.0 - VdotU * VdotU;
|
||||
float VdotUM2 = VdotUM + smoothstep1(pow2(pow2(1.0 - abs(VdotU)))) * 0.2;
|
||||
|
||||
vec4 beams = vec4(0.0);
|
||||
float gradientMix = 1.0;
|
||||
for(int i = 0; i < sampleCount; i++) {
|
||||
vec2 planeCoord = playerPos.xz + cameraPosition.xz;
|
||||
planeCoord *= (1.0 + i * 6.0 / sampleCount) * 0.0014;
|
||||
|
||||
float noise = BeamNoise(planeCoord, wind);
|
||||
noise = max(0.75 - 1.0 / abs(noise - (4.0 + VdotUM * 2.0)), 0.0) * 3.0;
|
||||
|
||||
if (noise > 0.0) {
|
||||
noise *= 0.65;
|
||||
float fireNoise = texture2D(noisetex, abs(planeCoord * 0.2) - wind).b;
|
||||
noise *= 0.5 * fireNoise + 0.75;
|
||||
noise = noise * noise * 3.0 / sampleCount;
|
||||
noise *= VdotUM2;
|
||||
|
||||
vec3 beamColor = beamPurple;
|
||||
beamColor += beamOrange * pow2(pow2(fireNoise - 0.5));
|
||||
beamColor *= gradientMix / sampleCount;
|
||||
|
||||
noise *= exp2(-6.0 * i / float(sampleCount));
|
||||
beams += vec4(noise * beamColor, noise);
|
||||
}
|
||||
gradientMix += 1.0;
|
||||
}
|
||||
|
||||
#ifdef IS_IRIS
|
||||
beams.rgb += 0.2 * lightningBoltPosition.w;
|
||||
#else
|
||||
beams.rgb += 0.3 * lightningFlashOptifine;
|
||||
#endif
|
||||
|
||||
beams.rgb *= beams.a * beams.a * beams.a * 3.5;
|
||||
beams.rgb = sqrt(beams.rgb);
|
||||
|
||||
return beams.rgb;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,29 @@
|
||||
float GetEnderStarNoise(vec2 pos) {
|
||||
return fract(sin(dot(pos, vec2(12.9898, 4.1414))) * 43758.54953);
|
||||
}
|
||||
|
||||
vec3 GetEnderStars(vec3 viewPos, float VdotU) {
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * 1000.0, 1.0)).xyz);
|
||||
|
||||
vec3 starCoord = 0.65 * wpos / (abs(wpos.y) + length(wpos.xz));
|
||||
vec2 starCoord2 = starCoord.xz * 0.5;
|
||||
if (VdotU < 0.0) starCoord2 += 100.0;
|
||||
float starFactor = 1024.0;
|
||||
starCoord2 = floor(starCoord2 * starFactor) / starFactor;
|
||||
|
||||
float star = 1.0;
|
||||
star *= GetEnderStarNoise(starCoord2.xy);
|
||||
star *= GetEnderStarNoise(starCoord2.xy+0.1);
|
||||
star *= GetEnderStarNoise(starCoord2.xy+0.23);
|
||||
star = max(star - 0.7, 0.0);
|
||||
star *= star;
|
||||
|
||||
vec3 enderStars = star * endSkyColor * 3000.0;
|
||||
|
||||
float VdotUM1 = abs(VdotU);
|
||||
float VdotUM2 = pow2(1.0 - VdotUM1);
|
||||
enderStars *= VdotUM1 * VdotUM1 * (VdotUM2 + 0.015) + 0.015;
|
||||
//if (gl_FragCoord.x > 960.0) enderStars = vec3(VdotUM1); else enderStars = vec3(VdotUM2);
|
||||
|
||||
return enderStars;
|
||||
}
|
||||
@ -0,0 +1,41 @@
|
||||
#ifdef CAVE_FOG
|
||||
#include "/spookylib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
const float rainBloomAdd = 8.0;
|
||||
const float nightBloomAdd = 3.0;
|
||||
const float caveBloomAdd = 10.0;
|
||||
const float waterBloomAdd = 14.0;
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
const float netherBloomAdd = 14.0;
|
||||
#else
|
||||
const float netherBloomAdd = 3.0;
|
||||
#endif
|
||||
|
||||
float GetBloomFog(float lViewPos) {
|
||||
#ifdef OVERWORLD
|
||||
float bloomFog = pow2(pow2(1.0 - exp(- lViewPos * (0.02 + 0.04 * float(isEyeInWater == 1)))));
|
||||
|
||||
float bloomFogMult;
|
||||
if (isEyeInWater != 1) {
|
||||
bloomFogMult = (rainFactor2 * rainBloomAdd + nightBloomAdd * (1.0 - sunFactor)) * eyeBrightnessM;
|
||||
#ifdef CAVE_FOG
|
||||
bloomFogMult += GetCaveFactor() * caveBloomAdd;
|
||||
#endif
|
||||
} else {
|
||||
bloomFogMult = waterBloomAdd;
|
||||
}
|
||||
#elif defined NETHER
|
||||
float bloomFog = lViewPos / clamp(far, 128.0, 256.0); // consistency9023HFUE85JG
|
||||
bloomFog *= bloomFog * bloomFog;
|
||||
bloomFog = 1.0 - exp(-8.0 * bloomFog);
|
||||
bloomFog *= float(isEyeInWater == 0);
|
||||
|
||||
float bloomFogMult = netherBloomAdd;
|
||||
#endif
|
||||
|
||||
bloomFogMult *= BLOOM_STRENGTH * 8.33333;
|
||||
|
||||
return 1.0 + bloomFog * bloomFogMult;
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
#ifndef INCLUDE_CAVE_FACTOR
|
||||
#define INCLUDE_CAVE_FACTOR
|
||||
float GetCaveFactor() {
|
||||
return clamp(1.0 - cameraPosition.y / oceanAltitude, 0.0, 1.0 - eyeBrightnessM);
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,192 @@
|
||||
#include "/spookylib/colors/colorMultipliers.glsl"
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
#ifdef OVERWORLD
|
||||
#include "/spookylib/atmospherics/sky.glsl"
|
||||
#elif defined NETHER
|
||||
#include "/spookylib/colors/skyColors.glsl"
|
||||
#endif
|
||||
|
||||
void DoBorderFog(inout vec3 color, inout float skyFade, float lPlayerPosXZ, float VdotU, float VdotS, float dither) {
|
||||
#if defined OVERWORLD || defined END
|
||||
float fog = lPlayerPosXZ / far;
|
||||
fog *= fog;
|
||||
fog = 1.0 - exp(-3.0 * fog);
|
||||
#endif
|
||||
#ifdef NETHER
|
||||
float farM = min(far, 256.0); // consistency9023HFUE85JG
|
||||
float fog = lPlayerPosXZ / farM;
|
||||
fog = pow(fog, 2.0 - farM / 256.0);
|
||||
#endif
|
||||
|
||||
if (fog > 0.0) {
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 fogColorM = GetSky(VdotU, VdotS, dither, true, false);
|
||||
#elif defined NETHER
|
||||
vec3 fogColorM = netherColor;
|
||||
#else
|
||||
vec3 fogColorM = endSkyColor;
|
||||
#endif
|
||||
|
||||
fogColorM *= atmColorMult;
|
||||
|
||||
color = mix(color, fogColorM, fog);
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
skyFade = fog;
|
||||
#else
|
||||
skyFade = fog * (1.0 - isEyeInWater);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/spookylib/atmospherics/fog/caveFactor.glsl"
|
||||
|
||||
void DoCaveFog(inout vec3 color, float lViewPos) {
|
||||
float fog = GetCaveFactor() * (0.9 - 0.9 * exp(- lViewPos * 0.015));
|
||||
|
||||
color = mix(color, caveFogColor, fog);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef ATMOSPHERIC_FOG
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/spookylib/colors/skyColors.glsl"
|
||||
|
||||
// SRATA: Atm. fog starts reducing above this altitude
|
||||
// CRFTM: Atm. fog continues reducing for this meters
|
||||
#ifdef OVERWORLD
|
||||
#define atmFogSRATA ATM_FOG_ALTITUDE + 0.1
|
||||
float atmFogCRFTM = 60.0;
|
||||
#else
|
||||
float atmFogSRATA = 55.1;
|
||||
float atmFogCRFTM = 30.0;
|
||||
#endif
|
||||
|
||||
float GetAtmFogAltitudeFactor(float altitude) {
|
||||
float altitudeFactor = pow2(1.0 - clamp(altitude - atmFogSRATA, 0.0, atmFogCRFTM) / atmFogCRFTM);
|
||||
#ifndef LIGHTSHAFTS_ACTIVE
|
||||
altitudeFactor = mix(altitudeFactor, 1.0, rainFactor * 0.2);
|
||||
#endif
|
||||
return altitudeFactor;
|
||||
}
|
||||
|
||||
void DoAtmosphericFog(inout vec3 color, vec3 playerPos, float lViewPos, float VdotS) {
|
||||
float renDisFactor = min1(192.0 / far);
|
||||
|
||||
#if ATM_FOG_DISTANCE != 100
|
||||
#define ATM_FOG_DISTANCE_M 100.0 / ATM_FOG_DISTANCE;
|
||||
renDisFactor *= ATM_FOG_DISTANCE_M;
|
||||
#endif
|
||||
|
||||
float fog = 1.0 - exp(-pow(lViewPos * (0.001 - 0.0007 * rainFactor), 2.0 - rainFactor2) * lViewPos * renDisFactor * 100.0);
|
||||
fog *= max(ATM_FOG_MULT, 1.0) - 0.1 - 0.15 * invRainFactor;
|
||||
|
||||
float altitudeFactorP = GetAtmFogAltitudeFactor(playerPos.y + cameraPosition.y);
|
||||
float altitudeFactor = altitudeFactorP;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
altitudeFactor *= 1.0 - 0.75 * GetAtmFogAltitudeFactor(cameraPosition.y) * invRainFactor;
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
fog *= 0.2 + 0.8 * sqrt2(eyeBrightnessM);
|
||||
fog *= 1.0 - GetCaveFactor();
|
||||
fog *= 1.5;
|
||||
fog *= mix(1.0, 0.6, rainFactor);
|
||||
#else
|
||||
fog *= eyeBrightnessM;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
fog *= altitudeFactor * 0.9 + 0.1;
|
||||
|
||||
if (fog > 0.0) {
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float nightFogMult = 2.5 - 0.625 * pow2(pow2(altitudeFactorP));
|
||||
float dayNightFogBlend = pow(invNightFactor, 4.0 - VdotS - 2.5 * sunVisibility2);
|
||||
vec3 fogColorM = mix(
|
||||
nightUpSkyColor * (nightFogMult - dayNightFogBlend * nightFogMult),
|
||||
dayDownSkyColor * (0.9 + 0.2 * noonFactor),
|
||||
dayNightFogBlend
|
||||
) * 0.5;
|
||||
#else
|
||||
vec3 fogColorM = endSkyColor;
|
||||
#endif
|
||||
|
||||
fogColorM *= atmColorMult;
|
||||
|
||||
color = mix(color, fogColorM, fog);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "/spookylib/atmospherics/fog/waterFog.glsl"
|
||||
|
||||
void DoWaterFog(inout vec3 color, float lViewPos) {
|
||||
float fog = GetWaterFog(lViewPos);
|
||||
|
||||
color = mix(color, waterFogColor, fog) * 0.7;
|
||||
}
|
||||
|
||||
void DoLavaFog(inout vec3 color, float lViewPos) {
|
||||
float fog = (lViewPos * 3.0 - gl_Fog.start) * gl_Fog.scale;
|
||||
|
||||
#ifdef LESS_LAVA_FOG
|
||||
fog = sqrt(fog) * 0.4;
|
||||
#endif
|
||||
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, fogColor * 5.0, fog);
|
||||
}
|
||||
|
||||
void DoPowderSnowFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos;
|
||||
fog *= fog;
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, fogColor, fog);
|
||||
}
|
||||
|
||||
void DoBlindnessFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos * 0.3 * blindness;
|
||||
fog *= fog;
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, vec3(0.0), fog);
|
||||
}
|
||||
|
||||
void DoDarknessFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos * 0.075 * darknessFactor;
|
||||
fog *= fog;
|
||||
fog *= fog;
|
||||
color *= exp(-fog);
|
||||
}
|
||||
|
||||
void DoFog(inout vec3 color, inout float skyFade, float lViewPos, vec3 playerPos, float VdotU, float VdotS, float dither) {
|
||||
#ifdef CAVE_FOG
|
||||
DoCaveFog(color, lViewPos);
|
||||
#endif
|
||||
#ifdef ATMOSPHERIC_FOG
|
||||
DoAtmosphericFog(color, playerPos, lViewPos, VdotS);
|
||||
#endif
|
||||
#ifdef BORDER_FOG
|
||||
DoBorderFog(color, skyFade, length(playerPos.xz), VdotU, VdotS, dither);
|
||||
#endif
|
||||
|
||||
if (isEyeInWater == 1) DoWaterFog(color, lViewPos);
|
||||
else if (isEyeInWater == 2) DoLavaFog(color, lViewPos);
|
||||
else if (isEyeInWater == 3) DoPowderSnowFog(color, lViewPos);
|
||||
|
||||
if (blindness > 0.00001) DoBlindnessFog(color, lViewPos);
|
||||
if (darknessFactor > 0.00001) DoDarknessFog(color, lViewPos);
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
#ifndef INCLUDE_WATER_FOG
|
||||
#define INCLUDE_WATER_FOG
|
||||
float GetWaterFog(float lViewPos) {
|
||||
#if WATER_FOG_MULT != 100
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
lViewPos *= WATER_FOG_MULT_M;
|
||||
#endif
|
||||
|
||||
#if LIGHTSHAFT_QUALI > 0 && defined REALTIME_SHADOWS
|
||||
float fog = lViewPos / 48.0;
|
||||
fog *= fog;
|
||||
#else
|
||||
float fog = lViewPos / 32.0;
|
||||
#endif
|
||||
|
||||
return 1.0 - exp(-fog);
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,91 @@
|
||||
float Noise3D(vec3 p) {
|
||||
p.z = fract(p.z) * 128.0;
|
||||
float iz = floor(p.z);
|
||||
float fz = fract(p.z);
|
||||
vec2 a_off = vec2(23.0, 29.0) * (iz) / 128.0;
|
||||
vec2 b_off = vec2(23.0, 29.0) * (iz + 1.0) / 128.0;
|
||||
float a = texture2D(noisetex, p.xy + a_off).r;
|
||||
float b = texture2D(noisetex, p.xy + b_off).r;
|
||||
return mix(a, b, fz);
|
||||
}
|
||||
|
||||
vec4 GetNetherStorm(vec3 color, vec3 translucentMult, vec3 playerPos, vec3 viewPos, float lViewPos, float lViewPos1, float dither) {
|
||||
vec4 netherStorm = vec4(1.0, 1.0, 1.0, 0.0);
|
||||
vec3 nPlayerPos = normalize(playerPos);
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
float maxDist = min(far, 256.0); // consistency9023HFUE85JG
|
||||
#else
|
||||
float maxDist = far;
|
||||
#endif
|
||||
|
||||
#ifndef LOW_QUALITY_NETHER_STORM
|
||||
int sampleCount = int(maxDist / 8.0 + 0.001);
|
||||
|
||||
vec3 traceAdd = nPlayerPos * maxDist / sampleCount;
|
||||
vec3 tracePos = cameraPosition;
|
||||
tracePos += traceAdd * dither;
|
||||
#else
|
||||
int sampleCount = int(maxDist / 16.0 + 0.001);
|
||||
|
||||
vec3 traceAdd = 0.75 * nPlayerPos * maxDist / sampleCount;
|
||||
vec3 tracePos = cameraPosition;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos += traceAdd * sampleCount * 0.25;
|
||||
#endif
|
||||
|
||||
vec3 translucentMultM = pow(translucentMult, vec3(1.0 / sampleCount));
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
vec3 tracedPlayerPos = tracePos - cameraPosition;
|
||||
float lTracePos = length(tracedPlayerPos);
|
||||
if (lTracePos > lViewPos1) break;
|
||||
|
||||
vec3 wind = vec3(frameTimeCounter * 0.002);
|
||||
|
||||
vec3 tracePosM = tracePos * 0.001;
|
||||
tracePosM.y += tracePosM.x;
|
||||
tracePosM += Noise3D(tracePosM - wind) * 0.01;
|
||||
tracePosM = tracePosM * vec3(2.0, 0.5, 2.0);
|
||||
|
||||
float traceAltitudeM = abs(tracePos.y - NETHER_STORM_LOWER_ALT);
|
||||
if (tracePos.y < NETHER_STORM_LOWER_ALT) traceAltitudeM *= 10.0;
|
||||
traceAltitudeM = 1.0 - min1(abs(traceAltitudeM) / NETHER_STORM_HEIGHT);
|
||||
|
||||
for (int h = 0; h < 4; h++) {
|
||||
float stormSample = pow2(Noise3D(tracePosM + wind));
|
||||
stormSample *= traceAltitudeM;
|
||||
stormSample = pow2(pow2(stormSample));
|
||||
stormSample *= sqrt1(max0(1.0 - lTracePos / maxDist));
|
||||
|
||||
netherStorm.a += stormSample;
|
||||
tracePosM *= 2.0;
|
||||
wind *= -2.0;
|
||||
}
|
||||
|
||||
#ifdef IS_IRIS
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, lightningBoltPosition.xyz, vec3(1.0), 150.0) * lightningBoltPosition.w * 8.0;
|
||||
netherStorm.rgb += lightningAdd.y;
|
||||
#else
|
||||
vec2 lightningAdd = lightningFlashEffect(tracePos - cameraPosition, vec3(0.0, exp(1.0) - 1000.0, 0.0), vec3(1.0), 80.0) * lightningFlashOptifine * 10.0;
|
||||
netherStorm.rgb += lightningAdd.y;
|
||||
#endif
|
||||
|
||||
if (lTracePos > lViewPos) netherStorm.rgb *= translucentMultM;
|
||||
}
|
||||
|
||||
#ifdef LOW_QUALITY_NETHER_STORM
|
||||
netherStorm.a *= 1.8;
|
||||
#endif
|
||||
|
||||
netherStorm.a = min1(netherStorm.a * NETHER_STORM_I);
|
||||
|
||||
netherStorm.rgb *= netherColor * 3.0;
|
||||
|
||||
//if (netherStorm.a > 0.98) netherStorm.rgb = vec3(1,0,1);
|
||||
//netherStorm.a *= 1.0 - max0(netherStorm.a - 0.98) * 50.0;
|
||||
|
||||
return netherStorm;
|
||||
}
|
||||
@ -0,0 +1,96 @@
|
||||
#include "/spookylib/atmospherics/stars.glsl"
|
||||
|
||||
// Nebula implementation by flytrap https://godotshaders.com/shader/2d-nebula-shader/
|
||||
|
||||
#ifndef HQ_NIGHT_NEBULA
|
||||
const int OCTAVE = 5;
|
||||
#else
|
||||
const int OCTAVE = 8;
|
||||
#endif
|
||||
const float timescale = 5.0;
|
||||
const float zoomScale = 3.0;
|
||||
const vec4 CLOUD1_COL = vec4(0.41, 0.64, 0.97, 0.4);
|
||||
const vec4 CLOUD2_COL = vec4(0.81, 0.55, 0.21, 0.2);
|
||||
const vec4 CLOUD3_COL = vec4(0.51, 0.81, 0.98, 1.0);
|
||||
|
||||
float rand(vec2 inCoord){
|
||||
return fract(sin(dot(inCoord, vec2(23.53, 44.0))) * 42350.45);
|
||||
}
|
||||
|
||||
float perlin(vec2 inCoord){
|
||||
vec2 i = floor(inCoord);
|
||||
vec2 j = fract(inCoord);
|
||||
vec2 coord = smoothstep(0.0, 1.0, j);
|
||||
|
||||
float a = rand(i);
|
||||
float b = rand(i + vec2(1.0, 0.0));
|
||||
float c = rand(i + vec2(0.0, 1.0));
|
||||
float d = rand(i + vec2(1.0, 1.0));
|
||||
|
||||
return mix(mix(a, b, coord.x), mix(c, d, coord.x), coord.y);
|
||||
}
|
||||
|
||||
float fbmCloud(vec2 inCoord, float minimum){
|
||||
float value = 0.0;
|
||||
float scale = 0.5;
|
||||
|
||||
for(int i = 0; i < OCTAVE; i++){
|
||||
value += perlin(inCoord) * scale;
|
||||
inCoord *= 2.0;
|
||||
scale *= 0.5;
|
||||
}
|
||||
|
||||
return smoothstep(0.0, 1.0, (smoothstep(minimum, 1.0, value) - minimum) / (1.0 - minimum));
|
||||
}
|
||||
|
||||
float fbmCloud2(vec2 inCoord, float minimum){
|
||||
float value = 0.0;
|
||||
float scale = 0.5;
|
||||
|
||||
for(int i = 0; i < OCTAVE; i++){
|
||||
value += perlin(inCoord) * scale;
|
||||
inCoord *= 2.0;
|
||||
scale *= 0.5;
|
||||
}
|
||||
|
||||
return (smoothstep(minimum, 1.0, value) - minimum) / (1.0 - minimum);
|
||||
}
|
||||
|
||||
vec3 GetNightNebula(vec3 viewPos, float VdotU, float VdotS) {
|
||||
float nebulaFactor = pow2(max0(VdotU) * min1(nightFactor * 2.0));
|
||||
nebulaFactor *= mix(1.0, invRainFactor, heightRelativeToCloud);
|
||||
if (nebulaFactor < 0.001) return vec3(0.0);
|
||||
|
||||
vec2 UV = GetStarCoord(viewPos, 0.5);
|
||||
float TIME = syncedTime * 0.003 + 15.0;
|
||||
|
||||
float timescaled = TIME * timescale;
|
||||
vec2 zoomUV2
|
||||
= vec2(zoomScale * UV.x + 0.03 * timescaled * sin(0.07 * timescaled), zoomScale * UV.y + 0.03 * timescaled * cos(0.06 * timescaled));
|
||||
vec2 zoomUV3
|
||||
= vec2(zoomScale * UV.x + 0.027 * timescaled * sin(0.07 * timescaled), zoomScale * UV.y + 0.025 * timescaled * cos(0.06 * timescaled));
|
||||
vec2 zoomUV4
|
||||
= vec2(zoomScale * UV.x + 0.021 * timescaled * sin(0.07 * timescaled), zoomScale * UV.y + 0.021 * timescaled * cos(0.07 * timescaled));
|
||||
float tide = 0.05 * sin(TIME);
|
||||
float tide2 = 0.06 * cos(0.3 * TIME);
|
||||
|
||||
vec4 nebulaTexture = vec4(vec3(0.0), 0.5 + 0.2 * sin(0.23 * TIME + UV.x - UV.y));
|
||||
nebulaTexture += fbmCloud2(zoomUV3, 0.24 + tide) * CLOUD1_COL;
|
||||
nebulaTexture += fbmCloud(zoomUV2 * 0.9, 0.33 - tide) * CLOUD2_COL;
|
||||
nebulaTexture = mix(nebulaTexture, CLOUD3_COL, fbmCloud(vec2(0.9 * zoomUV4.x, 0.9 * zoomUV4.y), 0.25 + tide2));
|
||||
|
||||
//nebulaTexture = vec4(1,0,1,1);,
|
||||
nebulaFactor *= 1.0 - pow2(pow2(pow2(abs(VdotS))));
|
||||
nebulaTexture.a *= min1(pow2(pow2(nebulaTexture.a))) * nebulaFactor;
|
||||
|
||||
float starFactor = 1024.0;
|
||||
vec2 starCoord = floor(UV * 0.2 * starFactor) / starFactor;
|
||||
nebulaTexture.rgb *= 1.5 + 10.0 * pow2(max0(GetStarNoise(starCoord) * GetStarNoise(starCoord + 0.1) - 0.6));
|
||||
|
||||
#if NIGHT_NEBULA_I != 100
|
||||
#define NIGHT_NEBULA_IM NIGHT_NEBULA_I * 0.01
|
||||
nebulaTexture.a *= NIGHT_NEBULA_IM;
|
||||
#endif
|
||||
|
||||
return max(nebulaTexture.rgb * nebulaTexture.a, vec3(0.0));
|
||||
}
|
||||
@ -0,0 +1,131 @@
|
||||
#ifndef INCLUDE_SKY
|
||||
#define INCLUDE_SKY
|
||||
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/spookylib/colors/skyColors.glsl"
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/spookylib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
vec3 GetSky(float VdotU, float VdotS, float dither, bool doGlare, bool doGround) {
|
||||
// Prepare variables
|
||||
float nightFactorM = sqrt3(nightFactor) * 0.4;
|
||||
float VdotSM1 = pow2(max(VdotS, 0.0));
|
||||
float VdotSM2 = pow2(VdotSM1);
|
||||
float VdotSM3 = pow2(pow2(max(-VdotS, 0.0)));
|
||||
float VdotSML = sunVisibility > 0.5 ? VdotS : -VdotS;
|
||||
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUmax0M = 1.0 - pow2(VdotUmax0);
|
||||
|
||||
// Prepare colors
|
||||
vec3 upColor = mix(nightUpSkyColor * (1.0 + nightFactorM * VdotSM3 * 1.5), dayUpSkyColor, sunFactor);
|
||||
vec3 middleColor = mix(nightMiddleSkyColor, dayMiddleSkyColor * (1.0 + VdotSM2 * 0.3), sunFactor);
|
||||
vec3 downColor = mix(nightDownSkyColor, dayDownSkyColor, (sunFactor + sunVisibility) * 0.5);
|
||||
|
||||
// Mix the colors
|
||||
// Set sky gradient
|
||||
float VdotUM1 = pow2(1.0 - VdotUmax0);
|
||||
VdotUM1 = pow(VdotUM1, 1.0 - VdotSM2 * 0.4);
|
||||
VdotUM1 = mix(VdotUM1, 1.0, rainFactor2 * 0.15);
|
||||
vec3 finalSky = mix(upColor, middleColor * 0.8, VdotUM1);
|
||||
|
||||
// Add sunset color
|
||||
float VdotUM2 = pow2(1.0 - abs(VdotU));
|
||||
VdotUM2 = VdotUM2 * VdotUM2 * (3.0 - 2.0 * VdotUM2);
|
||||
VdotUM2 *= (0.7 - nightFactorM + VdotSM1 * (0.3 + nightFactorM)) * invNoonFactor * sunFactor;
|
||||
finalSky = mix(finalSky, sunsetDownSkyColorP * (1.0 + VdotSM1 * 0.3), VdotUM2 * invRainFactor);
|
||||
|
||||
// Add sky ground with fake light scattering
|
||||
float VdotUM3 = min(max0(-VdotU + 0.08) / 0.35, 1.0);
|
||||
VdotUM3 = smoothstep1(VdotUM3);
|
||||
vec3 scatteredGroundMixer = vec3(VdotUM3 * VdotUM3, sqrt1(VdotUM3), sqrt3(VdotUM3));
|
||||
scatteredGroundMixer = mix(vec3(VdotUM3), scatteredGroundMixer, 0.75 - 0.5 * rainFactor);
|
||||
finalSky = mix(finalSky, downColor, scatteredGroundMixer * 0.2);
|
||||
//
|
||||
|
||||
// Sky Ground
|
||||
if (doGround)
|
||||
finalSky *= smoothstep1(pow2(1.0 + min(VdotU, 0.0)));
|
||||
|
||||
// Apply Underwater Fog
|
||||
if (isEyeInWater == 1)
|
||||
finalSky = mix(finalSky * 3.0, waterFogColor, VdotUmax0M);
|
||||
|
||||
// Sun/Moon Glare
|
||||
if (doGlare) {
|
||||
if (0.0 < VdotSML) {
|
||||
float glareScatter = 4.0 * (2.0 - clamp01(VdotS * 1000.0));
|
||||
float VdotSM4 = pow(abs(VdotS), glareScatter);
|
||||
|
||||
float visfactor = 0.075;
|
||||
float glare = visfactor / (1.0 - (1.0 - visfactor) * VdotSM4) - visfactor;
|
||||
|
||||
glare *= 0.5 + pow2(noonFactor) * 1.2;
|
||||
glare *= 1.0 - rainFactor * 0.5;
|
||||
|
||||
float glareWaterFactor = isEyeInWater * sunVisibility;
|
||||
vec3 moonGlareColor = vec3(0.502, 0.3804, 0.3804);
|
||||
#if BLOOD_MOON > 0
|
||||
moonGlareColor = mix(moonGlareColor, vec3(1.0, 0.0, 0.0) * 1.5, getBloodMoon(moonPhase, sunVisibility));
|
||||
#endif
|
||||
vec3 glareColor = mix(moonGlareColor * 0.7, vec3(0.5), sunVisibility);
|
||||
glareColor = glareColor + glareWaterFactor * vec3(7.0);
|
||||
glare *= 0.5;
|
||||
|
||||
finalSky += glare * shadowTime * glareColor;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
// Apply Cave Fog
|
||||
finalSky = mix(finalSky, caveFogColor, GetCaveFactor() * VdotUmax0M);
|
||||
#endif
|
||||
|
||||
// Dither to fix banding
|
||||
finalSky += (dither - 0.5) / 128.0;
|
||||
|
||||
return finalSky;
|
||||
}
|
||||
|
||||
vec3 GetLowQualitySky(float VdotU, float VdotS, float dither, bool doGlare, bool doGround) {
|
||||
// Prepare variables
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUmax0M = 1.0 - pow2(VdotUmax0);
|
||||
|
||||
// Prepare colors
|
||||
vec3 upColor = mix(nightUpSkyColor, dayUpSkyColor, sunFactor);
|
||||
vec3 middleColor = mix(nightMiddleSkyColor, dayMiddleSkyColor, sunFactor);
|
||||
|
||||
// Mix the colors
|
||||
// Set sky gradient
|
||||
float VdotUM1 = pow2(1.0 - VdotUmax0);
|
||||
VdotUM1 = mix(VdotUM1, 1.0, rainFactor2 * 0.2);
|
||||
vec3 finalSky = mix(upColor, middleColor, VdotUM1);
|
||||
|
||||
// Add sunset color
|
||||
float VdotUM2 = pow2(1.0 - abs(VdotU));
|
||||
VdotUM2 *= invNoonFactor * sunFactor * (0.8 + 0.2 * VdotS);
|
||||
finalSky = mix(finalSky, sunsetDownSkyColorP * (shadowTime * 0.6 + 0.2), VdotUM2 * invRainFactor);
|
||||
//
|
||||
|
||||
// Sky Ground
|
||||
finalSky *= pow2(pow2(1.0 + min(VdotU, 0.0)));
|
||||
|
||||
// Apply Underwater Fog
|
||||
if (isEyeInWater == 1)
|
||||
finalSky = mix(finalSky, waterFogColor, VdotUmax0M);
|
||||
|
||||
// Sun/Moon Glare
|
||||
finalSky *= 1.0 + mix(nightFactor, 0.5 + 0.7 * noonFactor, VdotS * 0.5 + 0.5) * pow2(pow2(pow2(VdotS)));
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
// Apply Cave Fog
|
||||
finalSky = mix(finalSky, caveFogColor, GetCaveFactor() * VdotUmax0M);
|
||||
#endif
|
||||
|
||||
return finalSky;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,47 @@
|
||||
#include "/spookylib/colors/skyColors.glsl"
|
||||
|
||||
float GetStarNoise(vec2 pos) {
|
||||
return fract(sin(dot(pos, vec2(12.9898, 4.1414))) * 43758.54953);
|
||||
}
|
||||
|
||||
vec2 GetStarCoord(vec3 viewPos, float sphereness) {
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * 1000.0, 1.0)).xyz);
|
||||
vec3 starCoord = wpos / (wpos.y + length(wpos.xz) * sphereness);
|
||||
vec3 moonPos = vec3(gbufferModelViewInverse * vec4(- sunVec * 70.0, 1.0));
|
||||
vec3 moonCoord = moonPos / (moonPos.y + length(moonPos.xz) * sphereness);
|
||||
return starCoord.xz - moonCoord.xz;
|
||||
}
|
||||
|
||||
vec3 GetStars(vec2 starCoord, float VdotU, float VdotS) {
|
||||
if (VdotU < 0.0) return vec3(0.0);
|
||||
|
||||
starCoord *= 0.4;
|
||||
float starFactor = 1024.0;
|
||||
starCoord = floor(starCoord * starFactor) / starFactor;
|
||||
|
||||
float star = 1.0;
|
||||
star *= GetStarNoise(starCoord.xy);
|
||||
star *= GetStarNoise(starCoord.xy+0.1);
|
||||
star *= GetStarNoise(starCoord.xy+0.23);
|
||||
|
||||
#if NIGHT_STAR_AMOUNT == 2
|
||||
star -= 0.5;
|
||||
star *= 0.55;
|
||||
#else
|
||||
star -= 0.6;
|
||||
star *= 0.65;
|
||||
#endif
|
||||
star = max0(star);
|
||||
star *= star;
|
||||
|
||||
float starFogFactor = min1(VdotU * 3.0);
|
||||
star *= starFogFactor * (1.0 - sunVisibility);
|
||||
star *= max0(1.0 - pow(abs(VdotS) * 1.002, 100.0));
|
||||
|
||||
vec3 stars = 40.0 * star * vec3(0.38, 0.4, 0.5) * 2.0;
|
||||
stars *= mix(1.0, invRainFactor, heightRelativeToCloud);
|
||||
|
||||
stars *= clamp(abs(texture2D(noisetex, starCoord + frameTimeCounter * 0.004).r - 0.5) * 10, 0.5, 1.0);
|
||||
|
||||
return stars;
|
||||
}
|
||||
@ -0,0 +1,262 @@
|
||||
// Volumetric tracing from Robobo1221, highly modified
|
||||
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
float GetDepth(float depth) {
|
||||
return 2.0 * near * far / (far + near - (2.0 * depth - 1.0) * (far - near));
|
||||
}
|
||||
|
||||
float GetDistX(float dist) {
|
||||
return (far * (dist - near)) / (dist * (far - near));
|
||||
}
|
||||
|
||||
vec4 DistortShadow(vec4 shadowpos, float distortFactor) {
|
||||
shadowpos.xy *= 1.0 / distortFactor;
|
||||
shadowpos.z = shadowpos.z * 0.2;
|
||||
shadowpos = shadowpos * 0.5 + 0.5;
|
||||
|
||||
return shadowpos;
|
||||
}
|
||||
|
||||
vec4 GetVolumetricLight(inout vec3 color, inout float vlFactor, vec3 translucentMult, float lViewPos, vec3 nViewPos, float VdotL, float VdotU, vec2 texCoord, float z0, float z1, float dither) {
|
||||
if (max(blindness, darknessFactor) > 0.1) return vec4(0.0);
|
||||
vec4 volumetricLight = vec4(0.0);
|
||||
|
||||
// For some reason Optifine doesn't provide correct shadowMapResolution if Shadow Quality isn't 1x
|
||||
vec2 shadowMapResolutionM = textureSize(shadowtex0, 0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 vlColor = lightColor;
|
||||
vec3 vlColorReducer = vec3(1.0);
|
||||
float vlSceneIntensity = isEyeInWater != 1 ? vlFactor : 1.0;
|
||||
float vlMult = 1.0;
|
||||
|
||||
if (sunVisibility < 0.5) {
|
||||
vlSceneIntensity = 0.0;
|
||||
vlMult = 0.6 + 0.4 * max0(far - lViewPos) / far;
|
||||
vlColor = normalize(pow(vlColor, vec3(1.0 - max0(1.0 - 1.5 * nightFactor))));
|
||||
vlColor *= 0.0766 + 0.0766 * vsBrightness;
|
||||
} else {
|
||||
vlColorReducer = 1.0 / sqrt(vlColor);
|
||||
}
|
||||
|
||||
float rainyNight = (1.0 - sunVisibility) * rainFactor;
|
||||
float VdotLM = max((VdotL + 1.0) / 2.0, 0.0);
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUM = mix(pow2(1.0 - VdotUmax0), 1.0, 0.5 * vlSceneIntensity);
|
||||
VdotUM = smoothstep1(VdotUM);
|
||||
VdotUM = pow(VdotUM, min(lViewPos / far, 1.0) * (3.0 - 2.0 * vlSceneIntensity));
|
||||
vlMult *= mix(VdotUM * VdotLM, 1.0, 0.4 * rainyNight) * vlTime;
|
||||
vlMult *= mix(invNoonFactor2 * 0.875 + 0.125, 1.0, max(vlSceneIntensity, rainFactor2));
|
||||
|
||||
#if LIGHTSHAFT_QUALI == 4
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 30 : 50;
|
||||
#elif LIGHTSHAFT_QUALI == 3
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 15 : 30;
|
||||
#elif LIGHTSHAFT_QUALI == 2
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 10 : 20;
|
||||
#elif LIGHTSHAFT_QUALI == 1
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 6 : 12;
|
||||
#endif
|
||||
#ifndef TAA
|
||||
//sampleCount *= 2;
|
||||
#endif
|
||||
#else
|
||||
translucentMult = sqrt(translucentMult); // Because we pow2() the vl result in composite for the End dimension
|
||||
|
||||
float vlSceneIntensity = 0.0;
|
||||
|
||||
#ifndef LOW_QUALITY_ENDER_NEBULA
|
||||
int sampleCount = 16;
|
||||
#else
|
||||
int sampleCount = 10;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float addition = 1.0;
|
||||
float maxDist = mix(max(far, 96.0) * 0.55, 80.0, vlSceneIntensity);
|
||||
|
||||
#if WATER_FOG_MULT != 100
|
||||
if (isEyeInWater == 1) {
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
maxDist /= WATER_FOG_MULT_M;
|
||||
}
|
||||
#endif
|
||||
|
||||
float distMult = maxDist / (sampleCount + addition);
|
||||
float sampleMultIntense = isEyeInWater != 1 ? 1.0 : 0.85;
|
||||
|
||||
float viewFactor = 1.0 - 0.7 * pow2(dot(nViewPos.xy, nViewPos.xy));
|
||||
|
||||
float depth0 = GetDepth(z0);
|
||||
float depth1 = GetDepth(z1);
|
||||
#ifdef END
|
||||
if (z0 == 1.0) depth0 = 1000.0;
|
||||
if (z1 == 1.0) depth1 = 1000.0;
|
||||
#endif
|
||||
|
||||
// Fast but inaccurate perspective distortion approximation
|
||||
maxDist *= viewFactor;
|
||||
distMult *= viewFactor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float maxCurrentDist = min(depth1, maxDist);
|
||||
#else
|
||||
float maxCurrentDist = min(depth1, far);
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float currentDist = (i + dither) * distMult + addition;
|
||||
|
||||
if (currentDist > maxCurrentDist) break;
|
||||
|
||||
vec4 viewPos = gbufferProjectionInverse * (vec4(texCoord, GetDistX(currentDist), 1.0) * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
vec4 wpos = gbufferModelViewInverse * viewPos;
|
||||
vec3 playerPos = wpos.xyz / wpos.w;
|
||||
#ifdef END
|
||||
vec4 enderBeamSample = vec4(DrawEnderBeams(VdotU, playerPos), 1.0);
|
||||
enderBeamSample /= sampleCount;
|
||||
#endif
|
||||
|
||||
float shadowSample = 1.0;
|
||||
vec3 vlSample = vec3(1.0);
|
||||
#ifdef REALTIME_SHADOWS
|
||||
wpos = shadowModelView * wpos;
|
||||
wpos = shadowProjection * wpos;
|
||||
wpos /= wpos.w;
|
||||
float distb = sqrt(wpos.x * wpos.x + wpos.y * wpos.y);
|
||||
float distortFactor = 1.0 - shadowMapBias + distb * shadowMapBias;
|
||||
vec4 shadowPosition = DistortShadow(wpos,distortFactor);
|
||||
//shadowPosition.z += 0.0001;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float percentComplete = currentDist / maxDist;
|
||||
float sampleMult = mix(percentComplete * 3.0, sampleMultIntense, max(rainFactor, vlSceneIntensity));
|
||||
if (currentDist < 5.0) sampleMult *= smoothstep1(clamp(currentDist / 5.0, 0.0, 1.0));
|
||||
sampleMult /= sampleCount;
|
||||
#endif
|
||||
|
||||
if (length(shadowPosition.xy * 2.0 - 1.0) < 1.0) {
|
||||
// 28A3DK6 We need to use texelFetch here or a lot of Nvidia GPUs can't get a valid value
|
||||
shadowSample = texelFetch(shadowtex0, ivec2(shadowPosition.xy * shadowMapResolutionM), 0).x;
|
||||
shadowSample = clamp((shadowSample-shadowPosition.z)*65536.0,0.0,1.0);
|
||||
vlSample = vec3(shadowSample);
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
if (shadowSample == 0.0) {
|
||||
float testsample = shadow2D(shadowtex1, shadowPosition.xyz).z;
|
||||
if (testsample == 1.0) {
|
||||
vec3 colsample = texture2D(shadowcolor1, shadowPosition.xy).rgb * 4.0;
|
||||
colsample *= colsample;
|
||||
vlSample = colsample * (1.0 - vlSample) + vlSample;
|
||||
#ifdef OVERWORLD
|
||||
vlSample *= vlColorReducer;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
#ifdef OVERWORLD
|
||||
// For water-tinting the water surface when observed from below the surface
|
||||
if (translucentMult != vec3(1.0) && currentDist > depth0) {
|
||||
if (isEyeInWater == 1) {
|
||||
vec3 translucentMultM = translucentMult * 2.8;
|
||||
vlSample *= pow(translucentMultM, vec3(sunVisibility * 3.0 * clamp01(playerPos.y * 0.03)));
|
||||
} else {
|
||||
vlSample *= 0.1 + 0.9 * pow2(pow2(translucentMult * 1.7));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (isEyeInWater == 1 && translucentMult == vec3(1.0)) vlSample = vec3(0.0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
if (currentDist > depth0) vlSample *= translucentMult;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
volumetricLight += vec4(vlSample, shadowSample) * sampleMult;
|
||||
#else
|
||||
volumetricLight += vec4(vlSample, shadowSample) * enderBeamSample;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined OVERWORLD && LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1
|
||||
if (viewWidth + viewHeight - gl_FragCoord.x - gl_FragCoord.y < 1.5) {
|
||||
if (frameCounter % int(0.06666 / frameTimeSmooth + 0.5) == 0) { // Change speed is not too different above 10 fps
|
||||
int salsX = 5;
|
||||
int salsY = 5;
|
||||
float heightThreshold = 6.0;
|
||||
|
||||
vec2 viewM = 1.0 / vec2(salsX, salsY);
|
||||
float salsSampleSum = 0.0;
|
||||
int salsSampleCount = 0;
|
||||
for (float i = 0.25; i < salsX; i++) {
|
||||
for (float h = 0.45; h < salsY; h++) {
|
||||
vec2 coord = 0.3 + 0.4 * viewM * vec2(i, h);
|
||||
ivec2 icoord = ivec2(coord * shadowMapResolutionM);
|
||||
float salsSample = texelFetch(shadowtex0, icoord, 0).x; // read 28A3DK6
|
||||
if (salsSample < 0.55) {
|
||||
float sampledHeight = max0(texture2D(shadowcolor1, coord).a - 0.25) / 0.05; // consistencyMEJHRI7DG
|
||||
salsSampleSum += sampledHeight;
|
||||
salsSampleCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
float salsCheck = salsSampleSum / salsSampleCount;
|
||||
int reduceAmount = 2;
|
||||
|
||||
int skyCheck = 0;
|
||||
for (float i = 0.1; i < 1.0; i += 0.2) {
|
||||
skyCheck += int(texelFetch(depthtex0, ivec2(view.x * i, view.y * 0.9), 0).x == 1.0);
|
||||
}
|
||||
if (skyCheck >= 4) {
|
||||
salsCheck = 0.0;
|
||||
reduceAmount = 3;
|
||||
}
|
||||
|
||||
if (salsCheck > heightThreshold) {
|
||||
vlFactor = min(vlFactor + OSIEBCA, 1.0);
|
||||
} else {
|
||||
vlFactor = max(vlFactor - OSIEBCA * reduceAmount, 0.0);
|
||||
}
|
||||
}
|
||||
} else vlFactor = 0.0;
|
||||
//if (gl_FragCoord.y < 50) color.rgb = vec3(1,0,1) * float(salsCheck / heightThreshold > gl_FragCoord.x / 1920.0);
|
||||
|
||||
/*for (float i = 0.25; i < salsX; i++) {
|
||||
for (float h = 0.45; h < salsY; h++) {
|
||||
if (length(texCoord - (0.3 + 0.4 * viewM * vec2(i, h))) < 0.01) return vec4(1,0,1,1);
|
||||
}
|
||||
}*/
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vlColor = pow(vlColor, vec3(0.5 + 0.5 * invNoonFactor * invRainFactor + 0.3 * rainFactor));
|
||||
vlColor *= 1.0 - (0.3 + 0.3 * noonFactor) * rainFactor - 0.5 * rainyNight;
|
||||
|
||||
#if LIGHTSHAFT_DAY_I != 100 || LIGHTSHAFT_NIGHT_I != 100
|
||||
#define LIGHTSHAFT_DAY_IM LIGHTSHAFT_DAY_I * 0.01
|
||||
#define LIGHTSHAFT_NIGHT_IM LIGHTSHAFT_NIGHT_I * 0.01
|
||||
vlColor.rgb *= mix(LIGHTSHAFT_NIGHT_IM, LIGHTSHAFT_DAY_IM, sunVisibility);
|
||||
#endif
|
||||
|
||||
#if LIGHTSHAFT_RAIN_I != 100
|
||||
#define LIGHTSHAFT_RAIN_IM LIGHTSHAFT_RAIN_I * 0.01
|
||||
vlColor.rgb *= mix(1.0, LIGHTSHAFT_RAIN_IM, rainFactor);
|
||||
#endif
|
||||
|
||||
volumetricLight.rgb *= vlMult * vlColor;
|
||||
#endif
|
||||
|
||||
volumetricLight = max(volumetricLight, vec4(0.0));
|
||||
volumetricLight.a = min(volumetricLight.a, 1.0);
|
||||
|
||||
float spookyVolLight = 0.2;
|
||||
|
||||
if (isEyeInWater == 1) volumetricLight *= 0.2;
|
||||
|
||||
return volumetricLight * 0.35;
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
vec3 cloudRainColor = mix(nightMiddleSkyColor, dayMiddleSkyColor, sunFactor);
|
||||
vec3 cloudAmbientColor = mix(ambientColor * (sunVisibility2 * (0.55 + 0.1 * noonFactor) + 0.35), cloudRainColor * 0.5, rainFactor);
|
||||
vec3 cloudLightColor = mix(lightColor * (0.9 + 0.2 * noonFactor), cloudRainColor * 0.25, noonFactor * rainFactor);
|
||||
@ -0,0 +1,57 @@
|
||||
#ifndef INCLUDE_LIGHT_AND_AMBIENT_MULTIPLIERS
|
||||
#define INCLUDE_LIGHT_AND_AMBIENT_MULTIPLIERS
|
||||
|
||||
vec3 GetLightColorMult() {
|
||||
vec3 lightColorMult;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 morningLightMult = vec3(LIGHT_MORNING_R, LIGHT_MORNING_G, LIGHT_MORNING_B) * LIGHT_MORNING_I;
|
||||
vec3 noonLightMult = vec3(LIGHT_NOON_R, LIGHT_NOON_G, LIGHT_NOON_B) * LIGHT_NOON_I;
|
||||
vec3 nightLightMult = vec3(LIGHT_NIGHT_R, LIGHT_NIGHT_G, LIGHT_NIGHT_B) * LIGHT_NIGHT_I;
|
||||
vec3 rainLightMult = vec3(LIGHT_RAIN_R, LIGHT_RAIN_G, LIGHT_RAIN_B) * LIGHT_RAIN_I;
|
||||
|
||||
lightColorMult = mix(noonLightMult, morningLightMult, invNoonFactor2);
|
||||
lightColorMult = mix(nightLightMult, lightColorMult, sunVisibility2);
|
||||
lightColorMult *= mix(vec3(1.0), rainLightMult, rainFactor);
|
||||
#elif defined NETHER
|
||||
vec3 netherLightMult = vec3(LIGHT_NETHER_R, LIGHT_NETHER_G, LIGHT_NETHER_B) * LIGHT_NETHER_I;
|
||||
|
||||
lightColorMult = netherLightMult;
|
||||
#elif defined END
|
||||
vec3 endLightMult = vec3(LIGHT_END_R, LIGHT_END_G, LIGHT_END_B) * LIGHT_END_I;
|
||||
|
||||
lightColorMult = endLightMult;
|
||||
#endif
|
||||
|
||||
return lightColorMult;
|
||||
}
|
||||
|
||||
vec3 GetAtmColorMult() {
|
||||
vec3 atmColorMult;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 morningAtmMult = vec3(ATM_MORNING_R, ATM_MORNING_G, ATM_MORNING_B) * ATM_MORNING_I;
|
||||
vec3 noonAtmMult = vec3(ATM_NOON_R, ATM_NOON_G, ATM_NOON_B) * ATM_NOON_I;
|
||||
vec3 nightAtmMult = vec3(ATM_NIGHT_R, ATM_NIGHT_G, ATM_NIGHT_B) * ATM_NIGHT_I * 0.5;
|
||||
vec3 rainAtmMult = vec3(ATM_RAIN_R, ATM_RAIN_G, ATM_RAIN_B) * ATM_RAIN_I * 0.75;
|
||||
|
||||
atmColorMult = mix(noonAtmMult, morningAtmMult, invNoonFactor2);
|
||||
atmColorMult = mix(nightAtmMult, atmColorMult, sunVisibility2);
|
||||
atmColorMult *= mix(vec3(1.0), rainAtmMult, rainFactor);
|
||||
#elif defined NETHER
|
||||
vec3 netherAtmMult = vec3(ATM_NETHER_R, ATM_NETHER_G, ATM_NETHER_B) * ATM_NETHER_I * 0.3;
|
||||
|
||||
atmColorMult = netherAtmMult;
|
||||
#elif defined END
|
||||
vec3 endAtmMult = vec3(ATM_END_R, ATM_END_G, ATM_END_B) * ATM_END_I * 0.5;
|
||||
|
||||
atmColorMult = endAtmMult;
|
||||
#endif
|
||||
|
||||
return atmColorMult;
|
||||
}
|
||||
|
||||
vec3 lightColorMult;
|
||||
vec3 atmColorMult;
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,60 @@
|
||||
#ifndef INCLUDE_LIGHT_AND_AMBIENT_COLORS
|
||||
#define INCLUDE_LIGHT_AND_AMBIENT_COLORS
|
||||
|
||||
#if defined OVERWORLD
|
||||
#ifndef COMPOSITE
|
||||
vec3 noonClearLightColor = vec3(0.7, 0.55, 0.4) * 1.9; //ground and cloud color
|
||||
#else
|
||||
vec3 noonClearLightColor = vec3(0.4, 0.7, 1.4); //light shaft color
|
||||
#endif
|
||||
vec3 noonClearAmbientColor = pow(skyColor, vec3(0.65)) * 0.85;
|
||||
|
||||
#ifndef COMPOSITE
|
||||
vec3 sunsetClearLightColor = pow(vec3(0.64, 0.45, 0.3), vec3(1.5 + invNoonFactor)) * 5.0; //ground and cloud color
|
||||
#else
|
||||
vec3 sunsetClearLightColor = pow(vec3(0.62, 0.39, 0.24), vec3(1.5 + invNoonFactor)) * 6.8; //light shaft color
|
||||
#endif
|
||||
vec3 sunsetClearAmbientColor = noonClearAmbientColor * vec3(1.21, 0.92, 0.76) * 0.95;
|
||||
|
||||
#if !defined COMPOSITE && !defined DEFERRED1
|
||||
vec3 nightClearLightColor = vec3(0.15, 0.14, 0.20) * (0.4 + vsBrightness * 0.4); //ground color
|
||||
#elif defined DEFERRED1
|
||||
vec3 nightClearLightColor = vec3(0.11, 0.14, 0.20); //cloud color
|
||||
#else
|
||||
vec3 nightClearLightColor = vec3(0.07, 0.12, 0.27); //light shaft color
|
||||
#endif
|
||||
vec3 nightClearAmbientColor = vec3(0.09, 0.12, 0.17) * (1.55 + vsBrightness * 0.77);
|
||||
|
||||
vec3 dayRainLightColor = vec3(0.21, 0.16, 0.13) * 0.85;
|
||||
vec3 dayRainAmbientColor = vec3(0.2, 0.2, 0.25) * 2.3;
|
||||
|
||||
vec3 nightRainLightColor = vec3(0.03, 0.035, 0.05) * (0.5 + 0.5 * vsBrightness);
|
||||
vec3 nightRainAmbientColor = vec3(0.16, 0.20, 0.3) * (0.75 + 0.6 * vsBrightness);
|
||||
|
||||
#ifndef COMPOSITE
|
||||
float noonFactorDM = noonFactor; //ground and cloud factor
|
||||
#else
|
||||
float noonFactorDM = noonFactor * noonFactor; //light shaft factor
|
||||
#endif
|
||||
vec3 dayLightColor = mix(sunsetClearLightColor, noonClearLightColor, noonFactorDM);
|
||||
vec3 dayAmbientColor = mix(sunsetClearAmbientColor, noonClearAmbientColor, noonFactorDM);
|
||||
|
||||
vec3 clearLightColor = mix(nightClearLightColor, dayLightColor, sunVisibility2);
|
||||
vec3 clearAmbientColor = mix(nightClearAmbientColor, dayAmbientColor, sunVisibility2);
|
||||
|
||||
vec3 rainLightColor = mix(nightRainLightColor, dayRainLightColor, sunVisibility2) * 2.5;
|
||||
vec3 rainAmbientColor = mix(nightRainAmbientColor, dayRainAmbientColor, sunVisibility2);
|
||||
|
||||
vec3 lightColor = mix(clearLightColor, rainLightColor, rainFactor) * 0.4;
|
||||
vec3 ambientColor = mix(clearAmbientColor, rainAmbientColor, rainFactor) * 0.4;
|
||||
#elif defined NETHER
|
||||
vec3 lightColor = vec3(0.0);
|
||||
vec3 ambientColor = (netherColor + 0.5 * lavaLightColor) * (0.9 + 0.45 * vsBrightness) * 0.4;
|
||||
#elif defined END
|
||||
vec3 endLightColor = vec3(0.68, 0.51, 1.07);
|
||||
float endLightBalancer = 0.2 * vsBrightness;
|
||||
vec3 lightColor = endLightColor * (0.35 - endLightBalancer) * 0.4;
|
||||
vec3 ambientColor = endLightColor * (0.2 + endLightBalancer) * 0.4;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
|
||||
|
||||
float moonPhaseInfluence = mix(
|
||||
1.0,
|
||||
moonPhase == 0 ? MOON_PHASE_FULL : moonPhase != 4 ? MOON_PHASE_PARTIAL : MOON_PHASE_DARK,
|
||||
1.0 - sunVisibility2
|
||||
);
|
||||
@ -0,0 +1,30 @@
|
||||
#ifndef INCLUDE_SKY_COLORS
|
||||
#define INCLUDE_SKY_COLORS
|
||||
|
||||
#ifdef OVERWORLD
|
||||
uniform vec3 skyColorSmooth;
|
||||
vec3 skyColorM = (skyColor / (length(clamp(skyColorSmooth, skyColor * 0.9, skyColor * 1.1)) + 0.0001)) * vec3(0.949, 0.7725, 0.5569);
|
||||
vec3 skyColorNoon = skyColorM * mix(1.28, 1.28 - 0.47 * rainFactor, heightRelativeToCloud);
|
||||
vec3 skyColorSunset = skyColorM * mix(1.18, 1.18 - 0.44 * rainFactor, heightRelativeToCloud) * invNightFactor * invNightFactor;
|
||||
|
||||
vec3 skyColorSqrt = sqrt(skyColorNoon);
|
||||
vec3 noonUpSkyColor = pow(skyColorSqrt, vec3(2.9));
|
||||
vec3 noonMiddleSkyColor = skyColorSqrt * mix(vec3(1.15), vec3(1.15) - vec3(0.1, 0.4, 0.6) * rainFactor, heightRelativeToCloud) + noonUpSkyColor * 0.6;
|
||||
vec3 noonDownSkyColor = skyColorSqrt * mix(vec3(0.9), vec3(0.9) - vec3(0.15, 0.3, 0.42) * rainFactor, heightRelativeToCloud) + noonUpSkyColor * 0.25;
|
||||
|
||||
vec3 sunsetUpSkyColor = skyColorSunset * mix(vec3(0.8, 0.58, 0.58), vec3(0.8, 0.58, 0.58) + vec3(0.1, 0.2, 0.35) * rainFactor2, heightRelativeToCloud);
|
||||
vec3 sunsetMiddleSkyColor = skyColorSunset * mix(vec3(1.8, 1.3, 1.2), vec3(1.8, 1.3, 1.2) + vec3(0.15, 0.25, -0.05) * rainFactor2, heightRelativeToCloud);
|
||||
vec3 sunsetDownSkyColorP = mix(vec3(1.45, 0.86, 0.5), vec3(1.45, 0.86, 0.5) - vec3(0.8, 0.3, 0.0) * rainFactor, heightRelativeToCloud);
|
||||
vec3 sunsetDownSkyColor = sunsetDownSkyColorP * 0.5 + 0.25 * sunsetMiddleSkyColor;
|
||||
|
||||
vec3 dayUpSkyColor = mix(noonUpSkyColor, sunsetUpSkyColor, invNoonFactor2);
|
||||
vec3 dayMiddleSkyColor = mix(noonMiddleSkyColor, sunsetMiddleSkyColor, invNoonFactor2);
|
||||
vec3 dayDownSkyColor = mix(noonDownSkyColor, sunsetDownSkyColor, invNoonFactor2);
|
||||
|
||||
vec3 nightColFactor = vec3(0.07, 0.14, 0.24) * mix(1.0, 1.0 - 0.5 * rainFactor, heightRelativeToCloud) + skyColor;
|
||||
vec3 nightUpSkyColor = pow(nightColFactor, vec3(0.90)) * 0.4;
|
||||
vec3 nightMiddleSkyColor = sqrt(nightUpSkyColor) * 0.68;
|
||||
vec3 nightDownSkyColor = nightMiddleSkyColor * vec3(0.82, 0.82, 0.88);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,670 @@
|
||||
/*---------------------------------------------------------------------
|
||||
___ __ __ ____ ___ ____ _____ _ _ _ _____
|
||||
|_ _| \/ | _ \ / _ \| _ \_ _|/ \ | \ | |_ _|
|
||||
| || |\/| | |_) | | | | |_) || | / _ \ | \| | | |
|
||||
| || | | | __/| |_| | _ < | |/ ___ \| |\ | | |
|
||||
|___|_| |_|_| \___/|_| \_\|_/_/ \_\_| \_| |_|
|
||||
.
|
||||
-> -> -> EDITING THIS FILE HAS A HIGH CHANCE TO BREAK THE SHADER PACK
|
||||
-> -> -> DO NOT CHANGE ANYTHING UNLESS YOU KNOW WHAT YOU ARE DOING
|
||||
-> -> -> DO NOT EXPECT SUPPORT AFTER MODIFYING SHADER FILES
|
||||
---------------------------------------------------------------------*/
|
||||
uniform float frameTimeCounter;
|
||||
uniform vec4 lightningBoltPosition;
|
||||
uniform float lightningFlashOptifine;
|
||||
uniform float lightning;
|
||||
uniform int moonPhase;
|
||||
uniform sampler2D noisetex;
|
||||
|
||||
//User Settings//
|
||||
#define SHADER_STYLE 4 //[1 4]
|
||||
|
||||
#define RP_MODE 1 //[1 0 3 2]
|
||||
#if RP_MODE == 1
|
||||
#define IPBR
|
||||
//#define GENERATED_NORMALS
|
||||
//#define COATED_TEXTURES
|
||||
//#define FANCY_GLASS
|
||||
//#define GREEN_SCREEN_LIME
|
||||
#endif
|
||||
#if RP_MODE >= 2
|
||||
#define CUSTOM_PBR
|
||||
#define POM
|
||||
#endif
|
||||
|
||||
#define REALTIME_SHADOWS
|
||||
#define SHADOW_QUALITY 2 //[0 1 2 3 4 5]
|
||||
const float shadowDistance = 192.0; //[64.0 80.0 96.0 112.0 128.0 160.0 192.0 224.0 256.0 320.0 384.0 512.0 768.0 1024.0]
|
||||
//#define ENTITY_SHADOWS
|
||||
#define SSAO_QUALI_DEFINE 2 //[0 2 3]
|
||||
#define FXAA
|
||||
#define DETAIL_QUALITY 2 //[0 2 3]
|
||||
#define CLOUD_QUALITY 2 //[0 1 2 3]
|
||||
#define LIGHTSHAFT_QUALI_DEFINE 2 //[0 1 2 3 4]
|
||||
#define WATER_QUALITY 2 //[1 2 3]
|
||||
#define WATER_REFLECT_QUALITY 2 //[0 1 2]
|
||||
#define BLOCK_REFLECT_QUALITY 3 //[0 1 2 3]
|
||||
|
||||
#define WATER_STYLE_DEFINE -1 //[-1 1 2 3]
|
||||
#define WATER_CAUSTIC_STYLE_DEFINE -1 //[-1 1 3]
|
||||
#define WATER_REFRACTION_INTENSITY 2.0 //[1.0 1.2 1.4 1.6 1.8 2.0 2.2 2.4 2.6 2.8 3.0]
|
||||
#define WATER_FOAM_I 100 //[0 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150]
|
||||
#define WATER_ALPHA_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300 325 350 375 400 425 450 475 500 550 600 650 700 750 800 850 900]
|
||||
#define WATER_FOG_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300 325 350 375 400 425 450 475 500 550 600 650 700 750 800 850 900]
|
||||
#define WATERCOLOR_MODE 3 //[3 2 0]
|
||||
#define BRIGHT_CAVE_WATER
|
||||
#define WATERCOLOR_R 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define WATERCOLOR_G 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define WATERCOLOR_B 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define UNDERWATERCOLOR_R 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150]
|
||||
#define UNDERWATERCOLOR_G 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150]
|
||||
#define UNDERWATERCOLOR_B 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150]
|
||||
#define WATER_BUMPINESS 1.25 //[0.05 0.10 0.15 0.20 0.25 0.30 0.40 0.50 0.65 0.80 1.00 1.25 1.50 2.00 2.50]
|
||||
#define WATER_BUMP_SMALL 0.75 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define WATER_BUMP_MED 1.70 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define WATER_BUMP_BIG 2.00 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define WATER_SPEED_MULT 1.10 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define WATER_SIZE_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
|
||||
#define PIXEL_SHADOW 0 //[0 8 16 32 64 128]
|
||||
#define RAIN_PUDDLES 1 //[0 1 2 3 4]
|
||||
#define SSAO_I 100 //[0 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define VANILLAAO_I 100 //[0 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
|
||||
#define AURORA_STYLE_DEFINE -1 //[-1 0 1 2]
|
||||
#define AURORA_CONDITION 3 //[0 1 2 3 4]
|
||||
//#define NIGHT_NEBULA
|
||||
#define NIGHT_NEBULA_I 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define WEATHER_TEX_OPACITY 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300 325 350 375 400 425 450 475 500 550 600 650 700 750 800 850 900]
|
||||
#define SUN_MOON_STYLE_DEFINE -1 //[-1 1 2 3]
|
||||
#define SUN_MOON_HORIZON
|
||||
#define NIGHT_STAR_AMOUNT 2 //[2 3]
|
||||
#define CLOUD_STYLE_DEFINE -1 //[-1 0 1 3 50]
|
||||
//#define CLOUD_SHADOWS
|
||||
#define CLOUD_CLOSED_AREA_CHECK
|
||||
#define CLOUD_ALT1 192 //[-96 -92 -88 -84 -80 -76 -72 -68 -64 -60 -56 -52 -48 -44 -40 -36 -32 -28 -24 -20 -16 -10 -8 -4 0 4 8 12 16 20 22 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 104 108 112 116 120 124 128 132 136 140 144 148 152 156 160 164 168 172 176 180 184 188 192 196 200 204 208 212 216 220 224 228 232 236 240 244 248 252 256 260 264 268 272 276 280 284 288 292 296 300 304 308 312 316 320 324 328 332 336 340 344 348 352 356 360 364 368 372 376 380 384 388 392 396 400 404 408 412 416 420 424 428 432 436 440 444 448 452 456 460 464 468 472 476 480 484 488 492 496 500 510 520 530 540 550 560 570 580 590 600 610 620 630 640 650 660 670 680 690 700 710 720 730 740 750 760 770 780 790 800]
|
||||
#define CLOUD_SPEED_MULT 100 //[0 5 7 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300 325 350 375 400 425 450 475 500 550 600 650 700 750 800 850 900]
|
||||
|
||||
#define CLOUD_UNBOUND_AMOUNT 1.00 //[0.70 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.80 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.90 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1.00 1.02 1.04 1.06 1.08 1.10 1.12 1.14 1.16 1.18 1.20 1.22 1.24 1.26 1.28 1.30 1.32 1.34 1.36 1.38 1.40 1.42 1.44 1.46 1.48 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.10 2.20 2.30 2.40 2.50 2.60 2.70 2.80 2.90 3.00]
|
||||
#define CLOUD_UNBOUND_SIZE_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
|
||||
//#define DOUBLE_REIM_CLOUDS
|
||||
#define CLOUD_ALT2 288 //[-96 -92 -88 -84 -80 -76 -72 -68 -64 -60 -56 -52 -48 -44 -40 -36 -32 -28 -24 -20 -16 -10 -8 -4 0 4 8 12 16 20 22 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 104 108 112 116 120 124 128 132 136 140 144 148 152 156 160 164 168 172 176 180 184 188 192 196 200 204 208 212 216 220 224 228 232 236 240 244 248 252 256 260 264 268 272 276 280 284 288 292 296 300 304 308 312 316 320 324 328 332 336 340 344 348 352 356 360 364 368 372 376 380 384 388 392 396 400 404 408 412 416 420 424 428 432 436 440 444 448 452 456 460 464 468 472 476 480 484 488 492 496 500 510 520 530 540 550 560 570 580 590 600 610 620 630 640 650 660 670 680 690 700 710 720 730 740 750 760 770 780 790 800]
|
||||
|
||||
#define NETHER_COLOR_MODE 3 //[3 2 0]
|
||||
#define NETHER_STORM
|
||||
#define NETHER_STORM_LOWER_ALT 28 //[-296 -292 -288 -284 -280 -276 -272 -268 -264 -260 -256 -252 -248 -244 -240 -236 -232 -228 -224 -220 -216 -212 -208 -204 -200 -196 -192 -188 -184 -180 -176 -172 -168 -164 -160 -156 -152 -148 -144 -140 -136 -132 -128 -124 -120 -116 -112 -108 -104 -100 -96 -92 -88 -84 -80 -76 -72 -68 -64 -60 -56 -52 -48 -44 -40 -36 -32 -28 -24 -20 -16 -12 -8 -4 0 4 8 12 16 20 22 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 104 108 112 116 120 124 128 132 136 140 144 148 152 156 160 164 168 172 176 180 184 188 192 196 200 204 208 212 216 220 224 228 232 236 240 244 248 252 256 260 264 268 272 276 280 284 288 292 296 300]
|
||||
#define NETHER_STORM_HEIGHT 200 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300 325 350 375 400 425 450 475 500 550 600 650 700 750 800 850 900]
|
||||
#define NETHER_STORM_I 0.40 //[0.05 0.06 0.07 0.08 0.09 0.10 0.12 0.14 0.16 0.18 0.22 0.26 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50]
|
||||
|
||||
#define BORDER_FOG
|
||||
#define ATM_FOG_MULT 0.95 //[0.50 0.65 0.80 0.95]
|
||||
#define ATM_FOG_DISTANCE 100 //[10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200 220 240 260 280 300]
|
||||
#define ATM_FOG_ALTITUDE 63 //[0 5 10 15 20 25 30 35 40 45 50 52 54 56 58 60 61 62 63 64 65 66 67 68 69 70 72 74 76 78 80 85 90 95 100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180 185 190 195 200 210 220 230 240 250 260 270 280 290 300]
|
||||
#define CAVE_FOG
|
||||
#define LIGHTSHAFT_BEHAVIOUR 1 //[0 1 2 3]
|
||||
#define LIGHTSHAFT_DAY_I 100 //[1 3 5 7 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
#define LIGHTSHAFT_NIGHT_I 100 //[1 3 5 7 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
#define LIGHTSHAFT_RAIN_I 100 //[1 3 5 7 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
|
||||
#define BLOOM
|
||||
#define BLOOM_STRENGTH 0.12 //[0.027 0.036 0.045 0.054 0.063 0.072 0.081 0.09 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.21 0.23 0.25 0.28 0.32 10.00]
|
||||
#define IMAGE_SHARPENING 3 //[0 1 2 3 4 5 6 7 8 9 10]
|
||||
//#define MOTION_BLURRING
|
||||
#define MOTION_BLURRING_STRENGTH 1.00 //[0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define VIGNETTE_R
|
||||
#define CHROMA_ABERRATION 0 //[0 1 2 3 4 5 6 7 8]
|
||||
#define UNDERWATER_DISTORTION
|
||||
//#define LENSFLARE
|
||||
#define LENSFLARE_I 1.00 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
|
||||
#define WORLD_BLUR 0 //[0 1 2]
|
||||
//#define WB_FOV_SCALED
|
||||
//#define WB_CHROMATIC
|
||||
//#define WB_ANAMORPHIC
|
||||
#define WB_DOF_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DOF_FOCUS 0 //[-1 0 1 2 3 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 65 67 69 72 74 76 79 81 83 86 88 91 94 96 99 102 104 107 110 113 115 118 121 124 127 130 133 136 140 143 146 149 153 156 160 163 167 170 174 178 182 185 189 193 197 201 206 210 214 219 223 227 232 237 242 246 251 256 261 267 272 277 283 288 294 300 306 312 318 324 330 337 344 350 357 364 371 379 386 394 402 410 418 427 435 444 453 462 472 481 491 501 512 530 550 575 600 625 650 675 700 725 750 800 850 900]
|
||||
#define WB_DB_DAY_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DB_NIGHT_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DB_RAIN_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DB_WATER_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DB_NETHER_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
#define WB_DB_END_I 64.0 //[1.0 1.5 2.0 3.0 4.5 6.0 9.0 12.0 18.0 24.0 32.0 48.0 64.0 96.0 128.0 192.0 256.0 384.0 512.0 768.0 1024.0 1536.0 2048.0 3072.0 4096.0]
|
||||
|
||||
#define ENTITY_GN_AND_CT
|
||||
#define GENERATED_NORMAL_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
#define COATED_TEXTURE_MULT 100 //[25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
|
||||
#define GLOWING_ORE_MASTER 0 //[0 1 2]
|
||||
#define GLOWING_ORE_MULT 1.00 //[0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#if GLOWING_ORE_MASTER == 2 || SHADER_STYLE == 4 && GLOWING_ORE_MASTER == 1
|
||||
#define GLOWING_ORE_IRON
|
||||
#define GLOWING_ORE_GOLD
|
||||
#define GLOWING_ORE_COPPER
|
||||
#define GLOWING_ORE_REDSTONE
|
||||
#define GLOWING_ORE_LAPIS
|
||||
#define GLOWING_ORE_EMERALD
|
||||
#define GLOWING_ORE_DIAMOND
|
||||
#define GLOWING_ORE_NETHERQUARTZ
|
||||
#define GLOWING_ORE_NETHERGOLD
|
||||
#define GLOWING_ORE_GILDEDBLACKSTONE
|
||||
#define GLOWING_ORE_ANCIENTDEBRIS
|
||||
#define GLOWING_ORE_MODDED
|
||||
#endif
|
||||
|
||||
#define GLOWING_AMETHYST 1 //[0 1 2]
|
||||
#define GLOWING_LICHEN 1 //[0 1 2]
|
||||
//#define EMISSIVE_REDSTONE_BLOCK
|
||||
//#define EMISSIVE_LAPIS_BLOCK
|
||||
//#define GLOWING_ARMOR_TRIM
|
||||
|
||||
#define NORMAL_MAP_STRENGTH 100 //[0 10 15 20 30 40 60 80 100 120 140 160 180 200]
|
||||
#define CUSTOM_EMISSION_INTENSITY 100 //[0 5 7 10 15 20 25 30 35 40 45 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200 225 250]
|
||||
#define POM_DEPTH 0.80 //[0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define POM_QUALITY 128 //[16 32 64 128 256 512]
|
||||
#define POM_DISTANCE 32 //[16 24 32 48 64 128 256 512 1024]
|
||||
#define POM_LIGHTING_MODE 2 //[1 2]
|
||||
//#define POM_ALLOW_CUTOUT
|
||||
#define DIRECTIONAL_BLOCKLIGHT 0 //[0 3 7 11]
|
||||
|
||||
#define MINIMUM_LIGHT_MODE 2 //[0 1 2 3 4]
|
||||
#define HELD_LIGHTING_MODE 2 //[0 1 2]
|
||||
#define AMBIENT_MULT 100 //[50 55 60 65 70 75 80 85 90 95 100 110 120 130 140 150 160 170 180 190 200]
|
||||
|
||||
#define WAVING_SPEED 1.00 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define WAVING_I 1.00 //[0.25 0.50 0.75 1.00 1.25 1.50 1.75 2.00 50.0]
|
||||
#define NO_WAVING_INDOORS
|
||||
#define WAVING_FOLIAGE
|
||||
#define WAVING_LEAVES
|
||||
#define WAVING_LAVA
|
||||
#define WAVING_WATER_VERTEX
|
||||
#define WAVING_RAIN
|
||||
|
||||
#define SUN_ANGLE -1 //[-1 0 -20 -30 -40 -50 -60 60 50 40 30 20]
|
||||
|
||||
#define SELECT_OUTLINE 1 //[0 1 3 4 2]
|
||||
#define SELECT_OUTLINE_I 1.00 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define SELECT_OUTLINE_R 1.35 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define SELECT_OUTLINE_G 0.35 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define SELECT_OUTLINE_B 1.75 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
|
||||
//#define WORLD_OUTLINE
|
||||
#define WORLD_OUTLINE_THICKNESS 1 //[1 2 3 4]
|
||||
#define WORLD_OUTLINE_I 1.50 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00]
|
||||
//#define DARK_OUTLINE
|
||||
#define DARK_OUTLINE_THICKNESS 1 //[1 2]
|
||||
|
||||
#define HAND_SWAYING 0 //[0 1 2 3]
|
||||
#define SHOW_LIGHT_LEVEL 0 //[0 1 2 3]
|
||||
//#define REDUCE_CLOSE_PARTICLES
|
||||
//#define LESS_LAVA_FOG
|
||||
//#define SNOWY_WORLD
|
||||
//#define COLOR_CODED_PROGRAMS
|
||||
|
||||
//#define MOON_PHASE_INF_LIGHT
|
||||
#define MOON_PHASE_INF_REFLECTION
|
||||
#define MOON_PHASE_FULL 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define MOON_PHASE_PARTIAL 0.85 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define MOON_PHASE_DARK 0.60 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
|
||||
#define T_EXPOSURE 1.40 //[0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.10 2.20 2.30 2.40 2.50 2.60 2.70 2.80]
|
||||
#define TM_WHITE_CURVE 2.0 //[1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0]
|
||||
#define T_LOWER_CURVE 1.20 //[0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define T_UPPER_CURVE 1.30 //[0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define T_SATURATION 1.00 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
#define T_VIBRANCE 1.00 //[0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00]
|
||||
//#define COLORGRADING
|
||||
#define GR_RR 100 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_RG 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_RB 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_RC 1.00 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define GR_GR 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_GG 100 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_GB 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_GC 1.00 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
#define GR_BR 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_BG 0 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_BB 100 //[0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 108 116 124 132 140 148 156 164 172 180 188 196 200 212 224 236 248 260 272 284 296 300 316 332 348 364 380 396 400 424 448 472 496 500]
|
||||
#define GR_BC 1.00 //[0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00 2.20 2.40 2.60 2.80 3.00 3.25 3.50 3.75 4.00 4.50 5.00]
|
||||
|
||||
//#define LIGHT_COLOR_MULTS
|
||||
//#define ATM_COLOR_MULTS
|
||||
#define LIGHT_MORNING_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_MORNING_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_MORNING_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_MORNING_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_MORNING_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_MORNING_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_MORNING_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_MORNING_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NOON_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NOON_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NOON_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NOON_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NOON_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NOON_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NOON_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NOON_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NIGHT_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NIGHT_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NIGHT_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NIGHT_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NIGHT_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NIGHT_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NIGHT_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NIGHT_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_RAIN_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_RAIN_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_RAIN_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_RAIN_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_RAIN_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_RAIN_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_RAIN_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_RAIN_I 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NETHER_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NETHER_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NETHER_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_NETHER_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NETHER_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NETHER_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NETHER_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_NETHER_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_END_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_END_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_END_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define LIGHT_END_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_END_R 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_END_G 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_END_B 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define ATM_END_I 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
|
||||
#define XLIGHT_R 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define XLIGHT_G 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
#define XLIGHT_B 1.00 //[0.01 0.03 0.05 0.07 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00]
|
||||
|
||||
//#define LIGHT_COLORING
|
||||
|
||||
#define EYES
|
||||
#define EYE_FREQUENCY 1.0 //[0.8 0.9 1.0 1.1 1.2 1.3 1.4 1.5]
|
||||
#define EYE_SPEED 1.0 //[0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 2.2 2.4 2.6 2.8 3.0]
|
||||
#define EYE_RED_PROBABILITY 0.07 //[0.00 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.20 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.30 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.40 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.50 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.60 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.70 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.80 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.90 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1.00]
|
||||
#define BLOOD_MOON 1 //[0 1 2] Off, Full Moon, Every Moon
|
||||
#define EMISSIVE_BLOOD_MOON_FLOWERS
|
||||
|
||||
//Internal Settings//
|
||||
#define SIDE_SHADOWING
|
||||
#define SHADOW_FILTERING
|
||||
|
||||
#define GLASS_OPACITY 0.25
|
||||
#define FANCY_NETHERPORTAL
|
||||
|
||||
#define DIRECTIONAL_SHADING
|
||||
|
||||
#define ATMOSPHERIC_FOG
|
||||
#define BLOOM_FOG
|
||||
|
||||
#define GLOWING_ENTITY_FIX
|
||||
#define FLICKERING_FIX
|
||||
//#define SAFER_GENERATED_NORMALS
|
||||
|
||||
//Extensions//
|
||||
#extension GL_ARB_shader_image_load_store : enable
|
||||
|
||||
//Information//
|
||||
#define info0 0 //[0]
|
||||
#define info1 0 //[0]
|
||||
#define info2 0 //[0]
|
||||
#define info3 0 //[0]
|
||||
#define info4 0 //[0]
|
||||
#define info5 0 //[0]
|
||||
#define info6 0 //[0]
|
||||
#define info7 0 //[0]
|
||||
#define info8 0 //[0]
|
||||
#define info9 0 //[0]
|
||||
#define info10 0 //[0]
|
||||
|
||||
//Visual Style and Performance Setting Handling//
|
||||
#if SHADER_STYLE == 1
|
||||
#define WATER_STYLE_DEFAULT 1
|
||||
//#define WATER_CAUSTIC_STYLE_DEFAULT 1
|
||||
#define AURORA_STYLE_DEFAULT 1
|
||||
#define SUN_MOON_STYLE_DEFAULT 1
|
||||
#define CLOUD_STYLE_DEFAULT 1
|
||||
#elif SHADER_STYLE == 4
|
||||
#define WATER_STYLE_DEFAULT 3
|
||||
//#define WATER_CAUSTIC_STYLE_DEFAULT 3
|
||||
#define AURORA_STYLE_DEFAULT 2
|
||||
#define SUN_MOON_STYLE_DEFAULT 3
|
||||
#define CLOUD_STYLE_DEFAULT 3
|
||||
#endif
|
||||
#if WATER_STYLE_DEFINE == -1
|
||||
#define WATER_STYLE WATER_STYLE_DEFAULT
|
||||
#else
|
||||
#define WATER_STYLE WATER_STYLE_DEFINE
|
||||
#endif
|
||||
#if WATER_CAUSTIC_STYLE_DEFINE == -1
|
||||
#define WATER_CAUSTIC_STYLE WATER_STYLE
|
||||
#else
|
||||
#define WATER_CAUSTIC_STYLE WATER_CAUSTIC_STYLE_DEFINE
|
||||
#endif
|
||||
#if AURORA_STYLE_DEFINE == -1
|
||||
#define AURORA_STYLE AURORA_STYLE_DEFAULT
|
||||
#else
|
||||
#define AURORA_STYLE AURORA_STYLE_DEFINE
|
||||
#endif
|
||||
#if SUN_MOON_STYLE_DEFINE == -1
|
||||
#define SUN_MOON_STYLE SUN_MOON_STYLE_DEFAULT
|
||||
#else
|
||||
#define SUN_MOON_STYLE SUN_MOON_STYLE_DEFINE
|
||||
#endif
|
||||
#if CLOUD_STYLE_DEFINE == -1
|
||||
#define CLOUD_STYLE CLOUD_STYLE_DEFAULT
|
||||
#else
|
||||
#define CLOUD_STYLE CLOUD_STYLE_DEFINE
|
||||
#endif
|
||||
// Thanks to SpacEagle17 and isuewo for the sun angle handling
|
||||
#if SUN_ANGLE == -1
|
||||
#if SHADER_STYLE == 1
|
||||
const float sunPathRotation = 0.0;
|
||||
#define PERPENDICULAR_TWEAKS
|
||||
#elif SHADER_STYLE == 4
|
||||
const float sunPathRotation = -40.0;
|
||||
#endif
|
||||
#elif SUN_ANGLE == 0
|
||||
const float sunPathRotation = 0.0;
|
||||
#define PERPENDICULAR_TWEAKS
|
||||
#elif SUN_ANGLE == 20
|
||||
const float sunPathRotation = 20.0;
|
||||
#elif SUN_ANGLE == 30
|
||||
const float sunPathRotation = 30.0;
|
||||
#elif SUN_ANGLE == 40
|
||||
const float sunPathRotation = 40.0;
|
||||
#elif SUN_ANGLE == 50
|
||||
const float sunPathRotation = 50.0;
|
||||
#elif SUN_ANGLE == 60
|
||||
const float sunPathRotation = 60.0;
|
||||
#elif SUN_ANGLE == -20
|
||||
const float sunPathRotation = -20.0;
|
||||
#elif SUN_ANGLE == -30
|
||||
const float sunPathRotation = -30.0;
|
||||
#elif SUN_ANGLE == -40
|
||||
const float sunPathRotation = -40.0;
|
||||
#elif SUN_ANGLE == -50
|
||||
const float sunPathRotation = -50.0;
|
||||
#elif SUN_ANGLE == -60
|
||||
const float sunPathRotation = -60.0;
|
||||
#endif
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
const int shadowMapResolution = 2048;
|
||||
#else
|
||||
const int shadowMapResolution = 1024;
|
||||
#endif
|
||||
|
||||
#if SSAO_I > 0
|
||||
#define SSAO_QUALI SSAO_QUALI_DEFINE
|
||||
#else
|
||||
#define SSAO_QUALI 0
|
||||
#endif
|
||||
#if LIGHTSHAFT_BEHAVIOUR > 0
|
||||
#define LIGHTSHAFT_QUALI LIGHTSHAFT_QUALI_DEFINE
|
||||
#else
|
||||
#define LIGHTSHAFT_QUALI 0
|
||||
#endif
|
||||
|
||||
#if BLOCK_REFLECT_QUALITY >= 1
|
||||
#define LIGHT_HIGHLIGHT
|
||||
#endif
|
||||
#if BLOCK_REFLECT_QUALITY >= 2 && RP_MODE >= 1
|
||||
#define PBR_REFLECTIONS
|
||||
#endif
|
||||
#if BLOCK_REFLECT_QUALITY >= 3
|
||||
#define TEMPORAL_FILTER
|
||||
#endif
|
||||
|
||||
#if DETAIL_QUALITY == 0
|
||||
#undef PERPENDICULAR_TWEAKS
|
||||
#define LOW_QUALITY_NETHER_STORM
|
||||
#define LOW_QUALITY_ENDER_NEBULA
|
||||
#endif
|
||||
#if DETAIL_QUALITY >= 1
|
||||
#define TAA
|
||||
#endif
|
||||
#if DETAIL_QUALITY >= 2
|
||||
|
||||
#endif
|
||||
#if DETAIL_QUALITY >= 3
|
||||
#define HQ_NIGHT_NEBULA
|
||||
#endif
|
||||
|
||||
//Define Handling//
|
||||
#ifdef OVERWORLD
|
||||
#if CLOUD_STYLE > 0 && CLOUD_STYLE != 50 && CLOUD_QUALITY > 0
|
||||
#define VL_CLOUDS_ACTIVE
|
||||
#if CLOUD_STYLE == 1
|
||||
#define CLOUDS_REIMAGINED
|
||||
#endif
|
||||
#if CLOUD_STYLE == 3
|
||||
#define CLOUDS_UNBOUND
|
||||
#endif
|
||||
#endif
|
||||
#else
|
||||
#undef LIGHT_HIGHLIGHT
|
||||
#undef CAVE_FOG
|
||||
#undef CLOUD_SHADOWS
|
||||
#undef SNOWY_WORLD
|
||||
#undef LENSFLARE
|
||||
#endif
|
||||
#ifdef NETHER
|
||||
#undef ATMOSPHERIC_FOG
|
||||
#else
|
||||
#undef NETHER_STORM
|
||||
#endif
|
||||
#ifdef END
|
||||
#undef BLOOM_FOG
|
||||
#endif
|
||||
|
||||
#ifndef BLOOM
|
||||
#undef BLOOM_FOG
|
||||
#endif
|
||||
|
||||
#ifdef BLOOM_FOG
|
||||
#if WORLD_BLUR > 0
|
||||
#define BLOOM_FOG_COMPOSITE3
|
||||
#elif defined MOTION_BLURRING
|
||||
#define BLOOM_FOG_COMPOSITE2
|
||||
#else
|
||||
#define BLOOM_FOG_COMPOSITE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined GBUFFERS_HAND || defined GBUFFERS_ENTITIES
|
||||
#undef SNOWY_WORLD
|
||||
#endif
|
||||
#if defined GBUFFERS_TEXTURED || defined GBUFFERS_BASIC
|
||||
#undef LIGHT_HIGHLIGHT
|
||||
#undef DIRECTIONAL_SHADING
|
||||
#undef SIDE_SHADOWING
|
||||
#endif
|
||||
#ifdef GBUFFERS_WATER
|
||||
#undef LIGHT_HIGHLIGHT
|
||||
#endif
|
||||
|
||||
#ifndef GLOWING_ENTITY_FIX
|
||||
#undef GBUFFERS_ENTITIES_GLOWING
|
||||
#endif
|
||||
|
||||
#if LIGHTSHAFT_QUALI > 0 && defined OVERWORLD && defined REALTIME_SHADOWS || defined END
|
||||
#define LIGHTSHAFTS_ACTIVE
|
||||
#endif
|
||||
|
||||
#if defined WAVING_FOLIAGE || defined WAVING_LEAVES || defined WAVING_LAVA
|
||||
#define WAVING_ANYTHING_TERRAIN
|
||||
#endif
|
||||
|
||||
#ifdef IS_IRIS
|
||||
#undef FANCY_GLASS
|
||||
#endif
|
||||
|
||||
#if WATERCOLOR_R != 100 || WATERCOLOR_G != 100 || WATERCOLOR_B != 100
|
||||
#define WATERCOLOR_RM WATERCOLOR_R * 0.01
|
||||
#define WATERCOLOR_GM WATERCOLOR_G * 0.01
|
||||
#define WATERCOLOR_BM WATERCOLOR_B * 0.01
|
||||
#define WATERCOLOR_CHANGED
|
||||
#endif
|
||||
|
||||
#if UNDERWATERCOLOR_R != 100 || UNDERWATERCOLOR_G != 100 || UNDERWATERCOLOR_B != 100
|
||||
#define UNDERWATERCOLOR_RM UNDERWATERCOLOR_R * 0.01
|
||||
#define UNDERWATERCOLOR_GM UNDERWATERCOLOR_G * 0.01
|
||||
#define UNDERWATERCOLOR_BM UNDERWATERCOLOR_B * 0.01
|
||||
#define UNDERWATERCOLOR_CHANGED
|
||||
#endif
|
||||
|
||||
//Activate Settings//
|
||||
#ifdef ENTITY_SHADOWS
|
||||
#endif
|
||||
#ifdef POM_ALLOW_CUTOUT
|
||||
#endif
|
||||
#ifdef CLOUD_CLOSED_AREA_CHECK
|
||||
#endif
|
||||
#ifdef BRIGHT_CAVE_WATER
|
||||
#endif
|
||||
|
||||
//Very Common Uniforms//
|
||||
uniform int worldTime;
|
||||
uniform int worldDay;
|
||||
|
||||
uniform float rainFactor;
|
||||
uniform float screenBrightness;
|
||||
uniform float eyeBrightnessM;
|
||||
|
||||
uniform vec3 fogColor;
|
||||
|
||||
#if NETHER_COLOR_MODE == 3
|
||||
uniform float inNetherWastes;
|
||||
uniform float inCrimsonForest;
|
||||
uniform float inWarpedForest;
|
||||
uniform float inBasaltDeltas;
|
||||
uniform float inSoulValley;
|
||||
#endif
|
||||
|
||||
#ifdef VERTEX_SHADER
|
||||
uniform mat4 gbufferModelView;
|
||||
#endif
|
||||
|
||||
//Very Common Variables//
|
||||
const float OSIEBCA = 1.0 / 255.0; // One Step In Eight Bit Color Attachment
|
||||
/* materialMask steps
|
||||
IntegratedPBR:
|
||||
OSIEBCA * 1.0 = Intense Fresnel
|
||||
OSIEBCA * 2.0 = Copper Fresnel
|
||||
OSIEBCA * 3.0 = Gold Fresnel
|
||||
OSIEBCA * 4.0 =
|
||||
OSIEBCA * 5.0 = Redstone Fresnel
|
||||
.
|
||||
OSIEBCA * 240.0 = Green Screen Lime Blocks
|
||||
PBR Independant: (Limited to 241 and above)
|
||||
OSIEBCA * 241.0 = Water
|
||||
.
|
||||
OSIEBCA * 252.0 = Versatile Selection Outline
|
||||
OSIEBCA * 253.0 = Reduced Edge TAA
|
||||
OSIEBCA * 254.0 = No SSAO, No TAA
|
||||
OSIEBCA * 255.0 = *Unused as 1.0 is the clear color*
|
||||
*/
|
||||
|
||||
float cloudMaxAdd = 5.0;
|
||||
uniform float cloudHeight = 192.0;
|
||||
uniform float eyeAltitude;
|
||||
#if defined DOUBLE_REIM_CLOUDS && defined CLOUDS_REIMAGINED
|
||||
float maximumCloudsHeight = max(CLOUD_ALT1, CLOUD_ALT2) + cloudMaxAdd;
|
||||
#elif CLOUD_STYLE_DEFINE == 50
|
||||
float maximumCloudsHeight = cloudHeight + cloudMaxAdd;
|
||||
#else
|
||||
float maximumCloudsHeight = CLOUD_ALT1 + cloudMaxAdd;
|
||||
#endif
|
||||
float cloudGradientLength = 30.0; // in blocks, probably...
|
||||
float heightRelativeToCloud = clamp(1.0 - (eyeAltitude - maximumCloudsHeight) / cloudGradientLength, 0.0, 1.0);
|
||||
|
||||
const float shadowMapBias = 1.0 - 25.6 / shadowDistance;
|
||||
float timeAngle = worldTime / 24000.0;
|
||||
float noonFactor = sqrt(max(sin(timeAngle*6.28318530718),0.0));
|
||||
float nightFactor = max(sin(timeAngle*(-6.28318530718)),0.0);
|
||||
float invNightFactor = 1.0 - nightFactor;
|
||||
float rainFactor2 = rainFactor * rainFactor;
|
||||
float invRainFactor = 1.0 - rainFactor;
|
||||
float invRainFactorSqrt = 1.0 - rainFactor * rainFactor;
|
||||
float invNoonFactor = 1.0 - noonFactor;
|
||||
float invNoonFactor2 = invNoonFactor * invNoonFactor;
|
||||
|
||||
float vsBrightness = clamp(screenBrightness, 0.0, 1.0);
|
||||
|
||||
int modifiedWorldDay = int(mod(worldDay, 100) + 5.0);
|
||||
float syncedTime = (worldTime + modifiedWorldDay * 24000) * 0.05;
|
||||
|
||||
const float pi = 3.14159265359;
|
||||
|
||||
const float oceanAltitude = 61.9;
|
||||
|
||||
const vec3 blocklightCol = vec3(0.2, 0.1098, 0.0431) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B);
|
||||
|
||||
const vec3 caveFogColorRaw = vec3(0.13, 0.13, 0.15);
|
||||
#if MINIMUM_LIGHT_MODE <= 1
|
||||
vec3 caveFogColor = caveFogColorRaw * 0.7;
|
||||
#elif MINIMUM_LIGHT_MODE == 2
|
||||
vec3 caveFogColor = caveFogColorRaw * (0.7 + 0.3 * vsBrightness); // Default
|
||||
#elif MINIMUM_LIGHT_MODE >= 3
|
||||
vec3 caveFogColor = caveFogColorRaw;
|
||||
#endif
|
||||
|
||||
#if WATERCOLOR_MODE >= 2
|
||||
vec3 underwaterColorM1 = pow(fogColor, vec3(0.33, 0.21, 0.26));
|
||||
#else
|
||||
vec3 underwaterColorM1 = vec3(0.46, 0.62, 1.0);
|
||||
#endif
|
||||
#ifndef UNDERWATERCOLOR_CHANGED
|
||||
vec3 underwaterColorM2 = underwaterColorM1;
|
||||
#else
|
||||
vec3 underwaterColorM2 = underwaterColorM1 * vec3(UNDERWATERCOLOR_RM, UNDERWATERCOLOR_GM, UNDERWATERCOLOR_BM);
|
||||
#endif
|
||||
vec3 waterFogColor = underwaterColorM2 * vec3(0.2 + 0.1 * vsBrightness);
|
||||
|
||||
#if NETHER_COLOR_MODE == 3 && defined FRAGMENT_SHADER
|
||||
float netherColorMixer = inNetherWastes + inCrimsonForest + inWarpedForest + inBasaltDeltas + inSoulValley;
|
||||
vec3 netherColor = mix(
|
||||
fogColor * 0.6 + 0.2 * normalize(fogColor + 0.0001),
|
||||
(
|
||||
inNetherWastes * vec3(0.38, 0.15, 0.05) + inCrimsonForest * vec3(0.33, 0.07, 0.04) +
|
||||
inWarpedForest * vec3(0.18, 0.1, 0.25) + inBasaltDeltas * vec3(0.25, 0.235, 0.23) +
|
||||
inSoulValley * vec3(0.1, vec2(0.24))
|
||||
),
|
||||
netherColorMixer
|
||||
);
|
||||
#elif NETHER_COLOR_MODE == 2
|
||||
vec3 netherColor = fogColor * 0.6 + 0.2 * normalize(fogColor + 0.0001);
|
||||
#elif NETHER_COLOR_MODE == 0
|
||||
vec3 netherColor = vec3(0.7, 0.26, 0.08) * 0.6;
|
||||
#endif
|
||||
vec3 lavaLightColor = vec3(0.15, 0.06, 0.01);
|
||||
|
||||
const vec3 endSkyColor = vec3(0.095, 0.07, 0.15) * 1.5;
|
||||
|
||||
#if WEATHER_TEX_OPACITY == 100
|
||||
const float rainTexOpacity = 0.35;
|
||||
const float snowTexOpacity = 0.5;
|
||||
#else
|
||||
#define WEATHER_TEX_OPACITY_M 100.0 / WEATHER_TEX_OPACITY
|
||||
const float rainTexOpacity = pow(0.35, WEATHER_TEX_OPACITY_M);
|
||||
const float snowTexOpacity = pow(0.5, WEATHER_TEX_OPACITY_M);
|
||||
#endif
|
||||
|
||||
#ifdef FRAGMENT_SHADER
|
||||
ivec2 texelCoord = ivec2(gl_FragCoord.xy);
|
||||
#endif
|
||||
|
||||
const int cloudAlt1i = int(CLOUD_ALT1); // Old setting files can send float values
|
||||
const int cloudAlt2i = int(CLOUD_ALT2);
|
||||
|
||||
//Very Common Functions//
|
||||
#include "/spookylib/util/commonFunctions.glsl"
|
||||
|
||||
// 62 75 74 20 74 68 4F 73 65 20 77 68 6F 20 68 6F 70 65 20 69 6E 20 74 68 65 20 6C 69 6D 69 4E 61 6C 0A 77 69 6C 6C 20 72 65 6E 65 77 20 74 68 65 69 72 20 73 54 72 65 6E 67 74 48 2E 0A 74 68 65 79 20 77 69 6C 6C 20 73 6F 41 72 20 6F 6E 20 65 6C 79 54 72 61 73 20 6C 69 6B 65 20 70 68 61 6E 74 6F 6D 73 3B 0A 74 68 65 79 20 77 69 6C 6C 20 72 75 6E 20 61 6E 44 20 6E 6F 74 20 67 72 6F 77 20 77 65 41 72 79 2C 0A 74 68 65 59 20 77 69 6C 6C 20 77 61 6C 6B 20 61 6E 64 20 6E 6F 74 20 62 65 20 66 61 69 6E 74 2E
|
||||
@ -0,0 +1,60 @@
|
||||
// GGX area light approximation from Horizon Zero Dawn
|
||||
float GetNoHSquared(float radiusTan, float NoL, float NoV, float VoL) {
|
||||
float radiusCos = 1.0 / sqrt(1.0 + radiusTan * radiusTan);
|
||||
|
||||
float RoL = 2.0 * NoL * NoV - VoL;
|
||||
if (RoL >= radiusCos)
|
||||
return 1.0;
|
||||
|
||||
float rOverLengthT = radiusCos * radiusTan / sqrt(1.0 - RoL * RoL);
|
||||
float NoTr = rOverLengthT * (NoV - RoL * NoL);
|
||||
float VoTr = rOverLengthT * (2.0 * NoV * NoV - 1.0 - RoL * VoL);
|
||||
|
||||
float triple = sqrt(clamp(1.0 - NoL * NoL - NoV * NoV - VoL * VoL + 2.0 * NoL * NoV * VoL, 0.0, 1.0));
|
||||
|
||||
float NoBr = rOverLengthT * triple, VoBr = rOverLengthT * (2.0 * triple * NoV);
|
||||
float NoLVTr = NoL * radiusCos + NoV + NoTr, VoLVTr = VoL * radiusCos + 1.0 + VoTr;
|
||||
float p = NoBr * VoLVTr, q = NoLVTr * VoLVTr, s = VoBr * NoLVTr;
|
||||
float xNum = q * (-0.5 * p + 0.25 * VoBr * NoLVTr);
|
||||
float xDenom = p * p + s * ((s - 2.0 * p)) + NoLVTr * ((NoL * radiusCos + NoV) * VoLVTr * VoLVTr +
|
||||
q * (-0.5 * (VoLVTr + VoL * radiusCos) - 0.5));
|
||||
float twoX1 = 2.0 * xNum / (xDenom * xDenom + xNum * xNum);
|
||||
float sinTheta = twoX1 * xDenom;
|
||||
float cosTheta = 1.0 - twoX1 * xNum;
|
||||
NoTr = cosTheta * NoTr + sinTheta * NoBr;
|
||||
VoTr = cosTheta * VoTr + sinTheta * VoBr;
|
||||
|
||||
float newNoL = NoL * radiusCos + NoTr;
|
||||
float newVoL = VoL * radiusCos + VoTr;
|
||||
float NoH = NoV + newNoL;
|
||||
float HoH = 2.0 * newVoL + 2.0;
|
||||
return clamp(NoH * NoH / HoH, 0.0, 1.0);
|
||||
}
|
||||
|
||||
float GGX(vec3 normalM, vec3 viewPos, vec3 lightVec, float NdotLmax0, float smoothnessG) {
|
||||
smoothnessG = sqrt1(smoothnessG * 0.9 + 0.1);
|
||||
float roughnessP = (1.35 - smoothnessG);
|
||||
float roughness = pow2(pow2(roughnessP));
|
||||
|
||||
vec3 halfVec = normalize(lightVec - viewPos);
|
||||
|
||||
float dotLH = clamp(dot(halfVec, lightVec), 0.0, 1.0);
|
||||
float dotNV = dot(normalM, -viewPos);
|
||||
|
||||
#if WATER_REFLECT_QUALITY >= 2
|
||||
float dotNH = GetNoHSquared(0.01, NdotLmax0, dotNV, dot(-viewPos, lightVec));
|
||||
#else
|
||||
float dotNH = pow2(min1(2.0 * NdotLmax0 * dotNV * length(halfVec) - dot(-viewPos, lightVec)));
|
||||
#endif
|
||||
|
||||
float denom = dotNH * roughness - dotNH + 1.0;
|
||||
float D = roughness / (3.141592653589793 * pow2(denom));
|
||||
float f0 = 0.05;
|
||||
float F = exp2((-5.55473 * dotLH - 6.98316) * dotLH) * (1.0 - f0) + f0;
|
||||
|
||||
float NdotLmax0M = sqrt3(NdotLmax0 * max0(dot(normal, lightVec)));
|
||||
float specular = max0(NdotLmax0M * D * F / pow2(dotLH));
|
||||
specular = specular / (0.125 * specular + 1.0);
|
||||
|
||||
return specular;
|
||||
}
|
||||
@ -0,0 +1,502 @@
|
||||
//Lighting Uniforms//
|
||||
uniform float darknessLightFactor;
|
||||
|
||||
#if HELD_LIGHTING_MODE >= 1
|
||||
uniform int heldBlockLightValue;
|
||||
uniform int heldBlockLightValue2;
|
||||
#endif
|
||||
|
||||
//Lighting Includes//
|
||||
#include "/spookylib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/spookylib/lighting/ggx.glsl"
|
||||
|
||||
#if defined REALTIME_SHADOWS && (defined OVERWORLD || defined END)
|
||||
#include "/spookylib/lighting/shadowSampling.glsl"
|
||||
#endif
|
||||
|
||||
#if defined CLOUDS_REIMAGINED && defined CLOUD_SHADOWS
|
||||
#if !defined GBUFFERS_WATER || WATER_STYLE == 1
|
||||
uniform sampler2D gaux4;
|
||||
#endif
|
||||
|
||||
#include "/spookylib/atmospherics/clouds/cloudCoord.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
#include "/spookylib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MOON_PHASE_INF_LIGHT || defined MOON_PHASE_INF_REFLECTION
|
||||
#include "/spookylib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
//
|
||||
vec3 highlightColor = normalize(pow(lightColor, vec3(0.37))) * (0.3 + 1.5 * sunVisibility2) * (1.0 - 0.85 * rainFactor);
|
||||
|
||||
//Lighting//
|
||||
void DoLighting(inout vec4 color, inout vec3 shadowMult, vec3 playerPos, vec3 viewPos, float lViewPos, vec3 normalM, vec2 lightmap,
|
||||
bool noSmoothLighting, bool noDirectionalShading, bool noVanillaAO, bool centerShadowBias,
|
||||
int subsurfaceMode, float smoothnessG, float highlightMult, float emission) {
|
||||
lightmap.x *= 0.85;
|
||||
float lightmapY2 = pow2(lightmap.y);
|
||||
float lightmapYM = smoothstep1(lightmap.y);
|
||||
float subsurfaceHighlight = 0.0;
|
||||
float ambientMult = 1.0;
|
||||
vec3 lightColorM = lightColor;
|
||||
vec3 ambientColorM = ambientColor;
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
|
||||
#if defined LIGHT_COLOR_MULTS && !defined GBUFFERS_WATER // lightColorMult is defined early in gbuffers_water
|
||||
lightColorMult = GetLightColorMult();
|
||||
#endif
|
||||
|
||||
vec3 normalLighting = ViewToPlayer(normal);
|
||||
#ifdef IS_IRIS
|
||||
vec2 lightningAdd = lightningFlashEffect(playerPos, lightningBoltPosition.xyz, normalLighting, 450.0) * lightningBoltPosition.w * 5.0;
|
||||
ambientColorM += lightningAdd.x;
|
||||
#else
|
||||
vec2 lightningAdd = lightningFlashEffect(playerPos, vec3(0.0), normalLighting, 450.0) * lightningFlashOptifine * 5.0;
|
||||
ambientColorM += lightningAdd.x;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float skyLightShadowMult = pow2(pow2(lightmapY2));
|
||||
#else
|
||||
float skyLightShadowMult = 1.0;
|
||||
#endif
|
||||
|
||||
#if defined SIDE_SHADOWING || defined DIRECTIONAL_SHADING
|
||||
float NdotN = dot(normalM, northVec);
|
||||
float absNdotN = abs(NdotN);
|
||||
#endif
|
||||
|
||||
#if defined CUSTOM_PBR || defined GENERATED_NORMALS
|
||||
float NPdotU = abs(dot(normal, upVec));
|
||||
#endif
|
||||
|
||||
// Shadows
|
||||
#if defined OVERWORLD || defined END
|
||||
float NdotL = dot(normalM, lightVec);
|
||||
#ifdef GBUFFERS_WATER
|
||||
//NdotL = mix(NdotL, 1.0, 1.0 - color.a);
|
||||
#endif
|
||||
#ifdef CUSTOM_PBR
|
||||
float geoNdotLM = dot(normal, lightVec);
|
||||
if (geoNdotLM > 0.0) geoNdotLM *= 10.0;
|
||||
NdotL = min(geoNdotLM, NdotL);
|
||||
|
||||
NdotL *= 1.0 - 0.7 * (1.0 - pow2(pow2(NdotUmax0))) * NPdotU;
|
||||
#endif
|
||||
#if !defined REALTIME_SHADOWS && defined GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode == 1) {
|
||||
NdotU = 1.0;
|
||||
NdotUmax0 = 1.0;
|
||||
NdotL = dot(upVec, lightVec);
|
||||
} else if (subsurfaceMode == 2) {
|
||||
highlightMult *= NdotL;
|
||||
NdotL = mix(NdotL, 1.0, 0.35);
|
||||
}
|
||||
|
||||
subsurfaceMode = 0;
|
||||
#endif
|
||||
float NdotLmax0 = max0(NdotL);
|
||||
float NdotLM = NdotLmax0 * 0.9999;
|
||||
|
||||
#ifndef GBUFFERS_TEXTURED
|
||||
#if defined GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode != 0) NdotLM = 1.0;
|
||||
#ifdef SIDE_SHADOWING
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
#ifdef SIDE_SHADOWING
|
||||
NdotLM = max0(NdotL + 0.4) * 0.714;
|
||||
|
||||
#ifdef END
|
||||
NdotLM = sqrt3(NdotLM);
|
||||
#endif
|
||||
#endif
|
||||
#else
|
||||
NdotLM = 1.0;
|
||||
#endif
|
||||
|
||||
#if !defined ENTITY_SHADOWS && (defined GBUFFERS_ENTITIES || defined GBUFFERS_BLOCK)
|
||||
lightColorM = mix(lightColorM * 0.75, ambientColorM, 0.5 * pow2(pow2(1.0 - NdotLM)));
|
||||
NdotLM = NdotLM * 0.75 + 0.25;
|
||||
#endif
|
||||
|
||||
if (shadowMult.r > 0.00001) {
|
||||
#ifdef REALTIME_SHADOWS
|
||||
if (NdotLM > 0.0001) {
|
||||
vec3 shadowMultBeforeLighting = shadowMult;
|
||||
float shadowLength = shadowDistance * 0.9166667 - length(vec4(playerPos.x, playerPos.y, playerPos.y, playerPos.z));
|
||||
|
||||
if (shadowLength > 0.000001) {
|
||||
float offset = 0.0009765;
|
||||
|
||||
vec3 playerPosM = playerPos;
|
||||
|
||||
#if PIXEL_SHADOW > 0 && !defined GBUFFERS_HAND
|
||||
playerPosM = floor((playerPosM + cameraPosition) * PIXEL_SHADOW + 0.001) / PIXEL_SHADOW - cameraPosition + 0.5 / PIXEL_SHADOW;
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_TEXTURED
|
||||
// Shadow bias without peter-panning
|
||||
vec3 worldNormal = normalize(ViewToPlayer(normal*1000.0));
|
||||
float distanceBias = pow(dot(playerPos, playerPos), 0.75);
|
||||
distanceBias = 0.12 + 0.0008 * distanceBias;
|
||||
vec3 bias = worldNormal * distanceBias * (2.0 - 0.95 * NdotLmax0); // 0.95 fixes pink petals noon shadows
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode == 2) {
|
||||
bias *= vec3(0.0, 0.0, -0.75);
|
||||
} else if (subsurfaceMode == 1) {
|
||||
bias *= 1.0 - lightmapYM;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Fix light leaking in caves
|
||||
if (lightmapYM < 0.999) {
|
||||
#ifdef GBUFFERS_HAND
|
||||
playerPosM = mix(vec3(0.0), playerPosM, 0.2 + 0.8 * lightmapYM);
|
||||
#else
|
||||
if (centerShadowBias) {
|
||||
#ifdef OVERWORLD
|
||||
vec3 centerPos = floor(playerPosM + cameraPosition) - cameraPosition + 0.5;
|
||||
playerPosM = mix(centerPos, playerPosM, 0.5 + 0.5 * lightmapYM);
|
||||
#endif
|
||||
} else {
|
||||
vec3 edgeFactor = 0.2 * (0.5 - fract(playerPosM + cameraPosition + worldNormal * 0.01));
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
bias *= 0.7;
|
||||
playerPosM += (1.0 - lightmapYM) * edgeFactor;
|
||||
#endif
|
||||
|
||||
playerPosM += (1.0 - pow2(pow2(max(glColor.a, lightmapYM)))) * edgeFactor;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
playerPosM += bias;
|
||||
#else
|
||||
vec3 centerplayerPos = floor(playerPosM + cameraPosition) - cameraPosition + 0.5;
|
||||
playerPosM = mix(centerplayerPos, playerPosM + vec3(0.0, 0.02, 0.0), lightmapYM);
|
||||
#endif
|
||||
|
||||
vec3 shadowPos = GetShadowPos(playerPosM);
|
||||
|
||||
bool leaves = false;
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode == 0) {
|
||||
#if defined PERPENDICULAR_TWEAKS && defined SIDE_SHADOWING
|
||||
offset *= 1.0 + pow2(absNdotN);
|
||||
#endif
|
||||
} else {
|
||||
float VdotL = dot(nViewPos, lightVec);
|
||||
float lightFactor = pow(max(VdotL, 0.0), 10.0) * float(isEyeInWater == 0);
|
||||
if (subsurfaceMode == 1) {
|
||||
offset = 0.0010235 * lightmapYM + 0.0009765;
|
||||
shadowPos.z -= max(NdotL * 0.0001, 0.0) * lightmapYM;
|
||||
subsurfaceHighlight = lightFactor * 0.8;
|
||||
#ifndef SHADOW_FILTERING
|
||||
shadowPos.z -= 0.0002;
|
||||
#endif
|
||||
} else {
|
||||
leaves = true;
|
||||
offset = 0.0005235 * lightmapYM + 0.0009765;
|
||||
shadowPos.z -= 0.000175 * lightmapYM;
|
||||
subsurfaceHighlight = lightFactor * 0.6;
|
||||
#ifndef SHADOW_FILTERING
|
||||
NdotLM = mix(NdotL, NdotLM, 0.5);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
shadowMult *= GetShadow(shadowPos, lViewPos, lightmap.y, offset, leaves);
|
||||
}
|
||||
|
||||
float shadowSmooth = 16.0;
|
||||
if (shadowLength < shadowSmooth) {
|
||||
float shadowMixer = max0(shadowLength / shadowSmooth);
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode != 0) {
|
||||
float shadowMixerM = pow2(shadowMixer);
|
||||
|
||||
if (subsurfaceMode == 1) skyLightShadowMult *= mix(0.6 + 0.3 * pow2(noonFactor), 1.0, shadowMixerM);
|
||||
else skyLightShadowMult *= mix(NdotL * 0.4999 + 0.5, 1.0, shadowMixerM);
|
||||
|
||||
subsurfaceHighlight *= shadowMixer;
|
||||
}
|
||||
#endif
|
||||
|
||||
shadowMult = mix(vec3(skyLightShadowMult * shadowMultBeforeLighting), shadowMult, shadowMixer);
|
||||
}
|
||||
|
||||
#ifdef CLOUD_SHADOWS
|
||||
if (shadowMult.r > 0.0001) {
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
float EdotL = dot(eastVec, lightVec);
|
||||
float EdotLM = tan(acos(EdotL));
|
||||
|
||||
#if SUN_ANGLE != 0
|
||||
float NVdotLM = tan(acos(dot(northVec, lightVec)));
|
||||
#endif
|
||||
|
||||
float distToCloudLayer1 = cloudAlt1i - worldPos.y;
|
||||
vec3 cloudOffset1 = vec3(distToCloudLayer1 / EdotLM, 0.0, 0.0);
|
||||
#if SUN_ANGLE != 0
|
||||
cloudOffset1.z += distToCloudLayer1 / NVdotLM;
|
||||
#endif
|
||||
vec2 cloudPos1 = GetRoundedCloudCoord(ModifyTracePos(worldPos + cloudOffset1, cloudAlt1i).xz);
|
||||
float cloudSample = texture2D(gaux4, cloudPos1).b;
|
||||
cloudSample *= clamp(distToCloudLayer1 * 0.1, 0.0, 1.0);
|
||||
|
||||
#ifdef DOUBLE_REIM_CLOUDS
|
||||
float distToCloudLayer2 = cloudAlt2i - worldPos.y;
|
||||
vec3 cloudOffset2 = vec3(distToCloudLayer2 / EdotLM, 0.0, 0.0);
|
||||
#if SUN_ANGLE != 0
|
||||
cloudOffset2.z += distToCloudLayer2 / NVdotLM;
|
||||
#endif
|
||||
vec2 cloudPos2 = GetRoundedCloudCoord(ModifyTracePos(worldPos + cloudOffset2, cloudAlt2i).xz);
|
||||
float cloudSample2 = texture2D(gaux4, cloudPos2).b;
|
||||
cloudSample2 *= clamp(distToCloudLayer2 * 0.1, 0.0, 1.0);
|
||||
|
||||
cloudSample = max(cloudSample, cloudSample2);
|
||||
#endif
|
||||
|
||||
cloudSample *= sqrt3(1.0 - abs(EdotL));
|
||||
shadowMult *= 1.0 - 0.85 * cloudSample;
|
||||
#else
|
||||
vec2 csPos = worldPos.xz + worldPos.y * 0.25;
|
||||
csPos.x += syncedTime;
|
||||
csPos *= 0.0002;
|
||||
|
||||
vec2 shadowoffsets[8] = vec2[8](
|
||||
vec2( 0.0 , 1.0 ),
|
||||
vec2( 0.7071, 0.7071),
|
||||
vec2( 1.0 , 0.0 ),
|
||||
vec2( 0.7071,-0.7071),
|
||||
vec2( 0.0 ,-1.0 ),
|
||||
vec2(-0.7071,-0.7071),
|
||||
vec2(-1.0 , 0.0 ),
|
||||
vec2(-0.7071, 0.7071));
|
||||
float cloudSample = 0.0;
|
||||
for (int i = 0; i < 8; i++) {
|
||||
cloudSample += texture2D(noisetex, csPos + 0.005 * shadowoffsets[i]).b;
|
||||
}
|
||||
|
||||
shadowMult *= smoothstep1(pow2(min1(cloudSample * 0.2)));
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#else
|
||||
shadowMult *= skyLightShadowMult;
|
||||
#endif
|
||||
|
||||
shadowMult *= max(NdotLM * shadowTime, 0.0);
|
||||
}
|
||||
#ifdef GBUFFERS_WATER
|
||||
else { // Low Quality Water
|
||||
shadowMult = vec3(pow2(lightmapY2) * max(NdotLM * shadowTime, 0.0));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Blocklight
|
||||
#if HELD_LIGHTING_MODE >= 1
|
||||
float heldLight = max(heldBlockLightValue, heldBlockLightValue2);
|
||||
float lViewPosL = lViewPos;
|
||||
heldLight *= 1.1;
|
||||
lViewPosL *= 2.5;
|
||||
lightmap.x = max(lightmap.x, (heldLight - lViewPosL) * 0.066666);
|
||||
#endif
|
||||
float lightmapXM;
|
||||
if (!noSmoothLighting) {
|
||||
float lightmapXMSteep = pow2(pow2(lightmap.x * lightmap.x)) * (3.8 - 0.6 * vsBrightness);
|
||||
float lightmapXMCalm = (lightmap.x) * (1.8 + 0.6 * vsBrightness);
|
||||
lightmapXM = pow(lightmapXMSteep + lightmapXMCalm, 2.25);
|
||||
} else lightmapXM = pow2(lightmap.x) * lightmap.x * 10.0;
|
||||
|
||||
vec2 flickerNoise = texture2D(noisetex, vec2(frameTimeCounter * 0.06)).rb;
|
||||
lightmapXM *= mix(1.0, min1(max(flickerNoise.r, flickerNoise.g) * 1.7), 0.7);
|
||||
|
||||
// Minimum Light
|
||||
float fadeDistance = max(1.0 - length(playerPos) / 80, 0.0);
|
||||
fadeDistance = exp((1.0 - fadeDistance) * -15.0) * (1.0 - nightVision) + nightVision;
|
||||
|
||||
#if !defined END && MINIMUM_LIGHT_MODE > 0
|
||||
#if MINIMUM_LIGHT_MODE == 1
|
||||
vec3 minLighting = vec3(0.0036) * fadeDistance;
|
||||
#elif MINIMUM_LIGHT_MODE == 2
|
||||
vec3 minLighting = vec3(0.005625 + vsBrightness * 0.043) * fadeDistance;
|
||||
#elif MINIMUM_LIGHT_MODE == 3
|
||||
vec3 minLighting = vec3(0.0625) * fadeDistance;
|
||||
#elif MINIMUM_LIGHT_MODE == 4
|
||||
vec3 minLighting = vec3(0.25) * fadeDistance;
|
||||
#endif
|
||||
|
||||
minLighting *= 1.0 - lightmapYM; //AAA
|
||||
#else
|
||||
vec3 minLighting = vec3(0.0);
|
||||
#endif
|
||||
|
||||
minLighting += nightVision * vec3(0.5, 0.5, 0.75);
|
||||
|
||||
// Lighting Tweaks
|
||||
#ifdef OVERWORLD
|
||||
ambientMult = mix(lightmapYM, pow2(lightmapYM) * lightmapYM, rainFactor);
|
||||
|
||||
#ifndef REALTIME_SHADOWS
|
||||
float tweakFactor = 1.0 + 0.6 * (1.0 - pow2(pow2(pow2(noonFactor))));
|
||||
lightColorM /= tweakFactor;
|
||||
ambientMult *= mix(tweakFactor, 1.0, 0.5 * NdotUmax0);
|
||||
#endif
|
||||
|
||||
#if AMBIENT_MULT != 100
|
||||
#define AMBIENT_MULT_M (AMBIENT_MULT - 100) * 0.006
|
||||
vec3 shadowMultP = shadowMult / (0.1 + 0.9 * sqrt2(max0(NdotLM)));
|
||||
ambientMult *= 1.0 + pow2(pow2(max0(1.0 - dot(shadowMultP, shadowMultP)))) * AMBIENT_MULT *
|
||||
(0.5 + 0.2 * sunFactor + 0.8 * noonFactor) * (1.0 - rainFactor * 0.5);
|
||||
#endif
|
||||
|
||||
if (isEyeInWater != 1) {
|
||||
float lxFactor = (sunVisibility2 * 0.4 + (0.6 - 0.6 * pow2(invNoonFactor))) * (6.0 - 5.0 * rainFactor);
|
||||
lxFactor *= lightmapY2 + lightmapY2 * 2.0 * pow2(shadowMult.r);
|
||||
lxFactor = max0(lxFactor - emission * 1000000.0);
|
||||
lightmapXM *= pow(max(lightmap.x, 0.001), lxFactor);
|
||||
|
||||
// Less light in the distance / more light closer to the camera during rain or night to simulate thicker fog
|
||||
float rainLF = 0.1 * rainFactor;
|
||||
float lightFogTweaks = 1.0 + max0(96.0 - lViewPos) * (0.002 * (1.0 - sunVisibility2) + 0.0104 * rainLF) - rainLF;
|
||||
ambientMult *= lightFogTweaks;
|
||||
lightColorM *= lightFogTweaks;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_HAND
|
||||
ambientMult *= 1.3; // To improve held map visibility
|
||||
#endif
|
||||
|
||||
// Directional Shading
|
||||
float directionShade = 1.0;
|
||||
#ifdef DIRECTIONAL_SHADING
|
||||
if (!noDirectionalShading) {
|
||||
float NdotE = dot(normalM, eastVec);
|
||||
float absNdotE = abs(NdotE);
|
||||
float absNdotE2 = pow2(absNdotE);
|
||||
|
||||
#if !defined NETHER
|
||||
float NdotUM = 0.75 + NdotU * 0.25;
|
||||
#else
|
||||
float NdotUM = 0.75 + abs(NdotU + 0.5) * 0.16666;
|
||||
#endif
|
||||
float NdotNM = 1.0 + 0.075 * absNdotN;
|
||||
float NdotEM = 1.0 - 0.1 * absNdotE2;
|
||||
directionShade = NdotUM * NdotEM * NdotNM;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
lightColorM *= 1.0 + absNdotE2 * 0.75;
|
||||
#elif defined NETHER
|
||||
directionShade *= directionShade;
|
||||
ambientColorM += lavaLightColor * pow2(absNdotN * 0.5 + max0(-NdotU)) * (0.7 + 0.35 * vsBrightness);
|
||||
#endif
|
||||
|
||||
#if defined CUSTOM_PBR || defined GENERATED_NORMALS
|
||||
float cpbrAmbFactor = NdotN * NPdotU;
|
||||
cpbrAmbFactor = 1.0 - 0.3 * cpbrAmbFactor;
|
||||
ambientColorM *= cpbrAmbFactor;
|
||||
minLighting *= cpbrAmbFactor;
|
||||
#endif
|
||||
|
||||
#if defined OVERWORLD && defined PERPENDICULAR_TWEAKS && defined SIDE_SHADOWING
|
||||
// Fake bounced light
|
||||
ambientColorM = mix(ambientColorM, lightColorM, (0.05 + 0.03 * subsurfaceMode) * absNdotN * lightmapY2);
|
||||
|
||||
// Get a bit more natural looking lighting during noon
|
||||
lightColorM *= 1.0 + max0(1.0 - subsurfaceMode) * pow(noonFactor, 20.0) * (pow2(absNdotN) - absNdotE2 * 0.1);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// Combine Lighting
|
||||
vec3 blockLighting = lightmapXM * blocklightCol;
|
||||
vec3 sceneLighting = lightColorM * shadowMult + ambientColorM * ambientMult;
|
||||
float dotSceneLighting = dot(sceneLighting, sceneLighting);
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
sceneLighting *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_LIGHT
|
||||
sceneLighting *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
// Vanilla Ambient Occlusion
|
||||
float vanillaAO = 1.0;
|
||||
#if VANILLAAO_I > 0
|
||||
if (subsurfaceMode != 0) vanillaAO = min1(glColor.a * 1.15);
|
||||
else if (!noVanillaAO) {
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
vanillaAO = min1(glColor.a + 0.08);
|
||||
#ifdef OVERWORLD
|
||||
vanillaAO = pow(
|
||||
pow1_5(vanillaAO),
|
||||
1.0 + dotSceneLighting * 0.02 + NdotUmax0 * (0.15 + 0.25 * pow2(noonFactor * pow2(lightmapY2)))
|
||||
);
|
||||
#elif defined NETHER
|
||||
vanillaAO = pow(
|
||||
pow1_5(vanillaAO),
|
||||
1.0 + NdotUmax0 * 0.5
|
||||
);
|
||||
#else
|
||||
vanillaAO = pow(
|
||||
vanillaAO,
|
||||
0.75 + NdotUmax0 * 0.25
|
||||
);
|
||||
#endif
|
||||
#else
|
||||
vanillaAO = glColor.a;
|
||||
#endif
|
||||
vanillaAO = vanillaAO * 0.9 + 0.1;
|
||||
|
||||
#if VANILLAAO_I != 100
|
||||
#define VANILLAAO_IM VANILLAAO_I * 0.01
|
||||
vanillaAO = pow(vanillaAO, VANILLAAO_IM);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// Light Highlight
|
||||
vec3 lightHighlight = vec3(0.0);
|
||||
#ifdef LIGHT_HIGHLIGHT
|
||||
float specularHighlight = GGX(normalM, nViewPos, lightVec, NdotLmax0, smoothnessG);
|
||||
|
||||
specularHighlight *= highlightMult;
|
||||
|
||||
lightHighlight = isEyeInWater != 1 ? shadowMult : pow(shadowMult, vec3(0.25)) * 0.35;
|
||||
lightHighlight *= (subsurfaceHighlight + specularHighlight) * highlightColor;
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
lightHighlight *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_REFLECTION
|
||||
lightHighlight *= pow2(moonPhaseInfluence);
|
||||
#endif
|
||||
|
||||
lightHighlight *= 0.3;
|
||||
#endif
|
||||
|
||||
// Mix Colors
|
||||
vec3 finalDiffuse = pow2(directionShade * vanillaAO) * (blockLighting + pow2(sceneLighting) + minLighting) + pow2(emission);
|
||||
finalDiffuse = sqrt(max(finalDiffuse, vec3(0.0))); // sqrt() for a bit more realistic light mix, max() to prevent NaNs
|
||||
|
||||
// Apply Lighting
|
||||
color.rgb *= finalDiffuse;
|
||||
color.rgb += lightHighlight;
|
||||
color.rgb *= pow2(1.0 - darknessLightFactor);
|
||||
}
|
||||
@ -0,0 +1,122 @@
|
||||
uniform sampler2D shadowcolor0;
|
||||
uniform sampler2DShadow shadowtex0;
|
||||
uniform sampler2DShadow shadowtex1;
|
||||
|
||||
vec3 GetShadowPos(vec3 playerPos) {
|
||||
vec3 shadowPos = PlayerToShadow(playerPos);
|
||||
float distb = sqrt(shadowPos.x * shadowPos.x + shadowPos.y * shadowPos.y);
|
||||
float distortFactor = distb * shadowMapBias + (1.0 - shadowMapBias);
|
||||
shadowPos.xy /= distortFactor;
|
||||
shadowPos.z *= 0.2;
|
||||
return shadowPos * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec3 SampleShadow(vec3 shadowPos, float colorMult, float colorPow) {
|
||||
float shadow0 = shadow2D(shadowtex0, vec3(shadowPos.st, shadowPos.z)).x;
|
||||
|
||||
vec3 shadowcol = vec3(0.0);
|
||||
if (shadow0 < 1.0) {
|
||||
float shadow1 = shadow2D(shadowtex1, vec3(shadowPos.st, shadowPos.z)).x;
|
||||
if (shadow1 > 0.9999) {
|
||||
shadowcol = texture2D(shadowcolor0, shadowPos.st).rgb * shadow1;
|
||||
|
||||
shadowcol *= colorMult;
|
||||
shadowcol = pow(shadowcol, vec3(colorPow));
|
||||
}
|
||||
}
|
||||
|
||||
return shadowcol * (1.0 - shadow0) + shadow0;
|
||||
}
|
||||
|
||||
float InterleavedGradientNoise() {
|
||||
float n = 52.9829189 * fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y);
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_HAND && !defined GBUFFERS_TEXTURED
|
||||
return fract(n + 1.61803398875 * mod(float(frameCounter), 3600.0));
|
||||
#else
|
||||
return fract(n);
|
||||
#endif
|
||||
}
|
||||
|
||||
vec2 offsetDist(float x, int s) {
|
||||
float n = fract(x * 2.427) * 3.1415;
|
||||
return vec2(cos(n), sin(n)) * 1.4 * x / s;
|
||||
}
|
||||
|
||||
vec3 SampleTAAFilteredShadow(vec3 shadowPos, float lViewPos, float offset, bool leaves, float colorMult, float colorPow) {
|
||||
vec3 shadow = vec3(0.0);
|
||||
float gradientNoise = InterleavedGradientNoise();
|
||||
|
||||
#if SHADOW_QUALITY == 0
|
||||
int shadowSamples = 0; // We don't use SampleTAAFilteredShadow on Shadow Quality 0
|
||||
#elif SHADOW_QUALITY == 1
|
||||
int shadowSamples = 1;
|
||||
#elif SHADOW_QUALITY == 2 || SHADOW_QUALITY == 3
|
||||
int shadowSamples = 2;
|
||||
#elif SHADOW_QUALITY == 4
|
||||
int shadowSamples = 2;
|
||||
if (lViewPos < 10.0) shadowSamples = 6;
|
||||
#elif SHADOW_QUALITY == 5
|
||||
int shadowSamples = 6;
|
||||
if (lViewPos < 10.0) shadowSamples = 12;
|
||||
#endif
|
||||
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_HAND && !defined GBUFFERS_TEXTURED
|
||||
offset *= 1.3875;
|
||||
#else
|
||||
shadowSamples *= 2;
|
||||
offset *= 0.69375;
|
||||
#endif
|
||||
|
||||
float shadowPosZM = shadowPos.z;
|
||||
for (int i = 0; i < shadowSamples; i++) {
|
||||
vec2 offset2 = offsetDist(gradientNoise + i, shadowSamples) * offset;
|
||||
if (leaves) shadowPosZM = shadowPos.z - 0.12 * offset * (gradientNoise + i) / shadowSamples;
|
||||
shadow += SampleShadow(vec3(shadowPos.st + offset2, shadowPosZM), colorMult, colorPow);
|
||||
shadow += SampleShadow(vec3(shadowPos.st - offset2, shadowPosZM), colorMult, colorPow);
|
||||
}
|
||||
|
||||
shadow /= shadowSamples * 2.0;
|
||||
|
||||
return shadow;
|
||||
}
|
||||
|
||||
vec2 shadowOffsets[4] = vec2[4](
|
||||
vec2( 1.0, 0.0),
|
||||
vec2( 0.0, 1.0),
|
||||
vec2(-1.0, 0.0),
|
||||
vec2( 0.0,-1.0));
|
||||
|
||||
vec3 SampleBasicFilteredShadow(vec3 shadowPos, float offset) {
|
||||
float shadow = 0.0;
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
shadow += shadow2D(shadowtex0, vec3(offset * shadowOffsets[i] + shadowPos.st, shadowPos.z)).x;
|
||||
}
|
||||
|
||||
return vec3(shadow * 0.25);
|
||||
}
|
||||
|
||||
vec3 GetShadow(vec3 shadowPos, float lViewPos, float lightmapY, float offset, bool leaves) {
|
||||
#if SHADOW_QUALITY > 0
|
||||
#if !defined ENTITY_SHADOWS && defined GBUFFERS_BLOCK
|
||||
offset *= 4.0;
|
||||
#else
|
||||
#ifdef OVERWORLD
|
||||
offset *= 1.0 + rainFactor2 * 2.0;
|
||||
#else
|
||||
offset *= 3.0;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float colorMult = 1.2 + 3.8 * lightmapY; // Natural strength is 5.0
|
||||
float colorPow = 1.1 - 0.6 * pow2(pow2(pow2(lightmapY)));
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
vec3 shadow = SampleTAAFilteredShadow(shadowPos, lViewPos, offset, leaves, colorMult, colorPow);
|
||||
#else
|
||||
vec3 shadow = SampleBasicFilteredShadow(shadowPos, offset);
|
||||
#endif
|
||||
|
||||
return shadow;
|
||||
}
|
||||
@ -0,0 +1,105 @@
|
||||
if (blockEntityId < 60028) {
|
||||
if (blockEntityId < 60012) {
|
||||
if (blockEntityId < 60004) {
|
||||
if (blockEntityId == 10548) { // Enchanting Table:Book
|
||||
smoothnessG = pow2(color.g) * 0.35;
|
||||
|
||||
if (color.b < 0.0001 && color.r > color.g) {
|
||||
emission = color.g * 4.0;
|
||||
}
|
||||
} else if (blockEntityId == 60000) { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60004) { // Signs
|
||||
noSmoothLighting = true;
|
||||
|
||||
if (glColor.r + glColor.g + glColor.b <= 2.99 || lmCoord.x > 0.999) { // Sign Text
|
||||
#include "/spookylib/materials/specificMaterials/others/signText.glsl"
|
||||
}
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
} else /*if (blockEntityId == 60008)*/ { // Chest
|
||||
noSmoothLighting = true;
|
||||
|
||||
smoothnessG = pow2(color.g);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60020) {
|
||||
if (blockEntityId == 60012) { // Ender Chest
|
||||
noSmoothLighting = true;
|
||||
|
||||
float factor = min(pow2(color.g), 0.25);
|
||||
smoothnessG = factor * 2.0;
|
||||
|
||||
if (color.g > color.r || color.b > color.g)
|
||||
emission = pow2(factor) * 20.0;
|
||||
emission += 0.35;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
} else /*if (blockEntityId == 60016)*/ { // Shulker Box+, Banner+, Head+, Bed+
|
||||
noSmoothLighting = true;
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.2;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60020) { // Conduit
|
||||
noSmoothLighting = true;
|
||||
lmCoordM.x = 0.9;
|
||||
|
||||
if (color.b > color.r) { // Conduit:Wind, Conduit:Blue Pixels of The Eye
|
||||
emission = color.r * 16.0;
|
||||
} else if (color.r > color.b * 2.5) { // Conduit:Red Pixels of The Eye
|
||||
emission = 20.0;
|
||||
color.rgb *= vec3(1.0, 0.25, 0.1);
|
||||
}
|
||||
} else /*if (blockEntityId == 60024)*/ { // End Portal
|
||||
#include "/spookylib/materials/specificMaterials/others/endPortalEffect.glsl"
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60044) {
|
||||
if (blockEntityId < 60036) {
|
||||
if (blockEntityId == 60028) { // End Gateway
|
||||
#include "/spookylib/materials/specificMaterials/others/endPortalEffect.glsl"
|
||||
} else /*if (blockEntityId == 60032)*/ { // Bell
|
||||
if (color.r + color.g > color.b + 0.5) { // Bell:Golden Part
|
||||
#include "/spookylib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/stone.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60036) { //
|
||||
|
||||
} else /*if (blockEntityId == 60040)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60052) {
|
||||
if (blockEntityId == 60044) { //
|
||||
|
||||
} else /*if (blockEntityId == 60048)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60052) { //
|
||||
|
||||
} else if (blockEntityId == 60056) { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,136 @@
|
||||
#ifdef POM
|
||||
#include "/spookylib/materials/materialMethods/pomEffects.glsl"
|
||||
#endif
|
||||
|
||||
void GetCustomMaterials(inout vec4 color, inout vec3 normalM, inout vec2 lmCoordM, inout float NdotU, inout vec3 shadowMult, inout float smoothnessG, inout float smoothnessD, inout float highlightMult, inout float emission, inout float materialMask, vec3 viewPos, float lViewPos) {
|
||||
vec2 texCoordM = texCoord;
|
||||
|
||||
#ifdef POM
|
||||
texCoordM = vTexCoord.xy * vTexCoordAM.zw + vTexCoordAM.xy;
|
||||
|
||||
float parallaxFade = pow2(lViewPos / POM_DISTANCE); // Still enabled to test: Lava, Painting
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
if (entityId == 50008) parallaxFade = 1.1; // Item Frame, Glow Item Frame
|
||||
#endif
|
||||
#ifdef GBUFFERS_BLOCK
|
||||
if (blockEntityId == 60004) parallaxFade = 1.1; // Signs
|
||||
#endif
|
||||
#ifdef GBUFFERS_HAND
|
||||
if (heldItemId == 40004 || heldItemId2 == 40004) parallaxFade = 1.1; // Filled Map
|
||||
#endif
|
||||
|
||||
vec3 parallaxTraceCoordDepth = vec3(texCoordM, 1.0);
|
||||
float parallaxTexDepth = 1.0;
|
||||
vec2 parallaxLocalCoord = vTexCoord.st;
|
||||
|
||||
vec4 normalMap = ReadNormal(vTexCoord.st);
|
||||
parallaxFade += pow(normalMap.a, 64.0);
|
||||
|
||||
if (parallaxFade < 1.0) {
|
||||
parallaxLocalCoord = GetParallaxCoord(parallaxFade, texCoordM, parallaxTexDepth, parallaxTraceCoordDepth);
|
||||
|
||||
normalMap = textureGrad(normals, texCoordM, dcdx, dcdy);
|
||||
color = textureGrad(tex, texCoordM, dcdx, dcdy);
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_BLOCK
|
||||
color.rgb *= glColor.rgb;
|
||||
#else
|
||||
color *= glColor;
|
||||
#endif
|
||||
|
||||
shadowMult *= GetParallaxShadow(parallaxFade, normalMap.a, parallaxLocalCoord, lightVec, tbnMatrix);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Normal Map
|
||||
#if NORMAL_MAP_STRENGTH != 0
|
||||
#ifndef POM
|
||||
vec4 normalMap = texture2D(normals, texCoordM);
|
||||
#endif
|
||||
|
||||
normalM = normalMap.xyz;
|
||||
normalM += vec3(0.5, 0.5, 0.0);
|
||||
normalM = pow(normalM, vec3(NORMAL_MAP_STRENGTH * 0.007)); // 70% strength by default
|
||||
normalM -= vec3(0.5, 0.5, 0.0);
|
||||
normalM = normalM * 2.0 - 1.0;
|
||||
|
||||
#if RP_MODE == 3 // labPBR
|
||||
if (normalM.x + normalM.y > -1.999) {
|
||||
if (length(normalM.xy) > 1.0) normalM.xy = normalize(normalM.xy);
|
||||
normalM.z = sqrt(1.0 - dot(normalM.xy, normalM.xy));
|
||||
normalM.xyz = normalize(clamp(normalM.xyz, vec3(-1.0), vec3(1.0)));
|
||||
} else normalM = vec3(0.0, 0.0, 1.0);
|
||||
#endif
|
||||
|
||||
#if defined POM && POM_QUALITY >= 128 && POM_LIGHTING_MODE == 2
|
||||
float slopeThreshold = max(1.0 / POM_QUALITY, 1.0/255.0);
|
||||
if (parallaxTexDepth - parallaxTraceCoordDepth.z > slopeThreshold) {
|
||||
vec3 slopeNormal = GetParallaxSlopeNormal(parallaxLocalCoord, parallaxTraceCoordDepth.z, viewVector);
|
||||
normalM = mix(normalM, slopeNormal, 0.5 * pow2(max0(1.0 - parallaxFade * 2.0)));
|
||||
}
|
||||
#endif
|
||||
|
||||
normalM = clamp(normalize(normalM * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
|
||||
NdotU = dot(normalM, upVec);
|
||||
NdotUmax0 = max0(NdotU);
|
||||
#endif
|
||||
|
||||
#if DIRECTIONAL_BLOCKLIGHT > 0
|
||||
mat3 lightmapTBN = mat3(normalize(dFdx(viewPos)), normalize(dFdy(viewPos)), vec3(0.0));
|
||||
lightmapTBN[2] = cross(lightmapTBN[0], lightmapTBN[1]);
|
||||
|
||||
float lmCoordXDir = lmCoordM.x;
|
||||
vec2 deriv = vec2(dFdx(lmCoordXDir), dFdy(lmCoordXDir)) * 256.0;
|
||||
vec3 dir = normalize(vec3(deriv.x * lightmapTBN[0] +
|
||||
0.0005 * lightmapTBN[2] +
|
||||
deriv.y * lightmapTBN[1]));
|
||||
|
||||
float pwr = clamp(dot(normalM, dir), -1.0, 1.0);
|
||||
float absPwr = abs(pwr);
|
||||
if (absPwr > 0.0) pwr = pow(absPwr, 9.0 / DIRECTIONAL_BLOCKLIGHT) * sign(pwr) * lmCoordXDir;
|
||||
if (length(deriv) > 0.001) lmCoordXDir = pow(max(lmCoordXDir, 0.00001), 1.0 - pwr);
|
||||
|
||||
lmCoordM.x = mix(lmCoordM.x, lmCoordXDir, 0.01 * max0(100.0 - pow2(lViewPos)));
|
||||
#endif
|
||||
|
||||
// Specular Map
|
||||
vec4 specularMap = texture2D(specular, texCoordM);
|
||||
|
||||
float smoothnessM = pow2(specularMap.r);
|
||||
smoothnessG = smoothnessM;
|
||||
smoothnessD = smoothnessM;
|
||||
highlightMult = 1.0 + 2.5 * specularMap.r;
|
||||
|
||||
#if RP_MODE == 3 // labPBR
|
||||
highlightMult *= 0.5 + 0.5 * specularMap.g;
|
||||
#endif
|
||||
|
||||
#if CUSTOM_EMISSION_INTENSITY > 0
|
||||
#if RP_MODE == 2 // seuspbr
|
||||
emission = specularMap.b;
|
||||
#elif RP_MODE == 3 // labPBR
|
||||
emission = specularMap.a < 1.0 ? specularMap.a : 0.0;
|
||||
|
||||
vec4 specularMapL0 = texture2DLod(specular, texCoordM, 0);
|
||||
float emissionL0 = specularMapL0.a < 1.0 ? specularMapL0.a : 0.0;
|
||||
emission = min(emission, emissionL0); // Fixes issues caused by mipmaps
|
||||
#endif
|
||||
emission *= 0.03 * CUSTOM_EMISSION_INTENSITY;
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
if (materialMask > OSIEBCA * 240.1) return;
|
||||
#endif
|
||||
|
||||
#if RP_MODE == 2 // seuspbr
|
||||
materialMask = specularMap.g * OSIEBCA * 240.0;
|
||||
#elif RP_MODE == 3 // labPBR
|
||||
if (specularMap.g < OSIEBCA * 229.1) {
|
||||
materialMask = specularMap.g * OSIEBCA * 214.0;
|
||||
} else {
|
||||
materialMask = specularMap.g - OSIEBCA * 15.0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
if (materialMaskInt != 0) {
|
||||
if (materialMaskInt < 9) {
|
||||
if (materialMaskInt < 5) {
|
||||
if (materialMaskInt < 3) {
|
||||
if (materialMaskInt == 1) { // Intense Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
} else /*if (materialMaskInt == 2)*/ { // Copper Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = mix(vec3(0.5, 0.75, 0.5), vec3(1.0, 0.45, 0.3), sqrt1(smoothnessD));
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 3) { // Gold Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = vec3(1.0, 0.8, 0.5);
|
||||
} else /*if (materialMaskInt == 4)*/ { // End Portal
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 7) {
|
||||
if (materialMaskInt == 5) { // Redstone Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = vec3(1.0, 0.3, 0.2);
|
||||
} else /*if (materialMaskInt == 6)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 7) { //
|
||||
|
||||
} else /*if (materialMaskInt == 8)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 13) {
|
||||
if (materialMaskInt < 11) {
|
||||
if (materialMaskInt == 9) { //
|
||||
|
||||
} else /*if (materialMaskInt == 10)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 11) { //
|
||||
|
||||
} else /*if (materialMaskInt == 12)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 15) {
|
||||
if (materialMaskInt == 13) { //
|
||||
|
||||
} else /*if (materialMaskInt == 14)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 254) { // No SSAO, No TAA
|
||||
ssao = 1.0;
|
||||
} else /*if (materialMaskInt == "15 to 255 except 254")*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,183 @@
|
||||
if (entityId < 50064) {
|
||||
if (entityId < 50032) {
|
||||
if (entityId < 50016) {
|
||||
if (entityId < 50008) {
|
||||
if (entityId == 50000) { // End Crystal
|
||||
lmCoordM.x *= 0.7;
|
||||
|
||||
if (color.g * 1.2 < color.r) {
|
||||
emission = 12.0 * color.g;
|
||||
color.r *= 1.1;
|
||||
}
|
||||
} else if (entityId == 50004) { // Lightning Bolt
|
||||
#include "/spookylib/materials/specificMaterials/entities/lightningBolt.glsl"
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50008) { // Item Frame, Glow Item Frame
|
||||
noSmoothLighting = true;
|
||||
} else /*if (entityId == 50012)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50024) {
|
||||
if (entityId == 50016) { // Player
|
||||
if (entityColor.a < 0.001) {
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
|
||||
if (CheckForColor(texelFetch(tex, ivec2(0, 0), 0).rgb, vec3(23, 46, 92))) {
|
||||
for (int i = 63; i >= 56; i--) {
|
||||
vec3 dif = color.rgb - texelFetch(tex, ivec2(i, 0), 0).rgb;
|
||||
if (dif == clamp(dif, vec3(-0.001), vec3(0.001))) {
|
||||
emission = 2.0 * texelFetch(tex, ivec2(i, 1), 0).r;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else /*if (entityId == 50020)*/ { // Blaze
|
||||
lmCoordM = vec2(0.9, 0.0);
|
||||
emission = min(color.r, 0.7) * 1.4;
|
||||
|
||||
float dotColor = dot(color.rgb, color.rgb);
|
||||
if (abs(dotColor - 1.5) > 1.4) {
|
||||
emission = 5.0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50024) { // Creeper
|
||||
emission = max0(color.b - color.g - color.r) * 10.0;
|
||||
} else /*if (entityId == 50028)*/ { // Drowned
|
||||
if (atlasSize.x < 900) {
|
||||
if (CheckForColor(color.rgb, vec3(143, 241, 215)) ||
|
||||
CheckForColor(color.rgb, vec3( 49, 173, 183)) ||
|
||||
CheckForColor(color.rgb, vec3(101, 224, 221))) emission = 3.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50048) {
|
||||
if (entityId < 50040) {
|
||||
if (entityId == 50032) { // Guardian
|
||||
vec3 absDif = abs(vec3(color.r - color.g, color.g - color.b, color.r - color.b));
|
||||
float maxDif = max(absDif.r, max(absDif.g, absDif.b));
|
||||
if (maxDif < 0.1 && color.b > 0.5 && color.b < 0.88) {
|
||||
emission = pow2(pow1_5(color.b)) * 5.0;
|
||||
color.rgb *= color.rgb;
|
||||
}
|
||||
} else /*if (entityId == 50036)*/ { // Elder Guardian
|
||||
if (CheckForColor(color.rgb, vec3(203, 177, 165)) ||
|
||||
CheckForColor(color.rgb, vec3(214, 155, 126))) {
|
||||
emission = pow2(pow1_5(color.b)) * 10.0;
|
||||
color.r *= 1.2;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50040) { // Endermite
|
||||
if (CheckForColor(color.rgb, vec3(87, 23, 50))) {
|
||||
emission = 8.0;
|
||||
color.rgb *= color.rgb;
|
||||
}
|
||||
} else /*if (entityId == 50044)*/ { // Ghast
|
||||
if (entityColor.a < 0.001)
|
||||
emission = max0(color.r - color.g - color.b) * 6.0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50056) {
|
||||
if (entityId == 50048) { // Glow Squid
|
||||
lmCoordM.x = 0.0;
|
||||
float dotColor = dot(color.rgb, color.rgb);
|
||||
emission = pow2(pow2(min(dotColor * 0.65, 1.5))) + 0.45;
|
||||
} else /*if (entityId == 50052)*/ { // Magma Cube
|
||||
emission = color.g * 6.0;
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50056) { // Stray
|
||||
if (CheckForColor(color.rgb, vec3(230, 242, 246)) && texCoord.y > 0.35)
|
||||
emission = 3.7;
|
||||
} else /*if (entityId == 50060)*/ { // Vex
|
||||
lmCoordM = vec2(0.0);
|
||||
emission = pow2(pow2(color.r)) * 3.5 + 0.5;
|
||||
color.a *= color.a;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50096) {
|
||||
if (entityId < 50080) {
|
||||
if (entityId < 50072) {
|
||||
if (entityId == 50064) { // Witch
|
||||
emission = 2.0 * color.g * float(color.g * 1.5 > color.b + color.r);
|
||||
} else /*if (entityId == 50068)*/ { // Wither, Wither Skull
|
||||
lmCoordM.x = 0.9;
|
||||
emission = 3.0 * float(dot(color.rgb, color.rgb) > 1.0);
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50072) { // Experience Orb
|
||||
emission = 7.5;
|
||||
|
||||
color.rgb *= color.rgb;
|
||||
} else /*if (entityId == 50076)*/ { // Boat
|
||||
//playerPos.y += 0.18; // to avoid water shadow
|
||||
playerPos.y += 0.38; // to also avoid the black inner shadow bug
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50088) {
|
||||
if (entityId == 50080) { // Allay
|
||||
if (atlasSize.x < 900) {
|
||||
lmCoordM = vec2(0.0);
|
||||
emission = float(color.r > 0.9 && color.b > 0.9) * 5.0 + color.g;
|
||||
} else {
|
||||
lmCoordM.x = 0.8;
|
||||
}
|
||||
} else /*if (entityId == 50084)*/ { // Slime
|
||||
//only slime code is in Vertex Shader for now
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50088) { // Entity Flame (Iris Feature)
|
||||
emission = 1.3;
|
||||
} else /*if (entityId == 50092)*/ { // Trident Entity
|
||||
#ifdef IS_IRIS
|
||||
// Only on Iris, because otherwise it would be inconsistent with the Trident item
|
||||
#include "/spookylib/materials/specificMaterials/others/trident.glsl"
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50112) {
|
||||
if (entityId < 50104) {
|
||||
if (entityId == 50096) { //
|
||||
|
||||
} else /*if (entityId == 50100)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50104) { //
|
||||
|
||||
} else /*if (entityId == 50108)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50120) {
|
||||
if (entityId == 50112) { //
|
||||
|
||||
} else /*if (entityId == 50116)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50120) { //
|
||||
|
||||
} else /*if (entityId == 50124)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,221 @@
|
||||
int mat = currentRenderedItemId;
|
||||
|
||||
#ifdef GBUFFERS_HAND
|
||||
float lViewPos = 0.0;
|
||||
#endif
|
||||
|
||||
int subsurfaceMode;
|
||||
bool noDirectionalShading, noVanillaAO, centerShadowBias;
|
||||
float noPuddles;
|
||||
|
||||
if (currentRenderedItemId < 45000) {
|
||||
#include "/spookylib/materials/materialHandling/terrainMaterials.glsl"
|
||||
} else
|
||||
|
||||
if (currentRenderedItemId < 45064) {
|
||||
if (currentRenderedItemId < 45032) {
|
||||
if (currentRenderedItemId < 45016) {
|
||||
if (currentRenderedItemId < 45008) {
|
||||
if (currentRenderedItemId == 45000) { // Armor Trims
|
||||
smoothnessG = 0.5;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 0.5;
|
||||
|
||||
#ifdef GLOWING_ARMOR_TRIM
|
||||
emission = 2.0;
|
||||
#endif
|
||||
} else if (currentRenderedItemId == 45004) { // Wooden Tools, Bow, Fishing Rod
|
||||
#include "/spookylib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
smoothnessG = min(smoothnessG, 0.4);
|
||||
smoothnessD = smoothnessG;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45008) { // Stone Tools
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/spookylib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/stone.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45012)*/ { // Iron Tools, Iron Armor, Iron Ingot, Iron Nugget, Iron Horse Armor, Flint and Steel, Flint, Spyglass, Shears
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/spookylib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45024) {
|
||||
if (currentRenderedItemId == 45016) { // Golden Tools, Golden Armor, Gold Ingot, Gold Nugget, Golden Apple, Enchanted Golden Apple, Golden Carrot, Golden Horse Armor, Copper Ingot
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/spookylib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45020)*/ { // Diamond Tools, Diamond Armor, Diamond, Diamond Horse Armor, Emerald
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/spookylib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/diamondBlock.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45024) { // Netherite Tools, Netherite Armor, Netherite Ingot
|
||||
smoothnessG = color.r * 2.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
highlightMult = smoothnessG * 2.0;
|
||||
smoothnessD = smoothnessG * 0.5 + 0.5;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
} else /*if (currentRenderedItemId == 45028)*/ { // Trident Item
|
||||
#include "/spookylib/materials/specificMaterials/others/trident.glsl"
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45048) {
|
||||
if (currentRenderedItemId < 45040) {
|
||||
if (currentRenderedItemId == 45032) { // Lava Bucket
|
||||
if (color.r + color.g > color.b * 2.0) {
|
||||
emission = color.r + color.g - color.b * 1.5;
|
||||
emission *= 1.8;
|
||||
color.rg += color.b * vec2(0.4, 0.15);
|
||||
color.b *= 0.8;
|
||||
} else {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45036)*/ { // Bucket++
|
||||
if (GetMaxColorDif(color.rgb) < 0.01) {
|
||||
#include "/spookylib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
} else {
|
||||
float factor = color.b;
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 2.0;
|
||||
smoothnessD = factor;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45040) { // Blaze Rod, Blaze Powder
|
||||
noSmoothLighting = false;
|
||||
lmCoordM.x = 0.85;
|
||||
emission = color.g;
|
||||
color.rgb = sqrt1(color.rgb);
|
||||
} else /*if (currentRenderedItemId == 45044)*/ { // Bottle o' Enchanting, Glow Inc Sac
|
||||
emission = color.b * 2.0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45056) {
|
||||
if (currentRenderedItemId == 45048) { // Fire Charge
|
||||
emission = max0(color.r + color.g - color.b * 0.5);
|
||||
} else /*if (currentRenderedItemId == 45052)*/ { // Chorus Fruit
|
||||
emission = max0(color.b * 2.0 - color.r) * 1.5;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45056) { // Amethyst Shard
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
float factor = pow2(color.r);
|
||||
smoothnessG = 0.8 - factor * 0.3;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
} else /*if (currentRenderedItemId == 45060)*/ { // Shield
|
||||
float factor = min(color.r * color.g * color.b * 4.0, 0.7);
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45096) {
|
||||
if (currentRenderedItemId < 45080) {
|
||||
if (currentRenderedItemId < 45072) {
|
||||
if (currentRenderedItemId == 45064) { // Turtle Shell
|
||||
float factor = color.g * 0.7;
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
} else /*if (currentRenderedItemId == 45068)*/ { // Ender Pearl
|
||||
smoothnessG = 1.0;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 1.0;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45072) { // Eye of Ender
|
||||
smoothnessG = 1.0;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 1.0;
|
||||
emission = max0(color.g - color.b * 0.25);
|
||||
color.rgb = pow(color.rgb, vec3(1.0 - 0.75 * emission));
|
||||
} else /*if (currentRenderedItemId == 45076)*/ { // Clock
|
||||
if (
|
||||
CheckForColor(color.rgb, vec3(255, 255, 0)) ||
|
||||
CheckForColor(color.rgb, vec3(204, 204, 0)) ||
|
||||
CheckForColor(color.rgb, vec3(73, 104, 216)) ||
|
||||
CheckForColor(color.rgb, vec3(58, 83, 172)) ||
|
||||
CheckForColor(color.rgb, vec3(108, 108, 137)) ||
|
||||
CheckForColor(color.rgb, vec3(86, 86, 109))
|
||||
) {
|
||||
emission = 1.0;
|
||||
color.rgb += vec3(0.1);
|
||||
}
|
||||
|
||||
#include "/spookylib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45088) {
|
||||
if (currentRenderedItemId == 45080) { // Compass
|
||||
if (color.r - 0.1 > color.b + color.g) {
|
||||
emission = color.r * 1.5;
|
||||
}
|
||||
|
||||
#include "/spookylib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
} else /*if (currentRenderedItemId == 45084)*/ { // Echo Shard, Recovery Compass, Music Disc 5
|
||||
emission = max0(color.b + color.g - color.r * 2.0);
|
||||
|
||||
#include "/spookylib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45088) { // Nether Star
|
||||
emission = pow2(color.r + color.g) * 0.5;
|
||||
} else /*if (currentRenderedItemId == 45092)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45112) {
|
||||
if (currentRenderedItemId < 45104) {
|
||||
if (currentRenderedItemId == 45096) { //
|
||||
|
||||
} else /*if (currentRenderedItemId == 45100)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45104) { //
|
||||
|
||||
} else /*if (currentRenderedItemId == 45108)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45120) {
|
||||
if (currentRenderedItemId == 45112) { //
|
||||
|
||||
} else /*if (currentRenderedItemId == 45116)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45120) { //
|
||||
|
||||
} else /*if (currentRenderedItemId == 45124)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,107 @@
|
||||
if (mat < 31008) {
|
||||
if (mat < 30016) {
|
||||
if (mat < 30008) {
|
||||
if (mat == 30000) { // Stained Glass
|
||||
#include "/spookylib/materials/specificMaterials/translucents/stainedGlass.glsl"
|
||||
} else if (mat == 30004) { // Stained Glass Pane
|
||||
#include "/spookylib/materials/specificMaterials/translucents/stainedGlass.glsl"
|
||||
noSmoothLighting = true;
|
||||
}
|
||||
} else {
|
||||
if (mat == 30008) { // Tinted Glass
|
||||
color.a = pow(color.a, 1.0 - fresnel * 0.65);
|
||||
reflectMult = 0.75;
|
||||
} else /*if (mat == 30012)*/ { // Slime Block
|
||||
translucentMultCalculated = true;
|
||||
reflectMult = 0.7;
|
||||
translucentMult.rgb = pow2(color.rgb) * 0.2;
|
||||
|
||||
smoothnessG = color.g * 0.7;
|
||||
highlightMult = 2.5;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 31000) {
|
||||
if (mat == 30016) { // Honey Block
|
||||
translucentMultCalculated = true;
|
||||
reflectMult = 1.0;
|
||||
translucentMult.rgb = pow2(color.rgb) * 0.2;
|
||||
|
||||
smoothnessG = color.r * 0.7;
|
||||
highlightMult = 2.5;
|
||||
} else /*if (mat == 30020)*/ { // Nether Portal
|
||||
#ifdef FANCY_NETHERPORTAL
|
||||
#include "/spookylib/materials/specificMaterials/translucents/netherPortal.glsl"
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
if (mat == 31000) { // Water
|
||||
#include "/spookylib/materials/specificMaterials/translucents/water.glsl"
|
||||
} else /*if (mat == 31004)*/ { // Ice
|
||||
smoothnessG = pow2(color.g) * color.g;
|
||||
highlightMult = pow2(min1(pow2(color.g) * 1.5)) * 3.5;
|
||||
|
||||
reflectMult = 0.7;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 31024) {
|
||||
if (mat < 31016) {
|
||||
if (mat == 31008) { // Glass
|
||||
#include "/spookylib/materials/specificMaterials/translucents/glass.glsl"
|
||||
} else /*if (mat == 31012)*/ { // Glass Pane
|
||||
if (color.a < 0.001 && abs(NdotU) > 0.95) discard; // Fixing artifacts on connected glass panes
|
||||
#include "/spookylib/materials/specificMaterials/translucents/glass.glsl"
|
||||
noSmoothLighting = true;
|
||||
}
|
||||
} else {
|
||||
if (mat == 31016) { // Beacon
|
||||
lmCoordM.x = 0.88;
|
||||
|
||||
translucentMultCalculated = true;
|
||||
translucentMult = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
|
||||
if (color.b > 0.5) {
|
||||
if (color.g - color.b < 0.01 && color.g < 0.99) {
|
||||
#include "/spookylib/materials/specificMaterials/translucents/glass.glsl"
|
||||
} else { // Beacon:Center
|
||||
lmCoordM = vec2(0.0);
|
||||
noDirectionalShading = true;
|
||||
|
||||
float lColor = length(color.rgb);
|
||||
vec3 baseColor = vec3(0.1, 1.0, 0.92);
|
||||
if (lColor > 1.5) color.rgb = baseColor + 0.22;
|
||||
else if (lColor > 1.3) color.rgb = baseColor + 0.15;
|
||||
else if (lColor > 1.15) color.rgb = baseColor + 0.09;
|
||||
else color.rgb = baseColor + 0.05;
|
||||
emission = 4.0;
|
||||
}
|
||||
} else { // Beacon:Obsidian
|
||||
float factor = color.r * 1.5;
|
||||
|
||||
smoothnessG = factor;
|
||||
highlightMult = 2.0 + min1(smoothnessG * 2.0) * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
}
|
||||
|
||||
} else /*if (mat == 31020)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 31032) {
|
||||
if (mat == 31024) { //
|
||||
|
||||
} else /*if (mat == 31028)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (mat == 31032) { //
|
||||
|
||||
} else /*if (mat == 31036)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
const float packSizeNT = 64.0;
|
||||
|
||||
void CoatTextures(inout vec3 color, float noiseFactor, vec3 playerPos) {
|
||||
#ifndef ENTITY_GN_AND_CT
|
||||
#if defined GBUFFERS_ENTITIES || defined GBUFFERS_HAND
|
||||
return;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef SAFER_GENERATED_NORMALS
|
||||
vec2 noiseCoord = floor(midCoordPos / 16.0 * packSizeNT * atlasSizeM) / packSizeNT / 3.0;
|
||||
#else
|
||||
vec2 offsetR = max(absMidCoordPos.x, absMidCoordPos.y) * vec2(float(atlasSizeM.y) / float(atlasSizeM.x), 1.0);
|
||||
vec2 noiseCoord = floor(midCoordPos / 2.0 * packSizeNT / offsetR) / packSizeNT / 3.0;
|
||||
#endif
|
||||
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_HAND
|
||||
vec3 floorWorldPos = floor(playerPos + cameraPosition + 0.001);
|
||||
noiseCoord += 0.84 * (floorWorldPos.xz + floorWorldPos.y);
|
||||
#endif
|
||||
|
||||
float noiseTexture = texture2D(noisetex, noiseCoord).r;
|
||||
noiseTexture = noiseTexture + 0.6;
|
||||
float colorBrightness = dot(color, color) * 0.3;
|
||||
#define COATED_TEXTURE_MULT_M COATED_TEXTURE_MULT * 0.0027
|
||||
noiseFactor *= COATED_TEXTURE_MULT_M * max0(1.0 - colorBrightness);
|
||||
noiseFactor *= max(1.0 - miplevel * 0.25, 0.0);
|
||||
noiseTexture = pow(noiseTexture, noiseFactor);
|
||||
color.rgb *= noiseTexture;
|
||||
}
|
||||
@ -0,0 +1,85 @@
|
||||
const float normalThreshold = 0.05;
|
||||
const float normalClamp = 0.2;
|
||||
const float packSizeGN = 128.0;
|
||||
|
||||
#ifndef GBUFFERS_HAND
|
||||
const float normalMult = GENERATED_NORMAL_MULT * 0.025;
|
||||
#else
|
||||
const float normalMult = GENERATED_NORMAL_MULT * 0.015;
|
||||
#endif
|
||||
|
||||
float GetDif(float lOriginalAlbedo, vec2 offsetCoord) {
|
||||
#ifndef GBUFFERS_WATER
|
||||
float lNearbyAlbedo = length(texture2D(tex, offsetCoord).rgb);
|
||||
#else
|
||||
vec4 textureSample = texture2D(tex, offsetCoord);
|
||||
float lNearbyAlbedo = length(textureSample.rgb * textureSample.a * 1.5);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
lOriginalAlbedo = abs(lOriginalAlbedo - 1.0);
|
||||
lNearbyAlbedo = abs(lNearbyAlbedo - 1.0);
|
||||
#endif
|
||||
|
||||
float dif = lOriginalAlbedo - lNearbyAlbedo;
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
dif = -dif;
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
if (dif > 0.0) dif = max(dif - normalThreshold, 0.0);
|
||||
else dif = min(dif + normalThreshold, 0.0);
|
||||
#endif
|
||||
|
||||
return clamp(dif, -normalClamp, normalClamp);
|
||||
}
|
||||
|
||||
void GenerateNormals(inout vec3 normalM, vec3 color) {
|
||||
#ifndef ENTITY_GN_AND_CT
|
||||
#if defined GBUFFERS_ENTITIES || defined GBUFFERS_HAND
|
||||
return;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
vec2 absMidCoordPos2 = absMidCoordPos * 2.0;
|
||||
float lOriginalAlbedo = length(color.rgb);
|
||||
|
||||
float normalMult = max0(1.0 - mipDelta) * normalMult;
|
||||
|
||||
#ifndef SAFER_GENERATED_NORMALS
|
||||
vec2 offsetR = 16.0 / atlasSizeM;
|
||||
#else
|
||||
vec2 offsetR = max(absMidCoordPos2.x, absMidCoordPos2.y) * vec2(float(atlasSizeM.y) / float(atlasSizeM.x), 1.0);
|
||||
#endif
|
||||
offsetR /= packSizeGN;
|
||||
|
||||
vec2 midCoord = texCoord - midCoordPos;
|
||||
vec2 maxOffsetCoord = midCoord + absMidCoordPos;
|
||||
vec2 minOffsetCoord = midCoord - absMidCoordPos;
|
||||
if (normalMult > 0.0) {
|
||||
vec3 normalMap = vec3(0.0, 0.0, 1.0);
|
||||
|
||||
vec2 offsetCoord = texCoord + vec2( 0.0, offsetR.y);
|
||||
if (offsetCoord.y < maxOffsetCoord.y)
|
||||
normalMap.y += GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2( offsetR.x, 0.0);
|
||||
if (offsetCoord.x < maxOffsetCoord.x)
|
||||
normalMap.x += GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2( 0.0,-offsetR.y);
|
||||
if (offsetCoord.y > minOffsetCoord.y)
|
||||
normalMap.y -= GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2(-offsetR.x, 0.0);
|
||||
if (offsetCoord.x > minOffsetCoord.x)
|
||||
normalMap.x -= GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
normalMap.xy *= normalMult;
|
||||
normalMap.xy = clamp(normalMap.xy, vec2(-1.0), vec2(1.0));
|
||||
|
||||
if (normalMap.xy != vec2(0.0, 0.0))
|
||||
normalM = clamp(normalize(normalMap * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,127 @@
|
||||
#include "/spookylib/util/dither.glsl"
|
||||
|
||||
vec2 vTexCoord = signMidCoordPos * 0.5 + 0.5;
|
||||
|
||||
#include "/spookylib/util/dFdxdFdy.glsl"
|
||||
|
||||
vec4 ReadNormal(vec2 coord) {
|
||||
coord = fract(coord) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
return textureGrad(normals, coord, dcdx, dcdy);
|
||||
}
|
||||
|
||||
vec2 GetParallaxCoord(float parallaxFade, inout vec2 newCoord, inout float texDepth, inout vec3 traceCoordDepth) {
|
||||
float invParallaxQuality = 1.0 / POM_QUALITY;
|
||||
vec4 normalMap = ReadNormal(vTexCoord.st);
|
||||
vec2 normalMapM = normalMap.xy * 2.0 - 1.0;
|
||||
float normalCheck = normalMapM.x + normalMapM.y;
|
||||
float minHeight = 1.0 - invParallaxQuality;
|
||||
|
||||
if (viewVector.z >= 0.0 || normalMap.a >= minHeight || normalCheck <= -1.999) return vTexCoord.st;
|
||||
|
||||
vec2 interval = viewVector.xy * 0.25 * (1.0 - parallaxFade) * POM_DEPTH / (-viewVector.z * POM_QUALITY);
|
||||
|
||||
float i = 0.0;
|
||||
vec2 localCoord;
|
||||
#if defined GBUFFERS_TERRAIN || defined GBUFFERS_BLOCK
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + 1.61803398875 * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
if (texDepth <= 1.0 - i * invParallaxQuality) {
|
||||
localCoord = vTexCoord.st + i * interval;
|
||||
texDepth = ReadNormal(localCoord).a;
|
||||
i = dither;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (; i < POM_QUALITY && texDepth <= 1.0 - i * invParallaxQuality; i++) {
|
||||
localCoord = vTexCoord.st + i * interval;
|
||||
texDepth = ReadNormal(localCoord).a;
|
||||
}
|
||||
|
||||
float pI = float(max(i - 1, 0));
|
||||
traceCoordDepth.xy -= pI * interval;
|
||||
traceCoordDepth.z -= pI * invParallaxQuality;
|
||||
|
||||
localCoord = fract(vTexCoord.st + pI * interval);
|
||||
newCoord = localCoord * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
return localCoord;
|
||||
}
|
||||
|
||||
float GetParallaxShadow(float parallaxFade, float height, vec2 coord, vec3 lightVec, mat3 tbn) {
|
||||
float parallaxshadow = 1.0;
|
||||
|
||||
vec3 parallaxdir = tbn * lightVec;
|
||||
parallaxdir.xy *= 1.0 * POM_DEPTH; // Angle
|
||||
float stepL = 1.0 / 32.0;
|
||||
|
||||
for(int i = 0; i < 4 && parallaxshadow >= 0.01; i++) {
|
||||
float stepLC = stepL * i;
|
||||
|
||||
float currentHeight = height + parallaxdir.z * stepLC;
|
||||
|
||||
vec2 parallaxCoord = fract(coord + parallaxdir.xy * stepLC) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
float offsetHeight = textureGrad(normals, parallaxCoord, dcdx, dcdy).a;
|
||||
|
||||
parallaxshadow *= clamp(1.0 - (offsetHeight - currentHeight) * 4.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
return mix(parallaxshadow, 1.0, parallaxFade);
|
||||
}
|
||||
|
||||
// Big thanks to null511 for slope normals
|
||||
vec3 GetParallaxSlopeNormal(vec2 texCoord, float traceDepth, vec3 viewDir) {
|
||||
vec2 atlasPixelSize = 1.0 / atlasSize;
|
||||
float atlasAspect = atlasSize.x / atlasSize.y;
|
||||
vec2 atlasCoord = fract(texCoord) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
|
||||
vec2 tileSize = atlasSize * vTexCoordAM.pq;
|
||||
vec2 tilePixelSize = 1.0 / tileSize;
|
||||
|
||||
vec2 tex_snapped = floor(atlasCoord * atlasSize) * atlasPixelSize;
|
||||
vec2 tex_offset = atlasCoord - (tex_snapped + 0.5 * atlasPixelSize);
|
||||
|
||||
vec2 stepSign = sign(tex_offset);
|
||||
vec2 viewSign = sign(viewDir.xy);
|
||||
|
||||
bool dir = abs(tex_offset.x * atlasAspect) < abs(tex_offset.y);
|
||||
vec2 tex_x, tex_y;
|
||||
|
||||
if (dir) {
|
||||
tex_x = texCoord - vec2(tilePixelSize.x * viewSign.x, 0.0);
|
||||
tex_y = texCoord + vec2(0.0, stepSign.y * tilePixelSize.y);
|
||||
}
|
||||
else {
|
||||
tex_x = texCoord + vec2(tilePixelSize.x * stepSign.x, 0.0);
|
||||
tex_y = texCoord - vec2(0.0, viewSign.y * tilePixelSize.y);
|
||||
}
|
||||
|
||||
float height_x = ReadNormal(tex_x).a;
|
||||
float height_y = ReadNormal(tex_y).a;
|
||||
|
||||
if (dir) {
|
||||
if (!(traceDepth > height_y && viewSign.y != stepSign.y)) {
|
||||
if (traceDepth > height_x) return vec3(-viewSign.x, 0.0, 0.0);
|
||||
|
||||
if (abs(viewDir.y) > abs(viewDir.x))
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
else
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
}
|
||||
else {
|
||||
if (!(traceDepth > height_x && viewSign.x != stepSign.x)) {
|
||||
if (traceDepth > height_y) return vec3(0.0, -viewSign.y, 0.0);
|
||||
|
||||
if (abs(viewDir.y) > abs(viewDir.x))
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
else
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,135 @@
|
||||
#ifdef OVERWORLD
|
||||
#include "/spookylib/atmospherics/sky.glsl"
|
||||
#endif
|
||||
#if defined END && defined DEFERRED1
|
||||
#include "/spookylib/atmospherics/enderBeams.glsl"
|
||||
#endif
|
||||
|
||||
vec3 nvec3(vec4 pos) {
|
||||
return pos.xyz/pos.w;
|
||||
}
|
||||
|
||||
vec3 refPos = vec3(0.0);
|
||||
|
||||
vec4 GetReflection(vec3 normalM, vec3 viewPos, vec3 nViewPos, vec3 playerPos, float lViewPos, float z0,
|
||||
sampler2D depthtex, float dither, float skyLightFactor, float fresnel,
|
||||
float smoothness, vec3 geoNormal, vec3 color, vec3 shadowMult, float highlightMult) {
|
||||
vec3 rfragpos = vec3(0.0);
|
||||
float dist = 0.0;
|
||||
int sr = 0;
|
||||
vec2 rEdge = vec2(0.6, 0.53);
|
||||
vec3 normalMR = normalM;
|
||||
|
||||
#if defined GBUFFERS_WATER && defined GENERATED_NORMALS && WATER_STYLE == 1
|
||||
normalMR = mix(geoNormal, normalM, 0.05);
|
||||
#endif
|
||||
|
||||
vec3 nViewPosR = reflect(nViewPos, normalMR);
|
||||
float RVdotU = dot(normalize(nViewPosR), upVec);
|
||||
float RVdotS = dot(normalize(nViewPosR), sunVec);
|
||||
|
||||
vec3 start = viewPos + normalMR * (lViewPos * 0.025 * (1.0 - fresnel) + 0.05);
|
||||
vec3 vector = reflect(nViewPos, normalize(normalMR));
|
||||
vector *= 0.5;
|
||||
vec3 viewPosRT = viewPos + vector;
|
||||
vec3 tvector = vector;
|
||||
|
||||
for(int i = 0; i < 30; i++) {
|
||||
refPos = nvec3(gbufferProjection * vec4(viewPosRT, 1.0)) * 0.5 + 0.5;
|
||||
if (abs(refPos.x - 0.5) > rEdge.x || abs(refPos.y - 0.5) > rEdge.y) break;
|
||||
|
||||
rfragpos = vec3(refPos.xy, texture2D(depthtex, refPos.xy).r);
|
||||
rfragpos = nvec3(gbufferProjectionInverse * vec4(rfragpos * 2.0 - 1.0, 1.0));
|
||||
dist = length(start - rfragpos);
|
||||
|
||||
float err = length(viewPosRT - rfragpos);
|
||||
|
||||
if (err < length(vector) * 3.0) {
|
||||
sr++;
|
||||
if (sr >= 6) break;
|
||||
tvector -= vector;
|
||||
vector *= 0.1;
|
||||
}
|
||||
vector *= 2.0;
|
||||
tvector += vector * (0.95 + 0.1 * dither);
|
||||
viewPosRT = start + tvector;
|
||||
}
|
||||
|
||||
vec2 absPos = abs(refPos.xy - 0.5);
|
||||
vec2 cdist = absPos / rEdge;
|
||||
float border = clamp(1.0 - pow(max(cdist.x, cdist.y), 50.0), 0.0, 1.0);
|
||||
|
||||
vec4 reflection = vec4(0.0);
|
||||
if (refPos.z < 0.99997) {
|
||||
reflection.a = border;
|
||||
|
||||
float lViewPosRT = length(rfragpos);
|
||||
|
||||
if (reflection.a > 0.001) {
|
||||
vec2 edgeFactor = pow2(pow2(pow2(cdist)));
|
||||
refPos.y += (dither - 0.5) * (0.05 * (edgeFactor.x + edgeFactor.y));
|
||||
|
||||
#ifdef DEFERRED1
|
||||
float smoothnessDM = pow2(smoothness);
|
||||
float lodFactor = 1.0 - exp(-0.125 * (1.0 - smoothnessDM) * dist);
|
||||
float lod = log2(viewHeight / 8.0 * (1.0 - smoothnessDM) * lodFactor) * 0.45;
|
||||
#ifdef CUSTOM_PBR
|
||||
if (z0 <= 0.56) lod *= 2.22;
|
||||
#endif
|
||||
lod = max(lod - 1.0, 0.0);
|
||||
|
||||
reflection.rgb = texture2DLod(colortex0, refPos.xy, lod).rgb;
|
||||
#else
|
||||
reflection = texture2D(gaux2, refPos.xy);
|
||||
reflection.rgb = pow2(reflection.rgb + 1.0);
|
||||
#endif
|
||||
|
||||
/**/
|
||||
float skyFade = 0.0;
|
||||
DoFog(reflection.rgb, skyFade, lViewPosRT, ViewToPlayer(rfragpos.xyz), RVdotU, RVdotS, dither);
|
||||
|
||||
edgeFactor.x = pow2(edgeFactor.x);
|
||||
edgeFactor = 1.0 - edgeFactor;
|
||||
reflection.a *= pow(edgeFactor.x * edgeFactor.y, 2.0 + 3.0 * GetLuminance(reflection.rgb));
|
||||
}
|
||||
|
||||
float posDif = lViewPosRT - lViewPos;
|
||||
reflection.a *= clamp(posDif + 3.0, 0.0, 1.0);
|
||||
}
|
||||
#if defined DEFERRED1 && defined TEMPORAL_FILTER
|
||||
else refPos.z = 1.0;
|
||||
#endif
|
||||
|
||||
if (reflection.a < 1.0) {
|
||||
#ifdef OVERWORLD
|
||||
vec3 skyReflection = GetSky(RVdotU, RVdotS, dither, true, true);
|
||||
|
||||
//skyReflection += pow(lightColor, vec3(0.8)) * 0.6 * rainFactor2; // Add approximate light shaft color
|
||||
|
||||
skyReflection *= atmColorMult;
|
||||
|
||||
#ifdef DEFERRED1
|
||||
skyReflection *= skyLightFactor;
|
||||
#else
|
||||
skyReflection = mix(color * 0.5, skyReflection, skyLightFactor);
|
||||
|
||||
float specularHighlight = GGX(normalM, nViewPos, lightVec, max(dot(normalM, lightVec), 0.0), smoothness);
|
||||
skyReflection += specularHighlight * highlightColor * shadowMult * highlightMult * invRainFactor;
|
||||
#endif
|
||||
#elif defined END
|
||||
#ifdef DEFERRED1
|
||||
vec3 skyReflection = (endSkyColor + 0.4 * DrawEnderBeams(RVdotU, playerPos)) * skyLightFactor;
|
||||
#else
|
||||
vec3 skyReflection = endSkyColor * shadowMult;
|
||||
#endif
|
||||
|
||||
skyReflection *= atmColorMult;
|
||||
#else
|
||||
vec3 skyReflection = vec3(0.0);
|
||||
#endif
|
||||
|
||||
reflection.rgb = mix(skyReflection, reflection.rgb, reflection.a);
|
||||
}
|
||||
|
||||
return reflection;
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
float GetApproxDistance(float depth) {
|
||||
return near * far / (far - depth * far);
|
||||
}
|
||||
|
||||
void DoRefraction(inout vec3 color, inout float z0, inout float z1, vec3 viewPos, float lViewPos) {
|
||||
// Prep
|
||||
if (int(texelFetch(colortex1, texelCoord, 0).g * 255.1) != 241) return;
|
||||
|
||||
float fovScale = gbufferProjection[1][1];
|
||||
|
||||
vec3 playerPos = ViewToPlayer(viewPos.xyz);
|
||||
vec3 worldPos = playerPos.xyz + cameraPosition.xyz;
|
||||
vec2 worldPosRM = worldPos.xz * 0.02 + worldPos.y * 0.01 + 0.01 * frameTimeCounter;
|
||||
|
||||
vec2 refractNoise = texture2D(noisetex, worldPosRM).rb - vec2(0.5);
|
||||
refractNoise *= WATER_REFRACTION_INTENSITY * fovScale / (3.0 + lViewPos);
|
||||
|
||||
#if WATER_STYLE < 3
|
||||
refractNoise *= 0.015;
|
||||
#else
|
||||
refractNoise *= 0.02;
|
||||
#endif
|
||||
|
||||
// Check
|
||||
float approxDif = GetApproxDistance(z1) - GetApproxDistance(z0);
|
||||
refractNoise *= clamp(approxDif, 0.0, 1.0);
|
||||
|
||||
vec2 refractCoord = texCoord.xy + refractNoise;
|
||||
|
||||
if (int(texture2D(colortex1, refractCoord).g * 255.1) != 241) return;
|
||||
|
||||
float z0check = texture2D(depthtex0, refractCoord).r;
|
||||
float z1check = texture2D(depthtex1, refractCoord).r;
|
||||
float approxDifCheck = GetApproxDistance(z1check) - GetApproxDistance(z0check);
|
||||
refractNoise *= clamp(approxDifCheck, 0.0, 1.0);
|
||||
|
||||
// Sample
|
||||
refractCoord = texCoord.xy + refractNoise;
|
||||
color = texture2D(colortex0, refractCoord).rgb;
|
||||
z0 = texture2D(depthtex0, refractCoord).r;
|
||||
z1 = texture2D(depthtex1, refractCoord).r;
|
||||
}
|
||||
@ -0,0 +1,131 @@
|
||||
vec3 GetWave(in vec3 pos, float waveSpeed) {
|
||||
float wind = frameTimeCounter * waveSpeed * WAVING_SPEED;
|
||||
|
||||
float magnitude = sin(wind * 0.0027 + pos.z + pos.y) * 0.04 + 0.04;
|
||||
magnitude *= mix(1.0, 2.5, rainFactor);
|
||||
float d0 = sin(wind * 0.0127);
|
||||
float d1 = sin(wind * 0.0089);
|
||||
float d2 = sin(wind * 0.0114);
|
||||
vec3 wave;
|
||||
wave.x = sin(wind*0.0063 + d0 + d1 - pos.x + pos.z + pos.y) * magnitude;
|
||||
wave.z = sin(wind*0.0224 + d1 + d2 + pos.x - pos.z + pos.y) * magnitude;
|
||||
wave.y = sin(wind*0.0015 + d2 + d0 + pos.z + pos.y - pos.y) * magnitude;
|
||||
|
||||
#ifdef NO_WAVING_INDOORS
|
||||
wave *= clamp(lmCoord.y - 0.87, 0.0, 0.1);
|
||||
#else
|
||||
wave *= 0.1;
|
||||
#endif
|
||||
|
||||
return wave * WAVING_I;
|
||||
}
|
||||
|
||||
void DoWave_Foliage(inout vec3 playerPos, vec3 worldPos) {
|
||||
worldPos.y *= 0.5;
|
||||
|
||||
vec3 wave = GetWave(worldPos, 170.0);
|
||||
wave.x = wave.x * 8.0 + wave.y * 4.0;
|
||||
wave.y = 0.0;
|
||||
wave.z = wave.z * 3.0;
|
||||
|
||||
playerPos.xyz += wave;
|
||||
}
|
||||
|
||||
void DoWave_GroundedFoliage(inout vec3 playerPos, vec3 worldPos) {
|
||||
if (gl_MultiTexCoord0.t < mc_midTexCoord.t || fract(worldPos.y + 0.21) > 0.26) {
|
||||
DoWave_Foliage(playerPos, worldPos);
|
||||
}
|
||||
}
|
||||
|
||||
void DoWave_Leaves(inout vec3 playerPos, vec3 worldPos, float waveMult) {
|
||||
worldPos *= vec3(0.5, 0.25, 0.5);
|
||||
|
||||
vec3 wave = GetWave(worldPos, 170.0);
|
||||
wave *= vec3(8.0, 3.0, 4.0);
|
||||
|
||||
playerPos.xyz += wave * waveMult;
|
||||
}
|
||||
|
||||
void DoWave_Water(inout vec3 playerPos, vec3 worldPos) {
|
||||
if (fract(worldPos.y + 0.005) > 0.06) {
|
||||
float waterWaveTime = frameTimeCounter * 6.0 * WAVING_SPEED;
|
||||
worldPos.xz *= 18.0;
|
||||
|
||||
float wave = sin(waterWaveTime * 0.7 + worldPos.x * 0.14 + worldPos.z * 0.07);
|
||||
wave += sin(waterWaveTime * 0.5 + worldPos.x * 0.10 + worldPos.z * 0.05);
|
||||
|
||||
#ifdef NO_WAVING_INDOORS
|
||||
wave *= clamp(lmCoord.y - 0.87, 0.0, 0.1);
|
||||
#else
|
||||
wave *= 0.1;
|
||||
#endif
|
||||
|
||||
playerPos.y += wave * 0.125 - 0.05;
|
||||
}
|
||||
}
|
||||
|
||||
void DoWave_Lava(inout vec3 playerPos, vec3 worldPos) {
|
||||
if (fract(worldPos.y + 0.005) > 0.06) {
|
||||
float lavaWaveTime = frameTimeCounter * 3.0 * WAVING_SPEED;
|
||||
worldPos.xz *= 14.0;
|
||||
|
||||
float wave = sin(lavaWaveTime * 0.7 + worldPos.x * 0.14 + worldPos.z * 0.07);
|
||||
wave += sin(lavaWaveTime * 0.5 + worldPos.x * 0.05 + worldPos.z * 0.10);
|
||||
|
||||
playerPos.y += wave * 0.0125;
|
||||
}
|
||||
}
|
||||
|
||||
void DoWave(inout vec3 playerPos, int mat) {
|
||||
vec3 worldPos = playerPos.xyz + cameraPosition.xyz;
|
||||
|
||||
#if defined GBUFFERS_TERRAIN || defined SHADOW
|
||||
#ifdef WAVING_FOLIAGE
|
||||
if (mat == 10003 || mat == 10004) { // Grounded Waving Foliage
|
||||
DoWave_GroundedFoliage(playerPos.xyz, worldPos);
|
||||
} else if (mat == 10020 || mat == 10021) { // Upper Layer Waving Foliage
|
||||
DoWave_Foliage(playerPos.xyz, worldPos);
|
||||
}
|
||||
|
||||
#if defined WAVING_LEAVES || defined WAVING_LAVA
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WAVING_LEAVES
|
||||
if (mat == 10008) { // Leaves
|
||||
DoWave_Leaves(playerPos.xyz, worldPos, 1.0);
|
||||
} else if (mat == 10012) { // Vine
|
||||
// Reduced waving on vines to prevent clipping through blocks
|
||||
DoWave_Leaves(playerPos.xyz, worldPos, 0.75);
|
||||
}
|
||||
|
||||
#ifdef WAVING_LAVA
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WAVING_LAVA
|
||||
if (mat == 10068 || mat == 10069) { // Lava
|
||||
DoWave_Lava(playerPos.xyz, worldPos);
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
// 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
|
||||
#endif
|
||||
|
||||
#if defined GBUFFERS_WATER || defined SHADOW
|
||||
#ifdef WAVING_WATER_VERTEX
|
||||
#if defined WAVING_ANYTHING_TERRAIN && defined SHADOW
|
||||
else
|
||||
#endif
|
||||
|
||||
if (mat == 31000) { // Water
|
||||
DoWave_Water(playerPos.xyz, worldPos);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1 @@
|
||||
#include "/spookylib/materials/specificMaterials/entities/itemFrame.glsl"
|
||||
@ -0,0 +1 @@
|
||||
noSmoothLighting = true;
|
||||
@ -0,0 +1 @@
|
||||
color = vec4(1.0, 1.25, 1.875, 1.0);
|
||||
@ -0,0 +1,65 @@
|
||||
// End Portal fix by fayer3#2332 (Modified)
|
||||
vec3[8] colors = vec3[](
|
||||
vec3(0.3472479, 0.6559956, 0.7387838) * 1.5,
|
||||
vec3(0.6010780, 0.7153565, 1.060625 ),
|
||||
vec3(0.4221090, 0.8135094, 0.9026056),
|
||||
vec3(0.3492291, 1.0241201, 1.8612821),
|
||||
vec3(0.7543085, 0.8238697, 0.6803233),
|
||||
vec3(0.4144472, 0.5648165, 0.8037 ),
|
||||
vec3(0.508905 , 0.6719649, 0.9982805),
|
||||
vec3(0.5361914, 0.4476583, 0.8008522));
|
||||
color.rgb = vec3(0.4214321, 0.4722309, 1.9922364) * 0.08;
|
||||
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + 1.61803398875 * mod(float(frameCounter), 3600.0));
|
||||
int repeat = 4;
|
||||
#else
|
||||
int repeat = 8;
|
||||
#endif
|
||||
float dismult = 0.5;
|
||||
for (int j = 0; j < repeat; j++) {
|
||||
float add = float(j + dither) * 0.0625 / float(repeat);
|
||||
for (int i = 1; i <= 8; i++) {
|
||||
float colormult = 0.9/(30.0+i);
|
||||
float rotation = (i - 0.1 * i + 0.71 * i - 11 * i + 21) * 0.01 + i * 0.01;
|
||||
float Cos = cos(radians(rotation));
|
||||
float Sin = sin(radians(rotation));
|
||||
vec2 offset = vec2(0.0, 1.0/(3600.0/24.0)) * pow(16.0 - i, 2.0) * 0.004;
|
||||
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * (i * dismult + 1), 1.0)).xyz);
|
||||
if (abs(NdotU) > 0.9) {
|
||||
wpos.xz /= wpos.y;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.y);
|
||||
wpos.xz *= abs(playerPos.y) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.xz * 0.05;
|
||||
} else {
|
||||
vec3 absPos = abs(playerPos);
|
||||
if (abs(dot(normal, eastVec)) > 0.9) {
|
||||
wpos.xz = wpos.yz / wpos.x;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.x);
|
||||
wpos.xz *= abs(playerPos.x) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.yz * 0.05;
|
||||
} else {
|
||||
wpos.xz = wpos.yx / wpos.z;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.z);
|
||||
wpos.xz *= abs(playerPos.z) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.yx * 0.05;
|
||||
}
|
||||
}
|
||||
vec2 pos = wpos.xz;
|
||||
|
||||
vec2 wind = fract((frameTimeCounter + 984.0) * (i + 8) * 0.125 * offset);
|
||||
vec2 coord = mat2(Cos, Sin, -Sin, Cos) * pos + wind;
|
||||
if (mod(float(i), 4) < 1.5) coord = coord.yx + vec2(-1.0, 1.0) * wind.y;
|
||||
|
||||
vec3 psample = pow(texture2D(tex, coord).rgb, vec3(0.85)) * colors[i-1] * colormult;
|
||||
color.rgb += psample * length(psample.rgb) * (3000.0 / repeat);
|
||||
}
|
||||
}
|
||||
color.rgb *= 0.4;
|
||||
noDirectionalShading = true;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.0;
|
||||
#endif
|
||||
@ -0,0 +1,15 @@
|
||||
normalM = upVec;
|
||||
|
||||
highlightMult = 0.0;
|
||||
shadowMult = vec3(0.0);
|
||||
|
||||
#if MC_VERSION >= 11700
|
||||
if (lmCoord.x > 0.99) { // Glowing Sign Text
|
||||
lmCoordM = vec2(0.0);
|
||||
|
||||
emission = 1.0;
|
||||
|
||||
color.rgb *= length(color.rgb) + 0.5;
|
||||
} else // Normal Sign Text
|
||||
#endif
|
||||
color.rgb *= 5.0;
|
||||
@ -0,0 +1,4 @@
|
||||
smoothnessG = color.g;
|
||||
smoothnessD = color.g;
|
||||
|
||||
emission = min(max0(dot(color.rgb, color.rgb) - 1.0) * 6.0, 1.0);
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.r)) * 0.65;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = color.r * 0.4;
|
||||
|
||||
smoothnessD = color.r * 0.3;
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 0.75;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.r) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = color.r * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(pow2(color.g))) * 12.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(color.r) * 0.7;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(pow2(color.g))) * 12.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 8.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.g) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = color.r;
|
||||
smoothnessD = color.r;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
@ -0,0 +1,2 @@
|
||||
smoothnessG = color.r;
|
||||
smoothnessD = color.r * 0.65;
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(pow2(color.g));
|
||||
smoothnessD = smoothnessG;
|
||||
smoothnessG = max(smoothnessG, 0.3 * color.g * float(color.g > color.b * 1.5));
|
||||
@ -0,0 +1,7 @@
|
||||
float lColor = length(color.rgb);
|
||||
smoothnessG = lColor * 0.2;
|
||||
smoothnessD = lColor * 0.15;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,11 @@
|
||||
#include "/spookylib/materials/specificMaterials/terrain/obsidian.glsl"
|
||||
|
||||
highlightMult *= 0.5;
|
||||
|
||||
float factor0 = sqrt2(max0(color.b - color.g * 6.0));
|
||||
float factor1 = pow2(color.b);
|
||||
emission = 1.35 + pow2(pow2(factor1)) * 7.5;
|
||||
emission *= factor0;
|
||||
color.r *= 1.15;
|
||||
|
||||
maRecolor = vec3(factor0 * min(max0(factor1 * 0.7 - 0.1) * 1.3, 0.5));
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 4.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
@ -0,0 +1,25 @@
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
|
||||
float factor = max(color.g, 0.8);
|
||||
float factor2 = pow2(factor);
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
float factor4 = pow2(factor2);
|
||||
#else
|
||||
float factor4 = factor2;
|
||||
#endif
|
||||
|
||||
smoothnessG = factor - pow2(pow2(color.g)) * 0.4;
|
||||
highlightMult = 3.0 * max(pow2(factor4), 0.2);
|
||||
|
||||
smoothnessD = factor4 * 0.75;
|
||||
|
||||
#if MC_VERSION < 11300
|
||||
highlightMult *= 2.0;
|
||||
smoothnessD /= 0.75;
|
||||
#endif
|
||||
|
||||
color.rgb *= 0.7 + 0.4 * GetLuminance(color.rgb);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1 @@
|
||||
smoothnessG = color.r * 0.1 + 0.1;
|
||||
@ -0,0 +1,14 @@
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
|
||||
float factor = color.g;
|
||||
float factor2 = pow2(factor);
|
||||
float factor4 = pow2(factor2);
|
||||
|
||||
smoothnessG = factor - factor4 * 0.4;
|
||||
highlightMult = 1.5 + 1.5 * factor4;
|
||||
|
||||
smoothnessD = factor4 * 0.75;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1,3 @@
|
||||
// End Portal Frame:Green Parts
|
||||
smoothnessG = 0.25;
|
||||
smoothnessD = 0.45;
|
||||
@ -0,0 +1,7 @@
|
||||
float factor = pow2(pow2(color.r));
|
||||
smoothnessG = factor * 0.65;
|
||||
smoothnessD = smoothnessG * 0.6;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,10 @@
|
||||
noSmoothLighting = true; noDirectionalShading = true;
|
||||
lmCoordM = vec2(1.0, 0.0);
|
||||
|
||||
float blockRes = absMidCoordPos.x * atlasSize.x;
|
||||
vec2 signMidCoordPosM = abs((floor((signMidCoordPos + 1.0) * blockRes) + 0.5) / blockRes - 1.0);
|
||||
float value = 1.0 - max(signMidCoordPosM.x, signMidCoordPosM.y);
|
||||
emission = 0.3 + value + pow(dot(color.rgb, color.rgb) * 0.33, frogPow);
|
||||
emission *= 1.7;
|
||||
|
||||
color.rgb = pow2(color.rgb);
|
||||
@ -0,0 +1,20 @@
|
||||
materialMask = OSIEBCA * 3.0; // Gold Fresnel
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
float colorG2 = pow2(color.g);
|
||||
#else
|
||||
float colorG2 = color.g;
|
||||
#endif
|
||||
float colorG4 = pow2(colorG2);
|
||||
float factor = max(color.g, 0.8);
|
||||
|
||||
smoothnessG = min1(factor - colorG4 * 0.5);
|
||||
highlightMult = 3.5 * max(colorG4, 0.2);
|
||||
|
||||
smoothnessD = colorG4;
|
||||
|
||||
color.rgb *= 0.5 + 0.4 * GetLuminance(color.rgb);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
@ -0,0 +1,14 @@
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
smoothnessG = pow2(pow2(color.r));
|
||||
#else
|
||||
smoothnessG = pow2(color.r);
|
||||
#endif
|
||||
highlightMult = smoothnessG * 3.0;
|
||||
smoothnessD = smoothnessG;
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
|
||||
color.rgb *= 0.6 + 0.5 * GetLuminance(color.rgb);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = color.b;
|
||||
smoothnessD = color.b;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.b) * 0.8;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1,33 @@
|
||||
// Tweak to prevent the animation of lava causing brightness pulsing
|
||||
vec3 avgColor = vec3(0.0);
|
||||
ivec2 itexCoordC = ivec2(midCoord * atlasSize + 0.0001);
|
||||
for (int x = -8; x < 8; x += 2) {
|
||||
for (int y = -8; y < 8; y += 2) {
|
||||
avgColor += texelFetch(tex, itexCoordC + ivec2(x, y), 0).rgb;
|
||||
}
|
||||
}
|
||||
color.rgb /= max(GetLuminance(avgColor) * 0.0390625, 0.001);
|
||||
noDirectionalShading = true;
|
||||
lmCoordM = vec2(0.0);
|
||||
emission = GetLuminance(color.rgb) * 6.5;
|
||||
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
vec2 lavaPos = (floor(worldPos.xz * 16.0) + worldPos.y * 32.0) * 0.000666;
|
||||
vec2 wind = vec2(frameTimeCounter * 0.012, 0.0);
|
||||
|
||||
#ifdef NETHER
|
||||
float noiseSample = texture2D(noisetex, lavaPos + wind).g;
|
||||
noiseSample = noiseSample - 0.5;
|
||||
noiseSample *= 0.1;
|
||||
color.rgb = pow(color.rgb, vec3(1.0 + noiseSample));
|
||||
#endif
|
||||
|
||||
if (mat == 10068 || mat == 10069){
|
||||
#include "/spookylib/materials/specificMaterials/terrain/lavaNoise.glsl"
|
||||
}
|
||||
|
||||
#if RAIN_PUDDLES >= 1
|
||||
noPuddles = 1.0;
|
||||
#endif
|
||||
|
||||
color.rgb = max(color.rgb, 0.023); // so black spots still have some textures and aren't fully black
|
||||
@ -0,0 +1,35 @@
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
float columnNoise = 0.0;
|
||||
float noise = 0.0;
|
||||
vec3 lavaNoiseColor = color.rgb + 0.1;
|
||||
float lavaNoiseEmission = emission;
|
||||
if (mat == 10068 || columnNoise == 1.0) {
|
||||
#ifdef NETHER
|
||||
if (worldPos.y > 30 && worldPos.y < 32) {
|
||||
noise += texture2D(noisetex, lavaPos * 0.2 + wind * 0.1).r;
|
||||
noise += texture2D(noisetex, lavaPos * 0.8 + wind * 0.04).r * 0.5;
|
||||
noise *= texture2D(noisetex, lavaPos * 0.1 + wind * 0.02).r * 0.5;
|
||||
lavaNoiseEmission *= 1.6;
|
||||
lavaNoiseColor *= smoothstep(0.00, 0.50, noise);
|
||||
lavaNoiseColor.r *= 1.2;
|
||||
}
|
||||
else {
|
||||
noise += texture2D(noisetex, lavaPos * 0.05 + wind * 0.01).r;
|
||||
noise -= texture2D(noisetex, lavaPos * 1.5 + wind * 0.05).r * 0.3;
|
||||
noise += texture2D(noisetex, lavaPos * 0.1).r * 0.7;
|
||||
lavaNoiseColor *= smoothstep(0.00, 0.70, noise);
|
||||
lavaNoiseColor.r *= 1.5;
|
||||
}
|
||||
#else
|
||||
noise += texture2D(noisetex, lavaPos * 0.2 + wind * 0.01).g;
|
||||
noise -= texture2D(noisetex, lavaPos * 2.0 + wind * 0.05).g * 0.3;
|
||||
noise += texture2D(noisetex, lavaPos * 0.1).g * 0.3;
|
||||
lavaNoiseColor *= smoothstep(0.00, 0.70, noise);
|
||||
lavaNoiseColor.r *= 1.25;
|
||||
lavaNoiseEmission *= 1.1;
|
||||
#endif
|
||||
}
|
||||
|
||||
color.rgb = mix(color.rgb, lavaNoiseColor, lavaNoiseIntensity);
|
||||
emission = mix(emission, lavaNoiseEmission, lavaNoiseIntensity);
|
||||
#endif
|
||||
@ -0,0 +1,19 @@
|
||||
subsurfaceMode = 2;
|
||||
materialMask = OSIEBCA * 253.0; // Reduced Edge TAA
|
||||
|
||||
#ifdef IPBR
|
||||
float factor = min1(pow2(color.g - 0.15 * (color.r + color.b)) * 2.5);
|
||||
smoothnessG = factor * 0.5;
|
||||
highlightMult = factor * 4.0 + 2.0;
|
||||
float fresnel = clamp(1.0 + dot(normalM, normalize(viewPos)), 0.0, 1.0);
|
||||
highlightMult *= 1.0 - pow2(pow2(fresnel));
|
||||
#endif
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
snowMinNdotU = min(pow2(pow2(color.g)), 0.1);
|
||||
color.rgb = color.rgb * 0.5 + 0.5 * (color.rgb / glColor.rgb);
|
||||
#endif
|
||||
|
||||
#if defined REALTIME_SHADOWS && SHADOW_QUALITY < 3
|
||||
shadowMult = vec3(sqrt1(max0(max(lmCoordM.y, min1(lmCoordM.x * 2.0)) - 0.95) * 20.0));
|
||||
#endif
|
||||
@ -0,0 +1,8 @@
|
||||
smoothnessG = pow2(color.r * 2.0);
|
||||
smoothnessG = min1(smoothnessG);
|
||||
highlightMult = smoothnessG * 2.0;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
#if MC_VERSION >= 11300
|
||||
smoothnessG = pow2(color.r) * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
#else
|
||||
smoothnessG = color.r * 0.4 + 0.2;
|
||||
#endif
|
||||
smoothnessD = smoothnessG;
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 2.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
@ -0,0 +1,13 @@
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
|
||||
float factor = max0(0.3 - abs(color.r - 0.3)) * 1.5;
|
||||
|
||||
smoothnessG = factor;
|
||||
highlightMult = 2.0 + min1(smoothnessG * 2.0) * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
|
||||
smoothnessD = min1(factor + 0.07);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 1.25;
|
||||
#endif
|
||||
@ -0,0 +1 @@
|
||||
smoothnessG = color.g * 0.25;
|
||||
@ -0,0 +1,19 @@
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
|
||||
float factor = color.g;
|
||||
float factor2 = pow2(factor);
|
||||
float factor4 = pow2(factor2);
|
||||
float factor8 = pow2(factor4);
|
||||
|
||||
smoothnessG = factor - factor8 * 0.5;
|
||||
highlightMult = 3.5 * factor8;
|
||||
|
||||
smoothnessD = factor8;
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
DoBrightBlockTweaks(color.rgb, 0.5, shadowMult, highlightMult);
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1,4 @@
|
||||
materialMask = OSIEBCA * 2.0; // Copper Fresnel
|
||||
smoothnessG = pow2(color.r + color.g * 0.25) * 0.4;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = min1(smoothnessG * smoothnessG * 2.0);
|
||||
@ -0,0 +1,3 @@
|
||||
materialMask = OSIEBCA * 3.0; // Gold Fresnel
|
||||
smoothnessG = pow2(pow2(color.g));
|
||||
smoothnessD = 0.5 * (smoothnessG + color.b);
|
||||
@ -0,0 +1,3 @@
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
smoothnessG = pow2(pow2(color.r)) * 0.7;
|
||||
smoothnessD = smoothnessG * 0.6;
|
||||
@ -0,0 +1,11 @@
|
||||
materialMask = OSIEBCA * 5.0; // Redstone Fresnel
|
||||
|
||||
float factor = pow2(color.r);
|
||||
smoothnessG = 0.4;
|
||||
highlightMult = factor + 0.2;
|
||||
|
||||
smoothnessD = factor * 0.5 + 0.1;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,15 @@
|
||||
noSmoothLighting = true; noDirectionalShading = true;
|
||||
lmCoordM.x = min(lmCoordM.x * 0.9, 0.77);
|
||||
|
||||
if (color.r > 0.65) {
|
||||
emission = (3.5 - 2.25 * color.g) * 0.97;
|
||||
color.rgb *= color.rgb;
|
||||
} else if (color.r > color.g * 2.0) {
|
||||
materialMask = OSIEBCA * 5.0; // Redstone Fresnel
|
||||
|
||||
float factor = pow2(color.r);
|
||||
smoothnessG = 0.4;
|
||||
highlightMult = factor + 0.4;
|
||||
|
||||
smoothnessD = factor * 0.7 + 0.3;
|
||||
}
|
||||
@ -0,0 +1,12 @@
|
||||
smoothnessG = (1.0 - pow(color.g, 64.0) * 0.3) * 0.4;
|
||||
highlightMult = 2.0;
|
||||
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
DoBrightBlockTweaks(color.rgb, 0.5, shadowMult, highlightMult);
|
||||
#endif
|
||||
|
||||
#if RAIN_PUDDLES >= 1
|
||||
noPuddles = 1.0;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,22 @@
|
||||
if (color.a > 0.001) {
|
||||
smoothnessG = 1.0;
|
||||
highlightMult = 3.5;
|
||||
reflectMult = 0.5;
|
||||
|
||||
translucentMultCalculated = true;
|
||||
translucentMult = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
} else {
|
||||
#ifdef FANCY_GLASS
|
||||
smoothnessG = 0.5;
|
||||
highlightMult = 2.5;
|
||||
reflectMult = 1.0;
|
||||
color.rgb = vec3(0.75, 0.8, 0.85);
|
||||
|
||||
translucentMultCalculated = true;
|
||||
translucentMult.a = 0.0;
|
||||
|
||||
color.a = max(color.a, GLASS_OPACITY);
|
||||
#else
|
||||
discard;
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1,34 @@
|
||||
lmCoordM = vec2(0.0);
|
||||
color = vec4(0.0);
|
||||
|
||||
int sampleCount = 8;
|
||||
|
||||
float multiplier = 0.4 / (-viewVector.z * sampleCount);
|
||||
vec2 interval = viewVector.xy * multiplier;
|
||||
vec2 coord = signMidCoordPos * 0.5 + 0.5;
|
||||
vec2 absMidCoordPos2 = absMidCoordPos * 2.0;
|
||||
vec2 midCoord = texCoord - absMidCoordPos * signMidCoordPos;
|
||||
vec2 minimumMidCoordPos = midCoord - absMidCoordPos;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float portalStep = (i + dither) / sampleCount;
|
||||
coord += interval * portalStep;
|
||||
vec2 sampleCoord = fract(coord) * absMidCoordPos2 + minimumMidCoordPos;
|
||||
vec4 psample = texture2DLod(tex, sampleCoord, 0);
|
||||
|
||||
float factor = 1.0 - portalStep;
|
||||
psample *= pow(factor, 0.1);
|
||||
|
||||
emission = max(emission, psample.r);
|
||||
|
||||
color += psample;
|
||||
}
|
||||
color /= sampleCount;
|
||||
|
||||
color.rgb *= color.rgb * vec3(1.25, 1.0, 0.65);
|
||||
color.a = sqrt1(color.a) * 0.8;
|
||||
|
||||
emission *= emission;
|
||||
emission *= emission;
|
||||
emission *= emission;
|
||||
emission = clamp(emission * 120.0, 0.03, 1.2) * 8.0;
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = 0.5;
|
||||
highlightMult = 1.5;
|
||||
reflectMult = 1.0;
|
||||
@ -0,0 +1,256 @@
|
||||
#if MC_VERSION >= 11300
|
||||
#if WATERCOLOR_MODE >= 2
|
||||
vec3 glColorM = glColor.rgb;
|
||||
|
||||
#if WATERCOLOR_MODE >= 3
|
||||
glColorM.g = max(glColorM.g, 0.39);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
translucentMultCalculated = true;
|
||||
translucentMult.rgb = normalize(sqrt2(glColor.rgb));
|
||||
translucentMult.g *= 0.88;
|
||||
#endif
|
||||
|
||||
glColorM = sqrt1(glColorM) * vec3(1.0, 0.85, 0.8);
|
||||
#else
|
||||
vec3 glColorM = vec3(0.43, 0.6, 0.8);
|
||||
#endif
|
||||
|
||||
#if WATER_STYLE < 3
|
||||
vec3 colorPM = pow2(colorP.rgb);
|
||||
color.rgb = colorPM * glColorM;
|
||||
#else
|
||||
vec3 colorPM = vec3(0.25);
|
||||
color.rgb = 0.375 * glColorM;
|
||||
#endif
|
||||
#else
|
||||
#if WATER_STYLE < 3
|
||||
color.rgb = mix(color.rgb, vec3(GetLuminance(color.rgb)), 0.88);
|
||||
color.rgb = pow2(color.rgb) * vec3(2.3, 3.5, 3.1) * 0.9;
|
||||
#else
|
||||
color.rgb = vec3(0.13, 0.2, 0.27);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WATERCOLOR_CHANGED
|
||||
color.rgb *= vec3(WATERCOLOR_RM, WATERCOLOR_GM, WATERCOLOR_BM);
|
||||
#endif
|
||||
|
||||
#define PHYSICS_OCEAN_INJECTION
|
||||
#if defined GENERATED_NORMALS && (WATER_STYLE >= 2 || defined PHYSICS_OCEAN)
|
||||
noGeneratedNormals = true;
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
lmCoordM.y = min(lmCoord.y * 1.07, 1.0); // Iris/Sodium skylight inconsistency workaround
|
||||
|
||||
reflectMult = 1.0;
|
||||
|
||||
#if WATER_QUALITY >= 3
|
||||
materialMask = OSIEBCA * 241.0; // Water
|
||||
#endif
|
||||
|
||||
#if WATER_QUALITY >= 2 || WATER_STYLE >= 2
|
||||
#define WATER_SPEED_MULT_M WATER_SPEED_MULT * 0.018
|
||||
vec2 wind = vec2(frameTimeCounter * WATER_SPEED_MULT_M, 0.0);
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
vec2 waterPos = worldPos.xz * 16.0;
|
||||
#if WATER_STYLE < 3
|
||||
waterPos = floor(waterPos);
|
||||
#endif
|
||||
waterPos = 0.002 * (waterPos + worldPos.y * 32.0);
|
||||
#endif
|
||||
|
||||
// Water Normals
|
||||
#if WATER_STYLE >= 2 || RAIN_PUDDLES >= 1 && WATER_STYLE == 1 && WATER_QUALITY >= 2
|
||||
vec3 normalMap = vec3(0.0, 0.0, 1.0);
|
||||
#if WATER_STYLE >= 2
|
||||
vec2 waterPosM = waterPos;
|
||||
|
||||
#if WATER_SIZE_MULT != 100
|
||||
#define WATER_SIZE_MULT_M WATER_SIZE_MULT * 0.01
|
||||
waterPosM *= WATER_SIZE_MULT_M;
|
||||
#endif
|
||||
|
||||
#define WATER_BUMPINESS_M WATER_BUMPINESS * 0.8
|
||||
|
||||
float rainWaterStrength = mix(1.0, 2.5, rainFactor);
|
||||
|
||||
#if WATER_STYLE >= 2
|
||||
waterPosM *= 2.5; wind *= 2.5;
|
||||
|
||||
#if WATER_QUALITY >= 2
|
||||
vec2 parallaxMult = -0.01 * viewVector.xy / viewVector.z;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
waterPosM += parallaxMult * texture2D(gaux4, waterPosM - wind).a;
|
||||
waterPosM += parallaxMult * texture2D(gaux4, waterPosM * 0.25 - 0.5 * wind).a;
|
||||
}
|
||||
#endif
|
||||
|
||||
vec2 normalMed = texture2D(gaux4, waterPosM + wind).rg - 0.5;
|
||||
vec2 normalSmall = texture2D(gaux4, waterPosM * 4.0 - 2.0 * wind).rg - 0.5;
|
||||
vec2 normalBig = texture2D(gaux4, waterPosM * 0.25 - 0.5 * wind).rg - 0.5;
|
||||
normalBig += texture2D(gaux4, waterPosM * 0.05 - 0.05 * wind).rg - 0.5;
|
||||
|
||||
normalMap.xy = normalMed * WATER_BUMP_MED + normalSmall * WATER_BUMP_SMALL + normalBig * WATER_BUMP_BIG;
|
||||
normalMap.xy *= 12.0 * (1.0 - fresnel) * WATER_BUMPINESS_M * rainWaterStrength;
|
||||
#endif
|
||||
|
||||
normalMap.xy *= 0.03 * lmCoordM.y + 0.01;
|
||||
#else
|
||||
float pNormalMult = 0.02 * rainFactor * inRainy * pow2(lmCoordM.y);
|
||||
|
||||
if (pNormalMult > 0.0005) {
|
||||
vec2 puddlePos = floor((playerPos.xz + cameraPosition.xz) * 16.0) * 0.00625;
|
||||
|
||||
vec2 puddleWind = vec2(frameTimeCounter) * 0.015;
|
||||
vec2 pNormalCoord1 = puddlePos + vec2(puddleWind.x, puddleWind.y);
|
||||
vec2 pNormalCoord2 = puddlePos + vec2(puddleWind.x * -1.5, puddleWind.y * -1.0);
|
||||
vec3 pNormalNoise1 = texture2D(noisetex, pNormalCoord1).rgb;
|
||||
vec3 pNormalNoise2 = texture2D(noisetex, pNormalCoord2).rgb;
|
||||
|
||||
normalMap.xy = (pNormalNoise1.xy + pNormalNoise2.xy - vec2(1.0)) * pNormalMult;
|
||||
#endif
|
||||
|
||||
normalMap.z = sqrt(1.0 - (pow2(normalMap.x) + pow2(normalMap.y)));
|
||||
normalM = clamp(normalize(normalMap * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
|
||||
#if WATER_STYLE == 1
|
||||
}
|
||||
#endif
|
||||
|
||||
#if WATER_STYLE >= 2
|
||||
vec3 vector = reflect(nViewPos, normalize(normalM));
|
||||
float norMix = pow2(pow2(pow2(1.0 - max0(dot(normal, vector))))) * 0.5;
|
||||
normalM = mix(normalM, normal, norMix); // Fixes normals pointing inside water
|
||||
|
||||
float fresnelP = fresnel;
|
||||
fresnel = clamp(1.0 + dot(normalM, nViewPos), 0.0, 1.0);
|
||||
#endif
|
||||
#endif
|
||||
////
|
||||
|
||||
float fresnel2 = pow2(fresnel);
|
||||
float fresnel4 = pow2(fresnel2);
|
||||
|
||||
#if WATER_QUALITY >= 2
|
||||
if (isEyeInWater != 1) {
|
||||
// Noise Coloring
|
||||
float noise = texture2D(noisetex, (waterPos + wind) * 0.25).g;
|
||||
noise = noise - 0.5;
|
||||
noise *= 0.25;
|
||||
color.rgb = pow(color.rgb, vec3(1.0 + noise));
|
||||
|
||||
// Water Alpha
|
||||
float depthT = texelFetch(depthtex1, texelCoord, 0).r;
|
||||
vec3 screenPosT = vec3(screenCoord, depthT);
|
||||
#ifdef TAA
|
||||
vec3 viewPosT = ScreenToView(vec3(TAAJitter(screenPosT.xy, -0.5), screenPosT.z));
|
||||
#else
|
||||
vec3 viewPosT = ScreenToView(screenPosT);
|
||||
#endif
|
||||
float lViewPosT = length(viewPosT);
|
||||
float lViewPosDifM = lViewPos - lViewPosT;
|
||||
|
||||
#if WATER_STYLE < 3
|
||||
color.a = sqrt1(color.a);
|
||||
#else
|
||||
color.a = 0.98;
|
||||
#endif
|
||||
|
||||
#if WATER_FOG_MULT != 100
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
lViewPosDifM *= WATER_FOG_MULT_M;
|
||||
#endif
|
||||
|
||||
float waterFog = max0(1.0 - exp(lViewPosDifM * 0.075));
|
||||
color.a *= 0.25 + 0.75 * waterFog;
|
||||
|
||||
#if defined BRIGHT_CAVE_WATER && WATER_ALPHA_MULT < 200
|
||||
// For better water visibility in caves and some extra color pop outdoors
|
||||
color.rgb *= 2.5 - sqrt2(waterFog) - 0.5 * lmCoordM.y;
|
||||
#endif
|
||||
|
||||
#if WATER_ALPHA_MULT != 100
|
||||
#define WATER_ALPHA_MULT_M 100.0 / WATER_ALPHA_MULT
|
||||
color.a = pow(color.a, WATER_ALPHA_MULT_M);
|
||||
#endif
|
||||
////
|
||||
|
||||
// Water Foam
|
||||
#if WATER_FOAM_I > 0
|
||||
if (NdotU > 0.99) {
|
||||
vec3 matrixM = vec3(
|
||||
gbufferModelViewInverse[0].y,
|
||||
gbufferModelViewInverse[1].y,
|
||||
gbufferModelViewInverse[2].y
|
||||
);
|
||||
float playerPosTY = dot(matrixM, viewPosT) + gbufferModelViewInverse[3].y;
|
||||
float yPosDif = playerPosTY - playerPos.y;
|
||||
|
||||
#if WATER_STYLE < 3 && MC_VERSION >= 11300
|
||||
float dotColorPM = dot(colorPM, colorPM);
|
||||
float foamThreshold = min(pow2(dotColorPM) * 1.6, 1.2);
|
||||
#else
|
||||
float foamThreshold = pow2(texture2D(noisetex, waterPos * 4.0 + wind * 0.5).g) * 1.6;
|
||||
#endif
|
||||
float foam = pow2(clamp((foamThreshold + yPosDif) / foamThreshold, 0.0, 1.0));
|
||||
#ifndef END
|
||||
foam *= 0.4 + 0.25 * lmCoord.y;
|
||||
#else
|
||||
foam *= 0.6;
|
||||
#endif
|
||||
foam *= clamp((fract(worldPos.y) - 0.7) * 10.0, 0.0, 1.0);
|
||||
|
||||
vec4 foamColor = vec4(0.9, 0.95, 1.05, 1.0);
|
||||
|
||||
#define WATER_FOAM_IM WATER_FOAM_I * 0.01
|
||||
#if WATER_FOAM_I < 0
|
||||
foam *= WATER_FOAM_IM;
|
||||
#elif WATER_FOAM_I > 100
|
||||
foamColor *= WATER_FOAM_IM;
|
||||
#endif
|
||||
|
||||
color = mix(color, foamColor, foam);
|
||||
reflectMult = 1.0 - foam;
|
||||
}
|
||||
#endif
|
||||
////
|
||||
} else { // Underwater
|
||||
noDirectionalShading = true;
|
||||
|
||||
reflectMult = 0.5;
|
||||
|
||||
#if MC_VERSION < 11300 && WATER_STYLE >= 3
|
||||
color.a = 0.7;
|
||||
#endif
|
||||
|
||||
#if WATER_STYLE == 1
|
||||
translucentMult.rgb *= 1.0 - fresnel4;
|
||||
#else
|
||||
translucentMult.rgb *= 1.0 - 0.9 * max(0.5 * sqrt(fresnel4), fresnel4);
|
||||
#endif
|
||||
}
|
||||
#else
|
||||
shadowMult = vec3(0.0);
|
||||
#endif
|
||||
|
||||
// Final Tweaks
|
||||
reflectMult *= 0.5 + 0.5 * NdotUmax0;
|
||||
|
||||
color.a = mix(color.a, 1.0, fresnel4);
|
||||
|
||||
#if WATER_STYLE == 3 || WATER_STYLE == 2 && SUN_MOON_STYLE >= 2
|
||||
smoothnessG = 1.0;
|
||||
|
||||
vec3 lightNormal = normalize(vec3(normalMed + 0.5 * normalSmall, 1.0) * tbnMatrix);
|
||||
highlightMult = dot(lightNormal, lightVec);
|
||||
highlightMult = max0(highlightMult) / max(dot(normal, lightVec), 0.17);
|
||||
highlightMult = mix(pow2(pow2(highlightMult * 1.1)), 1.0, min1(sqrt(miplevel) * 0.45)) * 0.3;
|
||||
#else
|
||||
smoothnessG = 0.5;
|
||||
|
||||
highlightMult = min(pow2(pow2(dot(colorP.rgb, colorP.rgb) * 0.4)), 0.5) * (16.0 - 15.0 * fresnel2) * (sunVisibility > 0.5 ? 1.0 : 0.5);
|
||||
#endif
|
||||
#endif
|
||||
@ -0,0 +1,35 @@
|
||||
void ColorCodeProgram(inout vec4 color) {
|
||||
#if defined GBUFFERS_TERRAIN // Green
|
||||
color.rgb = vec3(0.0, 1.0, 0.0);
|
||||
#elif defined GBUFFERS_WATER // Dark Blue
|
||||
color.rgb = vec3(0.0, 0.0, 1.0);
|
||||
#elif defined GBUFFERS_SKYBASIC // Light Blue
|
||||
color.rgb = vec3(0.0, 1.0, 2.0);
|
||||
#elif defined GBUFFERS_WEATHER // Magenta
|
||||
color.rgb = vec3(3.0, 0.0, 3.0);
|
||||
#elif defined GBUFFERS_BLOCK // Yellow
|
||||
color.rgb = vec3(1.5, 1.5, 0.0);
|
||||
#elif defined GBUFFERS_HAND // Orange
|
||||
color.rgb = vec3(1.5, 0.7, 0.0);
|
||||
#elif defined GBUFFERS_ENTITIES // Red
|
||||
color.rgb = vec3(1.5, 0.0, 0.0);
|
||||
#elif defined GBUFFERS_BASIC // White
|
||||
color.rgb = vec3(3.0, 3.0, 3.0);
|
||||
#elif defined GBUFFERS_SPIDEREYES // Red-Blue Vertical Stripes
|
||||
color.rgb = mix(vec3(2.0, 0.0, 0.0), vec3(0.0, 0.0, 2.0), mod(gl_FragCoord.x, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_TEXTURED // Red-Blue Horizontal Stripes
|
||||
color.rgb = mix(vec3(2.0, 0.0, 0.0), vec3(0.0, 0.0, 2.0), mod(gl_FragCoord.y, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_CLOUDS // Red-Green Vertical Stripes
|
||||
color.rgb = mix(vec3(2.0, 0.0, 0.0), vec3(0.0, 2.0, 0.0), mod(gl_FragCoord.x, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_BEACONBEAM // Red-Green Horizontal Stripes
|
||||
color.rgb = mix(vec3(2.0, 0.0, 0.0), vec3(0.0, 2.0, 0.0), mod(gl_FragCoord.y, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_ARMOR_GLINT // Black-White Vertical Stripes
|
||||
color.rgb = mix(vec3(0.0, 0.0, 0.0), vec3(1.5, 1.5, 1.5), mod(gl_FragCoord.x, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_DAMAGEDBLOCK // Black-White Horizontal Stripes
|
||||
color.rgb = mix(vec3(0.0, 0.0, 0.0), vec3(1.5, 1.5, 1.5), mod(gl_FragCoord.y, 20.0) / 20.0);
|
||||
#elif defined GBUFFERS_SKYTEXTURED // Green-Blue Horizontal Stripes
|
||||
color.rgb = mix(vec3(0.0, 2.0, 0.0), vec3(0.0, 0.0, 2.0), mod(gl_FragCoord.y, 20.0) / 20.0);
|
||||
#endif
|
||||
|
||||
color.rgb *= 0.75;
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
vec2 darkOutlineOffsets[12] = vec2[12](
|
||||
vec2( 1.0,0.0),
|
||||
vec2(-1.0,1.0),
|
||||
vec2( 0.0,1.0),
|
||||
vec2( 1.0,1.0),
|
||||
vec2(-2.0,2.0),
|
||||
vec2(-1.0,2.0),
|
||||
vec2( 0.0,2.0),
|
||||
vec2( 1.0,2.0),
|
||||
vec2( 2.0,2.0),
|
||||
vec2(-2.0,1.0),
|
||||
vec2( 2.0,1.0),
|
||||
vec2( 2.0,0.0)
|
||||
);
|
||||
|
||||
void DoDarkOutline(inout vec3 color, inout float skyFade, float z0, float dither) {
|
||||
vec2 scale = vec2(1.0 / view);
|
||||
|
||||
float outline = 1.0;
|
||||
float z = GetLinearDepth(z0) * far * 2.0;
|
||||
float minZ = 1.0, sampleZA = 0.0, sampleZB = 0.0;
|
||||
|
||||
#if DARK_OUTLINE_THICKNESS == 1
|
||||
int sampleCount = 4;
|
||||
#elif DARK_OUTLINE_THICKNESS == 2
|
||||
int sampleCount = 12;
|
||||
#endif
|
||||
|
||||
for(int i = 0; i < sampleCount; i++) {
|
||||
vec2 offset = scale * darkOutlineOffsets[i];
|
||||
sampleZA = texture2D(depthtex0, texCoord + offset).r;
|
||||
sampleZB = texture2D(depthtex0, texCoord - offset).r;
|
||||
float sampleZsum = GetLinearDepth(sampleZA) + GetLinearDepth(sampleZB);
|
||||
outline *= clamp(1.0 - (z - sampleZsum * far), 0.0, 1.0);
|
||||
minZ = min(minZ, min(sampleZA, sampleZB));
|
||||
}
|
||||
|
||||
if (outline < 0.909091) {
|
||||
vec4 viewPos = gbufferProjectionInverse * (vec4(texCoord, minZ, 1.0) * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
float lViewPos = length(viewPos.xyz);
|
||||
vec3 playerPos = ViewToPlayer(viewPos.xyz);
|
||||
vec3 nViewPos = normalize(viewPos.xyz);
|
||||
float VdotU = dot(nViewPos, upVec);
|
||||
float VdotS = dot(nViewPos, sunVec);
|
||||
|
||||
vec3 newColor = vec3(0.0);
|
||||
DoFog(newColor, skyFade, lViewPos, playerPos, VdotU, VdotS, dither);
|
||||
|
||||
color = mix(color, newColor, 1.0 - outline * 1.1);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
#if HAND_SWAYING == 1
|
||||
const float handSwayMult = 0.5;
|
||||
#elif HAND_SWAYING == 2
|
||||
const float handSwayMult = 1.0;
|
||||
#elif HAND_SWAYING == 3
|
||||
const float handSwayMult = 2.0;
|
||||
#endif
|
||||
gl_Position.x += handSwayMult * (sin(frameTimeCounter * 0.86)) / 256.0;
|
||||
gl_Position.y += handSwayMult * (cos(frameTimeCounter * 1.5)) / 64.0;
|
||||
|
||||
//dvd screensaver
|
||||
//gl_Position.x -= - 0.1 + mod(frameTimeCounter * 0.3, 1.0) * sign(mod(frameTimeCounter * 0.3, 2.0) - 1.0) + float(mod(frameTimeCounter * 0.3, 2.0) < 1.0);
|
||||
//gl_Position.y += mod(frameTimeCounter * 0.61803398875, 1.0) * sign(mod(frameTimeCounter * 0.61803398875, 2.0) - 1.0) + float(mod(frameTimeCounter * 0.61803398875, 2.0) < 1.0);
|
||||
@ -0,0 +1,107 @@
|
||||
float fovmult = gbufferProjection[1][1] / 1.37373871;
|
||||
|
||||
float BaseLens(vec2 lightPos, float size, float dist, float hardness) {
|
||||
vec2 lensCoord = (texCoord + (lightPos * dist - 0.5)) * vec2(aspectRatio, 1.0);
|
||||
float lens = clamp(1.0 - length(lensCoord) / (size * fovmult), 0.0, 1.0 / hardness) * hardness;
|
||||
lens *= lens; lens *= lens;
|
||||
return lens;
|
||||
}
|
||||
|
||||
float OverlapLens(vec2 lightPos, float size, float dista, float distb) {
|
||||
return BaseLens(lightPos, size, dista, 2.0) * BaseLens(lightPos, size, distb, 2.0);
|
||||
}
|
||||
|
||||
float PointLens(vec2 lightPos, float size, float dist) {
|
||||
float lens = BaseLens(lightPos, size, dist, 1.5) + BaseLens(lightPos, size * 4.0, dist, 1.0) * 0.5;
|
||||
return lens * (0.5 + 0.5 * sunFactor);
|
||||
}
|
||||
|
||||
float RingLensTransform(float lensFlare) {
|
||||
return pow(1.0 - pow(1.0 - pow(lensFlare, 0.25), 10.0), 5.0);
|
||||
}
|
||||
float RingLens(vec2 lightPos, float size, float distA, float distB) {
|
||||
float lensFlare1 = RingLensTransform(BaseLens(lightPos, size, distA, 1.0));
|
||||
float lensFlare2 = RingLensTransform(BaseLens(lightPos, size, distB, 1.0));
|
||||
|
||||
float lensFlare = clamp(lensFlare2 - lensFlare1, 0.0, 1.0);
|
||||
lensFlare *= sqrt(lensFlare);
|
||||
|
||||
lensFlare *= 1.0 - length(texCoord - lightPos - 0.5);
|
||||
return lensFlare;
|
||||
}
|
||||
|
||||
vec2 lensFlareCheckOffsets[4] = vec2[4](
|
||||
vec2( 1.0,0.0),
|
||||
vec2(-1.0,1.0),
|
||||
vec2( 0.0,1.0),
|
||||
vec2( 1.0,1.0)
|
||||
);
|
||||
|
||||
void DoLensFlare(inout vec3 color, vec3 viewPos, float dither) {
|
||||
vec4 clipPosSun = gbufferProjection * vec4(sunVec, 1.0);
|
||||
vec3 lightPos3 = clipPosSun.xyz / clipPosSun.w * 0.5;
|
||||
vec2 lightPos = lightPos3.xy;
|
||||
vec3 screenPosSun = lightPos3 + 0.5;
|
||||
|
||||
float flareFactor = 1.0;
|
||||
vec2 cScale = 40.0 / vec2(viewWidth, viewHeight);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
vec2 cOffset = (lensFlareCheckOffsets[i] - dither) * cScale;
|
||||
vec2 checkCoord1 = screenPosSun.xy + cOffset;
|
||||
vec2 checkCoord2 = screenPosSun.xy - cOffset;
|
||||
|
||||
float zSample1 = texture2D(depthtex0, checkCoord1).r;
|
||||
float zSample2 = texture2D(depthtex0, checkCoord2).r;
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
float cloudLinearDepth1 = texture2D(colortex4, checkCoord1).r;
|
||||
float cloudLinearDepth2 = texture2D(colortex4, checkCoord2).r;
|
||||
zSample1 = min(zSample1, cloudLinearDepth1);
|
||||
zSample2 = min(zSample2, cloudLinearDepth2);
|
||||
#endif
|
||||
|
||||
if (zSample1 < 1.0)
|
||||
flareFactor -= 0.125;
|
||||
if (zSample2 < 1.0)
|
||||
flareFactor -= 0.125;
|
||||
}
|
||||
|
||||
float str = length(lightPos * vec2(aspectRatio, 1.0));
|
||||
str = pow(clamp(str * 8.0, 0.0, 1.0), 2.0) - clamp(str * 3.0 - 1.5, 0.0, 1.0);
|
||||
flareFactor *= str;
|
||||
|
||||
flareFactor *= LENSFLARE_I * (0.65 - 0.4 * rainFactor);
|
||||
|
||||
vec3 flare = (
|
||||
BaseLens(lightPos, 0.3, -0.45, 1.0) * vec3(2.2, 1.2, 0.1) * 0.07 +
|
||||
BaseLens(lightPos, 0.3, 0.10, 1.0) * vec3(2.2, 0.4, 0.1) * 0.03 +
|
||||
BaseLens(lightPos, 0.3, 0.30, 1.0) * vec3(2.2, 0.2, 0.1) * 0.04 +
|
||||
BaseLens(lightPos, 0.3, 0.50, 1.0) * vec3(2.2, 0.4, 2.5) * 0.05 +
|
||||
BaseLens(lightPos, 0.3, 0.70, 1.0) * vec3(1.8, 0.4, 2.5) * 0.06 +
|
||||
BaseLens(lightPos, 0.3, 0.90, 1.0) * vec3(0.1, 0.2, 2.5) * 0.07 +
|
||||
|
||||
OverlapLens(lightPos, 0.08, -0.28, -0.39) * vec3(2.5, 1.2, 0.1) * 0.015 +
|
||||
OverlapLens(lightPos, 0.08, -0.20, -0.31) * vec3(2.5, 0.5, 0.1) * 0.010 +
|
||||
OverlapLens(lightPos, 0.12, 0.06, 0.19) * vec3(2.5, 0.2, 0.1) * 0.020 +
|
||||
OverlapLens(lightPos, 0.12, 0.15, 0.28) * vec3(1.8, 0.1, 1.2) * 0.015 +
|
||||
OverlapLens(lightPos, 0.12, 0.24, 0.37) * vec3(1.0, 0.1, 2.5) * 0.010 +
|
||||
|
||||
PointLens(lightPos, 0.03, -0.55) * vec3(2.5, 1.6, 0.0) * 0.06 +
|
||||
PointLens(lightPos, 0.02, -0.40) * vec3(2.5, 1.0, 0.0) * 0.045 +
|
||||
PointLens(lightPos, 0.04, 0.43) * vec3(2.5, 0.6, 0.6) * 0.06 +
|
||||
PointLens(lightPos, 0.02, 0.60) * vec3(0.2, 0.6, 2.5) * 0.045 +
|
||||
PointLens(lightPos, 0.03, 0.67) * vec3(0.7, 1.1, 3.0) * 0.075 +
|
||||
|
||||
RingLens(lightPos, 0.22, 0.44, 0.46) * vec3(0.10, 0.35, 2.50) * 1.5 +
|
||||
RingLens(lightPos, 0.15, 0.98, 0.99) * vec3(0.15, 0.40, 2.55) * 2.5
|
||||
);
|
||||
|
||||
if (sunVec.z > 0.0) {
|
||||
flare = flare * 0.2 + GetLuminance(flare) * vec3(0.3, 0.4, 0.6);
|
||||
flare *= clamp01(1.0 - (SdotU + 0.1) * 5.0);
|
||||
} else {
|
||||
flare *= clamp01((SdotU + 0.1) * 5.0);
|
||||
}
|
||||
flare *= flareFactor;
|
||||
|
||||
color = mix(color, vec3(1.0), flare);
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
#if SHOW_LIGHT_LEVEL == 1
|
||||
if (heldItemId == 40000 || heldItemId2 == 40000)
|
||||
#elif SHOW_LIGHT_LEVEL == 2
|
||||
if (heldBlockLightValue > 7.4 || heldBlockLightValue2 > 7.4)
|
||||
#endif
|
||||
|
||||
if (NdotU > 0.99) {
|
||||
#ifdef OVERWORLD
|
||||
#if MC_VERSION < 11800
|
||||
float lxMin = 0.533334;
|
||||
#else
|
||||
float lxMin = 0.000001;
|
||||
#endif
|
||||
float lyMin = 0.533334;
|
||||
#else
|
||||
float lxMin = 0.8;
|
||||
float lyMin = 0.533334;
|
||||
#endif
|
||||
|
||||
bool xDanger = lmCoord.x < lxMin;
|
||||
#ifndef NETHER
|
||||
bool yDanger = lmCoord.y < lyMin;
|
||||
#else
|
||||
bool yDanger = lmCoord.x < lyMin;
|
||||
#endif
|
||||
|
||||
if (xDanger) {
|
||||
vec2 indicatePos = playerPos.xz + cameraPosition.xz;
|
||||
indicatePos = 1.0 - 2.0 * abs(fract(indicatePos) - 0.5);
|
||||
float minPos = min(indicatePos.x, indicatePos.y);
|
||||
|
||||
if (minPos > 0.5) {
|
||||
color.rgb = yDanger ? vec3(0.4, 0.05, 0.05) : vec3(0.3, 0.3, 0.05);
|
||||
|
||||
smoothnessG = 0.5;
|
||||
highlightMult = 1.0;
|
||||
smoothnessD = 0.0;
|
||||
|
||||
emission = 3.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
vec2 worldOutlineOffset[4] = vec2[4] (
|
||||
vec2(-1.0, 1.0),
|
||||
vec2( 0, 1.0),
|
||||
vec2( 1.0, 1.0),
|
||||
vec2( 1.0, 0)
|
||||
);
|
||||
|
||||
void DoWorldOutline(inout vec3 color, float linearZ0) {
|
||||
vec2 scale = vec2(1.0 / view);
|
||||
|
||||
float outlines[2] = float[2] (0.0, 0.0);
|
||||
float outlined = 1.0;
|
||||
float z = linearZ0 * far;
|
||||
float totalz = 0.0;
|
||||
float maxz = 0.0;
|
||||
float sampleza = 0.0;
|
||||
float samplezb = 0.0;
|
||||
|
||||
int sampleCount = WORLD_OUTLINE_THICKNESS * 4;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
vec2 offset = (1.0 + floor(i / 4.0)) * scale * worldOutlineOffset[int(mod(float(i), 4))];
|
||||
float depthCheckP = GetLinearDepth(texture2D(depthtex0, texCoord + offset).r) * far;
|
||||
float depthCheckN = GetLinearDepth(texture2D(depthtex0, texCoord - offset).r) * far;
|
||||
|
||||
outlined *= clamp(1.0 - ((depthCheckP + depthCheckN) - z * 2.0) * 32.0 / z, 0.0, 1.0);
|
||||
|
||||
if (i <= 4) maxz = max(maxz, max(depthCheckP, depthCheckN));
|
||||
totalz += depthCheckP + depthCheckN;
|
||||
}
|
||||
|
||||
float outlinea = 1.0 - clamp((z * 8.0 - totalz) * 64.0 / z, 0.0, 1.0) * clamp(1.0 - ((z * 8.0 - totalz) * 32.0 - 1.0) / z, 0.0, 1.0);
|
||||
float outlineb = clamp(1.0 + 8.0 * (z - maxz) / z, 0.0, 1.0);
|
||||
float outlinec = clamp(1.0 + 64.0 * (z - maxz) / z, 0.0, 1.0);
|
||||
|
||||
float outline = (0.35 * (outlinea * outlineb) + 0.65) * (0.75 * (1.0 - outlined) * outlinec + 1.0);
|
||||
outline -= 1.0;
|
||||
|
||||
outline *= WORLD_OUTLINE_I / WORLD_OUTLINE_THICKNESS;
|
||||
if (outline < 0.0) outline = -outline * 0.25;
|
||||
|
||||
color += min(color * outline * 2.5, vec3(outline));
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
/*
|
||||
const int colortex0Format = R11F_G11F_B10F; //main color
|
||||
const int colortex1Format = RGBA8; //smoothnessD & materialMask & skyLightFactor
|
||||
const int colortex2Format = RGBA16; //taa
|
||||
const int colortex3Format = RGBA8; //(cloud/water map on deferred) | translucentMult & bloom & final color // can replace colortex8
|
||||
const int colortex4Format = R8; //volumetric cloud linear depth & volumetric light factor
|
||||
const int colortex5Format = RGBA8_SNORM; //normalM & scene image for water reflections
|
||||
|
||||
const int colortex6Format = R16; //previous depth
|
||||
const int colortex7Format = RGBA16F; //(cloud/water map on gbuffers) | temporal filter
|
||||
|
||||
const int colortex8Format = RGBA8; //light source info but replaces colortex3 to work as colorimg3
|
||||
*/
|
||||
const bool colortex0Clear = true;
|
||||
const bool colortex1Clear = true;
|
||||
const bool colortex2Clear = false;
|
||||
#ifndef LIGHT_COLORING
|
||||
const bool colortex3Clear = true;
|
||||
#else
|
||||
const bool colortex3Clear = false;
|
||||
#endif
|
||||
const bool colortex4Clear = false;
|
||||
const bool colortex5Clear = false;
|
||||
|
||||
const bool colortex6Clear = false;
|
||||
const bool colortex7Clear = false;
|
||||
|
||||
const bool colortex8Clear = false;
|
||||
//
|
||||
|
||||
const int noiseTextureResolution = 128;
|
||||
|
||||
const bool shadowHardwareFiltering = true;
|
||||
const float shadowDistanceRenderMul = 1.0;
|
||||
const float entityShadowDistanceMul = 0.125; // Iris feature
|
||||
|
||||
const float drynessHalflife = 300.0;
|
||||
const float wetnessHalflife = 300.0;
|
||||
|
||||
const float ambientOcclusionLevel = 1.0;
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user