minerender 2.0.0-alpha.6 → 2.0.0-alpha.8

package/src/assets/AssetLoader.ts

@@ -11,142 +11,41 @@ import { ListAsset } from "../ListAsset";
 import { AssetKey } from "./AssetKey";
 import { NBTAsset, NBTHelper } from "../nbt/NBTHelper";
 import { prefix } from "../util/log";
+import { AssetSource } from "./source/AssetSource";
+import { AssetParser } from "./source/parser/AssetParsers";
+import { HostedAssetSource } from "./source";
 
 const p = prefix("AssetLoader");
 
-export interface ResponseParser<T extends MinecraftAsset> {
-    config(request: AxiosRequestConfig);
-
-    parse(response: AxiosResponse): Maybe<T> | Promise<Maybe<T>>;
-}
 
 export class AssetLoader {
 
-    static readonly MODEL: ResponseParser<Model> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<Model> {
-            return response.data as Model;
-        }
-    }
-    static readonly BLOCKSTATE: ResponseParser<BlockState> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<BlockState> {
-            return response.data as BlockState;
-        }
-    }
-    static readonly META: ResponseParser<MinecraftTextureMeta> = {
-        config(request: AxiosRequestConfig) {
-            // request.responseType = "arraybuffer";
-        },
-        parse(response: AxiosResponse): Maybe<MinecraftTextureMeta> {
-            return response.data as MinecraftTextureMeta;
-        }
-    }
-    static readonly NBT: ResponseParser<NBTAsset> = {
-        config(request: AxiosRequestConfig) {
-            request.responseType = "arraybuffer";
-        },
-        parse(response: AxiosResponse): Promise<Maybe<NBTAsset>> {
-            return NBTHelper.fromBuffer(Buffer.from(response.data));
-        }
-    }
-    static readonly IMAGE: ResponseParser<TextureAsset> = {
-        config(request: AxiosRequestConfig) {
-            request.responseType = "arraybuffer";
-        },
-        async parse(response: AxiosResponse): Promise<Maybe<TextureAsset>> {
-            return await ImageLoader.processResponse(response) as TextureAsset;
-        }
-    }
-    static readonly LIST: ResponseParser<ListAsset> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<ListAsset> {
-            return response.data as ListAsset;
-        }
-    }
-    static readonly JSON: ResponseParser<any> = {
-        config(request: AxiosRequestConfig) {
-        },
-        parse(response: AxiosResponse): Maybe<any> {
-            return response.data;
-        }
+    static ROOT: string = DEFAULT_ROOT;
+
+    private static _SOURCES: AssetSourceReference[] = [];
+
+    public static addSource(key: string, source: AssetSource) {
+        this._SOURCES.unshift({key, source});
+        console.log(p, "Added AssetSource", key);
     }
 
-    static ROOT: string = DEFAULT_ROOT;
+    static {
+        this.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT));
+    }
 
