pixi.js 7.0.3 → 7.1.0-alpha

package/dist/pixi.js

@@ -1,6 +1,6 @@
 /*!
- * pixi.js - v7.0.3
- * Compiled Mon, 07 Nov 2022 00:40:25 UTC
+ * pixi.js - v7.1.0-alpha
+ * Compiled Thu, 10 Nov 2022 16:24:03 UTC
  *
  * pixi.js is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -7026,7 +7026,7 @@ Deprecated since v${version}`);
   RenderTexturePool.SCREEN_KEY = -1;
 
   class Attribute {
-    constructor(buffer, size = 0, normalized = false, type = TYPES.FLOAT, stride, start, instance) {
+    constructor(buffer, size = 0, normalized = false, type = TYPES.FLOAT, stride, start, instance, divisor = 1) {
       this.buffer = buffer;
       this.size = size;
       this.normalized = normalized;
@@ -7034,6 +7034,7 @@ Deprecated since v${version}`);
       this.stride = stride;
       this.start = start;
       this.instance = instance;
+      this.divisor = divisor;
     }
     destroy() {
       this.buffer = null;
@@ -8541,7 +8542,7 @@ Deprecated since v${version}`);
           gl.vertexAttribPointer(location, attribute.size, attribute.type || gl.FLOAT, attribute.normalized, attribute.stride, attribute.start);
           if (attribute.instance) {
             if (this.hasInstance) {
-              gl.vertexAttribDivisor(location, 1);
+              gl.vertexAttribDivisor(location, attribute.divisor);
             } else {
               throw new Error("geometry error, GPU Instancing is not supported on this device");
             }
@@ -11367,7 +11368,7 @@ ${this.fragmentSrc}`;
       const renderer = this.renderer;
       renderer.emitWithCustomOptions(renderer.runners.init, options);
       if (options.hello) {
-        console.log(`PixiJS ${"7.0.3"} - ${renderer.rendererLogId} - https://pixijs.com`);
+        console.log(`PixiJS ${"7.1.0-alpha"} - ${renderer.rendererLogId} - https://pixijs.com`);
       }
       renderer.resize(this.renderer.screen.width, this.renderer.screen.height);
     }
@@ -11493,7 +11494,17 @@ ${this.fragmentSrc}`;
         projectionMatrix: new Matrix()
       }, true);
       const systemConfig = {
-        runners: ["init", "destroy", "contextChange", "reset", "update", "postrender", "prerender", "resize"],
+        runners: [
+          "init",
+          "destroy",
+          "contextChange",
+          "resolutionChange",
+          "reset",
+          "update",
+          "postrender",
+          "prerender",
+          "resize"
+        ],
         systems: _Renderer.__systems,
         priority: [
           "_view",
@@ -11588,6 +11599,10 @@ ${this.fragmentSrc}`;
     get resolution() {
       return this._view.resolution;
     }
+    set resolution(value) {
+      this._view.resolution = value;
+      this.runners.resolutionChange.emit(value);
+    }
     get autoDensity() {
       return this._view.autoDensity;
     }
@@ -12336,7 +12351,7 @@ ${this.fragmentSrc}`;
   };
   extensions$1.add(ObjectRendererSystem);
 
-  const VERSION = "7.0.3";
+  const VERSION = "7.1.0-alpha";
 
   var fragment$6 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float uAlpha;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord) * uAlpha;\n}\n";
 
@@ -15392,6 +15407,9 @@ ${this.fragmentSrc}`;
       this.setTargetElement(view);
       this.resolution = resolution;
     }
+    resolutionChange(resolution) {
+      this.resolution = resolution;
+    }
     destroy() {
       this.setTargetElement(null);
       this.renderer = null;
@@ -16576,222 +16594,6 @@ ${e}`);
     }
   }
 
-  class AssetsClass {
-    constructor() {
-      this._detections = [];
-      this._initialized = false;
-      this.resolver = new Resolver();
-      this.loader = new Loader();
-      this.cache = Cache;
-      this._backgroundLoader = new BackgroundLoader(this.loader);
-      this._backgroundLoader.active = true;
-      this.reset();
-    }
-    async init(options = {}) {
-      if (this._initialized) {
-        return;
-      }
-      this._initialized = true;
-      if (options.basePath) {
-        this.resolver.basePath = options.basePath;
-      }
-      if (options.manifest) {
-        let manifest = options.manifest;
-        if (typeof manifest === "string") {
-          manifest = await this.load(manifest);
-        }
-        this.resolver.addManifest(manifest);
-      }
-      const resolutionPref = options.texturePreference?.resolution ?? 1;
-      const resolution = typeof resolutionPref === "number" ? [resolutionPref] : resolutionPref;
-      let formats = [];
-      if (options.texturePreference?.format) {
-        const formatPref = options.texturePreference?.format;
-        formats = typeof formatPref === "string" ? [formatPref] : formatPref;
-        for (const detection of this._detections) {
-          if (!await detection.test()) {
-            formats = await detection.remove(formats);
-          }
-        }
-      } else {
-        for (const detection of this._detections) {
-          if (await detection.test()) {
-            formats = await detection.add(formats);
-          }
-        }
-      }
-      this.resolver.prefer({
-        params: {
-          format: formats,
-          resolution
-        }
-      });
-    }
-    add(keysIn, assetsIn, data) {
-      this.resolver.add(keysIn, assetsIn, data);
-    }
-    async load(urls, onProgress) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      const singleAsset = isSingleItem(urls);
-      const urlArray = convertToList(urls).map((url) => {
-        if (typeof url !== "string") {
-          this.resolver.add(url.src, url);
-          return url.src;
-        }
-        return url;
-      });
-      const resolveResults = this.resolver.resolve(urlArray);
-      const out = await this._mapLoadToResolve(resolveResults, onProgress);
-      return singleAsset ? out[urlArray[0]] : out;
-    }
-    addBundle(bundleId, assets) {
-      this.resolver.addBundle(bundleId, assets);
-    }
-    async loadBundle(bundleIds, onProgress) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      let singleAsset = false;
-      if (typeof bundleIds === "string") {
-        singleAsset = true;
-        bundleIds = [bundleIds];
-      }
-      const resolveResults = this.resolver.resolveBundle(bundleIds);
-      const out = {};
-      const keys = Object.keys(resolveResults);
-      let count = 0;
-      let total = 0;
-      const _onProgress = () => {
-        onProgress?.(++count / total);
-      };
-      const promises = keys.map((bundleId) => {
-        const resolveResult = resolveResults[bundleId];
-        total += Object.keys(resolveResult).length;
-        return this._mapLoadToResolve(resolveResult, _onProgress).then((resolveResult2) => {
-          out[bundleId] = resolveResult2;
-        });
-      });
-      await Promise.all(promises);
-      return singleAsset ? out[bundleIds[0]] : out;
-    }
-    async backgroundLoad(urls) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      if (typeof urls === "string") {
-        urls = [urls];
-      }
-      const resolveResults = this.resolver.resolve(urls);
-      this._backgroundLoader.add(Object.values(resolveResults));
-    }
-    async backgroundLoadBundle(bundleIds) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      if (typeof bundleIds === "string") {
-        bundleIds = [bundleIds];
-      }
-      const resolveResults = this.resolver.resolveBundle(bundleIds);
-      Object.values(resolveResults).forEach((resolveResult) => {
-        this._backgroundLoader.add(Object.values(resolveResult));
-      });
-    }
-    reset() {
-      this.resolver.reset();
-      this.loader.reset();
-      this.cache.reset();
-      this._initialized = false;
-    }
-    get(keys) {
-      if (typeof keys === "string") {
-        return Cache.get(keys);
-      }
-      const assets = {};
-      for (let i = 0; i < keys.length; i++) {
-        assets[i] = Cache.get(keys[i]);
-      }
-      return assets;
-    }
-    async _mapLoadToResolve(resolveResults, onProgress) {
-      const resolveArray = Object.values(resolveResults);
-      const resolveKeys = Object.keys(resolveResults);
-      this._backgroundLoader.active = false;
-      const loadedAssets = await this.loader.load(resolveArray, onProgress);
-      this._backgroundLoader.active = true;
-      const out = {};
-      resolveArray.forEach((resolveResult, i) => {
-        const asset = loadedAssets[resolveResult.src];
-        const keys = [resolveResult.src];
-        if (resolveResult.alias) {
-          keys.push(...resolveResult.alias);
-        }
-        out[resolveKeys[i]] = asset;
-        Cache.set(keys, asset);
-      });
-      return out;
-    }
-    async unload(urls) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      const urlArray = convertToList(urls).map((url) => typeof url !== "string" ? url.src : url);
-      const resolveResults = this.resolver.resolve(urlArray);
-      await this._unloadFromResolved(resolveResults);
-    }
-    async unloadBundle(bundleIds) {
-      if (!this._initialized) {
-        await this.init();
-      }
-      bundleIds = convertToList(bundleIds);
-      const resolveResults = this.resolver.resolveBundle(bundleIds);
-      const promises = Object.keys(resolveResults).map((bundleId) => this._unloadFromResolved(resolveResults[bundleId]));
-      await Promise.all(promises);
-    }
-    async _unloadFromResolved(resolveResult) {
-      const resolveArray = Object.values(resolveResult);
-      resolveArray.forEach((resolveResult2) => {
-        Cache.remove(resolveResult2.src);
-      });
-      await this.loader.unload(resolveArray);
-    }
-    get detections() {
-      return this._detections;
-    }
-  }
-  const Assets = new AssetsClass();
-  extensions$1.handleByList(ExtensionType.LoadParser, Assets.loader.parsers).handleByList(ExtensionType.ResolveParser, Assets.resolver.parsers).handleByList(ExtensionType.CacheParser, Assets.cache.parsers).handleByList(ExtensionType.DetectionParser, Assets.detections);
-
-  const assetKeyMap = {
-    loader: ExtensionType.LoadParser,
-    resolver: ExtensionType.ResolveParser,
-    cache: ExtensionType.CacheParser,
-    detection: ExtensionType.DetectionParser
-  };
-  extensions$1.handle(ExtensionType.Asset, (extension) => {
-    const ref = extension.ref;
-    Object.entries(assetKeyMap).filter(([key]) => !!ref[key]).forEach(([key, type]) => extensions$1.add(Object.assign(ref[key], { extension: ref[key].extension ?? type })));
-  }, (extension) => {
-    const ref = extension.ref;
-    Object.keys(assetKeyMap).filter((key) => !!ref[key]).forEach((key) => extensions$1.remove(ref[key]));
-  });
-
-  const cacheTextureArray = {
-    extension: ExtensionType.CacheParser,
-    test: (asset) => Array.isArray(asset) && asset.every((t) => t instanceof Texture),
-    getCacheableAssets: (keys, asset) => {
-      const out = {};
-      keys.forEach((key) => {
-        asset.forEach((item, i) => {
-          out[key + (i === 0 ? "" : i + 1)] = item;
-        });
-      });
-      return out;
-    }
-  };
-  extensions$1.add(cacheTextureArray);
-
   var LoaderParserPriority = /* @__PURE__ */ ((LoaderParserPriority2) => {
     LoaderParserPriority2[LoaderParserPriority2["Low"] = 0] = "Low";
     LoaderParserPriority2[LoaderParserPriority2["Normal"] = 1] = "Normal";
@@ -17157,6 +16959,228 @@ ${e}`);
     unload: loadTextures.unload
   };
 
+  class AssetsClass {
+    constructor() {
+      this._detections = [];
+      this._initialized = false;
+      this.resolver = new Resolver();
+      this.loader = new Loader();
+      this.cache = Cache;
+      this._backgroundLoader = new BackgroundLoader(this.loader);
+      this._backgroundLoader.active = true;
+      this.reset();
+    }
+    async init(options = {}) {
+      if (this._initialized) {
+        return;
+      }
+      this._initialized = true;
+      if (options.basePath) {
+        this.resolver.basePath = options.basePath;
+      }
+      if (options.manifest) {
+        let manifest = options.manifest;
+        if (typeof manifest === "string") {
+          manifest = await this.load(manifest);
+        }
+        this.resolver.addManifest(manifest);
+      }
+      const resolutionPref = options.texturePreference?.resolution ?? 1;
+      const resolution = typeof resolutionPref === "number" ? [resolutionPref] : resolutionPref;
+      let formats = [];
+      if (options.texturePreference?.format) {
+        const formatPref = options.texturePreference?.format;
+        formats = typeof formatPref === "string" ? [formatPref] : formatPref;
+        for (const detection of this._detections) {
+          if (!await detection.test()) {
+            formats = await detection.remove(formats);
+          }
+        }
+      } else {
+        for (const detection of this._detections) {
+          if (await detection.test()) {
+            formats = await detection.add(formats);
+          }
+        }
+      }
+      this.resolver.prefer({
+        params: {
+          format: formats,
+          resolution
+        }
+      });
+    }
+    add(keysIn, assetsIn, data) {
+      this.resolver.add(keysIn, assetsIn, data);
+    }
+    async load(urls, onProgress) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      const singleAsset = isSingleItem(urls);
+      const urlArray = convertToList(urls).map((url) => {
+        if (typeof url !== "string") {
+          this.resolver.add(url.src, url);
+          return url.src;
+        }
+        return url;
+      });
+      const resolveResults = this.resolver.resolve(urlArray);
+      const out = await this._mapLoadToResolve(resolveResults, onProgress);
+      return singleAsset ? out[urlArray[0]] : out;
+    }
+    addBundle(bundleId, assets) {
+      this.resolver.addBundle(bundleId, assets);
+    }
+    async loadBundle(bundleIds, onProgress) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      let singleAsset = false;
+      if (typeof bundleIds === "string") {
+        singleAsset = true;
+        bundleIds = [bundleIds];
+      }
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      const out = {};
+      const keys = Object.keys(resolveResults);
+      let count = 0;
+      let total = 0;
+      const _onProgress = () => {
+        onProgress?.(++count / total);
+      };
+      const promises = keys.map((bundleId) => {
+        const resolveResult = resolveResults[bundleId];
+        total += Object.keys(resolveResult).length;
+        return this._mapLoadToResolve(resolveResult, _onProgress).then((resolveResult2) => {
+          out[bundleId] = resolveResult2;
+        });
+      });
+      await Promise.all(promises);
+      return singleAsset ? out[bundleIds[0]] : out;
+    }
+    async backgroundLoad(urls) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      if (typeof urls === "string") {
+        urls = [urls];
+      }
+      const resolveResults = this.resolver.resolve(urls);
+      this._backgroundLoader.add(Object.values(resolveResults));
+    }
+    async backgroundLoadBundle(bundleIds) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      if (typeof bundleIds === "string") {
+        bundleIds = [bundleIds];
+      }
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      Object.values(resolveResults).forEach((resolveResult) => {
+        this._backgroundLoader.add(Object.values(resolveResult));
+      });
+    }
+    reset() {
+      this.resolver.reset();
+      this.loader.reset();
+      this.cache.reset();
+      this._initialized = false;
+    }
+    get(keys) {
+      if (typeof keys === "string") {
+        return Cache.get(keys);
+      }
+      const assets = {};
+      for (let i = 0; i < keys.length; i++) {
+        assets[i] = Cache.get(keys[i]);
+      }
+      return assets;
+    }
+    async _mapLoadToResolve(resolveResults, onProgress) {
+      const resolveArray = Object.values(resolveResults);
+      const resolveKeys = Object.keys(resolveResults);
+      this._backgroundLoader.active = false;
+      const loadedAssets = await this.loader.load(resolveArray, onProgress);
+      this._backgroundLoader.active = true;
+      const out = {};
+      resolveArray.forEach((resolveResult, i) => {
+        const asset = loadedAssets[resolveResult.src];
+        const keys = [resolveResult.src];
+        if (resolveResult.alias) {
+          keys.push(...resolveResult.alias);
+        }
+        out[resolveKeys[i]] = asset;
+        Cache.set(keys, asset);
+      });
+      return out;
+    }
+    async unload(urls) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      const urlArray = convertToList(urls).map((url) => typeof url !== "string" ? url.src : url);
+      const resolveResults = this.resolver.resolve(urlArray);
+      await this._unloadFromResolved(resolveResults);
+    }
+    async unloadBundle(bundleIds) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      bundleIds = convertToList(bundleIds);
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      const promises = Object.keys(resolveResults).map((bundleId) => this._unloadFromResolved(resolveResults[bundleId]));
+      await Promise.all(promises);
+    }
+    async _unloadFromResolved(resolveResult) {
+      const resolveArray = Object.values(resolveResult);
+      resolveArray.forEach((resolveResult2) => {
+        Cache.remove(resolveResult2.src);
+      });
+      await this.loader.unload(resolveArray);
+    }
+    get detections() {
+      return this._detections;
+    }
+    get preferWorker() {
+      return loadTextures.config.preferWorker;
+    }
+    set preferWorker(value) {
+      loadTextures.config.preferWorker = value;
+    }
+  }
+  const Assets = new AssetsClass();
+  extensions$1.handleByList(ExtensionType.LoadParser, Assets.loader.parsers).handleByList(ExtensionType.ResolveParser, Assets.resolver.parsers).handleByList(ExtensionType.CacheParser, Assets.cache.parsers).handleByList(ExtensionType.DetectionParser, Assets.detections);
+
+  const assetKeyMap = {
+    loader: ExtensionType.LoadParser,
+    resolver: ExtensionType.ResolveParser,
+    cache: ExtensionType.CacheParser,
+    detection: ExtensionType.DetectionParser
+  };
+  extensions$1.handle(ExtensionType.Asset, (extension) => {
+    const ref = extension.ref;
+    Object.entries(assetKeyMap).filter(([key]) => !!ref[key]).forEach(([key, type]) => extensions$1.add(Object.assign(ref[key], { extension: ref[key].extension ?? type })));
+  }, (extension) => {
+    const ref = extension.ref;
+    Object.keys(assetKeyMap).filter((key) => !!ref[key]).forEach((key) => extensions$1.remove(ref[key]));
+  });
+
+  const cacheTextureArray = {
+    extension: ExtensionType.CacheParser,
+    test: (asset) => Array.isArray(asset) && asset.every((t) => t instanceof Texture),
+    getCacheableAssets: (keys, asset) => {
+      const out = {};
+      keys.forEach((key) => {
+        asset.forEach((item, i) => {
+          out[key + (i === 0 ? "" : i + 1)] = item;
+        });
+      });
+      return out;
+    }
+  };
+  extensions$1.add(cacheTextureArray);
+
   const resolveTextureUrl = {
     extension: ExtensionType.ResolveParser,
     test: loadTextures.test,
@@ -24176,6 +24200,7 @@ ${e}`);
   exports.settings = settings;
   exports.spritesheetAsset = spritesheetAsset;
   exports.uniformParsers = uniformParsers;
+  exports.unsafeEvalSupported = unsafeEvalSupported;
   exports.utils = index;
 
   Object.defineProperty(exports, '__esModule', { value: true });