B1,B2,Altar Sky Shaders, HorseHead/Ox Light Removal

Zennysoft.Game.Ma/src/map/dungeon/floors/AltarSky.tres

@@ -1,25 +0,0 @@
-[gd_resource type="VisualShader" load_steps=3 format=3 uid="uid://bl4n1pe2c1l07"]
-
-[sub_resource type="VisualShaderNodeInput" id="VisualShaderNodeInput_2ykon"]
-input_name = "time"
-
-[sub_resource type="VisualShaderNodeTexture3D" id="VisualShaderNodeTexture3D_iqpgl"]
-
-[resource]
-code = "shader_type sky;
-
-
-
-void sky() {
-}
-"
-graph_offset = Vector2(-173.47, -138.662)
-mode = 3
-flags/use_half_res_pass = false
-flags/use_quarter_res_pass = false
-flags/disable_fog = false
-flags/use_debanding = false
-nodes/sky/2/node = SubResource("VisualShaderNodeInput_2ykon")
-nodes/sky/2/position = Vector2(320, 40)
-nodes/sky/3/node = SubResource("VisualShaderNodeTexture3D_iqpgl")
-nodes/sky/3/position = Vector2(20, 40)

Zennysoft.Game.Ma/src/map/dungeon/rooms/Set A/15. Boss Floor A.tscn

@@ -1,4 +1,4 @@
-[gd_scene load_steps=125 format=4 uid="uid://5ja3qxn8h7iw"]
+[gd_scene load_steps=128 format=4 uid="uid://5ja3qxn8h7iw"]
 
 [ext_resource type="Script" uid="uid://tqyybt313web" path="res://src/map/dungeon/code/BossRoomA.cs" id="1_0h3lb"]
 [ext_resource type="Texture2D" uid="uid://vjbe1lg810gh" path="res://src/map/dungeon/models/Set A/15. Boss Floor A/15_A1_BOSS FLOOR A_VER_swirled_column.png" id="2_06eum"]
@@ -27,8 +27,9 @@
 [ext_resource type="PackedScene" uid="uid://2wibfnu2jvlv" path="res://src/enemy/enemy_types/14. horse_head/HorseFace.tscn" id="25_a482y"]
 [ext_resource type="PackedScene" uid="uid://bvv5giqyrhtl1" path="res://src/enemy/enemy_types/15. ox_face/OxFaceStatue.tscn" id="26_futcf"]
 [ext_resource type="PackedScene" uid="uid://6dnsw37d1uw4" path="res://src/enemy/enemy_types/15. ox_face/OxFace.tscn" id="27_g6y6v"]
-[ext_resource type="Shader" uid="uid://dr68ani6ouefm" path="res://src/map/dungeon/rooms/Set A/Bloss Floor Clouds 2.gdshader" id="28_1qa0g"]
 [ext_resource type="Texture2D" uid="uid://dh2b74lac57p0" path="res://src/map/dungeon/models/Set A/15. Boss Floor A/Sunset Skybox.png" id="28_i45xk"]
+[ext_resource type="Shader" uid="uid://dvcgcgijc7nng" path="res://src/map/map shaders/B1 Cloud Roll Top.gdshader" id="29_4xaw3"]
+[ext_resource type="Shader" uid="uid://dr68ani6ouefm" path="res://src/map/map shaders/B1 Cloud Roll.gdshader" id="30_lmjp4"]
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_syull"]
 
@@ -1342,6 +1343,14 @@ adjustment_saturation = 0.94
 [sub_resource type="CameraAttributesPractical" id="CameraAttributesPractical_i45xk"]
 dof_blur_far_distance = 42.38
 
+[sub_resource type="PlaneMesh" id="PlaneMesh_lmjp4"]
+
+[sub_resource type="ShaderMaterial" id="ShaderMaterial_54iu8"]
+render_priority = 0
+shader = ExtResource("29_4xaw3")
+shader_parameter/cloud_color = Vector4(1, 1, 1, 1)
+shader_parameter/cloud_opacity = 0.1
+
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_54iu8"]
 shading_mode = 0
 albedo_texture = ExtResource("28_i45xk")
@@ -1355,16 +1364,16 @@ subdivide_depth = 90
 
 [sub_resource type="ShaderMaterial" id="ShaderMaterial_4xaw3"]
 render_priority = 0
