let mut n = 22usize;

wr!(full => "pub mod full {{");

wr!(quar => "pub mod quar {{");

// forced to do this because try_into isnt const

wr!(eigh => "pub mod eigh {{");

for mut file in [&full, &quar, &eigh] {

wr!(file => "use crate::utils::Image;");

for i in 1..=16 {

}

}

for e in walkdir.into_iter().filter_map(Result::ok) {

let path = e.path();

if path.is_file() && let Some(e) = path.extension() && e == "png" {

if path.file_name().unwrap().to_str().unwrap().contains("-liquid.png") {

continue

}

if f.contains("bottom") || f.contains("-team") || f.contains("-end") || f.contains("stack") {

continue;

}

let path = kebab2bigsnek(path.with_extension("").file_name().unwrap().to_str().unwrap());

if matches!(path.as_str(), "CLIFF_CRUSHER_ROTATOR" | "NEOPLASIA_REACTOR_CENTER" | "FLUX_REACTOR_MID" | "EDGE" | "PHASE_CONVEYOR_BRIDGE" | "BRIDGE_ARROW" | "DUCT_BRIDGE_BRIDGE" | "DUCT_BRIDGE_ARROW" | "LAUNCHPOD" | "BRIDGE_CONVEYOR_BRIDGE" | "BRIDGE_CONVEYOR_ARROW" | "PHASE_CONVEYOR_ARROW" | "REINFORCED_BRIDGE_CONDUIT_ARROW" | "REINFORCED_BRIDGE_CONDUIT_BRIDGE" | "PHASE_CONDUIT_BRIDGE" | "BRIDGE_CONDUIT_ARROW" | "PHASE_CONDUIT_ARROW" | "BRIDGE_CONDUIT_BRIDGE" | "PLATED_CONDUIT_CAP") {

continue

macro_rules! writ {

($ext:ident / $scale:literal) => {

let mut buf = File::create(o.join(n.to_string() + "-" + stringify!($ext))).unwrap();

let new = if $scale == 1 {

p.clone()

} else {

&p,

mx / $scale,

my / $scale,

image::imageops::Nearest,

};

let x = new.width();

let y = new.height();

};

}

writ!(full / 1);

$field, BlockLogicEnum::BasicBlock(BasicBlock::new($size, true, &[])), Some(crate::data::renderer::load!($field))

); }

};

}

// pub(self) use make_register;

make_register! {

"ore-beryllium": 1;

"ore-copper": 1;

"ore-lead": 1;

"ore-wall-thorium": 1;

"ore-wall-tungsten": 1;

"graphitic-wall": 1;

"boulder": 1;

"arkyic-wall": 1;

"beryllic-stone-wall": 1;

"carbon-wall": 1;

"cliff": 1;

"crystalline-stone-wall": 1;

"dacite-wall": 1;

"dark-metal": 1;

"dirt-wall": 1;

"dune-wall": 1;

"ferric-stone-wall": 1;

"ice-wall": 1;

"pebbles": 1;

"pine": 1;

"red-diamond-wall": 1;

"red-ice-wall": 1;

"red-stone-wall": 1;

"regolith-wall": 1;

"rhyolite-wall": 1;

"salt-wall": 1;

"sand-wall": 1;

"shale-wall": 1;

"snow-pine": 1;

"snow-wall": 1;

"spawn": 1;

"spore-pine": 1;

"spore-wall": 1;

"stone-wall": 1;

"yellow-stone-wall": 1;

// props

"yellow-stone-boulder": 1;

"vibrant-crystal-cluster": 1;

"crystal-orbs": 1;

// end tall

"build2": 1;

"build3": 1;

"build4": 1;

}

#[inline]

lo!(self.floor => [

| "darksand"

| "sand-floor"

/// Draw the floor of this tile

#[must_use]

let mut floor = self.floor(s);

if self.has_ore() {

}

floor

}

#[macro_export]

macro_rules! load {

($name:literal, $scale:expr) => { paste::paste! {

$crate::utils::image::ImageHolder::from(match $scale {

$crate::data::renderer::Scale::Quarter => &$crate::data::renderer::quar::[<$name:snake:upper>],

// canvas has a shadow

let p2 = unsafe { canvas.pixel(x, y) };

let p = unsafe { bg.pixel_mut(x, y) };

}

}

}

}

slice_as_chunks,

slice_swap_unchecked,

portable_simd,

let_chains,

effects,

test

}

use assert_unchecked;

unsafe fn repeated(&self, x: u32, y: u32) -> Self::Output {

let mut img = Image::alloc(x, y); // could probably optimize this a ton but eh

for x in 0..(x / self.width()) {

for y in 0..(y / self.height()) {

// SAFETY: caller upholds

unsafe { a.overlay_at(self, x * self.width(), y * self.height()) };

}

}

}

impl Image<Vec<u8>, 3> {

#[cfg(feature = "bin")]

pub fn save(&self, f: impl AsRef<std::path::Path>) {

use super::*;

#[test]

fn scale() {

let mut from = Image::alloc(6, 6);

unsafe { from.set_pixel(3, 3, [255, 255, 255, 255]) };

}

}

impl Overlay<Image<&[u8], 4>> for Image<&mut [u8], 3> {

unsafe fn overlay(&mut self, with: &Image<&[u8], 4>) -> &mut Self {

unsafe { assert_unchecked!(self.width() == with.width()) };

use crate::{data::renderer::Scale, load};

#[bench]

fn overlay_4on3at(bench: &mut Bencher) {

let mut a: Image<_, 3> = Image::new(

v.as_mut_slice(),

);

bench.iter(|| unsafe {

});

}

#[bench]

fn overlay_4on4at(bench: &mut Bencher) {

let mut a: Image<_, 4> = Image::new(

v.as_mut_slice(),

);

bench.iter(|| unsafe {

});

}

}