-    public static async loadOrRetryWithDefaults<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
-        const direct = await this.load<T>(key, parser);
-        if (typeof direct !== "undefined") {
-            return direct;
-        }
-        if (key.namespace !== DEFAULT_NAMESPACE) {
-            console.info(p, "Retrying", key, "with default namespace");
-            // Try on the same host but with default minecraft: namespace
-            const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
-            const namespaced = await this.load<T>(namespaceKey, parser);
-            if (typeof namespaced !== "undefined") {
-                return namespaced;
-            }
-            if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.ROOT !== "undefined" && this.ROOT !== DEFAULT_ROOT)) {
-                console.info(p, "Retrying", key, "with default root+namespace");
-                // Try both defaults
-                const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
-                const namespacedRooted = await this.load<T>(namespacedRootedKey, parser);
-                if (typeof namespacedRooted !== "undefined") {
-                    return namespacedRooted;
-                }
-            }
-        } else if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.ROOT !== "undefined" && this.ROOT !== DEFAULT_ROOT)) {
-            console.info(p, "Retrying", key, "with default root");
-            // Try on default root
-            const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
-            const rooted = await this.load<T>(rootKey, parser);
-            if (typeof rooted !== "undefined") {
-                return rooted;
+    public static async get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>> {
+        for (const source of this._SOURCES) {
+            const result = await source.source.get<T>(key, parser);
+            if (result) {
+                return result;
             }
         }
         return undefined;
     }
 
+}
 
-    protected static async load<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
-        console.info(p, "Loading", key);
-        const url = `${ this.assetBasePath(key) }${ key.type !== undefined ? key.type + '/' : '' }${ key.path }${ key.extension }`;
-        console.debug(p, url);
-        let req: AxiosRequestConfig = {
-            url: url
-        };
-        parser.config(req);
-        return await Requests.mcAssetRequest(req)
-            .then(response => {
-                if (response && response.data) {
-                    try {
-                        return parser.parse(response);
-                    } catch (e) {
-                        console.warn("Parser failed to process response", response, e);
-                        throw e;
-                    }
-                }
-                return undefined;
-            })
-            .catch(err => {
-                if (err.response) {
-                    let response = err.response as AxiosResponse;
-                    if (response.status === 404) {
-                        console.debug(p, key, "not found");
-                        return undefined;
-                    }
-                }
-                console.debug(p, "Failed to load", key, err?.message);
-                return undefined;
-            })
-    }
-
-    public static assetBasePath(key: AssetKey) {
-        return `${ key.root ?? this.ROOT }/${ key.rootType !== undefined ? key.rootType + '/' : '' }${ key.namespace !== undefined ? key.namespace + '/' : '' }${ key.assetType !== undefined ? key.assetType + '/' : '' }`;
-    }
-
+interface AssetSourceReference {
+    key: string;
+    source: AssetSource;
 }

package/src/assets/BlockStates.ts

@@ -8,6 +8,8 @@ import defaultBlockStates from "../model/defaultBlockStates.json";
 import { BlockStateProperties, BlockStatePropertyDefaults } from "../model/block/BlockStateProperties";
 import { AssetKey } from "./AssetKey";
 import { PersistentCache } from "../cache/PersistentCache";
