Weiter am Wettersystem gearbeitet, ordentliche Wolken und Regen etc ergänzt

blight-assets/src/main/resources/Common/MatDefs/Light/PBRLighting.j3md

@@ -0,0 +1,336 @@
+MaterialDef PBR Lighting {
+
+    MaterialParameters {
+        Int BoundDrawBuffer
+
+        // Alpha threshold for fragment discarding
+        Float AlphaDiscardThreshold (AlphaTestFallOff)
+
+        //metallicity of the material
+        Float Metallic : 1.0
+        //Roughness of the material
+        Float Roughness : 1.0        
+        // Base material color
+        Color BaseColor : 1.0 1.0 1.0 1.0
+        // The emissive color of the object
+        Color Emissive        
+        // the emissive power
+        Float EmissivePower : 3.0        
+        // the emissive intensity
+        Float EmissiveIntensity : 2.0
+
+        // BaseColor map
+        Texture2D BaseColorMap
+
+        // Metallic map
+        Texture2D MetallicMap -LINEAR
+        
+        // Roughness Map
+        Texture2D RoughnessMap -LINEAR
+
+        //Metallic and Roughness are packed respectively in the b and g channel of a single map
+        // r: AO (if AoPackedInMRMap is true)
+        // g: Roughness
+        // b: Metallic
+        Texture2D MetallicRoughnessMap -LINEAR
+        
+        // Texture of the emissive parts of the material
+        Texture2D EmissiveMap
+
+        // Normal map
+        Texture2D NormalMap -LINEAR
+        // The scalar parameter applied to each normal vector of the normal map
+        Float NormalScale
+
+        //The type of normal map: -1.0 (DirectX), 1.0 (OpenGl)
+        Float NormalType : -1.0
+
+        // For Spec gloss pipeline
+        Boolean UseSpecGloss
+        Texture2D SpecularMap
+        Texture2D GlossinessMap
+        Texture2D SpecularGlossinessMap
+        Color Specular : 1.0 1.0 1.0 1.0
+        Float Glossiness : 1.0
+
+        // Parallax/height map
+        Texture2D ParallaxMap -LINEAR
+
+        // Specular-AA
+        Boolean UseSpecularAA : true
+        // screen space variance,Use the slider to set the strength of the geometric specular anti-aliasing effect between 0 and 1. Higher values produce a blurrier result with less aliasing.
+        Float SpecularAASigma
+        // clamping threshold,Use the slider to set a maximum value for the offset that HDRP subtracts from the smoothness value to reduce artifacts.
+        Float SpecularAAKappa
+
+        //Set to true if parallax map is stored in the alpha channel of the normal map
+        Boolean PackedNormalParallax   
+
+        //Sets the relief height for parallax mapping
+        Float ParallaxHeight : 0.05       
+
+        //Set to true to activate Steep Parallax mapping
+        Boolean SteepParallax
+
+        //Horizon fade
+        Boolean HorizonFade
+
+        // Set to Use Lightmap
+        Texture2D LightMap
+
+        // A scalar multiplier controlling the amount of occlusion applied.
+        // A value of `0.0` means no occlusion. A value of `1.0` means full occlusion.
+        Float AoStrength
+
+        // Set to use TexCoord2 for the lightmap sampling
+        Boolean SeparateTexCoord
+        // the light map is a grayscale ao map, only the r channel will be read.
+        Boolean LightMapAsAOMap
+        Boolean AoPackedInMRMap
+        //shadows
+        Int FilterMode
+        Boolean HardwareShadows
+
+        Texture2D ShadowMap0
+        Texture2D ShadowMap1
+        Texture2D ShadowMap2
+        Texture2D ShadowMap3
+        //pointLights
+        Texture2D ShadowMap4
+        Texture2D ShadowMap5
+        
+        Float ShadowIntensity
+        Vector4 Splits
+        Vector2 FadeInfo
+
+        Matrix4 LightViewProjectionMatrix0
+        Matrix4 LightViewProjectionMatrix1
+        Matrix4 LightViewProjectionMatrix2
+        Matrix4 LightViewProjectionMatrix3
+        //pointLight
+        Matrix4 LightViewProjectionMatrix4
+        Matrix4 LightViewProjectionMatrix5   
+        Vector3 LightPos
+        Vector3 LightDir
+
+        Float PCFEdge
+        Float ShadowMapSize
+
+        // For hardware skinning
+        Int NumberOfBones
+        Matrix4Array BoneMatrices
+
+        // For Morph animation
+        FloatArray MorphWeights
+        Int NumberOfMorphTargets
+        Int NumberOfTargetsBuffers
+                
+        // For instancing
+        Boolean UseInstancing
+
+        // For Vertex Color
+        Boolean UseVertexColor
+
+        Boolean BackfaceShadows : false
+
+        Boolean UseFog
+        Color FogColor
+        Vector2 LinearFog
+        Float ExpFog
+        Float ExpSqFog
+
+        Texture2D SunLightExposureMap
+        Boolean UseVertexColorsAsSunIntensity
+        Float StaticSunIntensity
+        Boolean BrightenIndoorShadows  //should be set true when shadows are enabled, in order to prevent areas with low SunExposure from being way too dark when shadows are cast
+
+         // debug the final value of the selected layer as a color output            
+        Int DebugValuesMode
+            // Layers:
+            //   0 - albedo (unshaded)
+            //   1 - normals
+            //   2 - roughness
+            //   3 - metallic
+            //   4 - ao
+            //   5 - emissive
+            //   6 - exposure
+            //   7 - alpha
+            //   8 - geometryNormals
+    }
+
+    Technique {
+        LightMode SinglePassAndImageBased
+        
+        VertexShader GLSL300 GLSL150 GLSL110:   Common/MatDefs/Light/PBRLighting.vert
+        FragmentShader GLSL300 GLSL150 GLSL110: Common/MatDefs/Light/PBRLighting.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            CameraPosition
+            WorldMatrix
+            WorldNormalMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {  
+            BOUND_DRAW_BUFFER: BoundDrawBuffer       
+            BASECOLORMAP : BaseColorMap            
+            NORMALMAP : NormalMap
+            NORMALSCALE : NormalScale
+            METALLICMAP : MetallicMap
+            ROUGHNESSMAP : RoughnessMap
+            EMISSIVEMAP : EmissiveMap
+            EMISSIVE : Emissive
+            SPECGLOSSPIPELINE : UseSpecGloss
+            PARALLAXMAP : ParallaxMap
+            NORMALMAP_PARALLAX : PackedNormalParallax
+            STEEP_PARALLAX : SteepParallax
+            LIGHTMAP : LightMap
+            SEPARATE_TEXCOORD : SeparateTexCoord
+            DISCARD_ALPHA : AlphaDiscardThreshold                        
+            NUM_BONES : NumberOfBones                        
+            INSTANCING : UseInstancing
+            USE_PACKED_MR: MetallicRoughnessMap
+            USE_PACKED_SG: SpecularGlossinessMap
+            SPECULARMAP : SpecularMap
+            SPECULAR_AA : UseSpecularAA
+            SPECULAR_AA_SCREEN_SPACE_VARIANCE : SpecularAASigma
+            SPECULAR_AA_THRESHOLD : SpecularAAKappa
+            GLOSSINESSMAP : GlossinessMap
+            NORMAL_TYPE: NormalType
+            VERTEX_COLOR : UseVertexColor
+            AO_MAP: LightMapAsAOMap
+            AO_PACKED_IN_MR_MAP : AoPackedInMRMap
+            AO_STRENGTH : AoStrength
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+            HORIZON_FADE: HorizonFade
+            EXPOSUREMAP : SunLightExposureMap
+            USE_VERTEX_COLORS_AS_SUN_INTENSITY : UseVertexColorsAsSunIntensity
+            STATIC_SUN_INTENSITY : StaticSunIntensity
+            BRIGHTEN_INDOOR_SHADOWS : BrightenIndoorShadows
+            DEBUG_VALUES_MODE : DebugValuesMode        
+            USE_FOG : UseFog
+            FOG_LINEAR : LinearFog
+            FOG_EXP : ExpFog
+            FOG_EXPSQ : ExpSqFog
+        }
+    }
+
+
+    Technique PreShadow {
+
+        VertexShader   GLSL300 GLSL150 GLSL100:   Common/MatDefs/Shadow/PreShadow.vert
+        FragmentShader GLSL300 GLSL150 GLSL100: Common/MatDefs/Shadow/PreShadowPBR.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldViewMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            DISCARD_ALPHA : AlphaDiscardThreshold
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+        ForcedRenderState {
+            FaceCull Off
+            DepthTest On
+            DepthWrite On
+            PolyOffset 5 3
+            ColorWrite Off
+        }
+
+    }
+
+
+    Technique PostShadow {
+        VertexShader   GLSL310 GLSL300 GLSL150 GLSL100:   Common/MatDefs/Shadow/PostShadow.vert
+        FragmentShader GLSL310 GLSL300 GLSL150 GLSL100: Common/MatDefs/Shadow/PostShadowPBR.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            HARDWARE_SHADOWS : HardwareShadows
+            FILTER_MODE : FilterMode
+            PCFEDGE : PCFEdge
+            DISCARD_ALPHA : AlphaDiscardThreshold           
+            SHADOWMAP_SIZE : ShadowMapSize
+            FADE : FadeInfo
+            PSSM : Splits
+            POINTLIGHT : LightViewProjectionMatrix5
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            BACKFACE_SHADOWS: BackfaceShadows
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+        ForcedRenderState {
+            Blend Modulate
+            DepthWrite Off                 
+            PolyOffset -0.1 0
+        }
+    }
+
+    Technique PreNormalPass {
+
+        VertexShader   GLSL300 GLSL150 GLSL100 :   Common/MatDefs/SSAO/normal.vert
+        FragmentShader GLSL300 GLSL150 GLSL100 : Common/MatDefs/SSAO/normal.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldViewMatrix
+            NormalMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            BASECOLORMAP_ALPHA : BaseColorMap            
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+    }
+
+    Technique Glow {
+
+        VertexShader   GLSL300 GLSL150 GLSL100:   Common/MatDefs/Misc/Unshaded.vert
+        FragmentShader GLSL300 GLSL150 GLSL100: Common/MatDefs/Light/PBRGlow.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            HAS_EMISSIVEMAP : EmissiveMap
+            HAS_EMISSIVECOLOR : Emissive
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            NEED_TEXCOORD1
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+    }
+
+}

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

