[Merged by Bors] - Simplify trait hierarchy for `SystemParam` by joseph-gio · Pull Request #6865 · bevyengine/bevy

joseph-gio · 2022-12-05T22:46:02Z

Objective

Implementing a custom SystemParam by hand requires implementing three traits -- four if it is read-only.
The trait SystemParamFetch<'w, 's> is a workaround from before we had generic associated types, and is no longer necessary.

Solution

Combine the trait SystemParamFetch with SystemParamState.
- I decided to remove the Fetch name and keep the State name, since the former was consistently conflated with the latter.
Replace the trait ReadOnlySystemParamFetch with ReadOnlySystemParam, which simplifies trait bounds in generic code.

Changelog

Removed the trait SystemParamFetch, moving its functionality to SystemParamState.
Replaced the trait ReadOnlySystemParamFetch with ReadOnlySystemParam.

Migration Guide

Merged with the guide for #6919.

james7132 · 2022-12-05T22:48:32Z

Could we go one step further, as we have with WorldQuery and further combine SystemParamState with SystemParam? What used to be FetchState is now just a type State: Send + Sync + 'static on WorldQuery.

joseph-gio · 2022-12-05T22:51:52Z

Unfortunately that is not possible due to how GATs work for now. You are forced to add the where Self: 'a bound on every lifetime GAT, which messes up any SystemParam with lifetimes.

james7132

LGTM. Just one style nit.

crates/bevy_ecs/src/system/system_param.rs

joseph-gio · 2022-12-06T13:07:49Z

You are forced to add the where Self: 'a bound on every lifetime GAT

Nevermind, I misunderstood how required bounds work the first time I tried this. Working on some more improvements.

alice-i-cecile

This change results in a serious simplification, and appears to be correctly done. @BoxyUwU can you double check this?

joseph-gio · 2022-12-07T02:31:27Z

My ultimate goal is to merge SystemParamState with SystemParam, which would flatten the hierarchy akin to WorldQuery (like James' suggestion above). It would also allow removing types like ResState, which will be amazing.

It seems doable, but unfortunately there is a nightmare of trait bounds that may take a while to untangle. It will also have hundreds of additional lines of churn, so I think I will split it off into a future PR.

joseph-gio · 2022-12-07T03:55:30Z

One last change: I replaced ReadOnlySystemParamState with ReadOnlySystemParam, which feels like a better API to present. It will also reduce churn later.

JonahPlusPlus · 2022-12-07T04:44:50Z

@JoJoJet If you are planning to merge SystemParam and SystemParamState, should I wait till after? It won't take me long to implement my changes (hopefully, I've got everything planned out exactly except Resultful (I think I've settled on that as a name, since it's an actual word, unlike Resultable)).

Basically, I want to make both generic for T: Fallibility, where Fallibility is a sealed trait implemented for markers Infallible, Optional and Resultful.

I don't think this would have any significant effect on your implementation. I'm guessing you just want to make it so SystemParam has an associated type that it uses for the SystemParamState functions and you would still have a state struct?

crates/bevy_ecs/src/system/system_param.rs

joseph-gio · 2022-12-07T13:01:53Z

If you are planning to merge SystemParam and SystemParamState, should I wait till after?

@JonahPlusPlus There's still a few things left to figure out for that PR, so it's not a sure thing for it to get merged. I wouldn't wait, so long as you're okay with a little rebasing if needed.

james7132 · 2022-12-07T18:43:12Z

crates/bevy_ecs/src/system/system_param.rs

 // SAFETY: QueryState is constrained to read-only fetches, so it only reads World.
-unsafe impl<'w, 's, Q: ReadOnlyWorldQuery, F: ReadOnlyWorldQuery> ReadOnlySystemParam
-    for Query<'w, 's, Q, F>
+unsafe impl<'w, 's, Q: ReadOnlyWorldQuery + 'static, F: ReadOnlyWorldQuery + 'static>


Was this required by the compiler? This seems incorrect to me.

These bounds are required because ReadOnlySystemParam: SystemParam -- same reason I had to add them to StaticSystemParam before. The bounds already exist on impl SystemParam for Query<>, so nothing is lost here.

oh awesome I didn't realise we were already requiring Q: 'static and F: 'static on the SystemParam impl. We should just require trait WorldQuery: 'static then

