Merge pull request #821 from AmbientRun/cleanup-hooks-2

Make all hooks free functions
AmbientRun · Sep 8, 2023 · 5d2b20c · 5d2b20c
2 parents 0e0f33c + b5e1f1d
commit 5d2b20c
Show file tree

Hide file tree

Showing 72 changed files with 1,224 additions and 1,109 deletions.
diff --git a/app/src/client/mod.rs b/app/src/client/mod.rs
@@ -9,7 +9,10 @@ use ambient_core::{
     window::{window_ctl, ExitStatus, WindowCtl},
 };
 use ambient_ecs::{Entity, SystemGroup};
-use ambient_element::{element_component, Element, ElementComponentExt, Hooks};
+use ambient_element::{
+    consume_context, element_component, use_effect, use_ref_with, use_spawn, use_state,
+    use_state_with, Element, ElementComponentExt, Hooks,
+};
 use ambient_native_std::{asset_cache::AssetCache, cb, friendly_id};
 use ambient_network::{
     client::{client_network_stats, GameClientRenderTarget},
@@ -124,7 +127,7 @@ fn MainApp(
     cert: Option<Vec<u8>>,
     mixer: Option<AudioMixer>,
 ) -> Element {
-    let (loaded, set_loaded) = hooks.use_state(false);
+    let (loaded, set_loaded) = use_state(hooks, false);
 
     FocusRoot::el([
         UICamera.el(),
@@ -192,13 +195,13 @@ fn GoldenImageTest(
     golden_image_output_dir: Option<PathBuf>,
     golden_image_cmd: GoldenImageCommand,
 ) -> Element {
-    let (render_target, _) = hooks.consume_context::<GameClientRenderTarget>().unwrap();
-    let render_target_ref = hooks.use_ref_with(|_| render_target.clone());
+    let (render_target, _) = consume_context::<GameClientRenderTarget>(hooks).unwrap();
+    let render_target_ref = use_ref_with(hooks, |_| render_target.clone());
     *render_target_ref.lock() = render_target.clone();
     let golden_image_output_dir = golden_image_output_dir.unwrap_or(PathBuf::new());
     let screenshot_path = golden_image_output_dir.join("screenshot.png");
     let fail_screenshot_path = golden_image_output_dir.join("fail_screenshot.png");
-    let (old_screenshot, _) = hooks.use_state_with(|_| {
+    let (old_screenshot, _) = use_state_with(hooks, |_| {
         tracing::info!("Loading screenshot from {:?}", screenshot_path);
         Some(Arc::new(image::open(&screenshot_path).ok()?))
     });
@@ -212,7 +215,7 @@ fn GoldenImageTest(
 
     match golden_image_cmd {
         GoldenImageCommand::Update { wait_seconds } => {
-            hooks.use_spawn(move |world| {
+            use_spawn(hooks, move |world| {
                 let window_ctl = world.resource(window_ctl()).clone();
                 let gpu = world.resource(gpu()).clone();
                 world.resource(runtime()).spawn(async move {
@@ -256,10 +259,10 @@ fn GoldenImageTest(
                 panic!("Existing screenshot must exist");
             };
 
-            // Note: this is basically hooks.use_interval_deps() except its
+            // Note: this is basically use_interval_deps(hooks, ) except its
             // internals are unwrapped in order to access the `world`, which we
             // need for window_ctl().
-            hooks.use_effect(render_target.0.color_buffer.id, move |world, _| {
+            use_effect(hooks, render_target.0.color_buffer.id, move |world, _| {
                 let window_ctl = world.resource(window_ctl()).clone();
                 let gpu = world.resource(gpu()).clone();
                 let start_time = Instant::now();

diff --git a/crates/asset_timeline/src/lib.rs b/crates/asset_timeline/src/lib.rs
@@ -1,7 +1,9 @@
 use std::{collections::HashMap, sync::Arc};
 
 use ambient_core::{asset_cache, transform::translation};
-use ambient_element::{Element, ElementComponent, ElementComponentExt, Hooks};
+use ambient_element::{
+    use_interval, use_state, Element, ElementComponent, ElementComponentExt, Hooks,
+};
 use ambient_native_std::{
     asset_cache::{AssetKey, AssetLifetime, AssetTimeline, AssetsTimeline},
     color::Color,
@@ -22,22 +24,22 @@ pub struct AssetTimelineVisualizer {
 impl ElementComponent for AssetTimelineVisualizer {
     fn render(self: Box<Self>, hooks: &mut Hooks) -> Element {
         let total_count = self.timeline.assets.len();
-        let (limit, set_limit) = hooks.use_state(Some(100));
+        let (limit, set_limit) = use_state(hooks, Some(100));
         #[derive(Debug, Clone, Copy, PartialEq, Eq)]
         enum Sorting {
             CpuSize,
             GpuSize,
             Name,
         }
-        let (sorting, set_sorting) = hooks.use_state(Sorting::CpuSize);
+        let (sorting, set_sorting) = use_state(hooks, Sorting::CpuSize);
         #[derive(Debug, Clone, Copy, PartialEq, Eq)]
         enum Filter {
             Loading,
             Alive,
             Aborted,
             All,
         }
-        let (filter, set_filter) = hooks.use_state(Filter::Loading);
+        let (filter, set_filter) = use_state(hooks, Filter::Loading);
         let mut roots: HashMap<AssetKey, (AssetTimeline, _)> = self
             .timeline
             .assets
@@ -185,7 +187,7 @@ impl ElementComponent for AssetTimelineRow {
             padding,
             total_gpu_size,
         } = *self;
-        let (expanded, set_expanded) = hooks.use_state(false);
+        let (expanded, set_expanded) = use_state(hooks, false);
         let key_text = Text::el(if key.len() > 30 { &key[0..30] } else { &key }).with(
             color(),
             if value.is_alive {
@@ -436,9 +438,9 @@ impl ElementComponent for AssetLifetimeViz {
 pub struct LocalAssetTimelineVisualizer;
 impl ElementComponent for LocalAssetTimelineVisualizer {
     fn render(self: Box<Self>, hooks: &mut Hooks) -> Element {
-        let (timeline, set_timeline) = hooks.use_state(AssetsTimeline::new());
+        let (timeline, set_timeline) = use_state(hooks, AssetsTimeline::new());
         let assets = hooks.world.resource(asset_cache()).clone();
-        hooks.use_interval(1., move || {
+        use_interval(hooks, 1., move || {
             let timeline = assets.timeline.lock().clone();
             set_timeline(timeline);
         });

diff --git a/crates/client_shared/src/game_view.rs b/crates/client_shared/src/game_view.rs
@@ -6,7 +6,10 @@ use ambient_core::window::{
 use ambient_debugger::Debugger;
 use ambient_ecs::{generated::messages, EntityId};
 use ambient_ecs_editor::{ECSEditor, InspectableAsyncWorld};
-use ambient_element::{element_component, Element, ElementComponentExt, Hooks};
+use ambient_element::{
+    consume_context, element_component, use_frame, use_runtime_message, use_state, Element,
+    ElementComponentExt, Hooks,
+};
 use ambient_layout::Docking;
 use ambient_network::client::{ClientState, GameClientRenderTarget, GameClientWorld};
 use ambient_shared_types::CursorIcon;
@@ -18,19 +21,19 @@ use glam::{uvec2, vec4, Vec2};
 
 #[element_component]
 pub fn GameView(hooks: &mut Hooks, show_debug: bool) -> Element {
-    let (client_state, _) = hooks.consume_context::<ClientState>().unwrap();
-    let (render_target, _) = hooks.consume_context::<GameClientRenderTarget>().unwrap();
+    let (client_state, _) = consume_context::<ClientState>(hooks).unwrap();
+    let (render_target, _) = consume_context::<GameClientRenderTarget>(hooks).unwrap();
 
-    let (show_ecs, set_show_ecs) = hooks.use_state(true);
-    let (ecs_size, set_ecs_size) = hooks.use_state(Vec2::ZERO);
-    let (debugger_size, set_debugger_size) = hooks.use_state(Vec2::ZERO);
+    let (show_ecs, set_show_ecs) = use_state(hooks, true);
+    let (ecs_size, set_ecs_size) = use_state(hooks, Vec2::ZERO);
+    let (debugger_size, set_debugger_size) = use_state(hooks, Vec2::ZERO);
 
-    let (w, set_w) = hooks.use_state(300.0);
-    let (w_memory, set_w_memory) = hooks.use_state(0.0);
-    let (mouse_on_edge, set_mouse_on_edge) = hooks.use_state(false);
-    let (should_track_resize, set_should_track_resize) = hooks.use_state(false);
+    let (w, set_w) = use_state(hooks, 300.0);
+    let (w_memory, set_w_memory) = use_state(hooks, 0.0);
+    let (mouse_on_edge, set_mouse_on_edge) = use_state(hooks, false);
+    let (should_track_resize, set_should_track_resize) = use_state(hooks, false);
 
-    hooks.use_runtime_message::<messages::WindowMouseInput>({
+    use_runtime_message::<messages::WindowMouseInput>(hooks, {
         move |_world, event| {
             let pressed = event.pressed;
             if pressed && mouse_on_edge {
@@ -41,7 +44,7 @@ pub fn GameView(hooks: &mut Hooks, show_debug: bool) -> Element {
         }
     });
 
-    hooks.use_frame({
+    use_frame(hooks, {
         let state = client_state.clone();
         let render_target = render_target.clone();
         let set_w = set_w.clone();

diff --git a/crates/client_shared/src/player.rs b/crates/client_shared/src/player.rs
@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use ambient_core::window::cursor_position;
 use ambient_ecs::{generated::messages, query_mut, SystemGroup, World};
-use ambient_element::{element_component, Element, Hooks};
+use ambient_element::{element_component, use_runtime_message, use_state, Element, Hooks};
 use ambient_input::{player_prev_raw_input, player_raw_input, PlayerRawInput};
 use ambient_network::client::client_state;
 use ambient_shared_types::VirtualKeyCode;
@@ -29,16 +29,16 @@ pub fn PlayerRawInputHandler(hooks: &mut Hooks) -> Element {
     const PIXELS_PER_LINE: f32 = 5.0;
 
     // Assume window has focus
-    let (has_focus, set_has_focus) = hooks.use_state(true);
-    hooks.use_runtime_message::<messages::WindowFocusChange>(move |world, event| {
+    let (has_focus, set_has_focus) = use_state(hooks, true);
+    use_runtime_message::<messages::WindowFocusChange>(hooks, move |world, event| {
         set_has_focus(event.focused);
 
         if !event.focused {
             process_input(world, true, |input, _| input.clear());
         }
     });
 
-    hooks.use_runtime_message::<messages::WindowKeyboardInput>(move |world, event| {
+    use_runtime_message::<messages::WindowKeyboardInput>(hooks, move |world, event| {
         process_input(world, has_focus, |input, _| {
             if let Some(keycode) = event.keycode.as_deref() {
                 let keycode = VirtualKeyCode::from_str(keycode).unwrap();
@@ -51,7 +51,7 @@ pub fn PlayerRawInputHandler(hooks: &mut Hooks) -> Element {
         });
     });
 
-    hooks.use_runtime_message::<messages::WindowMouseInput>(move |world, event| {
+    use_runtime_message::<messages::WindowMouseInput>(hooks, move |world, event| {
         process_input(world, has_focus, |input, _| {
             if event.pressed {
                 input.mouse_buttons.insert(event.button.into());
@@ -61,14 +61,14 @@ pub fn PlayerRawInputHandler(hooks: &mut Hooks) -> Element {
         });
     });
 
-    hooks.use_runtime_message::<messages::WindowMouseMotion>(move |world, msg| {
+    use_runtime_message::<messages::WindowMouseMotion>(hooks, move |world, msg| {
         process_input(world, has_focus, |input, mouse_pos| {
             input.mouse_position = mouse_pos;
             input.mouse_delta += msg.delta;
         });
     });
 
-    hooks.use_runtime_message::<messages::WindowMouseWheel>(move |world, event| {
+    use_runtime_message::<messages::WindowMouseWheel>(hooks, move |world, event| {
         process_input(world, has_focus, |input, _| {
             let delta = event.delta;
             input.mouse_wheel += match event.pixels {

diff --git a/crates/debugger/src/lib.rs b/crates/debugger/src/lib.rs
@@ -10,7 +10,10 @@ use ambient_core::{
     runtime,
 };
 use ambient_ecs::{query, World};
-use ambient_element::{element_component, Element, ElementComponentExt, Hooks};
+use ambient_element::{
+    consume_context, element_component, use_state, use_state_with, Element, ElementComponentExt,
+    Hooks,
+};
 use ambient_gizmos::{gizmos, GizmoPrimitive};
 use ambient_native_std::{asset_cache::AssetCache, color::Color, Cb};
 use ambient_network::{client::ClientState, server::RpcArgs as ServerRpcArgs};
@@ -76,8 +79,8 @@ fn dump_to_user(_assets: &AssetCache, _label: &'static str, s: String) {
 
 #[element_component]
 pub fn Debugger(hooks: &mut Hooks, get_state: GetDebuggerState) -> Element {
-    let (show_shadows, set_show_shadows) = hooks.use_state(false);
-    let (client_state, _) = hooks.consume_context::<ClientState>().unwrap();
+    let (show_shadows, set_show_shadows) = use_state(hooks, false);
+    let (client_state, _) = consume_context::<ClientState>(hooks).unwrap();
 
     FlowColumn::el([
         FlowRow(vec![
@@ -213,7 +216,7 @@ pub fn Debugger(hooks: &mut Hooks, get_state: GetDebuggerState) -> Element {
 
 #[element_component]
 fn ShadowMapsViz(hooks: &mut Hooks, get_state: GetDebuggerState) -> Element {
-    let (shadow_cascades, _) = hooks.use_state_with(|_| {
+    let (shadow_cascades, _) = use_state_with(hooks, |_| {
         let mut n_cascades = 0;
         get_state(&mut |renderer, _, _| {
             n_cascades = renderer.config.shadow_cascades;
@@ -237,7 +240,7 @@ fn ShadowMapsViz(hooks: &mut Hooks, get_state: GetDebuggerState) -> Element {
 
 #[element_component]
 fn ShadowMapViz(hooks: &mut Hooks, get_state: GetDebuggerState, cascade: u32) -> Element {
-    let (texture, _) = hooks.use_state_with(|_| {
+    let (texture, _) = use_state_with(hooks, |_| {
         let mut tex = None;
         get_state(&mut |renderer, _, _| {
             tex = Some(renderer.shadows.as_ref().map(|x| {
@@ -259,9 +262,9 @@ fn ShadowMapViz(hooks: &mut Hooks, get_state: GetDebuggerState, cascade: u32) ->
 
 #[element_component]
 fn ShaderDebug(hooks: &mut Hooks, get_state: GetDebuggerState) -> Element {
-    let (show, set_show) = hooks.use_state(false);
+    let (show, set_show) = use_state(hooks, false);
 
-    let (_, upd) = hooks.use_state(());
+    let (_, upd) = use_state(hooks, ());
 
     let mut params = Default::default();
     get_state(&mut |renderer, _, _| {

diff --git a/crates/ecs_editor/src/lib.rs b/crates/ecs_editor/src/lib.rs
@@ -2,7 +2,9 @@ use std::{sync::Arc, time::Duration};
 
 use ambient_core::name;
 use ambient_ecs::{query, EntityId, World};
-use ambient_element::{element_component, Element, ElementComponentExt, Hooks};
+use ambient_element::{
+    element_component, use_interval_deps, use_state, Element, ElementComponentExt, Hooks,
+};
 use ambient_layout::{fit_horizontal, max_width, width, Fit};
 use ambient_native_std::{cb, Cb};
 use ambient_renderer::color;
@@ -121,8 +123,8 @@ impl InspectableWorld for InspectableAsyncWorld {
 
 #[element_component]
 pub fn ECSEditor(hooks: &mut Hooks, world: Arc<dyn InspectableWorld>) -> Element {
-    let (comp_filter, set_comp_filter) = hooks.use_state("".to_string());
-    let (entity_filter, set_entity_filter) = hooks.use_state("".to_string());
+    let (comp_filter, set_comp_filter) = use_state(hooks, "".to_string());
+    let (entity_filter, set_entity_filter) = use_state(hooks, "".to_string());
 
     FlowColumn::el([
         {
@@ -157,10 +159,11 @@ fn EntityList(
     filter_entities: String,
     filter_components: String,
 ) -> Element {
-    let (show_all, set_show_all) = hooks.use_state(false);
-    let (entities, set_entities) = hooks.use_state(Vec::new());
+    let (show_all, set_show_all) = use_state(hooks, false);
+    let (entities, set_entities) = use_state(hooks, Vec::new());
     const MAX: usize = 30;
-    hooks.use_interval_deps(
+    use_interval_deps(
+        hooks,
         Duration::from_secs_f32(0.5),
         true,
         filter_entities.clone(),
@@ -213,8 +216,8 @@ fn EntityBlock(
     filter_entities: String,
     filter_components: String,
 ) -> Element {
-    let (expanded, set_expanded) = hooks.use_state(false);
-    let (components, set_components) = hooks.use_state(false);
+    let (expanded, set_expanded) = use_state(hooks, false);
+    let (components, set_components) = use_state(hooks, false);
     FlowColumn::el([
         FlowRow::el([
             Button::new(
@@ -272,8 +275,9 @@ fn EntityComponents(
     entity: EntityId,
     filter_components: String,
 ) -> Element {
-    let (components, set_components) = hooks.use_state(Vec::new());
-    hooks.use_interval_deps(
+    let (components, set_components) = use_state(hooks, Vec::new());
+    use_interval_deps(
+        hooks,
         Duration::from_secs_f32(0.5),
         true,
         filter_components.clone(),

diff --git a/crates/editor/src/ui/build_mode/entity_browser.rs b/crates/editor/src/ui/build_mode/entity_browser.rs
@@ -1,7 +1,9 @@
 use ambient_core::{name, selectable, tags};
 use ambient_ecs::{query, EntityId};
 use ambient_ecs_editor::{ECSEditor, InspectableAsyncWorld};
-use ambient_element::{Element, ElementComponent, ElementComponentExt, Hooks};
+use ambient_element::{
+    consume_context, use_spawn, use_state, Element, ElementComponent, ElementComponentExt, Hooks,
+};
 use ambient_native_std::{cb, Cb};
 use ambient_network::{
     client::{client_state, ClientState},
@@ -21,11 +23,11 @@ pub struct EntityBrowser {
 impl ElementComponent for EntityBrowser {
     fn render(self: Box<Self>, hooks: &mut Hooks) -> Element {
         let Self { on_select } = *self;
-        let (entities, set_entities) = hooks.use_state(Vec::new());
-        let (all_tags, set_all_tags) = hooks.use_state(Vec::new());
-        let (selected_tag, set_selected_tag) = hooks.use_state(None);
-        let (client_state, _) = hooks.consume_context::<ClientState>().unwrap();
-        hooks.use_spawn(move |_| {
+        let (entities, set_entities) = use_state(hooks, Vec::new());
+        let (all_tags, set_all_tags) = use_state(hooks, Vec::new());
+        let (selected_tag, set_selected_tag) = use_state(hooks, None);
+        let (client_state, _) = consume_context::<ClientState>(hooks).unwrap();
+        use_spawn(hooks, move |_| {
             let state = client_state.game_state.lock();
             let entities = query(selectable())
                 .incl(is_remote_entity())
@@ -112,7 +114,7 @@ pub struct EntityBrowserScreen {
 impl ElementComponent for EntityBrowserScreen {
     fn render(self: Box<Self>, hooks: &mut Hooks) -> Element {
         let Self { on_select, on_back } = *self;
-        let (advanced, set_advanced) = hooks.use_state(false);
+        let (advanced, set_advanced) = use_state(hooks, false);
         DialogScreen(
             ScrollArea::el(
                 ScrollAreaSizing::FitChildrenWidth,