@navaramap/three 0.0.0

package/src/material/enhancer/instancedSprite/instancedSpriteBaseEnhancer/shader.test.ts

@@ -0,0 +1,114 @@
+import instancedSpriteFragmentShader from "@shaders/glsl/instancedSprite.frag.glsl";
+import instancedSpriteVertexShader from "@shaders/glsl/instancedSprite.vert.glsl";
+import { describe, expect, it } from "vitest";
+
+import { createInstancedSpriteBaseEnhancer, type SupportedMaterial } from ".";
+
+describe("instancedSpriteBaseEnhancer shader", () => {
+  const createMockMaterial = () =>
+    ({
+      type: "ShaderMaterial",
+      userData: {},
+    }) as unknown as SupportedMaterial;
+
+  const createMockShader = () => ({
+    vertexShader: "",
+    fragmentShader: "",
+    uniforms: {},
+    defines: {} as Record<string, unknown>,
+  });
+
+  it("should set correct vertex and fragment shaders", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({});
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.vertexShader).toBe(instancedSpriteVertexShader);
+    expect(shader.fragmentShader).toBe(instancedSpriteFragmentShader);
+  });
+
+  it("should set USE_RTE define when useRTE=true", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ useRTE: true });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.USE_RTE).toBe(1);
+  });
+
+  it("should not set USE_RTE define when useRTE=false", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ useRTE: false });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.USE_RTE).toBeUndefined();
+  });
+
+  it("should set BILLBOARD define when billboard=true", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ billboard: true });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.BILLBOARD).toBe(1);
+  });
+
+  it("should not set BILLBOARD define when billboard=false", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ billboard: false });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.BILLBOARD).toBeUndefined();
+  });
+
+  it("should set both USE_RTE and BILLBOARD when both are true", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ useRTE: true, billboard: true });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.USE_RTE).toBe(1);
+    expect(shader.defines.BILLBOARD).toBe(1);
+  });
+
+  it("should merge material.userData.defines", () => {
+    const material = createMockMaterial();
+    material.userData.defines = { CUSTOM_DEFINE: 1 };
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({});
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect(shader.defines.CUSTOM_DEFINE).toBe(1);
+  });
+
+  it("should assign uniforms to shader.uniforms", () => {
+    const material = createMockMaterial();
+    const enhancer = createInstancedSpriteBaseEnhancer(material);
+    enhancer.mount({ scale: 200 });
+
+    const shader = createMockShader();
+    enhancer.transformShader(shader as any);
+
+    expect((shader.uniforms as Record<string, unknown>).uScale).toBeDefined();
+    expect(
+      (shader.uniforms as Record<string, { value: unknown }>).uScale.value,
+    ).toBe(200);
+  });
+});

package/src/material/enhancer/instancedSprite/instancedSpriteBaseEnhancer/shader.ts

@@ -0,0 +1,49 @@
+import instancedSpriteFragmentShader from "@shaders/glsl/instancedSprite.frag.glsl";
+import instancedSpriteVertexShader from "@shaders/glsl/instancedSprite.vert.glsl";
+import type { WebGLProgramParametersWithUniforms } from "three";
+
+import type { SupportedMaterial } from "./material";
+import type {
+  InstancedSpriteBaseMutates,
+  InstancedSpriteBaseState,
+} from "./types";
+
+/**
+ * Transform shader with instancedSprite base modifications.
+ *
+ * InstancedSprites use custom ShaderMaterial shaders. This function:
+ * 1. Sets the vertex/fragment shader sources
+ * 2. Sets defines based on state (USE_RTE, BILLBOARD)
+ * 3. Assigns uniform refs via mutates.updateUniforms()
+ */
+export const transformShader = (
+  shader: WebGLProgramParametersWithUniforms,
+  state: InstancedSpriteBaseState,
+  mutates: InstancedSpriteBaseMutates,
+  material: SupportedMaterial,
+): void => {
+  // Set shaders — instancedSprite always uses the same shader pair
+  shader.vertexShader = instancedSpriteVertexShader;
+  shader.fragmentShader = instancedSpriteFragmentShader;
+
+  // Set defines based on state
+  shader.defines ??= {};
+
+  if (state.useRTE) {
+    shader.defines.USE_RTE = 1;
+  }
+
+  if (state.billboard) {
+    shader.defines.BILLBOARD = 1;
+  }
+
+  shader.defines.USE_SELECTIVE_EFFECT = 1;
+
+  // Merge defines from material.userData.defines
+  if (material.userData?.defines) {
+    Object.assign(shader.defines, material.userData.defines);
+  }
+
+  // Assign uniform refs to shader.uniforms via mutates
+  mutates.updateUniforms(shader.uniforms, state);
+};

