MaterialMesh2dBundle - Update polygon sides from RegularPolygon

[rmoraes92]

Hi,

So I borrowed the "spawn" logic from the breakout example and created the following function:

pub fn spawn_ball(
    commands: &mut Commands,
    meshes: &mut ResMut<Assets<Mesh>>,
    materials: &mut ResMut<Assets<ColorMaterial>>,
    asset_server: &Res<AssetServer>,
) {
    let mesh_2d_handle: Handle<Mesh> = meshes.add(RegularPolygon::new(BALL_DIAMETER, 6));
    // let ball_handle: Handle<Mesh> = meshes.add(Circle::default());
    commands.spawn((
        MaterialMesh2dBundle {
            mesh: mesh_2d_handle.into(),
            material: materials.add(BALL_COLOR),
            transform: Transform::from_translation(BALL_STARTING_POSITION)
                .with_scale(Vec2::splat(BALL_DIAMETER).extend(1.)),
            ..default()
        },
        Ball,
        Velocity(INITIAL_BALL_DIRECTION.normalize() * BALL_SPEED),
    ));
}

Now I'm trying to create a "system" function that will increase or decrease the amount of side of the polygon:

pub fn update_ball_shape(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut query: Query<&mut Mesh2dHandle, With<Ball>>,
    time: Res<Time>,
) {
    let mut ball_mesh_handle = query.single_mut();
    let mut new_sides: u32 = ball_mesh_handle.0.(Some Magic Step).sides;

    if keyboard_input.pressed(KeyCode::Digit1) {
        new_sides -= 1;
    }

    if keyboard_input.pressed(KeyCode::Digit2) {
        new_sides += 1;
    }
    let mesh_2d_handle: Handle<Mesh> = meshes.add(RegularPolygon::new(BALL_DIAMETER, new_sides));
    ball_mesh_handle = mesh_2d_handle.into();
}

But I'm having a hard time wrapping my head around on How should I query for the Ball.

I know that on the example above the ball_mesh_handle.0 will return a Handle<Mesh> struct but I got no clue how to recover the original RegularPolygon struct from it.

Any tips?

[rparrett]

After the mesh is created, the original RegularPolygon is discarded. If you want to keep it around to access it later, a handy place to store it would be an additional component to your Ball entity.

// `RegularPolygon` doesn't impl `Component`, so we need to wrap it in our own type.
#[derive(Component)]
struct BallShape(RegularPolygon);

// Create a regular polygon with a circumcircle radius of 0.5, or diameter of 1.0.
// This will be scaled by `BALL_DIAMETER` later.
let shape = RegularPolygon::new(0.5, 6);
let mesh_2d_handle = meshes.add(Mesh::from(shape));

commands.spawn((
    /* snipped for brevity */
    Ball,
    BallShape(shape)
));

You could then add it to the query in your update_ball_shape:

fn update_ball_shape(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut query: Query<(&mut Mesh2dHandle, &mut BallShape), With<Ball>>,
    mut meshes: ResMut<Assets<Mesh>>,
) {
    let (mut ball_mesh_handle, mut ball_shape) = query.single_mut();

    // Watch out, this will crash if `sides` is < 3. You will want to clamp this value.
    if keyboard_input.just_pressed(KeyCode::Digit1) {
        ball_shape.0.sides -= 1;
    }

    // Also note: `just_pressed` is used here instead of `pressed`` so that sides isn't
    // incremented every frame while the button is held.
    if keyboard_input.just_pressed(KeyCode::Digit2) {
        ball_shape.0.sides += 1;
    }

    *ball_mesh_handle = meshes
        .add(RegularPolygon::new(BALL_DIAMETER, ball_shape.0.sides))
        .into();
}

[rmoraes92]

@rparrett Thank you for the answer. I managed to make it work without the extra component.

#[derive(Resource)]
pub struct BallPolygon {
    pub sides: usize,
}

pub fn update_ball_shape(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut ball_poly: ResMut<BallPolygon>,
    // mut query: Query<&mut Mesh2dHandle, With<Ball>>,
    mut query: Query<&mut Mesh2dHandle, With<Ball>>,
    mut meshes: ResMut<Assets<Mesh>>,
    time: Res<Time>,
) {

    if keyboard_input.pressed(KeyCode::Digit1) {
        if ball_poly.sides > 3 {
            ball_poly.sides -= 1;
        }
    }

    if keyboard_input.pressed(KeyCode::Digit2) {
        ball_poly.sides += 1;
    }

    println!("ball sides {}", ball_poly.sides);

    let mut ball_mesh_handle: Mut<Mesh2dHandle> = query.single_mut();

    *ball_mesh_handle = meshes.add(
        RegularPolygon::new(
            BALL_DIAMETER, ball_poly.sides
        )
    ).into(); 

but I got some extra questions:

• Does the call to meshes.add appends a new meshes (?) to the list of existing meshes? Asking this because I had the impression that calling it with a new RegularPolygon would NOT replace the old one and instead just push another mesh instance to the "global" list.
• The breakout example is passing this time: Res<Time> argument. Any tips on how to use it to avoid letting the function adding too many sides at once?

[rparrett]

Cool, a Resource certainly works just fine. To answer your other questions:

1. Right.

   Assets<Mesh>> is the asset storage for meshes. meshes.add just adds another mesh to it, and returns a handle to that mesh. The *ball_mesh_handle = part replaces the old handle with the new one. Because no handles will exist that reference the old mesh, it will get cleaned up from the storage.

2. Your code is currently changing the number of sides on every frame that the button is in the down position. You can change this behavior so that it only happens the first time the button transitions from up to down by using just_pressed instead of pressed.

   If you want to create something like a cooldown timer, check out the timers example which demonstrates how to tick a timer and check if it is finished.