### 2D Camera Plugin Setup

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Minimal plugin setup for 2D rendering with a 2D camera. Ensure Shape2dPlugin is added to your Bevy App.

```rust
use bevy::prelude::*;
use bevy_vector_shapes::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(Shape2dPlugin::default())
        .add_systems(Startup, setup)
        .add_systems(Update, draw)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2d);
}

fn draw(mut painter: ShapePainter) {
    painter.circle(100.0);
}
```

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

### Basic Bevy App Setup with Shape2dPlugin

Source: https://github.com/james-j-obrien/bevy_vector_shapes/blob/main/README.md

Set up a Bevy application with the Shape2dPlugin for 2D cameras. This includes initializing the Bevy app, adding the shape plugin, and defining startup and update systems for drawing.

```rust
use bevy::prelude::*;
// Import commonly used items
use bevy_vector_shapes::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // Add the shape plugin:
        // - Shape2dPlugin for 2D cameras
        // - ShapePlugin for both 3D and 2D cameras
        .add_plugins(Shape2dPlugin::default())
        .add_systems(Startup, setup)
        .add_systems(Update, draw)
        .run();
}

fn setup(mut commands: Commands) {
    // Spawn the camera
    commands.spawn(Camera2dBundle::default());
}

fn draw(mut painter: ShapePainter) {
    // Draw a circle
    painter.circle(100.0);
}
```

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

### 2D and 3D Camera Plugin Setup

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Plugin setup for rendering shapes with both 3D and 2D cameras. This includes Shape2dPlugin and adds 3D rendering capabilities.

```rust
use bevy::prelude::*;
use bevy_vector_shapes::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(ShapePlugin::default())
        .add_systems(Startup, setup)
        .add_systems(Update, draw)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(0., 0., 16.).looking_at(Vec3::ZERO, Vec3::Y),
        Msaa::Off,
    ));
}

fn draw(mut painter: ShapePainter) {
    painter.circle(1.0);
    painter.translate(Vec3::X * 3.0);
    painter.rect(Vec2::new(2.0, 1.5));
}
```

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

### Retained Mode Spawning with ShapeCommands

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Spawns shapes as persistent entities using ShapeCommands. These shapes are retained until despawned and can be manipulated via Bevy's ECS. Example includes spawning a circle with child lines.

```rust
use bevy::prelude::*;
use bevy_vector_shapes::prelude::*;
use std::f32::consts::PI;

fn spawn_shapes(mut commands: Commands, mut shapes: ShapeCommands) {
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(0., 0., 16.).looking_at(Vec3::ZERO, Vec3::Y),
        Msaa::Off,
    ));

    // Spawn a circle with child lines
    shapes.circle(1.0).with_children(|parent| {
        for _ in 0..4 {
            parent.rotate_z(PI / 2.0);
            parent.line(Vec3::ZERO, Vec3::Y * 2.0);
        }
    });
}

// Query and animate retained shapes
fn rotate_shapes(time: Res<Time>, mut circles: Query<&mut Transform, With<DiscComponent>>) {
    for mut transform in circles.iter_mut() {
        transform.rotation *= Quat::from_rotation_z(time.delta_secs());
    }
}
```

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

### Configuring Shape Properties with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Illustrates how to configure various visual and rendering properties of shapes using the ShapePainter. This includes transformations, colors, stroke properties, shape-specific settings, and rendering options.

```rust
use bevy::prelude::*;
use bevy::camera::visibility::RenderLayers;
use bevy_vector_shapes::prelude::*;

fn configure_shapes(mut painter: ShapePainter) {
    // Transform manipulation
    painter.set_translation(Vec3::new(0.0, 2.0, 0.0));
    painter.translate(Vec3::X * 3.0);  // Relative translation respecting rotation
    painter.set_rotation(Quat::from_rotation_z(0.5));
    painter.rotate_z(0.1);  // Relative rotation
    painter.set_scale(Vec3::ONE * 2.0);

    // Visual properties
    painter.color = Color::srgb(1.0, 0.5, 0.2);
    painter.set_color(Color::srgba(0.5, 0.8, 0.3, 0.7));

    // Stroke properties
    painter.hollow = true;
    painter.thickness = 0.2;
    painter.thickness_type = ThicknessType::World;  // World, Pixels, or Screen

    // Shape-specific properties
    painter.cap = Cap::Round;  // None, Square, or Round
    painter.roundness = 0.1;   // For polygons and triangles
    painter.corner_radii = Vec4::splat(0.2);  // For rectangles
    painter.alignment = Alignment::Flat;  // Flat or Billboard

    // Rendering properties
    painter.alpha_mode = ShapeAlphaMode::Blend;
    painter.disable_laa = false;  // Local anti-aliasing
    painter.render_layers = Some(RenderLayers::layer(1));

    // Pipeline selection
    painter.set_2d();  // Use 2D pipeline
    painter.set_3d();  // Use 3D pipeline

    // Draw with current config
    painter.circle(1.0);

    // Reset to base configuration
    painter.reset();
}
```

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

