minerender 1.4.11 → 2.0.0-alpha.1

package/src/assets/BlockStates.ts

@@ -0,0 +1,64 @@
+import { Maybe } from "../util/util";
+import { BlockState } from "../model/block/BlockState";
+import { Caching } from "../cache/Caching";
+import { AssetLoader } from "./AssetLoader";
+import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
+import { Memoize } from "typscript-memoize";
+import defaultBlockStates from "../model/defaultBlockStates.json";
+import { BlockStateProperties, BlockStatePropertyDefaults } from "../model/block/BlockStateProperties";
+import { AssetKey } from "./AssetKey";
+import { PersistentCache } from "../cache/PersistentCache";
+
+export class BlockStates {
+
+    private static PERSISTENT_CACHE = PersistentCache.open("minerender-blockstates");
+
+    // BlockState names are hardcoded
+    @Memoize()
+    public static async getList(): Promise<string[]> {
+        return AssetLoader.loadOrRetryWithDefaults(new AssetKey(
+            DEFAULT_NAMESPACE,
+            "_list",
+            "blockstates",
+            undefined,
+            "assets",
+            ".json",
+            DEFAULT_ROOT
+        ), AssetLoader.LIST).then(r => r?.files ?? []);
+    }
+
+    public static getDefaultState(key: AssetKey): Maybe<BlockStatePropertyDefaults> {
+        return defaultBlockStates["minecraft:" + key.path] as BlockStatePropertyDefaults;
+    }
+
+    public static async get(key: AssetKey): Promise<Maybe<BlockState>> {
+        if (!key.assetType) {
+            key.assetType = "blockstates";
+        }
+        if (!key.extension) {
+            key.extension = ".json";
+        }
+        const keyStr = key.serialize();
+        return Caching.blockStateCache.get(keyStr, k => {
+            return this.PERSISTENT_CACHE.getOrLoad(keyStr, k1 => {
+                return AssetLoader.loadOrRetryWithDefaults(key, AssetLoader.BLOCKSTATE).then(asset => {
+                    return asset;
+                })
+            })
+        }).then(asset => {
+            if (asset) {
+                asset.key = key;
+            }
+            return asset;
+        })
+    }
+
+    public static getAll(keys: AssetKey[] | Iterable<AssetKey>): Promise<Maybe<BlockState>[]> {
+        const promises: Promise<Maybe<BlockState>>[] = [];
+        for (let key of keys) {
+            promises.push(this.get(key));
+        }
+        return Promise.all(promises);
+    }
+
+}

package/src/assets/Entities.d.ts