Oh man that's nutty. Seems counterintuitive in this case, though probably for the best. LGTM then, we can address the WorldQuery: 'static thing in another PR.

We should just require trait WorldQuery: 'static then

I agree -- I just tried this though and it seems like it'll add a bunch of churn, so I'll leave it for another PR.

JonahPlusPlus · 2022-12-08T20:50:07Z

crates/bevy_ecs/src/system/system_param.rs

+/// [`World`] access used by the [`SystemParamState`].
 /// Additionally, it is the implementor's responsibility to ensure there is no
 /// conflicting access across all [`SystemParam`]'s.
 pub unsafe trait SystemParamState: Send + Sync + 'static {


Does this and the function get_param have to both be marked unsafe?

Yes. unsafe has different implications for fns and traits: unsafe fn requires the caller of the fn to uphold safety invariants, whereas unsafe trait requires the implementer of the trait to uphold safety invariants. In this case, we want it to be both unsafe to implement and to call, so we mark both as unsafe.

Ah, so the other methods are unsafe to implement, but get_param is unsafe to call. Thanks for the clarification, I couldn't find anything online explaining why you would prefer one over the other.

alice-i-cecile · 2022-12-11T18:26:29Z

bors r+

# Objective * Implementing a custom `SystemParam` by hand requires implementing three traits -- four if it is read-only. * The trait `SystemParamFetch<'w, 's>` is a workaround from before we had generic associated types, and is no longer necessary. ## Solution * Combine the trait `SystemParamFetch` with `SystemParamState`. * I decided to remove the `Fetch` name and keep the `State` name, since the former was consistently conflated with the latter. * Replace the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`, which simplifies trait bounds in generic code. --- ## Changelog - Removed the trait `SystemParamFetch`, moving its functionality to `SystemParamState`. - Replaced the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`. ## Migration Guide The trait `SystemParamFetch` has been removed, and its functionality has been transferred to `SystemParamState`. ```rust // Before impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(...) -> Self::Item; } // After impl SystemParamState for MyParamState { type Item<'w, 's> = MyParam<'w, 's>; // Generic associated types! fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } fn get_param<'w, 's>(...) -> Self::Item<'w, 's>; } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl<'w, 's> ReadOnlySystemParam for MyParam<'w, 's> {} ```

bors · 2022-12-11T18:45:53Z

Pull request successfully merged into main.

Build succeeded:

…6919) Spiritual successor to #5205. Actual successor to #6865. # Objective Currently, system params are defined using three traits: `SystemParam`, `ReadOnlySystemParam`, `SystemParamState`. The behavior for each param is specified by the `SystemParamState` trait, while `SystemParam` simply defers to the state. Splitting the traits in this way makes it easier to implement within macros, but it increases the cognitive load. Worst of all, this approach requires each `MySystemParam` to have a public `MySystemParamState` type associated with it. ## Solution * Merge the trait `SystemParamState` into `SystemParam`. * Remove all trivial `SystemParam` state types. * `OptionNonSendMutState<T>`: you will not be missed. --- - [x] Fix/resolve the remaining test failure. ## Changelog * Removed the trait `SystemParamState`, merging its functionality into `SystemParam`. ## Migration Guide **Note**: this should replace the migration guide for #6865. This is relative to Bevy 0.9, not main. The traits `SystemParamState` and `SystemParamFetch` have been removed, and their functionality has been transferred to `SystemParam`. ```rust // Before (0.9) impl SystemParam for MyParam<'_, '_> { type State = MyParamState; } unsafe impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } unsafe impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(&mut self, ...) -> Self::Item; } unsafe impl ReadOnlySystemParamFetch for MyParamState { } // After (0.10) unsafe impl SystemParam for MyParam<'_, '_> { type State = MyParamState; type Item<'w, 's> = MyParam<'w, 's>; fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { ... } fn get_param<'w, 's>(state: &mut Self::State, ...) -> Self::Item<'w, 's>; } unsafe impl ReadOnlySystemParam for MyParam<'_, '_> { } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl ReadOnlySystemParam for MyParam<'_, '_> {} ```

