use std::collections::HashMap;
use std::sync::Arc;
#[derive(Debug, Default, Clone)]
pub struct SpriteManager {
sprites: HashMap<Arc<str>, Sprite>,
sprite_list: Vec<(u8, Arc<str>)>,
}
#[derive(Debug, Clone)]
pub struct Sprite {
texture: Arc<str>,
x: f32,
y: f32,
z: u8,
width: f32,
height: f32,
}
impl SpriteManager {
pub fn new() -> Self {
Self {
sprites: HashMap::new(),
sprite_list: Vec::new(),
}
}
pub fn with_capacity(capacity: usize) -> Self {
Self {
sprites: HashMap::with_capacity(capacity),
sprite_list: Vec::with_capacity(capacity),
}
}
pub fn add_sprite(&mut self, name: Arc<str>, sprite: Sprite) {
let z = sprite.z;
self.sprites.insert(name.clone(), sprite);
self.sprite_list.push((z, name));
}
pub fn clear(&mut self) {
self.sprites.clear();
self.sprite_list.clear();
}
pub fn remove_sprite(&mut self, name: Arc<str>) {
self.sprites.remove(&name);
self.sprite_list.retain(|(_, n)| name != n.clone());
}
pub fn get_mut_sprite(&mut self, name: &str) -> Option<&mut Sprite> {
self.sprites.get_mut(name)
}
pub fn set_sprite_z(&mut self, name: Arc<str>, new_z: u8) -> Option<()> {
let sprite = self.sprites.get_mut(&name)?;
sprite.z = new_z;
for (depth, n) in &mut self.sprite_list {
if n.clone() == name {
*depth = new_z;
}
}
Some(())
}
fn sort(&mut self) {
// in case it's unclear, this is insertion sort
// the list is usually already sorted, so this is the most efficient algorithm
for i in 0..self.sprite_list.len() {
let t = self.sprite_list[i].clone();
let mut j = i;
while j > 0 && self.sprite_list[j - 1].0 > t.0 {
self.sprite_list[j] = self.sprite_list[j - 1].clone();
j -= 1;
}
self.sprite_list[j] = t;
}
}
pub fn sorted_sprites(&mut self) -> Vec<Sprite> {
self.sort();
let mut sprites = Vec::new();
for (_, sprite) in &self.sprite_list {
// i don't like accessing the hashmap every time, but i can't think
// of anything better
sprites.push(self.sprites[sprite].clone());
}
sprites
}
}
impl Sprite {
pub fn new(x: f32, y: f32, z: u8, width: f32, height: f32, texture: Arc<str>) -> Self {
Self {
texture,
x,
y,
z,
width,
height,
}
}
pub fn x(&self) -> f32 {
self.x
}
pub fn y(&self) -> f32 {
self.y
}
pub fn z(&self) -> u8 {
self.z
}
pub fn width(&self) -> f32 {
self.width
}
pub fn height(&self) -> f32 {
self.height
}
pub fn texture_name(&self) -> &Arc<str> {
&self.texture
}
pub fn set_x(&mut self, x: f32) {
self.x = x;
}
pub fn set_y(&mut self, y: f32) {
self.y = y;
}
pub fn set_width(&mut self, width: f32) {
self.width = width;
}
pub fn set_height(&mut self, height: f32) {
self.height = height;
}
pub fn set_texture(&mut self, texture_name: Arc<str>) {
self.texture = texture_name;
}
}
|