package/src/material/enhancer/instancedSprite/instancedSpriteBaseEnhancer/state.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+
+import { DEFAULT_BASE_STATE, updateState } from "./state";
+
+describe("instancedSpriteBaseEnhancer / state", () => {
+  describe("updateState", () => {
+    it("initializes state from props with defaults", () => {
+      const state = updateState({ scale: 50 }, DEFAULT_BASE_STATE);
+      expect(state.scale).toBe(50);
+      expect(state.center).toEqual([0.0, 0.0]);
+      expect(state.sizeInMeters).toBe(true);
+    });
+
+    it("preserves immutable fields (useRTE) from currentState", () => {
+      const currentState = { ...DEFAULT_BASE_STATE, useRTE: true };
+      const state = updateState({ useRTE: false }, currentState);
+      expect(state.useRTE).toBe(true);
+    });
+
+    it("preserves immutable fields (billboard) from currentState", () => {
+      const currentState = { ...DEFAULT_BASE_STATE, billboard: true };
+      const state = updateState({ billboard: false }, currentState);
+      expect(state.billboard).toBe(true);
+    });
+
+    it("updates scale", () => {
+      const state = updateState({ scale: 200 }, DEFAULT_BASE_STATE);
+      expect(state.scale).toBe(200);
+    });
+
+    it("updates center", () => {
+      const state = updateState({ center: [0.5, 0.5] }, DEFAULT_BASE_STATE);
+      expect(state.center).toEqual([0.5, 0.5]);
+    });
+
+    it("updates sizeInMeters", () => {
+      const state = updateState({ sizeInMeters: false }, DEFAULT_BASE_STATE);
+      expect(state.sizeInMeters).toBe(false);
+    });
+
+    it("updates offsetDepth", () => {
+      const state = updateState({ offsetDepth: false }, DEFAULT_BASE_STATE);
+      expect(state.offsetDepth).toBe(false);
+    });
+
+    it("updates alphaTest", () => {
+      const state = updateState({ alphaTest: 0.5 }, DEFAULT_BASE_STATE);
+      expect(state.alphaTest).toBe(0.5);
+    });
+
+    it("updates pickable", () => {
+      const state = updateState({ pickable: true }, DEFAULT_BASE_STATE);
+      expect(state.pickable).toBe(true);
+    });
+
+    it("updates transparent", () => {
+      const state = updateState({ transparent: false }, DEFAULT_BASE_STATE);
+      expect(state.transparent).toBe(false);
+    });
+
+    it("updates depthTest", () => {
+      const state = updateState({ depthTest: false }, DEFAULT_BASE_STATE);
+      expect(state.depthTest).toBe(false);
+    });
+
+    it("updates atlasSize", () => {
+      const state = updateState({ atlasSize: [512, 256] }, DEFAULT_BASE_STATE);
+      expect(state.atlasSize).toEqual([512, 256]);
+    });
+
+    it("falls back to currentState for missing props", () => {
+      const currentState = {
+        ...DEFAULT_BASE_STATE,
+        scale: 42,
+        center: [1, 2] as [number, number],
+      };
+      const state = updateState({}, currentState);
+      expect(state.scale).toBe(42);
+      expect(state.center).toEqual([1, 2]);
+    });
+  });
+});

package/src/material/enhancer/instancedSprite/instancedSpriteBaseEnhancer/state.ts

