TODO.md

@@ -1,9 +1,5 @@
 # Specific projects
 
-## Now:
-- renderer scenes
-- outfitter
-
 ## Small jobs
 - 🌟 Better planet desc formatting
 - Procedural suns

crates/playeragent/src/inputstatus.rs

@@ -16,7 +16,7 @@ pub struct InputStatus {
 	key_guns: bool,
 	key_leftclick: bool,
 
-	// One-shot keys (automatically released at the end of each frame)
+	// One-shot keys (audomatically released at the end of each frame)
 	key_land: bool,
 	v_scroll: f32,
 }
@@ -137,11 +137,6 @@ impl InputStatus {
 		self.key_guns
 	}
 
-	/// Is the player pressing the left mouse button?
-	pub fn pressed_leftclick(&self) -> bool {
-		self.key_leftclick
-	}
-
 	/// Has the player pressed the "land" key?
 	/// (One-shot, reset to false at the start of each frame)
 	pub fn pressed_land(&self) -> bool {

crates/render/src/gpustate/render.rs

@@ -111,7 +111,7 @@ impl<'a> super::GPUState {
 			0..self.state.get_radialbar_counter(),
 		);
 
-		let textareas = self.ui.get_textareas(input, &self.state);
+		let textareas = self.ui.get_textareas_flying(input, &self.state);
 		self.state
 			.text_renderer
 			.prepare(
@@ -219,7 +219,7 @@ impl<'a> super::GPUState {
 			0..self.state.get_radialbar_counter(),
 		);
 
-		let textareas = self.ui.get_textareas(input, &self.state);
+		let textareas = self.ui.get_textareas_landed(input, &self.state);
 		self.state
 			.text_renderer
 			.prepare(
@@ -281,7 +281,6 @@ impl<'a> super::GPUState {
 		);
 
 		self.state.frame_reset();
-		self.ui.update_state(&input, &mut self.state);
 
 		match input
 			.phys_img

crates/render/src/ui/manager.rs

@@ -1,121 +1,29 @@
-use std::fmt::Debug;
-
 use galactica_content::Content;
 use galactica_system::{data::ShipState, phys::PhysSimShipHandle};
 use glyphon::TextArea;
-use log::info;
 
-use super::scenes::{FlyingScene, LandedScene, OutfitterScene};
+use super::{fpsindicator::FpsIndicator, planet::Planet, radar::Radar, status::Status};
 use crate::{RenderInput, RenderState};
 
