mirror of
https://github.com/italicsjenga/agb.git
synced 2024-12-25 09:11:34 +11:00
190 lines
5.1 KiB
Rust
190 lines
5.1 KiB
Rust
use crate::colour::Colour;
|
|
use std::collections::HashSet;
|
|
|
|
const MAX_COLOURS: usize = 256;
|
|
const MAX_COLOURS_PER_PALETTE: usize = 16;
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
|
|
pub(crate) struct Palette16 {
|
|
colours: Vec<Colour>,
|
|
}
|
|
|
|
impl Palette16 {
|
|
pub fn new() -> Self {
|
|
Palette16 {
|
|
colours: Vec::with_capacity(MAX_COLOURS_PER_PALETTE),
|
|
}
|
|
}
|
|
|
|
pub fn add_colour(&mut self, colour: Colour) -> bool {
|
|
if self.colours.contains(&colour) {
|
|
return false;
|
|
}
|
|
|
|
if self.colours.len() == MAX_COLOURS_PER_PALETTE {
|
|
panic!("Can have at most 16 colours in a single palette");
|
|
}
|
|
self.colours.push(colour);
|
|
true
|
|
}
|
|
pub fn colour_index(&self, colour: Colour) -> u8 {
|
|
self.colours
|
|
.iter()
|
|
.position(|c| *c == colour)
|
|
.expect("Can't get a colour index without it existing") as u8
|
|
}
|
|
|
|
fn union_length(&self, other: &Palette16) -> usize {
|
|
self.colours
|
|
.iter()
|
|
.chain(&other.colours)
|
|
.collect::<HashSet<_>>()
|
|
.len()
|
|
}
|
|
|
|
fn is_satisfied_by(&self, other: &Palette16) -> bool {
|
|
self.colours
|
|
.iter()
|
|
.collect::<HashSet<_>>()
|
|
.is_subset(&other.colours.iter().collect::<HashSet<_>>())
|
|
}
|
|
}
|
|
|
|
impl IntoIterator for Palette16 {
|
|
type Item = Colour;
|
|
type IntoIter = std::vec::IntoIter<Self::Item>;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
self.colours.into_iter()
|
|
}
|
|
}
|
|
|
|
pub(crate) struct Palette16Optimiser {
|
|
palettes: Vec<Palette16>,
|
|
colours: Vec<Colour>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct Palette16OptimisationResults {
|
|
pub optimised_palettes: Vec<Palette16>,
|
|
pub assignments: Vec<usize>,
|
|
}
|
|
|
|
impl Palette16Optimiser {
|
|
pub fn new() -> Self {
|
|
Palette16Optimiser {
|
|
palettes: vec![],
|
|
colours: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn add_palette(&mut self, palette: Palette16) {
|
|
self.palettes.push(palette.clone());
|
|
|
|
for colour in palette.colours {
|
|
if self.colours.contains(&colour) {
|
|
continue;
|
|
}
|
|
|
|
self.colours.push(colour);
|
|
}
|
|
|
|
if self.colours.len() > MAX_COLOURS {
|
|
panic!("Cannot have over 256 colours");
|
|
}
|
|
}
|
|
|
|
pub fn optimise_palettes(
|
|
&self,
|
|
transparent_colour: Option<Colour>,
|
|
) -> Palette16OptimisationResults {
|
|
let mut assignments = vec![0; self.palettes.len()];
|
|
let mut optimised_palettes = vec![];
|
|
|
|
let mut unsatisfied_palettes = self
|
|
.palettes
|
|
.iter()
|
|
.cloned()
|
|
.collect::<HashSet<Palette16>>();
|
|
|
|
while !unsatisfied_palettes.is_empty() {
|
|
let palette = self.find_maximal_palette_for(&unsatisfied_palettes, transparent_colour);
|
|
|
|
for test_palette in unsatisfied_palettes.clone() {
|
|
if test_palette.is_satisfied_by(&palette) {
|
|
unsatisfied_palettes.remove(&test_palette);
|
|
}
|
|
}
|
|
|
|
for (i, overall_palette) in self.palettes.iter().enumerate() {
|
|
if overall_palette.is_satisfied_by(&palette) {
|
|
assignments[i] = optimised_palettes.len();
|
|
}
|
|
}
|
|
|
|
optimised_palettes.push(palette);
|
|
|
|
if optimised_palettes.len() == MAX_COLOURS / MAX_COLOURS_PER_PALETTE {
|
|
panic!("Failed to find covering palettes");
|
|
}
|
|
}
|
|
|
|
Palette16OptimisationResults {
|
|
optimised_palettes,
|
|
assignments,
|
|
}
|
|
}
|
|
|
|
fn find_maximal_palette_for(
|
|
&self,
|
|
unsatisfied_palettes: &HashSet<Palette16>,
|
|
transparent_colour: Option<Colour>,
|
|
) -> Palette16 {
|
|
let mut palette = Palette16::new();
|
|
|
|
if let Some(transparent_colour) = transparent_colour {
|
|
palette.add_colour(transparent_colour);
|
|
}
|
|
|
|
loop {
|
|
let mut colour_usage = vec![0; MAX_COLOURS];
|
|
let mut a_colour_is_used = false;
|
|
|
|
for current_palette in unsatisfied_palettes {
|
|
if palette.union_length(current_palette) > MAX_COLOURS_PER_PALETTE {
|
|
continue;
|
|
}
|
|
|
|
for colour in ¤t_palette.colours {
|
|
if palette.colours.contains(colour) {
|
|
continue;
|
|
}
|
|
|
|
if let Some(colour_index) = self.colours.iter().position(|c| c == colour) {
|
|
colour_usage[colour_index] += 1;
|
|
a_colour_is_used = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if !a_colour_is_used {
|
|
return palette;
|
|
}
|
|
|
|
let best_index = colour_usage
|
|
.iter()
|
|
.enumerate()
|
|
.max_by(|(_, usage1), (_, usage2)| usage1.cmp(usage2))
|
|
.unwrap()
|
|
.0;
|
|
|
|
let best_colour = self.colours[best_index];
|
|
|
|
palette.add_colour(best_colour);
|
|
if palette.colours.len() == MAX_COLOURS_PER_PALETTE {
|
|
return palette;
|
|
}
|
|
}
|
|
}
|
|
}
|