### Setup GlizmoPlugin in Bevy Application

Source: https://context7.com/atlv24/glizmo/llms.txt

This code demonstrates how to add the GlizmoPlugin to a Bevy application. This is necessary to enable the immediate-mode gizmo drawing functionalities. It also shows a basic example of calling a glizmo function within game logic.

```rust
use bevy::prelude::*;
use glizmo::GlizmoPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(GlizmoPlugin)
        .add_systems(Update, my_game_logic)
        .run();
}

fn my_game_logic() {
    // Now you can call glizmo functions anywhere
    glizmo::sphere(Vec3::ZERO, 1.0, Color::srgb(1.0, 0.0, 0.0));
}
```

--------------------------------

### Complete Usage Example: Bevy Game with Glizmo

Source: https://context7.com/atlv24/glizmo/llms.txt

This example demonstrates how to integrate and use various glizmo functions within a Bevy game loop. It showcases drawing axes, velocity vectors, rays, spheres, AABBs, and a grid. Dependencies include Bevy engine and its default plugins.

```rust
use bevy::{color::palettes::css::*, prelude::*};
use std::f32::consts::PI;

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, glizmo::GlizmoPlugin))
        .add_systems(Startup, setup)
        .add_systems(Update, (
            debug_player_system,
            debug_physics_system,
            draw_debug_grid,
        ))
        .run();
}

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(-5.0, 5.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    commands.spawn(( 
        Mesh3d(meshes.add(Plane3d::default().mesh().size(20.0, 20.0))),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
    ));

    commands.spawn(( 
        PointLight {
            intensity: 2_000_000.0,
            shadows_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));
}

#[derive(Component)]
struct Player {
    velocity: Vec3,
    look_direction: Vec3,
}

fn debug_player_system(
    query: Query<(&Transform, &Player)>,
    time: Res<Time>,
) {
    for (transform, player) in &query {
        let pos = transform.translation;

        // Draw coordinate axes at player position
        glizmo::axes(*transform, 1.0);

        // Draw velocity vector
        glizmo::arrow(pos, pos + player.velocity, GREEN);

        // Draw look direction
        glizmo::ray(pos + Vec3::Y * 0.5, player.look_direction * 2.0, YELLOW);

        // Draw player's collision sphere
        glizmo::sphere(
            Isometry3d::from_translation(pos),
            0.5,
            BLUE.with_alpha(0.5)
        );

        // Draw ground detection ray
        glizmo::ray(pos, Vec3::NEG_Y * 1.5, RED);
    }
}

#[derive(Component)]
struct PhysicsBody {
    aabb: Aabb3d,
}

fn debug_physics_system(query: Query<(&Transform, &PhysicsBody)>) {
    for (transform, body) in &query {
        // Draw collision box
        glizmo::aabb_3d(body.aabb, *transform, LIME);

        // Draw center cross
        glizmo::cross(
            Isometry3d::from_translation(transform.translation),
            0.2,
            WHITE
        );
    }
}

fn draw_debug_grid(time: Res<Time>) {
    // Ground grid
    glizmo::grid(
        Isometry3d::new(Vec3::ZERO, Quat::from_rotation_x(PI / 2.0)),
        UVec2::splat(20),
        Vec2::splat(1.0),
        LinearRgba::gray(0.3)
    );

    // Animated sphere to show time
    let offset = (time.elapsed_secs().sin() + 1.0) * 2.0;
    glizmo::sphere(
        Isometry3d::from_translation(Vec3::new(offset, 1.0, 0.0)),
        0.5,
        PURPLE
    );
}

```

--------------------------------

### Glizmo Plugin Setup

Source: https://context7.com/atlv24/glizmo/llms.txt

How to add the GlizmoPlugin to your Bevy application to enable immediate-mode gizmo drawing.

