@gjsify/webgl 0.3.16 → 0.3.18

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

@@ -1,481 +1,7 @@
-import { destroyTestFBO, makeTestFBO, pixelClose, readPixel } from "../test-utils.js";
-import { createGLSetup } from "./setup.js";
-import { beforeEach, describe, expect, it, on } from "@gjsify/unit";
-
-//#region src/ts/conformance/programs.spec.ts
-const VS_POSITION = `attribute vec4 a_position; void main() { gl_Position = a_position; }`;
-const VS_COLOR_ATTRIB = `attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex; }`;
-const FS_VARYING_COLOR = `precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }`;
-const FS_RED = `void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }`;
-const FS_GREEN = `void main() { gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); }`;
-const FS_SETTABLE = `precision mediump float; uniform vec4 u_color; void main() { gl_FragColor = u_color; }`;
-const VS_STANDARD = `
+import{destroyTestFBO as e,makeTestFBO as t,pixelClose as n,readPixel as r}from"../test-utils.js";import{createGLSetup as i}from"./setup.js";import{beforeEach as a,describe as o,expect as s,it as c,on as l}from"@gjsify/unit";const u=`attribute vec4 a_position; void main() { gl_Position = a_position; }`,d=`attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex; }`,f=`precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }`,p=`void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }`,m=`void main() { gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); }`,h=`
     attribute vec4 a_vertex;
     attribute vec3 a_normal;
     uniform mat4 u_modelViewProjMatrix;
-    void main() { gl_Position = u_modelViewProjMatrix * (a_vertex + vec4(a_normal, 0.0)); }`;
-const FS_STANDARD = `
+    void main() { gl_Position = u_modelViewProjMatrix * (a_vertex + vec4(a_normal, 0.0)); }`,g=`
     precision mediump float;
