New Terastalization effect.

Author: Waterpicker

src/main/resources/shaders/experimental/animated.fs.glsl

@@ -3,9 +3,9 @@
 in vec2 texCoord0;
 in vec4 vertexColor;
 in float vertexDistance;
-in vec3 fragNormal;
-in vec3 fragTangent;
-in vec3 fragBitangent;
+flat in vec3 fragNormal;
+flat in vec3 fragTangent;
+flat in vec3 fragBitangent;
 
 out vec4 outColor;
 
@@ -322,60 +322,83 @@ mat3 getTBN() {
 
 // ===== Tersaalization Effect =====
 
-#define TERA_LIGHT_DIRECT   vec3(0.3f, 0.9f, 0.0f)
-#define TERATYPE_TINT       vec3(0.161, 0.502, 0.937)
+#define TERATYPE_TINT         vec3(0.161, 0.502, 0.937)
 
-#define FACET_RES           8.0
-#define SHIMMER_BANDS       5.0
-#define GAMMA_CORRECTION    1.4
-#define SHIMMER_STRENGTH    0.8
-#define IRIDESCENCE_STRENGTH 0.2
+#define FACET_RES             8.0
+#define SHIMMER_BANDS         5.0
+#define GAMMA_CORRECTION      1.4
+#define SHIMMER_STRENGTH      0.8
+#define IRIDESCENCE_STRENGTH  0.2
 
 uniform bool tera;
 
 in vec3 fragViewDir;
 in vec3 worldPos;
 
-vec3 calculateTersaalizationEffect(
-    vec3 baseColor
-) {
+vec3 calculateTersaalizationEffect(vec3 baseColor, vec2 uv) {
     mat3 TBN = getTBN();
 
-    vec3 N = TBN[2];
+    vec3 T = normalize(TBN[0]);
+    vec3 B = normalize(TBN[1]);
+    vec3 N = normalize(TBN[2]);
     vec3 V = normalize(fragViewDir);
 
-    // Fresnel rim lighting
-    float fresnel = pow(1.0 - max(dot(N, V), 0.0), 5.0);
+    float NoV = clamp(dot(N, V), 0.0, 1.0);
+    float edge = 1.0 - NoV;
 
-    // Directional lighting response
-    float lightResponse = max(dot(N, TERA_LIGHT_DIRECT), 0.0);
+    float fresnel    = pow(edge, 3.5);
+    float thickness  = pow(edge, 1.6);
+    float innerGlow  = pow(edge, 1.2);
 
-    // Facet simulation via quantized normals
-    vec3 faceted = normalize(floor(N * FACET_RES + 0.5) / FACET_RES);
-    float facetResponse = pow(max(dot(faceted, V), 0.0), 6.0);
+    vec3 facetN = normalize(round(N * FACET_RES) / FACET_RES);
+    // Was pow(..., 8.0) – far too harsh
+    float facetResponse = pow(max(dot(facetN, V), 0.0), 4.0);
 
-    // Composite shimmer signal
-    float shimmer = fresnel * 0.5 + lightResponse * 0.3 + facetResponse * 0.8;
-    shimmer = pow(clamp(shimmer, 0.0, 1.0), GAMMA_CORRECTION);
+    float tView = abs(dot(T, V));
+    float bView = abs(dot(B, V));
+    float anisotropic = pow(max(tView, bView * 0.7), 2.0);
+
+    float shimmer = 0.0;
+    shimmer += fresnel       * 0.25;
+    shimmer += thickness     * 0.30;
+    shimmer += innerGlow     * 0.25;
+    shimmer += facetResponse * 0.40;
+    shimmer += anisotropic   * 0.35;
 
-    // Posterization
-    shimmer = floor(shimmer * SHIMMER_BANDS) / SHIMMER_BANDS;
+    shimmer = pow(clamp(shimmer, 0.0, 1.0), GAMMA_CORRECTION);
 
-    // Micro-noise based on 3D direction
-    float angleNoise = abs(sin(dot(N.xyz, vec3(12.9898, 78.233, 45.164)) * 43758.5453));
+    float angleNoise = abs(sin(dot(N, vec3(12.9898, 78.233, 45.164)) * 43758.5453));
     shimmer += angleNoise * 0.02;
+    shimmer = clamp(shimmer, 0.0, 1.0);
+
+    // Make the shell mask less picky
+    float shellMask = clamp(facetResponse * 0.5 + thickness * 0.5, 0.0, 1.0);
+    shellMask = smoothstep(0.08, 0.90, shellMask);
+
+    float baseLuma = dot(baseColor, vec3(0.2126, 0.7152, 0.0722));
+    float highlightPreserve = 1.0 - smoothstep(0.80, 0.98, baseLuma);
+    highlightPreserve = mix(0.50, 1.0, highlightPreserve);
 
-    // Optional iridescent variation
-    vec3 iridescent = vec3(1.0, 0.9, 0.8) + vec3(0.05, -0.02, 0.03) * sin(shimmer * 20.0);
+    shellMask *= highlightPreserve;
 
-    // Tint variation based on light response
-    vec3 directionalTint = mix(TERATYPE_TINT, vec3(1.0), lightResponse);
+    vec3 ambientTint = mix(TERATYPE_TINT, vec3(0.93, 0.98, 1.0), 0.5);
+    vec3 specTint    = mix(vec3(1.0), TERATYPE_TINT, 0.4);
 
-    // Final output
-    return baseColor
-    + directionalTint * shimmer * SHIMMER_STRENGTH
-    + iridescent * shimmer * IRIDESCENCE_STRENGTH;
+    vec3 addCrystal = ambientTint * shimmer * SHIMMER_STRENGTH;
+    addCrystal += specTint * facetResponse * (IRIDESCENCE_STRENGTH * 0.8);
+
+    addCrystal *= shellMask;
+
+    float maxBase   = max(max(baseColor.r, baseColor.g), baseColor.b);
+    float headroom  = 1.0 - maxBase;
+    float intensityScale = 0.50 + headroom * 1.00;
+
+    addCrystal *= intensityScale;
+
+    vec3 result = baseColor + addCrystal;
+    return clamp(result, 0.0, 1.0);
 }
+
 //////////////////////////////////////
 
 void main() {
@@ -388,7 +411,7 @@ void main() {
     outColor.rgb *= tint;
 
     if(tera) {
-        outColor.rgb = calculateTersaalizationEffect(outColor.rgb);
+        outColor.rgb = calculateTersaalizationEffect(outColor.rgb, texCoord0);
     } else if (useLight) {
         outColor *= vertexColor;
         // Sample Minecraft's light level from the lightmap texture

src/main/resources/shaders/experimental/animated.vs.glsl

@@ -15,9 +15,9 @@ out vec4 vertexColor;
 out vec2 texCoord0;
 out vec3 fragViewDir;
 out vec3 worldPos;
-out vec3 fragNormal;
-out vec3 fragTangent;
-out vec3 fragBitangent;
+flat out vec3 fragNormal;
+flat out vec3 fragTangent;
+flat out vec3 fragBitangent;
 
 uniform bool dynamicVertexColor;
 
@@ -54,31 +54,37 @@ float fog_distance(mat4 modelViewMat, vec3 pos, int shape) {
     }
 }
 
-vec4 getVertexColor() {
+vec4 getVertexColor(vec3 litNormal) {
     if(dynamicVertexColor) return vec4(1);
 
     vec3 lightDir0 = normalize(Light0_Direction);
     vec3 lightDir1 = normalize(Light1_Direction);
-    float light0 = max(0.0, dot(Light0_Direction, normals));
-    float light1 = max(0.0, dot(Light1_Direction, normals));
+    float light0 = max(0.0, dot(lightDir0, litNormal));
+    float light1 = max(0.0, dot(lightDir1, litNormal));
     float lightAccum = min(1.0, (light0 + light1) * MINECRAFT_LIGHT_POWER + MINECRAFT_AMBIENT_LIGHT);
     return vec4(lightAccum, lightAccum, lightAccum, 1);
 }
 
 void main() {
+    mat4 boneTransform = getBoneTransform();
+    mat4 modelTransform = modelMatrix * boneTransform;
     mat4 worldSpace = projectionMatrix * viewMatrix;
-    mat4 modelTransform = modelMatrix * getBoneTransform();
+    mat4 modelView = viewMatrix * modelTransform;
     vec4 worldPosition = modelTransform * vec4(positions, 1.0);
 
-    fragNormal    = normalize(normalMatrix * normals);
-    fragTangent   = normalize(normalMatrix * tangents.xyz);
+    mat3 boneMatrix = mat3(boneTransform);
+    vec3 skinnedNormal = normalize(boneMatrix * normals);
+    vec3 skinnedTangent = normalize(boneMatrix * tangents.xyz);
+
+    fragNormal    = normalize(normalMatrix * skinnedNormal);
+    fragTangent   = normalize(normalMatrix * skinnedTangent);
     fragTangent   = normalize(fragTangent - dot(fragTangent, fragNormal) * fragNormal);
     fragBitangent = cross(fragNormal, fragTangent) * tangents.w;
 
     texCoord0 = (texcoords * uvScale) + uvOffset;
-    gl_Position = worldSpace * worldPosition;
-    vertexDistance = fog_distance(worldSpace * modelTransform, positions, FogShape);
-    vertexColor = getVertexColor();
+    gl_Position = projectionMatrix * modelView * vec4(positions, 1.0);
+    vertexDistance = fog_distance(modelView, positions, FogShape);
+    vertexColor = getVertexColor(fragNormal);
 
     fragViewDir = normalize(-(viewMatrix * worldPosition).xyz);
     worldPos = worldPosition.xyz;