```APIDOC
## Glizmo Plugin Setup

### Description
Add GlizmoPlugin to your Bevy application to enable immediate-mode gizmo drawing.

### Method
`add_plugins`

### Endpoint
N/A (Plugin integration)

### Parameters
None

### Request Example
```rust
use bevy::prelude::*;
use glizmo::GlizmoPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(GlizmoPlugin)
        .add_systems(Update, my_game_logic)
        .run();
}

fn my_game_logic() {
    // Now you can call glizmo functions anywhere
    glizmo::sphere(Vec3::ZERO, 1.0, Color::srgb(1.0, 0.0, 0.0));
}
```

### Response
None (Plugin setup)

### Response Example
None
```

--------------------------------

### Basic Bevy App Setup with GlizmoPlugin

Source: https://github.com/atlv24/glizmo/blob/main/README.md

This Rust code demonstrates how to set up a basic Bevy application and integrate the GlizmoPlugin. It also includes a system 'draw' to visualize a sphere using glizmo.

```rust
use bevy::{color::palettes::css::*, prelude::*};

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, glizmo::GlizmoPlugin))
        .add_systems(Update, draw)
        .run();
}

fn draw() {
    glizmo::sphere(Vec3::splat(10.0), 1.0, PURPLE);
}
```

--------------------------------

### 3D Line Drawing with Glizmo in Rust

Source: https://context7.com/atlv24/glizmo/llms.txt

This snippet illustrates various ways to draw lines, rays, and line strips in 3D space using the Glizmo library. It includes examples for simple lines, lines with color gradients, rays, and connected line segments (linestrips), showcasing different color and path configurations.

```rust
use bevy::{color::palettes::css::*, prelude::*};

fn debug_physics() {
    // Simple line from point A to point B
    glizmo::line(Vec3::ZERO, Vec3::new(5.0, 0.0, 0.0), GREEN);

    // Line with color gradient
    glizmo::line_gradient(
        Vec3::ZERO,
        Vec3::new(0.0, 5.0, 0.0),
        BLUE,
        RED
    );

    // Ray from origin in a direction
    glizmo::ray(Vec3::new(2.0, 0.0, 0.0), Vec3::Y * 3.0, YELLOW);

    // Ray with gradient
    glizmo::ray_gradient(Vec3::ZERO, Vec3::X * 5.0, WHITE, PURPLE);

    // Connected line segments
    let path = vec![
        Vec3::ZERO,
        Vec3::new(1.0, 1.0, 0.0),
        Vec3::new(2.0, 0.5, 0.0),
        Vec3::new(3.0, 1.5, 0.0),
    ];
    glizmo::linestrip(path, ORANGE);

    // Line strip with per-vertex colors
    let colored_path = vec![
        (Vec3::ZERO, GREEN),
        (Vec3::X, YELLOW),
        (Vec3::Y, RED),
        (Vec3::Z, BLUE),
    ];
    glizmo::linestrip_gradient(colored_path);
}
```

--------------------------------

### 2D and 3D Rectangles and Boxes with Glizmo in Rust

Source: https://context7.com/atlv24/glizmo/llms.txt

This Rust code snippet demonstrates drawing wireframe rectangles in 2D and 3D, as well as cubes, using the Glizmo library. It includes examples for axis-aligned and rotated 3D rectangles, cubes with transform support, AABB (Axis-Aligned Bounding Box), and 2D rectangles.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::Isometry3d};

