Struct bevy_vector_shapes::painter::ShapePainter

source · 
pub struct ShapePainter<'w, 's> { /* private fields */ }
Expand description

A system param that allows ergonomic drawing of immediate mode shapes.

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 are spawned via events which will be extracted for rendering.

Implementations§

source§

impl<'w, 's> ShapePainter<'w, 's>

source

pub fn config(&self) -> &ShapeConfig

source

pub fn set_config(&mut self, config: ShapeConfig)

source

pub fn send<T: ShapeData>(&mut self, data: T) -> &mut Self

source

pub fn send_with_config<T: ShapeData>( &mut self, config: &ShapeConfig, data: T ) -> &mut Self

source

pub fn with_children( &mut self, spawn_children: impl FnOnce(&mut ShapePainter<'_, '_>) ) -> &mut Self

Takes a closure which builds children for this shape.

While event based shapes don’t have the parent child relationship that entities have, this API allows parity between the behaviour of ShapeCommands and ShapePainter

Examples found in repository?
examples/parenting_painter.rs (lines 42-46)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

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: Query<&mut Transform, With<Tree>>,
) {
    let mut tree = tree.single_mut();
    tree.rotation = Quat::from_rotation_z(time.elapsed_seconds().sin() / 4.0);

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

pub fn reset(&mut self)

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

Examples found in repository?
examples/canvas_modes.rs (line 54)
43
44
45
46
47
48
49
50
51
52
53
54
55

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

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

    painter.reset();
}
More examples
Hide additional examples
examples/alpha_mode.rs (line 53)
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

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

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

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

    painter.reset();
    painter.translate(Vec3::X * radius * 4.0);
    painter.alpha_mode = AlphaMode::Blend;
    draw_circles(&mut painter, radius);
}
examples/textured.rs (line 44)
32
33
34
35
36
37
38
39
40
41
42
43
44
45

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Query<(Entity, &Canvas)>) {
    let (canvas, _) = canvas.single();
    painter.rotate_z(time.elapsed_seconds().sin());
    painter.set_canvas(canvas);
    painter.color = 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 39)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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

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

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

    painter.reset();
}
examples/render_layers.rs (line 92)
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

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_seconds().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.color = 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.color = 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);
}
examples/thickness.rs (line 26)
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

fn draw_gallery(
    time: Res<Time>,
    mut painter: ShapePainter,
    mut cameras: Query<&mut Transform, With<Camera3d>>,
) {
    painter.reset();
    cameras.iter_mut().for_each(|mut tf| {
        *tf = Transform::from_xyz(0., 0., 20. + 10.0 * time.elapsed_seconds().sin())
            .looking_at(Vec3::ZERO, Vec3::Y);
    });

    let between_lines = 1.0;
    let between_sets = 3.0;
    let line_vec = Vec3::new(0.4, 2.0, 0.0);

    painter.color = Color::MIDNIGHT_BLUE;
    painter.translate(Vec3::NEG_X * (between_lines * 3.0 + between_sets));
    painter.thickness_type = ThicknessType::Pixels;

    painter.thickness = 1.0;
    painter.line(-line_vec, line_vec);

    painter.thickness = 5.0;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);

    painter.thickness = 10.0;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);

    painter.color = Color::CRIMSON;
    painter.translate(Vec3::X * between_sets);
    painter.thickness_type = ThicknessType::World;

    painter.thickness = 0.1;
    painter.line(-line_vec, line_vec);

    painter.thickness = 0.2;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);

    painter.thickness = 0.5;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);

    painter.color = Color::SEA_GREEN;
    painter.translate(Vec3::X * between_sets);
    painter.thickness_type = ThicknessType::Screen;

    painter.thickness = 1.0;
    painter.line(-line_vec, line_vec);

    painter.thickness = 2.0;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);

    painter.thickness = 5.0;
    painter.translate(Vec3::X * between_lines);
    painter.line(-line_vec, line_vec);
}

