Cargo.lock

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

Cargo.toml

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

TODO.md

@@ -1,6 +1,7 @@
 # Specific projects
 
 ## Currently working on:
+ - first: fix animation transition timings
  - first: fix particles & physics
  - clickable buttons
  - planet outfitter
@@ -217,7 +218,6 @@
  - 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,4 +27,3 @@ walkdir = { workspace = true }
 nalgebra = { workspace = true }
 image = { workspace = true }
 rapier2d = { workspace = true }
-lazy_static = { workspace = true }

crates/content/src/animautomaton.rs

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

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: NonZeroU32) -> &SpriteAtlasImage {
-		&self.sprite_atlas.get_by_idx(idx)
+	pub fn get_image(&self, idx: u32) -> &SpriteAtlasImage {
+		&self.sprite_atlas.index[idx as usize]
 	}
 
 	/// Get an outfit from a handle

crates/content/src/part/config.rs

@@ -1,4 +1,4 @@
-use std::{num::NonZeroU32, path::PathBuf};
+use std::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.get_idx_by_path(&self.starfield.texture) {
-				Some(s) => s,
+			let starfield_texture = match atlas.path_map.get(&self.starfield.texture) {
+				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: NonZeroU32,
+	pub starfield_texture: u32,
 
 	/// 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,
-	SectionEdge,
+	StartEdge,
 };
 
 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<SectionEdge>,
+	pub engine_flare_on_start: Option<StartEdge>,
 
 	/// Jump to this edge when engines turn off
-	pub engine_flare_on_stop: Option<SectionEdge>,
+	pub engine_flare_on_stop: Option<StartEdge>,
 
 	/// Shield hit points
 	pub shield_strength: f32,
@@ -289,75 +289,30 @@ 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();
-						let mut e = x
-							.resolve_as_edge(sprite_handle, build_context, 0.0)
-							.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)
+						Some(
+							x.resolve_as_start(sprite_handle, build_context)
+								.with_context(|| format!("in outfit `{}`", outfit_name))?,
+						)
 					}
 				};
 
-				// 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();
-						let mut e = x
-							.resolve_as_edge(sprite_handle, build_context, 0.0)
-							.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)
+						Some(
+							x.resolve_as_start(sprite_handle, build_context)
+								.with_context(|| format!("in outfit `{}`", outfit_name))?,
+						)
 					}
 				};
 			}

crates/content/src/part/sprite.rs

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

crates/galactica/src/main.rs

@@ -17,20 +17,7 @@ use winit::{
 	window::WindowBuilder,
 };
 