fn debug_collision_boxes() {
    // 3D rectangle aligned with XY plane
    glizmo::rect(
        Isometry3d::from_translation(Vec3::new(0.0, 2.0, 0.0)),
        Vec2::new(2.0, 1.0),
        GREEN
    );

    // Rotated 3D rectangle
    glizmo::rect(
        Isometry3d::new(
            Vec3::new(5.0, 0.0, 0.0),
            Quat::from_rotation_y(std::f32::consts::PI / 4.0)
        ),
        Vec2::splat(1.5),
        BLUE
    );

    // Wireframe cube with transform
    glizmo::cube(
        Transform::from_xyz(0.0, 0.5, 0.0).with_scale(Vec3::splat(1.0)),
        RED
    );

    // AABB (Axis-Aligned Bounding Box)
    glizmo::aabb_3d(
        Aabb3d::new(Vec3::new(3.0, 1.0, 0.0), Vec3::splat(0.5)),
        Transform::IDENTITY,
        YELLOW
    );

    // 2D rectangle
    glizmo::rect_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        Vec2::new(50.0, 30.0),
        PURPLE
    );
}
```

--------------------------------

### Add Glizmo Dependency to Cargo.toml

Source: https://github.com/atlv24/glizmo/blob/main/README.md

To use the glizmo crate, add it as a dependency in your project's Cargo.toml file. This example shows how to include version 0.1 of glizmo.

```toml
[dependencies]
glizmo = "0.1"
```

--------------------------------

### Draw Arrows and Axes in 2D/3D

Source: https://context7.com/atlv24/glizmo/llms.txt

Draws directional arrows and coordinate axes for debugging orientation and transforms. Supports both 2D and 3D contexts. Uses Bevy's Transform and math types. Arrows are defined by start and end points, while axes are defined by a transform and scale.

```rust
use bevy::{color::palettes::css::*, prelude::*};

fn debug_directions_and_transforms() {
    // 3D arrow from start to end point
    glizmo::arrow(Vec3::ZERO, Vec3::new(3.0, 2.0, 1.0), YELLOW);

    // 2D arrow
    glizmo::arrow_2d(Vec2::ZERO, Vec2::new(100.0, 50.0), RED);

    // Draw coordinate axes at a transform
    let transform = Transform::from_xyz(5.0, 1.0, 0.0)
        .with_rotation(Quat::from_rotation_y(std::f32::consts::FRAC_PI_4));
    glizmo::axes(transform, 1.0);

    // Draw 2D coordinate axes
    let transform_2d = Transform::from_translation(Vec3::new(100.0, 100.0, 0.0))
        .with_rotation(Quat::from_rotation_z(std::f32::consts::FRAC_PI_6));
    glizmo::axes_2d(transform_2d, 50.0);

    // Visualize entity transforms in a query
    fn visualize_entities(query: Query<&Transform, With<Enemy>>) {
        for transform in &query {
            glizmo::axes(*transform, 0.5);
        }
    }
}
```

--------------------------------

### 2D Line Drawing with Glizmo in Rust

Source: https://context7.com/atlv24/glizmo/llms.txt

This code snippet demonstrates how to draw 2D lines, rays, and line strips in the XY plane using Glizmo. It covers basic 2D lines, lines with gradients, 2D rays, and connected 2D paths (linestrips), including options for per-vertex coloring.

```rust
use bevy::{color::palettes::css::*, prelude::*};

