Struct ShapeCommands

pub struct ShapeCommands<'w, 's> { /* private fields */ }

A system param that allows ergonomic spawning of shape entities.

The ShapeConfig used is initially extracted from the BaseShapeConfig resource. Subsequent calls to reset() will reset the config back to whatever is currently stored within the BaseShapeConfig resource.

Shapes will be spawned with commands during the next instance of apply_deferred

Implementations

impl<'w, 's> ShapeCommands<'w, 's>

pub fn reset(&mut self)

Set the painter’s ShapeConfig to the current value of the BaseShapeConfig resource.

Methods from Deref<Target = ShapeConfig>

pub fn translate(&mut self, dir: Vec3)

Helper method to modify the configs transform taking into account rotation and scale.

Examples found in repository

examples/healthbar_stress_test.rs (line 35)

fn draw_health_bar(painter: &mut ShapePainter, hp: f32) {
    painter.translate(Vec3::Y * 0.7);
    painter.corner_radii = Vec4::splat(0.3);

    painter.set_color(GREEN * hp + RED * (1. - hp));
    painter.rect(Vec2::new(0.2 + 0.8 * hp, 0.2));

    painter.thickness = 0.02;
    painter.hollow = true;
    painter.color = Color::WHITE;
    painter.rect(Vec2::new(1.06, 0.26));
}

examples/canvas_modes.rs (line 50)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 6.0;
    painter.set_color(CRIMSON);
    painter.translate(Vec3::Y * time.elapsed_secs().sin() * 256.0);
    painter.circle(48.0);

    painter.reset();
}

examples/textured.rs (line 36)

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Single<Entity, With<Canvas>>) {
    painter.rotate_z(time.elapsed_secs().sin());
    painter.set_canvas(*canvas);
    painter.set_color(WHITE * 2.0);
    painter.translate(Vec3::NEG_Y * 12.0 * 16.0);
    painter.thickness = 16.0;

    for _ in 0..12 {
        painter.translate(Vec3::Y * 32.0);
        painter.line(Vec3::NEG_X * 256.0, Vec3::X * 256.0);
    }
    painter.reset();
}

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<&Canvas>) {
    painter.texture = Some(canvas.image.clone());
    painter.translate(Vec3::NEG_Y * 2.0);

    gallery(painter, time.elapsed_secs(), 0..10);
}

examples/alpha_mode.rs (line 36)

fn draw_circles(painter: &mut ShapePainter, radius: f32) {
    painter.translate(-(Vec3::X + Vec3::NEG_Y) * f32::sqrt(radius) * 0.5);
    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 + Vec3::Z * 0.0001);
    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 + Vec3::Z * 0.0001);
    painter.color = Color::srgba(0.0, 0.0, 1.0, 0.5);
    painter.circle(radius);
}

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

    painter.reset();
    painter.translate(Vec3::X * radius * -4.0);
    painter.alpha_mode = ShapeAlphaMode::Add;
    draw_circles(&mut painter, radius);

    painter.reset();
    painter.alpha_mode = ShapeAlphaMode::Multiply;
    draw_circles(&mut painter, radius);

    painter.reset();
    painter.translate(Vec3::X * radius * 4.0);
    painter.alpha_mode = ShapeAlphaMode::Blend;
    draw_circles(&mut painter, radius);
}

examples/parenting_painter.rs (line 44)

fn draw_tree(time: f32, painter: &mut ShapePainter, depth: u32) {
    if depth == 0 {
        return;
    }

    let line_a = Vec3::Y + Vec3::X * 0.5;
    painter.rotate_z(time.sin() * 0.2);
    painter
        .line(Vec3::ZERO, line_a)
        .with_children(|child_painter| {
            child_painter.translate(line_a);

            draw_tree(time, child_painter, depth - 1);
        });

    let line_b = Vec3::Y + Vec3::NEG_X * 0.5;
    painter.rotate_z(-time.sin() * 0.4);
    painter
        .line(Vec3::ZERO, line_b)
        .with_children(|child_painter| {
            child_painter.translate(line_b);

            draw_tree(time, child_painter, depth - 1);
        });
}