Methods from Deref<Target = ShapeConfig>§

source

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 33)
32
33
34
35
36
37
38
39
40
41
42
43

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

    painter.color = Color::GREEN * hp + Color::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));
}
More examples
Hide additional examples
examples/canvas_modes.rs (line 51)
43
44
45
46
47
48
49
50
51
52
53
54
55

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

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

    painter.reset();
}
examples/textured.rs (line 37)
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Query<(Entity, &Canvas)>) {
    let (canvas, _) = canvas.single();
    painter.rotate_z(time.elapsed_seconds().sin());
    painter.set_canvas(canvas);
    painter.color = 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: Query<(Entity, &Canvas)>) {
    let (_, canvas) = canvas.single();
    painter.texture = Some(canvas.image.clone());
    painter.translate(Vec3::NEG_Y * 2.0);

    gallery(painter, time.elapsed_seconds(), 0..10);
}
examples/alpha_mode.rs (line 35)
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

fn draw_circles(painter: &mut ShapePainter, radius: f32) {
    painter.translate(-(Vec3::X + Vec3::NEG_Y) * f32::sqrt(radius) * 0.5);
    painter.color = Color::rgba(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::rgba(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::rgba(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 = AlphaMode::Add;
    draw_circles(&mut painter, radius);

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

    painter.reset();
    painter.translate(Vec3::X * radius * 4.0);
    painter.alpha_mode = AlphaMode::Blend;
    draw_circles(&mut painter, radius);
}
examples/parenting_painter.rs (line 43)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

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: Query<&mut Transform, With<Tree>>,
) {
    let mut tree = tree.single_mut();
    tree.rotation = Quat::from_rotation_z(time.elapsed_seconds().sin() / 4.0);

    // Position our painter relative to our tree entity
    painter.transform = *tree;
    painter.color = Color::SEA_GREEN + Color::WHITE * 0.25;
    painter
        .line(Vec3::ZERO, Vec3::Y)
        .with_children(|child_painter| {
            child_painter.translate(Vec3::Y);
            draw_tree(time.elapsed_seconds(), child_painter, 10);
        });
}
examples/render_layers.rs (line 115)
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

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_seconds().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.color = 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.color = 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:
source

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)
21
22
23
24
25
26

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);
}
source

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

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

source

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

Helper method to set the configs rotation.

source

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

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

source

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

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

source

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 34)
32
33
34
35
36
37
38
39
40
41
42
43
44
45

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Query<(Entity, &Canvas)>) {
    let (canvas, _) = canvas.single();
    painter.rotate_z(time.elapsed_seconds().sin());
    painter.set_canvas(canvas);
    painter.color = 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();
}
More examples
Hide additional examples
examples/retained.rs (line 28)
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

    // The ShapeCommands API is identical to the ShapePainter API so can be used almost interchangably
    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 36)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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

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

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

    painter.reset();
}
examples/alpha_mode.rs (line 39)
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

fn draw_circles(painter: &mut ShapePainter, radius: f32) {
    painter.translate(-(Vec3::X + Vec3::NEG_Y) * f32::sqrt(radius) * 0.5);
    painter.color = Color::rgba(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::rgba(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::rgba(0.0, 0.0, 1.0, 0.5);
    painter.circle(radius);
}
examples/parenting_painter.rs (line 39)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

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 37)
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

    // 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, SpatialBundle::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)
        .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(PbrBundle {
                    mesh: cube_handle.clone(),
                    transform,
                    ..default()
                });
            }
        });
}
Additional examples can be found in:
source

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

Helper method to scale the configs transform.

Examples found in repository?
examples/gallery_2d.rs (line 25)
24
25
26
27

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

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

Helper method to set the configs scale.