fn debug_2d_pathfinding() {
    // 2D line
    glizmo::line_2d(Vec2::ZERO, Vec2::new(100.0, 50.0), GREEN);

    // 2D line with gradient
    glizmo::line_gradient_2d(Vec2::ZERO, Vec2::X * 100.0, BLUE, RED);

    // 2D ray from position in direction
    glizmo::ray_2d(Vec2::new(50.0, 50.0), Vec2::new(20.0, 30.0), YELLOW);

    // 2D ray with gradient
    glizmo::ray_gradient_2d(Vec2::ZERO, Vec2::ONE * 50.0, WHITE, PURPLE);

    // Connected 2D path
    let waypoints = vec![
        Vec2::ZERO,
        Vec2::new(50.0, 25.0),
        Vec2::new(100.0, 50.0),
        Vec2::new(150.0, 25.0),
    ];
    glizmo::linestrip_2d(waypoints, ORANGE);

    // 2D path with per-vertex colors
    glizmo::linestrip_gradient_2d(vec![
        (Vec2::ZERO, GREEN),
        (Vec2::X * 50.0, YELLOW),
        (Vec2::Y * 50.0, RED),
    ]);
}
```

--------------------------------

### Draw 2D and 3D Grids

Source: https://context7.com/atlv24/glizmo/llms.txt

This section covers drawing various types of grids, including 2D grids in 3D space, pure 2D grids, and 3D voxel grids. The `glizmo::grid`, `glizmo::grid_3d`, and `glizmo::grid_2d` functions are used. These functions allow for specifying the grid's position, orientation, dimensions (number of cells and cell size), and color. The `grid` function draws a 2D grid oriented in 3D space.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::Isometry3d};
use std::f32::consts::PI;

fn debug_world_space() {
    // 2D grid in 3D (XY plane at ground level)
    glizmo::grid(
        Isometry3d::new(
            Vec3::ZERO,
            Quat::from_rotation_x(PI / 2.0) // Rotate to XZ plane
        ),
        UVec2::new(10, 10),
        Vec2::splat(1.0),
        LinearRgba::gray(0.5)
    );

    // Rotated and translated grid
    glizmo::grid(
        Isometry3d::new(
            Vec3::new(0.0, 5.0, 0.0),
            Quat::from_rotation_y(PI / 4.0)
        ),
        UVec2::new(20, 20),
        Vec2::new(0.5, 0.5),
        GREEN
    );

    // 3D voxel grid
    glizmo::grid_3d(
        Isometry3d::from_translation(Vec3::new(10.0, 0.0, 0.0)),
        UVec3::new(5, 3, 5),
        Vec3::splat(1.0),
        BLUE
    );

    // 2D grid for UI or 2D games
    glizmo::grid_2d(
        Isometry2d::IDENTITY,
        UVec2::new(16, 9),
        Vec2::splat(50.0),
        LinearRgba::gray(0.3)
    );
}

```

--------------------------------

### Draw 2D and 3D Curves with Gradients

Source: https://context7.com/atlv24/glizmo/llms.txt

This snippet demonstrates how to draw parametric curves in 2D and 3D, including support for color gradients along the curve. It uses the `glizmo::curve_2d`, `glizmo::curve_3d`, `glizmo::curve_gradient_2d`, and `glizmo::curve_gradient_3d` functions. Curves are defined using `FunctionCurve` which takes a domain and a closure to compute points. Gradients are applied by providing an iterator of (time, color) tuples.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::Curve};

fn debug_splines_and_paths() {
    // 2D sinusoidal curve
    let domain = Interval::UNIT;
    let curve_2d = FunctionCurve::new(domain, |t| {
        Vec2::new(t * 10.0, (t * std::f32::consts::TAU).sin() * 2.0)
    });
    glizmo::curve_2d(curve_2d, (0..=100).map(|n| n as f32 / 100.0), RED);

    // 3D helix curve
    let curve_3d = FunctionCurve::new(domain, |t| {
        let angle = t * std::f32::consts::TAU * 3.0;
        Vec3::new(angle.cos(), t * 5.0, angle.sin())
    });
    glizmo::curve_3d(curve_3d, (0..=200).map(|n| n as f32 / 200.0), BLUE);

    // 2D curve with color gradient
    let gradient_curve = FunctionCurve::new(domain, |t| {
        Vec2::from((t * std::f32::consts::TAU).sin_cos()) * 3.0
    });
    let times_and_colors = (0..=100)
        .map(|n| n as f32 / 100.0)
        .map(|t| (t, GREEN.mix(&PURPLE, t)));
    glizmo::curve_gradient_2d(gradient_curve, times_and_colors);

    // 3D curve with gradient
    let spiral = FunctionCurve::new(domain, |t| {
        let radius = t * 2.0;
        let angle = t * std::f32::consts::TAU * 4.0;
        Vec3::new(angle.cos() * radius, t * 3.0, angle.sin() * radius)
    });
    let gradient_3d = (0..=150)
        .map(|n| n as f32 / 150.0)
        .map(|t| (t, YELLOW.mix(&RED, t)));
    glizmo::curve_gradient_3d(spiral, gradient_3d);
}

