pixi.js 7.1.1 → 7.1.2

package/dist/pixi.js

@@ -1,6 +1,6 @@
 /*!
- * pixi.js - v7.1.1
- * Compiled Sat, 21 Jan 2023 23:38:22 UTC
+ * pixi.js - v7.1.2
+ * Compiled Tue, 31 Jan 2023 14:52:16 UTC
  *
  * pixi.js is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -224,16 +224,15 @@ var PIXI = (function (exports) {
     RESOLUTION: 1,
     RENDER_OPTIONS: {
       view: null,
-      antialias: false,
+      width: 800,
+      height: 600,
       autoDensity: false,
       backgroundColor: 0,
       backgroundAlpha: 1,
-      premultipliedAlpha: true,
       clearBeforeRender: true,
+      antialias: false,
+      premultipliedAlpha: true,
       preserveDrawingBuffer: false,
-      width: 800,
-      height: 600,
-      legacy: false,
       hello: false
     },
     CREATE_IMAGE_BITMAP: false,
@@ -10458,7 +10457,7 @@ ${this.fragmentSrc}`;
       const renderer = this.renderer;
       renderer.emitWithCustomOptions(renderer.runners.init, options);
       if (options.hello) {
-        console.log(`PixiJS ${"7.1.1"} - ${renderer.rendererLogId} - https://pixijs.com`);
+        console.log(`PixiJS ${"7.1.2"} - ${renderer.rendererLogId} - https://pixijs.com`);
       }
       renderer.resize(this.renderer.screen.width, this.renderer.screen.height);
     }
@@ -11964,8 +11963,8 @@ ${this.fragmentSrc}`;
           preserveDrawingBuffer: options.preserveDrawingBuffer
         }
       };
-      this.startup.run(startupOptions);
       this.options = options;
+      this.startup.run(startupOptions);
     }
     static test(options) {
       if (options?.forceCanvas) {
@@ -12649,7 +12648,7 @@ ${this.fragmentSrc}`;
     }
   }
 
-  const VERSION = "7.1.1";
+  const VERSION = "7.1.2";
 
   class Bounds {
     constructor() {
@@ -16905,9 +16904,6 @@ ${e}`);
       return checkDataUrl(url, validFontMIMEs) || checkExtension(url, validFontExtensions);
     },
     async load(url, options) {
-      if (!globalThis.navigator.onLine) {
-        throw new Error("[loadWebFont] Cannot load font - navigator is offline");
-      }
       const fonts = settings.ADAPTER.getFontFaceSet();
       if (fonts) {
         const fontFaces = [];
@@ -17193,9 +17189,14 @@ ${e}`);
 
   class Resolver {
     constructor() {
-      this._bundleIdConnector = "-";
-      this._createBundleAssetId = (bundleId, assetId) => `${bundleId}${this._bundleIdConnector}${assetId}`;
-      this._extractAssetIdFromBundle = (bundleId, assetBundleId) => assetBundleId.replace(`${bundleId}${this._bundleIdConnector}`, "");
+      this._defaultBundleIdentifierOptions = {
+        connector: "-",
+        createBundleAssetId: (bundleId, assetId) => `${bundleId}${this._bundleIdConnector}${assetId}`,
+        extractAssetIdFromBundle: (bundleId, assetBundleId) => assetBundleId.replace(`${bundleId}${this._bundleIdConnector}`, "")
+      };
+      this._bundleIdConnector = this._defaultBundleIdentifierOptions.connector;
+      this._createBundleAssetId = this._defaultBundleIdentifierOptions.createBundleAssetId;
+      this._extractAssetIdFromBundle = this._defaultBundleIdentifierOptions.extractAssetIdFromBundle;
       this._assetMap = {};
       this._preferredOrder = [];
       this._parsers = [];
@@ -17235,12 +17236,15 @@ ${e}`);
       return this._parsers;
     }
     reset() {
+      this.setBundleIdentifier(this._defaultBundleIdentifierOptions);
+      this._assetMap = {};
       this._preferredOrder = [];
       this._resolverHash = {};
-      this._assetMap = {};
       this._rootPath = null;
       this._basePath = null;
       this._manifest = null;
+      this._bundles = {};
+      this._defaultSearchParams = null;
     }
     setDefaultSearchParams(searchParams) {
       if (typeof searchParams === "string") {
@@ -17286,7 +17290,7 @@ ${e}`);
     add(keysIn, assetsIn, data) {
       const keys = convertToList(keysIn);
       keys.forEach((key) => {
-        if (this._assetMap[key]) {
+        if (this.hasKey(key)) {
           console.warn(`[Resolver] already has key: ${key} overwriting`);
         }
       });
@@ -17400,6 +17404,12 @@ ${e}`);
       });
       return singleAsset ? result[keys[0]] : result;
     }
+    hasKey(key) {
+      return !!this._assetMap[key];
+    }
+    hasBundle(key) {
+      return !!this._bundles[key];
+    }
     _getPreferredOrder(assets) {
       for (let i = 0; i < assets.length; i++) {
         const asset = assets[0];
@@ -17489,6 +17499,9 @@ ${e}`);
           this.resolver.add(url.src, url);
           return url.src;
         }
+        if (!this.resolver.hasKey(url)) {
+          this.resolver.add(url, url);
+        }
         return url;
       });
       const resolveResults = this.resolver.resolve(urlArray);
@@ -18529,42 +18542,10 @@ ${e}`);
       throw new Error("Extract.base64() requires ICanvas.toDataURL or ICanvas.convertToBlob to be implemented");
     }
     canvas(target, frame) {
-      const renderer = this.renderer;
-      let resolution;
-      let flipY = false;
-      let renderTexture;
-      let generated = false;
-      if (target) {
-        if (target instanceof RenderTexture) {
-          renderTexture = target;
-        } else {
-          renderTexture = this.renderer.generateTexture(target);
-          generated = true;
-        }
-      }
-      if (renderTexture) {
-        resolution = renderTexture.baseTexture.resolution;
-        frame = frame ?? renderTexture.frame;
-        flipY = false;
-        renderer.renderTexture.bind(renderTexture);
-      } else {
-        resolution = renderer.resolution;
-        if (!frame) {
-          frame = TEMP_RECT;
-          frame.width = renderer.width;
-          frame.height = renderer.height;
-        }
-        flipY = true;
-        renderer.renderTexture.bind(null);
-      }
-      const width = Math.round(frame.width * resolution);
-      const height = Math.round(frame.height * resolution);
+      const { pixels, width, height, flipY } = this._rawPixels(target, frame);
       let canvasBuffer = new CanvasRenderTarget(width, height, 1);
-      const webglPixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
-      const gl = renderer.gl;
-      gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, webglPixels);
       const canvasData = canvasBuffer.context.getImageData(0, 0, width, height);
-      _Extract.arrayPostDivide(webglPixels, canvasData.data);
+      _Extract.arrayPostDivide(pixels, canvasData.data);
       canvasBuffer.context.putImageData(canvasData, 0, 0);
       if (flipY) {
         const target2 = new CanvasRenderTarget(canvasBuffer.width, canvasBuffer.height, 1);
@@ -18573,27 +18554,43 @@ ${e}`);
         canvasBuffer.destroy();
         canvasBuffer = target2;
       }
-      if (generated) {
-        renderTexture.destroy(true);
-      }
       return canvasBuffer.canvas;
     }
     pixels(target, frame) {
+      const { pixels } = this._rawPixels(target, frame);
+      _Extract.arrayPostDivide(pixels, pixels);
+      return pixels;
+    }
+    _rawPixels(target, frame) {
       const renderer = this.renderer;
       let resolution;
+      let flipY = false;
       let renderTexture;
       let generated = false;
       if (target) {
         if (target instanceof RenderTexture) {
           renderTexture = target;
         } else {
-          renderTexture = this.renderer.generateTexture(target);
+          const multisample = renderer.context.webGLVersion >= 2 ? renderer.multisample : MSAA_QUALITY.NONE;
+          renderTexture = this.renderer.generateTexture(target, { multisample });
+          if (multisample !== MSAA_QUALITY.NONE) {
+            const resolvedTexture = RenderTexture.create({
+              width: renderTexture.width,
+              height: renderTexture.height
+            });
+            renderer.framebuffer.bind(renderTexture.framebuffer);
+            renderer.framebuffer.blit(resolvedTexture.framebuffer);
+            renderer.framebuffer.bind(null);
+            renderTexture.destroy(true);
+            renderTexture = resolvedTexture;
+          }
           generated = true;
         }
       }
       if (renderTexture) {
         resolution = renderTexture.baseTexture.resolution;
         frame = frame ?? renderTexture.frame;
+        flipY = false;
         renderer.renderTexture.bind(renderTexture);
       } else {
         resolution = renderer.resolution;
@@ -18602,18 +18599,18 @@ ${e}`);
           frame.width = renderer.width;
           frame.height = renderer.height;
         }
+        flipY = true;
         renderer.renderTexture.bind(null);
       }
       const width = Math.round(frame.width * resolution);
       const height = Math.round(frame.height * resolution);
-      const webglPixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
+      const pixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
       const gl = renderer.gl;
-      gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, webglPixels);
+      gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
       if (generated) {
         renderTexture.destroy(true);
       }
-      _Extract.arrayPostDivide(webglPixels, webglPixels);
-      return webglPixels;
+      return { pixels, width, height, flipY };
     }
     destroy() {
       this.renderer = null;