273 lines
6.9 KiB
Rust
273 lines
6.9 KiB
Rust
use anyhow::{bail, Context, Result};
|
|
use galactica_packer::{SpriteAtlas, SpriteAtlasImage};
|
|
use image::{imageops, GenericImageView, ImageBuffer, Rgba, RgbaImage};
|
|
use std::{
|
|
fs::File,
|
|
io::{Read, Write},
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
// TODO: article
|
|
// TODO: rework texturearray
|
|
// TODO: reasonable sprite sizes
|
|
// TODO: consistent naming
|
|
// TODO: parallelize
|
|
// spriteatlas: the big images
|
|
// texture: the same, what we load to wgpu
|
|
// image: a single file
|
|
// sprite: a possibly animated texture
|
|
|
|
pub struct AtlasSet {
|
|
/// The width of each atlas
|
|
texture_width: u32,
|
|
|
|
/// The height of each atlas
|
|
texture_height: u32,
|
|
|
|
/// Make at most this many atlases
|
|
/// Probably determined by the GPU
|
|
texture_limit: usize,
|
|
|
|
/// Keeps track of image files
|
|
index: SpriteAtlas,
|
|
|
|
/// Array of textures, grows as needed
|
|
texture_list: Vec<ImageBuffer<Rgba<u8>, Vec<u8>>>,
|
|
|
|
/// The size of the smallest image that didn't fit in each texture
|
|
image_max_sizes: Vec<[u32; 2]>,
|
|
|
|
/// (y-value, image size)
|
|
image_y_start: Vec<(u32, [u32; 2])>,
|
|
|
|
/// A list of used regions in each texture
|
|
/// Format: ([xpos, ypos], [width, height])
|
|
/// in pixels, with (0, 0) at top left
|
|
used_regions: Vec<Vec<([u32; 2], [u32; 2])>>,
|
|
|
|
/// Used to calculate packing efficiency
|
|
used_area: f64,
|
|
|
|
/// The root directory that contains all image files.
|
|
/// Files outside this directory will not be packed.
|
|
asset_root: PathBuf,
|
|
|
|
/// Leave an empty border this many pixels wide around each image
|
|
image_margin: u32,
|
|
}
|
|
|
|
impl AtlasSet {
|
|
pub fn new(
|
|
texture_width: u32,
|
|
texture_height: u32,
|
|
texture_limit: usize,
|
|
asset_root: &Path,
|
|
image_margin: u32,
|
|
) -> Self {
|
|
Self {
|
|
asset_root: asset_root.to_path_buf(),
|
|
texture_width,
|
|
texture_height,
|
|
texture_limit,
|
|
texture_list: Vec::new(),
|
|
image_max_sizes: Vec::new(),
|
|
used_regions: Vec::new(),
|
|
index: SpriteAtlas::new(),
|
|
used_area: 0f64,
|
|
image_y_start: Vec::new(),
|
|
image_margin,
|
|
}
|
|
}
|
|
|
|
/// Add a sprite to this atlas set
|
|
pub fn write_image(&mut self, path: &Path) -> Result<usize> {
|
|
let mut f = File::open(&path)?;
|
|
let mut bytes = Vec::new();
|
|
f.read_to_end(&mut bytes)
|
|
.with_context(|| format!("While reading file `{}`", path.display()))?;
|
|
let img = image::load_from_memory(&bytes)
|
|
.with_context(|| format!("While loading file `{}`", path.display()))?;
|
|
|
|
let image_dim = img.dimensions();
|
|
|
|
/*
|
|
TODO: seperate CLI argument to check these.
|
|
don't check this every run,because sometimes it's necessary. (for animated sprites!)
|
|
let mut transparent_border = true;
|
|
for (x, y, c) in img.pixels() {
|
|
if (x == 0 || y == 0 || x == img.width() - 1 || y == img.height() - 1) && c[3] != 0 {
|
|
transparent_border = false;
|
|
break;
|
|
}
|
|
}
|
|
if transparent_border {
|
|
println!("[WARNING] {} wastes space with a transmparent border",);
|
|
}
|
|
*/
|
|
|
|
let dim = [
|
|
image_dim.0 + 2 * self.image_margin,
|
|
image_dim.1 + 2 * self.image_margin,
|
|
];
|
|
|
|
let mut x = 0;
|
|
let mut y = 0;
|
|
let mut final_atlas_idx = None;
|
|
|
|
// Loop over atlas textures
|
|
'outer: for atlas_idx in 0..self.texture_limit {
|
|
if atlas_idx >= self.texture_list.len() {
|
|
// Start a new atlas
|
|
self.texture_list
|
|
.push(RgbaImage::new(self.texture_width, self.texture_height));
|
|
self.used_regions.push(Vec::new());
|
|
self.image_max_sizes.push([u32::MAX, u32::MAX]);
|
|
self.image_y_start.push((0, [u32::MAX, u32::MAX]));
|
|
}
|
|
|
|
// Optimization: save the smallest sprite that didn't fit in each atlas,
|
|
// and don't try to add similarly-sized sprites.
|
|
if dim[0] >= self.image_max_sizes[atlas_idx][0]
|
|
&& dim[1] >= self.image_max_sizes[atlas_idx][1]
|
|
{
|
|
continue 'outer;
|
|
}
|
|
|
|
x = 0;
|
|
y = 0;
|
|
if self.image_y_start.len() != 0 {
|
|
let (sy, sd) = self.image_y_start[atlas_idx];
|
|
if dim[0] >= sd[0] || dim[1] >= sd[1] {
|
|
y = sy;
|
|
}
|
|
}
|
|
|
|
let mut free = false;
|
|
let mut new;
|
|
'inner: while y < self.texture_height && !free {
|
|
new = ([x, y], dim);
|
|
free = true;
|
|
for r in &self.used_regions[atlas_idx] {
|
|
// If boxes overlap...
|
|
if r.0[0] < new.0[0] + new.1[0]
|
|
&& r.0[0] + r.1[0] > new.0[0]
|
|
&& r.0[1] < new.0[1] + new.1[1]
|
|
&& r.0[1] + r.1[1] > new.0[1]
|
|
{
|
|
// Skip the whole occupied area
|
|
x = r.1[0] + r.0[0];
|
|
if x + dim[0] >= self.texture_width {
|
|
y += 1;
|
|
x = 0;
|
|
}
|
|
free = false;
|
|
continue 'inner;
|
|
}
|
|
}
|
|
}
|
|
|
|
if y + dim[1] >= self.texture_height {
|
|
// This sprite didn't fit, move on to the next atlas
|
|
self.image_max_sizes[atlas_idx] = [dim[0] / 2, dim[1] / 2];
|
|
} else if free {
|
|
final_atlas_idx = Some(atlas_idx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
let atlas_idx = match final_atlas_idx {
|
|
None => bail!("textures didn't fit!"),
|
|
Some(s) => s,
|
|
};
|
|
|
|
// We found a spot for this image, write it.
|
|
imageops::overlay(
|
|
&mut self.texture_list[atlas_idx],
|
|
&img,
|
|
(x + self.image_margin).into(),
|
|
(y + self.image_margin).into(),
|
|
);
|
|
self.used_regions[atlas_idx].push(([x, y], dim));
|
|
self.used_area += dim[0] as f64 * dim[1] as f64;
|
|
|
|
let (sy, sd) = self.image_y_start[atlas_idx];
|
|
if dim[0] <= sd[0] && dim[1] <= sd[1] {
|
|
// Reset start y if both dimensions of this texture are smaller than the previous smallest texture
|
|
// We check for both, because that ensures that the smaller texture can tile the previous largest one.
|
|
self.image_y_start[atlas_idx] = (0, [dim[0] / 2, dim[1] / 2]);
|
|
} else {
|
|
self.image_y_start[atlas_idx] = (y.max(sy), sd);
|
|
}
|
|
|
|
let p = path.strip_prefix(&self.asset_root).with_context(|| {
|
|
format!(
|
|
"path `{}` is not relative to asset root `{}`",
|
|
path.display(),
|
|
self.asset_root.display()
|
|
)
|
|
})?;
|
|
|
|
self.index.index.insert(
|
|
p.to_path_buf(),
|
|
SpriteAtlasImage {
|
|
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);
|
|
}
|
|
|
|
pub fn save_files<F>(mut self, atlas_path: F, index_path: &Path) -> Result<()>
|
|
where
|
|
F: Fn(usize) -> PathBuf,
|
|
{
|
|
// Save atlases
|
|
for i in 0..self.texture_list.len() {
|
|
let path = atlas_path(i);
|
|
self.texture_list[i].save(&path)?;
|
|
self.index
|
|
.atlas_list
|
|
.push(path.file_name().unwrap().to_str().unwrap().to_owned());
|
|
}
|
|
|
|
// Save index
|
|
let toml = toml::to_string(&self.index)?;
|
|
let mut f = File::create(index_path)?;
|
|
f.write_all(toml.as_bytes())?;
|
|
return Ok(());
|
|
}
|
|
|
|
/*
|
|
pub fn get_width(&self) -> u32 {
|
|
self.texture_width
|
|
}
|
|
|
|
pub fn get_height(&self) -> u32 {
|
|
self.texture_height
|
|
}
|
|
|
|
pub fn get_limit(&self) -> usize {
|
|
self.texture_limit
|
|
}
|
|
|
|
pub fn get_used_area(&self) -> f64 {
|
|
self.used_area
|
|
}
|
|
|
|
pub fn num_textures(&self) -> usize {
|
|
self.texture_list.len()
|
|
}
|
|
*/
|
|
|
|
pub fn get_efficiency(&self) -> f64 {
|
|
self.used_area
|
|
/ (self.texture_height as f64
|
|
* self.texture_width as f64
|
|
* self.texture_list.len() as f64)
|
|
}
|
|
}
|