```

--------------------------------

### 2D Line Drawing API

Source: https://context7.com/atlv24/glizmo/llms.txt

Functions for drawing lines, rays, and line strips in 2D space (XY plane), with gradient options.

```APIDOC
## 2D Line Drawing API

### Description
Draw lines, rays, and line strips in 2D space (XY plane).

### Method
`glizmo::line_2d`, `glizmo::line_gradient_2d`, `glizmo::ray_2d`, `glizmo::ray_gradient_2d`, `glizmo::linestrip_2d`, `glizmo::linestrip_gradient_2d`

### Endpoint
N/A (Function calls)

### Parameters
- `glizmo::line_2d(start: Vec2, end: Vec2, color: Color)`
- `glizmo::line_gradient_2d(start: Vec2, end: Vec2, start_color: Color, end_color: Color)`
- `glizmo::ray_2d(position: Vec2, direction: Vec2, color: Color)`
- `glizmo::ray_gradient_2d(position: Vec2, direction: Vec2, start_color: Color, end_color: Color)`
- `glizmo::linestrip_2d(waypoints: Vec<Vec2>, color: Color)`
- `glizmo::linestrip_gradient_2d(colored_waypoints: Vec<(Vec2, Color)>)`

### Request Example
```rust
use bevy::{color::palettes::css::*, prelude::*};

fn debug_2d_pathfinding() {
    // 2D line
    glizmo::line_2d(Vec2::ZERO, Vec2::new(100.0, 50.0), GREEN);

    // 2D line with gradient
    glizmo::line_gradient_2d(Vec2::ZERO, Vec2::X * 100.0, BLUE, RED);

    // 2D ray from position in direction
    glizmo::ray_2d(Vec2::new(50.0, 50.0), Vec2::new(20.0, 30.0), YELLOW);

    // 2D ray with gradient
    glizmo::ray_gradient_2d(Vec2::ZERO, Vec2::ONE * 50.0, WHITE, PURPLE);

    // Connected 2D path
    let waypoints = vec![
        Vec2::ZERO,
        Vec2::new(50.0, 25.0),
        Vec2::new(100.0, 50.0),
        Vec2::new(150.0, 25.0),
    ];
    glizmo::linestrip_2d(waypoints, ORANGE);

    // 2D path with per-vertex colors
    glizmo::linestrip_gradient_2d(vec![
        (Vec2::ZERO, GREEN),
        (Vec2::X * 50.0, YELLOW),
        (Vec2::Y * 50.0, RED),
    ]);
}
```

### Response
None (Gizmos are rendered directly)

### Response Example
None
```

--------------------------------

### 3D Line Drawing API

Source: https://context7.com/atlv24/glizmo/llms.txt

Functions for drawing lines, rays, and line strips in 3D space, with options for color gradients.

```APIDOC
## 3D Line Drawing API

### Description
Draw lines, rays, and line strips in 3D space with optional color gradients.

### Method
`glizmo::line`, `glizmo::line_gradient`, `glizmo::ray`, `glizmo::ray_gradient`, `glizmo::linestrip`, `glizmo::linestrip_gradient`

### Endpoint
N/A (Function calls)

### Parameters
- `glizmo::line(start: Vec3, end: Vec3, color: Color)`
- `glizmo::line_gradient(start: Vec3, end: Vec3, start_color: Color, end_color: Color)`
- `glizmo::ray(origin: Vec3, direction: Vec3, color: Color)`
- `glizmo::ray_gradient(origin: Vec3, direction: Vec3, start_color: Color, end_color: Color)`
- `glizmo::linestrip(path: Vec<Vec3>, color: Color)`
- `glizmo::linestrip_gradient(colored_path: Vec<(Vec3, Color)>)`

