diff --git a/Cargo.toml b/Cargo.toml
index cc1dcc9f09..476fa13047 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -178,6 +178,10 @@ path = "examples/3d/pbr_pipelined.rs"
 name = "render_to_texture"
 path = "examples/3d/render_to_texture.rs"
 
+[[example]]
+name = "shadow_biases_pipelined"
+path = "examples/3d/shadow_biases_pipelined.rs"
+
 [[example]]
 name = "spawner"
 path = "examples/3d/spawner.rs"
diff --git a/examples/3d/shadow_biases_pipelined.rs b/examples/3d/shadow_biases_pipelined.rs
new file mode 100644
index 0000000000..ad56596ebc
--- /dev/null
+++ b/examples/3d/shadow_biases_pipelined.rs
@@ -0,0 +1,334 @@
+use bevy::{
+    core::Time,
+    ecs::prelude::*,
+    input::{mouse::MouseMotion, Input},
+    math::{EulerRot, Mat4, Quat, Vec2, Vec3},
+    pbr2::{
+        DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle,
+        StandardMaterial,
+    },
+    prelude::{App, Assets, KeyCode, Transform},
+    render2::{
+        camera::{Camera, OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    println!(
+        "Controls:
+    WSAD   - forward/back/strafe left/right
+    LShift - 'run'
+    E      - up
+    Q      - down
+    L      - switch between directional and point lights
+    1/2    - decrease/increase point light depth bias
+    3/4    - decrease/increase point light normal bias
+    5/6    - decrease/increase direction light depth bias
+    7/8    - decrease/increase direction light normal bias"
+    );
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup.system())
+        .add_system(adjust_point_light_biases.system())
+        .add_system(toggle_light.system())
+        .add_system(adjust_directional_light_biases.system())
+        .add_system(camera_controller.system())
+        .run();
+}
+
+/// set up a 3D scene to test shadow biases and perspective projections
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let spawn_plane_depth = 500.0f32;
+    let spawn_height = 2.0;
+    let sphere_radius = 0.25;
+
+    let white_handle = materials.add(StandardMaterial {
+        base_color: Color::WHITE,
+        perceptual_roughness: 1.0,
+        ..Default::default()
+    });
+    let sphere_handle = meshes.add(Mesh::from(shape::Icosphere {
+        radius: sphere_radius,
+        ..Default::default()
+    }));
+
+    println!("Using DirectionalLight");
+
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(5.0, 5.0, 0.0),
+        point_light: PointLight {
+            intensity: 0.0,
+            range: spawn_plane_depth,
+            color: Color::WHITE,
+            shadow_depth_bias: 0.0,
+            shadow_normal_bias: 0.0,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+
+    let theta = std::f32::consts::FRAC_PI_4;
+    let light_transform = Mat4::from_euler(EulerRot::ZYX, 0.0, std::f32::consts::FRAC_PI_2, -theta);
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            illuminance: 100000.0,
+            shadow_projection: OrthographicProjection {
+                left: -0.35,
+                right: 500.35,
+                bottom: -0.1,
+                top: 5.0,
+                near: -5.0,
+                far: 5.0,
+                ..Default::default()
+            },
+            shadow_depth_bias: 0.0,
+            shadow_normal_bias: 0.0,
+            ..Default::default()
+        },
+        transform: Transform::from_matrix(light_transform),
+        ..Default::default()
+    });
+
+    // camera
+    commands
+        .spawn_bundle(PerspectiveCameraBundle {
+            transform: Transform::from_xyz(-1.0, 1.0, 1.0)
+                .looking_at(Vec3::new(-1.0, 1.0, 0.0), Vec3::Y),
+            ..Default::default()
+        })
+        .insert(CameraController::default());
+
+    for z_i32 in -spawn_plane_depth as i32..=0 {
+        commands.spawn_bundle(PbrBundle {
+            mesh: sphere_handle.clone(),
+            material: white_handle.clone(),
+            transform: Transform::from_xyz(0.0, spawn_height, z_i32 as f32),
+            ..Default::default()
+        });
+    }
+
+    // ground plane
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane {
+            size: 2.0 * spawn_plane_depth,
+        })),
+        material: white_handle.clone(),
+        ..Default::default()
+    });
+}
+
+fn toggle_light(
+    input: Res<Input<KeyCode>>,
+    mut point_lights: Query<&mut PointLight>,
+    mut directional_lights: Query<&mut DirectionalLight>,
+) {
+    if input.just_pressed(KeyCode::L) {
+        for mut light in point_lights.iter_mut() {
+            light.intensity = if light.intensity == 0.0 {
+                println!("Using PointLight");
+                100000000.0
+            } else {
+                0.0
+            };
+        }
+        for mut light in directional_lights.iter_mut() {
+            light.illuminance = if light.illuminance == 0.0 {
+                println!("Using DirectionalLight");
+                100000.0
+            } else {
+                0.0
+            };
+        }
+    }
+}
+
+fn adjust_point_light_biases(input: Res<Input<KeyCode>>, mut query: Query<&mut PointLight>) {
+    let depth_bias_step_size = 0.01;
+    let normal_bias_step_size = 0.1;
+    for mut light in query.iter_mut() {
+        if input.just_pressed(KeyCode::Key1) {
+            light.shadow_depth_bias -= depth_bias_step_size;
+            println!("PointLight shadow_depth_bias: {}", light.shadow_depth_bias);
+        }
+        if input.just_pressed(KeyCode::Key2) {
+            light.shadow_depth_bias += depth_bias_step_size;
+            println!("PointLight shadow_depth_bias: {}", light.shadow_depth_bias);
+        }
+        if input.just_pressed(KeyCode::Key3) {
+            light.shadow_normal_bias -= normal_bias_step_size;
+            println!(
+                "PointLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key4) {
+            light.shadow_normal_bias += normal_bias_step_size;
+            println!(
+                "PointLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+    }
+}
+
+fn adjust_directional_light_biases(
+    input: Res<Input<KeyCode>>,
+    mut query: Query<&mut DirectionalLight>,
+) {
+    let depth_bias_step_size = 0.01;
+    let normal_bias_step_size = 0.1;
+    for mut light in query.iter_mut() {
+        if input.just_pressed(KeyCode::Key5) {
+            light.shadow_depth_bias -= depth_bias_step_size;
+            println!(
+                "DirectionalLight shadow_depth_bias: {}",
+                light.shadow_depth_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key6) {
+            light.shadow_depth_bias += depth_bias_step_size;
+            println!(
+                "DirectionalLight shadow_depth_bias: {}",
+                light.shadow_depth_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key7) {
+            light.shadow_normal_bias -= normal_bias_step_size;
+            println!(
+                "DirectionalLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key8) {
+            light.shadow_normal_bias += normal_bias_step_size;
+            println!(
+                "DirectionalLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+    }
+}
+
+struct CameraController {
+    pub enabled: bool,
+    pub sensitivity: f32,
+    pub key_forward: KeyCode,
+    pub key_back: KeyCode,
+    pub key_left: KeyCode,
+    pub key_right: KeyCode,
+    pub key_up: KeyCode,
+    pub key_down: KeyCode,
+    pub key_run: KeyCode,
+    pub walk_speed: f32,
+    pub run_speed: f32,
+    pub friction: f32,
+    pub pitch: f32,
+    pub yaw: f32,
+    pub velocity: Vec3,
+}
+
+impl Default for CameraController {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            sensitivity: 0.5,
+            key_forward: KeyCode::W,
+            key_back: KeyCode::S,
+            key_left: KeyCode::A,
+            key_right: KeyCode::D,
+            key_up: KeyCode::E,
+            key_down: KeyCode::Q,
+            key_run: KeyCode::LShift,
+            walk_speed: 10.0,
+            run_speed: 30.0,
+            friction: 0.5,
+            pitch: 0.0,
+            yaw: 0.0,
+            velocity: Vec3::ZERO,
+        }
+    }
+}
+
+fn camera_controller(
+    time: Res<Time>,
+    mut mouse_events: EventReader<MouseMotion>,
+    key_input: Res<Input<KeyCode>>,
+    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
+) {
+    let dt = time.delta_seconds();
+
+    // Handle mouse input
+    let mut mouse_delta = Vec2::ZERO;
+    for mouse_event in mouse_events.iter() {
+        mouse_delta += mouse_event.delta;
+    }
+
+    for (mut transform, mut options) in query.iter_mut() {
+        if !options.enabled {
+            continue;
+        }
+
+        // Handle key input
+        let mut axis_input = Vec3::ZERO;
+        if key_input.pressed(options.key_forward) {
+            axis_input.z += 1.0;
+        }
+        if key_input.pressed(options.key_back) {
+            axis_input.z -= 1.0;
+        }
+        if key_input.pressed(options.key_right) {
+            axis_input.x += 1.0;
+        }
+        if key_input.pressed(options.key_left) {
+            axis_input.x -= 1.0;
+        }
+        if key_input.pressed(options.key_up) {
+            axis_input.y += 1.0;
+        }
+        if key_input.pressed(options.key_down) {
+            axis_input.y -= 1.0;
+        }
+
+        // Apply movement update
+        if axis_input != Vec3::ZERO {
+            let max_speed = if key_input.pressed(options.key_run) {
+                options.run_speed
+            } else {
+                options.walk_speed
+            };
+            options.velocity = axis_input.normalize() * max_speed;
+        } else {
+            let friction = options.friction.clamp(0.0, 1.0);
+            options.velocity *= 1.0 - friction;
+            if options.velocity.length_squared() < 1e-6 {
+                options.velocity = Vec3::ZERO;
+            }
+        }
+        let forward = transform.forward();
+        let right = transform.right();
+        transform.translation += options.velocity.x * dt * right
+            + options.velocity.y * dt * Vec3::Y
+            + options.velocity.z * dt * forward;
+
+        if mouse_delta != Vec2::ZERO {
+            // Apply look update
+            let (pitch, yaw) = (
+                (options.pitch - mouse_delta.y * 0.5 * options.sensitivity * dt).clamp(
+                    -0.99 * std::f32::consts::FRAC_PI_2,
+                    0.99 * std::f32::consts::FRAC_PI_2,
+                ),
+                options.yaw - mouse_delta.x * options.sensitivity * dt,
+            );
+            transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, yaw, pitch);
+            options.pitch = pitch;
+            options.yaw = yaw;
+        }
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/light.rs b/pipelined/bevy_pbr2/src/light.rs
index db6d71b923..44f2c2b6f7 100644
--- a/pipelined/bevy_pbr2/src/light.rs
+++ b/pipelined/bevy_pbr2/src/light.rs
@@ -8,6 +8,9 @@ pub struct PointLight {
     pub range: f32,
     pub radius: f32,
     pub shadow_depth_bias: f32,
+    /// A bias applied along the direction of the fragment's surface normal. It is scaled to the
+    /// shadow map's texel size so that it can be small close to the camera and gets larger further
+    /// away.
     pub shadow_normal_bias: f32,
 }
 
@@ -26,7 +29,7 @@ impl Default for PointLight {
 
 impl PointLight {
     pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
-    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.02;
+    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.5;
 }
 
 /// A Directional light.
@@ -61,6 +64,8 @@ pub struct DirectionalLight {
     pub illuminance: f32,
     pub shadow_projection: OrthographicProjection,
     pub shadow_depth_bias: f32,
+    /// A bias applied along the direction of the fragment's surface normal. It is scaled to the
+    /// shadow map's texel size so that it is automatically adjusted to the orthographic projection.
     pub shadow_normal_bias: f32,
 }
 
@@ -87,7 +92,7 @@ impl Default for DirectionalLight {
 
 impl DirectionalLight {
     pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
-    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.02;
+    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.6;
 }
 
 // Ambient light color.
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
index 158655c027..12e229e1f3 100644
--- a/pipelined/bevy_pbr2/src/render/light.rs
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -172,8 +172,8 @@ impl FromWorld for ShadowShaders {
                     write_mask: 0,
                 },
                 bias: DepthBiasState {
-                    constant: 2,
-                    slope_scale: 2.0,
+                    constant: 0,
+                    slope_scale: 0.0,
                     clamp: 0.0,
                 },
             }),
@@ -228,6 +228,14 @@ pub fn extract_lights(
         color: ambient_light.color,
         brightness: ambient_light.brightness,
     });
+    // This is the point light shadow map texel size for one face of the cube as a distance of 1.0
+    // world unit from the light.
+    // point_light_texel_size = 2.0 * 1.0 * tan(PI / 4.0) / cube face width in texels
+    // PI / 4.0 is half the cube face fov, tan(PI / 4.0) = 1.0, so this simplifies to:
+    // point_light_texel_size = 2.0 / cube face width in texels
+    // NOTE: When using various PCF kernel sizes, this will need to be adjusted, according to:
+    // https://catlikecoding.com/unity/tutorials/custom-srp/point-and-spot-shadows/
+    let point_light_texel_size = 2.0 / POINT_SHADOW_SIZE.width as f32;
     for (entity, point_light, transform) in point_lights.iter() {
         commands.get_or_spawn(entity).insert(ExtractedPointLight {
             color: point_light.color,
@@ -236,10 +244,24 @@ pub fn extract_lights(
             radius: point_light.radius,
             transform: *transform,
             shadow_depth_bias: point_light.shadow_depth_bias,
-            shadow_normal_bias: point_light.shadow_normal_bias,
+            // The factor of SQRT_2 is for the worst-case diagonal offset
+            shadow_normal_bias: point_light.shadow_normal_bias
+                * point_light_texel_size
+                * std::f32::consts::SQRT_2,
         });
     }
     for (entity, directional_light, transform) in directional_lights.iter() {
+        // Calulate the directional light shadow map texel size using the largest x,y dimension of
+        // the orthographic projection divided by the shadow map resolution
+        // NOTE: When using various PCF kernel sizes, this will need to be adjusted, according to:
+        // https://catlikecoding.com/unity/tutorials/custom-srp/directional-shadows/
+        let largest_dimension = (directional_light.shadow_projection.right
+            - directional_light.shadow_projection.left)
+            .max(
+                directional_light.shadow_projection.top
+                    - directional_light.shadow_projection.bottom,
+            );
+        let directional_light_texel_size = largest_dimension / DIRECTIONAL_SHADOW_SIZE.width as f32;
         commands
             .get_or_spawn(entity)
             .insert(ExtractedDirectionalLight {
@@ -248,7 +270,10 @@ pub fn extract_lights(
                 direction: transform.forward(),
                 projection: directional_light.shadow_projection.get_projection_matrix(),
                 shadow_depth_bias: directional_light.shadow_depth_bias,
-                shadow_normal_bias: directional_light.shadow_normal_bias,
+                // The factor of SQRT_2 is for the worst-case diagonal offset
+                shadow_normal_bias: directional_light.shadow_normal_bias
+                    * directional_light_texel_size
+                    * std::f32::consts::SQRT_2,
             });
     }
 }
diff --git a/pipelined/bevy_pbr2/src/render/pbr.wgsl b/pipelined/bevy_pbr2/src/render/pbr.wgsl
index 63cf0e7711..d7668d331e 100644
--- a/pipelined/bevy_pbr2/src/render/pbr.wgsl
+++ b/pipelined/bevy_pbr2/src/render/pbr.wgsl
@@ -379,12 +379,24 @@ fn directional_light(light: DirectionalLight, roughness: f32, NdotV: f32, normal
     return (specular_light + diffuse) * light.color.rgb * NoL;
 }
 
-fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>) -> f32 {
+fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>, surface_normal: vec3<f32>) -> f32 {
     let light = lights.point_lights[light_id];
 
     // because the shadow maps align with the axes and the frustum planes are at 45 degrees
     // we can get the worldspace depth by taking the largest absolute axis
-    let frag_ls = light.position.xyz - frag_position.xyz;
+    let surface_to_light = light.position.xyz - frag_position.xyz;
+    let surface_to_light_abs = abs(surface_to_light);
+    let distance_to_light = max(surface_to_light_abs.x, max(surface_to_light_abs.y, surface_to_light_abs.z));
+
+    // The normal bias here is already scaled by the texel size at 1 world unit from the light.
+    // The texel size increases proportionally with distance from the light so multiplying by
+    // distance to light scales the normal bias to the texel size at the fragment distance.
+    let normal_offset = light.shadow_normal_bias * distance_to_light * surface_normal.xyz;
+    let depth_offset = light.shadow_depth_bias * normalize(surface_to_light.xyz);
+    let offset_position = frag_position.xyz + normal_offset + depth_offset;
+
+    // similar largest-absolute-axis trick as above, but now with the offset fragment position
+    let frag_ls = light.position.xyz - offset_position.xyz;
     let abs_position_ls = abs(frag_ls);
     let major_axis_magnitude = max(abs_position_ls.x, max(abs_position_ls.y, abs_position_ls.z));
 
@@ -398,14 +410,6 @@ fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>) -> f32 {
     let w = major_axis_magnitude;
     let depth = z / w;
 
-    // let shadow = texture(samplerCubeArrayShadow(t_Shadow, s_Shadow), vec4(frag_ls, i), depth - bias);
-
-    // manual depth testing
-    // float shadow = texture(samplerCubeArray(t_Shadow, s_Shadow), vec4(-frag_ls, 6 * i)).r;
-    // shadow = depth > shadow ? 0.0 : 1.0;
-    // o_Target = vec4(vec3(shadow * 20 - 19, depth * 20 - 19, 0.0), 1.0);
-    // o_Target = vec4(vec3(shadow * 20 - 19), 1.0);
-
     // do the lookup, using HW PCF and comparison
     // NOTE: Due to the non-uniform control flow above, we must use the Level variant of
     //       textureSampleCompare to avoid undefined behaviour due to some of the fragments in
@@ -415,21 +419,35 @@ fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>) -> f32 {
     return textureSampleCompareLevel(point_shadow_textures, point_shadow_textures_sampler, frag_ls, i32(light_id), depth);
 }
 
-fn fetch_directional_shadow(light_id: i32, frag_position: vec4<f32>) -> f32 {
+fn fetch_directional_shadow(light_id: i32, frag_position: vec4<f32>, surface_normal: vec3<f32>) -> f32 {
     let light = lights.directional_lights[light_id];
-    let homogeneous_coords = light.view_projection * frag_position;
-    if (homogeneous_coords.w <= 0.0) {
+
+    // The normal bias is scaled to the texel size.
+    let normal_offset = light.shadow_normal_bias * surface_normal.xyz;
+    let depth_offset = light.shadow_depth_bias * light.direction_to_light.xyz;
+    let offset_position = vec4<f32>(frag_position.xyz + normal_offset + depth_offset, frag_position.w);
+
+    let offset_position_clip = light.view_projection * offset_position;
+    if (offset_position_clip.w <= 0.0) {
         return 1.0;
     }
-    // compensate for the Y-flip difference between the NDC and texture coordinates
+    let offset_position_ndc = offset_position_clip.xyz / offset_position_clip.w;
+    // No shadow outside the orthographic projection volume
+    if (any(offset_position_ndc.xy < vec2<f32>(-1.0)) || offset_position_ndc.z < 0.0
+            || any(offset_position_ndc > vec3<f32>(1.0))) {
+        return 1.0;
+    }
+
+    // compute texture coordinates for shadow lookup, compensating for the Y-flip difference
+    // between the NDC and texture coordinates
     let flip_correction = vec2<f32>(0.5, -0.5);
-    let proj_correction = 1.0 / homogeneous_coords.w;
-    // compute texture coordinates for shadow lookup
-    let light_local = homogeneous_coords.xy * flip_correction * proj_correction + vec2<f32>(0.5, 0.5);
+    let light_local = offset_position_ndc.xy * flip_correction + vec2<f32>(0.5, 0.5);
+
+    let depth = offset_position_ndc.z;
     // do the lookup, using HW PCF and comparison
     // NOTE: Due to non-uniform control flow above, we must use the level variant of the texture
     //       sampler to avoid use of implicit derivatives causing possible undefined behavior.
-    return textureSampleCompareLevel(directional_shadow_textures, directional_shadow_textures_sampler, light_local, i32(light_id), homogeneous_coords.z * proj_correction);
+    return textureSampleCompareLevel(directional_shadow_textures, directional_shadow_textures_sampler, light_local, i32(light_id), depth);
 }
 
 struct FragmentInput {
@@ -522,26 +540,13 @@ fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
         let n_directional_lights = i32(lights.n_directional_lights);
         for (var i: i32 = 0; i < n_point_lights; i = i + 1) {
             let light = lights.point_lights[i];
-
-            let dir_to_light = normalize(light.position.xyz - in.world_position.xyz);
-            let depth_bias = light.shadow_depth_bias * dir_to_light.xyz;
-            let NdotL = dot(dir_to_light.xyz, in.world_normal.xyz);
-            let normal_bias = light.shadow_normal_bias * (1.0 - NdotL) * in.world_normal.xyz;
-            let biased_position = vec4<f32>(in.world_position.xyz + depth_bias + normal_bias, in.world_position.w);
-
-            let shadow = fetch_point_shadow(i, biased_position);
+            let shadow = fetch_point_shadow(i, in.world_position, in.world_normal);
             let light_contrib = point_light(in.world_position.xyz, light, roughness, NdotV, N, V, R, F0, diffuse_color);
             light_accum = light_accum + light_contrib * shadow;
         }
         for (var i: i32 = 0; i < n_directional_lights; i = i + 1) {
             let light = lights.directional_lights[i];
-
-            let depth_bias = light.shadow_depth_bias * light.direction_to_light.xyz;
-            let NdotL = dot(light.direction_to_light.xyz, in.world_normal.xyz);
-            let normal_bias = light.shadow_normal_bias * (1.0 - NdotL) * in.world_normal.xyz;
-            let biased_position = vec4<f32>(in.world_position.xyz + depth_bias + normal_bias, in.world_position.w);
-
-            let shadow = fetch_directional_shadow(i, biased_position);
+            let shadow = fetch_directional_shadow(i, in.world_position, in.world_normal);
             let light_contrib = directional_light(light, roughness, NdotV, N, V, R, F0, diffuse_color);
             light_accum = light_accum + light_contrib * shadow;
         }