@xmcl/resource-manager/index.cjs.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var resourcepack = require('@xmcl/resourcepack');
var system = require('@xmcl/system');

/**
 * The model loader load the resource
 */
class ModelLoader {
    /**
     * @param manager The resource manager
     */
    constructor(manager) {
        this.manager = manager;
        /**
         * All required texture raw resources
         */
        this.textures = {};
        /**
         * All the resolved model
         */
        this.models = {};
    }
    static findRealTexturePath(model, variantKey) {
        let texturePath = model.textures[variantKey];
        while (texturePath.startsWith("#")) {
            const next = model.textures[texturePath.substring(1, texturePath.length)];
            if (!next) {
                return undefined;
            }
            texturePath = next;
        }
        return texturePath;
    }
    /**
     * Load a model by search its parent. It will throw an error if the model is not found.
     */
    async loadModel(modelPath) {
        const res = await this.manager.load(resourcepack.ResourceLocation.ofModelPath(modelPath));
        if (!res) {
            throw new Error(`Model ${modelPath} (${resourcepack.ResourceLocation.ofModelPath(modelPath)}) not found`);
        }
        const raw = JSON.parse(system.System.bufferToText(res.content));
        if (!raw.textures) {
            raw.textures = {};
        }
        if (raw.parent) {
            const parentModel = await this.loadModel(raw.parent);
            if (!parentModel) {
                throw new Error(`Missing parent model ${raw.parent} for ${location.toString()}`);
            }
            if (!raw.elements) {
                raw.elements = parentModel.elements;
            }
            if (!raw.ambientocclusion) {
                raw.ambientocclusion = parentModel.ambientocclusion;
            }
            if (!raw.display) {
                raw.display = parentModel.display;
            }
            if (!raw.overrides) {
                raw.overrides = parentModel.overrides;
            }
            if (parentModel.textures) {
                Object.assign(raw.textures, parentModel.textures);
            }
        }
        raw.ambientocclusion = raw.ambientocclusion || false;
        raw.overrides = raw.overrides || [];
        delete raw.parent;
        const model = raw;
        this.models[modelPath] = model;
        const reg = this.textures;
        for (const variant of Object.keys(model.textures)) {
            const texPath = ModelLoader.findRealTexturePath(model, variant);
            if (texPath) {
                const load = await this.manager.load(resourcepack.ResourceLocation.ofTexturePath(texPath));
                if (load) {
                    reg[texPath] = load;
                }
            }
        }
        return model;
    }
}

/**
 * The resource manager. Design to be able to use in both nodejs and browser environment.
 * @template T The type of the resource content. If you use this in node, it's probably `Buffer`. If you are in browser, it might be `string`. Just align this with your `ResourceSource`
 */
class ResourceManager {
    constructor(list = []) {
        this.list = list;
        this.cache = {};
    }
    get allResourcePacks() { return this.list.map((l) => l.info); }
    /**
     * Add a new resource source to the end of the resource list.
     */
    async addResourcePack(resourcePack) {
        let info;
        try {
            info = await resourcePack.info();
        }
        catch (_a) {
            info = { pack_format: -1, description: "" };
        }
        const domains = await resourcePack.domains();
        const wrapper = { info, source: resourcePack, domains };
        this.list.push(wrapper);
    }
    /**
     * Clear all cache
     */
    clearCache() { this.cache = {}; }
    /**
     * Clear all resource source and cache
     */
    clearAll() {
        this.cache = {};
        this.list.splice(0, this.list.length);
    }
    /**
     * Swap the resource source priority.
     */
    swap(first, second) {
        if (first >= this.list.length || first < 0 || second >= this.list.length || second < 0) {
            throw new Error("Illegal index");
        }
        const fir = this.list[first];
        this.list[first] = this.list[second];
        this.list[second] = fir;
        this.clearCache();
    }
    /**
     * Invalidate the resource cache
     */
    invalidate(location) {
        delete this.cache[`${location.domain}:${location.path}`];
    }
    /**
     * Load the resource in that location. This will walk through current resource source list to load the resource.
     * @param location The resource location
     * @param urlOnly If true, it will force return uri, else it will return the normal resource content
     */
    async load(location, urlOnly = false) {
        const cached = this.cache[`${location.domain}:${location.path}`];
        if (cached) {
            return cached;
        }
        for (const src of this.list) {
            const loaded = await src.source.load(location, urlOnly);
            if (!loaded) {
                continue;
            }
            this.putCache(loaded);
            return loaded;
        }
        return undefined;
    }
    putCache(res) {
        this.cache[`${res.location.domain}:${res.location.path}`] = res;
    }
}

exports.ModelLoader = ModelLoader;
exports.ResourceManager = ResourceManager;