@nodecraft/rendermite 0.0.1 → 1.0.1

package/dist/legacy-reshape-CewShfF3.js

@@ -0,0 +1,203 @@
+import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { open } from "yauzl";
+import sharp from "sharp";
+//#region src/versions/legacy-reshape.ts
+/**
+* Pre-1.6 texture recovery, ported from the ui pipeline's legacy-assets.ts:
+* 1.5.x jars keep individually-named textures at the archive root under old
+* names (`oreDiamond.png`); ≤1.4.7 has only stitched sheets (terrain.png,
+* gui/items.png) whose cell identity lived in hardcoded Java. Both are
+* recovered by pixel-matching against the 1.6.4 reference art (the version
+* whose names the donor block models reference), emitting the pre-1.13 plural
+* texture directories the donor geometry expects. A tile that matches nothing
+* within tolerance is dropped — a text label beats someone else's icon.
+*/
+const MATCH_TOLERANCE = 40;
+const TILE_SIZE = 16;
+const SHEET_COLUMNS = 16;
+/** Read arbitrary entries out of a zip (pre-1.6 jars have no assets/ prefix). */
+async function readJarEntries(jarPath, wanted) {
+	return new Promise((resolve, reject) => {
+		open(jarPath, { lazyEntries: true }, (err, zip) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			const results = /* @__PURE__ */ new Map();
+			let pending = 0;
+			let ended = false;
+			const finish = () => {
+				if (ended && pending === 0) {
+					zip.close();
+					resolve(results);
+				}
+			};
+			zip.on("entry", (entry) => {
+				if (!wanted(entry.fileName)) {
+					zip.readEntry();
+					return;
+				}
+				pending++;
+				zip.openReadStream(entry, (streamErr, stream) => {
+					if (streamErr) {
+						reject(streamErr);
+						return;
+					}
+					const chunks = [];
+					stream.on("data", (chunk) => {
+						chunks.push(chunk);
+					});
+					stream.on("end", () => {
+						results.set(entry.fileName, Buffer.concat(chunks));
+						pending--;
+						finish();
+						zip.readEntry();
+					});
+					stream.on("error", reject);
+				});
+			});
+			zip.on("end", () => {
+				ended = true;
+				finish();
+			});
+			zip.on("error", reject);
+			zip.readEntry();
+		});
+	});
+}
+/** First 16x16 frame of a reference texture (animated strips use frame 0). */
+async function referenceTile(png) {
+	try {
+		const image = await sharp(png).extract({
+			left: 0,
+			top: 0,
+			width: TILE_SIZE,
+			height: TILE_SIZE
+		}).ensureAlpha().raw().toBuffer();
+		return new Uint8ClampedArray(image.buffer, image.byteOffset, image.length);
+	} catch {
+		return null;
+	}
+}
+function isBlankTile(pixels) {
+	for (let i = 3; i < pixels.length; i += 4) if (pixels[i] > 8) return false;
+	return true;
+}
+/** Sum of squared per-channel deltas over RGBA, divided by pixel count. */
+function pixelDistance(candidate, reference) {
+	if (candidate.length !== reference.length) return Infinity;
+	let sum = 0;
+	for (let i = 0; i < candidate.length; i++) {
+		const delta = candidate[i] - reference[i];
+		sum += delta * delta;
+	}
+	return sum / (candidate.length / 4);
+}
+async function loadReferences(referenceJar, directory) {
+	const prefix = `assets/minecraft/textures/${directory}/`;
+	const entries = await readJarEntries(referenceJar, (path) => path.startsWith(prefix) && path.endsWith(".png"));
+	const references = /* @__PURE__ */ new Map();
+	for (const [path, png] of entries) {
+		const pixels = await referenceTile(png);
+		if (pixels) references.set(path.slice(prefix.length, -4), pixels);
+	}
+	return references;
+}
+function matchTile(pixels, references, taken) {
+	let bestName = null;
+	let bestDistance = Infinity;
+	for (const [name, reference] of references) {
+		const distance = pixelDistance(pixels, reference);
+		if (distance < bestDistance) {
+			bestDistance = distance;
+			bestName = name;
+		}
+	}
+	if (bestName !== null && bestDistance <= MATCH_TOLERANCE && !taken.has(bestName)) return bestName;
+	return null;
+}
+/** Slice a stitched sheet into 16-column grid tiles, nearest-resized to 16x16. */
+async function sheetTiles(png) {
+	const meta = await sharp(png).metadata();
+	const size = Math.floor((meta.width ?? 0) / SHEET_COLUMNS);
+	if (size === 0) return [];
+	const rows = Math.floor((meta.height ?? 0) / size);
+	const tiles = [];
+	for (let row = 0; row < rows; row++) for (let column = 0; column < SHEET_COLUMNS; column++) {
+		const tile = sharp(png).extract({
+			left: column * size,
+			top: row * size,
+			width: size,
+			height: size
+		}).resize(TILE_SIZE, TILE_SIZE, { kernel: "nearest" });
+		const raw = await tile.clone().ensureAlpha().raw().toBuffer();
+		tiles.push({
+			name: `${row}_${column}`,
+			pixels: new Uint8ClampedArray(raw.buffer, raw.byteOffset, raw.length),
+			png: await tile.png().toBuffer()
+		});
+	}
+	return tiles;
+}
+async function fileTiles(entries, prefix) {
+	const tiles = [];
+	for (const [path, png] of entries) {
+		if (!path.startsWith(prefix) || !path.endsWith(".png")) continue;
+		const pixels = await referenceTile(png);
+		if (pixels) tiles.push({
+			name: path.slice(prefix.length, -4),
+			pixels,
+			png
+		});
+	}
+	return tiles;
+}
+async function matchInto(output, tiles, references, directory) {
+	const taken = /* @__PURE__ */ new Set();
+	let matched = 0;
+	let dropped = 0;
+	for (const tile of tiles) {
+		if (isBlankTile(tile.pixels)) continue;
+		const name = matchTile(tile.pixels, references, taken);
+		if (name === null) {
+			dropped++;
+			continue;
+		}
+		taken.add(name);
+		output.set("texture", `minecraft:${directory}/${name}`, tile.png);
+		matched++;
+	}
+	return {
+		matched,
+		dropped
+	};
+}
+/**
+* Build an in-memory texture layer for a pre-1.6 jar. `sheets` selects the
+* ≤1.4.7 stitched-sheet path; otherwise the 1.5.x individual-file path.
+*/
+async function reshapeLegacyAssets(jarPath, referenceJar, sheets) {
+	const output = new MapResourceManager();
+	const [blockReferences, itemReferences] = await Promise.all([loadReferences(referenceJar, "blocks"), loadReferences(referenceJar, "items")]);
+	let entries;
+	if (sheets) {
+		entries = await readJarEntries(jarPath, (path) => [
+			"terrain.png",
+			"gui/items.png",
+			"misc/glint.png"
+		].includes(path));
+		const terrain = entries.get("terrain.png");
+		if (terrain) await matchInto(output, await sheetTiles(terrain), blockReferences, "blocks");
+		const items = entries.get("gui/items.png");
+		if (items) await matchInto(output, await sheetTiles(items), itemReferences, "items");
+	} else {
+		entries = await readJarEntries(jarPath, (path) => path.startsWith("textures/") || path === "misc/glint.png");
+		await matchInto(output, await fileTiles(entries, "textures/blocks/"), blockReferences, "blocks");
+		await matchInto(output, await fileTiles(entries, "textures/items/"), itemReferences, "items");
+	}
+	const glint = entries.get("misc/glint.png");
+	if (glint) output.set("texture", "minecraft:misc/enchanted_glint_item", glint);
+	return output;
+}
+//#endregion
+export { reshapeLegacyAssets as t };

