@nodecraft/rendermite 1.1.3 → 1.2.0

package/assets/builtin/renderchest/models/block/fluid.json

@@ -0,0 +1,83 @@
+{
+	"texture_size": [
+		16,
+		16
+	],
+	"elements": [
+		{
+			"name": "fluid",
+			"from": [
+				0,
+				0,
+				0
+			],
+			"to": [
+				16,
+				16,
+				16
+			],
+			"faces": {
+				"north": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "north"
+				},
+				"east": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "east"
+				},
+				"south": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "south"
+				},
+				"west": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "west"
+				},
+				"up": {
+					"uv": [
+						0,
+						0,
+						16,
+						16
+					],
+					"texture": "#still",
+					"cullface": "up"
+				},
+				"down": {
+					"uv": [
+						0,
+						0,
+						16,
+						16
+					],
+					"texture": "#still",
+					"cullface": "down"
+				}
+			}
+		}
+	]
+}

package/assets/builtin/renderchest/models/block/fluid_tinted.json

@@ -0,0 +1,89 @@
+{
+	"texture_size": [
+		16,
+		16
+	],
+	"elements": [
+		{
+			"name": "fluid",
+			"from": [
+				0,
+				0,
+				0
+			],
+			"to": [
+				16,
+				16,
+				16
+			],
+			"faces": {
+				"north": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "north",
+					"tintindex": 0
+				},
+				"east": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "east",
+					"tintindex": 0
+				},
+				"south": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "south",
+					"tintindex": 0
+				},
+				"west": {
+					"uv": [
+						0,
+						0,
+						8,
+						8
+					],
+					"texture": "#flow",
+					"cullface": "west",
+					"tintindex": 0
+				},
+				"up": {
+					"uv": [
+						0,
+						0,
+						16,
+						16
+					],
+					"texture": "#still",
+					"cullface": "up",
+					"tintindex": 0
+				},
+				"down": {
+					"uv": [
+						0,
+						0,
+						16,
+						16
+					],
+					"texture": "#still",
+					"cullface": "down",
+					"tintindex": 0
+				}
+			}
+		}
+	]
+}

package/assets/builtin/renderchest/models/block/hanging_sign.json

@@ -0,0 +1,54 @@
+{
+	"__comment": "Hanging sign, for the block pack. A 16x2x4 bar at the ceiling, a 14x10x2 board below it, and two short chains between — the chains are boxes cut from the sheet's chain art rather than the crossed planes the entity model uses, which reads the same at world scale. UVs follow the 64x32 hanging sheet's box unwrap.",
+	"texture_size": [64, 32],
+	"elements": [
+		{
+			"name": "bar",
+			"from": [0, 14, 6],
+			"to": [16, 16, 10],
+			"faces": {
+				"north": { "uv": [1, 2, 5, 3], "texture": "#texture" },
+				"east": { "uv": [5, 2, 6, 3], "texture": "#texture" },
+				"south": { "uv": [6, 2, 10, 3], "texture": "#texture" },
+				"west": { "uv": [0, 2, 1, 3], "texture": "#texture" },
+				"up": { "uv": [5, 0, 9, 2], "texture": "#texture" },
+				"down": { "uv": [1, 0, 5, 2], "texture": "#texture" }
+			}
+		},
+		{
+			"name": "chain_left",
+			"from": [3, 10, 7.5],
+			"to": [5, 14, 8.5],
+			"faces": {
+				"north": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"east": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"south": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"west": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" }
+			}
+		},
+		{
+			"name": "chain_right",
+			"from": [11, 10, 7.5],
+			"to": [13, 14, 8.5],
+			"faces": {
+				"north": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"east": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"south": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" },
+				"west": { "uv": [0, 3, 0.5, 5.5], "texture": "#texture" }
+			}
+		},
+		{
+			"name": "board",
+			"from": [1, 0, 7],
+			"to": [15, 10, 9],
+			"faces": {
+				"north": { "uv": [0.5, 7, 4, 12], "texture": "#texture" },
+				"east": { "uv": [4, 7, 4.5, 12], "texture": "#texture" },
+				"south": { "uv": [4.5, 7, 8, 12], "texture": "#texture" },
+				"west": { "uv": [0, 7, 0.5, 12], "texture": "#texture" },
+				"up": { "uv": [4, 6, 7.5, 7], "texture": "#texture" },
+				"down": { "uv": [0.5, 6, 4, 7], "texture": "#texture" }
+			}
+		}
+	]
+}

package/assets/builtin/renderchest/models/block/standing_sign.json

