diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 09dd0f5..556d06f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,8 +29,25 @@ jobs:
 
       - name: Run clippy
         run: |
-          cargo clippy -- -D warnings
+          cargo clippy --all-features -- -D warnings
 
+  checks:
+    name: Checks
+    strategy:
+      matrix:
+        features: ["--no-default-features", "--features avian2d", "--features avian3d", "--features debug-with-gizmos"]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Run clippy
+        run: |
+          cargo check ${{ matrix.features }}
+                
   tests:
     name: Tests
     runs-on: ubuntu-latest
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 6a687b2..f6ec892 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -9,7 +9,7 @@ permissions:
   id-token: write
 
 jobs:
-  deploy:
+  build:
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
@@ -23,45 +23,30 @@ jobs:
         with:
           target: wasm32-unknown-unknown
 
-      - name: Install wasm-bindgen
+      - name: install tools
         run: |
-          cargo install cargo-quickinstall
-          cargo quickinstall wasm-bindgen-cli
+          cargo install wasm-bindgen-cli
+          sudo apt-get install -y binaryen
 
       - name: Build
         run: |
-          cargo build --target wasm32-unknown-unknown --release --example moving --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/moving.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example lines --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/lines.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example many --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/many.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example gltf --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/gltf.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example random_obstacles --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/random_obstacles.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example auto_navmesh_aabb --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/auto_navmesh_aabb.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example auto_navmesh_primitive --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/auto_navmesh_primitive.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example primitive_3d --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/primitive_3d.wasm
-
-          cargo build --target wasm32-unknown-unknown --release --example demo --features bevy/webgl2
-          wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/demo.wasm
+          for example in "auto_navmesh_aabb" "auto_navmesh_primitive" "primitive_3d" "demo" "auto_navmesh_avian2d" "auto_navmesh_avian3d" "many" "lines" "moving" "gltf" "random_obstacles"
+          do
+            echo "Building $example"
+            cargo build --target wasm32-unknown-unknown --release --example $example --features "bevy/webgl2,avian2d,avian3d"
+            wasm-bindgen --no-typescript --out-dir wasm --target web target/wasm32-unknown-unknown/release/examples/$example.wasm
+            wasm-opt -Oz wasm/${example}_bg.wasm --output wasm/${example}-opt.wasm
+            rm wasm/${example}_bg.wasm
+            mv wasm/${example}-opt.wasm wasm/${example}_bg.wasm
+            cp wasm/example.html wasm/${example}.html
+            sed -i'' "s/name-of-example/${example}/g" wasm/${example}.html
+          done
 
       - name: Copy Assets
         run: cp -r assets wasm/
 
       - name: Copy Screenshots
