Create/Update assets for version 25w10a

assets/minecraft/shaders/post/_list.json

@@ -0,0 +1 @@
+{"directories":[],"files":["bits.fsh","blit.fsh","blit.vsh","blur.vsh","box_blur.fsh","color_convolve.fsh","entity_outline_box_blur.fsh","entity_sobel.fsh","invert.fsh","invert.vsh","rotscale.vsh","screenquad.vsh","sobel.vsh","spiderclip.fsh","transparency.fsh"]}

assets/minecraft/shaders/post/bits.fsh

@@ -0,0 +1,30 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+in vec2 oneTexel;
+
+uniform vec2 InSize;
+
+uniform float Resolution;
+uniform float MosaicSize;
+
+out vec4 fragColor;
+
+const float Saturation = 1.5;
+
+void main() {
+    vec2 mosaicInSize = InSize / MosaicSize;
+    vec2 fractPix = fract(texCoord * mosaicInSize) / mosaicInSize;
+
+    vec4 baseTexel = texture(InSampler, texCoord - fractPix);
+
+    vec3 fractTexel = baseTexel.rgb - fract(baseTexel.rgb * Resolution) / Resolution;
+    float luma = dot(fractTexel, vec3(0.3, 0.59, 0.11));
+    vec3 chroma = (fractTexel - luma) * Saturation;
+    baseTexel.rgb = luma + chroma;
+    baseTexel.a = 1.0;
+
+    fragColor = baseTexel;
+}

assets/minecraft/shaders/post/blit.fsh

@@ -0,0 +1,13 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+uniform vec4 ColorModulate;
+
+in vec2 texCoord;
+
+out vec4 fragColor;
+
+void main(){
+    fragColor = texture(InSampler, texCoord) * ColorModulate;
+}

assets/minecraft/shaders/post/blit.vsh

@@ -0,0 +1,15 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 OutSize;
+
+out vec2 texCoord;
+
+void main(){
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+
+    texCoord = Position.xy;
+}

assets/minecraft/shaders/post/blur.vsh

@@ -0,0 +1,21 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 InSize;
+uniform vec2 OutSize;
+uniform vec2 BlurDir;
+
+out vec2 texCoord;
+out vec2 sampleStep;
+
+void main() {
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+
+    vec2 oneTexel = 1.0 / InSize;
+    sampleStep = oneTexel * BlurDir;
+
+    texCoord = Position.xy;
+}

assets/minecraft/shaders/post/box_blur.fsh

@@ -0,0 +1,23 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+in vec2 sampleStep;
+
+uniform float Radius;
+
+out vec4 fragColor;
+
+// This shader relies on GL_LINEAR sampling to reduce the amount of texture samples in half.
+// Instead of sampling each pixel position with a step of 1 we sample between pixels with a step of 2.
+// In the end we sample the last pixel with a half weight, since the amount of pixels to sample is always odd (actualRadius * 2 + 1).
+void main() {
+    vec4 blurred = vec4(0.0);
+    float actualRadius = round(Radius);
+    for (float a = -actualRadius + 0.5; a <= actualRadius; a += 2.0) {
+        blurred += texture(InSampler, texCoord + sampleStep * a);
+    }
+    blurred += texture(InSampler, texCoord + sampleStep * actualRadius) / 2.0;
+    fragColor = blurred / (actualRadius + 0.5);
+}

assets/minecraft/shaders/post/color_convolve.fsh

@@ -0,0 +1,33 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+in vec2 oneTexel;
+uniform vec2 InSize;
+
+uniform vec3 RedMatrix;
+uniform vec3 GreenMatrix;
+uniform vec3 BlueMatrix;
+
+const vec3 Gray = vec3(0.3, 0.59, 0.11);
+const float Saturation = 1.8;
+
+out vec4 fragColor;
+
+void main() {
+    vec4 InTexel = texture(InSampler, texCoord);
+
+    // Color Matrix
+    float RedValue = dot(InTexel.rgb, RedMatrix);
+    float GreenValue = dot(InTexel.rgb, GreenMatrix);
+    float BlueValue = dot(InTexel.rgb, BlueMatrix);
+    vec3 OutColor = vec3(RedValue, GreenValue, BlueValue);
+
+    // Saturation
+    float Luma = dot(OutColor, Gray);
+    vec3 Chroma = OutColor - Luma;
+    OutColor = (Chroma * Saturation) + Luma;
+
+    fragColor = vec4(OutColor, 1.0);
+}

assets/minecraft/shaders/post/entity_outline_box_blur.fsh

