@cesium/engine 25.0.0 → 26.0.0

package/Source/Renderer/createUniformArray.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Cartesian2 from "../Core/Cartesian2.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Cartesian4 from "../Core/Cartesian4.js";
@@ -10,8 +12,11 @@ import Matrix4 from "../Core/Matrix4.js";
 import RuntimeError from "../Core/RuntimeError.js";
 
 /**
+ * @param {WebGL2RenderingContext} gl
+ * @param {WebGLActiveInfo} activeUniform
+ * @param {string} uniformName
+ * @param {WebGLUniformLocation[]} locations
  * @private
- * @constructor
  */
 function createUniformArray(gl, activeUniform, uniformName, locations) {
   switch (activeUniform.type) {
@@ -69,570 +74,678 @@ function createUniformArray(gl, activeUniform, uniformName, locations) {
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayFloat(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayFloat {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayFloat.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (v !== arraybuffer[i]) {
-      arraybuffer[i] = v;
-      changed = true;
+      if (v !== arraybuffer[i]) {
+        arraybuffer[i] = v;
+        changed = true;
+      }
     }
-  }
 
-  if (changed) {
-    this._gl.uniform1fv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform1fv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayFloatVec2(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayFloatVec2 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 2);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 2);
 
-UniformArrayFloatVec2.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+    this._gl = gl;
+    this._location = locations[0];
+  }
+
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Cartesian2.equalsArray(v, arraybuffer, j)) {
-      Cartesian2.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Cartesian2.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian2.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 2;
     }
-    j += 2;
-  }
 
-  if (changed) {
-    this._gl.uniform2fv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform2fv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayFloatVec3(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayFloatVec3 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 3);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 3);
 
-UniformArrayFloatVec3.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
-
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
-
-    if (defined(v.red)) {
-      if (
-        v.red !== arraybuffer[j] ||
-        v.green !== arraybuffer[j + 1] ||
-        v.blue !== arraybuffer[j + 2]
-      ) {
-        arraybuffer[j] = v.red;
-        arraybuffer[j + 1] = v.green;
-        arraybuffer[j + 2] = v.blue;
-        changed = true;
-      }
-    } else if (defined(v.x)) {
-      if (!Cartesian3.equalsArray(v, arraybuffer, j)) {
-        Cartesian3.pack(v, arraybuffer, j);
-        changed = true;
+    this._gl = gl;
+    this._location = locations[0];
+  }
+
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
+
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
+
+      if (defined(v.red)) {
+        if (
+          v.red !== arraybuffer[j] ||
+          v.green !== arraybuffer[j + 1] ||
+          v.blue !== arraybuffer[j + 2]
+        ) {
+          arraybuffer[j] = v.red;
+          arraybuffer[j + 1] = v.green;
+          arraybuffer[j + 2] = v.blue;
+          changed = true;
+        }
+      } else if (defined(v.x)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        if (!Cartesian3.equalsArray(v, arraybuffer, j)) {
+          // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+          Cartesian3.pack(v, arraybuffer, j);
+          changed = true;
+        }
+      } else {
+        //>>includeStart('debug', pragmas.debug);
+        throw new DeveloperError("Invalid vec3 value.");
+        //>>includeEnd('debug');
       }
-    } else {
-      //>>includeStart('debug', pragmas.debug);
-      throw new DeveloperError("Invalid vec3 value.");
-      //>>includeEnd('debug');
-    }
 
-    j += 3;
-  }
+      j += 3;
+    }
 
-  if (changed) {
-    this._gl.uniform3fv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform3fv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayFloatVec4(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayFloatVec4 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 4);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 4);
 