### Request Example
```rust
use bevy::{color::palettes::css::*, prelude::*};

fn debug_physics() {
    // Simple line from point A to point B
    glizmo::line(Vec3::ZERO, Vec3::new(5.0, 0.0, 0.0), GREEN);

    // Line with color gradient
    glizmo::line_gradient(
        Vec3::ZERO,
        Vec3::new(0.0, 5.0, 0.0),
        BLUE,
        RED
    );

    // Ray from origin in a direction
    glizmo::ray(Vec3::new(2.0, 0.0, 0.0), Vec3::Y * 3.0, YELLOW);

    // Ray with gradient
    glizmo::ray_gradient(Vec3::ZERO, Vec3::X * 5.0, WHITE, PURPLE);

    // Connected line segments
    let path = vec![
        Vec3::ZERO,
        Vec3::new(1.0, 1.0, 0.0),
        Vec3::new(2.0, 0.5, 0.0),
        Vec3::new(3.0, 1.5, 0.0),
    ];
    glizmo::linestrip(path, ORANGE);

    // Line strip with per-vertex colors
    let colored_path = vec![
        (Vec3::ZERO, GREEN),
        (Vec3::X, YELLOW),
        (Vec3::Y, RED),
        (Vec3::Z, BLUE),
    ];
    glizmo::linestrip_gradient(colored_path);
}
```

### Response
None (Gizmos are rendered directly)

### Response Example
None
```

--------------------------------

### Draw 2D and 3D Circles, Ellipses, and Spheres

Source: https://context7.com/atlv24/glizmo/llms.txt

This snippet demonstrates how to draw various circular and elliptical shapes in both 2D and 3D space. It utilizes the `glizmo::circle`, `glizmo::ellipse`, `glizmo::sphere`, `glizmo::circle_2d`, and `glizmo::ellipse_2d` functions. Shapes can be positioned and oriented using `Isometry3d` and `Isometry2d`, with configurable radii and colors. Note that `glizmo::sphere` draws a wireframe sphere using three circles.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::{Isometry2d, Isometry3d}};

fn debug_ranges_and_radii() {
    // 3D circle in XY plane
    glizmo::circle(
        Isometry3d::from_translation(Vec3::new(0.0, 1.0, 0.0)),
        2.0,
        GREEN
    );

    // Rotated 3D circle
    glizmo::circle(
        Isometry3d::new(
            Vec3::new(5.0, 0.0, 0.0),
            Quat::from_rotation_x(std::f32::consts::FRAC_PI_2)
        ),
        1.5,
        BLUE
    );

    // 3D ellipse with non-uniform radii
    glizmo::ellipse(
        Isometry3d::from_translation(Vec3::new(-3.0, 0.0, 0.0)),
        Vec2::new(2.0, 1.0),
        YELLOW
    );

    // Wireframe sphere (3 circles around axes)
    glizmo::sphere(
        Isometry3d::from_translation(Vec3::new(0.0, 3.0, 0.0)),
        1.0,
        RED
    );

    // 2D circle
    glizmo::circle_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        50.0,
        PURPLE
    );

    // 2D ellipse with rotation
    glizmo::ellipse_2d(
        Isometry2d::new(
            Vec2::new(200.0, 100.0),
            Rot2::degrees(45.0)
        ),
        Vec2::new(60.0, 30.0),
        ORANGE
    );
}

```

--------------------------------

### Rectangles and Boxes API

Source: https://context7.com/atlv24/glizmo/llms.txt

Functions for drawing wireframe rectangles in 2D/3D and cubes, with transform support.

```APIDOC
## Rectangles and Boxes API

### Description
Draw wireframe rectangles in 2D/3D and cubes with transform support.

### Method
`glizmo::rect`, `glizmo::cube`, `glizmo::aabb_3d`, `glizmo::rect_2d`

### Endpoint
N/A (Function calls)

### Parameters
- `glizmo::rect(transform: Isometry3d, size: Vec2, color: Color)`: Draws a 3D rectangle aligned with the transform's orientation.
- `glizmo::cube(transform: Transform, color: Color)`: Draws a wireframe cube with the given transform.
- `glizmo::aabb_3d(aabb: Aabb3d, transform: Transform, color: Color)`: Draws a wireframe AABB with an optional transform.
- `glizmo::rect_2d(transform: Isometry2d, size: Vec2, color: Color)`: Draws a 2D rectangle.

### Request Example
```rust
use bevy::{color::palettes::css::*, prelude::*, math::Isometry3d};

