@flighthq/scene2d-wgpu 0.3.0-next.906.07cea63 → 0.3.0

package/src/wgpuScale9Shape.test.ts

@@ -9,7 +9,6 @@ import {
   destroyWgpuScale9ShapeData,
   drawWgpuScale9Shape,
   drawWgpuScale9ShapeMask,
-  remapWgpuScale9Commands,
 } from './wgpuScale9Shape';
 
 const grid = { height: 80, width: 80, x: 10, y: 10 };
@@ -83,15 +82,3 @@ describe('drawWgpuScale9ShapeMask', () => {
     submitWgpuRenderPass(state);
   });
 });
-
-describe('remapWgpuScale9Commands', () => {
-  it('remaps coordinates with a compatible mapper', () => {
-    const out: unknown[] = [];
-    remapWgpuScale9Commands(out, ['drawRectangle', 4, 10, 20, 50, 30], {
-      mapX: (x: number) => x * 2,
-      mapY: (y: number) => y * 3,
-    });
-
-    expect(out).toEqual(['drawRectangle', 4, 20, 60, 100, 90]);
-  });
-});

package/src/wgpuShape.test.ts

@@ -3,18 +3,33 @@ import type * as FlightNodeModule from '@flighthq/node/contract';
 import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
 import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import {
+  appendShapeBeginFill,
+  appendShapeEndFill,
+  appendShapePath,
+  appendShapeLineStyle,
+  appendShapeLineTo,
+  appendShapeMoveTo,
+  appendShapeRectangle,
+  createShape,
+} from '@flighthq/shape/contract';
 import type { RenderProxy2D } from '@flighthq/types/contract';
-import { BatchFormat } from '@flighthq/types/contract';
+import { BatchFormat, PathCommand } from '@flighthq/types/contract';
 
+import { enableWgpuStrokePathTessellation } from './enableWgpuStrokePathTessellation';
 import { scopeModuleMocks } from './moduleMockTestHelper';
 import type * as WgpuShapeModule from './wgpuShape';
-import { registerStandardWgpuMaterial } from './wgpuStandardMaterial';
+import { registerWgpuShapeRasterizer } from './wgpuShapeRasterizer';
+import { registerWgpuStandardMaterial } from './wgpuStandardMaterial';
+
+const noopRasterizer = (): void => {};
 
 // @flighthq/node's bounds/revision queries expect a real BoundsNode; these tests drive drawWgpuShape
 // with lightweight fake proxies, so the two queries are stubbed. scopeModuleMocks scopes the stub to
 // this file (registry reset before the mock applies, unmock + reset after), so under a shared
 // (isolate:false) worker it never leaks into the many real consumers of these functions (node,
 // interaction, shape, text) — and a sibling that pre-evaluated ./wgpuShape still picks up the stub.
+let defaultWgpuMorphShapeRenderer: typeof WgpuShapeModule.defaultWgpuMorphShapeRenderer;
 let defaultWgpuShapeRenderer: typeof WgpuShapeModule.defaultWgpuShapeRenderer;
 let drawWgpuShape: typeof WgpuShapeModule.drawWgpuShape;
 
@@ -26,16 +41,32 @@ beforeAll(async () => {
     getNodeLocalBoundsRectangle: () => ({ x: 0, y: 0, width: 64, height: 48 }),
     getNodeLocalContentRevision: (source: any) => source?.data?.version ?? 0,
   }));
-  ({ defaultWgpuShapeRenderer, drawWgpuShape } = await import('./wgpuShape'));
+  ({ defaultWgpuMorphShapeRenderer, defaultWgpuShapeRenderer, drawWgpuShape } = await import('./wgpuShape'));
   installWgpuMock();
 });
 