@@ -0,0 +1,8 @@
+import { BasicAssetKey } from "./AssetKey";
+import { EntityModel } from "../entity/EntityModel";
+export declare class Entities {
+    static getBlockList(): Promise<string[]>;
+    static getEntityList(): Promise<string[]>;
+    static getBlock(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel>;
+    static getEntity(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel>;
+}

package/src/assets/Entities.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entities = void 0;
+const blockEntityModels_json_1 = __importDefault(require("../entity/blockEntityModels.json"));
+const entityModels_json_1 = __importDefault(require("../entity/entityModels.json"));
+const AssetKey_1 = require("./AssetKey");
+class Entities {
+    // BlockEntity names are hardcoded
+    static async getBlockList() {
+        return Object.keys(blockEntityModels_json_1.default);
+    }
+    static async getEntityList() {
+        return Object.keys(entityModels_json_1.default);
+    }
+    static async getBlock(modelKey, textureKey) {
+        if (!textureKey) {
+            textureKey = modelKey;
+        }
+        const baseKey = modelKey.path.includes("/") ? new AssetKey_1.BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
+        return {
+            key: textureKey,
+            parts: blockEntityModels_json_1.default[baseKey.toNamespacedString()]
+        };
+    }
+    static async getEntity(modelKey, textureKey) {
+        if (!textureKey) {
+            textureKey = modelKey;
+        }
+        const baseKey = modelKey.path.includes("/") ? new AssetKey_1.BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
+        return {
+            key: textureKey,
+            parts: entityModels_json_1.default[baseKey.toNamespacedString()]
+        };
+    }
+}
+exports.Entities = Entities;
+//# sourceMappingURL=Entities.js.map

package/src/assets/Entities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entities.js","sourceRoot":"./","sources":["src/assets/Entities.ts"],"names":[],"mappings":";;;;;;AAAA,8FAAiE;AACjE,oFAAuD;AACvD,yCAA2C;AAG3C,MAAa,QAAQ;IAEjB,kCAAkC;IAC3B,MAAM,CAAC,KAAK,CAAC,YAAY;QAC5B,OAAO,MAAM,CAAC,IAAI,CAAC,gCAAiB,CAAC,CAAC;IAC1C,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,aAAa;QAC7B,OAAO,MAAM,CAAC,IAAI,CAAC,2BAAY,CAAC,CAAC;IACrC,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAuB,EAAE,UAA0B;QAC5E,IAAI,CAAC,UAAU,EAAE;YACb,UAAU,GAAG,QAAQ,CAAA;SACxB;QACD,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,wBAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7H,OAAO;YACH,GAAG,EAAE,UAAU;YACf,KAAK,EAAE,gCAAiB,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC;SACzD,CAAA;IACL,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,QAAuB,EAAE,UAA0B;QAC7E,IAAI,CAAC,UAAU,EAAE;YACb,UAAU,GAAG,QAAQ,CAAA;SACxB;QACD,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,wBAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7H,OAAO;YACH,GAAG,EAAE,UAAU;YACf,KAAK,EAAE,2BAAY,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC;SACpD,CAAA;IACL,CAAC;CAGJ;AAlCD,4BAkCC"}

package/src/assets/Entities.ts

@@ -0,0 +1,40 @@
+import blockEntityModels from "../entity/blockEntityModels.json";
+import entityModels from "../entity/entityModels.json";
+import { BasicAssetKey } from "./AssetKey";
+import { EntityModel } from "../entity/EntityModel";
+
+export class Entities {
+
+    // BlockEntity names are hardcoded
+    public static async getBlockList(): Promise<string[]> {
+        return Object.keys(blockEntityModels);
+    }
+
+    public static async getEntityList(): Promise<string[]> {
+        return Object.keys(entityModels);
+    }
+
+    public static async getBlock(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel> {
+        if (!textureKey) {
+            textureKey = modelKey
+        }
+        const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
+        return {
+            key: textureKey,
+            parts: blockEntityModels[baseKey.toNamespacedString()]
+        }
+    }
+
+    public static async getEntity(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<EntityModel> {
+        if (!textureKey) {
+            textureKey = modelKey
+        }
+        const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("\/")[0]) : modelKey;
+        return {
+            key: textureKey,
+            parts: entityModels[baseKey.toNamespacedString()]
+        }
+    }
+
+
+}

package/src/assets/ModelTextures.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "../util/util";
+import { TextureAsset } from "../model/Model";
+import { ExtractableImageData } from "../ExtractableImageData";
+import { MinecraftTextureMeta } from "../MinecraftTextureMeta";
+import { AssetKey } from "./AssetKey";
+export declare class ModelTextures {
+    private static PERSISTENT_META_CACHE;
+    static get(key: AssetKey): Promise<Maybe<ExtractableImageData>>;
+    static preload(key: AssetKey): Promise<Maybe<TextureAsset>>;
+    static getMeta(key: AssetKey): Promise<Maybe<MinecraftTextureMeta>>;
+}

package/src/assets/ModelTextures.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelTextures = void 0;
+const Caching_1 = require("../cache/Caching");
+const AssetLoader_1 = require("./AssetLoader");
+const ImageLoader_1 = require("../image/ImageLoader");
+const PersistentCache_1 = require("../cache/PersistentCache");
+class ModelTextures {
+    static async get(key) {
+        const asset = await this.preload(key);
+        if (asset) {
+            return ImageLoader_1.ImageLoader.infoToCanvasData(asset);
+        }
+        return undefined;
+    }
+    static async preload(key) {
+        const keyStr = key.serialize();
+        return Caching_1.Caching.textureAssetCache.get(keyStr, k => {
+            return AssetLoader_1.AssetLoader.loadOrRetryWithDefaults(key, AssetLoader_1.AssetLoader.IMAGE).then(asset => {
+                if (asset)
+                    asset.key = key;
+                return asset;
+            });
+        });
+    }
+    static async getMeta(key) {
+        key.extension += ".mcmeta";
+        const keyStr = key.serialize();
+        return Caching_1.Caching.textureMetaCache.get(keyStr, k => {
+            return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, k1 => {
+                return AssetLoader_1.AssetLoader.loadOrRetryWithDefaults(key, AssetLoader_1.AssetLoader.META).then(asset => {
+                    if (asset)
+                        asset.key = key;
+                    return asset;
+                });
+            });
+        });
+    }
+}
+exports.ModelTextures = ModelTextures;
+ModelTextures.PERSISTENT_META_CACHE = PersistentCache_1.PersistentCache.open("minerender-texturemeta");
+//# sourceMappingURL=ModelTextures.js.map

package/src/assets/ModelTextures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelTextures.js","sourceRoot":"./","sources":["src/assets/ModelTextures.ts"],"names":[],"mappings":";;;AAEA,8CAA2C;AAC3C,+CAA4C;AAE5C,sDAAmD;AAGnD,8DAA2D;AAI3D,MAAa,aAAa;IAIf,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAa;QACjC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,KAAK,EAAE;YACP,OAAO,yBAAW,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;SAC9C;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAa;QACrC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC;QAC/B,OAAO,iBAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;YAC7C,OAAO,yBAAW,CAAC,uBAAuB,CAAe,GAAG,EAAE,yBAAW,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBAC1F,IAAI,KAAK;oBACL,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;gBACpB,OAAO,KAAK,CAAC;YACjB,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;IACN,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAa;QACrC,GAAG,CAAC,SAAS,IAAI,SAAS,CAAC;QAC3B,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC;QAE/B,OAAO,iBAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;YAC5C,OAAO,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACrD,OAAO,yBAAW,CAAC,uBAAuB,CAAuB,GAAG,EAAE,yBAAW,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;oBACjG,IAAI,KAAK;wBACL,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;oBACpB,OAAO,KAAK,CAAC;gBACjB,CAAC,CAAC,CAAA;YACN,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;IACN,CAAC;;AApCL,sCAuCC;AArCkB,mCAAqB,GAAG,iCAAe,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC"}

package/src/assets/ModelTextures.ts

@@ -0,0 +1,58 @@
+import { Maybe } from "../util/util";
+import { TextureAsset } from "../model/Model";
+import { Caching } from "../cache/Caching";
+import { AssetLoader } from "./AssetLoader";
+import { CompatImage } from "../canvas/CanvasCompat";
+import { ImageLoader } from "../image/ImageLoader";
+import { ExtractableImageData } from "../ExtractableImageData";
+import { MinecraftTextureMeta } from "../MinecraftTextureMeta";
+import { PersistentCache } from "../cache/PersistentCache";
+import { keys } from "node-persist";
+import { AssetKey } from "./AssetKey";
+
+export class ModelTextures {
+
+    private static PERSISTENT_META_CACHE = PersistentCache.open("minerender-texturemeta");
+
+    public static async get(key: AssetKey): Promise<Maybe<ExtractableImageData>> {
+        const asset = await this.preload(key);
+        if (asset) {
+            return ImageLoader.infoToCanvasData(asset);
+        }
+        return undefined;
+    }
+
+    public static async preload(key: AssetKey): Promise<Maybe<TextureAsset>> {
+        const keyStr = key.serialize();
+        return Caching.textureAssetCache.get(keyStr, k => {
+            return AssetLoader.loadOrRetryWithDefaults<TextureAsset>(key, AssetLoader.IMAGE).then(asset => {
+                if (asset)
+                    asset.key = key;
+                return asset;
+            })
+        })
+    }
+
+    public static async getMeta(key: AssetKey): Promise<Maybe<MinecraftTextureMeta>> {
+        if (!key.extension || !key.extension.endsWith(".mcmeta")) {
+            key = Object.assign(new AssetKey("", ""), key);
+            key.extension += ".mcmeta";
+        }
+        const keyStr = key.serialize();
+
+        return Caching.textureMetaCache.get(keyStr, k => {
+            return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, k1 => {
+                return AssetLoader.loadOrRetryWithDefaults<MinecraftTextureMeta>(key, AssetLoader.META).then(asset => {
+                    if (asset)
+                        asset.key = key;
+                    return asset;
+                })
+            })
+        })
+    }
+
+    public static async clearCache() {
+        await this.PERSISTENT_META_CACHE.clear();
+    }
+
+}

package/src/assets/Models.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "../model/Model";
+import { Maybe } from "../util/util";
+import { AssetKey } from "./AssetKey";
+export declare class Models {
+    private static PERSISTENT_CACHE;
+    static getItemList(): Promise<string[]>;
+    static loadAndMerge(key: AssetKey): Promise<Maybe<Model>>;
+    static getRaw(key: AssetKey): Promise<Maybe<Model>>;
+    static getMerged(key: AssetKey): Promise<Maybe<Model>>;
+    static get(key: AssetKey): Promise<Maybe<Model>>;
+}

package/src/assets/Models.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Models = void 0;
+const Caching_1 = require("../cache/Caching");
+const ModelMerger_1 = require("../model/ModelMerger");
+const AssetLoader_1 = require("./AssetLoader");
+const typscript_memoize_1 = require("typscript-memoize");
+const Assets_1 = require("./Assets");
+const PersistentCache_1 = require("../cache/PersistentCache");
+const AssetKey_1 = require("./AssetKey");
+class Models {
+    static async getItemList() {
+        return AssetLoader_1.AssetLoader.loadOrRetryWithDefaults(new AssetKey_1.AssetKey(Assets_1.DEFAULT_NAMESPACE, "_list", "models", "item", ".json", Assets_1.DEFAULT_ROOT), AssetLoader_1.AssetLoader.LIST).then(r => { var _a; return (_a = r === null || r === void 0 ? void 0 : r.files) !== null && _a !== void 0 ? _a : []; });
+    }
+    static async loadAndMerge(key) {
+        const model = await this.getRaw(key);
+        if (!model) {
+            return undefined;
+        }
+        return ModelMerger_1.ModelMerger.mergeWithParents(model);
+    }
+    static async getRaw(key) {
+        if (!key.assetType) {
+            key.assetType = "models";
+        }
+        if (!key.extension) {
+            key.extension = ".json";
+        }
+        const keyStr = key.serialize();
+        return Caching_1.Caching.rawModelCache.get(keyStr, k => {
+            return this.PERSISTENT_CACHE.getOrLoad(keyStr, k1 => {
+                return AssetLoader_1.AssetLoader.loadOrRetryWithDefaults(key, AssetLoader_1.AssetLoader.MODEL).then(asset => {
+                    return asset;
+                });
+            });
+        }).then(asset => {
+            if (asset) {
+                asset.key = key;
+            }
+            return asset;
+        });
+    }
+    static async getMerged(key) {
+        if (!key.assetType) {
+            key.assetType = "models";
+        }
+        if (!key.extension) {
+            key.extension = ".json";
+        }
+        const keyStr = key.serialize();
+        return Caching_1.Caching.mergedModelCache.get(keyStr, k => {
+            return Models.loadAndMerge(key);
+        });
+    }
+    static async get(key) {
+        return this.getMerged(key);
+    }
+}
+Models.PERSISTENT_CACHE = PersistentCache_1.PersistentCache.open("minerender-models");
+__decorate([
+    typscript_memoize_1.Memoize()
+], Models, "getItemList", null);
+exports.Models = Models;
+//# sourceMappingURL=Models.js.map

package/src/assets/Models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Models.js","sourceRoot":"./","sources":["src/assets/Models.ts"],"names":[],"mappings":";;;;;;;;;AACA,8CAA2C;AAG3C,sDAAmD;AACnD,+CAA4C;AAC5C,yDAA4C;AAC5C,qCAA2D;AAC3D,8DAA2D;AAC3D,yCAAsC;AAEtC,MAAa,MAAM;IAKR,MAAM,CAAC,KAAK,CAAC,WAAW;QAC3B,OAAO,yBAAW,CAAC,uBAAuB,CAAC,IAAI,mBAAQ,CACnD,0BAAiB,EACjB,OAAO,EACP,QAAQ,EACR,MAAM,EACN,OAAO,EACP,qBAAY,CACf,EAAE,yBAAW,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAC,OAAA,MAAA,CAAC,aAAD,CAAC,uBAAD,CAAC,CAAE,KAAK,mCAAI,EAAE,CAAA,EAAA,CAAC,CAAC;IACnD,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAa;QAC1C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE;YACR,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,yBAAW,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAa;QACpC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YAChB,GAAG,CAAC,SAAS,GAAG,QAAQ,CAAC;SAC5B;QACD,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YAChB,GAAG,CAAC,SAAS,GAAG,OAAO,CAAC;SAC3B;QACD,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC;QAC/B,OAAO,iBAAO,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;YACzC,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBAChD,OAAO,yBAAW,CAAC,uBAAuB,CAAC,GAAG,EAAE,yBAAW,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;oBAC5E,OAAO,KAAK,CAAC;gBACjB,CAAC,CAAC,CAAA;YACN,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YACZ,IAAI,KAAK,EAAE;gBACP,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;aACnB;YACD,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAA;IACN,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,GAAa;QACvC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YAChB,GAAG,CAAC,SAAS,GAAG,QAAQ,CAAC;SAC5B;QACD,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YAChB,GAAG,CAAC,SAAS,GAAG,OAAO,CAAC;SAC3B;QACD,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC;QAC/B,OAAO,iBAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;YAC5C,OAAO,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAa;QACjC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;;AA3Dc,uBAAgB,GAAG,iCAAe,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;AAG5E;IADC,2BAAO,EAAE;+BAUT;AAdL,wBA+DC"}

package/src/assets/Models.ts

@@ -0,0 +1,81 @@
+import { Model } from "../model/Model";
+import { Caching } from "../cache/Caching";
+import { Textures } from "../texture/Textures";
+import { Maybe } from "../util/util";
+import { ModelMerger } from "../model/ModelMerger";
+import { AssetLoader } from "./AssetLoader";
+import { Memoize } from "typscript-memoize";
+import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
+import { PersistentCache } from "../cache/PersistentCache";
+import { AssetKey } from "./AssetKey";
+
+export class Models {
+
+    private static PERSISTENT_CACHE = PersistentCache.open("minerender-models");
+
+    @Memoize()
+    public static async getItemList(): Promise<string[]> {
+        return AssetLoader.loadOrRetryWithDefaults(new AssetKey(
+            DEFAULT_NAMESPACE,
+            "_list",
+            "models",
+            "item",
+            "assets",
+            ".json",
+            DEFAULT_ROOT
+        ), AssetLoader.LIST).then(r => r?.files ?? []);
+    }
+
+    public static async loadAndMerge(key: AssetKey): Promise<Maybe<Model>> {
+        const model = await this.getRaw(key);
+        if (!model) {
+            return undefined;
+        }
+        return ModelMerger.mergeWithParents(model);
+    }
+
+    public static async getRaw(key: AssetKey): Promise<Maybe<Model>> {
+        if (!key.assetType) {
+            key.assetType = "models";
+        }
+        if (!key.extension) {
+            key.extension = ".json";
+        }
+        const keyStr = key.serialize();
+        return Caching.rawModelCache.get(keyStr, k => {
+            return this.PERSISTENT_CACHE.getOrLoad(keyStr, k1 => {
+                return AssetLoader.loadOrRetryWithDefaults(key, AssetLoader.MODEL).then(asset => {
+                    return asset;
+                })
+            })
+        }).then(asset => {
+            if (asset) {
+                asset.key = key;
+            }
+            return asset;
+        })
+    }
+
+    public static async getMerged(key: AssetKey): Promise<Maybe<Model>> {
+        if (!key.assetType) {
+            key.assetType = "models";
+        }
+        if (!key.extension) {
+            key.extension = ".json";
+        }
+        const keyStr = key.serialize();
+        return Caching.mergedModelCache.get(keyStr, k => {
+            //TODO: persistent cache
+            return Models.loadAndMerge(key);
+        });
+    }
+
+    public static async get(key: AssetKey): Promise<Maybe<Model>> {
+        return this.getMerged(key);
+    }
+
+    public static async clearCache() {
+        return this.PERSISTENT_CACHE.clear();
+    }
+
+}

package/src/bedrock/BedrockEntityDescription.ts

@@ -0,0 +1,11 @@
+export interface BedrockEntityDescription {
+    identifier: string;
+    materials: { [k: string]: string };
+    textures: { [k: string]: string };
+    geometry: { [k: string]: string };
+    scripts?: any;
+    animations: { [k: string]: string };
+    animation_controllers?: any;
+    render_controllers: any;
+    enable_attachables?: boolean;
+}

package/src/bedrock/BedrockEntityFile.ts

@@ -0,0 +1,8 @@
+import { BedrockEntityDescription } from "./BedrockEntityDescription";
+
+export interface BedrockEntityFile {
+    format_version: string;
+    "minecraft:client_entity": {
+        "description": BedrockEntityDescription;
+    }
+}

package/src/bedrock/BedrockGeometry.ts

@@ -0,0 +1,28 @@
+import { DoubleArray, TripleArray } from "../model/Model";
+
+export interface BedrockGeometry {
+    visible_bounds_width: number;
+    visible_bounds_height: number;
+    visible_bounds_offset: TripleArray;
+    texturewidth: number;
+    textureheight: number;
+    bones: BedrockBone[];
+}
+
+export interface BedrockBone {
+    name: string;
+    parent?: string;
+    reset?: boolean;
+    pivot?: TripleArray;
+    cubes?: BedrockCube[];
+    rotation?: TripleArray;
+    neverRender?: boolean;
+    locators?: {[k: string]:TripleArray};
+}
+
+export interface BedrockCube {
+    origin: TripleArray;
+    size: TripleArray;
+    uv?: DoubleArray;
+    inflate?: number;
+}

package/src/bedrock/BedrockGeometryFile.ts

@@ -0,0 +1,7 @@
+import { BedrockGeometry } from "./BedrockGeometry";
+
+export interface BedrockGeometryFile {
+    format_version: string;
+
+    [key: string]: BedrockGeometry|any;
+}

package/src/cache/CacheKey.d.ts

@@ -0,0 +1,28 @@
+import { PixelFormat } from "three";
+export declare type CacheKey = string;
+export interface RawImageKey {
+    src: string;
+}
+export declare function serializeImageKey(key: RawImageKey): string;
+export interface BoxGeometryKey {
+    width: number;
+    height: number;
+    depth: number;
+    uv?: number[];
+}
+export declare function serializeBoxGeometryKey(key: BoxGeometryKey): string;
+export interface TextureKey extends RawImageKey {
+    format?: PixelFormat;
+    rotation?: number;
+}
+export declare function serializeTextureKey(key: TextureKey): string;
+export interface MaterialKey {
+    texture: TextureKey;
+    transparent?: boolean;
+}
+export declare function serializeMaterialKey(key: MaterialKey): string;
+export interface MeshKey {
+    geometry: BoxGeometryKey;
+    material: MaterialKey;
+}
+export declare function serializeMeshKey(key: MeshKey): string;

package/src/cache/CacheKey.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeMeshKey = exports.serializeMaterialKey = exports.serializeTextureKey = exports.serializeBoxGeometryKey = exports.serializeImageKey = void 0;
+const util_1 = require("../util/util");
+function serializeImageKey(key) {
+    return util_1.md5(key.src);
+}
+exports.serializeImageKey = serializeImageKey;
+function serializeBoxGeometryKey(key) {
+    var _a;
+    return util_1.md5([key.width, key.height, key.depth, (_a = key.uv) === null || _a === void 0 ? void 0 : _a.join(":")].join("_"));
+}
+exports.serializeBoxGeometryKey = serializeBoxGeometryKey;
+function serializeTextureKey(key) {
+    return util_1.md5([key.src, key.format, key.rotation].join("$"));
+}
+exports.serializeTextureKey = serializeTextureKey;
+function serializeMaterialKey(key) {
+    return util_1.md5([serializeTextureKey(key.texture), key.transparent].join("~"));
+}
+exports.serializeMaterialKey = serializeMaterialKey;
+function serializeMeshKey(key) {
+    return util_1.md5([serializeBoxGeometryKey(key.geometry), serializeMaterialKey(key.material)].join("#"));
+}
+exports.serializeMeshKey = serializeMeshKey;
+///
+//# sourceMappingURL=CacheKey.js.map

package/src/cache/CacheKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheKey.js","sourceRoot":"./","sources":["src/cache/CacheKey.ts"],"names":[],"mappings":";;;AACA,uCAAmC;AAQnC,SAAgB,iBAAiB,CAAC,GAAgB;IAC9C,OAAO,UAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACxB,CAAC;AAFD,8CAEC;AAiBD,SAAgB,uBAAuB,CAAC,GAAmB;;IACvD,OAAO,UAAG,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,MAAA,GAAG,CAAC,EAAE,0CAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAChF,CAAC;AAFD,0DAEC;AAoBD,SAAgB,mBAAmB,CAAC,GAAe;IAC/C,OAAO,UAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9D,CAAC;AAFD,kDAEC;AAiBD,SAAgB,oBAAoB,CAAC,GAAgB;IACjD,OAAO,UAAG,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9E,CAAC;AAFD,oDAEC;AAUD,SAAgB,gBAAgB,CAAC,GAAY;IACzC,OAAO,UAAG,CAAC,CAAC,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AACtG,CAAC;AAFD,4CAEC;AAGD,GAAG"}

package/src/cache/CacheKey.ts

@@ -0,0 +1,90 @@
+import { PixelFormat } from "three";
+import { md5 } from "../util/util";
+
+export type CacheKey = string;
+
+export interface RawImageKey {
+    src: string;
+}
+
+export function serializeImageKey(key: RawImageKey): string {
+    return md5(key.src);
+}
+
+// export function parseImageKey(key: string): RawImageKey {
+//     return {
+//         src: base64decode(key)
+//     };
+// }
+
+///
+
+export interface BoxGeometryKey {
+    width: number;
+    height: number;
+    depth: number;
+    uv?: number[];
+}
+
+export function serializeBoxGeometryKey(key: BoxGeometryKey): string {
+    return md5([key.width, key.height, key.depth, key.uv?.join(":")].join("_"));
+}
+
+// export function parseBoxGeometryKey(key: string): BoxGeometryKey {
+//     let [width, height, depth, uvS] = base64decode(key).split("_");
+//     let uv = uvS.split(":").map(s => +s);
+//     return {
+//         width: +width,
+//         height: +height,
+//         depth: +depth,
+//         uv
+//     }
+// }
+
+///
+
+export interface TextureKey extends RawImageKey {
+    format?: PixelFormat;
+    rotation?: number;
+}
+
+export function serializeTextureKey(key: TextureKey): string {
+    return md5([key.src, key.format, key.rotation].join("$"));
+}
+
+// export function parseTextureGeometryKey(key: string): TextureKey {
+//     let [src, format] = base64decode(key).split("$");
+//     return {
+//         src,
+//         format: +format
+//     }
+// }
+
+///
+
+export interface MaterialKey {
+    texture: TextureKey;
+    transparent?: boolean;
+}
+
+export function serializeMaterialKey(key: MaterialKey): string {
+    return md5([serializeTextureKey(key.texture), key.transparent].join("~"));
+}
+
+
+///
+
+export interface MeshKey {
+    geometry: BoxGeometryKey;
+    material: MaterialKey;
+}
+
+export function serializeMeshKey(key: MeshKey): string {
+    return md5([serializeBoxGeometryKey(key.geometry), serializeMaterialKey(key.material)].join("#"));
+}
+
+
+///
+
+
+