@nodecraft/rendermite 0.0.1 → 1.0.0

package/dist/loader-C-eqwp3M.js

@@ -0,0 +1,359 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+//#region src/models/loader.ts
+var ModelResolutionError = class extends Error {};
+const MAX_PARENT_DEPTH = 64;
+const MAX_TEXTURE_REF_DEPTH = 16;
+/**
+* Per-mod synthesizers for loaders whose geometry lives entirely in Java but
+* whose icon shape is simple and stable enough to rebuild from the model json.
+* Keyed on the EXACT loader id so an unknown mod's loader never gets a wrong
+* guess — unhandled loaders keep the strip-and-fail-loud path below, and the
+* run() fallback chain (block model, geo, entity, sprite) still applies.
+* Adding a mod means adding an entry here plus a fixture test.
+*/
+const MOD_LOADER_HANDLERS = {
+	"immersiveengineering:conf_sides": flattenConfSides,
+	"immersiveengineering:models/conveyor": flattenConveyor
+};
+/**
+* Rewrite custom-loader models (forge/neoforge `loader` key) into drawable
+* geometry. Left unhandled they fall back to a textureless parent and render
+* as black squares — worse than failing, since the item still counts as having
+* an icon (1,793 such icons in the old pipeline's modded run). Resolution
+* order mirrors what each loader actually draws: the gui perspective IS the
+* icon view; composite children draw first-to-last; fluid containers' real
+* parent is loader-provided with no file behind it. OBJ loaders are left
+* alone — their geometry is a different file format.
+*/
+function flattenLoaderModel(json, depth = 0) {
+	const loader = extractLoaderType(json);
+	if (!loader || depth > 8) return json;
+	if (/obj$/i.test(loader)) {
+		const extended = json;
+		if (typeof extended.model === "string") {
+			const marked = withoutLoader(json);
+			marked.objModel = {
+				model: extended.model,
+				flipV: extended.flip_v ?? extended.flip_V ?? false
+			};
+			delete marked.model;
+			return marked;
+		}
+		return json;
+	}
+	const handler = MOD_LOADER_HANDLERS[loader];
+	if (handler) return handler(json);
+	const extended = json;
+	if (extended.perspectives?.gui && typeof extended.perspectives.gui === "object") return flattenLoaderModel(extended.perspectives.gui, depth + 1);
+	if (extended.base && typeof extended.base === "object") return flattenLoaderModel(extended.base, depth + 1);
+	if (typeof extended.childModel === "string") return { parent: extended.childModel };
+	if (extended.children && typeof extended.children === "object") {
+		const children = Object.values(extended.children);
+		const inline = children.filter((child) => typeof child === "object" && child !== null);
+		if (inline.length > 0 && inline.every((child) => Array.isArray(child.elements))) return {
+			...withoutLoader(json),
+			children: void 0,
+			textures: Object.assign({}, ...inline.map((child) => child.textures), json.textures),
+			elements: inline.flatMap((child) => child.elements ?? [])
+		};
+		const first = children[0];
+		if (typeof first === "string") return { parent: first };
+		if (first && typeof first === "object") return flattenLoaderModel(first, depth + 1);
+	}
+	if (extended.inner_model && typeof extended.inner_model === "object") return flattenLoaderModel(extended.inner_model, depth + 1);
+	if (/fluid_container|bucket/i.test(loader)) {
+		const fluid = json.fluid;
+		const bucket = { parent: "minecraft:item/bucket" };
+		if (typeof fluid === "string" && fluid.length > 0 && !fluid.endsWith(":empty")) bucket.fluidContained = fluid;
+		return bucket;
+	}
+	return withoutLoader(json);
+}
+/** IE conveyor types whose belt texture is not simply `block/conveyor/<type>`. */
+const CONVEYOR_BELTS = {
+	basic: "conveyor",
+	covered: "conveyor",
+	extract: "conveyor",
+	splitter: "split"
+};
+/**
+* IE's conveyor loader builds its belt entirely in code, but the shape it
+* draws for the icon is just a flat 16x2x16 belt with the type's (animated)
+* belt texture on top. The display transform is inlined because the model
+* json has no block/block parent to inherit the gui pose from.
+*/
+function flattenConveyor(json) {
+	const conveyorType = json.conveyorType;
+	if (typeof conveyorType !== "string" || !conveyorType.includes(":")) return withoutLoader(json);
+	const [namespace, type] = conveyorType.split(":", 2);
+	const belt = `${namespace}:block/conveyor/${CONVEYOR_BELTS[type] ?? type}`;
+	const side = {
+		uv: [
+			0,
+			0,
+			16,
+			2
+		],
+		texture: "#belt"
+	};
+	return {
+		gui_light: "side",
+		display: { gui: {
+			rotation: [
+				30,
+				225,
+				0
+			],
+			translation: [
+				0,
+				0,
+				0
+			],
+			scale: [
+				.625,
+				.625,
+				.625
+			]
+		} },
+		textures: {
+			belt,
+			particle: belt
+		},
+		elements: [{
+			from: [
+				0,
+				0,
+				0
+			],
+			to: [
+				16,
+				2,
+				16
+			],
+			faces: {
+				up: {
+					uv: [
+						0,
+						0,
+						16,
+						16
+					],
+					texture: "#belt"
+				},
+				down: {
+					uv: [
+						0,
+						0,
+						16,
+						16
+					],
+					texture: "#belt"
+				},
+				north: side,
+				south: side,
+				east: side,
+				west: side
+			}
+		}]
+	};
+}
+/**
+* IE's conf_sides loader picks per-face textures from `<base_name>` plus a
+* side/io suffix at runtime; the icon always shows the unconfigured ("none")
+* state, so a plain cube with those textures matches what the game draws.
+*/
+function flattenConfSides(json) {
+	const { type, base_name: base } = json;
+	if (typeof base !== "string") return withoutLoader(json);
+	const faces = type === "side_top_bottom" ? {
+		up: `${base}_up_none`,
+		down: `${base}_down_none`,
+		side: `${base}_side_none`
+	} : type === "vertical" ? {
+		up: `${base}_up_none`,
+		down: `${base}_up_none`,
+		side: `${base}_side`
+	} : {
+		up: `${base}_side_none`,
+		down: `${base}_side_none`,
+		side: `${base}_side_none`
+	};
+	return {
+		parent: "minecraft:block/cube",
+		textures: {
+			particle: faces.side,
+			up: faces.up,
+			down: faces.down,
+			north: faces.side,
+			south: faces.side,
+			east: faces.side,
+			west: faces.side
+		}
+	};
+}
+function extractLoaderType(json) {
+	const record = json;
+	if (typeof record.loader === "string") return record.loader;
+	if (typeof record.loader === "object" && record.loader !== null) {
+		const type = record.loader.type;
+		return typeof type === "string" ? type : null;
+	}
+	return null;
+}
+function withoutLoader(json) {
+	const rest = { ...json };
+	delete rest.loader;
+	return rest;
+}
+function isBuiltinParent(parent) {
+	return parent.startsWith("builtin/") || parent.startsWith("minecraft:builtin/");
+}
+function normalizeBuiltin(parent) {
+	return parent.replace(/^minecraft:/, "");
+}
+/**
+* Return the first complete JSON value in a string, tolerating trailing junk the way
+* Gson does (IntegratedDynamics ships models with garbage after the closing brace).
+* Returns null when no complete value exists.
+*/
+function salvageJson(text) {
+	const start = text.search(/[[{]/);
+	if (start === -1) return null;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = start; i < text.length; i++) {
+		const char = text[i];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") inString = true;
+		else if (char === "{" || char === "[") depth++;
+		else if (char === "}" || char === "]") {
+			depth--;
+			if (depth === 0) try {
+				return JSON.parse(text.slice(start, i + 1));
+			} catch {
+				return null;
+			}
+		}
+	}
+	return null;
+}
+var ModelLoader = class {
+	resources;
+	cache = /* @__PURE__ */ new Map();
+	constructor(resources) {
+		this.resources = resources;
+	}
+	async readModelJson(locator) {
+		const raw = await this.resources.getResource("model", locator);
+		if (raw === null) throw new ModelResolutionError(`Model not found: ${locator}`);
+		let json;
+		try {
+			json = JSON.parse(raw.toString("utf8"));
+		} catch {
+			const salvaged = salvageJson(raw.toString("utf8"));
+			if (salvaged === null) throw new ModelResolutionError(`Model is not valid JSON: ${locator}`);
+			json = salvaged;
+		}
+		return flattenLoaderModel(json);
+	}
+	async resolve(locator) {
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = locator;
+		let builtinParent = null;
+		while (current !== null) {
+			const key = current.toString();
+			if (seen.has(key)) throw new ModelResolutionError(`Model parent cycle at ${key} (from ${locator})`);
+			if (chain.length >= MAX_PARENT_DEPTH) throw new ModelResolutionError(`Model parent chain exceeds ${MAX_PARENT_DEPTH} at ${locator}`);
+			seen.add(key);
+			const json = await this.readModelJson(current);
+			chain.push({
+				locator: current,
+				json
+			});
+			if (json.parent === void 0) current = null;
+			else if (isBuiltinParent(json.parent)) {
+				builtinParent = normalizeBuiltin(json.parent);
+				current = null;
+			} else current = ResourceLocator.parse(json.parent);
+		}
+		const textures = {};
+		const display = {};
+		let elements = [];
+		let guiLight;
+		let elementsGuiLight;
+		for (let i = chain.length - 1; i >= 0; i--) {
+			const { json } = chain[i];
+			for (const [name, value] of Object.entries(json.textures ?? {})) textures[name] = typeof value === "object" && value !== null ? String(value.sprite ?? "") : value;
+			Object.assign(display, json.display);
+			if (json.gui_light !== void 0) guiLight = json.gui_light;
+			if (json.elements !== void 0) {
+				elements = json.elements;
+				elementsGuiLight = guiLight;
+			}
+		}
+		let obj;
+		for (const entry of chain) {
+			const marked = entry.json;
+			if (marked.objModel) {
+				obj = marked.objModel;
+				break;
+			}
+		}
+		let fluid;
+		for (const entry of chain) {
+			const marked = entry.json;
+			if (marked.fluidContained) {
+				fluid = marked.fluidContained;
+				break;
+			}
+		}
+		const defaultLight = builtinParent === "builtin/generated" ? "front" : "side";
+		return {
+			obj,
+			fluid,
+			locator,
+			builtinParent,
+			guiLight: guiLight ?? defaultLight,
+			elementsGuiLight: elementsGuiLight ?? defaultLight,
+			display,
+			textures,
+			elements,
+			chain: chain.map((entry) => entry.locator.toString())
+		};
+	}
+	/** Load and flatten a model by locator string (e.g. `minecraft:item/stone`). */
+	async load(locator) {
+		const parsed = typeof locator === "string" ? ResourceLocator.parse(locator) : locator;
+		const key = parsed.toString();
+		let pending = this.cache.get(key);
+		if (!pending) {
+			pending = this.resolve(parsed);
+			this.cache.set(key, pending);
+		}
+		return pending;
+	}
+};
+/**
+* Resolve a texture variable (`#layer0`) through the merged texture map to a locator.
+* Returns null for unresolved variables — the caller decides whether that fails the
+* item or just the face.
+*/
+function resolveTexture(model, reference) {
+	let value = reference;
+	for (let depth = 0; depth < MAX_TEXTURE_REF_DEPTH; depth++) {
+		if (!value.startsWith("#")) return ResourceLocator.tryParse(value);
+		const next = model.textures[value.slice(1)];
+		if (next === void 0) return null;
+		value = next;
+	}
+	return null;
+}
+//#endregion
+export { salvageJson as a, resolveTexture as i, ModelResolutionError as n, flattenLoaderModel as r, ModelLoader as t };

package/dist/loader-CBzn3Koc.js

@@ -0,0 +1,228 @@
+import sharp from "sharp";
+//#region src/textures/loader.ts
+var TextureResolutionError = class extends Error {};
+/**
+* Animation-aware texture access: frame extraction over strips and grids with
+* mcmeta frame lists, per-frame times, and interpolation (upstream semantics:
+* cols = trunc(16/meta.width), frame count from geometry when no list).
+*/
+var AnimatedTexture = class {
+	full;
+	meta;
+	columns;
+	frameCache = /* @__PURE__ */ new Map();
+	frameWidth;
+	frameHeight;
+	frameCount;
+	constructor(full, meta) {
+		this.full = full;
+		this.meta = meta;
+		const metaWidth = meta?.animation?.width ?? 16;
+		const metaHeight = meta?.animation?.height ?? 16;
+		this.columns = Math.max(1, Math.trunc(16 / metaWidth));
+		this.frameWidth = Math.round(full.width * (metaWidth / 16));
+		this.frameHeight = Math.round(this.frameWidth * (metaHeight / 16));
+		const frames = meta?.animation?.frames;
+		if (!meta?.animation) this.frameCount = 1;
+		else if (frames?.length) this.frameCount = frames.length;
+		else this.frameCount = Math.max(1, Math.round(full.height / this.frameHeight * this.columns));
+	}
+	get interpolated() {
+		return this.meta?.animation?.interpolate ?? false;
+	}
+	/** Total animation length in game ticks (1 for unanimated). */
+	get tickLength() {
+		if (!this.meta?.animation || this.frameCount <= 1) return 1;
+		const frameTime = this.meta.animation.frametime ?? 1;
+		const frames = this.meta.animation.frames;
+		if (frames?.length) {
+			let total = 0;
+			for (const frame of frames) total += typeof frame === "number" ? frameTime : frame.time ?? frameTime;
+			return total;
+		}
+		return this.frameCount * frameTime;
+	}
+	/** Which physical frame index shows at a tick, and the interpolation factor. */
+	resolveFrame(tick) {
+		const animation = this.meta?.animation;
+		if (!animation || this.frameCount <= 1) return {
+			frame: 0,
+			interpolation: 0
+		};
+		const frameTime = animation.frametime ?? 1;
+		const frames = animation.frames;
+		if (!frames?.length) return {
+			frame: Math.floor(tick / frameTime) % this.frameCount,
+			interpolation: tick % frameTime / frameTime
+		};
+		let remaining = tick % this.tickLength;
+		for (const entry of frames) {
+			const index = typeof entry === "number" ? entry : entry.index;
+			const time = typeof entry === "number" ? frameTime : entry.time ?? frameTime;
+			if (remaining < time) return {
+				frame: index,
+				interpolation: remaining / time
+			};
+			remaining -= time;
+		}
+		return {
+			frame: typeof frames[0] === "number" ? frames[0] : frames[0].index,
+			interpolation: 0
+		};
+	}
+	/** Crop one physical frame out of the strip/grid (memoized). */
+	frame(index) {
+		let cached = this.frameCache.get(index);
+		if (!cached) {
+			const left = index % this.columns * this.frameWidth;
+			const top = Math.floor(index / this.columns) * this.frameHeight;
+			const data = new Uint8ClampedArray(this.frameWidth * this.frameHeight * 4);
+			for (let y = 0; y < this.frameHeight; y++) {
+				const sourceStart = ((top + y) * this.full.width + left) * 4;
+				data.set(this.full.data.subarray(sourceStart, sourceStart + this.frameWidth * 4), y * this.frameWidth * 4);
+			}
+			cached = {
+				width: this.frameWidth,
+				height: this.frameHeight,
+				data
+			};
+			this.frameCache.set(index, cached);
+		}
+		return cached;
+	}
+	/** The image shown at a tick: the frame, interpolated toward the next when enabled. */
+	at(tick) {
+		const { frame, interpolation } = this.resolveFrame(tick);
+		const base = this.frame(frame);
+		if (!this.interpolated || interpolation === 0) return base;
+		const next = this.frame((frame + 1) % this.frameCount);
+		const data = new Uint8ClampedArray(base.data.length);
+		for (let i = 0; i < data.length; i++) data[i] = Math.round(base.data[i] + (next.data[i] - base.data[i]) * interpolation);
+		return {
+			width: base.width,
+			height: base.height,
+			data
+		};
+	}
+};
+var TextureLoader = class {
+	resources;
+	cache = /* @__PURE__ */ new Map();
+	atlas = null;
+	constructor(resources) {
+		this.resources = resources;
+	}
+	async decode(locator) {
+		let raw = await this.resources.getResource("texture", locator);
+		if (raw === null && this.atlas) {
+			const sprite = await this.atlas.resolve(locator);
+			if (sprite?.kind === "pixels") return sprite.texture;
+			if (sprite?.kind === "file") raw = await this.resources.getResource("texture", sprite.locator);
+		}
+		if (raw === null) return null;
+		let image;
+		try {
+			image = await sharp(raw).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+		} catch (err) {
+			throw new TextureResolutionError(`Failed to decode texture ${locator}: ${err.message}`);
+		}
+		let texture = {
+			width: image.info.width,
+			height: image.info.height,
+			data: new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.length)
+		};
+		const meta = await this.readMeta(locator);
+		const frame = frameSize(texture, meta);
+		if (frame.height !== texture.height || frame.width !== texture.width) texture = cropFrame(texture, frame.width, frame.height);
+		return texture;
+	}
+	async readMeta(locator) {
+		const raw = await this.resources.getResource("textureMeta", locator);
+		if (raw === null) return null;
+		try {
+			return JSON.parse(raw.toString("utf8"));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Attach an atlas resolver, consulted when no texture file exists directly —
+	* the path that synthesizes paletted_permutations sprites (armor trims) and
+	* unstitch regions. Directory/single sources are effectively covered by the
+	* direct file lookup already.
+	*/
+	setAtlasResolver(atlas) {
+		this.atlas = atlas;
+		this.cache.clear();
+	}
+	/**
+	* Load a texture with its animation metadata for multi-frame rendering.
+	* Returns null when the texture does not exist.
+	*/
+	async loadAnimated(locator) {
+		const raw = await this.resources.getResource("texture", locator);
+		let full = null;
+		if (raw !== null) {
+			const image = await sharp(raw).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+			full = {
+				width: image.info.width,
+				height: image.info.height,
+				data: new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.length)
+			};
+		} else if (this.atlas) {
+			const sprite = await this.load(locator);
+			if (sprite) return new AnimatedTexture(sprite, null);
+		}
+		if (!full) return null;
+		return new AnimatedTexture(full, await this.readMeta(locator));
+	}
+	/**
+	* Load a texture's first animation frame (what a static icon shows).
+	* Returns null when the texture does not exist; the caller decides whether
+	* that fails the item or just the face.
+	*/
+	async load(locator) {
+		const key = locator.toString();
+		let pending = this.cache.get(key);
+		if (!pending) {
+			pending = this.decode(locator);
+			this.cache.set(key, pending);
+		}
+		return pending;
+	}
+};
+/**
+* The size of one animation frame. Vertical strips are the norm (frame = width x width);
+* mcmeta may override with explicit width/height. Textures without animation metadata
+* but taller than wide are still treated as strips, matching how icons of animated
+* textures (water, fire, magma) have always been derived.
+*/
+function frameSize(texture, meta) {
+	const animation = meta?.animation;
+	if (animation) return {
+		width: animation.width ?? texture.width,
+		height: animation.height ?? Math.min(texture.height, texture.width)
+	};
+	if (texture.height > texture.width && texture.height % texture.width === 0) return {
+		width: texture.width,
+		height: texture.width
+	};
+	return {
+		width: texture.width,
+		height: texture.height
+	};
+}
+function cropFrame(texture, width, height) {
+	const data = new Uint8ClampedArray(width * height * 4);
+	for (let y = 0; y < height; y++) {
+		const sourceStart = y * texture.width * 4;
+		data.set(texture.data.subarray(sourceStart, sourceStart + width * 4), y * width * 4);
+	}
+	return {
+		width,
+		height,
+		data
+	};
+}
+//#endregion
+export { TextureLoader as n, TextureResolutionError as r, AnimatedTexture as t };

package/dist/loader-TFFNV4Jl.d.ts

@@ -0,0 +1,88 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+//#region src/textures/loader.d.ts
+/** Structural interface for atlas resolvers (avoids a circular module edge). */
+interface AtlasResolverLike {
+  resolve(locator: ResourceLocator): Promise<{
+    kind: 'file';
+    locator: ResourceLocator;
+  } | {
+    kind: 'pixels';
+    texture: Texture;
+  } | null>;
+}
+/** Decoded texture pixels, always RGBA, 8-bit per channel. */
+interface Texture {
+  width: number;
+  height: number;
+  /** RGBA, row-major, length = width * height * 4. */
+  data: Uint8ClampedArray;
+}
+interface TextureMeta {
+  animation?: {
+    frametime?: number;
+    frames?: Array<number | {
+      index: number;
+      time?: number;
+    }>;
+    interpolate?: boolean;
+    width?: number;
+    height?: number;
+  };
+}
+declare class TextureResolutionError extends Error {}
+/**
+ * Animation-aware texture access: frame extraction over strips and grids with
+ * mcmeta frame lists, per-frame times, and interpolation (upstream semantics:
+ * cols = trunc(16/meta.width), frame count from geometry when no list).
+ */
+declare class AnimatedTexture {
+  private readonly full;
+  private readonly meta;
+  private readonly columns;
+  private readonly frameCache;
+  readonly frameWidth: number;
+  readonly frameHeight: number;
+  readonly frameCount: number;
+  constructor(full: Texture, meta: TextureMeta | null);
+  get interpolated(): boolean;
+  /** Total animation length in game ticks (1 for unanimated). */
+  get tickLength(): number;
+  /** Which physical frame index shows at a tick, and the interpolation factor. */
+  resolveFrame(tick: number): {
+    frame: number;
+    interpolation: number;
+  };
+  /** Crop one physical frame out of the strip/grid (memoized). */
+  frame(index: number): Texture;
+  /** The image shown at a tick: the frame, interpolated toward the next when enabled. */
+  at(tick: number): Texture;
+}
+declare class TextureLoader {
+  private readonly resources;
+  private readonly cache;
+  private atlas;
+  constructor(resources: ResourceManager);
+  private decode;
+  private readMeta;
+  /**
+   * Attach an atlas resolver, consulted when no texture file exists directly —
+   * the path that synthesizes paletted_permutations sprites (armor trims) and
+   * unstitch regions. Directory/single sources are effectively covered by the
+   * direct file lookup already.
+   */
+  setAtlasResolver(atlas: AtlasResolverLike): void;
+  /**
+   * Load a texture with its animation metadata for multi-frame rendering.
+   * Returns null when the texture does not exist.
+   */
+  loadAnimated(locator: ResourceLocator): Promise<AnimatedTexture | null>;
+  /**
+   * Load a texture's first animation frame (what a static icon shows).
+   * Returns null when the texture does not exist; the caller decides whether
+   * that fails the item or just the face.
+   */
+  load(locator: ResourceLocator): Promise<Texture | null>;
+}
+//#endregion
+export { TextureMeta as a, TextureLoader as i, AtlasResolverLike as n, TextureResolutionError as o, Texture as r, AnimatedTexture as t };