+import { AssetParser } from "./source/parser/AssetParsers";
+import { ListAsset } from "../ListAsset";
 
 export class BlockStates {
 
@@ -16,7 +18,7 @@ export class BlockStates {
     // BlockState names are hardcoded
     @Memoize()
     public static async getList(): Promise<string[]> {
-        return AssetLoader.loadOrRetryWithDefaults(new AssetKey(
+        return AssetLoader.get<ListAsset>(new AssetKey(
             DEFAULT_NAMESPACE,
             "_list",
             "blockstates",
@@ -24,7 +26,7 @@ export class BlockStates {
             "assets",
             ".json",
             DEFAULT_ROOT
-        ), AssetLoader.LIST).then(r => r?.files ?? []);
+        ), AssetParser.LIST).then(r => r?.files ?? []);
     }
 
     public static getDefaultState(key: AssetKey): Maybe<BlockStatePropertyDefaults> {
@@ -41,9 +43,7 @@ export class BlockStates {
         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;
-                })
+                return AssetLoader.get<BlockState>(key, AssetParser.BLOCKSTATE);
             })
         }).then(asset => {
             if (asset) {
@@ -61,4 +61,8 @@ export class BlockStates {
         return Promise.all(promises);
     }
 
+    public static async clearCache() {
+        await this.PERSISTENT_CACHE.clear();
+    }
+
 }

package/src/assets/ModelTextures.ts

@@ -9,6 +9,7 @@ import { MinecraftTextureMeta } from "../MinecraftTextureMeta";
 import { PersistentCache } from "../cache/PersistentCache";
 import { keys } from "node-persist";
 import { AssetKey } from "./AssetKey";
+import { AssetParser } from "./source/parser/AssetParsers";
 
 export class ModelTextures {
 
@@ -25,7 +26,7 @@ export class ModelTextures {
     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 => {
+            return AssetLoader.get<TextureAsset>(key, AssetParser.IMAGE).then(asset => {
                 if (asset)
                     asset.key = key;
                 return asset;
@@ -42,7 +43,7 @@ export class ModelTextures {
 
         return Caching.textureMetaCache.get(keyStr, k => {
             return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, k1 => {
-                return AssetLoader.loadOrRetryWithDefaults<MinecraftTextureMeta>(key, AssetLoader.META).then(asset => {
+                return AssetLoader.get<MinecraftTextureMeta>(key, AssetParser.META).then(asset => {
                     if (asset)
                         asset.key = key;
                     return asset;

package/src/assets/Models.ts

@@ -8,6 +8,8 @@ import { Memoize } from "typescript-memoize";
 import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "./Assets";
 import { PersistentCache } from "../cache/PersistentCache";
 import { AssetKey } from "./AssetKey";
+import { ListAsset } from "../ListAsset";
+import { AssetParser } from "./source/parser/AssetParsers";
 
 export class Models {
 
@@ -15,7 +17,7 @@ export class Models {
 
     @Memoize()
     public static async getItemList(): Promise<string[]> {
-        return AssetLoader.loadOrRetryWithDefaults(new AssetKey(
+        return AssetLoader.get<ListAsset>(new AssetKey(
             DEFAULT_NAMESPACE,
             "_list",
             "models",
@@ -23,7 +25,7 @@ export class Models {
             "assets",
             ".json",
             DEFAULT_ROOT
-        ), AssetLoader.LIST).then(r => r?.files ?? []);
+        ), AssetParser.LIST).then(r => r?.files ?? []);
     }
 
     public static async loadAndMerge(key: AssetKey): Promise<Maybe<Model>> {
@@ -44,9 +46,7 @@ export class Models {
         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;
-                })
+                return AssetLoader.get<Model>(key, AssetParser.MODEL);
             })
         }).then(asset => {
             if (asset) {

package/src/assets/index.ts

@@ -0,0 +1,9 @@
+// autogenerated
+export * from './AssetKey';
+export * from './AssetLoader';
+export * from './Assets';
+export * from './BlockStates';
+export * from './Entities';
+export * from './ModelTextures';
+export * from './Models';
+export * from './source';

package/src/assets/source/AssetSource.ts

@@ -0,0 +1,13 @@
+import { MinecraftAsset } from "../../MinecraftAsset";
+import { AssetKey } from "../AssetKey";
+import { Maybe } from "../../util";
+import { AssetParser } from "./parser/AssetParsers";
+
+export abstract class AssetSource {
+
+    protected constructor() {
+    }
+
+    public abstract get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>>;
+
+}

package/src/assets/source/HostedAssetSource.ts

@@ -0,0 +1,191 @@
+import { AssetSource } from ".";
+import { BlockState, Model, TextureAsset } from "../../model";
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { Maybe, prefix } from "../../util";
+import { MinecraftTextureMeta } from "../../MinecraftTextureMeta";
+import { NBTAsset, NBTHelper } from "../../nbt";
+import { ImageLoader } from "../../image";
+import { ListAsset } from "../../ListAsset";
+import { MinecraftAsset } from "../../MinecraftAsset";
+import { AssetKey } from "../AssetKey";
+import { DEFAULT_NAMESPACE, DEFAULT_ROOT } from "../Assets";
+import { Requests } from "../../request";
+import { AssetLoader } from "../AssetLoader";
+import { AssetParser } from "./parser";
+import { ResponseParser } from "./parser";
+import merge from "ts-deepmerge";
+
+const p = prefix("HostedAssetSource");
+
+const DEFAULT_OPTIONS: HostedAssetSourceOptions = {
+    retryDefaults: true
+}
+
+export class HostedAssetSource extends AssetSource {
+
+    static readonly MODEL: ResponseParser<Model> = {
+        config(request: AxiosRequestConfig) {
+        },
+        parse(response: AxiosResponse): Maybe<Model> {
+            return response.data as Model;
+        }
+    }
+    static readonly BLOCKSTATE: ResponseParser<BlockState> = {
+        config(request: AxiosRequestConfig) {
+        },
+        parse(response: AxiosResponse): Maybe<BlockState> {
+            return response.data as BlockState;
+        }
+    }
+    static readonly META: ResponseParser<MinecraftTextureMeta> = {
+        config(request: AxiosRequestConfig) {
+            // request.responseType = "arraybuffer";
+        },
+        parse(response: AxiosResponse): Maybe<MinecraftTextureMeta> {
+            return response.data as MinecraftTextureMeta;
+        }
+    }
+    static readonly NBT: ResponseParser<NBTAsset> = {
+        config(request: AxiosRequestConfig) {
+            request.responseType = "arraybuffer";
+        },
+        parse(response: AxiosResponse): Promise<Maybe<NBTAsset>> {
+            return NBTHelper.fromBuffer(Buffer.from(response.data));
+        }
+    }
+    static readonly IMAGE: ResponseParser<TextureAsset> = {
+        config(request: AxiosRequestConfig) {
+            request.responseType = "arraybuffer";
+        },
+        async parse(response: AxiosResponse): Promise<Maybe<TextureAsset>> {
+            return await ImageLoader.processResponse(response) as TextureAsset;
+        }
+    }
+    static readonly LIST: ResponseParser<ListAsset> = {
+        config(request: AxiosRequestConfig) {
+        },
+        parse(response: AxiosResponse): Maybe<ListAsset> {
+            return response.data as ListAsset;
+        }
+    }
+    static readonly JSON: ResponseParser<any> = {
+        config(request: AxiosRequestConfig) {
+        },
+        parse(response: AxiosResponse): Maybe<any> {
+            return response.data;
+        }
+    }
+
+    static readonly PARSER_MAP: Map<AssetParser, ResponseParser<any>> = new Map<AssetParser, ResponseParser<any>>([
+        [AssetParser.MODEL, HostedAssetSource.MODEL],
+        [AssetParser.BLOCKSTATE, HostedAssetSource.BLOCKSTATE],
+        [AssetParser.META, HostedAssetSource.META],
+        [AssetParser.NBT, HostedAssetSource.NBT],
+        [AssetParser.IMAGE, HostedAssetSource.IMAGE],
+        [AssetParser.LIST, HostedAssetSource.LIST],
+        [AssetParser.JSON, HostedAssetSource.JSON],
+    ]);
+
+    public async loadOrRetryWithDefaults<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
+        const direct = await this.load<T>(key, parser);
+        if (typeof direct !== "undefined") {
+            return direct;
+        }
+        if (key.namespace !== DEFAULT_NAMESPACE) {
+            console.info(p, "Retrying", key, "with default namespace");
+            // Try on the same host but with default minecraft: namespace
+            const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
+            const namespaced = await this.load<T>(namespaceKey, parser);
+            if (typeof namespaced !== "undefined") {
+                return namespaced;
+            }
+            if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT)) {
+                console.info(p, "Retrying", key, "with default root+namespace");
+                // Try both defaults
+                const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
+                const namespacedRooted = await this.load<T>(namespacedRootedKey, parser);
+                if (typeof namespacedRooted !== "undefined") {
+                    return namespacedRooted;
+                }
+            }
+        } else if ((typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT) || (typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT)) {
+            console.info(p, "Retrying", key, "with default root");
+            // Try on default root
+            const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
+            const rooted = await this.load<T>(rootKey, parser);
+            if (typeof rooted !== "undefined") {
+                return rooted;
+            }
+        }
+        return undefined;
+    }
+
+
+    protected async load<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>> {
+        console.info(p, "Loading", key);
+        const url = `${ this.assetBasePath(key) }${ key.type !== undefined ? key.type + '/' : '' }${ key.path }${ key.extension }`;
+        console.debug(p, url);
+        let req: AxiosRequestConfig = {
+            url: url
+        };
+        parser.config(req);
+        // @ts-ignore
+        return await Requests.mcAssetRequest(req)
+            .then(response => {
+                if (response && response.data) {
+                    try {
+                        return parser.parse(response);
+                    } catch (e) {
+                        console.warn("Parser failed to process response", response, e);
+                        throw e;
+                    }
+                }
+                return undefined;
+            })
+            .catch(err => {
+                if (err.response) {
+                    let response = err.response as AxiosResponse;
+                    if (response.status === 404) {
+                        console.debug(p, key, "not found");
+                        return undefined;
+                    }
+                }
+                console.debug(p, "Failed to load", key, err?.message);
+                return undefined;
+            })
+    }
+
+    public assetBasePath(key: AssetKey) {
+        return `${ key.root ?? this.root ?? AssetLoader.ROOT }/${ key.rootType !== undefined ? key.rootType + '/' : '' }${ key.namespace !== undefined ? key.namespace + '/' : '' }${ key.assetType !== undefined ? key.assetType + '/' : '' }`;
+    }
+
+    private readonly _root: string;
+    private readonly _options: HostedAssetSourceOptions;
+
+    public constructor(root: string, options?: Partial<HostedAssetSourceOptions>) {
+        super();
+        this._root = root;
+        this._options = merge({}, DEFAULT_OPTIONS, options ?? {});
+    }
+
+    public get root(): string {
+        return this._root;
+    }
+
+    public get options(): HostedAssetSourceOptions {
+        return this._options;
+    }
+
+    public get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser): Promise<Maybe<T>> {
+        const responseParser = HostedAssetSource.PARSER_MAP.get(parser) as ResponseParser<T>;
+        if (this.options.retryDefaults) {
+            return this.loadOrRetryWithDefaults(key, responseParser);
+        }
+        return this.load(key, responseParser);
+    }
+
+}
+
+interface HostedAssetSourceOptions {
+    retryDefaults: boolean;
+}

package/src/assets/source/index.ts

@@ -0,0 +1,4 @@
+// autogenerated
+export * from './AssetSource';
+export * from './HostedAssetSource';
+export * from './parser';

package/src/assets/source/parser/AssetParsers.ts

@@ -0,0 +1,11 @@
+export enum AssetParser {
+
+    MODEL = "model",
+    BLOCKSTATE = "blockstate",
+    META = "meta",
+    NBT = "nbt",
+    IMAGE = "image",
+    LIST = "list",
+    JSON = "json",
+
+}

package/src/assets/source/parser/ResponseParser.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { Maybe } from "../../../util";
+import { MinecraftAsset } from "../../../MinecraftAsset";
+
+export interface ResponseParser<T extends MinecraftAsset> {
+    config(request: AxiosRequestConfig);
+
+    parse(response: AxiosResponse): Maybe<T> | Promise<Maybe<T>>;
+}

package/src/assets/source/parser/index.ts

@@ -0,0 +1,3 @@
+// autogenerated
+export * from './AssetParsers';
+export * from './ResponseParser';

package/src/bedrock/index.ts

@@ -0,0 +1,5 @@
+// autogenerated
+export * from './BedrockEntityDescription';
+export * from './BedrockEntityFile';
+export * from './BedrockGeometry';
+export * from './BedrockGeometryFile';

package/src/cache/index.ts

@@ -0,0 +1,4 @@
+// autogenerated
+export * from './CacheKey';
+export * from './Caching';
+export * from './PersistentCache';

package/src/canvas/index.ts

@@ -0,0 +1,3 @@
+// autogenerated
+export * from './CanvasCompat';
+export * from './CanvasImage';

package/src/entity/index.ts

@@ -0,0 +1,3 @@
+// autogenerated
+export * from './EntityModel';
+export * from './scene';

package/src/entity/scene/index.ts

@@ -0,0 +1,2 @@
+// autogenerated
+export * from './EntityObject';

package/src/error/index.ts

@@ -0,0 +1,2 @@
+// autogenerated
+export * from './MineRenderError';

package/src/gui/index.ts

@@ -0,0 +1,2 @@
+// autogenerated
+export * from './scene';

package/src/gui/scene/index.ts

@@ -0,0 +1,2 @@
+// autogenerated
+export * from './GuiObject';

package/src/image/index.ts

@@ -0,0 +1,2 @@
+// autogenerated
+export * from './ImageLoader';