@dcl-regenesislabs/bevy-explorer-web 0.1.0-18354928058.commit-b951631 → 0.1.0-18381724482.commit-d31fa29

package/assets/shaders/nishita_cloud.wgsl

@@ -1,378 +0,0 @@
-// 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

@@ -1,69 +0,0 @@
-#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;
-}

package/assets/shaders/simplex.wgsl

@@ -1,77 +0,0 @@
-// simplex noise
-fn simplex_noise_3d(v: vec3<f32>) -> f32 {
-    let C = vec2(1. / 6., 1. / 3.);
-    let D = vec4(0., 0.5, 1., 2.);
-
-    // first corner
-    var i = floor(v + dot(v, C.yyy));
-    let x0 = v - i + dot(i, C.xxx);
-
-    // other corners
-    let g = step(x0.yzx, x0.xyz);
-    let l = 1. - g;
-    let i1 = min(g.xyz, l.zxy);
-    let i2 = max(g.xyz, l.zxy);
-
-    // x0 = x0 - 0. + 0. * C
-    let x1 = x0 - i1 + 1. * C.xxx;
-    let x2 = x0 - i2 + 2. * C.xxx;
-    let x3 = x0 - 1. + 3. * C.xxx;
-
-    // permutations
-    i = i % vec3(289.);
-    let p = permute_4_(permute_4_(permute_4_(
-        i.z + vec4(0., i1.z, i2.z, 1.)) +
-        i.y + vec4(0., i1.y, i2.y, 1.)) +
-        i.x + vec4(0., i1.x, i2.x, 1.)
-    );
-
-    // gradients (NxN points uniformly over a square, mapped onto an octahedron)
-    let n_ = 1. / 7.; // N=7
-    let ns = n_ * D.wyz - D.xzx;
-
-    let j = p - 49. * floor(p * ns.z * ns.z); // mod(p, N*N)
-
-    let x_ = floor(j * ns.z);
-    let y_ = floor(j - 7. * x_); // mod(j, N)
-
-    let x = x_ * ns.x + ns.yyyy;
-    let y = y_ * ns.x + ns.yyyy;
-    let h = 1. - abs(x) - abs(y);
-
-    let b0 = vec4(x.xy, y.xy);
-    let b1 = vec4(x.zw, y.zw);
-
-    let s0 = floor(b0) * 2. + 1.;
-    let s1 = floor(b1) * 2. + 1.;
-    let sh = -step(h, vec4(0.));
-
-    let a0 = b0.xzyw + s0.xzyw * sh.xxyy;
-    let a1 = b1.xzyw + s1.xzyw * sh.zzww;
-
-    var p0 = vec3(a0.xy, h.x);
-    var p1 = vec3(a0.zw, h.y);
-    var p2 = vec3(a1.xy, h.z);
-    var p3 = vec3(a1.zw, h.w);
-
-    // normalize gradients
-    let norm = taylor_inv_sqrt_4_(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-    p0 = p0 * norm.x;
-    p1 = p1 * norm.y;
-    p2 = p2 * norm.z;
-    p3 = p3 * norm.w;
-
-    // mix final noise value
-    var m = 0.6 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3));
-    m = max(m, vec4(0.));
-    m *= m;
-    return 42. * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
-}
-
-fn permute_4_(x: vec4<f32>) -> vec4<f32> {
-    return ((x * 34. + 1.) * x) % vec4<f32>(289.);
-}
-
-fn taylor_inv_sqrt_4_(r: vec4<f32>) -> vec4<f32> {
-    return 1.79284291400159 - 0.85373472095314 * r;
-}

package/assets/shaders/stretch_uv_material.wgsl

