mc-assets 0.1.7 → 0.2.1

package/README.MD

@@ -19,7 +19,7 @@ npm i mc-assets
 - **Easy to Use Items Textures** - Includes hand-crafted isometric textures for some blocks.
 - **Block Entities Models** - Includes community-crafted models for block entities.
 
-This module was originally designed as standalone package for [https://mcraft.fun](mcraft.fun) (repo) project so it is easier to maintain, but now it became a library that I think can cover any use case where you need to work with minecraft assets. This library means block states, models data and texture contents, it doesn't cover minecraft-data use cases.
+This module was originally designed as standalone package for [https://mcraft.fun](mcraft.fun) (repo) project so it is easier to maintain, but now it became a library that I think can cover any use case where you need to work with minecraft assets. This library means block states, models data and texture contents, it doesn't cover minecraft-data use cases. With the best block model parser you can build your own renderers, editors, etc.
 
 > Bundled modules & block states are version-accurate starting from 1.13.0 (post-flattening) version.
 > Tested on Node.js 18 and above.
@@ -162,32 +162,26 @@ This packages includes versions for: 1.7.10, 1.8, 1.8.1, 1.8.2, 1.8.3, 1.8.4, 1.
 - ✅ yellow_wall_banner
 - ✅ zombie_head
 - ✅ zombie_wall_head
-- ❌ black_candle
-- ❌ blue_candle
-- ❌ brown_candle
-- ❌ candle
-- ❌ cyan_candle
+- ❌ black_glazed_terracotta
+- ❌ blue_glazed_terracotta
+- ❌ brown_glazed_terracotta
+- ❌ cyan_glazed_terracotta
 - ❌ end_gateway
 - ❌ end_portal
-- ❌ gray_candle
-- ❌ green_candle
-- ❌ light_blue_candle
-- ❌ light_gray_candle
-- ❌ lime_candle
-- ❌ magenta_candle
-- ❌ orange_candle
-- ❌ pink_candle
-- ❌ pink_petals
-- ❌ powder_snow_cauldron
-- ❌ purple_candle
-- ❌ red_candle
-- ❌ repeater
-- ❌ sea_pickle
+- ❌ gray_glazed_terracotta
+- ❌ green_glazed_terracotta
+- ❌ light_blue_glazed_terracotta
+- ❌ light_gray_glazed_terracotta
+- ❌ lime_glazed_terracotta
+- ❌ magenta_glazed_terracotta
+- ❌ orange_glazed_terracotta
+- ❌ pink_glazed_terracotta
+- ❌ purple_glazed_terracotta
+- ❌ red_glazed_terracotta
 - ❌ structure_void
-- ❌ turtle_egg
-- ❌ water_cauldron
-- ❌ white_candle
-- ❌ yellow_candle
+- ❌ trial_spawner
+- ❌ white_glazed_terracotta
+- ❌ yellow_glazed_terracotta
 
 </details>
 
@@ -195,6 +189,8 @@ This packages includes versions for: 1.7.10, 1.8, 1.8.1, 1.8.2, 1.8.3, 1.8.4, 1.
 
 [Atlas explorer (web demo)](https://zardoy.github.io/mc-assets/).
 
+[External Models Playground](https://mcraft.fun/playground.html)
+
 ## Usage
 
 Following atlases are generated:
@@ -223,38 +219,50 @@ const model = modelsStore.get('latest', 'block/stone_mirrored')
 // note: you can always specify a specific version instead of 'latest'
 const assetsParser = new AssetsParser('latest', blockstatesStore, modelsStore)
 
-const resolvedModel = assetsParser.getResolvedModel({
+const resolvedModel = assetsParser.getAllResolvedModels({
     name: 'stone', // block name not model name
     properties: {},
 }, false) // false (default) means return empty if variant matching properties is not found
-// {
-//   textures: {
-//     all: 'block/stone',
-//     particle: 'block/stone',
-//     down: 'block/stone',
-//     up: 'block/stone',
-//     north: 'block/stone',
-//     east: 'block/stone',
-//     south: 'block/stone',
-//     west: 'block/stone'
-//   },
-//   elements: [
+// [
+//   [
 //     {
-//       from: [ 0, 0, 0 ],
-//       to: [ 16, 16, 16 ],
-//       faces: {
-//         down: { texture: 'block/stone', cullface: 'down' },
-//         up: { texture: 'block/stone', cullface: 'up' },
-//         north: { texture: 'block/stone', cullface: 'north' },
-//         south: { texture: 'block/stone', cullface: 'south' },
-//         west: { texture: 'block/stone', cullface: 'west' },
-//         east: { texture: 'block/stone', cullface: 'east' }
-//       }
+//       x: undefined,
+//       y: undefined,
+//       z: undefined,
+//       uvlock: undefined,
+//       weight: undefined,
+//       textures: {
+//         all: 'block/stone',
+//         particle: 'block/stone',
+//         down: 'block/stone',
+//         up: 'block/stone',
+//         north: 'block/stone',
+//         east: 'block/stone',
+//         south: 'block/stone',
+//         west: 'block/stone'
+//       },
+//       elements: [
+//         {
+//           from: [ 0, 0, 0 ],
+//           to: [ 16, 16, 16 ],
+//           faces: {
+//             down: { texture: 'block/stone', cullface: 'down' },
+//             up: { texture: 'block/stone', cullface: 'up' },
+//             north: { texture: 'block/stone', cullface: 'north' },
+//             south: { texture: 'block/stone', cullface: 'south' },
+//             west: { texture: 'block/stone', cullface: 'west' },
+//             east: { texture: 'block/stone', cullface: 'east' }
+//           }
+//         }
+//       ]
 //     }
-//   ]
-// }
+//   ],
+//   [ ... ] // second variant and so on
+// ]
 ```
 
+`getAllResolvedModels` returns an array of arrays, where first depth level is model parts, second depth level is variants (for example Minecraft chooses them randomly). You can use `getResolvedModelFirst` to get first variant only. Or `getResolvedModelRandom` to get a random variant.
+
 ### Rendering Atlas Textures
 
 ```ts

package/dist/assetsParser.d.ts

@@ -14,39 +14,31 @@ export declare class AssetsParser {
     blockModelsStore: BlockModelsStore;
     stateIdToElements: Record<string, BlockElement[] | 1>;
     constructor(version: string, blockStatesStore: BlockStatesStore, blockModelsStore: BlockModelsStore);
-    getElementsCached(queriedBlock: QueriedBlock): number | BlockElement[];
+    getElementsCached(queriedBlock: QueriedBlock): 1 | BlockElement[];
+    parseProperties(properties: string): Record<string, string | boolean>;
+    getElements(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): 0 | 1 | BlockElement[];
     private resolvedModel;
-    getElements(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): number | BlockElement[];
-    getResolvedModelByModelName(model: string, debugQueryName?: string, clearModel?: boolean): {
-        elementsOptimized: number | BlockElement[];
-        resolvedModel: Pick<BlockModel, "x" | "y" | "z" | "textures" | "ao" | "elements">;
-    } | undefined;
-    getResolvedModel(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): {
+    private getModelsByBlock;
+    private getResolvedModelsByModel;
+    getResolvedModelFirst(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): (Pick<BlockModel, "textures" | "ao" | "elements"> & {
         x?: number;
         y?: number;
         z?: number;
-        textures?: {
-            [name: string]: string;
-        };
-        ao?: boolean;
-        elements?: {
-            from: BlockElementPos;
-            to: BlockElementPos;
-            rotation?: {
-                origin: [number, number, number];
-                axis: string;
-                angle: number;
-                rescale?: boolean;
-            };
-            faces: {
-                [name: string]: {
-                    texture: string;
-                    uv?: number[];
-                    cullface?: string;
-                    rotation?: number;
-                    tintindex?: 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;
 }

package/dist/assetsParser.js

@@ -17,26 +17,39 @@ export class AssetsParser {
         this.stateIdToElements[stateId] = final;
         return final;
     }
-    // looks like workaround
-    resolvedModel = {};
+    parseProperties(properties) {
+        if (typeof properties === 'object') {
+            return properties;
+        }
+        const json = {};
+        for (const prop of properties.split(',')) {
+            const [key, value] = prop.split('=');
+            json[key] = value;
+        }
+        return json;
+    }
     getElements(queriedBlock, fallbackVariant = false) {
-        function parseProperties(properties) {
-            if (typeof properties === 'object') {
-                return properties;
-            }
-            const json = {};
-            for (const prop of properties.split(',')) {
-                const [key, value] = prop.split('=');
-                json[key] = value;
-            }
-            return json;
+        const model = this.getResolvedModelFirst(queriedBlock, fallbackVariant);
+        if (!model)
+            return 0;
+        const allElements = [];
+        for (const m of model) {
+            if (!m?.elements)
+                continue;
+            allElements.push(...m.elements.map(({ from, to }) => [from, to]));
         }
-        function matchProperties(block, /* to match against */ properties) {
+        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 = {};
+    getModelsByBlock(queriedBlock, fallbackVariant, multiOptim) {
+        const matchProperties = (block, /* to match against */ properties) => {
             if (!properties) {
                 return true;
             }
             if (typeof properties === 'string') {
-                properties = parseProperties(properties);
+                properties = this.parseProperties(properties);
             }
             const blockProps = block.properties;
             if (properties.OR) {
@@ -50,11 +63,11 @@ export class AssetsParser {
                 }
             }
             return true;
-        }
-        let modelApply;
+        };
+        let applyModels = [];
         const blockStates = this.blockStatesStore.get(this.version, queriedBlock.name);
         if (!blockStates)
-            return 0;
+            return;
         const states = blockStates.variants;
         if (states) {
             let state = states[''] || states['normal'];
@@ -71,42 +84,62 @@ export class AssetsParser {
                     state = states[Object.keys(states)[0]];
                 }
                 else {
-                    return 0;
+                    return;
                 }
             }
-            modelApply = state;
+            if (state) {
+                applyModels.push(state);
+            }
         }
         if (blockStates.multipart) {
-            // TODO! multiple variants
-            const multipartWithWhen = blockStates.multipart.filter(x => x.when);
-            const multipartWithoutWhen = blockStates.multipart.filter(x => !x.when);
-            for (const { when, apply } of multipartWithWhen) {
-                if (matchProperties(queriedBlock, when)) {
-                    modelApply = apply;
+            for (const { when, apply } of blockStates.multipart) {
+                if (!when || matchProperties(queriedBlock, when)) {
+                    applyModels.push(apply);
                 }
             }
-            if (!modelApply) {
-                modelApply = multipartWithoutWhen[0]?.apply;
+            if (!applyModels.length && fallbackVariant) {
+                const multipartWithWhen = blockStates.multipart.filter(x => x.when);
+                const apply = multipartWithWhen[0]?.apply;
+                if (apply) {
+                    applyModels.push(apply);
+                }
             }
-            if (!modelApply && fallbackVariant) {
-                modelApply = multipartWithWhen[0]?.apply;
+        }
+        if (!applyModels.length)
+            return;
+        const modelsResolved = [];
+        let part = 0;
+        for (const model of applyModels) {
+            part++;
+            let variant = 0;
+            modelsResolved.push([]);
+            for (const varModel of Array.isArray(model) ? model : [model]) {
+                variant++;
+                this.resolvedModel = {
+                    x: varModel.x,
+                    y: varModel.y,
+                    z: varModel.z,
+                    uvlock: varModel.uvlock,
+                    weight: varModel.weight,
+                };
+                if (!varModel)
+                    continue;
+                this.getResolvedModelsByModel(varModel.model, queriedBlock.name + '-' + part + '-' + variant, false);
+                // if (!result || Object.keys(result).length === 0) continue // todo: maybe we should push null?
+                modelsResolved[modelsResolved.length - 1].push(this.resolvedModel);
+                if (!multiOptim && modelsResolved[modelsResolved.length - 1].length > 0)
+                    break;
             }
         }
-        if (!modelApply)
-            return 0;
-        // TODO losing x, y, uvlock, and not 0!
-        const model = (Array.isArray(modelApply) ? modelApply[0 /* Math.floor(Math.random() * modelApply.length) */] : modelApply).model;
-        return this.getResolvedModelByModelName(model, queriedBlock.name)?.elementsOptimized ?? 0;
+        return modelsResolved; // todo figure out the type error
     }
-    getResolvedModelByModelName(model, debugQueryName, clearModel = true) {
+    getResolvedModelsByModel(model, debugQueryName, clearModel = true) {
         if (clearModel) {
             this.resolvedModel = {};
         }
         const modelData = this.blockModelsStore.get(this.version, model);
         if (!modelData)
             return;
-        // let textures = {} as Record<string, string>
-        let elements = [];
         const resolveModel = (model) => {
             if (model.ambientocclusion !== undefined) {
                 this.resolvedModel.ao = model.ambientocclusion;
@@ -114,21 +147,11 @@ export class AssetsParser {
             if (model.ao !== undefined) {
                 this.resolvedModel.ao = model.ao;
             }
-            if (model.x !== undefined) {
-                this.resolvedModel.x = model.x;
-            }
-            if (model.y !== undefined) {
-                this.resolvedModel.y = model.y;
-            }
-            if (model.z !== undefined) {
-                this.resolvedModel.z = model.z;
-            }
             if (model.textures) {
                 this.resolvedModel.textures ??= {};
                 Object.assign(this.resolvedModel.textures, model.textures);
             }
             if (model.elements) {
-                elements.push(...model.elements.map(({ from, to }) => [from, to]));
                 this.resolvedModel.elements ??= [];
                 this.resolvedModel.elements.push(...structuredClone(model.elements));
             }
@@ -174,21 +197,18 @@ export class AssetsParser {
                 face.texture = this.resolvedModel.textures[face.texture.replace('#', '')] ?? face.texture;
             }
         }
-        // todo cleanup methods
         return {
-            elementsOptimized: elements.length === 1 && arrEq(elements[0][0], [0, 0, 0]) && arrEq(elements[0][1], [16, 16, 16]) ? 1 : elements,
             resolvedModel: this.resolvedModel,
         };
     }
-    getResolvedModel(queriedBlock, fallbackVariant = false) {
-        this.resolvedModel = {};
-        const elements = this.getElements(queriedBlock, fallbackVariant);
-        return {
-            ...this.resolvedModel,
-            // elements: elements === 0 ? [] : elements === 1 ? [
-            //     [[0, 0, 0], [16, 16, 16]]
-            // ] : elements,
-        };
+    getResolvedModelFirst(queriedBlock, fallbackVariant = false) {
+        return this.getModelsByBlock(queriedBlock, fallbackVariant, false)?.map(x => x[0]);
+    }
+    getResolvedModelRandom(queriedBlock, fallbackVariant = false) {
+        return this.getModelsByBlock(queriedBlock, fallbackVariant, false)?.map(x => x[Math.floor(Math.random() * x.length)]);
+    }
+    getAllResolvedModels(queriedBlock, fallbackVariant = false) {
+        return this.getModelsByBlock(queriedBlock, fallbackVariant, true);
     }
 }
 const arrEq = (a, b) => !!a && !!b && a.length === b.length && a.every((v, i) => v === b[i]);