vintage_schematics/formats/

litematic.rs

//! Litematica format support.

use std::io::Read;

use bitvec::{field::BitField, prelude::*};
use cfg_if::cfg_if;
use eyre::{Context, OptionExt};
use formats::should_reject;
use serde::{Deserialize, Serialize};
use tracing::warn;

use crate::{
	Map, formats,
	formats::{
		Loadable, ToInternal,
		common::{FLATTENING_VERSION, MODERNISED_BLOCKS, MinecraftBlockEntity, Xyz},
		internal,
		internal::{BlockCodes, Internal, MinecraftBlockCode},
		read,
	},
};

/// Litematica schematic format.
///
/// <https://modrinth.com/mod/litematica>
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Litematic {
	pub regions: Map<String, Region>,
	pub version: i32,
	#[serde(default)]
	pub sub_version: i32,
	pub minecraft_data_version: i32,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Region {
	pub block_state_palette: Vec<MinecraftBlockCode>,
	pub block_states: Vec<u64>,
	pub size: Xyz,
	pub tile_entities: Vec<LitematicBlockEntity>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LitematicBlockEntity {
	// some files are missing this field :(
	pub id: Option<String>,
	pub x: i32,
	pub y: i32,
	pub z: i32,
	#[serde(flatten, skip_serializing)]
	pub components: Map<String, mininbt::Value>,
}

impl Region {
	/// The minimum number of bits required to represent all block IDs in the palette.
	#[allow(clippy::cast_possible_truncation)]
	#[must_use]
	pub fn block_bit_width(&self) -> u32 { 2.max((self.block_state_palette.len() as u32 - 1).bit_width()) }
}

impl Loadable for Litematic {
	fn load(reader: impl Read, compressed: bool) -> eyre::Result<Self> {
		let mut schematic: Self = read(reader, compressed).context("failed to load schematic")?;

		if schematic.version != 7 && schematic.version != 6 {
			warn!("unsupported schematic version: {}", schematic.version);
		}

		schematic.modernise();

		Ok(schematic)
	}

	fn modernise(&mut self) {
		if self.minecraft_data_version < FLATTENING_VERSION {
			for region in &mut self.regions.values_mut() {
				for block in &mut region.block_state_palette {
					if let Some((_, new)) = MODERNISED_BLOCKS.iter().find(|(old, _)| old == &block.name) {
						block.name = new.to_string();
					}
				}
			}
		}
	}
}

impl ToInternal for Litematic {
	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
	fn to_internal(self) -> eyre::Result<Internal> {
		// TODO: multiple regions
		if self.regions.len() > 1 {
			warn!("multiple regions in schematic, only using one region");
		}
		let (_name, region) = self.regions.into_iter().next().ok_or_eyre("schematic has no regions")?;
		let bit_width = region.block_bit_width();

		// block IDs are stored as arbitrary bit width unsigned little endian integers, saved as an NBT long array
		cfg_if! {
			if #[cfg(target_pointer_width = "64")] {
				let bits = region.block_states.view_bits::<Lsb0>();
			} else {
				// `u64` doesn't implement `BitStore` on 32-bit platforms:
				// https://github.com/ferrilab/bitvec/blob/5fb855073acc2ed045094ed89d8daf8c765f0135/src/store.rs#L194
				// unfortunately, this is much slower :(
				let bytes: Vec<u8> = region.block_states.into_iter().flat_map(u64::to_le_bytes).collect();
				let bits = bytes.view_bits::<Lsb0>();
			}
		}
		let chunks = bits.chunks_exact(bit_width as usize);

		// negative size coords indicate where the region's "corners" are, something we don't care about
		let height = region.size.z.abs();
		let width = region.size.x.abs();
		let layers = region.size.y.abs();

		let palette_size = region.block_state_palette.len();
		let mut blocks = Vec::with_capacity(chunks.len());

		// build new block ID list and convert non-rejected palette entries to `MinecraftBlockCode`
		let (ids, block_codes): (Vec<Option<u32>>, Vec<MinecraftBlockCode>) = {
			let mut current_id = 0;
			let mut ids = Vec::with_capacity(palette_size);
			let mut block_codes = Vec::with_capacity(palette_size);
			for code in region.block_state_palette {
				if should_reject(&code) {
					ids.push(None);
				} else {
					ids.push(Some(current_id));
					block_codes.push(code);
					current_id += 1;
				}
			}
			(ids, block_codes)
		};

		// coordinate system:
		// ^ y (UP)
		// |
		// |
		// |-------> x (EAST)
		//  \_
		//    \_
		//      V z (SOUTH)

		for (i, index) in (0..=i32::MAX).zip(chunks.map(BitField::load_le::<u32>)) {
			let index = index as usize;
			let Some(id) = ids[index] else {
				continue;
			};
			let id = id as usize;

			let (width_quotient, width_remainder) = (i / width, i % width);
			let position = Xyz {
				x: width_remainder,
				y: width_quotient / height,
				z: width_quotient % height,
			};

			blocks.push(internal::Block { id, position });
		}

		// fix tile entities with missing IDs
		let mut tile_entities = region.tile_entities;
		let bit_width = bit_width as usize;

		for entity in &mut tile_entities {
			if entity.id.is_none() {
				// determine this entity's position in the packed block bits
				let i = (entity.y * height * width) + (entity.z * width) + entity.x;

				// if this is the third block, and the bit width is five, the bits for the block can be found at:
				// (3 * 5)..(3 * 5) + 5
				let start_bit = i as usize * bit_width;
				let index: u32 = bits[start_bit..start_bit + bit_width].load_le();

				let index = index as usize;
				let Some(id) = ids[index] else {
					// rejected
					continue;
				};
				let id = id as usize;

				entity.id = Some(block_codes[id].name.clone());
			}
		}

		let tile_entities = tile_entities
			.into_iter()
			.filter(|e| e.id.is_some())
			.map(|e| MinecraftBlockEntity {
				id: e.id.expect("missing IDs have been filtered out"),
				x: e.x,
				y: e.y,
				z: e.z,
				components: e.components,
			})
			.collect();

		Ok(Internal {
			block_codes: BlockCodes::Minecraft(block_codes),
			blocks,
			tile_entities,
			size: Xyz {
				x: width,
				y: layers,
				z: height,
			},
		})
	}
}