@nodecraft/rendermite 1.4.1 → 1.6.0

package/dist/sprite-sheet-LQAEtGkp.js

@@ -0,0 +1,185 @@
+import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
+//#region src/blocks/sprite-sheet.ts
+/**
+* Turning a set of texture ids into a stitched atlas plus the JSON that
+* addresses it, which is the same problem whether the sprites came from block
+* models or from item models.
+*
+* Extracted from `export.ts` when the item sprites arrived, unchanged: the
+* fiddly parts — an animation strip becoming one rect per physical frame, a
+* `.mcmeta` claiming more frames than an atlas can hold, a sprite too large for
+* a page, alpha deciding the render layer — are all things it would be a mistake
+* to write twice and let drift.
+*
+* Nothing here knows what names the sprites. Callers that need a guaranteed
+* fallback sprite pass `includeMissing`; callers that do not (an item sheet, where
+* a missing sprite means the consumer draws a box instead) leave it off.
+*/
+/**
+* Vanilla's own id for the missing-texture sprite. A face whose texture does
+* not resolve is drawn by the game in black and magenta rather than skipped —
+* Blockbench leaves `"texture": "#missing"` on unassigned faces and mods ship
+* models naming textures they forgot to include. Dropping those faces would
+* put holes in geometry the player can see, and would read as our bug rather
+* than the mod's.
+*/
+const MISSING_SPRITE = "minecraft:missingno";
+/**
+* A sprite whose strip is longer than this exports as its first frame only.
+* A broken `.mcmeta` can claim thousands of frames, and packing them would
+* blow the atlas out for one texture.
+*/
+const MAX_FRAMES_PER_SPRITE = 256;
+/** `MissingTextureAtlasSprite`: 16x16, black and magenta in 8px quarters. */
+function missingTexture() {
+	const size = 16;
+	const data = /* @__PURE__ */ new Uint8ClampedArray(1024);
+	for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+		const magenta = x < 8 !== y < 8;
+		const offset = (y * size + x) * 4;
+		data[offset] = magenta ? 248 : 0;
+		data[offset + 1] = 0;
+		data[offset + 2] = magenta ? 248 : 0;
+		data[offset + 3] = 255;
+	}
+	return {
+		width: size,
+		height: size,
+		data
+	};
+}
+/**
+* Alpha decides the render layer: vanilla assets do not state cutout versus
+* translucent (`render_type` is a loader extension adopted only recently), and
+* inferring it covers mods for free.
+*/
+function inferRenderLayer(frames) {
+	let sawHole = false;
+	for (const frame of frames) for (let offset = 3; offset < frame.data.length; offset += 4) {
+		const alpha = frame.data[offset];
+		if (alpha === 0) sawHole = true;
+		else if (alpha !== 255) return "translucent";
+	}
+	return sawHole ? "cutout" : "solid";
+}
+/**
+* Loads every id, packs the frames, and returns the sheet plus everything that
+* did not make it. Ids are packed in sorted order so an unchanged input produces
+* a byte-identical atlas.
+*/
+async function buildSpriteSheet(ids, textures, options = {}) {
+	const wanted = new Set(ids);
+	if (options.includeMissing) wanted.delete(MISSING_SPRITE);
+	const failures = [];
+	const missing = /* @__PURE__ */ new Set();
+	const loaded = [];
+	let done = 0;
+	for (const id of [...wanted].toSorted((left, right) => left.localeCompare(right))) {
+		options.onProgress?.(++done, wanted.size);
+		let animated;
+		try {
+			animated = await textures.loadAnimated(ResourceLocator.parse(id));
+		} catch (err) {
+			failures.push({
+				id,
+				reason: err.message
+			});
+			missing.add(id);
+			continue;
+		}
+		if (!animated) {
+			failures.push({
+				id,
+				reason: "texture not found"
+			});
+			missing.add(id);
+			continue;
+		}
+		const overlong = animated.frameCount > MAX_FRAMES_PER_SPRITE;
+		if (overlong) failures.push({
+			id,
+			reason: `${animated.frameCount} frames exceeds the ${MAX_FRAMES_PER_SPRITE} cap; exported static`
+		});
+		const starts = overlong ? [0] : animated.frameStartTicks();
+		const total = overlong ? 1 : animated.tickLength;
+		const sequence = starts.map((start, index) => {
+			return {
+				frame: animated.resolveFrame(start).frame,
+				time: (index + 1 < starts.length ? starts[index + 1] : total) - start
+			};
+		});
+		const frames = /* @__PURE__ */ new Map();
+		for (const entry of sequence) if (!frames.has(entry.frame)) frames.set(entry.frame, animated.frame(entry.frame));
+		loaded.push({
+			id,
+			frames,
+			sequence,
+			interpolate: animated.interpolated
+		});
+	}
+	if (options.includeMissing) loaded.push({
+		id: MISSING_SPRITE,
+		frames: /* @__PURE__ */ new Map([[0, missingTexture()]]),
+		sequence: [{
+			frame: 0,
+			time: 1
+		}],
+		interpolate: false
+	});
+	const packed = packAtlas(loaded.flatMap((sprite) => [...sprite.frames].map(([index, texture]) => {
+		return {
+			key: `${sprite.id}#${index}`,
+			texture
+		};
+	})), {
+		padding: options.padding,
+		maxPageSize: options.maxPageSize
+	});
+	for (const key of packed.oversized) {
+		const id = key.split("#", 1)[0];
+		if (!missing.has(id)) {
+			failures.push({
+				id,
+				reason: "sprite is larger than one atlas page; drawn as the missing texture"
+			});
+			missing.add(id);
+		}
+	}
+	if (options.includeMissing && missing.has("minecraft:missingno")) throw new Error("the missing-texture sprite does not fit an atlas page; maxPageSize is too small");
+	const rects = new Map(packed.rects.map((rect) => [rect.key, rect]));
+	const sprites = {};
+	for (const sprite of loaded) {
+		const first = rects.get(`${sprite.id}#${sprite.sequence[0].frame}`);
+		if (!first) continue;
+		const frames = [];
+		for (const entry of sprite.sequence) {
+			const rect = rects.get(`${sprite.id}#${entry.frame}`);
+			if (rect) frames.push({
+				page: rect.page,
+				x: rect.x,
+				y: rect.y,
+				time: entry.time
+			});
+		}
+		sprites[sprite.id] = {
+			page: first.page,
+			x: first.x,
+			y: first.y,
+			w: first.width,
+			h: first.height,
+			layer: inferRenderLayer(sprite.frames.values().toArray()),
+			...frames.length === sprite.sequence.length && frames.length > 1 && { frames },
+			...sprite.interpolate && { interpolate: true }
+		};
+	}
+	return {
+		pages: packed.pages,
+		sprites,
+		missing,
+		failures,
+		padding: packed.padding
+	};
+}
+//#endregion
+export { missingTexture as i, buildSpriteSheet as n, inferRenderLayer as r, MISSING_SPRITE as t };