…evyengine#6919) Spiritual successor to bevyengine#5205. Actual successor to bevyengine#6865. # Objective Currently, system params are defined using three traits: `SystemParam`, `ReadOnlySystemParam`, `SystemParamState`. The behavior for each param is specified by the `SystemParamState` trait, while `SystemParam` simply defers to the state. Splitting the traits in this way makes it easier to implement within macros, but it increases the cognitive load. Worst of all, this approach requires each `MySystemParam` to have a public `MySystemParamState` type associated with it. ## Solution * Merge the trait `SystemParamState` into `SystemParam`. * Remove all trivial `SystemParam` state types. * `OptionNonSendMutState<T>`: you will not be missed. --- - [x] Fix/resolve the remaining test failure. ## Changelog * Removed the trait `SystemParamState`, merging its functionality into `SystemParam`. ## Migration Guide **Note**: this should replace the migration guide for bevyengine#6865. This is relative to Bevy 0.9, not main. The traits `SystemParamState` and `SystemParamFetch` have been removed, and their functionality has been transferred to `SystemParam`. ```rust // Before (0.9) impl SystemParam for MyParam<'_, '_> { type State = MyParamState; } unsafe impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } unsafe impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(&mut self, ...) -> Self::Item; } unsafe impl ReadOnlySystemParamFetch for MyParamState { } // After (0.10) unsafe impl SystemParam for MyParam<'_, '_> { type State = MyParamState; type Item<'w, 's> = MyParam<'w, 's>; fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { ... } fn get_param<'w, 's>(state: &mut Self::State, ...) -> Self::Item<'w, 's>; } unsafe impl ReadOnlySystemParam for MyParam<'_, '_> { } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl ReadOnlySystemParam for MyParam<'_, '_> {} ```

# Objective * Implementing a custom `SystemParam` by hand requires implementing three traits -- four if it is read-only. * The trait `SystemParamFetch<'w, 's>` is a workaround from before we had generic associated types, and is no longer necessary. ## Solution * Combine the trait `SystemParamFetch` with `SystemParamState`. * I decided to remove the `Fetch` name and keep the `State` name, since the former was consistently conflated with the latter. * Replace the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`, which simplifies trait bounds in generic code. --- ## Changelog - Removed the trait `SystemParamFetch`, moving its functionality to `SystemParamState`. - Replaced the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`. ## Migration Guide The trait `SystemParamFetch` has been removed, and its functionality has been transferred to `SystemParamState`. ```rust // Before impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(...) -> Self::Item; } // After impl SystemParamState for MyParamState { type Item<'w, 's> = MyParam<'w, 's>; // Generic associated types! fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } fn get_param<'w, 's>(...) -> Self::Item<'w, 's>; } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl<'w, 's> ReadOnlySystemParam for MyParam<'w, 's> {} ```

…evyengine#6919) Spiritual successor to bevyengine#5205. Actual successor to bevyengine#6865. # Objective Currently, system params are defined using three traits: `SystemParam`, `ReadOnlySystemParam`, `SystemParamState`. The behavior for each param is specified by the `SystemParamState` trait, while `SystemParam` simply defers to the state. Splitting the traits in this way makes it easier to implement within macros, but it increases the cognitive load. Worst of all, this approach requires each `MySystemParam` to have a public `MySystemParamState` type associated with it. ## Solution * Merge the trait `SystemParamState` into `SystemParam`. * Remove all trivial `SystemParam` state types. * `OptionNonSendMutState<T>`: you will not be missed. --- - [x] Fix/resolve the remaining test failure. ## Changelog * Removed the trait `SystemParamState`, merging its functionality into `SystemParam`. ## Migration Guide **Note**: this should replace the migration guide for bevyengine#6865. This is relative to Bevy 0.9, not main. The traits `SystemParamState` and `SystemParamFetch` have been removed, and their functionality has been transferred to `SystemParam`. ```rust // Before (0.9) impl SystemParam for MyParam<'_, '_> { type State = MyParamState; } unsafe impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } unsafe impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(&mut self, ...) -> Self::Item; } unsafe impl ReadOnlySystemParamFetch for MyParamState { } // After (0.10) unsafe impl SystemParam for MyParam<'_, '_> { type State = MyParamState; type Item<'w, 's> = MyParam<'w, 's>; fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { ... } fn get_param<'w, 's>(state: &mut Self::State, ...) -> Self::Item<'w, 's>; } unsafe impl ReadOnlySystemParam for MyParam<'_, '_> { } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl ReadOnlySystemParam for MyParam<'_, '_> {} ```

