@vpmedia/phaser 1.103.0 → 1.104.0

package/src/phaser/display/display_object.ts

@@ -7,6 +7,62 @@ import { PI_2 } from '../util/math.js';
 import { renderCanvas, renderWebGL } from './sprite_util.js';
 
 export class DisplayObject {
+  /** @type {boolean} */
+  exists = true;
+  /** @type {boolean} */
+  renderable = false;
+  /** @type {boolean} */
+  visible = true;
+  /** @type {Point} */
+  position;
+  /** @type {Point} */
+  scale;
+  /** @type {Point} */
+  pivot;
+  /** @type {Point} */
+  anchor;
+  /** @type {number} */
+  rotation = 0;
+  /** @type {number} */
+  alpha = 1;
+  /** @type {Rectangle} */
+  hitArea = null;
+  /** @type {DisplayObject} */
+  parent = null;
+  /** @type {number} */
+  worldAlpha = 1;
+  /** @type {Matrix} */
+  worldTransform;
+  /** @type {Point} */
+  worldScale;
+  /** @type {Rectangle} */
+  filterArea = null;
+  /** @type {number} */
+  _sr = 0;
+  /** @type {number} */
+  _cr = 1;
+  /** @type {Rectangle} */
+  cachedBounds;
+  /** @type {Rectangle} */
+  currentBounds = null;
+  /** @type {import('./graphics.js').Graphics} */
+  _mask = null;
+  /** @type {object[]} */
+  _filters = null;
+  /** @type {object} */
+  _filterBlock = null;
+  /** @type {DisplayObject[]} */
+  children;
+  /** @type {boolean} */
+  ignoreChildInput = false;
+  /** @type {string | null} */
+  name = null;
+  /** @type {object | null} */
+  data = null;
+  /** @type {import('../core/game.js').Game} */
+  game;
+  /** @type {number} */
+  type;
   /**
    * Creates a new DisplayObject instance.
    * @param {import('../core/game.js').Game} game - The game instance this display object belongs to.
@@ -38,10 +94,10 @@ export class DisplayObject {
     this.worldAlpha = 1;
     /** @type {Matrix} */
     this.worldTransform = new Matrix();
-    // this.worldPosition = new Point(0, 0);
+    // This.worldPosition = new Point(0, 0);
     /** @type {Point} */
     this.worldScale = new Point(1, 1);
-    // this.worldRotation = 0;
+    // This.worldRotation = 0;
     /** @type {Rectangle} */
     this.filterArea = null;
     /** @type {number} */
@@ -86,7 +142,7 @@ export class DisplayObject {
     this.visible = false;
     // TODO: investigate how to clean up properly object references without breaking delayed tween cleanups.
     /*
-    this.position = null;
+    This.position = null;
     this.scale = null;
     this.pivot = null;
     this.anchor = null;
@@ -94,7 +150,7 @@ export class DisplayObject {
     this.hitArea = null;
     this.parent = null;
     this.worldTransform = null;
-    // this.worldPosition = null;
+    // This.worldPosition = null;
     this.worldScale = null;
     this.filterArea = null;
     this.cachedBounds = null;
@@ -175,8 +231,8 @@ export class DisplayObject {
       throw new Error('The supplied index is out of bounds');
     }
     const currentIndex = this.getChildIndex(child);
-    this.children.splice(currentIndex, 1); // remove from old position
-    this.children.splice(index, 0, child); // add at new position
+    this.children.splice(currentIndex, 1); // Remove from old position
+    this.children.splice(index, 0, child); // Add at new position
   }
 
   /**
@@ -270,37 +326,37 @@ export class DisplayObject {
     } else if (!this.parent) {
       p = this.game.world;
     }
-    // create some matrix refs for easy access
+    // Create some matrix refs for easy access
     const pt = p.worldTransform;
     const wt = this.worldTransform;
-    // temporary matrix variables
+    // Temporary matrix variables
     let a;
     let b;
     let c;
     let d;
     let tx;
     let ty;
-    // so if rotation is between 0 then we can simplify the multiplication process..
+    // So if rotation is between 0 then we can simplify the multiplication process..
     if (this.rotation % PI_2) {
-      // check to see if the rotation is the same as the previous render. This means we only need to use sin and cos when rotation actually changes
+      // Check to see if the rotation is the same as the previous render. This means we only need to use sin and cos when rotation actually changes
       if (this.rotation !== this.rotationCache) {
         this.rotationCache = this.rotation;
         this._sr = Math.sin(this.rotation);
         this._cr = Math.cos(this.rotation);
       }
-      // get the matrix values of the displayobject based on its transform properties..
+      // Get the matrix values of the displayobject based on its transform properties..
       a = this._cr * this.scale.x;
       b = this._sr * this.scale.x;
       c = -this._sr * this.scale.y;
       d = this._cr * this.scale.y;
       tx = this.position.x;
       ty = this.position.y;
-      // check for pivot.. not often used so geared towards that fact!
+      // Check for pivot.. not often used so geared towards that fact!
       if (this.pivot.x || this.pivot.y) {
         tx -= this.pivot.x * a + this.pivot.y * c;
         ty -= this.pivot.x * b + this.pivot.y * d;
       }
-      // concat the parent matrix with the objects transform.
+      // Concat the parent matrix with the objects transform.
       wt.a = a * pt.a + b * pt.c;
       wt.b = a * pt.b + b * pt.d;
       wt.c = c * pt.a + d * pt.c;
@@ -308,7 +364,7 @@ export class DisplayObject {
       wt.tx = tx * pt.a + ty * pt.c + pt.tx;
       wt.ty = tx * pt.b + ty * pt.d + pt.ty;
     } else {
-      // lets do the fast version as we know there is no rotation..
+      // Lets do the fast version as we know there is no rotation..
       a = this.scale.x;
       d = this.scale.y;
       tx = this.position.x - this.pivot.x * a;
@@ -322,13 +378,13 @@ export class DisplayObject {
     }
     //  Set the World values
     this.worldAlpha = this.alpha * p.worldAlpha;
-    // this.worldPosition.setTo(wt.tx, wt.ty);
+    // This.worldPosition.setTo(wt.tx, wt.ty);
     this.worldScale.setTo(
       this.scale.x * Math.sqrt(wt.a * wt.a + wt.c * wt.c),
       this.scale.y * Math.sqrt(wt.b * wt.b + wt.d * wt.d)
     );
     this.worldRotation = Math.atan2(-wt.c, wt.d);
-    // reset the bounds each time this is called!
+    // Reset the bounds each time this is called!
     this.currentBounds = null;
     //  Custom callback?
     if (this.transformCallback) {
@@ -392,13 +448,13 @@ export class DisplayObject {
       const w1 = bounds.width + bounds.x;
       const h0 = bounds.y;
       const h1 = bounds.height + bounds.y;
-      const worldTransform = this.worldTransform;
-      const a = worldTransform.a;
-      const b = worldTransform.b;
-      const c = worldTransform.c;
-      const d = worldTransform.d;
-      const tx = worldTransform.tx;
-      const ty = worldTransform.ty;
+      const { worldTransform } = this;
+      const { a } = worldTransform;
+      const { b } = worldTransform;
+      const { c } = worldTransform;
+      const { d } = worldTransform;
+      const { tx } = worldTransform;
+      const { ty } = worldTransform;
       const x1 = a * w1 + c * h1 + tx;
       const y1 = d * h1 + b * w1 + ty;
       const x2 = a * w0 + c * h1 + tx;
@@ -475,7 +531,7 @@ export class DisplayObject {
     }
     let i;
     if (this._mask || this._filters) {
-      // push filter first as we need to ensure the stencil buffer is correct for any masking
+      // Push filter first as we need to ensure the stencil buffer is correct for any masking
       if (this._filters) {
         renderSession.spriteBatch.flush();
         renderSession.filterManager.pushFilter(this._filterBlock);
@@ -489,8 +545,12 @@ export class DisplayObject {
         this.children[i].renderWebGL(renderSession);
       }
       renderSession.spriteBatch.stop();
-      if (this._mask) renderSession.maskManager.popMask(this._mask, renderSession);
-      if (this._filters) renderSession.filterManager.popFilter();
+      if (this._mask) {
+        renderSession.maskManager.popMask(this._mask, renderSession);
+      }
+      if (this._filters) {
+        renderSession.filterManager.popFilter();
+      }
       renderSession.spriteBatch.start();
     } else {
       for (i = 0; i < this.children.length; i += 1) {
@@ -522,21 +582,21 @@ export class DisplayObject {
    * Called before the update cycle for this display object.
    */
   preUpdate() {
-    // override
+    // Override
   }
 
   /**
    * Called during the update cycle for this display object.
    */
   update() {
-    // override
+    // Override
   }
 
   /**
    * Called after the update cycle for this display object.
    */
   postUpdate() {
-    // override
+    // Override
   }
 
   /**
@@ -621,7 +681,7 @@ export class DisplayObject {
    * @param {number} value - The new width in pixels.
    */
   set width(value) {
-    const width = this.getLocalBounds().width;
+    const { width } = this.getLocalBounds();
     if (width !== 0) {
       this.scale.x = value / width;
     } else {
@@ -643,7 +703,7 @@ export class DisplayObject {
    * @param {number} value - The new height in pixels.
    */
   set height(value) {
-    const height = this.getLocalBounds().height;
+    const { height } = this.getLocalBounds();
     if (height !== 0) {
       this.scale.y = value / height;
     } else {

package/src/phaser/display/graphics.ts

@@ -26,6 +26,24 @@ import { renderGraphics as renderWebGLGraphics } from './webgl/graphics.js';
 import { textureFromCanvas } from './webgl/texture_util.js';
 
 export class Graphics extends DisplayObject {
+type;
+renderable;
+fillAlpha;
+lineWidth;
+lineColor;
+graphicsData;
+tint;
+blendMode;
+currentPath;
+_webGL;
+isMask;
+boundsPadding;
+_localBounds;
+dirty;
+_boundsDirty;
+_cacheAsBitmap;
+webGLDirty;
+cachedSpriteDirty;
   /**
    * Creates a new Graphics object.
    * @param {import('../core/game.js').Game} game - The game instance.

package/src/phaser/display/graphics_data.ts

@@ -2,6 +2,16 @@
 import { clone } from './graphics_data_util.js';
 
 export class GraphicsData {
+lineWidth;
+lineColor;
+lineAlpha;
+_lineTint;
+fillColor;
+fillAlpha;
+_fillTint;
+fill;
+shape;
+type;
   /**
    * Creates a new GraphicsData object.
    * @param {number} lineWidth - The line width.

package/src/phaser/display/group.ts

@@ -8,6 +8,34 @@ export const SORT_ASCENDING = -1;
 export const SORT_DESCENDING = 1;
 
 export class Group extends DisplayObject {
+  /** @type {number} */
+  z;
+  /** @type {boolean} */
+  ignoreDestroy;
+  /** @type {boolean} */
+  pendingDestroy;
+  /** @type {Function} */
+  classType;
+  /** @type {DisplayObject | null} */
+  cursor;
+  /** @type {boolean} */
+  inputEnableChildren;
+  /** @type {Signal} */
+  onChildInputDown;
+  /** @type {Signal} */
+  onChildInputUp;
+  /** @type {Signal} */
+  onChildInputOver;
+  /** @type {Signal} */
+  onChildInputOut;
+  /** @type {Signal} */
+  onDestroy;
+  /** @type {number} */
+  cursorIndex;
+  /** @type {string} */
+  _sortProperty;
+  /** @type {object[] | null} */
+  filters;
   /**
    * Creates a new Group object.
    * @param {import('../core/game.js').Game} game - The game instance this group belongs to.

package/src/phaser/display/image.ts

@@ -9,6 +9,44 @@ import { getBounds, getLocalBounds, renderCanvas, renderWebGL, setTexture } from
 import { Texture } from './webgl/texture.js';
 
 export class Image extends DisplayObject {
+  /** @type {string | number | Texture} */
+  key;
+  /** @type {Texture} */
+  texture;
+  /** @type {number} */
+  _width;
+  /** @type {number} */
+  _height;
+  /** @type {number} */
+  tint;
+  /** @type {number} */
+  cachedTint;
+  /** @type {Texture | null} */
+  tilingTexture;
+  /** @type {Texture | null} */
+  tintedTexture;
+  /** @type {number} */
+  blendMode;
+  /** @type {object | null} */
+  shader;
+  /** @type {import('../core/frame.js').Frame | null} */
+  _frame;
+  /** @type {boolean} */
+  pendingDestroy;
+  /** @type {EventManager} */
+  events;
+  /** @type {AnimationManager} */
+  animations;
+  /** @type {boolean} */
+  customRender;
+  /** @type {Rectangle | null} */
+  cropRect;
+  /** @type {Rectangle | null} */
+  _crop;
+  /** @type {boolean} */
+  refreshTexture;
+  /** @type {number} */
+  renderOrderID;
   /**
    * Creates a new Image instance.
    * @param {import('../core/game.js').Game} game - The game instance this image belongs to.
@@ -33,7 +71,7 @@ export class Image extends DisplayObject {
     /** @type {number} */
     this._height = 0;
     /** @type {number} */
-    this.tint = 0xffffff;
+    this.tint = 0xff_ff_ff;
     /** @type {number} */
     this.cachedTint = -1;
     /** @type {Texture | null} */
@@ -46,7 +84,7 @@ export class Image extends DisplayObject {
     this._frame = null;
     /** @type {boolean} */
     this.pendingDestroy = false;
-    /* if (this.texture.baseTexture.hasLoaded) {
+    /* If (this.texture.baseTexture.hasLoaded) {
       this.onTextureUpdate();
     } */
     this.position.setTo(x, y);
@@ -65,7 +103,7 @@ export class Image extends DisplayObject {
     this.key = null;
     this.data = null;
     this.texture = null;
-    this.tint = 0xffffff;
+    this.tint = 0xff_ff_ff;
     this.cachedTint = -1;
     this.tintedTexture = null;
     this.shader = null;
@@ -113,7 +151,7 @@ export class Image extends DisplayObject {
    * @param {string | number | null | undefined} frame - The frame identifier (name or index) to use.
    * @param {boolean} stopAnimation - Whether to stop the animation when changing textures.
    */
-  loadTexture(key, frame = 0, stopAnimation = true) {
+  loadTexture(key, frame: string | number | null = 0, stopAnimation = true) {
     if (key === PENDING_ATLAS) {
       key = frame;
       frame = 0;
@@ -125,7 +163,7 @@ export class Image extends DisplayObject {
     }
     this.key = key;
     this.customRender = false;
-    const cache = this.game.cache;
+    const { cache } = this.game;
     const smoothed = !this.texture.baseTexture.scaleMode;
     let setFrame = true;
     if (key instanceof Texture) {
@@ -342,7 +380,7 @@ export class Image extends DisplayObject {
    * Called when the texture of this image is updated.
    */
   onTextureUpdate() {
-    // so if _width is 0 then width was not set..
+    // So if _width is 0 then width was not set..
     if (this._width) {
       this.scale.x = this._width / this.texture.frame.width;
     }

package/src/phaser/display/webgl/abstract_filter.ts

@@ -1,5 +1,11 @@
 // @ts-nocheck
 export class AbstractFilter {
+passes;
+shaders;
+dirty;
+padding;
+uniforms;
+fragmentSrc;
   /**
    * Creates a new AbstractFilter instance.
    * @param {string[]} fragmentSrc - The fragment shader source.

package/src/phaser/display/webgl/base_texture.ts

@@ -2,6 +2,18 @@
 import { removeByCanvas } from '../canvas/pool.js';
 
 export class BaseTexture {
+resolution;
+width;
+height;
+scaleMode;
+hasLoaded;
+source;
+premultipliedAlpha;
+_glTextures;
+mipmap;
+skipRender;
+_powerOf2;
+_dirty;
   /**
    * Updates the base texture with a new source.
    * @param {HTMLCanvasElement} source - The new canvas element to use as the texture source.

package/src/phaser/display/webgl/blend_manager.ts

@@ -1,5 +1,7 @@
 // @ts-nocheck
 export class WebGLBlendModeManager {
+gl;
+currentBlendMode;
   /**
    * Creates a new BlendModeManager instance.
    */

package/src/phaser/display/webgl/fast_sprite_batch.ts

@@ -1,5 +1,20 @@
 // @ts-nocheck
 export class FastSpriteBatch {
+vertSize;
+maxSize;
+size;
+vertices;
+indices;
+vertexBuffer;
+indexBuffer;
+lastIndexCount;
+drawing;
+currentBatchSize;
+currentBaseTexture;
+currentBlendMode;
+renderSession;
+shader;
+matrix;
   /**
    * Creates a new FastSpriteBatch instance.
    * @param {WebGLRenderingContext & { id: number }} gl - The WebGL rendering context.

package/src/phaser/display/webgl/filter_manager.ts

@@ -1,5 +1,8 @@
 // @ts-nocheck
 export class WebGLFilterManager {
+filterStack;
+offsetX;
+offsetY;
   /**
    * Creates a new FilterManager instance.
    */

package/src/phaser/display/webgl/filter_texture.ts

@@ -2,6 +2,10 @@
 import { SCALE_LINEAR } from '../../core/const.js';
 
 export class FilterTexture {
+gl;
+frameBuffer;
+texture;
+renderBuffer;
   /**
    * Creates a new FilterTexture instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/graphics_data.ts

@@ -1,5 +1,14 @@
 // @ts-nocheck
 export class GraphicsData {
+gl;
+color;
+points;
+indices;
+buffer;
+indexBuffer;
+mode;
+alpha;
+dirty;
   /**
    * Creates a new GraphicsData instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/render_texture.ts

@@ -8,6 +8,16 @@ import { FilterTexture } from './filter_texture.js';
 import { Texture } from './texture.js';
 
 export class RenderTexture extends Texture {
+width;
+height;
+resolution;
+frame;
+crop;
+renderer;
+textureBuffer;
+render;
+projection;
+valid;
   /**
    * Creates a new RenderTexture instance.
    * @param {number} width - The width of the render texture.

package/src/phaser/display/webgl/renderer.ts

@@ -33,6 +33,23 @@ import { WebGLStencilManager } from './stencil_manager.js';
 import { getWebGLContextErrorCode, getWebGLContextErrorName } from './util.js';
 
 export class WebGLRenderer {
+type;
+resolution;
+autoResize;
+contextLost;
+clearBeforeRender;
+width;
+height;
+view;
+_contextOptions;
+projection;
+offset;
+shaderManager;
+spriteBatch;
+filterManager;
+stencilManager;
+blendModeManager;
+renderSession;
   /**
    * Creates a new WebGLRenderer instance.
    * @param {import('../../core/game.js').Game} game - The game instance.

package/src/phaser/display/webgl/shader/complex.ts

@@ -5,6 +5,11 @@ import { compileProgram } from '../util.js';
 // the next one is used for rendering triangle strips
 
 export class ComplexPrimitiveShader {
+gl;
+_UID;
+program;
+fragmentSrc;
+vertexSrc;
   /**
    * Creates a new ComplexShader instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/shader/fast.ts

@@ -5,6 +5,12 @@ import { compileProgram } from '../util.js';
 // this shader is used for the fast sprite rendering
 
 export class FastShader {
+gl;
+_UID;
+program;
+textureCount;
+fragmentSrc;
+vertexSrc;
   /**
    * Creates a new FastShader instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/shader/normal.ts

@@ -25,6 +25,16 @@ const defaultVertexSrc = [
 // this shader is used for the default sprite rendering
 
 export class NormalShader {
+gl;
+_UID;
+program;
+fragmentSrc;
+vertexSrc;
+textureCount;
+firstRun;
+dirty;
+uniforms;
+attributes;
   /**
    * Creates a new NormalShader instance.
    * @param {WebGLRenderingContext & { id: number }} gl - The WebGL rendering context.

package/src/phaser/display/webgl/shader/primitive.ts

@@ -5,6 +5,11 @@ import { compileProgram } from '../util.js';
 // the next one is used for rendering primitives
 
 export class PrimitiveShader {
+gl;
+_UID;
+program;
+fragmentSrc;
+vertexSrc;
   /**
    * Creates a new PrimitiveShader instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/shader/strip.ts

@@ -5,6 +5,11 @@ import { compileProgram } from '../util.js';
 // the next one is used for rendering triangle strips
 
 export class StripShader {
+gl;
+_UID;
+program;
+fragmentSrc;
+vertexSrc;
   /**
    * Creates a new StripShader instance.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.

package/src/phaser/display/webgl/shader_manager.ts

@@ -6,6 +6,16 @@ import { PrimitiveShader } from './shader/primitive.js';
 import { StripShader } from './shader/strip.js';
 
 export class WebGLShaderManager {
+gl;
+primitiveShader;
+complexPrimitiveShader;
+defaultShader;
+fastShader;
+stripShader;
+maxAttibs;
+attribState;
+tempAttribState;
+stack;
   /**
    * Initializes the shader manager with a WebGL context.
    */

package/src/phaser/display/webgl/sprite_batch.ts

@@ -3,6 +3,22 @@ import { AbstractFilter } from './abstract_filter.js';
 import { NormalShader } from './shader/normal.js';
 
 export class WebGLSpriteBatch {
+vertSize;
+size;
+vertices;
+positions;
+colors;
+indices;
+lastIndexCount;
+drawing;
+currentBatchSize;
+currentBaseTexture;
+dirty;
+textures;
+blendModes;
+shaders;
+sprites;
+defaultShader;
   /**
    * Creates a new SpriteBatch instance.
    */