@@ -0,0 +1,18 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+in vec2 sampleStep;
+
+out vec4 fragColor;
+
+void main() {
+    vec4 blurred = vec4(0.0);
+    float radius = 2.0;
+    for (float a = -radius + 0.5; a <= radius; a += 2.0) {
+        blurred += texture(InSampler, texCoord + sampleStep * a);
+    }
+    blurred += texture(InSampler, texCoord + sampleStep * radius) / 2.0;
+    fragColor = vec4((blurred / (radius + 0.5)).rgb, blurred.a);
+}

assets/minecraft/shaders/post/entity_sobel.fsh

@@ -0,0 +1,23 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+in vec2 oneTexel;
+
+out vec4 fragColor;
+
+void main(){
+    vec4 center = texture(InSampler, texCoord);
+    vec4 left = texture(InSampler, texCoord - vec2(oneTexel.x, 0.0));
+    vec4 right = texture(InSampler, texCoord + vec2(oneTexel.x, 0.0));
+    vec4 up = texture(InSampler, texCoord - vec2(0.0, oneTexel.y));
+    vec4 down = texture(InSampler, texCoord + vec2(0.0, oneTexel.y));
+    float leftDiff  = abs(center.a - left.a);
+    float rightDiff = abs(center.a - right.a);
+    float upDiff    = abs(center.a - up.a);
+    float downDiff  = abs(center.a - down.a);
+    float total = clamp(leftDiff + rightDiff + upDiff + downDiff, 0.0, 1.0);
+    vec3 outColor = center.rgb * center.a + left.rgb * left.a + right.rgb * right.a + up.rgb * up.a + down.rgb * down.a;
+    fragColor = vec4(outColor * 0.2, total);
+}

assets/minecraft/shaders/post/invert.fsh

@@ -0,0 +1,16 @@
+#version 150
+
+uniform sampler2D InSampler;
+
+in vec2 texCoord;
+
+uniform float InverseAmount;
+
+out vec4 fragColor;
+
+void main(){
+    vec4 diffuseColor = texture(InSampler, texCoord);
+    vec4 invertColor = 1.0 - diffuseColor;
+    vec4 outColor = mix(diffuseColor, invertColor, InverseAmount);
+    fragColor = vec4(outColor.rgb, 1.0);
+}

assets/minecraft/shaders/post/invert.vsh

@@ -0,0 +1,20 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 InSize;
+uniform vec2 OutSize;
+
+out vec2 texCoord;
+
+void main(){
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+
+    vec2 sizeRatio = OutSize / InSize;
+    texCoord = Position.xy;
+    texCoord.x = texCoord.x * sizeRatio.x;
+    texCoord.y = texCoord.y * sizeRatio.y;
+    texCoord.y = sizeRatio.y - texCoord.y;
+}

assets/minecraft/shaders/post/rotscale.vsh

@@ -0,0 +1,29 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 InSize;
+uniform vec2 OutSize;
+
+uniform vec2 InScale;
+uniform vec2 InOffset;
+uniform float InRotation;
+
+out vec2 texCoord;
+out vec2 scaledCoord;
+
+void main(){
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+
+    texCoord = Position.xy;
+
+    float Deg2Rad = 0.0174532925;
+    float InRadians = InRotation * Deg2Rad;
+    float Cosine = cos(InRadians);
+    float Sine = sin(InRadians);
+    float RotU = texCoord.x * Cosine - texCoord.y * Sine;
+    float RotV = texCoord.y * Cosine + texCoord.x * Sine;
+    scaledCoord = vec2(RotU, RotV) * InScale + InOffset;
+}

assets/minecraft/shaders/post/screenquad.vsh

@@ -0,0 +1,14 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 OutSize;
+
+out vec2 texCoord;
+
+void main() {
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+    texCoord = Position.xy;
+}

assets/minecraft/shaders/post/sobel.vsh

@@ -0,0 +1,19 @@
+#version 150
+
+in vec4 Position;
+
+uniform mat4 ProjMat;
+uniform vec2 InSize;
+uniform vec2 OutSize;
+
+out vec2 texCoord;
+out vec2 oneTexel;
+
+void main(){
+    vec4 outPos = ProjMat * vec4(Position.xy * OutSize, 0.0, 1.0);
+    gl_Position = vec4(outPos.xy, 0.2, 1.0);
+
+    oneTexel = 1.0 / InSize;
+
+    texCoord = Position.xy;
+}

assets/minecraft/shaders/post/spiderclip.fsh

