index.js

"use strict";

var Resource = require("resource-loader").Resource;

function pathWithoutFile(path) {
    var elements = path.split("/");
    elements.pop(); // remove filename
    return elements.join("/");
}

// Simple "wait for all" helper class
function WaitForAll(count, allDone) {
    var remaining = count;

    this.done = function() {
        remaining--;
        if (remaining === 0) {
            allDone();
        }
    };
}

module.exports = function (PIXI)
{
    var PIXI_VERSION = Number(PIXI.VERSION.charAt(0));
    if(PIXI_VERSION < 4) {
        throw new Error("PIXI version needs to be >= v4.0.0");
    }

    return function (resource, next)
    {
        // skip if no data, its not json, or it isn't a pixi-packer manifest
        if (!resource.data || resource.type !== Resource.TYPE.JSON || !resource.data.meta || resource.data.meta.type !== "pixi-packer") {
            return next();
        }

        if (resource.data.meta.version > 1) {
            throw new Error("pixi-packer manifest version " + resource.data.meta.version + " not supported");
        }

        var loader = this;

        var loadOptions = {
            crossOrigin: resource.crossOrigin,
            loadType: Resource.LOAD_TYPE.IMAGE,
            parentResource: resource
        };

        var urlForManifest = resource.url.replace(loader.baseUrl, "");
        var route = pathWithoutFile(urlForManifest);

        var resolution = resource.data.resolution;
        var versionResolutionFactor = PIXI_VERSION >= 5 ? 1 : resolution;

        if (resource.data.spritesheets.length && loader.progress === 100) {
            // This is a temporary workaround until a solution for https://github.com/englercj/resource-loader/pull/32 is found
            loader.progress = 0;
        }

        // Load all spritesheets
        var waiter = new WaitForAll(resource.data.spritesheets.length, next);
        resource.data.spritesheets.forEach(function(spritesheet) {
            var name = spritesheet.image;
            var imageUrl = route + "/" + spritesheet.image;
            if (PIXI.Texture.removeFromCache) {
                PIXI.Texture.removeFromCache(name);
                PIXI.Texture.removeFromCache(imageUrl);
                PIXI.BaseTexture.removeFromCache(name);
                PIXI.BaseTexture.removeFromCache(imageUrl);
            }
            loader.add(name, imageUrl, loadOptions, function (res) {
                res.texture.baseTexture.resolution = resolution;
                res.texture.baseTexture.update();
                res.textures = {};
                spritesheet.sprites.forEach(function(sprite) {
                    var frame = new PIXI.Rectangle(
                        sprite.position.x / versionResolutionFactor,
                        sprite.position.y / versionResolutionFactor,
                        sprite.dimension.w / versionResolutionFactor,
                        sprite.dimension.h / versionResolutionFactor
                    );

                    var crop = new PIXI.Rectangle(
                        0,
                        0,
                        sprite.dimension.w / resolution,
                        sprite.dimension.h / resolution
                    );

                    var trim = crop;

                    //  Check to see if the sprite is trimmed
                    if (sprite.trim) {
                        trim = new PIXI.Rectangle(
                            sprite.trim.x / resolution,
                            sprite.trim.y / resolution,
                            sprite.trim.w / resolution,
                            sprite.trim.h / resolution
                        );

                        frame.width = sprite.trim.w / versionResolutionFactor;
                        frame.height = sprite.trim.h / versionResolutionFactor;
                    }

                    res.textures[sprite.name] = new PIXI.Texture(res.texture.baseTexture, frame, crop, trim, 0);

                    // lets also add the frame to pixi's global cache for fromFrame and fromImage functions
                    PIXI.utils.TextureCache[sprite.name] = res.textures[sprite.name];
                });
                waiter.done();
            });
        });
    };
};