clouds

Utworzony shader to prosty shader chmur, który generuje efekty chmur za pomocą szumu Perlina. Oto krótki opis jego funkcjonalności i sposobu zastosowania go do modelu PlaneMesh w Godot:

Opis funkcjonalności

1. Kolor chmury : Shader pozwala ustawić kolor chmur za pomocą cloud_colorparametru, który definiuje zarówno kolor, jak i przezroczystość chmur. Możesz ustawić kolor na dowolny odcień (np. biały, czerwony) i kontrolować przezroczystość.

2. Animacja chmur : Chmury poruszają się w czasie, kontrolowane przez speedparametr. Sprawia to, że efekt chmur wydaje się dynamiczny.

3. Perlin Noise : Shader używa Perlin Noise do generowania chmur o naturalnym, losowym wyglądzie. Składa się z kilku warstw szumu, aby stworzyć bardziej złożony efekt.

4. Parametry konfigurowalne :

   • cloud_color:Definiuje kolor i przezroczystość chmur.
   • cloud_opacity: Steruje kryciem chmur.
   • cloud_size: Ustawia rozmiar chmur.
   • scale:Określa skalę szumu, która wpływa na ogólny wygląd chmur.

Stosowanie Shadera do modelu PlaneMesh

Aby zastosować ten shader jako materiał do PlaneMeshmodelu w programie Godot, wykonaj następujące kroki:

1. Utwórz Shader :

   • Otwórz Godot Engine i utwórz nowy Shaderzasób.
   • Skopiuj kod shadera podany powyżej i wklej go do edytora shaderów.

2. Utwórz materiał :

   • Utwórz nowy ShaderMaterialzasób.
   • Przypisz nowo utworzony shader do ShaderMaterial.

3. Zastosuj materiał :

   • Wybierz PlaneMeshobiekt na scenie.
   • Znajdź nieruchomość w panelu inspektora Material.
   • Przypisz utworzone ShaderMaterialdo Materialwłaściwości.

4. Konfiguruj parametry :

   • W panelu inspektora dostosuj opcje cloud_colori cloud_opacitywłaściwości, aby ShaderMaterialustawić pożądany kolor i przezroczystość chmur.

5. Dostosuj rozmiar chmury :

   • Możesz również dostosować inne parametry shadera, takie jak cloud_sizei scale, aby dopasować efekt chmur do wymagań sceny.

Testowanie

Po zastosowaniu shadera do PlaneMeshmodelu uruchom scenę w Godot, aby zobaczyć efekt chmury. Możesz dostosować parametry materiału w czasie rzeczywistym, aby uzyskać pożądany wygląd chmur.

Shader code

shader_type spatial;

render_mode blend_mix, depth_draw_opaque, cull_back, unshaded;

// Uniformy dla zmiennych konfigurowalnych
uniform vec4 cloud_color = vec4(1.0, 1.0, 1.0, 1.0); // Kolor chmur (w tym przezroczystość)
uniform float cloud_opacity : hint_range(0.0, 1.0) = 0.1; // Przezroczystość chmur

// Funkcja do interpolacji (fade) używana w szumie Perlin'a
float fade(float t) {
    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}

// Funkcja do generowania gradientu
float grad(int hash, float x, float y) {
    int h = hash & 7;  // maska hash
    float u = h < 4 ? x : y;
    float v = h < 4 ? y : x;
    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
}

// Funkcja do generowania prostego szumu Perlin'a
float perlin_noise(vec2 coord) {
    vec2 p = floor(coord);
    vec2 f = fract(coord);
    f = f * f * (3.0 - 2.0 * f);

    float n = p.x + p.y * 57.0;
    float res = mix(
        mix(grad(int(n + 0.0), f.x, f.y),
            grad(int(n + 1.0), f.x - 1.0, f.y), fade(f.x)),
        mix(grad(int(n + 57.0), f.x, f.y - 1.0),
            grad(int(n + 58.0), f.x - 1.0, f.y - 1.0), fade(f.x)),
        fade(f.y));
    return res;
}

// Funkcja do generowania warstwowego szumu dla bardziej chmurowego efektu
float layered_perlin_noise(vec2 coord, float scale, float amplitude) {
    float noise = 0.0;
    float persistence = 0.5;  // Ustawienie wpływu kolejnych warstw szumu

    // Dodajemy kilka warstw szumu, aby uzyskać bardziej złożony efekt
    for (int i = 0; i < 5; i++) {
        noise += perlin_noise(coord * scale) * amplitude;
        scale *= 2.0;
        amplitude *= persistence;
    }
    return noise;
}

void fragment() {
    // Pobranie współrzędnych UV
    vec2 uv = UV;

    // Dodanie animacji do współrzędnych UV
    float speed = 0.0001; // Prędkość przesuwania chmur
    vec2 animated_uv = uv + vec2(TIME * speed, TIME * speed);

    // Parametry dla różnych chmur
    int num_clouds = 9; // Więcej chmur
    float cloud_size = 0.02; // Bardzo mały rozmiar chmury
    float scale = 9000.0; // Zmniejszona skala szumu

    // Inicjalizacja zmiennej do przechowywania wyniku końcowego
    float final_noise = 0.0;

    for (int i = 0; i < num_clouds; i++) {
        // Losowe przesunięcie dla każdej chmury
        float random_offset = float(i) * 0.01;
        vec2 cloud_center = vec2(fract(sin(float(i) * 0.1) * 43758.5453), fract(cos(float(i) * 0.1) * 43758.5453));

        // Modyfikacja współrzędnych UV dla efektu szumu
        vec2 cloud_uv = (animated_uv - cloud_center) * (scale * cloud_size);
        float noise = layered_perlin_noise(cloud_uv, 1.0, 1.0);

        // Wygładzanie i ograniczenie wartości szumu
        noise = smoothstep(0.3, 0.7, noise);
        final_noise = max(final_noise, noise);
    }

    // Ustawienie koloru chmur na podstawie uniformu
    vec4 color = vec4(cloud_color.rgb, cloud_color.a * final_noise * cloud_opacity);

    ALBEDO = color.rgb;
    ALPHA = color.a;
}

Tags