+// Mirrors createWgpuShapeData: the rasterization surface is absent until a shape actually needs one,
+// so a scene drawn entirely through the mesh path carries no canvases.
 function makeShapeData() {
-  const canvas = document.createElement('canvas');
-  canvas.width = 1;
-  canvas.height = 1;
-  const ctx = canvas.getContext('2d')!;
-  return { canvas, ctx, image: createImageResource(canvas), lastContentId: -1, lastW: 0, lastH: 0 };
+  return {
+    surface: null,
+    lastContentId: -1,
+    lastPixelRatio: 0,
+    lastW: 0,
+    lastH: 0,
+    meshVersion: -1,
+    meshes: null,
+    meshBuffers: {
+      vertexBuffers: [],
+      vertexCapacities: [],
+      indexBuffers: [],
+      indexCapacities: [],
+      uniformBuffers: [],
+      bindGroups: [],
+      colorScaleBiasUniformBuffers: [],
+      colorScaleBiasBindGroups: [],
+    },
+  };
 }
 
 function makeShapeProxy(data: Record<string, unknown> = {}, rendererData: unknown = null): RenderProxy2D {
@@ -50,7 +81,24 @@ function makeShapeProxy(data: Record<string, unknown> = {}, rendererData: unknow
   } as unknown as RenderProxy2D;
 }
 
