@gjsify/webgl 0.3.12 → 0.3.14

package/lib/esm/conformance/uniforms.spec.js

@@ -1,9 +1,11 @@
-import { describe, it, expect, beforeEach, on } from "@gjsify/unit";
 import { makeProgram } from "../test-utils.js";
 import { createGLSetup } from "./setup.js";
+import { beforeEach, describe, expect, it, on } from "@gjsify/unit";
+
+//#region src/ts/conformance/uniforms.spec.ts
 const VS = `attribute vec4 a_position; void main() { gl_Position = a_position; }`;
 function makeFS(body) {
-  return `precision mediump float; ${body}`;
+	return `precision mediump float; ${body}`;
 }
 const FS_FLOAT = makeFS("uniform float u_f; void main() { gl_FragColor = vec4(u_f,0,0,1); }");
 const FS_INT = makeFS("uniform int u_i; void main() { gl_FragColor = vec4(float(u_i),0,0,1); }");
@@ -16,313 +18,467 @@ const FS_MAT3 = makeFS("uniform mat3 u_m3; void main() { gl_FragColor = vec4(u_m
 const FS_MAT4 = makeFS("uniform mat4 u_m4; void main() { gl_FragColor = u_m4[0]; }");
 const FS_ARR = makeFS("uniform float u_arr[3]; void main() { gl_FragColor = vec4(u_arr[0]+u_arr[1]+u_arr[2],0,0,1); }");
 const FS_VEC4ARR = makeFS("uniform vec4 u_v4arr[3]; void main() { gl_FragColor = u_v4arr[0]+u_v4arr[1]+u_v4arr[2]; }");
-function floatArrayClose(a, b, tol = 1e-3) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < b.length; i++) {
-    if (Math.abs(a[i] - b[i]) > tol) return false;
-  }
-  return true;
+function floatArrayClose(a, b, tol = .001) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < b.length; i++) {
+		if (Math.abs(a[i] - b[i]) > tol) return false;
+	}
+	return true;
 }
 var uniforms_spec_default = async () => {
-  await on("Display", async () => {
-    const setup = createGLSetup();
-    if (!setup) {
-      console.warn("WebGL context not available \u2014 skipping conformance/uniforms tests");
-      return;
-    }
-    const { gl, glArea } = setup;
-    glArea.make_current();
-    await describe("conformance/uniforms/null-uniform-location", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("uniform* with null location generates NO_ERROR", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        gl.uniform1f(null, 1);
-        gl.getError();
-        gl.uniform1fv(null, [1]);
-        gl.getError();
-        gl.uniform1i(null, 1);
-        gl.getError();
-        gl.uniform1iv(null, [1]);
-        gl.getError();
-        gl.uniform2f(null, 1, 2);
-        gl.getError();
-        gl.uniform2fv(null, [1, 2]);
-        gl.getError();
-        gl.uniform2i(null, 1, 2);
-        gl.getError();
-        gl.uniform2iv(null, [1, 2]);
-        gl.getError();
-        gl.uniform3f(null, 1, 2, 3);
-        gl.getError();
-        gl.uniform3fv(null, [1, 2, 3]);
-        gl.getError();
-        gl.uniform3i(null, 1, 2, 3);
-        gl.getError();
-        gl.uniform3iv(null, [1, 2, 3]);
-        gl.getError();
-        gl.uniform4f(null, 1, 2, 3, 4);
-        gl.getError();
-        gl.uniform4fv(null, [1, 2, 3, 4]);
-        gl.getError();
-        gl.uniform4i(null, 1, 2, 3, 4);
-        gl.getError();
-        gl.uniform4iv(null, [1, 2, 3, 4]);
-        gl.getError();
-        gl.uniformMatrix2fv(null, false, [1, 0, 0, 1]);
-        gl.getError();
-        gl.uniformMatrix3fv(null, false, [1, 0, 0, 0, 1, 0, 0, 0, 1]);
-        gl.getError();
-        gl.uniformMatrix4fv(null, false, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-        gl.getError();
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-    });
-    await describe("conformance/uniforms/gl-unknown-uniform", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("getUniformLocation for unknown uniform returns null", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "someUnknownUniform");
-        expect(loc).toBeNull();
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("uniform1f with null location (unknown) generates NO_ERROR", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        gl.uniform1f(null, 42);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-    });
-    await describe("conformance/uniforms/gl-uniform-bool", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("setting a bool uniform via uniform1i succeeds", async () => {
-        const prog = makeProgram(gl, VS, FS_BOOL);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_b");
-        expect(loc).not.toBeNull();
-        gl.uniform1i(loc, 1);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-    });
-    await describe("conformance/uniforms/scalar-vector-round-trip", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("uniform1f / getUniform round-trips a float", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_f");
-        gl.uniform1f(loc, 0.5);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(Math.abs(val - 0.5) < 1e-3).toBe(true);
-      });
-      await it("uniform1i / getUniform round-trips an int", async () => {
-        const prog = makeProgram(gl, VS, FS_INT);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_i");
-        gl.uniform1i(loc, 7);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(val).toBe(7);
-      });
-      await it("uniform2fv / getUniform round-trips a vec2", async () => {
-        const prog = makeProgram(gl, VS, FS_VEC2);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_v2");
-        gl.uniform2fv(loc, [0.25, 0.75]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(floatArrayClose(val, [0.25, 0.75])).toBe(true);
-      });
-      await it("uniform3fv / getUniform round-trips a vec3", async () => {
-        const prog = makeProgram(gl, VS, FS_VEC3);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_v3");
-        gl.uniform3fv(loc, [0.1, 0.2, 0.3]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(floatArrayClose(val, [0.1, 0.2, 0.3])).toBe(true);
-      });
-      await it("uniform4fv / getUniform round-trips a vec4", async () => {
-        const prog = makeProgram(gl, VS, FS_VEC4);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_v4");
-        gl.uniform4fv(loc, [0.1, 0.2, 0.3, 0.4]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(floatArrayClose(val, [0.1, 0.2, 0.3, 0.4])).toBe(true);
-      });
-    });
-    await describe("conformance/uniforms/gl-uniformmatrix4fv", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("uniformMatrix2fv with correct size (4 elements) succeeds", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT2);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m2");
-        gl.uniformMatrix2fv(loc, false, [1, 0, 0, 1]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("uniformMatrix2fv with too few elements generates INVALID_VALUE", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT2);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m2");
-        gl.uniformMatrix2fv(loc, false, [1, 0, 0]);
-        expect(gl.getError()).toBe(gl.INVALID_VALUE);
-      });
-      await it("uniformMatrix3fv with correct size (9 elements) succeeds", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT3);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m3");
-        gl.uniformMatrix3fv(loc, false, [1, 0, 0, 0, 1, 0, 0, 0, 1]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("uniformMatrix4fv with correct size (16 elements) succeeds", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT4);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m4");
-        gl.uniformMatrix4fv(loc, false, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("uniformMatrix4fv with transpose=true generates INVALID_VALUE in WebGL1", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT4);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m4");
-        gl.uniformMatrix4fv(loc, true, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-        expect(gl.getError()).toBe(gl.INVALID_VALUE);
-      });
-      await it("uniformMatrix4fv / getUniform round-trips a mat4", async () => {
-        const prog = makeProgram(gl, VS, FS_MAT4);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_m4");
-        const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-        gl.uniformMatrix4fv(loc, false, identity);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(floatArrayClose(val, identity)).toBe(true);
-      });
-    });
-    await describe("conformance/uniforms/gl-uniform-arrays", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("uniform1fv sets a float array and getUniform retrieves element [0]", async () => {
-        const prog = makeProgram(gl, VS, FS_ARR);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_arr[0]");
-        expect(loc).not.toBeNull();
-        gl.uniform1fv(loc, [0.1, 0.2, 0.3]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, loc);
-        expect(Math.abs(val - 0.1) < 1e-3).toBe(true);
-      });
-      await it("uniform1fv with fewer values than array size (partial update) succeeds", async () => {
-        const prog = makeProgram(gl, VS, FS_ARR);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_arr[0]");
-        gl.uniform1fv(loc, [0.5, 0.6]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("uniform4fv sets a vec4 array", async () => {
-        const prog = makeProgram(gl, VS, FS_VEC4ARR);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_v4arr[0]");
-        expect(loc).not.toBeNull();
-        gl.uniform4fv(loc, [
-          0.1,
-          0.2,
-          0.3,
-          0.4,
-          0.5,
-          0.6,
-          0.7,
-          0.8,
-          0.9,
-          1,
-          0,
-          0
-        ]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("getUniformLocation resolves bare array name (without [0] suffix)", async () => {
-        const prog = makeProgram(gl, VS, FS_ARR);
-        gl.useProgram(prog);
-        const locBare = gl.getUniformLocation(prog, "u_arr");
-        expect(locBare).not.toBeNull();
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        gl.uniform1fv(locBare, [0.7, 0.8, 0.9]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, locBare);
-        expect(Math.abs(val - 0.7) < 1e-3).toBe(true);
-      });
-      await it("bare array name and indexed [0] name resolve to equivalent locations", async () => {
-        const prog = makeProgram(gl, VS, FS_ARR);
-        gl.useProgram(prog);
-        const locBare = gl.getUniformLocation(prog, "u_arr");
-        const locIndexed = gl.getUniformLocation(prog, "u_arr[0]");
-        expect(locBare).not.toBeNull();
-        expect(locIndexed).not.toBeNull();
-        gl.uniform1fv(locBare, [0.42, 0.43, 0.44]);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-        const val = gl.getUniform(prog, locIndexed);
-        expect(Math.abs(val - 0.42) < 1e-3).toBe(true);
-      });
-      await it("calling uniform* before useProgram generates INVALID_OPERATION", async () => {
-        const prog = makeProgram(gl, VS, FS_ARR);
-        gl.useProgram(null);
-        const loc = gl.getUniformLocation(prog, "u_arr[0]");
-        if (loc !== null) {
-          gl.uniform1fv(loc, [1, 2, 3]);
-          expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-        } else {
-          expect(gl.getError()).toBe(gl.NO_ERROR);
-        }
-      });
-    });
-    await describe("conformance/uniforms/uniform-location", async () => {
-      beforeEach(async () => {
-        glArea.make_current();
-      });
-      await it("getUniformLocation returns non-null for known uniform", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        const loc = gl.getUniformLocation(prog, "u_f");
-        expect(loc).not.toBeNull();
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-      await it("location from different program generates INVALID_OPERATION", async () => {
-        const prog1 = makeProgram(gl, VS, FS_FLOAT);
-        const prog2 = makeProgram(gl, VS, FS_FLOAT);
-        const loc = gl.getUniformLocation(prog1, "u_f");
-        gl.useProgram(prog2);
-        gl.uniform1f(loc, 1);
-        expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-      });
-      await it("location becomes invalid after relinkProgram", async () => {
-        const prog = makeProgram(gl, VS, FS_FLOAT);
-        gl.useProgram(prog);
-        const locBefore = gl.getUniformLocation(prog, "u_f");
-        expect(locBefore).not.toBeNull();
-        gl.linkProgram(prog);
-        gl.uniform1f(locBefore, 1);
-        expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-        const locAfter = gl.getUniformLocation(prog, "u_f");
-        expect(locAfter).not.toBeNull();
-        gl.uniform1f(locAfter, 1);
-        expect(gl.getError()).toBe(gl.NO_ERROR);
-      });
-    });
-  });
-};
-export {
-  uniforms_spec_default as default
+	await on("Display", async () => {
+		const setup = createGLSetup();
+		if (!setup) {
+			console.warn("WebGL context not available — skipping conformance/uniforms tests");
+			return;
+		}
+		const { gl, glArea } = setup;
+		glArea.make_current();
+		await describe("conformance/uniforms/null-uniform-location", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("uniform* with null location generates NO_ERROR", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				gl.uniform1f(null, 1);
+				gl.getError();
+				gl.uniform1fv(null, [1]);
+				gl.getError();
+				gl.uniform1i(null, 1);
+				gl.getError();
+				gl.uniform1iv(null, [1]);
+				gl.getError();
+				gl.uniform2f(null, 1, 2);
+				gl.getError();
+				gl.uniform2fv(null, [1, 2]);
+				gl.getError();
+				gl.uniform2i(null, 1, 2);
+				gl.getError();
+				gl.uniform2iv(null, [1, 2]);
+				gl.getError();
+				gl.uniform3f(null, 1, 2, 3);
+				gl.getError();
+				gl.uniform3fv(null, [
+					1,
+					2,
+					3
+				]);
+				gl.getError();
+				gl.uniform3i(null, 1, 2, 3);
+				gl.getError();
+				gl.uniform3iv(null, [
+					1,
+					2,
+					3
+				]);
+				gl.getError();
+				gl.uniform4f(null, 1, 2, 3, 4);
+				gl.getError();
+				gl.uniform4fv(null, [
+					1,
+					2,
+					3,
+					4
+				]);
+				gl.getError();
+				gl.uniform4i(null, 1, 2, 3, 4);
+				gl.getError();
+				gl.uniform4iv(null, [
+					1,
+					2,
+					3,
+					4
+				]);
+				gl.getError();
+				gl.uniformMatrix2fv(null, false, [
+					1,
+					0,
+					0,
+					1
+				]);
+				gl.getError();
+				gl.uniformMatrix3fv(null, false, [
+					1,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					1
+				]);
+				gl.getError();
+				gl.uniformMatrix4fv(null, false, [
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1
+				]);
+				gl.getError();
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+		});
+		await describe("conformance/uniforms/gl-unknown-uniform", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("getUniformLocation for unknown uniform returns null", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "someUnknownUniform");
+				expect(loc).toBeNull();
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("uniform1f with null location (unknown) generates NO_ERROR", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				gl.uniform1f(null, 42);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+		});
+		await describe("conformance/uniforms/gl-uniform-bool", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("setting a bool uniform via uniform1i succeeds", async () => {
+				const prog = makeProgram(gl, VS, FS_BOOL);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_b");
+				expect(loc).not.toBeNull();
+				gl.uniform1i(loc, 1);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+		});
+		await describe("conformance/uniforms/scalar-vector-round-trip", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("uniform1f / getUniform round-trips a float", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_f");
+				gl.uniform1f(loc, .5);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(Math.abs(val - .5) < .001).toBe(true);
+			});
+			await it("uniform1i / getUniform round-trips an int", async () => {
+				const prog = makeProgram(gl, VS, FS_INT);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_i");
+				gl.uniform1i(loc, 7);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(val).toBe(7);
+			});
+			await it("uniform2fv / getUniform round-trips a vec2", async () => {
+				const prog = makeProgram(gl, VS, FS_VEC2);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_v2");
+				gl.uniform2fv(loc, [.25, .75]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(floatArrayClose(val, [.25, .75])).toBe(true);
+			});
+			await it("uniform3fv / getUniform round-trips a vec3", async () => {
+				const prog = makeProgram(gl, VS, FS_VEC3);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_v3");
+				gl.uniform3fv(loc, [
+					.1,
+					.2,
+					.3
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(floatArrayClose(val, [
+					.1,
+					.2,
+					.3
+				])).toBe(true);
+			});
+			await it("uniform4fv / getUniform round-trips a vec4", async () => {
+				const prog = makeProgram(gl, VS, FS_VEC4);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_v4");
+				gl.uniform4fv(loc, [
+					.1,
+					.2,
+					.3,
+					.4
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(floatArrayClose(val, [
+					.1,
+					.2,
+					.3,
+					.4
+				])).toBe(true);
+			});
+		});
+		await describe("conformance/uniforms/gl-uniformmatrix4fv", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("uniformMatrix2fv with correct size (4 elements) succeeds", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT2);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m2");
+				gl.uniformMatrix2fv(loc, false, [
+					1,
+					0,
+					0,
+					1
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("uniformMatrix2fv with too few elements generates INVALID_VALUE", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT2);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m2");
+				gl.uniformMatrix2fv(loc, false, [
+					1,
+					0,
+					0
+				]);
+				expect(gl.getError()).toBe(gl.INVALID_VALUE);
+			});
+			await it("uniformMatrix3fv with correct size (9 elements) succeeds", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT3);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m3");
+				gl.uniformMatrix3fv(loc, false, [
+					1,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					1
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("uniformMatrix4fv with correct size (16 elements) succeeds", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT4);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m4");
+				gl.uniformMatrix4fv(loc, false, [
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("uniformMatrix4fv with transpose=true generates INVALID_VALUE in WebGL1", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT4);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m4");
+				gl.uniformMatrix4fv(loc, true, [
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1
+				]);
+				expect(gl.getError()).toBe(gl.INVALID_VALUE);
+			});
+			await it("uniformMatrix4fv / getUniform round-trips a mat4", async () => {
+				const prog = makeProgram(gl, VS, FS_MAT4);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_m4");
+				const identity = [
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1,
+					0,
+					0,
+					0,
+					0,
+					1
+				];
+				gl.uniformMatrix4fv(loc, false, identity);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(floatArrayClose(val, identity)).toBe(true);
+			});
+		});
+		await describe("conformance/uniforms/gl-uniform-arrays", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("uniform1fv sets a float array and getUniform retrieves element [0]", async () => {
+				const prog = makeProgram(gl, VS, FS_ARR);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_arr[0]");
+				expect(loc).not.toBeNull();
+				gl.uniform1fv(loc, [
+					.1,
+					.2,
+					.3
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, loc);
+				expect(Math.abs(val - .1) < .001).toBe(true);
+			});
+			await it("uniform1fv with fewer values than array size (partial update) succeeds", async () => {
+				const prog = makeProgram(gl, VS, FS_ARR);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_arr[0]");
+				gl.uniform1fv(loc, [.5, .6]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("uniform4fv sets a vec4 array", async () => {
+				const prog = makeProgram(gl, VS, FS_VEC4ARR);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_v4arr[0]");
+				expect(loc).not.toBeNull();
+				gl.uniform4fv(loc, [
+					.1,
+					.2,
+					.3,
+					.4,
+					.5,
+					.6,
+					.7,
+					.8,
+					.9,
+					1,
+					0,
+					0
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("getUniformLocation resolves bare array name (without [0] suffix)", async () => {
+				const prog = makeProgram(gl, VS, FS_ARR);
+				gl.useProgram(prog);
+				const locBare = gl.getUniformLocation(prog, "u_arr");
+				expect(locBare).not.toBeNull();
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				gl.uniform1fv(locBare, [
+					.7,
+					.8,
+					.9
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, locBare);
+				expect(Math.abs(val - .7) < .001).toBe(true);
+			});
+			await it("bare array name and indexed [0] name resolve to equivalent locations", async () => {
+				const prog = makeProgram(gl, VS, FS_ARR);
+				gl.useProgram(prog);
+				const locBare = gl.getUniformLocation(prog, "u_arr");
+				const locIndexed = gl.getUniformLocation(prog, "u_arr[0]");
+				expect(locBare).not.toBeNull();
+				expect(locIndexed).not.toBeNull();
+				gl.uniform1fv(locBare, [
+					.42,
+					.43,
+					.44
+				]);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+				const val = gl.getUniform(prog, locIndexed);
+				expect(Math.abs(val - .42) < .001).toBe(true);
+			});
+			await it("calling uniform* before useProgram generates INVALID_OPERATION", async () => {
+				const prog = makeProgram(gl, VS, FS_ARR);
+				gl.useProgram(null);
+				const loc = gl.getUniformLocation(prog, "u_arr[0]");
+				if (loc !== null) {
+					gl.uniform1fv(loc, [
+						1,
+						2,
+						3
+					]);
+					expect(gl.getError()).toBe(gl.INVALID_OPERATION);
+				} else {
+					expect(gl.getError()).toBe(gl.NO_ERROR);
+				}
+			});
+		});
+		await describe("conformance/uniforms/uniform-location", async () => {
+			beforeEach(async () => {
+				glArea.make_current();
+			});
+			await it("getUniformLocation returns non-null for known uniform", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				const loc = gl.getUniformLocation(prog, "u_f");
+				expect(loc).not.toBeNull();
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+			await it("location from different program generates INVALID_OPERATION", async () => {
+				const prog1 = makeProgram(gl, VS, FS_FLOAT);
+				const prog2 = makeProgram(gl, VS, FS_FLOAT);
+				const loc = gl.getUniformLocation(prog1, "u_f");
+				gl.useProgram(prog2);
+				gl.uniform1f(loc, 1);
+				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
+			});
+			await it("location becomes invalid after relinkProgram", async () => {
+				const prog = makeProgram(gl, VS, FS_FLOAT);
+				gl.useProgram(prog);
+				const locBefore = gl.getUniformLocation(prog, "u_f");
+				expect(locBefore).not.toBeNull();
+				gl.linkProgram(prog);
+				gl.uniform1f(locBefore, 1);
+				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
+				const locAfter = gl.getUniformLocation(prog, "u_f");
+				expect(locAfter).not.toBeNull();
+				gl.uniform1f(locAfter, 1);
+				expect(gl.getError()).toBe(gl.NO_ERROR);
+			});
+		});
+	});
 };
+
+//#endregion
+export { uniforms_spec_default as default };