diff --git a/Cargo.toml b/Cargo.toml
index b3e0074..bc04f24 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "bevy_polyline"
-version = "0.8.1"
+version = "0.9.0"
 description = "Polyline Rendering for Bevy"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/ForesightMiningSoftwareCorporation/bevy_polyline"
@@ -18,21 +18,17 @@ authors = [
 
 [dependencies]
 bitflags = "2.3"
-bevy = { version = "0.12", default-features = false, features = [
+bevy = { version = "0.13", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
 ] }
 
-[dependencies.naga]
-features = ["glsl-in", "spv-out", "wgsl-out"]
-version = "0.13"
-
 [dev-dependencies]
 lazy_static = "1.4.0"
 rand = "0.8.4"
 ringbuffer = "0.15"
-bevy = { version = "0.12", default-features = false, features = [
+bevy = { version = "0.13", default-features = false, features = [
     "bevy_winit",
     "bevy_pbr",
     "x11",
diff --git a/examples/depth_bias.rs b/examples/depth_bias.rs
index 78a59a6..7efd599 100644
--- a/examples/depth_bias.rs
+++ b/examples/depth_bias.rs
@@ -41,11 +41,11 @@ fn rotate_plane(time: Res<Time>, mut animated: Query<(&mut Transform, &Rotating)
     }
 }
 
-fn move_camera(input: Res<Input<KeyCode>>, mut camera: Query<&mut Transform, With<Camera>>) {
+fn move_camera(input: Res<ButtonInput<KeyCode>>, mut camera: Query<&mut Transform, With<Camera>>) {
     if let Ok(mut camera_transform) = camera.get_single_mut() {
         let trans = &mut camera_transform.translation;
-        let go_forward = input.any_pressed([KeyCode::Up, KeyCode::I, KeyCode::W]);
-        let go_backward = input.any_pressed([KeyCode::Down, KeyCode::K, KeyCode::S]);
+        let go_forward = input.any_pressed([KeyCode::ArrowUp, KeyCode::KeyI, KeyCode::KeyW]);
+        let go_backward = input.any_pressed([KeyCode::ArrowDown, KeyCode::KeyK, KeyCode::KeyS]);
         if go_forward && trans.x > 10.0 {
             trans.x -= 2.0;
         } else if go_backward && trans.x < 500.0 {
@@ -65,8 +65,8 @@ fn setup(
         .insert(Transform::from_xyz(100.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y));
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(shape::Box::new(0.01, 100.0, 10000.0).into()),
-            material: pbr_materials.add(Color::WHITE.into()),
+            mesh: meshes.add(Cuboid::from_size(Vec3::new(0.01, 100.0, 10000.0)).mesh()),
+            material: pbr_materials.add(Color::WHITE),
             ..default()
         },
         Rotating(30.0),
diff --git a/examples/linestrip.rs b/examples/linestrip.rs
index b4fa72f..3303531 100644
--- a/examples/linestrip.rs
+++ b/examples/linestrip.rs
@@ -43,16 +43,17 @@ fn setup(
 
     // circular base
     commands.spawn(PbrBundle {
-        mesh: meshes.add(shape::Circle::new(4.0).into()),
-        material: standard_materials.add(Color::WHITE.into()),
+        mesh: meshes.add(Circle::new(4.0)),
+        material: standard_materials.add(Color::WHITE),
         transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2))
             .with_translation(Vec3::new(0.0, -0.5, 0.0)),
         ..default()
     });
     // cube
     commands.spawn(PbrBundle {
-        mesh: meshes.add(shape::Cube { size: 1.0 }.into()),
-        material: standard_materials.add(Color::rgb_u8(124, 144, 255).into()),
+        mesh: meshes.add(Cuboid::from_size(Vec3::ONE)),
+        material: standard_materials.add(Color::rgb_u8(124, 144, 255)),
+        transform: Transform::from_xyz(0.0, 0.0, 0.0),
         ..default()
     });
 
diff --git a/examples/nbody.rs b/examples/nbody.rs
index 0f2e198..ba5a39c 100644
--- a/examples/nbody.rs
+++ b/examples/nbody.rs
@@ -205,7 +205,7 @@ fn update_trails(
     mut polylines: ResMut<Assets<Polyline>>,
     mut query: Query<(&Body, &mut Trail, &Handle<Polyline>)>,
 ) {
-    query.for_each_mut(|(body, mut trail, polyline)| {
+    query.iter_mut().for_each(|(body, mut trail, polyline)| {
         if let Some(position) = trail.0.back() {
             let last_vec = *position - body.position;
             let last_last_vec = if let Some(position) = trail.0.get_signed(-2) {
diff --git a/examples/perspective.rs b/examples/perspective.rs
index 3fc4509..0e266a0 100644
--- a/examples/perspective.rs
+++ b/examples/perspective.rs
@@ -41,28 +41,28 @@ fn setup(
 
 fn move_camera(
     mut q: Query<&mut Transform, With<Camera>>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
     time: Res<Time>,
 ) {
     let speed = 5.0;
     for mut t in &mut q {
         let mut dir = Vec3::ZERO;
-        if keyboard_input.pressed(KeyCode::W) {
+        if keyboard_input.pressed(KeyCode::KeyW) {
             dir.z -= 1.0;
         }
-        if keyboard_input.pressed(KeyCode::S) {
+        if keyboard_input.pressed(KeyCode::KeyS) {
             dir.z += 1.0;
         }
-        if keyboard_input.pressed(KeyCode::A) {
+        if keyboard_input.pressed(KeyCode::KeyA) {
             dir.x -= 1.0;
         }
-        if keyboard_input.pressed(KeyCode::D) {
+        if keyboard_input.pressed(KeyCode::KeyD) {
             dir.x += 1.0;
         }
-        if keyboard_input.pressed(KeyCode::Q) {
+        if keyboard_input.pressed(KeyCode::KeyQ) {
             dir.y -= 1.0;
         }
-        if keyboard_input.pressed(KeyCode::E) {
+        if keyboard_input.pressed(KeyCode::KeyE) {
             dir.y += 1.0;
         }
         t.translation += dir * time.delta_seconds() * speed;
@@ -71,10 +71,10 @@ fn move_camera(
 
 fn toggle_perspective(
     mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
 ) {
     for (_, mat) in polyline_materials.iter_mut() {
-        if keyboard_input.just_pressed(KeyCode::X) {
+        if keyboard_input.just_pressed(KeyCode::KeyX) {
             mat.perspective = !mat.perspective;
         }
     }
diff --git a/src/material.rs b/src/material.rs
index eb9c613..76e21eb 100644
--- a/src/material.rs
+++ b/src/material.rs
@@ -13,12 +13,12 @@ use bevy::{
         },
     },
     prelude::*,
-    reflect::{TypePath, TypeUuid},
+    reflect::TypePath,
     render::{
         extract_component::ExtractComponentPlugin,
-        render_asset::{RenderAsset, RenderAssetPlugin, RenderAssets},
+        render_asset::{RenderAsset, RenderAssetPlugin, RenderAssetUsages, RenderAssets},
         render_phase::*,
-        render_resource::*,
+        render_resource::{binding_types::uniform_buffer, *},
         renderer::{RenderDevice, RenderQueue},
         view::{ExtractedView, ViewUniformOffset, VisibleEntities},
         Render, RenderApp, RenderSet,
@@ -26,8 +26,7 @@ use bevy::{
 };
 use std::fmt::Debug;
 
-#[derive(Asset, Debug, PartialEq, Clone, Copy, TypeUuid, TypePath)]
-#[uuid = "69b87497-2ba0-4c38-ba82-f54bf1ffe873"]
+#[derive(Asset, Debug, PartialEq, Clone, Copy, TypePath)]
 pub struct PolylineMaterial {
     /// Width of the line.
     ///
@@ -72,19 +71,13 @@ impl Default for PolylineMaterial {
 
 impl PolylineMaterial {
     pub fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayout {
-        render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[BindGroupLayoutEntry {
-                binding: 0,
-                visibility: ShaderStages::VERTEX,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Uniform,
-                    has_dynamic_offset: false,
-                    min_binding_size: BufferSize::new(PolylineMaterialUniform::min_size().into()),
-                },
-                count: None,
-            }],
-            label: Some("polyline_material_layout"),
-        })
+        render_device.create_bind_group_layout(
+            "polyline_material_layout",
+            &BindGroupLayoutEntries::single(
+                ShaderStages::VERTEX,
+                uniform_buffer::<PolylineMaterialUniform>(false),
+            ),
+        )
     }
 
     #[inline]
@@ -114,7 +107,6 @@ pub struct GpuPolylineMaterial {
 }
 
 impl RenderAsset for PolylineMaterial {
-    type ExtractedAsset = PolylineMaterial;
     type PreparedAsset = GpuPolylineMaterial;
     type Param = (
         SRes<RenderDevice>,
@@ -122,21 +114,18 @@ impl RenderAsset for PolylineMaterial {
         SRes<PolylineMaterialPipeline>,
     );
 
-    fn extract_asset(&self) -> Self::ExtractedAsset {
-        *self
+    fn asset_usage(&self) -> bevy::render::render_asset::RenderAssetUsages {
+        RenderAssetUsages::default()
     }
 
     fn prepare_asset(
-        material: Self::ExtractedAsset,
+        self,
         (device, queue, polyline_pipeline): &mut bevy::ecs::system::SystemParamItem<Self::Param>,
-    ) -> Result<
-        Self::PreparedAsset,
-        bevy::render::render_asset::PrepareAssetError<Self::ExtractedAsset>,
-    > {
+    ) -> Result<Self::PreparedAsset, bevy::render::render_asset::PrepareAssetError<Self>> {
         let value = PolylineMaterialUniform {
-            width: material.width,
-            depth_bias: material.depth_bias,
-            color: material.color.as_linear_rgba_f32().into(),
+            width: self.width,
+            depth_bias: self.depth_bias,
+            color: self.color.as_linear_rgba_f32().into(),
         };
 
         let mut buffer = UniformBuffer::from(value);
@@ -151,7 +140,7 @@ impl RenderAsset for PolylineMaterial {
             }],
         );
 
-        let alpha_mode = if material.color.a() < 1.0 {
+        let alpha_mode = if self.color.a() < 1.0 {
             AlphaMode::Blend
         } else {
             AlphaMode::Opaque
@@ -159,7 +148,7 @@ impl RenderAsset for PolylineMaterial {
 
         Ok(GpuPolylineMaterial {
             buffer,
-            perspective: material.perspective,
+            perspective: self.perspective,
             alpha_mode,
             bind_group,
         })
@@ -237,15 +226,15 @@ type DrawMaterial = (
 
 pub struct SetPolylineViewBindGroup<const I: usize>;
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineViewBindGroup<I> {
-    type ViewWorldQuery = (Read<ViewUniformOffset>, Read<PolylineViewBindGroup>);
-    type ItemWorldQuery = ();
+    type ViewQuery = (Read<ViewUniformOffset>, Read<PolylineViewBindGroup>);
+    type ItemQuery = ();
     type Param = ();
 
     #[inline]
     fn render<'w>(
         _item: &P,
-        (view_uniform, mesh_view_bind_group): ROQueryItem<'w, Self::ViewWorldQuery>,
-        _entity: ROQueryItem<'w, Self::ItemWorldQuery>,
+        (view_uniform, mesh_view_bind_group): ROQueryItem<'w, Self::ViewQuery>,
+        _entity: Option<ROQueryItem<'w, Self::ItemQuery>>,
         _param: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
@@ -256,18 +245,21 @@ impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineViewBindGroup
 
 pub struct SetMaterialBindGroup<const I: usize>;
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetMaterialBindGroup<I> {
-    type ViewWorldQuery = ();
-    type ItemWorldQuery = Read<Handle<PolylineMaterial>>;
+    type ViewQuery = ();
+    type ItemQuery = Read<Handle<PolylineMaterial>>;
     type Param = SRes<RenderAssets<PolylineMaterial>>;
 
     fn render<'w>(
         _item: &P,
-        _view: ROQueryItem<'w, Self::ViewWorldQuery>,
-        material_handle: ROQueryItem<'w, Self::ItemWorldQuery>,
+        _view: ROQueryItem<'w, Self::ViewQuery>,
+        material_handle: Option<ROQueryItem<'w, Self::ItemQuery>>,
         materials: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
-        let material = materials.into_inner().get(material_handle).unwrap();
+        let material = materials
+            .into_inner()
+            .get(material_handle.unwrap())
+            .unwrap();
         pass.set_bind_group(
             I,
             PolylineMaterial::bind_group(material),
@@ -296,22 +288,22 @@ pub fn queue_material_polylines(
         &mut RenderPhase<Transparent3d>,
     )>,
 ) {
+    let draw_opaque = opaque_draw_functions
+        .read()
+        .get_id::<DrawMaterial>()
+        .unwrap();
+    let draw_alpha_mask = alpha_mask_draw_functions
+        .read()
+        .get_id::<DrawMaterial>()
+        .unwrap();
+    let draw_transparent = transparent_draw_functions
+        .read()
+        .get_id::<DrawMaterial>()
+        .unwrap();
+
     for (view, visible_entities, mut opaque_phase, mut alpha_mask_phase, mut transparent_phase) in
         views.iter_mut()
     {
-        let draw_opaque = opaque_draw_functions
-            .read()
-            .get_id::<DrawMaterial>()
-            .unwrap();
-        let draw_alpha_mask = alpha_mask_draw_functions
-            .read()
-            .get_id::<DrawMaterial>()
-            .unwrap();
-        let draw_transparent = transparent_draw_functions
-            .read()
-            .get_id::<DrawMaterial>()
-            .unwrap();
-
         let inverse_view_matrix = view.transform.compute_matrix().inverse();
         let inverse_view_row_2 = inverse_view_matrix.row(2);
 
@@ -319,117 +311,68 @@ pub fn queue_material_polylines(
         polyline_key |= PolylinePipelineKey::from_hdr(view.hdr);
 
         for visible_entity in &visible_entities.entities {
-            if let Ok((material_handle, polyline_uniform)) = material_meshes.get(*visible_entity) {
-                if let Some(material) = render_materials.get(material_handle) {
-                    if material.alpha_mode == AlphaMode::Blend {
-                        polyline_key |= PolylinePipelineKey::TRANSPARENT_MAIN_PASS
-                    }
-                    if material.perspective {
-                        polyline_key |= PolylinePipelineKey::PERSPECTIVE
-                    }
-                    let pipeline_id =
-                        pipelines.specialize(&pipeline_cache, &material_pipeline, polyline_key);
-
-                    // NOTE: row 2 of the inverse view matrix dotted with column 3 of the model matrix
-                    // gives the z component of translation of the mesh in view space
-                    let polyline_z = inverse_view_row_2.dot(polyline_uniform.transform.col(3));
-                    match material.alpha_mode {
-                        AlphaMode::Opaque => {
-                            opaque_phase.add(Opaque3d {
-                                entity: *visible_entity,
-                                draw_function: draw_opaque,
-                                pipeline: pipeline_id,
-                                // NOTE: Front-to-back ordering for opaque with ascending sort means near should have the
-                                // lowest sort key and getting further away should increase. As we have
-                                // -z in front of the camera, values in view space decrease away from the
-                                // camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
-                                distance: -polyline_z,
-                                batch_range: 0..1,
-                                dynamic_offset: None,
-                            });
-                        }
-                        AlphaMode::Mask(_) => {
-                            alpha_mask_phase.add(AlphaMask3d {
-                                entity: *visible_entity,
-                                draw_function: draw_alpha_mask,
-                                pipeline: pipeline_id,
-                                // NOTE: Front-to-back ordering for alpha mask with ascending sort means near should have the
-                                // lowest sort key and getting further away should increase. As we have
-                                // -z in front of the camera, values in view space decrease away from the
-                                // camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
-                                distance: -polyline_z,
-                                batch_range: 0..1,
-                                dynamic_offset: None,
-                            });
-                        }
-                        AlphaMode::Blend
-                        | AlphaMode::Premultiplied
-                        | AlphaMode::Add
-                        | AlphaMode::Multiply => {
-                            transparent_phase.add(Transparent3d {
-                                entity: *visible_entity,
-                                draw_function: draw_transparent,
-                                pipeline: pipeline_id,
-                                // NOTE: Back-to-front ordering for transparent with ascending sort means far should have the
-                                // lowest sort key and getting closer should increase. As we have
-                                // -z in front of the camera, the largest distance is -far with values increasing toward the
-                                // camera. As such we can just use mesh_z as the distance
-                                distance: polyline_z,
-                                batch_range: 0..1,
-                                dynamic_offset: None,
-                            });
-                        }
-                    }
+            let Ok((material_handle, polyline_uniform)) = material_meshes.get(*visible_entity)
+            else {
+                continue;
+            };
+            let Some(material) = render_materials.get(material_handle) else {
+                continue;
+            };
+            if material.alpha_mode == AlphaMode::Blend {
+                polyline_key |= PolylinePipelineKey::TRANSPARENT_MAIN_PASS
+            }
+            if material.perspective {
+                polyline_key |= PolylinePipelineKey::PERSPECTIVE
+            }
+            let pipeline_id =
+                pipelines.specialize(&pipeline_cache, &material_pipeline, polyline_key);
+
+            // NOTE: row 2 of the inverse view matrix dotted with column 3 of the model matrix
+            // gives the z component of translation of the mesh in view space
+            let polyline_z = inverse_view_row_2.dot(polyline_uniform.transform.col(3));
+            match material.alpha_mode {
+                AlphaMode::Opaque => {
+                    opaque_phase.add(Opaque3d {
+                        entity: *visible_entity,
+                        draw_function: draw_opaque,
+                        pipeline: pipeline_id,
+                        batch_range: 0..1,
+                        dynamic_offset: None,
+                        asset_id: Default::default(),
+                    });
+                }
+                AlphaMode::Mask(_) => {
+                    alpha_mask_phase.add(AlphaMask3d {
+                        entity: *visible_entity,
+                        draw_function: draw_alpha_mask,
+                        pipeline: pipeline_id,
+                        // NOTE: Front-to-back ordering for alpha mask with ascending sort means near should have the
+                        // lowest sort key and getting further away should increase. As we have
+                        // -z in front of the camera, values in view space decrease away from the
+                        // camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
+                        distance: -polyline_z,
+                        batch_range: 0..1,
+                        dynamic_offset: None,
+                    });
+                }
+                AlphaMode::Blend
+                | AlphaMode::Premultiplied
+                | AlphaMode::Add
+                | AlphaMode::Multiply => {
+                    transparent_phase.add(Transparent3d {
+                        entity: *visible_entity,
+                        draw_function: draw_transparent,
+                        pipeline: pipeline_id,
+                        // NOTE: Back-to-front ordering for transparent with ascending sort means far should have the
+                        // lowest sort key and getting closer should increase. As we have
+                        // -z in front of the camera, the largest distance is -far with values increasing toward the
+                        // camera. As such we can just use mesh_z as the distance
+                        distance: polyline_z,
+                        batch_range: 0..1,
+                        dynamic_offset: None,
+                    });
                 }
             }
         }
     }
 }
-
-/// Sets how a material's base color alpha channel is used for transparency.
-#[derive(Debug, Default, Reflect, Copy, Clone, PartialEq)]
-#[reflect(Default, Debug)]
-pub enum AlphaMode {
-    /// Base color alpha values are overridden to be fully opaque (1.0).
-    #[default]
-    Opaque,
-    /// Reduce transparency to fully opaque or fully transparent
-    /// based on a threshold.
-    ///
-    /// Compares the base color alpha value to the specified threshold.
-    /// If the value is below the threshold,
-    /// considers the color to be fully transparent (alpha is set to 0.0).
-    /// If it is equal to or above the threshold,
-    /// considers the color to be fully opaque (alpha is set to 1.0).
-    Mask(f32),
-    /// The base color alpha value defines the opacity of the color.
-    /// Standard alpha-blending is used to blend the fragment's color
-    /// with the color behind it.
-    Blend,
-    /// Similar to [`AlphaMode::Blend`], however assumes RGB channel values are
-    /// [premultiplied](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied).
-    ///
-    /// For otherwise constant RGB values, behaves more like [`AlphaMode::Blend`] for
-    /// alpha values closer to 1.0, and more like [`AlphaMode::Add`] for
-    /// alpha values closer to 0.0.
-    ///
-    /// Can be used to avoid “border” or “outline” artifacts that can occur
-    /// when using plain alpha-blended textures.
-    Premultiplied,
-    /// Combines the color of the fragments with the colors behind them in an
-    /// additive process, (i.e. like light) producing lighter results.
-    ///
-    /// Black produces no effect. Alpha values can be used to modulate the result.
-    ///
-    /// Useful for effects like holograms, ghosts, lasers and other energy beams.
-    Add,
-    /// Combines the color of the fragments with the colors behind them in a
-    /// multiplicative process, (i.e. like pigments) producing darker results.
-    ///
-    /// White produces no effect. Alpha values can be used to modulate the result.
-    ///
-    /// Useful for effects like stained glass, window tint film and some colored liquids.
-    Multiply,
-}
-
-impl Eq for AlphaMode {}
diff --git a/src/polyline.rs b/src/polyline.rs
index 71520bb..5b75bf6 100644
--- a/src/polyline.rs
+++ b/src/polyline.rs
@@ -9,12 +9,12 @@ use bevy::{
         },
     },
     prelude::*,
-    reflect::{TypePath, TypeUuid},
+    reflect::TypePath,
     render::{
         extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
-        render_asset::{RenderAsset, RenderAssetPlugin, RenderAssets},
+        render_asset::{RenderAsset, RenderAssetPlugin, RenderAssetUsages, RenderAssets},
         render_phase::{PhaseItem, RenderCommand, RenderCommandResult, TrackedRenderPass},
-        render_resource::*,
+        render_resource::{binding_types::uniform_buffer, *},
         renderer::RenderDevice,
         texture::BevyDefault,
         view::{ViewUniform, ViewUniforms},
@@ -64,31 +64,25 @@ pub struct PolylineBundle {
     pub view_visibility: ViewVisibility,
 }
 
-#[derive(Debug, Default, Asset, Clone, TypeUuid, TypePath)]
-#[uuid = "c76af88a-8afe-405c-9a64-0a7d845d2546"]
+#[derive(Debug, Default, Asset, Clone, TypePath)]
 pub struct Polyline {
     pub vertices: Vec<Vec3>,
 }
 
 impl RenderAsset for Polyline {
-    type ExtractedAsset = Polyline;
-
     type PreparedAsset = GpuPolyline;
 
     type Param = SRes<RenderDevice>;
 
-    fn extract_asset(&self) -> Self::ExtractedAsset {
-        self.clone()
+    fn asset_usage(&self) -> RenderAssetUsages {
+        RenderAssetUsages::default()
     }
 
     fn prepare_asset(
-        polyline: Self::ExtractedAsset,
+        self,
         render_device: &mut bevy::ecs::system::SystemParamItem<Self::Param>,
-    ) -> Result<
-        Self::PreparedAsset,
-        bevy::render::render_asset::PrepareAssetError<Self::ExtractedAsset>,
-    > {
-        let vertex_buffer_data = cast_slice(polyline.vertices.as_slice());
+    ) -> Result<Self::PreparedAsset, bevy::render::render_asset::PrepareAssetError<Self>> {
+        let vertex_buffer_data = cast_slice(self.vertices.as_slice());
         let vertex_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
             usage: BufferUsages::VERTEX,
             label: Some("Polyline Vertex Buffer"),
@@ -97,7 +91,7 @@ impl RenderAsset for Polyline {
 
         Ok(GpuPolyline {
             vertex_buffer,
-            vertex_count: polyline.vertices.len() as u32,
+            vertex_count: self.vertices.len() as u32,
         })
     }
 }
@@ -159,36 +153,21 @@ pub struct PolylinePipeline {
 impl FromWorld for PolylinePipeline {
     fn from_world(world: &mut World) -> Self {
         let render_device = world.get_resource::<RenderDevice>().unwrap();
-        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[
-                // View
-                BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: ShaderStages::VERTEX,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Uniform,
-                        has_dynamic_offset: true,
-                        min_binding_size: BufferSize::new(ViewUniform::min_size().into()),
-                    },
-                    count: None,
-                },
-            ],
-            label: Some("polyline_view_layout"),
-        });
+        let view_layout = render_device.create_bind_group_layout(
+            "polyline_view_layout",
+            &BindGroupLayoutEntries::single(
+                ShaderStages::VERTEX,
+                uniform_buffer::<ViewUniform>(true),
+            ),
+        );
 
-        let polyline_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[BindGroupLayoutEntry {
-                binding: 0,
-                visibility: ShaderStages::VERTEX,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Uniform,
-                    has_dynamic_offset: true,
-                    min_binding_size: BufferSize::new(PolylineUniform::min_size().into()),
-                },
-                count: None,
-            }],
-            label: Some("polyline_layout"),
-        });
+        let polyline_layout = render_device.create_bind_group_layout(
+            "polyline_layout",
+            &BindGroupLayoutEntries::single(
+                ShaderStages::VERTEX,
+                uniform_buffer::<PolylineUniform>(true),
+            ),
+        );
 
         PolylinePipeline {
             view_layout,
@@ -397,38 +376,42 @@ pub fn prepare_polyline_view_bind_groups(
 
 pub struct SetPolylineBindGroup<const I: usize>;
 impl<const I: usize, P: PhaseItem> RenderCommand<P> for SetPolylineBindGroup<I> {
-    type ViewWorldQuery = ();
-    type ItemWorldQuery = Read<DynamicUniformIndex<PolylineUniform>>;
+    type ViewQuery = ();
+    type ItemQuery = Read<DynamicUniformIndex<PolylineUniform>>;
     type Param = SRes<PolylineBindGroup>;
 
     #[inline]
     fn render<'w>(
         _item: &P,
-        _view: ROQueryItem<'w, Self::ViewWorldQuery>,
-        polyline_index: ROQueryItem<'w, Self::ItemWorldQuery>,
+        _view: ROQueryItem<'w, Self::ViewQuery>,
+        polyline_index: Option<ROQueryItem<'w, Self::ItemQuery>>,
         bind_group: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
-        pass.set_bind_group(I, &bind_group.into_inner().value, &[polyline_index.index()]);
+        pass.set_bind_group(
+            I,
+            &bind_group.into_inner().value,
+            &[polyline_index.unwrap().index()],
+        );
         RenderCommandResult::Success
     }
 }
 
 pub struct DrawPolyline;
 impl<P: PhaseItem> RenderCommand<P> for DrawPolyline {
-    type ViewWorldQuery = ();
-    type ItemWorldQuery = Read<Handle<Polyline>>;
+    type ViewQuery = ();
+    type ItemQuery = Read<Handle<Polyline>>;
     type Param = SRes<RenderAssets<Polyline>>;
 
     #[inline]
     fn render<'w>(
         _item: &P,
-        _view: ROQueryItem<'w, Self::ViewWorldQuery>,
-        pl_handle: ROQueryItem<'w, Self::ItemWorldQuery>,
+        _view: ROQueryItem<'w, Self::ViewQuery>,
+        pl_handle: Option<ROQueryItem<'w, Self::ItemQuery>>,
         polylines: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
-        if let Some(gpu_polyline) = polylines.into_inner().get(pl_handle) {
+        if let Some(gpu_polyline) = polylines.into_inner().get(pl_handle.unwrap()) {
             pass.set_vertex_buffer(0, gpu_polyline.vertex_buffer.slice(..));
             let num_instances = gpu_polyline.vertex_count.max(1) - 1;
             pass.draw(0..6, 0..num_instances);