fn debug_collision_boxes() {
    // 3D rectangle aligned with XY plane
    glizmo::rect(
        Isometry3d::from_translation(Vec3::new(0.0, 2.0, 0.0)),
        Vec2::new(2.0, 1.0),
        GREEN
    );

    // Rotated 3D rectangle
    glizmo::rect(
        Isometry3d::new(
            Vec3::new(5.0, 0.0, 0.0),
            Quat::from_rotation_y(std::f32::consts::PI / 4.0)
        ),
        Vec2::splat(1.5),
        BLUE
    );

    // Wireframe cube with transform
    glizmo::cube(
        Transform::from_xyz(0.0, 0.5, 0.0).with_scale(Vec3::splat(1.0)),
        RED
    );

    // AABB (Axis-Aligned Bounding Box)
    glizmo::aabb_3d(
        Aabb3d::new(Vec3::new(3.0, 1.0, 0.0), Vec3::splat(0.5)),
        Transform::IDENTITY,
        YELLOW
    );

    // 2D rectangle
    glizmo::rect_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        Vec2::new(50.0, 30.0),
        PURPLE
    );
}
```

### Response
None (Gizmos are rendered directly)

### Response Example
None
```

--------------------------------

### Draw Geometric Primitives in 2D/3D

Source: https://context7.com/atlv24/glizmo/llms.txt

Renders Bevy's built-in geometric primitives in both 2D and 3D. Supports shapes like capsules, planes, tori, triangles, and regular polygons. Requires Bevy's primitive types and Isometry for positioning.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::{Isometry2d, Isometry3d, primitives::*}};

fn debug_geometric_primitives() {
    // 3D capsule
    let capsule = Capsule3d::new(0.5, 2.0);
    glizmo::primitive_3d(
        &capsule,
        Isometry3d::from_translation(Vec3::new(0.0, 1.0, 0.0)),
        GREEN
    );

    // 3D plane
    let plane = Plane3d {
        normal: Dir3::Y,
        half_size: Vec2::splat(1.0),
    };
    glizmo::primitive_3d(
        &plane,
        Isometry3d::new(
            Vec3::new(3.0, 0.0, 0.0),
            Quat::from_rotation_x(std::f32::consts::FRAC_PI_4)
        ),
        BLUE
    );

    // 3D torus
    let torus = Torus::new(1.0, 0.3);
    glizmo::primitive_3d(
        &torus,
        Isometry3d::from_translation(Vec3::new(-3.0, 1.0, 0.0)),
        PURPLE
    );

    // 2D triangle
    let triangle = Triangle2d::new(
        Vec2::ZERO,
        Vec2::new(50.0, 0.0),
        Vec2::new(25.0, 50.0)
    );
    glizmo::primitive_2d(
        &triangle,
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        YELLOW
    );

    // 2D polygon
    let polygon = RegularPolygon::new(30.0, 6);
    glizmo::primitive_2d(
        &polygon,
        Isometry2d::from_translation(Vec2::new(200.0, 100.0)),
        RED
    );
}
```

--------------------------------

### Draw Arcs in 2D/3D

Source: https://context7.com/atlv24/glizmo/llms.txt

Draws circular arcs in 2D and 3D with various angle configurations. Supports drawing arcs by angle and radius, or between two points. Utilizes Bevy's Isometry types for positioning and orientation.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::{Isometry2d, Isometry3d}};
use std::f32::consts::{PI, FRAC_PI_4};

fn debug_angles_and_sectors() {
    // 2D arc (quarter circle)
    glizmo::arc_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        FRAC_PI_4,
        50.0,
        GREEN
    );

    // 3D arc
    glizmo::arc_3d(
        PI,
        1.0,
        Isometry3d::new(
            Vec3::new(0.0, 1.0, 0.0),
            Quat::from_rotation_arc(Vec3::Y, Vec3::ONE.normalize())
        ),
        ORANGE
    );

    // Short arc between two points in 3D
    glizmo::short_arc_3d_between(
        Vec3::ZERO,          // center
        Vec3::X,             // from
        Vec3::new(0.5, 0.866, 0.0),  // to (60 degrees)
        BLUE
    );

    // Long arc (takes the longer path around the circle)
    glizmo::long_arc_3d_between(
        Vec3::new(0.0, 2.0, 0.0),
        Vec3::X + Vec3::Y * 2.0,
        Vec3::Z + Vec3::Y * 2.0,
        RED
    );

    // 2D short arc between points
    glizmo::short_arc_2d_between(
        Vec2::new(100.0, 100.0),
        Vec2::new(150.0, 100.0),
        Vec2::new(100.0, 150.0),
        YELLOW
    );

    // 2D long arc between points
    glizmo::long_arc_2d_between(
        Vec2::ZERO,
        Vec2::X * 50.0,
        Vec2::Y * 50.0,
        PURPLE
    );
}
```