-shader = ExtResource("28_1qa0g")
-shader_parameter/height_scale = 0.5
-shader_parameter/wave_speed = 0.1
-shader_parameter/upper_transparency = 0.89
+shader = ExtResource("30_lmjp4")
+shader_parameter/height_scale = 0.3
+shader_parameter/wave_speed = 0.2
+shader_parameter/upper_transparency = 0.99
 shader_parameter/global_transparency = 0.9
 shader_parameter/time_factor = Vector2(2, 3)
 shader_parameter/uv1_scale = Vector3(0, 0, 0)
 shader_parameter/uv1_offset = Vector3(0, 0, 0)
-shader_parameter/color1 = Color(0.78, 0.91, 0.93, 1)
-shader_parameter/color2 = Color(0.71, 0.89, 0.95, 1)
+shader_parameter/color1 = Color(0.88, 0.91, 0.93, 1)
+shader_parameter/color2 = Color(0.88, 0.99, 0.95, 1)
 
 [node name="Boss Floor A" type="Node3D"]
 script = ExtResource("1_0h3lb")
@@ -1623,25 +1632,24 @@ collision_mask = 2
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -240.071, 36.4279, 34.624)
 shape = SubResource("BoxShape3D_pkvyy")
 
-[node name="HorseHeadStatue" parent="Room" instance=ExtResource("24_r1rk5")]
+[node name="Horse Head Statue" parent="Room" instance=ExtResource("24_r1rk5")]
 unique_name_in_owner = true
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -102.157, -2.30863, 13.0139)
 
-[node name="HorseFace" parent="Room" instance=ExtResource("25_a482y")]
+[node name="Horse Head Active" parent="Room" instance=ExtResource("25_a482y")]
 unique_name_in_owner = true
 transform = Transform3D(0.15, 0, 0, 0, 0.15, 0, 0, 0, 0.15, -102.157, -0.510939, 13.0139)
 visible = false
 PrimaryAttackElementalType = 0
 PrimaryAttackElementalDamageBonus = 1.0
 
-[node name="OxFaceStatue" parent="Room" instance=ExtResource("26_futcf")]
+[node name="Ox Face Statue" parent="Room" instance=ExtResource("26_futcf")]
 unique_name_in_owner = true
 transform = Transform3D(-1, 0, -8.74228e-08, 0, 1, 0, 8.74228e-08, 0, -1, -101.555, -2.30863, 21.5833)
 
-[node name="OxFace" parent="Room" instance=ExtResource("27_g6y6v")]
+[node name="OxFace Active" parent="Room" instance=ExtResource("27_g6y6v")]
 unique_name_in_owner = true
 transform = Transform3D(-0.15, 0, -2.26494e-08, 0, 0.15, 0, 2.26494e-08, 0, -0.15, -101.703, -0.479859, 22.0955)
-visible = false
 
 [node name="Exit" type="Area3D" parent="Room"]
 unique_name_in_owner = true
@@ -1667,6 +1675,12 @@ shadow_enabled = true
 shadow_blur = 3.602
 
 [node name="MeshInstance3D" type="MeshInstance3D" parent="."]
+transform = Transform3D(600, 0, 0, 0, 600, 0, 0, 0, 600, -316.281, -6.937, -581.099)
+mesh = SubResource("PlaneMesh_lmjp4")
+skeleton = NodePath("../Sky Billboard")
+surface_material_override/0 = SubResource("ShaderMaterial_54iu8")
+
+[node name="Sky Billboard" type="MeshInstance3D" parent="."]
 transform = Transform3D(2000, 0, 2.62268e-05, 8.74228e-05, 1.14641e-12, -600, 0, 600, 1.14641e-12, -485.068, -193.889, -378.654)
 material_override = SubResource("StandardMaterial3D_54iu8")
 mesh = SubResource("PlaneMesh_3pfmd")

Zennysoft.Game.Ma/src/map/dungeon/rooms/Set B/34. Boss Floor B.tscn

@@ -29,8 +29,6 @@
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_4oyst"]
 resource_name = "COLUMN WHITE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("2_egkxs")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_6nbut"]
@@ -69,38 +67,26 @@ shadow_mesh = SubResource("ArrayMesh_6nbut")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_id3eh"]
 resource_name = "A2 MAIN "
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("3_sfnee")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_nqkft"]
 resource_name = "A2 TILE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("4_utkqh")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_483aw"]
 resource_name = "A2 TILE 3"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("5_oqcwc")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_eapvp"]
 resource_name = "A2 TILE 2"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("6_f0q5s")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_ns6l2"]
 resource_name = "WHITE BRICK"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("7_1davs")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_yxf2d"]
 resource_name = "MARBLE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("8_v2xvs")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_65iwq"]