@@ -0,0 +1,80 @@
+import type {
+  InstancedSpriteBaseProps,
+  InstancedSpriteBaseState,
+} from "./types";
+
+export const DEFAULT_BASE_PROPS: Required<
+  Omit<InstancedSpriteBaseProps, "texture" | "rtcCenter">
+> = {
+  useRTE: false,
+  billboard: false,
+  scale: 100.0,
+  center: [0.0, 0.0],
+  sizeInMeters: true,
+  offsetDepth: true,
+  alphaTest: 0.0,
+  pickable: false,
+  effectIdsMask: 0,
+  emissiveColor: 0,
+  emissiveIntensity: 0,
+  transparent: true,
+  depthTest: true,
+  atlasSize: [1.0, 1.0],
+  fovRad: 1.0,
+  screenHeightPx: 1080,
+};
+
+/** Default state derived from DEFAULT_BASE_PROPS */
+export const DEFAULT_BASE_STATE: InstancedSpriteBaseState = {
+  useRTE: DEFAULT_BASE_PROPS.useRTE,
+  billboard: DEFAULT_BASE_PROPS.billboard,
+  scale: DEFAULT_BASE_PROPS.scale,
+  center: DEFAULT_BASE_PROPS.center,
+  sizeInMeters: DEFAULT_BASE_PROPS.sizeInMeters,
+  offsetDepth: DEFAULT_BASE_PROPS.offsetDepth,
+  alphaTest: DEFAULT_BASE_PROPS.alphaTest,
+  pickable: DEFAULT_BASE_PROPS.pickable,
+  effectIdsMask: DEFAULT_BASE_PROPS.effectIdsMask,
+  emissiveColor: DEFAULT_BASE_PROPS.emissiveColor,
+  emissiveIntensity: DEFAULT_BASE_PROPS.emissiveIntensity,
+  transparent: DEFAULT_BASE_PROPS.transparent,
+  depthTest: DEFAULT_BASE_PROPS.depthTest,
+  atlasSize: DEFAULT_BASE_PROPS.atlasSize,
+  fovRad: DEFAULT_BASE_PROPS.fovRad,
+  screenHeightPx: DEFAULT_BASE_PROPS.screenHeightPx,
+};
+
+/**
+ * Update mutable state from props.
+ * Props override currentState values; missing props fall back to currentState.
+ * Pass DEFAULT_BASE_STATE as currentState for initial mount.
+ *
+ * @param props - The props to apply
+ * @param currentState - The current state to use as fallback (use DEFAULT_BASE_STATE for mount)
+ */
+export const updateState = (
+  props: InstancedSpriteBaseProps,
+  currentState: InstancedSpriteBaseState,
+): InstancedSpriteBaseState => {
+  return {
+    // Immutable after mount - always preserve current value
+    useRTE: currentState.useRTE,
+    billboard: currentState.billboard,
+    // Mutable
+    scale: props.scale ?? currentState.scale,
+    center: props.center ?? currentState.center,
+    sizeInMeters: props.sizeInMeters ?? currentState.sizeInMeters,
+    offsetDepth: props.offsetDepth ?? currentState.offsetDepth,
+    alphaTest: props.alphaTest ?? currentState.alphaTest,
+    pickable: props.pickable ?? currentState.pickable,
+    effectIdsMask: props.effectIdsMask ?? currentState.effectIdsMask,
+    emissiveColor: props.emissiveColor ?? currentState.emissiveColor,
+    emissiveIntensity:
+      props.emissiveIntensity ?? currentState.emissiveIntensity,
+    transparent: props.transparent ?? currentState.transparent,
+    depthTest: props.depthTest ?? currentState.depthTest,
+    atlasSize: props.atlasSize ?? currentState.atlasSize,
+    fovRad: props.fovRad ?? currentState.fovRad,
+    screenHeightPx: props.screenHeightPx ?? currentState.screenHeightPx,
+  };
+};

package/src/material/enhancer/instancedSprite/instancedSpriteBaseEnhancer/types.ts

