Bootstrap Image Generator application (#53)

This PR begins scaffolding the Stable Diffusion Turbo application (title
TBD), which is a separate frontend for Storyteller Engine which focuses
on image generation.

### Design Overview

* The application renders a "split-screen" view, with Storyteller Studio
  on the left, and the Stable Diffusion Turbo output on the right
* When changes are made in the Studio editor:
  - A screenshot is taken from the Bevy application
  - Screenshot is piped into Stable Diffusion Turbo model
  - Model output is rendered to the screen
* This all happens in as close to real-time as possible

### Work completed in this PR

* The `studio-frontend` project has been (somewhat crudely) refactored
  to split most of its components into reusable libraries
  - `studio-ui` is a use-case-agnostic design system library for core UI
    components. These are "dumb" components which are controlled
    via `@property` inputs and send `CustomEvent`s in response to user
    input.
  - `studio-frontend` is a collection of reusable Storyteller Studio
    widgets. These are "smart" components which depend on
    `@storyteller/studio` directly, manage their own state, and require very
    little configuration or styling. They are designed to be drop-in
    building blocks that can be reused between various frontends.
* The new application has been bootstrapped as `image-generator-demo`
  - Currently, this simply grabs screenshots from the Bevy application and
    renders those screenshots on the right side of the split-screen view. A
    future PR will wire up to the Storyteller.ai backend to pipe these
    screenshots through Stable Diffusion Turbo, and render that model's
    output instead.

### Testing

* Install dependencies as described in the repo's README
* Run `npx nx serve image-generator-demo`
* Open [localhost:4200](http://localhost:4200) in your browser
  - Use the camera controller in the left side of the view to manipulate
    the Bevy scene
  - Verify the right side of the view updates with a fresh screenshot at a
    rate of ~5 fps
* Toggle the "Realtime Capture" checkbox
  - Verify the right side view no longer updates while the user is
    actively manipulating the editor
  - This should allow the app to run smoother on lower-spec hardware

---------

Co-authored-by: Danny McGee <dannymcgee@gmail.com>

studio/src/camera_controller.rs

@@ -10,7 +10,7 @@ use crate::{
     interaction::Selected,
     math::{
         Easing, InterpPosition, InterpVelocity, Interpolation, InterpolationSystem, NearlyEq,
-        Velocity,
+        NearlyZero, Velocity,
     },
 };
 
@@ -78,9 +78,6 @@ fn camera_control_kinematic(
         return;
     }
 
-    let (mut controller, mut xform, proj) = q_camera.single_mut();
-    let mut window = q_window.single_mut();
-
     let mut any_ongoing = false;
     let mut any_started = false;
     let mut any_stopped = false;
@@ -92,7 +89,8 @@ fn camera_control_kinematic(
         )
     }) {
         if let InputAction(lifecycle, Action::Camera(motion)) = action {
-            use CameraMotion::*;
+            let (mut controller, mut xform, proj) = q_camera.single_mut();
+            let window = q_window.single();
 
             match lifecycle {
                 Lifecycle::Start => any_started = true,
@@ -100,20 +98,21 @@ fn camera_control_kinematic(
                 Lifecycle::Stop => any_stopped = true,
             }
 
+            use CameraMotion::*;
             match motion {
-                Pan(delta) => do_pan(proj, &window, *delta, &mut xform, &mut controller),
-                Zoom(delta) => do_zoom(&window, *delta, &mut xform, &mut controller),
-                Orbit(delta) => do_orbit(&window, *delta, *lifecycle, &mut xform, &mut controller),
-                Rotate(delta) => do_rotate(&window, *delta, &mut xform, &mut controller),
+                Pan(delta) => do_pan(proj, window, *delta, &mut xform, &mut controller),
+                Zoom(delta) => do_zoom(window, *delta, &mut xform, &mut controller),
+                Orbit(delta) => do_orbit(window, *delta, *lifecycle, &mut xform, &mut controller),
+                Rotate(delta) => do_rotate(window, *delta, &mut xform, &mut controller),
                 _ => {}
             }
         }
     }
 
     if any_started {
-        capture_pointer(&mut window);
+        capture_pointer(&mut q_window.single_mut());
     } else if any_stopped && !any_ongoing {
-        release_pointer(&mut window);
+        release_pointer(&mut q_window.single_mut());
     }
 }
 
@@ -215,12 +214,16 @@ fn process_focus_inputs(
 }
 
 fn camera_control_physical(
-    mut q_camera: Query<(&mut CameraController, &mut Transform, &Velocity)>,
+    mut q_camera: Query<(Entity, &mut CameraController, &Velocity)>,
+    mut q_xforms: Query<&mut Transform>,
 ) {
-    for (mut controller, mut xform, velocity) in q_camera.iter_mut() {
-        let delta_pos = xform.rotation * (**velocity);
-        xform.translation += delta_pos;
-        controller.focus += delta_pos;
+    for (ent, mut controller, velocity) in q_camera.iter_mut() {
+        if !velocity.nearly_zero() {
+            let mut xform = q_xforms.get_mut(ent).unwrap();
+            let delta_pos = xform.rotation * (**velocity);
+            xform.translation += delta_pos;
+            controller.focus += delta_pos;
+        }
     }
 }