fn draw_gallery(
    time: Res<Time>,
    mut painter: ShapePainter,
    mut tree: Single<&mut Transform, With<Tree>>,
) {
    tree.rotation = Quat::from_rotation_z(time.elapsed_secs().sin() / 4.0);

    // Position our painter relative to our tree entity
    painter.transform = **tree;
    painter.set_color(SEA_GREEN + WHITE * 0.25);
    painter
        .line(Vec3::ZERO, Vec3::Y)
        .with_children(|child_painter| {
            child_painter.translate(Vec3::Y);
            draw_tree(time.elapsed_secs(), child_painter, 10);
        });
}

examples/render_layers.rs (line 112)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter) {
    painter.reset();
    painter.render_layers = Some(RenderLayers::layer(1));
    painter.hollow = true;
    painter.transform.scale = Vec3::ONE * 3.0;

    let meter_fill = (time.elapsed_secs().sin() + 1.0) / 2.0;
    let meter_size = PI * 1.5;

    let start_angle = -meter_size / 2.0;
    let end_angle = -meter_size / 2.0 + meter_fill * meter_size;

    painter.cap = Cap::Round;
    painter.thickness = 0.4;
    painter.set_color(CRIMSON * (1.0 / (0.5 + meter_fill)));
    painter.arc(1.3, start_angle, end_angle);

    painter.cap = Cap::None;
    painter.thickness = 0.2;
    painter.set_color(DARK_GRAY);
    painter.arc(1.6, start_angle, -start_angle);
    painter.arc(0.8, start_angle, -start_angle);

    let offset = Quat::from_rotation_z(start_angle) * Vec3::Y * 1.1;
    painter.translate(offset);
    painter.arc(0.5, start_angle + PI * 1.5, start_angle + 2.5 * PI);
    painter.translate(-offset);

    painter.translate(Quat::from_rotation_z(-start_angle) * Vec3::Y * 1.1);
    painter.arc(0.5, start_angle + PI, start_angle + 2.0 * PI);
}

Additional examples can be found in:

• examples/thickness.rs
• examples/gallery_3d.rs

pub fn set_translation(&mut self, translation: Vec3)

Helper method to set the configs transform.

Examples found in repository

examples/minimal_3d.rs (line 23)

fn draw(mut painter: ShapePainter) {
    // Move the painter so it's not inside the camera
    painter.set_translation(Vec3::NEG_Z);
    // Draw a circle
    painter.circle(0.1);
}

examples/origin.rs (line 38)

fn draw(mut painter: ShapePainter) {
    // Render the background
    painter.color = Color::BLACK.with_alpha(0.9);
    painter.corner_radii = Vec4::splat(0.1);
    painter.rect(Vec2::new(2.0, 1.0));

    // Set the circle color
    painter.color = Color::WHITE;

    // Set the origin of the circles in front of the background
    // Without this, the left circle is blended in the wrong order
    painter.origin = Some(Vec3::Z * 0.01);

    // Render the left circle
    painter.set_translation(Vec3::X * -0.5);
    painter.circle(0.2);

    // Render the right circle
    painter.set_translation(Vec3::X * 0.5);
    painter.circle(0.2);
}

pub fn rotate(&mut self, quat: Quat)

Helper method to rotate the configs transform by a given Quat.

pub fn set_rotation(&mut self, rotation: Quat)

Helper method to set the configs rotation.

pub fn rotate_x(&mut self, angle: f32)

Helper method to rotate the configs transform around the x axis.

pub fn rotate_y(&mut self, angle: f32)

Helper method to rotate the configs transform around the y axis.

pub fn rotate_z(&mut self, angle: f32)

Helper method to rotate the configs transform around the z axis.

Examples found in repository

examples/textured.rs (line 33)

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Single<Entity, With<Canvas>>) {
    painter.rotate_z(time.elapsed_secs().sin());
    painter.set_canvas(*canvas);
    painter.set_color(WHITE * 2.0);
    painter.translate(Vec3::NEG_Y * 12.0 * 16.0);
    painter.thickness = 16.0;

    for _ in 0..12 {
        painter.translate(Vec3::Y * 32.0);
        painter.line(Vec3::NEG_X * 256.0, Vec3::X * 256.0);
    }
    painter.reset();
}