-UniformArrayFloatVec4.prototype.set = function () {
-  // PERFORMANCE_IDEA: if it is a common case that only a few elements
-  // in a uniform array change, we could use heuristics to determine
-  // when it is better to call uniform4f for each element that changed
-  // vs. call uniform4fv once to set the entire array.  This applies
-  // to all uniform array types, not just vec4.  We might not care
-  // once we have uniform buffers since that will be the fast path.
-
-  // PERFORMANCE_IDEA: Micro-optimization (I bet it works though):
-  // As soon as changed is true, break into a separate loop that
-  // does the copy without the equals check.
-
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
-
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
-
-    if (defined(v.red)) {
-      if (!Color.equalsArray(v, arraybuffer, j)) {
-        Color.pack(v, arraybuffer, j);
-        changed = true;
-      }
-    } else if (defined(v.x)) {
-      if (!Cartesian4.equalsArray(v, arraybuffer, j)) {
-        Cartesian4.pack(v, arraybuffer, j);
-        changed = true;
+    this._gl = gl;
+    this._location = locations[0];
+  }
+
+  set() {
+    // PERFORMANCE_IDEA: if it is a common case that only a few elements
+    // in a uniform array change, we could use heuristics to determine
+    // when it is better to call uniform4f for each element that changed
+    // vs. call uniform4fv once to set the entire array.  This applies
+    // to all uniform array types, not just vec4.  We might not care
+    // once we have uniform buffers since that will be the fast path.
+
+    // PERFORMANCE_IDEA: Micro-optimization (I bet it works though):
+    // As soon as changed is true, break into a separate loop that
+    // does the copy without the equals check.
+
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
+
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
+
+      if (defined(v.red)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        if (!Color.equalsArray(v, arraybuffer, j)) {
+          Color.pack(v, arraybuffer, j);
+          changed = true;
+        }
+      } else if (defined(v.x)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        if (!Cartesian4.equalsArray(v, arraybuffer, j)) {
+          // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+          Cartesian4.pack(v, arraybuffer, j);
+          changed = true;
+        }
+      } else {
+        //>>includeStart('debug', pragmas.debug);
+        throw new DeveloperError("Invalid vec4 value.");
+        //>>includeEnd('debug');
       }
-    } else {
-      //>>includeStart('debug', pragmas.debug);
-      throw new DeveloperError("Invalid vec4 value.");
-      //>>includeEnd('debug');
-    }
 
-    j += 4;
-  }
+      j += 4;
+    }
 