# Objective * Implementing a custom `SystemParam` by hand requires implementing three traits -- four if it is read-only. * The trait `SystemParamFetch<'w, 's>` is a workaround from before we had generic associated types, and is no longer necessary. ## Solution * Combine the trait `SystemParamFetch` with `SystemParamState`. * I decided to remove the `Fetch` name and keep the `State` name, since the former was consistently conflated with the latter. * Replace the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`, which simplifies trait bounds in generic code. --- ## Changelog - Removed the trait `SystemParamFetch`, moving its functionality to `SystemParamState`. - Replaced the trait `ReadOnlySystemParamFetch` with `ReadOnlySystemParam`. ## Migration Guide The trait `SystemParamFetch` has been removed, and its functionality has been transferred to `SystemParamState`. ```rust // Before impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(...) -> Self::Item; } // After impl SystemParamState for MyParamState { type Item<'w, 's> = MyParam<'w, 's>; // Generic associated types! fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } fn get_param<'w, 's>(...) -> Self::Item<'w, 's>; } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl<'w, 's> ReadOnlySystemParam for MyParam<'w, 's> {} ```

…evyengine#6919) Spiritual successor to bevyengine#5205. Actual successor to bevyengine#6865. # Objective Currently, system params are defined using three traits: `SystemParam`, `ReadOnlySystemParam`, `SystemParamState`. The behavior for each param is specified by the `SystemParamState` trait, while `SystemParam` simply defers to the state. Splitting the traits in this way makes it easier to implement within macros, but it increases the cognitive load. Worst of all, this approach requires each `MySystemParam` to have a public `MySystemParamState` type associated with it. ## Solution * Merge the trait `SystemParamState` into `SystemParam`. * Remove all trivial `SystemParam` state types. * `OptionNonSendMutState<T>`: you will not be missed. --- - [x] Fix/resolve the remaining test failure. ## Changelog * Removed the trait `SystemParamState`, merging its functionality into `SystemParam`. ## Migration Guide **Note**: this should replace the migration guide for bevyengine#6865. This is relative to Bevy 0.9, not main. The traits `SystemParamState` and `SystemParamFetch` have been removed, and their functionality has been transferred to `SystemParam`. ```rust // Before (0.9) impl SystemParam for MyParam<'_, '_> { type State = MyParamState; } unsafe impl SystemParamState for MyParamState { fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self { ... } } unsafe impl<'w, 's> SystemParamFetch<'w, 's> for MyParamState { type Item = MyParam<'w, 's>; fn get_param(&mut self, ...) -> Self::Item; } unsafe impl ReadOnlySystemParamFetch for MyParamState { } // After (0.10) unsafe impl SystemParam for MyParam<'_, '_> { type State = MyParamState; type Item<'w, 's> = MyParam<'w, 's>; fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { ... } fn get_param<'w, 's>(state: &mut Self::State, ...) -> Self::Item<'w, 's>; } unsafe impl ReadOnlySystemParam for MyParam<'_, '_> { } ``` The trait `ReadOnlySystemParamFetch` has been replaced with `ReadOnlySystemParam`. ```rust // Before unsafe impl ReadOnlySystemParamFetch for MyParamState {} // After unsafe impl ReadOnlySystemParam for MyParam<'_, '_> {} ```

joseph-gio added 11 commits December 5, 2022 16:17

simplify SystemParam traits

248327e

update ParamSet

55e1d3b

update derive macro

fefccaa

update bevy_ecs

0f07356

rename ReadOnlySystemParamFetch -> ReadOnlySystemParamState

f7c3c88

update bevy_render

90e5475

simplify exclusive system params

33b5cbe

use SystemParamItem type alias

bc8175c

update some doc comments

1371d69

add ExclusiveSystemParamState: 'static bound

a7c812c

update a UI test

56b853c

james7132 added A-ECS Entities, components, systems, and events C-Code-Quality A section of code that is hard to understand or change M-Migration-Guide A breaking change to Bevy's public API that needs to be noted in a migration guide labels Dec 5, 2022

Update system_param_derive_readonly.stderr

caa0d93

