-version = "1.4.6"

-fast_image_resize = "2.7"

- let mut f = File::create(Path::new(&o).join("asset")).unwrap();

- let mut n = 1usize;

- f.write_all(b"phf::phf_map! {").unwrap();

- let mut s = String::new(); // idk write_all / write wasnt working

- let x = p.width();

- let y = p.height();

- let mut f = File::create(Path::new(&o).join(n.to_string())).unwrap();

- f.write_all(&p.into_raw()).unwrap();

- println!("writing {path:?}");

- s += &format!("\t\"{path}\" => r!(LazyLock::new(|| RgbaImage::from_vec({x}, {y}, include_bytes!(concat!(env!(\"OUT_DIR\"), \"/{n}\")).to_vec()).unwrap())),\n");

- f.write_all(s.as_bytes()).unwrap();

- f.write_all(b"}").unwrap();

- |_, name, _, ctx: Option<&RenderingContext>, rot: Rotation| {

- let ctx = ctx.unwrap(); // we set want_context to true

- tile(ctx, name, rot)

- },

- |_, name, _, ctx: Option<&RenderingContext>, rot| {

- let ctx = ctx.unwrap();

- tile(ctx, name, rot)

- },

-make_simple!(JunctionBlock => |_, _, _, buff: &mut DataRead| { read_directional_item_buffer(buff) });

