@gjsify/webgl 0.1.2 → 0.1.3

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

@@ -0,0 +1,354 @@
+import { describe, it, expect, beforeEach, on } from "@gjsify/unit";
+import { makeProgram, drawTriangle, makeTestFBO, destroyTestFBO } from "../test-utils.js";
+import { createGLSetup } from "./setup.js";
+const VS_TEX = `
+    precision mediump float;
+    attribute vec2 position;
+    varying vec2 vTexCoord;
+    void main() {
+        vTexCoord = 0.5 * (position + 1.0);
+        gl_Position = vec4(position, 0.0, 1.0);
+    }`;
+const FS_TEX = `
+    precision mediump float;
+    uniform sampler2D uTex;
+    varying vec2 vTexCoord;
+    void main() { gl_FragColor = texture2D(uTex, vTexCoord); }`;
+var textures_spec_default = async () => {
+  await on("Display", async () => {
+    const setup = createGLSetup();
+    if (!setup) {
+      console.warn("WebGL context not available \u2014 skipping conformance/textures tests");
+      return;
+    }
+    const { gl, glArea } = setup;
+    glArea.make_current();
+    await describe("textures/texImage2D-rgba", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("upload 2\xD72 RGBA Uint8Array and sample it back", async () => {
+        const W = 2, H = 2;
+        const fbo = makeTestFBO(gl, W, H);
+        const data = new Uint8Array([
+          255,
+          0,
+          0,
+          255,
+          // red
+          0,
+          255,
+          0,
+          255,
+          // green
+          0,
+          0,
+          255,
+          255,
+          // blue
+          255,
+          255,
+          0,
+          255
+          // yellow
+        ]);
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, W, H, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+        const prog = makeProgram(gl, VS_TEX, FS_TEX);
+        gl.useProgram(prog);
+        gl.uniform1i(gl.getUniformLocation(prog, "uTex"), 0);
+        drawTriangle(gl);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.deleteTexture(tex);
+        destroyTestFBO(gl, fbo);
+      });
+      await it("createTexture returns non-null; deleteTexture cleans up", async () => {
+        const tex = gl.createTexture();
+        expect(tex).toBeDefined();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texImage2D(
+          gl.TEXTURE_2D,
+          0,
+          gl.RGBA,
+          1,
+          1,
+          0,
+          gl.RGBA,
+          gl.UNSIGNED_BYTE,
+          new Uint8Array([128, 128, 128, 255])
+        );
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+      });
+    });
+    await describe("textures/alpha-texture", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("ALPHA format texImage2D: RGB channels zero, alpha matches upload data", async () => {
+        const W = 4, H = 4;
+        const fbo = makeTestFBO(gl, W, H);
+        const data = new Uint8Array(W * H);
+        for (let i = 0; i < H; i++) {
+          for (let j = 0; j < W; j++) {
+            data[i * W + j] = (i + j) % 255;
+          }
+        }
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.ALPHA, W, H, 0, gl.ALPHA, gl.UNSIGNED_BYTE, data);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        const prog = makeProgram(gl, VS_TEX, FS_TEX);
+        gl.useProgram(prog);
+        gl.uniform1i(gl.getUniformLocation(prog, "uTex"), 0);
+        drawTriangle(gl);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        const pixels = new Uint8Array(W * H * 4);
+        gl.readPixels(0, 0, W, H, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+        let ok = true;
+        for (let k = 0; k < W * H; k++) {
+          const i = k * 4;
+          if (pixels[i] !== 0 || pixels[i + 1] !== 0 || pixels[i + 2] !== 0) {
+            ok = false;
+            break;
+          }
+          if (Math.abs(pixels[i + 3] - data[k]) > 3) {
+            ok = false;
+            break;
+          }
+        }
+        expect(ok).toBe(true);
+        gl.deleteTexture(tex);
+        destroyTestFBO(gl, fbo);
+      });
+    });
+    await describe("textures/texSubImage2D", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("texSubImage2D overwrites a sub-region of an RGBA texture", async () => {
+        const W = 4, H = 4;
+        const fbo = makeTestFBO(gl, W, H);
+        const redData = new Uint8Array(W * H * 4).fill(0);
+        for (let i = 0; i < W * H; i++) {
+          redData[i * 4] = 255;
+          redData[i * 4 + 3] = 255;
+        }
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, W, H, 0, gl.RGBA, gl.UNSIGNED_BYTE, redData);
+        const greenPatch = new Uint8Array([
+          0,
+          255,
+          0,
+          255,
+          0,
+          255,
+          0,
+          255,
+          0,
+          255,
+          0,
+          255,
+          0,
+          255,
+          0,
+          255
+        ]);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 2, 2, gl.RGBA, gl.UNSIGNED_BYTE, greenPatch);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.deleteTexture(tex);
+        destroyTestFBO(gl, fbo);
+      });
+    });
+    await describe("textures/parameters", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("getTexParameter returns set WRAP and FILTER values", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)).toBe(gl.CLAMP_TO_EDGE);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T)).toBe(gl.REPEAT);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)).toBe(gl.LINEAR);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER)).toBe(gl.NEAREST);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+      await it("MIRRORED_REPEAT wrap mode is accepted", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.MIRRORED_REPEAT);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)).toBe(gl.MIRRORED_REPEAT);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+      await it("LINEAR_MIPMAP_LINEAR min filter is accepted", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        expect(gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)).toBe(gl.LINEAR_MIPMAP_LINEAR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+    });
+    await describe("textures/active-texture", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("activeTexture switches binding slot; each unit holds independent binding", async () => {
+        const tex0 = gl.createTexture();
+        const tex1 = gl.createTexture();
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, tex0);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, tex1);
+        gl.activeTexture(gl.TEXTURE0);
+        expect(gl.getParameter(gl.TEXTURE_BINDING_2D)).toBe(tex0);
+        gl.activeTexture(gl.TEXTURE1);
+        expect(gl.getParameter(gl.TEXTURE_BINDING_2D)).toBe(tex1);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex0);
+        gl.deleteTexture(tex1);
+      });
+      await it("getParameter ACTIVE_TEXTURE reflects activeTexture call", async () => {
+        gl.activeTexture(gl.TEXTURE3);
+        expect(gl.getParameter(gl.ACTIVE_TEXTURE)).toBe(gl.TEXTURE3);
+        gl.activeTexture(gl.TEXTURE0);
+        expect(gl.getParameter(gl.ACTIVE_TEXTURE)).toBe(gl.TEXTURE0);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+      });
+    });
+    await describe("textures/cubemap", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("attach all 6 cubemap faces to FBO \u2014 no GL error", async () => {
+        const tex = gl.createTexture();
+        const fb = gl.createFramebuffer();
+        const whitePixel = new Uint8Array([255, 255, 255, 255]);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+        for (let i = 0; i < 6; i++) {
+          gl.texImage2D(
+            gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
+            0,
+            gl.RGBA,
+            1,
+            1,
+            0,
+            gl.RGBA,
+            gl.UNSIGNED_BYTE,
+            whitePixel
+          );
+          gl.framebufferTexture2D(
+            gl.FRAMEBUFFER,
+            gl.COLOR_ATTACHMENT0,
+            gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
+            tex,
+            0
+          );
+        }
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.deleteTexture(tex);
+        gl.deleteFramebuffer(fb);
+      });
+      await it("createTexture with TEXTURE_CUBE_MAP binding \u2014 no error", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
+        gl.deleteTexture(tex);
+      });
+    });
+    await describe("textures/luminance", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("LUMINANCE format texImage2D \u2014 no error", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        const data = new Uint8Array([128, 64, 192, 32]);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, 4, 1, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, data);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+      await it("LUMINANCE_ALPHA format texImage2D \u2014 no error", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        const data = new Uint8Array([128, 255, 64, 128]);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE_ALPHA, 2, 1, 0, gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE, data);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+    });
+    await describe("textures/generateMipmap", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("generateMipmap on power-of-two RGBA texture \u2014 no error", async () => {
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        const W = 4, H = 4;
+        const data = new Uint8Array(W * H * 4).fill(255);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, W, H, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+        gl.generateMipmap(gl.TEXTURE_2D);
+        expect(gl.getError()).toBe(gl.NO_ERROR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.deleteTexture(tex);
+      });
+    });
+  });
+};
+export {
+  textures_spec_default as default
+};

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

