Minor edits

Cargo.lock

@@ -642,6 +642,7 @@ dependencies = [
  "galactica-packer",
  "galactica-util",
  "image",
+ "lazy_static",
  "nalgebra",
  "rapier2d",
  "serde",

Cargo.toml

@@ -64,3 +64,4 @@ rand = "0.8.5"
 walkdir = "2.4.0"
 toml = "0.8.8"
 glyphon = "0.4.1"
+lazy_static = "1.4.0"

TODO.md

@@ -1,7 +1,6 @@
 # Specific projects
 
 ## Currently working on:
- - first: fix animation transition timings
  - first: fix particles & physics
  - clickable buttons
  - planet outfitter
@@ -218,6 +217,7 @@
  - Naming: atlas, sprite, image, frame, texture
  - Outfits may not change unless you've landed. They might not change ever for CC ships!
  - All angle adjustments happen in content & shaders
+ - Reserved texture: index zero
 
 
 ## Ideas

crates/content/Cargo.toml

@@ -27,3 +27,4 @@ walkdir = { workspace = true }
 nalgebra = { workspace = true }
 image = { workspace = true }
 rapier2d = { workspace = true }
+lazy_static = { workspace = true }

crates/content/src/lib.rs

@@ -3,9 +3,9 @@
 //! This subcrate is responsible for loading, parsing, validating game content,
 //! which is usually stored in `./content`.
 
-mod animautomaton;
 mod handle;
 mod part;
+mod spriteautomaton;
 mod util;
 
 use anyhow::{bail, Context, Result};
@@ -13,16 +13,16 @@ use galactica_packer::{SpriteAtlas, SpriteAtlasImage};
 use std::{
 	collections::HashMap,
 	fs::File,
-	hash::Hash,
 	io::Read,
+	num::NonZeroU32,
 	path::{Path, PathBuf},
 };
 use toml;
 use walkdir::WalkDir;
 
-pub use animautomaton::*;
 pub use handle::*;
 pub use part::*;
+pub use spriteautomaton::*;
 
 mod syntax {
 	use anyhow::{bail, Context, Result};
@@ -304,8 +304,8 @@ impl Content {
 	}
 
 	/// Get a texture by its index
-	pub fn get_image(&self, idx: u32) -> &SpriteAtlasImage {
+	pub fn get_image(&self, idx: NonZeroU32) -> &SpriteAtlasImage {
-		&self.sprite_atlas.index[idx as usize]
+		&self.sprite_atlas.get_by_idx(idx)
 	}
 
 	/// Get an outfit from a handle

crates/content/src/part/config.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{num::NonZeroU32, path::PathBuf};
 
 pub(crate) mod syntax {
 	use anyhow::{bail, Result};
@@ -36,8 +36,8 @@ pub(crate) mod syntax {
 			// An insufficient limit will result in some tiles not being drawn
 			let starfield_instance_limit = 12 * starfield_count as u64;
 
-			let starfield_texture = match atlas.path_map.get(&self.starfield.texture) {
+			let starfield_texture = match atlas.get_idx_by_path(&self.starfield.texture) {
-				Some(s) => *s,
+				Some(s) => s,
 				None => {
 					bail!(
 						"starfield texture `{}` doesn't exist",
@@ -129,7 +129,7 @@ pub struct Config {
 	pub starfield_max_dist: f32,
 
 	/// Index of starfield texture
-	pub starfield_texture: u32,
+	pub starfield_texture: NonZeroU32,
 
 	/// Size of a square starfield tile, in game units.
 	/// A tile of size STARFIELD_Z_MAX * screen-size-in-game-units

crates/content/src/part/outfit.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use crate::{
 	handle::SpriteHandle, Content, ContentBuildContext, EffectHandle, OutfitHandle, OutfitSpace,
-	StartEdge,
+	SectionEdge,
 };
 
 pub(crate) mod syntax {
@@ -148,10 +148,10 @@ pub struct Outfit {
 	pub engine_flare_sprite: Option<SpriteHandle>,
 
 	/// Jump to this edge when engines turn on
-	pub engine_flare_on_start: Option<StartEdge>,
+	pub engine_flare_on_start: Option<SectionEdge>,
 
 	/// Jump to this edge when engines turn off
-	pub engine_flare_on_stop: Option<StartEdge>,
+	pub engine_flare_on_stop: Option<SectionEdge>,
 
 	/// Shield hit points
 	pub shield_strength: f32,
@@ -289,30 +289,75 @@ impl crate::Build for Outfit {
 				};
 				o.engine_thrust = engine.thrust;
 				o.engine_flare_sprite = Some(sprite_handle);
+				let sprite = content.get_sprite(sprite_handle);
 
+				// Flare animation will traverse this edge when the player presses the thrust key
+				// This leads from the idle animation to the transition animation
 				o.engine_flare_on_start = {
 					let x = engine.flare.on_start;
 					if x.is_none() {
 						None
 					} else {
 						let x = x.unwrap();
-						Some(
+						let mut e = x
-							x.resolve_as_start(sprite_handle, build_context)
+							.resolve_as_edge(sprite_handle, build_context, 0.0)
-								.with_context(|| format!("in outfit `{}`", outfit_name))?,
+							.with_context(|| format!("in outfit `{}`", outfit_name))?;
-						)
+						match e {
+							// Inherit duration from transition sequence
+							SectionEdge::Top {
+								section,
+								ref mut duration,
+							}
+							| SectionEdge::Bot {
+								section,
+								ref mut duration,
+							} => {
+								*duration = sprite.get_section(section).frame_duration;
+							}
+							_ => {
+								return Err(anyhow!(
+									"bad edge `{}`: must be `top` or `bot`",
+									x.val
+								))
+								.with_context(|| format!("in outfit `{}`", outfit_name));
+							}
+						};
+						Some(e)
 					}
 				};
 
+				// Flare animation will traverse this edge when the player releases the thrust key
+				// This leads from the idle animation to the transition animation
 				o.engine_flare_on_stop = {
 					let x = engine.flare.on_stop;
 					if x.is_none() {
 						None
 					} else {
 						let x = x.unwrap();
-						Some(
+						let mut e = x
-							x.resolve_as_start(sprite_handle, build_context)
+							.resolve_as_edge(sprite_handle, build_context, 0.0)
-								.with_context(|| format!("in outfit `{}`", outfit_name))?,
+							.with_context(|| format!("in outfit `{}`", outfit_name))?;
-						)
+						match e {
+							// Inherit duration from transition sequence
+							SectionEdge::Top {
+								section,
+								ref mut duration,
+							}
+							| SectionEdge::Bot {
+								section,
+								ref mut duration,
+							} => {
+								*duration = sprite.get_section(section).frame_duration;
+							}
+							_ => {
+								return Err(anyhow!(
+									"bad edge `{}`: must be `top` or `bot`",
+									x.val
+								))
+								.with_context(|| format!("in outfit `{}`", outfit_name));
+							}
+						};
+						Some(e)
 					}
 				};
 			}

crates/content/src/part/sprite.rs

@@ -1,4 +1,5 @@
 use anyhow::{anyhow, bail, Context, Result};
+use lazy_static::lazy_static;
 use std::collections::HashMap;
 
 use crate::{handle::SpriteHandle, Content, ContentBuildContext};
@@ -71,15 +72,15 @@ pub(crate) mod syntax {
 			// Make sure all frames have the same size and add them
 			// to the frame vector
 			let mut dim = None;
-			let mut frames = Vec::new();
+			let mut frames: Vec<u32> = Vec::new();
 			for f in &self.frames {
-				let idx = match content.sprite_atlas.path_map.get(f) {
+				let idx = match content.sprite_atlas.get_idx_by_path(f) {
-					Some(s) => *s,
+					Some(s) => s,
 					None => {
 						bail!("error: file `{}` isn't in the sprite atlas", f.display());
 					}
 				};
-				let img = &content.sprite_atlas.index[idx as usize];
+				let img = &content.sprite_atlas.get_by_idx(idx);
 
 				match dim {
 					None => dim = Some(img.true_size),
@@ -90,8 +91,13 @@ pub(crate) mod syntax {
 					}
 				}
 
-				frames.push(img.idx);
+				frames.push(img.idx.into());
 			}
+
+			if frames.len() == 0 {
+				bail!("sprite sections must not be empty",)
+			}
+
 			let dim = dim.unwrap();
 
 			let frame_duration = match self.timing.variant {
@@ -104,12 +110,12 @@ pub(crate) mod syntax {
 			}
 
 			let edge_top = match &self.top {
-				Some(x) => x.resolve_as_edge(this_sprite, build_context)?,
+				Some(x) => x.resolve_as_edge(this_sprite, build_context, frame_duration)?,
 				None => super::SectionEdge::Stop,
 			};
 
 			let edge_bot = match &self.bot {
-				Some(x) => x.resolve_as_edge(this_sprite, build_context)?,
+				Some(x) => x.resolve_as_edge(this_sprite, build_context, frame_duration)?,
 				None => super::SectionEdge::Stop,
 			};
 
@@ -139,11 +145,11 @@ pub(crate) mod syntax {
 			build_context: &ContentBuildContext,
 		) -> Result<super::StartEdge> {
 			let e = self
-				.resolve_as_edge(sprite, build_context)
+				.resolve_as_edge(sprite, build_context, 0.0)
 				.with_context(|| format!("while resolving start edge"))?;
 			match e {
-				super::SectionEdge::Bot { section } => Ok(super::StartEdge::Bot { section }),
+				super::SectionEdge::Bot { section, .. } => Ok(super::StartEdge::Bot { section }),
-				super::SectionEdge::Top { section } => Ok(super::StartEdge::Top { section }),
+				super::SectionEdge::Top { section, .. } => Ok(super::StartEdge::Top { section }),
 				_ => {
 					bail!("bad section start specification `{}`", self.val);
 				}
@@ -154,19 +160,27 @@ pub(crate) mod syntax {
 			&self,
 			sprite: SpriteHandle,
 			build_context: &ContentBuildContext,
+			duration: f32,
 		) -> Result<super::SectionEdge> {
 			let all_sections = build_context.sprite_section_index.get(&sprite).unwrap();
 
+			if self.val == "hidden" {
+				return Ok(super::SectionEdge::Top {
+					section: crate::AnimSectionHandle::Hidden,
+					duration,
+				});
+			}
+
 			if self.val == "stop" {
 				return Ok(super::SectionEdge::Stop);
 			}
 
 			if self.val == "reverse" {
-				return Ok(super::SectionEdge::Reverse);
+				return Ok(super::SectionEdge::Reverse { duration });
 			}
 
-			if self.val == "restart" {
+			if self.val == "repeat" {
-				return Ok(super::SectionEdge::Restart);
+				return Ok(super::SectionEdge::Repeat { duration });
 			}
 
 			let (s, p) = match self.val.split_once(":") {
@@ -185,8 +199,8 @@ pub(crate) mod syntax {
 			};
 
 			match p {
-				"top" => Ok(super::SectionEdge::Top { section }),
+				"top" => Ok(super::SectionEdge::Top { section, duration }),
-				"bot" => Ok(super::SectionEdge::Bot { section }),
+				"bot" => Ok(super::SectionEdge::Bot { section, duration }),
 				_ => {
 					return Err(anyhow!("bad section edge specification `{}`", self.val))
 						.with_context(|| format!("invalid target `{}`", p));
@@ -196,10 +210,24 @@ pub(crate) mod syntax {
 	}
 }
 
-// TODO: should be pub crate
 /// A handle for an animation section inside a sprite
 #[derive(Debug, Copy, Clone)]
-pub struct AnimSectionHandle(pub(crate) usize);
+pub enum AnimSectionHandle {
+	/// The hidden section
+	Hidden,
+
+	/// An index into this sprite's section array
+	Idx(usize),
+}
+
+impl AnimSectionHandle {
+	fn get_idx(&self) -> Option<usize> {
+		match self {
+			Self::Hidden => None,
+			Self::Idx(idx) => Some(*idx),
+		}
+	}
+}
 
 /// An edge between two animation sections
 #[derive(Debug, Clone, Copy)]
@@ -211,19 +239,31 @@ pub enum SectionEdge {
 	Bot {
 		/// The section to play
 		section: AnimSectionHandle,
+
+		/// The length of this edge, in seconds
+		duration: f32,
 	},
 
 	/// Play the given section from the top
 	Top {
 		/// The section to play
 		section: AnimSectionHandle,
+
+		/// The length of this edge, in seconds
+		duration: f32,
 	},
 
 	/// Replay this section in the opposite direction
-	Reverse,
+	Reverse {
+		/// The length of this edge, in seconds
+		duration: f32,
+	},
 
 	/// Restart this section from the opposite end
-	Restart,
+	Repeat {
+		/// The length of this edge, in seconds
+		duration: f32,
+	},
 }
 
 /// Where to start an animation
@@ -245,8 +285,14 @@ pub enum StartEdge {
 impl Into<SectionEdge> for StartEdge {
 	fn into(self) -> SectionEdge {
 		match self {
-			Self::Bot { section } => SectionEdge::Bot { section },
+			Self::Bot { section } => SectionEdge::Bot {
-			Self::Top { section } => SectionEdge::Top { section },
+				section,
+				duration: 0.0,
+			},
+			Self::Top { section } => SectionEdge::Top {
+				section,
+				duration: 0.0,
+			},
 		}
 	}
 }
@@ -270,13 +316,25 @@ pub struct Sprite {
 	pub aspect: f32,
 }
 
+lazy_static! {
+	static ref HIDDEN_SECTION: SpriteSection = SpriteSection {
+		frames: vec![0],
+		frame_duration: 0.0,
+		edge_bot: SectionEdge::Stop,
+		edge_top: SectionEdge::Stop,
+	};
+}
+
 impl Sprite {
 	/// Get an animation section from a handle
 	pub fn get_section(&self, section: AnimSectionHandle) -> &SpriteSection {
-		&self.sections[section.0]
+		match section {
+			AnimSectionHandle::Hidden => &HIDDEN_SECTION,
+			AnimSectionHandle::Idx(idx) => &self.sections[idx],
+		}
 	}
 
-	/// Get this sprite's first frame
+	/// Get the index of the texture of this sprite's first frame
 	pub fn get_first_frame(&self) -> u32 {
 		match self.start_at {
 			StartEdge::Bot { section } => *self.get_section(section).frames.last().unwrap(),
@@ -327,8 +385,8 @@ impl crate::Build for Sprite {
 		for (sprite_name, t) in sprites {
 			match t {
 				syntax::Sprite::Static(t) => {
-					let idx = match content.sprite_atlas.path_map.get(&t.file) {
+					let idx = match content.sprite_atlas.get_idx_by_path(&t.file) {
-						Some(s) => *s,
+						Some(s) => s,
 						None => {
 							return Err(
 								anyhow!("error while processing sprite `{}`", sprite_name,),
@@ -341,7 +399,7 @@ impl crate::Build for Sprite {
 							});
 						}
 					};
-					let img = &content.sprite_atlas.index[idx as usize];
+					let img = &content.sprite_atlas.get_by_idx(idx);
 					let aspect = img.w / img.h;
 
 					let h = SpriteHandle {
@@ -350,16 +408,16 @@ impl crate::Build for Sprite {
 
 					content.sprite_index.insert(sprite_name.clone(), h);
 					let mut smap = HashMap::new();
-					smap.insert("anim".to_string(), AnimSectionHandle(0));
+					smap.insert("anim".to_string(), AnimSectionHandle::Idx(0));
 					build_context.sprite_section_index.insert(h, smap);
 
 					content.sprites.push(Self {
 						name: sprite_name,
 						start_at: StartEdge::Top {
-							section: AnimSectionHandle(0),
+							section: AnimSectionHandle::Idx(0),
 						},
 						sections: vec![SpriteSection {
-							frames: vec![img.idx],
+							frames: vec![img.idx.into()],
 							// We implement unanimated sprites with a very fast framerate
 							// and STOP endpoints.
 							frame_duration: 0.01,
@@ -373,7 +431,7 @@ impl crate::Build for Sprite {
 				syntax::Sprite::OneSection(s) => {
 					let mut section_names: HashMap<String, _> = HashMap::new();
 					// Name the one section in this sprite "anim"
-					section_names.insert("anim".to_owned(), AnimSectionHandle(0));
+					section_names.insert("anim".to_owned(), AnimSectionHandle::Idx(0));
 
 					let sprite_handle = SpriteHandle {
 						index: content.sprites.len(),
@@ -382,7 +440,7 @@ impl crate::Build for Sprite {
 						.sprite_index
 						.insert(sprite_name.clone(), sprite_handle);
 					let mut smap = HashMap::new();
-					smap.insert("anim".to_string(), AnimSectionHandle(0));
+					smap.insert("anim".to_string(), AnimSectionHandle::Idx(0));
 					build_context
 						.sprite_section_index
 						.insert(sprite_handle, smap);
@@ -398,19 +456,18 @@ impl crate::Build for Sprite {
 					content.sprites.push(Self {
 						name: sprite_name,
 						sections,
-						start_at: StartEdge::Bot {
+						start_at: StartEdge::Top {
-							section: AnimSectionHandle(0),
+							section: AnimSectionHandle::Idx(0),
 						},
 						handle: sprite_handle,
 						aspect,
 					});
 				}
 				syntax::Sprite::Complete(s) => {
-					let mut idx = 0;
 					let mut section_names = HashMap::new();
 					for (name, _) in &s.section {
-						section_names.insert(name.to_owned(), AnimSectionHandle(idx));
+						section_names
-						idx += 1;
+							.insert(name.to_owned(), AnimSectionHandle::Idx(section_names.len()));
 					}
 
 					let sprite_handle = SpriteHandle {
@@ -428,19 +485,19 @@ impl crate::Build for Sprite {
 						.resolve_as_start(sprite_handle, build_context)
 						.with_context(|| format!("while loading sprite `{}`", sprite_name))?;
 
-					let mut sections = Vec::with_capacity(idx);
+					let mut sections = Vec::with_capacity(section_names.len());
 					let mut dim = None;
 
 					// Make sure we add sections in order
 					let mut names = section_names.iter().collect::<Vec<_>>();
-					names.sort_by(|a, b| (a.1).0.cmp(&(b.1).0));
+					names.sort_by(|a, b| (a.1).get_idx().unwrap().cmp(&(b.1).get_idx().unwrap()));
 
 					for (k, _) in names {
 						let v = s.section.get(k).unwrap();
 						let (d, s) = v
 							.add_to(sprite_handle, build_context, content)
-							.with_context(|| format!("while parsing sprite `{}`", sprite_name))
+							.with_context(|| format!("while parsing section `{}`", k))
-							.with_context(|| format!("while parsing section `{}`", k))?;
+							.with_context(|| format!("while parsing sprite `{}`", sprite_name))?;
 
 						// Make sure all dimensions are the same
 						if dim.is_none() {

crates/content/src/spriteautomaton.rs

@@ -25,7 +25,7 @@ impl AnimationState {
 }
 
 /// What direction are we playing our animation in?
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 enum AnimDirection {
 	/// Top to bottom, with increasing frame indices
 	/// (normal)
@@ -35,13 +35,13 @@ enum AnimDirection {
 	/// (reverse)
 	Down,
 
-	/// Stopped, no animation
+	/// Stopped on one frame
 	Stop,
 }
 
 /// Manages a single sprite's animation state.
 #[derive(Debug, Clone)]
-pub struct AnimAutomaton {
+pub struct SpriteAutomaton {
 	/// The sprite we're animating
 	sprite: SpriteHandle,
 
@@ -53,8 +53,10 @@ pub struct AnimAutomaton {
 	current_frame: usize,
 
 	/// Where we are between frames.
-	/// Always between zero and one.
+	current_edge_progress: f32,
-	current_fade: f32,
+
+	/// The length of the current edge we're on, in seconds
+	current_edge_duration: f32,
 
 	/// In what direction are we playing the current section?
 	current_direction: AnimDirection,
@@ -71,7 +73,7 @@ pub struct AnimAutomaton {
 	next_edge_override: Option<SectionEdge>,
 }
 
-impl AnimAutomaton {
+impl SpriteAutomaton {
 	/// Create a new AnimAutomaton
 	pub fn new(ct: &Content, sprite_handle: SpriteHandle) -> Self {
 		let sprite = ct.get_sprite(sprite_handle);
@@ -89,10 +91,19 @@ impl AnimAutomaton {
 			),
 		};
 
+		let sec = sprite.get_section(current_section);
+
 		Self {
 			sprite: sprite.handle,
 			current_frame: 0,
-			current_fade: 0.0,
+
+			current_edge_progress: match current_direction {
+				AnimDirection::Down => 0.0,
+				AnimDirection::Up => sec.frame_duration,
+				AnimDirection::Stop => unreachable!("how'd you get here?"),
+			},
+
+			current_edge_duration: sec.frame_duration,
 			next_edge_override: None,
 
 			current_direction,
@@ -108,49 +119,108 @@ impl AnimAutomaton {
 	}
 
 	/// Force a transition to the given section right now
-	pub fn jump_to(&mut self, ct: &Content, start: StartEdge) {
+	pub fn jump_to(&mut self, ct: &Content, start: SectionEdge) {
-		self.take_edge(ct, start.into());
+		self.take_edge(ct, start);
 	}
 
 	fn take_edge(&mut self, ct: &Content, e: SectionEdge) {
 		let sprite = ct.get_sprite(self.sprite);
 		let current_section = sprite.get_section(self.current_section);
+		let last_direction = self.current_direction;
 
 		match e {
 			SectionEdge::Stop => {
-				self.current_fade = 0.0;
-				self.current_frame = current_section.frames.len() - 1;
-				self.current_direction = AnimDirection::Stop;
-			}
-			SectionEdge::Top { section } => {
-				self.current_section = section;
-				self.current_frame = 0;
-				self.current_direction = AnimDirection::Down;
-			}
-			SectionEdge::Bot { section } => {
-				let s = sprite.get_section(section);
-				self.current_section = section;
-				self.current_frame = s.frames.len() - 1;
-				self.current_direction = AnimDirection::Up;
-			}
-			SectionEdge::Restart => {
-				self.current_frame = 0;
-			}
-			SectionEdge::Reverse => {
-				// Jump to SECOND frame, since we've already shown the
-				// first during the fade transition
-
 				match self.current_direction {
 					AnimDirection::Stop => {}
 					AnimDirection::Up => {
 						self.current_frame = 0;
-						self.current_direction = AnimDirection::Down;
 					}
 					AnimDirection::Down => {
 						self.current_frame = current_section.frames.len() - 1;
+					}
+				}
+
+				self.current_edge_duration = 1.0;
+				self.current_direction = AnimDirection::Stop;
+			}
+			SectionEdge::Top { section, duration } => {
+				self.current_section = section;
+				self.current_edge_duration = duration;
+				self.current_frame = 0;
+				self.current_direction = AnimDirection::Down;
+			}
+			SectionEdge::Bot { section, duration } => {
+				let s = sprite.get_section(section);
+				self.current_section = section;
+				self.current_frame = s.frames.len() - 1;
+				self.current_edge_duration = duration;
+				self.current_direction = AnimDirection::Up;
+			}
+			SectionEdge::Repeat { duration } => {
+				match self.current_direction {
+					AnimDirection::Stop => {}
+					AnimDirection::Up => {
+						self.current_frame = current_section.frames.len() - 1;
+					}
+					AnimDirection::Down => {
+						self.current_frame = 0;
+					}
+				}
+				self.current_edge_duration = duration;
+			}
+			SectionEdge::Reverse { duration } => {
+				match self.current_direction {
+					AnimDirection::Stop => {}
+					AnimDirection::Up => {
+						// Jump to SECOND frame, since we've already shown the
+						// first during the fade transition
+						self.current_frame = {
+							if current_section.frames.len() == 1 {
+								0
+							} else {
+								1
+							}
+						};
+						self.current_direction = AnimDirection::Down;
+					}
+					AnimDirection::Down => {
+						self.current_frame = {
+							if current_section.frames.len() == 1 {
+								0
+							} else {
+								current_section.frames.len() - 2
+							}
+						};
 						self.current_direction = AnimDirection::Up;
 					}
 				}
+				self.current_edge_duration = duration;
+			}
+		}
+
+		let last = match last_direction {
+			AnimDirection::Stop => self.last_texture,
+			AnimDirection::Down => self.next_texture,
+			AnimDirection::Up => self.last_texture,
+		};
+
+		match self.current_direction {
+			AnimDirection::Stop => {
+				let current_section = sprite.get_section(self.current_section);
+				self.next_texture = current_section.frames[self.current_frame];
+				self.last_texture = current_section.frames[self.current_frame];
+			}
+			AnimDirection::Down => {
+				let current_section = sprite.get_section(self.current_section);
+				self.last_texture = last;
+				self.next_texture = current_section.frames[self.current_frame];
+				self.current_edge_progress = 0.0;
+			}
+			AnimDirection::Up => {
+				let current_section = sprite.get_section(self.current_section);
+				self.next_texture = last;
+				self.last_texture = current_section.frames[self.current_frame];
+				self.current_edge_progress = self.current_edge_duration;
 			}
 		}
 	}
@@ -168,13 +238,12 @@ impl AnimAutomaton {
 		// and we switch to the next frame when it hits 1.0. If we are stepping foward, it increases,
 		// and if we are stepping backwards, it decreases.
 
-		// This should always be positive, and this fact is enforced by the content loader.
+		// Note that frame_duration may be zero!
-		// if we get here, something is very wrong.
+		// This is only possible in the hidden texture, since
-		assert!(current_section.frame_duration > 0.0);
+		// user-provided sections are always checked to be positive.
+		assert!(current_section.frame_duration >= 0.0);
 
 		match self.current_direction {
-			AnimDirection::Down => self.current_fade += t / current_section.frame_duration,
-			AnimDirection::Up => self.current_fade -= t / current_section.frame_duration,
 			AnimDirection::Stop => {
 				// Edge case: we're stopped and got a request to transition.
 				// we should transition right away.
@@ -182,57 +251,57 @@ impl AnimAutomaton {
 				if let Some(e) = self.next_edge_override {
 					self.take_edge(ct, e);
 				}
-			}
-		}
 
-		// We're stepping foward and finished this frame
+				return;
-		// (implies we're travelling downwards)
-		if self.current_fade > 1.0 {
-			while self.current_fade > 1.0 {
-				self.current_fade -= 1.0;
 			}
 
-			if self.current_frame < current_section.frames.len() - 1 {
+			AnimDirection::Down => {
-				self.current_frame += 1;
+				self.current_edge_progress += t;
-			} else {
+
-				let e = {
+				// We're stepping foward and finished this frame
-					if self.next_edge_override.is_some() {
+				if self.current_edge_progress > self.current_edge_duration {
-						self.next_edge_override.take().unwrap()
+					if self.current_frame < current_section.frames.len() - 1 {
+						self.current_frame += 1;
+						self.last_texture = self.next_texture;
+						self.next_texture = current_section.frames[self.current_frame];
+						self.current_edge_progress = 0.0;
+						self.current_edge_duration = current_section.frame_duration;
 					} else {
-						current_section.edge_bot.clone()
+						let e = {
+							if self.next_edge_override.is_some() {
+								self.next_edge_override.take().unwrap()
+							} else {
+								current_section.edge_bot.clone()
+							}
+						};
+						self.take_edge(ct, e);
 					}
-				};
+				}
-				self.take_edge(ct, e);
 			}
 
-			let current_section = sprite.get_section(self.current_section);
+			AnimDirection::Up => {
-			self.last_texture = self.next_texture;
+				self.current_edge_progress -= t;
-			self.next_texture = current_section.frames[self.current_frame];
-		}
 
-		// We're stepping backward and finished this frame
+				// We're stepping backward and finished this frame
-		// (implies we're travelling upwards)
+				if self.current_edge_progress < 0.0 {
-		if self.current_fade < 0.0 {
+					if self.current_frame > 0 {
-			while self.current_fade < 0.0 {
+						self.current_frame -= 1;
-				self.current_fade += 1.0;
+						self.next_texture = self.last_texture;
-			}
+						self.last_texture = current_section.frames[self.current_frame];
-
+						self.current_edge_progress = current_section.frame_duration;
-			if self.current_frame > 0 {
+						self.current_edge_duration = current_section.frame_duration;
-				self.current_frame -= 1;
-			} else {
-				let e = {
-					if self.next_edge_override.is_some() {
-						self.next_edge_override.take().unwrap()
 					} else {
-						current_section.edge_top.clone()
+						let e = {
+							if self.next_edge_override.is_some() {
+								self.next_edge_override.take().unwrap()
+							} else {
+								current_section.edge_top.clone()
+							}
+						};
+						self.take_edge(ct, e);
 					}
-				};
+				}
-				self.take_edge(ct, e);
 			}
-
-			let current_section = sprite.get_section(self.current_section);
-			self.next_texture = self.last_texture;
-			self.last_texture = current_section.frames[self.current_frame];
 		}
 	}
 
@@ -241,7 +310,7 @@ impl AnimAutomaton {
 		return AnimationState {
 			texture_a: self.last_texture,
 			texture_b: self.next_texture,
-			fade: self.current_fade,
+			fade: self.current_edge_progress / self.current_edge_duration,
 		};
 	}
 }

crates/galactica/src/main.rs

@@ -17,7 +17,20 @@ use winit::{
 	window::WindowBuilder,
 };
 
-fn main() -> Result<()> {
+fn main() {
+	if let Err(err) = try_main() {
+		eprintln!("Galactica failed with an error");
+
+		let mut i = 0;
+		for e in err.chain().rev() {
+			eprintln!("{i:02}: {}", e);
+			i += 1;
+		}
+		std::process::exit(1);
+	}
+}
+
+fn try_main() -> Result<()> {
 	let cache_dir = Path::new(ASSET_CACHE);
 	fs::create_dir_all(cache_dir)?;
 

crates/packer/src/atlasset.rs

@@ -4,6 +4,7 @@ use image::{imageops, GenericImageView, ImageBuffer, Rgba, RgbaImage};
 use std::{
 	fs::File,
 	io::{Read, Write},
+	num::NonZeroU32,
 	path::{Path, PathBuf},
 };
 
@@ -205,19 +206,19 @@ impl AtlasSet {
 			)
 		})?;
 
-		self.index
+		self.index.push(
-			.path_map
+			p,
-			.insert(p.to_path_buf(), self.index.index.len() as u32);
+			SpriteAtlasImage {
-
+				true_size: image_dim,
-		self.index.index.push(SpriteAtlasImage {
+				// Add one to account for hidden texture
-			true_size: image_dim,
+				idx: NonZeroU32::new(self.index.len() as u32 + 1).unwrap(),
-			idx: self.index.index.len() as u32,
+				atlas: atlas_idx as u32,
-			atlas: atlas_idx as u32,
+				x: (x + self.image_margin) as f32 / self.texture_width as f32,
-			x: (x + self.image_margin) as f32 / self.texture_width as f32,
+				y: (y + self.image_margin) as f32 / self.texture_height as f32,
-			y: (y + self.image_margin) as f32 / self.texture_height as f32,
+				w: image_dim.0 as f32 / self.texture_width as f32,
-			w: image_dim.0 as f32 / self.texture_width as f32,
+				h: image_dim.1 as f32 / self.texture_height as f32,
-			h: image_dim.1 as f32 / self.texture_height as f32,
+			},
-		});
+		);
 
 		return Ok(atlas_idx);
 	}

crates/packer/src/lib.rs

@@ -2,7 +2,11 @@
 
 //! This crate creates texture atlases from an asset tree.
 
-use std::{collections::HashMap, path::PathBuf};
+use std::{
+	collections::HashMap,
+	num::NonZeroU32,
+	path::{Path, PathBuf},
+};
 
 use serde::{Deserialize, Serialize};
 
@@ -13,8 +17,9 @@ pub struct SpriteAtlasImage {
 	/// This is an index in SpriteAtlas.atlas_list
 	pub atlas: u32,
 
-	/// A globally unique, consecutively numbered index for this sprite
+	/// A globally unique, consecutively numbered index for this sprite.
-	pub idx: u32,
+	/// This is nonzero because index zero is reserved for the "hidden" texture.
+	pub idx: NonZeroU32,
 
 	/// The size of this image, in pixels
 	pub true_size: (u32, u32),
@@ -41,10 +46,10 @@ pub struct SpriteAtlasImage {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SpriteAtlas {
 	/// The images in this atlas
-	pub index: Vec<SpriteAtlasImage>,
+	pub(crate) index: Vec<SpriteAtlasImage>,
 
 	/// Map paths to image indices
-	pub path_map: HashMap<PathBuf, u32>,
+	path_map: HashMap<PathBuf, NonZeroU32>,
 
 	/// The file names of the atlas textures we've generated
 	pub atlas_list: Vec<String>,
@@ -59,4 +64,30 @@ impl SpriteAtlas {
 			atlas_list: Vec::new(),
 		}
 	}
+
+	/// Get a SpriteAtlasImage by index
+	pub fn get_by_idx(&self, idx: NonZeroU32) -> &SpriteAtlasImage {
+		&self.index[idx.get() as usize - 1]
+	}
+
+	/// Get an image index from its path
+	/// returns None if this path isn't in this index
+	pub fn get_idx_by_path(&self, path: &Path) -> Option<NonZeroU32> {
+		self.path_map.get(path).map(|x| *x)
+	}
+
+	/// Get the number of images in this atlas
+	pub fn len(&self) -> u32 {
+		self.index.len() as u32
+	}
+
+	/// Add an image with the given path to this index
+	pub fn push(&mut self, p: &Path, i: SpriteAtlasImage) {
+		self.path_map.insert(
+			p.to_path_buf(),
+			NonZeroU32::new(self.index.len() as u32 + 1).unwrap(),
+		);
+
+		self.index.push(i);
+	}
 }

crates/render/shaders/object.wgsl

@@ -103,7 +103,7 @@ fn transform_vertex(obj: ObjectData, vertex_position: vec2<f32>, texture_index:
 		);
 	}
 
-	return vec4<f32>(pos, 0.0, 1.0);;
+	return vec4<f32>(pos, 0.0, 1.0);
 }
 
 @vertex
@@ -113,35 +113,63 @@ fn vertex_main(
 ) -> VertexOutput {
 	var out: VertexOutput;
 
-	out.position = transform_vertex(
+	// Pick texture size by the size of the visible texture
-		objects[instance.object_index],
+	// (texture index 0 is special, it's the "hidden" texture)
-		vertex.position.xy,
+	if instance.texture_index.x == 0u && instance.texture_index.y == 0u {
-		instance.texture_index.x
+		out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
-	);
+	} else if instance.texture_index.x == 0u {
+		out.position = transform_vertex(
+			objects[instance.object_index],
+			vertex.position.xy,
+			instance.texture_index.y
+		);
+	} else if instance.texture_index.y == 0u {
+		out.position = transform_vertex(
+			objects[instance.object_index],
+			vertex.position.xy,
+			instance.texture_index.x
+		);
+	} else {
+		out.position = transform_vertex(
+			objects[instance.object_index],
+			vertex.position.xy,
+			instance.texture_index.x
+		);
+	}
+
 
 
-	// Compute texture coordinates
-	let age = global_data.current_time.x;
 	out.tween = instance.texture_fade;
 
-	let t = global_atlas[instance.texture_index.x];
+	// Texture 0 is special, it's the empty texture
-	out.texture_index_a = u32(t.atlas_texture);
+	if instance.texture_index.x == 0u {
-	out.texture_coords_a = vec2(t.xpos, t.ypos);
+		out.texture_index_a = 0u;
-	if vertex.texture_coords.x == 1.0 {
+		out.texture_coords_a = vec2(0.0, 0.0);
-		out.texture_coords_a = out.texture_coords_a + vec2(t.width, 0.0);
+	} else {
-	}
+		let t = global_atlas[instance.texture_index.x];
-	if vertex.texture_coords.y == 1.0 {
+		out.texture_index_a = t.atlas_texture;
-		out.texture_coords_a = out.texture_coords_a + vec2(0.0, t.height);
+		out.texture_coords_a = vec2(t.xpos, t.ypos);
+		if vertex.texture_coords.x == 1.0 {
+			out.texture_coords_a = out.texture_coords_a + vec2(t.width, 0.0);
+		}
+		if vertex.texture_coords.y == 1.0 {
+			out.texture_coords_a = out.texture_coords_a + vec2(0.0, t.height);
+		}
 	}
 
-	let b = global_atlas[instance.texture_index.y];
+	if instance.texture_index.y == 0u {
-	out.texture_index_b = u32(b.atlas_texture);
+		out.texture_index_b = u32(0u);
-	out.texture_coords_b = vec2(b.xpos, b.ypos);
+		out.texture_coords_b = vec2(0.0, 0.0);
-	if vertex.texture_coords.x == 1.0 {
+	} else {
-		out.texture_coords_b = out.texture_coords_b + vec2(b.width, 0.0);
+		let b = global_atlas[instance.texture_index.y];
-	}
+		out.texture_index_b = u32(b.atlas_texture);
-	if vertex.texture_coords.y == 1.0 {
+		out.texture_coords_b = vec2(b.xpos, b.ypos);
-		out.texture_coords_b = out.texture_coords_b + vec2(0.0, b.height);
+		if vertex.texture_coords.x == 1.0 {
+			out.texture_coords_b = out.texture_coords_b + vec2(b.width, 0.0);
+		}
+		if vertex.texture_coords.y == 1.0 {
+			out.texture_coords_b = out.texture_coords_b + vec2(0.0, b.height);
+		}
 	}
 
 	return out;
@@ -150,19 +178,42 @@ fn vertex_main(
 
 @fragment
 fn fragment_main(in: VertexOutput) -> @location(0) vec4<f32> {
-	return mix(
+
-		textureSampleLevel(
+	var texture_a: vec4<f32> = vec4(0.0, 0.0, 0.0, 0.0);
+	if !(
+		(in.texture_index_a == 0u) &&
+		(in.texture_coords_a.x == 0.0) &&
+		(in.texture_coords_a.y == 0.0)
+	) {
+		texture_a = textureSampleLevel(
 			texture_array[in.texture_index_a],
 			sampler_array[0],
 			in.texture_coords_a,
 			0.0
-		).rgba,
+		).rgba;
-		textureSampleLevel(
+	}
+
+
+	var texture_b: vec4<f32> = vec4(0.0, 0.0, 0.0, 0.0);
+	if !(
+		(in.texture_index_b == 0u) &&
+		(in.texture_coords_b.x == 0.0) &&
+		(in.texture_coords_b.y == 0.0)
+	) {
+		texture_b = textureSampleLevel(
 			texture_array[in.texture_index_b],
 			sampler_array[0],
 			in.texture_coords_b,
 			0.0
-		).rgba,
+		).rgba;
+	}
+
+	let color = mix(
+		texture_a,
+		texture_b,
 		in.tween
 	);
+
+
+	return color;
 }

crates/render/shaders/ui.wgsl

@@ -33,12 +33,12 @@ var sampler_array: binding_array<sampler>;
 
 // INCLUDE: anchor.wgsl
 
-@vertex
-fn vertex_main(
-	vertex: VertexInput,
-	instance: InstanceInput,
-) -> VertexOutput {
 
+fn transform_vertex(
+	instance: InstanceInput,
+	vertex_position: vec3<f32>,
+	texture_index: u32,
+) -> vec4<f32> {
 	
 	let window_dim = global_data.window_size / global_data.window_scale.x;
 	let scale = instance.size / window_dim.y;
@@ -50,8 +50,8 @@ fn vertex_main(
 	// Apply scale and sprite aspect
 	// Note that our mesh starts centered at (0, 0). This is important!
 	var pos: vec2<f32> = vec2(
-		vertex.position.x * scale * aspect,
+		vertex_position.x * scale * aspect,
-		vertex.position.y * scale
+		vertex_position.y * scale
 	);
 
 	// Apply rotation (and adjust sprite angle, since sprites point north)
@@ -72,10 +72,27 @@ fn vertex_main(
 		vec2(instance.size * aspect, instance.size)
 	);
 
-	var out: VertexOutput;
+	return vec4<f32>(pos, 0.0, 1.0);
-	out.position = vec4<f32>(pos, 1.0, 1.0);
+}
-	out.color_transform = instance.color_transform;
 
+@vertex
+fn vertex_main(
+	vertex: VertexInput,
+	instance: InstanceInput,
+) -> VertexOutput {
+
+	// TODO: this will break if we try to use texture 0.
+	// implement animations for ui sprites & fix that here.
+
+	let pos = transform_vertex(
+		instance,
+		vertex.position,
+		instance.texture_index.x,
+	);
+
+	var out: VertexOutput;
+	out.position = pos;
+	out.color_transform = instance.color_transform;
 
 
 	// TODO: function to get texture from sprite
@@ -108,7 +125,6 @@ fn vertex_main(
 		out.mask_index = vec2(0u, 0u);
 	}
 
-
 	return out;
 }
 

crates/render/src/gpustate/render.rs

@@ -306,7 +306,7 @@ impl<'a> super::GPUState {
 				],
 				window_scale: [self.state.window.scale_factor() as f32, 0.0],
 				window_aspect: [self.state.window_aspect, 0.0],
-				starfield_sprite: [input.ct.get_config().starfield_texture, 0],
+				starfield_sprite: [input.ct.get_config().starfield_texture.into(), 0],
 				starfield_tile_size: [input.ct.get_config().starfield_size, 0.0],
 				starfield_size_limits: [
 					input.ct.get_config().starfield_min_size,

crates/render/src/shaderprocessor.rs

@@ -1,5 +1,6 @@
 use crate::globaluniform::GlobalUniform;
 
+// TODO: build script?
 /// Basic wgsl preprocesser
 pub(crate) fn preprocess_shader(
 	shader: &str,

crates/render/src/texturearray.rs

@@ -112,15 +112,23 @@ impl TextureArray {
 		for sprite in &ct.sprites {
 			for section in sprite.iter_sections() {
 				for idx in &section.frames {
-					let image = ct.get_image(*idx);
+					// Some atlas entries may be written twice here,
-					image_locations.data[*idx as usize] = AtlasImageLocation {
+					// but that's not really a problem. They're all the same!
-						xpos: image.x,
+					//
-						ypos: image.y,
+					// This happens rarely---only when two different sections
-						width: image.w,
+					// use the same frame.
-						height: image.h,
+					let idx = NonZeroU32::new(*idx);
-						atlas_texture: image.atlas,
+					if idx.is_some() {
-						_padding: Default::default(),
+						let image = ct.get_image(idx.unwrap());
-					};
+						image_locations.data[idx.unwrap().get() as usize] = AtlasImageLocation {
+							xpos: image.x,
+							ypos: image.y,
+							width: image.w,
+							height: image.h,
+							atlas_texture: image.atlas,
+							_padding: Default::default(),
+						};
+					}
 				}
 			}
 		}

crates/render/src/vertexbuffer/types.rs

@@ -152,6 +152,7 @@ pub struct UiInstance {
 
 	/// What texture to use for this instance
 	pub texture_index: [u32; 2],
+
 	/// Fade parameter between textures
 	pub texture_fade: f32,
 

crates/system/src/phys/objects/projectile.rs

@@ -1,4 +1,4 @@
-use galactica_content::{AnimAutomaton, AnimationState, Content, FactionHandle, Projectile};
+use galactica_content::{AnimationState, Content, FactionHandle, Projectile, SpriteAutomaton};
 use rand::Rng;
 use rapier2d::{dynamics::RigidBodyHandle, geometry::ColliderHandle};
 
@@ -9,7 +9,7 @@ pub struct PhysProjectile {
 	pub content: Projectile,
 
 	/// This projectile's sprite animation state
-	anim: AnimAutomaton,
+	anim: SpriteAutomaton,
 
 	/// The remaining lifetime of this projectile, in seconds
 	pub lifetime: f32,
@@ -40,7 +40,7 @@ impl PhysProjectile {
 		let size_rng = content.size_rng;
 		let lifetime = content.lifetime;
 		PhysProjectile {
-			anim: AnimAutomaton::new(ct, content.sprite),
+			anim: SpriteAutomaton::new(ct, content.sprite),
 			rigid_body,
 			collider,
 			content,

crates/system/src/phys/objects/ship.rs

@@ -1,5 +1,5 @@
 use galactica_content::{
-	AnimAutomaton, AnimationState, Content, EnginePoint, FactionHandle, OutfitHandle, ShipHandle,
+	AnimationState, Content, EnginePoint, FactionHandle, OutfitHandle, ShipHandle, SpriteAutomaton,
 };
 use nalgebra::{point, vector, Rotation2, Vector2};
 use rand::Rng;
@@ -56,10 +56,10 @@ pub struct PhysSimShip {
 	pub(crate) data: ShipData,
 
 	/// This ship's sprite animation state
-	anim: AnimAutomaton,
+	anim: SpriteAutomaton,
 
 	/// Animation state for each of this ship's engines
-	engine_anim: Vec<(EnginePoint, AnimAutomaton)>,
+	engine_anim: Vec<(EnginePoint, SpriteAutomaton)>,
 
 	/// This ship's controls
 	pub(crate) controls: ShipControls,
@@ -83,7 +83,7 @@ impl PhysSimShip {
 	) -> Self {
 		let ship_ct = ct.get_ship(handle);
 		PhysSimShip {
-			anim: AnimAutomaton::new(ct, ship_ct.sprite),
+			anim: SpriteAutomaton::new(ct, ship_ct.sprite),
 			rigid_body,
 			collider,
 			data: ShipData::new(ct, handle, faction, personality),
@@ -273,7 +273,7 @@ impl PhysSimShip {
 			.get_ship(self.data.get_content())
 			.engines
 			.iter()
-			.map(|e| (e.clone(), AnimAutomaton::new(ct, flare)))
+			.map(|e| (e.clone(), SpriteAutomaton::new(ct, flare)))
 			.collect();
 	}
 
@@ -300,7 +300,7 @@ impl PhysSimShip {
 	}
 
 	/// Get this ship's engine animations
-	pub fn iter_engine_anim(&self) -> impl Iterator<Item = &(EnginePoint, AnimAutomaton)> {
+	pub fn iter_engine_anim(&self) -> impl Iterator<Item = &(EnginePoint, SpriteAutomaton)> {
 		self.engine_anim.iter()
 	}