package/dist/versions/prepare.js

@@ -1,2 +1,2 @@
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-8LswFoS-.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-D49Gu4Lv.js";
 export { Era, GEOMETRY_DONOR_VERSIONS, compareVersions, eraForVersion, prepareVersionResources };

package/dist/workers/render-worker.js

@@ -1,5 +1,5 @@
-import { t as ItemPipeline } from "../pipeline-B8e6x8Hh.js";
-import { n as restoreResources } from "../descriptor-D7VKgeGT.js";
+import { t as ItemPipeline } from "../pipeline-BUIMzMzg.js";
+import { n as restoreResources } from "../descriptor-JyXhfd-c.js";
 import sharp from "sharp";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/workers/render-worker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.4.1",
+	"version": "1.6.0",
 	"description": "Minecraft item icon renderer: renders inventory-identical item icons from vanilla and modded assets across game versions, outputting optimized PNG/WebP/AVIF plus CSS and a JSON item library.",
 	"type": "module",
 	"license": "MIT",

package/dist/pack-format-BVC_B-ZW.d.ts

@@ -1,140 +0,0 @@
-import { n as BiomeClimatePack } from "./biomes-CJDJQqJb.js";
-import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
-import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
-import { t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
-import { n as BlockTintPack } from "./tints-DoBv5S9v.js";
-//#region src/blocks/pack-format.d.ts
-/** How a sprite's alpha classifies it, inferred because assets rarely say. */
-type BlockPackRenderLayer = 'solid' | 'cutout' | 'translucent';
-interface BlockPackFace {
-  sprite: string;
-  /** [u1, v1, u2, v2] in 0–16 sprite space, derived when the model omits it. */
-  uv: Vec4;
-  rotation?: number;
-  tintindex?: number;
-  cullface?: FaceDirectionName;
-}
-interface BlockPackElement {
-  from: Vec3;
-  to: Vec3;
-  rotation?: ModelElementJson['rotation'];
-  shade?: false;
-  faces: Partial<Record<FaceDirectionName, BlockPackFace>>;
-}
-interface BlockPackModel {
-  ao: boolean;
-  elements: BlockPackElement[];
-  /**
-   * The model's `particle` texture. What the game throws when the block breaks
-   * or is walked on, and the only colour a consumer has to work with for a
-   * block that draws nothing — a placeholder cube for a chest comes out oak
-   * rather than magenta.
-   */
-  particle?: string;
-  /** Triangle geometry from an OBJ loader, when the model uses one. */
-  mesh?: MeshGroup[];
-  /**
-   * The layer the model states it draws on. Authoritative where present, and
-   * it beats the per-sprite alpha inference — the same sprite can be solid in
-   * one model and translucent in another.
-   */
-  renderType?: BlockPackRenderLayer;
-  /** Block offsets a split-multiblock mesh spans. */
-  multiblock?: Array<[number, number, number]>;
-  /**
-   * Present when the block is a fluid, whose real surface height and flow
-   * direction come from its neighbours and so cannot be baked. The cube here is
-   * a stand-in; these are the sheets to mesh the real thing with.
-   */
-  fluid?: {
-    still: string;
-    flow: string;
-    overlay?: string;
-  };
-}
-interface BlockPackSpriteFrame {
-  page: number;
-  x: number;
-  y: number;
-  /** Duration in game ticks. */
-  time: number;
-}
-interface BlockPackSprite {
-  page: number;
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-  layer: BlockPackRenderLayer;
-  /** The displayed sequence, which can revisit a frame; absent when static. */
-  frames?: BlockPackSpriteFrame[];
-  interpolate?: true;
-}
-interface BlockPackAtlasPage {
-  file: string;
-  width: number;
-  height: number;
-}
-/** `atlas.json`. */
-interface BlockPackAtlasFile {
-  /** Edge-extended border per sprite, in pixels. */
-  padding: number;
-  pages: BlockPackAtlasPage[];
-  sprites: Record<string, BlockPackSprite>;
-}
-/** `models.json`, by fully-qualified model id. */
-type BlockPackModelsFile = Record<string, BlockPackModel>;
-/** `blockstates.json`, by block id, with keys and predicates already parsed. */
-type BlockPackBlockStatesFile = Record<string, BlockPackBlockState>;
-/**
- * A variant as the pack writes it. Every rotation is optional because the emit
- * drops each one at its default, which is most of them.
- */
-interface BlockPackVariant {
-  model: string;
-  x?: number;
-  y?: number;
-  z?: number;
-  uvlock?: true;
-  weight?: number;
-}
-/**
- * One block's cases as the pack writes them: what `evaluateBlockState` takes,
- * flattened to the key the file uses. Pass it as
- * `{ kind: 'variants', cases: state.variants }` and the models come back as
- * `BlockPackVariant`, no cast in either direction.
- */
-type BlockPackBlockState = {
-  variants: Array<BlockStateVariantCase<BlockPackVariant>>;
-  multipart?: undefined;
-} | {
-  multipart: Array<BlockStateMultipartCase<BlockPackVariant>>;
-  variants?: undefined;
-};
-/** `tints.json`. */
-type BlockPackTintsFile = BlockTintPack;
-/**
- * `biomes.json`, present only when the pack has biomes to describe: vanilla's
- * whole table, or the ones a mod's datapack declares. Absent is not empty — a
- * consumer with no file falls back to tinting at `tints.json`'s flat climate.
- */
-type BlockPackBiomesFile = BiomeClimatePack;
-/** `meta.json`, written last because it hashes every other file. */
-interface BlockPackMetaFile {
-  generator: string;
-  version: string;
-  namespaces: string[];
-  counts: {
-    blocks: number;
-    models: number;
-    sprites: number;
-    pages: number;
-    /** Biomes in `biomes.json`; `0` means the pack has none and the file is absent. */
-    biomes: number;
-    failures: number;
-  };
-  /** sha256 per file, enough to verify a cached copy without refetching it. */
-  hashes: Record<string, string>;
-}
-//#endregion
-export { BlockPackBlockStatesFile as a, BlockPackMetaFile as c, BlockPackRenderLayer as d, BlockPackSprite as f, BlockPackVariant as h, BlockPackBlockState as i, BlockPackModel as l, BlockPackTintsFile as m, BlockPackAtlasPage as n, BlockPackElement as o, BlockPackSpriteFrame as p, BlockPackBiomesFile as r, BlockPackFace as s, BlockPackAtlasFile as t, BlockPackModelsFile as u };

package/dist/{descriptor-D7VKgeGT.js → descriptor-JyXhfd-c.js}

@@ -1,6 +1,6 @@
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
 import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
 //#region src/resources/descriptor.ts
 /**
 * Serializable descriptions of a resource tree, so the same layered tree can be

package/dist/{face-CKHboPfh.js → face-B2JjWT46.js}

@@ -1,6 +1,6 @@
 import { a as scaleTextureAlpha, n as cloneFloatTexture, r as darkenTexture, s as tintTexture, u as uvWindow } from "./blend-KXMclcHk.js";
-import { c as normalize, g as transformVector, h as transformDirection, m as sub, r as dot, t as cross } from "./vector-CCxLae_T.js";
 import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, r as compactFaceBuffer, t as RowCursor } from "./rasterizer-DcVJzkxz.js";
+import { c as normalize, g as transformVector, h as transformDirection, m as sub, r as dot, t as cross } from "./vector-CCxLae_T.js";
 //#region src/render/face.ts
 /**
 * Face rendering: cull, transform, project, tint, darken, rasterize — a faithful

package/dist/{prepare-8LswFoS-.js → prepare-D49Gu4Lv.js}

@@ -1,7 +1,7 @@
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-BNibYkmI.js";
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
 import { t as JarResourceManager } from "./jar-W2cV2ZVO.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "./synthetic-rc9BPT4P.js";
 import { t as reshapeLegacyAssets } from "./legacy-reshape-CcdstKyI.js";
 //#region src/versions/prepare.ts
 /**

package/dist/{tints-C1tT6pKk.js → tints-BspVCz2G.js}

@@ -1,8 +1,8 @@
 import { i as modTintPackPath } from "./builtin-WkWjATeh.js";
 import { n as ResourceLocator } from "./locator-COMEtEn9.js";
+import { a as defaultProperties, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 import { t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as MapResourceManager } from "./synthetic-rc9BPT4P.js";
-import { a as defaultProperties, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 //#region src/mods/tints.ts
 /**
 * Tints for mod items whose colors live in client code rather than asset JSON.