@@ -0,0 +1,146 @@
+import type { Matrix4, Texture, Vector2, Vector3 } from "three";
+
+import type { UniformValue } from "../../../types";
+import type { Mutates } from "../../MaterialEnhancer";
+
+/**
+ * Props for the instancedSprite base enhancer.
+ */
+export type InstancedSpriteBaseProps = {
+  // Immutable after mount
+  useRTE?: boolean;
+  billboard?: boolean;
+
+  // Mutable state
+  scale?: number;
+  center?: [number, number];
+  sizeInMeters?: boolean;
+  offsetDepth?: boolean;
+  alphaTest?: number;
+  pickable?: boolean;
+
+  // SelectiveEffect
+  effectIdsMask?: number;
+  emissiveColor?: number;
+  emissiveIntensity?: number;
+
+  // Material properties (set directly on material, not via uniforms)
+  transparent?: boolean;
+  depthTest?: boolean;
+
+  // External uniform refs / values (may change over time)
+  rtcCenter?: [number, number, number];
+  texture?: UniformValue<Texture | null>;
+  /** Billboard atlas dimensions in pixels; normalizes instanceUvRect in the shader. */
+  atlasSize?: [number, number];
+  fovRad?: number;
+  screenHeightPx?: number;
+};
+
+/**
+ * Immutable state snapshot for the instancedSprite base enhancer.
+ * This state is always replaced as a whole (never mutated).
+ */
+export type InstancedSpriteBaseState = Readonly<{
+  // Immutable after mount
+  useRTE: boolean;
+  billboard: boolean;
+
+  // Mutable
+  scale: number;
+  center: [number, number];
+  sizeInMeters: boolean;
+  offsetDepth: boolean;
+  alphaTest: number;
+  pickable: boolean;
+  effectIdsMask: number;
+  emissiveColor: number;
+  emissiveIntensity: number;
+
+  // Material properties
+  transparent: boolean;
+  depthTest: boolean;
+
+  // External ref state
+  atlasSize: [number, number];
+  fovRad: number;
+  screenHeightPx: number;
+}>;
+
+/**
+ * Mutable references (uniforms) for the instancedSprite base enhancer.
+ * These are shared references with shader.uniforms.
+ * Internal type - not exposed externally.
+ */
+export type InstancedSpriteBaseRefs = {
+  uRTCCenter: UniformValue<Vector3>;
+  uRTCCenterView: UniformValue<Vector3>;
+  uEyeRTELow: UniformValue<Vector3>;
+  uEyeRTEHigh: UniformValue<Vector3>;
+  uScale: UniformValue<number>;
+  uCenter: UniformValue<Vector2>;
+  uSizeInMeters: UniformValue<boolean>;
+  uOffsetDepth: UniformValue<boolean>;
+  uAlphaTest: UniformValue<number>;
+  uFarPlane: UniformValue<number>;
+  uAtlasSize: UniformValue<Vector2>;
+  nvr_uPickable: UniformValue<number>;
+  uEffectIdsMask: UniformValue<number>;
+  uEmissiveColor: UniformValue<Vector3>;
+  uEmissiveIntensity: UniformValue<number>;
+  uFovRad: UniformValue<number>;
+  uScreenHeightPx: UniformValue<number>;
+
+  // External ref - only present in billboard mode
+  uTexture?: UniformValue<Texture | null>;
+};
+
+export type InstancedSpriteBaseUniforms = Partial<InstancedSpriteBaseRefs>;
+
+/**
+ * Mutation functions for the instancedSprite base enhancer.
+ */
+export type InstancedSpriteBaseMutates = Mutates<
+  InstancedSpriteBaseState,
+  InstancedSpriteBaseUniforms,
+  {
+    /**
+     * Update RTE uniforms per-frame.
+     * Calls encodePosition internally to split camera position into high/low.
+     */
+    updateRteUniforms: (
+      cameraX: number,
+      cameraY: number,
+      cameraZ: number,
+      state: InstancedSpriteBaseState,
+    ) => void;
+    /**
+     * Update the RTC uniforms per-frame. Transforms the RTC center into view
+     * space on the CPU (float64) so the shader avoids a large-coordinate
+     * float32 subtraction that would otherwise cause jitter.
+     */
+    updateRtcUniforms: (
+      viewMatrix: Matrix4,
+      state: InstancedSpriteBaseState,
+    ) => void;
+    /**
+     * Update far plane per-frame from camera.
+     */
+    updateFarPlane: (far: number) => void;
+
+    /**
+     * Update FOV per-frame from camera, in radians.
+     */
+    updateFovRad: (fovRad: number) => void;
+
+    /**
+     * Update screen height per-frame from renderer size, in pixels.
+     */
+    updateScreenHeightPx: (height: number) => void;
+
+    /**
+     * Set texture external ref.
+     */
+    setTexture: (texture: UniformValue<Texture | null>) => void;
+  }
+>;