@@ -0,0 +1,32 @@
+{
+	"__comment": "Standing sign, for the block pack. Vanilla ships no model for one: SignRenderer draws it from an entity model, so a world viewer reading only the assets sees nothing. Proportions follow that model (a 24x12x2 board on a 2x14x2 post, at the renderer's 2/3 scale) and the UVs follow the 64x32 entity sheet's own box unwrap, both verified by rendering.",
+	"texture_size": [64, 32],
+	"elements": [
+		{
+			"name": "post",
+			"from": [7.25, 0, 7.25],
+			"to": [8.75, 9, 8.75],
+			"faces": {
+				"north": { "uv": [0.5, 8, 1, 15], "texture": "#texture" },
+				"east": { "uv": [1, 8, 1.5, 15], "texture": "#texture" },
+				"south": { "uv": [1.5, 8, 2, 15], "texture": "#texture" },
+				"west": { "uv": [0, 8, 0.5, 15], "texture": "#texture" },
+				"up": { "uv": [1, 7, 1.5, 8], "texture": "#texture" },
+				"down": { "uv": [0.5, 7, 1, 8], "texture": "#texture" }
+			}
+		},
+		{
+			"name": "board",
+			"from": [0, 9, 7.25],
+			"to": [16, 17, 8.75],
+			"faces": {
+				"north": { "uv": [0.5, 1, 6.5, 7], "texture": "#texture" },
+				"east": { "uv": [6.5, 1, 7, 7], "texture": "#texture" },
+				"south": { "uv": [7, 1, 13, 7], "texture": "#texture" },
+				"west": { "uv": [0, 1, 0.5, 7], "texture": "#texture" },
+				"up": { "uv": [6.5, 0, 12.5, 1], "texture": "#texture" },
+				"down": { "uv": [0.5, 0, 6.5, 1], "texture": "#texture" }
+			}
+		}
+	]
+}

package/assets/builtin/renderchest/models/block/wall_sign.json

@@ -0,0 +1,19 @@
+{
+	"__comment": "Wall sign: the same board as the standing sign with no post, sitting against the block behind it. Authored facing north, so the blockstate's facing rotates it from there.",
+	"texture_size": [64, 32],
+	"elements": [
+		{
+			"name": "board",
+			"from": [0, 4.5, 0],
+			"to": [16, 12.5, 1.5],
+			"faces": {
+				"north": { "uv": [0.5, 1, 6.5, 7], "texture": "#texture" },
+				"east": { "uv": [6.5, 1, 7, 7], "texture": "#texture" },
+				"south": { "uv": [7, 1, 13, 7], "texture": "#texture" },
+				"west": { "uv": [0, 1, 0.5, 7], "texture": "#texture" },
+				"up": { "uv": [6.5, 0, 12.5, 1], "texture": "#texture" },
+				"down": { "uv": [0.5, 0, 6.5, 1], "texture": "#texture" }
+			}
+		}
+	]
+}

package/dist/atlas/registry.js

@@ -1,2 +1,2 @@
-import { t as loadAtlasResolver } from "../registry-DS5PZ57l.js";
+import { t as loadAtlasResolver } from "../registry-DlduyjtM.js";
 export { loadAtlasResolver };

package/dist/atlas/sources.js

@@ -1,2 +1,2 @@
-import { a as UnstitchAtlasSource, i as SingleAtlasSource, n as DirectoryAtlasSource, o as createAtlasResolver, r as PalettedPermutationsSource, s as parseAtlasSources, t as AtlasSourceError } from "../sources-Bxk-WOzH.js";
+import { a as UnstitchAtlasSource, i as SingleAtlasSource, n as DirectoryAtlasSource, o as createAtlasResolver, r as PalettedPermutationsSource, s as parseAtlasSources, t as AtlasSourceError } from "../sources-BlUriDCs.js";
 export { AtlasSourceError, DirectoryAtlasSource, PalettedPermutationsSource, SingleAtlasSource, UnstitchAtlasSource, createAtlasResolver, parseAtlasSources };

package/dist/atlas-pack-CoOih7By.js

