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

#ifdef HAS_STEEP
uniform int m_SteepIndex;
#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;

#ifdef HAS_STEEP
// Triplanare Textur-Abfrage aus einem Sampler2DArray-Layer
vec4 triplanarArray(vec2 uvX, vec2 uvY, vec2 uvZ, vec3 bw, int idx) {
    return texture(m_DiffuseArray, vec3(uvX, float(idx))) * bw.x
         + texture(m_DiffuseArray, vec3(uvY, float(idx))) * bw.y
         + texture(m_DiffuseArray, vec3(uvZ, float(idx))) * bw.z;
}
#endif

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]);
        }
    }

#ifdef HAS_STEEP
    // Klippen-Textur: Triplanar auf steilen Flächen (identisch zu Voxel.frag)
    vec3  bw         = pow(abs(vNormal), vec3(4.0));
    bw /= (bw.x + bw.y + bw.z + 0.001);
    float steepScale = m_DiffuseScales[m_SteepIndex];
    vec2  uvX        = vWorldPos.yz / steepScale;
    vec2  uvZ        = vWorldPos.xy / steepScale;
    float flatBlend  = smoothstep(0.70, 0.90, vNormal.y);
    float steepBlend = 1.0 - flatBlend;
    vec4  steepCol   = triplanarArray(uvX, vWorldPos.xz / steepScale, uvZ, bw, m_SteepIndex);
    col = col * flatBlend + steepCol * steepBlend;
#endif

    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
}