@gjsify/webgl 0.0.3 → 0.1.0

package/lib/esm/webgl2.spec.js

@@ -0,0 +1,578 @@
+import { describe, it, expect, beforeEach, on } from "@gjsify/unit";
+import { WebGL2RenderingContext as OurWebGL2RenderingContext, CanvasWebGLWidget } from "@gjsify/webgl";
+import {
+  makeProgram,
+  drawTriangle,
+  readPixel,
+  makeTestFBO,
+  destroyTestFBO
+} from "./test-utils.js";
+import GLib from "@girs/glib-2.0";
+import Gtk from "@girs/gtk-4.0";
+var webgl2_spec_default = async () => {
+  await on("Display", async () => {
+    Gtk.init();
+    let glArea;
+    let gl2;
+    const readyLoop = new GLib.MainLoop(null, false);
+    const win = new Gtk.Window({});
+    win.set_default_size(200, 200);
+    glArea = new CanvasWebGLWidget();
+    glArea.onReady((c, _g) => {
+      gl2 = c.getContext("webgl2");
+      readyLoop.quit();
+    });
+    win.set_child(glArea);
+    win.present();
+    const giveUpId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1e4, () => {
+      readyLoop.quit();
+      return GLib.SOURCE_REMOVE;
+    });
+    readyLoop.run();
+    GLib.source_remove(giveUpId);
+    if (!gl2) {
+      console.warn("WebGL2 context not available \u2014 skipping WebGL2 tests");
+      win.destroy();
+      return;
+    }
+    glArea.make_current();
+    await describe("WebGL2 context", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it('getContext("webgl2") returns a WebGL2RenderingContext', async () => {
+        expect(gl2).toBeInstanceOf(OurWebGL2RenderingContext);
+      });
+      await it('VERSION is "WebGL 2.0"', async () => {
+        expect(gl2.getParameter(gl2.VERSION)).toBe("WebGL 2.0");
+      });
+      await it('SHADING_LANGUAGE_VERSION is "WebGL GLSL ES 3.00"', async () => {
+        expect(gl2.getParameter(gl2.SHADING_LANGUAGE_VERSION)).toBe("WebGL GLSL ES 3.00");
+      });
+      await it("drawingBufferWidth and drawingBufferHeight are positive", async () => {
+        expect(gl2.drawingBufferWidth > 0).toBeTruthy();
+        expect(gl2.drawingBufferHeight > 0).toBeTruthy();
+      });
+      await it("getError() returns NO_ERROR initially", async () => {
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+      });
+    });
+    await describe("GLSL ES 3.00 compilation", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      const VS300 = [
+        "#version 300 es",
+        "in vec2 position;",
+        "void main() { gl_Position = vec4(position, 0.0, 1.0); }"
+      ].join("\n");
+      const FS300 = [
+        "#version 300 es",
+        "precision mediump float;",
+        "out vec4 fragColor;",
+        "void main() { fragColor = vec4(0.0, 1.0, 0.0, 1.0); }"
+      ].join("\n");
+      await it("#version 300 es vertex shader compiles", async () => {
+        const sh = gl2.createShader(gl2.VERTEX_SHADER);
+        gl2.shaderSource(sh, VS300);
+        gl2.compileShader(sh);
+        if (!gl2.getShaderParameter(sh, gl2.COMPILE_STATUS)) {
+          console.error("VS300 log:", gl2.getShaderInfoLog(sh));
+        }
+        expect(gl2.getShaderParameter(sh, gl2.COMPILE_STATUS)).toBeTruthy();
+        gl2.deleteShader(sh);
+      });
+      await it("#version 300 es fragment shader compiles", async () => {
+        const sh = gl2.createShader(gl2.FRAGMENT_SHADER);
+        gl2.shaderSource(sh, FS300);
+        gl2.compileShader(sh);
+        if (!gl2.getShaderParameter(sh, gl2.COMPILE_STATUS)) {
+          console.error("FS300 log:", gl2.getShaderInfoLog(sh));
+        }
+        expect(gl2.getShaderParameter(sh, gl2.COMPILE_STATUS)).toBeTruthy();
+        gl2.deleteShader(sh);
+      });
+      await it("#version 300 es program links and renders green", async () => {
+        const prog = makeProgram(gl2, VS300, FS300);
+        if (!gl2.getProgramParameter(prog, gl2.LINK_STATUS)) {
+          console.error("Program300 log:", gl2.getProgramInfoLog(prog));
+        }
+        expect(gl2.getProgramParameter(prog, gl2.LINK_STATUS)).toBeTruthy();
+        const fbo = makeTestFBO(gl2, 4, 4);
+        gl2.clearColor(0, 0, 0, 1);
+        gl2.clear(gl2.COLOR_BUFFER_BIT);
+        gl2.useProgram(prog);
+        drawTriangle(gl2);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        const p = readPixel(gl2, 0, 0);
+        destroyTestFBO(gl2, fbo);
+        expect(p[0]).toBe(0);
+        expect(p[1]).toBe(255);
+        expect(p[2]).toBe(0);
+        expect(p[3]).toBe(255);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("VAO", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("createVertexArray returns a non-null object", async () => {
+        const vao = gl2.createVertexArray();
+        expect(vao).not.toBeNull();
+        expect(vao).toBeDefined();
+        gl2.deleteVertexArray(vao);
+      });
+      await it("isVertexArray is true after creation, false after deletion", async () => {
+        const vao = gl2.createVertexArray();
+        gl2.bindVertexArray(vao);
+        expect(gl2.isVertexArray(vao)).toBeTruthy();
+        gl2.bindVertexArray(null);
+        gl2.deleteVertexArray(vao);
+        expect(gl2.isVertexArray(vao)).toBeFalsy();
+      });
+      await it("VAO preserves vertex attribute state", async () => {
+        const VS = [
+          "#version 300 es",
+          "in vec2 position;",
+          "void main() { gl_Position = vec4(position,0.0,1.0); }"
+        ].join("\n");
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "out vec4 c;",
+          "void main() { c = vec4(0.0,1.0,0.0,1.0); }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS, FS);
+        gl2.useProgram(prog);
+        const fbo = makeTestFBO(gl2, 4, 4);
+        const vao = gl2.createVertexArray();
+        gl2.bindVertexArray(vao);
+        const buf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, buf);
+        gl2.bufferData(gl2.ARRAY_BUFFER, new Float32Array([-2, -2, -2, 4, 4, -2]), gl2.STREAM_DRAW);
+        gl2.enableVertexAttribArray(0);
+        gl2.vertexAttribPointer(0, 2, gl2.FLOAT, false, 0, 0);
+        gl2.bindVertexArray(null);
+        gl2.bindVertexArray(vao);
+        gl2.clearColor(0, 0, 0, 1);
+        gl2.clear(gl2.COLOR_BUFFER_BIT);
+        gl2.drawArrays(gl2.TRIANGLES, 0, 3);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        const p = readPixel(gl2, 0, 0);
+        destroyTestFBO(gl2, fbo);
+        expect(p[1]).toBe(255);
+        gl2.bindVertexArray(null);
+        gl2.deleteVertexArray(vao);
+        gl2.deleteBuffer(buf);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("getBufferSubData", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("reads back float data written with bufferData", async () => {
+        const src = new Float32Array([1, 2, 3, 4]);
+        const buf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, buf);
+        gl2.bufferData(gl2.ARRAY_BUFFER, src, gl2.STATIC_READ);
+        const dst = new Float32Array(4);
+        gl2.getBufferSubData(gl2.ARRAY_BUFFER, 0, dst);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        expect(dst[0]).toBe(1);
+        expect(dst[1]).toBe(2);
+        expect(dst[2]).toBe(3);
+        expect(dst[3]).toBe(4);
+        gl2.deleteBuffer(buf);
+      });
+      await it("reads a sub-range correctly", async () => {
+        const src = new Float32Array([10, 20, 30, 40]);
+        const buf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, buf);
+        gl2.bufferData(gl2.ARRAY_BUFFER, src, gl2.STATIC_READ);
+        const dst = new Float32Array(2);
+        gl2.getBufferSubData(gl2.ARRAY_BUFFER, 8, dst);
+        expect(dst[0]).toBe(30);
+        expect(dst[1]).toBe(40);
+        gl2.deleteBuffer(buf);
+      });
+    });
+    await describe("sync objects", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("fenceSync returns a non-null sync", async () => {
+        const sync = gl2.fenceSync(gl2.SYNC_GPU_COMMANDS_COMPLETE, 0);
+        expect(sync).not.toBeNull();
+        gl2.deleteSync(sync);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+      });
+      await it("isSync is true before deletion, false after", async () => {
+        const sync = gl2.fenceSync(gl2.SYNC_GPU_COMMANDS_COMPLETE, 0);
+        expect(gl2.isSync(sync)).toBeTruthy();
+        gl2.deleteSync(sync);
+        expect(gl2.isSync(sync)).toBeFalsy();
+      });
+      await it("clientWaitSync returns TIMEOUT_EXPIRED or CONDITION_SATISFIED", async () => {
+        const sync = gl2.fenceSync(gl2.SYNC_GPU_COMMANDS_COMPLETE, 0);
+        gl2.flush();
+        const result = gl2.clientWaitSync(sync, 0, 0);
+        const valid = result === gl2.TIMEOUT_EXPIRED || result === gl2.CONDITION_SATISFIED || result === gl2.ALREADY_SIGNALED;
+        expect(valid).toBeTruthy();
+        gl2.deleteSync(sync);
+      });
+    });
+    await describe("uint uniforms", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      const VS_U = [
+        "#version 300 es",
+        "in vec2 position;",
+        "void main() { gl_Position = vec4(position,0.0,1.0); }"
+      ].join("\n");
+      const FS_U = [
+        "#version 300 es",
+        "precision mediump float;",
+        "uniform uint uR; uniform uint uG; uniform uint uB;",
+        "out vec4 c;",
+        "void main() { c = vec4(float(uR)/255.0, float(uG)/255.0, float(uB)/255.0, 1.0); }"
+      ].join("\n");
+      await it("uniform1ui sets an unsigned int uniform", async () => {
+        const prog = makeProgram(gl2, VS_U, FS_U);
+        expect(gl2.getProgramParameter(prog, gl2.LINK_STATUS)).toBeTruthy();
+        gl2.useProgram(prog);
+        const locR = gl2.getUniformLocation(prog, "uR");
+        const locG = gl2.getUniformLocation(prog, "uG");
+        const locB = gl2.getUniformLocation(prog, "uB");
+        gl2.uniform1ui(locR, 0);
+        gl2.uniform1ui(locG, 255);
+        gl2.uniform1ui(locB, 0);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        expect(gl2.getUniform(prog, locR)).toBe(0);
+        expect(gl2.getUniform(prog, locG)).toBe(255);
+        gl2.deleteProgram(prog);
+      });
+      await it("uniform2ui, uniform3ui, uniform4ui set without error", async () => {
+        const FS2 = [
+          "#version 300 es",
+          "precision mediump float;",
+          "uniform uvec2 u2; uniform uvec3 u3; uniform uvec4 u4;",
+          "out vec4 c;",
+          "void main() { c = vec4(float(u2.x), float(u3.x), float(u4.x), 1.0)/255.0; }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS_U, FS2);
+        gl2.useProgram(prog);
+        gl2.uniform2ui(gl2.getUniformLocation(prog, "u2"), 1, 2);
+        gl2.uniform3ui(gl2.getUniformLocation(prog, "u3"), 1, 2, 3);
+        gl2.uniform4ui(gl2.getUniformLocation(prog, "u4"), 1, 2, 3, 4);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("non-square matrix uniforms", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      const VS_M = [
+        "#version 300 es",
+        "in vec2 position;",
+        "void main() { gl_Position = vec4(position,0.0,1.0); }"
+      ].join("\n");
+      await it("uniformMatrix2x3fv sets a mat2x3 without error", async () => {
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "uniform mat2x3 m; out vec4 c;",
+          "void main() { c = vec4(m[0][0], m[0][1], m[0][2], 1.0); }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS_M, FS);
+        gl2.useProgram(prog);
+        gl2.uniformMatrix2x3fv(
+          gl2.getUniformLocation(prog, "m"),
+          false,
+          new Float32Array([1, 0, 0, 0, 1, 0])
+        );
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteProgram(prog);
+      });
+      await it("uniformMatrix3x2fv sets a mat3x2 without error", async () => {
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "uniform mat3x2 m; out vec4 c;",
+          "void main() { c = vec4(m[0][0], m[0][1], 0.0, 1.0); }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS_M, FS);
+        gl2.useProgram(prog);
+        gl2.uniformMatrix3x2fv(
+          gl2.getUniformLocation(prog, "m"),
+          false,
+          new Float32Array([1, 0, 0, 1, 0, 0])
+        );
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("Uniform Buffer Objects", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("getUniformBlockIndex + uniformBlockBinding works", async () => {
+        const VS = [
+          "#version 300 es",
+          "layout(std140) uniform Params { vec4 color; };",
+          "in vec2 position;",
+          "out vec4 vColor;",
+          "void main() { vColor = color; gl_Position = vec4(position,0.0,1.0); }"
+        ].join("\n");
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "in vec4 vColor; out vec4 c;",
+          "void main() { c = vColor; }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS, FS);
+        expect(gl2.getProgramParameter(prog, gl2.LINK_STATUS)).toBeTruthy();
+        const idx = gl2.getUniformBlockIndex(prog, "Params");
+        expect(idx).not.toBe(gl2.INVALID_INDEX);
+        gl2.uniformBlockBinding(prog, idx, 0);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        const ubo = gl2.createBuffer();
+        gl2.bindBuffer(gl2.UNIFORM_BUFFER, ubo);
+        gl2.bufferData(gl2.UNIFORM_BUFFER, new Float32Array([0, 1, 0, 1]), gl2.STATIC_DRAW);
+        gl2.bindBufferBase(gl2.UNIFORM_BUFFER, 0, ubo);
+        const fbo = makeTestFBO(gl2, 4, 4);
+        gl2.useProgram(prog);
+        gl2.clearColor(0, 0, 0, 1);
+        gl2.clear(gl2.COLOR_BUFFER_BIT);
+        drawTriangle(gl2);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        const p = readPixel(gl2, 0, 0);
+        destroyTestFBO(gl2, fbo);
+        expect(p[1]).toBe(255);
+        gl2.deleteBuffer(ubo);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("instanced drawing", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("drawArraysInstanced renders without error", async () => {
+        const VS = [
+          "#version 300 es",
+          "in vec2 position;",
+          "void main() { gl_Position = vec4(position,0.0,1.0); }"
+        ].join("\n");
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "out vec4 c;",
+          "void main() { c = vec4(0.0,1.0,0.0,1.0); }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS, FS);
+        gl2.useProgram(prog);
+        const fbo = makeTestFBO(gl2, 4, 4);
+        const buf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, buf);
+        gl2.bufferData(gl2.ARRAY_BUFFER, new Float32Array([-2, -2, -2, 4, 4, -2]), gl2.STREAM_DRAW);
+        gl2.enableVertexAttribArray(0);
+        gl2.vertexAttribPointer(0, 2, gl2.FLOAT, false, 0, 0);
+        gl2.vertexAttribDivisor(0, 0);
+        gl2.clearColor(0, 0, 0, 1);
+        gl2.clear(gl2.COLOR_BUFFER_BIT);
+        gl2.drawArraysInstanced(gl2.TRIANGLES, 0, 3, 1);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        const p = readPixel(gl2, 0, 0);
+        destroyTestFBO(gl2, fbo);
+        expect(p[1]).toBe(255);
+        gl2.disableVertexAttribArray(0);
+        gl2.deleteBuffer(buf);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("drawBuffers (MRT)", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("drawBuffers with 2 COLOR_ATTACHMENTs renders to both", async () => {
+        const VS = [
+          "#version 300 es",
+          "in vec2 position;",
+          "void main() { gl_Position = vec4(position,0.0,1.0); }"
+        ].join("\n");
+        const FS = [
+          "#version 300 es",
+          "precision mediump float;",
+          "layout(location=0) out vec4 c0;",
+          "layout(location=1) out vec4 c1;",
+          "void main() { c0 = vec4(1.0,0.0,0.0,1.0); c1 = vec4(0.0,0.0,1.0,1.0); }"
+        ].join("\n");
+        const prog = makeProgram(gl2, VS, FS);
+        expect(gl2.getProgramParameter(prog, gl2.LINK_STATUS)).toBeTruthy();
+        const fb = gl2.createFramebuffer();
+        gl2.bindFramebuffer(gl2.FRAMEBUFFER, fb);
+        const tex0 = gl2.createTexture();
+        gl2.bindTexture(gl2.TEXTURE_2D, tex0);
+        gl2.texImage2D(gl2.TEXTURE_2D, 0, gl2.RGBA, 4, 4, 0, gl2.RGBA, gl2.UNSIGNED_BYTE, null);
+        gl2.framebufferTexture2D(gl2.FRAMEBUFFER, gl2.COLOR_ATTACHMENT0, gl2.TEXTURE_2D, tex0, 0);
+        const tex1 = gl2.createTexture();
+        gl2.bindTexture(gl2.TEXTURE_2D, tex1);
+        gl2.texImage2D(gl2.TEXTURE_2D, 0, gl2.RGBA, 4, 4, 0, gl2.RGBA, gl2.UNSIGNED_BYTE, null);
+        gl2.framebufferTexture2D(gl2.FRAMEBUFFER, gl2.COLOR_ATTACHMENT1, gl2.TEXTURE_2D, tex1, 0);
+        const status = gl2.checkFramebufferStatus(gl2.FRAMEBUFFER);
+        if (status !== gl2.FRAMEBUFFER_COMPLETE) {
+          console.warn("MRT framebuffer not complete:", status);
+          gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+          gl2.deleteFramebuffer(fb);
+          gl2.deleteTexture(tex0);
+          gl2.deleteTexture(tex1);
+          gl2.deleteProgram(prog);
+          return;
+        }
+        gl2.drawBuffers([gl2.COLOR_ATTACHMENT0, gl2.COLOR_ATTACHMENT1]);
+        gl2.viewport(0, 0, 4, 4);
+        gl2.clearColor(0, 0, 0, 1);
+        gl2.clear(gl2.COLOR_BUFFER_BIT);
+        gl2.useProgram(prog);
+        drawTriangle(gl2);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.readBuffer(gl2.COLOR_ATTACHMENT0);
+        const p0 = readPixel(gl2, 0, 0);
+        expect(p0[0]).toBe(255);
+        expect(p0[1]).toBe(0);
+        gl2.readBuffer(gl2.COLOR_ATTACHMENT1);
+        const p1 = readPixel(gl2, 0, 0);
+        expect(p1[0]).toBe(0);
+        expect(p1[2]).toBe(255);
+        gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+        gl2.deleteFramebuffer(fb);
+        gl2.deleteTexture(tex0);
+        gl2.deleteTexture(tex1);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("3D texture", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("createTexture + TEXTURE_3D binding works", async () => {
+        const tex = gl2.createTexture();
+        expect(tex).not.toBeNull();
+        gl2.bindTexture(gl2.TEXTURE_3D, tex);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteTexture(tex);
+      });
+      await it("texImage3D uploads a 2\xD72\xD72 RGBA texture without error", async () => {
+        const tex = gl2.createTexture();
+        gl2.bindTexture(gl2.TEXTURE_3D, tex);
+        gl2.texParameteri(gl2.TEXTURE_3D, gl2.TEXTURE_MIN_FILTER, gl2.NEAREST);
+        gl2.texParameteri(gl2.TEXTURE_3D, gl2.TEXTURE_MAG_FILTER, gl2.NEAREST);
+        gl2.texParameteri(gl2.TEXTURE_3D, gl2.TEXTURE_WRAP_S, gl2.CLAMP_TO_EDGE);
+        gl2.texParameteri(gl2.TEXTURE_3D, gl2.TEXTURE_WRAP_T, gl2.CLAMP_TO_EDGE);
+        gl2.texParameteri(gl2.TEXTURE_3D, gl2.TEXTURE_WRAP_R, gl2.CLAMP_TO_EDGE);
+        const data = new Uint8Array(2 * 2 * 2 * 4).fill(128);
+        gl2.texImage3D(gl2.TEXTURE_3D, 0, gl2.RGBA, 2, 2, 2, 0, gl2.RGBA, gl2.UNSIGNED_BYTE, data);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteTexture(tex);
+      });
+      await it("texStorage3D allocates storage without error", async () => {
+        const tex = gl2.createTexture();
+        gl2.bindTexture(gl2.TEXTURE_3D, tex);
+        gl2.texStorage3D(gl2.TEXTURE_3D, 1, gl2.RGBA8, 4, 4, 4);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.deleteTexture(tex);
+      });
+    });
+    await describe("transform feedback", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("captures vertex shader output via transform feedback", async () => {
+        const VS_TF = [
+          "#version 300 es",
+          "in float inVal;",
+          "out float outVal;",
+          "void main() { outVal = inVal * 2.0; gl_Position = vec4(0.0); }"
+        ].join("\n");
+        const FS_TF = [
+          "#version 300 es",
+          "precision mediump float;",
+          "out vec4 c;",
+          "void main() { c = vec4(0.0); }"
+        ].join("\n");
+        const vert = gl2.createShader(gl2.VERTEX_SHADER);
+        gl2.shaderSource(vert, VS_TF);
+        gl2.compileShader(vert);
+        if (!gl2.getShaderParameter(vert, gl2.COMPILE_STATUS)) {
+          console.error("TF VS:", gl2.getShaderInfoLog(vert));
+        }
+        const frag = gl2.createShader(gl2.FRAGMENT_SHADER);
+        gl2.shaderSource(frag, FS_TF);
+        gl2.compileShader(frag);
+        const prog = gl2.createProgram();
+        gl2.attachShader(prog, vert);
+        gl2.attachShader(prog, frag);
+        gl2.transformFeedbackVaryings(prog, ["outVal"], gl2.SEPARATE_ATTRIBS);
+        gl2.linkProgram(prog);
+        if (!gl2.getProgramParameter(prog, gl2.LINK_STATUS)) {
+          console.error("TF prog:", gl2.getProgramInfoLog(prog));
+        }
+        expect(gl2.getProgramParameter(prog, gl2.LINK_STATUS)).toBeTruthy();
+        const inBuf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, inBuf);
+        gl2.bufferData(gl2.ARRAY_BUFFER, new Float32Array([1, 2, 3, 4]), gl2.STATIC_DRAW);
+        const attribLoc = gl2.getAttribLocation(prog, "inVal");
+        gl2.enableVertexAttribArray(attribLoc);
+        gl2.vertexAttribPointer(attribLoc, 1, gl2.FLOAT, false, 0, 0);
+        const outBuf = gl2.createBuffer();
+        gl2.bindBuffer(gl2.TRANSFORM_FEEDBACK_BUFFER, outBuf);
+        gl2.bufferData(gl2.TRANSFORM_FEEDBACK_BUFFER, 4 * 4, gl2.STATIC_READ);
+        const tf = gl2.createTransformFeedback();
+        gl2.bindTransformFeedback(gl2.TRANSFORM_FEEDBACK, tf);
+        gl2.bindBufferBase(gl2.TRANSFORM_FEEDBACK_BUFFER, 0, outBuf);
+        const fbo = makeTestFBO(gl2, 1, 1);
+        gl2.useProgram(prog);
+        gl2.enable(gl2.RASTERIZER_DISCARD);
+        gl2.beginTransformFeedback(gl2.POINTS);
+        gl2.drawArrays(gl2.POINTS, 0, 4);
+        gl2.endTransformFeedback();
+        gl2.disable(gl2.RASTERIZER_DISCARD);
+        expect(gl2.getError()).toBe(gl2.NO_ERROR);
+        gl2.bindTransformFeedback(gl2.TRANSFORM_FEEDBACK, null);
+        destroyTestFBO(gl2, fbo);
+        const result = new Float32Array(4);
+        gl2.bindBuffer(gl2.TRANSFORM_FEEDBACK_BUFFER, outBuf);
+        gl2.getBufferSubData(gl2.TRANSFORM_FEEDBACK_BUFFER, 0, result);
+        expect(result[0]).toBe(2);
+        expect(result[1]).toBe(4);
+        expect(result[2]).toBe(6);
+        expect(result[3]).toBe(8);
+        gl2.disableVertexAttribArray(attribLoc);
+        gl2.deleteBuffer(inBuf);
+        gl2.deleteBuffer(outBuf);
+        gl2.deleteTransformFeedback(tf);
+        gl2.deleteProgram(prog);
+      });
+    });
+    await describe("getStringi", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("getStringi(EXTENSIONS, 0) returns a string", async () => {
+        const numExts = gl2.getParameter(gl2.NUM_EXTENSIONS);
+        if (numExts > 0) {
+          const ext = gl2.getStringi(gl2.EXTENSIONS, 0);
+          expect(typeof ext).toBe("string");
+          expect(ext.length > 0).toBeTruthy();
+        }
+      });
+    });
+    win.destroy();
+  });
+};
+export {
+  webgl2_spec_default as default
+};