Weiter gearbeitet

blight-assets/src/main/resources/Shaders/TerrainArray.frag

@@ -0,0 +1,133 @@
+uniform sampler2DArray m_DiffuseArray;
+#ifdef DEBUG_DIRECT_TEX
+uniform sampler2D m_DebugDirectTex;
+#endif
+uniform float          m_DiffuseScales[12];
+uniform sampler2D      m_AlphaMap;
+
+#ifdef HAS_ALPHA_1
+uniform sampler2D m_AlphaMap_1;
+#endif
+#ifdef HAS_ALPHA_2
+uniform sampler2D m_AlphaMap_2;
+#endif
+
+#ifdef HAS_NORMAL_ARRAY
+uniform sampler2DArray m_NormalArray;
+#endif
+
+#ifdef HAS_LIGHTDIR
+uniform vec3 m_LightDir;
+#endif
+
+#ifdef HAS_SCENE_LIGHT
+uniform vec3 m_SunColor;
+uniform vec3 m_AmbientColor;
+#endif
+
+in vec2 vSplatUV;
+in vec3 vWorldPos;
+in vec3 vNormal;
+in vec4 vTangent;
+
+out vec4 outColor;
+
+void main() {
+    vec4 a0 = texture(m_AlphaMap, vSplatUV);
+    vec4 a1 = vec4(0.0);
+    vec4 a2 = vec4(0.0);
+#ifdef HAS_ALPHA_1
+    a1 = texture(m_AlphaMap_1, vSplatUV);
+#endif
+#ifdef HAS_ALPHA_2
+    a2 = texture(m_AlphaMap_2, vSplatUV);
+#endif
+
+    // Slot-Mapping:
+    //   Array[0]  = Editor-Slot 1 (Basis, immer sichtbar — a0.r ist hardcoded 1.0)
+    //   Array[1]  = Editor-Slot 2,  alpha = a0.g
+    //   Array[2]  = Editor-Slot 3,  alpha = a0.b
+    //   Array[3]  = Editor-Slot 4,  alpha = a0.a
+    //   Array[4]  = Editor-Slot 5,  alpha = a1.r
+    //   Array[5]  = Editor-Slot 6,  alpha = a1.g
+    //   Array[6]  = Editor-Slot 7,  alpha = a1.b
+    //   Array[7]  = Editor-Slot 8,  alpha = a1.a
+    //   Array[8]  = Editor-Slot 9,  alpha = a2.r
+    //   Array[9]  = Editor-Slot 10, alpha = a2.g
+    //   Array[10] = Editor-Slot 11, alpha = a2.b
+    //   Array[11] = Editor-Slot 12, alpha = a2.a
+    //
+    // Blending: sequential mix — jeder Overlay ersetzt den Basis-Layer schrittweise.
+    // a0.r (Slot 1) wird vom Painting-Tool immer auf 1.0 gesetzt und dient nur als
+    // "Basis ist belegt"-Marker; er ist kein echter Alpha-Wert.
+
+    float overlays[11] = float[](a0.g, a0.b, a0.a,
+                                  a1.r, a1.g, a1.b, a1.a,
+                                  a2.r, a2.g, a2.b, a2.a);
+
+#ifdef DEBUG_DIRECT_TEX
+    vec4 directCol = texture(m_DebugDirectTex, vWorldPos.xz / m_DiffuseScales[0]);
+    outColor = vec4(directCol.rgb, directCol.a);
+    return;
+#endif
+
+    // Basis (Slot 1)
+    vec4 col = texture(m_DiffuseArray, vec3(vWorldPos.xz / m_DiffuseScales[0], 0.0));
+
+#ifdef DEBUG_SLOT0_ONLY
+    // Debug: nur Slot 0 anzeigen, keine Alpha-Blending-Schleife
+    outColor = vec4(col.rgb, col.a);
+    return;
+#endif
+
+    // Overlays (Slots 2-12) sequentiell darüber mischen
+    for (int i = 0; i < 11; i++) {
+        if (overlays[i] > 0.001) {
+            vec2 uv = vWorldPos.xz / m_DiffuseScales[i + 1];
+            col = mix(col, texture(m_DiffuseArray, vec3(uv, float(i + 1))), overlays[i]);
+        }
+    }
+
+    vec3 N = normalize(vNormal);
+
+#ifdef HAS_NORMAL_ARRAY
+    vec3 T   = normalize(vTangent.xyz);
+    vec3 B   = cross(N, T) * vTangent.w;
+    mat3 TBN = mat3(T, B, N);
+
+    // Normal-Map Basis (Slot 1)
+    vec2 uv0 = vWorldPos.xz / m_DiffuseScales[0];
+    vec3 nm0 = texture(m_NormalArray, vec3(uv0, 0.0)).rgb * 2.0 - 1.0;
+    vec3 pertN = TBN * nm0;
+
+    // Normal-Maps Overlays (Slots 2-12) sequentiell mischen
+    for (int i = 0; i < 11; i++) {
+        if (overlays[i] > 0.001) {
+            vec2 uv = vWorldPos.xz / m_DiffuseScales[i + 1];
+            vec3 nm = texture(m_NormalArray, vec3(uv, float(i + 1))).rgb * 2.0 - 1.0;
+            pertN = mix(pertN, TBN * nm, overlays[i]);
+        }
+    }
+    N = normalize(pertN);
+#endif
+
+#ifdef HAS_LIGHTDIR
+    vec3 lightDir = normalize(m_LightDir);
+#else
+    vec3 lightDir = normalize(vec3(0.6, 1.0, 0.4));
+#endif
+    float diff = max(dot(N, lightDir), 0.0);
+
+#ifdef HAS_SCENE_LIGHT
+    vec3 light = m_AmbientColor + m_SunColor * diff;
+#else
+    vec3 light = vec3(diff * 0.65 + 0.35);
+#endif
+
+    const float BRIGHTNESS = 0.80;
+#ifdef DEBUG_NO_LIGHT
+    outColor = vec4(col.rgb * BRIGHTNESS, col.a);
+#else
+    outColor = vec4(col.rgb * light * BRIGHTNESS, col.a);
+#endif
+}