@dcl-regenesislabs/bevy-explorer-web 0.1.0-18229784557.commit-ef374b9

package/assets/shaders/floor_vertex.wgsl

@@ -0,0 +1,47 @@
+#import bevy_pbr::{
+    mesh_functions,
+    view_transformations::{position_world_to_clip, position_view_to_world},
+}
+
+#ifdef PREPASS_PIPELINE
+    #import bevy_pbr::prepass_io::Vertex;
+#else
+    #import bevy_pbr::forward_io::Vertex;
+#endif
+
+#import boimp::shared::ImposterVertexOut;
+#import boimp::bindings::{imposter_data, sample_uvs_unbounded, grid_weights, sample_positions_from_camera_dir};
+
+struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) inverse_rotation_0c: vec3<f32>,
+    @location(1) inverse_rotation_1c: vec3<f32>,
+    @location(2) inverse_rotation_2c: vec3<f32>,
+    @location(3) uv: vec2<f32>,
+}
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOut {
+    var out: VertexOut;
+
+    var model = mesh_functions::get_world_from_local(vertex.instance_index);
+
+    let imposter_world_position = mesh_functions::mesh_position_local_to_world(model, vec4<f32>(0.0, 0.0, 0.0, 1.0)).xyz;
+
+    // extract inverse rotation
+    let inv_rot = transpose(mat3x3<f32>(
+        normalize(model[0].xyz),
+        normalize(model[1].xyz),
+        normalize(model[2].xyz)
+    ));
+
+    out.inverse_rotation_0c = inv_rot[0];
+    out.inverse_rotation_1c = inv_rot[1];
+    out.inverse_rotation_2c = inv_rot[2];
+
+    let world_position = mesh_functions::mesh_position_local_to_world(model, vec4<f32>(vertex.position, 1.0)).xyz;
+    out.position = position_world_to_clip(world_position);
+    out.uv = vertex.uv;
+
+    return out;
+}

package/assets/shaders/loading.wgsl

@@ -0,0 +1,35 @@
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    mesh_view_bindings::globals,
+}
+#import "shaders/simplex.wgsl"::simplex_noise_3d
+
+struct LoadingData {
+    player_pos_and_render: vec4<f32>,
+}
+
+@group(2) @binding(0)
+var<uniform> material: LoadingData;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+) -> FragmentOutput {
+    if material.player_pos_and_render.a == 0.0 {
+        discard;
+    }
+
+    let world_position = in.world_position.xyz;
+    let offset = world_position - material.player_pos_and_render.xyz;
+
+    let noise = simplex_noise_3d(world_position * 2.0 + globals.time * vec3(0.2, 0.16, 0.24)) * 0.5 + 0.5;
+
+    if noise > 0.5 {
+        discard;
+    }
+
+    var out: FragmentOutput;
+    out.color = vec4<f32>(noise, noise * 10.0, noise, pow((1.0 - clamp(dot(offset, offset) * 0.03, 0.0, 1.0)), 2.0));
+    return out;
+}

package/assets/shaders/mask_material.wgsl

