Texturierung von Voxel Popoxel ermöglicht

blight-assets/src/main/resources/MatDefs/BakedTerrain.j3md

@@ -0,0 +1,35 @@
+MaterialDef BakedTerrain {
+
+    MaterialParameters {
+        TextureArray DiffuseArray
+        FloatArray   DiffuseScales
+        Texture2D    AlphaMap
+        Texture2D    AlphaMap_1
+        Texture2D    AlphaMap_2
+        Vector3      LightDir     : 0.6 -0.8 0.4
+        Vector3      SunColor     : 0.68 0.65 0.60
+        Vector3      AmbientColor : 0.08 0.10 0.16
+        Boolean      DebugNoLight
+    }
+
+    Technique {
+        VertexShader   GLSL150 : Shaders/BakedTerrain.vert
+        FragmentShader GLSL150 : Shaders/BakedTerrain.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldMatrix
+            CameraPosition
+        }
+
+        Defines {
+            HAS_ALPHA_1    : AlphaMap_1
+            HAS_ALPHA_2    : AlphaMap_2
+            DEBUG_NO_LIGHT : DebugNoLight
+        }
+
+        RenderState {
+            FaceCull Off
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+uniform sampler2DArray m_DiffuseArray;
+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
+
+uniform vec3 m_LightDir;
+uniform vec3 m_SunColor;
+uniform vec3 m_AmbientColor;
+uniform vec3 g_CameraPosition;
+
+in vec3 vWorldPos;
+in vec3 vNormal;
+
+out vec4 outColor;
+
+void main() {
+    // World-space splatmap UV (identisch zur Painting-Logik in TerrainEditorState)
+    vec2 splatUV = vec2(
+        (vWorldPos.x + 2048.0) / 4096.0,
+        1.0 - (vWorldPos.z + 2048.0) / 4096.0
+    );
+
+    vec4 a0 = texture(m_AlphaMap, splatUV);
+    vec4 a1 = vec4(0.0);
+    vec4 a2 = vec4(0.0);
+#ifdef HAS_ALPHA_1
+    a1 = texture(m_AlphaMap_1, splatUV);
+#endif
+#ifdef HAS_ALPHA_2
+    a2 = texture(m_AlphaMap_2, splatUV);
+#endif
+
+    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);
+
+    // Basis (Slot 1)
+    vec4 col = texture(m_DiffuseArray, vec3(vWorldPos.xz / m_DiffuseScales[0], 0.0));
+
+    // 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);
+    vec3  lightDir = normalize(m_LightDir);
+    float diff     = max(dot(N, lightDir), 0.0);
+    vec3  light    = m_AmbientColor + m_SunColor * diff;
+
+    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
+}

blight-assets/src/main/resources/Shaders/BakedTerrain.vert

@@ -0,0 +1,16 @@
+uniform mat4 g_WorldViewProjectionMatrix;
+uniform mat4 g_WorldMatrix;
+
+in vec3 inPosition;
+in vec3 inNormal;
+
+out vec3 vWorldPos;
+out vec3 vNormal;
+
+void main() {
+    vec4 worldPos4 = g_WorldMatrix * vec4(inPosition, 1.0);
+    mat3 worldMat3 = mat3(g_WorldMatrix);
+    vWorldPos = worldPos4.xyz;
+    vNormal   = normalize(worldMat3 * inNormal);
+    gl_Position = g_WorldViewProjectionMatrix * vec4(inPosition, 1.0);
+}