@@ -283,14 +269,10 @@ shadow_mesh = SubResource("ArrayMesh_s7p6n")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_yfiih"]
 resource_name = "SWIRLED"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("9_weetq")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_gcr7v"]
 resource_name = "A2 HAND TILE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("10_57q1h")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_itbxn"]
@@ -298,8 +280,6 @@ resource_name = "A2 MOTHER"
 transparency = 2
 alpha_scissor_threshold = 0.5
 alpha_antialiasing_mode = 0
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("11_y26hv")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_rqt7b"]
@@ -406,8 +386,6 @@ shadow_mesh = SubResource("ArrayMesh_rqt7b")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_0n8c2"]
 resource_name = "A2 MAIN STONE 2"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("12_wo03q")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_jnoab"]
@@ -445,7 +423,6 @@ blend_shape_mode = 0
 shadow_mesh = SubResource("ArrayMesh_jnoab")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_xdswc"]
-shading_mode = 1
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_cmq71"]
 _surfaces = [{
@@ -479,14 +456,10 @@ shadow_mesh = SubResource("ArrayMesh_cmq71")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_wy8dd"]
 resource_name = "AREA 2 CORRIDOR TRIM"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("13_d5bj7")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_jwani"]
 resource_name = "WHITE TILE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("14_gpqil")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_kcblo"]
@@ -661,8 +634,6 @@ shadow_mesh = SubResource("ArrayMesh_kcblo")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_cqc6b"]
 resource_name = "HAND LIME"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("10_57q1h")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_pwi10"]
@@ -839,8 +810,6 @@ shadow_mesh = SubResource("ArrayMesh_8on1a")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_i3ftr"]
 resource_name = "A2 DARKER STONE"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("15_g11te")
 texture_filter = 2
 
@@ -914,34 +883,24 @@ shadow_mesh = SubResource("ArrayMesh_s1yj6")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_xoxtd"]
 resource_name = "AREA 2 FLOOR"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("5_oqcwc")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_jfrd3"]
 resource_name = "AREA 2 STUCCO"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("16_l6lac")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_v4iuw"]
 resource_name = "AREA 2 DARK "
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("17_w36g2")
 texture_filter = 2
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_fd687"]
 resource_name = "AREA 2 FLOOR VARIATION"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("6_f0q5s")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_6s383"]
 resource_name = "A2 STONE PANEL"
 transparency = 4
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("18_vkld8")
 texture_filter = 2
 
@@ -950,21 +909,15 @@ resource_name = "HAND CYCLE"
 transparency = 2
 alpha_scissor_threshold = 0.5
 alpha_antialiasing_mode = 0
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("19_ydosv")
 texture_filter = 2
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_n5ffv"]
 resource_name = "Material.010"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("20_28gy6")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_msj5l"]
 resource_name = "Material.006"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("21_tt5wf")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_iamgl"]
@@ -1350,8 +1303,6 @@ resource_name = "Material.008"
 transparency = 2
 alpha_scissor_threshold = 0.5
 alpha_antialiasing_mode = 0
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("22_ddrwt")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_7f5nk"]
@@ -1388,8 +1339,6 @@ shadow_mesh = SubResource("ArrayMesh_7f5nk")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_a5xuq"]
 resource_name = "Material"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("23_rke2f")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_yocju"]
@@ -1429,8 +1378,6 @@ resource_name = "Material.002"
 transparency = 2
 alpha_scissor_threshold = 0.5
 alpha_antialiasing_mode = 0
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("24_k805n")
 texture_filter = 2
 
@@ -1500,8 +1447,6 @@ shadow_mesh = SubResource("ArrayMesh_rgh1o")
 
 [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_pc5d1"]
 resource_name = "AREA 2 STUCCO 2"
-cull_mode = 0
-shading_mode = 1
 albedo_texture = ExtResource("2_egkxs")
 
 [sub_resource type="ArrayMesh" id="ArrayMesh_14bn4"]

Zennysoft.Game.Ma/src/map/map shaders/Altar Sky Environment.gdshader

@@ -0,0 +1,291 @@
+shader_type sky;
+
+render_mode use_quarter_res_pass;
+
+// Originaly based on https://godotshaders.com/shader/stylized-sky-shader-with-clouds/ but there's not much left
+
+group_uniforms sky;
+	uniform vec3 day_top_color : source_color = vec3( 0.1, 0.6, 1.0 );
+	uniform vec3 day_bottom_color : source_color = vec3( 0.4, 0.8, 1.0 );
+	uniform vec3 sunset_top_color : source_color = vec3( 0.7, 0.75, 1.0 );
+	uniform vec3 sunset_bottom_color : source_color = vec3( 1.0, 0.5, 0.7 );
+	uniform vec3 night_top_color : source_color = vec3( 0.02, 0.0, 0.04 );
+	uniform vec3 night_bottom_color : source_color = vec3( 0.1, 0.0, 0.2 );
+
+group_uniforms horizon;
+	uniform vec3 horizon_color : source_color = vec3( 0.0, 0.7, 0.8 );
+	uniform float horizon_blur : hint_range( 0.0, 1.0, 0.01 ) = 0.05;
+
+group_uniforms sun; // First DirectionalLight3D will be the sun
+	uniform vec3 sun_color : source_color = vec3( 10.0, 8.0, 1.0 );
+	uniform vec3 sun_sunset_color : source_color = vec3( 10.0, 0.0, 0.0 );
+	uniform float sun_size : hint_range( 0.01, 1.0 ) = 0.2;
+	uniform float sun_blur : hint_range( 0.01, 20.0 ) = 10.0;
+
+group_uniforms moon; // Second DirectionalLight3D will be the moon
+	uniform vec3 moon_color : source_color = vec3( 1.0, 0.95, 0.7 );
+	uniform float moon_size : hint_range( 0.01, 1.0 ) = 0.06;
+	uniform float moon_blur : hint_range( 0.01, 10.0 ) = 0.1;
+
+group_uniforms clouds;
+	// Replaced by noise functions, unncomment if you want to use graphical textures
+//	uniform sampler2D clouds_top_texture : filter_linear_mipmap, hint_default_black;
+//	uniform sampler2D clouds_middle_texture : filter_linear_mipmap, hint_default_black;
+//	uniform sampler2D clouds_bottom_texture : filter_linear_mipmap, hint_default_black;
+	uniform vec3 clouds_edge_color : source_color = vec3( 0.8, 0.8, 0.98 );
+	uniform vec3 clouds_top_color : source_color = vec3( 1.0, 1.0, 1.00 );
+	uniform vec3 clouds_middle_color : source_color = vec3( 0.92, 0.92, 0.98 );
+	uniform vec3 clouds_bottom_color : source_color = vec3( 0.83, 0.83, 0.94 );
+	uniform float clouds_speed : hint_range( 0.0, 20.0, 0.01 ) = 2.0;
+	uniform float clouds_direction : hint_range( -0.5, 0.5, 0.0 ) = 0.2;
+	uniform float clouds_scale : hint_range( 0.0, 4.0, 0.01 ) = 1.0;
+	uniform float clouds_cutoff : hint_range( 0.0, 1.0, 0.01 ) = 0.3;
+	uniform float clouds_fuzziness : hint_range( 0.0, 2.0, 0.01 ) = 0.5;
+	// More weight is simply a darker color, usefull for rain/storm
+	uniform float clouds_weight : hint_range( 0.0, 1.0, 0.01 ) = 0.0;
+	uniform float clouds_blur : hint_range( 0.0, 1.0, 0.01 ) = 0.25;
+
+group_uniforms stars;
+	// Stars should be at black background
+	uniform sampler2D stars_texture : filter_linear_mipmap, hint_default_black;
+	uniform float stars_speed : hint_range( 0.0, 20.0, 0.01 ) = 1.0;
+
+group_uniforms settings;
+	uniform float overwritten_time = 0.0;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+	// Function for clouds noises. You can replace using "gen_fractal_ping_pong" with a simple texture reading.
+	// I was frustrated with the repeating texture that's why I included the algorithm in the code.
+	// Source: https://github.com/Auburn/FastNoiseLite/tree/master
+	const int PRIME_X = 501125321;
+	const int PRIME_Y = 1136930381;
+	float lerp( float a, float b, float t )
+	{
+		return a + t * ( b - a );
+	}
+	float cubic_lerp( float a, float b, float c, float d, float t )
+	{
+		float p = d - c - ( a - b );
+		return t * t * t * p + t * t * ( a - b - p ) + t * ( c - a ) + b;
+	}
+	float ping_pong( float t )
+	{
+		t -= trunc( t * 0.5 ) * 2.0;
+		return t < 1.0 ? t : 2.0 - t;
+	}
+	int hash( int seed, int x_primed, int y_primed )
+	{
+		return ( seed ^ x_primed ^ y_primed ) * 0x27d4eb2d;
+	}
+	float val_coord( int seed, int x_primed, int y_primed )
+	{
+	    int hash = hash( seed, x_primed, y_primed );
+	    hash *= hash;
+	    hash ^= hash << 19;
+	    return float( hash ) * ( 1.0 / 2147483648.0 );
+	}
+	float single_value_cubic( int seed, float x, float y )
+	{
+	    int x1 = int( floor( x ));
+	    int y1 = int( floor( y ));
+
+	    float xs = x - float( x1 );
+	    float ys = y - float( y1 );
+
+	    x1 *= PRIME_X;
+	    y1 *= PRIME_Y;
+	    int x0 = x1 - PRIME_X;
+	    int y0 = y1 - PRIME_Y;
+	    int x2 = x1 + PRIME_X;
+	    int y2 = y1 + PRIME_Y;
+	    int x3 = x1 + ( PRIME_X << 1 );
+	    int y3 = y1 + ( PRIME_Y << 1 );
+
+	    return cubic_lerp(
+	        cubic_lerp( val_coord( seed, x0, y0 ), val_coord( seed, x1, y0 ), val_coord( seed, x2, y0 ), val_coord( seed, x3, y0 ), xs ),
+	        cubic_lerp( val_coord( seed, x0, y1 ), val_coord( seed, x1, y1 ), val_coord( seed, x2, y1 ), val_coord( seed, x3, y1 ), xs ),
+	        cubic_lerp( val_coord( seed, x0, y2 ), val_coord( seed, x1, y2 ), val_coord( seed, x2, y2 ), val_coord( seed, x3, y2 ), xs ),
+	        cubic_lerp( val_coord( seed, x0, y3 ), val_coord( seed, x1, y3 ), val_coord( seed, x2, y3 ), val_coord( seed, x3, y3 ), xs ),
+	    ys ) * ( 1.0 / ( 1.5 * 1.5 ));
+	}
+	// Params can be change in the same way as in noise settings in Godot
+	const float FRACTAL_BOUNDING = 1.0 / 1.75;
+	const int OCTAVES = 5;
+	const float PING_PONG_STRENGTH = 2.0;
+	const float WEIGHTED_STRENGTH = 0.0;
+	const float GAIN = 0.5;
+	const float LACUNARITY = 2.0;
+	float gen_fractal_ping_pong( vec2 pos, int seed, float frequency )
+	{
+		float x = pos.x * frequency;
+		float y = pos.y * frequency;
+	    float sum = 0.0;
+		float amp = FRACTAL_BOUNDING;
+	    for( int i = 0; i < OCTAVES; i++ )
+	    {
+	        float noise = ping_pong(( single_value_cubic( seed++, x, y ) + 1.0 ) * PING_PONG_STRENGTH );
+	        sum += ( noise - 0.5 ) * 2.0 * amp;
+	        amp *= lerp( 1.0, noise, WEIGHTED_STRENGTH );
+	        x *= LACUNARITY;
+	        y *= LACUNARITY;
+	        amp *= GAIN;
+	    }
+	    return sum * 0.5 + 0.5;
+	}
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Function needed to calculate the phase of the moon
+// Source: https://kelvinvanhoorn.com/2022/03/17/skybox-tutorial-part-1/
+float sphere_intersect( vec3 view_dir, vec3 sphere_pos, float radius )
+{
+    float b = dot( -sphere_pos, view_dir );
+    float c = dot( -sphere_pos, -sphere_pos ) - pow( radius, 2 );
+    float h = pow( b, 2 ) - c;
+    return h < 0.0 ? -1.0 : -b - sqrt( h );
+}
+
+void sky()
+{
+	float time = overwritten_time != 0.0 ? overwritten_time : TIME;
+
+	//////////////////// SKY ///////////////////////////////////////////////////////////////////////
+	float _eyedir_y = abs( sin( EYEDIR.y * PI * 0.5 ));
+
+	// The day color will be our base color
+	vec3 _sky_color = mix( day_bottom_color, day_top_color, _eyedir_y );
+	_sky_color = mix( _sky_color, vec3( 0.0 ), clamp(( 0.7 - clouds_cutoff ) * clouds_weight, 0.0, 1.0 ));
+
+	float _sunset_amount = clamp( 0.5 - abs( LIGHT0_DIRECTION.y ), 0.0, 0.5 ) * 2.0;
+	// The sky should be more red around the west, on the opposite side you don't see it as much
+	float _sunset_distance = clamp( 1.0 - pow( distance( EYEDIR, LIGHT0_DIRECTION ), 2 ), 0.0, 1.0 );
+	vec3 _sky_sunset_color = mix( sunset_bottom_color, sunset_top_color, _eyedir_y + 0.5 );
+	_sky_sunset_color = mix( _sky_sunset_color, sunset_bottom_color, _sunset_amount * _sunset_distance );
+	_sky_color = mix( _sky_color, _sky_sunset_color, _sunset_amount );
+
+	float _night_amount = clamp( -LIGHT0_DIRECTION.y + 0.7, 0.0, 1.0 );
+	vec3 _sky_night_color = mix( night_bottom_color, night_top_color, _eyedir_y );
+	_sky_color = mix( _sky_color, _sky_night_color, _night_amount );
+
+	// Final sky color
+	COLOR = _sky_color;
+
+	//////////////////// HORIZON ///////////////////////////////////////////////////////////////////
+	float _horizon_amount = 0.0;
+	if( EYEDIR.y < 0.0 )
+	{
+		_horizon_amount = clamp( abs( EYEDIR.y ) / horizon_blur, 0.0, 1.0 );
+		// Mixing with the color of the night sky to make the horizon darker
+		vec3 _horizon_color = mix( horizon_color, _sky_color, _night_amount * 0.9 );
+		// And if ther are many dark clouds, we also make the horizon darker
+		_horizon_color = mix( _horizon_color, vec3( 0.0 ), ( 1.0 - clouds_cutoff ) * clouds_weight * 0.7 );
+		COLOR = mix( COLOR, _horizon_color, _horizon_amount );
+	}
+
+	//////////////////// MOON //////////////////////////////////////////////////////////////////////
+	float _moon_amount = 0.0;
+	if( LIGHT1_ENABLED )
+	{
+		// Bigger moon near the horizon
+		float _moon_size = moon_size + cos( LIGHT1_DIRECTION.y * PI ) * moon_size * 0.25;
+		float _moon_distance = distance( EYEDIR, LIGHT1_DIRECTION ) / _moon_size;
+		// Finding moon disc and edge blur
+		_moon_amount = clamp(( 1.0 - _moon_distance ) / moon_blur, 0.0, 1.0 );
+		if( _moon_amount > 0.0 )
+		{
+			// Moon illumination depending on the position of the sun
+			float _moon_intersect = sphere_intersect( EYEDIR, LIGHT1_DIRECTION, _moon_size );
+			vec3 _moon_normal = normalize( LIGHT1_DIRECTION - EYEDIR * _moon_intersect );
+			// Power on the result gives a better effect
+			float _moon_n_dot_l = pow( clamp( dot( _moon_normal, -LIGHT0_DIRECTION ), 0.05, 1.0 ), 2 );
+			// Hiding the moon behind the horizon
+			_moon_amount *= 1.0 - _horizon_amount;
+			COLOR = mix( COLOR, moon_color, _moon_n_dot_l * _moon_amount );
+		}
+	}
+
+	//////////////////// SUN ///////////////////////////////////////////////////////////////////////
+	float _sun_distance = 0.0;
+	if( LIGHT0_ENABLED )
+	{
+		_sun_distance = distance( EYEDIR, LIGHT0_DIRECTION );
+		// Bigger sun near the horizon
+		float _sun_size = sun_size + cos( LIGHT0_DIRECTION.y * PI ) * sun_size * 0.25;
+		// Finding sun disc and edge blur
+		float _sun_amount = clamp(( 1.0 - _sun_distance / _sun_size ) / sun_blur, 0.0, 1.0 );
+		if( _sun_amount > 0.0 )
+		{
+			// Changing color of the sun during sunset
+			float _sunset_amount = 1.0;
+			if( LIGHT0_DIRECTION.y > 0.0 )
+				_sunset_amount = clamp( cos( LIGHT0_DIRECTION.y * PI ), 0.0, 1.0 );
+			vec3 _sun_color = mix( sun_color, sun_sunset_color, _sunset_amount );
+			// Hiding the sun behind the moon
+			_sun_amount = clamp( _sun_amount * ( 1.0 - _moon_amount ), 0.0, 1.0 );
+			// Hiding the sun behind the horizon
+			_sun_amount *= 1.0 - _horizon_amount;
+			// Leveling the "glow" in color
+			if( _sun_color.r > 1.0 || _sun_color.g > 1.0 || _sun_color.b > 1.0 )
+				_sun_color *= _sun_amount;
+			COLOR = mix( COLOR, _sun_color, _sun_amount );
+		}
+	}
+
+	//////////////////// STARS /////////////////////////////////////////////////////////////////
+	vec2 _sky_uv = EYEDIR.xz / sqrt( EYEDIR.y );
+	if( EYEDIR.y > -0.01 && LIGHT0_DIRECTION.y < 0.0  )
+	{
+		// Stars UV rotation
+		float _stars_speed_cos = cos( stars_speed * time * 0.005 );
+		float _stars_speed_sin = sin( stars_speed * time * 0.005 );
+		vec2 _stars_uv = vec2(
+			_sky_uv.x * _stars_speed_cos - _sky_uv.y * _stars_speed_sin,
+			_sky_uv.x * _stars_speed_sin + _sky_uv.y * _stars_speed_cos
+		);
+		// Stars texture
+		vec3 _stars_color = texture( stars_texture, _stars_uv ).rgb * -LIGHT0_DIRECTION.y;
+		// Hiding stars behind the moon
+		_stars_color *= 1.0 - _moon_amount;
+		COLOR += _stars_color;
+	}
+
+	//////////////////// CLOUDS ////////////////////////////////////////////////////////////////
+	if( EYEDIR.y > 0.0 )
+	{
+		// Clouds UV movement direction
+		float _clouds_speed = time * clouds_speed * 0.01;
+		float _sin_x = sin( clouds_direction * PI * 2.0 );
+		float _cos_y = cos( clouds_direction * PI * 2.0 );
+		// I using 3 levels of clouds. Top is the lightes and botom the darkest.
+		// The speed of movement (and direction a little) is different for the illusion of the changing shape of the clouds.
+		vec2 _clouds_movement = vec2( _sin_x, _cos_y ) * _clouds_speed;
+//		float _noise_top = texture( clouds_top_texture, ( _sky_uv + _clouds_movement ) * clouds_scale ).r;
+		float _noise_top = gen_fractal_ping_pong( ( _sky_uv + _clouds_movement ) * clouds_scale, 0, 0.5 );
+		_clouds_movement = vec2( _sin_x * 0.97, _cos_y * 1.07 ) * _clouds_speed * 3.89;
+//		float _noise_middle = texture( clouds_middle_texture, ( _sky_uv + _clouds_movement ) * clouds_scale ).r;
+		float _noise_middle = gen_fractal_ping_pong( ( _sky_uv + _clouds_movement ) * clouds_scale, 1, 0.89 );
+		_clouds_movement = vec2( _sin_x * 1.01, _cos_y * 0.89 ) * _clouds_speed * 2.79;
+//		float _noise_bottom = texture( clouds_bottom_texture, ( _sky_uv + _clouds_movement ) * clouds_scale ).r;
+		float _noise_bottom = gen_fractal_ping_pong( ( _sky_uv + _clouds_movement ) * clouds_scale, 2, 1.0 );
+		// Smoothstep with the addition of a noise value from a lower level gives a nice, deep result
+		_noise_bottom = smoothstep( clouds_cutoff, clouds_cutoff + clouds_fuzziness, _noise_bottom );
+		_noise_middle = smoothstep( clouds_cutoff, clouds_cutoff + clouds_fuzziness, _noise_middle + _noise_bottom * 0.2 ) * 1.1;
+		_noise_top = smoothstep( clouds_cutoff, clouds_cutoff + clouds_fuzziness, _noise_top + _noise_middle * 0.4 ) * 1.2;
+		float _clouds_amount = clamp( _noise_top + _noise_middle + _noise_bottom, 0.0, 1.0 );
+		// Fading clouds near the horizon
+		_clouds_amount *= clamp( abs( EYEDIR.y ) / clouds_blur, 0.0, 1.0 );
+
+		vec3 _clouds_color = mix( vec3( 0.0 ), clouds_top_color, _noise_top );
+		_clouds_color = mix( _clouds_color, clouds_middle_color, _noise_middle );
+		_clouds_color = mix( _clouds_color, clouds_bottom_color, _noise_bottom );
+		// The edge color gives a nice smooth edge, you can try turning this off if you need sharper edges
+		_clouds_color = mix( clouds_edge_color, _clouds_color, _noise_top );
+		// The sun passing through the clouds effect
+		_clouds_color = mix( _clouds_color, clamp( sun_color, 0.0, 1.0 ), pow( 1.0 - clamp( _sun_distance, 0.0, 1.0 ), 5 ));
+		// Color combined with sunset condition
+		_clouds_color = mix( _clouds_color, sunset_bottom_color, _sunset_amount * 0.75 );
+		// Color depending on the "progress" of the night.
+		_clouds_color = mix( _clouds_color, _sky_color, clamp( _night_amount, 0.0, 0.98 ));
+		_clouds_color = mix( _clouds_color, vec3( 0.0 ), clouds_weight * 0.9 );
+		COLOR = mix( COLOR, _clouds_color, _clouds_amount );
+	}
+}

Zennysoft.Game.Ma/src/map/map shaders/Altar Sky Environment.gdshader.uid

@@ -0,0 +1 @@
+uid://c4a68uhm5o2h4

Zennysoft.Game.Ma/src/map/map shaders/B1 Cloud Roll Top.gdshader.uid

@@ -0,0 +1 @@
+uid://dvcgcgijc7nng

Zennysoft.Game.Ma/src/map/map shaders/B1 Cloud Roll.gdshader

@@ -52,35 +52,35 @@ float fbm(vec2 x, float time) {
 }
 
 void vertex() {
-	
+
 	UV=UV*uv1_scale.xy+uv1_offset.xy;
-	
+
 	out_color = vec3(color1.r, color1.g, color1.b);
 	soft_color = vec3(color1.r, color1.g, color1.b);
-	
+
 	float height = fbm(VERTEX.xz * 4.0, TIME);
 	VERTEX.y += height * height_scale;
 	COLOR.xyz = vec3(height);
-	
+
 	if (VERTEX.y > 0.3){
 		out_color = lerpColor(color1, color2, clamp((VERTEX.y) / 3.0, 0.5, 1.0));
 		soft_color = vec3(color2.r, color2.g, color2.b);
-		
-		
-		
+
+
+
 	}
 }
 
 
 
 void fragment(){
-	
+
 	ALBEDO = COLOR.xyz;
 	vec2 base_uv = UV;
 	vec4 albedo_tex = texture(texture_albedo,base_uv);
 	ALPHA = global_transparency;
 	ALBEDO = out_color * albedo_tex.rgb * COLOR.xyz;
-	 if (soft_color.r==color2.r && soft_color.g==color2.g && color2.b==color2.b) {   
+	 if (soft_color.r==color2.r && soft_color.g==color2.g && color2.b==color2.b) {
        ALPHA = upper_transparency;
     }
 }

Zennysoft.Game.Ma/src/map/map shaders/B2 Cloud Roll Middle.gdshader

@@ -0,0 +1,87 @@
+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.01; // Prędkość przesuwania chmur
+    vec2 animated_uv = uv + vec2(TIME * speed, TIME * speed);
+
+    // Parametry dla różnych chmur
+    int num_clouds = 23; // Więcej chmur
+    float cloud_size = 0.001; // 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;
+}

Zennysoft.Game.Ma/src/map/map shaders/B2 Cloud Roll Top.gdshader

@@ -0,0 +1,87 @@
+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.01; // Prędkość przesuwania chmur
+    vec2 animated_uv = uv + vec2(TIME * speed, TIME * speed);
+
+    // Parametry dla różnych chmur
+    int num_clouds = 23; // Więcej chmur
+    float cloud_size = 0.001; // 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;
+}

Zennysoft.Game.Ma/src/map/map shaders/B2 Cloud Roll Top.gdshader.uid

@@ -0,0 +1 @@
+uid://c1aea2co8saff

Zennysoft.Game.Ma/src/map/map shaders/B2 Night Sky Star Textures.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bk2irsqn0sbex"
+path="res://.godot/imported/B2 Night Sky Star Textures.png-b64ddda4d862ce7c66dcb29d88b5b9ac.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://src/map/map shaders/B2 Night Sky Star Textures.png"
+dest_files=["res://.godot/imported/B2 Night Sky Star Textures.png-b64ddda4d862ce7c66dcb29d88b5b9ac.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

Zennysoft.Game.Ma/src/map/map shaders/Overworld Cloud Roll Lower.gdshader

@@ -0,0 +1,87 @@
+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.01; // Prędkość przesuwania chmur
+    vec2 animated_uv = uv + vec2(TIME * speed, TIME * speed);
+
+    // Parametry dla różnych chmur
+    int num_clouds = 23; // Więcej chmur
+    float cloud_size = 0.001; // 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;
+}

Zennysoft.Game.Ma/src/map/map shaders/Overworld Cloud Roll Lower.gdshader.uid

@@ -0,0 +1 @@
+uid://clm02ijbllxoc

Zennysoft.Game.Ma/src/map/map shaders/Overworld Cloud Roll Top.gdshader

@@ -0,0 +1,87 @@
+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.01; // Prędkość przesuwania chmur
+    vec2 animated_uv = uv + vec2(TIME * speed, TIME * speed);
+
+    // Parametry dla różnych chmur
+    int num_clouds = 23; // Więcej chmur
+    float cloud_size = 0.001; // 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;
+}

Zennysoft.Game.Ma/src/map/map shaders/Overworld Cloud Roll Top.gdshader.uid

@@ -0,0 +1 @@
+uid://n21uv0l8t8vf