### Immediate Mode Drawing with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Utilizes ShapePainter for immediate-mode drawing. Shapes are configured and drawn each frame. Use painter.reset() to revert to default settings.

```rust
use bevy::prelude::*;
use bevy_vector_shapes::prelude::*;
use std::f32::consts::PI;

fn draw_shapes(mut painter: ShapePainter, time: Res<Time>) {
    // Configure the painter
    painter.color = Color::srgb(1.0, 0.5, 0.2);
    painter.thickness = 0.5;
    painter.hollow = true;

    // Draw a rotating circle
    painter.rotate_z(time.elapsed_secs());
    painter.circle(2.0);

    // Draw a line with round caps
    painter.cap = Cap::Round;
    painter.color = Color::srgb(0.2, 0.8, 0.4);
    painter.line(Vec3::new(-3.0, 0.0, 0.0), Vec3::new(3.0, 0.0, 0.0));

    // Reset to base config for next shape
    painter.reset();
    painter.set_color(Color::srgb(0.4, 0.4, 1.0));
    painter.corner_radii = Vec4::splat(0.3);
    painter.rect(Vec2::new(4.0, 2.0));
}
```

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

### Draw Circles with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Demonstrates drawing solid and hollow circles with Bevy's ShapePainter. Configure color, hollow mode, and thickness before calling the circle function.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn draw_circles(mut painter: ShapePainter) {
    // Solid filled circle
    painter.color = Color::srgb(1.0, 0.5, 0.0);
    painter.hollow = false;
    painter.circle(2.0);

    // Hollow circle (ring)
    painter.translate(Vec3::X * 5.0);
    painter.hollow = true;
    painter.thickness = 0.3;
    painter.color = Color::srgb(0.0, 0.8, 0.4);
    painter.circle(1.5);

    // Small decorative circles
    painter.translate(Vec3::X * 5.0);
    painter.hollow = false;
    for i in 0..5 {
        painter.translate(Vec3::Y * 0.8);
        painter.circle(0.3 - i as f32 * 0.05);
    }
}
```

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

### Draw Rectangles with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Demonstrates drawing rectangles with customizable corner rounding using ShapePainter. Supports solid, hollow, and mixed corner radii.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn draw_rectangles(mut painter: ShapePainter) {
    // Sharp corner rectangle
    painter.color = Color::srgb(0.3, 0.7, 0.5);
    painter.corner_radii = Vec4::ZERO;
    painter.rect(Vec2::new(3.0, 1.5));

    // Fully rounded rectangle (pill shape)
    painter.translate(Vec3::Y * -2.5);
    painter.corner_radii = Vec4::splat(0.5);
    painter.color = Color::srgb(0.5, 0.3, 0.8);
    painter.rect(Vec2::new(3.0, 1.0));

    // Mixed corner radii
    painter.translate(Vec3::Y * -2.5);
    painter.corner_radii = Vec4::new(0.0, 0.3, 0.6, 0.0);
    painter.color = Color::srgb(0.9, 0.5, 0.3);
    painter.rect(Vec2::new(3.0, 1.5));

    // Hollow rectangle (border only)
    painter.translate(Vec3::Y * -2.5);
    painter.hollow = true;
    painter.thickness = 0.15;
    painter.corner_radii = Vec4::splat(0.3);
    painter.color = Color::WHITE;
    painter.rect(Vec2::new(3.0, 1.5));
}
```

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

### Utilize Alpha Modes for Transparency

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Shapes support `ShapeAlphaMode::Add`, `ShapeAlphaMode::Multiply`, and `ShapeAlphaMode::Blend` for different transparency effects. Use `reset()` to revert to default settings.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*
use std::f32::consts::TAU;