-/// Output from a ui scene step
-pub struct UiSceneStepResult {
-	/// If Some, switch to this scene
-	pub new_scene: Option<UiScenes>,
-}
-
-pub trait UiScene<'this>
-where
-	Self: 'this,
-{
-	/// Draw this scene
-	fn draw(&mut self, input: &RenderInput, state: &mut RenderState);
-
-	/// Update this scene's state for this frame.
-	/// Handles clicks, keys, etc.
-	fn step(&mut self, input: &RenderInput, state: &mut RenderState) -> UiSceneStepResult;
-
-	fn get_textareas(
-		&'this self,
-		v: &mut Vec<TextArea<'this>>,
-		input: &RenderInput,
-		state: &RenderState,
-	);
-}
-
-pub(super) enum UiScenes {
-	Landed(LandedScene),
-	Flying(FlyingScene),
-	Outfitter(OutfitterScene),
-}
-
-impl Debug for UiScenes {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self {
-			Self::Flying(_) => write!(f, "UiScenes::Flying"),
-			Self::Landed(_) => write!(f, "UiScenes::Landed"),
-			Self::Outfitter(_) => write!(f, "UiScenes::Outfitter"),
-		}
-	}
-}
-
-impl UiScenes {
-	fn is_flying(&self) -> bool {
-		match self {
-			Self::Flying(_) => true,
-			_ => false,
-		}
-	}
-
-	fn is_landed(&self) -> bool {
-		match self {
-			Self::Landed(_) => true,
-			_ => false,
-		}
-	}
-
-	fn is_outfitter(&self) -> bool {
-		match self {
-			Self::Outfitter(_) => true,
-			_ => false,
-		}
-	}
-}
-
-impl<'a> UiScene<'a> for UiScenes {
-	fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
-		match self {
-			Self::Flying(s) => s.draw(input, state),
-			Self::Landed(s) => s.draw(input, state),
-			Self::Outfitter(s) => s.draw(input, state),
-		}
-	}
-
-	fn step(&mut self, input: &RenderInput, state: &mut RenderState) -> UiSceneStepResult {
-		match self {
-			Self::Flying(s) => s.step(input, state),
-			Self::Landed(s) => s.step(input, state),
-			Self::Outfitter(s) => s.step(input, state),
-		}
-	}
-
-	fn get_textareas(
-		&'a self,
-		v: &mut Vec<TextArea<'a>>,
-		input: &RenderInput,
-		state: &RenderState,
-	) {
-		match self {
-			Self::Flying(s) => s.get_textareas(v, input, state),
-			Self::Landed(s) => s.get_textareas(v, input, state),
-			Self::Outfitter(s) => s.get_textareas(v, input, state),
-		}
-	}
-}
-
 pub struct UiManager {
-	current_scene: UiScenes,
+	radar: Radar,
+	status: Status,
+	fps: FpsIndicator,
+	planet: Planet,
 }
 
 impl UiManager {
 	pub fn new(ct: &Content, state: &mut RenderState) -> Self {
 		Self {
-			current_scene: UiScenes::Flying(FlyingScene::new(ct, state)),
+			planet: Planet::new(ct, state),
+			radar: Radar::new(),
+			status: Status::new(),
+			fps: FpsIndicator::new(state),
 		}
 	}
 
-	// TODO: remove this.
+	/// Draw all ui elements
-	pub fn update_state(&mut self, input: &RenderInput, state: &mut RenderState) {
+	pub fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
 		let ship_handle = input.player.ship.unwrap();
 		let ship = &input
 			.phys_img
@@ -123,44 +31,41 @@ impl UiManager {
 			.unwrap()
 			.ship;
 
+		self.fps.update(input, state);
+
 		match ship.get_data().get_state() {
 			ShipState::Collapsing
 			| ShipState::Dead
 			| ShipState::Flying { .. }
 			| ShipState::Landing { .. }
 			| ShipState::UnLanding { .. } => {
-				if !self.current_scene.is_flying() {
+				self.radar.draw(input, state);
-					self.current_scene = UiScenes::Flying(FlyingScene::new(input.ct, state));
+				self.status.draw(input, state);
-				}
 			}
 
 			ShipState::Landed { .. } => {
-				if !self.current_scene.is_landed() && !self.current_scene.is_outfitter() {
+				self.planet.draw(input, state);
-					self.current_scene = UiScenes::Landed(LandedScene::new(input.ct, state))
 			}
 		}
 	}
-	}
-
-	/// Draw all ui elements
-	pub fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
-		loop {
-			let r = self.current_scene.step(input, state);
-			if let Some(new_state) = r.new_scene {
-				info!("switching to {:?}", new_state);
-				self.current_scene = new_state;
-			} else {
-				break;
-			}
-		}
-
-		self.current_scene.draw(input, state);
-	}
 
 	/// Textareas to show while player is flying
-	pub fn get_textareas(&self, input: &RenderInput, state: &RenderState) -> Vec<TextArea> {
+	pub fn get_textareas_flying(
+		&self,
+		_input: &RenderInput,
+		_state: &RenderState,
+	) -> Vec<TextArea> {
 		let mut v = Vec::with_capacity(5);
-		self.current_scene.get_textareas(&mut v, input, state);
+		v.push(self.fps.get_textarea());
+
+		return v;
+	}
+
+	/// Textareas to show when player is landed
+	pub fn get_textareas_landed(&self, input: &RenderInput, state: &RenderState) -> Vec<TextArea> {
+		let mut v = Vec::with_capacity(5);
+		v.extend(self.planet.get_textarea(input, state));
+
 		return v;
 	}
 }

crates/render/src/ui/mod.rs

@@ -1,5 +1,8 @@
+mod fpsindicator;
 mod manager;
-mod scenes;
+mod planet;
+mod radar;
+mod status;
 mod util;
 
 pub use manager::UiManager;

crates/render/src/ui/planet.rs

@@ -3,20 +3,13 @@ use galactica_system::{data::ShipState, phys::PhysSimShipHandle};
 use glyphon::{cosmic_text::Align, Attrs, Color, Metrics, TextArea, Weight};
 use nalgebra::{Point2, Vector2};
 
-use crate::{
+use super::util::{SpriteRect, UiSprite, UiTextArea};
-	ui::{
+use crate::{RenderInput, RenderState};
-		manager::{UiScene, UiSceneStepResult, UiScenes},
-		util::{SpriteRect, UiSprite, UiTextArea},
-	},
-	RenderInput, RenderState,
-};
 
-use super::OutfitterScene;
+pub(super) struct Planet {
-
-pub struct LandedScene {
 	// UI elements
-	description: UiTextArea,
+	planet_desc: UiTextArea,
-	title: UiTextArea,
+	planet_name: UiTextArea,
 	frame: UiSprite,
 	landscape: UiSprite,
 	button: UiSprite,
@@ -24,13 +17,11 @@ pub struct LandedScene {
 	/// What object we're displaying currently.
 	/// Whenever this changes, we need to reflow text.
 	current_object: Option<SystemObjectHandle>,
-
-	/// True if we've caught a left click event.
-	/// Used for edge detection.
-	leftclick_down: bool,
 }
 
-impl LandedScene {
+// TODO: animate in/out
+
+impl Planet {
 	pub fn new(ct: &Content, state: &mut RenderState) -> Self {
 		let frame = UiSprite::from(ct, &ct.get_ui().landed_frame);
 		let button = UiSprite::from(ct, &ct.get_ui().landed_button);
@@ -43,9 +34,8 @@ impl LandedScene {
 		let s = Self {
 			// height of element in logical pixels
 			current_object: None,
-			leftclick_down: false,
 
-			description: UiTextArea::new(
+			planet_desc: UiTextArea::new(
 				ct,
 				state,
 				frame.get_sprite(),
@@ -60,7 +50,7 @@ impl LandedScene {
 				Align::Left,
 			),
 
-			title: UiTextArea::new(
+			planet_name: UiTextArea::new(
 				ct,
 				state,
 				frame.get_sprite(),
@@ -82,9 +72,11 @@ impl LandedScene {
 
 		return s;
 	}
+}
 
+impl Planet {
 	fn reflow(&mut self, planet: &SystemObject, state: &mut RenderState) {
-		self.description.set_text(
+		self.planet_desc.set_text(
 			state,
 			&planet.desc,
 			Attrs::new()
@@ -92,7 +84,7 @@ impl LandedScene {
 				.family(glyphon::Family::SansSerif),
 		);
 
-		self.title.set_text(
+		self.planet_name.set_text(
 			state,
 			&planet.name,
 			Attrs::new()
@@ -101,29 +93,8 @@ impl LandedScene {
 		);
 		self.current_object = Some(planet.handle);
 	}
-}
 
-impl<'this> UiScene<'this> for LandedScene {
+	pub fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
-	fn step(&mut self, input: &RenderInput, state: &mut RenderState) -> UiSceneStepResult {
-		let frame_rect = Some(self.frame.get_rect(input));
-		self.button.step(input, state, frame_rect);
-		self.landscape.step(input, state, frame_rect);
-		self.frame.step(input, state, None);
-
-		let mut new_scene = None;
-		if input.player.input.pressed_leftclick() && !self.leftclick_down {
-			self.leftclick_down = true;
-			if self.button.contains_mouse(input, state, frame_rect) {
-				new_scene = Some(UiScenes::Outfitter(OutfitterScene::new(input.ct, state)));
-			}
-		} else if !input.player.input.pressed_leftclick() {
-			self.leftclick_down = false;
-		}
-
-		return UiSceneStepResult { new_scene };
-	}
-
-	fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
 		// Get required data
 		let ship_handle = input.player.ship.unwrap();
 		let ship_data = &input
@@ -146,20 +117,24 @@ impl<'this> UiScene<'this> for LandedScene {
 			self.reflow(planet, state);
 		}
 
+		self.button
+			.step(input, state, Some(self.frame.get_rect(input)));
+		self.landscape
+			.step(input, state, Some(self.frame.get_rect(input)));
+		self.frame.step(input, state, None);
+
 		// Draw elements
-		let frame_rect = Some(self.frame.get_rect(input));
+		self.button
-		self.button.push_to_buffer(input, state, frame_rect);
+			.push_to_buffer(input, state, Some(self.frame.get_rect(input)));
-		self.landscape.push_to_buffer(input, state, frame_rect);
+		self.landscape
+			.push_to_buffer(input, state, Some(self.frame.get_rect(input)));
 		self.frame.push_to_buffer(input, state, None);
 	}
 
-	fn get_textareas(
+	pub fn get_textarea(&self, input: &RenderInput, state: &RenderState) -> [TextArea; 2] {
-		&'this self,
+		[
-		v: &mut Vec<TextArea<'this>>,
+			self.planet_desc.get_textarea(input, state),
-		input: &RenderInput,
+			self.planet_name.get_textarea(input, state),
-		state: &RenderState,
+		]
-	) {
-		v.push(self.description.get_textarea(input, state));
-		v.push(self.title.get_textarea(input, state));
 	}
 }

crates/render/src/ui/scenes/flying/mod.rs

@@ -1,6 +0,0 @@
-mod fpsindicator;
-mod radar;
-mod scene;
-mod status;
-
-pub use scene::FlyingScene;

crates/render/src/ui/scenes/flying/scene.rs

@@ -1,45 +0,0 @@
-use galactica_content::Content;
-use glyphon::TextArea;
-
-use super::{fpsindicator::FpsIndicator, radar::Radar, status::Status};
-use crate::{
-	ui::manager::{UiScene, UiSceneStepResult},
-	RenderInput, RenderState,
-};
-
-pub struct FlyingScene {
-	radar: Radar,
-	status: Status,
-	fps: FpsIndicator,
-}
-
-impl FlyingScene {
-	pub fn new(_ct: &Content, state: &mut RenderState) -> Self {
-		Self {
-			radar: Radar::new(),
-			status: Status::new(),
-			fps: FpsIndicator::new(state),
-		}
-	}
-}
-
-impl<'this> UiScene<'this> for FlyingScene {
-	fn step(&mut self, input: &RenderInput, state: &mut RenderState) -> UiSceneStepResult {
-		self.fps.update(input, state);
-		return UiSceneStepResult { new_scene: None };
-	}
-
-	fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
-		self.radar.draw(input, state);
-		self.status.draw(input, state);
-	}
-
-	fn get_textareas(
-		&'this self,
-		v: &mut Vec<TextArea<'this>>,
-		_input: &RenderInput,
-		_state: &RenderState,
-	) {
-		v.push(self.fps.get_textarea());
-	}
-}

crates/render/src/ui/scenes/mod.rs

@@ -1,7 +0,0 @@
-mod flying;
-mod landed;
-mod outfitter;
-
-pub use flying::FlyingScene;
-pub use landed::LandedScene;
-pub use outfitter::OutfitterScene;

crates/render/src/ui/scenes/outfitter.rs

@@ -1,145 +0,0 @@
-use galactica_content::{Content, SystemObject, SystemObjectHandle};
-use galactica_system::{data::ShipState, phys::PhysSimShipHandle};
-use glyphon::{cosmic_text::Align, Attrs, Color, Metrics, TextArea, Weight};
-use nalgebra::{Point2, Vector2};
-
-use crate::{
-	ui::{
-		manager::{UiScene, UiSceneStepResult, UiScenes},
-		util::{SpriteRect, UiSprite, UiTextArea},
-	},
-	RenderInput, RenderState,
-};
-
-use super::LandedScene;
-
-pub struct OutfitterScene {
-	// UI elements
-	description: UiTextArea,
-	landscape: UiSprite,
-	button: UiSprite,
-
-	/// What object we're displaying currently.
-	/// Whenever this changes, we need to reflow text.
-	current_object: Option<SystemObjectHandle>,
-
-	/// True if we've caught a left click event.
-	/// Used for edge detection.
-	leftclick_down: bool,
-}
-
-impl OutfitterScene {
-	pub fn new(ct: &Content, state: &mut RenderState) -> Self {
-		let button = UiSprite::new(
-			ct,
-			ct.get_sprite_handle("ui::button"),
-			None,
-			SpriteRect {
-				pos: Point2::new(0.0, 0.0),
-				dim: Vector2::new(200.0, 200.0),
-			},
-			None,
-			None,
-		);
-
-		let landscape = UiSprite::from_with_sprite(
-			ct,
-			&ct.get_ui().landed_landscape,
-			ct.get_sprite_handle("ui::landscape::test"),
-		);
-
-		let s = Self {
-			// height of element in logical pixels
-			current_object: None,
-			leftclick_down: false,
-
-			description: UiTextArea::new(
-				ct,
-				state,
-				button.get_sprite(),
-				Point2::new(0.0, 0.0),
-				800.0,
-				SpriteRect {
-					pos: Point2::new(25.831, 284.883) / 512.0,
-					dim: Vector2::new(433.140, 97.220) / 512.0,
-				},
-				Metrics::new(16.0, 18.0),
-				Color::rgb(255, 255, 255),
-				Align::Left,
-			),
-
-			landscape,
-			button,
-		};
-
-		return s;
-	}
-
-	fn reflow(&mut self, planet: &SystemObject, state: &mut RenderState) {
-		self.description.set_text(
-			state,
-			&planet.desc,
-			Attrs::new()
-				.weight(Weight::NORMAL)
-				.family(glyphon::Family::SansSerif),
-		);
-
-		self.current_object = Some(planet.handle);
-	}
-}
-
-impl<'this> UiScene<'this> for OutfitterScene {
-	fn step(&mut self, input: &RenderInput, state: &mut RenderState) -> UiSceneStepResult {
-		self.button.step(input, state, None);
-		self.landscape.step(input, state, None);
-
-		let mut new_scene = None;
-		if input.player.input.pressed_leftclick() && !self.leftclick_down {
-			self.leftclick_down = true;
-			if self.button.contains_mouse(input, state, None) {
-				new_scene = Some(UiScenes::Landed(LandedScene::new(input.ct, state)));
-			}
-		} else if !input.player.input.pressed_leftclick() {
-			self.leftclick_down = false;
-		}
-
-		return UiSceneStepResult { new_scene };
-	}
-
-	fn draw(&mut self, input: &RenderInput, state: &mut RenderState) {
-		// Get required data
-		let ship_handle = input.player.ship.unwrap();
-		let ship_data = &input
-			.phys_img
-			.get_ship(&PhysSimShipHandle(ship_handle))
-			.unwrap()
-			.ship;
-		let planet_handle = match ship_data.get_data().get_state() {
-			ShipState::Landed { target } => *target,
-			_ => unreachable!("tried to draw planet interface while not landed!"),
-		};
-		let planet = input.ct.get_system_object(planet_handle);
-
-		// Reconfigure for new planet if necessary
-		if self
-			.current_object
-			.map(|x| x != planet_handle)
-			.unwrap_or(true)
-		{
-			self.reflow(planet, state);
-		}
-
-		// Draw elements
-		self.button.push_to_buffer(input, state, None);
-		self.landscape.push_to_buffer(input, state, None);
-	}
-
-	fn get_textareas(
-		&'this self,
-		v: &mut Vec<TextArea<'this>>,
-		input: &RenderInput,
-		state: &RenderState,
-	) {
-		v.push(self.description.get_textarea(input, state));
-	}
-}

crates/render/src/ui/util/sprite.rs

@@ -17,24 +17,6 @@ pub struct UiSprite {
 }
 
 impl UiSprite {
-	pub fn new(
-		ct: &Content,
-		sprite: SpriteHandle,
-		mask: Option<SpriteHandle>,
-		rect: SpriteRect,
-		on_mouse_enter: Option<SectionEdge>,
-		on_mouse_leave: Option<SectionEdge>,
-	) -> Self {
-		return Self {
-			anim: SpriteAutomaton::new(ct, sprite),
-			mask,
-			rect,
-			has_mouse: false,
-			on_mouse_enter,
-			on_mouse_leave,
-		};
-	}
-
 	pub fn from(ct: &Content, ui: &UiSpriteConfig) -> Self {
 		if ui.sprite.is_none() {
 			unreachable!("called `UiSprite.from()` on a UiSprite with a None sprite!")
@@ -44,17 +26,17 @@ impl UiSprite {
 	}
 
 	pub fn from_with_sprite(ct: &Content, ui: &UiSpriteConfig, sprite: SpriteHandle) -> Self {
-		Self::new(
+		return Self {
-			ct,
+			anim: SpriteAutomaton::new(ct, sprite),
-			sprite,
+			mask: ui.mask,
-			ui.mask,
+			rect: SpriteRect {
-			SpriteRect {
 				pos: *ui.rect.get_pos(),
 				dim: *ui.rect.get_dim(),
 			},
-			ui.on_mouse_enter,
+			has_mouse: false,
-			ui.on_mouse_leave,
+			on_mouse_enter: ui.on_mouse_enter,
-		)
+			on_mouse_leave: ui.on_mouse_leave,
+		};
 	}
 
 	pub fn step(&mut self, input: &RenderInput, state: &RenderState, parent: Option<SpriteRect>) {