package/src/material/enhancer/instancedSprite/instancedSpriteMaterialEnhancer.ts

@@ -0,0 +1,105 @@
+/**
+ * InstancedSprite Material Enhancer - Currently just the Base enhancer
+ *
+ * This module provides instancedSprite material functionality using the base enhancer.
+ * Structured for future composition if additional enhancers are needed.
+ */
+
+import type { MaterialEnhancer } from "../MaterialEnhancer";
+
+import {
+  createInstancedSpriteBaseEnhancer,
+  type InstancedSpriteBaseMutates,
+  type InstancedSpriteBaseProps,
+  type InstancedSpriteBaseState,
+  type SupportedMaterial,
+} from "./instancedSpriteBaseEnhancer";
+
+/**
+ * Props for the instancedSprite material enhancer.
+ * Currently just wraps the base props, but structured for future composition.
+ */
+export type InstancedSpriteMaterialProps = {
+  base?: InstancedSpriteBaseProps;
+};
+
+// Shaders this enhancer supports (custom ShaderMaterial via the "shader" shader name)
+const AVAILABLE_SHADERS = ["shader"] as const;
+type AVAILABLE_SHADERS = typeof AVAILABLE_SHADERS;
+
+/**
+ * Factory function to create the instancedSprite material enhancer.
+ *
+ * This creates a new enhancer instance with its own internal state.
+ *
+ * @param material - The Three.js ShaderMaterial to enhance
+ *
+ * @example
+ * ```typescript
+ * const material = new ShaderMaterial();
+ * const enhancer = createInstancedSpriteMaterialEnhancer(material);
+ *
+ * // Mount with base props
+ * enhancer.mount({
+ *   base: { scale: 100, useRTE: true, billboard: true },
+ * });
+ *
+ * // Get state directly via states() - refresh after updates
+ * const state = enhancer.states();
+ *
+ * // Update RTE uniforms per-frame via mutates()
+ * if (state.useRTE) {
+ *   const mutates = enhancer.mutates();
+ *   mutates.updateRteUniforms(camX, camY, camZ, state);
+ * }
+ *
+ * // Update props (then call states() again to get fresh state)
+ * enhancer.update({ base: { scale: 200 } });
+ *
+ * // Use transformShader for onBeforeCompile
+ * material.onBeforeCompile = enhancer.transformShader;
+ * ```
+ */
+export function createInstancedSpriteMaterialEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  InstancedSpriteMaterialProps,
+  InstancedSpriteBaseState,
+  InstancedSpriteBaseMutates,
+  AVAILABLE_SHADERS
+> {
+  const baseEnhancer = createInstancedSpriteBaseEnhancer(material);
+
+  return {
+    material,
+    availableShaders: AVAILABLE_SHADERS,
+
+    transformShader: (shader) => {
+      baseEnhancer.transformShader(shader);
+    },
+
+    mount: (props) => {
+      baseEnhancer.mount(props.base ?? {});
+    },
+
+    update: (props) => {
+      if (props.base) {
+        baseEnhancer.update(props.base);
+      }
+    },
+
+    states: () => baseEnhancer.states(),
+
+    mutates: () => baseEnhancer.mutates(),
+
+    programCacheKey: () => baseEnhancer.programCacheKey(),
+  };
+}
+
+// Re-export types for convenience
+export type {
+  InstancedSpriteBaseMutates,
+  InstancedSpriteBaseProps,
+  InstancedSpriteBaseState,
+};

