pixi.js 7.1.0 → 7.1.2

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2013-2017 Mathew Groves, Chad Engler
+Copyright (c) 2013-2023 Mathew Groves, Chad Engler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/pixi.js

@@ -1,6 +1,6 @@
 /*!
- * pixi.js - v7.1.0
- * Compiled Tue, 10 Jan 2023 21:29:23 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,
@@ -7973,7 +7972,7 @@ ${this.fragmentSrc}`;
     }
     static fromLoader(source, imageUrl, name, options) {
       const baseTexture = new BaseTexture(source, Object.assign({
-        scaleMode: settings.SCALE_MODE,
+        scaleMode: BaseTexture.defaultOptions.scaleMode,
         resolution: getResolutionOfUrl(imageUrl)
       }, options));
       const { resource } = baseTexture;
@@ -9358,7 +9357,7 @@ ${this.fragmentSrc}`;
       this.pooled = false;
       this.isMaskData = true;
       this.resolution = null;
-      this.multisample = settings.FILTER_MULTISAMPLE;
+      this.multisample = Filter.defaultMultisample;
       this.enabled = true;
       this.colorMask = 15;
       this._filters = null;
@@ -10458,7 +10457,7 @@ ${this.fragmentSrc}`;
       const renderer = this.renderer;
       renderer.emitWithCustomOptions(renderer.runners.init, options);
       if (options.hello) {
-        console.log(`PixiJS ${"7.1.0"} - ${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);
     }
@@ -11241,7 +11240,7 @@ ${this.fragmentSrc}`;
         return BaseTexture.defaultOptions.wrapMode;
       },
       set(value) {
-        deprecation("7.1.0", "settings.WRAP_MODE is deprecated, use BaseTeture.defaultOptions.wrapMode");
+        deprecation("7.1.0", "settings.WRAP_MODE is deprecated, use BaseTexture.defaultOptions.wrapMode");
         BaseTexture.defaultOptions.wrapMode = value;
       }
     },
@@ -11250,7 +11249,7 @@ ${this.fragmentSrc}`;
         return BaseTexture.defaultOptions.scaleMode;
       },
       set(value) {
-        deprecation("7.1.0", "settings.SCALE_MODE is deprecated, use BaseTeture.defaultOptions.scaleMode");
+        deprecation("7.1.0", "settings.SCALE_MODE is deprecated, use BaseTexture.defaultOptions.scaleMode");
         BaseTexture.defaultOptions.scaleMode = value;
       }
     },
@@ -11259,7 +11258,7 @@ ${this.fragmentSrc}`;
         return BaseTexture.defaultOptions.mipmap;
       },
       set(value) {
-        deprecation("7.1.0", "settings.MIPMAP_TEXTURES is deprecated, use BaseTeture.defaultOptions.mipmap");
+        deprecation("7.1.0", "settings.MIPMAP_TEXTURES is deprecated, use BaseTexture.defaultOptions.mipmap");
         BaseTexture.defaultOptions.mipmap = value;
       }
     },
@@ -11268,7 +11267,7 @@ ${this.fragmentSrc}`;
         return BaseTexture.defaultOptions.anisotropicLevel;
       },
       set(value) {
-        deprecation("7.1.0", "settings.ANISOTROPIC_LEVEL is deprecated, use BaseTeture.defaultOptions.anisotropicLevel");
+        deprecation("7.1.0", "settings.ANISOTROPIC_LEVEL is deprecated, use BaseTexture.defaultOptions.anisotropicLevel");
         BaseTexture.defaultOptions.anisotropicLevel = value;
       }
     },
@@ -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) {
@@ -12288,17 +12287,18 @@ ${this.fragmentSrc}`;
 
   class ImageBitmapResource extends BaseImageResource {
     constructor(source, options) {
-      var __super = (...args) => {
-        super(...args);
-      };
       options = options || {};
+      let baseSource;
+      let url;
       if (typeof source === "string") {
-        __super(ImageBitmapResource.EMPTY);
-        this.url = source;
+        baseSource = ImageBitmapResource.EMPTY;
+        url = source;
       } else {
-        __super(source);
-        this.url = null;
+        baseSource = source;
+        url = null;
       }
+      super(baseSource);
+      this.url = url;
       this.crossOrigin = options.crossOrigin ?? true;
       this.alphaMode = typeof options.alphaMode === "number" ? options.alphaMode : null;
       this._load = null;
@@ -12648,7 +12648,7 @@ ${this.fragmentSrc}`;
     }
   }
 
-  const VERSION = "7.1.0";
+  const VERSION = "7.1.2";
 
   class Bounds {
     constructor() {
@@ -14157,7 +14157,7 @@ ${this.fragmentSrc}`;
   }
 
   class BlurFilterPass extends Filter {
-    constructor(horizontal, strength = 8, quality = 4, resolution = settings.FILTER_RESOLUTION, kernelSize = 5) {
+    constructor(horizontal, strength = 8, quality = 4, resolution = Filter.defaultResolution, kernelSize = 5) {
       const vertSrc = generateBlurVertSource(kernelSize, horizontal);
       const fragSrc = generateBlurFragSource(kernelSize);
       super(vertSrc, fragSrc);
@@ -15353,7 +15353,7 @@ ${this.fragmentSrc}`;
       const isMouse = e.pointerType === "mouse" || e.pointerType === "pen";
       const trackingData = this.trackingData(from.pointerId);
       const outTarget = this.findMountedTarget(trackingData.overTargets);
-      if (trackingData.overTargets && outTarget !== e.target) {
+      if (trackingData.overTargets?.length > 0 && outTarget !== e.target) {
         const outType = from.type === "mousemove" ? "mouseout" : "pointerout";
         const outEvent = this.createPointerEvent(from, outType, outTarget);
         this.dispatchEvent(outEvent, "pointerout");
@@ -15402,10 +15402,14 @@ ${this.fragmentSrc}`;
       }
       const propagationMethod = this.moveOnAll ? "all" : "dispatchEvent";
       this[propagationMethod](e, "pointermove");
-      if (e.pointerType === "touch")
+      this.all(e, "globalpointermove");
+      if (e.pointerType === "touch") {
         this[propagationMethod](e, "touchmove");
+        this.all(e, "globaltouchmove");
+      }
       if (isMouse) {
         this[propagationMethod](e, "mousemove");
+        this.all(e, "globalmousemove");
         this.cursor = e.target?.cursor;
       }
       trackingData.overTargets = e.composedPath();
@@ -16071,6 +16075,7 @@ ${this.fragmentSrc}`;
     onmouseenter: null,
     onmouseleave: null,
     onmousemove: null,
+    onglobalmousemove: null,
     onmouseout: null,
     onmouseover: null,
     onmouseup: null,
@@ -16080,6 +16085,7 @@ ${this.fragmentSrc}`;
     onpointerenter: null,
     onpointerleave: null,
     onpointermove: null,
+    onglobalpointermove: null,
     onpointerout: null,
     onpointerover: null,
     onpointertap: null,
@@ -16094,6 +16100,7 @@ ${this.fragmentSrc}`;
     ontouchend: null,
     ontouchendoutside: null,
     ontouchmove: null,
+    onglobaltouchmove: null,
     ontouchstart: null,
     onwheel: null,
     interactive: false,
@@ -16614,6 +16621,14 @@ ${this.fragmentSrc}`;
     });
   };
 
+  const copySearchParams = (targetUrl, sourceUrl) => {
+    const searchParams = sourceUrl.split("?")[1];
+    if (searchParams) {
+      targetUrl += `?${searchParams}`;
+    }
+    return targetUrl;
+  };
+
   function processX(base, ids, depth, result, tags) {
     const id = ids[depth];
     for (let i = 0; i < id.length; i++) {
@@ -16889,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 = [];
@@ -17177,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 = [];
@@ -17219,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") {
@@ -17250,7 +17270,7 @@ ${e}`);
           if (typeof asset.name === "string") {
             const bundleAssetId = this._createBundleAssetId(bundleId, asset.name);
             assetNames.push(bundleAssetId);
-            this.add([asset.name, bundleAssetId], asset.srcs);
+            this.add([asset.name, bundleAssetId], asset.srcs, asset.data);
           } else {
             const bundleIds = asset.name.map((name) => this._createBundleAssetId(bundleId, name));
             bundleIds.forEach((bundleId2) => {
@@ -17270,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`);
         }
       });
@@ -17384,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];
@@ -17473,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);
@@ -18513,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);
@@ -18557,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;
@@ -18586,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;
@@ -23408,7 +23421,8 @@ ${e}`);
         if (basePath && basePath.lastIndexOf("/") !== basePath.length - 1) {
           basePath += "/";
         }
-        const imagePath = basePath + asset.meta.image;
+        let imagePath = basePath + asset.meta.image;
+        imagePath = copySearchParams(imagePath, options.src);
         const assets = await loader.load([imagePath]);
         const texture = assets[imagePath];
         const spritesheet = new Spritesheet(texture.baseTexture, asset, options.src);
@@ -23420,10 +23434,11 @@ ${e}`);
             if (typeof item !== "string") {
               continue;
             }
-            const itemUrl = basePath + item;
+            let itemUrl = basePath + item;
             if (options.data?.ignoreMultiPack) {
               continue;
             }
+            itemUrl = copySearchParams(itemUrl, options.src);
             promises.push(loader.load({
               src: itemUrl,
               data: {
@@ -23929,7 +23944,7 @@ ${e}`);
           height,
           xoffset: 0,
           yoffset: 0,
-          xadvance: Math.ceil(width - (style.dropShadow ? style.dropShadowDistance : 0) - (style.stroke ? style.strokeThickness : 0))
+          xadvance: width - (style.dropShadow ? style.dropShadowDistance : 0) - (style.stroke ? style.strokeThickness : 0)
         });
         positionX += (textureGlyphWidth + 2 * padding) * resolution;
         positionX = Math.ceil(positionX);
@@ -24067,8 +24082,8 @@ ${e}`);
         charRenderData.texture = charData.texture;
         charRenderData.line = line;
         charRenderData.charCode = charCode;
-        charRenderData.position.x = pos.x + charData.xOffset + this._letterSpacing / 2;
-        charRenderData.position.y = pos.y + charData.yOffset;
+        charRenderData.position.x = Math.round(pos.x + charData.xOffset + this._letterSpacing / 2);
+        charRenderData.position.y = Math.round(pos.y + charData.yOffset);
         charRenderData.prevSpaces = spaceCount;
         chars.push(charRenderData);
         lastLineWidth = charRenderData.position.x + Math.max(charData.xAdvance - charData.xOffset, charData.texture.orig.width);
@@ -24460,7 +24475,8 @@ ${e}`);
       const textureUrls = [];
       for (let i = 0; i < pages.length; ++i) {
         const pageFile = pages[i].file;
-        const imagePath = path.join(path.dirname(src), pageFile);
+        let imagePath = path.join(path.dirname(src), pageFile);
+        imagePath = copySearchParams(imagePath, src);
         textureUrls.push(imagePath);
       }
       const loadedTextures = await loader.load(textureUrls);
@@ -24668,6 +24684,7 @@ ${e}`);
   exports.checkExtension = checkExtension;
   exports.checkMaxIfStatementsInShader = checkMaxIfStatementsInShader;
   exports.convertToList = convertToList;
+  exports.copySearchParams = copySearchParams;
   exports.createStringVariations = createStringVariations;
   exports.createTexture = createTexture;
   exports.createUBOElements = createUBOElements;