fn draw_transparent_shapes(mut painter: ShapePainter) {
    let radius = 2.0;

    // Additive blending - colors add together
    painter.translate(Vec3::X * -6.0);
    painter.alpha_mode = ShapeAlphaMode::Add;
    draw_overlapping_circles(&mut painter, radius);

    // Multiplicative blending - colors multiply
    painter.reset();
    painter.alpha_mode = ShapeAlphaMode::Multiply;
    draw_overlapping_circles(&mut painter, radius);

    // Standard blend - normal transparency
    painter.reset();
    painter.translate(Vec3::X * 6.0);
    painter.alpha_mode = ShapeAlphaMode::Blend;
    draw_overlapping_circles(&mut painter, radius);
}

fn draw_overlapping_circles(painter: &mut ShapePainter, radius: f32) {
    painter.color = Color::srgba(1.0, 0.0, 0.0, 0.5);
    painter.circle(radius);

    painter.rotate_z(-TAU / 3.0);
    painter.translate(Vec3::Y * radius * 1.2);
    painter.color = Color::srgba(0.0, 1.0, 0.0, 0.5);
    painter.circle(radius);

    painter.rotate_z(-TAU / 3.0);
    painter.translate(Vec3::Y * radius * 1.2);
    painter.color = Color::srgba(0.0, 0.0, 1.0, 0.5);
    painter.circle(radius);
}
```

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

### Draw Arcs with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Illustrates drawing filled and hollow arcs using ShapePainter. Supports configuration of radius, angle range, color, thickness, and cap styles.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*
use std::f32::consts::{PI, TAU};

fn draw_arcs(mut painter: ShapePainter, time: Res<Time>) {
    // Filled arc (pie slice)
    painter.hollow = false;
    painter.cap = Cap::None;
    painter.color = Color::srgb(0.8, 0.2, 0.3);
    painter.arc(2.0, 0.0, TAU * (2.0 / 3.0));

    // Hollow arc with round caps (progress indicator)
    painter.translate(Vec3::X * 6.0);
    painter.hollow = true;
    painter.thickness = 0.4;
    painter.cap = Cap::Round;
    painter.color = Color::srgb(0.3, 0.7, 1.0);

    let progress = (time.elapsed_secs().sin() + 1.0) / 2.0;
    let start_angle = -PI * 0.75;
    let end_angle = start_angle + progress * PI * 1.5;
    painter.arc(1.5, start_angle, end_angle);

    // Background track for progress indicator
    painter.thickness = 0.2;
    painter.color = Color::srgba(1.0, 1.0, 1.0, 0.3);
    painter.cap = Cap::None;
    painter.arc(1.5, start_angle, -start_angle);
}
```

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

### Bloom Effects with Bevy Vector Shapes

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Demonstrates how shapes integrate with Bevy's bloom post-processing when HDR is enabled. Bright colors will produce a glow effect.

```rust
use bevy::prelude::*;
use bevy::post_process::bloom::Bloom;
use bevy::render::view::Hdr;
use bevy_vector_shapes::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(ShapePlugin::default())
        .insert_resource(ClearColor(Color::BLACK))
        .add_systems(Startup, setup)
        .add_systems(Update, draw_glowing_shapes)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(0., 0., 16.).looking_at(Vec3::ZERO, Vec3::Y),
        Hdr,
        Msaa::Off,
        Bloom::default(),
    ));
}

fn draw_glowing_shapes(mut painter: ShapePainter, time: Res<Time>) {
    // Bright colors will bloom
    let intensity = (time.elapsed_secs().sin() + 1.0) / 2.0;
    painter.color = Color::srgb(1.0 + intensity, 0.5, 0.2);
    painter.circle(2.0);

    painter.translate(Vec3::X * 5.0);
    painter.color = Color::srgb(0.2, 1.0 + intensity, 0.5);
    painter.rect(Vec2::new(3.0, 2.0));
}
```

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

### Draw Lines with ShapePainter

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Shows how to draw lines between two 3D points using ShapePainter. Supports stroke rendering with configurable thickness and cap styles (None, Square, Round).

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*
use std::f32::consts::PI;