package/src/material/enhancer/model/index.ts

@@ -0,0 +1,25 @@
+export { createModelBaseEnhancer } from "./modelBaseEnhancer";
+export {
+  MODEL_BASE_SHADER_MARKERS,
+  createModelBaseShaderReplacer,
+} from "./modelBaseEnhancer";
+export type {
+  ModelBaseMutates,
+  ModelBaseProps,
+  ModelBaseState,
+} from "./modelBaseEnhancer";
+
+export { createModelWaterEnhancer } from "./modelWaterEnhancer";
+export type {
+  ModelWaterCombinedMutates,
+  ModelWaterCombinedStates,
+  ModelWaterOnlyProps,
+  ModelWaterProps,
+  ModelWaterState,
+} from "./modelWaterEnhancer";
+
+export { createModelMaterialEnhancer } from "./modelMaterialEnhancer";
+export type { ModelMaterialProps } from "./modelMaterialEnhancer";
+
+export { createPntsEnhancer } from "./pntsEnhancer";
+export type { PntsMutates, PntsProps, PntsState } from "./pntsEnhancer";

package/src/material/enhancer/model/modelBaseEnhancer/index.test.ts

@@ -0,0 +1,74 @@
+import { MeshStandardMaterial } from "three";
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { createModelBaseEnhancer } from ".";
+
+describe("modelBaseEnhancer", () => {
+  let enhancer: ReturnType<typeof createModelBaseEnhancer>;
+
+  beforeEach(() => {
+    enhancer = createModelBaseEnhancer(new MeshStandardMaterial());
+  });
+
+  describe("lifecycle", () => {
+    it("states() should throw if called before mount", () => {
+      const freshEnhancer = createModelBaseEnhancer(new MeshStandardMaterial());
+      expect(() => freshEnhancer.states()).toThrow(
+        "mount() must be called before states",
+      );
+    });
+
+    it("mutates() should throw if called before mount", () => {
+      const freshEnhancer = createModelBaseEnhancer(new MeshStandardMaterial());
+      expect(() => freshEnhancer.mutates()).toThrow(
+        "mount() must be called before mutates",
+      );
+    });
+
+    it("update() should throw if called before mount", () => {
+      const freshEnhancer = createModelBaseEnhancer(new MeshStandardMaterial());
+      expect(() => freshEnhancer.update({})).toThrow(
+        "mount() must be called before update",
+      );
+    });
+  });
+
+  describe("programCacheKey", () => {
+    it("should return cache key based on shader-affecting state", () => {
+      enhancer.mount({
+        useBatchTexture: true,
+        useBatchColorShow: false,
+      });
+
+      const cacheKey = enhancer.programCacheKey();
+      const parsed = JSON.parse(cacheKey);
+
+      expect(parsed).toEqual({
+        useBatchTexture: true,
+        useBatchColorShow: false,
+      });
+    });
+
+    it("should return different cache keys for different shader-affecting states", () => {
+      enhancer.mount({ useBatchTexture: false });
+      const cacheKey1 = enhancer.programCacheKey();
+
+      const enhancer2 = createModelBaseEnhancer(new MeshStandardMaterial());
+      enhancer2.mount({ useBatchTexture: true });
+      const cacheKey2 = enhancer2.programCacheKey();
+
+      expect(cacheKey1).not.toBe(cacheKey2);
+    });
+
+    it("should return same cache key for same shader-affecting states with different non-affecting states", () => {
+      enhancer.mount({ useBatchTexture: true, pickable: true });
+      const cacheKey1 = enhancer.programCacheKey();
+
+      const enhancer2 = createModelBaseEnhancer(new MeshStandardMaterial());
+      enhancer2.mount({ useBatchTexture: true, pickable: false });
+      const cacheKey2 = enhancer2.programCacheKey();
+
+      expect(cacheKey1).toBe(cacheKey2);
+    });
+  });
+});