-        run: cp screenshots/* wasm/
+        run: cp -r screenshots wasm/
 
       - name: Setup Pages
         uses: actions/configure-pages@v5
@@ -71,6 +56,13 @@ jobs:
         with:
           path: "wasm"
 
+  deploy:
+    needs: build
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
       - name: Deploy to GitHub Pages
         id: deployment
         uses: actions/deploy-pages@v4
diff --git a/Cargo.toml b/Cargo.toml
index 962af30..2943498 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,6 +16,18 @@ categories = ["game-development"]
 itertools = "0.13"
 tracing = { version = "0.1", optional = true }
 
+[dependencies.avian2d]
+version = "0.1"
+features = ["2d", "f32", "parry-f32"]
+default-features = false
+optional = true
+
+[dependencies.avian3d]
+version = "0.1"
+features = ["3d", "f32", "parry-f32"]
+default-features = false
+optional = true
+
 [dependencies.polyanya]
 version = "0.7.1"
 
@@ -52,5 +64,10 @@ default = ["debug-with-gizmos"]
 linuxci = ["bevy/x11"]
 debug-with-gizmos = ["bevy/bevy_gizmos"]
 
-[profile.dev.package."*"]
-opt-level = 3
+[[example]]
+name = "auto_navmesh_avian2d"
+required-features = ["avian2d"]
+
+[[example]]
+name = "auto_navmesh_avian3d"
+required-features = ["avian3d"]
diff --git a/examples/auto_navmesh_aabb.rs b/examples/auto_navmesh_aabb.rs
index 7578fff..6ea38e3 100644
--- a/examples/auto_navmesh_aabb.rs
+++ b/examples/auto_navmesh_aabb.rs
@@ -30,6 +30,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/auto_navmesh_avian2d.rs b/examples/auto_navmesh_avian2d.rs
new file mode 100644
index 0000000..6ee88ce
--- /dev/null
+++ b/examples/auto_navmesh_avian2d.rs
@@ -0,0 +1,225 @@
+use avian2d::{math::*, prelude::*};
+use bevy::{color::palettes, math::vec2, prelude::*, sprite::MaterialMesh2dBundle};
+use rand::Rng;
+use vleue_navigator::prelude::*;
+
+#[derive(Component)]
+enum Obstacle {
+    Peg,
+    Wall,
+}
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins.set(WindowPlugin {
+                primary_window: Some(Window {
+                    title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
+                    ..default()
+                }),
+                ..default()
+            }),
+            PhysicsPlugins::default().with_length_unit(20.0),
+            VleueNavigatorPlugin,
+            NavmeshUpdaterPlugin::<Collider, Obstacle>::default(),
+        ))
+        .insert_resource(ClearColor(Color::srgb(0.05, 0.05, 0.1)))
+        .insert_resource(Gravity(Vector::NEG_Y * 9.81 * 100.0))
+        .add_systems(Startup, setup)
+        .add_systems(
+            PreUpdate,
+            (puck_back_to_start, move_puck, display_puck_path),
+        )
+        .insert_resource(NavMeshesDebug(palettes::tailwind::RED_800.into()))
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    commands.spawn(Camera2dBundle::default());
+
+    let square_sprite = Sprite {
+        color: Color::srgb(0.7, 0.7, 0.8),
+        custom_size: Some(Vec2::splat(50.0)),
+        ..default()
+    };
+
+    // Left wall
+    commands.spawn((
+        SpriteBundle {
+            sprite: square_sprite.clone(),
+            transform: Transform::from_xyz(-50.0 * 9.5, 0.0, 0.0)
+                .with_scale(Vec3::new(1.0, 15.0, 1.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::rectangle(50.0, 50.0),
+        Obstacle::Wall,
+    ));
+    // Right wall
+    commands.spawn((
+        SpriteBundle {
+            sprite: square_sprite,
+            transform: Transform::from_xyz(50.0 * 9.5, 0.0, 0.0)
+                .with_scale(Vec3::new(1.0, 15.0, 1.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::rectangle(50.0, 50.0),
+        Obstacle::Wall,
+    ));
+
+    let marble_radius = 15.0;
+    let step = 10;
+    let marble_mesh = meshes.add(Circle::new(marble_radius));
+    let marble_material = materials.add(Color::srgb(0.2, 0.7, 0.9));
+
+    for x in (-50..50).step_by(step).skip(1) {
+        for (yi, y) in (-50..50).step_by(step).skip(1).enumerate() {
+            commands.spawn((
+                MaterialMesh2dBundle {
+                    mesh: marble_mesh.clone().into(),
+                    material: marble_material.clone(),
+                    transform: Transform::from_xyz(
+                        (x as f32
+                            + if yi % 2 == 0 {
+                                -(step as f32 / 4.0)
+                            } else {
+                                step as f32 / 4.0
+                            }
+                            + rand::thread_rng().gen_range(-1.0..1.0))
+                            * 9.5,
+                        (y as f32 + rand::thread_rng().gen_range(-1.0..1.0)) * 6.0,
+                        0.0,
+                    ),
+                    ..default()
+                },
+                RigidBody::Static,
+                Collider::circle(marble_radius as Scalar),
+                Obstacle::Peg,
+            ));
+        }
+    }
+
+    let mesh = meshes.add(Circle::new(5.0));
+    let material = materials.add(Color::srgb(0.7, 0.9, 0.2));
+    for x in (-50..50).step_by(5).skip(1) {
+        let start = Vec3::new(x as f32 * 9.5, 300.0, 0.0);
+        commands.spawn((
+            MaterialMesh2dBundle {
+                mesh: mesh.clone().into(),
+                material: material.clone(),
+                transform: Transform::from_translation(start),
+                ..default()
+            },
+            RigidBody::Dynamic,
+            LinearVelocity(
+                Vec2::new(
+                    rand::thread_rng().gen_range(-1.0..1.0),
+                    rand::thread_rng().gen_range(-1.0..1.0),
+                )
+                .normalize()
+                    * 200.0,
+            ),
+            Collider::circle(5.0 as Scalar),
+            Puck(start),
+        ));
+    }
+
+    commands.spawn(NavMeshBundle {
+        settings: NavMeshSettings {
+            // Define the outer borders of the navmesh.
+            fixed: Triangulation::from_outer_edges(&vec![
+                vec2(-500.0, -500.0),
+                vec2(500.0, -500.0),
+                vec2(500.0, 500.0),
+                vec2(-500.0, 500.0),
+            ]),
+            ..default()
+        },
+        update_mode: NavMeshUpdateMode::Direct,
+        ..default()
+    });
+}
+
+#[derive(Component)]
+struct Puck(Vec3);
+
+fn puck_back_to_start(
+    mut commands: Commands,
+    query: Query<(Entity, Ref<Transform>, &Puck), Without<Path>>,
+    navmeshes: Res<Assets<NavMesh>>,
+    navmesh: Query<&Handle<NavMesh>>,
+) {
+    let Some(navmesh) = navmeshes.get(navmesh.single()) else {
+        return;
+    };
+
+    for (entity, transform, puck) in query.iter() {
+        if transform.translation.y < -300.0 {
+            let Some(path) = navmesh.transformed_path(transform.translation, puck.0) else {
+                continue;
+            };
+
+            if let Some((first, remaining)) = path.path.split_first() {
+                let mut remaining = remaining.to_vec();
+                remaining.reverse();
+
+                commands.entity(entity).insert((
+                    RigidBody::Static,
+                    Path {
+                        current: first.clone(),
+                        next: remaining,
+                    },
+                ));
+            }
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct Path {
+    current: Vec3,
+    next: Vec<Vec3>,
+}
+
+pub fn move_puck(
+    mut commands: Commands,
+    mut navigator: Query<(&mut Transform, &mut Path, Entity, &mut LinearVelocity)>,
+    time: Res<Time>,
+) {
+    for (mut transform, mut path, entity, mut linvel) in navigator.iter_mut() {
+        let move_direction = path.current - transform.translation;
+        transform.translation += move_direction.normalize() * time.delta_seconds() * 200.0;
+
+        if transform.translation.distance(path.current) < 10.0 {
+            if let Some(next) = path.next.pop() {
+                path.current = next;
+            }
+        }
+        if transform.translation.distance(path.current) < 50.0 && path.next.is_empty() {
+            commands
+                .entity(entity)
+                .insert(RigidBody::Dynamic)
+                .remove::<Path>();
+            linvel.0 = (path.current - transform.translation).xy() * 10.0;
+            continue;
+        }
+    }
+}
+
+pub fn display_puck_path(navigator: Query<(&Transform, &Path)>, mut gizmos: Gizmos) {
+    for (transform, path) in &navigator {
+        let mut to_display = path.next.iter().map(|v| v.xy()).collect::<Vec<_>>();
+        to_display.push(path.current.clone().xy());
+        to_display.push(transform.translation.xy());
+        to_display.reverse();
+        if to_display.len() >= 1 {
+            gizmos.linestrip_2d(to_display, palettes::tailwind::YELLOW_400);
+        }
+    }
+}
diff --git a/examples/auto_navmesh_avian3d.rs b/examples/auto_navmesh_avian3d.rs
new file mode 100644
index 0000000..06e7d85
--- /dev/null
+++ b/examples/auto_navmesh_avian3d.rs
@@ -0,0 +1,230 @@
+use std::time::Duration;
+
+use avian3d::{math::*, prelude::*};
+use bevy::{color::palettes, math::vec2, prelude::*, time::common_conditions::on_timer};
+
+use vleue_navigator::prelude::*;
+
+#[derive(Component)]
+struct Obstacle;
+
+fn main() {
+    let mut app = App::new();
+    app.add_plugins((
+        DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Navmesh with Polyanya".to_string(),
+                fit_canvas_to_parent: true,
+                ..default()
+            }),
+            ..default()
+        }),
+        PhysicsPlugins::default().with_length_unit(20.0),
+        VleueNavigatorPlugin,
+        NavmeshUpdaterPlugin::<Collider, Obstacle>::default(),
+    ))
+    .insert_resource(ClearColor(Color::srgb(0.05, 0.05, 0.1)))
+    .insert_resource(Gravity(Vector::NEG_Y * 9.81 * 50.0))
+    .add_systems(Startup, setup)
+    .add_systems(
+        Update,
+        view_navmesh.run_if(on_timer(Duration::from_secs_f32(1.0))),
+    )
+    .add_systems(Update, cached_material);
+
+    let mut config_store = app
+        .world_mut()
+        .get_resource_mut::<GizmoConfigStore>()
+        .unwrap();
+    for (_, config, _) in config_store.iter_mut() {
+        config.depth_bias = -1.0;
+    }
+
+    app.run();
+}
+
+pub const MATERIAL_OBSTACLE_LIVE: Handle<StandardMaterial> = Handle::weak_from_u128(0);
+pub const MATERIAL_OBSTACLE_CACHED: Handle<StandardMaterial> = Handle::weak_from_u128(1);
+
+fn setup(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    materials.insert(&MATERIAL_OBSTACLE_LIVE, Color::srgb(0.2, 0.7, 0.9).into());
+    materials.insert(&MATERIAL_OBSTACLE_CACHED, Color::srgb(0.2, 0.9, 0.7).into());
+
+    let arena_mesh = meshes.add(Cuboid::default());
+    let arena_material = materials.add(Color::srgb(0.7, 0.7, 0.8));
+
+    // Ground
+    commands.spawn((
+        PbrBundle {
+            mesh: arena_mesh.clone(),
+            material: arena_material.clone(),
+            transform: Transform::from_xyz(0.0, -5.0, 0.0).with_scale(Vec3::new(50.0, 10.0, 50.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+    commands.spawn((
+        PbrBundle {
+            mesh: arena_mesh.clone(),
+            material: arena_material.clone(),
+            transform: Transform::from_xyz(25.5, 0.0, 0.0).with_scale(Vec3::new(1.0, 10.0, 50.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+    commands.spawn((
+        PbrBundle {
+            mesh: arena_mesh.clone(),
+            material: arena_material.clone(),
+            transform: Transform::from_xyz(-25.5, 0.0, 0.0).with_scale(Vec3::new(1.0, 10.0, 50.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+    commands.spawn((
+        PbrBundle {
+            mesh: arena_mesh.clone(),
+            material: arena_material.clone(),
+            transform: Transform::from_xyz(0.0, 0.0, 25.5).with_scale(Vec3::new(50.0, 10.0, 1.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+    commands.spawn((
+        PbrBundle {
+            mesh: arena_mesh.clone(),
+            material: arena_material.clone(),
+            transform: Transform::from_xyz(0.0, 0.0, -25.5).with_scale(Vec3::new(50.0, 10.0, 1.0)),
+            ..default()
+        },
+        RigidBody::Static,
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+
+    let obstacle_size = 2.0;
+    let spacing = 1.0;
+
+    use rand::seq::SliceRandom;
+
+    let types = [
+        (
+            meshes.add(Cuboid::from_length(2.0)),
+            Collider::cuboid(2.0, 2.0, 2.0),
+        ),
+        (
+            meshes.add(Cone {
+                radius: 2.0,
+                height: 2.0,
+            }),
+            Collider::cone(2.0, 2.0),
+        ),
+        (meshes.add(Sphere::new(1.0)), Collider::sphere(1.0)),
+        (
+            meshes.add(Capsule3d::new(1.0, 2.0)),
+            Collider::capsule(1.0, 2.0),
+        ),
+    ];
+    // Spawn some obstacles
+    for x in -3..3 {
+        for z in -3..3 {
+            let (mesh, collider) = types.choose(&mut rand::thread_rng()).unwrap();
+            let position = Vec3::new((x as f32 - 0.5) * spacing, 25.0, (z as f32 - 0.5) * spacing)
+                * obstacle_size;
+            commands.spawn((
+                PbrBundle {
+                    mesh: mesh.clone(),
+                    material: MATERIAL_OBSTACLE_LIVE.clone(),
+                    transform: Transform::from_translation(position),
+                    ..default()
+                },
+                Friction::new(0.1),
+                RigidBody::Dynamic,
+                collider.clone(),
+                Obstacle,
+            ));
+        }
+    }
+
+    // Directional light
+    commands.spawn(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            illuminance: 5000.0,
+            shadows_enabled: true,
+            ..default()
+        },
+        transform: Transform::default().looking_at(Vec3::new(-1.0, -2.5, -1.5), Vec3::Y),
+        ..default()
+    });
+
+    // Camera
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_translation(Vec3::new(0.0, 40.0, 30.0))
+            .looking_at(Vec3::Z * 5.0, Vec3::Y),
+        ..default()
+    });
+
+    let nb_navmeshes = 3;
+    let height_step = 2.0 / (nb_navmeshes as f32);
+    for idx in 0..nb_navmeshes {
+        commands.spawn((NavMeshBundle {
+            settings: NavMeshSettings {
+                // Define the outer borders of the navmesh.
+                fixed: Triangulation::from_outer_edges(&vec![
+                    vec2(-25.0, -25.0),
+                    vec2(25.0, -25.0),
+                    vec2(25.0, 25.0),
+                    vec2(-25.0, 25.0),
+                ]),
+                build_timeout: Some(1.0),
+                simplify: 0.005,
+                merge_steps: 0,
+                ..default()
+            },
+            update_mode: NavMeshUpdateMode::Direct,
+            transform: Transform::from_xyz(0.0, 0.1 + idx as f32 * height_step, 0.0)
+                .with_rotation(Quat::from_rotation_x(-FRAC_PI_2)),
+            handle: Handle::<NavMesh>::weak_from_u128(idx as u128),
+
+            ..default()
+        },));
+    }
+}
+
+fn view_navmesh(
+    mut commands: Commands,
+    navmeshes: Query<Entity, With<Handle<NavMesh>>>,
+    mut current: Local<usize>,
+) {
+    for (i, entity) in navmeshes.iter().sort::<Entity>().enumerate() {
+        commands.entity(entity).remove::<NavMeshDebug>();
+        if i == *current {
+            commands
+                .entity(entity)
+                .insert(NavMeshDebug(palettes::tailwind::RED_800.into()));
+        }
+    }
+    *current = (*current + 1) % navmeshes.iter().len();
+}
+
+fn cached_material(
+    mut obstacles: Query<(&mut Handle<StandardMaterial>, Option<Ref<CachableObstacle>>)>,
+    mut removed: RemovedComponents<CachableObstacle>,
+) {
+    for (mut material, cachable) in &mut obstacles {
+        if cachable.is_some() {
+            *material = MATERIAL_OBSTACLE_CACHED.clone();
+        }
+    }
+    for removed in removed.read() {
+        let (mut material, _) = obstacles.get_mut(removed).unwrap();
+        *material = MATERIAL_OBSTACLE_LIVE.clone();
+    }
+}
diff --git a/examples/auto_navmesh_primitive.rs b/examples/auto_navmesh_primitive.rs
index 6e649bd..e0318f0 100644
--- a/examples/auto_navmesh_primitive.rs
+++ b/examples/auto_navmesh_primitive.rs
@@ -26,6 +26,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/demo.rs b/examples/demo.rs
index 6c98ce3..fae32b8 100644
--- a/examples/demo.rs
+++ b/examples/demo.rs
@@ -5,7 +5,7 @@ use bevy::{
 };
 use polyanya::Triangulation;
 use rand::Rng;
-use vleue_navigator::{prelude::*, NavMeshDebug};
+use vleue_navigator::prelude::*;
 
 #[path = "helpers/agent3d.rs"]
 mod agent3d;
@@ -33,6 +33,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
@@ -70,7 +71,7 @@ fn main() {
         )
         .add_systems(FixedUpdate, random_obstacle)
         .insert_resource(Time::<Fixed>::from_seconds(0.25))
-        .insert_resource(NavMeshDebug(palettes::tailwind::RED_800.into()))
+        .insert_resource(NavMeshesDebug(palettes::tailwind::RED_800.into()))
         .run();
 }
 
diff --git a/examples/gltf.rs b/examples/gltf.rs
index bceda64..36eafb7 100644
--- a/examples/gltf.rs
+++ b/examples/gltf.rs
@@ -21,6 +21,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/lines.rs b/examples/lines.rs
index f7096f8..fab62fc 100644
--- a/examples/lines.rs
+++ b/examples/lines.rs
@@ -13,6 +13,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/many.rs b/examples/many.rs
index dc7cd96..441f6d1 100644
--- a/examples/many.rs
+++ b/examples/many.rs
@@ -13,7 +13,7 @@ use bevy::{
     sprite::MaterialMesh2dBundle,
     tasks::AsyncComputeTaskPool,
     utils::Instant,
-    window::{PresentMode, PrimaryWindow, WindowResized},
+    window::{PrimaryWindow, WindowResized},
 };
 use rand::prelude::*;
 
@@ -27,12 +27,11 @@ fn main() {
                 .set(WindowPlugin {
                     primary_window: Some(Window {
                         title: "Navmesh with Polyanya".to_string(),
-                        present_mode: PresentMode::AutoNoVsync,
+                        fit_canvas_to_parent: true,
                         ..default()
                     }),
                     ..default()
-                })
-                // This example will be async heavy, increase the default threadpool
+                }) // This example will be async heavy, increase the default threadpool
                 .set(TaskPoolPlugin {
                     task_pool_options: TaskPoolOptions {
                         async_compute: TaskPoolThreadAssignmentPolicy {
diff --git a/examples/moving.rs b/examples/moving.rs
index bed43fa..e8e6d5e 100644
--- a/examples/moving.rs
+++ b/examples/moving.rs
@@ -21,6 +21,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/primitive_3d.rs b/examples/primitive_3d.rs
index 6bacaf8..f631032 100644
--- a/examples/primitive_3d.rs
+++ b/examples/primitive_3d.rs
@@ -20,6 +20,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/examples/random_obstacles.rs b/examples/random_obstacles.rs
index a0c2c50..8d595f0 100644
--- a/examples/random_obstacles.rs
+++ b/examples/random_obstacles.rs
@@ -18,6 +18,7 @@ fn main() {
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Navmesh with Polyanya".to_string(),
+                    fit_canvas_to_parent: true,
                     ..default()
                 }),
                 ..default()
diff --git a/screenshots/auto_navmesh_avian2d.png b/screenshots/auto_navmesh_avian2d.png
new file mode 100644
index 0000000..91e346f
Binary files /dev/null and b/screenshots/auto_navmesh_avian2d.png differ
diff --git a/screenshots/auto_navmesh_avian3d.png b/screenshots/auto_navmesh_avian3d.png
new file mode 100644
index 0000000..fb4b2d5
Binary files /dev/null and b/screenshots/auto_navmesh_avian3d.png differ
diff --git a/screenshots/primitive_3d.png b/screenshots/primitive_3d.png
index 0d12c3b..a65a077 100644
Binary files a/screenshots/primitive_3d.png and b/screenshots/primitive_3d.png differ
diff --git a/src/lib.rs b/src/lib.rs
index 7d4c180..34344be 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,17 +36,28 @@ pub mod prelude {
         CachableObstacle, NavMeshBundle, NavMeshSettings, NavMeshStatus, NavMeshUpdateMode,
         NavMeshUpdateModeBlocking, NavmeshUpdaterPlugin, NAVMESH_BUILD_DURATION,
     };
-    pub use crate::{NavMesh, VleueNavigatorPlugin};
+    pub use crate::{NavMesh, Triangulation, VleueNavigatorPlugin};
+    #[cfg(feature = "debug-with-gizmos")]
+    pub use crate::{NavMeshDebug, NavMeshesDebug};
 }
 
 /// Bevy plugin to add support for the [`NavMesh`] asset type.
 #[derive(Debug, Clone, Copy)]
 pub struct VleueNavigatorPlugin;
 
-/// Controls wether to display the NavMesh with gizmos.
-/// When this resource is present, the NavMesh will be visible.
+/// Controls wether to display all NavMeshes with gizmos.
+/// When this resource is present, all NavMeshes will be visible.
 #[cfg(feature = "debug-with-gizmos")]
 #[derive(Resource, Clone, Copy, Debug)]
+pub struct NavMeshesDebug(
+    /// Color to display the NavMesh with
+    pub Color,
+);
+
+/// Controls wether to display a NavMesh with gizmos.
+/// When this component is present, the NavMesh will be visible.
+#[cfg(feature = "debug-with-gizmos")]
+#[derive(Component, Clone, Copy, Debug)]
 pub struct NavMeshDebug(
     /// Color to display the NavMesh with
     pub Color,
@@ -58,10 +69,7 @@ impl Plugin for VleueNavigatorPlugin {
             .init_asset::<NavMesh>();
 
         #[cfg(feature = "debug-with-gizmos")]
-        app.add_systems(
-            Update,
-            display_navmesh.run_if(resource_exists::<NavMeshDebug>),
-        );
+        app.add_systems(Update, display_navmesh);
     }
 }
 
@@ -81,7 +89,7 @@ pub use polyanya::{Path, Triangulation};
 #[derive(Debug, TypePath, Clone, Asset)]
 pub struct NavMesh {
     mesh: Arc<polyanya::Mesh>,
-    transform: Transform,
+    pub(crate) transform: Transform,
 }
 
 impl NavMesh {
@@ -329,32 +337,44 @@ fn get_vectors(
 #[cfg(feature = "debug-with-gizmos")]
 /// Use gizmos to display navmeshes
 pub fn display_navmesh(
-    live_navmeshes: Query<&Handle<NavMesh>>,
+    live_navmeshes: Query<(&Handle<NavMesh>, Option<&NavMeshDebug>)>,
     mut gizmos: Gizmos,
     navmeshes: Res<Assets<NavMesh>>,
-    controls: Res<NavMeshDebug>,
+    controls: Option<Res<NavMeshesDebug>>,
 ) {
     use bevy::math::vec3;
-    for mesh in &live_navmeshes {
+    for (mesh, debug) in &live_navmeshes {
+        let Some(color) = debug
+            .map(|debug| debug.0)
+            .or_else(|| controls.as_ref().map(|c| c.0))
+        else {
+            continue;
+        };
         if let Some(navmesh) = navmeshes.get(mesh) {
             let inverse_transform = navmesh.inverse_transform();
+            let transform = navmesh.transform();
             let navmesh = navmesh.get();
             for polygon in &navmesh.polygons {
                 let mut v = polygon
                     .vertices
                     .iter()
                     .map(|i| &navmesh.vertices[*i as usize].coords)
-                    .map(|v| inverse_transform.transform_point(vec3(v.x, v.y, 0.0)))
+                    .map(|v| {
+                        inverse_transform.rotation.mul_vec3(vec3(v.x, v.y, 0.0))
+                            + transform.translation
+                    })
                     .collect::<Vec<_>>();
                 if !v.is_empty() {
                     let first = polygon.vertices[0];
                     let first = &navmesh.vertices[first as usize];
-                    v.push(inverse_transform.transform_point(vec3(
-                        first.coords.x,
-                        first.coords.y,
-                        0.0,
-                    )));
-                    gizmos.linestrip(v, controls.0);
+                    v.push(
+                        inverse_transform.rotation.mul_vec3(vec3(
+                            first.coords.x,
+                            first.coords.y,
+                            0.0,
+                        )) + transform.translation,
+                    );
+                    gizmos.linestrip(v, color);
                 }
             }
         }
diff --git a/src/obstacles/avian2d.rs b/src/obstacles/avian2d.rs
new file mode 100644
index 0000000..6ba935d
--- /dev/null
+++ b/src/obstacles/avian2d.rs
@@ -0,0 +1,141 @@
+use avian2d::{dynamics::rigid_body::Sleeping, parry::shape::TypedShape, prelude::Collider};
+use bevy::{
+    math::{vec3, Vec3Swizzles},
+    prelude::*,
+};
+
+use crate::updater::CachableObstacle;
+
+use super::{ObstacleSource, RESOLUTION};
+
+impl ObstacleSource for Collider {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        navmesh_transform: &Transform,
+    ) -> Vec<Vec2> {
+        self.shape_scaled()
+            .as_typed_shape()
+            .get_polygon(obstacle_transform, navmesh_transform)
+    }
+}
+
+trait InnerObstacleSource {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        navmesh_transform: &Transform,
+    ) -> Vec<Vec2>;
+}
+
+impl<'a> InnerObstacleSource for TypedShape<'a> {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        _navmesh_transform: &Transform,
+    ) -> Vec<Vec2> {
+        let transform = obstacle_transform.compute_transform();
+
+        match self {
+            TypedShape::Ball(collider) => collider
+                .to_polyline(RESOLUTION)
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Cuboid(collider) => collider
+                .to_polyline()
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Capsule(collider) => collider
+                .to_polyline(RESOLUTION)
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Triangle(collider) => [collider.a, collider.b, collider.c]
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::TriMesh(collider) => collider
+                .vertices()
+                .iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Polyline(collider) => collider
+                .vertices()
+                .iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Compound(collider) => collider
+                .shapes()
+                .iter()
+                .flat_map(|(_iso, shape)| {
+                    // TODO: handle the isometry of each shape
+                    shape
+                        .as_typed_shape()
+                        .get_polygon(obstacle_transform, _navmesh_transform)
+                })
+                .collect(),
+            TypedShape::ConvexPolygon(collider) => collider
+                .points()
+                .iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::RoundCuboid(collider) => collider
+                .to_polyline(RESOLUTION)
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            // TODO: handle the round corner or RoundTriangle
+            TypedShape::RoundTriangle(collider) => [
+                collider.inner_shape.a,
+                collider.inner_shape.b,
+                collider.inner_shape.c,
+            ]
+            .into_iter()
+            .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+            .map(|p| p.xy())
+            .collect(),
+            TypedShape::RoundConvexPolygon(collider) => collider
+                .to_polyline(RESOLUTION)
+                .into_iter()
+                .map(|v| transform.transform_point(vec3(v.x, v.y, 0.0)))
+                .map(|p| p.xy())
+                .collect(),
+            TypedShape::Segment(_) => {
+                warn!("Segment collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::HalfSpace(_) => {
+                warn!("HalfSpace collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::HeightField(_) => {
+                warn!("HeightField collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::Custom(_) => {
+                warn!("Custom collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+        }
+    }
+}
+
+pub fn on_sleeping_inserted(trigger: Trigger<OnInsert, Sleeping>, mut commands: Commands) {
+    commands.entity(trigger.entity()).insert(CachableObstacle);
+}
+
+pub fn on_sleeping_removed(trigger: Trigger<OnRemove, Sleeping>, mut commands: Commands) {
+    commands
+        .entity(trigger.entity())
+        .remove::<CachableObstacle>();
+}
diff --git a/src/obstacles/avian3d.rs b/src/obstacles/avian3d.rs
new file mode 100644
index 0000000..015529d
--- /dev/null
+++ b/src/obstacles/avian3d.rs
@@ -0,0 +1,246 @@
+use avian3d::{
+    dynamics::rigid_body::Sleeping,
+    parry::{
+        math::Isometry,
+        na::{Const, OPoint, Vector3},
+        query::IntersectResult,
+        shape::{Polyline, TriMesh, TypedShape},
+    },
+    prelude::Collider,
+};
+use bevy::{math::vec3, prelude::*};
+
+use crate::updater::CachableObstacle;
+
+use super::{ObstacleSource, RESOLUTION};
+
+impl ObstacleSource for Collider {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        navmesh_transform: &Transform,
+    ) -> Vec<Vec2> {
+        self.shape_scaled()
+            .as_typed_shape()
+            .get_polygon(obstacle_transform, navmesh_transform)
+    }
+}
+
+trait InnerObstacleSource {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        navmesh_transform: &Transform,
+    ) -> Vec<Vec2>;
+}
+
+const BIAS: f32 = 0.0;
+
+impl<'a> InnerObstacleSource for TypedShape<'a> {
+    fn get_polygon(
+        &self,
+        obstacle_transform: &GlobalTransform,
+        navmesh_transform: &Transform,
+    ) -> Vec<Vec2> {
+        let transform = obstacle_transform.compute_transform();
+
+        let inverse_navmesh_transform = navmesh_transform.compute_affine().inverse();
+
+        let to_vec2 = |v: Vec3| inverse_navmesh_transform.transform_point3(v).xz();
+        let intersection_to_polygon = |intersection: IntersectResult<Polyline>| match intersection {
+            IntersectResult::Intersect(i) => i
+                .segments()
+                .map(|s| s.a)
+                .map(|p| to_vec2(vec3(p[0], p[1], p[2])))
+                .collect(),
+            IntersectResult::Negative => vec![],
+            IntersectResult::Positive => vec![],
+        };
+
+        let trimesh_to_local = |vertices: Vec<OPoint<f32, Const<3>>>| {
+            vertices
+                .iter()
+                .map(|p| transform.transform_point(vec3(p[0], p[1], p[2])))
+                .map(|p| navmesh_transform.transform_point(vec3(p[0], p[1], p[2])))
+                .map(|v| v.into())
+                .collect::<Vec<OPoint<f32, Const<3>>>>()
+        };
+
+        let intersection_plane = Isometry::from_parts(
+            navmesh_transform.translation.into(),
+            navmesh_transform.rotation.into(),
+        );
+        match self {
+            TypedShape::Cuboid(collider) => {
+                let (vertices, indices) = collider.to_trimesh();
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Ball(collider) => {
+                let (vertices, indices) = collider.to_trimesh(RESOLUTION, RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Capsule(collider) => {
+                let (vertices, indices) = collider.to_trimesh(RESOLUTION, RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::TriMesh(collider) => {
+                vec![intersection_to_polygon(collider.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::HeightField(collider) => {
+                let (vertices, indices) = collider.to_trimesh();
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Compound(collider) => {
+                collider
+                    .shapes()
+                    .iter()
+                    .map(|(_iso, shape)| {
+                        // TODO: handle the isometry of each shape
+                        shape
+                            .as_typed_shape()
+                            .get_polygon(obstacle_transform, navmesh_transform)
+                    })
+                    .collect()
+            }
+            TypedShape::ConvexPolyhedron(collider) => {
+                let (vertices, indices) = collider.to_trimesh();
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Cylinder(collider) => {
+                let (vertices, indices) = collider.to_trimesh(RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Cone(collider) => {
+                let (vertices, indices) = collider.to_trimesh(RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &Isometry::from_parts(
+                        navmesh_transform.translation.into(),
+                        navmesh_transform.rotation.into(),
+                    ),
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::RoundCuboid(collider) => {
+                let (vertices, indices) = collider.inner_shape.to_trimesh();
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::RoundCylinder(collider) => {
+                let (vertices, indices) = collider.inner_shape.to_trimesh(RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::RoundCone(collider) => {
+                let (vertices, indices) = collider.inner_shape.to_trimesh(RESOLUTION);
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::RoundConvexPolyhedron(collider) => {
+                let (vertices, indices) = collider.inner_shape.to_trimesh();
+                let trimesh = TriMesh::new(trimesh_to_local(vertices), indices);
+                vec![intersection_to_polygon(trimesh.intersection_with_plane(
+                    &intersection_plane,
+                    &Vector3::ith_axis(1),
+                    BIAS,
+                    f32::EPSILON,
+                ))]
+            }
+            TypedShape::Segment(_) => {
+                warn!("Segment collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::Triangle(_) => {
+                warn!("Triangle collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::Polyline(_) => {
+                warn!("Polyline collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::HalfSpace(_) => {
+                warn!("HalfSpace collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::RoundTriangle(_) => {
+                warn!("RoundTriangle collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+            TypedShape::Custom(_) => {
+                warn!("Custom collider not supported for NavMesh obstacle generation");
+                vec![]
+            }
+        }
+        .into_iter()
+        .flatten()
+        .collect()
+    }
+}
+
+pub fn on_sleeping_inserted(trigger: Trigger<OnInsert, Sleeping>, mut commands: Commands) {
+    commands.entity(trigger.entity()).insert(CachableObstacle);
+}
+
+pub fn on_sleeping_removed(trigger: Trigger<OnRemove, Sleeping>, mut commands: Commands) {
+    commands
+        .entity(trigger.entity())
+        .remove::<CachableObstacle>();
+}
diff --git a/src/obstacles/mod.rs b/src/obstacles/mod.rs
index 01409bb..ed0e8b5 100644
--- a/src/obstacles/mod.rs
+++ b/src/obstacles/mod.rs
@@ -4,7 +4,13 @@ use bevy::{
     transform::components::{GlobalTransform, Transform},
 };
 
+const RESOLUTION: u32 = 32;
+
 mod aabb;
+#[cfg(feature = "avian2d")]
+pub(crate) mod avian2d;
+#[cfg(feature = "avian3d")]
+pub(crate) mod avian3d;
 pub(crate) mod cached;
 pub(crate) mod primitive;
 
diff --git a/src/obstacles/primitive.rs b/src/obstacles/primitive.rs
index 2c41fac..a71ec3f 100644
--- a/src/obstacles/primitive.rs
+++ b/src/obstacles/primitive.rs
@@ -7,7 +7,7 @@ use bevy::{
     transform::components::{GlobalTransform, Transform},
 };
 
-use super::ObstacleSource;
+use super::{ObstacleSource, RESOLUTION};
 
 /// A primitive obstacle that can be used to create a [`NavMesh`].
 /// Variants are made from primitive shapes defined in Bevy
@@ -38,7 +38,7 @@ mod copypasta {
 
     use bevy::math::Vec2;
 
-    pub(crate) fn ellipse_inner(half_size: Vec2, resolution: usize) -> impl Iterator<Item = Vec2> {
+    pub(crate) fn ellipse_inner(half_size: Vec2, resolution: u32) -> impl Iterator<Item = Vec2> {
         (0..resolution + 1).map(move |i| {
             let angle = i as f64 * TAU / resolution as f64;
             let (x, y) = angle.sin_cos();
@@ -50,7 +50,7 @@ mod copypasta {
         direction_angle: f64,
         arc_angle: f64,
         radius: f32,
-        resolution: usize,
+        resolution: u32,
     ) -> impl Iterator<Item = Vec2> {
         (0..resolution + 1).map(move |i| {
             let start = direction_angle - arc_angle / 2.;
@@ -62,11 +62,7 @@ mod copypasta {
         })
     }
 
-    pub(crate) fn single_circle_coordinate(
-        radius: f32,
-        resolution: usize,
-        nth_point: usize,
-    ) -> Vec2 {
+    pub(crate) fn single_circle_coordinate(radius: f32, resolution: u32, nth_point: usize) -> Vec2 {
         let angle = nth_point as f64 * TAU / resolution as f64;
         let (x, y) = angle.sin_cos();
         Vec2::new(x as f32, y as f32) * radius
@@ -79,7 +75,6 @@ impl ObstacleSource for PrimitiveObstacle {
         obstacle_transform: &GlobalTransform,
         navmesh_transform: &Transform,
     ) -> Vec<Vec2> {
-        let resolution = 32;
         let transform = obstacle_transform.compute_transform();
         let to_vec2 = |v: Vec3| navmesh_transform.transform_point(v).xy();
         let to_navmesh = |v: Vec2| {
@@ -109,12 +104,12 @@ impl ObstacleSource for PrimitiveObstacle {
                 )))),
             ],
             PrimitiveObstacle::Circle(primitive) => {
-                copypasta::ellipse_inner(vec2(primitive.radius, primitive.radius), resolution)
+                copypasta::ellipse_inner(vec2(primitive.radius, primitive.radius), RESOLUTION)
                     .map(|v| to_vec2(transform.transform_point(to_navmesh(v))))
                     .collect()
             }
             PrimitiveObstacle::Ellipse(primitive) => {
-                copypasta::ellipse_inner(primitive.half_size, resolution)
+                copypasta::ellipse_inner(primitive.half_size, RESOLUTION)
                     .map(|v| to_vec2(transform.transform_point(to_navmesh(v))))
                     .collect()
             }
@@ -123,7 +118,7 @@ impl ObstacleSource for PrimitiveObstacle {
                     0.0,
                     primitive.arc.angle() as f64,
                     primitive.arc.radius,
-                    resolution,
+                    RESOLUTION,
                 )
                 .map(|v| to_vec2(transform.transform_point(to_navmesh(v))))
                 .collect::<Vec<_>>();
@@ -134,7 +129,7 @@ impl ObstacleSource for PrimitiveObstacle {
                 0.0,
                 primitive.arc.angle() as f64,
                 primitive.arc.radius,
-                resolution,
+                RESOLUTION,
             )
             .map(|v| to_vec2(transform.transform_point(to_navmesh(v))))
             .collect(),
@@ -143,7 +138,7 @@ impl ObstacleSource for PrimitiveObstacle {
                     0.0,
                     std::f64::consts::PI,
                     primitive.radius,
-                    resolution,
+                    RESOLUTION,
                 )
                 .map(|v| {
                     to_vec2(
@@ -156,7 +151,7 @@ impl ObstacleSource for PrimitiveObstacle {
                         0.0,
                         std::f64::consts::PI,
                         primitive.radius,
-                        resolution,
+                        RESOLUTION,
                     )
                     .map(|v| {
                         to_vec2(transform.transform_point(to_navmesh(
@@ -171,7 +166,7 @@ impl ObstacleSource for PrimitiveObstacle {
                 .map(|p| {
                     copypasta::single_circle_coordinate(
                         primitive.circumcircle.radius,
-                        primitive.sides,
+                        primitive.sides as u32,
                         p,
                     )
                 })
diff --git a/src/updater.rs b/src/updater.rs
index b5ce14c..8837a79 100644
--- a/src/updater.rs
+++ b/src/updater.rs
@@ -134,7 +134,8 @@ fn build_navmesh<T: ObstacleSource>(
     let mut triangulation = base.clone();
     let obstacle_aabbs = obstacles
         .iter()
-        .map(|(transform, obstacle)| obstacle.get_polygon(transform, &mesh_transform));
+        .map(|(transform, obstacle)| obstacle.get_polygon(transform, &mesh_transform))
+        .filter(|p| !p.is_empty());
     triangulation.add_obstacles(obstacle_aabbs);
 
     if settings.simplify != 0.0 {
@@ -425,5 +426,16 @@ impl<Obstacle: ObstacleSource, Marker: Component> Plugin
         app.add_systems(PostUpdate, trigger_navmesh_build::<Marker, Obstacle>)
             .add_systems(PreUpdate, (drop_dead_tasks, update_navmesh_asset).chain())
             .register_diagnostic(Diagnostic::new(NAVMESH_BUILD_DURATION));
+
+        #[cfg(feature = "avian2d")]
+        {
+            app.observe(crate::obstacles::avian2d::on_sleeping_inserted)
+                .observe(crate::obstacles::avian2d::on_sleeping_removed);
+        }
+        #[cfg(feature = "avian3d")]
+        {
+            app.observe(crate::obstacles::avian3d::on_sleeping_inserted)
+                .observe(crate::obstacles::avian3d::on_sleeping_removed);
+        }
     }
 }
diff --git a/wasm/auto_navmesh_aabb.html b/wasm/auto_navmesh_aabb.html
deleted file mode 100644
index f04100f..0000000
--- a/wasm/auto_navmesh_aabb.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!doctype html>
-<html lang="en">
-    <head>
-        <title>Navmesh with Polyanya</title>
-        <style>
-            .disable-select {
-                user-select: none;
-                /* supported by Chrome and Opera */
-                -webkit-user-select: none;
-                /* Safari */
-                -khtml-user-select: none;
-                /* Konqueror HTML */
-                -moz-user-select: none;
-                /* Firefox */
-                -ms-user-select: none;
-                /* Internet Explorer/Edge */
-            }
-        </style>
-    </head>
-
-    <script type="module">
-        import init from "./auto_navmesh_aabb.js";
-        init();
-    </script>
-
-    <body style="margin: 0px; height: 100vh" class="disable-select"></body>
-</html>
diff --git a/wasm/auto_navmesh_primitive.html b/wasm/auto_navmesh_primitive.html
deleted file mode 100644
index 6f49c30..0000000
--- a/wasm/auto_navmesh_primitive.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!doctype html>
-<html lang="en">
-    <head>
-        <title>Navmesh with Polyanya</title>
-        <style>
-            .disable-select {
-                user-select: none;
-                /* supported by Chrome and Opera */
-                -webkit-user-select: none;
-                /* Safari */
-                -khtml-user-select: none;
-                /* Konqueror HTML */
-                -moz-user-select: none;
-                /* Firefox */
-                -ms-user-select: none;
-                /* Internet Explorer/Edge */
-            }
-        </style>
-    </head>
-
-    <script type="module">
-        import init from "./auto_navmesh_primitive.js";
-        init();
-    </script>
-
-    <body style="margin: 0px; height: 100vh" class="disable-select"></body>
-</html>
diff --git a/wasm/demo.html b/wasm/demo.html
deleted file mode 100644
index 8070258..0000000
--- a/wasm/demo.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-    <style>
-        .disable-select {
-            user-select: none;
-            /* supported by Chrome and Opera */
-            -webkit-user-select: none;
-            /* Safari */
-            -khtml-user-select: none;
-            /* Konqueror HTML */
-            -moz-user-select: none;
-            /* Firefox */
-            -ms-user-select: none;
-            /* Internet Explorer/Edge */
-        }
-    </style>
-</head>
-
-<script type="module">
-    import init from './demo.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh" class="disable-select">
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/wasm/moving.html b/wasm/example.html
similarity index 93%
rename from wasm/moving.html
rename to wasm/example.html
index 489705c..faae311 100644
--- a/wasm/moving.html
+++ b/wasm/example.html
@@ -22,7 +22,7 @@
 </head>
 
 <script type="module">