@@ -0,0 +1,130 @@
+//#region src/blocks/atlas-pack.ts
+const DEFAULT_PADDING = 4;
+const DEFAULT_MAX_PAGE_SIZE = 4096;
+function nextPowerOfTwo(value) {
+	let size = 1;
+	while (size < value) size *= 2;
+	return size;
+}
+/**
+* A NaN or negative option would otherwise classify every sprite oversized and
+* write an empty atlas that looks like a successful export.
+*/
+function requireSize(value, name, minimum) {
+	if (!Number.isSafeInteger(value) || value < minimum) throw new RangeError(`${name} must be an integer of at least ${minimum}, got ${value}`);
+	return value;
+}
+/** Largest power of two that still fits under `value`, floored at 1. */
+function previousPowerOfTwo(value) {
+	let size = 1;
+	while (size * 2 <= value) size *= 2;
+	return size;
+}
+/**
+* Lay entries out at a fixed page width, opening a new page when the current
+* one runs out of shelf room. Returns the placements plus the used height of
+* every page, so the caller can trim the last one.
+*/
+function shelvePlacements(entries, pageSize, padding) {
+	const placements = [];
+	const usedHeights = [0];
+	let shelves = [];
+	let page = 0;
+	for (const entry of entries) {
+		const width = entry.texture.width + padding * 2;
+		const height = entry.texture.height + padding * 2;
+		let shelf = shelves.find((candidate) => candidate.height >= height && candidate.cursor + width <= pageSize);
+		if (!shelf) {
+			if (usedHeights[page] + height > pageSize) {
+				page++;
+				shelves = [];
+				usedHeights[page] = 0;
+			}
+			shelf = {
+				y: usedHeights[page],
+				height,
+				cursor: 0
+			};
+			shelves.push(shelf);
+			usedHeights[page] += height;
+		}
+		placements.push({
+			entry,
+			page,
+			x: shelf.cursor + padding,
+			y: shelf.y + padding
+		});
+		shelf.cursor += width;
+	}
+	return {
+		placements,
+		usedHeights
+	};
+}
+/**
+* Copy a sprite into a page, extending its edge pixels outward across the
+* padding by clamping the sample coordinates.
+*/
+function blit(page, texture, left, top, padding) {
+	for (let y = -padding; y < texture.height + padding; y++) {
+		const sourceY = Math.min(texture.height - 1, Math.max(0, y));
+		for (let x = -padding; x < texture.width + padding; x++) {
+			const sourceX = Math.min(texture.width - 1, Math.max(0, x));
+			const source = (sourceY * texture.width + sourceX) * 4;
+			const target = ((top + y) * page.width + (left + x)) * 4;
+			page.data[target] = texture.data[source];
+			page.data[target + 1] = texture.data[source + 1];
+			page.data[target + 2] = texture.data[source + 2];
+			page.data[target + 3] = texture.data[source + 3];
+		}
+	}
+}
+function packAtlas(entries, options = {}) {
+	const padding = requireSize(options.padding ?? DEFAULT_PADDING, "padding", 0);
+	const pageCeiling = previousPowerOfTwo(requireSize(options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE, "maxPageSize", 1));
+	const oversized = [];
+	const packable = [];
+	for (const entry of entries) if (entry.texture.width + padding * 2 <= pageCeiling && entry.texture.height + padding * 2 <= pageCeiling) packable.push(entry);
+	else oversized.push(entry.key);
+	packable.sort((left, right) => right.texture.height - left.texture.height || right.texture.width - left.texture.width || left.key.localeCompare(right.key));
+	let area = 0;
+	let widest = 1;
+	for (const entry of packable) {
+		area += (entry.texture.width + padding * 2) * (entry.texture.height + padding * 2);
+		widest = Math.max(widest, entry.texture.width + padding * 2);
+	}
+	let pageSize = Math.min(pageCeiling, Math.max(nextPowerOfTwo(widest), nextPowerOfTwo(Math.ceil(Math.sqrt(area)))));
+	let layout = shelvePlacements(packable, pageSize, padding);
+	while (layout.usedHeights.length > 1 && pageSize < pageCeiling) {
+		pageSize *= 2;
+		layout = shelvePlacements(packable, pageSize, padding);
+	}
+	const pages = layout.usedHeights.map((used) => {
+		const height = Math.max(1, nextPowerOfTwo(used));
+		return {
+			width: pageSize,
+			height,
+			data: new Uint8ClampedArray(pageSize * height * 4)
+		};
+	});
+	const rects = [];
+	for (const placement of layout.placements) {
+		blit(pages[placement.page], placement.entry.texture, placement.x, placement.y, padding);
+		rects.push({
+			key: placement.entry.key,
+			page: placement.page,
+			x: placement.x,
+			y: placement.y,
+			width: placement.entry.texture.width,
+			height: placement.entry.texture.height
+		});
+	}
+	return {
+		pages,
+		rects,
+		oversized,
+		padding
+	};
+}
+//#endregion
+export { packAtlas as t };

package/dist/atlas-pack-DRTrWcSU.d.ts

@@ -0,0 +1,41 @@
+import { r as Texture } from "./loader-Myy22TDL.js";
+//#region src/blocks/atlas-pack.d.ts
+interface PackEntry {
+  /** Caller's identifier; carried through to the emitted rect. */
+  key: string;
+  texture: Texture;
+}
+interface PackedRect {
+  key: string;
+  page: number;
+  /** Position of the sprite itself, inside its padding. */
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface PackedPage {
+  width: number;
+  height: number;
+  /** RGBA, row-major. */
+  data: Uint8ClampedArray;
+}
+interface PackedAtlas {
+  pages: PackedPage[];
+  rects: PackedRect[];
+  /** Entries too large for a single page — reported, never dropped silently. */
+  oversized: string[];
+  padding: number;
+}
+interface PackOptions {
+  /** Edge-extended border per side, in pixels. */
+  padding?: number;
+  /**
+   * Hard ceiling on a page's dimensions; GPUs and browsers both cap this.
+   * Pages stay power-of-two, so a ceiling that is not one is rounded down.
+   */
+  maxPageSize?: number;
+}
+declare function packAtlas(entries: PackEntry[], options?: PackOptions): PackedAtlas;
+//#endregion
+export { PackedRect as a, PackedPage as i, PackOptions as n, packAtlas as o, PackedAtlas as r, PackEntry as t };