Upgrade Pixi to 8.7.3

Extensions/BBText/bbtextruntimeobject-pixi-renderer.ts

@@ -1,4 +1,5 @@
 namespace gdjs {
+  // TODO PIXI8 Use HTMLText instead.
   /**
    * The PIXI.js renderer for the BBCode Text runtime object.
    */

Extensions/BitmapText/bitmaptextruntimeobject-pixi-renderer.ts

@@ -24,10 +24,27 @@ namespace gdjs {
           runtimeObject._bitmapFontResourceName,
           runtimeObject._textureAtlasResourceName
         );
-      this._pixiObject = new PIXI.BitmapText(runtimeObject._text, {
-        fontName: bitmapFont.font,
-        fontSize: bitmapFont.size,
-      });
+      if (bitmapFont) {
+        this._pixiObject = new PIXI.BitmapText({
+          text: runtimeObject._text,
+          style: {
+            fontFamily: bitmapFont.fontFamily,
+            fontSize: bitmapFont.fontMetrics.fontSize,
+          },
+        });
+      } else {
+        const defaultBitmapFontName = instanceContainer
+          .getGame()
+          .getBitmapFontManager()
+          .getDefaultBitmapFont();
+        this._pixiObject = new PIXI.BitmapText({
+          text: runtimeObject._text,
+          style: {
+            fontFamily: defaultBitmapFontName,
+            fontSize: 20,
+          },
+        });
+      }
 
       // Set the object on the scene
       instanceContainer
@@ -61,13 +78,17 @@ namespace gdjs {
         .getInstanceContainer()
         .getGame()
         .getBitmapFontManager()
-        .releaseBitmapFont(this._pixiObject.fontName);
+        .releaseBitmapFont(
+          Array.isArray(this._pixiObject.style.fontFamily)
+            ? this._pixiObject.style.fontFamily[0]
+            : this._pixiObject.style.fontFamily
+        );
 
       this._pixiObject.destroy();
     }
 
     getFontSize() {
-      return this._pixiObject.fontSize;
+      return this._pixiObject.style.fontSize;
     }
 
     updateFont(): void {
@@ -86,12 +107,18 @@ namespace gdjs {
         .getInstanceContainer()
         .getGame()
         .getBitmapFontManager()
-        .releaseBitmapFont(this._pixiObject.fontName);
+        .releaseBitmapFont(
+          Array.isArray(this._pixiObject.style.fontFamily)
+            ? this._pixiObject.style.fontFamily[0]
+            : this._pixiObject.style.fontFamily
+        );
 
       // Update the font used by the object:
-      this._pixiObject.fontName = bitmapFont.font;
-      this._pixiObject.fontSize = bitmapFont.size;
-      this.updatePosition();
+      if (bitmapFont) {
+        this._pixiObject.style.fontFamily = bitmapFont.fontFamily;
+        this._pixiObject.style.fontSize = bitmapFont.fontMetrics.fontSize;
+        this.updatePosition();
+      }
     }
 
     updateTint(): void {
@@ -100,7 +127,6 @@ namespace gdjs {
         this._object._tint[1],
         this._object._tint[2]
       );
-      this._pixiObject.dirty = true;
     }
 
     /**
@@ -131,12 +157,12 @@ namespace gdjs {
 
     updateWrappingWidth(): void {
       if (this._object._wordWrap) {
-        this._pixiObject.maxWidth =
+        this._pixiObject.style.wordWrap = true;
+        this._pixiObject.style.wordWrapWidth =
           this._object._wrappingWidth / this._object._scaleX;
-        this._pixiObject.dirty = true;
       } else {
-        this._pixiObject.maxWidth = 0;
-        this._pixiObject.dirty = true;
+        this._pixiObject.style.wordWrap = false;
+        this._pixiObject.style.wordWrapWidth = 0;
       }
       this.updatePosition();
     }
@@ -166,11 +192,11 @@ namespace gdjs {
     }
 
     getWidth(): float {
-      return this._pixiObject.textWidth * this.getScale();
+      return this._pixiObject.width * this.getScale();
     }
 
     getHeight(): float {
-      return this._pixiObject.textHeight * this.getScale();
+      return this._pixiObject.height * this.getScale();
     }
   }
   export const BitmapTextRuntimeObjectRenderer =

Extensions/Effects/blending-mode-pixi-filter.ts

@@ -1,7 +1,7 @@
 namespace gdjs {
   interface BlendingModeFilterNetworkSyncData {
     a: number;
-    bm: number;
+    bm: string;
   }
   gdjs.PixiFiltersTools.registerFilterCreator(
     'BlendingMode',
@@ -20,7 +20,8 @@ namespace gdjs {
         if (parameterName === 'alpha') {
           blendingModeFilter.alpha = value;
         } else if (parameterName === 'blendmode') {
-          blendingModeFilter.blendMode = value;
+          blendingModeFilter.blendMode =
+            gdjs.PixiFiltersTools.getBlendModeName(value);
         }
       }
       getDoubleParameter(filter: PIXI.Filter, parameterName: string): number {
@@ -29,7 +30,9 @@ namespace gdjs {
           return blendingModeFilter.alpha;
         }
         if (parameterName === 'blendmode') {
-          return blendingModeFilter.blendMode;
+          return gdjs.PixiFiltersTools.getBlendModeIndex(
+            blendingModeFilter.blendMode
+          );
         }
         return 0;
       }
@@ -66,6 +69,7 @@ namespace gdjs {
       ) {
         const blendingModeFilter = filter as unknown as PIXI.AlphaFilter;
         blendingModeFilter.alpha = data.a;
+        // @ts-ignore
         blendingModeFilter.blendMode = data.bm;
       }
     })()

Extensions/Effects/blur-pixi-filter.ts

@@ -3,7 +3,7 @@ namespace gdjs {
     b: number;
     q: number;
     ks: number;
-    res: number | null;
+    res: number | 'inherit';
   }
   gdjs.PixiFiltersTools.registerFilterCreator(
     'Blur',

Extensions/Effects/light-night-pixi-filter.ts

@@ -4,8 +4,7 @@ namespace gdjs {
   }
   export class LightNightPixiFilter extends PIXI.Filter {
     constructor() {
-      const vertexShader = undefined;
-      const fragmentShader = [
+      const fragment = [
         'precision mediump float;',
         '',
         'varying vec2 vTextureCoord;',
@@ -20,7 +19,10 @@ namespace gdjs {
         '}',
       ].join('\n');
       const uniforms = { opacity: { type: '1f', value: 1 } };
-      super(vertexShader, fragmentShader, uniforms);
+      super({
+        glProgram: new PIXI.GlProgram({ vertex: '', fragment }),
+        resources: uniforms,
+      });
     }
   }
   LightNightPixiFilter.prototype.constructor = gdjs.LightNightPixiFilter;
@@ -38,7 +40,7 @@ namespace gdjs {
         value: number
       ) {
         if (parameterName === 'opacity') {
-          filter.uniforms.opacity = gdjs.PixiFiltersTools.clampValue(
+          filter.resources.opacity = gdjs.PixiFiltersTools.clampValue(
             value,
             0,
             1
@@ -47,7 +49,7 @@ namespace gdjs {
       }
       getDoubleParameter(filter: PIXI.Filter, parameterName: string): number {
         if (parameterName === 'opacity') {
-          return filter.uniforms.opacity;
+          return filter.resources.opacity;
         }
         return 0;
       }
@@ -71,14 +73,14 @@ namespace gdjs {
       ) {}
       getNetworkSyncData(filter: PIXI.Filter): LightNightFilterExtra {
         return {
-          o: filter.uniforms.opacity,
+          o: filter.resources.opacity,
         };
       }
       updateFromNetworkSyncData(
         filter: PIXI.Filter,
         data: LightNightFilterExtra
       ) {
-        filter.uniforms.opacity = data.o;
+        filter.resources.opacity = data.o;
       }
     })()
   );

Extensions/Effects/night-pixi-filter.ts

@@ -5,8 +5,7 @@ namespace gdjs {
   }
   export class NightPixiFilter extends PIXI.Filter {
     constructor() {
-      const vertexShader = undefined;
-      const fragmentShader = [
+      const fragment = [
         'precision mediump float;',
         '',
         'varying vec2 vTextureCoord;',
@@ -25,7 +24,10 @@ namespace gdjs {
         intensity: { type: '1f', value: 1 },
         opacity: { type: '1f', value: 1 },
       };
-      super(vertexShader, fragmentShader, uniforms);
+      super({
+        glProgram: new PIXI.GlProgram({ vertex: '', fragment }),
+        resources: uniforms,
+      });
     }
   }
   NightPixiFilter.prototype.constructor = gdjs.NightPixiFilter;
@@ -45,14 +47,14 @@ namespace gdjs {
         if (parameterName !== 'intensity' && parameterName !== 'opacity') {
           return;
         }
-        filter.uniforms[parameterName] = gdjs.PixiFiltersTools.clampValue(
+        filter.resources[parameterName] = gdjs.PixiFiltersTools.clampValue(
           value,
           0,
           1
         );
       }
       getDoubleParameter(filter: PIXI.Filter, parameterName: string): number {
-        return filter.uniforms[parameterName] || 0;
+        return filter.resources[parameterName] || 0;
       }
       updateStringParameter(
         filter: PIXI.Filter,
@@ -74,16 +76,16 @@ namespace gdjs {
       ) {}
       getNetworkSyncData(filter: PIXI.Filter): NightFilterNetworkSyncData {
         return {
-          i: filter.uniforms['intensity'],
-          o: filter.uniforms['opacity'],
+          i: filter.resources['intensity'],
+          o: filter.resources['opacity'],
         };
       }
       updateFromNetworkSyncData(
         filter: PIXI.Filter,
         data: NightFilterNetworkSyncData
       ) {
-        filter.uniforms['intensity'] = data.i;
-        filter.uniforms['opacity'] = data.o;
+        filter.resources['intensity'] = data.i;
+        filter.resources['opacity'] = data.o;
       }
     })()
   );

Extensions/ExampleJsExtension/dummyeffect.ts

@@ -33,8 +33,8 @@ namespace gdjs {
   gdjs.PixiFiltersTools.registerFilterCreator(
     'MyDummyExtension::DummyEffect',
     new (class extends gdjs.PixiFiltersTools.PixiFilterCreator {
-      // MakePIXIFilter should return a PIXI.Filter, that will be applied on the PIXI.Container (for layers)
-      // or the PIXI.DisplayObject (for objects).
+      // MakePIXIFilter should return a PIXI.Filter, that will be applied on the
+      // PIXI.Container (for layers or objects).
       makePIXIFilter(layer, effectData) {
         const filter = new DummyPixiFilter();
 
@@ -72,7 +72,7 @@ namespace gdjs {
         value: number
       ) {
         if (parameterName === 'opacity') {
-          filter.uniforms.opacity = gdjs.PixiFiltersTools.clampValue(
+          filter.resources.opacity = gdjs.PixiFiltersTools.clampValue(
             value,
             0,
             1
@@ -81,7 +81,7 @@ namespace gdjs {
       }
       getDoubleParameter(filter: PIXI.Filter, parameterName: string): number {
         if (parameterName === 'opacity') {
-          return filter.uniforms.opacity;
+          return filter.resources.opacity;
         }
         return 0;
       }
@@ -106,10 +106,10 @@ namespace gdjs {
         value: boolean
       ) {}
       getNetworkSyncData(filter: PIXI.Filter): any {
-        return { opacity: filter.uniforms.opacity };
+        return { opacity: filter.resources.opacity };
       }
       updateFromNetworkSyncData(filter: PIXI.Filter, data: any) {
-        filter.uniforms.opacity = data.opacity;
+        filter.resources.opacity = data.opacity;
       }
     })()
   );

Extensions/JsExtensionTypes.d.ts

@@ -14,7 +14,7 @@ class RenderedInstance {
   _associatedObjectConfiguration: gd.ObjectConfiguration;
   _pixiContainer: PIXI.Container;
   _pixiResourcesLoader: Class<PixiResourcesLoader>;
-  _pixiObject: PIXI.DisplayObject | null;
+  _pixiObject: PIXI.Container | null;
   wasUsed: boolean;
 
   /** Set to true when onRemovedFromScene is called. Allows to cancel promises/asynchronous operations (notably: waiting for a resource load). */
@@ -38,7 +38,7 @@ class RenderedInstance {
    */
   update(): void;
 
-  getPixiObject(): PIXI.DisplayObject | null;
+  getPixiObject(): PIXI.Container | null;
 
   getInstance(): gd.InitialInstance;
 
@@ -92,7 +92,7 @@ class Rendered3DInstance {
   _pixiContainer: PIXI.Container;
   _threeGroup: THREE.Group;
   _pixiResourcesLoader: Class<PixiResourcesLoader>;
-  _pixiObject: PIXI.DisplayObject | null;
+  _pixiObject: PIXI.Container | null;
   _threeObject: THREE.Object3D | null;
   wasUsed: boolean;
 
@@ -131,7 +131,7 @@ class Rendered3DInstance {
    */
   update(): void;
 
-  getPixiObject(): PIXI.DisplayObject;
+  getPixiObject(): PIXI.Container;
 
   getThreeObject(): THREE.Object3D;