examples/retained.rs (line 28)

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

    // The ShapeCommands API is identical to the ShapePainter API so can be used almost interchangeably
    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);
        }
    });
}

examples/canvas_recursion.rs (line 37)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(12.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 16.0;
    painter.set_color(SEA_GREEN + Srgba::WHITE * 0.25);
    painter.rect(Vec2::splat(1024.0));

    painter.rotate_z(time.elapsed_secs().sin());
    painter.image(canvas.image.clone(), Vec2::splat(980.0));

    painter.reset();
}

examples/alpha_mode.rs (line 40)

fn draw_circles(painter: &mut ShapePainter, radius: f32) {
    painter.translate(-(Vec3::X + Vec3::NEG_Y) * f32::sqrt(radius) * 0.5);
    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 + Vec3::Z * 0.0001);
    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 + Vec3::Z * 0.0001);
    painter.color = Color::srgba(0.0, 0.0, 1.0, 0.5);
    painter.circle(radius);
}

examples/parenting_painter.rs (line 40)

fn draw_tree(time: f32, painter: &mut ShapePainter, depth: u32) {
    if depth == 0 {
        return;
    }

    let line_a = Vec3::Y + Vec3::X * 0.5;
    painter.rotate_z(time.sin() * 0.2);
    painter
        .line(Vec3::ZERO, line_a)
        .with_children(|child_painter| {
            child_painter.translate(line_a);

            draw_tree(time, child_painter, depth - 1);
        });

    let line_b = Vec3::Y + Vec3::NEG_X * 0.5;
    painter.rotate_z(-time.sin() * 0.4);
    painter
        .line(Vec3::ZERO, line_b)
        .with_children(|child_painter| {
            child_painter.translate(line_b);

            draw_tree(time, child_painter, depth - 1);
        });
}

examples/parenting_commands.rs (line 38)

fn setup(mut commands: Commands, mut shapes: ShapeCommands, mut meshes: ResMut<Assets<Mesh>>) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0., 0.0, 16.).looking_at(Vec3::ZERO, Vec3::Y),
        Msaa::Off,
    ));

    // When spawning shapes as children of non-shape entities you can use `with_shape_children`
    // This requires passing in a ShapeConfig, you can construct one yourself or
    // take an existing one from a ShapePainter or ShapeCommands with .config()
    commands
        .spawn((Target, Transform::default(), Visibility::default()))
        .with_shape_children(shapes.config(), |child_builder| {
            for _ in 0..4 {
                child_builder.rotate_z(PI / 2.0);
                child_builder.line(Vec3::Y, Vec3::Y * 2.0);
            }
        });

    let cube_handle = meshes.add(Mesh::from(Cuboid::new(0.2, 0.2, 0.2)));

    // When spawning non-shapes as children of shapes you can use `with_children` like normal
    shapes
        .circle(0.2)
        .insert((Target, Transform::default(), Visibility::default()))
        .with_children(|child_builder| {
            for i in 0..4 {
                let transform = Transform::from_translation(
                    Quat::from_rotation_z(PI / 2.0 * i as f32 + PI / 4.0)
                        * Vec3::new(0.0, 1.0, 0.0),
                );
                child_builder.spawn((
                    Mesh3d(cube_handle.clone()),
                    MeshMaterial3d::<StandardMaterial>::default(),
                    transform,
                ));
            }
        });
}

Additional examples can be found in:

• examples/gallery_3d.rs

pub fn scale(&mut self, scale: Vec3)

Helper method to scale the configs transform.

Examples found in repository

examples/gallery_2d.rs (line 24)

fn draw_gallery(time: Res<Time>, mut painter: ShapePainter) {
    painter.scale(Vec3::ONE * 34.0);
    gallery(painter, time.elapsed_secs(), 0..15);
}

pub fn set_scale(&mut self, scale: Vec3)

Helper method to set the configs scale.

Examples found in repository

examples/canvas_basic.rs (line 35)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 48.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

examples/canvas_bloom.rs (line 47)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 12.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