@@ -0,0 +1,117 @@
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_fragment::pbr_input_from_vertex_output,
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+    mesh_view_bindings::globals,
+}
+#import "shaders/simplex.wgsl"::simplex_noise_3d
+#import "shaders/outline.wgsl"::apply_outline
+
+struct Bounds {
+    min: u32,
+    max: u32,
+    height: f32,
+    _padding0: u32,
+}
+
+fn unpack_bounds(packed: u32) -> vec2<f32> {
+    let x = i32((packed >> 16) & 0xFFFF);
+    let x_signed = select(x, x - 0x10000, (x & 0x8000) != 0);
+    let y = i32(packed & 0xFFFF);
+    let y_signed = select(y, y - 0x10000, (y & 0x8000) != 0);
+    return vec2<f32>(f32((x_signed) * 16), f32((y_signed) * 16));
+}
+
+struct MaskMaterial {
+    bounds: array<Bounds,8>,
+    color: vec4<f32>,
+    distance: f32,
+    num_bounds: u32,
+};
+
+@group(2) @binding(0)
+var<uniform> material: MaskMaterial;
+@group(2) @binding(1)
+var base_texture: texture_2d<f32>;
+@group(2) @binding(2)
+var base_sampler: sampler;
+@group(2) @binding(3)
+var mask_texture: texture_2d<f32>;
+@group(2) @binding(4)
+var mask_sampler: sampler;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+#ifdef MULTISAMPLED
+    @builtin(sample_index) sample_index: u32,
+#endif
+) -> FragmentOutput {
+#ifndef MULTISAMPLED
+    let sample_index = 0u;
+#endif
+
+    var pbr_input = pbr_input_from_vertex_output(in, is_front, false);
+
+    let world_position = pbr_input.world_position.xyz;
+    // check bounds
+    var outside_amt: f32 = 9999.0;
+    var nearest_region_distance: f32 = 9999.0;
+    var nearest_region_height: f32 = 9999.0;
+    if material.num_bounds > 0 {
+        for (var ix = 0u; ix < material.num_bounds; ix += 1u) {
+            let min_wp = unpack_bounds(material.bounds[ix].min);
+            let max_wp = unpack_bounds(material.bounds[ix].max);
+
+            let outside_xy = abs(clamp(world_position.xz, min_wp, max_wp) - world_position.xz);
+            let distance = max(outside_xy.x, outside_xy.y);
+            if distance < nearest_region_distance {
+                nearest_region_distance = distance;
+                nearest_region_height = material.bounds[ix].height;
+            }
+            outside_amt = min(outside_amt, distance);
+        }
+        let outside_height = max(world_position.y - nearest_region_height, 0.0);
+        outside_amt = max(outside_amt, outside_height);
+    } else {
+        outside_amt = 0.0;
+    }
+
+    var noise = 0.05;
+    if outside_amt > 0.00 {
+        if outside_amt < material.distance {
+            noise = simplex_noise_3d(world_position * 2.0 + globals.time * vec3(0.2, 0.16, 0.24)) * 0.5 + 0.55;
+            if noise < (outside_amt - 0.125) / 2.0 {
+                discard;
+            }
+        } else if outside_amt > 0.05 {
+            discard;
+        }
+    }
+
+    let mask = textureSample(mask_texture, mask_sampler, in.uv);
+    let base = textureSample(base_texture, base_sampler, in.uv);
+    let color_amt = mask.r * mask.a;
+
+    let color = mix(material.color, vec4<f32>(1.0), color_amt) * base;
+
+    pbr_input.material.base_color = color;
+
+    var out: FragmentOutput;
+    // apply lighting
+    out.color = apply_pbr_lighting(pbr_input);
+
+    out.color = apply_outline(
+        in.position,
+        out.color, 
+        false,
+        sample_index,
+    );
+
+    // apply in-shader post processing (fog, alpha-premultiply, and also tonemapping, debanding if the camera is non-hdr)
+    // note this does not include fullscreen postprocessing effects like bloom.
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+
+    return out;
+}

package/assets/shaders/nineslice_material.wgsl

@@ -0,0 +1,47 @@
+#import bevy_ui::ui_vertex_output::UiVertexOutput
+
+struct SliceData {
+    bounds: vec4<f32>,
+    surface: vec4<f32>,
+}
+
+@group(1) @binding(0) var image_texture: texture_2d<f32>;
+@group(1) @binding(1) var image_sampler: sampler;
+@group(1) @binding(2) var<uniform> slice_data: SliceData;
+@group(1) @binding(3) var<uniform> bg_color: vec4<f32>;
+
+@fragment
+fn fragment(in: UiVertexOutput) -> @location(0) vec4<f32> {
+    var uv = in.uv;
+    let image_size = vec2<f32>(textureDimensions(image_texture));
+    let border_size = vec2<f32>(slice_data.bounds.x + slice_data.bounds.z, slice_data.bounds.y + slice_data.bounds.z);
+    let position = in.uv * slice_data.surface.xy;
+
+    if slice_data.surface.x > image_size.x {
+        let left = slice_data.bounds.x - position.x;
+        let right = position.x - (slice_data.surface.x - slice_data.bounds.z);
+
+        if left > 0.0 && left > right {
+            uv.x = position.x / image_size.x;
+        } else if right > 0.0 {
+            uv.x = 1.0 - (slice_data.surface.x - position.x) / image_size.x;
+        } else {
+            uv.x = ((position.x - slice_data.bounds.x) / (slice_data.surface.x - border_size.x) * (image_size.x - border_size.x) + slice_data.bounds.x) / image_size.x;
+        }
+    }
+
+    if slice_data.surface.y > image_size.y {
+        let top = slice_data.bounds.y - position.y;
+        let bottom = position.y - (slice_data.surface.y - slice_data.bounds.w);
+        
+        if top > 0.0 && top > bottom {
+            uv.y = position.y / image_size.y;
+        } else if bottom > 0.0 {
+            uv.y = 1.0 - (slice_data.surface.y - position.y) / image_size.y;
+        } else {
+            uv.y = ((position.y - slice_data.bounds.y) / (slice_data.surface.y - border_size.y) * (image_size.y - border_size.y) + slice_data.bounds.y) / image_size.y;
+        }
+    }
+
+    return textureSample(image_texture, image_sampler, uv) * bg_color;
+}