fn draw_lines(mut painter: ShapePainter) {
    painter.thickness = 0.3;

    // Line with no caps
    painter.cap = Cap::None;
    painter.color = Color::srgb(0.4, 0.4, 0.8);
    painter.line(Vec3::new(-3.0, 1.5, 0.0), Vec3::new(3.0, 1.5, 0.0));

    // Line with square caps (extends line by thickness)
    painter.cap = Cap::Square;
    painter.color = Color::srgb(0.5, 0.8, 0.4);
    painter.line(Vec3::new(-3.0, 0.0, 0.0), Vec3::new(3.0, 0.0, 0.0));

    // Line with round caps
    painter.cap = Cap::Round;
    painter.color = Color::srgb(0.9, 0.6, 0.2);
    painter.line(Vec3::new(-3.0, -1.5, 0.0), Vec3::new(3.0, -1.5, 0.0));

    // Create a star pattern
    painter.translate(Vec3::X * 8.0);
    painter.thickness = 0.15;
    for i in 0..8 {
        let rotation = Quat::from_rotation_z(PI / 4.0 * i as f32);
        painter.line(Vec3::ZERO, rotation * Vec3::Y * 2.0);
    }
}
```

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

### Draw Images/Textures - image()

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Draws a textured rectangle using a provided image handle. The texture is applied to a rectangle shape with the specified size. Multiple copies can be drawn at different positions.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn draw_textured_shapes(
    mut painter: ShapePainter,
    asset_server: Res<AssetServer>,
) {
    let texture: Handle<Image> = asset_server.load("my_texture.png");

    // Draw image at specific size
    painter.image(texture.clone(), Vec2::new(4.0, 4.0));

    // Draw multiple copies at different positions
    painter.translate(Vec3::X * 6.0);
    painter.image(texture.clone(), Vec2::new(2.0, 2.0));

    painter.translate(Vec3::Y * 3.0);
    painter.image(texture, Vec2::splat(1.5));
}
```

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

### Draw Regular Polygons - ngon()

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Draws a regular polygon with a specified number of sides and radius. Supports corner rounding via the `roundness` property. Use `hollow` and `thickness` for outlines.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn draw_polygons(mut painter: ShapePainter) {
    painter.hollow = false;

    // Triangle
    painter.color = Color::srgb(0.8, 0.3, 0.3);
    painter.roundness = 0.0;
    painter.ngon(3.0, 1.5);

    // Square with rounded corners
    painter.translate(Vec3::X * 4.0);
    painter.color = Color::srgb(0.3, 0.8, 0.3);
    painter.roundness = 0.2;
    painter.ngon(4.0, 1.5);

    // Pentagon
    painter.translate(Vec3::X * 4.0);
    painter.color = Color::srgb(0.3, 0.3, 0.8);
    painter.roundness = 0.0;
    painter.ngon(5.0, 1.5);

    // Hexagon hollow
    painter.translate(Vec3::X * 4.0);
    painter.hollow = true;
    painter.thickness = 0.3;
    painter.color = Color::srgb(0.8, 0.6, 0.2);
    painter.ngon(6.0, 1.5);
}
```

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

### Draw Triangles - triangle()

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Draws a triangle with three specified vertex positions, allowing for arbitrary shapes. Supports hollow rendering and corner rounding.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn draw_triangles(mut painter: ShapePainter) {
    // Equilateral-ish triangle
    painter.color = Color::srgb(0.9, 0.4, 0.4);
    painter.triangle(
        Vec2::new(0.0, 1.5),
        Vec2::new(-1.3, -0.75),
        Vec2::new(1.3, -0.75),
    );

    // Right triangle
    painter.translate(Vec3::X * 4.0);
    painter.color = Color::srgb(0.4, 0.9, 0.4);
    painter.triangle(
        Vec2::new(-1.0, -1.0),
        Vec2::new(1.0, -1.0),
        Vec2::new(-1.0, 1.0),
    );

    // Hollow triangle with rounded corners
    painter.translate(Vec3::X * 4.0);
    painter.hollow = true;
    painter.thickness = 0.2;
    painter.roundness = 0.1;
    painter.color = Color::srgb(0.4, 0.4, 0.9);
    painter.triangle(
        Vec2::new(0.0, 1.2),
        Vec2::new(-1.0, -0.8),
        Vec2::new(1.0, -0.8),
    );
}
```

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

