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

package/assets/shaders/bound_material.wgsl

@@ -0,0 +1,183 @@
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::{SampleBias, alpha_discard, apply_pbr_lighting, main_pass_post_lighting_processing},
+    pbr_bindings::{material, emissive_texture, emissive_sampler},
+    pbr_types::STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT,
+    mesh_view_bindings::{globals, view},
+    pbr_types,
+}
+#import "shaders/simplex.wgsl"::simplex_noise_3d
+#import "shaders/outline.wgsl"::apply_outline
+
+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));
+}
+
+const SHOW_OUTSIDE: u32 = 1u;
+//const OUTLINE: u32 = 2u; // replaced by OUTLINE shader def
+const OUTLINE_RED: u32 = 4u;
+const OUTLINE_FORCE: u32 = 8u;
+
+@group(2) @binding(100)
+var<uniform> bounds: SceneBounds;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+#ifdef OUTLINE
+#ifdef MULTISAMPLED
+    @builtin(sample_index) sample_index: u32,
+#endif
+#endif
+) -> FragmentOutput {
+    // generate a PbrInput struct from the StandardMaterial bindings
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+    var out: FragmentOutput;
+
+#ifdef OUTLINE
+#ifndef MULTISAMPLED
+    let sample_index = 0u;
+#endif
+#endif
+
+    // apply emmissive multiplier
+    // dcl uses default 2.0 intensity. we also override bevy_pbr base emissive rules so that 
+    // - if emissive texture is supplied but color is not, we use the texture (bevy by default multiplies emissive color and emissive texture, so color must be white to pass the texture through)
+    // - if emissive color (== gltf emissive_intensity == dcl pbr emissive_color * emissive_intensity) is supplied but emissive texture is not, we use emissive color * base color
+    // emissive color | emissive texture  | result
+    // 0                no                  0
+    // x                no                  x * base color
+    // 0                t                   2 * t
+    // x != 0           t                   x * t
+    var emissive: vec4<f32> = material.emissive;
+#ifdef VERTEX_UVS
+    if ((material.flags & STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT) != 0u) {
+        if dot(emissive, emissive) == 0.0 {
+            emissive = vec4(2.0);
+        }
+        var bias: SampleBias;
+        bias.mip_bias = view.mip_bias;
+        emissive = vec4<f32>(emissive.rgb * textureSampleBias(
+            emissive_texture, 
+            emissive_sampler,
+#ifdef STANDARD_MATERIAL_EMISSIVE_UV_B
+#ifdef VERTEX_UVS_B
+            (material.uv_transform * vec3(in.uv_b, 1.0)).xy,
+#else
+            (material.uv_transform * vec3(in.uv, 1.0)).xy,
+#endif
+#else
+            (material.uv_transform * vec3(in.uv, 1.0)).xy,
+#endif
+            bias.mip_bias,
+        ).rgb, emissive.a);
+    } else {
+        if dot(emissive, emissive) != 0.0 {
+            // emissive is set, no emissive texture, use base color texture as emissive texture
+            emissive = emissive * pbr_input.material.base_color;
+        }
+    }
+#endif
+    // scale up for lumens
+    pbr_input.material.emissive = emissive * 10.0;
+    pbr_input.material.emissive.a = min(pbr_input.material.emissive.a, 1.0);
+
+    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 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.05;
+    var should_discard = false;
+    if outside_amt > 0.00 {
+        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 {
+                should_discard = true;
+            }
+        } else if outside_amt > 0.05 {
+            should_discard = true;
+        }
+    }
+
+    if should_discard && ((bounds.flags & SHOW_OUTSIDE) == 0) {
+        discard;
+    }
+
+    // alpha discard
+    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+    // apply lighting
+    if (pbr_input.material.flags & bevy_pbr::pbr_types::STANDARD_MATERIAL_FLAGS_UNLIT_BIT) == 0u {
+        out.color = apply_pbr_lighting(pbr_input);
+    } else {
+        out.color = pbr_input.material.base_color;
+    }
+
+    if should_discard {
+        out.color.a = out.color.a * 0.5;
+        out.color.r = 4.0;
+    } else {
+        if noise < outside_amt / 2.0 {
+            out.color = mix(out.color, vec4(10.0, 1.0, 0.0, 1.0), (outside_amt / 2.0 - noise) / 0.125);
+        }
+    }
+
+#ifdef OUTLINE
+    let alpha_mode = material.flags & pbr_types::STANDARD_MATERIAL_FLAGS_ALPHA_MODE_RESERVED_BITS;
+    if (alpha_mode == pbr_types::STANDARD_MATERIAL_FLAGS_ALPHA_MODE_OPAQUE) || ((bounds.flags & OUTLINE_FORCE) != 0u) {
+        out.color = apply_outline(
+            in.position,
+            out.color, 
+            (bounds.flags & OUTLINE_RED) != 0u,
+            sample_index,
+        );
+    }
+#endif
+
+    // 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/bound_material_baker.wgsl