-    import init from './moving.js'
+    import init from './name-of-example.js'
     init()
 </script>
 
diff --git a/wasm/gltf.html b/wasm/gltf.html
deleted file mode 100644
index 6507566..0000000
--- a/wasm/gltf.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-    <style>
-        .disable-select {
-            user-select: none;
-            /* supported by Chrome and Opera */
-            -webkit-user-select: none;
-            /* Safari */
-            -khtml-user-select: none;
-            /* Konqueror HTML */
-            -moz-user-select: none;
-            /* Firefox */
-            -ms-user-select: none;
-            /* Internet Explorer/Edge */
-        }
-    </style>
-</head>
-
-<script type="module">
-    import init from './gltf.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh" class="disable-select">
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/wasm/index.html b/wasm/index.html
index 305b9c8..6224cac 100644
--- a/wasm/index.html
+++ b/wasm/index.html
@@ -22,45 +22,70 @@ <h1>Links</h1>
     <h1>Examples</h1>
     <div style="display: flex; flex-wrap: wrap;">
         <a href="primitive_3d.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="primitive_3d.png" /></div>
-            <div>Auto updating a NavMesh from Bevy shapes, in 3d</div>
+            <div><img src="screenshots/primitive_3d.png" /></div>
+            <div>Auto updating a NavMesh from Bevy shapes</div>
         </a>
