galactica
/
Galactica
1
0
Fork 0
Code Issues Releases Activity

Compare commits

base: galactica:a86b57d85cf33e1ab03817432b124609cd575ac0
Branches Tags
galactica:master
..
compare: galactica:23451eeb4b35c405ce31358212d4d082b112fc4f
Branches Tags
galactica:master

No commits in common. "a86b57d85cf33e1ab03817432b124609cd575ac0" and "23451eeb4b35c405ce31358212d4d082b112fc4f" have entirely different histories.
a86b57d85c ... 23451eeb4b

21 changed files with 531 additions and 778 deletions
Show Stats Expand all files Collapse all files

5
TODO.md
View File

@ -1,11 +1,11 @@
# Specific projects
## Now:
- hide ui element
- zoom limits
- clean up content
- Clean up state api
- Clean up & document UI api
- Persistent variables in ui scripts
- Better planet icons
- Clean up scripting errors
- Mouse colliders
- Fade sprites and text in scrollbox
@ -14,7 +14,6 @@
- fps textbox positioning
## Small jobs
- Better planet icons in radar
- Clean up sprite content (and content in general)
- Check game version in config
- Fix window resizing

2
assets

@ -1 +1 @@
Subproject commit b8ea8c5a04c0216304a81ebf396b7320a709d6ed
Subproject commit 1400f7bb89f1190a11a7371bb23778881073a49f

18
content/sprite.toml
View File

@ -92,23 +92,7 @@ file = "ui/landscape/test.png"
file = "ui/landscape-mask.png"
[sprite."ui::outfitbg"]
start_at = "off:top"
section.off.top = "stop"
section.off.bot = "stop"
section.off.timing.duration = 0.5
section.off.frames = ["ui/outfitbg.png"]
section.hover.top = "stop"
section.hover.bot = "stop"
section.hover.timing.duration = 0.5
section.hover.frames = ["ui/outfitbg-hover.png"]
section.selected.top = "stop"
section.selected.bot = "stop"
section.selected.timing.duration = 0.5
section.selected.frames = ["ui/outfitbg-selected.png"]
section.hoverselected.top = "stop"
section.hoverselected.bot = "stop"
section.hoverselected.timing.duration = 0.5
section.hoverselected.frames = ["ui/outfitbg-hover-selected.png"]
file = "ui/outfit-bg.png"
[sprite."ui::outfitterbox"]
file = "ui/outfitter-box.png"

15
content/ui/flying.rhai
View File

