mc-assets 0.2.49 → 0.2.51

package/README.MD

@@ -27,7 +27,7 @@ For contributing & building instructions see [building](#building) section.
 > Tested on Node.js 18 and above.
 
 
-All blockstates + models + all atlas textures for all versions bundled with rsbuild (uncompressed): 4.99 MB.
+All blockstates + models + all atlas textures for all versions bundled with rsbuild (uncompressed): 5 MB.
 
 This packages includes versions for: 1.7.10, 1.8, 1.8.1, 1.8.2, 1.8.3, 1.8.4, 1.8.5, 1.8.6, 1.8.7, 1.8.8, 1.8.9, 1.9, 1.9.1, 1.9.2, 1.9.3, 1.9.4, 1.10, 1.10.1, 1.10.2, 1.11, 1.11.1, 1.11.2, 1.12, 1.12.1, 1.12.2, 1.13, 1.13.1, 1.13.2, 1.14, 1.14.1, 1.14.2, 1.14.3, 1.14.4, 1.15, 1.15.1, 1.15.2, 1.16, 1.16.1, 1.16.2, 1.16.3, 1.16.4, 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5-pre2, 1.21.5-pre3, 1.21.5-rc1, 1.21.5-rc2, 1.21.5.
 

package/dist/assetsParser.d.ts

@@ -1,5 +1,5 @@
 import { BlockModelsStore, BlockStatesStore } from './stores';
-import { BlockElementPos, BlockModel } from './types';
+import { BlockElementPos, BlockModel, ResolvedBlockModel } from './types';
 export interface QueriedBlock {
     stateId: number;
     name: string;
@@ -24,42 +24,12 @@ export declare class AssetsParser {
     private getModelsByBlock;
     private getModelData;
     getResolvedModelsByModel(model: string, debugQueryName?: string, clearModel?: boolean): {
-        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
-            x?: number;
-            y?: number;
-            z?: number;
-            uvlock?: boolean;
-            weight?: number;
-        };
+        resolvedModel: ResolvedBlockModel;
     } | undefined;
     getResolvedModelsByModelData(modelData: BlockModel, debugQueryName?: string, clearModel?: boolean): {
-        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
-            x?: number;
-            y?: number;
-            z?: number;
-            uvlock?: boolean;
-            weight?: number;
-        };
+        resolvedModel: ResolvedBlockModel;
     };
-    getResolvedModelFirst(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): (Pick<BlockModel, "textures" | "ao" | "elements"> & {
-        x?: number;
-        y?: number;
-        z?: number;
-        uvlock?: boolean;
-        weight?: number;
-    })[] | undefined;
-    getResolvedModelRandom(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): (Pick<BlockModel, "textures" | "ao" | "elements"> & {
-        x?: number;
-        y?: number;
-        z?: number;
-        uvlock?: boolean;
-        weight?: number;
-    })[] | undefined;
-    getAllResolvedModels(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): (Pick<BlockModel, "textures" | "ao" | "elements"> & {
-        x?: number;
-        y?: number;
-        z?: number;
-        uvlock?: boolean;
-        weight?: number;
-    })[][] | undefined;
+    getResolvedModelFirst(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): ResolvedBlockModel[] | undefined;
+    getResolvedModelRandom(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): ResolvedBlockModel[] | undefined;
+    getAllResolvedModels(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): ResolvedBlockModel[][] | undefined;
 }

package/dist/assetsParser.js

@@ -49,8 +49,9 @@ export class AssetsParser {
         const elementsOptimized = allElements.length === 1 && arrEq(allElements[0][0], [0, 0, 0]) && arrEq(allElements[0][1], [16, 16, 16]) ? 1 : allElements;
         return elementsOptimized;
     }
-    // looks like workaround
-    resolvedModel = {};
+    resolvedModel = {
+        modelName: ''
+    };
     issues = [];
     matchedModels = [];
     matchedConditions = [];