@@ -0,0 +1,145 @@
+#import bevy_pbr::{
+    prepass_io::{VertexOutput, FragmentOutput},
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::{SampleBias, alpha_discard, apply_pbr_lighting, main_pass_post_lighting_processing},
+    pbr_bindings::{material, emissive_texture, emissive_sampler},
+    pbr_types::STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT,
+    mesh_view_bindings::{globals, view},
+    pbr_types,
+}
+#import boimp::shared::pack_pbrinput;
+
+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));
+}
+
+const SHOW_OUTSIDE: u32 = 1u;
+//const OUTLINE: u32 = 2u; // replaced by OUTLINE shader def
+const OUTLINE_RED: u32 = 4u;
+const OUTLINE_FORCE: u32 = 8u;
+
+@group(2) @binding(100)
+var<uniform> bounds: SceneBounds;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+#ifdef OUTLINE
+#ifdef MULTISAMPLED
+    @builtin(sample_index) sample_index: u32,
+#endif
+#endif
+) -> @location(0) vec2<u32> {
+    // generate a PbrInput struct from the StandardMaterial bindings
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+    var out: FragmentOutput;
+
+#ifdef OUTLINE
+#ifndef MULTISAMPLED
+    let sample_index = 0u;
+#endif
+#endif
+
+    // apply emmissive multiplier
+    // dcl uses default 2.0 intensity. we also override bevy_pbr base emissive rules so that 
+    // - if emissive texture is supplied but color is not, we use the texture (bevy by default multiplies emissive color and emissive texture, so color must be white to pass the texture through)
+    // - if emissive color (== gltf emissive_intensity == dcl pbr emissive_color * emissive_intensity) is supplied but emissive texture is not, we use emissive color * base color
+    // emissive color | emissive texture  | result
+    // 0                no                  0
+    // x                no                  x * base color
+    // 0                t                   2 * t
+    // x != 0           t                   x * t
+    var emissive: vec4<f32> = material.emissive;
+#ifdef VERTEX_UVS
+    if ((material.flags & STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT) != 0u) {
+        if dot(emissive, emissive) == 0.0 {
+            emissive = vec4(2.0);
+        }
+        var bias: SampleBias;
+        bias.mip_bias = view.mip_bias;
+        emissive = vec4<f32>(emissive.rgb * textureSampleBias(
+            emissive_texture,
+            emissive_sampler,
+#ifdef STANDARD_MATERIAL_EMISSIVE_UV_B
+#ifdef VERTEX_UVS_B
+            (material.uv_transform * vec3(in.uv_b, 1.0)).xy,
+#else
+            (material.uv_transform * vec3(in.uv, 1.0)).xy,
+#endif
+#else
+            (material.uv_transform * vec3(in.uv, 1.0)).xy,
+#endif
+            bias.mip_bias,
+        ).rgb, emissive.a);
+    } else {
+        if dot(emissive, emissive) != 0.0 {
+            // emissive is set, no emissive texture, use base color texture as emissive texture
+            emissive = emissive * pbr_input.material.base_color;
+        }
+    }
+#endif
+    // scale up for lumens
+    pbr_input.material.emissive = emissive * 10.0;
+    pbr_input.material.emissive.a = min(pbr_input.material.emissive.a, 1.0);
+
+    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 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;
+    }
+
+    if outside_amt > bounds.distance {
+        discard;
+    }
+
+    // alpha discard
+    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+    if pbr_input.material.base_color.a < 0.5 {
+        discard;
+    }    
+
+    // use max of emissive and color (imposters only take albedo)
+    // pbr_input.material.base_color = max(pbr_input.material.base_color, pbr_input.material.emissive);
+
+    return pack_pbrinput(pbr_input);
+}

package/assets/shaders/bound_node.wgsl

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

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

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

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