modular ui rework
This commit is contained in:
galister
609
src/gui/modular/button.rs
Normal file
609
src/gui/modular/button.rs
Normal file
@@ -0,0 +1,609 @@
|
||||
use std::{
|
||||
f32::consts::PI,
|
||||
io::Cursor,
|
||||
ops::Add,
|
||||
process::{self, Child},
|
||||
sync::Arc,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use glam::{Quat, Vec3A};
|
||||
use rodio::{Decoder, Source};
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::{
|
||||
backend::{
|
||||
common::{ColorChannel, OverlaySelector, SystemTask, TaskType},
|
||||
input::PointerMode,
|
||||
overlay::RelativeTo,
|
||||
},
|
||||
overlays::{
|
||||
mirror,
|
||||
toast::Toast,
|
||||
watch::{save_watch, WATCH_NAME},
|
||||
},
|
||||
state::AppState,
|
||||
};
|
||||
|
||||
use super::{ExecArgs, ModularControl, ModularData};
|
||||
|
||||
#[derive(Deserialize, Clone, Copy)]
|
||||
pub enum ViewAngleKind {
|
||||
/// The cosine of the angle at which the watch becomes fully transparent
|
||||
MinOpacity,
|
||||
/// The cosine of the angle at which the watch becomes fully opaque
|
||||
MaxOpacity,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone, Copy)]
|
||||
pub enum Axis {
|
||||
X,
|
||||
Y,
|
||||
Z,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone)]
|
||||
pub enum SystemAction {
|
||||
PlayspaceResetOffset,
|
||||
PlayspaceFixFloor,
|
||||
RecalculateExtent,
|
||||
PersistConfig,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone)]
|
||||
pub enum WatchAction {
|
||||
/// Hide the watch until Show/Hide binding is used
|
||||
Hide,
|
||||
/// Switch the watch to the opposite controller
|
||||
SwitchHands,
|
||||
/// Change the fade behavior of the watch
|
||||
ViewAngle {
|
||||
kind: ViewAngleKind,
|
||||
delta: f32,
|
||||
},
|
||||
Rotation {
|
||||
axis: Axis,
|
||||
delta: f32,
|
||||
},
|
||||
Position {
|
||||
axis: Axis,
|
||||
delta: f32,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone)]
|
||||
pub enum OverlayAction {
|
||||
/// Reset the overlay to be in front of the HMD with its original scale
|
||||
Reset,
|
||||
/// Toggle the visibility of the overlay
|
||||
ToggleVisible,
|
||||
/// Toggle the ability to grab and recenter the overlay
|
||||
ToggleImmovable,
|
||||
/// Toggle the ability of the overlay to reacto to laser pointer
|
||||
ToggleInteraction,
|
||||
/// Change the opacity of the overlay
|
||||
Opacity { delta: f32 },
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone)]
|
||||
pub enum WindowAction {
|
||||
/// Create a new mirror window, or show/hide an existing one
|
||||
ShowMirror,
|
||||
/// Create a new UI window, or show/hide an existing one
|
||||
ShowUi,
|
||||
/// Destroy a previously created window, if it exists
|
||||
Destroy,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Clone)]
|
||||
#[serde(tag = "type")]
|
||||
pub enum ButtonAction {
|
||||
Exec {
|
||||
command: ExecArgs,
|
||||
toast: Option<Arc<str>>,
|
||||
},
|
||||
Watch {
|
||||
action: WatchAction,
|
||||
},
|
||||
Overlay {
|
||||
target: OverlaySelector,
|
||||
action: OverlayAction,
|
||||
},
|
||||
Window {
|
||||
target: Arc<str>,
|
||||
action: WindowAction,
|
||||
},
|
||||
Toast {
|
||||
message: Arc<str>,
|
||||
body: Option<Arc<str>>,
|
||||
seconds: Option<f32>,
|
||||
},
|
||||
ColorAdjust {
|
||||
channel: ColorChannel,
|
||||
delta: f32,
|
||||
},
|
||||
System {
|
||||
action: SystemAction,
|
||||
},
|
||||
}
|
||||
|
||||
pub(super) struct PressData {
|
||||
last_down: Instant,
|
||||
last_mode: PointerMode,
|
||||
child: Option<Child>,
|
||||
}
|
||||
impl Clone for PressData {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
last_down: self.last_down,
|
||||
last_mode: self.last_mode,
|
||||
child: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Default for PressData {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
last_down: Instant::now(),
|
||||
last_mode: PointerMode::Left,
|
||||
child: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default, Clone)]
|
||||
pub struct ButtonData {
|
||||
#[serde(skip)]
|
||||
pub(super) press: PressData,
|
||||
|
||||
pub(super) click_down: Option<Vec<ButtonAction>>,
|
||||
pub(super) click_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) long_click_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) right_down: Option<Vec<ButtonAction>>,
|
||||
pub(super) right_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) long_right_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) middle_down: Option<Vec<ButtonAction>>,
|
||||
pub(super) middle_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) long_middle_up: Option<Vec<ButtonAction>>,
|
||||
pub(super) scroll_down: Option<Vec<ButtonAction>>,
|
||||
pub(super) scroll_up: Option<Vec<ButtonAction>>,
|
||||
}
|
||||
|
||||
pub fn modular_button_init(button: &mut ModularControl, data: &ButtonData) {
|
||||
button.state = Some(ModularData::Button(data.clone()));
|
||||
button.on_press = Some(modular_button_dn);
|
||||
button.on_release = Some(modular_button_up);
|
||||
button.on_scroll = Some(modular_button_scroll);
|
||||
}
|
||||
|
||||
fn modular_button_dn(
|
||||
button: &mut ModularControl,
|
||||
_: &mut (),
|
||||
app: &mut AppState,
|
||||
mode: PointerMode,
|
||||
) {
|
||||
// want panic
|
||||
let ModularData::Button(data) = button.state.as_mut().unwrap() else {
|
||||
panic!("modular_button_dn: button state is not Button");
|
||||
};
|
||||
|
||||
data.press.last_down = Instant::now();
|
||||
data.press.last_mode = mode;
|
||||
|
||||
let actions = match mode {
|
||||
PointerMode::Left => data.click_down.as_ref(),
|
||||
PointerMode::Right => data.right_down.as_ref(),
|
||||
PointerMode::Middle => data.middle_down.as_ref(),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
if let Some(actions) = actions {
|
||||
for action in actions {
|
||||
handle_action(action, &mut data.press, app);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn modular_button_up(button: &mut ModularControl, _: &mut (), app: &mut AppState) {
|
||||
// want panic
|
||||
let ModularData::Button(data) = button.state.as_mut().unwrap() else {
|
||||
panic!("modular_button_up: button state is not Button");
|
||||
};
|
||||
|
||||
let now = Instant::now();
|
||||
let duration = now - data.press.last_down;
|
||||
let long_press = duration.as_secs_f32() > app.session.config.long_press_duration;
|
||||
|
||||
let actions = match data.press.last_mode {
|
||||
PointerMode::Left => {
|
||||
if long_press {
|
||||
data.long_click_up.as_ref()
|
||||
} else {
|
||||
data.click_up.as_ref()
|
||||
}
|
||||
}
|
||||
PointerMode::Right => {
|
||||
if long_press {
|
||||
data.long_right_up.as_ref()
|
||||
} else {
|
||||
data.right_up.as_ref()
|
||||
}
|
||||
}
|
||||
PointerMode::Middle => {
|
||||
if long_press {
|
||||
data.long_middle_up.as_ref()
|
||||
} else {
|
||||
data.middle_up.as_ref()
|
||||
}
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
|
||||
if let Some(actions) = actions {
|
||||
for action in actions {
|
||||
handle_action(action, &mut data.press, app);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn modular_button_scroll(button: &mut ModularControl, _: &mut (), app: &mut AppState, delta: f32) {
|
||||
// want panic
|
||||
let ModularData::Button(data) = button.state.as_mut().unwrap() else {
|
||||
panic!("modular_button_scroll: button state is not Button");
|
||||
};
|
||||
|
||||
let actions = if delta < 0.0 {
|
||||
data.scroll_down.as_ref()
|
||||
} else {
|
||||
data.scroll_up.as_ref()
|
||||
};
|
||||
|
||||
if let Some(actions) = actions {
|
||||
for action in actions {
|
||||
handle_action(action, &mut data.press, app);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppState) {
|
||||
match action {
|
||||
ButtonAction::Exec { command, toast } => run_exec(command, toast, press, app),
|
||||
ButtonAction::Watch { action } => run_watch(action, app),
|
||||
ButtonAction::Overlay { target, action } => run_overlay(target, action, app),
|
||||
ButtonAction::Window { target, action } => run_window(target, action, app),
|
||||
ButtonAction::Toast {
|
||||
message,
|
||||
body,
|
||||
seconds,
|
||||
} => {
|
||||
Toast::new(message.clone(), body.clone().unwrap_or_else(|| "".into()))
|
||||
.with_timeout(seconds.unwrap_or(5.))
|
||||
.submit(app);
|
||||
}
|
||||
ButtonAction::ColorAdjust { channel, delta } => {
|
||||
let channel = *channel;
|
||||
let delta = *delta;
|
||||
app.tasks
|
||||
.enqueue(TaskType::System(SystemTask::ColorGain(channel, delta)));
|
||||
}
|
||||
ButtonAction::System { action } => run_system(action, app),
|
||||
}
|
||||
}
|
||||
|
||||
fn run_system(action: &SystemAction, app: &mut AppState) {
|
||||
match action {
|
||||
SystemAction::PlayspaceResetOffset => {
|
||||
app.tasks
|
||||
.enqueue(TaskType::System(SystemTask::ResetPlayspace));
|
||||
}
|
||||
SystemAction::PlayspaceFixFloor => {
|
||||
let now = Instant::now();
|
||||
let sec = Duration::from_secs(1);
|
||||
for i in 0..5 {
|
||||
let at = now.add(i * sec);
|
||||
let display = 5 - i;
|
||||
Toast::new(
|
||||
format!("Fixing floor in {}", display).into(),
|
||||
"Place either controller on the floor.".into(),
|
||||
)
|
||||
.with_timeout(1.0)
|
||||
.submit_at(app, at);
|
||||
}
|
||||
app.tasks
|
||||
.enqueue_at(TaskType::System(SystemTask::FixFloor), now.add(5 * sec));
|
||||
}
|
||||
SystemAction::RecalculateExtent => {
|
||||
todo!()
|
||||
}
|
||||
SystemAction::PersistConfig => {
|
||||
if let Err(e) = save_watch(app) {
|
||||
log::error!("Failed to save watch config: {:?}", e);
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn run_exec(args: &ExecArgs, toast: &Option<Arc<str>>, press: &mut PressData, app: &mut AppState) {
|
||||
if let Some(proc) = press.child.as_mut() {
|
||||
match proc.try_wait() {
|
||||
Ok(Some(code)) => {
|
||||
if !code.success() {
|
||||
log::error!("Child process exited with code: {}", code);
|
||||
}
|
||||
press.child = None;
|
||||
}
|
||||
Ok(None) => {
|
||||
log::warn!("Unable to launch child process: previous child not exited yet");
|
||||
return;
|
||||
}
|
||||
Err(e) => {
|
||||
press.child = None;
|
||||
log::error!("Error checking child process: {:?}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
let args = args.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
|
||||
match process::Command::new(args[0]).args(&args[1..]).spawn() {
|
||||
Ok(proc) => {
|
||||
press.child = Some(proc);
|
||||
if let Some(toast) = toast.as_ref() {
|
||||
Toast::new(toast.clone(), "".into()).submit(app);
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("Failed to spawn process {:?}: {:?}", args, e);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn run_watch(data: &WatchAction, app: &mut AppState) {
|
||||
match data {
|
||||
WatchAction::Hide => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
OverlaySelector::Name(WATCH_NAME.into()),
|
||||
Box::new(|app, o| {
|
||||
if o.saved_scale.is_none() {
|
||||
o.saved_scale = Some(o.spawn_scale);
|
||||
o.want_visible = false;
|
||||
o.saved_scale = Some(0.0);
|
||||
Toast::new(
|
||||
"Watch hidden".into(),
|
||||
"Use show/hide binding to restore.".into(),
|
||||
)
|
||||
.with_timeout(3.)
|
||||
.submit(app);
|
||||
} else {
|
||||
o.want_visible = true;
|
||||
o.saved_scale = None;
|
||||
Toast::new("Watch restored".into(), "".into()).submit(app);
|
||||
}
|
||||
}),
|
||||
));
|
||||
audio_thump(app);
|
||||
}
|
||||
WatchAction::SwitchHands => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
OverlaySelector::Name(WATCH_NAME.into()),
|
||||
Box::new(|app, o| {
|
||||
if let RelativeTo::Hand(0) = o.relative_to {
|
||||
o.relative_to = RelativeTo::Hand(1);
|
||||
o.spawn_rotation = Quat::from_slice(&app.session.config.watch_rot)
|
||||
* Quat::from_rotation_x(PI)
|
||||
* Quat::from_rotation_z(PI);
|
||||
o.spawn_point = Vec3A::from_slice(&app.session.config.watch_pos);
|
||||
o.spawn_point.x *= -1.;
|
||||
} else {
|
||||
o.relative_to = RelativeTo::Hand(0);
|
||||
o.spawn_rotation = Quat::from_slice(&app.session.config.watch_rot);
|
||||
o.spawn_point = Vec3A::from_slice(&app.session.config.watch_pos);
|
||||
}
|
||||
o.dirty = true;
|
||||
Toast::new("Watch switched".into(), "Check your other hand".into())
|
||||
.with_timeout(3.)
|
||||
.submit(app);
|
||||
}),
|
||||
));
|
||||
audio_thump(app);
|
||||
}
|
||||
WatchAction::ViewAngle { kind, delta } => match kind {
|
||||
ViewAngleKind::MinOpacity => {
|
||||
let diff = (app.session.config.watch_view_angle_max
|
||||
- app.session.config.watch_view_angle_min)
|
||||
+ delta;
|
||||
|
||||
app.session.config.watch_view_angle_min = (app.session.config.watch_view_angle_max
|
||||
- diff)
|
||||
.clamp(0.0, app.session.config.watch_view_angle_max - 0.05);
|
||||
}
|
||||
ViewAngleKind::MaxOpacity => {
|
||||
let diff = app.session.config.watch_view_angle_max
|
||||
- app.session.config.watch_view_angle_min;
|
||||
|
||||
app.session.config.watch_view_angle_max =
|
||||
(app.session.config.watch_view_angle_max + delta).clamp(0.05, 1.0);
|
||||
|
||||
app.session.config.watch_view_angle_min = (app.session.config.watch_view_angle_max
|
||||
- diff)
|
||||
.clamp(0.0, app.session.config.watch_view_angle_max - 0.05);
|
||||
}
|
||||
},
|
||||
WatchAction::Rotation { axis, delta } => {
|
||||
let rot = match axis {
|
||||
Axis::X => Quat::from_rotation_x(delta.to_radians()),
|
||||
Axis::Y => Quat::from_rotation_y(delta.to_radians()),
|
||||
Axis::Z => Quat::from_rotation_z(delta.to_radians()),
|
||||
};
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
OverlaySelector::Name(WATCH_NAME.into()),
|
||||
Box::new(move |app, o| {
|
||||
o.spawn_rotation = o.spawn_rotation * rot;
|
||||
app.session.config.watch_rot = o.spawn_rotation.into();
|
||||
o.dirty = true;
|
||||
}),
|
||||
));
|
||||
}
|
||||
WatchAction::Position { axis, delta } => {
|
||||
let delta = *delta;
|
||||
let axis = match axis {
|
||||
Axis::X => 0,
|
||||
Axis::Y => 1,
|
||||
Axis::Z => 2,
|
||||
};
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
OverlaySelector::Name(WATCH_NAME.into()),
|
||||
Box::new(move |app, o| {
|
||||
o.spawn_point[axis] += delta;
|
||||
app.session.config.watch_pos = o.spawn_point.into();
|
||||
o.dirty = true;
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppState) {
|
||||
match action {
|
||||
OverlayAction::Reset => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
overlay.clone(),
|
||||
Box::new(|app, o| {
|
||||
o.reset(app, true);
|
||||
Toast::new(format!("{} has been reset!", o.name).into(), "".into()).submit(app);
|
||||
}),
|
||||
));
|
||||
}
|
||||
OverlayAction::ToggleVisible => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
overlay.clone(),
|
||||
Box::new(|app, o| {
|
||||
o.want_visible = !o.want_visible;
|
||||
if o.recenter {
|
||||
o.show_hide = o.want_visible;
|
||||
o.reset(app, false);
|
||||
}
|
||||
}),
|
||||
));
|
||||
}
|
||||
OverlayAction::ToggleImmovable => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
overlay.clone(),
|
||||
Box::new(|app, o| {
|
||||
o.recenter = !o.recenter;
|
||||
o.grabbable = o.recenter;
|
||||
o.show_hide = o.recenter;
|
||||
if !o.recenter {
|
||||
Toast::new(
|
||||
format!("{} is now locked in place!", o.name).into(),
|
||||
"".into(),
|
||||
)
|
||||
.submit(app);
|
||||
} else {
|
||||
Toast::new(format!("{} is now unlocked!", o.name).into(), "".into())
|
||||
.submit(app);
|
||||
}
|
||||
}),
|
||||
));
|
||||
audio_thump(app);
|
||||
}
|
||||
OverlayAction::ToggleInteraction => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
overlay.clone(),
|
||||
Box::new(|app, o| {
|
||||
o.interactable = !o.interactable;
|
||||
if !o.interactable {
|
||||
Toast::new(
|
||||
format!("{} is now non-interactable!", o.name).into(),
|
||||
"".into(),
|
||||
)
|
||||
.submit(app);
|
||||
} else {
|
||||
Toast::new(format!("{} is now interactable!", o.name).into(), "".into())
|
||||
.submit(app);
|
||||
}
|
||||
}),
|
||||
));
|
||||
audio_thump(app);
|
||||
}
|
||||
OverlayAction::Opacity { delta } => {
|
||||
let delta = *delta;
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
overlay.clone(),
|
||||
Box::new(move |_, o| {
|
||||
o.alpha = (o.alpha + delta).clamp(0.1, 1.0);
|
||||
o.dirty = true;
|
||||
log::debug!("{}: alpha {}", o.name, o.alpha);
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "wayland")]
|
||||
fn run_window(window: &Arc<str>, action: &WindowAction, app: &mut AppState) {
|
||||
use crate::overlays::custom;
|
||||
let selector = OverlaySelector::Name(window.clone());
|
||||
|
||||
match action {
|
||||
WindowAction::ShowMirror => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
selector,
|
||||
Box::new(|app, o| {
|
||||
o.want_visible = !o.want_visible;
|
||||
if o.recenter {
|
||||
o.show_hide = o.want_visible;
|
||||
o.reset(app, false);
|
||||
}
|
||||
}),
|
||||
));
|
||||
app.tasks.enqueue(TaskType::CreateOverlay(
|
||||
OverlaySelector::Name(window.clone()),
|
||||
Box::new({
|
||||
let name = window.clone();
|
||||
move |app| {
|
||||
Toast::new("Check your desktop for popup.".into(), "".into())
|
||||
.with_sound(true)
|
||||
.submit(app);
|
||||
mirror::new_mirror(name.clone(), false, &app.session)
|
||||
}
|
||||
}),
|
||||
));
|
||||
}
|
||||
WindowAction::ShowUi => {
|
||||
app.tasks.enqueue(TaskType::Overlay(
|
||||
selector,
|
||||
Box::new(|app, o| {
|
||||
o.want_visible = !o.want_visible;
|
||||
if o.recenter {
|
||||
o.show_hide = o.want_visible;
|
||||
o.reset(app, false);
|
||||
}
|
||||
}),
|
||||
));
|
||||
app.tasks.enqueue(TaskType::CreateOverlay(
|
||||
OverlaySelector::Name(window.clone()),
|
||||
Box::new({
|
||||
let name = window.clone();
|
||||
move |app| custom::create_custom(app, name)
|
||||
}),
|
||||
));
|
||||
}
|
||||
WindowAction::Destroy => {
|
||||
app.tasks
|
||||
.enqueue(TaskType::DropOverlay(OverlaySelector::Name(window.clone())));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "wayland"))]
|
||||
fn run_action_window(_: Arc<str>, _: &WindowAction, _: &mut AppState) {
|
||||
log::warn!("Cannot run Window action without Wayland feature.");
|
||||
}
|
||||
|
||||
fn audio_thump(app: &mut AppState) {
|
||||
if let Some(handle) = app.audio.get_handle() {
|
||||
let wav = include_bytes!("../../res/380885.wav");
|
||||
let cursor = Cursor::new(wav);
|
||||
let source = Decoder::new_wav(cursor).unwrap();
|
||||
let _ = handle.play_raw(source.convert_samples());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user