add weather and time

Assets/Enviro 3 - Sky and Weather/Resources/Shader/Includes/NoiseInclude.cginc

@@ -0,0 +1,151 @@
+///////////PERLIN NOISE////////////////
+//////// NOT USED ANYMORE ////////////
+
+// Hash to get pseudo-random gradient direction
+float2 hash2(float2 p)
+{
+    // A simple 2D hash
+    p = frac(p * float2(127.1, 311.7));
+    p += dot(p, p + 74.7);
+    return normalize(frac(float2(p.x * p.y, p.x + p.y)) * 2.0 - 1.0);
+}
+
+// Quintic fade curve for smooth interpolation
+float fade(float t)
+{
+    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+float penoise(float2 uv, float scale)
+{
+    // Scale and wrap UVs to create tileable domain
+    float2 p = uv * scale;
+
+    // Integer cell coordinates
+    float2 i0 = floor(p);
+    float2 f  = frac(p);
+
+    // Wrap to ensure seamless tiling
+    float2 i1 = fmod(i0 + 1.0, scale);
+
+    // Gradient vectors for the four cell corners
+    float2 g00 = hash2(fmod(i0, scale));
+    float2 g10 = hash2(float2(i1.x, i0.y));
+    float2 g01 = hash2(float2(i0.x, i1.y));
+    float2 g11 = hash2(i1);
+
+    // Distance vectors to corners
+    float2 d00 = f - float2(0.0, 0.0);
+    float2 d10 = f - float2(1.0, 0.0);
+    float2 d01 = f - float2(0.0, 1.0);
+    float2 d11 = f - float2(1.0, 1.0);
+
+    // Dot products
+    float n00 = dot(g00, d00);
+    float n10 = dot(g10, d10);
+    float n01 = dot(g01, d01);
+    float n11 = dot(g11, d11);
+
+    // Smooth interpolation
+    float2 u = fade(f);
+    float nx0 = lerp(n00, n10, u.x);
+    float nx1 = lerp(n01, n11, u.x);
+    float nxy = lerp(nx0, nx1, u.y);
+
+    // Normalize to [0,1]
+    return 0.5 + 0.5 * nxy;
+} 
+
+float perlinFBM(float2 uv, float baseScale, int octaves, float gain, float lacun)
+{
+    float total  = 0.0;
+    float amp    = 0.5;       // starting amplitude
+    float freq   = 1.0;       // starting frequency
+    float weight = 0.0;
+
+    // Always wrap UV first to avoid precision drift
+    uv = frac(uv);
+
+    [unroll]
+    for (int i = 0; i < octaves; i++)
+    {
+        // Sample tileable perlin at increasing frequency
+        // Keep tiling domain proportional to frequency for seamless wrap
+        total  += amp * penoise(uv * freq, baseScale * freq);
+        weight += amp;
+
+        freq *= lacun; // e.g. 2.0
+        amp  *= gain;  // e.g. 0.5
+    }
+
+    // Normalize to 0..1
+    return saturate(total / weight);
+}
+//////////////////////////////////////////
+///////////WORLEY NOISE///////////////////
+//////////////////////////////////////////
+
+// Hash to generate a repeatable 0..1 value for integer coords
+float hash21_stable(int2 p, int period)
+{
+    uint2 pu = (uint2)(p + period * 4096); // shift into positive domain
+    pu = pu % (uint)period;
+ 
+    uint n = pu.x * 73856093u ^ pu.y * 19349663u;
+    return frac((float)n * 0.000000119f);
+}
+
+float2 hash22_stable(int2 p, int period)
+{
+    float h1 = hash21_stable(p, period);
+    float h2 = hash21_stable(p + int2(17, 37), period);
+    return float2(h1, h2);
+}
+
+float Worley2D_Stable(float2 uv, int tileCount)
+{
+    // Tile domain
+    float2 p = uv * tileCount;
+    int2 baseCell = int2(floor(p));
+    float2 f = frac(p);
+
+    float minDist = 1.0;
+
+    // Search 3x3 neighborhood
+    [unroll]
+    for (int y = -1; y <= 1; y++)
+    {
+        [unroll]
+        for (int x = -1; x <= 1; x++)
+        {
+            int2 neighbor = baseCell + int2(x, y);
+            float2 rand = hash22_stable(neighbor, tileCount);
+            float2 feature = float2(x, y) + rand;
+
+            float d = length(f - feature);
+            minDist = min(minDist, d);
+        }
+    }
+    return saturate(minDist);
+}
+
+float WorleyFBM2D(float2 uv, int baseTiles, float bias)
+{
+    uv = frac(uv); // ensure [0,1] input
+
+    float n   = 0.0;
+    float amp = 0.5;
+    int   tiles = baseTiles;
+
+    [unroll]
+    for (int octave = 0; octave < 3; octave++)
+    {
+        n += amp * Worley2D_Stable(uv, tiles);
+        tiles *= 2;   // double tiles per octave
+        amp  *= 0.5;  // halve amplitude
+    }
+
+    // Invert + bias for cloud-like coverage
+    n = pow(1.0 - n, bias);
+    return saturate(n);
+}