package/dist/legacy-tints-B09J0Rxh.js

@@ -0,0 +1,169 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+//#region src/render/legacy-tints.ts
+/**
+* Hard-coded tint tables for eras before item definitions (pre-1.21.4), ported
+* from renderchest v2.5.2's TinterManager. Keyed by model path in the parent
+* chain (upstream bound a tinter per model as each chain entry loaded, so the
+* deepest matching entry wins). Colormap-driven tints sample the map center
+* (0.5, 0.5), matching the era's renderer.
+*/
+const FOLIAGE_MODELS = /* @__PURE__ */ new Set([
+	"block/oak_leaves",
+	"block/birch_leaves",
+	"block/acacia_leaves",
+	"block/jungle_leaves",
+	"block/spruce_leaves",
+	"block/dark_oak_leaves",
+	"block/mangrove_leaves",
+	"item/lily_pad",
+	"item/grass",
+	"item/short_grass",
+	"item/tall_grass",
+	"item/fern",
+	"item/large_fern",
+	"item/vine"
+]);
+/** Spawn eggs: [base, spots]; banners/potions single layer. Verbatim from v2.5.2. */
+const FIXED_COLORS = {
+	"item/potion": ["#375cc4"],
+	"item/splash_potion": ["#375cc4"],
+	"item/lingering_potion": ["#375cc4"],
+	"item/allay_spawn_egg": ["#00d7fc", "#00abfc"],
+	"item/armadillo_spawn_egg": ["#a67775", "#734b4f"],
+	"item/axolotl_spawn_egg": ["#f8bfe0", "#a42c73"],
+	"item/bat_spawn_egg": ["#4b3d2f", "#0f0f0f"],
+	"item/bee_spawn_egg": ["#eac142", "#42241b"],
+	"item/blaze_spawn_egg": ["#f3b001", "#fcf57d"],
+	"item/breeze_spawn_egg": ["#af94df", "#9166df"],
+	"item/cat_spawn_egg": ["#ecc68c", "#937155"],
+	"item/cave_spider_spawn_egg": ["#0c414d", "#a60e0e"],
+	"item/chicken_spawn_egg": ["#9f9f9f", "#fc0000"],
+	"item/cod_spawn_egg": ["#bfa569", "#e2c289"],
+	"item/cow_spawn_egg": ["#433526", "#9f9f9f"],
+	"item/creeper_spawn_egg": ["#0da50b", "#000000"],
+	"item/dolphin_spawn_egg": ["#223a4c", "#f6f6f6"],
+	"item/donkey_spawn_egg": ["#524438", "#847465"],
+	"item/drowned_spawn_egg": ["#8deed4", "#789a64"],
+	"item/elder_guardian_spawn_egg": ["#cccab8", "#737591"],
+	"item/enderman_spawn_egg": ["#161616", "#000000"],
+	"item/endermite_spawn_egg": ["#161616", "#6d6d6d"],
+	"item/evoker_spawn_egg": ["#939999", "#1e1c1a"],
+	"item/fox_spawn_egg": ["#d2b49d", "#ca6820"],
+	"item/frog_spawn_egg": ["#ce7343", "#fcc57b"],
+	"item/ghast_spawn_egg": ["#f6f6f6", "#bababa"],
+	"item/glow_squid_spawn_egg": ["#095555", "#83eeba"],
+	"item/goat_spawn_egg": ["#a3927b", "#54483d"],
+	"item/guardian_spawn_egg": ["#598071", "#ee7c2f"],
+	"item/hoglin_spawn_egg": ["#c46d54", "#5e6363"],
+	"item/horse_spawn_egg": ["#be9c7c", "#ebe200"],
+	"item/husk_spawn_egg": ["#786f60", "#e3ca92"],
+	"item/llama_spawn_egg": ["#be9c7c", "#975e3f"],
+	"item/magma_cube_spawn_egg": ["#330000", "#f9f900"],
+	"item/mooshroom_spawn_egg": ["#9e0f10", "#b5b5b5"],
+	"item/mule_spawn_egg": ["#1b0200", "#50321d"],
+	"item/ocelot_spawn_egg": ["#ecdb7c", "#554333"],
+	"item/panda_spawn_egg": ["#e4e4e4", "#1b1b22"],
+	"item/parrot_spawn_egg": ["#0da50b", "#fc0000"],
+	"item/phantom_spawn_egg": ["#425088", "#86fc00"],
+	"item/pig_spawn_egg": ["#eda3a0", "#d8625e"],
+	"item/piglin_spawn_egg": ["#975e3f", "#f6f0a2"],
+	"item/piglin_brute_spawn_egg": ["#582910", "#f6f0a2"],
+	"item/pillager_spawn_egg": ["#522e35", "#939999"],
+	"item/polar_bear_spawn_egg": ["#efefef", "#93938e"],
+	"item/pufferfish_spawn_egg": ["#f3b001", "#36c1ef"],
+	"item/rabbit_spawn_egg": ["#975e3f", "#724730"],
+	"item/ravager_spawn_egg": ["#74736f", "#5a4f48"],
+	"item/salmon_spawn_egg": ["#9e0f10", "#0e8273"],
+	"item/sheep_spawn_egg": ["#e4e4e4", "#fcb3b3"],
+	"item/shulker_spawn_egg": ["#926692", "#4c3751"],
+	"item/silverfish_spawn_egg": ["#6d6d6d", "#2f2f2f"],
+	"item/skeleton_spawn_egg": ["#bfbfbf", "#484848"],
+	"item/skeleton_horse_spawn_egg": ["#67674e", "#e2e2d5"],
+	"item/slime_spawn_egg": ["#509e3d", "#7dbd6d"],
+	"item/spider_spawn_egg": ["#332c27", "#a60e0e"],
+	"item/squid_spawn_egg": ["#223a4c", "#6f8697"],
+	"item/stray_spawn_egg": ["#607576", "#dae7e7"],
+	"item/strider_spawn_egg": ["#9a3335", "#4c484c"],
+	"item/tadpole_spawn_egg": ["#6c523c", "#160a00"],
+	"item/trader_llama_spawn_egg": ["#e7a22f", "#446194"],
+	"item/tropical_fish_spawn_egg": ["#ec6815", "#fcf6ec"],
+	"item/turtle_spawn_egg": ["#e4e4e4", "#00adad"],
+	"item/vex_spawn_egg": ["#798ea2", "#e5eaee"],
+	"item/villager_spawn_egg": ["#553b32", "#bb8971"],
+	"item/vindicator_spawn_egg": ["#939999", "#275d60"],
+	"item/wandering_trader_spawn_egg": ["#446194", "#e7a22f"],
+	"item/warden_spawn_egg": ["#0f4548", "#38d3dd"],
+	"item/witch_spawn_egg": ["#330000", "#509e3d"],
+	"item/wither_skeleton_spawn_egg": ["#141414", "#464c4c"],
+	"item/wolf_spawn_egg": ["#d4d0d0", "#ccad94"],
+	"item/zoglin_spawn_egg": ["#c46d54", "#e3e3e3"],
+	"item/zombie_spawn_egg": ["#00adad", "#789a64"],
+	"item/zombie_horse_spawn_egg": ["#305133", "#95c082"],
+	"item/zombie_villager_spawn_egg": ["#553b32", "#789a64"],
+	"item/zombified_piglin_spawn_egg": ["#e79191", "#4b7028"],
+	"item/camel_spawn_egg": ["#f9c168", "#c99136"],
+	"item/ender_dragon_spawn_egg": ["#1c1c1c", "#dd78f7"],
+	"item/wither_spawn_egg": ["#141414", "#4c719e"],
+	"item/snow_golem_spawn_egg": ["#d6efef", "#7fa2a2"],
+	"item/iron_golem_spawn_egg": ["#d8cbc0", "#73a131"],
+	"item/sniffer_spawn_egg": ["#871e09", "#25ab70"],
+	"item/banner": ["#f6fcfb"],
+	"item/white_banner": ["#f6fcfb"],
+	"item/orange_banner": ["#f67e1d"],
+	"item/magenta_banner": ["#c54dbb"],
+	"item/light_blue_banner": ["#39b1d7"],
+	"item/yellow_banner": ["#fbd53c"],
+	"item/lime_banner": ["#7ec51f"],
+	"item/pink_banner": ["#f089a8"],
+	"item/gray_banner": ["#464e51"],
+	"item/light_gray_banner": ["#9b9b95"],
+	"item/cyan_banner": ["#169a9a"],
+	"item/purple_banner": ["#8731b6"],
+	"item/blue_banner": ["#3b43a8"],
+	"item/brown_banner": ["#815331"],
+	"item/green_banner": ["#5d7b16"],
+	"item/red_banner": ["#ae2d26"],
+	"item/black_banner": ["#1d1d21"]
+};
+function hexTint(hex) {
+	return {
+		r: Number.parseInt(hex.slice(1, 3), 16) / 255,
+		g: Number.parseInt(hex.slice(3, 5), 16) / 255,
+		b: Number.parseInt(hex.slice(5, 7), 16) / 255
+	};
+}
+/** Sample a colormap; both axes clamped, out-of-map falls back to magenta. */
+async function sampleCenter(textures, map) {
+	const texture = await textures.load(ResourceLocator.parse(map));
+	if (!texture) return {
+		r: 1,
+		g: 0,
+		b: 1
+	};
+	const x = Math.min(texture.width - 1, Math.floor(.5 * texture.width));
+	const offset = (Math.min(texture.height - 1, Math.floor(.5 * texture.height)) * texture.width + x) * 4;
+	return {
+		r: texture.data[offset] / 255,
+		g: texture.data[offset + 1] / 255,
+		b: texture.data[offset + 2] / 255
+	};
+}
+/**
+* Tints for a model rendered without an item definition (pre-1.21.4 eras and
+* modded models/item trees). Walks the resolved chain deepest-first, so an
+* item model beats the block model it parents, matching upstream's per-model
+* binding. Returns null when nothing in the chain is tinted.
+*/
+async function legacyTintsForChain(chain, textures) {
+	for (const entry of chain) {
+		const locator = ResourceLocator.tryParse(entry);
+		if (!locator || locator.namespace !== "minecraft") continue;
+		const fixed = FIXED_COLORS[locator.path];
+		if (fixed) return fixed.map((color) => hexTint(color));
+		if (FOLIAGE_MODELS.has(locator.path)) return [await sampleCenter(textures, "minecraft:colormap/foliage")];
+		if (locator.path === "block/grass_block") return [await sampleCenter(textures, "minecraft:colormap/grass")];
+	}
+	return null;
+}
+//#endregion
+export { legacyTintsForChain as t };