Examples found in repository?
examples/canvas_basic.rs (line 34)
29
30
31
32
33
34
35
36
37

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
More examples
Hide additional examples
examples/canvas_bloom.rs (line 49)
44
45
46
47
48
49
50
51
52

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
examples/canvas_low_res.rs (line 39)
34
35
36
37
38
39
40
41
42

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
source

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 33)
29
30
31
32
33
34
35
36
37

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
More examples
Hide additional examples
examples/canvas_bloom.rs (line 48)
44
45
46
47
48
49
50
51
52

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
examples/canvas_low_res.rs (line 38)
34
35
36
37
38
39
40
41
42

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

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

    gallery(painter, time.elapsed_seconds(), 0..15);
}
examples/canvas_modes.rs (line 47)
43
44
45
46
47
48
49
50
51
52
53
54
55

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

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

    painter.reset();
}
examples/textured.rs (line 35)
32
33
34
35
36
37
38
39
40
41
42
43
44
45

fn draw_canvas(time: Res<Time>, mut painter: ShapePainter, canvas: Query<(Entity, &Canvas)>) {
    let (canvas, _) = canvas.single();
    painter.rotate_z(time.elapsed_seconds().sin());
    painter.set_canvas(canvas);
    painter.color = 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 30)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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

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

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

    painter.reset();
}
source

pub fn set_3d(&mut self)

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

source

pub fn set_2d(&mut self)

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

source

pub fn without_transform(&self) -> Self

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

Trait Implementations§

source§

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

§

type Target = ShapeConfig

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

impl<'w, 's> DiscPainter for ShapePainter<'w, 's>

source§

fn circle(&mut self, radius: f32) -> &mut Self

source§

fn arc(&mut self, radius: f32, start_angle: f32, end_angle: f32) -> &mut Self

source§

impl<'w, 's> LinePainter for ShapePainter<'w, 's>

source§

fn line(&mut self, start: Vec3, end: Vec3) -> &mut Self

source§

impl<'w, 's> RectPainter for ShapePainter<'w, 's>

source§

fn rect(&mut self, size: Vec2) -> &mut Self

source§

fn image(&mut self, image: Handle<Image>, size: Vec2) -> &mut Self

source§

impl<'w, 's> RegularPolygonPainter for ShapePainter<'w, 's>

source§

fn ngon(&mut self, sides: f32, radius: f32) -> &mut Self

source§

impl SystemParam for ShapePainter<'_, '_>

§

type State = FetchState

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

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

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

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.
source§

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).
source§

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 apply_deferred.
source§

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. Read more
source§

impl<'w, 's> TrianglePainter for ShapePainter<'w, 's>

source§

fn triangle(&mut self, v_a: Vec2, v_b: Vec2, v_c: Vec2) -> &mut Self

source§

impl<'w, 's> ReadOnlySystemParam for ShapePainter<'w, 's>
where &'s mut ShapeConfig: ReadOnlySystemParam, ResMut<'w, ShapeStorage>: ReadOnlySystemParam, Res<'w, BaseShapeConfig>: ReadOnlySystemParam,

Auto Trait Implementations§

§

impl<'w, 's> !RefUnwindSafe for ShapePainter<'w, 's>

§

impl<'w, 's> Send for ShapePainter<'w, 's>

§

impl<'w, 's> Sync for ShapePainter<'w, 's>

§

impl<'w, 's> Unpin for ShapePainter<'w, 's>

§

impl<'w, 's> !UnwindSafe for ShapePainter<'w, 's>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the T [ShaderType] for self. When used in [AsBindGroup] derives, it is safe to assume that all images in self exist.
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<T> SatisfyTraits<dyn None> for T

source§

impl<T> SatisfyTraits<dyn Send> for T
where T: Send,

source§

impl<T> SatisfyTraits<dyn Sync + Send> for T
where T: Send + Sync,

source§

impl<T> SatisfyTraits<dyn Sync> for T
where T: Sync,

§

impl<T> Settings for T
where T: 'static + Send + Sync,

§

impl<T> WasmNotSend for T
where T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where T: Sync,