+        <a href="auto_navmesh_aabb.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
+            <div><img src="screenshots/auto_navmesh_aabb.png" /></div>
+            <div>Auto updating a NavMesh from Bevy `Aabb` component</div>
+        </a>
+        <a href="auto_navmesh_primitive.html"
+            style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
+            <div><img src="screenshots/auto_navmesh_primitive.png" /></div>
+            <div>NavMesh updated using primitive shapes (rectangle, circle, ...)</div>
+        </a>
+        <a href="demo.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
+            <div><img src="screenshots/demo.png" /></div>
+            <div>Demo to test NavMesh settings</div>
+        </a>
+    </div>
+
+    <h2>Avian integration</h2>
+    <div style="display: flex; flex-wrap: wrap;">
+        <a href="auto_navmesh_avian2d.html"
+            style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
+            <div><img src="screenshots/auto_navmesh_avian2d.png" /></div>
+            <div>Auto updating a NavMesh with colliders from Avian2d</div>
+        </a>
+        <a href="auto_navmesh_avian3d.html"
+            style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
+            <div><img src="screenshots/auto_navmesh_avian3d.png" /></div>
+            <div>Auto updating a NavMesh with colliders from Avian3d</div>
+        </a>
+    </div>
+
+    <h2>Others</h2>
+    <div style="display: flex; flex-wrap: wrap;">
         <a href="many.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="many.png" /></div>
