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-util",
"image",
"lazy_static",
"nalgebra",
"rapier2d",
"serde",

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"

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

View File

@ -27,4 +27,3 @@ walkdir = { workspace = true }
nalgebra = { workspace = true }
image = { 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?
#[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,
};
}
}

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

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

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

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

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

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

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

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

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

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,

View File

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

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,

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,

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,

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