@flighthq/render-gl 0.3.0 → 0.3.1-next.1050.9114695

package/src/glRenderState.test.ts

@@ -1,14 +1,31 @@
 import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import {
+  createKeyedTable,
+  getRegistryTableEntry,
+  hasRegistryTableEntry,
+  withRegistryTableEntry,
+} from '@flighthq/registry/contract';
 import {
   copyAllRenderersFromRenderState,
+  enableColorAdjustmentGuards,
+  enableColorAdjustments,
+  getColorAdjustmentUnsupportedGuard,
   getRenderStateRuntime,
   prepareScene2DRender,
   registerRenderer,
 } from '@flighthq/render/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
-import { BlendMode } from '@flighthq/types/contract';
-
-import { enableGlRenderStateGuards } from './enableGlRenderStateGuards';
+import type {
+  GlColorAdjustmentMaterialFeature,
+  GlColorAdjustmentMaterialFeatureGuard,
+  RenderEffectPaddingResolver,
+  RenderState,
+} from '@flighthq/types/contract';
+import { BlendMode, RegistryEntryState } from '@flighthq/types/contract';
+
+import { areGlRenderStateGuardsEnabled, enableGlRenderStateGuards } from './enableGlRenderStateGuards';
+import { registerGlCompressedTextureDecoder, registerGlCompressedTextureUpload } from './glCompressedTexture';
+import { isBlendModeSupported, registerGlBlendMode } from './glDraw';
 import { registerGlMaterialRenderer } from './glMaterialRegistry';
 import {
   copyGlRenderStateRegistrations,
@@ -16,6 +33,8 @@ import {
   createGlRenderState,
   createGlRenderStateRuntime,
   destroyGlRenderState,
+  getGlColorAdjustmentMaterialFeature,
+  getGlColorAdjustmentMaterialFeatureGuard,
   getGlRenderStateRuntime,
   invalidateGlRenderStateCache,
 } from './glRenderState';
@@ -31,32 +50,135 @@ function makeCanvas() {
   return { canvas, gl };
 }
 
+function getPaddingResolver(state: RenderState, kind: string): RenderEffectPaddingResolver | null {
+  const table = getRenderStateRuntime(state).registries.effectPaddingResolvers;
+  return table === undefined ? null : getRegistryTableEntry(table, kind);
+}
+
+function registerPaddingResolver(state: RenderState, kind: string, resolver: RenderEffectPaddingResolver): void {
+  const runtime = getRenderStateRuntime(state);
+  runtime.registries.effectPaddingResolvers = withRegistryTableEntry(
+    runtime.registries.effectPaddingResolvers ??
+      createKeyedTable<RenderEffectPaddingResolver>('RenderEffectPaddingResolver', 'Zero'),
+    kind,
+    resolver,
+  );
+}
+
 describe('copyGlRenderStateRegistrations', () => {
   it('copies late GL registrations only when explicitly requested', () => {
     const { canvas } = makeCanvas();
     const screen = createGlRenderState(canvas);
     const offscreen = createGlOffscreenRenderState(screen);
+    const materialRenderer = { instanceFloatCount: 0, bind: vi.fn() } as never;
+    const offscreenMaterialRenderer = { instanceFloatCount: 0, bind: vi.fn() } as never;
+    const decoder = vi.fn(() => new Uint8ClampedArray(4));
     const resolver = vi.fn(() => null);
+    registerGlBlendMode(screen, 'acme.LateBlend', { src: 'ONE', dst: 'ZERO' });
+    registerGlCompressedTextureDecoder(screen, decoder);
+    registerGlCompressedTextureUpload(screen);
+    registerGlMaterialRenderer(screen, 'acme.LateMaterial', materialRenderer);
     registerGlTextureResolver(screen, 'acme.LateTexture', resolver);
 
-    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.has('acme.LateTexture')).not.toBe(true);
+    expect(isBlendModeSupported(offscreen, 'acme.LateBlend')).toBe(false);
+    expect(
+      hasRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.materialRenderers, 'acme.LateMaterial'),
+    ).toBe(false);
+    expect(
+      hasRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
+    ).toBe(false);
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureDecoder.entry).toBeNull();
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureUpload.entry).toBeNull();
     copyGlRenderStateRegistrations(offscreen, screen);
-    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.get('acme.LateTexture')).toBe(resolver);
+    expect(isBlendModeSupported(offscreen, 'acme.LateBlend')).toBe(true);
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.materialRenderers, 'acme.LateMaterial'),
+    ).toBe(materialRenderer);
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
+    ).toBe(resolver);
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureDecoder).toBe(
+      getGlRenderStateRuntime(screen).registries.compressedTextureDecoder,
+    );
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureDecoder.entry).toEqual({
+      state: RegistryEntryState.Bound,
+      value: decoder,
+    });
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureUpload).toBe(
+      getGlRenderStateRuntime(screen).registries.compressedTextureUpload,
+    );
+    registerGlMaterialRenderer(offscreen, 'acme.LateMaterial', offscreenMaterialRenderer);
+    registerGlBlendMode(offscreen, 'acme.LateBlend', { src: 'ZERO', dst: 'ONE' });
+    registerGlCompressedTextureDecoder(offscreen, null);
+    registerGlCompressedTextureUpload(offscreen, null);
+    registerGlTextureResolver(offscreen, 'acme.LateTexture', null);
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.materialRenderers, 'acme.LateMaterial'),
+    ).toBe(offscreenMaterialRenderer);
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(screen).registries.materialRenderers, 'acme.LateMaterial'),
+    ).toBe(materialRenderer);
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(screen).registries.blendRealizations, 'acme.LateBlend'),
+    ).toEqual({ src: 'ONE', dst: 'ZERO' });
+    expect(
+      hasRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
+    ).toBe(false);
+    expect(getRegistryTableEntry(getGlRenderStateRuntime(screen).registries.textureResolvers, 'acme.LateTexture')).toBe(
+      resolver,
+    );
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureDecoder.entry).toBeNull();
+    expect(getGlRenderStateRuntime(screen).registries.compressedTextureDecoder.entry?.state).toBe(
+      RegistryEntryState.Bound,
+    );
+    expect(getGlRenderStateRuntime(offscreen).registries.compressedTextureUpload.entry).toBeNull();
+    expect(getGlRenderStateRuntime(screen).registries.compressedTextureUpload.entry?.state).toBe(
+      RegistryEntryState.Bound,
+    );
   });
 });
 
 describe('createGlOffscreenRenderState', () => {
-  it('shares context resources while snapshotting registration policy into independent maps', () => {
+  it('shares context resources and persistent registration snapshots through independent aggregates', () => {
     const { canvas } = makeCanvas();
     const screen = createGlRenderState(canvas);
     const renderer = { createData: () => null, submit: vi.fn() };
     const materialRenderer = { getBatchData: vi.fn(), getBatchFloats: vi.fn() } as never;
     const paddingResolver = vi.fn(() => ({ bottom: 1, left: 1, right: 1, top: 1 }));
     const textureResolver = vi.fn(() => null);
+    const effectRunner = vi.fn();
+    const colorAdjustmentFeature: GlColorAdjustmentMaterialFeature = {
+      drawShapeMeshes: vi.fn(),
+      flush: vi.fn(() => false),
+      fragmentShaderChunk: '',
+      matrixFragmentShaderChunk: '',
+      record: vi.fn(),
+    };
+    const colorAdjustmentFeatureGuard: GlColorAdjustmentMaterialFeatureGuard = vi.fn();
     registerRenderer(screen, 'acme.Node', renderer);
     registerGlMaterialRenderer(screen, 'acme.Material', materialRenderer);
     registerGlTextureResolver(screen, 'acme.Texture', textureResolver);
-    getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.Effect', paddingResolver]]);
+    enableColorAdjustments(screen);
+    enableColorAdjustmentGuards(screen);
+    enableGlRenderStateGuards(screen);
+    getGlRenderStateRuntime(screen).registries.renderEffects = withRegistryTableEntry(
+      getGlRenderStateRuntime(screen).registries.renderEffects,
+      'acme.Effect',
+      { runner: effectRunner as never },
+    );
+    registerPaddingResolver(screen, 'acme.Effect', paddingResolver);
+    getGlRenderStateRuntime(screen).registries.colorAdjustmentFeature = {
+      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeature },
+      onMiss: 'Disabled',
+      registry: 'GlColorAdjustmentFeature',
+      shape: 'slot',
+    };
+    getGlRenderStateRuntime(screen).registries.colorAdjustmentFeatureGuard = {
+      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeatureGuard },
+      onMiss: 'Disabled',
+      registry: 'GlColorAdjustmentFeatureGuard',
+      shape: 'slot',
+    };
     getGlRenderStateRuntime(screen).glRenderTextureCache = new WeakMap();
 
     const offscreen = createGlOffscreenRenderState(screen);
@@ -71,16 +193,67 @@ describe('createGlOffscreenRenderState', () => {
     );
     expect(offscreenRuntime.glRenderTextureCache).toBe(screenRuntime.glRenderTextureCache);
     expect(offscreenRuntime.quadIndexBuffer).toBe(screenRuntime.quadIndexBuffer);
-    expect(offscreenRuntime.rendererMap).not.toBe(screenRuntime.rendererMap);
-    expect(offscreenRuntime.materialRendererMap).not.toBe(screenRuntime.materialRendererMap);
-    expect(offscreenRuntime.glTextureResolverRegistry).not.toBe(screenRuntime.glTextureResolverRegistry);
-    expect(offscreenRuntime.renderEffectPaddingResolverRegistry).not.toBe(
-      screenRuntime.renderEffectPaddingResolverRegistry,
+    expect(offscreenRuntime.registries.renderers).toBe(screenRuntime.registries.renderers);
+    expect(offscreenRuntime.registries).not.toBe(screenRuntime.registries);
+    expect(offscreenRuntime.registries.blendRealizations).toBe(screenRuntime.registries.blendRealizations);
+    expect(offscreenRuntime.registries.colorAdjustmentFeature).toBe(screenRuntime.registries.colorAdjustmentFeature);
+    expect(getGlColorAdjustmentMaterialFeature(offscreen)).toBe(colorAdjustmentFeature);
+    expect(offscreenRuntime.registries.colorAdjustmentFeatureGuard).toBe(
+      screenRuntime.registries.colorAdjustmentFeatureGuard,
+    );
+    expect(getGlColorAdjustmentMaterialFeatureGuard(offscreen)).toBe(colorAdjustmentFeatureGuard);
+    const sharedColorFeatureGuard = offscreenRuntime.registries.colorAdjustmentFeatureGuard;
+    screenRuntime.registries.colorAdjustmentFeatureGuard = undefined;
+    expect(getGlColorAdjustmentMaterialFeatureGuard(screen)).toBeNull();
+    expect(offscreenRuntime.registries.colorAdjustmentFeatureGuard).toBe(sharedColorFeatureGuard);
+    expect(getGlColorAdjustmentMaterialFeatureGuard(offscreen)).toBe(colorAdjustmentFeatureGuard);
+    const sharedColorFeature = offscreenRuntime.registries.colorAdjustmentFeature;
+    screenRuntime.registries.colorAdjustmentFeature = undefined;
+    expect(getGlColorAdjustmentMaterialFeature(screen)).toBeNull();
+    expect(offscreenRuntime.registries.colorAdjustmentFeature).toBe(sharedColorFeature);
+    expect(getGlColorAdjustmentMaterialFeature(offscreen)).toBe(colorAdjustmentFeature);
+    expect(offscreenRuntime.registries.colorAdjustments).toBe(screenRuntime.registries.colorAdjustments);
+    expect(offscreenRuntime.registries.colorAdjustmentUnsupportedGuard).toBe(
+      screenRuntime.registries.colorAdjustmentUnsupportedGuard,
     );
-    expect(offscreenRuntime.rendererMap.get('acme.Node')).toBe(renderer);
-    expect(offscreenRuntime.materialRendererMap?.get('acme.Material')).toBe(materialRenderer);
-    expect(offscreenRuntime.glTextureResolverRegistry?.get('acme.Texture')).toBe(textureResolver);
-    expect(offscreenRuntime.renderEffectPaddingResolverRegistry?.get('acme.Effect')).toBe(paddingResolver);
+    expect(getColorAdjustmentUnsupportedGuard(offscreen)).not.toBeNull();
+    const sharedUnsupportedGuard = offscreenRuntime.registries.colorAdjustmentUnsupportedGuard;
+    screenRuntime.registries.colorAdjustmentUnsupportedGuard = undefined;
+    expect(getColorAdjustmentUnsupportedGuard(screen)).toBeNull();
+    expect(offscreenRuntime.registries.colorAdjustmentUnsupportedGuard).toBe(sharedUnsupportedGuard);
+    expect(getColorAdjustmentUnsupportedGuard(offscreen)).not.toBeNull();
+    expect(offscreenRuntime.registries.renderRootGuard).toBe(screenRuntime.registries.renderRootGuard);
+    expect(areGlRenderStateGuardsEnabled(offscreen)).toBe(true);
+    const sharedRenderRootGuard = offscreenRuntime.registries.renderRootGuard;
+    screenRuntime.registries.renderRootGuard = undefined;
+    expect(screenRuntime.registries.renderRootGuard).toBeUndefined();
+    expect(offscreenRuntime.registries.renderRootGuard).toBe(sharedRenderRootGuard);
+    expect(areGlRenderStateGuardsEnabled(offscreen)).toBe(true);
+    expect(offscreenRuntime.registries.compressedTextureDecoder).toBe(
+      screenRuntime.registries.compressedTextureDecoder,
+    );
+    expect(offscreenRuntime.registries.compressedTextureUpload).toBe(screenRuntime.registries.compressedTextureUpload);
+    expect(offscreenRuntime.registries.customEffectShaders).toBe(screenRuntime.registries.customEffectShaders);
+    expect(offscreenRuntime.registries.customMaterialShaders).toBe(screenRuntime.registries.customMaterialShaders);
+    expect(offscreenRuntime.registries.materialRenderers).toBe(screenRuntime.registries.materialRenderers);
+    expect(offscreenRuntime.registries.meshMaterialRenderers).toBe(screenRuntime.registries.meshMaterialRenderers);
+    expect(offscreenRuntime.registries.modifierSnippets).toBe(screenRuntime.registries.modifierSnippets);
+    expect(offscreenRuntime.registries.modifierSnippetRevision).toBe(screenRuntime.registries.modifierSnippetRevision);
+    expect(offscreenRuntime.registries.pbrExtensions).toBe(screenRuntime.registries.pbrExtensions);
+    expect(offscreenRuntime.registries.pbrExtensionRevision).toBe(screenRuntime.registries.pbrExtensionRevision);
+    expect(offscreenRuntime.registries.renderEffects).toBe(screenRuntime.registries.renderEffects);
+    expect(offscreenRuntime.registries.shapeRasterizer).toBe(screenRuntime.registries.shapeRasterizer);
+    expect(offscreenRuntime.registries.strokeTessellator).toBe(screenRuntime.registries.strokeTessellator);
+    expect(offscreenRuntime.registries.textureResolvers).toBe(screenRuntime.registries.textureResolvers);
+    expect(offscreenRuntime.registries.velocityWriters).toBe(screenRuntime.registries.velocityWriters);
+    expect(offscreenRuntime.registries.effectPaddingResolvers).toBe(screenRuntime.registries.effectPaddingResolvers);
+    expect(getRegistryTableEntry(offscreenRuntime.registries.renderers, 'acme.Node')).toBe(renderer);
+    expect(getRegistryTableEntry(offscreenRuntime.registries.materialRenderers, 'acme.Material')).toBe(
+      materialRenderer,
+    );
+    expect(getRegistryTableEntry(offscreenRuntime.registries.textureResolvers, 'acme.Texture')).toBe(textureResolver);
+    expect(getRegistryTableEntry(offscreenRuntime.registries.renderEffects, 'acme.Effect')?.runner).toBe(effectRunner);
+    expect(getPaddingResolver(offscreen, 'acme.Effect')).toBe(paddingResolver);
 
     screenRuntime.currentProgram = {} as WebGLProgram;
     expect(offscreenRuntime.currentProgram).toBe(screenRuntime.currentProgram);
@@ -95,19 +268,23 @@ describe('createGlOffscreenRenderState', () => {
     const resolver = vi.fn(() => null);
     registerRenderer(screen, 'acme.LateNode', renderer);
     registerGlTextureResolver(screen, 'acme.LateTexture', resolver);
-    getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.LateEffect', paddingResolver]]);
+    registerPaddingResolver(screen, 'acme.LateEffect', paddingResolver);
 
-    expect(getRenderStateRuntime(offscreen).rendererMap.has('acme.LateNode')).toBe(false);
-    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.has('acme.LateTexture')).not.toBe(true);
-    expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.has('acme.LateEffect')).not.toBe(true);
+    expect(hasRegistryTableEntry(getRenderStateRuntime(offscreen).registries.renderers, 'acme.LateNode')).toBe(false);
+    expect(
+      hasRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
+    ).toBe(false);
+    expect(getPaddingResolver(offscreen, 'acme.LateEffect')).toBeNull();
 
     copyAllRenderersFromRenderState(offscreen, screen);
     copyGlRenderStateRegistrations(offscreen, screen);
-    expect(getRenderStateRuntime(offscreen).rendererMap.get('acme.LateNode')).toBe(renderer);
-    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.get('acme.LateTexture')).toBe(resolver);
-    expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.get('acme.LateEffect')).toBe(
-      paddingResolver,
+    expect(getRegistryTableEntry(getRenderStateRuntime(offscreen).registries.renderers, 'acme.LateNode')).toBe(
+      renderer,
     );
+    expect(
+      getRegistryTableEntry(getGlRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
+    ).toBe(resolver);
+    expect(getPaddingResolver(offscreen, 'acme.LateEffect')).toBe(paddingResolver);
   });
 
   it('keeps proxy trees independent and destroys derived renderer data without freeing shared context resources', () => {
@@ -129,7 +306,7 @@ describe('createGlOffscreenRenderState', () => {
     expect(gl.deleteProgram).not.toHaveBeenCalled();
 
     destroyGlRenderState(screen);
-    expect(gl.deleteProgram).toHaveBeenCalled();
+    expect(gl.deleteBuffer).toHaveBeenCalled();
   });
 });
 
@@ -229,14 +406,94 @@ describe('createGlRenderState', () => {
 });
 
 describe('createGlRenderStateRuntime', () => {
-  it('returns a runtime carrying the base entity-runtime binding slot', () => {
+  it('returns a runtime with the base binding slot and empty named registration tables', () => {
     const runtime = createGlRenderStateRuntime();
     expect(runtime.binding).toBeNull();
+    expect(runtime.registries.blendRealizations).toMatchObject({
+      onMiss: 'Normal',
+      registry: 'GlBlendRealization',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.blendRealizations.entries.size).toBe(0);
+    expect(runtime.registries.customEffectShaders).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlCustomEffectShader',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.customEffectShaders.entries.size).toBe(0);
+    expect(runtime.registries.customMaterialShaders).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlCustomMaterialShader',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.customMaterialShaders.entries.size).toBe(0);
+    expect(runtime.registries.materialRenderers).toMatchObject({
+      onMiss: 'StandardMaterial',
+      registry: 'GlMaterialRenderer',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.materialRenderers.entries.size).toBe(0);
+    expect(runtime.registries.meshMaterialRenderers).toMatchObject({
+      onMiss: 'StandardMaterial',
+      registry: 'GlMeshMaterialRenderer',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.meshMaterialRenderers.entries.size).toBe(0);
+    expect(runtime.registries.modifierSnippets).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlModifierSnippet',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.modifierSnippets.entries.size).toBe(0);
+    expect(runtime.registries.modifierSnippetRevision).toBe(0);
+    expect(runtime.registries.pbrExtensions).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlPbrExtension',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.pbrExtensions.entries.size).toBe(0);
+    expect(runtime.registries.pbrExtensionRevision).toBe(0);
+    expect(runtime.registries.renderEffects).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlRenderEffect',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.compressedTextureDecoder).toEqual({
+      entry: null,
+      onMiss: 'Unregistered',
+      registry: 'GlCompressedTextureDecoder',
+      shape: 'slot',
+    });
+    expect(runtime.registries.colorAdjustments).toBeUndefined();
+    expect(runtime.registries.compressedTextureUpload).toEqual({
+      entry: null,
+      onMiss: 'Unregistered',
+      registry: 'GlCompressedTextureUpload',
+      shape: 'slot',
+    });
+    expect(runtime.registries.shapeRasterizer).toEqual({
+      entry: null,
+      onMiss: 'Unregistered',
+      registry: 'GlShapeRasterizer',
+      shape: 'slot',
+    });
+    expect(runtime.registries.strokeTessellator).toEqual({
+      entry: null,
+      onMiss: 'Rasterize',
+      registry: 'StrokeTessellator',
+      shape: 'slot',
+    });
+    expect(runtime.registries.velocityWriters).toMatchObject({
+      onMiss: 'Unregistered',
+      registry: 'GlVelocityWriter',
+      shape: 'keyed',
+    });
+    expect(runtime.registries.velocityWriters.entries.size).toBe(0);
   });
 });
 
 describe('destroyGlRenderState', () => {
-  it('deletes the state-owned shader programs and buffers', () => {
+  it('deletes buffers on destroy even when no shader was compiled', () => {
     const { canvas, gl } = makeCanvas();
     const state = createGlRenderState(canvas);
     const deleteProgram = vi.spyOn(gl, 'deleteProgram');
@@ -244,7 +501,7 @@ describe('destroyGlRenderState', () => {
 
     destroyGlRenderState(state);
 
-    expect(deleteProgram).toHaveBeenCalled();
+    expect(deleteProgram).not.toHaveBeenCalled();
     expect(deleteBuffer).toHaveBeenCalled();
   });
 
@@ -275,13 +532,65 @@ describe('enableGlRenderStateGuards', () => {
   });
 });
 
+describe('getGlColorAdjustmentMaterialFeature', () => {
+  it('resolves only a bound feature entry', () => {
+    const { canvas } = makeCanvas();
+    const state = createGlRenderState(canvas);
+    const feature: GlColorAdjustmentMaterialFeature = {
+      drawShapeMeshes: vi.fn(),
+      flush: vi.fn(() => false),
+      fragmentShaderChunk: '',
+      matrixFragmentShaderChunk: '',
+      record: vi.fn(),
+    };
+    const runtime = getGlRenderStateRuntime(state);
+
+    expect(getGlColorAdjustmentMaterialFeature(state)).toBeNull();
+    runtime.registries.colorAdjustmentFeature = {
+      entry: { state: RegistryEntryState.Bound, value: feature },
+      onMiss: 'Disabled',
+      registry: 'GlColorAdjustmentFeature',
+      shape: 'slot',
+    };
+    expect(getGlColorAdjustmentMaterialFeature(state)).toBe(feature);
+    runtime.registries.colorAdjustmentFeature = {
+      ...runtime.registries.colorAdjustmentFeature,
+      entry: { state: RegistryEntryState.Tombstoned },
+    };
+    expect(getGlColorAdjustmentMaterialFeature(state)).toBeNull();
+  });
+});
+
+describe('getGlColorAdjustmentMaterialFeatureGuard', () => {
+  it('resolves only a bound guard entry', () => {
+    const { canvas } = makeCanvas();
+    const state = createGlRenderState(canvas);
+    const guard: GlColorAdjustmentMaterialFeatureGuard = vi.fn();
+    const runtime = getGlRenderStateRuntime(state);
+
+    expect(getGlColorAdjustmentMaterialFeatureGuard(state)).toBeNull();
+    runtime.registries.colorAdjustmentFeatureGuard = {
+      entry: { state: RegistryEntryState.Bound, value: guard },
+      onMiss: 'Disabled',
+      registry: 'GlColorAdjustmentFeatureGuard',
+      shape: 'slot',
+    };
+    expect(getGlColorAdjustmentMaterialFeatureGuard(state)).toBe(guard);
+    runtime.registries.colorAdjustmentFeatureGuard = {
+      ...runtime.registries.colorAdjustmentFeatureGuard,
+      entry: { state: RegistryEntryState.Tombstoned },
+    };
+    expect(getGlColorAdjustmentMaterialFeatureGuard(state)).toBeNull();
+  });
+});
+
 describe('getGlRenderStateRuntime', () => {
   it('returns the runtime attached by createGlRenderState', () => {
     const { canvas } = makeCanvas();
     const state = createGlRenderState(canvas);
     const runtime = getGlRenderStateRuntime(state);
     expect(runtime).toBeDefined();
-    expect(runtime.defaultBitmapShader).toBeDefined();
+    expect(runtime.defaultBitmapShader).toBeNull();
   });
 
   it('resolves the same runtime object on repeated calls', () => {