+            <div><img src="screenshots/many.png" /></div>
             <div>Spawn many agents
                 and run a lot of concurrent pathfinding tasks</div>
         </a>
         <a href="lines.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="lines.png" /></div>
+            <div><img src="screenshots/lines.png" /></div>
             <div>Showing path
                 lines</div>
         </a>
         <a href="moving.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="moving.png" /></div>
+            <div><img src="screenshots/moving.png" /></div>
             <div>Moving a dot
                 around the
                 meshes</div>
         </a>
         <a href="gltf.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="gltf.png" /></div>
+            <div><img src="screenshots/gltf.png" /></div>
             <div>Loading a navmesh
                 from a gLTF
                 file</div>
         </a>
         <a href="random_obstacles.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="random_obstacles.png" /></div>
+            <div><img src="screenshots/random_obstacles.png" /></div>
             <div>Navmesh from random obstacles</div>
         </a>
         <a href="auto_navmesh_aabb.html" style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="auto_navmesh_aabb.png" /></div>
+            <div><img src="screenshots/auto_navmesh_aabb.png" /></div>
             <div>NavMesh automatically updated from obstacles using `Aabb`</div>
         </a>
-        <a href="auto_navmesh_primitive.html"
-            style="margin: 20px; font-size: 1.5rem; display: flex; flex-direction: column">
-            <div><img src="auto_navmesh_primitive.png" /></div>
-            <div>NavMesh automatically updated from obstacles using primitive shapes (rectangle, circle, regular
-                polygon, ...)</div>
-        </a>
     </div>
 </body>
 
