@vpmedia/phaser 1.113.0 → 1.115.0

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

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+import { triangulate } from './earcut.js';
+
+/** Signed area of the polygon a triangulation covers, used to check it tiles the input. */
+const triangleArea = (data: number[], a: number, b: number, c: number): number => {
+  const ax = data[a * 2]!;
+  const ay = data[a * 2 + 1]!;
+  const bx = data[b * 2]!;
+  const by = data[b * 2 + 1]!;
+  const cx = data[c * 2]!;
+  const cy = data[c * 2 + 1]!;
+  return Math.abs((ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) / 2);
+};
+
+const coveredArea = (data: number[], triangles: number[]): number => {
+  let total = 0;
+  for (let i = 0; i < triangles.length; i += 3) {
+    total += triangleArea(data, triangles[i]!, triangles[i + 1]!, triangles[i + 2]!);
+  }
+  return total;
+};
+
+const SQUARE = [0, 0, 10, 0, 10, 10, 0, 10];
+const TRIANGLE = [0, 0, 10, 0, 0, 10];
+const L_SHAPE = [0, 0, 20, 0, 20, 10, 10, 10, 10, 20, 0, 20];
+const CONCAVE = [0, 0, 20, 0, 20, 20, 10, 10, 0, 20];
+const SQUARE_WITH_HOLE = [
+  // outer ring
+  0, 0, 30, 0, 30, 30, 0, 30,
+  // hole
+  10, 10, 20, 10, 20, 20, 10, 20,
+];
+
+describe('earcut triangulate', () => {
+  describe('simple polygons', () => {
+    it('cuts a square into two triangles', () => {
+      const triangles = triangulate(SQUARE, null, 2);
+      expect(triangles).toHaveLength(6);
+      expect(coveredArea(SQUARE, triangles)).toBeCloseTo(100, 6);
+    });
+
+    it('leaves a triangle as one triangle', () => {
+      const triangles = triangulate(TRIANGLE, null, 2);
+      expect(triangles).toHaveLength(3);
+      expect(coveredArea(TRIANGLE, triangles)).toBeCloseTo(50, 6);
+    });
+
+    it('covers an L shape exactly', () => {
+      const triangles = triangulate(L_SHAPE, null, 2);
+      expect(triangles).toHaveLength(12);
+      expect(coveredArea(L_SHAPE, triangles)).toBeCloseTo(300, 6);
+    });
+
+    it('covers a concave polygon exactly', () => {
+      const triangles = triangulate(CONCAVE, null, 2);
+      expect(coveredArea(CONCAVE, triangles)).toBeCloseTo(300, 6);
+    });
+
+    it('emits indices in range and in whole triangles', () => {
+      const triangles = triangulate(L_SHAPE, null, 2);
+      expect(triangles.length % 3).toBe(0);
+      for (const index of triangles) {
+        expect(index).toBeGreaterThanOrEqual(0);
+        expect(index).toBeLessThan(L_SHAPE.length / 2);
+      }
+    });
+  });
+
+  describe('polygons with holes', () => {
+    it('covers the outer ring minus the hole', () => {
+      const triangles = triangulate(SQUARE_WITH_HOLE, [4], 2);
+      expect(coveredArea(SQUARE_WITH_HOLE, triangles)).toBeCloseTo(900 - 100, 6);
+    });
+
+    it('emits whole triangles', () => {
+      const triangles = triangulate(SQUARE_WITH_HOLE, [4], 2);
+      expect(triangles.length % 3).toBe(0);
+      expect(triangles.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('winding order', () => {
+    it('gives the same coverage whichever way the ring is wound', () => {
+      const clockwise = [0, 0, 0, 10, 10, 10, 10, 0];
+      const counter = [0, 0, 10, 0, 10, 10, 0, 10];
+      expect(coveredArea(clockwise, triangulate(clockwise, null, 2))).toBeCloseTo(
+        coveredArea(counter, triangulate(counter, null, 2)),
+        6
+      );
+    });
+  });
+
+  describe('degenerate input', () => {
+    it('returns nothing for an empty ring', () => {
+      expect(triangulate([], null, 2)).toStrictEqual([]);
+    });
+
+    it('returns nothing for a single point', () => {
+      expect(triangulate([1, 1], null, 2)).toStrictEqual([]);
+    });
+
+    it('returns nothing for a two point ring', () => {
+      expect(triangulate([0, 0, 10, 10], null, 2)).toStrictEqual([]);
+    });
+
+    it('returns nothing for a zero area ring', () => {
+      expect(triangulate([0, 0, 10, 10, 20, 20], null, 2)).toStrictEqual([]);
+    });
+
+    it('drops duplicated consecutive points', () => {
+      const withDuplicate = [0, 0, 0, 0, 10, 0, 10, 10, 0, 10];
+      expect(coveredArea(withDuplicate, triangulate(withDuplicate, null, 2))).toBeCloseTo(100, 6);
+    });
+  });
+
+  describe('large rings', () => {
+    // Past 80 vertices earcut switches to the z-order curve hash, a separate code path.
+    it('covers a many sided polygon exactly, exercising the hashed path', () => {
+      const sides = 200;
+      const radius = 100;
+      const ring: number[] = [];
+      for (let i = 0; i < sides; i += 1) {
+        const angle = (i / sides) * Math.PI * 2;
+        ring.push(Math.cos(angle) * radius, Math.sin(angle) * radius);
+      }
+      const triangles = triangulate(ring, null, 2);
+      expect(triangles).toHaveLength((sides - 2) * 3);
+      const expected = 0.5 * sides * radius * radius * Math.sin((2 * Math.PI) / sides);
+      expect(coveredArea(ring, triangles)).toBeCloseTo(expected, 3);
+    });
+  });
+});

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

@@ -5,49 +5,51 @@ import { Node } from './earcut_node.js';
  * @param {object} list - The list of points to process.
  * @returns {object} The processed earcut data structure.
  */
-export function sortLinked(list: any) {
-  let i;
-  let p;
-  let q;
-  let e;
-  let tail;
+export function sortLinked(list: Node | null): Node | null {
   let numMerges;
-  let pSize;
-  let qSize;
   let inSize = 1;
   do {
-    p = list;
+    let p: Node | null = list;
+    let tail: Node | null = null;
     list = null;
-    tail = null;
     numMerges = 0;
     while (p) {
       numMerges += 1;
-      q = p;
-      pSize = 0;
-      for (i = 0; i < inSize; i += 1) {
+      let q: Node | null = p;
+      let pSize = 0;
+      for (let i = 0; i < inSize; i += 1) {
         pSize += 1;
         q = q.nextZ;
         if (!q) {
           break;
         }
       }
-      qSize = inSize;
+      let qSize = inSize;
       while (pSize > 0 || (qSize > 0 && q)) {
+        let e: Node;
+        // The run counters keep p and q in step with the loop condition; the guards below cannot
+        // fire, they only spell that invariant out for the type checker.
         if (pSize === 0) {
+          if (!q) {
+            break;
+          }
           e = q;
-          q = q.nextZ;
+          q = e.nextZ;
           qSize -= 1;
         } else if (qSize === 0 || !q) {
+          if (!p) {
+            break;
+          }
           e = p;
-          p = p.nextZ;
+          p = e.nextZ;
           pSize -= 1;
-        } else if (p.z <= q.z) {
+        } else if (p && (p.z ?? 0) <= (q.z ?? 0)) {
           e = p;
-          p = p.nextZ;
+          p = e.nextZ;
           pSize -= 1;
         } else {
           e = q;
-          q = q.nextZ;
+          q = e.nextZ;
           qSize -= 1;
         }
         if (tail) {
@@ -60,7 +62,9 @@ export function sortLinked(list: any) {
       }
       p = q;
     }
-    tail.nextZ = null;
+    if (tail) {
+      tail.nextZ = null;
+    }
     inSize *= 2;
   } while (numMerges > 1);
   return list;
@@ -72,7 +76,7 @@ export function sortLinked(list: any) {
  * @param {object} b - The second point of the triangle.
  * @returns {number} The calculated area of the triangle.
  */
-export function compareX(a: any, b: any) {
+export function compareX(a: Node, b: Node): number {
   return a.x - b.x;
 }
 
@@ -107,17 +111,15 @@ export function zOrder(x: number, y: number, minX: number, minY: number, size: n
  * @param {number} minY - The minimum y-coordinate of the bounding box.
  * @param {number} size - The size of the bounding box.
  */
-export function indexCurve(start: any, minX = 0, minY = 0, size = 0) {
+export function indexCurve(start: Node, minX = 0, minY = 0, size = 0): void {
   let p = start;
   do {
-    if (p.z === null) {
-      p.z = zOrder(p.x, p.y, minX, minY, size);
-    }
+    p.z ??= zOrder(p.x, p.y, minX, minY, size);
     p.prevZ = p.prev;
     p.nextZ = p.next;
     p = p.next;
   } while (p !== start);
-  p.prevZ.nextZ = null;
+  p.prevZ!.nextZ = null;
   p.prevZ = null;
   sortLinked(p);
 }
@@ -127,7 +129,7 @@ export function indexCurve(start: any, minX = 0, minY = 0, size = 0) {
  * @param {object} start - TBD.
  * @returns {object} The calculated point that is the closest to the triangle edge.
  */
-export function getLeftmost(start: any) {
+export function getLeftmost(start: Node): Node {
   let p = start;
   let leftmost = start;
   do {
@@ -175,7 +177,7 @@ export function pointInTriangle(
  * @param {object} r - TBD.
  * @returns {number} TBD.
  */
-export function area(p: any, q: any, r: any) {
+export function area(p: Node, q: Node, r: Node): number {
   return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
 }
 
@@ -185,7 +187,7 @@ export function area(p: any, q: any, r: any) {
  * @param {object} p2 - The second point of the triangle.
  * @returns {boolean} True if the point is inside the triangle, false otherwise.
  */
-export function equals(p1: any, p2: any) {
+export function equals(p1: Node, p2: Node): boolean {
   return p1.x === p2.x && p1.y === p2.y;
 }
 
@@ -197,7 +199,7 @@ export function equals(p1: any, p2: any) {
  * @param {object} q2 - The second point of the second line segment.
  * @returns {boolean} True if the line segments intersect, false otherwise.
  */
-export function intersects(p1: any, q1: any, p2: any, q2: any) {
+export function intersects(p1: Node, q1: Node, p2: Node, q2: Node): boolean {
   return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 && area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;
 }
 
@@ -207,7 +209,7 @@ export function intersects(p1: any, q1: any, p2: any, q2: any) {
  * @param {object} b - The second point of the line segment.
  * @returns {boolean} True if the points are collinear, false otherwise.
  */
-export function intersectsPolygon(a: any, b: any) {
+export function intersectsPolygon(a: Node, b: Node): boolean {
   let p = a;
   do {
     if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) {
@@ -224,7 +226,7 @@ export function intersectsPolygon(a: any, b: any) {
  * @param {object} b - The second point of the cross product.
  * @returns {object} The calculated cross product result.
  */
-export function locallyInside(a: any, b: any) {
+export function locallyInside(a: Node, b: Node): boolean {
   return area(a.prev, a, a.next) < 0
     ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0
     : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
@@ -236,7 +238,7 @@ export function locallyInside(a: any, b: any) {
  * @param {object} b - The second point of the triangle.
  * @returns {boolean} True if the point is inside the triangle, false otherwise.
  */
-export function middleInside(a: any, b: any) {
+export function middleInside(a: Node, b: Node): boolean {
   let p = a;
   let inside = false;
   const px = (a.x + b.x) / 2;
@@ -256,7 +258,7 @@ export function middleInside(a: any, b: any) {
  * @param {object} b - The second point of the triangle.
  * @returns {boolean} True if the point is inside the triangle, false otherwise.
  */
-export function isValidDiagonal(a: any, b: any) {
+export function isValidDiagonal(a: Node, b: Node): boolean {
   return (
     equals(a, b) ||
     (a.next.i !== b.i &&
@@ -274,7 +276,7 @@ export function isValidDiagonal(a: any, b: any) {
  * @param {object} b - TBD.
  * @returns {object} TBD.
  */
-export function splitPolygon(a: any, b: any) {
+export function splitPolygon(a: Node, b: Node): Node {
   const a2 = new Node(a.i, a.x, a.y);
   const b2 = new Node(b.i, b.x, b.y);
   const an = a.next;
@@ -298,7 +300,7 @@ export function splitPolygon(a: any, b: any) {
  * @param {object} last - TBD.
  * @returns {object} TBD.
  */
-export function insertNode(i: number, x: number, y: number, last: any) {
+export function insertNode(i: number, x: number, y: number, last: Node | null): Node {
   const p = new Node(i, x, y);
   if (!last) {
     p.prev = p;
@@ -316,7 +318,7 @@ export function insertNode(i: number, x: number, y: number, last: any) {
  * TBD.
  * @param {object} p - TBD.
  */
-export function removeNode(p: any) {
+export function removeNode(p: Node): void {
   p.next.prev = p.prev;
   p.prev.next = p.next;
   if (p.prevZ) {
@@ -332,7 +334,7 @@ export function removeNode(p: any) {
  * @param {object} ear - TBD.
  * @returns {boolean} TBD.
  */
-export function isEar(ear: any) {
+export function isEar(ear: Node): boolean {
   const a = ear.prev;
   const b = ear;
   const c = ear.next;
@@ -358,7 +360,7 @@ export function isEar(ear: any) {
  * @param {number} size - TBD.
  * @returns {boolean} TBD.
  */
-export function isEarHashed(ear: any, minX = 0, minY = 0, size = 0) {
+export function isEarHashed(ear: Node, minX = 0, minY = 0, size = 0): boolean {
   const a = ear.prev;
   const b = ear;
   const c = ear.next;
@@ -375,7 +377,7 @@ export function isEarHashed(ear: any, minX = 0, minY = 0, size = 0) {
   const maxZ = zOrder(maxTX, maxTY, minX, minY, size);
   // first look for points inside the triangle in increasing z-order
   let p = ear.nextZ;
-  while (p && p.z <= maxZ) {
+  while (p && p.z! <= maxZ) {
     if (
       p !== ear.prev &&
       p !== ear.next &&
@@ -388,7 +390,7 @@ export function isEarHashed(ear: any, minX = 0, minY = 0, size = 0) {
   }
   // then look for points in decreasing z-order
   p = ear.prevZ;
-  while (p && p.z >= minZ) {
+  while (p && p.z! >= minZ) {
     if (
       p !== ear.prev &&
       p !== ear.next &&
@@ -411,24 +413,24 @@ export function isEarHashed(ear: any, minX = 0, minY = 0, size = 0) {
  * @param {boolean} clockwise - Whether the triangles should be clockwise or counterclockwise.
  * @returns {object} The processed earcut data structure with triangulation information.
  */
-export function linkedList(data: any, start: number, end: number, dim: number, clockwise: boolean) {
+export function linkedList(data: number[], start: number, end: number, dim: number, clockwise: boolean): Node | null {
   let sum = 0;
   let i;
   let j;
-  let last;
+  let last: Node | null = null;
   // calculate original winding order of a polygon ring
   for (i = start, j = end - dim; i < end; i += dim) {
-    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    sum += (data[j]! - data[i]!) * (data[i + 1]! + data[j + 1]!);
     j = i;
   }
   // link points into circular doubly-linked list in the specified winding order
   if (clockwise === sum > 0) {
     for (i = start; i < end; i += dim) {
-      last = insertNode(i, data[i], data[i + 1], last);
+      last = insertNode(i, data[i]!, data[i + 1]!, last ?? null);
     }
   } else {
     for (i = end - dim; i >= start; i -= dim) {
-      last = insertNode(i, data[i], data[i + 1], last);
+      last = insertNode(i, data[i]!, data[i + 1]!, last ?? null);
     }
   }
   return last;
@@ -440,7 +442,7 @@ export function linkedList(data: any, start: number, end: number, dim: number, c
  * @param {object} end - The ending point in the data structure.
  * @returns {object} The calculated bounding box with min and max coordinates.
  */
-export function filterPoints(start: any, end?: any) {
+export function filterPoints(start: Node | null, end?: Node | null): Node | null {
   if (!start) {
     return start;
   }
@@ -470,7 +472,7 @@ export function filterPoints(start: any, end?: any) {
  * @param {object} outerNode - The outer node that contains the hole.
  * @returns {object} The processed hole data structure.
  */
-export function findHoleBridge(hole: any, outerNode: any) {
+export function findHoleBridge(hole: Node, outerNode: Node): Node | null {
   let p = outerNode;
   const hx = hole.x;
   const hy = hole.y;
@@ -523,10 +525,10 @@ export function findHoleBridge(hole: any, outerNode: any) {
  * @param {object} hole - The hole to process.
  * @param {object} outerNode - The outer node that contains the hole.
  */
-export function eliminateHole(hole: any, outerNode: any) {
-  outerNode = findHoleBridge(hole, outerNode);
-  if (outerNode) {
-    const b = splitPolygon(outerNode, hole);
+export function eliminateHole(hole: Node, outerNode: Node): void {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (bridge) {
+    const b = splitPolygon(bridge, hole);
     filterPoints(b, b.next);
   }
 }
@@ -539,7 +541,12 @@ export function eliminateHole(hole: any, outerNode: any) {
  * @param {object} dim - The dimension of the data (2 or 3).
  * @returns {object} The processed earcut data structure with holes included.
  */
-export function eliminateHoles(data: any, holeIndices: any, outerNode: any, dim: any) {
+export function eliminateHoles(
+  data: number[],
+  holeIndices: number[],
+  outerNode: Node | null,
+  dim: number
+): Node | null {
   const queue = [];
   let i;
   let len;
@@ -547,8 +554,8 @@ export function eliminateHoles(data: any, holeIndices: any, outerNode: any, dim:
   let end;
   let list;
   for (i = 0, len = holeIndices.length; i < len; i += 1) {
-    start = holeIndices[i] * dim;
-    end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    start = holeIndices[i]! * dim;
+    end = i < len - 1 ? holeIndices[i + 1]! * dim : data.length;
     list = linkedList(data, start, end, dim, false);
     if (!list) {
       continue;
@@ -561,7 +568,10 @@ export function eliminateHoles(data: any, holeIndices: any, outerNode: any, dim:
   queue.sort(compareX);
   // process holes from left to right
   for (i = 0; i < queue.length; i += 1) {
-    eliminateHole(queue[i], outerNode);
+    if (!outerNode) {
+      return outerNode;
+    }
+    eliminateHole(queue[i]!, outerNode);
     outerNode = filterPoints(outerNode, outerNode.next);
   }
   return outerNode;
@@ -574,7 +584,7 @@ export function eliminateHoles(data: any, holeIndices: any, outerNode: any, dim:
  * @param {number} dim - The dimension of the data (2 or 3).
  * @returns {object} The processed triangulation data structure.
  */
-export function cureLocalIntersections(start: any, triangles: any, dim: number) {
+export function cureLocalIntersections(start: Node, triangles: number[], dim: number): Node {
   let p = start;
   do {
     const a = p.prev;
@@ -604,7 +614,7 @@ export function cureLocalIntersections(start: any, triangles: any, dim: number)
  * @param {number} minY - The minimum y-coordinate of the bounding box.
  * @param {number} size - The size of the bounding box.
  */
-export function splitEarcut(start: any, triangles: any, dim: number, minX = 0, minY = 0, size = 0) {
+export function splitEarcut(start: Node, triangles: number[], dim: number, minX = 0, minY = 0, size = 0): void {
   // look for a valid diagonal that divides the polygon into two
   let a = start;
   do {
@@ -612,13 +622,13 @@ export function splitEarcut(start: any, triangles: any, dim: number, minX = 0, m
     while (b !== a.prev) {
       if (a.i !== b.i && isValidDiagonal(a, b)) {
         // split the polygon in two by the diagonal
-        let c = splitPolygon(a, b);
+        const c = splitPolygon(a, b);
         // filter colinear points around the cuts
-        a = filterPoints(a, a.next);
-        c = filterPoints(c, c.next);
+        const halfA = filterPoints(a, a.next);
+        const halfC = filterPoints(c, c.next);
         // run earcut on each half
-        earcutLinked(a, triangles, dim, minX, minY, size);
-        earcutLinked(c, triangles, dim, minX, minY, size);
+        earcutLinked(halfA, triangles, dim, minX, minY, size);
+        earcutLinked(halfC, triangles, dim, minX, minY, size);
         return;
       }
       b = b.next;
@@ -638,13 +648,13 @@ export function splitEarcut(start: any, triangles: any, dim: number, minX = 0, m
  * @param {object} pass - The pass information for triangulation.
  */
 export function earcutLinked(
-  ear: any,
-  triangles: any,
+  ear: Node | null,
+  triangles: number[],
   dim: number,
   minX?: number,
   minY?: number,
   size?: number,
-  pass?: any
+  pass?: number
 ) {
   if (!ear) {
     return;
@@ -697,9 +707,9 @@ export function earcutLinked(
  * @param {number} dim - The dimension of the data (2 or 3).
  * @returns {object} The processed earcut data structure with triangulation information.
  */
-export function triangulate(data: any, holeIndices: any, dim = 2) {
+export function triangulate(data: number[], holeIndices: number[] | null, dim = 2): number[] {
   const hasHoles = holeIndices && holeIndices.length;
-  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  const outerLen = hasHoles ? holeIndices[0]! * dim : data.length;
   let outerNode = linkedList(data, 0, outerLen, dim, true);
   const triangles: number[] = [];
   if (!outerNode) {
@@ -717,13 +727,13 @@ export function triangulate(data: any, holeIndices: any, dim = 2) {
   }
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
   if (data.length > 80 * dim) {
-    minX = data[0];
-    maxX = data[0];
-    minY = data[1];
-    maxY = data[1];
+    minX = data[0]!;
+    maxX = data[0]!;
+    minY = data[1]!;
+    maxY = data[1]!;
     for (let i = dim; i < outerLen; i += dim) {
-      x = data[i];
-      y = data[i + 1];
+      x = data[i]!;
+      y = data[i + 1]!;
       if (x < minX) {
         minX = x;
       }

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

@@ -2,8 +2,8 @@ export class Node {
   public i: number;
   public x: number;
   public y: number;
-  public prev: Node | null;
-  public next: Node | null;
+  public prev: Node;
+  public next: Node;
   public z: number | null;
   public prevZ: Node | null;
   public nextZ: Node | null;
@@ -21,9 +21,9 @@ export class Node {
     // vertex coordinates
     this.x = x;
     this.y = y;
-    // previous and next vertice nodes in a polygon ring
-    this.prev = null;
-    this.next = null;
+    // previous and next vertice nodes in a polygon ring; a lone node is its own ring
+    this.prev = this;
+    this.next = this;
     // z-order curve value
     this.z = null;
     // previous and next nodes in z-order

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

@@ -1,5 +1,6 @@
 import type { IdentifiedWebGLRenderingContext } from './util.js';
 import type { Image } from '../../display/image.js';
+import type { RenderSession } from '../render_session.js';
 
 export class FastSpriteBatch {
   public gl!: any;
@@ -15,7 +16,7 @@ export class FastSpriteBatch {
   public currentBatchSize!: any;
   public currentBaseTexture!: any;
   public currentBlendMode!: any;
-  public renderSession!: any;
+  public renderSession!: RenderSession;
   public shader!: any;
   public matrix!: any;
   /**
@@ -46,7 +47,6 @@ export class FastSpriteBatch {
     this.currentBatchSize = 0;
     this.currentBaseTexture = null;
     this.currentBlendMode = 0;
-    this.renderSession = null;
     this.shader = null;
     this.matrix = null;
     this.setContext(gl);
@@ -74,7 +74,7 @@ export class FastSpriteBatch {
    * @param {object} spriteBatch - The sprite batch to render.
    * @param {object} renderSession - The render session to use.
    */
-  public begin(spriteBatch: any, renderSession: any) {
+  public begin(spriteBatch: any, renderSession: RenderSession) {
     this.renderSession = renderSession;
     this.shader = this.renderSession.shaderManager.fastShader;
     this.matrix = spriteBatch.worldTransform.toArray(true);
@@ -230,7 +230,7 @@ export class FastSpriteBatch {
     const { gl } = this;
     // bind the current texture
     if (!this.currentBaseTexture._glTextures[gl.id]) {
-      this.renderSession.renderer.updateTexture(this.currentBaseTexture, gl);
+      this.renderSession.renderer.updateTexture(this.currentBaseTexture);
     }
     gl.bindTexture(gl.TEXTURE_2D, this.currentBaseTexture._glTextures[gl.id]);
     // upload the verts to the buffer

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

@@ -33,7 +33,7 @@ export class WebGLFilterManager {
   /**
    * Updates the filter texture for the specified size.
    */
-  public pushFilter() {
+  public pushFilter(_filterBlock: object | null) {
     // TODO
   }