@@ -154,6 +155,7 @@ export class AssetsParser {
             for (const varModel of Array.isArray(model) ? model : [model]) {
                 variant++;
                 this.resolvedModel = {
+                    modelName: varModel.model ?? queriedBlock.name,
                     x: varModel.x,
                     y: varModel.y,
                     z: varModel.z,
@@ -169,7 +171,7 @@ export class AssetsParser {
                     break;
             }
         }
-        return modelsResolved; // todo figure out the type error
+        return modelsResolved;
     }
     getModelData(model) {
         const modelData = this.blockModelsStore.get(this.version, model.replace('minecraft:', ''));
@@ -177,7 +179,9 @@ export class AssetsParser {
     }
     getResolvedModelsByModel(model, debugQueryName, clearModel = true) {
         if (clearModel) {
-            this.resolvedModel = {};
+            this.resolvedModel = {
+                modelName: this.resolvedModel.modelName
+            };
         }
         const modelData = this.getModelData(model);
         if (!modelData) {
@@ -189,7 +193,9 @@ export class AssetsParser {
     }
     getResolvedModelsByModelData(modelData, debugQueryName, clearModel = true) {
         if (clearModel) {
-            this.resolvedModel = {};
+            this.resolvedModel = {
+                modelName: this.resolvedModel.modelName
+            };
         }
         const collectedParentModels = [];
         const collectModels = (model) => {

package/dist/atlasCreator.d.ts

@@ -29,11 +29,11 @@ export type AtlasCreatorOptions = {
         renderSourceWidth?: number;
         renderSourceHeight?: number;
     };
-    format?: 'uv' | 'index';
+    needHorizontalIndexes?: boolean;
     tileSize?: number;
     getCanvas?: (imgSize: number) => HTMLCanvasElement;
 };
-export declare const makeTextureAtlas: ({ input, getLoadedImage, tileSize, getCanvas, }: AtlasCreatorOptions) => {
+export declare const makeTextureAtlas: ({ input, getLoadedImage, tileSize, getCanvas, needHorizontalIndexes, }: AtlasCreatorOptions) => {
     json: JsonAtlas;
     canvas: HTMLCanvasElement;
 };

package/dist/atlasCreator.js

@@ -1,3 +1,4 @@
+//@ts-ignore
 import { MaxRectsPacker, PACKING_LOGIC, Rectangle } from 'maxrects-packer';
 export const MAX_CANVAS_SIZE = 16_384;
 function nextPowerOfTwo(n) {
@@ -18,7 +19,7 @@ export const getAtlasSize = (numberOfTiles, tileSize) => {
         height: size * tileSize
     };
 };
-export const makeTextureAtlas = ({ input, getLoadedImage, tileSize = 16, getCanvas = (imgSize) => typeof document !== 'undefined' && document.createElement ? document.createElement('canvas') : new globalThis.Canvas(imgSize, imgSize, 'png'), }) => {
+export const makeTextureAtlas = ({ input, getLoadedImage, tileSize = 16, getCanvas = (imgSize) => typeof document !== 'undefined' && document.createElement ? document.createElement('canvas') : new globalThis.Canvas(imgSize, imgSize, 'png'), needHorizontalIndexes = false, }) => {
     // Pre-calculate all texture dimensions and prepare images
     const texturesWithDimensions = [...new Set(input)].map(keyValue => {
         const inputData = getLoadedImage(keyValue);
@@ -56,9 +57,10 @@ export const makeTextureAtlas = ({ input, getLoadedImage, tileSize = 16, getCanv
     // Use MaxRectsPacker to calculate optimal positions
     const packer = new MaxRectsPacker(undefined, undefined, 0, {
         square: true,
-        smart: true,
         pot: true,
-        logic: PACKING_LOGIC.MAX_AREA,
+        ...needHorizontalIndexes ? {} : { smart: true },
+        logic: needHorizontalIndexes ? PACKING_LOGIC.FILL_WIDTH : PACKING_LOGIC.MAX_AREA,
+        // logic: PACKING_LOGIC.FILL_WIDTH,
     });
     // Add all textures as rectangles
     const rectangles = texturesWithDimensions.map(tex => {

package/dist/atlasParser.d.ts

@@ -1,4 +1,5 @@
 import { VersionedStore } from './versionedStore';
+import { AtlasCreatorOptions } from './atlasCreator';
 type Texture = {
     u: number;
     v: number;
@@ -33,8 +34,19 @@ export declare class AtlasParser {
     atlasHasLegacyImage: boolean;
     constructor(atlasJson: any, latestImage: string, legacyImage?: string | undefined);
     get atlas(): ItemsAtlases;
-    getTextureInfo(itemName: string, version?: string): any;
-    makeNewAtlas(version: string, getCustomImage?: (itemName: string) => DataUrl | HTMLImageElement | boolean | void, _unusedTileSize?: number, getTextureSortRankOrTopTextures?: string[] | ((key: string) => number), addTextures?: string[]): Promise<{
+    getTextureInfo(itemName: string, version?: string): {
+        su: number;
+        sv: number;
+        /** @deprecated */
+        getLoadedImage: () => Promise<HTMLImageElement>;
+        getLoadedAtlasImage: () => Promise<HTMLImageElement>;
+        u: number;
+        v: number;
+        tileIndex: number;
+        imageType: "latest" | "legacy";
+        version: string;
+    } | undefined;
+    makeNewAtlas(version: string, getCustomImage?: (itemName: string) => DataUrl | HTMLImageElement | boolean | void, _unusedTileSize?: number, getTextureSortRankOrTopTextures?: string[] | ((key: string) => number), addTextures?: string[], options?: Pick<AtlasCreatorOptions, 'needHorizontalIndexes' | 'getCanvas'>): Promise<{
         canvas: HTMLCanvasElement;
         atlas: import("./atlasCreator").JsonAtlas;
         readonly newAtlasParser: AtlasParser;

package/dist/atlasParser.js

@@ -40,12 +40,18 @@ export class AtlasParser {
             ...info,
             su: info?.su ?? defaultSuSv,
             sv: info?.sv ?? defaultSuSv,
+            /** @deprecated */
             getLoadedImage: async () => {
                 return await getLoadedImage(info.imageType === 'latest' ? this.latestImage : this.legacyImage);
-            }
+            },
+            getLoadedAtlasImage: async () => {
+                return await getLoadedImage(info.imageType === 'latest' ? this.latestImage : this.legacyImage);
+            },
         };
     }
-    async makeNewAtlas(version, getCustomImage, _unusedTileSize = this.atlas.latest.tileSize, getTextureSortRankOrTopTextures, addTextures = []) {
+    // getRenderedFullBlockSide(resolvedModel: ResolvedBlockModel, side: 'top' | 'bottom' | 'north' | 'south' | 'east' | 'west') {
+    // }
+    async makeNewAtlas(version, getCustomImage, _unusedTileSize = this.atlas.latest.tileSize, getTextureSortRankOrTopTextures, addTextures = [], options = {}) {
         const itemsAtlases = this.atlasJson;
         const newTextures = {};
         const legacyImg = this.atlasHasLegacyImage ? await getLoadedImage(this.legacyImage) : null;
@@ -106,6 +112,7 @@ export class AtlasParser {
                 };
             },
             tileSize: this.atlas.latest.tileSize,
+            ...options,
         });
         let _newAtlasParser;
         return {

package/dist/itemsRenderer.d.ts

@@ -17,13 +17,7 @@ export declare class ItemsRenderer {
         path: string;
     } | undefined;
     resolveBlockModel(model: any, blockName: string): {
-        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
-            x?: number;
-            y?: number;
-            z?: number;
-            uvlock?: boolean;
-            weight?: number;
-        };
+        resolvedModel: import("./types").ResolvedBlockModel;
         readonly top: string;
         readonly left: string;
         readonly right: string;
@@ -55,13 +49,7 @@ export declare class ItemsRenderer {
         /** @deprecated */
         path: string;
     } | {
-        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
-            x?: number;
-            y?: number;
-            z?: number;
-            uvlock?: boolean;
-            weight?: number;
-        };
+        resolvedModel: import("./types").ResolvedBlockModel;
         readonly top: string;
         readonly left: string;
         readonly right: string;

package/dist/types.d.ts

@@ -58,6 +58,14 @@ export type BlockModel = {
     ambientocclusion?: boolean;
     ao?: boolean;
 };
+export type ResolvedBlockModel = Pick<BlockModel, 'textures' | 'elements' | 'ao'> & {
+    modelName: string;
+    x?: number;
+    y?: number;
+    z?: number;
+    uvlock?: boolean;
+    weight?: number;
+};
 type DisplayPresentation = {
     rotation?: [number, number, number];
     translation?: [number, number, number];

package/dist/versionedStore.d.ts

@@ -11,7 +11,7 @@ export declare class VersionedStore<T = string> {
     get versionsSorted(): string[];
     /** The order is important: from newest to oldest */
     push(version: string, key: string, data: T): void;
-    get(version: string, key: string, inclusive?: boolean): any;
+    get(version: string, key: string, inclusive?: boolean): T | undefined;
     semverToNumber(version: string): number;
     loadData(data: typeof this.data): void;
 }

package/dist/worldBlockProvider.d.ts

@@ -1,16 +1,16 @@
 import { QueriedBlock } from './assetsParser';
 import { BlockModel } from './types';
 export default function worldBlockProvider(blockstatesModels: any, blocksAtlas: any, version: string): {
-    getAllResolvedModels0_1(block: Omit<QueriedBlock, "stateId">, fallbackVariant?: boolean, possibleIssues?: string[], matchedModels?: string[], matchedConditions?: string[]): ({
+    getAllResolvedModels0_1(block: Omit<QueriedBlock, "stateId">, fallbackVariant?: boolean, possibleIssues?: string[], matchedModels?: string[], matchedConditions?: string[], partialElementsProcessing?: boolean): ({
         elements: {
             faces: {
                 [k: string]: {
                     texture: {
-                        u: any;
-                        v: any;
+                        u: number;
+                        v: number;
                         su: number;
                         sv: number;
-                        tileIndex: any;
+                        tileIndex: number;
                         debugName: string;
                     };
                     uv?: number[];
@@ -28,29 +28,17 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
                 rescale?: boolean;
             };
         }[];
-    } & Omit<Pick<BlockModel, "textures" | "ao" | "elements"> & {
-        x?: number;
-        y?: number;
-        z?: number;
-        uvlock?: boolean;
-        weight?: number;
-    }, "textures" | "elements">)[][];
-    transformModel: <T extends BlockModel | (Pick<BlockModel, "textures" | "ao" | "elements"> & {
-        x?: number;
-        y?: number;
-        z?: number;
-        uvlock?: boolean;
-        weight?: number;
-    })>(model: T, block: Omit<QueriedBlock, "stateId">) => {
+    } & Omit<import("./types").ResolvedBlockModel, "textures" | "elements">)[][];
+    transformModel: <T extends BlockModel | import("./types").ResolvedBlockModel>(model: T, block: Omit<QueriedBlock, "stateId">, elementsProcessingIssues?: string[]) => {
         elements: {
             faces: {
                 [k: string]: {
                     texture: {
-                        u: any;
-                        v: any;
+                        u: number;
+                        v: number;
                         su: number;
                         sv: number;
-                        tileIndex: any;
+                        tileIndex: number;
                         debugName: string;
                     };
                     uv?: number[];
@@ -69,6 +57,16 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
             };
         }[];
     } & Omit<T, "textures" | "elements">;
-    getTextureInfo: (textureName: string) => any;
+    getTextureInfo: (textureName: string) => {
+        su: number;
+        sv: number;
+        getLoadedImage: () => Promise<HTMLImageElement>;
+        getLoadedAtlasImage: () => Promise<HTMLImageElement>;
+        u: number;
+        v: number;
+        tileIndex: number;
+        imageType: "latest" | "legacy";
+        version: string;
+    } | undefined;
 };
 export type WorldBlockProvider = ReturnType<typeof worldBlockProvider>;

package/dist/worldBlockProvider.js

@@ -9,55 +9,61 @@ export default function worldBlockProvider(blockstatesModels, blocksAtlas, versi
     const getTextureInfo = (textureName) => {
         return atlasParser.getTextureInfo(textureName.replace('block/', '').replace('blocks/', ''), version);
     };
-    const transformModel = (model, block) => {
+    const transformModel = (model, block, elementsProcessingIssues) => {
         const { elements, textures, ...rest } = model;
         return {
             // todo validate elements
-            elements: elements?.map((elem) => {
-                return {
-                    ...elem,
-                    faces: Object.fromEntries(Object.entries(elem.faces).map(([faceName, face]) => {
-                        const texture = face.texture;
-                        if (!texture)
-                            throw new Error(`Missing resolved texture ${texture} for face ${faceName} of ${block.name}`);
-                        const finalTexture = getTextureInfo(texture);
-                        if (!finalTexture)
-                            throw new Error(`Missing texture data ${texture} for ${block.name}`);
-                        const _from = elem.from;
-                        const _to = elem.to;
-                        // taken from https://github.com/DragonDev1906/Minecraft-Overviewer/
-                        const COORDINATE_MAX = 16;
-                        const uv = (face.uv || {
-                            // default UVs
-                            // format: [u1, v1, u2, v2] (u = x, v = y)
-                            north: [_to[0], COORDINATE_MAX - _to[1], _from[0], COORDINATE_MAX - _from[1]],
-                            east: [_from[2], COORDINATE_MAX - _to[1], _to[2], COORDINATE_MAX - _from[1]],
-                            south: [_from[0], COORDINATE_MAX - _to[1], _to[0], COORDINATE_MAX - _from[1]],
-                            west: [_from[2], COORDINATE_MAX - _to[1], _to[2], COORDINATE_MAX - _from[1]],
-                            up: [_from[0], _from[2], _to[0], _to[2]],
-                            down: [_to[0], _from[2], _from[0], _to[2]]
-                        }[faceName]);
-                        const su = (uv[2] - uv[0]) / COORDINATE_MAX * finalTexture.su;
-                        const sv = (uv[3] - uv[1]) / COORDINATE_MAX * finalTexture.sv;
-                        return [faceName, {
-                                ...face,
-                                texture: {
-                                    u: finalTexture.u + uv[0] / 16 * finalTexture.su,
-                                    v: finalTexture.v + uv[1] / 16 * finalTexture.sv,
-                                    su,
-                                    sv,
-                                    tileIndex: finalTexture.tileIndex,
-                                    debugName: texture,
-                                },
-                            }];
-                    }))
-                };
-            }),
+            elements: elements?.map((elem, i) => {
+                try {
+                    return {
+                        ...elem,
+                        faces: Object.fromEntries(Object.entries(elem.faces).map(([faceName, face]) => {
+                            const texture = face.texture;
+                            if (!texture)
+                                throw new Error(`Missing resolved texture ${texture} for face ${faceName} of ${block.name}`);
+                            const finalTexture = getTextureInfo(texture);
+                            if (!finalTexture)
+                                throw new Error(`Missing texture data ${texture} for ${block.name}`);
+                            const _from = elem.from;
+                            const _to = elem.to;
+                            // taken from https://github.com/DragonDev1906/Minecraft-Overviewer/
+                            const COORDINATE_MAX = 16;
+                            const uv = (face.uv || {
+                                // default UVs
+                                // format: [u1, v1, u2, v2] (u = x, v = y)
+                                north: [_to[0], COORDINATE_MAX - _to[1], _from[0], COORDINATE_MAX - _from[1]],
+                                east: [_from[2], COORDINATE_MAX - _to[1], _to[2], COORDINATE_MAX - _from[1]],
+                                south: [_from[0], COORDINATE_MAX - _to[1], _to[0], COORDINATE_MAX - _from[1]],
+                                west: [_from[2], COORDINATE_MAX - _to[1], _to[2], COORDINATE_MAX - _from[1]],
+                                up: [_from[0], _from[2], _to[0], _to[2]],
+                                down: [_to[0], _from[2], _from[0], _to[2]]
+                            }[faceName]);
+                            const su = (uv[2] - uv[0]) / COORDINATE_MAX * finalTexture.su;
+                            const sv = (uv[3] - uv[1]) / COORDINATE_MAX * finalTexture.sv;
+                            return [faceName, {
+                                    ...face,
+                                    texture: {
+                                        u: finalTexture.u + uv[0] / 16 * finalTexture.su,
+                                        v: finalTexture.v + uv[1] / 16 * finalTexture.sv,
+                                        su,
+                                        sv,
+                                        tileIndex: finalTexture.tileIndex,
+                                        debugName: texture,
+                                    },
+                                }];
+                        }))
+                    };
+                }
+                catch (e) {
+                    elementsProcessingIssues?.push(`Error processing element ${i} in ${block.name}: ${e.message}`);
+                    return null;
+                }
+            }).filter(a => a !== null),
             ...rest
         };
     };
     return {
-        getAllResolvedModels0_1(block, fallbackVariant = false, possibleIssues = [], matchedModels = [], matchedConditions = []) {
+        getAllResolvedModels0_1(block, fallbackVariant = false, possibleIssues = [], matchedModels = [], matchedConditions = [], partialElementsProcessing = false) {
             assetsParser.issues = [];
             assetsParser.matchedModels = [];
             assetsParser.matchedConditions = [];
@@ -74,7 +80,7 @@ export default function worldBlockProvider(blockstatesModels, blocksAtlas, versi
                 const result = modelsParts.map(modelVariants => {
                     return modelVariants.map(model => {
                         try {
-                            return transformModel(model, block);
+                            return transformModel(model, block, partialElementsProcessing ? possibleIssues : undefined);
                         }
                         catch (e) {
                             possibleIssues.push(`Error transforming model for ${block.name}: ${e.message}`);

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "mc-assets",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "author": "Vitaly Turovsky <vital2580@icloud.com>",
   "license": "MIT",
   "files": [
     "dist",
-    "docs-assets"
+    "docs-assets",
+    "temp-lib"
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,7 +54,7 @@
     "minecraft block entity"
   ],
   "dependencies": {
-    "maxrects-packer": "^2.7.3",
+    "maxrects-packer": "file:./temp-lib/zardoy-maxrects-packer-2.7.4.tgz",
     "zod": "^3.24.1"
   },
   "repository": "https://github.com/zardoy/mc-assets",