@vpmedia/phaser 1.112.0 → 1.113.0

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

@@ -1,31 +1,38 @@
 import { AbstractFilter } from './abstract_filter.js';
 import { NormalShader } from './shader/normal.js';
 import type { IdentifiedWebGLRenderingContext } from './util.js';
+import type { Image } from '../../display/image.js';
+import type { Matrix } from '../../geom/matrix.js';
+import type { BaseTexture } from './base_texture.js';
 
 export class WebGLSpriteBatch {
-  [key: string]: any;
-  vertSize!: any;
-  size!: any;
-  vertices!: any;
-  positions!: any;
-  colors!: any;
-  indices!: any;
-  lastIndexCount!: any;
-  drawing!: any;
-  currentBatchSize!: any;
-  currentBaseTexture!: any;
-  dirty!: any;
-  textures!: any;
-  blendModes!: any;
-  shaders!: any;
-  sprites!: any;
-  defaultShader!: any;
+  public vertSize = 5;
+  public size = 2e3;
+  public vertices: ArrayBuffer | null;
+  public positions: Float32Array | null;
+  public colors: Uint32Array | null;
+  public indices: Uint16Array | null;
+  public lastIndexCount: number;
+  public drawing: boolean;
+  public currentBatchSize: number;
+  public currentBaseTexture: any;
+  public dirty: boolean;
+  public textures: any[];
+  public blendModes: number[];
+  public shaders: NormalShader[];
+  public sprites: any[];
+  public defaultShader: any;
+  public gl!: IdentifiedWebGLRenderingContext;
+  public vertexBuffer!: WebGLBuffer | null;
+  public indexBuffer!: WebGLBuffer | null;
+  public currentBlendMode!: number;
+  public renderSession!: any;
+  public shader!: NormalShader | null;
   /**
    * Creates a new SpriteBatch instance.
    */
-  constructor() {
-    this.vertSize = 5;
-    this.size = 2000; // Math.pow(2, 16) /  this.vertSize;
+  public constructor() {
+    // Math.pow(2, 16) /  this.vertSize;
     // the total number of bytes in our batch
     const numVerts = this.size * 4 * 4 * this.vertSize;
     // the total number of indices in our batch
@@ -66,7 +73,7 @@ export class WebGLSpriteBatch {
    * Renders a sprite using WebGL.
    * @param {WebGLRenderingContext & { id: number }} gl - The WebGL rendering context.
    */
-  setContext(gl: IdentifiedWebGLRenderingContext) {
+  public setContext(gl: IdentifiedWebGLRenderingContext) {
     this.gl = gl;
     // create a couple of buffers
     this.vertexBuffer = gl.createBuffer();
@@ -77,7 +84,7 @@ export class WebGLSpriteBatch {
     gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indices, gl.STATIC_DRAW);
     gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
     gl.bufferData(gl.ARRAY_BUFFER, this.vertices, gl.DYNAMIC_DRAW);
-    this.currentBlendMode = 99999;
+    this.currentBlendMode = 99_999;
     const shader = new NormalShader(gl);
     shader.fragmentSrc = this.defaultShader.fragmentSrc;
     shader.uniforms = {};
@@ -89,7 +96,7 @@ export class WebGLSpriteBatch {
    * Renders the sprite batch using WebGL.
    * @param {object} renderSession - The render session to use.
    */
-  begin(renderSession: any) {
+  public begin(renderSession: any) {
     this.renderSession = renderSession;
     this.shader = this.renderSession.shaderManager.defaultShader;
     this.start();
@@ -98,17 +105,17 @@ export class WebGLSpriteBatch {
   /**
    * Updates the sprite batch.
    */
-  end() {
+  public end() {
     this.flush();
   }
 
   /**
    * Renders a sprite using the sprite batch.
-   * @param {import('../../display/image.js').Image} sprite - The sprite to render.
-   * @param {import('../../geom/matrix.js').Matrix} matrix - The transformation matrix.
+   * @param {Image} sprite - The sprite to render.
+   * @param {Matrix} matrix - The transformation matrix.
    */
-  render(sprite: import('../../display/image.js').Image, matrix: import('../../geom/matrix.js').Matrix) {
-    const texture = sprite.texture;
+  public render(sprite: Image, matrix: Matrix) {
+    const { texture } = sprite;
     //  They provided an alternative rendering matrix, so use it
     let wt = sprite.worldTransform;
     if (matrix) {
@@ -133,7 +140,7 @@ export class WebGLSpriteBatch {
     let h1;
     if (texture.trim) {
       // if the sprite is trimmed then we need to add the extra space before transforming the sprite coords.
-      const trim = texture.trim;
+      const { trim } = texture;
       w1 = trim.x - aX * trim.width;
       w0 = w1 + texture.crop.width;
       h1 = trim.y - aY * trim.height;
@@ -145,28 +152,28 @@ export class WebGLSpriteBatch {
       h1 = texture.frame.height * -aY;
     }
     const i = this.currentBatchSize * 4 * this.vertSize;
-    const resolution = texture.baseTexture.resolution;
+    const { resolution } = texture.baseTexture;
     const a = wt.a / resolution;
     const b = wt.b / resolution;
     const c = wt.c / resolution;
     const d = wt.d / resolution;
-    const tx = wt.tx;
-    const ty = wt.ty;
-    const colors = this.colors;
-    const positions = this.positions;
+    const { tx } = wt;
+    const { ty } = wt;
+    const colors = this.colors!;
+    const positions = this.positions!;
     if (this.renderSession.roundPixels) {
       // xy
-      positions[i] = (a * w1 + c * h1 + tx) | 0;
-      positions[i + 1] = (d * h1 + b * w1 + ty) | 0;
+      positions[i] = Math.trunc(a * w1 + c * h1 + tx);
+      positions[i + 1] = Math.trunc(d * h1 + b * w1 + ty);
       // xy
-      positions[i + 5] = (a * w0 + c * h1 + tx) | 0;
-      positions[i + 6] = (d * h1 + b * w0 + ty) | 0;
+      positions[i + 5] = Math.trunc(a * w0 + c * h1 + tx);
+      positions[i + 6] = Math.trunc(d * h1 + b * w0 + ty);
       // xy
-      positions[i + 10] = (a * w0 + c * h0 + tx) | 0;
-      positions[i + 11] = (d * h0 + b * w0 + ty) | 0;
+      positions[i + 10] = Math.trunc(a * w0 + c * h0 + tx);
+      positions[i + 11] = Math.trunc(d * h0 + b * w0 + ty);
       // xy
-      positions[i + 15] = (a * w1 + c * h0 + tx) | 0;
-      positions[i + 16] = (d * h0 + b * w1 + ty) | 0;
+      positions[i + 15] = Math.trunc(a * w1 + c * h0 + tx);
+      positions[i + 16] = Math.trunc(d * h0 + b * w1 + ty);
     } else {
       // xy
       positions[i] = a * w1 + c * h1 + tx;
@@ -194,11 +201,11 @@ export class WebGLSpriteBatch {
     positions[i + 17] = uvs.x3;
     positions[i + 18] = uvs.y3;
     // color and alpha
-    const tint = sprite.tint;
+    const { tint } = sprite;
     colors[i + 4] = (tint >> 16) + (tint & 0xff00) + ((tint & 0xff) << 16) + ((sprite.worldAlpha * 255) << 24);
-    colors[i + 9] = colors[i + 4];
-    colors[i + 14] = colors[i + 4];
-    colors[i + 19] = colors[i + 4];
+    colors[i + 9] = colors[i + 4]!;
+    colors[i + 14] = colors[i + 4]!;
+    colors[i + 19] = colors[i + 4]!;
     // increment the batchsize
     this.sprites[this.currentBatchSize] = sprite;
     this.currentBatchSize += 1;
@@ -207,19 +214,19 @@ export class WebGLSpriteBatch {
   /**
    * Binds the sprite batch to the WebGL context.
    */
-  renderTilingSprite() {
+  public renderTilingSprite() {
     // TODO
   }
 
   /**
    * Updates the sprite batch.
    */
-  flush() {
+  public flush() {
     // If the batch is length 0 then return as there is nothing to draw
     if (this.currentBatchSize === 0) {
       return;
     }
-    const gl = this.gl;
+    const { gl } = this;
     let shader;
     if (this.dirty) {
       this.dirty = false;
@@ -238,9 +245,9 @@ export class WebGLSpriteBatch {
     }
     // upload the verts to the buffer
     if (this.currentBatchSize > this.size * 0.5) {
-      gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.vertices);
+      gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.vertices!);
     } else {
-      const view = this.positions.subarray(0, this.currentBatchSize * 4 * this.vertSize);
+      const view = this.positions!.subarray(0, this.currentBatchSize * 4 * this.vertSize);
       gl.bufferSubData(gl.ARRAY_BUFFER, 0, view);
     }
     let nextTexture;
@@ -249,7 +256,7 @@ export class WebGLSpriteBatch {
     let batchSize = 0;
     let start = 0;
     let currentBaseTexture = null;
-    let currentBlendMode = this.renderSession.blendModeManager.currentBlendMode;
+    let { currentBlendMode } = this.renderSession.blendModeManager;
     let currentShader = null;
     let blendSwap = false;
     let shaderSwap = false;
@@ -262,7 +269,7 @@ export class WebGLSpriteBatch {
         nextTexture = sprite.texture.baseTexture;
       }
       nextBlendMode = sprite.blendMode;
-      nextShader = sprite.shader || this.defaultShader;
+      nextShader = sprite.shader ?? this.defaultShader;
       blendSwap = currentBlendMode !== nextBlendMode;
       shaderSwap = !currentShader || !nextShader || currentShader._UID !== nextShader._UID;
       let skip = nextTexture.skipRender;
@@ -295,7 +302,7 @@ export class WebGLSpriteBatch {
           }
           // both these only need to be set if they are changing..
           // set the projection
-          const projection = this.renderSession.projection;
+          const { projection } = this.renderSession;
           gl.uniform2f(shader.projectionVector, projection.x, projection.y);
           // TODO - this is temporary!
           const offsetVector = this.renderSession.offset;
@@ -312,15 +319,15 @@ export class WebGLSpriteBatch {
 
   /**
    * Updates the sprite batch with a new texture.
-   * @param {import('./base_texture.js').BaseTexture} texture - The texture to use.
+   * @param {BaseTexture} texture - The texture to use.
    * @param {number} size - The size of the batch.
    * @param {number} startIndex - The start index in the batch.
    */
-  renderBatch(texture: import('./base_texture.js').BaseTexture, size: number, startIndex: number) {
+  public renderBatch(texture: BaseTexture, size: number, startIndex: number) {
     if (size === 0) {
       return;
     }
-    const gl = this.gl;
+    const { gl } = this;
     // check if a texture is dirty..
     if (texture._dirty[gl.id]) {
       if (!this.renderSession.renderer.updateTexture(texture)) {
@@ -340,7 +347,7 @@ export class WebGLSpriteBatch {
   /**
    * Destroys this sprite batch and cleans up resources.
    */
-  stop() {
+  public stop() {
     this.flush();
     this.dirty = true;
   }
@@ -348,14 +355,14 @@ export class WebGLSpriteBatch {
   /**
    * Renders the sprite batch using Canvas.
    */
-  start() {
+  public start(): void {
     this.dirty = true;
   }
 
   /**
    * Destroys the sprite batch instance.
    */
-  destroy() {
+  public destroy(): void {
     this.vertices = null;
     this.positions = null;
     this.colors = null;
@@ -363,6 +370,5 @@ export class WebGLSpriteBatch {
     this.gl.deleteBuffer(this.vertexBuffer);
     this.gl.deleteBuffer(this.indexBuffer);
     this.currentBaseTexture = null;
-    this.gl = null;
   }
 }

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

@@ -1,14 +1,16 @@
 import { hex2rgb } from '../../util/math.js';
+import type { Graphics } from '../graphics.js';
+import type { GraphicsData } from './graphics_data.js';
 
 export class WebGLStencilManager {
-  [key: string]: any;
-  stencilStack!: any;
-  reverse!: any;
-  count!: any;
+  public gl!: WebGLRenderingContext;
+  public stencilStack!: any;
+  public reverse!: any;
+  public count!: any;
   /**
    * Initializes the stencil manager.
    */
-  constructor() {
+  public constructor() {
     this.stencilStack = [];
     this.reverse = true;
     this.count = 0;
@@ -18,30 +20,25 @@ export class WebGLStencilManager {
    * Binds the stencil buffer for rendering.
    * @param {WebGLRenderingContext} gl - The WebGL rendering context.
    */
-  setContext(gl: WebGLRenderingContext) {
+  public setContext(gl: WebGLRenderingContext) {
     this.gl = gl;
   }
 
   /**
    * Sets up the stencil buffer for rendering.
    */
-  destroy() {
+  public destroy(): void {
     this.stencilStack = null;
-    this.gl = null;
   }
 
   /**
    * Renders the stencil buffer for graphics.
-   * @param {import('../graphics.js').Graphics} graphics - The graphics object to render.
-   * @param {import('./graphics_data.js').GraphicsData} webGLData - The WebGL graphics data.
+   * @param {Graphics} graphics - The graphics object to render.
+   * @param {GraphicsData} webGLData - The WebGL graphics data.
    * @param {object} renderSession - The rendering session.
    */
-  pushStencil(
-    graphics: import('../graphics.js').Graphics,
-    webGLData: import('./graphics_data.js').GraphicsData,
-    renderSession: any
-  ) {
-    const gl = renderSession.gl;
+  public pushStencil(graphics: Graphics, webGLData: GraphicsData, renderSession: any) {
+    const { gl } = renderSession;
     this.bindGraphics(graphics, webGLData, renderSession);
     if (this.stencilStack.length === 0) {
       gl.enable(gl.STENCIL_TEST);
@@ -94,21 +91,17 @@ export class WebGLStencilManager {
 
   /**
    * Renders the stencil buffer for graphics.
-   * @param {import('../graphics.js').Graphics} graphics - The graphics object to render.
-   * @param {import('./graphics_data.js').GraphicsData} webGLData - The WebGL graphics data.
+   * @param {Graphics} graphics - The graphics object to render.
+   * @param {GraphicsData} webGLData - The WebGL graphics data.
    * @param {object} renderSession - The rendering session.
    */
-  bindGraphics(
-    graphics: import('../graphics.js').Graphics,
-    webGLData: import('./graphics_data.js').GraphicsData,
-    renderSession: any
-  ) {
+  public bindGraphics(graphics: Graphics, webGLData: GraphicsData, renderSession: any) {
     // if(this._currentGraphics === graphics)return;
     // this._currentGraphics = graphics;
-    const gl = renderSession.gl;
+    const { gl } = renderSession;
     // bind the graphics object..
-    const projection = renderSession.projection;
-    const offset = renderSession.offset;
+    const { projection } = renderSession;
+    const { offset } = renderSession;
     let shader; // = renderSession.shaderManager.primitiveShader;
     if (webGLData.mode === 1) {
       shader = renderSession.shaderManager.complexPrimitiveShader;
@@ -145,16 +138,12 @@ export class WebGLStencilManager {
 
   /**
    * Renders the stencil buffer for graphics.
-   * @param {import('../graphics.js').Graphics} graphics - The graphics object to render.
-   * @param {import('./graphics_data.js').GraphicsData} webGLData - The WebGL graphics data.
+   * @param {Graphics} graphics - The graphics object to render.
+   * @param {GraphicsData} webGLData - The WebGL graphics data.
    * @param {object} renderSession - The rendering session.
    */
-  popStencil(
-    graphics: import('../graphics.js').Graphics,
-    webGLData: import('./graphics_data.js').GraphicsData,
-    renderSession: any
-  ) {
-    const gl = renderSession.gl;
+  public popStencil(graphics: Graphics, webGLData: GraphicsData, renderSession: any) {
+    const { gl } = renderSession;
     this.stencilStack.pop();
     this.count -= 1;
     if (this.stencilStack.length === 0) {

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

@@ -1,35 +1,31 @@
 import { Rectangle } from '../../geom/rectangle.js';
+import type { BaseTexture } from './base_texture.js';
 
 export class TextureUvs {
-  noFrame!: any;
-  baseTexture!: any;
-  frame!: any;
-  trim!: any;
-  valid!: any;
-  isTiling!: any;
-  requiresUpdate!: any;
-  requiresReTint!: any;
-  _uvs!: any;
-  width!: any;
-  height!: any;
-  crop!: any;
-  x0!: any;
-  y0!: any;
-  x1!: any;
-  y1!: any;
-  x2!: any;
-  y2!: any;
-  x3!: any;
-  y3!: any;
+  public noFrame!: any;
+  public baseTexture!: any;
+  public frame!: any;
+  public trim!: any;
+  public valid!: any;
+  public isTiling!: any;
+  public requiresUpdate!: any;
+  public requiresReTint!: any;
+  public _uvs!: any;
+  public width!: any;
+  public height!: any;
+  public crop!: any;
+  public x0: any = 0;
+  public y0: any = 0;
+  public x1: any = 0;
+  public y1: any = 0;
+  public x2: any = 0;
+  public y2!: any;
+  public x3!: any;
+  public y3!: any;
   /**
    * Creates a new Texture instance.
    */
-  constructor() {
-    this.x0 = 0;
-    this.y0 = 0;
-    this.x1 = 0;
-    this.y1 = 0;
-    this.x2 = 0;
+  public constructor() {
     this.y2 = 0;
     this.x3 = 0;
     this.y3 = 0;
@@ -37,32 +33,31 @@ export class TextureUvs {
 }
 
 export class Texture {
-  noFrame!: any;
-  baseTexture!: any;
-  frame!: any;
-  trim!: any;
-  valid!: any;
-  isTiling!: any;
-  requiresUpdate!: any;
-  requiresReTint!: any;
-  _uvs!: any;
-  width!: any;
-  height!: any;
-  crop!: any;
+  public noFrame: any = false;
+  public baseTexture!: any;
+  public frame!: any;
+  public trim!: any;
+  public valid!: any;
+  public isTiling!: any;
+  public requiresUpdate!: any;
+  public requiresReTint!: any;
+  public _uvs!: any;
+  public width!: any;
+  public height!: any;
+  public crop!: any;
   /**
    * Creates a new Texture instance.
-   * @param {import('./base_texture.js').BaseTexture} baseTexture - The base texture to use.
+   * @param {BaseTexture} baseTexture - The base texture to use.
    * @param {Rectangle | null | undefined} frame - The frame rectangle.
    * @param {Rectangle | null | undefined} crop - The crop rectangle.
    * @param {Rectangle | null | undefined} trim - The trim rectangle.
    */
-  constructor(
-    baseTexture: import('./base_texture.js').BaseTexture,
+  public constructor(
+    baseTexture: BaseTexture,
     frame: Rectangle | null | undefined = null,
     crop: Rectangle | null | undefined = null,
     trim: Rectangle | null | undefined = null
   ) {
-    this.noFrame = false;
     if (!frame) {
       this.noFrame = true;
       frame = new Rectangle(0, 0, 1, 1);
@@ -90,7 +85,7 @@ export class Texture {
     /** @type {number} */
     this.height = 0;
     /** @type {Rectangle} */
-    this.crop = crop || new Rectangle(0, 0, 1, 1);
+    this.crop = crop ?? new Rectangle(0, 0, 1, 1);
     if (baseTexture.hasLoaded) {
       if (this.noFrame) {
         frame = new Rectangle(0, 0, baseTexture.width, baseTexture.height);
@@ -102,7 +97,7 @@ export class Texture {
   /**
    * Destroys this texture and cleans up resources.
    */
-  onBaseTextureLoaded() {
+  public onBaseTextureLoaded() {
     if (this.noFrame) {
       this.frame = new Rectangle(0, 0, this.baseTexture.width, this.baseTexture.height);
     }
@@ -113,7 +108,7 @@ export class Texture {
    * Destroys this texture and cleans up resources.
    * @param {boolean} destroyBase - Whether to destroy the base texture as well.
    */
-  destroy(destroyBase: boolean = false) {
+  public destroy(destroyBase: boolean = false) {
     if (destroyBase) {
       this.baseTexture.destroy();
     }
@@ -125,7 +120,7 @@ export class Texture {
    * @param {Rectangle} frame - The new frame rectangle.
    * @throws {Error} If the operation fails.
    */
-  setFrame(frame: Rectangle) {
+  public setFrame(frame: Rectangle) {
     this.noFrame = false;
     this.frame = frame;
     this.width = frame.width;
@@ -163,10 +158,8 @@ export class Texture {
   /**
    * Updates the texture UVs based on the crop frame.
    */
-  _updateUvs() {
-    if (!this._uvs) {
-      this._uvs = new TextureUvs();
-    }
+  public _updateUvs() {
+    this._uvs ??= new TextureUvs();
     const frame = this.crop;
     const tw = this.baseTexture.width;
     const th = this.baseTexture.height;

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

@@ -23,6 +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) => {
-  return new Texture(baseTextureFromCanvas(canvas, scaleMode));
-};
+export const textureFromCanvas = (canvas: HTMLCanvasElement, scaleMode?: any) =>
+  new Texture(baseTextureFromCanvas(canvas, scaleMode));

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

@@ -1,3 +1,4 @@
+import { getRegistry } from '../../core/registry.js';
 /** WebGL context tagged with the per-context id the renderer assigns, used to key shader caches. */
 export type IdentifiedWebGLRenderingContext = WebGLRenderingContext & { id: number };
 
@@ -21,9 +22,7 @@ export const CONTEXT_LOST_WEBGL = 0x9242;
  * @param {WebGLRenderingContext} gl - The WebGL rendering context.
  * @returns {number} The error code from the WebGL context.
  */
-export const getWebGLContextErrorCode = (gl: WebGLRenderingContext) => {
-  return gl?.getError() ?? 0;
-};
+export const getWebGLContextErrorCode = (gl: WebGLRenderingContext) => gl?.getError() ?? 0;
 
 /**
  * Gets the WebGL context error name from an error code.
@@ -32,22 +31,30 @@ export const getWebGLContextErrorCode = (gl: WebGLRenderingContext) => {
  */
 export const getWebGLContextErrorName = (errorCode: number) => {
   switch (errorCode) {
-    case NO_ERROR:
+    case NO_ERROR: {
       return 'NO_ERROR';
-    case INVALID_ENUM:
+    }
+    case INVALID_ENUM: {
       return 'INVALID_ENUM';
-    case INVALID_VALUE:
+    }
+    case INVALID_VALUE: {
       return 'INVALID_VALUE';
-    case INVALID_OPERATION:
+    }
+    case INVALID_OPERATION: {
       return 'INVALID_OPERATION';
-    case INVALID_FRAMEBUFFER_OPERATION:
+    }
+    case INVALID_FRAMEBUFFER_OPERATION: {
       return 'INVALID_FRAMEBUFFER_OPERATION';
-    case OUT_OF_MEMORY:
+    }
+    case OUT_OF_MEMORY: {
       return 'OUT_OF_MEMORY';
-    case CONTEXT_LOST_WEBGL:
+    }
+    case CONTEXT_LOST_WEBGL: {
       return 'CONTEXT_LOST_WEBGL';
-    default:
+    }
+    default: {
       return `UNKNOWN_ERROR_${errorCode}`;
+    }
   }
 };
 
@@ -72,10 +79,8 @@ export const compileShader = (gl: WebGLRenderingContext, shaderSrc: string[] | s
   gl.shaderSource(shader, src);
   gl.compileShader(shader);
   if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    if (!window.PhaserRegistry) {
-      window.PhaserRegistry = {};
-    }
-    window.PhaserRegistry.GL_SHADER_INFO_LOG = gl.getShaderInfoLog(shader);
+    getRegistry();
+    globalThis.PhaserRegistry.GL_SHADER_INFO_LOG = gl.getShaderInfoLog(shader);
     return null;
   }
   return shader;
@@ -87,9 +92,8 @@ export const compileShader = (gl: WebGLRenderingContext, shaderSrc: string[] | s
  * @param {string[]|string} shaderSrc - The vertex shader source code.
  * @returns {WebGLShader} The compiled WebGL vertex shader or null if compilation failed.
  */
-export const compileVertexShader = (gl: WebGLRenderingContext, shaderSrc: string[] | string) => {
-  return compileShader(gl, shaderSrc, gl.VERTEX_SHADER);
-};
+export const compileVertexShader = (gl: WebGLRenderingContext, shaderSrc: string[] | string) =>
+  compileShader(gl, shaderSrc, gl.VERTEX_SHADER);
 
 /**
  * Compiles a WebGL fragment shader.
@@ -97,9 +101,8 @@ export const compileVertexShader = (gl: WebGLRenderingContext, shaderSrc: string
  * @param {string[]|string} shaderSrc - The fragment shader source code.
  * @returns {WebGLShader} The compiled WebGL fragment shader or null if compilation failed.
  */
-export const compileFragmentShader = (gl: WebGLRenderingContext, shaderSrc: string[] | string) => {
-  return compileShader(gl, shaderSrc, gl.FRAGMENT_SHADER);
-};
+export const compileFragmentShader = (gl: WebGLRenderingContext, shaderSrc: string[] | string) =>
+  compileShader(gl, shaderSrc, gl.FRAGMENT_SHADER);
 
 /**
  * Compiles a WebGL shader program.
@@ -126,10 +129,8 @@ export const compileProgram = (
   gl.linkProgram(shaderProgram);
 
   if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
-    if (!window.PhaserRegistry) {
-      window.PhaserRegistry = {};
-    }
-    window.PhaserRegistry.GL_PROGRAM_INFO_LOG = gl.getProgramInfoLog(shaderProgram);
+    getRegistry();
+    globalThis.PhaserRegistry.GL_PROGRAM_INFO_LOG = gl.getProgramInfoLog(shaderProgram);
   }
   return shaderProgram;
 };

package/src/phaser/geom/circle.test.ts

@@ -1,4 +1,4 @@
-import { expect } from 'vitest';
+import { expect, describe, it } from 'vitest';
 import { Circle } from './circle.js';
 import { Point } from './point.js';
 
@@ -121,7 +121,7 @@ describe('Circle', () => {
     it('should return Infinity when diameter is 0', () => {
       const circle = new Circle();
       circle.diameter = 0;
-      expect(circle.distance(new Point(1, 1))).toBeCloseTo(1.4142);
+      expect(circle.distance(new Point(1, 1))).toBeCloseTo(Math.SQRT2);
     });
   });
 
@@ -152,7 +152,6 @@ describe('Circle', () => {
   describe('circumferencePoint', () => {
     it('should generate a point on the circumference correctly', () => {
       const circle = new Circle();
-      const output = new Point();
       expect(circle.circumferencePoint(Math.PI / 2).x).toBeCloseTo(0.5 * circle.radius);
     });