mc-assets 0.2.29 → 0.2.31

package/dist/assetsParser.d.ts

@@ -19,7 +19,24 @@ export declare class AssetsParser {
     getElements(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): 0 | 1 | BlockElement[];
     private resolvedModel;
     private getModelsByBlock;
-    private getResolvedModelsByModel;
+    getResolvedModelsByModel(model: string, debugQueryName?: string, clearModel?: boolean): {
+        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
+            x?: number;
+            y?: number;
+            z?: number;
+            uvlock?: boolean;
+            weight?: number;
+        };
+    } | undefined;
+    getResolvedModelsByModelData(modelData: BlockModel, debugQueryName?: string, clearModel?: boolean): {
+        resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {
+            x?: number;
+            y?: number;
+            z?: number;
+            uvlock?: boolean;
+            weight?: number;
+        };
+    };
     getResolvedModelFirst(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): (Pick<BlockModel, "textures" | "ao" | "elements"> & {
         x?: number;
         y?: number;

package/dist/assetsParser.js

@@ -143,6 +143,12 @@ export class AssetsParser {
         const modelData = this.blockModelsStore.get(this.version, model);
         if (!modelData)
             return;
+        return this.getResolvedModelsByModelData(modelData, debugQueryName, clearModel);
+    }
+    getResolvedModelsByModelData(modelData, debugQueryName, clearModel = true) {
+        if (clearModel) {
+            this.resolvedModel = {};
+        }
         const collectedParentModels = [];
         const collectModels = (model) => {
             collectedParentModels.push(model);

package/dist/itemsRenderer.d.ts

@@ -1,6 +1,7 @@
 import { AtlasParser } from './atlasParser';
 import { AssetsParser } from './assetsParser';
 import { BlockModelsStore, BlockStatesStore } from './stores';
+import { BlockModel } from './types';
 export declare class ItemsRenderer {
     version: string;
     itemsAtlasParser: AtlasParser;
@@ -15,7 +16,7 @@ export declare class ItemsRenderer {
         /** @deprecated */
         path: string;
     } | undefined;
-    tryGetFullBlock(blockName: string, properties?: Record<string, string | boolean>): {
+    tryGetFullBlock(model: any, blockName: string): {
         top: {
             slice: [number, number, number, number];
             type: string;
@@ -34,8 +35,9 @@ export declare class ItemsRenderer {
             /** @deprecated */
             path: string;
         };
+        resolvedModel: BlockModel;
     } | undefined;
-    getItemTexture(itemNameOrModel: string, properties?: Record<string, string | boolean>, exactItemResolve?: boolean): {
+    getItemTexture(itemNameOrModel: string, _properties?: Record<string, string | boolean>, exactItemResolve?: boolean): {
         slice: [number, number, number, number];
         type: string;
         /** @deprecated */
@@ -59,5 +61,6 @@ export declare class ItemsRenderer {
             /** @deprecated */
             path: string;
         };
+        resolvedModel: BlockModel;
     } | undefined;
 }

package/dist/itemsRenderer.js

@@ -34,14 +34,10 @@ export class ItemsRenderer {
             path: type
         };
     }
-    tryGetFullBlock(blockName, properties = {}) {
+    tryGetFullBlock(model, blockName) {
         if (!this.blocksAtlasParser)
             return;
-        const resolvedModelParts = this.assetsParser.getResolvedModelFirst({
-            name: blockName,
-            properties,
-        }, true);
-        const resolvedModel = resolvedModelParts?.[0];
+        const { resolvedModel } = this.assetsParser.getResolvedModelsByModelData(model);
         if (!resolvedModel?.elements?.length)
             return;
         const isAllFullModels = resolvedModel.elements.every(elem => elem.from[0] === 0 && elem.from[1] === 0 && elem.from[2] === 0 && elem.to[0] === 16 && elem.to[1] === 16 && elem.to[2] === 16);
@@ -66,23 +62,35 @@ export class ItemsRenderer {
             top: topTextureResolved,
             left: leftTextureResolved,
             right: rightTextureResolved,
+            resolvedModel: resolvedModel
         };
     }
-    getItemTexture(itemNameOrModel, properties = {}, exactItemResolve = false) {
-        itemNameOrModel = itemNameOrModel.replace(/^minecraft:/, '');
+    getItemTexture(itemNameOrModel, _properties = {}, exactItemResolve = false) {
+        let [_namespace, _name] = itemNameOrModel.includes(':') ? itemNameOrModel.split(':') : ['minecraft', itemNameOrModel];
+        const namespace = _namespace === 'minecraft' ? '' : _namespace;
+        const name = _name;
+        const itemModelPath = namespace ? `${namespace}:item/${name}` : `item/${name}`;
+        const blockModelPath = namespace ? `${namespace}:block/${name}` : `block/${name}`;
+        const cleanFullModelPath = namespace ? `${namespace}:${name}` : name;
         let model;
-        if (itemNameOrModel.includes('/') || exactItemResolve) {
-            model = this.modelsStore.get(this.version, itemNameOrModel);
+        if (cleanFullModelPath.includes('/') || exactItemResolve) {
+            model = this.modelsStore.get(this.version, cleanFullModelPath);
         }
         else {
-            model = this.modelsStore.get(this.version, `item/${itemNameOrModel}`);
-            if (!model || model.parent?.includes('block/')) {
-                return this.tryGetFullBlock(itemNameOrModel, properties);
+            model = this.modelsStore.get(this.version, itemModelPath);
+            let blockModel = model?.parent?.includes('block/');
+            if (!model) {
+                model = this.modelsStore.get(this.version, blockModelPath);
+                if (model)
+                    blockModel = true;
+            }
+            if (blockModel) {
+                return this.tryGetFullBlock(model, cleanFullModelPath);
             }
         }
         if (!model)
             return;
-        const texture = itemNameOrModel.includes('block/') ?
+        const texture = cleanFullModelPath.includes('block/') ?
             // first defined block texture
             Object.values(model.textures ?? {})[0] :
             model.textures?.layer0; // classic item texture

package/dist/itemsRenderer.test.js

@@ -10,11 +10,19 @@ describe('ItemsRenderer', () => {
     const itemsAtlasParser = new AtlasParser(itemsAtlases, '');
     const blocksAtlasParser = new AtlasParser(blocksAtlases, '');
     const renderer = new ItemsRenderer('latest', blockstatesModels, itemsAtlasParser, blocksAtlasParser);
+    const getItemTexture = (item) => {
+        const result = renderer.getItemTexture(item);
+        if (!result)
+            return result;
+        result['resolvedModel'] = !!result['resolvedModel'];
+        return result;
+    };
     describe('getItemTexture', () => {
         it('items texture', () => {
-            expect(renderer.getItemTexture('item_frame')).toMatchInlineSnapshot(`
+            expect(getItemTexture('item_frame')).toMatchInlineSnapshot(`
               {
                 "path": "items",
+                "resolvedModel": false,
                 "slice": [
                   720,
                   128,
@@ -26,7 +34,7 @@ describe('ItemsRenderer', () => {
             `);
         });
         it('full blocks texture', () => {
-            expect(renderer.getItemTexture('stone')).toMatchInlineSnapshot(`
+            expect(getItemTexture('stone')).toMatchInlineSnapshot(`
               {
                 "left": {
                   "path": "blocks",
@@ -38,6 +46,7 @@ describe('ItemsRenderer', () => {
                   ],
                   "type": "blocks",
                 },
+                "resolvedModel": true,
                 "right": {
                   "path": "blocks",
                   "slice": [
@@ -62,9 +71,10 @@ describe('ItemsRenderer', () => {
             `);
         });
         it('invsprite textures', () => {
-            expect(renderer.getItemTexture('chest')).toMatchInlineSnapshot(`
+            expect(getItemTexture('chest')).toMatchInlineSnapshot(`
               {
                 "path": "items",
+                "resolvedModel": false,
                 "slice": [
                   400,
                   0,
@@ -76,7 +86,8 @@ describe('ItemsRenderer', () => {
             `);
         });
         it('not implemented logic', () => {
-            expect(renderer.getItemTexture('cut_copper_slab')).toMatchInlineSnapshot(`undefined`);
+            expect(getItemTexture('cut_copper_slab')).toMatchInlineSnapshot(`undefined`);
+            expect(getItemTexture('bla_bla')).toMatchInlineSnapshot(`undefined`);
         });
     });
     describe('resolveTexture', () => {
@@ -93,6 +104,7 @@ describe('ItemsRenderer', () => {
                 "type": "items",
               }
             `);
+            expect(renderer.resolveTexture('bla')).toMatchInlineSnapshot(`undefined`);
         });
     });
 });

package/dist/worldBlockProvider.d.ts

@@ -1,12 +1,47 @@
 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): {
-        ao?: boolean;
+    getAllResolvedModels0_1(block: Omit<QueriedBlock, "stateId">, fallbackVariant?: boolean): ({
+        elements: {
+            faces: {
+                [k: string]: {
+                    texture: {
+                        u: number;
+                        v: number;
+                        su: number;
+                        sv: number;
+                        tileIndex: number;
+                        debugName: string;
+                    };
+                    uv?: number[];
+                    cullface?: string;
+                    rotation?: number;
+                    tintindex?: number;
+                };
+            };
+            from: import("./types").BlockElementPos;
+            to: import("./types").BlockElementPos;
+            rotation?: {
+                origin: [number, number, number];
+                axis: string;
+                angle: number;
+                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">) => {
         elements: {
             faces: {
                 [k: string]: {
@@ -33,8 +68,8 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
                 rescale?: boolean;
             };
         }[];
-    }[][];
-    getTextureInfo(textureName: string): {
+    } & Omit<T, "textures" | "elements">;
+    getTextureInfo: (textureName: string) => {
         su: number;
         sv: number;
         getLoadedImage: () => Promise<HTMLImageElement>;

package/dist/worldBlockProvider.js

@@ -6,62 +6,67 @@ export default function worldBlockProvider(blockstatesModels, blocksAtlas, versi
     const blockModelsStore = getLoadedModelsStore(blockstatesModels);
     const assetsParser = new AssetsParser(version, blockStatesStore, blockModelsStore);
     const atlasParser = new AtlasParser(blocksAtlas, 'latest', 'legacy');
+    const getTextureInfo = (textureName) => {
+        return atlasParser.getTextureInfo(textureName.replace('block/', '').replace('blocks/', ''), version);
+    };
+    const transformModel = (model, block) => {
+        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,
+                                },
+                            }];
+                    }))
+                };
+            }),
+            ...rest
+        };
+    };
     return {
         getAllResolvedModels0_1(block, fallbackVariant = false) {
             const modelsParts = assetsParser.getAllResolvedModels(block, fallbackVariant) ?? [];
             const interestedFaces = ['north', 'east', 'south', 'west', 'up', 'down'];
             return modelsParts.map(modelVariants => {
                 return modelVariants.map(model => {
-                    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 = this.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,
-                                            },
-                                        }];
-                                }))
-                            };
-                        }),
-                        ...rest
-                    };
+                    return transformModel(model, block);
                 }).filter(a => a.elements?.length);
             }).filter(a => a.length);
         },
-        getTextureInfo(textureName) {
-            return atlasParser.getTextureInfo(textureName.replace('block/', '').replace('blocks/', ''), version);
-        }
+        transformModel,
+        getTextureInfo
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc-assets",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "author": "Vitaly Turovsky <vital2580@icloud.com>",
   "license": "MIT",
   "files": [