-make_simple!(SimpleDuctBlock, |_, name, _, _, rot: Rotation| {

- let mut base = load("duct-base");

- let mut top = load(name);

- let edge = load(&format!("{name}-edge"));

- let gimme = |n: u8| load(&format!("{name}-{n}"));

- let mut p = load(name);

- if let Some(s) = Self::get_state(state) {

- let mut top = load(match name {

- "unit-cargo-unload-point" => "unit-cargo-unload-point-top",

- "unloader" => "unloader-center",

- _ => "center",

- });

- p.overlay(top.tint(s.color()));

- let mut arrow = load("top");

- let mut top = load("duct-unloader-top");

- let mut arrow = load("top");

- let mut null = load("cross-full");

-

- read(name, self.size)

- |_, name, _, _, rot: Rotation| {

- let mut base = load(name);

- let mut top = load(&format!("{name}-top"));

- load(name)

-make_simple!(WallCrafter, |_, _, _, _, rot: Rotation| {

- let mut base = load("cliff-crusher");

- let mut top = load("cliff-crusher-top");

- make_simple!(EnvironmentBlock, |_, name, _, _, _| {

- 2..=6 => load(&format!("{}{}", $field, rand.next_range(1usize..$variations))),

- 1 => load($field),

- 0 => ImageHolder::from(RgbaImage::new($size * 32, $size * 32)),

- |_, name, _, ctx: Option<&RenderingContext>, rot| {

- let tile = rotations2tile((index, rot, flip), &format!("{name}-top"));

- let mut bottom = load(&format!("conduit-bottom-{index}"));

- let mut p = load(name);

- if let Some(s) = Self::get_state(state) {

- let mut top = load("center");

- p.overlay(top.tint(s.color()));

- let mut null = load("cross-full");

- // SAFETY: canvas_size cannot be 0, so width & height musnt be 0, and size cannot be 0

- let p = unsafe {

- DynamicImage::from(

- RgbImage::from_raw(

- self.canvas_size as u32,

- self.canvas_size as u32,

- p.into_raw(),

- )

- .unwrap(),

- )

- .into_rgba8()

- .scale((self.size as u32 * 32) - 14)

- let mut borders = load(n);

- borders.overlay_at(&p, 7, 7);

- let mut def = RgbaImage::new(self.size as u32 * 32, self.size as u32 * 32);

- read(name, self.size)

- let mut base = load("switch");

- let on = load("switch-on");

- read(name, self.size)

- self.logic.as_ref().draw(&self.name, state, context, rot)

- read(name, self.size)

-make_simple!(DiodeBlock, |_, _, _, _, rot: Rotation| {

- let mut base = load("diode");

- let mut top = load("diode-arrow");

- read(name, self.size)

- read(name, self.size)

- $draw(self, name, state, context, rot)

- |m: &Self, n: &str, _, _, _| crate::data::renderer::read(n, m.get_size()),

- |m: &Self, n: &str, _, _, _| crate::data::renderer::read(n, m.get_size()),

- let mut base = load(&path);

- base.overlay(&load(name));

-make_simple!(ConstructorBlock, |me: &Self, name, _, _, rot: Rotation| {

- let mut base = load(name);

- let mut out = load(&match name {

- "additive-reconstructor"

- | "multiplicative-reconstructor"

- | "exponential-reconstructor"

- | "tetrative-reconstructor" => format!("factory-out-{}", me.size),

- _ => format!("factory-out-{}-dark", me.size),

- });

- let mut input = load(&match name {

- "additive-reconstructor"

- | "multiplicative-reconstructor"

- | "exponential-reconstructor"

- | "tetrative-reconstructor" => format!("factory-in-{}", me.size),

- _ => format!("factory-in-{}-dark", me.size),

- });

- base.overlay(&load(&format!("{name}-top")));

- let mut side = load(&format!("{name}-side"));

- let mut base = load(name);

- let mut out = load(match name {

- "ground-factory" | "air-factory" | "naval-factory" => "factory-out-3",

- _ => "factory-out-3-dark",

- });

- base.overlay(&load(&match name {

- "ground-factory" | "air-factory" | "naval-factory" => {

- format!("factory-top-{}", self.size)

- }

- _ => format!("{name}-top"),

- }));

-make_simple!(WallBlock, |_, name, _, _, _| {

- load(&format!("{}{}", $name, rand.next_range(1usize..$n)))

- read_with("thruster", SFX, 4u32)

- _ => load(name),

- read(name, self.size)

-pub fn tile(ctx: &RenderingContext<'_>, name: &str, rot: Rotation) -> ImageHolder {

- rotations2tile(mask2rotations(mask(ctx, rot, name), rot), name)

-pub fn rotations2tile((index, rot, flip): (u8, u8, u8), name: &str) -> ImageHolder {

- let mut p = load(&format!("{name}-{index}"));

- pub fn floor_image(&self, context: Option<&RenderingContext>) -> ImageHolder {

- let mut i = self.floor.image(None, context, Rotation::Up);

- i.overlay(ore.image(None, context, Rotation::Up).borrow());

- pub fn build_image(&self, context: Option<&RenderingContext>) -> ImageHolder {

- b.image(context)

- pub fn image(&self, context: Option<&RenderingContext>) -> ImageHolder {

- .image(self.state.as_ref(), context, self.rotation)

-type Cache = phf::Map<&'static str, &'static LazyLock<RgbaImage>>;

-static CACHE: Cache = include!(concat!(env!("OUT_DIR"), "/asset"));

-pub(crate) fn try_load(name: &str) -> Option<&'static RgbaImage> {

- CACHE.get(&key).map(|v| LazyLock::force(v))

-pub(crate) fn load(name: &str) -> ImageHolder {

- try_load(name)

-pub(crate) fn read<S>(name: &str, size: S) -> ImageHolder

- read_with(name, SUFFIXES, size)

-pub(crate) fn read_with<S>(name: &str, suffixes: &'static [&'static str], size: S) -> ImageHolder

- let mut c = RgbaImage::new(size.into() * 32, size.into() * 32);

- if let Some(p) = try_load(&format!("{name}{suffix}")) {

- bg.repeat(METAL_FLOOR.image(None, None, Rotation::Up).borrow());

- tile.image(ctx.as_ref(), tile.get_rotation().unwrap_or(Rotation::Up))

- .borrow(),

- 8

- 4

- let mut floor = RgbaImage::new(self.width as u32 * scale, self.height as u32 * scale);

- let mut top = RgbaImage::new(self.width as u32 * scale, self.height as u32 * scale);

- floor.overlay_at(

- // SAFETY: [`load_raw`] forces nonzero image size

- unsafe { &tile.floor_image(None).own().scale(scale) },

- x as u32 * scale,

- y as u32 * scale,

- );

- top.overlay_at(

- // SAFETY: tile.size can never be 0, and [`load_raw`] forces nonzero.

- unsafe {

- &tile

- .build_image(ctx.as_ref())

- .own()

- .scale(tile.size() as u32 * scale)

- },

- x as u32 * scale,

- y as u32 * scale,

- );

- pub fn image(&self, context: Option<&RenderingContext>, rot: Rotation) -> ImageHolder {

- self.block.image(self.get_state(), context, rot)

-#![feature(lazy_cell, slice_as_chunks)]

-use fast_image_resize as fr;

-use std::num::NonZeroU32;

- ///

- /// SAFETY: to and width and height cannot be 0.

- unsafe fn scale(self, to: u32) -> Self;

- for (i, other_pixels) in unsafe { other.as_chunks_unchecked::<4>() }

- .iter()

- .enumerate()

- {

- unsafe fn scale(self, to: u32) -> Self {

- debug_assert_ne!(to, 0);

- debug_assert_ne!(self.width(), 0);

- debug_assert_ne!(self.height(), 0);

- let to = NonZeroU32::new_unchecked(to);

- let src = fr::Image::from_vec_u8(

- NonZeroU32::new_unchecked(self.width()),

- NonZeroU32::new_unchecked(self.height()),

- self.into_vec(),

- fr::PixelType::U8x4,

- )

- .unwrap();

- let mut dst = fr::Image::new(to, to, fr::PixelType::U8x4);

- fr::Resizer::new(fr::ResizeAlg::Nearest)

- .resize(&src.view(), &mut dst.view_mut())

- .unwrap();

- RgbaImage::from_raw(to.get(), to.get(), dst.into_vec()).unwrap()