package/dist/lighting--5myudVu.js

@@ -0,0 +1,83 @@
+import { c as normalize, d as rotationY, h as transformDirection, l as rotationEuler, p as scaling, r as dot, s as multiply, u as rotationX } from "./vector-CCxLae_T.js";
+//#region src/render/lighting.ts
+/** Vanilla two-direction diffuse (renderchest master, v5.2.0-beta.3+). */
+var DiffuseLightSource = class {
+	direction0;
+	direction1;
+	constructor(direction0, direction1, transformation) {
+		this.direction0 = transformDirection(transformation, normalize(direction0));
+		this.direction1 = transformDirection(transformation, normalize(direction1));
+	}
+	lightLevelForNormal(normal) {
+		return Math.min(1, (Math.max(0, dot(this.direction0, normal)) + Math.max(0, dot(this.direction1, normal))) * .6 + .4);
+	}
+};
+const BASE_DIRECTION_0 = [
+	.2,
+	1,
+	-.7
+];
+const BASE_DIRECTION_1 = [
+	-.2,
+	1,
+	.7
+];
+function guiFrontLight() {
+	const transform = multiply(multiply(scaling(1, -1, 1), rotationY(-Math.PI / 8)), rotationX(Math.PI * 3 / 4));
+	return new DiffuseLightSource(BASE_DIRECTION_0, BASE_DIRECTION_1, transform);
+}
+function guiSideLight() {
+	const transform = multiply(rotationEuler(3.2375858, 1.0821041, 0), rotationEuler(Math.PI * 3 / 4, -Math.PI / 8, 0));
+	return new DiffuseLightSource(BASE_DIRECTION_0, BASE_DIRECTION_1, transform);
+}
+/**
+* Legacy single-direction light used by the tags the published corpus was rendered
+* with (v2.5.2 through v5.1.0): darkness = max(0, (dot(n, dir) + 1)/2 - baseLight),
+* front light entirely inactive. Kept for golden-image comparison, not default output.
+*/
+var LegacyLightSource = class {
+	direction;
+	baseLight;
+	active;
+	constructor(direction, baseLight, active) {
+		this.direction = normalize(direction);
+		this.baseLight = baseLight;
+		this.active = active;
+	}
+	lightLevelForNormal(normal) {
+		if (!this.active) return 1;
+		return 1 - Math.max(0, (dot(normal, this.direction) + 1) / 2 - this.baseLight);
+	}
+};
+function legacySideLight() {
+	return new LegacyLightSource([
+		.75,
+		-2,
+		0
+	], .18, true);
+}
+function legacyFrontLight() {
+	return new LegacyLightSource([
+		0,
+		0,
+		1
+	], 1, false);
+}
+const LightingProfile = {
+	/** renderchest master (v5.2.0-beta.3): vanilla-accurate two-direction diffuse. */
+	modern: "modern",
+	/** v2.5.2–v5.1.0: single-direction side light, inactive front light. */
+	legacy: "legacy"
+};
+function lightsForProfile(profile) {
+	if (profile === "legacy") return {
+		front: legacyFrontLight(),
+		side: legacySideLight()
+	};
+	return {
+		front: guiFrontLight(),
+		side: guiSideLight()
+	};
+}
+//#endregion
+export { guiSideLight as a, lightsForProfile as c, guiFrontLight as i, LegacyLightSource as n, legacyFrontLight as o, LightingProfile as r, legacySideLight as s, DiffuseLightSource as t };

