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

package/assets/shaders/bound_node.wgsl

@@ -1,57 +0,0 @@
-#import bevy_ui::ui_vertex_output::UiVertexOutput
-#import bevy_render::view::View
-
-@group(0) @binding(0) var<uniform> view: View;
-
-struct Bounds {
-    bounds: vec4<f32>,
-    border_color: vec4<f32>,
-    edge_scale: vec4<f32>,
-    corner_size: f32,
-    corner_blend_size: f32,
-    border_size: 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> bounds_data: Bounds;
-@group(1) @binding(3) var<uniform> bg_color: vec4<f32>;
-
-fn edge_color(uv: vec2<f32>, position: vec4<f32>, in_color: vec4<f32>) -> vec4<f32> {
-    let corner_size = bounds_data.corner_size;
-    let bounds = bounds_data.bounds;
-    let edges = bounds_data.edge_scale;
-
-    let left = max(0.0, (bounds.x + corner_size) - position.x) * edges.x;
-    let right = max(0.0, position.x - (bounds.z - corner_size)) * edges.y;
-    let top = max(0.0, (bounds.y + corner_size) - position.y) * edges.z;
-    let bottom = max(0.0, position.y - (bounds.w - corner_size)) * edges.w;
-    let corner_dist_sq = max(left * left, right * right) + max(top * top, bottom * bottom);
-    let corner_end_size_sq = corner_size * corner_size;
-
-    if corner_dist_sq > corner_end_size_sq {
-        discard;
-    }
-
-    let edge_sq = max(corner_dist_sq, max(max(left * left, right * right), max(top * top, bottom * bottom)));
-    var out_color = in_color;
-    if bounds_data.border_size > 0.0 {
-        let border_start_size_sq = (corner_size - bounds_data.border_size) * (corner_size - bounds_data.border_size);
-        let border = 1.0 - clamp((edge_sq - border_start_size_sq) / (corner_end_size_sq - border_start_size_sq), 0.0, 1.0);
-        out_color = mix(bounds_data.border_color, out_color, border);
-    }
-
-    if bounds_data.corner_blend_size > 0.0 {
-        let corner_start_size_sq = (corner_size - bounds_data.corner_blend_size) * (corner_size - bounds_data.corner_blend_size);
-        let alpha = 1.0 - clamp((edge_sq - corner_start_size_sq) / (corner_end_size_sq - corner_start_size_sq), 0.0, 1.0);
-        out_color.a *= alpha;
-    }
-
-    return out_color;
-}
-
-@fragment
-fn fragment(in: UiVertexOutput) -> @location(0) vec4<f32> {
-    var color = textureSample(image_texture, image_sampler, in.uv) * bg_color;
-    return edge_color(in.uv, in.position, color);
-}

package/assets/shaders/bound_prepass.wgsl

@@ -1,160 +0,0 @@
-#import bevy_pbr::{
-    prepass_bindings,
-    prepass_io::{Vertex, VertexOutput, FragmentOutput},
-    mesh_view_bindings::{view, previous_view_proj},
-    pbr_fragment::pbr_input_from_standard_material,
-    pbr_prepass_functions::prepass_alpha_discard,
-}
-#import bevy_render::globals::Globals;
-
-#import "shaders/simplex.wgsl"::simplex_noise_3d
-
-@group(0) @binding(1) var<uniform> globals: Globals;
-
-struct Bounds {
-    min: u32,
-    max: u32,
-    height: f32,
-    _padding0: u32,
-}
-
-struct SceneBounds {
-    bounds: array<Bounds,8>,
-    distance: f32,
-    flags: u32,
-    num_bounds: u32,
-    _pad: 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));
-}
-
-@group(2) @binding(100)
-var<uniform> bounds: SceneBounds;
-
-
-#ifdef PREPASS_FRAGMENT
-@fragment
-fn fragment(
-    in: VertexOutput, 
-    @builtin(front_facing) is_front: bool
-) -> FragmentOutput {
-    var out: FragmentOutput;
-
-#ifdef NORMAL_PREPASS
-    out.normal = vec4(in.world_normal * 0.5 + vec3(0.5), 1.0);
-#endif
-
-#ifdef UNCLIPPED_DEPTH_ORTHO_EMULATION
-    out.frag_depth = in.unclipped_depth;
-#endif // UNCLIPPED_DEPTH_ORTHO_EMULATION
-
-#ifdef MOTION_VECTOR_PREPASS
-    let clip_position_t = view.unjittered_view_proj * in.world_position;
-    let clip_position = clip_position_t.xy / clip_position_t.w;
-    let previous_clip_position_t = prepass_bindings::previous_view_proj * in.previous_world_position;
-    let previous_clip_position = previous_clip_position_t.xy / previous_clip_position_t.w;
-    // These motion vectors are used as offsets to UV positions and are stored
-    // in the range -1,1 to allow offsetting from the one corner to the
-    // diagonally-opposite corner in UV coordinates, in either direction.
-    // A difference between diagonally-opposite corners of clip space is in the
-    // range -2,2, so this needs to be scaled by 0.5. And the V direction goes
-    // down where clip space y goes up, so y needs to be flipped.
-    out.motion_vector = (clip_position - previous_clip_position) * vec2(0.5, -0.5);
-#endif // MOTION_VECTOR_PREPASS
-
-#ifdef DEFERRED_PREPASS
-    // There isn't any material info available for this default prepass shader so we are just writing 
-    // emissive magenta out to the deferred gbuffer to be rendered by the first deferred lighting pass layer.
-    // The is here so if the default prepass fragment is used for deferred magenta will be rendered, and also
-    // as an example to show that a user could write to the deferred gbuffer if they were to start from this shader.
-    out.deferred = vec4(0u, bevy_pbr::rgb9e5::vec3_to_rgb9e5_(vec3(1.0, 0.0, 1.0)), 0u, 0u);
-    out.deferred_lighting_pass_id = 1u;
-#endif
-
-    let world_position = in.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 bounds.num_bounds > 0 {
-        for (var ix = 0u; ix < bounds.num_bounds; ix += 1u) {
-            let min_wp = unpack_bounds(bounds.bounds[ix].min);
-            let max_wp = unpack_bounds(bounds.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 = bounds.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.0;
-    if outside_amt > 0.0 {
-        if outside_amt < bounds.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;
-        }
-    }
-
-    prepass_alpha_discard(in);
-
-    return out;
-}
-#else // !PREPASS_FRAGMENT (?)
-@fragment
-fn fragment(in: VertexOutput) {
-    let world_position = in.world_position.xyz;
-    var outside_amt: f32 = 9999.0;
-    var nearest_region_distance: f32 = 9999.0;
-    var nearest_region_height: f32 = 9999.0;
-    if bounds.num_bounds > 0 {
-        for (var ix = 0u; ix < bounds.num_bounds; ix += 1u) {
-            let min_wp = unpack_bounds(bounds.bounds[ix].min);
-            let max_wp = unpack_bounds(bounds.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 = bounds.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.0;
-    if outside_amt > 0.0 {
-        if outside_amt < bounds.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;
-        }
-    }
-    
-    prepass_alpha_discard(in);
-}
-#endif // PREPASS_FRAGMENT

package/assets/shaders/floor_bake.wgsl

@@ -1,30 +0,0 @@
-#import boimp::shared::{ImposterVertexOut, unpack_pbrinput, pack_pbrinput};
-#import boimp::bindings::sample_tile_material;
-
-@group(2) @binding(100)
-var<uniform> offset: f32;
-
-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>,
-}
-
-@fragment
-fn fragment(in: VertexOut) -> @location(0) vec2<u32> {
-    let inv_rot = mat3x3(
-        in.inverse_rotation_0c,
-        in.inverse_rotation_1c,
-        in.inverse_rotation_2c,
-    );
-
-    var props = sample_tile_material(vec4<f32>(clamp(in.uv, vec2(0.0001), vec2(17.0/18.0 - 0.0001)), vec2<f32>(0.0)), vec2(0u,0u), vec2(offset, offset));
-    var pbr_input = unpack_pbrinput(props, in.position);
-    pbr_input.N = inv_rot * normalize(pbr_input.N);
-    pbr_input.world_normal = pbr_input.N;
-
-    // write the imposter gbuffer
-    return pack_pbrinput(pbr_input);
-}

package/assets/shaders/floor_fragment.wgsl

@@ -1,74 +0,0 @@
-#import bevy_pbr::{
-    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
-    pbr_types::{STANDARD_MATERIAL_FLAGS_ALPHA_MODE_ADD, STANDARD_MATERIAL_FLAGS_FOG_ENABLED_BIT},
-}
-
-#ifdef PREPASS_PIPELINE
- #import bevy_pbr::prepass_io::FragmentOutput;
-#else
- #import bevy_pbr::forward_io::FragmentOutput;
-#endif
-
-#import boimp::shared::unpack_pbrinput;
-#import boimp::bindings::sample_tile_material;
-
-@group(2) @binding(100)
-var<uniform> offset: f32;
-
-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>,
-}
-
-@fragment
-fn fragment(in: VertexOut) -> FragmentOutput {
-    var out: FragmentOutput;
-
-#ifdef PREPASS_PIPELINE
-
-    #ifdef NORMAL_PREPASS
-        out.normal = vec4<f32>(0.0, 1.0, 0.0, 0.0);
-    #endif
-    // we don't support MOTION_VECTOR or DEFERRED
-    #ifdef UNCLIPPED_DEPTH_ORTHO_EMULATION
-        out.frag_depth = in.position.z;
-    #endif
-
-#else 
-
-    let inv_rot = mat3x3(
-        in.inverse_rotation_0c,
-        in.inverse_rotation_1c,
-        in.inverse_rotation_2c,
-    );
-
-    var props = sample_tile_material(vec4<f32>(clamp(in.uv, vec2(0.0001), vec2(17.0/18.0 - 0.0001)), vec2<f32>(0.0)), vec2(0u,0u), vec2(offset, offset));
-
-    if props.rgba.a == 0.0 {
-        // hacky - we are using opaque to ensure imposters render above the floor
-        // so we have to put the ground color here
-        // todo use some nice 
-        props.rgba = vec4<f32>(0.07323897, 0.17064494, 0.033104762, 1.0);
-        props.roughness = 1.0;
-        props.metallic = 0.0;
-        props.normal = vec3<f32>(0.0, 1.0, 0.0);
-    }
-
-    props.rgba.a = 1.0;
-
-    var pbr_input = unpack_pbrinput(props, in.position);
-    pbr_input.N = inv_rot * normalize(pbr_input.N);
-    pbr_input.world_normal = pbr_input.N;
-    pbr_input.material.flags |= STANDARD_MATERIAL_FLAGS_ALPHA_MODE_ADD;
-    out.color = apply_pbr_lighting(pbr_input);
-
-    pbr_input.material.flags |= STANDARD_MATERIAL_FLAGS_FOG_ENABLED_BIT;
-    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
-
-#endif
-
-    return out;
-}

package/assets/shaders/floor_vertex.wgsl

@@ -1,47 +0,0 @@
-#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

@@ -1,35 +0,0 @@
-#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

@@ -1,117 +0,0 @@
-#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

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