diff --git a/wasm/lines.html b/wasm/lines.html
deleted file mode 100644
index 9908357..0000000
--- a/wasm/lines.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-</head>
-
-<script type="module">
-    import init from './lines.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh">
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/wasm/many.html b/wasm/many.html
deleted file mode 100644
index 5c4b285..0000000
--- a/wasm/many.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-    <style>
-        .disable-select {
-            user-select: none;
-            /* supported by Chrome and Opera */
-            -webkit-user-select: none;
-            /* Safari */
-            -khtml-user-select: none;
-            /* Konqueror HTML */
-            -moz-user-select: none;
-            /* Firefox */
-            -ms-user-select: none;
-            /* Internet Explorer/Edge */
-        }
-    </style>
-</head>
-
-<script type="module">
-    import init from './many.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh" class="disable-select">
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/wasm/primitive_3d.html b/wasm/primitive_3d.html
deleted file mode 100644
index f380093..0000000
--- a/wasm/primitive_3d.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-    <style>
-        .disable-select {
-            user-select: none;
-            /* supported by Chrome and Opera */
-            -webkit-user-select: none;
-            /* Safari */
-            -khtml-user-select: none;
-            /* Konqueror HTML */
-            -moz-user-select: none;
-            /* Firefox */
-            -ms-user-select: none;
-            /* Internet Explorer/Edge */
-        }
-    </style>
-</head>
-
-<script type="module">
-    import init from './primitive_3d.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh" class="disable-select">
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/wasm/random_obstacles.html b/wasm/random_obstacles.html
deleted file mode 100644
index 8259be6..0000000
--- a/wasm/random_obstacles.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>
-        Navmesh with Polyanya
-    </title>
-    <style>
-        .disable-select {
-            user-select: none;
-            /* supported by Chrome and Opera */
-            -webkit-user-select: none;
-            /* Safari */
-            -khtml-user-select: none;
-            /* Konqueror HTML */
-            -moz-user-select: none;
-            /* Firefox */
-            -ms-user-select: none;
-            /* Internet Explorer/Edge */
-        }
-    </style>
-</head>
-
-<script type="module">
-    import init from './random_obstacles.js'
-    init()
-</script>
-
-<body style="margin: 0px; height: 100vh" class="disable-select">
-
-</body>
-
-</html>
\ No newline at end of file