More Loader updates, lots to do though.

Author: photonstorm

v3/src/loader/File.js

@@ -0,0 +1,165 @@
+import XHRLoader from 'loader/XHRLoader.js';
+import XHRSettings from 'loader/XHRSettings.js';
+
+//  File level consts
+
+export const PENDING = 0;      // file is in the load queue but not yet started
+export const LOADING = 1;      // file has been started to load by the loader (onLoad called)
+export const LOADED = 2;       // file has loaded successfully, awaiting processing
+export const FAILED = 3;       // file failed to load
+export const PROCESSING = 4;   // file is being processed (onProcess callback)
+export const COMPLETE = 5;     // file has finished processing
+export const DESTROYED = 6;    // file has been destroyed
+
+//  Our base File object (from which all File Types extend)
+
+//  key = user level file key (can be filename or other string based value)
+//  url = the URL to load the file from, doesn't include baseURL or Path (which are both set by the Loader)
+//  type = a user-level value that can control which cache the file is added to
+
+var File = function (key, url, type)
+{
+    if (!key)
+    {
+        console.warn('Invalid File key');
+        return;
+    }
+
+    return {
+
+        key: key,
+
+        url: url,
+
+        //  Both of these are overridden by the BaseLoader (if being used)
+        path: '',
+        src: url,
+
+        tag: '',    // Tag this file, this is a non-unique string. For example you could tag a collection of files as 'level1', or 'mainmenu'.
+
+        type: type, // the file type, i.e. 'image', 'json', etc which can be used to control which cache it gets added to
+
+        state: PENDING,
+
+        //  Multipart file? (i.e. an atlas and its json)
+        multipart: undefined,
+        linkFile: undefined,
+
+        //  The actual processed file data
+        data: undefined,
+
+        //  For CORs based loading.
+        //  If this is undefined then the File will check BaseLoader.crossOrigin and use that (if set)
+        crossOrigin: undefined,
+
+        //  Optionally set by the Promise returned from BaseLoader.addFile.
+        resolve: undefined,
+        reject: undefined,
+
+        //  maybe you have to set it in the Promise?
+        processCallback: undefined,
+
+        //  xhr specific settings (ignored by TagLoaded files)
+        xhr: XHRSettings('text'),
+
+        onStateChange: function (value) {
+
+            // console.log('onStateChange', this.url, 'from', this.state, 'to', value);
+
+            if (this.state !== value)
+            {
+                this.state = value;
+
+                //  Loaded AND Processed
+                if (value === COMPLETE)
+                {
+                    //  Part of a multipart load?
+                    if (this.multipart)
+                    {
+                        //  Has the linked file loaded too?
+                        if (this.linkFile.state === COMPLETE && this.multipart.resolve)
+                        {
+                            //  Send the Promise for the multipart file
+                            this.multipart.resolve(this.multipart);
+                        }
+                    }
+
+                    //  Send the Promise for this file
+                    if (this.resolve)
+                    {
+                        this.resolve(this);
+                    }
+                }
+                else if (value === FAILED)
+                {
+                    //  Part of a multipart load?
+                    if (this.multipart)
+                    {
+                        if (this.multipart.reject)
+                        {
+                            //  Send the Promise for the multipart file
+                            this.multipart.reject(this.multipart, error);
+                        }
+                    }
+
+                    //  Send the Promise for this file
+                    if (this.reject)
+                    {
+                        this.reject(this);
+                    }
+                }
+            }
+
+        },
+
+        //  These functions are usually overridden by the custom file types
+
+        load: function (globalXHRSettings) {
+
+            this.onStateChange(LOADING);
+
+            //  Returns a Promise from the XHRLoader
+            return XHRLoader(this, globalXHRSettings);
+
+        },
+
+        onLoad: function () {
+
+            //  If overridden it must set `state` to LOADED
+            this.onStateChange(LOADED);
+
+        },
+
+        onError: function () {
+
+            //  If overridden it must set `state` to FAILED
+            this.onStateChange(FAILED);
+
+        },
+
+        onProcess: function () {
+
+            //  If overridden it must set `state` to PROCESSING
+            this.onStateChange(PROCESSING);
+
+        },
+
+        onComplete: function () {
+
+            //  If overridden it must set `state` to COMPLETE
+            this.onStateChange(COMPLETE);
+
+        },
+
+        onDestroy: function () {
+
+            //  If overridden it must set `state` to DESTROYED
+            this.onStateChange(DESTROYED);
+
+        }
+
+    };
+
+};
+
+module.exports = File;

v3/src/loader/Loader.js

@@ -1,17 +1,16 @@
 var Set = require('../structs/Set');
 var XHRSettings = require('./XHRSettings');
+// var ImageLoader = require('./filetypes/Image');
 
 var Loader = function ()
 {
-    //  Move to a 'setURL' method
+    //  Move to a 'setURL' method?
     this.baseURL = '';
     this.path = '';
 
-    this.tag = '';
-
+    //  Read from Game Config
     this.enableParallel = true;
-
-    this.maxParallelDownloads = 4;
+    this.maxParallelDownloads = 8;
 
     //  xhr specific global settings (can be overridden on a per-file basis)
     this.xhr = XHRSettings();
@@ -31,9 +30,23 @@ Loader.prototype.contructor = Loader;
 
 Loader.prototype = {
 
-    add: function ()
+    //  The File Loaders
+
+    //  Add a File direct to the queue. Must extend File base object.
+    add: function (file)
+    {
+
+    },
+
+    //  Different images based on device-pixel ratio
+    //  And maybe on screen resolution breakpoints
+
+    image: function (key, url)
     {
-        
+
+
+
+        // return ImageLoader(this, key, url);
     }
 
 };

v3/src/loader/filetypes/Image.js

@@ -0,0 +1,32 @@
+// var File = require('../File');
+
+var onLoad = function ()
+{
+
+};
+
+var ImageFile = function (loader, key, url)
+{
+    if (!key)
+    {
+        console.warn('Loader: You tried to load an Image, but no key was given');
+        return;
+    }
+
+    if (!url)
+    {
+        url = key + '.png';
+    }
+
+    var file = {
+        type: 'image',
+        key: key,
+        url: url,
+        onload: onLoad
+    };
+
+    loader.add(file);
+
+};
+
+module.exports = ImageFile;