@@ -0,0 +1,23 @@
+MaterialDef CloudDome {
+
+    MaterialParameters {
+        Vector2 CloudOffset  : 0.0 0.0
+        Float   CloudCover   : 0.0
+        Color   CloudColor   : 1.0 1.0 1.0 1.0
+    }
+
+    Technique {
+        VertexShader   GLSL150 : Shaders/skies/clouds/CloudDome.vert
+        FragmentShader GLSL150 : Shaders/skies/clouds/CloudDome.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+        }
+
+        RenderState {
+            Blend Alpha
+            DepthWrite Off
+            FaceCull Front
+        }
+    }
+}

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

@@ -5,6 +5,7 @@ MaterialDef Fern {
         Float     WindStrength     : 0.15
         Float     WindSpeed        : 0.6
         Vector2   WindDir          : 0.0 1.0
+        Float     Wetness          : 0.0
         Texture2D DiffuseMap
         Boolean   HasDiffuseMap    : false
         Texture2D NormalMap -LINEAR

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

@@ -4,10 +4,12 @@ MaterialDef Grass {
         Color Color (Color) : 1.0 1.0 1.0 1.0
         Texture2D ColorMap
         Texture2D NormalMap
-        Float WindSpeed    : 0.5
-        Float WindStrength : 0.12
+        Float     WindSpeed    : 0.5
+        Float     WindStrength : 0.12
+        Vector2   WindDir      : 0.0 1.0
         Vector3 SunDir     : 0.55 0.80 0.35
         Color   SunColor   : 1.0 1.0 0.95 1.0
+        Float   Wetness    : 0.0
     }
 
     Technique {

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

@@ -7,6 +7,7 @@ MaterialDef GrassSeed {
         Vector2   WindDir      : 0.0 1.0
         Vector3   SunDir       : 0.35 0.8 0.45
         Color     SunColor     : 0.95 0.90 0.75 1.0
+        Float     Wetness      : 0.0
     }
 
     Technique {

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

@@ -6,6 +6,7 @@ MaterialDef GrassVertex {
         Vector2 WindDir      : 0.0 1.0
         Vector3 SunDir       : 0.35 0.8 0.45
         Color   SunColor     : 0.95 0.90 0.75 1.0
+        Float   Wetness      : 0.0
     }
 
     Technique {

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

@@ -8,6 +8,7 @@ MaterialDef TerrainArray {
         Vector3      LightDir      : 0.6 -0.8 0.4
         Vector3      SunColor      : 0.68 0.65 0.60
         Vector3      AmbientColor  : 0.08 0.10 0.16
+        Float        Wetness       : 0.0
         Boolean      DebugNoLight
         Boolean      DebugSlot0Only
         Texture2D    DebugDirectTex
@@ -24,6 +25,7 @@ MaterialDef TerrainArray {
             WorldViewProjectionMatrix
             WorldMatrix
             ViewProjectionMatrix
+            CameraPosition
         }
 
         Defines {

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

@@ -5,6 +5,7 @@ MaterialDef TreeLeaf {
         Float     WindStrength     : 0.30
         Float     WindSpeed        : 0.7
         Vector2   WindDir          : 0.0 1.0
+        Float     Wetness          : 0.0
         Texture2D LeafMap
         Boolean   HasLeafMap       : false
 

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

@@ -5,6 +5,7 @@ uniform sampler2D m_DiffuseMap;
 uniform bool      m_HasDiffuseMap;
 uniform sampler2D m_NormalMap;
 uniform bool      m_HasNormalMap;
+uniform float     m_Wetness;
 
 in vec2  texCoord;
 in vec3  vNormal;
@@ -38,5 +39,7 @@ void main() {
     diff = max(diff, max(0.0, dot(-N, sun)) * 0.5);
     float lit   = 0.45 + diff * 0.55;
 
-    gl_FragColor = vec4(baseColor * lit, 1.0);
+    baseColor *= (1.0 - 0.18 * m_Wetness);
+    float shine = pow(diff, 12.0) * m_Wetness * 0.25;
+    gl_FragColor = vec4(baseColor * lit + vec3(shine), 1.0);
 }

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

@@ -1,7 +1,8 @@
-uniform vec4 m_Color;
-uniform vec3 m_SunDir;
-uniform vec4 m_SunColor;
-uniform vec4 g_AmbientLightColor;
+uniform vec4  m_Color;
+uniform vec3  m_SunDir;
+uniform vec4  m_SunColor;
+uniform vec4  g_AmbientLightColor;
+uniform float m_Wetness;
 
 #ifdef HAS_COLORMAP
 uniform sampler2D m_ColorMap;
@@ -35,7 +36,8 @@ void main() {
     // Beleuchtung: Sonne (two-sided via abs für Grashalme) + Ambient
     float diffuse = abs(dot(n, normalize(m_SunDir)));
     vec3 lit = g_AmbientLightColor.rgb + m_SunColor.rgb * diffuse;
+    color.rgb *= (1.0 - 0.18 * m_Wetness);
     color.rgb *= lit;
-
-    outFragColor = color;
+    float shine = pow(diffuse, 12.0) * m_Wetness * 0.25;
+    outFragColor = vec4(color.rgb + vec3(shine), color.a);
 }

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

@@ -4,6 +4,7 @@ uniform float g_Time;
 
 uniform float m_WindSpeed;
 uniform float m_WindStrength;
+uniform vec2  m_WindDir;
 
 in vec3 inPosition;
 in vec2 inTexCoord;
@@ -26,17 +27,20 @@ void main() {
         vec2 worldXZ = (g_WorldMatrix * pos).xz;
         float t = g_Time * m_WindSpeed;
 
+        vec2 windN = (dot(m_WindDir, m_WindDir) > 0.001) ? normalize(m_WindDir) : vec2(0.0, 1.0);
+        float wavePhase = dot(worldXZ, windN);
+
         // Zwei überlagerte Sinuswellen für organische Bewegung
-        float sway = sin(t * 2.1 + worldXZ.x * 0.08 + worldXZ.y * 0.06) * 0.6
-                   + sin(t * 1.4 - worldXZ.x * 0.05 + worldXZ.y * 0.09) * 0.4;
+        float sway = sin(t * 2.1 + wavePhase * 0.08) * 0.6
+                   + sin(t * 1.4 + wavePhase * 0.06) * 0.4;
 
         // Mindest-Stärke damit bei wenig Wind noch Bewegung sichtbar ist
         float effectiveStrength = max(m_WindStrength, 0.05);
 
         // Quadratische Gewichtung: Spitze bewegt sich mehr als Basis
         float bend = sway * effectiveStrength * inTexCoord.y * inTexCoord.y;
-        pos.x += bend;
-        pos.z += bend * 0.3;
+        pos.x += windN.x * bend;
+        pos.z += windN.y * bend;
         // Y-Kompression: Halm neigt sich statt zu strecken → verhindert visuelles Breiterwerden
         pos.y -= bend * bend * 0.5;
     }

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

@@ -2,6 +2,7 @@ uniform sampler2D m_ColorMap;
 uniform vec4      g_AmbientLightColor;
 uniform vec3      m_SunDir;
 uniform vec4      m_SunColor;
+uniform float     m_Wetness;
 
 in vec2 varUV;
 
@@ -14,6 +15,7 @@ void main() {
     // Wrapped diffuse – kein Normalvektor nötig für Billboard-Quads
     float light = 0.5 + 0.5 * max(dot(m_SunDir, vec3(0.0, 1.0, 0.0)), 0.0);
     vec3 ambient = g_AmbientLightColor.rgb * c.rgb;
-    vec3 diffuse = m_SunColor.rgb * c.rgb * light;
-    outFragColor = vec4(min(ambient + diffuse, c.rgb * 1.5), c.a);
+    vec3 diffuse = m_SunColor.rgb * c.rgb * (1.0 - 0.18 * m_Wetness) * light;
+    float shine  = pow(light, 12.0) * m_Wetness * 0.25;
+    outFragColor = vec4(min(ambient + diffuse, c.rgb * 1.5) + vec3(shine), c.a);
 }

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

@@ -1,7 +1,8 @@
-uniform vec4 g_AmbientLightColor;
+uniform vec4  g_AmbientLightColor;
 
-uniform vec3 m_SunDir;    // Richtung von der Fläche zur Sonne (world-space, normiert)
-uniform vec4 m_SunColor;  // Sonnenfarbe RGB
+uniform vec3  m_SunDir;    // Richtung von der Fläche zur Sonne (world-space, normiert)
+uniform vec4  m_SunColor;  // Sonnenfarbe RGB
+uniform float m_Wetness;
 
 in vec4 varColor;
 in vec3 varNormal;
@@ -23,12 +24,13 @@ void main() {
 
     float light = nDotL + sss;
 
-    vec3 ambient = g_AmbientLightColor.rgb * varColor.rgb;
-    vec3 diffuse = m_SunColor.rgb * varColor.rgb * light;
+    vec3 col = varColor.rgb * (1.0 - 0.18 * m_Wetness);
+    vec3 ambient = g_AmbientLightColor.rgb * col;
+    vec3 diffuse = m_SunColor.rgb * col * light;
 
     // Farbe nicht über die Vertex-Color-Helligkeit hinaus aufhellen
     vec3 result = ambient + diffuse;
-    result = min(result, varColor.rgb * 1.5);
-
-    outFragColor = vec4(result, 1.0);
+    result = min(result, col * 1.5);
+    float shine = pow(max(nDotL, 0.0), 12.0) * m_Wetness * 0.25;
+    outFragColor = vec4(result + vec3(shine), 1.0);
 }

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

@@ -16,9 +16,11 @@ uniform sampler2D m_AlphaMap_2;
 uniform sampler2DArray m_NormalArray;
 #endif
 
-uniform vec3 m_LightDir;
-uniform vec3 m_SunColor;
-uniform vec3 m_AmbientColor;
+uniform vec3  m_LightDir;
+uniform vec3  m_SunColor;
+uniform vec3  m_AmbientColor;
+uniform float m_Wetness;
+uniform vec3  g_CameraPosition;
 
 in vec2 vSplatUV;
 in vec3 vWorldPos;
@@ -106,14 +108,20 @@ void main() {
     N = normalize(pertN);
 #endif
 
-    vec3 lightDir = normalize(m_LightDir);
-    float diff = max(dot(N, lightDir), 0.0);
-    vec3 light = m_AmbientColor + m_SunColor * diff;
+    vec3  lightDir = normalize(m_LightDir);
+    float diff     = max(dot(N, lightDir), 0.0);
+    vec3  light    = m_AmbientColor + m_SunColor * diff;
+
+    // Nass-Effekt: Oberfläche abdunkeln + Blinn-Phong Specular Schimmer
+    col.rgb *= (1.0 - 0.20 * m_Wetness);
+    vec3  viewDir = normalize(g_CameraPosition - vWorldPos);
+    vec3  H       = normalize(lightDir + viewDir);
+    float spec    = pow(max(dot(N, H), 0.0), 80.0) * m_Wetness;
 
     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);
+    outColor = vec4(col.rgb * light * BRIGHTNESS + vec3(spec * 0.35), col.a);
 #endif
 }

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

@@ -6,6 +6,7 @@ uniform bool      m_HasBarkMap;
 uniform vec3      m_LightDir;
 uniform vec3      m_SunColor;
 uniform vec3      m_AmbientColor;
+uniform float     m_Wetness;
 
 in vec2 texCoord;
 in vec3 worldNormal;
@@ -20,5 +21,7 @@ void main() {
     float diff  = max(dot(n, normalize(m_LightDir)), 0.0);
     vec3  light = clamp(m_AmbientColor + m_SunColor * diff, 0.0, 1.0);
 
-    gl_FragColor = vec4(baseColor * light, m_Diffuse.a);
+    baseColor *= (1.0 - 0.18 * m_Wetness);
+    float shine = pow(diff, 12.0) * m_Wetness * 0.30;
+    gl_FragColor = vec4(baseColor * light + vec3(shine), m_Diffuse.a);
 }

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

@@ -6,6 +6,7 @@ uniform bool      m_HasLeafMap;
 uniform vec3      m_LightDir;
 uniform vec3      m_SunColor;
 uniform vec3      m_AmbientColor;
+uniform float     m_Wetness;
 
 in vec2 texCoord;
 in vec3 worldNormal;
@@ -27,5 +28,7 @@ void main() {
     // Blätter transmittieren Licht — abs() für doppelseitige Beleuchtung
     float diff  = abs(dot(normalize(worldNormal), normalize(m_LightDir)));
     vec3  light = clamp(m_AmbientColor + m_SunColor * diff * 0.6, 0.0, 1.0);
-    gl_FragColor = vec4(baseColor * light, 1.0);
+    baseColor *= (1.0 - 0.18 * m_Wetness);
+    float shine = pow(diff, 12.0) * m_Wetness * 0.25;
+    gl_FragColor = vec4(baseColor * light + vec3(shine), 1.0);
 }

blight-assets/src/main/resources/Shaders/skies/clouds/CloudDome.frag

@@ -0,0 +1,53 @@
+uniform vec2  m_CloudOffset;
+uniform float m_CloudCover;
+uniform vec4  m_CloudColor;
+
+in  vec3 vDir;
+out vec4 outColor;
+
+float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+float vnoise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(hash(i),                hash(i + vec2(1.0, 0.0)), f.x),
+               mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), f.x), f.y);
+}
+
+float fbm(vec2 p) {
+    float v = 0.0;
+    float a = 0.5;
+    for (int i = 0; i < 6; i++) {
+        v += a * vnoise(p);
+        p  = p * 2.17 + vec2(0.631, 1.137);
+        a *= 0.5;
+    }
+    return v;
+}
+
+void main() {
+    vec3 dir = normalize(vDir);
+
+    if (dir.y < -0.02) discard;
+
+    // Horizon fade — clouds become transparent near the horizon
+    float hFade = smoothstep(0.0, 0.15, dir.y);
+
+    // Stereographic projection: maps sphere direction to 2D without pole distortion
+    vec2 uv = dir.xz / (dir.y + 1.001);
+    uv = uv * 3.5 + m_CloudOffset;
+
+    float f = fbm(uv);
+
+    // m_CloudCover 0=clear (threshold high → few clouds), 1=overcast (threshold low → all clouds)
+    float threshold = mix(0.72, 0.22, m_CloudCover);
+    float softness  = 0.09;
+    float cloud     = smoothstep(threshold - softness, threshold + softness, f);
+
+    cloud *= hFade;
+
+    outColor = vec4(m_CloudColor.rgb, cloud * m_CloudColor.a);
+}

blight-assets/src/main/resources/Shaders/skies/clouds/CloudDome.vert

@@ -0,0 +1,9 @@
+uniform mat4 g_WorldViewProjectionMatrix;
+
+in  vec3 inPosition;
+out vec3 vDir;
+
+void main() {
+    vDir        = inPosition;
+    gl_Position = g_WorldViewProjectionMatrix * vec4(inPosition, 1.0);
+}

blight-assets/src/main/resources/Shaders/skies/dome66/dome66.frag

@@ -0,0 +1,238 @@
+/*
+ Copyright (c) 2014-2022, Stephen Gold
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * fragment shader used by dome66.j3md
+ */
+#import "Common/ShaderLib/GLSLCompat.glsllib"
+uniform vec4 m_ClearColor;
+varying vec2 skyTexCoord;
+
+#ifdef HAS_STARS
+        uniform sampler2D m_StarsColorMap;
+#endif
+
+#ifdef HAS_OBJECT0
+        uniform vec4 m_Object0Color;
+	uniform sampler2D m_Object0ColorMap;
+	varying vec2 object0Coord;
+#endif
+
+#ifdef HAS_OBJECT1
+        uniform vec4 m_Object1Color;
+	uniform sampler2D m_Object1ColorMap;
+	varying vec2 object1Coord;
+#endif
+
+#ifdef HAS_OBJECT2
+        uniform vec4 m_Object2Color;
+	uniform sampler2D m_Object2ColorMap;
+	varying vec2 object2Coord;
+#endif
+
+#ifdef HAS_OBJECT3
+        uniform vec4 m_Object3Color;
+	uniform sampler2D m_Object3ColorMap;
+	varying vec2 object3Coord;
+#endif
+
+#ifdef HAS_OBJECT4
+        uniform vec4 m_Object4Color;
+	uniform sampler2D m_Object4ColorMap;
+	varying vec2 object4Coord;
+#endif
+
+#ifdef HAS_OBJECT5
+        uniform vec4 m_Object5Color;
+	uniform sampler2D m_Object5ColorMap;
+	varying vec2 object5Coord;
+#endif
+
+#ifdef HAS_HAZE
+        uniform sampler2D m_HazeAlphaMap;
+        uniform vec4 m_HazeColor;
+#endif
+
+#ifdef HAS_CLOUDS0
+        uniform sampler2D m_Clouds0AlphaMap;
+        uniform vec4 m_Clouds0Color;
+	varying vec2 clouds0Coord;
+#endif
+
+#ifdef HAS_CLOUDS1
+        uniform sampler2D m_Clouds1AlphaMap;
+        uniform vec4 m_Clouds1Color;
+	varying vec2 clouds1Coord;
+#endif
+
+#ifdef HAS_CLOUDS2
+        uniform sampler2D m_Clouds2AlphaMap;
+        uniform vec4 m_Clouds2Color;
+	varying vec2 clouds2Coord;
+#endif
+
+#ifdef HAS_CLOUDS3
+        uniform sampler2D m_Clouds3AlphaMap;
+        uniform vec4 m_Clouds3Color;
+	varying vec2 clouds3Coord;
+#endif
+
+#ifdef HAS_CLOUDS4
+        uniform sampler2D m_Clouds4AlphaMap;
+        uniform vec4 m_Clouds4Color;
+	varying vec2 clouds4Coord;
+#endif
+
+#ifdef HAS_CLOUDS5
+        uniform sampler2D m_Clouds5AlphaMap;
+        uniform vec4 m_Clouds5Color;
+	varying vec2 clouds5Coord;
+#endif
+
+vec4 mixColors(vec4 color0, vec4 color1) {
+        vec4 result;
+        float a0 = color0.a * (1.0 - color1.a);
+        result.a = a0 + color1.a;
+        if (result.a > 0.0) {
+                result.rgb = (a0 * color0.rgb + color1.a * color1.rgb)/result.a;
+        } else {
+                result.rgb = vec3(0.0);
+        }
+        return result;
+}
+
+void main() {
+        #ifdef HAS_STARS
+                vec4 stars = texture2D(m_StarsColorMap, skyTexCoord);
+        #else
+                vec4 stars = vec4(0.0);
+        #endif
+
+        vec4 objects = vec4(0.0);
+
+        #ifdef HAS_OBJECT0
+                if (floor(object0Coord.s) == 0.0 &&
+                    floor(object0Coord.t) == 0.0) {
+                        objects = m_Object0Color;
+                        objects *= texture2D(m_Object0ColorMap, object0Coord);
+                }
+	#endif
+
+        #ifdef HAS_OBJECT1
+                if (floor(object1Coord.s) == 0.0 &&
+                    floor(object1Coord.t) == 0.0) {
+                        vec4 object1 = m_Object1Color;
+                        object1 *= texture2D(m_Object1ColorMap, object1Coord);
+                        objects = mixColors(objects, object1);
+                }
+	#endif
+
+        #ifdef HAS_OBJECT2
+                if (floor(object2Coord.s) == 0.0 &&
+                    floor(object2Coord.t) == 0.0) {
+                        vec4 object2 = m_Object2Color;
+                        object2 *= texture2D(m_Object2ColorMap, object2Coord);
+                        objects = mixColors(objects, object2);
+                }
+	#endif
+
+        #ifdef HAS_OBJECT3
+                if (floor(object3Coord.s) == 0.0 &&
+                    floor(object3Coord.t) == 0.0) {
+                        vec4 object3 = m_Object3Color;
+                        object3 *= texture2D(m_Object3ColorMap, object3Coord);
+                        objects = mixColors(objects, object3);
+                }
+	#endif
+
+        #ifdef HAS_OBJECT4
+                if (floor(object4Coord.s) == 0.0 &&
+                    floor(object4Coord.t) == 0.0) {
+                        vec4 object4 = m_Object4Color;
+                        object4 *= texture2D(m_Object4ColorMap, object4Coord);
+                        objects = mixColors(objects, object4);
+                }
+	#endif
+
+        #ifdef HAS_OBJECT5
+                if (floor(object5Coord.s) == 0.0 &&
+                    floor(object5Coord.t) == 0.0) {
+                        vec4 object5 = m_Object5Color;
+                        object5 *= texture2D(m_Object5ColorMap, object5Coord);
+                        objects = mixColors(objects, object5);
+                }
+	#endif
+
+        vec4 color = mixColors(stars, objects);
+
+        vec4 clear = m_ClearColor;
+	#ifdef HAS_HAZE
+                vec4 haze = m_HazeColor;
+                haze.a *= texture2D(m_HazeAlphaMap, skyTexCoord).r;
+	        clear = mixColors(clear, haze);
+	#endif
+        color = mixColors(color, clear);
+        // Bright parts of objects shine through the clear areas.
+        color.rgb += objects.rgb * objects.a * (1.0 - clear.rgb) * clear.a;
+
+	#ifdef HAS_CLOUDS0
+                vec4 clouds0 = m_Clouds0Color;
+		clouds0.a *= texture2D(m_Clouds0AlphaMap, clouds0Coord).r;
+                color = mixColors(color, clouds0);
+        #endif
+
+	#ifdef HAS_CLOUDS1
+                vec4 clouds1 = m_Clouds1Color;
+		clouds1.a *= texture2D(m_Clouds1AlphaMap, clouds1Coord).r;
+                color = mixColors(color, clouds1);
+        #endif
+
+	#ifdef HAS_CLOUDS2
+                vec4 clouds2 = m_Clouds2Color;
+		clouds2.a *= texture2D(m_Clouds2AlphaMap, clouds2Coord).r;
+                color = mixColors(color, clouds2);
+        #endif
+
+	#ifdef HAS_CLOUDS3
+                vec4 clouds3 = m_Clouds3Color;
+		clouds3.a *= texture2D(m_Clouds3AlphaMap, clouds3Coord).r;
+                color = mixColors(color, clouds3);
+        #endif
+
+	#ifdef HAS_CLOUDS4
+                vec4 clouds4 = m_Clouds4Color;
+		clouds4.a *= texture2D(m_Clouds4AlphaMap, clouds4Coord).r;
+                color = mixColors(color, clouds4);
+        #endif
+
+	#ifdef HAS_CLOUDS5
+                vec4 clouds5 = m_Clouds5Color;
+		clouds5.a *= texture2D(m_Clouds5AlphaMap, clouds5Coord).r;
+                color = mixColors(color, clouds5);
+        #endif
+
+	gl_FragColor = color;
+}