+function makeMeshPassSpy(): GPURenderPassEncoder {
+  return {
+    setPipeline: vi.fn(),
+    setBindGroup: vi.fn(),
+    setVertexBuffer: vi.fn(),
+    setIndexBuffer: vi.fn(),
+    setStencilReference: vi.fn(),
+    draw: vi.fn(),
+    drawIndexed: vi.fn(),
+    end: vi.fn(),
+  } as unknown as GPURenderPassEncoder;
+}
+
 describe('defaultWgpuShapeRenderer', () => {
+  it('provides the MorphShape renderer alias', () => {
+    expect(defaultWgpuMorphShapeRenderer).toBe(defaultWgpuShapeRenderer);
+  });
+
   it('declares BatchFormat.Quad', () => {
     expect(defaultWgpuShapeRenderer.format).toBe(BatchFormat.Quad);
   });
@@ -62,35 +110,141 @@ describe('defaultWgpuShapeRenderer', () => {
 });
 
 describe('drawWgpuShape', () => {
+  it('draws a solid fill and open solid stroke as GPU meshes in one shape', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
+    renderWgpuBackground(state);
+    getWgpuRenderStateRuntime(state).renderPass = makeMeshPassSpy();
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0x00cc00);
+    appendShapeRectangle(shape, 8, 8, 32, 24);
+    appendShapeEndFill(shape);
+    appendShapeLineStyle(shape, 4, 0xff0000);
+    appendShapeMoveTo(shape, 8, 4);
+    appendShapeLineTo(shape, 40, 4);
+    const rendererData = defaultWgpuShapeRenderer.createData!(state, shape)!;
+
+    drawWgpuShape(state, makeShapeProxy({ commands: shape.data.commands, version: 1 }, rendererData));
+
+    const pass = getWgpuRenderStateRuntime(state).renderPass as unknown as {
+      drawIndexed: ReturnType<typeof vi.fn>;
+    };
+    expect(pass.drawIndexed).toHaveBeenCalledTimes(2);
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
+    submitWgpuRenderPass(state);
+  });
+
+  it('draws a closed solid stroke ring as one GPU mesh', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
+    enableWgpuStrokePathTessellation(state);
+    renderWgpuBackground(state);
+    getWgpuRenderStateRuntime(state).renderPass = makeMeshPassSpy();
+    const shape = createShape();
+    appendShapeLineStyle(shape, 8, 0xff0000);
+    appendShapeRectangle(shape, 8, 8, 32, 24);
+    const rendererData = defaultWgpuShapeRenderer.createData!(state, shape)!;
+
+    drawWgpuShape(state, makeShapeProxy({ commands: shape.data.commands, version: 1 }, rendererData));
+
+    const pass = getWgpuRenderStateRuntime(state).renderPass as unknown as {
+      drawIndexed: ReturnType<typeof vi.fn>;
+    };
+    expect(pass.drawIndexed).toHaveBeenCalledTimes(1);
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
+    submitWgpuRenderPass(state);
+  });
+
+  it('keeps a closed stroke on the raster lane until stroke-path tessellation is enabled', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
+    renderWgpuBackground(state);
+    registerWgpuStandardMaterial(state);
+    const pass = makeMeshPassSpy();
+    getWgpuRenderStateRuntime(state).renderPass = pass;
+    const shape = createShape();
+    appendShapeLineStyle(shape, 8, 0xff0000);
+    appendShapeRectangle(shape, 8, 8, 32, 24);
+    const rendererData = defaultWgpuShapeRenderer.createData!(state, shape)!;
+
+    drawWgpuShape(state, makeShapeProxy({ commands: shape.data.commands, version: 1 }, rendererData));
+
+    expect(pass.drawIndexed).not.toHaveBeenCalled();
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
+    submitWgpuRenderPass(state);
+  });
+
+  it('falls back to the raster quad for a self-intersecting stroke centerline', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
+    enableWgpuStrokePathTessellation(state);
+    renderWgpuBackground(state);
+    registerWgpuStandardMaterial(state);
+    const pass = makeMeshPassSpy();
+    getWgpuRenderStateRuntime(state).renderPass = pass;
+    const shape = createShape();
+    appendShapeLineStyle(shape, 8, 0xff0000);
+    appendShapePath(
+      shape,
+      [PathCommand.MOVE_TO, PathCommand.LINE_TO, PathCommand.LINE_TO, PathCommand.LINE_TO, PathCommand.CLOSE],
+      [8, 8, 40, 40, 8, 40, 40, 8],
+      'nonZero',
+    );
+    const rendererData = defaultWgpuShapeRenderer.createData!(state, shape)!;
+    const proxy = makeShapeProxy({ commands: shape.data.commands, version: 1 }, rendererData);
+
+    drawWgpuShape(state, proxy);
+    // The first draw rasterized, so the surface exists by now — it is allocated on demand, not with the node.
+    const canvas = (rendererData as unknown as { surface: { canvas: HTMLCanvasElement } }).surface.canvas;
+    let canvasWidth = canvas.width;
+    let canvasHeight = canvas.height;
+    const setWidth = vi.fn((value: number) => (canvasWidth = value));
+    const setHeight = vi.fn((value: number) => (canvasHeight = value));
+    Object.defineProperty(canvas, 'width', { configurable: true, get: () => canvasWidth, set: setWidth });
+    Object.defineProperty(canvas, 'height', { configurable: true, get: () => canvasHeight, set: setHeight });
+    (proxy.source as unknown as { data: { version: number } }).data.version = 2;
+    drawWgpuShape(state, proxy);
+
+    expect(pass.drawIndexed).not.toHaveBeenCalled();
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(2);
+    expect(setWidth).not.toHaveBeenCalled();
+    expect(setHeight).not.toHaveBeenCalled();
+    submitWgpuRenderPass(state);
+  });
+
   it('returns early without writing to batch when commands are empty', async () => {
     const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
     renderWgpuBackground(state);
-    registerStandardWgpuMaterial(state);
+    registerWgpuStandardMaterial(state);
     drawWgpuShape(state, makeShapeProxy({ commands: [] }, makeShapeData()));
-    expect(getWgpuRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
     submitWgpuRenderPass(state);
   });
 
   it('returns early without writing to batch when rendererData is null', async () => {
     const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
     renderWgpuBackground(state);
-    registerStandardWgpuMaterial(state);
+    registerWgpuStandardMaterial(state);
     drawWgpuShape(state, makeShapeProxy({ commands: [{}] }, null));
-    expect(getWgpuRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
     submitWgpuRenderPass(state);
   });
 
   it('does not throw when renderPass is null', async () => {
     const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
     expect(() => drawWgpuShape(state, makeShapeProxy({ commands: [{}] }, makeShapeData()))).not.toThrow();
   });
 
-  it('writes one instance to the sprite batch when shape has valid commands and bounds', async () => {
+  it('writes one instance to the quad-batch writer when shape has valid commands and bounds', async () => {
     const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, noopRasterizer);
     renderWgpuBackground(state);
-    registerStandardWgpuMaterial(state);
+    registerWgpuStandardMaterial(state);
     drawWgpuShape(state, makeShapeProxy({ commands: [{}], version: 1 }, makeShapeData()));
-    expect(getWgpuRenderStateRuntime(state).spriteBatchCount).toBe(1);
+    expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
     submitWgpuRenderPass(state);
   });
 });

package/src/wgpuShapeData.test.ts

@@ -0,0 +1,97 @@
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import type { WgpuShapeRendererData } from '@flighthq/types/contract';
+
+import {
+  acquireWgpuShapeRasterSurface,
+  createWgpuShapeData,
+  destroyWgpuShapeData,
+  getWgpuShapeData,
+} from './wgpuShapeData';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+function emptyData(): WgpuShapeRendererData {
+  return {
+    surface: null,
+    lastContentId: -1,
+    lastPixelRatio: 0,
+    lastW: 0,
+    lastH: 0,
+    meshVersion: -1,
+    meshes: null,
+    meshBuffers: {
+      vertexBuffers: [],
+      vertexCapacities: [],
+      indexBuffers: [],
+      indexCapacities: [],
+      uniformBuffers: [],
+      bindGroups: [],
+      colorScaleBiasUniformBuffers: [],
+      colorScaleBiasBindGroups: [],
+    },
+  };
+}
+
+describe('acquireWgpuShapeRasterSurface', () => {
+  it('allocates once and returns the same surface thereafter', () => {
+    const data = emptyData();
+    const first = acquireWgpuShapeRasterSurface(data);
+    expect(data.surface).toBe(first);
+    expect(acquireWgpuShapeRasterSurface(data)).toBe(first);
+  });
+
+  it('wraps the canvas as an Image so the quad batch treats it like any other texture source', () => {
+    const surface = acquireWgpuShapeRasterSurface(emptyData());
+    expect(surface.image.source).toBe(surface.canvas);
+  });
+});
+
+describe('createWgpuShapeData', () => {
+  it('allocates no canvas up front, so a mesh-only scene carries none', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const data = getWgpuShapeData(createWgpuShapeData(state, {} as never))!;
+    expect(data.surface).toBeNull();
+    expect(data.meshes).toBeNull();
+    expect(data.meshVersion).toBe(-1);
+  });
+});
+
+describe('destroyWgpuShapeData', () => {
+  it('does nothing when the shape only ever tessellated, since there is no surface to free', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const data = createWgpuShapeData(state, {} as never);
+    expect(() => destroyWgpuShapeData(state, data)).not.toThrow();
+  });
+
+  it('destroys the cached GPU texture keyed on the raster surface, and the mesh buffers', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const data = createWgpuShapeData(state, {} as never);
+    const shapeData = getWgpuShapeData(data)!;
+    const surface = acquireWgpuShapeRasterSurface(shapeData);
+    const destroy = vi.fn();
+    getWgpuRenderStateRuntime(state).textureSourcePremultipliedTextureCache.set(surface.image, {
+      texture: { destroy },
+    } as never);
+    const bufferDestroy = vi.fn();
+    shapeData.meshBuffers.vertexBuffers.push({ destroy: bufferDestroy } as never);
+    shapeData.meshBuffers.colorScaleBiasUniformBuffers.push({ destroy: bufferDestroy } as never);
+
+    destroyWgpuShapeData(state, data);
+
+    expect(destroy).toHaveBeenCalled();
+    expect(bufferDestroy).toHaveBeenCalled();
+    expect(shapeData.meshBuffers.vertexBuffers).toHaveLength(0);
+    expect(shapeData.meshBuffers.colorScaleBiasUniformBuffers).toHaveLength(0);
+  });
+});
+
+describe('getWgpuShapeData', () => {
+  it('reads the shape data back out of the opaque RendererData slot', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const data = createWgpuShapeData(state, {} as never);
+    expect(getWgpuShapeData(data)?.meshVersion).toBe(-1);
+  });
+});

