Nearly-working impl of EventWriter<T> components

Had to change EventWriter and Reader to take vanilla refs, rather than Res smart pointers to accommodate mixed resource and component usage.

Lifetimes are still sad.

Author: alice-i-cecile

crates/bevy_ecs/src/event.rs

@@ -1,7 +1,6 @@
-use crate as bevy_ecs;
 use crate::{
     component::Component,
-    system::{Local, Query, Res, ResMut, SystemParam},
+    system::{Local, Query, ResMut, ResMutState, ResState, SystemParam},
 };
 use bevy_utils::tracing::trace;
 use std::{
@@ -150,16 +149,22 @@ fn map_instance_event<T>(event_instance: &EventInstance<T>) -> &T {
 }
 
 /// Reads events of type `T` in order and tracks which events have already been read.
-#[derive(SystemParam)]
 pub struct EventReader<'a, T: Component> {
     last_event_count: Local<'a, (usize, PhantomData<T>)>,
-    events: Res<'a, Events<T>>,
+    events: &'a Events<T>,
+}
+
+impl<'a, T: Component> SystemParam for EventReader<'a, T> {
+    type Fetch = ResState<Events<T>>;
 }
 
 /// Sends events of type `T`.
-#[derive(SystemParam)]
 pub struct EventWriter<'a, T: Component> {
-    events: ResMut<'a, Events<T>>,
+    events: &'a mut Events<T>,
+}
+
+impl<'a, T: Component> SystemParam for EventWriter<'a, T> {
+    type Fetch = ResMutState<Events<T>>;
 }
 
 impl<'a, T: Component> EventWriter<'a, T> {

crates/bevy_ecs/src/query/event.rs

@@ -1,71 +1,140 @@
 use super::{
-    super::event::{EventReader, EventWriter, Events, ManualEventReader},
-    Access, Fetch, FetchState, FilteredAccess, WorldQuery,
+    super::event::{EventWriter, Events},
+    Access, Fetch, FetchState, FilteredAccess, WorldQuery, WriteFetch, WriteState,
 };
 use crate::{
     archetype::{Archetype, ArchetypeComponentId},
-    component::{Component, ComponentId},
+    component::{Component, ComponentId, StorageType},
     prelude::World,
     storage::{Table, Tables},
 };
-use std::marker::PhantomData;
+use std::any::TypeId;
 
 impl<'a, T: Component> WorldQuery for EventWriter<'a, T> {
-    type Fetch = EventWriterFetch<T>;
+    type Fetch = EventWriterFetch<'a, T>;
     type State = EventWriterState<T>;
 }
 
-struct EventWriterFetch<T> {
-    marker: PhantomData<T>,
+struct EventWriterFetch<'s, T> {
+    /// EventWriter query parameters require write access to &mut Events<T>
+    write_fetch: WriteFetch<Events<T>>,
+    state: &'s EventWriterState<T>,
 }
 
-impl<'a, T: Component> Fetch<'a> for EventWriterFetch<T> {
-    // EventWriter queries return an EventWriter<T> in each item
+impl<'a, T: Component> Fetch<'a> for EventWriterFetch<'a, T> {
+    /// EventWriter queries return an EventWriter<T> in each item
     type Item = EventWriter<'a, T>;
-    // This is the corresponding S: FetchState type
+    /// This is the corresponding S: FetchState type
     type State = EventWriterState<T>;
 
+    /// Checks the storage type of the corresponding Events<T> component
+    fn is_dense(&self) -> bool {
+        match self.state.event_storage_type {
+            StorageType::SparseSet => false,
+            StorageType::Table => true,
+        }
+    }
+
     unsafe fn init(
         world: &World,
         state: &Self::State,
         last_change_tick: u32,
         change_tick: u32,
     ) -> Self {
+        EventWriterFetch {
+            write_fetch: WriteFetch::<Events<T>>::init(
+                world,
+                &state.write_state,
+                last_change_tick,
+                change_tick,
+            ),
+            state,
+        }
     }
 
-    fn is_dense(&self) -> bool {}
-
     unsafe fn set_archetype(
         &mut self,
         state: &Self::State,
         archetype: &Archetype,
         tables: &Tables,
     ) {
+        self.write_fetch
+            .set_archetype(&state.write_state, archetype, tables);
     }
 
-    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {}
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+        self.write_fetch.set_table(&state.write_state, table);
+    }
 
-    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {}
+    /// Returns the EventWriter<T> of the next entity when the storage type of the query is sparse
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        let events = *self.write_fetch.archetype_fetch(archetype_index);
+        EventWriter {
+            events: &mut events,
+        }
+    }
 
-    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {}
+    /// Returns the EventWriter<T> of the next entity when the storage type of the query is dense
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        let events = *self.write_fetch.archetype_fetch(table_row);
+        EventWriter {
+            events: &mut events,
+        }
+    }
 }
 struct EventWriterState<T> {
-    marker: PhantomData<T>,
+    event_component_id: ComponentId,
+    event_storage_type: StorageType,
+    /// EventWriter query parameters require write access to &mut Events<T>
+    write_state: WriteState<Events<T>>,
 }
 
 unsafe impl<T: Component> FetchState for EventWriterState<T> {
-    fn init(world: &mut World) -> Self {}
+    fn init(world: &mut World) -> Self {
+        let event_component_id = world.components.get_id(TypeId::of::<Events<T>>()).unwrap();
+        EventWriterState {
+            event_component_id,
+            event_storage_type: world
+                .components
+                .get_info(event_component_id)
+                .unwrap()
+                .storage_type(),
+            write_state: WriteState::<Events<T>>::init(world),
+        }
+    }
 
-    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {}
+    /// Access is based on &Events<T>
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        if access.access().has_write(self.event_component_id) {
+            panic!("&{} conflicts with a previous access in this query. Shared access cannot coincide with exclusive access.",
+                std::any::type_name::<Events<T>>());
+        }
+        access.add_read(self.event_component_id)
+    }
 
+    /// Access is based on &Events<T>
     fn update_archetype_component_access(
         &self,
         archetype: &Archetype,
         access: &mut Access<ArchetypeComponentId>,
     ) {
+        if let Some(archetype_component_id) =
+            archetype.get_archetype_component_id(self.event_component_id)
+        {
+            access.add_read(archetype_component_id);
+        }
     }
 
-    fn matches_archetype(&self, archetype: &Archetype) -> bool {}
+    /// Matches based on &Events<T>
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        archetype.contains(self.event_component_id)
+    }
 
-    fn matches_table(&self, table: &Table) -> bool {}
+    /// Matches based on &Events<T>
+    fn matches_table(&self, table: &Table) -> bool {
+        table.has_column(self.event_component_id)
+    }
 }
+
+// TODO: add tests
+mod tests {}