diff --git a/Cargo.toml b/Cargo.toml
index e4a1314..d98250b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@
 
 [workspace.package]
   authors     = ["IDEDARY"]
-  version     = "0.2.1"
+  version     = "0.2.2"
   edition     = "2021"
   license     = "MIT OR Apache-2.0"
   repository  = "https://github.com/bytestring-net/bevy-lunex"
@@ -26,8 +26,8 @@
 
 [workspace.dependencies]
 
-  bevy_lunex   = { path = "crates/bevy_lunex", version = "0.2.1" }
-  lunex_engine = { path = "crates/lunex_engine", version = "0.2.1" }
+  bevy_lunex   = { path = "crates/bevy_lunex", version = "0.2.2" }
+  lunex_engine = { path = "crates/lunex_engine", version = "0.2.2" }
 
   colored            = { version = "^2.1" }
   indexmap           = { version = "^2.1" }
diff --git a/README.md b/README.md
index 631d7a6..280d704 100644
--- a/README.md
+++ b/README.md
@@ -89,7 +89,7 @@ For production ready example/template check out [`Bevypunk source code`](https:/
 
 |  Bevy  |    Bevy Lunex   |
 |--------|-----------------|
-| 0.14.0 | 0.2.0 - 0.2.1   |
+| 0.14.0 | 0.2.0 - 0.2.2   |
 | 0.13.2 |      0.1.0      |
 | 0.12.1 | 0.0.10 - 0.0.11 |
 | 0.12.0 | 0.0.7 - 0.0.9   |
diff --git a/crates/bevy_lunex/README.md b/crates/bevy_lunex/README.md
index 631d7a6..280d704 100644
--- a/crates/bevy_lunex/README.md
+++ b/crates/bevy_lunex/README.md
@@ -89,7 +89,7 @@ For production ready example/template check out [`Bevypunk source code`](https:/
 
 |  Bevy  |    Bevy Lunex   |
 |--------|-----------------|
-| 0.14.0 | 0.2.0 - 0.2.1   |
+| 0.14.0 | 0.2.0 - 0.2.2   |
 | 0.13.2 |      0.1.0      |
 | 0.12.1 | 0.0.10 - 0.0.11 |
 | 0.12.0 | 0.0.7 - 0.0.9   |
diff --git a/crates/bevy_lunex/src/logic/actions.rs b/crates/bevy_lunex/src/logic/actions.rs
index e88b794..5f472fd 100644
--- a/crates/bevy_lunex/src/logic/actions.rs
+++ b/crates/bevy_lunex/src/logic/actions.rs
@@ -159,7 +159,7 @@ fn apply_event_hide_cursor_2d(mut events: EventReader<HideCursor2d>, mut query:
         for mut cursor in &mut query {
             #[cfg(feature = "verbose")]
             info!("{} - Set cursor to hidden: {}", "EVENT".purple().bold(), event.0);
-            cursor.hidden = event.0;
+            cursor.visible = !event.0;
         }
     }
 }
diff --git a/crates/bevy_lunex/src/logic/cursor.rs b/crates/bevy_lunex/src/logic/cursor.rs
index 92ff2da..e08e982 100644
--- a/crates/bevy_lunex/src/logic/cursor.rs
+++ b/crates/bevy_lunex/src/logic/cursor.rs
@@ -1,10 +1,13 @@
 use crate::*;
-use bevy::{utils::HashMap, window::{CursorGrabMode, PrimaryWindow}};
-
+use bevy::{input::{gamepad::GamepadButtonChangedEvent, mouse::MouseButtonInput, ButtonState}, render::camera::RenderTarget, utils::HashMap, window::{CursorGrabMode, PrimaryWindow, WindowRef}};
+use picking_core::PickSet;
+use pointer::{InputMove, InputPress, Location};
 
 // #===================#
 // #=== CURSOR TYPE ===#
 
+/// Component for easy cursor control.
+/// Read more about it in the [docs](https://bytestring-net.github.io/bevy_lunex/advanced/3_cursor.html)
 #[derive(Component, Default)]
 pub struct Cursor2d {
     /// Indicates which cursor is being requested.
@@ -13,12 +16,12 @@ pub struct Cursor2d {
     cursor_request_priority: f32,
     /// Map which cursor has which atlas index and offset
     cursor_atlas_map: HashMap<CursorIcon, (usize, Vec2)>,
-    /// A toggle if this cursor should replace the native cursor
-    native_cursor: bool,
-    /// If the cursor is allowed to leave window
+    /// Location of the cursor (same as [`Transform`] without sprite offset).
+    pub location: Vec2,
+    /// If the cursor is allowed to leave window. Does nothing is cursor is controlled by gamepad.
     pub confined: bool,
-    /// A toggle if the cursor should be hidden
-    pub hidden: bool,
+    /// A toggle if the cursor should be visible
+    pub visible: bool,
 }
 impl Cursor2d {
     /// Creates new default Cursor2d.
@@ -27,21 +30,11 @@ impl Cursor2d {
             cursor_request: CursorIcon::Default,
             cursor_request_priority: 0.0,
             cursor_atlas_map: HashMap::new(),
-            native_cursor: true,
+            location: Vec2::ZERO,
             confined: false,
-            hidden: false,
+            visible: true,
         }
     }
-    /// If the cursor is allowed to leave window
-    pub fn confined(mut self, confined: bool) -> Self {
-        self.confined = confined;
-        self
-    }
-    /// A toggle if this cursor should be native
-    pub fn native_cursor(mut self, enable: bool) -> Self {
-        self.native_cursor = enable;
-        self
-    }
     /// A method to request a new cursor icon. Works only if priority is higher than already set priority this tick.
     pub fn request_cursor(&mut self, request: CursorIcon, priority: f32) {
         if priority > self.cursor_request_priority {
@@ -49,58 +42,292 @@ impl Cursor2d {
             self.cursor_request_priority = priority;
         }
     }
-    /// Adds a new index and offset to the cursor.
-    pub fn register_cursor(mut self, icon: CursorIcon, index: usize, offset: impl Into<Vec2>) -> Self {
+    /// This function binds the specific cursor icon to an image index that is used if the entity has texture atlas attached to it.
+    pub fn set_index(mut self, icon: CursorIcon, index: usize, offset: impl Into<Vec2>) -> Self {
         self.cursor_atlas_map.insert(icon, (index, offset.into()));
         self
     }
 }
 
 
-fn cursor_update(
+/// This will make the [`Cursor2d`] controllable by specific gamepad.
+#[derive(Component, Debug, Clone, PartialEq)]
+pub struct GamepadCursor {
+    /// Gamepad index
+    pub id: usize,
+    /// This struct defines how should the cursor movement behave.
+    pub mode: GamepadCursorMode,
+    /// Cursor speed scale
+    pub speed: f32,
+}
+impl GamepadCursor {
+    /// Creates a new instance from gamepad id.
+    pub fn new(id: usize) -> Self {
+        Self { id, ..Default::default() }
+    }
+}
+impl Default for GamepadCursor {
+    fn default() -> Self {
+        Self { id: 0, mode: Default::default(), speed: 1.0 }
+    }
+}
+
+
+/// This struct defines how should the cursor movement behave.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub enum GamepadCursorMode {
+    /// Cursor will freely move on input.
+    #[default]
+    Free,
+    // /// Will try to snap to nearby nodes on input.
+    //Snap,
+}
+
+
+// #========================#
+// #=== CURSOR FUNCTIONS ===#
+
+/// This function controls the visibility of the cursor
+fn cursor_set_visibility(
     mut windows: Query<&mut Window, With<PrimaryWindow>>,
-    cameras: Query<&OrthographicProjection>,
-    mut query: Query<(&Cursor2d, &Parent, &mut Transform, &mut Visibility)>
+    mut query: Query<(&Cursor2d, Option<&mut Visibility>, Has<GamepadCursor>, Has<Handle<Image>>)>
 ) {
     if let Ok(mut window) = windows.get_single_mut() {
-        for (cursor, parent, mut transform, mut visibility) in &mut query {
+        for (cursor, optional_visibility, has_gamepad, has_image) in &mut query {
+            // If we have visibility then change it
+            if let Some(mut visibility) = optional_visibility {
+                *visibility = if cursor.visible { Visibility::Visible } else { Visibility::Hidden };
+                if window.cursor_position().is_none() && !has_gamepad { *visibility = Visibility::Hidden }
+            }
+
+            // If it is not a gamepad
+            if !has_gamepad {
+                // Set native cursor to invisible if image is attached to the cursor
+                window.cursor.visible = if has_image { false } else { cursor.visible };
+            }
+        }
+    }
+}
 
-            window.cursor.visible = if cursor.native_cursor { !cursor.hidden } else { false };
+/// This function controls the native mouse cursor settings
+fn cursor_change_native(
+    mut windows: Query<&mut Window, With<PrimaryWindow>>,
+    mut query: Query<&Cursor2d, Without<GamepadCursor>>
+) {
+    if let Ok(mut window) = windows.get_single_mut() {
+        for cursor in &mut query {
+            // Change native cursor
             if window.cursor.visible { window.cursor.icon = cursor.cursor_request; }
 
-            if cursor.confined {
-                window.cursor.grab_mode = CursorGrabMode::Confined;
-            } else {
-                window.cursor.grab_mode = CursorGrabMode::None;
+            // Change grab mode
+            window.cursor.grab_mode = if cursor.confined { CursorGrabMode::Confined } else { CursorGrabMode::None }
+        }
+    }
+}
+
+
+/// This function controls the location of the cursor based on gamepad input
+fn gamepad_move_cursor(
+    axis: Res<Axis<GamepadAxis>>,
+    time: Res<Time>,
+    windows: Query<&Window, With<PrimaryWindow>>,
+    mut query: Query<(&mut Cursor2d, &GamepadCursor)>,
+) {
+    if let Ok(window) = windows.get_single() {
+        for (mut cursor, gamepad) in query.iter_mut() {
+            // Pull axis values
+            let x = axis.get(GamepadAxis { gamepad: Gamepad::new(gamepad.id), axis_type: GamepadAxisType::LeftStickX });
+            let y = axis.get(GamepadAxis { gamepad: Gamepad::new(gamepad.id), axis_type: GamepadAxisType::LeftStickY });
+
+            if let (Some(x), Some(y)) = (x, y) {
+                // Move the cursor
+                cursor.location.x += x * time.delta_seconds() * 500.0 * gamepad.speed;
+                cursor.location.y += y * time.delta_seconds() * 500.0 * gamepad.speed;
+
+                // Clamp the cursor within window
+                let w = window.width()/2.0;
+                let h = window.height()/2.0;
+                cursor.location.x = cursor.location.x.clamp(-w, w);
+                cursor.location.y = cursor.location.y.clamp(-h, h);
+            }
+        }
+    }
+}
+
+/// This function controls the location of the cursor based on mouse input
+fn mouse_move_cursor(
+    windows: Query<&Window, With<PrimaryWindow>>,
+    cameras: Query<&OrthographicProjection>,
+    mut query: Query<(&mut Cursor2d, &Parent), Without<GamepadCursor>>
+) {
+    if let Ok(window) = windows.get_single() {
+        for (mut cursor, parent) in &mut query {
+            if let Some(position) = window.cursor_position() {
+                // Get projection scale to account for zoomed cameras
+                let scale = if let Ok(projection) = cameras.get(**parent) { projection.scale } else { 1.0 };
+
+                // Move the cursor
+                cursor.location.x = (position.x - window.width()*0.5) * scale;
+                cursor.location.y = -((position.y - window.height()*0.5) * scale);
             }
+        }
+    }
+}
+
+/// This function updates the transform component with the modified location and sprite offsets
+fn cursor_update_transform(
+    mut query: Query<(&Cursor2d, &mut Transform)>
+) {
+    for (cursor, mut transform) in &mut query {
+        let sprite_offset = cursor.cursor_atlas_map.get(&cursor.cursor_request).unwrap_or(&(0, Vec2::ZERO)).1;
+        transform.translation.x = cursor.location.x - sprite_offset.x * transform.scale.x;
+        transform.translation.y = cursor.location.y + sprite_offset.y * transform.scale.y;
+    }
+}
 
-            match window.cursor_position() {
-                Some(position) => {
+/// This function controls virtual pointer attached to the cursor
+fn cursor_move_virtual_pointer(
+    windows: Query<(Entity, &Window), With<PrimaryWindow>>,
+    mut query: Query<(&mut PointerLocation, &Cursor2d)>,
+) {
+    if let Ok((win_entity, window)) = windows.get_single() {
+        for (mut pointer, cursor) in query.iter_mut() {
+            // Change the pointer location
+            pointer.location = Some(pointer::Location {
+                target: RenderTarget::Window(WindowRef::Primary).normalize(Some(win_entity)).unwrap(),
+                position: Vec2 {
+                    x: cursor.location.x + window.width()/2.0,
+                    y: -cursor.location.y + window.height()/2.0,
+                }.round(),
+            });
+        }
+    }
+}
+
+/// This function sends mouse pointer events to be processed by the mod picking core plugin
+fn cursor_mouse_pick_events(
+    // Input
+    mut mouse_inputs: EventReader<MouseButtonInput>,
+    mut cursor_last: Local<HashMap<PointerId, Vec2>>,
+    pointers: Query<(&PointerId, &PointerLocation), (With<Cursor2d>, Without<GamepadCursor>)>,
+    // Output
+    mut pointer_move: EventWriter<InputMove>,
+    mut pointer_presses: EventWriter<InputPress>,
+) {
+    // Send mouse movement events
+    for (pointer, location) in &pointers {
+        if let Some(location) = &location.location {
+            let last = cursor_last.get(pointer).unwrap_or(&Vec2::ZERO);
+            if *last == location.position { continue; }
 
-                    let sprite_offset = cursor.cursor_atlas_map.get(&cursor.cursor_request).unwrap_or(&(0, Vec2::ZERO)).1;
+            pointer_move.send(InputMove::new(
+                *pointer,
+                Location {
+                    target: location.target.clone(),
+                    position: location.position,
+                },
+                location.position - *last,
+            ));
+            cursor_last.insert(*pointer, location.position);
+        }
+    }
 
-                    let scale = if let Ok(projection) = cameras.get(**parent) {
-                        projection.scale
-                    } else { 1.0 };
+    // Send mouse click events
+    for input in mouse_inputs.read() {
+        let button = match input.button {
+            MouseButton::Left => PointerButton::Primary,
+            MouseButton::Right => PointerButton::Secondary,
+            MouseButton::Middle => PointerButton::Middle,
+            MouseButton::Other(_) => continue,
+            MouseButton::Back => continue,
+            MouseButton::Forward => continue,
+        };
 
-                    transform.translation.x = (position.x - window.width()*0.5) * scale - sprite_offset.x * transform.scale.x;
-                    transform.translation.y = -((position.y - window.height()*0.5) * scale - sprite_offset.y * transform.scale.y);
-                    *visibility = if cursor.hidden || cursor.native_cursor { Visibility::Hidden } else { Visibility::Visible };
+        match input.state {
+            ButtonState::Pressed => {
+                for (pointer, _) in &pointers {
+                    pointer_presses.send(InputPress::new_down(*pointer, button));
+                }
+            }
+            ButtonState::Released => {
+                for (pointer, _) in &pointers {
+                    pointer_presses.send(InputPress::new_up(*pointer, button));
                 }
-                None => {
-                    *visibility = Visibility::Hidden;
+            }
+        }
+    }
+}
+
+/// This function sends mouse pointer events to be processed by the mod picking core plugin
+fn cursor_gamepad_pick_events(
+    // Input
+    mut gamepad_inputs: EventReader<GamepadButtonChangedEvent>,
+    mut cursor_last: Local<HashMap<PointerId, Vec2>>,
+    pointers: Query<(&PointerId, &PointerLocation, &GamepadCursor), With<Cursor2d>>,
+    // Output
+    mut pointer_move: EventWriter<InputMove>,
+    mut pointer_presses: EventWriter<InputPress>,
+) {
+    // Send mouse movement events
+    for (pointer, location, _) in &pointers {
+        if let Some(location) = &location.location {
+            let last = cursor_last.get(pointer).unwrap_or(&Vec2::ZERO);
+            if *last == location.position { continue; }
+
+            pointer_move.send(InputMove::new(
+                *pointer,
+                Location {
+                    target: location.target.clone(),
+                    position: location.position,
+                },
+                location.position - *last,
+            ));
+            cursor_last.insert(*pointer, location.position);
+        }
+    }
+
+    // Send mouse click events
+    for input in gamepad_inputs.read() {
+        let button = match input.button_type {
+            GamepadButtonType::South => PointerButton::Primary,
+            GamepadButtonType::East => PointerButton::Secondary,
+            GamepadButtonType::West => PointerButton::Middle,
+            _ => continue,
+        };
+
+        match input.value {
+            1.0 => {
+                for (pointer, _, gamepad) in &pointers {
+                    if gamepad.id != input.gamepad.id { continue; }
+                    pointer_presses.send(InputPress::new_down(*pointer, button));
                 }
             }
+            0.0 => {
+                for (pointer, _, gamepad) in &pointers {
+                    if gamepad.id != input.gamepad.id { continue; }
+                    pointer_presses.send(InputPress::new_up(*pointer, button));
+                }
+            },
+            _ => {}
         }
     }
 }
-fn cursor_preupdate(mut query: Query<&mut Cursor2d>) {
+
+
+/// This function resets the requested cursor back to default every tick
+fn cursor_reset_icon(
+    mut query: Query<&mut Cursor2d>
+) {
     for mut cursor in &mut query {
         cursor.cursor_request = CursorIcon::Default;
         cursor.cursor_request_priority = 0.0;
     }
 }
-fn cursor_update_texture(mut query: Query<(&Cursor2d, &mut TextureAtlas)>) {
+
+/// This function updates the atlas index texture based on requested cursor icon
+fn cursor_update_texture(
+    mut query: Query<(&Cursor2d, &mut TextureAtlas)>
+) {
     for (cursor, mut atlas) in &mut query {
         atlas.index = cursor.cursor_atlas_map.get(&cursor.cursor_request).unwrap_or(&(0, Vec2::ZERO)).0;
     }
@@ -139,9 +366,18 @@ pub struct CursorPlugin;
 impl Plugin for CursorPlugin {
     fn build(&self, app: &mut App) {
         app
-            .add_systems(PreUpdate,  cursor_preupdate)
-            .add_systems(PostUpdate, cursor_update)
+
+            // Add systems for mod picking event emitters
+            .add_systems(First, (cursor_mouse_pick_events, cursor_gamepad_pick_events, apply_deferred).chain().in_set(PickSet::Input))
+
+            // Add core systems 
+            .add_systems(PreUpdate, cursor_reset_icon)
+            .add_systems(PreUpdate, (gamepad_move_cursor, mouse_move_cursor, cursor_update_transform, cursor_move_virtual_pointer).chain())
+            .add_systems(PostUpdate, cursor_set_visibility)
+            .add_systems(PostUpdate, cursor_change_native)
             .add_systems(PostUpdate, cursor_update_texture)
+
+            // Other stuff
             .add_systems(Update, on_hover_set_cursor);
     }
 }
\ No newline at end of file
diff --git a/crates/bevy_lunex/src/picking.rs b/crates/bevy_lunex/src/picking.rs
index 082f88e..d99e7d4 100644
--- a/crates/bevy_lunex/src/picking.rs
+++ b/crates/bevy_lunex/src/picking.rs
@@ -17,7 +17,7 @@ pub struct LunexBackend;
 impl Plugin for LunexBackend {
     fn build(&self, app: &mut App) {
         app
-            .add_plugins(DefaultPickingPlugins)
+            .add_plugins(DefaultPickingPlugins.build().disable::<InputPlugin>())
             .add_systems(PreUpdate, lunex_picking.in_set(PickSet::Backend))
             .add_systems(Update, rendered_texture_picking);
     }
@@ -116,7 +116,7 @@ pub fn rendered_texture_picking(
         if let Ok(texture_handle) = texture_viewports.get(event.target) {
             let position = event.pointer_location.position;
             pointer_move.send(pointer::InputMove {
-                pointer_id: PointerId::Mouse,
+                pointer_id: event.pointer_id,
                 location: pointer::Location {
                     target: bevy::render::camera::NormalizedRenderTarget::Image(
                         texture_handle.clone_weak(),
diff --git a/docs/src/2_installation.md b/docs/src/2_installation.md
index 8f0627d..af6971f 100644
--- a/docs/src/2_installation.md
+++ b/docs/src/2_installation.md
@@ -6,7 +6,7 @@ Add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-bevy_lunex = { version = "0.2.1" }
+bevy_lunex = { version = "0.2.2" }
 ```
 
 Alternatively, you can use the latest bleeding edge version from the Git repository:
diff --git a/docs/src/6_help.md b/docs/src/6_help.md
index af91f0a..67a04a6 100644
--- a/docs/src/6_help.md
+++ b/docs/src/6_help.md
@@ -2,6 +2,6 @@
 
 For issues related to the library, please create a ticket on [`GitHub`](https://github.com/bytestring-net/bevy_lunex/issues).
 
-You can also reach out on the [`Bevy Discord`](https://discord.gg/bevy), where I am likely to see your message.
+You can also reach out to me on the [`Bevy Discord`](https://discord.gg/bevy), where you can use the [`#Ecosystem-crates: Bevy Lunex`](https://discord.com/channels/691052431525675048/1034543904478998539) thread.
 
-For questions or additional help, feel free to send me a direct message on Discord: `@idedary`.
+For specific questions, feel free to send me a direct message on Discord: `@idedary`.
diff --git a/docs/src/advanced/3_cursor.md b/docs/src/advanced/3_cursor.md
index 7aad80b..c3943f7 100644
--- a/docs/src/advanced/3_cursor.md
+++ b/docs/src/advanced/3_cursor.md
@@ -1,10 +1,62 @@
 # Cursor
 
-Lunex provides a custom API for a cursor within your Bevy application.
+Lunex provides a custom abstraction for a cursor related features within your Bevy application.
 
-This feature works by spawning a cursor atlas image alongside a special `Cursor2d` component as a child of a 2D camera.
+This is achieved by moving all logic to a an entity that is spawned as a child of a `Camera2d`.
 
-To use the custom cursor styling, we need to expand our `Camera2d` entity as follows:
+It is required that you spawn this entity, otherwise picking won't work.
+
+### Required components
+
+You need to spawn these components for 
+
+```rust
+// This is the main component
+Cursor2d::new(),
+// This is required so that the sprite doesn't block our picking raycaster
+Pickable::IGNORE,
+// This is required so that the sprite doesn't block our picking raycaster
+PointerBundle::new(PointerId::Custom(pointer::Uuid::new_v4())),
+```
+
+### Styling components
+
+If you want to attach custom image to your cursor, you have to attach texture atlas to the entity.
+You will need to have all the icons in a image strip like this.
+
+![Cursor](../images/cursor.png)
+
+
+```rust
+// Specify the texture atlas properties
+TextureAtlas {
+    // ...
+},
+// Specify the image to load 
+SpriteBundle {
+    // ...
+},
+```
+
+### Gamepad support
+
+To bind a cursor to a gamepad, you have to add this component:
+
+```rust
+GamepadCursor::new(0),
+```
+
+If you want the cursor to accept both Mouse and Gamepad inputs, you have to create an additional
+system that listens to recent input events and based on them "removes" or "adds" this component.
+
+Currently, there is only 1 mode supported and that is `Free` which means you just use your stick to move
+the cursor around. There is no "jumping" yet.
+
+However, it is planned to add `Snap` mode, which makes the cursor "jump" and snap to the next node in input direction.
+
+## Example
+
+Here's an example of how to set up a custom cursor with gamepad control:
 
 ```rust
 # fn setup(mut commands: Commands, assets: Res<AssetServer>, mut atlas_layout: ResMut<Assets<TextureAtlasLayout>>){
@@ -13,50 +65,44 @@ commands.spawn((
     Camera2dBundle { transform: Transform::from_xyz(0.0, 0.0, 1000.0), ..default() }
 )).with_children(|camera| {
 
-    // Spawn cursor
-    camera.spawn ((
-
-        // Here we can map different native cursor icons to texture atlas indexes and sprite offsets
-        Cursor2d::new().native_cursor(false)
-            .register_cursor(CursorIcon::Default, 0, (14.0, 14.0))
-            .register_cursor(CursorIcon::Pointer, 1, (10.0, 12.0))
-            .register_cursor(CursorIcon::Grab, 2, (40.0, 40.0)),
-
-        // Add texture atlas to the cursor
-        TextureAtlas {
-            layout: atlas_layout.add(TextureAtlasLayout::from_grid(UVec2::splat(80), 3, 1, None, None)),
-            index: 0,
-        },
-
-        // Add sprite bundle to the cursor
-        SpriteBundle {
-            texture: assets.cursor.clone(),
-            transform: Transform { scale: Vec3::new(0.45, 0.45, 1.0), ..default() },
-            sprite: Sprite {
-                color: Color::BEVYPUNK_YELLOW.with_alpha(2.0),
-                anchor: Anchor::TopLeft,
+    // Spawn 2D camera
+    commands.spawn(camera()).with_children(|camera| {
+
+        // Spawn cursor
+        camera.spawn ((
+
+            // Here we can map different native cursor icons to texture atlas indexes and sprite offsets
+            Cursor2d::new()
+                .set_index(CursorIcon::Default, 0, (14.0, 14.0))
+                .set_index(CursorIcon::Pointer, 1, (10.0, 12.0))
+                .set_index(CursorIcon::Grab, 2, (40.0, 40.0)),
+
+            // Here we specify that the cursor should be controlled by gamepad 0
+            GamepadCursor::new(0),
+
+            // This is required for picking to work
+            PointerBundle::new(PointerId::Custom(pointer::Uuid::new_v4())),
+            
+            // Add texture atlas to the cursor
+            TextureAtlas {                                           // Size 80x80, 3 columns, 1 row
+                layout: atlas_layout.add(TextureAtlasLayout::from_grid(UVec2::splat(80), 3, 1, None, None)),
+                index: 0,
+            },
+            SpriteBundle {
+                texture: assets.load("cursor.png"),
+                transform: Transform { scale: Vec3::new(0.45, 0.45, 1.0), ..default() },
+                sprite: Sprite {
+                    color: Color::YELLOW.with_alpha(2.0),
+                    anchor: Anchor::TopLeft,
+                    ..default()
+                },
                 ..default()
             },
-            ..default()
-        },
 
-        // Make the raycaster ignore this entity, we don't want our cursor to block clicking
-        Pickable::IGNORE,
-    ));
+            // Make the raycaster ignore this entity, we don't want our cursor to block clicking
+            Pickable::IGNORE,
+        ));
+    });
 });
 # }
 ```
-
-When creating a `Cursor2d` component, you can use the `native_cursor()` method to specify whether the cursor should exist as an entity within the game world or be injected into the `Winit` crate as a custom cursor sprite. (Note: This feature is currently a work in progress, and enabling it only hides the sprite for now.)
-
-![Cursor](../images/cursor.png)
-
-By default, spawning the cursor entity will hide the native system cursor unless `native_cursor(true)` is set.
-
-Additionally, you must register each cursor icon with its respective texture atlas indices and sprite offsets to define the appearance and positioning of different cursor states.
-
-Finally, to prevent the cursor from interfering with clicking events, we add the `Pickable::IGNORE` component. This ensures that the cursor sprite does not block any button interactions or other clickable elements in the UI.
-
-### Cursor position
-
-You can query for `GlobalTransform` of `Cursor2d` to get it's worldspace location. For localspace, use regular `Transform`.