examples/canvas_low_res.rs (line 39)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 12.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

pub fn set_canvas(&mut self, canvas: Entity)

Helper method to change shape render target to a canvas.

Also sets pipeline to Shape2d.

Examples found in repository

examples/canvas_basic.rs (line 34)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 48.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

examples/canvas_bloom.rs (line 46)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 12.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

examples/canvas_low_res.rs (line 38)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.set_scale(Vec3::ONE * 12.0);

    gallery(painter, time.elapsed_secs(), 0..15);
}

examples/canvas_modes.rs (line 46)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 6.0;
    painter.set_color(CRIMSON);
    painter.translate(Vec3::Y * time.elapsed_secs().sin() * 256.0);
    painter.circle(48.0);

    painter.reset();
}

examples/textured.rs (line 34)

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Single<Entity, With<Canvas>>) {
    painter.rotate_z(time.elapsed_secs().sin());
    painter.set_canvas(*canvas);
    painter.set_color(WHITE * 2.0);
    painter.translate(Vec3::NEG_Y * 12.0 * 16.0);
    painter.thickness = 16.0;

    for _ in 0..12 {
        painter.translate(Vec3::Y * 32.0);
        painter.line(Vec3::NEG_X * 256.0, Vec3::X * 256.0);
    }
    painter.reset();
}

examples/canvas_recursion.rs (line 31)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(12.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 16.0;
    painter.set_color(SEA_GREEN + Srgba::WHITE * 0.25);
    painter.rect(Vec2::splat(1024.0));

    painter.rotate_z(time.elapsed_secs().sin());
    painter.image(canvas.image.clone(), Vec2::splat(980.0));

    painter.reset();
}

pub fn set_3d(&mut self)

Helper method to change the target pipeline to the 3d pipeline.

pub fn set_2d(&mut self)

Helper method to change the target pipeline to the 2d pipeline.

pub fn without_transform(&self) -> Self

Helper method to clone the config without it’s transform, useful when parenting.

pub fn set_color(&mut self, color: impl Into<Color>)

Examples found in repository

examples/healthbar_stress_test.rs (line 38)

fn draw_health_bar(painter: &mut ShapePainter, hp: f32) {
    painter.translate(Vec3::Y * 0.7);
    painter.corner_radii = Vec4::splat(0.3);

    painter.set_color(GREEN * hp + RED * (1. - hp));
    painter.rect(Vec2::new(0.2 + 0.8 * hp, 0.2));

    painter.thickness = 0.02;
    painter.hollow = true;
    painter.color = Color::WHITE;
    painter.rect(Vec2::new(1.06, 0.26));
}

fn draw_spheres(time: Res<Time>, mut painter: ShapePainter) {
    for x in 0..SHAPES_PER_AXIS {
        for y in 0..SHAPES_PER_AXIS {
            let (x, y) = (x as f32, y as f32);
            let offset = time.elapsed_secs() + x + 100. * y;
            let position = Vec3::new(x * 2.0, offset.sin(), y * 2.0);

            painter.hollow = false;
            painter.set_color(GRAY);
            painter.alignment = Alignment::Billboard;
            painter.transform.translation = position;
            painter.corner_radii = Vec4::splat(1.0);
            painter.rect(Vec2::splat(1.0));

            let hp = (offset.sin() + 1.) / 2.0;
            draw_health_bar(&mut painter, hp);
        }
    }
}

examples/canvas_modes.rs (line 49)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(20.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 6.0;
    painter.set_color(CRIMSON);
    painter.translate(Vec3::Y * time.elapsed_secs().sin() * 256.0);
    painter.circle(48.0);

    painter.reset();
}

examples/textured.rs (line 35)

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Single<Entity, With<Canvas>>) {
    painter.rotate_z(time.elapsed_secs().sin());
    painter.set_canvas(*canvas);
    painter.set_color(WHITE * 2.0);
    painter.translate(Vec3::NEG_Y * 12.0 * 16.0);
    painter.thickness = 16.0;

    for _ in 0..12 {
        painter.translate(Vec3::Y * 32.0);
        painter.line(Vec3::NEG_X * 256.0, Vec3::X * 256.0);
    }
    painter.reset();
}