package/assets/shaders/nishita_cloud.wgsl

@@ -0,0 +1,378 @@
+// cloud sampling:
+
+// find cloud_floor intersection
+// step through
+// at each point
+//   sample once based on xy only -> take as density at lo + 0.25 * (hi-lo)
+//   sample again based on xy only -> take as density at lo + 0.75 * (hi-lo)
+//   smooth step to get actual density at point
+
+struct Nishita {
+    ray_origin: vec3<f32>,
+    sun_position: vec3<f32>,
+    sun_intensity: f32,
+    planet_radius: f32,
+    atmosphere_radius: f32,
+    rayleigh_coefficient: vec3<f32>,
+    rayleigh_scale_height: f32,
+    mie_coefficient: f32,
+    mie_scale_height: f32,
+    mie_direction: f32,
+    time: f32,
+    cloudy: f32,
+    tick: u32,
+    sun_color: vec3<f32>,
+    dir_light_intensity: f32,
+}
+
+const PI: f32 = 3.141592653589793;
+const ISTEPS: u32 = 16u;
+const JSTEPS: u32 = 8u;
+
+fn rsi(rd: vec3<f32>, r0: vec3<f32>, sr: f32) -> vec2<f32> {
+    // ray-sphere intersection that assumes
+    // the sphere is centered at the origin.
+    // No intersection when result.x > result.y
+    let a = dot(rd, rd);
+    let b = 2.0 * dot(rd, r0);
+    let c = dot(r0, r0) - (sr * sr);
+    let d = (b * b) - (4.0 * a * c);
+
+    if d < 0.0 {
+        return vec2<f32>(1e5, -1e5);
+    } else {
+        return vec2<f32>(
+            (-b - sqrt(d)) / (2.0 * a),
+            (-b + sqrt(d)) / (2.0 * a)
+        );
+    }
+}
+
+fn render_nishita(r_full: vec3<f32>, r0: vec3<f32>, p_sun_full: vec3<f32>, i_sun: f32, r_planet: f32, r_atmos: f32, k_rlh: vec3<f32>, k_mie: f32, sh_rlh: f32, sh_mie: f32, g: f32) -> vec3<f32> {
+    // Normalize the ray direction and sun position.
+    let r = normalize(r_full);
+    let p_sun = normalize(p_sun_full);
+
+    // Calculate the step size of the primary ray.
+    var p = rsi(r, r0, r_atmos);
+    if p.x > p.y { return vec3<f32>(0f); }
+    p.y = min(p.y, rsi(r, r0, r_planet).x);
+    let i_step_size = (p.y - p.x) / f32(ISTEPS);
+
+    // Initialize the primary ray depth.
+    var i_depth = 0.0;
+
+    // Initialize accumulators for Rayleigh and Mie scattering.
+    var total_rlh = vec3<f32>(0f);
+    var total_mie = vec3<f32>(0f);
+
+    // Initialize optical depth accumulators for the primary ray.
+    var i_od_rlh = 0f;
+    var i_od_mie = 0f;
+
+    // Calculate the Rayleigh and Mie phases.
+    let mu = dot(r, p_sun);
+    let mumu = mu * mu;
+    let gg = g * g;
+    let p_rlh = 3.0 / (16.0 * PI) * (1.0 + mumu);
+    let p_mie = 3.0 / (8.0 * PI) * ((1.0 - gg) * (mumu + 1.0)) / (pow(1.0 + gg - 2.0 * mu * g, 1.5) * (2.0 + gg));
+
+    // Sample the primary ray.
+    for (var i = 0u; i < ISTEPS; i++) {
+        // Calculate the primary ray sample position.
+        let i_pos = r0 + r * (i_depth + i_step_size * 0.5);
+
+        // Calculate the height of the sample.
+        let i_height = length(i_pos) - r_planet;
+
+        // Calculate the optical depth of the Rayleigh and Mie scattering for this step.
+        let od_step_rlh = exp(-i_height / sh_rlh) * i_step_size;
+        let od_step_mie = exp(-i_height / sh_mie) * i_step_size;
+
+        // Accumulate optical depth.
+        i_od_rlh += od_step_rlh;
+        i_od_mie += od_step_mie;
+
+        // Calculate the step size of the secondary ray.
+        let j_step_size = rsi(p_sun, i_pos, r_atmos).y / f32(JSTEPS);
+
+        // Initialize the secondary ray depth.
+        var j_depth = 0f;
+
+        // Initialize optical depth accumulators for the secondary ray.
+        var j_od_rlh = 0f;
+        var j_od_mie = 0f;
+
+        // Sample the secondary ray.
+        for (var j = 0u; j < JSTEPS; j++) {
+
+            // Calculate the secondary ray sample position.
+            let j_pos = i_pos + p_sun * (j_depth + j_step_size * 0.5);
+
+            // Calculate the height of the sample.
+            let j_height = length(j_pos) - r_planet;
+
+            // Accumulate the optical depth.
+            j_od_rlh += exp(-j_height / sh_rlh) * j_step_size;
+            j_od_mie += exp(-j_height / sh_mie) * j_step_size;
+
+            // Increment the secondary ray depth.
+            j_depth += j_step_size;
+        }
+
+        // Calculate attenuation.
+        let attn = exp(-(k_mie * (i_od_mie + j_od_mie) + k_rlh * (i_od_rlh + j_od_rlh)));
+
+        // Accumulate scattering.
+        total_rlh += od_step_rlh * attn;
+        total_mie += od_step_mie * attn;
+
+        // Increment the primary ray depth.
+        i_depth += i_step_size;
+    }
+
+    // Calculate and return the final color.
+    return i_sun * (p_rlh * k_rlh * total_rlh + p_mie * k_mie * total_mie);
+}
+
+@group(0) @binding(0) var<uniform> nishita: Nishita;
+@group(0) @binding(1) var noise_texture: texture_2d<f32>;
+@group(0) @binding(2) var noise_sampler: sampler;
+
+const CLOUD_LOWER: f32 = 3300.0;
+const CLOUD_UPPER: f32 = 4800.0;
+
+fn noise(x: vec2<f32>) -> f32 {
+    return textureSampleLevel(noise_texture, noise_sampler, x / 65536.0, 0.0).r;
+}
+
+const m: mat3x3<f32> = mat3x3<f32>( 0.00,  0.80,  0.60,
+                                   -0.80,  0.36, -0.48,
+                                   -0.60, -0.48,  0.64 ) * 2.345;
+
+fn FBM(p0: vec3<f32>) -> f32 {
+	var p = p0;
+
+    let speed = 2.0;
+
+    p.x += nishita.time * 3.0 * speed;
+	
+	var f = 0.3750 * noise(p.xz); p = m*p; p.y -= nishita.time * 20.0 * speed;
+	f += 0.3750   * noise(p.xz); p = m*p; p.y += nishita.time * 10.0 * speed;
+	f += 0.1250   * noise(p.xz); p = m*p; p.x -= nishita.time * 10.0 * speed;
+	f += 0.0625   * noise(p.xz); p = m*p;
+	f += 0.03125  * noise(p.xz); p = m*p;
+	f += 0.015625 * noise(p.xz);
+    return f;
+}
+
+fn cloudy() -> f32 {
+    return (nishita.cloudy - 0.5) * 0.666;
+}
+
+fn density(p: vec3<f32>) -> f32 {
+	let density = clamp(FBM(p) * 0.5 + cloudy(), 0.0, 1.0);
+    let cloud_range = CLOUD_UPPER - CLOUD_LOWER;
+    let outside = clamp(abs(clamp(p.y, CLOUD_LOWER + 0.1 * cloud_range, CLOUD_UPPER - 0.1 * cloud_range) - p.y) / (0.1 * cloud_range), 0.0, 1.0);
+    return mix(density, 0.0, outside);
+}
+
+fn lighting(p: vec3<f32>, dir: vec3<f32>, sun: vec3<f32>) -> f32 {
+    let l = density(p + sun * 400.0);
+    return clamp(pow(l, 0.25), 0.0, 1.0);
+}
+
+const STEPS: u32 = 20u;
+
+fn render_cloud(sky: vec3<f32>, pos: vec3<f32>, dir: vec3<f32>) -> vec3<f32> {
+    let p_sun = normalize(nishita.sun_position);
+    let sun_amount: f32 = max(dot(dir, p_sun), 0.0);
+
+	var low = ((CLOUD_LOWER-pos.y) / dir.y);
+	let high = ((CLOUD_UPPER-pos.y) / dir.y);
+	    
+    var p = pos + dir * low;
+
+    var d = 0.0;
+    let add = dir * ((high - low) / f32(STEPS));
+    var shade_sum: vec2<f32> = vec2<f32>(0.0);
+
+    let step_length = length(add);
+
+    let density_cap = 0.8;
+    for (var i = 0u; i < STEPS; i += 1u) {
+        if shade_sum.y >= density_cap {
+            break;
+        }
+
+        let base_density = clamp(cloudy(), 0.0, 1.0);
+        let base_light = pow(base_density, 0.25) * base_density;
+
+        let sample_density = density(p);
+        let sample_light = lighting(p, dir, p_sun) * sample_density;
+
+        let density = mix(sample_density, base_density, clamp(length(p.xz) / 100000.0, 0.0, 1.0));
+        let light = mix(sample_light, base_light, clamp(length(p.xz) / 100000.0, 0.0, 1.0));
+
+        shade_sum += vec2<f32>(light, density) * (vec2<f32>(1.0) - shade_sum.y);
+        p += add;
+    }
+
+    shade_sum /= max(shade_sum.y, density_cap);
+
+    let light_cloud_color_indirect = max(vec3(0.05), saturate(nishita.sun_color * 1.5) * min(1.0, nishita.dir_light_intensity / 5000.0));
+    let light_cloud_color_direct = max(vec3(0.05), saturate(nishita.sun_color * 1.5) * min(nishita.dir_light_intensity / 1000.0, 4.0));
+    let light_cloud_color = mix(light_cloud_color_indirect, light_cloud_color_direct, pow(smoothstep(0.8 + (0.1 * shade_sum.y), 1.0, sun_amount), 5.0));
+    shade_sum.y = mix(shade_sum.y, sqrt(shade_sum.y), smoothstep(0.9, 1.0, sun_amount));
+
+    let clouds = mix(light_cloud_color, vec3(0.05), pow(shade_sum.x, 3.0));
+    let result = mix(sky, min(clouds, vec3<f32>(1.0)), shade_sum.y);
+    return clamp(result, vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+@group(1) @binding(0)
+var image: texture_storage_2d_array<rgba16float, write>;
+
+fn hash13(p: vec3<f32>) -> f32 {
+    // A common simple hash function
+    var p3 = fract(p * vec3<f32>(0.1031, 0.1030, 0.0973));
+    p3 = p3 + dot(p3, p3.yzx + 19.19);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) original_invocation_id: vec3<u32>, @builtin(num_workgroups) num_workgroups: vec3<u32>) {
+    let size = textureDimensions(image).x;
+    let scale = f32(size) / 2f;
+
+    // dither pattern for updates
+    let tick = nishita.tick & 63;
+
+    var UPDATE_OFFSETS_X: array<u32,64> = array<u32,64>(
+        0u, 4u, 4u, 0u, 2u, 6u, 6u, 2u, 2u, 6u, 6u, 2u, 0u, 4u, 4u, 0u,
+        1u, 5u, 5u, 1u, 3u, 7u, 7u, 3u, 3u, 7u, 7u, 3u, 1u, 5u, 5u, 1u,
+        1u, 5u, 5u, 1u, 3u, 7u, 7u, 3u, 3u, 7u, 7u, 3u, 1u, 5u, 5u, 1u,
+        0u, 4u, 4u, 0u, 2u, 6u, 6u, 2u, 2u, 6u, 6u, 2u, 0u, 4u, 4u, 0u
+    );
+
+    var UPDATE_OFFSETS_Y: array<u32,64> = array<u32,64>(
+        0u, 4u, 0u, 4u, 2u, 6u, 2u, 6u, 0u, 4u, 0u, 4u, 2u, 6u, 2u, 6u,
+        1u, 5u, 1u, 5u, 3u, 7u, 3u, 7u, 1u, 5u, 1u, 5u, 3u, 7u, 3u, 7u,
+        4u, 0u, 4u, 0u, 6u, 2u, 6u, 2u, 4u, 0u, 4u, 0u, 6u, 2u, 6u, 2u,
+        5u, 1u, 5u, 1u, 7u, 3u, 7u, 3u, 5u, 1u, 5u, 1u, 7u, 3u, 7u, 3u
+    );
+
+    let invocation_id = original_invocation_id * vec3(8, 8, 1) + vec3(UPDATE_OFFSETS_X[tick], UPDATE_OFFSETS_Y[tick], 0);
+
+    let dir = vec2<f32>((f32(invocation_id.x) / scale) - 1f, (f32(invocation_id.y) / scale) - 1f);
+
+    var ray: vec3<f32>;
+
+    switch invocation_id.z {
+        case 0u {
+            ray = vec3<f32>(1f, -dir.y, -dir.x); // +X
+        }
+        case 1u {
+            ray = vec3<f32>(-1f, -dir.y, dir.x);// -X
+        }
+        case 2u {
+            ray = vec3<f32>(dir.x, 1f, dir.y); // +Y
+        }
+        case 3u {
+            ray = vec3<f32>(dir.x, -1f, -dir.y);// -Y
+        }
+        case 4u {
+            ray = vec3<f32>(dir.x, -dir.y, 1f); // +Z
+        }
+        default: {
+            ray = vec3<f32>(-dir.x, -dir.y, -1f);// -Z
+        }
+    }
+
+    var initial_y = normalize(ray).y;
+    if ray.y < 0.0 {
+        ray.y = 0.0;
+    }
+    ray = normalize(ray);
+
+
+    var render_base = vec3<f32>(0.0);
+
+    let fwd = normalize(nishita.sun_position);
+    let basis_u = vec3<f32>(0.0, sign(nishita.sun_position.z), 0.0);
+    let right = normalize(cross(basis_u, fwd));
+    let up = normalize(cross(fwd, right));
+    let sun_transform = mat3x3(right, up, fwd);
+
+    let multiplier = 1.0 + saturate(nishita.dir_light_intensity / 11000.0);
+
+    if nishita.dir_light_intensity > 0.0 {
+        render_base = render_nishita(
+            ray,
+            nishita.ray_origin,
+            nishita.sun_position,
+            nishita.sun_intensity * multiplier,
+            nishita.planet_radius,
+            nishita.atmosphere_radius,
+            nishita.rayleigh_coefficient,
+            nishita.mie_coefficient,
+            nishita.rayleigh_scale_height,
+            nishita.mie_scale_height,
+            nishita.mie_direction,
+        );
+
+
+        // // add sun
+        let sun_weight = dot(ray, normalize(nishita.sun_position));
+        if sun_weight >= 0.997 {
+            render_base = max(render_base, mix(render_base, nishita.sun_color, smoothstep(0.997, 0.999, sun_weight)));
+        }
+        // sun 2 ..
+        let angle = 0.3;
+        let cosa = cos(angle);
+        let sina = sin(angle);
+        let sun_weight_2 = dot(ray, normalize(nishita.sun_position - vec3(0.3, 0.3, 0.3)));
+        if sun_weight_2 >= 0.998 {
+            render_base = max(render_base, mix(render_base, nishita.sun_color, smoothstep(0.999, 1.0, sun_weight_2)));
+        }
+    }
+
+    // stars
+    if nishita.dir_light_intensity < 1000.0 {
+        for (var i=0u; i<1000u; i++) {
+            let star_world_dir = normalize(
+                vec3<f32>(
+                    hash13(vec3::<f32>(17.5, 19.2, -888.2) * f32(i)), 
+                    hash13(vec3::<f32>(117.5, 19.2, -888.2) * f32(i)), 
+                    abs(hash13(vec3::<f32>(217.5, 19.2, -888.2) * f32(i)))
+                ) * 2.0 - 1.0
+            );
+            let star_dir = sun_transform * star_world_dir;
+            let stardirdot = dot(normalize(star_dir), ray);
+            let hash = hash13(star_world_dir);
+            // size range should vary based on resolution of the cubemap
+            let size = 0.99995 + 0.000025 * pow(fract(hash * 100000.0), 0.25);
+            if stardirdot > size {
+                let color = vec3<f32>(0.25 + 0.75 * fract(hash * 1000.0), 0.625 + 0.375 * fract(hash * 1000.0), 1.0);
+                let brightness = smoothstep(0.99995 + 0.000025, 0.99995, size);
+                render_base += vec3<f32>(
+                    color 
+                    * clamp(1.0 - nishita.dir_light_intensity / 1000.0, 0.0, 1.0)) // sun brightness
+                    * brightness // star brightness
+                    * pow(smoothstep(size, 1.0, stardirdot), 3.0)  // distance from middle of the star
+                    * clamp(ray.y * 10.0, 0.0, 1.0); // distance above horizon
+            }
+        }
+    }
+
+    let render = render_cloud(render_base, nishita.ray_origin * 0.0, normalize(ray));
+
+    let store_value = mix(render, vec3(0.0), smoothstep(0.0, -0.5, initial_y));
+
+    textureStore(
+        image,
+        vec2<i32>(invocation_id.xy),
+        i32(invocation_id.z),
+        vec4<f32>(store_value, 1.0)
+    );
+}

package/assets/shaders/outline.wgsl

@@ -0,0 +1,69 @@
+#import bevy_pbr::{
+    pbr_types::STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT,
+    mesh_view_bindings::view,
+    prepass_utils::{prepass_depth, prepass_normal},
+    pbr_types,
+}
+
+#ifdef DEPTH_PREPASS
+fn get_depth(pos: vec4<f32>, si: u32) -> f32 {
+    return view.clip_from_view[3][2] / prepass_depth(pos, si); 
+}
+#endif
+
+fn apply_outline(position: vec4<f32>, color_in: vec4<f32>, hilight: bool, sample_index: u32) -> vec4<f32> {
+    var out = color_in;
+#ifdef DEPTH_PREPASS
+
+    var edge1 = false;
+    var edge2 = false;
+
+    let is_orthographic = view.clip_from_view[3].w == 1.0;
+    var mid = 0.0;
+    if is_orthographic {
+        mid = 2.0 / view.clip_from_view[1].y;
+    } else {
+        mid = get_depth(position, sample_index);
+    }
+    let width = (1.0 / mid) * view.viewport.z / 640.0;
+    let d = clamp(width, 1.0, 5.0);
+
+    let pxpy = get_depth(position + vec4<f32>(d, d, 0.0, 0.0), sample_index);
+    let pxmy = get_depth(position + vec4<f32>(d, -d, 0.0, 0.0), sample_index);
+    let mxpy = get_depth(position + vec4<f32>(-d, d, 0.0, 0.0), sample_index);
+    let mxmy = get_depth(position + vec4<f32>(-d, -d, 0.0, 0.0), sample_index);
+
+    let expected = (pxpy + pxmy + mxpy + mxmy) / 4.0;
+
+    if (expected / mid - 1) > 0.03 {
+        edge1 = true;
+    }
+
+#ifdef NORMAL_PREPASS
+    let nd = 1.0;
+    let nmid = prepass_normal(position, sample_index);
+    let npxpy = prepass_normal(position + vec4<f32>(nd, nd, 0.0, 0.0), sample_index);
+    let npxmy = prepass_normal(position + vec4<f32>(nd, -nd, 0.0, 0.0), sample_index);
+    let nmxpy = prepass_normal(position + vec4<f32>(-nd, nd, 0.0, 0.0), sample_index);
+    let nmxmy = prepass_normal(position + vec4<f32>(-nd, -nd, 0.0, 0.0), sample_index);        
+
+    let nexpected = (npxpy + nmxmy) / 2.0;
+    let nexpected2 = (npxmy + nmxpy) / 2.0;
+    if length(nmid - nexpected) + length(nmid - nexpected2) > 0.4 {
+        edge2 = true;
+    }
+#endif
+
+    var hi = 0.0;
+    if hilight {
+        hi = 1.0;
+    }
+    if edge1 {
+        out = vec4<f32>(10.0 * hi, 0.0, 0.0, out.a);
+    } else if edge2 {
+        out = vec4<f32>(out.rgb * vec3<f32>(4.5 * hi + 0.5, 0.5, 0.5), out.a);
+    }
+#endif
+
+return out;
+}