@@ -1,79 +0,0 @@
-#import bevy_ui::ui_vertex_output::UiVertexOutput
-
-@group(1) @binding(0) var image_texture: texture_2d<f32>;
-@group(1) @binding(1) var image_sampler: sampler;
-@group(1) @binding(2) var<uniform> uvs: array<vec4<f32>,2>;
-@group(1) @binding(3) var<uniform> color: vec4<f32>;
-
-fn sd_rounded_box(point: vec2<f32>, size: vec2<f32>, corner_radii: vec4<f32>) -> f32 {
-    // If 0.0 < y then select bottom left (w) and bottom right corner radius (z).
-    // Else select top left (x) and top right corner radius (y).
-    let rs = select(corner_radii.xy, corner_radii.wz, 0.0 < point.y);
-    // w and z are swapped above so that both pairs are in left to right order, otherwise this second 
-    // select statement would return the incorrect value for the bottom pair.
-    let radius = select(rs.x, rs.y, 0.0 < point.x);
-    // Vector from the corner closest to the point, to the point.
-    let corner_to_point = abs(point) - 0.5 * size;
-    // Vector from the center of the radius circle to the point.
-    let q = corner_to_point + radius;
-    // Length from center of the radius circle to the point, zeros a component if the point is not 
-    // within the quadrant of the radius circle that is part of the curved corner.
-    let l = length(max(q, vec2(0.0)));
-    let m = min(max(q.x, q.y), 0.0);
-    return l + m - radius;
-}
-
-fn sd_inset_rounded_box(point: vec2<f32>, size: vec2<f32>, radius: vec4<f32>, inset: vec4<f32>) -> f32 {
-    let inner_size = size - inset.xy - inset.zw;
-    let inner_center = inset.xy + 0.5 * inner_size - 0.5 * size;
-    let inner_point = point - inner_center;
-
-    var r = radius;
-
-    // Top left corner.
-    r.x = r.x - max(inset.x, inset.y);
-
-    // Top right corner.
-    r.y = r.y - max(inset.z, inset.y);
-
-    // Bottom right corner.
-    r.z = r.z - max(inset.z, inset.w); 
-
-    // Bottom left corner.
-    r.w = r.w - max(inset.x, inset.w);
-
-    let half_size = inner_size * 0.5;
-    let min_size = min(half_size.x, half_size.y);
-
-    r = min(max(r, vec4(0.0)), vec4<f32>(min_size));
-
-    return sd_rounded_box(inner_point, inner_size, r);
-}
-
-fn draw(in: UiVertexOutput, color: vec4<f32>) -> vec4<f32> {
-    // Signed distances. The magnitude is the distance of the point from the edge of the shape.
-    // * Negative values indicate that the point is inside the shape.
-    // * Zero values indicate the point is on the edge of the shape.
-    // * Positive values indicate the point is outside the shape.
-
-    let point = (in.uv - vec2<f32>(0.5)) * in.size;
-
-    // Signed distance from the border's internal edge (the signed distance is negative if the point 
-    // is inside the rect but not on the border).
-    // If the border size is set to zero, this is the same as the external distance.
-    let internal_distance = -sd_inset_rounded_box(point, in.size, in.border_radius, in.border_widths);
-
-    let t = saturate(internal_distance + 1.0);
-
-    return vec4(color.rgb, saturate(color.a * t));
-}
-
-@fragment
-fn fragment(in: UiVertexOutput) -> @location(0) vec4<f32> {
-    // this is a bit lazy; really we should find a way to push the uvs directly into the vertex buffer
-    let uv = mix(mix(uvs[0].xy, uvs[1].zw, in.uv.x), mix(uvs[0].zw, uvs[1].xy, in.uv.x), 1.0 - in.uv.y) * vec2<f32>(1.0, -1.0) + vec2<f32>(0.0, 1.0);
-
-    let texture_color = textureSample(image_texture, image_sampler, uv) * color;
-    return draw(in, texture_color);
-    // return texture_color;
-}

package/assets/shaders/text_quad_vertex.wgsl

@@ -1,78 +0,0 @@
-#import bevy_pbr::{
-    mesh_functions,
-    view_transformations::position_world_to_clip,
-    pbr_bindings::base_color_texture,
-    mesh_view_bindings::view,
-}
-#import bevy_render::instance_index::get_instance_index
-
-#ifdef PREPASS_PIPELINE
-    #import bevy_pbr::prepass_io::{Vertex, VertexOutput};
-#else
-    #import bevy_pbr::forward_io::{Vertex, VertexOutput};
-#endif
-
-struct TextQuadData {
-    uvs: vec4<f32>,
-    valign: f32,
-    halign: f32,
-    pix_per_m: f32,
-    add_y_pix: f32,
-    vertex_billboard: u32,
-}
-
-@group(2) @binding(200)
-var<uniform> quad_data: TextQuadData;
-
-@vertex
-fn vertex(vertex_no_morph: Vertex) -> VertexOutput {
-    var out: VertexOutput;
-    var vertex = vertex_no_morph;
-
-    // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
-    // See https://github.com/gfx-rs/naga/issues/2416 .
-    var model = mesh_functions::get_world_from_local(vertex_no_morph.instance_index);
-
-    // we assume a quad with [-0.5, 0.5] bounds in x,y and 0 in z
-    // then we take the pixels per meter and texture size to determine where the vertices should lie
-    let tex_dims = textureDimensions(base_color_texture);
-    let region_dims = quad_data.uvs.zw - quad_data.uvs.xy;
-    let modified_vertex_position = vec3<f32>(
-        (vertex.position.x + quad_data.halign) * f32(region_dims.x) / quad_data.pix_per_m,
-        ((vertex.position.y + quad_data.valign) * f32(region_dims.y) + quad_data.add_y_pix) / quad_data.pix_per_m,
-        0.0
-    );
-
-    if (quad_data.vertex_billboard == 1u) {
-        out.world_position = mesh_functions::mesh_position_local_to_world(
-            mat4x4<f32>(
-                vec4<f32>(view.world_from_view[0].xyz, 0.0),
-                vec4<f32>(view.world_from_view[1].xyz, 0.0),
-                vec4<f32>(view.world_from_view[2].xyz, 0.0),
-                vec4<f32>(model[3].xyz, 1.0)
-            ), 
-            vec4<f32>(modified_vertex_position, 1.0)
-        );
-    } else {
-        out.world_position = mesh_functions::mesh_position_local_to_world(model, vec4<f32>(modified_vertex_position, 1.0));
-    }
-    out.position = position_world_to_clip(out.world_position.xyz);
-
-    out.uv = mix(quad_data.uvs.xy, quad_data.uvs.zw, vertex.uv) / vec2<f32>(tex_dims.xy);
-
-    // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
-    // See https://github.com/gfx-rs/naga/issues/2416
-    out.instance_index = vertex_no_morph.instance_index;
-
-
-#ifdef NORMAL_PREPASS_OR_DEFERRED_PREPASS
-    out.world_normal = mesh_functions::mesh_normal_local_to_world(
-        vertex.normal,
-        // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
-        // See https://github.com/gfx-rs/naga/issues/2416
-        vertex_no_morph.instance_index
-    );
-#endif // NORMAL_PREPASS_OR_DEFERRED_PREPASS
-
-    return out;
-}