#

API Docs for: 1.6.0
Show: Inherited Protected Private Deprecated

# File: src/pixi/loaders/AssetLoader.js

    /**
     * @author Mat Groves http://matgroves.com/ @Doormat23
     */

    /**
     * A Class that loads a bunch of images / sprite sheet / bitmap font files. Once the
     * assets have been loaded they are added to the PIXI Texture cache and can be accessed
     * easily through PIXI.Texture.fromImage() and PIXI.Sprite.fromImage()
     * When all items have been loaded this class will dispatch a 'onLoaded' event
     * As each individual item is loaded this class will dispatch a 'onProgress' event
     *
     * @class AssetLoader
     * @constructor
     * @uses EventTarget
     * @param {Array<String>} assetURLs an array of image/sprite sheet urls that you would like loaded
     *      supported. Supported image formats include 'jpeg', 'jpg', 'png', 'gif'. Supported
     *      sprite sheet data formats only include 'JSON' at this time. Supported bitmap font
     *      data formats include 'xml' and 'fnt'.
     * @param crossorigin {Boolean} Whether requests should be treated as crossorigin
     */
    PIXI.AssetLoader = function(assetURLs, crossorigin)
    {
        PIXI.EventTarget.call(this);

        /**
         * The array of asset URLs that are going to be loaded
         *
         * @property assetURLs
         * @type Array<String>
         */
        this.assetURLs = assetURLs;

        /**
         * Whether the requests should be treated as cross origin
         *
         * @property crossorigin
         * @type Boolean
         */
        this.crossorigin = crossorigin;

        /**
         * Maps file extension to loader types
         *
         * @property loadersByType
         * @type Object
         */
        this.loadersByType = {
            'jpg':  PIXI.ImageLoader,
            'jpeg': PIXI.ImageLoader,
            'png':  PIXI.ImageLoader,
            'gif':  PIXI.ImageLoader,
            'webp': PIXI.ImageLoader,
            'json': PIXI.JsonLoader,
            'atlas': PIXI.AtlasLoader,
            'anim': PIXI.SpineLoader,
            'xml':  PIXI.BitmapFontLoader,
            'fnt':  PIXI.BitmapFontLoader
        };
    };

    /**
     * Fired when an item has loaded
     * @event onProgress
     */

    /**
     * Fired when all the assets have loaded
     * @event onComplete
     */

    // constructor
    PIXI.AssetLoader.prototype.constructor = PIXI.AssetLoader;

    /**
     * Given a filename, returns its extension, wil
     *
     * @method _getDataType
     * @param str {String} the name of the asset
     */
    PIXI.AssetLoader.prototype._getDataType = function(str)
    {
        var test = 'data:';
        //starts with 'data:'
        var start = str.slice(0, test.length).toLowerCase();
        if (start === test) {
            var data = str.slice(test.length);

            var sepIdx = data.indexOf(',');
            if (sepIdx === -1) //malformed data URI scheme
                return null;

            //e.g. 'image/gif;base64' => 'image/gif'
            var info = data.slice(0, sepIdx).split(';')[0];

            //We might need to handle some special cases here...
            //standardize text/plain to 'txt' file extension
            if (!info || info.toLowerCase() === 'text/plain')
                return 'txt';

            //User specified mime type, try splitting it by '/'
            return info.split('/').pop().toLowerCase();
        }

        return null;
    };

    /**
     * Starts loading the assets sequentially
     *
     * @method load
     */
    PIXI.AssetLoader.prototype.load = function()
    {
        var scope = this;

        function onLoad(evt) {
            scope.onAssetLoaded(evt.content);
        }

        this.loadCount = this.assetURLs.length;

        for (var i=0; i < this.assetURLs.length; i++)
        {
            var fileName = this.assetURLs[i];
            //first see if we have a data URI scheme..
            var fileType = this._getDataType(fileName);

            //if not, assume it's a file URI
            if (!fileType)
                fileType = fileName.split('?').shift().split('.').pop().toLowerCase();

            var Constructor = this.loadersByType[fileType];
            if(!Constructor)
                throw new Error(fileType + ' is an unsupported file type');

            var loader = new Constructor(fileName, this.crossorigin);

            loader.addEventListener('loaded', onLoad);
            loader.load();
        }
    };

    /**
     * Invoked after each file is loaded
     *
     * @method onAssetLoaded
     * @private
     */
    PIXI.AssetLoader.prototype.onAssetLoaded = function(loader)
    {
        this.loadCount--;
        this.dispatchEvent({ type: 'onProgress', content: this, loader: loader });
        if (this.onProgress) this.onProgress(loader);

        if (!this.loadCount)
        {
            this.dispatchEvent({type: 'onComplete', content: this});
            if(this.onComplete) this.onComplete();
        }
    };