@@ -0,0 +1,33 @@
+#version 150
+
+uniform sampler2D InSampler;
+uniform sampler2D BlurSampler;
+
+in vec2 texCoord;
+in vec2 scaledCoord;
+
+uniform vec2 InSize;
+uniform vec4 Scissor;
+uniform vec4 Vignette;
+
+out vec4 fragColor;
+
+void main() {
+    vec4 ScaledTexel = texture(InSampler, scaledCoord);
+    vec4 BlurTexel = texture(BlurSampler, texCoord);
+    vec4 OutTexel = ScaledTexel;
+
+    // -- Alpha Clipping --
+    if (scaledCoord.x < Scissor.x) OutTexel = BlurTexel;
+    if (scaledCoord.y < Scissor.y) OutTexel = BlurTexel;
+    if (scaledCoord.x > Scissor.z) OutTexel = BlurTexel;
+    if (scaledCoord.y > Scissor.w) OutTexel = BlurTexel;
+
+    clamp(scaledCoord, 0.0, 1.0);
+
+    if (scaledCoord.x < Vignette.x) OutTexel = mix(BlurTexel, OutTexel, (Scissor.x - scaledCoord.x) / (Scissor.x - Vignette.x));
+    if (scaledCoord.y < Vignette.y) OutTexel = mix(BlurTexel, OutTexel, (Scissor.y - scaledCoord.y) / (Scissor.y - Vignette.y));
+    if (scaledCoord.x > Vignette.z) OutTexel = mix(BlurTexel, OutTexel, (Scissor.z - scaledCoord.x) / (Scissor.z - Vignette.z));
+    if (scaledCoord.y > Vignette.w) OutTexel = mix(BlurTexel, OutTexel, (Scissor.w - scaledCoord.y) / (Scissor.w - Vignette.w));
+    fragColor = vec4(OutTexel.rgb, 1.0);
+}

assets/minecraft/shaders/post/transparency.fsh

@@ -0,0 +1,70 @@
+#version 150
+
+uniform sampler2D MainSampler;
+uniform sampler2D MainDepthSampler;
+uniform sampler2D TranslucentSampler;
+uniform sampler2D TranslucentDepthSampler;
+uniform sampler2D ItemEntitySampler;
+uniform sampler2D ItemEntityDepthSampler;
+uniform sampler2D ParticlesSampler;
+uniform sampler2D ParticlesDepthSampler;
+uniform sampler2D WeatherSampler;
+uniform sampler2D WeatherDepthSampler;
+uniform sampler2D CloudsSampler;
+uniform sampler2D CloudsDepthSampler;
+
+in vec2 texCoord;
+
+#define NUM_LAYERS 6
+
+vec4 color_layers[NUM_LAYERS];
+float depth_layers[NUM_LAYERS];
+int active_layers = 0;
+
+out vec4 fragColor;
+
+void try_insert( vec4 color, float depth ) {
+    if ( color.a == 0.0 ) {
+        return;
+    }
+
+    color_layers[active_layers] = color;
+    depth_layers[active_layers] = depth;
+
+    int jj = active_layers++;
+    int ii = jj - 1;
+    while ( jj > 0 && depth_layers[jj] > depth_layers[ii] ) {
+        float depthTemp = depth_layers[ii];
+        depth_layers[ii] = depth_layers[jj];
+        depth_layers[jj] = depthTemp;
+
+        vec4 colorTemp = color_layers[ii];
+        color_layers[ii] = color_layers[jj];
+        color_layers[jj] = colorTemp;
+
+        jj = ii--;
+    }
+}
+
+vec3 blend( vec3 dst, vec4 src ) {
+    return ( dst * ( 1.0 - src.a ) ) + src.rgb;
+}
+
+void main() {
+    color_layers[0] = vec4( texture( MainSampler, texCoord ).rgb, 1.0 );
+    depth_layers[0] = texture( MainDepthSampler, texCoord ).r;
+    active_layers = 1;
+
+    try_insert( texture( TranslucentSampler, texCoord ), texture( TranslucentDepthSampler, texCoord ).r );
+    try_insert( texture( ItemEntitySampler, texCoord ), texture( ItemEntityDepthSampler, texCoord ).r );
+    try_insert( texture( ParticlesSampler, texCoord ), texture( ParticlesDepthSampler, texCoord ).r );
+    try_insert( texture( WeatherSampler, texCoord ), texture( WeatherDepthSampler, texCoord ).r );
+    try_insert( texture( CloudsSampler, texCoord ), texture( CloudsDepthSampler, texCoord ).r );
+
+    vec3 texelAccum = color_layers[0].rgb;
+    for ( int ii = 1; ii < active_layers; ++ii ) {
+        texelAccum = blend( texelAccum, color_layers[ii] );
+    }
+
+    fragColor = vec4( texelAccum.rgb, 1.0 );
+}