@ -39,8 +39,6 @@ fn init(state) {
let radar_size = 150.0;
let radar_range = 4000.0;
let hide_range = 0.85;
let shrink_distance = 20.0;
sprite::add(
"radar",
@ -80,9 +78,9 @@ fn event(state, event) {
if type_of(event) == "PlayerShipStateEvent" {
if state.player_ship().is_landed() {
ui::go_to_scene("landed");
return PlayerDirective::None;
return;
}
return PlayerDirective::None;
return;
}
if type_of(event) == "ScrollEvent" {
@ -108,7 +106,6 @@ fn event(state, event) {
if event.key() == "L" && event.is_down() {
return PlayerDirective::Land;
}
return PlayerDirective::None;
}
}
@ -124,6 +121,10 @@ fn step(state) {
// TODO: share variables with init();
let radar_size = 150.0;
let radar_range = 4000.0;
let hide_range = 0.85;
let shrink_distance = 20.0;
let p_pos = state.player_ship().get_pos();
// Radar arrow
@ -284,8 +285,8 @@ fn step(state) {
// Window frame
{
let dx = (((ui::get_camera_zoom() / 2.0) * state.window_aspect()) / radar_range) * (radar_size / 2.0);
let dy = ((ui::get_camera_zoom() / 2.0) / radar_range) * (radar_size / 2.0);
let dx = (((state.camera_zoom() / 2.0) * state.window_aspect()) / radar_range) * (radar_size / 2.0);
let dy = ((state.camera_zoom() / 2.0) / radar_range) * (radar_size / 2.0);
sprite::set_rect("radar.frame.ne",
Rect(
(radar_size / 2.0 + 5) - dx,

31
content/ui/landed.rhai
View File

@ -1,4 +1,6 @@
fn init(state) {
let player = state.player_ship();
conf::show_starfield(true);
conf::show_phys(false);
@ -15,8 +17,8 @@ fn init(state) {
sprite::add(
"landscape",
{
if state.player_ship().is_landed() {
state.player_ship().landed_on().image();
if player.is_landed() {
player.landed_on().image();
} else {
"";
}
@ -38,9 +40,6 @@ fn init(state) {
Anchor::Center
)
);
// If this is not set, the button will
// not receive events
sprite::set_disable_events("frame", true);
textbox::add(
@ -55,8 +54,8 @@ fn init(state) {
textbox::align_center("title");
textbox::font_serif("title");
textbox::weight_bold("title");
if state.player_ship().is_landed() {
textbox::set_text("title", state.player_ship().landed_on().display_name());
if player.is_landed() {
textbox::set_text("title", player.landed_on().display_name());
}
textbox::add(
@ -69,8 +68,8 @@ fn init(state) {
Color(1.0, 1.0, 1.0, 1.0)
);
textbox::font_sans("desc");
if state.player_ship().is_landed() {
textbox::set_text("desc", state.player_ship().landed_on().desc());
if player.is_landed() {
textbox::set_text("desc", player.landed_on().desc());
}
}
@ -84,19 +83,19 @@ fn event(state, event) {
sprite::jump_to("button", "off:top", 0.1);
}
}
return PlayerDirective::None;
return;
}
if type_of(event) == "MouseClickEvent" {
if !event.is_down() {
return PlayerDirective::None;
return;
}
let element = event.element();
if element == "button" {
ui::go_to_scene("outfitter");
return PlayerDirective::None;
return;
}
return;
}
@ -104,7 +103,7 @@ fn event(state, event) {
if type_of(event) == "KeyboardEvent" {
if !event.is_down() {
return PlayerDirective::None;
return;
}
if event.key() == "L" {
@ -113,15 +112,15 @@ fn event(state, event) {
if event.key() == "O" {
ui::go_to_scene("outfitter");
return PlayerDirective::None;
return;
}
}
if type_of(event) == "PlayerShipStateEvent" {
if !state.player_ship().is_landed() {
ui::go_to_scene("flying");
return PlayerDirective::None;
return;
}
return PlayerDirective::None;
return;
}
}

149
content/ui/outfitter.rhai
View File

@ -163,6 +163,7 @@ fn init(state) {
// width should be calculated as a fraction of screen width
let scrollbox_rect = Rect(
222.0, -16.0, 470.0, 480.0,
Anchor::NorthWest,
@ -171,73 +172,68 @@ fn init(state) {
scrollbox::add("outfit_list", scrollbox_rect);
let selected_outfit = false;
let p = state.player_ship();
if p.is_landed() {
let s = "";
let x = scrollbox_rect.pos().x() + 45.0;
let y = scrollbox_rect.pos().y() - 45.0;
for xxx in ["1","2","3"] {
for i in p.landed_on().outfitter() {
s = s + i.display_name() + "\n";
{
// p cannot be saved in the global scope.
let p = state.player_ship();
if p.is_landed() {
let s = "";
let x = scrollbox_rect.pos().x() + 45.0;
let y = scrollbox_rect.pos().y() - 45.0;
for xxx in ["1","2","3"] {
for i in p.landed_on().outfitter() {
s = s + i.display_name() + "\n";
let thumb_name = "outfit.thumb." + i.index() + xxx;
let backg_name = "outfit.backg." + i.index() + xxx;
let title_name = "outfit.title." + i.index() + xxx;
let thumb_name = "outfit.thumb." + i.index() + xxx;
let backg_name = "outfit.backg." + i.index() + xxx;
let title_name = "outfit.title." + i.index() + xxx;
sprite::add(
backg_name,
"ui::outfitbg",
Rect(
x, y, 90.0, 90.0,
Anchor::Center,
Anchor::NorthWest
)
);
sprite::preserve_aspect(backg_name, true);
scrollbox::add_element("outfit_list", backg_name);
sprite::add(
backg_name,
"ui::outfitbg",
Rect(
x, y, 90.0, 90.0,
Anchor::Center,
Anchor::NorthWest
)
);
sprite::preserve_aspect(backg_name, true);
scrollbox::add_element("outfit_list", backg_name);
sprite::add(
thumb_name,
i.thumbnail(),
Rect(
x, y, 75.0, 75.0,
Anchor::Center,
Anchor::NorthWest
)
);
sprite::preserve_aspect(thumb_name, true);
scrollbox::add_element("outfit_list", thumb_name);
sprite::add(
thumb_name,
i.thumbnail(),
Rect(
x, y, 75.0, 75.0,
Anchor::Center,
Anchor::NorthWest
)
);
sprite::preserve_aspect(thumb_name, true);
scrollbox::add_element("outfit_list", thumb_name);
textbox::add(
title_name,
10.0, 10.0,
Rect(
x, y - 50.0, 90.0, 10.0,
Anchor::Center,
Anchor::NorthWest,
),
Color(1.0, 1.0, 1.0, 1.0)
);
textbox::font_sans(title_name);
textbox::align_center(title_name);
textbox::set_text(title_name, i.display_name());
scrollbox::add_element("outfit_list", title_name);
textbox::add(
title_name,
10.0, 10.0,
Rect(
x, y - 50.0, 90.0, 10.0,
Anchor::Center,
Anchor::NorthWest,
),
Color(1.0, 1.0, 1.0, 1.0)
);
textbox::font_sans(title_name);
textbox::align_center(title_name);
textbox::set_text(title_name, i.display_name());
scrollbox::add_element("outfit_list", title_name);
x = x + 120.0;
if x > (
scrollbox_rect.pos().x() + scrollbox_rect.dim().x() - 45.0
) {
x = scrollbox_rect.pos().x() + 45.0;
y = y - 120.0;
}
x = x + 120.0;
if x > (
scrollbox_rect.pos().x() + scrollbox_rect.dim().x() - 45.0
) {
x = scrollbox_rect.pos().x() + 45.0;
y = y - 120.0;
}
}
textbox::set_text("outfit_stats", s);
}
}
textbox::set_text("outfit_stats", s);
}
}
@ -252,51 +248,28 @@ fn event(state, event) {
sprite::jump_to("exit_button", "off:top", 0.1);
}
}
if element.starts_with("outfit.backg.") && element != selected_outfit {
if event.is_enter() {
sprite::jump_to(element, "hover:top", 0.1);
} else {
sprite::jump_to(element, "off:top", 0.1);
}
}
return PlayerDirective::None;
return;
}
// TODO: this occasionally breaks because of sprite ordering.
// Clicks go to se_box instead!
if type_of(event) == "MouseClickEvent" {
if !event.is_down() {
return PlayerDirective::None;
return;
}
print(event.element());
let element = event.element();
if element == "exit_button" {
ui::go_to_scene("landed");
return PlayerDirective::None;
return;
}
if element.starts_with("outfit.backg.") && element != selected_outfit {
if selected_outfit != false {
sprite::jump_to(selected_outfit, "off:top", 0.1);
}
sprite::jump_to(element, "selected:top", 0.1);
selected_outfit = element;
return PlayerDirective::None;
}
return;
}
if type_of(event) == "PlayerShipStateEvent" {
if !state.player_ship().is_landed() {
ui::go_to_scene("flying");
return;
}
return PlayerDirective::None;
return;
}
}

16
crates/content/src/lib.rs
View File

@ -12,7 +12,6 @@ use rhai::ImmutableString;
use serde::{Deserialize, Deserializer};
use smartstring::{LazyCompact, SmartString};
use std::{
borrow::Borrow,
collections::HashMap,
fmt::Display,
fs::File,
@ -131,20 +130,7 @@ pub struct ContentIndex(Arc<SmartString<LazyCompact>>);
impl From<ImmutableString> for ContentIndex {
fn from(value: ImmutableString) -> Self {
Self(Arc::new(value.into()))
}
}
impl From<ContentIndex> for ImmutableString {
fn from(value: ContentIndex) -> Self {
ImmutableString::from(Arc::into_inner(value.0).unwrap())
}
}
impl From<&ContentIndex> for ImmutableString {
fn from(value: &ContentIndex) -> Self {
let x: &SmartString<LazyCompact> = value.0.borrow();
ImmutableString::from(x.clone())
Self::new(&value)
}
}

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

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

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

@ -279,14 +279,17 @@ impl GPUState {
/// Handle user input
pub fn process_input(
&mut self,
input: &Arc<RenderInput>,
input: RenderInput,
event: InputEvent,
) -> Result<PlayerDirective> {
let input = Arc::new(input);
self.ui.process_input(&mut self.state, input, event)
}
/// Main render function. Draws sprites on a window.
pub fn render(&mut self, input: &Arc<RenderInput>) -> Result<(), wgpu::SurfaceError> {
pub fn render(&mut self, input: RenderInput) -> Result<(), wgpu::SurfaceError> {
let input = Arc::new(input);
if let Some(ship) = input.player.ship {
let o = input.phys_img.get_ship(&PhysSimShipHandle(ship));
if let Some(o) = o {
@ -387,7 +390,7 @@ impl GPUState {
self.push_effects(&input, (clip_ne, clip_sw));
}
self.ui.draw(&mut self.state, input).unwrap();
self.ui.draw(&mut self.state, input.clone()).unwrap();
// These should match the indices in each shader,
// 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)]
pub struct RenderInput {
/// Player ship data
pub player: PlayerAgent,
pub player: Arc<PlayerAgent>,
/// The system we're currently in
pub current_system: Arc<System>,
/// The world state to render
pub phys_img: PhysImage,
pub phys_img: Arc<PhysImage>,
// TODO: handle overflow. is it a problem?
/// The current time, in seconds

22
crates/render/src/ui/api/functions/radialbar.rs
View File

@ -14,10 +14,11 @@ pub fn build_radialbar_module(state_src: Rc<RefCell<UiState>>) -> Module {
.with_namespace(FnNamespace::Internal)
.set_into_module(
&mut module,
// TODO: fix ugly spaces
move |name: ImmutableString, stroke: f32, color: Color, rect: Rect| {
let mut ui_state = state.borrow_mut();
if ui_state.contains_name(&name) {
if ui_state.elements.contains_key(&name) {
error!("tried to make a radialbar using an existing name `{name}`");
return;
}
@ -37,23 +38,12 @@ pub fn build_radialbar_module(state_src: Rc<RefCell<UiState>>) -> Module {
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, val: f32| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::RadialBar(x) => x,
_ => {
error!("called `radialbar::set_val` on an invalid name `{name}`");
return;
}
},
Some(UiElement::RadialBar(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::RadialBar(x)) => x.set_val(val),
_ => {
error!("called `radialbar::set_val` on an invalid name `{name}`");
return;
error!("called `radialbar_set_val` on an invalid name `{name}`")
}
};
e.set_val(val);
}
});
return module;

69
crates/render/src/ui/api/functions/scrollbox.rs
View File

@ -15,7 +15,7 @@ pub fn build_scrollbox_module(state_src: Rc<RefCell<UiState>>) -> Module {
.set_into_module(&mut module, move |name: ImmutableString, rect: Rect| {
let mut ui_state = state.borrow_mut();
if ui_state.contains_name(&name) {
if ui_state.elements.contains_key(&name) {
error!("tried to make a scrollbox using an existing name `{name}`");
return;
}
@ -30,41 +30,44 @@ pub fn build_scrollbox_module(state_src: Rc<RefCell<UiState>>) -> Module {
&mut module,
move |name: ImmutableString, target: ImmutableString| {
let mut ui_state = state.borrow_mut();
// Make sure `name` is a scrollbox
match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Scrollbox(_) => {}
_ => {
error!("called `scrollbox::add_element` on an invalid name `{name}`");
return;
Some(UiElement::Scrollbox(_)) => {
match ui_state.get_mut_by_name(&target) {
Some(UiElement::Text(_)) | Some(UiElement::Sprite(_)) => {
let e = match ui_state.remove_element_incomplete(&target) {
Some(UiElement::Sprite(s)) => {
Rc::new(RefCell::new(UiElement::Sprite(s)))
}
Some(UiElement::Text(t)) => {
Rc::new(RefCell::new(UiElement::Text(t)))
}
_ => unreachable!(),
};
// Add a subelement pointing to this sprite
ui_state.add_element(UiElement::SubElement {
parent: name.clone(),
element: e.clone(),
});
// Add this sprite to a scrollbox
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Scrollbox(s)) => {
s.add_element(e);
}
_ => unreachable!(),
};
}
Some(_) => {
error!("cannot add `{name}` to scrollbox `{name}`, invalid type.")
}
None => {
error!("called `scrollbox::add_element` with a non-existing target `{target}`")
}
}
},
Some(UiElement::Scrollbox(_)) => {}
}
_ => {
error!("called `scrollbox::add_element` on an invalid name `{name}`");
return;
}
}
// Replace the target with a SubElement, without changing its position in the array.
match ui_state.get_mut_by_name(&target) {
Some(UiElement::Text(_)) | Some(UiElement::Sprite(_)) => {
let e = ui_state.get_mut_by_name(&target).unwrap();
let new = (*e).clone();
*e = UiElement::SubElement {
parent: name.clone(),
element: Box::new(new),
};
}
Some(_) => {
error!("cannot add `{name}` to scrollbox `{name}`, invalid type.")
}
None => {
error!(
"called `scrollbox::add_element` with a non-existing target `{target}`"
)
error!("called `scrollbox::add_element` on an invalid name `{name}`")
}
}
},

147
crates/render/src/ui/api/functions/sprite.rs
View File

@ -26,7 +26,7 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
return;
}
if ui_state.contains_name(&name) {
if ui_state.elements.contains_key(&name) {
error!("tried to make a sprite using an existing name `{name}`");
return;
}
@ -55,7 +55,7 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
if ui_state.contains_name(&name) {
if ui_state.elements.contains_key(&name) {
ui_state.remove_element(&name);
} else {
error!("called `sprite::remove` on an invalid name `{name}`")
@ -96,36 +96,29 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
move |name: ImmutableString, edge_name: ImmutableString, duration: f32| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::jump_to` on an invalid name `{name}`");
return;
}
},
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Sprite(x)) => {
let sprite = x.anim.get_sprite();
Some(UiElement::Sprite(x)) => x,
let edge =
resolve_edge_as_edge(&sprite.sections, edge_name.as_str(), duration);
let edge = match edge {
Err(_) => {
error!(
"called `sprite::jump_to` on an invalid edge `{}` on sprite `{}`",
edge_name, sprite.index
);
return;
}
Ok(s) => s,
};
x.anim.jump_to(&edge);
}
_ => {
error!("called `sprite::jump_to` on an invalid name `{name}`");
return;
error!("called `sprite::jump_to` on an invalid name `{name}`")
}
};
let sprite = e.anim.get_sprite();
let edge = resolve_edge_as_edge(&sprite.sections, edge_name.as_str(), duration);
let edge = match edge {
Err(_) => {
error!(
"called `sprite::jump_to` on an invalid edge `{}` on sprite `{}`",
edge_name, sprite.index
);
return;
}
Ok(s) => s,
};
e.anim.jump_to(&edge);
}
},
);
@ -134,22 +127,12 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, x: f32| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::set_angle` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Sprite(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Sprite(s)) => s.set_angle(x),
_ => {
error!("called `sprite::set_angle` on an invalid name `{name}`");
return;
error!("called `sprite::set_angle` on an invalid name `{name}`")
}
};
e.set_angle(x)
}
});
let state = state_src.clone();
@ -157,22 +140,12 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, x: Rect| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::set_rect` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Sprite(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Sprite(s)) => s.set_rect(x),
_ => {
error!("called `sprite::set_rect` on an invalid name `{name}`");
return;
error!("called `sprite::set_rect` on an invalid name `{name}`")
}
};
e.set_rect(x);
}
});
let state = state_src.clone();
@ -180,22 +153,12 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, x: Color| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::set_color` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Sprite(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Sprite(s)) => s.set_color(x),
_ => {
error!("called `sprite::set_color` on an invalid name `{name}`");
return;
error!("called `sprite::set_color` on an invalid name `{name}`")
}
};
e.set_color(x);
}
});
let state = state_src.clone();
@ -203,46 +166,12 @@ pub fn build_sprite_module(ct_src: Arc<Content>, state_src: Rc<RefCell<UiState>>
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, x: bool| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::preserve_aspect` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Sprite(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Sprite(s)) => s.set_preserve_aspect(x),
_ => {
error!("called `sprite::preserve_aspect` on an invalid name `{name}`");
return;
error!("called `sprite::set_preserve_aspect` on an invalid name `{name}`")
}
};
e.set_preserve_aspect(x);
}
});
let state = state_src.clone();
let _ = FuncRegistration::new("set_disable_events")
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString, x: bool| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Sprite(x) => x,
_ => {
error!("called `sprite::set_disable_events` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Sprite(x)) => x,
_ => {
error!("called `sprite::set_disable_events` on an invalid name `{name}`");
return;
}
};
e.set_disable_events(x);
});
return module;
}

240
crates/render/src/ui/api/functions/textbox.rs
View File

@ -27,7 +27,7 @@ pub fn build_textbox_module(
color: Color| {
let mut ui_state = state.borrow_mut();
if ui_state.contains_name(&name) {
if ui_state.elements.contains_key(&name) {
error!("tried to make a textbox using an existing name `{name}`");
return;
}
@ -51,24 +51,12 @@ pub fn build_textbox_module(
&mut module,
move |name: ImmutableString, text: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::set_text` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_text(&mut font.borrow_mut(), text.as_str()),
_ => {
error!("called `textbox::set_text` on an invalid name `{name}`");
return;
error!("called `textbox::set_text` on an invalid name `{name}`")
}
};
e.set_text(&mut font.borrow_mut(), text.as_str());
}
},
);
@ -78,24 +66,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::align_left` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_align(&mut font.borrow_mut(), Align::Left),
_ => {
error!("called `textbox::align_left` on an invalid name `{name}`");
return;
error!("called `textbox::align_left` on an invalid name `{name}`")
}
};
e.set_align(&mut font.borrow_mut(), Align::Left);
}
});
let state = state_src.clone();
@ -104,23 +80,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::align_right` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_align(&mut font.borrow_mut(), Align::Right),
_ => {
error!("called `textbox::align_right` on an invalid name `{name}`");
return;
error!("called `textbox::align_right` on an invalid name `{name}`")
}
};
e.set_align(&mut font.borrow_mut(), Align::Right);
}
});
let state = state_src.clone();
@ -129,23 +94,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::align_justify` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_align(&mut font.borrow_mut(), Align::Justified),
_ => {
error!("called `textbox::align_justify` on an invalid name `{name}`");
return;
error!("called `textbox::align_justify` on an invalid name `{name}`")
}
};
e.set_align(&mut font.borrow_mut(), Align::Justified);
}
});
let state = state_src.clone();
@ -154,23 +108,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::align_center` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_align(&mut font.borrow_mut(), Align::Center),
_ => {
error!("called `textbox::align_center` on an invalid name `{name}`");
return;
error!("called `textbox::align_center` on an invalid name `{name}`")
}
};
e.set_align(&mut font.borrow_mut(), Align::Center);
}
});
let state = state_src.clone();
@ -179,23 +122,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::weight_bold` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_weight(&mut font.borrow_mut(), Weight::BOLD),
_ => {
error!("called `textbox::weight_bold` on an invalid name `{name}`");
return;
error!("called `textbox::weight_bold` on an invalid name `{name}`")
}
};
e.set_weight(&mut font.borrow_mut(), Weight::BOLD);
}
});
let state = state_src.clone();
@ -204,23 +136,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::weight_normal` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_weight(&mut font.borrow_mut(), Weight::NORMAL),
_ => {
error!("called `textbox::weight_normal` on an invalid name `{name}`");
return;
error!("called `textbox::weight_normal` on an invalid name `{name}`")
}
};
e.set_weight(&mut font.borrow_mut(), Weight::NORMAL);
}
});
let state = state_src.clone();
@ -229,23 +150,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::font_serif` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_font(&mut font.borrow_mut(), FamilyOwned::Serif),
_ => {
error!("called `textbox::font_serif` on an invalid name `{name}`");
return;
error!("called `textbox::font_serif` on an invalid name `{name}`")
}
};
e.set_font(&mut font.borrow_mut(), FamilyOwned::Serif);
}
});
let state = state_src.clone();
@ -254,23 +164,14 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::font_sans` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
_ => {
error!("called `textbox::font_sans` on an invalid name `{name}`");
return;
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => {
x.set_font(&mut font.borrow_mut(), FamilyOwned::SansSerif)
}
};
e.set_font(&mut font.borrow_mut(), FamilyOwned::SansSerif);
_ => {
error!("called `textbox::font_sans` on an invalid name `{name}`")
}
}
});
let state = state_src.clone();
@ -279,23 +180,14 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::font_mono` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
_ => {
error!("called `textbox::font_mono` on an invalid name `{name}`");
return;
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => {
x.set_font(&mut font.borrow_mut(), FamilyOwned::Monospace)
}
};
e.set_font(&mut font.borrow_mut(), FamilyOwned::Monospace);
_ => {
error!("called `textbox::font_mono` on an invalid name `{name}`")
}
}
});
let state = state_src.clone();
@ -304,23 +196,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::style_normal` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_style(&mut font.borrow_mut(), Style::Normal),
_ => {
error!("called `textbox::style_normal` on an invalid name `{name}`");
return;
error!("called `textbox::style_normal` on an invalid name `{name}`")
}
};
e.set_style(&mut font.borrow_mut(), Style::Normal);
}
});
let state = state_src.clone();
@ -329,23 +210,12 @@ pub fn build_textbox_module(
.with_namespace(FnNamespace::Internal)
.set_into_module(&mut module, move |name: ImmutableString| {
let mut ui_state = state.borrow_mut();
let e = match ui_state.get_mut_by_name(&name) {
Some(UiElement::SubElement { element, .. }) => match &mut **element {
UiElement::Text(x) => x,
_ => {
error!("called `textbox::style_italic` on an invalid name `{name}`");
return;
}
},
Some(UiElement::Text(x)) => x,
match ui_state.get_mut_by_name(&name) {
Some(UiElement::Text(x)) => x.set_style(&mut font.borrow_mut(), Style::Italic),
_ => {
error!("called `textbox::style_italic` on an invalid name `{name}`");
return;
error!("called `textbox::style_italic` on an invalid name `{name}`")
}
};
e.set_style(&mut font.borrow_mut(), Style::Italic);
}
});
return module;

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

@ -38,7 +38,7 @@ pub fn register_into_engine(
.build_type::<PlayerShipStateEvent>()
.build_type::<KeyboardEvent>()
.build_type::<ScrollEvent>()
// Enums
// Bigger modules
.register_type_with_name::<Anchor>("Anchor")
.register_static_module("Anchor", exported_module!(anchor_mod).into())
.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 {}
impl State {
pub fn new(state: &RenderState, input: &Arc<RenderInput>) -> Self {
pub fn new(state: &RenderState, input: Arc<RenderInput>) -> Self {
Self {
input: input.clone(),
input,
window_aspect: state.window_aspect,
}
}

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

@ -1,14 +1,17 @@
use nalgebra::Vector2;
use rhai::{Dynamic, ImmutableString};
use std::{cell::RefCell, collections::HashMap, rc::Rc};
use winit::window::Window;
use super::super::api::Rect;
use crate::{InputEvent, RenderInput, RenderState};
use super::{super::api::Rect, OwnedTextArea};
use crate::{ui::UiElement, InputEvent, RenderInput, RenderState};
#[derive(Debug, Clone)]
#[derive(Debug)]
pub struct UiScrollbox {
pub name: ImmutableString,
pub rect: Rect,
pub offset: Vector2<f32>,
pub elements: HashMap<ImmutableString, Rc<RefCell<UiElement>>>,
has_mouse: bool,
}
@ -18,13 +21,31 @@ impl UiScrollbox {
Self {
name,
rect,
elements: HashMap::new(),
offset: Vector2::new(0.0, 0.0),
has_mouse: false,
}
}
pub fn step(&mut self, _t: f32) {
// TODO: inertia
pub fn add_element(&mut self, e: Rc<RefCell<UiElement>>) {
let name = e.borrow().get_name().clone();
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(
@ -33,21 +54,31 @@ impl UiScrollbox {
state: &mut RenderState,
event: &InputEvent,
) -> Option<Dynamic> {
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
let r = self
.rect
.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 {
InputEvent::MouseMove(pos) => {
if r.contains_mouse(state, pos) && !self.has_mouse {
@ -71,3 +102,35 @@ impl UiScrollbox {
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,9 +19,6 @@ pub struct UiSprite {
/// Sprite angle, in degrees
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 false, this sprite will be stretched to fit in its box
preserve_aspect: bool,
@ -46,7 +43,6 @@ impl UiSprite {
has_mouse: false,
has_click: false,
preserve_aspect: false,
disable_events: false,
}
}
@ -66,10 +62,6 @@ impl UiSprite {
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) {
self.preserve_aspect = preserve_aspect;
}
@ -132,24 +124,14 @@ impl UiSprite {
state: &mut RenderState,
event: &InputEvent,
) -> Option<Dynamic> {
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
let r = self
.rect
.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 {
InputEvent::MouseMove(pos) => {
@ -163,7 +145,6 @@ impl UiSprite {
if !r.contains_mouse(state, pos) && self.has_mouse {
self.has_mouse = false;
self.has_click = false;
return Some(Dynamic::from(MouseHoverEvent {
enter: false,
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 crate::{ui::api, RenderInput};
#[derive(Debug, Clone)]
#[derive(Debug)]
pub struct UiTextBox {
pub name: ImmutableString,

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

@ -3,7 +3,7 @@ use galactica_content::Content;
use galactica_system::{phys::PhysSimShipHandle, PlayerDirective};
use galactica_util::rhai_error_to_anyhow;
use log::{debug, error};
use rhai::{CallFnOptions, Dynamic, Engine, ImmutableString, Scope};
use rhai::{Dynamic, Engine, ImmutableString, Scope};
use std::{cell::RefCell, num::NonZeroU32, rc::Rc, sync::Arc};
use winit::event::VirtualKeyCode;
@ -58,119 +58,87 @@ impl UiScriptExecutor {
pub fn process_input(
&mut self,
state: &mut RenderState,
input: &Arc<RenderInput>,
input: Arc<RenderInput>,
event: InputEvent,
) -> Result<PlayerDirective> {
let current_scene = (*self.state).borrow().get_scene().clone();
if current_scene.is_none() {
return Ok(PlayerDirective::None);
}
let mut arg: Option<Dynamic> = None;
// First, check if this event is captured by any ui elements.
let len = (*self.state).borrow().len();
// 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() {
for (_, e) in &mut self.state.borrow_mut().elements {
arg = match e {
UiElement::Sprite(sprite) => sprite.handle_event(&input, state, &event),
UiElement::Scrollbox(sbox) => sbox.handle_event(&input, state, &event),
UiElement::RadialBar(_) | UiElement::Text(..) => None,
UiElement::SubElement { parent, element } => {
// Be very careful here, to avoid
// borrowing mutably twice...
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!(),
}
}
// Subelements are intentionally skipped,
// they should be handled by their parent's `handle_event` method.
UiElement::SubElement { .. } => None,
};
drop(ui_state);
// Return if event hook returns any PlayerDirective (including None),
// 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 arg.is_some() {
break;
}
}
// If nothing was caught, check global events
let arg = match event {
InputEvent::Scroll(val) => Some(Dynamic::from(ScrollEvent { val })),
InputEvent::Keyboard { down, key } => {
let str = match key {
VirtualKeyCode::A => Some("A"),
VirtualKeyCode::B => Some("B"),
VirtualKeyCode::C => Some("C"),
VirtualKeyCode::D => Some("D"),
VirtualKeyCode::E => Some("E"),
VirtualKeyCode::F => Some("F"),
VirtualKeyCode::G => Some("G"),
VirtualKeyCode::H => Some("H"),
VirtualKeyCode::I => Some("I"),
VirtualKeyCode::J => Some("J"),
VirtualKeyCode::K => Some("K"),
VirtualKeyCode::L => Some("L"),
VirtualKeyCode::M => Some("M"),
VirtualKeyCode::N => Some("N"),
VirtualKeyCode::O => Some("O"),
VirtualKeyCode::P => Some("P"),
VirtualKeyCode::Q => Some("Q"),
VirtualKeyCode::R => Some("R"),
VirtualKeyCode::S => Some("S"),
VirtualKeyCode::T => Some("T"),
VirtualKeyCode::U => Some("U"),
VirtualKeyCode::V => Some("V"),
VirtualKeyCode::W => Some("W"),
VirtualKeyCode::X => Some("X"),
VirtualKeyCode::Y => Some("Y"),
VirtualKeyCode::Z => Some("Z"),
VirtualKeyCode::Up => Some("up"),
VirtualKeyCode::Down => Some("down"),
VirtualKeyCode::Left => Some("left"),
VirtualKeyCode::Right => Some("right"),
VirtualKeyCode::Space => Some("space"),
_ => None,
};
if let Some(str) = str {
Some(Dynamic::from(KeyboardEvent {
down,
key: ImmutableString::from(str),
}))
} else {
None
if arg.is_none() {
arg = match event {
InputEvent::Scroll(val) => Some(Dynamic::from(ScrollEvent { val })),
InputEvent::Keyboard { down, key } => {
let str = match key {
VirtualKeyCode::A => Some("A"),
VirtualKeyCode::B => Some("B"),
VirtualKeyCode::C => Some("C"),
VirtualKeyCode::D => Some("D"),
VirtualKeyCode::E => Some("E"),
VirtualKeyCode::F => Some("F"),
VirtualKeyCode::G => Some("G"),
VirtualKeyCode::H => Some("H"),
VirtualKeyCode::I => Some("I"),
VirtualKeyCode::J => Some("J"),
VirtualKeyCode::K => Some("K"),
VirtualKeyCode::L => Some("L"),
VirtualKeyCode::M => Some("M"),
VirtualKeyCode::N => Some("N"),
VirtualKeyCode::O => Some("O"),
VirtualKeyCode::P => Some("P"),
VirtualKeyCode::Q => Some("Q"),
VirtualKeyCode::R => Some("R"),
VirtualKeyCode::S => Some("S"),
VirtualKeyCode::T => Some("T"),
VirtualKeyCode::U => Some("U"),
VirtualKeyCode::V => Some("V"),
VirtualKeyCode::W => Some("W"),
VirtualKeyCode::X => Some("X"),
VirtualKeyCode::Y => Some("Y"),
VirtualKeyCode::Z => Some("Z"),
VirtualKeyCode::Up => Some("up"),
VirtualKeyCode::Down => Some("down"),
VirtualKeyCode::Left => Some("left"),
VirtualKeyCode::Right => Some("right"),
VirtualKeyCode::Space => Some("space"),
_ => None,
};
if let Some(str) = str {
Some(Dynamic::from(KeyboardEvent {
down,
key: ImmutableString::from(str),
}))
} else {
None
}
}
}
_ => None,
};
_ => None,
};
}
if let Some(arg) = arg {
Ok(self
.run_event_callback(state, &input, arg)?
.unwrap_or(PlayerDirective::None))
self.run_event_callback(state, input, arg)
} else {
return Ok(PlayerDirective::None);
}
@ -179,42 +147,39 @@ impl UiScriptExecutor {
fn run_event_callback(
&mut self,
state: &mut RenderState,
input: &Arc<RenderInput>,
input: Arc<RenderInput>,
arg: Dynamic,
) -> Result<Option<PlayerDirective>> {
) -> Result<PlayerDirective> {
let current_scene = (*self.state).borrow().get_scene().clone();
if current_scene.is_none() {
return Ok(None);
return Ok(PlayerDirective::None);
}
let current_scene = current_scene.unwrap();
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::<Dynamic, _>(self.engine.call_fn_with_options(
CallFnOptions::new().rewind_scope(true),
let d: Dynamic = rhai_error_to_anyhow(self.engine.call_fn(
&mut self.scope,
ast,
ct.config.ui_scenes.get(current_scene.as_str()).unwrap(),
"event",
(State::new(state, input), arg.clone()),
(State::new(state, input.clone()), arg.clone()),
))
.with_context(|| format!("while calling `event()`"))
.with_context(|| format!("in UI scene `{}`", current_scene.as_str()))?;
.with_context(|| format!("while handling event `{:?}`", arg))
.with_context(|| format!("in ui scene `{}`", current_scene))?;
if d.is::<PlayerDirective>() {
return Ok(Some(d.cast::<PlayerDirective>()));
return Ok(d.cast());
} else if !(d.is_unit()) {
error!(
"`event()` in UI scene `{}` returned invalid type `{}`",
d,
current_scene.as_str()
"`event()` in UI scene `{current_scene}` returned invalid type `{}`",
d
)
}
return Ok(None);
return Ok(PlayerDirective::None);
}
/// 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();
if self.last_scene == current_scene {
return Ok(());
@ -230,44 +195,33 @@ impl UiScriptExecutor {
current_scene.as_ref().unwrap()
);
let ct = (*self.state).borrow().ct.clone();
let ast = ct
.config
.ui_scenes
.get(current_scene.as_ref().unwrap().as_str())
.unwrap();
// Clear previous state
self.scope.clear();
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),),
))
// 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();
rhai_error_to_anyhow(
self.engine.call_fn(
&mut self.scope,
ct.config
.ui_scenes
.get(current_scene.as_ref().unwrap().as_str())
.unwrap(),
"init",
(State::new(state, input.clone()),),
),
)
.with_context(|| format!("while running `init()`"))
.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(());
}
/// 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();
// Initialize start scene if we haven't yet
@ -276,10 +230,10 @@ impl UiScriptExecutor {
.borrow_mut()
.set_scene(ImmutableString::from(&ct.config.start_ui_scene));
}
self.set_scene(state, input)?;
self.set_scene(state, input.clone())?;
let current_scene = (*self.state).borrow().get_scene().clone();
(*self.state).borrow_mut().step(state, input);
(*self.state).borrow_mut().step(state, input.clone());
// Run step() (if it is defined)
let ast = ct
@ -288,12 +242,11 @@ impl UiScriptExecutor {
.get(current_scene.as_ref().unwrap().as_str())
.unwrap();
if ast.iter_functions().any(|x| x.name == "step") {
rhai_error_to_anyhow(self.engine.call_fn_with_options(
CallFnOptions::new().rewind_scope(true),
rhai_error_to_anyhow(self.engine.call_fn(
&mut self.scope,
ast,
"step",
(State::new(state, input),),
(State::new(state, input.clone()),),
))
.with_context(|| format!("while calling `step()`"))
.with_context(|| format!("in ui scene `{}`", current_scene.as_ref().unwrap()))?;
@ -318,12 +271,12 @@ impl UiScriptExecutor {
true
}
} {
self.run_event_callback(state, &input, Dynamic::from(PlayerShipStateEvent {}))?;
self.run_event_callback(state, input.clone(), Dynamic::from(PlayerShipStateEvent {}))?;
}
let len = (*self.state).borrow().len();
for i in 0..len {
match self.state.borrow().get_by_idx(i).unwrap() {
match (*self.state).borrow_mut().get_mut_by_idx(i).unwrap() {
UiElement::Sprite(sprite) => {
sprite.push_to_buffer(&input, state);
}
@ -332,27 +285,15 @@ impl UiScriptExecutor {
x.push_to_buffer(&input, state);
}
UiElement::Scrollbox(_) => {}
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 { .. } => {}
},
_ => {}
}
UiElement::Scrollbox(x) => {
x.push_to_buffer(&input, state);
}
UiElement::SubElement { .. } | UiElement::Text(..) => {}
}
}
//self.scope.rewind(0);
self.scope.rewind(0);
return Ok(());
}
}

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

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