galactica
/
Galactica
1
0
Fork 0
Code Issues Releases Activity

Reworked subelements 

Cleaned up argument passing
Added persistent UI script variables
master
Mark 2024-02-08 20:40:12 -08:00
parent 3d59ffffef
commit 847542a8cb
Signed by: Mark
GPG Key ID: C6D63995FE72FD80
10 changed files with 287 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
crates/galactica/src/main.rs
View File

@ -123,21 +123,26 @@ fn try_main() -> Result<()> {
let mut game = game::Game::new(content.clone()); let mut game = game::Game::new(content.clone());
let p = game.make_player(); let p = game.make_player();
let player = Arc::new(PlayerAgent::new(&content, p.0)); let mut input = Arc::new(RenderInput {
let mut phys_img = Arc::new(PhysImage::new()); current_time: game.get_current_time(),
ct: content.clone(),
phys_img: PhysImage::new(),
player: PlayerAgent::new(&content, p.0),
// TODO: this is a hack for testing.
current_system: content.systems.values().next().unwrap().clone(),
timing: game.get_timing().clone(),
});
event_loop.run(move |event, _, control_flow| { event_loop.run(move |event, _, control_flow| {
{
let i = Arc::get_mut(&mut input).unwrap();
i.current_time = game.get_current_time();
i.timing = game.get_timing().clone();
}
match event { match event {
Event::RedrawRequested(window_id) if window_id == gpu.window().id() => { Event::RedrawRequested(window_id) if window_id == gpu.window().id() => {
match gpu.render(RenderInput { match gpu.render(&input) {
current_time: game.get_current_time(),
ct: content.clone(),
phys_img: phys_img.clone(),
player: player.clone(),
// TODO: this is a hack for testing.
current_system: content.systems.values().next().unwrap().clone(),
timing: game.get_timing().clone(),
}) {
Ok(_) => {} Ok(_) => {}
Err(wgpu::SurfaceError::Lost) => gpu.resize(&content), Err(wgpu::SurfaceError::Lost) => gpu.resize(&content),
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit, Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
@ -147,8 +152,9 @@ fn try_main() -> Result<()> {
} }
Event::MainEventsCleared => { Event::MainEventsCleared => {
game.step(&phys_img); let i = Arc::get_mut(&mut input).unwrap();
game.update_image(Arc::get_mut(&mut phys_img).unwrap()); game.step(&i.phys_img);
game.update_image(&mut i.phys_img);
gpu.window().request_redraw(); gpu.window().request_redraw();
} }
@ -171,37 +177,20 @@ fn try_main() -> Result<()> {
} => { } => {
let directive = gpu let directive = gpu
.process_input( .process_input(
RenderInput { &input,
current_time: game.get_current_time(),
ct: content.clone(),
phys_img: phys_img.clone(),
player: player.clone(),
current_system: content.systems.values().next().unwrap().clone(),
timing: game.get_timing().clone(),
},
InputEvent::Keyboard { InputEvent::Keyboard {
down: state == &ElementState::Pressed, down: state == &ElementState::Pressed,
key: *key, key: *key,
}, },
) )
.unwrap(); .unwrap();
game.apply_directive(directive, &player); game.apply_directive(directive, &input.player);
} }
WindowEvent::CursorMoved { position, .. } => { WindowEvent::CursorMoved { position, .. } => {
let directive = gpu let directive = gpu
.process_input( .process_input(&input, InputEvent::MouseMove(position.cast()))
RenderInput {
current_time: game.get_current_time(),
ct: content.clone(),
phys_img: phys_img.clone(),
player: player.clone(),
current_system: content.systems.values().next().unwrap().clone(),
timing: game.get_timing().clone(),
},
InputEvent::MouseMove(position.cast()),
)
.unwrap(); .unwrap();
game.apply_directive(directive, &player); game.apply_directive(directive, &input.player);
} }
WindowEvent::MouseInput { state, button, .. } => { WindowEvent::MouseInput { state, button, .. } => {
let down = state == &ElementState::Pressed; let down = state == &ElementState::Pressed;
@ -211,45 +200,21 @@ fn try_main() -> Result<()> {
_ => None, _ => None,
}; };
if let Some(event) = event { if let Some(event) = event {
let directive = gpu let directive = gpu.process_input(&input, event).unwrap();
.process_input( game.apply_directive(directive, &input.player);
RenderInput {
current_time: game.get_current_time(),
ct: content.clone(),
phys_img: phys_img.clone(),
player: player.clone(),
current_system: content
.systems
.values()
.next()
.unwrap()
.clone(),
timing: game.get_timing().clone(),
},
event,
)
.unwrap();
game.apply_directive(directive, &player);
} }
} }
WindowEvent::MouseWheel { delta, .. } => { WindowEvent::MouseWheel { delta, .. } => {
let directive = gpu let directive = gpu
.process_input( .process_input(
RenderInput { &input,
current_time: game.get_current_time(),
ct: content.clone(),
phys_img: phys_img.clone(),
player: player.clone(),
current_system: content.systems.values().next().unwrap().clone(),
timing: game.get_timing().clone(),
},
InputEvent::Scroll(match delta { InputEvent::Scroll(match delta {
MouseScrollDelta::LineDelta(_h, v) => *v, MouseScrollDelta::LineDelta(_h, v) => *v,
MouseScrollDelta::PixelDelta(v) => v.x as f32, MouseScrollDelta::PixelDelta(v) => v.x as f32,
}), }),
) )
.unwrap(); .unwrap();
game.apply_directive(directive, &player); game.apply_directive(directive, &input.player);
} }
WindowEvent::Resized(_) => { WindowEvent::Resized(_) => {
gpu.resize(&content); gpu.resize(&content);

9
crates/render/src/gpustate.rs
View File

@ -279,17 +279,14 @@ impl GPUState {
/// Handle user input /// Handle user input
pub fn process_input( pub fn process_input(
&mut self, &mut self,
input: RenderInput, input: &Arc<RenderInput>,
event: InputEvent, event: InputEvent,
) -> Result<PlayerDirective> { ) -> Result<PlayerDirective> {
let input = Arc::new(input);
self.ui.process_input(&mut self.state, input, event) self.ui.process_input(&mut self.state, input, event)
} }
/// Main render function. Draws sprites on a window. /// Main render function. Draws sprites on a window.
pub fn render(&mut self, input: RenderInput) -> Result<(), wgpu::SurfaceError> { pub fn render(&mut self, input: &Arc<RenderInput>) -> Result<(), wgpu::SurfaceError> {
let input = Arc::new(input);
if let Some(ship) = input.player.ship { if let Some(ship) = input.player.ship {
let o = input.phys_img.get_ship(&PhysSimShipHandle(ship)); let o = input.phys_img.get_ship(&PhysSimShipHandle(ship));
if let Some(o) = o { if let Some(o) = o {
@ -390,7 +387,7 @@ impl GPUState {
self.push_effects(&input, (clip_ne, clip_sw)); self.push_effects(&input, (clip_ne, clip_sw));
} }
self.ui.draw(&mut self.state, input.clone()).unwrap(); self.ui.draw(&mut self.state, input).unwrap();
// These should match the indices in each shader, // These should match the indices in each shader,
// and should each have a corresponding bind group layout. // and should each have a corresponding bind group layout.

4
crates/render/src/renderinput.rs
View File

@ -9,13 +9,13 @@ use galactica_util::timing::Timing;
#[derive(Debug)] #[derive(Debug)]
pub struct RenderInput { pub struct RenderInput {
/// Player ship data /// Player ship data
pub player: Arc<PlayerAgent>, pub player: PlayerAgent,
/// The system we're currently in /// The system we're currently in
pub current_system: Arc<System>, pub current_system: Arc<System>,
/// The world state to render /// The world state to render
pub phys_img: Arc<PhysImage>, pub phys_img: PhysImage,
// TODO: handle overflow. is it a problem? // TODO: handle overflow. is it a problem?
/// The current time, in seconds /// The current time, in seconds

2
crates/render/src/ui/api/mod.rs
View File

@ -38,7 +38,7 @@ pub fn register_into_engine(
.build_type::<PlayerShipStateEvent>() .build_type::<PlayerShipStateEvent>()
.build_type::<KeyboardEvent>() .build_type::<KeyboardEvent>()
.build_type::<ScrollEvent>() .build_type::<ScrollEvent>()
// Bigger modules // Enums
.register_type_with_name::<Anchor>("Anchor") .register_type_with_name::<Anchor>("Anchor")
.register_static_module("Anchor", exported_module!(anchor_mod).into()) .register_static_module("Anchor", exported_module!(anchor_mod).into())
.register_type_with_name::<PlayerDirective>("PlayerDirective") .register_type_with_name::<PlayerDirective>("PlayerDirective")

4
crates/render/src/ui/api/state.rs
View File

@ -241,9 +241,9 @@ unsafe impl Send for State {}
unsafe impl Sync for State {} unsafe impl Sync for State {}
impl State { impl State {
pub fn new(state: &RenderState, input: Arc<RenderInput>) -> Self { pub fn new(state: &RenderState, input: &Arc<RenderInput>) -> Self {
Self { Self {
input, input: input.clone(),
window_aspect: state.window_aspect, window_aspect: state.window_aspect,
} }
} }

97
crates/render/src/ui/elements/scrollbox.rs
View File

@ -1,17 +1,14 @@
use nalgebra::Vector2; use nalgebra::Vector2;
use rhai::{Dynamic, ImmutableString}; use rhai::{Dynamic, ImmutableString};
use std::{cell::RefCell, collections::HashMap, rc::Rc};
use winit::window::Window;
use super::{super::api::Rect, OwnedTextArea}; use super::super::api::Rect;
use crate::{ui::UiElement, InputEvent, RenderInput, RenderState}; use crate::{InputEvent, RenderInput, RenderState};
#[derive(Debug)] #[derive(Debug, Clone)]
pub struct UiScrollbox { pub struct UiScrollbox {
pub name: ImmutableString, pub name: ImmutableString,
pub rect: Rect, pub rect: Rect,
pub offset: Vector2<f32>, pub offset: Vector2<f32>,
pub elements: HashMap<ImmutableString, Rc<RefCell<UiElement>>>,
has_mouse: bool, has_mouse: bool,
} }
@ -21,31 +18,13 @@ impl UiScrollbox {
Self { Self {
name, name,
rect, rect,
elements: HashMap::new(),
offset: Vector2::new(0.0, 0.0), offset: Vector2::new(0.0, 0.0),
has_mouse: false, has_mouse: false,
} }
} }
pub fn add_element(&mut self, e: Rc<RefCell<UiElement>>) { pub fn step(&mut self, _t: f32) {
let name = e.borrow().get_name().clone(); // TODO: inertia
self.elements.insert(name, e);
}
pub fn remove_element(&mut self, sprite: &ImmutableString) {
self.elements.remove(sprite);
}
pub fn step(&mut self, t: f32) {
for (_name, e) in &self.elements {
match &mut *e.clone().borrow_mut() {
UiElement::Sprite(sprite) => sprite.step(t),
UiElement::RadialBar(_) => {}
UiElement::Text(..) => {}
UiElement::Scrollbox(..) => {}
UiElement::SubElement { .. } => {}
}
}
} }
pub fn handle_event( pub fn handle_event(
@ -54,31 +33,21 @@ impl UiScrollbox {
state: &mut RenderState, state: &mut RenderState,
event: &InputEvent, event: &InputEvent,
) -> Option<Dynamic> { ) -> Option<Dynamic> {
let r = self self.handle_event_with_offset(input, state, event, Vector2::new(0.0, 0.0))
}
pub fn handle_event_with_offset(
&mut self,
input: &RenderInput,
state: &mut RenderState,
event: &InputEvent,
offset: Vector2<f32>,
) -> Option<Dynamic> {
let mut r = self
.rect .rect
.to_centered(&state.window, input.ct.config.ui_scale); .to_centered(&state.window, input.ct.config.ui_scale);
r.pos += offset;
// TODO: handle only if used in event()
// i.e, scrollable sprites shouldn't break scrollboxes
// First, check if this event is captured by any sub-elements
for (_, e) in &mut self.elements {
let arg = match &mut *e.borrow_mut() {
UiElement::Sprite(sprite) => sprite.handle_event(&input, state, &event),
UiElement::Scrollbox(sbox) => sbox.handle_event(&input, state, &event),
UiElement::RadialBar(_) | UiElement::Text(..) => None,
// Subelements are intentionally skipped,
// they should be handled by their parent's `handle_event` method.
UiElement::SubElement { .. } => None,
};
if arg.is_some() {
return arg;
}
}
// If no inner events were captured, handle self events.
match event { match event {
InputEvent::MouseMove(pos) => { InputEvent::MouseMove(pos) => {
if r.contains_mouse(state, pos) && !self.has_mouse { if r.contains_mouse(state, pos) && !self.has_mouse {
@ -102,35 +71,3 @@ impl UiScrollbox {
return None; return None;
} }
} }
impl UiScrollbox {
pub fn push_to_buffer(&self, input: &RenderInput, state: &mut RenderState) {
for (_name, e) in &self.elements {
match &*e.clone().borrow() {
UiElement::Sprite(sprite) => {
sprite.push_to_buffer_with_offset(input, state, self.offset)
}
UiElement::RadialBar(..) => {}
UiElement::Text(..) => {}
UiElement::Scrollbox(..) => {}
UiElement::SubElement { .. } => {}
}
}
}
}
// TODO: don't allocate here
impl<'a> UiScrollbox {
pub fn get_textareas(&'a self, input: &RenderInput, window: &Window) -> Vec<OwnedTextArea> {
let mut v = Vec::with_capacity(32);
for e in self.elements.values() {
match &*e.clone().borrow() {
UiElement::Text(x) => {
v.push(x.get_textarea_with_offset(input, window, self.offset))
}
_ => {}
}
}
return v;
}
}

31
crates/render/src/ui/elements/sprite.rs
View File

@ -19,6 +19,9 @@ pub struct UiSprite {
/// Sprite angle, in degrees /// Sprite angle, in degrees
angle: f32, angle: f32,
/// If true, this sprite ignores all events
disable_events: bool,
/// If true, this sprite will be scaled to fit in its box without affecting aspect ratio. /// If true, this sprite will be scaled to fit in its box without affecting aspect ratio.
/// If false, this sprite will be stretched to fit in its box /// If false, this sprite will be stretched to fit in its box
preserve_aspect: bool, preserve_aspect: bool,
@ -43,6 +46,7 @@ impl UiSprite {
has_mouse: false, has_mouse: false,
has_click: false, has_click: false,
preserve_aspect: false, preserve_aspect: false,
disable_events: false,
} }
} }
@ -62,6 +66,10 @@ impl UiSprite {
self.color = color; self.color = color;
} }
pub fn set_disable_events(&mut self, disable_events: bool) {
self.disable_events = disable_events;
}
pub fn set_preserve_aspect(&mut self, preserve_aspect: bool) { pub fn set_preserve_aspect(&mut self, preserve_aspect: bool) {
self.preserve_aspect = preserve_aspect; self.preserve_aspect = preserve_aspect;
} }
@ -124,14 +132,24 @@ impl UiSprite {
state: &mut RenderState, state: &mut RenderState,
event: &InputEvent, event: &InputEvent,
) -> Option<Dynamic> { ) -> Option<Dynamic> {
let r = self self.handle_event_with_offset(input, state, event, Vector2::new(0.0, 0.0))
}
pub fn handle_event_with_offset(
&mut self,
input: &RenderInput,
state: &mut RenderState,
event: &InputEvent,
offset: Vector2<f32>,
) -> Option<Dynamic> {
if self.disable_events {
return None;
}
let mut r = self
.rect .rect
.to_centered(&state.window, input.ct.config.ui_scale); .to_centered(&state.window, input.ct.config.ui_scale);
r.pos += offset;
// Release mouse when cursor leaves box
if self.has_click && !self.has_mouse {
self.has_click = false;
}
match event { match event {
InputEvent::MouseMove(pos) => { InputEvent::MouseMove(pos) => {
@ -145,6 +163,7 @@ impl UiSprite {
if !r.contains_mouse(state, pos) && self.has_mouse { if !r.contains_mouse(state, pos) && self.has_mouse {
self.has_mouse = false; self.has_mouse = false;
self.has_click = false;
return Some(Dynamic::from(MouseHoverEvent { return Some(Dynamic::from(MouseHoverEvent {
enter: false, enter: false,
element: self.name.clone(), element: self.name.clone(),

2
crates/render/src/ui/elements/textbox.rs
View File

@ -10,7 +10,7 @@ use winit::window::Window;
use super::{super::api::Rect, OwnedTextArea}; use super::{super::api::Rect, OwnedTextArea};
use crate::{ui::api, RenderInput}; use crate::{ui::api, RenderInput};
#[derive(Debug)] #[derive(Debug, Clone)]
pub struct UiTextBox { pub struct UiTextBox {
pub name: ImmutableString, pub name: ImmutableString,

267
crates/render/src/ui/executor.rs
View File

@ -3,7 +3,7 @@ use galactica_content::Content;
use galactica_system::{phys::PhysSimShipHandle, PlayerDirective}; use galactica_system::{phys::PhysSimShipHandle, PlayerDirective};
use galactica_util::rhai_error_to_anyhow; use galactica_util::rhai_error_to_anyhow;
use log::{debug, error}; use log::{debug, error};
use rhai::{Dynamic, Engine, ImmutableString, Scope}; use rhai::{CallFnOptions, Dynamic, Engine, ImmutableString, Scope};
use std::{cell::RefCell, num::NonZeroU32, rc::Rc, sync::Arc}; use std::{cell::RefCell, num::NonZeroU32, rc::Rc, sync::Arc};
use winit::event::VirtualKeyCode; use winit::event::VirtualKeyCode;
@ -58,87 +58,119 @@ impl UiScriptExecutor {
pub fn process_input( pub fn process_input(
&mut self, &mut self,
state: &mut RenderState, state: &mut RenderState,
input: Arc<RenderInput>, input: &Arc<RenderInput>,
event: InputEvent, event: InputEvent,
) -> Result<PlayerDirective> { ) -> Result<PlayerDirective> {
let current_scene = (*self.state).borrow().get_scene().clone(); let current_scene = (*self.state).borrow().get_scene().clone();
if current_scene.is_none() { if current_scene.is_none() {
return Ok(PlayerDirective::None); return Ok(PlayerDirective::None);
} }
let mut arg: Option<Dynamic> = None;
// First, check if this event is captured by any ui elements. // First, check if this event is captured by any ui elements.
for (_, e) in &mut self.state.borrow_mut().elements { let len = (*self.state).borrow().len();
arg = match e { // Iterate front to back
// (this also ensures that sub-elements are handled BEFORE their container.)
for i in (0..len).rev() {
let mut ui_state = self.state.borrow_mut();
let arg = match ui_state.get_mut_by_idx(i).unwrap() {
UiElement::Sprite(sprite) => sprite.handle_event(&input, state, &event), UiElement::Sprite(sprite) => sprite.handle_event(&input, state, &event),
UiElement::Scrollbox(sbox) => sbox.handle_event(&input, state, &event), UiElement::Scrollbox(sbox) => sbox.handle_event(&input, state, &event),
UiElement::RadialBar(_) | UiElement::Text(..) => None, UiElement::RadialBar(_) | UiElement::Text(..) => None,
UiElement::SubElement { parent, element } => {
// Subelements are intentionally skipped, // Be very careful here, to avoid
// they should be handled by their parent's `handle_event` method. // borrowing mutably twice...
UiElement::SubElement { .. } => None, let e_name = element.get_name();
let p_name = parent.clone();
let parent = ui_state.get_by_name(&p_name).unwrap();
match parent {
UiElement::Scrollbox(sbox) => {
let offset = sbox.offset;
let element = ui_state.get_mut_by_name(&e_name).unwrap();
match element {
UiElement::SubElement { element, .. } => match &mut **element {
UiElement::Sprite(sprite) => sprite
.handle_event_with_offset(&input, state, &event, offset),
UiElement::Scrollbox(sbox) => {
sbox.handle_event_with_offset(&input, state, &event, offset)
}
UiElement::RadialBar(_) | UiElement::Text(..) => None,
UiElement::SubElement { .. } => unreachable!(),
},
_ => unreachable!(),
}
}
_ => unreachable!(),
}
}
}; };
drop(ui_state);
if arg.is_some() { // Return if event hook returns any PlayerDirective (including None),
break; // continue to the next element if the hook returns ().
if let Some(arg) = arg {
let result = self.run_event_callback(state, &input, arg)?;
if let Some(result) = result {
return Ok(result);
}
} }
} }
// If nothing was caught, check global events // If nothing was caught, check global events
if arg.is_none() { let arg = match event {
arg = match event { InputEvent::Scroll(val) => Some(Dynamic::from(ScrollEvent { val })),
InputEvent::Scroll(val) => Some(Dynamic::from(ScrollEvent { val })), InputEvent::Keyboard { down, key } => {
InputEvent::Keyboard { down, key } => { let str = match key {
let str = match key { VirtualKeyCode::A => Some("A"),
VirtualKeyCode::A => Some("A"), VirtualKeyCode::B => Some("B"),
VirtualKeyCode::B => Some("B"), VirtualKeyCode::C => Some("C"),
VirtualKeyCode::C => Some("C"), VirtualKeyCode::D => Some("D"),
VirtualKeyCode::D => Some("D"), VirtualKeyCode::E => Some("E"),
VirtualKeyCode::E => Some("E"), VirtualKeyCode::F => Some("F"),
VirtualKeyCode::F => Some("F"), VirtualKeyCode::G => Some("G"),
VirtualKeyCode::G => Some("G"), VirtualKeyCode::H => Some("H"),
VirtualKeyCode::H => Some("H"), VirtualKeyCode::I => Some("I"),
VirtualKeyCode::I => Some("I"), VirtualKeyCode::J => Some("J"),
VirtualKeyCode::J => Some("J"), VirtualKeyCode::K => Some("K"),
VirtualKeyCode::K => Some("K"), VirtualKeyCode::L => Some("L"),
VirtualKeyCode::L => Some("L"), VirtualKeyCode::M => Some("M"),
VirtualKeyCode::M => Some("M"), VirtualKeyCode::N => Some("N"),
VirtualKeyCode::N => Some("N"), VirtualKeyCode::O => Some("O"),
VirtualKeyCode::O => Some("O"), VirtualKeyCode::P => Some("P"),
VirtualKeyCode::P => Some("P"), VirtualKeyCode::Q => Some("Q"),
VirtualKeyCode::Q => Some("Q"), VirtualKeyCode::R => Some("R"),
VirtualKeyCode::R => Some("R"), VirtualKeyCode::S => Some("S"),
VirtualKeyCode::S => Some("S"), VirtualKeyCode::T => Some("T"),
VirtualKeyCode::T => Some("T"), VirtualKeyCode::U => Some("U"),
VirtualKeyCode::U => Some("U"), VirtualKeyCode::V => Some("V"),
VirtualKeyCode::V => Some("V"), VirtualKeyCode::W => Some("W"),
VirtualKeyCode::W => Some("W"), VirtualKeyCode::X => Some("X"),
VirtualKeyCode::X => Some("X"), VirtualKeyCode::Y => Some("Y"),
VirtualKeyCode::Y => Some("Y"), VirtualKeyCode::Z => Some("Z"),
VirtualKeyCode::Z => Some("Z"), VirtualKeyCode::Up => Some("up"),
VirtualKeyCode::Up => Some("up"), VirtualKeyCode::Down => Some("down"),
VirtualKeyCode::Down => Some("down"), VirtualKeyCode::Left => Some("left"),
VirtualKeyCode::Left => Some("left"), VirtualKeyCode::Right => Some("right"),
VirtualKeyCode::Right => Some("right"), VirtualKeyCode::Space => Some("space"),
VirtualKeyCode::Space => Some("space"), _ => None,
_ => None, };
}; if let Some(str) = str {
if let Some(str) = str { Some(Dynamic::from(KeyboardEvent {
Some(Dynamic::from(KeyboardEvent { down,
down, key: ImmutableString::from(str),
key: ImmutableString::from(str), }))
})) } else {
} else { None
None
}
} }
_ => None, }
}; _ => None,
} };
if let Some(arg) = arg { if let Some(arg) = arg {
self.run_event_callback(state, input, arg) Ok(self
.run_event_callback(state, &input, arg)?
.unwrap_or(PlayerDirective::None))
} else { } else {
return Ok(PlayerDirective::None); return Ok(PlayerDirective::None);
} }
@ -147,39 +179,42 @@ impl UiScriptExecutor {
fn run_event_callback( fn run_event_callback(
&mut self, &mut self,
state: &mut RenderState, state: &mut RenderState,
input: Arc<RenderInput>, input: &Arc<RenderInput>,
arg: Dynamic, arg: Dynamic,
) -> Result<PlayerDirective> { ) -> Result<Option<PlayerDirective>> {
let current_scene = (*self.state).borrow().get_scene().clone(); let current_scene = (*self.state).borrow().get_scene().clone();
if current_scene.is_none() { if current_scene.is_none() {
return Ok(PlayerDirective::None); return Ok(None);
} }
let current_scene = current_scene.unwrap(); let current_scene = current_scene.unwrap();
let ct = (*self.state).borrow().ct.clone(); let ct = (*self.state).borrow().ct.clone();
let ast = ct.config.ui_scenes.get(current_scene.as_str()).unwrap();
let d: Dynamic = rhai_error_to_anyhow(self.engine.call_fn( let d: Dynamic = rhai_error_to_anyhow::<Dynamic, _>(self.engine.call_fn_with_options(
CallFnOptions::new().rewind_scope(true),
&mut self.scope, &mut self.scope,
ct.config.ui_scenes.get(current_scene.as_str()).unwrap(), ast,
"event", "event",
(State::new(state, input.clone()), arg.clone()), (State::new(state, input), arg.clone()),
)) ))
.with_context(|| format!("while handling event `{:?}`", arg)) .with_context(|| format!("while calling `event()`"))
.with_context(|| format!("in ui scene `{}`", current_scene))?; .with_context(|| format!("in UI scene `{}`", current_scene.as_str()))?;
if d.is::<PlayerDirective>() { if d.is::<PlayerDirective>() {
return Ok(d.cast()); return Ok(Some(d.cast::<PlayerDirective>()));
} else if !(d.is_unit()) { } else if !(d.is_unit()) {
error!( error!(
"`event()` in UI scene `{current_scene}` returned invalid type `{}`", "`event()` in UI scene `{}` returned invalid type `{}`",
d d,
current_scene.as_str()
) )
} }
return Ok(PlayerDirective::None); return Ok(None);
} }
/// Change the current scene /// Change the current scene
pub fn set_scene(&mut self, state: &RenderState, input: Arc<RenderInput>) -> Result<()> { pub fn set_scene(&mut self, state: &RenderState, input: &Arc<RenderInput>) -> Result<()> {
let current_scene = (*self.state).borrow().get_scene().clone(); let current_scene = (*self.state).borrow().get_scene().clone();
if self.last_scene == current_scene { if self.last_scene == current_scene {
return Ok(()); return Ok(());
@ -195,33 +230,44 @@ impl UiScriptExecutor {
current_scene.as_ref().unwrap() current_scene.as_ref().unwrap()
); );
self.scope.clear();
// Drop this right away, since all script calls borrow elm mutably.
let mut elm = self.state.borrow_mut();
elm.clear();
drop(elm);
let ct = (*self.state).borrow().ct.clone(); let ct = (*self.state).borrow().ct.clone();
rhai_error_to_anyhow( let ast = ct
self.engine.call_fn( .config
&mut self.scope, .ui_scenes
ct.config .get(current_scene.as_ref().unwrap().as_str())
.ui_scenes .unwrap();
.get(current_scene.as_ref().unwrap().as_str())
.unwrap(), // Clear previous state
"init", self.scope.clear();
(State::new(state, input.clone()),), self.state.borrow_mut().clear();
),
) rhai_error_to_anyhow(self.engine.call_fn_with_options(
CallFnOptions::new().rewind_scope(false),
&mut self.scope,
ast,
"init",
(State::new(state, input),),
))
.with_context(|| format!("while running `init()`")) .with_context(|| format!("while running `init()`"))
.with_context(|| format!("in ui scene `{}`", current_scene.as_ref().unwrap()))?; .with_context(|| format!("in ui scene `{}`", current_scene.as_ref().unwrap()))?;
// Make sure input isn't borrowed (which would happen if the UI script adds a state class to the scope)
// At this point, the only reference to input should be the one in main.rs.
// Note how we always pass input as &Arc, not Arc.
if Arc::strong_count(&input) != 1 {
error!(
"State has been captured in the scope of UI scene `{}`",
current_scene.as_ref().unwrap()
);
error!("Clearing scope to prevent a panic, this may break the UI script.");
self.scope.clear();
};
return Ok(()); return Ok(());
} }
/// Draw all ui elements /// Draw all ui elements
pub fn draw(&mut self, state: &mut RenderState, input: Arc<RenderInput>) -> Result<()> { pub fn draw(&mut self, state: &mut RenderState, input: &Arc<RenderInput>) -> Result<()> {
let ct = (*self.state).borrow().ct.clone(); let ct = (*self.state).borrow().ct.clone();
// Initialize start scene if we haven't yet // Initialize start scene if we haven't yet
@ -230,10 +276,10 @@ impl UiScriptExecutor {
.borrow_mut() .borrow_mut()
.set_scene(ImmutableString::from(&ct.config.start_ui_scene)); .set_scene(ImmutableString::from(&ct.config.start_ui_scene));
} }
self.set_scene(state, input.clone())?; self.set_scene(state, input)?;
let current_scene = (*self.state).borrow().get_scene().clone(); let current_scene = (*self.state).borrow().get_scene().clone();
(*self.state).borrow_mut().step(state, input.clone()); (*self.state).borrow_mut().step(state, input);
// Run step() (if it is defined) // Run step() (if it is defined)
let ast = ct let ast = ct
@ -242,11 +288,12 @@ impl UiScriptExecutor {
.get(current_scene.as_ref().unwrap().as_str()) .get(current_scene.as_ref().unwrap().as_str())
.unwrap(); .unwrap();
if ast.iter_functions().any(|x| x.name == "step") { if ast.iter_functions().any(|x| x.name == "step") {
rhai_error_to_anyhow(self.engine.call_fn( rhai_error_to_anyhow(self.engine.call_fn_with_options(
CallFnOptions::new().rewind_scope(true),
&mut self.scope, &mut self.scope,
ast, ast,
"step", "step",
(State::new(state, input.clone()),), (State::new(state, input),),
)) ))
.with_context(|| format!("while calling `step()`")) .with_context(|| format!("while calling `step()`"))
.with_context(|| format!("in ui scene `{}`", current_scene.as_ref().unwrap()))?; .with_context(|| format!("in ui scene `{}`", current_scene.as_ref().unwrap()))?;
@ -271,12 +318,12 @@ impl UiScriptExecutor {
true true
} }
} { } {
self.run_event_callback(state, input.clone(), Dynamic::from(PlayerShipStateEvent {}))?; self.run_event_callback(state, &input, Dynamic::from(PlayerShipStateEvent {}))?;
} }
let len = (*self.state).borrow().len(); let len = (*self.state).borrow().len();
for i in 0..len { for i in 0..len {
match (*self.state).borrow_mut().get_mut_by_idx(i).unwrap() { match self.state.borrow().get_by_idx(i).unwrap() {
UiElement::Sprite(sprite) => { UiElement::Sprite(sprite) => {
sprite.push_to_buffer(&input, state); sprite.push_to_buffer(&input, state);
} }
@ -285,15 +332,27 @@ impl UiScriptExecutor {
x.push_to_buffer(&input, state); x.push_to_buffer(&input, state);
} }
UiElement::Scrollbox(x) => { UiElement::Scrollbox(_) => {}
x.push_to_buffer(&input, state); UiElement::Text(..) => {}
}
UiElement::SubElement { .. } | UiElement::Text(..) => {} UiElement::SubElement { element, parent } => {
match self.state.borrow().get_by_name(parent).unwrap() {
UiElement::Scrollbox(sbox) => match &**element {
UiElement::Sprite(sprite) => {
sprite.push_to_buffer_with_offset(input, state, sbox.offset)
}
UiElement::RadialBar(..) => {}
UiElement::Text(..) => {}
UiElement::Scrollbox(..) => {}
UiElement::SubElement { .. } => {}
},
_ => {}
}
}
} }
} }
self.scope.rewind(0); //self.scope.rewind(0);
return Ok(()); return Ok(());
} }
} }

88
crates/render/src/ui/state.rs
View File

@ -1,7 +1,7 @@
use galactica_content::Content; use galactica_content::Content;
use log::{debug, error}; use log::{debug, error};
use rhai::ImmutableString; use rhai::ImmutableString;
use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc, time::Instant}; use std::{collections::HashMap, sync::Arc, time::Instant};
use winit::window::Window; use winit::window::Window;
use super::{ use super::{
@ -10,7 +10,7 @@ use super::{
}; };
use crate::{RenderInput, RenderState}; use crate::{RenderInput, RenderState};
#[derive(Debug)] #[derive(Debug, Clone)]
pub enum UiElement { pub enum UiElement {
Sprite(UiSprite), Sprite(UiSprite),
RadialBar(UiRadialBar), RadialBar(UiRadialBar),
@ -20,7 +20,7 @@ pub enum UiElement {
/// This is a sub-element managed by another element /// This is a sub-element managed by another element
SubElement { SubElement {
parent: ImmutableString, parent: ImmutableString,
element: Rc<RefCell<UiElement>>, element: Box<UiElement>,
}, },
} }
@ -31,7 +31,7 @@ impl UiElement {
Self::RadialBar(x) => x.name.clone(), Self::RadialBar(x) => x.name.clone(),
Self::Text(x) => x.name.clone(), Self::Text(x) => x.name.clone(),
Self::Scrollbox(x) => x.name.clone(), Self::Scrollbox(x) => x.name.clone(),
Self::SubElement { element, .. } => element.borrow().get_name(), Self::SubElement { element, .. } => element.get_name(),
} }
} }
} }
@ -43,8 +43,11 @@ pub(crate) struct UiConfig {
} }
pub(crate) struct UiState { pub(crate) struct UiState {
pub elements: HashMap<ImmutableString, UiElement>, /// The Ui elements on the screen right now
pub names: Vec<ImmutableString>, elements: HashMap<ImmutableString, UiElement>,
/// Keeps track of element order
elements_ordered: Vec<ImmutableString>,
pub ct: Arc<Content>, pub ct: Arc<Content>,
current_scene: Option<ImmutableString>, current_scene: Option<ImmutableString>,
@ -68,7 +71,7 @@ impl UiState {
Self { Self {
ct, ct,
elements: HashMap::new(), elements: HashMap::new(),
names: Vec::new(), elements_ordered: Vec::new(),
current_scene: None, current_scene: None,
show_timings: true, show_timings: true,
@ -84,29 +87,32 @@ impl UiState {
pub fn clear(&mut self) { pub fn clear(&mut self) {
self.elements.clear(); self.elements.clear();
self.names.clear(); self.elements_ordered.clear();
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.elements.len() assert!(self.elements.len() == self.elements_ordered.len());
return self.elements.len();
} }
/* pub fn contains_name(&self, name: &ImmutableString) -> bool {
pub fn get_by_idx(&self, idx: usize) -> Option<&UiElement> { self.elements.contains_key(name)
self.elements.get(idx)
} }
pub fn get_by_name(&self, name: &ImmutableString) -> Option<&UiElement> { pub fn get_by_name(&self, name: &ImmutableString) -> Option<&UiElement> {
let idx = self.names.get(name); self.elements.get(name)
if idx.is_none() { }
pub fn get_by_idx(&self, idx: usize) -> Option<&UiElement> {
let name = self.elements_ordered.get(idx);
if name.is_none() {
return None; return None;
} }
self.get_by_idx(*idx.unwrap()) self.elements.get(name.unwrap())
} }
*/
pub fn get_mut_by_idx(&mut self, idx: usize) -> Option<&mut UiElement> { pub fn get_mut_by_idx(&mut self, idx: usize) -> Option<&mut UiElement> {
let name = self.names.get(idx); let name = self.elements_ordered.get(idx);
if name.is_none() { if name.is_none() {
return None; return None;
} }
@ -131,12 +137,19 @@ impl UiState {
self.current_scene = Some(scene); self.current_scene = Some(scene);
} }
pub fn step(&mut self, state: &mut RenderState, input: Arc<RenderInput>) { pub fn step(&mut self, state: &mut RenderState, input: &Arc<RenderInput>) {
let t = self.last_step.elapsed().as_secs_f32(); let t = self.last_step.elapsed().as_secs_f32();
for (_, e) in &mut self.elements { for (_, e) in &mut self.elements {
match e { match e {
UiElement::Sprite(sprite) => sprite.step(t), UiElement::Sprite(sprite) => sprite.step(t),
UiElement::Scrollbox(sbox) => sbox.step(t), UiElement::Scrollbox(sbox) => sbox.step(t),
UiElement::SubElement { element, .. } => match &mut **element {
UiElement::Sprite(sprite) => sprite.step(t),
UiElement::RadialBar(_) => {}
UiElement::Text(..) => {}
UiElement::Scrollbox(..) => {}
UiElement::SubElement { .. } => {}
},
_ => {} _ => {}
} }
} }
@ -149,34 +162,14 @@ impl UiState {
} }
pub fn add_element(&mut self, e: UiElement) { pub fn add_element(&mut self, e: UiElement) {
self.names.push(e.get_name().clone()); self.elements_ordered.push(e.get_name().clone());
self.elements.insert(e.get_name().clone(), e); self.elements.insert(e.get_name().clone(), e);
} }
// Remove an element from this sprite.
// This does NOT remove subelements from their parent sprites.
pub fn remove_element_incomplete(&mut self, name: &ImmutableString) -> Option<UiElement> {
let e = self.elements.remove(name);
self.names.retain(|x| *x != name);
return e;
}
// Remove an element from this sprite and from all subsprites. // Remove an element from this sprite and from all subsprites.
pub fn remove_element(&mut self, name: &ImmutableString) { pub fn remove_element(&mut self, name: &ImmutableString) {
let e = self.elements.remove(name); let _ = self.elements.remove(name);
self.names.retain(|x| *x != name); self.elements_ordered.retain(|x| *x != name);
match e {
Some(UiElement::SubElement { parent, element }) => {
let x = Rc::into_inner(element).unwrap().into_inner();
let parent = self.elements.get_mut(&parent).unwrap();
match parent {
UiElement::Scrollbox(s) => s.remove_element(&x.get_name()),
_ => unreachable!("invalid subelement parent"),
}
}
_ => {}
}
} }
} }
@ -196,7 +189,18 @@ impl<'a> UiState {
for e in self.elements.values() { for e in self.elements.values() {
match &e { match &e {
UiElement::Text(t) => v.push(t.get_textarea(input, window)), UiElement::Text(t) => v.push(t.get_textarea(input, window)),
UiElement::Scrollbox(b) => v.extend(b.get_textareas(input, window)), UiElement::SubElement { parent, element } => {
let parent = self.get_by_name(parent).unwrap();
match parent {
UiElement::Scrollbox(sbox) => match &**element {
UiElement::Text(x) => {
v.push(x.get_textarea_with_offset(input, window, sbox.offset))
}
_ => {}
},
_ => unreachable!(),
}
}
_ => {} _ => {}
} }
} }