@vpmedia/phaser 1.123.0 → 1.125.0

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

@@ -1,5 +1,6 @@
 import { v4 as uuidv4 } from 'uuid';
 import { compileProgram } from '../util.js';
+import type { Texture } from '../texture.js';
 
 const defaultVertexSrc = [
   'attribute vec2 aVertexPosition;',
@@ -21,7 +22,7 @@ const defaultVertexSrc = [
   '}',
 ];
 
-const glMember = (gl: WebGLRenderingContext, name: string): any => (gl as unknown as Record<string, unknown>)[name];
+const glMember = (gl: WebGLRenderingContext, name: string): GLenum => (gl as unknown as Record<string, GLenum>)[name]!;
 
 /** Applies one of the gl uniform setters, whose signatures vary by uniform kind. */
 const callUniformSetter = (setter: unknown, gl: WebGLRenderingContext, ...args: unknown[]): void => {
@@ -32,9 +33,29 @@ const callUniformSetter = (setter: unknown, gl: WebGLRenderingContext, ...args:
 
 // this shader is used for the default sprite rendering
 
+/** The extra texture parameters a sampler uniform may carry, as the consumer supplied them. */
+export type ShaderTextureData = {
+  magFilter?: GLenum;
+  minFilter?: GLenum;
+  wrapS?: GLenum;
+  wrapT?: GLenum;
+  luminance?: boolean;
+  repeat?: boolean;
+  flipY?: boolean;
+  width?: number;
+  height?: number;
+  border?: number;
+};
+
+/** A sampler uniform, whose value is the texture to bind. */
+export type SamplerUniform = ShaderUniform & { value: Texture | null };
+
+/** A vector uniform value, read component-wise by the setter matching its arity. */
+export type UniformVector = { x: number; y: number; z?: number; w?: number };
+
 export type ShaderUniform = {
   type: string;
-  value: any;
+  value: unknown;
   uniformLocation?: WebGLUniformLocation | null;
   /** One of the gl uniform setters. Their arities differ by uniform kind, so the stored value is
    * opaque and applied through callUniformSetter. */
@@ -42,7 +63,7 @@ export type ShaderUniform = {
   glMatrix?: boolean;
   glValueLength?: number;
   transpose?: boolean;
-  textureData?: Record<string, any>;
+  textureData?: ShaderTextureData;
   _init?: boolean;
 };
 
@@ -141,7 +162,7 @@ export class NormalShader {
       if (type === 'sampler2D') {
         uniform._init = false;
         if (uniform.value !== null) {
-          this.initSampler2D(uniform);
+          this.initSampler2D(uniform as SamplerUniform);
         }
       } else if (type === 'mat2' || type === 'mat3' || type === 'mat4') {
         //  These require special handling
@@ -174,13 +195,14 @@ export class NormalShader {
    * Sets a uniform value for this shader.
    * @param {object} uniform - The uniform to set.
    */
-  public initSampler2D(uniform: any): void {
-    if (!uniform.value || !uniform.value.baseTexture || !uniform.value.baseTexture.hasLoaded) {
+  public initSampler2D(uniform: SamplerUniform): void {
+    const texture = uniform.value;
+    if (texture?.baseTexture.hasLoaded !== true) {
       return;
     }
     const { gl } = this;
     gl.activeTexture(glMember(gl, `TEXTURE${this.textureCount}`));
-    gl.bindTexture(gl.TEXTURE_2D, uniform.value.baseTexture._glTextures[gl.id]);
+    gl.bindTexture(gl.TEXTURE_2D, texture.baseTexture._glTextures[gl.id] ?? null);
     //  Extended texture data
     if (uniform.textureData) {
       const data = uniform.textureData;
@@ -196,13 +218,13 @@ export class NormalShader {
       const minFilter = data.minFilter ?? gl.LINEAR;
       let wrapS = data.wrapS ?? gl.CLAMP_TO_EDGE;
       let wrapT = data.wrapT ?? gl.CLAMP_TO_EDGE;
-      const format = data.luminance ? gl.LUMINANCE : gl.RGBA;
-      if (data.repeat) {
+      const format = data.luminance === true ? gl.LUMINANCE : gl.RGBA;
+      if (data.repeat === true) {
         wrapS = gl.REPEAT;
         wrapT = gl.REPEAT;
       }
       gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, Boolean(data.flipY));
-      if (data.width) {
+      if (data.width !== undefined) {
         const width = data.width ?? 512;
         const height = data.height ?? 2;
         const border = data.border ?? 0;
@@ -211,14 +233,14 @@ export class NormalShader {
         gl.texImage2D(gl.TEXTURE_2D, 0, format, width, height, border, format, gl.UNSIGNED_BYTE, null);
       } else {
         //  void texImage2D(GLenum target, GLint level, GLenum internalformat, GLenum format, GLenum type, ImageData? pixels);
-        gl.texImage2D(gl.TEXTURE_2D, 0, format, gl.RGBA, gl.UNSIGNED_BYTE, uniform.value.baseTexture.source);
+        gl.texImage2D(gl.TEXTURE_2D, 0, format, gl.RGBA, gl.UNSIGNED_BYTE, texture.baseTexture.source!);
       }
       gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter);
       gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter);
       gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS);
       gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT);
     }
-    gl.uniform1i(uniform.uniformLocation, this.textureCount);
+    gl.uniform1i(uniform.uniformLocation ?? null, this.textureCount);
     uniform._init = true;
     this.textureCount += 1;
   }
@@ -231,6 +253,8 @@ export class NormalShader {
     const { gl } = this;
     //  This would probably be faster in an array and it would guarantee key order
     for (const uniform of Object.values(this.uniforms)) {
+      const vector = uniform.value as UniformVector;
+      const sampler = uniform as SamplerUniform;
       if (uniform.glValueLength === 1) {
         if (uniform.glMatrix === true) {
           callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, uniform.transpose, uniform.value);
@@ -238,40 +262,26 @@ export class NormalShader {
           callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, uniform.value);
         }
       } else if (uniform.glValueLength === 2) {
-        callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, uniform.value.x, uniform.value.y);
+        callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, vector.x, vector.y);
       } else if (uniform.glValueLength === 3) {
-        callUniformSetter(
-          uniform.glFunc,
-          gl,
-          uniform.uniformLocation,
-          uniform.value.x,
-          uniform.value.y,
-          uniform.value.z
-        );
+        callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, vector.x, vector.y, vector.z);
       } else if (uniform.glValueLength === 4) {
-        callUniformSetter(
-          uniform.glFunc,
-          gl,
-          uniform.uniformLocation,
-          uniform.value.x,
-          uniform.value.y,
-          uniform.value.z,
-          uniform.value.w
-        );
+        callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, vector.x, vector.y, vector.z, vector.w);
       } else if (uniform.type === 'sampler2D') {
-        if (uniform._init) {
+        if (uniform._init === true) {
           gl.activeTexture(glMember(gl, `TEXTURE${this.textureCount}`));
-          if (uniform.value.baseTexture._dirty[gl.id]) {
-            globalThis.PhaserRegistry.INSTANCES[gl.id]?.updateTexture(uniform.value.baseTexture);
+          const { baseTexture } = sampler.value!;
+          if (baseTexture._dirty[gl.id] === true) {
+            globalThis.PhaserRegistry.INSTANCES[gl.id]?.updateTexture(baseTexture);
           } else {
             // bind the current texture
-            gl.bindTexture(gl.TEXTURE_2D, uniform.value.baseTexture._glTextures[gl.id]);
+            gl.bindTexture(gl.TEXTURE_2D, baseTexture._glTextures[gl.id] ?? null);
           }
           //  gl.bindTexture(gl.TEXTURE_2D, uniform.value.baseTexture._glTextures[gl.id] || PIXI.createWebGLTexture( uniform.value.baseTexture, gl));
           gl.uniform1i(uniform.uniformLocation ?? null, this.textureCount);
           this.textureCount += 1;
         } else {
-          this.initSampler2D(uniform);
+          this.initSampler2D(sampler);
         }
       }
     }

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

@@ -23,29 +23,29 @@ const createStubGl = (options: StubOptions = {}) => {
     createShader: vi.fn(() => ({})),
     shaderSource: vi.fn(),
     compileShader: vi.fn(),
-    getShaderParameter: vi.fn(() => true),
-    getShaderInfoLog: vi.fn(() => ''),
-    createProgram: vi.fn(() => program),
+    getShaderParameter: vi.fn((): boolean => true),
+    getShaderInfoLog: vi.fn((): string => ''),
+    createProgram: vi.fn((): object | null => program),
     attachShader: vi.fn(),
     linkProgram: vi.fn(),
-    getProgramParameter: vi.fn(() => linkStatus),
-    getProgramInfoLog: vi.fn(() => 'link failed'),
+    getProgramParameter: vi.fn((): boolean => linkStatus),
+    getProgramInfoLog: vi.fn((): string => 'link failed'),
     useProgram,
     deleteProgram,
-    getUniformLocation: vi.fn((_program: unknown, name: string) => {
+    getUniformLocation: vi.fn((_program: unknown, name: string): object | undefined => {
       if (!uniformLocations.has(name)) {
         uniformLocations.set(name, { name });
       }
       return uniformLocations.get(name);
     }),
-    getAttribLocation: vi.fn((_program: unknown, name: string) => attribLocations[name] ?? 0),
+    getAttribLocation: vi.fn((_program: unknown, name: string): number => attribLocations[name] ?? 0),
   } as unknown as WebGLRenderingContext;
   return { gl, deleteProgram, useProgram };
 };
 
-describe('WebGL shaders', () => {
-  describe('PrimitiveShader', () => {
-    it('resolves its uniforms and attributes on construction', () => {
+describe('WebGL shaders', (): void => {
+  describe('PrimitiveShader', (): void => {
+    it('resolves its uniforms and attributes on construction', (): void => {
       const { gl } = createStubGl({ attribLocations: { aVertexPosition: 0, aColor: 1 } });
       const shader = new PrimitiveShader(gl);
       expect(shader.program).not.toBeNull();
@@ -53,7 +53,7 @@ describe('WebGL shaders', () => {
       expect(shader.attributes).toStrictEqual([0, 1]);
     });
 
-    it('releases the program on destroy', () => {
+    it('releases the program on destroy', (): void => {
       const { gl, deleteProgram } = createStubGl();
       const shader = new PrimitiveShader(gl);
       shader.destroy();
@@ -62,24 +62,24 @@ describe('WebGL shaders', () => {
       expect(shader.gl).toBeNull();
     });
 
-    it('leaves the program null when compilation fails', () => {
+    it('leaves the program null when compilation fails', (): void => {
       const { gl, useProgram } = createStubGl({ program: null });
       const shader = new PrimitiveShader(gl);
       expect(shader.program).toBeNull();
       expect(useProgram).not.toHaveBeenCalled();
     });
 
-    it('destroys cleanly after a failed compile', () => {
+    it('destroys cleanly after a failed compile', (): void => {
       const { gl } = createStubGl({ program: null });
       const shader = new PrimitiveShader(gl);
-      expect(() => {
+      expect((): void => {
         shader.destroy();
       }).not.toThrow();
     });
   });
 
-  describe('StripShader', () => {
-    it('resolves its uniforms and attributes on construction', () => {
+  describe('StripShader', (): void => {
+    it('resolves its uniforms and attributes on construction', (): void => {
       const { gl } = createStubGl({
         attribLocations: { aVertexPosition: 0, aTextureCoord: 1, aColor: 2 },
       });
@@ -89,7 +89,7 @@ describe('WebGL shaders', () => {
       expect(shader.translationMatrix).toBeDefined();
     });
 
-    it('clears its attributes on destroy', () => {
+    it('clears its attributes on destroy', (): void => {
       const { gl } = createStubGl();
       const shader = new StripShader(gl);
       shader.destroy();
@@ -97,8 +97,8 @@ describe('WebGL shaders', () => {
     });
   });
 
-  describe('ComplexPrimitiveShader', () => {
-    it('resolves the uniforms it declares', () => {
+  describe('ComplexPrimitiveShader', (): void => {
+    it('resolves the uniforms it declares', (): void => {
       const { gl } = createStubGl();
       const shader = new ComplexPrimitiveShader(gl);
       expect(shader.tintColor).toBeDefined();
@@ -106,7 +106,7 @@ describe('WebGL shaders', () => {
       expect(shader.flipY).toBeDefined();
     });
 
-    it('leaves colorAttribute unresolved, as the shader never reads aColor', () => {
+    it('leaves colorAttribute unresolved, as the shader never reads aColor', (): void => {
       const { gl } = createStubGl();
       const shader = new ComplexPrimitiveShader(gl);
       expect(shader.colorAttribute).toBeUndefined();
@@ -114,8 +114,8 @@ describe('WebGL shaders', () => {
     });
   });
 
-  describe('FastShader', () => {
-    it('resolves the full attribute set in batch order', () => {
+  describe('FastShader', (): void => {
+    it('resolves the full attribute set in batch order', (): void => {
       const { gl } = createStubGl({
         attribLocations: {
           aVertexPosition: 0,
@@ -130,13 +130,13 @@ describe('WebGL shaders', () => {
       expect(shader.attributes).toStrictEqual([0, 1, 2, 3, 4, 5]);
     });
 
-    it('falls back to slot 2 when the driver reports aColor as -1', () => {
+    it('falls back to slot 2 when the driver reports aColor as -1', (): void => {
       const { gl } = createStubGl({ attribLocations: { aColor: -1 } });
       const shader = new FastShader(gl);
       expect(shader.colorAttribute).toBe(2);
     });
 
-    it('releases the program and buffers on destroy', () => {
+    it('releases the program and buffers on destroy', (): void => {
       const { gl, deleteProgram } = createStubGl();
       const shader = new FastShader(gl);
       shader.destroy();

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

@@ -21,17 +21,17 @@ const createManager = (): { manager: WebGLShaderManager; gl: GlMocks } => {
 const shaderStub = (uid: string, attributes: number[]): NormalShader =>
   ({ _UID: uid, program: {}, attributes }) as unknown as NormalShader;
 
-describe('WebGLShaderManager', () => {
-  describe('constructor', () => {
-    it('starts with ten disabled attribute slots', () => {
+describe('WebGLShaderManager', (): void => {
+  describe('constructor', (): void => {
+    it('starts with ten disabled attribute slots', (): void => {
       const manager = new WebGLShaderManager();
       expect(manager.attribState).toHaveLength(10);
-      expect(manager.attribState.every((enabled) => enabled === false)).toBe(true);
+      expect(manager.attribState.every((enabled): boolean => enabled === false)).toBe(true);
     });
   });
 
-  describe('setAttribs', () => {
-    it('enables exactly the requested attribute slots', () => {
+  describe('setAttribs', (): void => {
+    it('enables exactly the requested attribute slots', (): void => {
       const { manager, gl } = createManager();
       manager.setAttribs([0, 2]);
       expect(gl.enableVertexAttribArray).toHaveBeenCalledTimes(2);
@@ -39,7 +39,7 @@ describe('WebGLShaderManager', () => {
       expect(gl.enableVertexAttribArray).toHaveBeenCalledWith(2);
     });
 
-    it('only touches slots whose state actually changed', () => {
+    it('only touches slots whose state actually changed', (): void => {
       const { manager, gl } = createManager();
       manager.setAttribs([0, 1]);
       vi.clearAllMocks();
@@ -48,7 +48,7 @@ describe('WebGLShaderManager', () => {
       expect(gl.disableVertexAttribArray).not.toHaveBeenCalled();
     });
 
-    it('disables slots dropped between calls', () => {
+    it('disables slots dropped between calls', (): void => {
       const { manager, gl } = createManager();
       manager.setAttribs([0, 1, 2]);
       vi.clearAllMocks();
@@ -58,13 +58,13 @@ describe('WebGLShaderManager', () => {
       expect(gl.enableVertexAttribArray).not.toHaveBeenCalled();
     });
 
-    it('mirrors the sparse temp state, leaving untouched slots unset', () => {
+    it('mirrors the sparse temp state, leaving untouched slots unset', (): void => {
       const { manager } = createManager();
       manager.setAttribs([1, 3]);
       expect(manager.attribState.slice(0, 4)).toStrictEqual([undefined, true, undefined, true]);
     });
 
-    it('disables the previously enabled slots when given no attributes', () => {
+    it('disables the previously enabled slots when given no attributes', (): void => {
       const { manager, gl } = createManager();
       manager.setAttribs([0, 1]);
       vi.clearAllMocks();
@@ -76,8 +76,8 @@ describe('WebGLShaderManager', () => {
     });
   });
 
-  describe('setShader', () => {
-    it('binds a new shader and reports that it switched', () => {
+  describe('setShader', (): void => {
+    it('binds a new shader and reports that it switched', (): void => {
       const { manager, gl } = createManager();
       const shader = shaderStub('a', [0, 1]);
       expect(manager.setShader(shader)).toBe(true);
@@ -85,7 +85,7 @@ describe('WebGLShaderManager', () => {
       expect(gl.useProgram).toHaveBeenCalledWith(shader.program);
     });
 
-    it('skips rebinding the shader already in use', () => {
+    it('skips rebinding the shader already in use', (): void => {
       const { manager, gl } = createManager();
       const shader = shaderStub('a', [0, 1]);
       manager.setShader(shader);
@@ -94,7 +94,7 @@ describe('WebGLShaderManager', () => {
       expect(gl.useProgram).not.toHaveBeenCalled();
     });
 
-    it('rebinds when a different shader is supplied', () => {
+    it('rebinds when a different shader is supplied', (): void => {
       const { manager } = createManager();
       manager.setShader(shaderStub('a', [0]));
       const next = shaderStub('b', [0, 1]);
@@ -103,8 +103,8 @@ describe('WebGLShaderManager', () => {
     });
   });
 
-  describe('destroy', () => {
-    it('clears attribute state and forgets the current shader', () => {
+  describe('destroy', (): void => {
+    it('clears attribute state and forgets the current shader', (): void => {
       const { manager } = createManager();
       manager.setShader(shaderStub('a', [0]));
       manager.destroy();
@@ -114,9 +114,9 @@ describe('WebGLShaderManager', () => {
       expect(manager._currentId).toBeNull();
     });
 
-    it('tolerates shaders that were never created', () => {
+    it('tolerates shaders that were never created', (): void => {
       const { manager } = createManager();
-      expect(() => {
+      expect((): void => {
         manager.destroy();
       }).not.toThrow();
     });

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

@@ -71,7 +71,7 @@ export class WebGLShaderManager {
     for (i = 0; i < this.attribState.length; i += 1) {
       if (this.attribState[i] !== this.tempAttribState[i]) {
         this.attribState[i] = this.tempAttribState[i];
-        if (this.tempAttribState[i]) {
+        if (this.tempAttribState[i] === true) {
           gl.enableVertexAttribArray(i);
         } else {
           gl.disableVertexAttribArray(i);

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

@@ -16,13 +16,13 @@ export class WebGLSpriteBatch {
   public lastIndexCount: number;
   public drawing: boolean;
   public currentBatchSize: number;
-  public currentBaseTexture: any;
+  public currentBaseTexture: BaseTexture | null;
   public dirty: boolean;
-  public textures: any[];
+  public textures: BaseTexture[];
   public blendModes: number[];
   public shaders: NormalShader[];
-  public sprites: any[];
-  public defaultShader: any;
+  public sprites: Image[];
+  public defaultShader: AbstractFilter;
   public gl!: IdentifiedWebGLRenderingContext;
   public vertexBuffer!: WebGLBuffer | null;
   public indexBuffer!: WebGLBuffer | null;
@@ -234,7 +234,7 @@ export class WebGLSpriteBatch {
       // bind the buffers
       gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
       gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
-      shader = this.defaultShader.shaders[gl.id];
+      shader = this.defaultShader.shaders[gl.id]!;
       // this is the same for each shader?
       const stride = this.vertSize * 4;
       gl.vertexAttribPointer(shader.aVertexPosition, 2, gl.FLOAT, false, stride, 0);
@@ -261,12 +261,12 @@ export class WebGLSpriteBatch {
     let shaderSwap = false;
     let sprite;
     for (let i = 0, j = this.currentBatchSize; i < j; i += 1) {
-      sprite = this.sprites[i];
+      sprite = this.sprites[i]!;
       nextTexture = sprite.tilingTexture ? sprite.tilingTexture.baseTexture : sprite.texture.baseTexture;
       nextBlendMode = sprite.blendMode;
       nextShader = sprite.shader ?? this.defaultShader;
       blendSwap = currentBlendMode !== nextBlendMode;
-      shaderSwap = !currentShader || !nextShader || currentShader._UID !== nextShader._UID;
+      shaderSwap = currentShader === null || currentShader._UID !== nextShader._UID;
       let skip = nextTexture.skipRender;
       if (skip && sprite.children.length > 0) {
         skip = false;
@@ -317,13 +317,13 @@ export class WebGLSpriteBatch {
    * @param {number} size - The size of the batch.
    * @param {number} startIndex - The start index in the batch.
    */
-  public renderBatch(texture: BaseTexture, size: number, startIndex: number): void {
-    if (size === 0) {
+  public renderBatch(texture: BaseTexture | null, size: number, startIndex: number): void {
+    if (size === 0 || !texture) {
       return;
     }
     const { gl } = this;
     // check if a texture is dirty..
-    if (texture._dirty[gl.id]) {
+    if (texture._dirty[gl.id] === true) {
       if (!this.renderSession.renderer.updateTexture(texture)) {
         //  If updateTexture returns false then we cannot render it, so bail out now
         return;

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

@@ -5,9 +5,9 @@ import type { RenderSession } from '../render_session.js';
 
 export class WebGLStencilManager {
   public gl!: WebGLRenderingContext;
-  public stencilStack!: any;
-  public reverse!: any;
-  public count!: any;
+  public stencilStack!: GraphicsData[];
+  public reverse!: boolean;
+  public count!: number;
   /**
    * Initializes the stencil manager.
    */
@@ -29,7 +29,7 @@ export class WebGLStencilManager {
    * Sets up the stencil buffer for rendering.
    */
   public destroy(): void {
-    this.stencilStack = null;
+    this.stencilStack = [];
   }
 
   /**

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

@@ -121,7 +121,8 @@ export class Texture {
       this.valid = false;
       return;
     }
-    this.valid = Boolean(frame && frame.width && frame.height && this.baseTexture.source && this.baseTexture.hasLoaded);
+    this.valid =
+      frame.width !== 0 && frame.height !== 0 && this.baseTexture.source !== null && this.baseTexture.hasLoaded;
     if (this.trim) {
       this.width = this.trim.width;
       this.height = this.trim.height;

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

@@ -7,7 +7,7 @@ import { Texture } from './texture.js';
  * @param {number} [scaleMode] - The scale mode to use for the texture.
  * @returns {BaseTexture} The newly created BaseTexture instance.
  */
-export const baseTextureFromCanvas = (canvas: HTMLCanvasElement, scaleMode: number): BaseTexture => {
+export const baseTextureFromCanvas = (canvas: HTMLCanvasElement, scaleMode?: number): BaseTexture => {
   if (canvas.width === 0) {
     canvas.width = 1;
   }
@@ -23,5 +23,5 @@ export const baseTextureFromCanvas = (canvas: HTMLCanvasElement, scaleMode: numb
  * @param {number} [scaleMode] - The scale mode to use for the texture.
  * @returns {Texture} The newly created Texture instance.
  */
-export const textureFromCanvas = (canvas: HTMLCanvasElement, scaleMode?: any): Texture =>
+export const textureFromCanvas = (canvas: HTMLCanvasElement, scaleMode?: number): Texture =>
   new Texture(baseTextureFromCanvas(canvas, scaleMode));

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

@@ -73,7 +73,7 @@ export const initDefaultShaders = (): void => {};
 export const compileShader = (
   gl: WebGLRenderingContext,
   shaderSrc: string[] | string,
-  shaderType: any
+  shaderType: GLenum
 ): WebGLShader | null => {
   const src = Array.isArray(shaderSrc) ? shaderSrc.join('\n') : shaderSrc;
   const shader = gl.createShader(shaderType);
@@ -82,7 +82,7 @@ export const compileShader = (
   }
   gl.shaderSource(shader, src);
   gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+  if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) !== true) {
     getRegistry();
     globalThis.PhaserRegistry.GL_SHADER_INFO_LOG = gl.getShaderInfoLog(shader);
     return null;
@@ -125,14 +125,14 @@ export const compileProgram = (
 
   const shaderProgram = gl.createProgram();
 
-  if (!shaderProgram || !vertexShader || !fragmentShader) {
+  if (shaderProgram === null || vertexShader === null || fragmentShader === null) {
     return null;
   }
   gl.attachShader(shaderProgram, vertexShader);
   gl.attachShader(shaderProgram, fragmentShader);
   gl.linkProgram(shaderProgram);
 
-  if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+  if (gl.getProgramParameter(shaderProgram, gl.LINK_STATUS) !== true) {
     getRegistry();
     globalThis.PhaserRegistry.GL_PROGRAM_INFO_LOG = gl.getProgramInfoLog(shaderProgram);
   }