-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<()> {
+fn main() -> Result<()> {
 	let cache_dir = Path::new(ASSET_CACHE);
 	fs::create_dir_all(cache_dir)?;
 

crates/packer/src/atlasset.rs

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

crates/packer/src/lib.rs

@@ -2,11 +2,7 @@
 
 //! This crate creates texture atlases from an asset tree.
 
-use std::{
-	collections::HashMap,
-	num::NonZeroU32,
-	path::{Path, PathBuf},
-};
+use std::{collections::HashMap, path::PathBuf};
 
 use serde::{Deserialize, Serialize};
 
@@ -17,9 +13,8 @@ pub struct SpriteAtlasImage {
 	/// This is an index in SpriteAtlas.atlas_list
 	pub atlas: u32,
 
-	/// A globally unique, consecutively numbered index for this sprite.
-	/// This is nonzero because index zero is reserved for the "hidden" texture.
-	pub idx: NonZeroU32,
+	/// A globally unique, consecutively numbered index for this sprite
+	pub idx: u32,
 
 	/// The size of this image, in pixels
 	pub true_size: (u32, u32),
@@ -46,10 +41,10 @@ pub struct SpriteAtlasImage {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SpriteAtlas {
 	/// The images in this atlas
-	pub(crate) index: Vec<SpriteAtlasImage>,
+	pub index: Vec<SpriteAtlasImage>,
 
 	/// Map paths to image indices
-	path_map: HashMap<PathBuf, NonZeroU32>,
+	pub path_map: HashMap<PathBuf, u32>,
 
 	/// The file names of the atlas textures we've generated
 	pub atlas_list: Vec<String>,
@@ -64,30 +59,4 @@ 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,63 +113,35 @@ fn vertex_main(
 ) -> VertexOutput {
 	var out: VertexOutput;
 
-	// Pick texture size by the size of the visible texture
-	// (texture index 0 is special, it's the "hidden" texture)
-	if instance.texture_index.x == 0u && instance.texture_index.y == 0u {
-		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
-		);
-	}
-
+	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;
 
-	// Texture 0 is special, it's the empty texture
-	if instance.texture_index.x == 0u {
-		out.texture_index_a = 0u;
-		out.texture_coords_a = vec2(0.0, 0.0);
-	} else {
-		let t = global_atlas[instance.texture_index.x];
-		out.texture_index_a = t.atlas_texture;
-		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 t = global_atlas[instance.texture_index.x];
+	out.texture_index_a = u32(t.atlas_texture);
+	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);
 	}
 
-	if instance.texture_index.y == 0u {
-		out.texture_index_b = u32(0u);
-		out.texture_coords_b = vec2(0.0, 0.0);
-	} else {
-		let b = global_atlas[instance.texture_index.y];
-		out.texture_index_b = u32(b.atlas_texture);
-		out.texture_coords_b = vec2(b.xpos, b.ypos);
-		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);
-		}
+	let b = global_atlas[instance.texture_index.y];
+	out.texture_index_b = u32(b.atlas_texture);
+	out.texture_coords_b = vec2(b.xpos, b.ypos);
+	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;
@@ -178,42 +150,19 @@ fn vertex_main(
 
 @fragment
 fn fragment_main(in: VertexOutput) -> @location(0) vec4<f32> {
-
-	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(
+	return mix(
+		textureSampleLevel(
 			texture_array[in.texture_index_a],
 			sampler_array[0],
 			in.texture_coords_a,
 			0.0
-		).rgba;
-	}
-
-
-	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(
+		).rgba,
+		textureSampleLevel(
 			texture_array[in.texture_index_b],
 			sampler_array[0],
 			in.texture_coords_b,
 			0.0
-		).rgba;
-	}
-
-	let color = mix(
-		texture_a,
-		texture_b,
+		).rgba,
 		in.tween
 	);
-
-
-	return color;
-}
+}

crates/render/shaders/ui.wgsl

@@ -33,13 +33,13 @@ var sampler_array: binding_array<sampler>;
 
 // INCLUDE: anchor.wgsl
 
-
-fn transform_vertex(
+@vertex
+fn vertex_main(
+	vertex: VertexInput,
 	instance: InstanceInput,
-	vertex_position: vec3<f32>,
-	texture_index: u32,
-) -> vec4<f32> {
-	
+) -> VertexOutput {
+
+
 	let window_dim = global_data.window_size / global_data.window_scale.x;
 	let scale = instance.size / window_dim.y;
 	let aspect = (
@@ -50,8 +50,8 @@ fn transform_vertex(
 	// 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.y * scale
+		vertex.position.x * scale * aspect,
+		vertex.position.y * scale
 	);
 
 	// Apply rotation (and adjust sprite angle, since sprites point north)
@@ -72,29 +72,12 @@ fn transform_vertex(
 		vec2(instance.size * aspect, instance.size)
 	);
 
-	return vec4<f32>(pos, 0.0, 1.0);
-}
-
-@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.position = vec4<f32>(pos, 1.0, 1.0);
 	out.color_transform = instance.color_transform;
 
 
+
 	// TODO: function to get texture from sprite
 	// Pick texture frame
 	let t = global_atlas[instance.texture_index.x];
@@ -125,6 +108,7 @@ 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.into(), 0],
+				starfield_sprite: [input.ct.get_config().starfield_texture, 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,6 +1,5 @@
 use crate::globaluniform::GlobalUniform;
 
-// TODO: build script?
 /// Basic wgsl preprocesser
 pub(crate) fn preprocess_shader(
 	shader: &str,

crates/render/src/texturearray.rs

@@ -112,23 +112,15 @@ impl TextureArray {
 		for sprite in &ct.sprites {
 			for section in sprite.iter_sections() {
 				for idx in &section.frames {
-					// Some atlas entries may be written twice here,
-					// but that's not really a problem. They're all the same!
-					//
-					// This happens rarely---only when two different sections
-					// use the same frame.
-					let idx = NonZeroU32::new(*idx);
-					if idx.is_some() {
-						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(),
-						};
-					}
+					let image = ct.get_image(*idx);
+					image_locations.data[*idx 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,7 +152,6 @@ 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::{AnimationState, Content, FactionHandle, Projectile, SpriteAutomaton};
+use galactica_content::{AnimAutomaton, AnimationState, Content, FactionHandle, Projectile};
 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: SpriteAutomaton,
+	anim: AnimAutomaton,
 
 	/// 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: SpriteAutomaton::new(ct, content.sprite),
+			anim: AnimAutomaton::new(ct, content.sprite),
 			rigid_body,
 			collider,
 			content,

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

@@ -1,5 +1,5 @@
 use galactica_content::{
-	AnimationState, Content, EnginePoint, FactionHandle, OutfitHandle, ShipHandle, SpriteAutomaton,
+	AnimAutomaton, AnimationState, Content, EnginePoint, FactionHandle, OutfitHandle, ShipHandle,
 };
 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: SpriteAutomaton,
+	anim: AnimAutomaton,
 
 	/// Animation state for each of this ship's engines
-	engine_anim: Vec<(EnginePoint, SpriteAutomaton)>,
+	engine_anim: Vec<(EnginePoint, AnimAutomaton)>,
 
 	/// This ship's controls
 	pub(crate) controls: ShipControls,
@@ -83,7 +83,7 @@ impl PhysSimShip {
 	) -> Self {
 		let ship_ct = ct.get_ship(handle);
 		PhysSimShip {
-			anim: SpriteAutomaton::new(ct, ship_ct.sprite),
+			anim: AnimAutomaton::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(), SpriteAutomaton::new(ct, flare)))
+			.map(|e| (e.clone(), AnimAutomaton::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, SpriteAutomaton)> {
+	pub fn iter_engine_anim(&self) -> impl Iterator<Item = &(EnginePoint, AnimAutomaton)> {
 		self.engine_anim.iter()
 	}