galactica
/
Galactica
1
0
Fork 0
Code Issues Releases Activity

Compare commits

base: galactica:d09158a324b2542510b7d73610150737f33343a2
Branches Tags
galactica:master
..
compare: galactica:57f2b97f40db5719ee7c961468b38463482244aa
Branches Tags
galactica:master

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

20 changed files with 207 additions and 503 deletions
Show Stats Expand all files Collapse all files

1
Cargo.lock generated
View File

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

1
Cargo.toml
View File

@ -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"

2
TODO.md
View File

@ -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

1
crates/content/Cargo.toml
View File

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

161
crates/content/src/spriteautomaton.rs → crates/content/src/animautomaton.rs
View File

@ -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_fade = 0.0;
self.current_frame = current_section.frames.len() - 1;
}
}
self.current_edge_duration = 1.0;
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 => {
SectionEdge::Restart => {
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 {
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,21 +182,18 @@ impl SpriteAutomaton {
if let Some(e) = self.next_edge_override {
self.take_edge(ct, e);
}
return;
}
}
AnimDirection::Down => {
self.current_edge_progress += t;
// We're stepping foward and finished this frame
if self.current_edge_progress > self.current_edge_duration {
// (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 {
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 {
let e = {
if self.next_edge_override.is_some() {
@ -276,20 +204,21 @@ impl SpriteAutomaton {
};
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 {
// (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;
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;
} else {
let e = {
if self.next_edge_override.is_some() {
@ -300,8 +229,10 @@ impl SpriteAutomaton {
};
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,
};
}
}

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

@ -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

8
crates/content/src/part/config.rs
View File

@ -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

67
crates/content/src/part/outfit.rs
View File

@ -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))?,
)
}
};
}

137
crates/content/src/part/sprite.rs
View File

@ -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() {

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

@ -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)?;

15
crates/packer/src/atlasset.rs
View File

@ -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 {
self.index
.path_map
.insert(p.to_path_buf(), self.index.index.len() as u32);
self.index.index.push(SpriteAtlasImage {
true_size: image_dim,
// Add one to account for hidden texture
idx: NonZeroU32::new(self.index.len() as u32 + 1).unwrap(),
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);
}

41
crates/packer/src/lib.rs
View File

@ -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);
}
}

69
crates/render/shaders/object.wgsl
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
@ -113,41 +113,19 @@ 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
);
}
// 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_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);
@ -155,12 +133,7 @@ fn vertex_main(
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);
@ -170,7 +143,6 @@ fn vertex_main(
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;
}

36
crates/render/shaders/ui.wgsl
View File

@ -33,12 +33,12 @@ 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;
@ -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;
}

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

@ -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,

1
crates/render/src/shaderprocessor.rs
View File

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

12
crates/render/src/texturearray.rs
View File

@ -112,15 +112,8 @@ 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 {
let image = ct.get_image(*idx);
image_locations.data[*idx as usize] = AtlasImageLocation {
xpos: image.x,
ypos: image.y,
width: image.w,
@ -131,7 +124,6 @@ impl TextureArray {
}
}
}
}
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,

1
crates/render/src/vertexbuffer/types.rs
View File

@ -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,

6
crates/system/src/phys/objects/projectile.rs
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 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,

12
crates/system/src/phys/objects/ship.rs
View File

@ -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()
}