--------------------------------

### Draw Rounded Rectangles and Cuboids

Source: https://context7.com/atlv24/glizmo/llms.txt

This code snippet illustrates how to draw wireframe rectangles and cuboids with rounded corners in both 2D and 3D. It uses the `glizmo::rounded_rect`, `glizmo::rounded_rect_2d`, and `glizmo::rounded_cuboid` functions. Parameters include the shape's transformation (position and orientation), dimensions (size), corner radius, and color. Note that `rounded_cuboid` creates a box with rounded edges.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::{Isometry2d, Isometry3d}};

fn debug_collision_shapes() {
    // Rounded rectangle in 3D
    glizmo::rounded_rect(
        Isometry3d::from_translation(Vec3::new(0.0, 1.0, 0.0)),
        Vec2::new(2.0, 1.0),
        0.2,
        GREEN
    );

    // Rounded rectangle in 2D
    glizmo::rounded_rect_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        Vec2::new(80.0, 50.0),
        10.0,
        BLUE
    );

    // Rounded cuboid (box with rounded edges)
    glizmo::rounded_cuboid(
        Isometry3d::new(
            Vec3::new(-2.0, 0.75, 0.0),
            Quat::from_rotation_y(std::f32::consts::FRAC_PI_4)
        ),
        Vec3::splat(1.5),
        0.1,
        TURQUOISE
    );
}

```

--------------------------------

### Draw Cross Markers in 2D/3D

Source: https://context7.com/atlv24/glizmo/llms.txt

Renders cross markers in 3D and 2D space to visualize specific points. Accepts Bevy's Isometry types for position and orientation, size, and color. Useful for marking waypoints or debug locations.

```rust
use bevy::{color::palettes::css::*, prelude::*, math::{Isometry2d, Isometry3d}};

fn debug_waypoints() {
    // 3D cross marker at position
    glizmo::cross(
        Isometry3d::from_translation(Vec3::new(1.0, 1.0, 1.0)),
        0.5,
        WHITE
    );

    // Rotated 3D cross
    glizmo::cross(
        Isometry3d::new(
            Vec3::new(5.0, 0.0, 0.0),
            Quat::from_rotation_y(std::f32::consts::FRAC_PI_4)
        ),
        0.3,
        RED
    );

    // 2D cross marker
    glizmo::cross_2d(
        Isometry2d::from_translation(Vec2::new(100.0, 100.0)),
        10.0,
        YELLOW
    );

    // Mark multiple points
    let points = vec![
        Vec3::new(1.0, 0.0, 1.0),
        Vec3::new(2.0, 0.0, 1.5),
        Vec3::new(3.0, 0.0, 0.5),
    ];
    for point in points {
        glizmo::cross(Isometry3d::from_translation(point), 0.2, LIME);
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.