james7132 approved these changes Dec 6, 2022

View reviewed changes

crates/bevy_ecs/src/system/system_param.rs Outdated Show resolved Hide resolved

move associated types

d5d4d17

JonahPlusPlus mentioned this pull request Dec 6, 2022

Add OptionalSystemParam and OptionalSystemParamFetch trait #6854

Closed

alice-i-cecile self-requested a review December 6, 2022 18:05

alice-i-cecile approved these changes Dec 6, 2022

View reviewed changes

alice-i-cecile requested a review from BoxyUwU December 6, 2022 18:09

alice-i-cecile added the S-Ready-For-Final-Review This PR has been approved by the community. It's ready for a maintainer to consider merging it label Dec 7, 2022

ReadOnlySystemParamState -> ReadOnlySystemParam

e7ccaaa

joseph-gio added 2 commits December 6, 2022 23:01

fix a UI test

c9fb9e6

actually fix the UI test

7791772

ok for real this time sorry for notifications

6aa02e4

james7132 requested changes Dec 7, 2022

View reviewed changes

crates/bevy_ecs/src/system/system_param.rs Outdated Show resolved Hide resolved

james7132 removed the S-Ready-For-Final-Review This PR has been approved by the community. It's ready for a maintainer to consider merging it label Dec 7, 2022

joseph-gio added 2 commits December 7, 2022 00:24

fix a StaticSystemParam impl

31dde29

make ReadOnlySystemParam: SystemParam

4da9218

this ui test is my nemesis

a369a2b

joseph-gio requested review from james7132 and removed request for BoxyUwU December 7, 2022 13:16

james7132 requested changes Dec 7, 2022

View reviewed changes

james7132 approved these changes Dec 7, 2022

View reviewed changes

james7132 added the S-Ready-For-Final-Review This PR has been approved by the community. It's ready for a maintainer to consider merging it label Dec 7, 2022

james7132 added this to the 0.10 milestone Dec 7, 2022

JonahPlusPlus reviewed Dec 8, 2022

View reviewed changes

bors bot changed the title ~~Simplify trait hierarchy for SystemParam~~ [Merged by Bors] - Simplify trait hierarchy for SystemParam Dec 11, 2022

bors bot closed this Dec 11, 2022

joseph-gio mentioned this pull request Dec 11, 2022

[Merged by Bors] - Remove the SystemParamState trait and remove types like ResState #6919

Closed

1 task

joseph-gio deleted the system-param-gats branch December 12, 2022 17:15

Uh oh!

Conversation

joseph-gio commented Dec 5, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Objective

Solution

Changelog

Migration Guide

Uh oh!

james7132 commented Dec 5, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

joseph-gio commented Dec 5, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

james7132 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

joseph-gio commented Dec 6, 2022

Uh oh!

alice-i-cecile left a comment

Choose a reason for hiding this comment

Uh oh!

joseph-gio commented Dec 7, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

joseph-gio commented Dec 7, 2022

Uh oh!

JonahPlusPlus commented Dec 7, 2022

Uh oh!

Uh oh!

joseph-gio commented Dec 7, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

james7132 Dec 7, 2022

Choose a reason for hiding this comment

Uh oh!

joseph-gio Dec 7, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

BoxyUwU Dec 7, 2022

Choose a reason for hiding this comment

Uh oh!

james7132 Dec 7, 2022

Choose a reason for hiding this comment

Uh oh!

joseph-gio Dec 7, 2022

Choose a reason for hiding this comment

Uh oh!

JonahPlusPlus Dec 8, 2022

Choose a reason for hiding this comment

Uh oh!

joseph-gio Dec 8, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JonahPlusPlus Dec 8, 2022

Choose a reason for hiding this comment

Uh oh!

alice-i-cecile commented Dec 11, 2022

Uh oh!

bors bot commented Dec 11, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

joseph-gio commented Dec 5, 2022 •

edited

Loading

james7132 commented Dec 5, 2022 •

edited

Loading

joseph-gio commented Dec 5, 2022 •

edited

Loading

joseph-gio commented Dec 7, 2022 •

edited

Loading

joseph-gio commented Dec 7, 2022 •

edited

Loading

joseph-gio Dec 7, 2022 •

edited

Loading

joseph-gio Dec 8, 2022 •

edited

Loading