134 lines
3.8 KiB
GLSL
134 lines
3.8 KiB
GLSL
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
|
|
}
|