-    void main() { gl_FragColor = vec4(1.0); }`;
-function compileShader(gl, type, src) {
-	const s = gl.createShader(type);
-	gl.shaderSource(s, src);
-	gl.compileShader(s);
-	return s;
-}
-function linkProgram(gl, vsSrc, fsSrc, attribBindings) {
-	const vs = compileShader(gl, gl.VERTEX_SHADER, vsSrc);
-	const fs = compileShader(gl, gl.FRAGMENT_SHADER, fsSrc);
-	const prog = gl.createProgram();
-	gl.attachShader(prog, vs);
-	gl.attachShader(prog, fs);
-	if (attribBindings) {
-		for (const [name, loc] of attribBindings) gl.bindAttribLocation(prog, loc, name);
-	}
-	gl.linkProgram(prog);
-	return prog;
-}
-/** Fill the current FBO with a fullscreen triangle and return the center pixel. */
-function drawFullscreenAndRead(gl, prog, posAttrib = "a_position") {
-	const loc = typeof posAttrib === "string" ? gl.getAttribLocation(prog, posAttrib) : posAttrib;
-	const buf = gl.createBuffer();
-	gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-		-4,
-		-4,
-		4,
-		-4,
-		0,
-		4
-	]), gl.STREAM_DRAW);
-	gl.enableVertexAttribArray(loc);
-	gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);
-	gl.drawArrays(gl.TRIANGLES, 0, 3);
-	gl.disableVertexAttribArray(loc);
-	gl.deleteBuffer(buf);
-	return readPixel(gl, 0, 0);
-}
-var programs_spec_default = async () => {
-	await on("Display", async () => {
-		const setup = createGLSetup();
-		if (!setup) {
-			console.warn("WebGL context not available — skipping conformance/programs tests");
-			return;
-		}
-		const { gl, glArea, win } = setup;
-		glArea.make_current();
-		await describe("conformance/programs/program-test: compileShader", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("good vertex shader should compile", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, "attribute vec4 aVertex; void main() { gl_Position = aVertex; }");
-				expect(gl.getShaderParameter(vs, gl.COMPILE_STATUS)).toBeTruthy();
-				gl.deleteShader(vs);
-			});
-			await it("good fragment shader should compile", async () => {
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, "precision mediump float; void main() { gl_FragColor = vec4(1.0); }");
-				expect(gl.getShaderParameter(fs, gl.COMPILE_STATUS)).toBeTruthy();
-				gl.deleteShader(fs);
-			});
-			await it("getShaderParameter with desktop-only INFO_LOG_LENGTH returns null and INVALID_ENUM", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, "attribute vec4 v; void main() { gl_Position = v; }");
-				const INFO_LOG_LENGTH = 35716;
-				const result = gl.getShaderParameter(vs, INFO_LOG_LENGTH);
-				expect(result).toBeNull();
-				expect(gl.getError()).toBe(gl.INVALID_ENUM);
-				gl.deleteShader(vs);
-			});
-		});
-		await describe("conformance/programs/program-test: attachShader / detachShader", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("attaching a vertex shader succeeds", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-			});
-			await it("attaching the same shader twice generates INVALID_OPERATION", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.getError();
-				gl.attachShader(prog, vs);
-				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-			});
-			await it("attaching two vertex shaders to same program generates INVALID_OPERATION", async () => {
-				const vs1 = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const vs2 = compileShader(gl, gl.VERTEX_SHADER, "attribute vec4 v; void main() { gl_Position = v * 0.5; }");
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs1);
-				gl.getError();
-				gl.attachShader(prog, vs2);
-				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs1);
-				gl.deleteShader(vs2);
-			});
-			await it("detaching an attached shader succeeds", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.detachShader(prog, vs);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-			});
-			await it("detaching a non-attached shader generates INVALID_OPERATION", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_VARYING_COLOR);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, fs);
-				gl.getError();
-				gl.detachShader(prog, vs);
-				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-		});
-		await describe("conformance/programs/program-test: getAttachedShaders", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("empty program returns empty list", async () => {
-				const prog = gl.createProgram();
-				const shaders = gl.getAttachedShaders(prog);
-				expect(shaders?.length).toBe(0);
-				gl.deleteProgram(prog);
-			});
-			await it("attached shaders appear in getAttachedShaders", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_VARYING_COLOR);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.attachShader(prog, fs);
-				const shaders = gl.getAttachedShaders(prog);
-				expect(shaders.length).toBe(2);
-				expect(shaders.includes(vs)).toBeTruthy();
-				expect(shaders.includes(fs)).toBeTruthy();
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-			await it("detached shaders are removed from getAttachedShaders", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_VARYING_COLOR);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.attachShader(prog, fs);
-				gl.detachShader(prog, vs);
-				const shaders = gl.getAttachedShaders(prog);
-				expect(shaders.length).toBe(1);
-				expect(shaders.includes(fs)).toBeTruthy();
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-		});
-		await describe("conformance/programs/program-test: linkProgram / useProgram", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("valid program should link", async () => {
-				const prog = linkProgram(gl, VS_COLOR_ATTRIB, FS_VARYING_COLOR, [["aVertex", 0], ["aColor", 1]]);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeTruthy();
-				expect(typeof gl.getProgramInfoLog(prog)).toBe("string");
-				gl.deleteProgram(prog);
-			});
-			await it("program with no fragment shader should fail to link", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.linkProgram(prog);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeFalsy();
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-			});
-			await it("program with no vertex shader should fail to link", async () => {
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_VARYING_COLOR);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, fs);
-				gl.linkProgram(prog);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeFalsy();
-				gl.deleteProgram(prog);
-				gl.deleteShader(fs);
-			});
-			await it("using a valid program should succeed", async () => {
-				const prog = linkProgram(gl, VS_COLOR_ATTRIB, FS_VARYING_COLOR, [["aVertex", 0], ["aColor", 1]]);
-				gl.useProgram(prog);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-				gl.useProgram(null);
-				gl.deleteProgram(prog);
-			});
-			await it("using an invalid (unlinked) program should generate INVALID_OPERATION", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_COLOR_ATTRIB);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.linkProgram(prog);
-				gl.useProgram(prog);
-				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-			});
-			await it("drawing with null program generates INVALID_OPERATION", async () => {
-				const prog = linkProgram(gl, VS_POSITION, FS_RED, [["a_position", 0]]);
-				const fbo = makeTestFBO(gl, 2, 2);
-				const buf = gl.createBuffer();
-				gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-					0,
-					0,
-					1,
-					0,
-					0,
-					1
-				]), gl.STATIC_DRAW);
-				gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-				gl.enableVertexAttribArray(0);
-				gl.useProgram(null);
-				gl.drawArrays(gl.TRIANGLES, 0, 3);
-				expect(gl.getError()).toBe(gl.INVALID_OPERATION);
-				gl.disableVertexAttribArray(0);
-				gl.deleteBuffer(buf);
-				destroyTestFBO(gl, fbo);
-				gl.deleteProgram(prog);
-			});
-		});
-		await describe("conformance/programs/program-test: deleteProgram / deleteShader", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("deleting the current program does not affect the current rendering state", async () => {
-				const prog = linkProgram(gl, VS_POSITION, FS_RED, [["a_position", 0]]);
-				gl.useProgram(prog);
-				gl.deleteProgram(prog);
-				const fbo = makeTestFBO(gl, 2, 2);
-				const pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-				expect(pixelClose(pixel, [
-					255,
-					0,
-					0,
-					255
-				])).toBeTruthy();
-				destroyTestFBO(gl, fbo);
-				gl.useProgram(null);
-			});
-			await it("unattached deleted shader is invalid immediately", async () => {
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_RED);
-				gl.deleteShader(fs);
-				gl.compileShader(fs);
-				expect(gl.getError()).toBe(gl.INVALID_VALUE);
-			});
-			await it("attached deleted shader is still valid while attached", async () => {
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_POSITION);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_RED);
-				const prog = linkProgram(gl, VS_POSITION, FS_RED, [["a_position", 0]]);
-				gl.attachShader(prog, vs);
-				gl.getError();
-				const fs3 = compileShader(gl, gl.FRAGMENT_SHADER, FS_GREEN);
-				const prog2 = gl.createProgram();
-				gl.attachShader(prog2, vs);
-				gl.attachShader(prog2, fs3);
-				gl.deleteShader(fs3);
-				gl.compileShader(fs3);
-				expect(gl.getShaderParameter(fs3, gl.COMPILE_STATUS)).toBeTruthy();
-				gl.deleteProgram(prog);
-				gl.deleteProgram(prog2);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-		});
-		await describe("conformance/programs/program-test: relink updates rendering", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("relinking with a new fragment shader updates the program output", async () => {
-				const fbo = makeTestFBO(gl, 2, 2);
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_POSITION);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_RED);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.attachShader(prog, fs);
-				gl.bindAttribLocation(prog, 0, "a_position");
-				gl.linkProgram(prog);
-				gl.useProgram(prog);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeTruthy();
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				let pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(pixelClose(pixel, [
-					255,
-					0,
-					0,
-					255
-				])).toBeTruthy();
-				gl.shaderSource(fs, FS_GREEN);
-				gl.compileShader(fs);
-				gl.linkProgram(prog);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeTruthy();
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(pixelClose(pixel, [
-					0,
-					255,
-					0,
-					255
-				])).toBeTruthy();
-				destroyTestFBO(gl, fbo);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-			await it("relinking clears uniforms — output should be transparent black", async () => {
-				const fbo = makeTestFBO(gl, 2, 2);
-				const vs = compileShader(gl, gl.VERTEX_SHADER, VS_POSITION);
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_SETTABLE);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.attachShader(prog, fs);
-				gl.bindAttribLocation(prog, 0, "a_position");
-				gl.linkProgram(prog);
-				gl.useProgram(prog);
-				const colorLoc = gl.getUniformLocation(prog, "u_color");
-				gl.uniform4f(colorLoc, 1, 0, 0, 1);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				let pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(pixelClose(pixel, [
-					255,
-					0,
-					0,
-					255
-				])).toBeTruthy();
-				gl.linkProgram(prog);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(pixelClose(pixel, [
-					0,
-					0,
-					0,
-					0
-				])).toBeTruthy();
-				destroyTestFBO(gl, fbo);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-		});
-		await describe("conformance/programs/gl-shader-test", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("creating a GEOMETRY shader should return null", async () => {
-				const GEOMETRY_SHADER_ARB = 36313;
-				const shader = gl.createShader(GEOMETRY_SHADER_ARB);
-				expect(shader).toBeNull();
-			});
-			await it("deferred compilation: shader linked with source set after first compile", async () => {
-				const fbo = makeTestFBO(gl, 2, 2);
-				const vs = compileShader(gl, gl.VERTEX_SHADER, "attribute vec4 vPosition; void main() { gl_Position = vPosition; }");
-				const fs = compileShader(gl, gl.FRAGMENT_SHADER, FS_GREEN);
-				gl.shaderSource(fs, FS_RED);
-				const prog = gl.createProgram();
-				gl.attachShader(prog, vs);
-				gl.attachShader(prog, fs);
-				gl.bindAttribLocation(prog, 0, "vPosition");
-				gl.linkProgram(prog);
-				gl.useProgram(prog);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				const pixel = drawFullscreenAndRead(gl, prog, 0);
-				expect(pixelClose(pixel, [
-					255,
-					0,
-					0,
-					255
-				])).toBeTruthy();
-				destroyTestFBO(gl, fbo);
-				gl.deleteProgram(prog);
-				gl.deleteShader(vs);
-				gl.deleteShader(fs);
-			});
-		});
-		await describe("conformance/programs/get-active-test: getActiveAttrib", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("getActiveAttrib returns correct info for standard attribs", async () => {
-				const prog = linkProgram(gl, VS_STANDARD, FS_STANDARD);
-				expect(gl.getProgramParameter(prog, gl.LINK_STATUS)).toBeTruthy();
-				const count = gl.getProgramParameter(prog, gl.ACTIVE_ATTRIBUTES);
-				expect(count).toBe(2);
-				const infos = [];
-				for (let i = 0; i < count; i++) {
-					const info = gl.getActiveAttrib(prog, i);
-					expect(info).not.toBeNull();
-					infos.push(info);
-				}
-				const names = infos.map((i) => i.name).sort();
-				expect(names).toContain("a_vertex");
-				expect(names).toContain("a_normal");
-				const vertexInfo = infos.find((i) => i.name === "a_vertex");
-				expect(vertexInfo.type).toBe(gl.FLOAT_VEC4);
-				expect(vertexInfo.size).toBe(1);
-				const normalInfo = infos.find((i) => i.name === "a_normal");
-				expect(normalInfo.type).toBe(gl.FLOAT_VEC3);
-				expect(normalInfo.size).toBe(1);
-				gl.deleteProgram(prog);
-			});
-			await it("getActiveAttrib with out-of-range index returns null and INVALID_VALUE", async () => {
-				const prog = linkProgram(gl, VS_STANDARD, FS_STANDARD);
-				const count = gl.getProgramParameter(prog, gl.ACTIVE_ATTRIBUTES);
-				const result = gl.getActiveAttrib(prog, count);
-				expect(result).toBeNull();
-				expect(gl.getError()).toBe(gl.INVALID_VALUE);
-				gl.deleteProgram(prog);
-			});
-			await it("getActiveAttrib with null program throws", async () => {
-				expect(() => gl.getActiveAttrib(null, 0)).toThrow();
-			});
-		});
-		await describe("conformance/programs/get-active-test: getActiveUniform", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("getActiveUniform returns correct info for u_modelViewProjMatrix", async () => {
-				const prog = linkProgram(gl, VS_STANDARD, FS_STANDARD);
-				const count = gl.getProgramParameter(prog, gl.ACTIVE_UNIFORMS);
-				expect(count).toBeGreaterThan(0);
-				let found = null;
-				for (let i = 0; i < count; i++) {
-					const info = gl.getActiveUniform(prog, i);
-					if (info?.name === "u_modelViewProjMatrix") found = info;
-				}
-				expect(found).not.toBeNull();
-				expect(found.type).toBe(gl.FLOAT_MAT4);
-				expect(found.size).toBe(1);
-				gl.deleteProgram(prog);
-			});
-			await it("getActiveUniform with out-of-range index returns null and INVALID_VALUE", async () => {
-				const prog = linkProgram(gl, VS_STANDARD, FS_STANDARD);
-				const count = gl.getProgramParameter(prog, gl.ACTIVE_UNIFORMS);
-				const result = gl.getActiveUniform(prog, count);
-				expect(result).toBeNull();
-				expect(gl.getError()).toBe(gl.INVALID_VALUE);
-				gl.deleteProgram(prog);
-			});
-			await it("getActiveUniform with null program throws", async () => {
-				expect(() => gl.getActiveUniform(null, 0)).toThrow();
-			});
-		});
-		win.destroy();
-	});
-};
-
-//#endregion
-export { programs_spec_default as default };
+    void main() { gl_FragColor = vec4(1.0); }`;function _(e,t,n){let r=e.createShader(t);return e.shaderSource(r,n),e.compileShader(r),r}function v(e,t,n,r){let i=_(e,e.VERTEX_SHADER,t),a=_(e,e.FRAGMENT_SHADER,n),o=e.createProgram();if(e.attachShader(o,i),e.attachShader(o,a),r)for(let[t,n]of r)e.bindAttribLocation(o,n,t);return e.linkProgram(o),o}function y(e,t,n=`a_position`){let i=typeof n==`string`?e.getAttribLocation(t,n):n,a=e.createBuffer();return e.bindBuffer(e.ARRAY_BUFFER,a),e.bufferData(e.ARRAY_BUFFER,new Float32Array([-4,-4,4,-4,0,4]),e.STREAM_DRAW),e.enableVertexAttribArray(i),e.vertexAttribPointer(i,2,e.FLOAT,!1,0,0),e.drawArrays(e.TRIANGLES,0,3),e.disableVertexAttribArray(i),e.deleteBuffer(a),r(e,0,0)}var b=async()=>{await l(`Display`,async()=>{let r=i();if(!r){console.warn(`WebGL context not available — skipping conformance/programs tests`);return}let{gl:l,glArea:b,win:x}=r;b.make_current(),await o(`conformance/programs/program-test: compileShader`,async()=>{a(async()=>{b.make_current()}),await c(`good vertex shader should compile`,async()=>{let e=_(l,l.VERTEX_SHADER,`attribute vec4 aVertex; void main() { gl_Position = aVertex; }`);s(l.getShaderParameter(e,l.COMPILE_STATUS)).toBeTruthy(),l.deleteShader(e)}),await c(`good fragment shader should compile`,async()=>{let e=_(l,l.FRAGMENT_SHADER,`precision mediump float; void main() { gl_FragColor = vec4(1.0); }`);s(l.getShaderParameter(e,l.COMPILE_STATUS)).toBeTruthy(),l.deleteShader(e)}),await c(`getShaderParameter with desktop-only INFO_LOG_LENGTH returns null and INVALID_ENUM`,async()=>{let e=_(l,l.VERTEX_SHADER,`attribute vec4 v; void main() { gl_Position = v; }`);s(l.getShaderParameter(e,35716)).toBeNull(),s(l.getError()).toBe(l.INVALID_ENUM),l.deleteShader(e)})}),await o(`conformance/programs/program-test: attachShader / detachShader`,async()=>{a(async()=>{b.make_current()}),await c(`attaching a vertex shader succeeds`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=l.createProgram();l.attachShader(t,e),s(l.getError()).toBe(l.NO_ERROR),l.deleteProgram(t),l.deleteShader(e)}),await c(`attaching the same shader twice generates INVALID_OPERATION`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=l.createProgram();l.attachShader(t,e),l.getError(),l.attachShader(t,e),s(l.getError()).toBe(l.INVALID_OPERATION),l.deleteProgram(t),l.deleteShader(e)}),await c(`attaching two vertex shaders to same program generates INVALID_OPERATION`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=_(l,l.VERTEX_SHADER,`attribute vec4 v; void main() { gl_Position = v * 0.5; }`),n=l.createProgram();l.attachShader(n,e),l.getError(),l.attachShader(n,t),s(l.getError()).toBe(l.INVALID_OPERATION),l.deleteProgram(n),l.deleteShader(e),l.deleteShader(t)}),await c(`detaching an attached shader succeeds`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=l.createProgram();l.attachShader(t,e),l.detachShader(t,e),s(l.getError()).toBe(l.NO_ERROR),l.deleteProgram(t),l.deleteShader(e)}),await c(`detaching a non-attached shader generates INVALID_OPERATION`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=_(l,l.FRAGMENT_SHADER,f),n=l.createProgram();l.attachShader(n,t),l.getError(),l.detachShader(n,e),s(l.getError()).toBe(l.INVALID_OPERATION),l.deleteProgram(n),l.deleteShader(e),l.deleteShader(t)})}),await o(`conformance/programs/program-test: getAttachedShaders`,async()=>{a(async()=>{b.make_current()}),await c(`empty program returns empty list`,async()=>{let e=l.createProgram();s(l.getAttachedShaders(e)?.length).toBe(0),l.deleteProgram(e)}),await c(`attached shaders appear in getAttachedShaders`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=_(l,l.FRAGMENT_SHADER,f),n=l.createProgram();l.attachShader(n,e),l.attachShader(n,t);let r=l.getAttachedShaders(n);s(r.length).toBe(2),s(r.includes(e)).toBeTruthy(),s(r.includes(t)).toBeTruthy(),l.deleteProgram(n),l.deleteShader(e),l.deleteShader(t)}),await c(`detached shaders are removed from getAttachedShaders`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=_(l,l.FRAGMENT_SHADER,f),n=l.createProgram();l.attachShader(n,e),l.attachShader(n,t),l.detachShader(n,e);let r=l.getAttachedShaders(n);s(r.length).toBe(1),s(r.includes(t)).toBeTruthy(),l.deleteProgram(n),l.deleteShader(e),l.deleteShader(t)})}),await o(`conformance/programs/program-test: linkProgram / useProgram`,async()=>{a(async()=>{b.make_current()}),await c(`valid program should link`,async()=>{let e=v(l,d,f,[[`aVertex`,0],[`aColor`,1]]);s(l.getProgramParameter(e,l.LINK_STATUS)).toBeTruthy(),s(typeof l.getProgramInfoLog(e)).toBe(`string`),l.deleteProgram(e)}),await c(`program with no fragment shader should fail to link`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=l.createProgram();l.attachShader(t,e),l.linkProgram(t),s(l.getProgramParameter(t,l.LINK_STATUS)).toBeFalsy(),l.deleteProgram(t),l.deleteShader(e)}),await c(`program with no vertex shader should fail to link`,async()=>{let e=_(l,l.FRAGMENT_SHADER,f),t=l.createProgram();l.attachShader(t,e),l.linkProgram(t),s(l.getProgramParameter(t,l.LINK_STATUS)).toBeFalsy(),l.deleteProgram(t),l.deleteShader(e)}),await c(`using a valid program should succeed`,async()=>{let e=v(l,d,f,[[`aVertex`,0],[`aColor`,1]]);l.useProgram(e),s(l.getError()).toBe(l.NO_ERROR),l.useProgram(null),l.deleteProgram(e)}),await c(`using an invalid (unlinked) program should generate INVALID_OPERATION`,async()=>{let e=_(l,l.VERTEX_SHADER,d),t=l.createProgram();l.attachShader(t,e),l.linkProgram(t),l.useProgram(t),s(l.getError()).toBe(l.INVALID_OPERATION),l.deleteProgram(t),l.deleteShader(e)}),await c(`drawing with null program generates INVALID_OPERATION`,async()=>{let n=v(l,u,p,[[`a_position`,0]]),r=t(l,2,2),i=l.createBuffer();l.bindBuffer(l.ARRAY_BUFFER,i),l.bufferData(l.ARRAY_BUFFER,new Float32Array([0,0,1,0,0,1]),l.STATIC_DRAW),l.vertexAttribPointer(0,2,l.FLOAT,!1,0,0),l.enableVertexAttribArray(0),l.useProgram(null),l.drawArrays(l.TRIANGLES,0,3),s(l.getError()).toBe(l.INVALID_OPERATION),l.disableVertexAttribArray(0),l.deleteBuffer(i),e(l,r),l.deleteProgram(n)})}),await o(`conformance/programs/program-test: deleteProgram / deleteShader`,async()=>{a(async()=>{b.make_current()}),await c(`deleting the current program does not affect the current rendering state`,async()=>{let r=v(l,u,p,[[`a_position`,0]]);l.useProgram(r),l.deleteProgram(r);let i=t(l,2,2),a=y(l,r,0);s(l.getError()).toBe(l.NO_ERROR),s(n(a,[255,0,0,255])).toBeTruthy(),e(l,i),l.useProgram(null)}),await c(`unattached deleted shader is invalid immediately`,async()=>{let e=_(l,l.FRAGMENT_SHADER,p);l.deleteShader(e),l.compileShader(e),s(l.getError()).toBe(l.INVALID_VALUE)}),await c(`attached deleted shader is still valid while attached`,async()=>{let e=_(l,l.VERTEX_SHADER,u),t=_(l,l.FRAGMENT_SHADER,p),n=v(l,u,p,[[`a_position`,0]]);l.attachShader(n,e),l.getError();let r=_(l,l.FRAGMENT_SHADER,m),i=l.createProgram();l.attachShader(i,e),l.attachShader(i,r),l.deleteShader(r),l.compileShader(r),s(l.getShaderParameter(r,l.COMPILE_STATUS)).toBeTruthy(),l.deleteProgram(n),l.deleteProgram(i),l.deleteShader(e),l.deleteShader(t)})}),await o(`conformance/programs/program-test: relink updates rendering`,async()=>{a(async()=>{b.make_current()}),await c(`relinking with a new fragment shader updates the program output`,async()=>{let r=t(l,2,2),i=_(l,l.VERTEX_SHADER,u),a=_(l,l.FRAGMENT_SHADER,p),o=l.createProgram();l.attachShader(o,i),l.attachShader(o,a),l.bindAttribLocation(o,0,`a_position`),l.linkProgram(o),l.useProgram(o),s(l.getProgramParameter(o,l.LINK_STATUS)).toBeTruthy(),l.clear(l.COLOR_BUFFER_BIT);let c=y(l,o,0);s(n(c,[255,0,0,255])).toBeTruthy(),l.shaderSource(a,m),l.compileShader(a),l.linkProgram(o),s(l.getProgramParameter(o,l.LINK_STATUS)).toBeTruthy(),l.clear(l.COLOR_BUFFER_BIT),c=y(l,o,0),s(n(c,[0,255,0,255])).toBeTruthy(),e(l,r),l.deleteProgram(o),l.deleteShader(i),l.deleteShader(a)}),await c(`relinking clears uniforms — output should be transparent black`,async()=>{let r=t(l,2,2),i=_(l,l.VERTEX_SHADER,u),a=_(l,l.FRAGMENT_SHADER,`precision mediump float; uniform vec4 u_color; void main() { gl_FragColor = u_color; }`),o=l.createProgram();l.attachShader(o,i),l.attachShader(o,a),l.bindAttribLocation(o,0,`a_position`),l.linkProgram(o),l.useProgram(o);let c=l.getUniformLocation(o,`u_color`);l.uniform4f(c,1,0,0,1),l.clear(l.COLOR_BUFFER_BIT);let d=y(l,o,0);s(n(d,[255,0,0,255])).toBeTruthy(),l.linkProgram(o),l.clear(l.COLOR_BUFFER_BIT),d=y(l,o,0),s(n(d,[0,0,0,0])).toBeTruthy(),e(l,r),l.deleteProgram(o),l.deleteShader(i),l.deleteShader(a)})}),await o(`conformance/programs/gl-shader-test`,async()=>{a(async()=>{b.make_current()}),await c(`creating a GEOMETRY shader should return null`,async()=>{s(l.createShader(36313)).toBeNull()}),await c(`deferred compilation: shader linked with source set after first compile`,async()=>{let r=t(l,2,2),i=_(l,l.VERTEX_SHADER,`attribute vec4 vPosition; void main() { gl_Position = vPosition; }`),a=_(l,l.FRAGMENT_SHADER,m);l.shaderSource(a,p);let o=l.createProgram();l.attachShader(o,i),l.attachShader(o,a),l.bindAttribLocation(o,0,`vPosition`),l.linkProgram(o),l.useProgram(o),l.clear(l.COLOR_BUFFER_BIT),s(n(y(l,o,0),[255,0,0,255])).toBeTruthy(),e(l,r),l.deleteProgram(o),l.deleteShader(i),l.deleteShader(a)})}),await o(`conformance/programs/get-active-test: getActiveAttrib`,async()=>{a(async()=>{b.make_current()}),await c(`getActiveAttrib returns correct info for standard attribs`,async()=>{let e=v(l,h,g);s(l.getProgramParameter(e,l.LINK_STATUS)).toBeTruthy();let t=l.getProgramParameter(e,l.ACTIVE_ATTRIBUTES);s(t).toBe(2);let n=[];for(let r=0;r<t;r++){let t=l.getActiveAttrib(e,r);s(t).not.toBeNull(),n.push(t)}let r=n.map(e=>e.name).sort();s(r).toContain(`a_vertex`),s(r).toContain(`a_normal`);let i=n.find(e=>e.name===`a_vertex`);s(i.type).toBe(l.FLOAT_VEC4),s(i.size).toBe(1);let a=n.find(e=>e.name===`a_normal`);s(a.type).toBe(l.FLOAT_VEC3),s(a.size).toBe(1),l.deleteProgram(e)}),await c(`getActiveAttrib with out-of-range index returns null and INVALID_VALUE`,async()=>{let e=v(l,h,g),t=l.getProgramParameter(e,l.ACTIVE_ATTRIBUTES);s(l.getActiveAttrib(e,t)).toBeNull(),s(l.getError()).toBe(l.INVALID_VALUE),l.deleteProgram(e)}),await c(`getActiveAttrib with null program throws`,async()=>{s(()=>l.getActiveAttrib(null,0)).toThrow()})}),await o(`conformance/programs/get-active-test: getActiveUniform`,async()=>{a(async()=>{b.make_current()}),await c(`getActiveUniform returns correct info for u_modelViewProjMatrix`,async()=>{let e=v(l,h,g),t=l.getProgramParameter(e,l.ACTIVE_UNIFORMS);s(t).toBeGreaterThan(0);let n=null;for(let r=0;r<t;r++){let t=l.getActiveUniform(e,r);t?.name===`u_modelViewProjMatrix`&&(n=t)}s(n).not.toBeNull(),s(n.type).toBe(l.FLOAT_MAT4),s(n.size).toBe(1),l.deleteProgram(e)}),await c(`getActiveUniform with out-of-range index returns null and INVALID_VALUE`,async()=>{let e=v(l,h,g),t=l.getProgramParameter(e,l.ACTIVE_UNIFORMS);s(l.getActiveUniform(e,t)).toBeNull(),s(l.getError()).toBe(l.INVALID_VALUE),l.deleteProgram(e)}),await c(`getActiveUniform with null program throws`,async()=>{s(()=>l.getActiveUniform(null,0)).toThrow()})}),x.destroy()})};export{b as default};

