Noob: Need to access argument of enum

[mwolfeu]

Working with bevy_mod_picking crate.

In the callback event when you pick a mesh the example code has:

  pub fn print_events(mut events: EventReader<PickingEvent>) {
  for event in events.iter() {
      match event {
          PickingEvent::Selection(e) => info!("selection  {:?}", e),
          PickingEvent::Hover(e) => info!("hover event {:?}", e),
          PickingEvent::Clicked(e) => info!("click {:?}", e),
        }
    }
  }

I need to access the Entity in all cases.
Clicked(e) is already an entity so I can modify it to use an Entity method:

PickingEvent::Clicked(e) => {
  info!("click {}", e.id());
},

The others are of type:

pub enum SelectionEvent {
    JustSelected(Entity),
    JustDeselected(Entity),
}

and

pub enum HoverEvent {
    JustEntered(Entity),
    JustLeft(Entity),
}

My question is two fold:

1. When I run the program and select a mesh "selection JustSelected(1v0)" is printed.
   1 in this case is the Entity id but I don't understand the construction 1v0. What is v in this case? Is this some sort way of printing a tuple?

2. Most importantly how do I modify the event handler to use the e argument of Selection(e)? As with Clicked(e) I would like to print the Entity id number of the selected mesh. Eg:

`PickingEvent::Selection(e) => info!("selection {}", e/magic grammar here/.id()),

Thanks
`

[LegNeato]

You should be able to use something like:

      match event {
          PickingEvent::Selection(SelectionEvent::JustSelected(e)) |  PickingEvent::Selection(SelectionEvent::JustDeselected(e)) => info!("selection  {:?}", e),
          PickingEvent::Hover(e) => info!("hover event {:?}", e),
          PickingEvent::Clicked(e) => info!("click {:?}", e),
        }

Or you can do a nested match:

      match event {
          PickingEvent::Selection(s) => match s {
                  SelectionEvent::JustSelected(e) =>  info!("selection  {:?}", e),
                  SelectionEvent::JustDeselected(e) =>  info!("deselection  {:?}", e),
            },
          PickingEvent::Hover(e) => info!("hover event {:?}", e),
          PickingEvent::Clicked(e) => info!("click {:?}", e),
        }

And I think on recent Rusts you can do:

     match event {
         PickingEvent::Selection(SelectionEvent::JustSelected(e) | SelectionEvent::JustDeselected(e)) => info!("selection  {:?}", e),
         PickingEvent::Hover(e) => info!("hover event {:?}", e),
         PickingEvent::Clicked(e) => info!("click {:?}", e),
       }

For the printing, you are using {:?}, which calls the Debug implementation ({} would call Display). You can check out the Entity Debug impl for Entity here:

bevy/crates/bevy_ecs/src/entity/mod.rs

Lines 150 to 154 in dbd856d

	impl fmt::Debug for Entity {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	write!(f, "{}v{}", self.id, self.generation)
	}
	}

Looks like it includes the generation so if you just want the id you should use {} and e.id() (that is, the Display impl of the id) rather than {:?} and e (that is, the Debug impl of the Entity)

[aevyrie]

To add to this - entities are uniquely identified with an id and generation. When an entity is despawned, its id becomes available for the next entity that is spawned, and the generation number is incremented. Ids get reused to save memory - the alternative is an ever-growing list of entities with unused slots where entities were despawned. In short: you cannot identify an entity by its id alone.

Here are the docs for string formatting: https://doc.rust-lang.org/std/fmt/. As @LegNeato mentioned, {:?} just means "use fmt::Debug to display this variable", which has been explicitly defined for Entity to be "{}v{}", self.id, self.generation - "1v0" in your example.