-  if (changed) {
-    this._gl.uniform4fv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform4fv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArraySampler(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArraySampler {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._locations = locations;
+    this.value = new Array(length);
+    this._value = new Float32Array(length);
 
-  this.textureUnitIndex = undefined;
-}
-
-UniformArraySampler.prototype.set = function () {
-  const gl = this._gl;
-  const textureUnitIndex = gl.TEXTURE0 + this.textureUnitIndex;
+    this._gl = gl;
+    this._locations = locations;
 
-  const value = this.value;
-  const length = value.length;
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
-    gl.activeTexture(textureUnitIndex + i);
-    gl.bindTexture(v._target, v._texture);
+    this.textureUnitIndex = undefined;
   }
-};
 
-UniformArraySampler.prototype._setSampler = function (textureUnitIndex) {
-  this.textureUnitIndex = textureUnitIndex;
+  set() {
+    const gl = this._gl;
+    const textureUnitIndex = gl.TEXTURE0 + this.textureUnitIndex;
 
-  const locations = this._locations;
-  const length = locations.length;
-  for (let i = 0; i < length; ++i) {
-    const index = textureUnitIndex + i;
-    this._gl.uniform1i(locations[i], index);
+    const value = this.value;
+    const length = value.length;
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
+      gl.activeTexture(textureUnitIndex + i);
+      gl.bindTexture(v._target, v._texture);
+    }
   }
 
-  return textureUnitIndex + length;
-};
+  /**
+   * @param {number} textureUnitIndex
+   * @returns {number}
+   */
+  _setSampler(textureUnitIndex) {
+    this.textureUnitIndex = textureUnitIndex;
+
+    const locations = this._locations;
+    const length = locations.length;
+    for (let i = 0; i < length; ++i) {
+      const index = textureUnitIndex + i;
+      this._gl.uniform1i(locations[i], index);
+    }
+
+    return textureUnitIndex + length;
+  }
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayInt(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayInt {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Int32Array(length);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Int32Array(length);
 
-UniformArrayInt.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
 
-    if (v !== arraybuffer[i]) {
-      arraybuffer[i] = v;
-      changed = true;
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
+
+      if (v !== arraybuffer[i]) {
+        arraybuffer[i] = v;
+        changed = true;
+      }
     }
-  }
 
-  if (changed) {
-    this._gl.uniform1iv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform1iv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayIntVec2(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayIntVec2 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Int32Array(length * 2);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Int32Array(length * 2);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayIntVec2.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Cartesian2.equalsArray(v, arraybuffer, j)) {
-      Cartesian2.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Cartesian2.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian2.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 2;
     }
-    j += 2;
-  }
 
-  if (changed) {
-    this._gl.uniform2iv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform2iv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayIntVec3(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayIntVec3 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Int32Array(length * 3);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Int32Array(length * 3);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayIntVec3.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Cartesian3.equalsArray(v, arraybuffer, j)) {
-      Cartesian3.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Cartesian3.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian3.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 3;
     }
-    j += 3;
-  }
 
-  if (changed) {
-    this._gl.uniform3iv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform3iv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayIntVec4(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayIntVec4 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Int32Array(length * 4);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Int32Array(length * 4);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayIntVec4.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Cartesian4.equalsArray(v, arraybuffer, j)) {
-      Cartesian4.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Cartesian4.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian4.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 4;
     }
-    j += 4;
-  }
 
-  if (changed) {
-    this._gl.uniform4iv(this._location, arraybuffer);
+    if (changed) {
+      this._gl.uniform4iv(this._location, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayMat2(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayMat2 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 4);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 4);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayMat2.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Matrix2.equalsArray(v, arraybuffer, j)) {
-      Matrix2.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Matrix2.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Matrix2.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 4;
     }
-    j += 4;
-  }
 
-  if (changed) {
-    this._gl.uniformMatrix2fv(this._location, false, arraybuffer);
+    if (changed) {
+      this._gl.uniformMatrix2fv(this._location, false, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayMat3(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayMat3 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 9);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 9);
+
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-UniformArrayMat3.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
 
-    if (!Matrix3.equalsArray(v, arraybuffer, j)) {
-      Matrix3.pack(v, arraybuffer, j);
-      changed = true;
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Matrix3.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Matrix3.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 9;
     }
-    j += 9;
-  }
 
-  if (changed) {
-    this._gl.uniformMatrix3fv(this._location, false, arraybuffer);
+    if (changed) {
+      this._gl.uniformMatrix3fv(this._location, false, arraybuffer);
+    }
   }
-};
+}
 
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * @private
- * @constructor
  */
-function UniformArrayMat4(gl, activeUniform, uniformName, locations) {
-  const length = locations.length;
-
+class UniformArrayMat4 {
   /**
-   * @type {string}
-   * @readonly
+   * @param {WebGL2RenderingContext} gl
+   * @param {WebGLActiveInfo} activeUniform
+   * @param {string} uniformName
+   * @param {WebGLUniformLocation[]} locations
    */
-  this.name = uniformName;
+  constructor(gl, activeUniform, uniformName, locations) {
+    const length = locations.length;
 
-  this.value = new Array(length);
-  this._value = new Float32Array(length * 16);
+    /**
+     * @type {string}
+     * @readonly
+     */
+    this.name = uniformName;
 
-  this._gl = gl;
-  this._location = locations[0];
-}
+    this.value = new Array(length);
+    this._value = new Float32Array(length * 16);
 
-UniformArrayMat4.prototype.set = function () {
-  const value = this.value;
-  const length = value.length;
-  const arraybuffer = this._value;
-  let changed = false;
-  let j = 0;
+    this._gl = gl;
+    this._location = locations[0];
+  }
 
-  for (let i = 0; i < length; ++i) {
-    const v = value[i];
+  set() {
+    const value = this.value;
+    const length = value.length;
+    const arraybuffer = this._value;
+    let changed = false;
+    let j = 0;
 
-    if (!Matrix4.equalsArray(v, arraybuffer, j)) {
-      Matrix4.pack(v, arraybuffer, j);
-      changed = true;
+    for (let i = 0; i < length; ++i) {
+      const v = value[i];
+
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      if (!Matrix4.equalsArray(v, arraybuffer, j)) {
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Matrix4.pack(v, arraybuffer, j);
+        changed = true;
+      }
+      j += 16;
     }
-    j += 16;
-  }
 
-  if (changed) {
-    this._gl.uniformMatrix4fv(this._location, false, arraybuffer);
+    if (changed) {
+      this._gl.uniformMatrix4fv(this._location, false, arraybuffer);
+    }
   }
-};
+}
+
 export default createUniformArray;