Compare commits

..

No commits in common. "d09158a324b2542510b7d73610150737f33343a2" and "57f2b97f40db5719ee7c961468b38463482244aa" have entirely different histories.

20 changed files with 207 additions and 503 deletions

1
Cargo.lock generated
View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -4,7 +4,7 @@ use std::collections::HashMap;
use crate::{ use crate::{
handle::SpriteHandle, Content, ContentBuildContext, EffectHandle, OutfitHandle, OutfitSpace, handle::SpriteHandle, Content, ContentBuildContext, EffectHandle, OutfitHandle, OutfitSpace,
SectionEdge, StartEdge,
}; };
pub(crate) mod syntax { pub(crate) mod syntax {
@ -148,10 +148,10 @@ pub struct Outfit {
pub engine_flare_sprite: Option<SpriteHandle>, pub engine_flare_sprite: Option<SpriteHandle>,
/// Jump to this edge when engines turn on /// 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 /// 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 /// Shield hit points
pub shield_strength: f32, pub shield_strength: f32,
@ -289,75 +289,30 @@ impl crate::Build for Outfit {
}; };
o.engine_thrust = engine.thrust; o.engine_thrust = engine.thrust;
o.engine_flare_sprite = Some(sprite_handle); 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 = { o.engine_flare_on_start = {
let x = engine.flare.on_start; let x = engine.flare.on_start;
if x.is_none() { if x.is_none() {
None None
} else { } else {
let x = x.unwrap(); let x = x.unwrap();
let mut e = x Some(
.resolve_as_edge(sprite_handle, build_context, 0.0) x.resolve_as_start(sprite_handle, build_context)
.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 = { o.engine_flare_on_stop = {
let x = engine.flare.on_stop; let x = engine.flare.on_stop;
if x.is_none() { if x.is_none() {
None None
} else { } else {
let x = x.unwrap(); let x = x.unwrap();
let mut e = x Some(
.resolve_as_edge(sprite_handle, build_context, 0.0) x.resolve_as_start(sprite_handle, build_context)
.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)
} }
}; };
} }

View File

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

View File

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

View File

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

View File

@ -2,11 +2,7 @@
//! This crate creates texture atlases from an asset tree. //! This crate creates texture atlases from an asset tree.
use std::{ use std::{collections::HashMap, path::PathBuf};
collections::HashMap,
num::NonZeroU32,
path::{Path, PathBuf},
};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -17,9 +13,8 @@ pub struct SpriteAtlasImage {
/// This is an index in SpriteAtlas.atlas_list /// This is an index in SpriteAtlas.atlas_list
pub atlas: u32, pub atlas: u32,
/// A globally unique, consecutively numbered index for this sprite. /// A globally unique, consecutively numbered index for this sprite
/// This is nonzero because index zero is reserved for the "hidden" texture. pub idx: u32,
pub idx: NonZeroU32,
/// The size of this image, in pixels /// The size of this image, in pixels
pub true_size: (u32, u32), pub true_size: (u32, u32),
@ -46,10 +41,10 @@ pub struct SpriteAtlasImage {
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SpriteAtlas { pub struct SpriteAtlas {
/// The images in this atlas /// The images in this atlas
pub(crate) index: Vec<SpriteAtlasImage>, pub index: Vec<SpriteAtlasImage>,
/// Map paths to image indices /// 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 /// The file names of the atlas textures we've generated
pub atlas_list: Vec<String>, pub atlas_list: Vec<String>,
@ -64,30 +59,4 @@ impl SpriteAtlas {
atlas_list: Vec::new(), 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);
}
} }

View File

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

View File

@ -33,12 +33,12 @@ var sampler_array: binding_array<sampler>;
// INCLUDE: anchor.wgsl // INCLUDE: anchor.wgsl
@vertex
fn transform_vertex( fn vertex_main(
vertex: VertexInput,
instance: InstanceInput, instance: InstanceInput,
vertex_position: vec3<f32>, ) -> VertexOutput {
texture_index: u32,
) -> vec4<f32> {
let window_dim = global_data.window_size / global_data.window_scale.x; let window_dim = global_data.window_size / global_data.window_scale.x;
let scale = instance.size / window_dim.y; let scale = instance.size / window_dim.y;
@ -50,8 +50,8 @@ fn transform_vertex(
// Apply scale and sprite aspect // Apply scale and sprite aspect
// Note that our mesh starts centered at (0, 0). This is important! // Note that our mesh starts centered at (0, 0). This is important!
var pos: vec2<f32> = vec2( 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) // Apply rotation (and adjust sprite angle, since sprites point north)
@ -72,29 +72,12 @@ fn transform_vertex(
vec2(instance.size * aspect, instance.size) 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; var out: VertexOutput;
out.position = pos; out.position = vec4<f32>(pos, 1.0, 1.0);
out.color_transform = instance.color_transform; out.color_transform = instance.color_transform;
// TODO: function to get texture from sprite // TODO: function to get texture from sprite
// Pick texture frame // Pick texture frame
let t = global_atlas[instance.texture_index.x]; let t = global_atlas[instance.texture_index.x];
@ -125,6 +108,7 @@ fn vertex_main(
out.mask_index = vec2(0u, 0u); out.mask_index = vec2(0u, 0u);
} }
return out; return out;
} }

View File

@ -306,7 +306,7 @@ impl<'a> super::GPUState {
], ],
window_scale: [self.state.window.scale_factor() as f32, 0.0], window_scale: [self.state.window.scale_factor() as f32, 0.0],
window_aspect: [self.state.window_aspect, 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_tile_size: [input.ct.get_config().starfield_size, 0.0],
starfield_size_limits: [ starfield_size_limits: [
input.ct.get_config().starfield_min_size, input.ct.get_config().starfield_min_size,

View File

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

View File

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

View File

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

View File

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

View File

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