@flighthq/scene3d-gl 0.2.1-next.840.857425c

package/src/unlitGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,88 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createUnlitMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy, VideoTexture } from '@flighthq/types';
+import { UnlitMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerUnlitGlMaterial, unlitGlMeshMaterialRenderer } from './unlitGlMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+const NO_LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(12),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createUnlitMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerUnlitGlMaterial', () => {
+  it('installs the renderer for UnlitMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerUnlitGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, UnlitMaterialKind)).toBe(unlitGlMeshMaterialRenderer);
+  });
+});
+
+describe('unlitGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull, view-projection, and the color uniform', () => {
+    const { state, gl } = makeGlScene3DState();
+    unlitGlMeshMaterialRenderer.bind(state, createUnlitMaterial(), NO_LIGHTS, makeCamera());
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'enable' && c.args[0] === gl.DEPTH_TEST)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+  });
+
+  it('binds a ready dynamic video map into the color-map slot', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createUnlitMaterial();
+    material.baseColorVideoMap = {
+      frameId: 1,
+      flipX: false,
+      flipY: false,
+      sampler: null,
+      source: {
+        element: { readyState: 4, videoHeight: 120, videoWidth: 160 } as HTMLVideoElement,
+      },
+      uvOffset: { x: 0, y: 0 },
+      uvRotation: 0,
+      uvScale: { x: 1, y: 1 },
+    } as unknown as VideoTexture;
+    unlitGlMeshMaterialRenderer.bind(state, material, NO_LIGHTS, makeCamera());
+    expect(gl.calls.some((c) => c.name === 'texImage2D')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    unlitGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    unlitGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const draw = gl.calls.find((c) => c.name === 'drawElements');
+    expect(draw).toBeDefined();
+    expect(draw!.args[1]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    unlitGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/vertexColorGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,60 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createVertexColorMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { VertexColorMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerVertexColorGlMaterial, vertexColorGlMeshMaterialRenderer } from './vertexColorGlMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+const NO_LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(12),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createVertexColorMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerVertexColorGlMaterial', () => {
+  it('installs the renderer for VertexColorMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerVertexColorGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, VertexColorMaterialKind)).toBe(vertexColorGlMeshMaterialRenderer);
+  });
+});
+
+describe('vertexColorGlMeshMaterialRenderer', () => {
+  it('bind compiles the vertex-color variant and uploads the tint', () => {
+    const { state, gl } = makeGlScene3DState();
+    vertexColorGlMeshMaterialRenderer.bind(state, createVertexColorMaterial(), NO_LIGHTS, makeCamera());
+    const shaderSources = gl.calls.filter((c) => c.name === 'shaderSource').map((c) => c.args[1] as string);
+    expect(shaderSources.some((s) => s.includes('#define VERTEX_COLOR'))).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    vertexColorGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    vertexColorGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+});

package/src/wireframeGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,69 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createWireframeMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { WireframeMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerWireframeGlMaterial, wireframeGlMeshMaterialRenderer } from './wireframeGlMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+const NO_LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(12),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createWireframeMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerWireframeGlMaterial', () => {
+  it('installs the renderer for WireframeMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerWireframeGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, WireframeMaterialKind)).toBe(wireframeGlMeshMaterialRenderer);
+  });
+});
+
+describe('wireframeGlMeshMaterialRenderer', () => {
+  it('bind selects the program, disables culling, and uploads the line color', () => {
+    const { state, gl } = makeGlScene3DState();
+    wireframeGlMeshMaterialRenderer.bind(state, createWireframeMaterial(), NO_LIGHTS, makeCamera());
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'disable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+  });
+
+  it('draw issues a LINES draw over the derived line range', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    wireframeGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    wireframeGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const draw = gl.calls.find((c) => c.name === 'drawElements');
+    expect(draw).toBeDefined();
+    // Line index count = triangle index count * 2.
+    expect(draw!.args[1]).toBe(proxy.subset.indexCount * 2);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    wireframeGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});