examples/canvas_recursion.rs (line 34)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter, canvas: Single<(Entity, &Canvas)>) {
    let (canvas_e, canvas) = canvas.into_inner();
    painter.image(canvas.image.clone(), Vec2::splat(12.));

    painter.set_canvas(canvas_e);
    painter.hollow = true;
    painter.thickness = 16.0;
    painter.set_color(SEA_GREEN + Srgba::WHITE * 0.25);
    painter.rect(Vec2::splat(1024.0));

    painter.rotate_z(time.elapsed_secs().sin());
    painter.image(canvas.image.clone(), Vec2::splat(980.0));

    painter.reset();
}

examples/parenting_painter.rs (line 69)

fn draw_gallery(
    time: Res<Time>,
    mut painter: ShapePainter,
    mut tree: Single<&mut Transform, With<Tree>>,
) {
    tree.rotation = Quat::from_rotation_z(time.elapsed_secs().sin() / 4.0);

    // Position our painter relative to our tree entity
    painter.transform = **tree;
    painter.set_color(SEA_GREEN + WHITE * 0.25);
    painter
        .line(Vec3::ZERO, Vec3::Y)
        .with_children(|child_painter| {
            child_painter.translate(Vec3::Y);
            draw_tree(time.elapsed_secs(), child_painter, 10);
        });
}

examples/render_layers.rs (line 102)

fn draw_shapes(time: Res<Time>, mut painter: ShapePainter) {
    painter.reset();
    painter.render_layers = Some(RenderLayers::layer(1));
    painter.hollow = true;
    painter.transform.scale = Vec3::ONE * 3.0;

    let meter_fill = (time.elapsed_secs().sin() + 1.0) / 2.0;
    let meter_size = PI * 1.5;

    let start_angle = -meter_size / 2.0;
    let end_angle = -meter_size / 2.0 + meter_fill * meter_size;

    painter.cap = Cap::Round;
    painter.thickness = 0.4;
    painter.set_color(CRIMSON * (1.0 / (0.5 + meter_fill)));
    painter.arc(1.3, start_angle, end_angle);

    painter.cap = Cap::None;
    painter.thickness = 0.2;
    painter.set_color(DARK_GRAY);
    painter.arc(1.6, start_angle, -start_angle);
    painter.arc(0.8, start_angle, -start_angle);

    let offset = Quat::from_rotation_z(start_angle) * Vec3::Y * 1.1;
    painter.translate(offset);
    painter.arc(0.5, start_angle + PI * 1.5, start_angle + 2.5 * PI);
    painter.translate(-offset);

    painter.translate(Quat::from_rotation_z(-start_angle) * Vec3::Y * 1.1);
    painter.arc(0.5, start_angle + PI, start_angle + 2.0 * PI);
}

Additional examples can be found in:

• examples/thickness.rs
• examples/gallery_3d.rs

Trait Implementations

impl<'w, 's> Deref for ShapeCommands<'w, 's>

type Target = ShapeConfig

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'w, 's> DerefMut for ShapeCommands<'w, 's>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'w, 's> ShapeSpawner<'w> for ShapeCommands<'w, 's>

fn spawn_shape(&mut self, bundle: impl Bundle) -> ShapeEntityCommands<'_, '_>

Note: ShapeBundle does not include RenderLayers as there is no support for optional components so instead it is inserted in this function conditionally depending on the ShapeConfig in self Prefer the function for the shape you want over ShapeSpawner::spawn_shape, e.g. commands.rect(...)

fn config(&self) -> &ShapeConfig

fn set_config(&mut self, config: ShapeConfig)

impl SystemParam for ShapeCommands<'_, '_>

type State = FetchState

Used to store data which persists across invocations of a system.

type Item<'w, 's> = ShapeCommands<'w, 's>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

unsafe fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn validate_param<'w, 's>( state: &'s Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's> ReadOnlySystemParam for ShapeCommands<'w, 's>

where &'s mut ShapeConfig: ReadOnlySystemParam, Commands<'w, 's>: ReadOnlySystemParam, Res<'w, BaseShapeConfig>: ReadOnlySystemParam,