package/src/wgpuShapeMesh.test.ts

@@ -1,11 +1,18 @@
 import { createMatrix } from '@flighthq/geometry/contract';
 import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
-import type { RenderProxy2D, WgpuRenderState, WgpuShapeMeshBuffers } from '@flighthq/types/contract';
+import type {
+  ColorScaleBias,
+  RenderProxy2D,
+  WgpuRenderState,
+  WgpuShapeMeshBuffers,
+  WgpuShapeMeshPipeline,
+} from '@flighthq/types/contract';
 import type { WgpuShapeMesh } from '@flighthq/types/contract';
 import { BlendMode } from '@flighthq/types/contract';
 
-import { drawWgpuShapeMeshes } from './wgpuShapeMesh';
+import { registerWgpuColorAdjustmentMaterialFeature } from './wgpuColorAdjustmentMaterialFeature';
+import { drawWgpuShapeMeshBatch, drawWgpuShapeMeshes } from './wgpuShapeMesh';
 
 beforeAll(() => {
   installWgpuMock();
@@ -20,12 +27,14 @@ const TRIANGLE: WgpuShapeMesh = {
 
 function makeBuffers(): WgpuShapeMeshBuffers {
   return {
-    vertexBuffer: null,
-    vertexCapacity: 0,
-    indexBuffer: null,
-    indexCapacity: 0,
-    uniformBuffer: null,
-    bindGroup: null,
+    vertexBuffers: [],
+    vertexCapacities: [],
+    indexBuffers: [],
+    indexCapacities: [],
+    uniformBuffers: [],
+    bindGroups: [],
+    colorScaleBiasUniformBuffers: [],
+    colorScaleBiasBindGroups: [],
   };
 }
 
@@ -41,8 +50,37 @@ function makePassSpy(): GPURenderPassEncoder {
   } as unknown as GPURenderPassEncoder;
 }
 
-function makeProxy(matrix = createMatrix(), alpha = 1, blendMode: BlendMode | null = null): RenderProxy2D {
-  return { alpha, blendMode, transform2D: matrix } as unknown as RenderProxy2D;
+function makeProxy(overrides?: Partial<RenderProxy2D>): RenderProxy2D {
+  return {
+    alpha: 1,
+    blendMode: null,
+    colorMatrix: null,
+    colorScaleBias: null,
+    transform2D: createMatrix(),
+    ...overrides,
+  } as unknown as RenderProxy2D;
+}
+
+function ct(
+  redScale = 1,
+  greenScale = 1,
+  blueScale = 1,
+  alphaScale = 1,
+  redBias = 0,
+  greenBias = 0,
+  blueBias = 0,
+  alphaBias = 0,
+): ColorScaleBias {
+  return {
+    redScale,
+    greenScale,
+    blueScale,
+    alphaScale,
+    redBias,
+    greenBias,
+    blueBias,
+    alphaBias,
+  } as ColorScaleBias;
 }
 
 async function makeState(): Promise<WgpuRenderState> {
@@ -51,6 +89,42 @@ async function makeState(): Promise<WgpuRenderState> {
   return state;
 }
 
+describe('drawWgpuShapeMeshBatch', () => {
+  it('writes only the shared matrix and color fields, preserving a feature-owned uniform tail', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+    const uniformBuffers: GPUBuffer[] = [];
+    const bindGroups: GPUBindGroup[] = [];
+    const uniformData = new Float32Array(24);
+    uniformData.set([0.25, 0.5, 0.75, 1, 0.1, 0.2, 0.3, 0.4], 16);
+    const pipelineEntry: WgpuShapeMeshPipeline = {
+      bindGroupLayout: {} as GPUBindGroupLayout,
+      pipeline: {} as GPURenderPipeline,
+    };
+    let upload: Float32Array | undefined;
+    state.device.queue.writeBuffer = vi.fn((buffer: GPUBuffer, _offset: number, data: BufferSource) => {
+      if (buffer !== uniformBuffers[0]) return;
+      const view = ArrayBuffer.isView(data) ? data : new Uint8Array(data as ArrayBuffer);
+      upload = new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    }) as unknown as GPUQueue['writeBuffer'];
+
+    drawWgpuShapeMeshBatch(
+      state,
+      makeProxy({ alpha: 0.5 }),
+      [{ ...TRIANGLE, color: 0xffffff }],
+      buffers,
+      pipelineEntry,
+      uniformBuffers,
+      bindGroups,
+      uniformData,
+    );
+
+    expect(uniformBuffers).toHaveLength(1);
+    expect(upload?.slice(12, 16)).toEqual(new Float32Array([0.5, 0.5, 0.5, 0.5]));
+    expect(upload?.slice(16, 24)).toEqual(new Float32Array([0.25, 0.5, 0.75, 1, 0.1, 0.2, 0.3, 0.4]));
+  });
+});
+
 describe('drawWgpuShapeMeshes', () => {
   it('sets the shape-mesh pipeline and draws each mesh', async () => {
     const state = await makeState();
@@ -68,6 +142,20 @@ describe('drawWgpuShapeMeshes', () => {
     expect(pass.drawIndexed).toHaveBeenCalledWith(3);
   });
 
+  it('retains distinct GPU storage for every mesh recorded before submit', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+
+    drawWgpuShapeMeshes(state, makeProxy(), [TRIANGLE, { ...TRIANGLE, color: 0x0080ff }], buffers);
+
+    expect(buffers.vertexBuffers).toHaveLength(2);
+    expect(buffers.indexBuffers).toHaveLength(2);
+    expect(buffers.uniformBuffers).toHaveLength(2);
+    expect(buffers.vertexBuffers[0]).not.toBe(buffers.vertexBuffers[1]);
+    expect(buffers.indexBuffers[0]).not.toBe(buffers.indexBuffers[1]);
+    expect(buffers.uniformBuffers[0]).not.toBe(buffers.uniformBuffers[1]);
+  });
+
   it('retires grown geometry buffers until the recorded frame is submitted', async () => {
     const state = await makeState();
     const buffers = makeBuffers();
@@ -83,7 +171,8 @@ describe('drawWgpuShapeMeshes', () => {
       indices: new Uint16Array([0, 1, 2, 1, 3, 2]),
     };
 
-    drawWgpuShapeMeshes(state, makeProxy(), [TRIANGLE, larger], buffers);
+    drawWgpuShapeMeshes(state, makeProxy(), [TRIANGLE], buffers);
+    drawWgpuShapeMeshes(state, makeProxy(), [larger], buffers);
 
     const retired = getWgpuRenderStateRuntime(state).retiredBuffers!;
     expect(retired).toHaveLength(2);
@@ -106,8 +195,8 @@ describe('drawWgpuShapeMeshes', () => {
   it('bakes the node blend mode into a distinct shape pipeline', async () => {
     const state = await makeState();
 
-    drawWgpuShapeMeshes(state, makeProxy(createMatrix(), 1, BlendMode.Normal), [TRIANGLE], makeBuffers());
-    drawWgpuShapeMeshes(state, makeProxy(createMatrix(), 1, BlendMode.Add), [TRIANGLE], makeBuffers());
+    drawWgpuShapeMeshes(state, makeProxy({ blendMode: BlendMode.Normal }), [TRIANGLE], makeBuffers());
+    drawWgpuShapeMeshes(state, makeProxy({ blendMode: BlendMode.Add }), [TRIANGLE], makeBuffers());
 
     const pipelines = [...getWgpuRenderStateRuntime(state).shapeMeshPipelines!.values()].map(
       (entry) => entry.pipeline,
@@ -130,9 +219,9 @@ describe('drawWgpuShapeMeshes', () => {
       }
     }) as unknown as GPUQueue['writeBuffer'];
 
-    drawWgpuShapeMeshes(state, makeProxy(createMatrix(), 0.5), [{ ...TRIANGLE, color: 0xffffff }], buffers);
+    drawWgpuShapeMeshes(state, makeProxy({ alpha: 0.5 }), [{ ...TRIANGLE, color: 0xffffff }], buffers);
 
-    const uniformData = writes.get(buffers.uniformBuffer!);
+    const uniformData = writes.get(buffers.uniformBuffers[0]);
     expect(uniformData).toBeDefined();
     // Color occupies floats 12..15 (after the mat3x3f columns): premultiplied (0.5, 0.5, 0.5, 0.5).
     const color = uniformData!.slice(12, 16);
@@ -161,4 +250,70 @@ describe('drawWgpuShapeMeshes', () => {
     expect(pass.setPipeline).not.toHaveBeenCalled();
     expect(runtime.shapeMeshPipelines?.size ?? 0).toBe(0);
   });
+
+  it('ignores ColorScaleBias when the opt-in feature is not registered', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+
+    drawWgpuShapeMeshes(state, makeProxy({ colorScaleBias: ct(0.5) }), [TRIANGLE], buffers);
+
+    expect(buffers.uniformBuffers).toHaveLength(1);
+    expect(buffers.colorScaleBiasUniformBuffers).toHaveLength(0);
+  });
+
+  it('keeps registered but unadjusted meshes on the lean uniform path', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+    registerWgpuColorAdjustmentMaterialFeature(state);
+
+    drawWgpuShapeMeshes(state, makeProxy(), [TRIANGLE], buffers);
+
+    expect(buffers.uniformBuffers).toHaveLength(1);
+    expect(buffers.colorScaleBiasUniformBuffers).toHaveLength(0);
+  });
+
+  it('folds ColorScaleBias through a separate 96-byte uniform and shader', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+    registerWgpuColorAdjustmentMaterialFeature(state);
+    const createShaderModule = vi.spyOn(state.device, 'createShaderModule');
+    const writes = new Map<GPUBuffer, Float32Array>();
+    state.device.queue.writeBuffer = vi.fn((buffer: GPUBuffer, _offset: number, data: BufferSource) => {
+      const view = ArrayBuffer.isView(data) ? data : new Uint8Array(data as ArrayBuffer);
+      if (view.byteLength % 4 === 0) {
+        writes.set(buffer, new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength)));
+      }
+    }) as unknown as GPUQueue['writeBuffer'];
+
+    drawWgpuShapeMeshes(
+      state,
+      makeProxy({ alpha: 0.5, colorScaleBias: ct(0.25, 0.5, 0.75, 0.8, 0.1, 0.2, 0.3, 0.4) }),
+      [{ ...TRIANGLE, color: 0xffffff }],
+      buffers,
+    );
+
+    expect(buffers.uniformBuffers).toHaveLength(0);
+    expect(buffers.colorScaleBiasUniformBuffers).toHaveLength(1);
+    const uniform = writes.get(buffers.colorScaleBiasUniformBuffers[0]);
+    expect(uniform).toHaveLength(24);
+    expect(uniform?.slice(12, 16)).toEqual(new Float32Array([0.5, 0.5, 0.5, 0.5]));
+    expect(uniform?.slice(16, 24)).toEqual(new Float32Array([0.25, 0.5, 0.75, 0.8, 0.1, 0.2, 0.3, 0.4]));
+    const shader = createShaderModule.mock.calls
+      .map(([descriptor]) => descriptor.code)
+      .find((code) => code.includes('struct ShapeMeshUniforms'));
+    expect(shader).toContain('u.color.rgb / u.color.a');
+    expect(shader).toContain('applyFlightColorAdjustment(color, u.colorScale, u.colorBias)');
+    expect(shader).toContain('color.rgb * color.a');
+  });
+
+  it('leaves the full color-matrix path outside the bounded solid-mesh fold', async () => {
+    const state = await makeState();
+    const buffers = makeBuffers();
+    registerWgpuColorAdjustmentMaterialFeature(state);
+
+    drawWgpuShapeMeshes(state, makeProxy({ colorMatrix: new Array(20).fill(0) }), [TRIANGLE], buffers);
+
+    expect(buffers.uniformBuffers).toHaveLength(1);
+    expect(buffers.colorScaleBiasUniformBuffers).toHaveLength(0);
+  });
 });

package/src/wgpuShapeRasterizer.test.ts

@@ -0,0 +1,36 @@
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import { createRenderState, enableRenderRegistryGuards, explainRenderRegistryMisses } from '@flighthq/render/contract';
+import { RenderRegistry } from '@flighthq/types/contract';
+
+import { getWgpuShapeRasterizer, registerWgpuShapeRasterizer } from './wgpuShapeRasterizer';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('getWgpuShapeRasterizer', () => {
+  it('reports none until one is registered', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(getWgpuShapeRasterizer(state)).toBeNull();
+  });
+});
+
+describe('registerWgpuShapeRasterizer', () => {
+  it('installs the rasterizer the shape path draws non-solid fills through', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const rasterizer = (): void => {};
+
+    registerWgpuShapeRasterizer(state, rasterizer);
+
+    expect(getWgpuShapeRasterizer(state)).toBe(rasterizer);
+  });
+
+  it('removes one again, so a state can drop back to tessellation only', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuShapeRasterizer(state, (): void => {});
+
+    registerWgpuShapeRasterizer(state, null);
+
+    expect(getWgpuShapeRasterizer(state)).toBeNull();
+  });
+});