@flighthq/render-gl 0.3.0 → 0.3.1-next.1041.35b950c

package/src/glShader.test.ts

@@ -233,6 +233,34 @@ describe('setGlBaseUniforms', () => {
 });
 
 describe('setGlMatrixFromTransform', () => {
+  it('projects the quad corner order to a clockwise triangle, which is why 2D draws need culling off', () => {
+    // Measured in a real WebGL2 context, not argued: with CULL_FACE enabled and the CCW default, this
+    // quad renders 0 lit pixels where it otherwise renders 2304 — a single-sided 3D draw earlier in the
+    // frame therefore erases all 2D content. `renderGlScene2D` disables CULL_FACE because of THIS, and
+    // without an assertion the reason lives only in a comment: someone who later made the winding CCW
+    // would find the disable looking superfluous. The corner order below mirrors the quadVertexData
+    // fill in glDraw.ts and must be changed with it.
+    const gl = makeGL();
+    const m = new Float32Array(9);
+    const canvas = document.createElement('canvas');
+    canvas.width = 200;
+    canvas.height = 100;
+    setGlMatrixFromTransform(gl, makeShaderLoc(), m, { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 }, canvas);
+
+    const project = (x: number, y: number): [number, number] => [
+      m[0] * x + m[3] * y + m[6],
+      m[1] * x + m[4] * y + m[7],
+    ];
+    const [x0, y0, x1, y1] = [20, 30, 120, 80];
+    const [ax, ay] = project(x0, y0);
+    const [bx, by] = project(x1, y0);
+    const [cx, cy] = project(x1, y1);
+
+    // Signed area of the first indexed triangle (indices [0, 1, 2]); negative is clockwise.
+    const signedArea = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    expect(signedArea).toBeLessThan(0);
+  });
+
   it('computes matrix scaled by canvas dimensions for identity transform', () => {
     const gl = makeGL();
     const loc = makeShaderLoc();

package/src/glTestHelper.test.ts

@@ -0,0 +1,51 @@
+import { makeGL } from './glTestHelper';
+
+describe('makeGL', () => {
+  it('keeps draw validation outside a test-installed mock implementation', () => {
+    const gl = makeGL();
+    const draw = vi.fn();
+    (gl.drawElements as ReturnType<typeof vi.fn>).mockImplementation(draw);
+
+    gl.drawElements(gl.TRIANGLES, 1, gl.UNSIGNED_SHORT, 1);
+
+    expect(draw).not.toHaveBeenCalled();
+    expect(gl.getError()).toBe(gl.INVALID_OPERATION);
+
+    gl.drawElements(gl.TRIANGLES, 1, gl.UNSIGNED_SHORT, 0);
+    expect(draw).toHaveBeenCalledOnce();
+  });
+
+  it('sets and consumes the first GL draw error without throwing', () => {
+    const gl = makeGL();
+
+    expect(() => gl.drawElements(gl.TRIANGLES, -1, gl.UNSIGNED_SHORT, 0)).not.toThrow();
+    gl.drawElements(0xffff, 1, gl.UNSIGNED_SHORT, 0);
+
+    expect(gl.drawElements).not.toHaveBeenCalled();
+    expect(gl.getError()).toBe(gl.INVALID_VALUE);
+    expect(gl.getError()).toBe(gl.NO_ERROR);
+  });
+
+  it('reports a type-misaligned index offset as INVALID_OPERATION', () => {
+    const gl = makeGL();
+
+    gl.drawElements(gl.TRIANGLES, 1, gl.UNSIGNED_SHORT, 1);
+
+    expect(gl.getError()).toBe(gl.INVALID_OPERATION);
+    expect(gl.getError()).toBe(gl.NO_ERROR);
+  });
+
+  it('validates non-indexed and instanced draw entry points', () => {
+    const gl = makeGL();
+
+    gl.drawArrays(0xffff, 0, 1);
+    expect(gl.getError()).toBe(gl.INVALID_ENUM);
+
+    gl.drawArraysInstanced(gl.TRIANGLES, 0, 1, -1);
+    expect(gl.getError()).toBe(gl.INVALID_VALUE);
+
+    gl.drawElementsInstanced(gl.TRIANGLES, 1, gl.FLOAT, 0, 1);
+    expect(gl.getError()).toBe(gl.INVALID_ENUM);
+    expect(gl.getError()).toBe(gl.NO_ERROR);
+  });
+});

package/src/glTextureResolver.test.ts

@@ -1,4 +1,5 @@
 import { createEntity } from '@flighthq/entity/contract';
+import { getRegistryTableKeys } from '@flighthq/registry/contract';
 import type { Image, RenderTexture, TextureLike, TextureSource } from '@flighthq/types/contract';
 import {
   BitmapTextureSourceKind,
@@ -80,11 +81,17 @@ function textureWithTarget(): TextureLike {
   return texture;
 }
 
+function registeredTextureSourceKinds(state: Parameters<typeof getGlRenderStateRuntime>[0]): string[] {
+  const kinds: string[] = [];
+  getRegistryTableKeys(kinds, getGlRenderStateRuntime(state).registries.textureResolvers);
+  return kinds;
+}
+
 describe('registerGlBitmapTextureResolver', () => {
   it('registers only the Bitmap source key', () => {
     const { state } = createGlState();
     registerGlBitmapTextureResolver(state);
-    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([BitmapTextureSourceKind]);
+    expect(registeredTextureSourceKinds(state)).toEqual([BitmapTextureSourceKind]);
   });
 });
 
@@ -92,9 +99,7 @@ describe('registerGlCompressedImageTextureResolver', () => {
   it('registers only the CompressedImage source key', () => {
     const { state } = createGlState();
     registerGlCompressedImageTextureResolver(state);
-    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([
-      CompressedImageTextureSourceKind,
-    ]);
+    expect(registeredTextureSourceKinds(state)).toEqual([CompressedImageTextureSourceKind]);
   });
 });
 
@@ -225,7 +230,7 @@ describe('registerGlTextureResolver', () => {
 
     registerGlTextureResolver(a, sourceKind, second);
     expect(resolveGlTexture(a, texture)).toEqual({ second: true });
-    expect(getGlRenderStateRuntime(a).glTextureResolverRegistry?.size).toBe(1);
+    expect(getGlRenderStateRuntime(a).registries.textureResolvers.entries.size).toBe(1);
 
     registerGlTextureResolver(a, sourceKind, null);
     expect(resolveGlTexture(a, texture)).toBeNull();
@@ -244,7 +249,7 @@ describe('registerStandardGlTextureResolvers', () => {
   it('registers bitmap, image, and render texture sources without compressed images', () => {
     const { state } = createGlState();
     registerStandardGlTextureResolvers(state);
-    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([
+    expect(registeredTextureSourceKinds(state)).toEqual([
       BitmapTextureSourceKind,
       ImageTextureSourceKind,
       RenderTargetTextureSourceKind,