package/lib/esm/conformance/rendering-basic.spec.js

@@ -1,142 +1,4 @@
-import { destroyTestFBO, drawTriangle, makeProgram, makeTestFBO, pixelClose } from "../test-utils.js";
-import { createGLSetup } from "./setup.js";
-import { beforeEach, describe, expect, it, on } from "@gjsify/unit";
-
-//#region src/ts/conformance/rendering-basic.spec.ts
-const VS_SRC = `
+import{destroyTestFBO as e,drawTriangle as t,makeProgram as n,makeTestFBO as r,pixelClose as i}from"../test-utils.js";import{createGLSetup as a}from"./setup.js";import{beforeEach as o,describe as s,expect as c,it as l,on as u}from"@gjsify/unit";const d=`
     attribute vec2 position;
-    void main() { gl_Position = vec4(position, 0.0, 1.0); }`;
-const FS_GREEN = `
-    void main() { gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); }`;
-var rendering_basic_spec_default = async () => {
-	await on("Display", async () => {
-		const setup = createGLSetup();
-		if (!setup) {
-			console.warn("WebGL context not available — skipping conformance/rendering-basic tests");
-			return;
-		}
-		const { gl, glArea } = setup;
-		glArea.make_current();
-		await describe("rendering-basic/clear-color", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			const W = 10, H = 10;
-			function testColor(r, g, b, a) {
-				const fbo = makeTestFBO(gl, W, H);
-				gl.clearColor(r / 255, g / 255, b / 255, a / 255);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				const pixels = new Uint8Array(W * H * 4);
-				gl.readPixels(0, 0, W, H, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-				destroyTestFBO(gl, fbo);
-				for (let i = 0; i < W * H * 4; i += 4) {
-					if (pixels[i] !== r || pixels[i + 1] !== g || pixels[i + 2] !== b || pixels[i + 3] !== a) return false;
-				}
-				return true;
-			}
-			await it("clearColor black (0,0,0,0) fills all pixels", async () => {
-				expect(testColor(0, 0, 0, 0)).toBe(true);
-			});
-			await it("clearColor white (255,255,255,255) fills all pixels", async () => {
-				expect(testColor(255, 255, 255, 255)).toBe(true);
-			});
-			await it("clearColor green (0,255,0,255) fills all pixels", async () => {
-				expect(testColor(0, 255, 0, 255)).toBe(true);
-			});
-			await it("clearColor magenta (255,0,255,0) fills all pixels", async () => {
-				expect(testColor(255, 0, 255, 0)).toBe(true);
-			});
-		});
-		await describe("rendering-basic/simple-shader", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("fullscreen green triangle covers every pixel", async () => {
-				const W = 50, H = 50;
-				const fbo = makeTestFBO(gl, W, H);
-				gl.clearColor(0, 0, 0, 0);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				const prog = makeProgram(gl, VS_SRC, FS_GREEN);
-				gl.useProgram(prog);
-				drawTriangle(gl);
-				const pixels = new Uint8Array(W * H * 4);
-				gl.readPixels(0, 0, W, H, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-				destroyTestFBO(gl, fbo);
-				let allGreen = true;
-				for (let i = 0; i < W * H * 4; i += 4) {
-					if (!pixelClose(pixels.subarray(i, i + 4), [
-						0,
-						255,
-						0,
-						255
-					])) {
-						allGreen = false;
-						break;
-					}
-				}
-				expect(allGreen).toBe(true);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-			});
-		});
-		await describe("rendering-basic/draw-indexed", async () => {
-			beforeEach(async () => {
-				glArea.make_current();
-			});
-			await it("drawElements covers every pixel with green", async () => {
-				const W = 50, H = 50;
-				const fbo = makeTestFBO(gl, W, H);
-				gl.clearColor(1, 0, 0, 1);
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				const prog = makeProgram(gl, VS_SRC, FS_GREEN);
-				gl.useProgram(prog);
-				const vbuffer = gl.createBuffer();
-				gl.bindBuffer(gl.ARRAY_BUFFER, vbuffer);
-				gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-					-1,
-					-1,
-					1,
-					-1,
-					-1,
-					1,
-					1,
-					1
-				]), gl.STATIC_DRAW);
-				gl.enableVertexAttribArray(0);
-				gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-				const ebuffer = gl.createBuffer();
-				gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebuffer);
-				gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array([
-					0,
-					1,
-					2,
-					2,
-					1,
-					3
-				]), gl.STATIC_DRAW);
-				gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-				const pixels = new Uint8Array(W * H * 4);
-				gl.readPixels(0, 0, W, H, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-				gl.deleteBuffer(vbuffer);
-				gl.deleteBuffer(ebuffer);
-				destroyTestFBO(gl, fbo);
-				let allGreen = true;
-				for (let i = 0; i < W * H * 4; i += 4) {
-					if (!pixelClose(pixels.subarray(i, i + 4), [
-						0,
-						255,
-						0,
-						255
-					])) {
-						allGreen = false;
-						break;
-					}
-				}
-				expect(allGreen).toBe(true);
-				expect(gl.getError()).toBe(gl.NO_ERROR);
-			});
-		});
-	});
-};
-
-//#endregion
-export { rendering_basic_spec_default as default };
+    void main() { gl_Position = vec4(position, 0.0, 1.0); }`,f=`
+    void main() { gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); }`;var p=async()=>{await u(`Display`,async()=>{let u=a();if(!u){console.warn(`WebGL context not available — skipping conformance/rendering-basic tests`);return}let{gl:p,glArea:m}=u;m.make_current(),await s(`rendering-basic/clear-color`,async()=>{o(async()=>{m.make_current()});function t(t,n,i,a){let o=r(p,10,10);p.clearColor(t/255,n/255,i/255,a/255),p.clear(p.COLOR_BUFFER_BIT);let s=new Uint8Array(400);p.readPixels(0,0,10,10,p.RGBA,p.UNSIGNED_BYTE,s),e(p,o);for(let e=0;e<400;e+=4)if(s[e]!==t||s[e+1]!==n||s[e+2]!==i||s[e+3]!==a)return!1;return!0}await l(`clearColor black (0,0,0,0) fills all pixels`,async()=>{c(t(0,0,0,0)).toBe(!0)}),await l(`clearColor white (255,255,255,255) fills all pixels`,async()=>{c(t(255,255,255,255)).toBe(!0)}),await l(`clearColor green (0,255,0,255) fills all pixels`,async()=>{c(t(0,255,0,255)).toBe(!0)}),await l(`clearColor magenta (255,0,255,0) fills all pixels`,async()=>{c(t(255,0,255,0)).toBe(!0)})}),await s(`rendering-basic/simple-shader`,async()=>{o(async()=>{m.make_current()}),await l(`fullscreen green triangle covers every pixel`,async()=>{let a=r(p,50,50);p.clearColor(0,0,0,0),p.clear(p.COLOR_BUFFER_BIT);let o=n(p,d,f);p.useProgram(o),t(p);let s=new Uint8Array(2500*4);p.readPixels(0,0,50,50,p.RGBA,p.UNSIGNED_BYTE,s),e(p,a);let l=!0;for(let e=0;e<2500*4;e+=4)if(!i(s.subarray(e,e+4),[0,255,0,255])){l=!1;break}c(l).toBe(!0),c(p.getError()).toBe(p.NO_ERROR)})}),await s(`rendering-basic/draw-indexed`,async()=>{o(async()=>{m.make_current()}),await l(`drawElements covers every pixel with green`,async()=>{let t=r(p,50,50);p.clearColor(1,0,0,1),p.clear(p.COLOR_BUFFER_BIT);let a=n(p,d,f);p.useProgram(a);let o=p.createBuffer();p.bindBuffer(p.ARRAY_BUFFER,o),p.bufferData(p.ARRAY_BUFFER,new Float32Array([-1,-1,1,-1,-1,1,1,1]),p.STATIC_DRAW),p.enableVertexAttribArray(0),p.vertexAttribPointer(0,2,p.FLOAT,!1,0,0);let s=p.createBuffer();p.bindBuffer(p.ELEMENT_ARRAY_BUFFER,s),p.bufferData(p.ELEMENT_ARRAY_BUFFER,new Uint16Array([0,1,2,2,1,3]),p.STATIC_DRAW),p.drawElements(p.TRIANGLES,6,p.UNSIGNED_SHORT,0);let l=new Uint8Array(2500*4);p.readPixels(0,0,50,50,p.RGBA,p.UNSIGNED_BYTE,l),p.deleteBuffer(o),p.deleteBuffer(s),e(p,t);let u=!0;for(let e=0;e<2500*4;e+=4)if(!i(l.subarray(e,e+4),[0,255,0,255])){u=!1;break}c(u).toBe(!0),c(p.getError()).toBe(p.NO_ERROR)})})})};export{p as default};