### Configure Billboard Alignment for Shapes

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Set the `Alignment::Billboard` in `ShapeConfig` to make shapes always face the camera. This is useful for 3D UIs, labels, and sprites.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(ShapePlugin {
            base_config: ShapeConfig {
                alignment: Alignment::Billboard,
                ..ShapeConfig::default_3d()
            },
            ..default()
        })
        .add_systems(Startup, setup)
        .add_systems(Update, draw_billboards)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn((Camera3d::default(), Msaa::Off));
}

fn draw_billboards(mut painter: ShapePainter, time: Res<Time>) {
    // All shapes will face the camera
    painter.color = Color::srgb(0.8, 0.4, 0.2);
    painter.circle(1.0);

    painter.translate(Vec3::X * 3.0);
    painter.rect(Vec2::new(2.0, 1.5));

    // Lines billboard around their axis
    painter.translate(Vec3::X * 3.0);
    painter.line(Vec3::NEG_Y, Vec3::Y);
}
```

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

### Off-Screen Rendering with Canvas API

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Renders shapes to a texture for use elsewhere in the scene. Canvases support Continuous, Persistent, and OnDemand drawing modes. Use `set_canvas` to switch drawing targets.

```rust
use bevy::prelude::*
use bevy_vector_shapes::prelude::*

fn setup(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
    // Create a 1024x1024 canvas
    let config = CanvasConfig::new(1024, 1024);
    let (canvas_handle, _entity) = commands.spawn_canvas(images.as_mut(), config);

    // Spawn main camera
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(0., 0., 16.).looking_at(Vec3::ZERO, Vec3::Y),
        Msaa::Off,
    ));
}

fn draw_to_canvas(
    mut painter: ShapePainter,
    canvas_query: Query<(Entity, &Canvas)>,
) {
    let (canvas_entity, canvas) = canvas_query.single();

    // Display the canvas texture as an image in the main scene
    painter.image(canvas.image.clone(), Vec2::splat(10.0));

    // Switch to drawing on the canvas
    painter.set_canvas(canvas_entity);
    painter.set_scale(Vec3::ONE * 50.0);

    // Draw shapes to the canvas
    painter.color = Color::srgb(1.0, 0.5, 0.2);
    painter.circle(2.0);

    painter.translate(Vec3::X * 5.0);
    painter.color = Color::srgb(0.2, 0.8, 0.5);
    painter.rect(Vec2::new(3.0, 2.0));
}
```

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

### Assign Shapes to Render Layers

Source: https://context7.com/james-j-obrien/bevy_vector_shapes/llms.txt

Use `RenderLayers` to assign shapes to specific rendering layers, controlled by cameras. This enables rendering to textures or multi-pass effects.

```rust
use bevy::prelude::*
use bevy::camera::visibility::RenderLayers
use bevy_vector_shapes::prelude::*

fn setup_render_layers(
    mut commands: Commands,
    mut images: ResMut<Assets<Image>>,
) {
    let image_handle = Canvas::create_image(
        images.as_mut(),
        512, 512,
        bevy::image::ImageSampler::Default,
        false
    );

    // Camera that renders to texture (layer 1)
    let first_pass_layer = RenderLayers::layer(1);
    commands.spawn(( 
        Camera3d::default(),
        Camera {
            clear_color: ClearColorConfig::Custom(Color::WHITE),
            order: -1,
            ..default()
        },
        bevy::camera::RenderTarget::Image(image_handle.clone().into()),
        Transform::from_xyz(0., 0., 15.).looking_at(Vec3::ZERO, Vec3::Y),
        first_pass_layer,
    ));

    // Main camera (default layer)
    commands.spawn(( 
        Camera3d::default(),
        Transform::from_xyz(0., 0., 15.).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

fn draw_layered_shapes(mut painter: ShapePainter) {
    // Draw to layer 1 only (rendered to texture)
    painter.render_layers = Some(RenderLayers::layer(1));
    painter.color = Color::srgb(0.8, 0.2, 0.2);
    painter.circle(2.0);

    // Reset to draw to default layer (main camera)
    painter.reset();
    painter.color = Color::srgb(0.2, 0.8, 0.2);
    painter.translate(Vec3::X * 5.0);
    painter.circle(1.5);
}
```

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