@@ -0,0 +1,305 @@
+import { describe, it, expect, beforeEach, on } from "@gjsify/unit";
+import { makeProgram } from "../test-utils.js";
+import { createGLSetup } from "./setup.js";
+const VS = `attribute vec4 a_position; void main() { gl_Position = a_position; }`;
+function makeFS(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); }");
+const FS_BOOL = makeFS("uniform bool u_b; void main() { gl_FragColor = vec4(u_b ? 1.0 : 0.0,0,0,1); }");
+const FS_VEC2 = makeFS("uniform vec2 u_v2; void main() { gl_FragColor = vec4(u_v2,0,1); }");
+const FS_VEC3 = makeFS("uniform vec3 u_v3; void main() { gl_FragColor = vec4(u_v3,1); }");
+const FS_VEC4 = makeFS("uniform vec4 u_v4; void main() { gl_FragColor = u_v4; }");
+const FS_MAT2 = makeFS("uniform mat2 u_m2; void main() { gl_FragColor = vec4(u_m2[0],u_m2[1]); }");
+const FS_MAT3 = makeFS("uniform mat3 u_m3; void main() { gl_FragColor = vec4(u_m3[0],1); }");
+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;
+}
+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("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
+};

package/lib/esm/conformance-test.js

@@ -0,0 +1,23 @@
+import { run } from "@gjsify/unit";
+import buffersTests from "./conformance/buffers.spec.js";
+import programsTests from "./conformance/programs.spec.js";
+import attribsTests from "./conformance/attribs.spec.js";
+import contextTests from "./conformance/context.spec.js";
+import renderingBasicTests from "./conformance/rendering-basic.spec.js";
+import uniformsTests from "./conformance/uniforms.spec.js";
+import stateTests from "./conformance/state.spec.js";
+import renderingTests from "./conformance/rendering.spec.js";
+import texturesTests from "./conformance/textures.spec.js";
+run({
+  testSuite: async () => {
+    await buffersTests();
+    await programsTests();
+    await attribsTests();
+    await contextTests();
+    await renderingBasicTests();
+    await uniformsTests();
+    await stateTests();
+    await renderingTests();
+    await texturesTests();
+  }
+});

package/lib/esm/extensions/ext-color-buffer-float.js

@@ -0,0 +1,13 @@
+class EXTColorBufferFloat {
+}
+function getEXTColorBufferFloat(context) {
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("EXT_color_buffer_float") >= 0) {
+    return new EXTColorBufferFloat();
+  }
+  return null;
+}
+export {
+  EXTColorBufferFloat,
+  getEXTColorBufferFloat
+};