package/dist/lighting-3FGRC3Af.d.ts

@@ -0,0 +1,42 @@
+import { n as Vec3 } from "./vector-DRKRi4--.js";
+//#region src/render/lighting.d.ts
+interface LightSource {
+  /** Light level in [0,1] for a view-space normal; faces darken by 1 - level. */
+  lightLevelForNormal(normal: Vec3): number;
+}
+/** Vanilla two-direction diffuse (renderchest master, v5.2.0-beta.3+). */
+declare class DiffuseLightSource implements LightSource {
+  private readonly direction0;
+  private readonly direction1;
+  constructor(direction0: Vec3, direction1: Vec3, transformation: Float64Array);
+  lightLevelForNormal(normal: Vec3): number;
+}
+declare function guiFrontLight(): LightSource;
+declare function guiSideLight(): LightSource;
+/**
+ * Legacy single-direction light used by the tags the published corpus was rendered
+ * with (v2.5.2 through v5.1.0): darkness = max(0, (dot(n, dir) + 1)/2 - baseLight),
+ * front light entirely inactive. Kept for golden-image comparison, not default output.
+ */
+declare class LegacyLightSource implements LightSource {
+  private readonly direction;
+  private readonly baseLight;
+  private readonly active;
+  constructor(direction: Vec3, baseLight: number, active: boolean);
+  lightLevelForNormal(normal: Vec3): number;
+}
+declare function legacySideLight(): LightSource;
+declare function legacyFrontLight(): LightSource;
+declare const LightingProfile: {
+  /** renderchest master (v5.2.0-beta.3): vanilla-accurate two-direction diffuse. */
+  readonly modern: "modern";
+  /** v2.5.2–v5.1.0: single-direction side light, inactive front light. */
+  readonly legacy: "legacy";
+};
+type LightingProfileName = keyof typeof LightingProfile;
+declare function lightsForProfile(profile: LightingProfileName): {
+  front: LightSource;
+  side: LightSource;
+};
+//#endregion
+export { LightingProfileName as a, legacyFrontLight as c, LightingProfile as i, legacySideLight as l, LegacyLightSource as n, guiFrontLight as o, LightSource as r, guiSideLight as s, DiffuseLightSource as t, lightsForProfile as u };