@navaramap/three 0.0.0

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/shader.ts

@@ -0,0 +1,36 @@
+import sdfTextFragmentShader from "@shaders/glsl/sdfText.frag.glsl";
+import sdfTextVertexShader from "@shaders/glsl/sdfText.vert.glsl";
+import type { WebGLProgramParametersWithUniforms } from "three";
+
+import type { SdfTextBaseMutates, SdfTextBaseState } from "./types";
+
+/**
+ * Transform shader with sdfText base modifications.
+ *
+ * SdfText uses custom ShaderMaterial shaders. This function:
+ * 1. Sets the vertex/fragment shader sources
+ * 2. Sets defines based on state (USE_RTE)
+ * 3. Assigns uniform refs via mutates.updateUniforms()
+ */
+export const transformShader = (
+  shader: WebGLProgramParametersWithUniforms,
+  state: SdfTextBaseState,
+  mutates: SdfTextBaseMutates,
+): void => {
+  // Set shaders — sdfText always uses the same shader pair
+  shader.vertexShader = sdfTextVertexShader;
+  shader.fragmentShader = sdfTextFragmentShader;
+
+  // Set defines based on state
+  shader.defines ??= {};
+
+  if (state.useRTE) {
+    shader.defines.USE_RTE = 1;
+  }
+  if (state.useMsdf) {
+    shader.defines.USE_MSDF = 1;
+  }
+
+  // Assign uniform refs to shader.uniforms via mutates
+  mutates.updateUniforms(shader.uniforms, state);
+};

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/state.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+
+import { DEFAULT_BASE_STATE, updateState } from "./state";
+import { sdfRadiusFor } from "./types";
+
+describe("sdfTextBaseEnhancer / state", () => {
+  describe("updateState", () => {
+    it("initializes state from props with defaults", () => {
+      const state = updateState({ fontSize: 24 }, DEFAULT_BASE_STATE);
+      expect(state.fontSize).toBe(24);
+      expect(state.center).toEqual([0.5, 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("updates color from hex to RGB tuple", () => {
+      const state = updateState({ color: 0xff0000 }, DEFAULT_BASE_STATE);
+      expect(state.color.getHex()).toBe(0xff0000);
+    });
+
+    it("updates fontSize", () => {
+      const state = updateState({ fontSize: 32 }, DEFAULT_BASE_STATE);
+      expect(state.fontSize).toBe(32);
+    });
+
+    it("updates center", () => {
+      const state = updateState({ center: [0.0, 0.5] }, DEFAULT_BASE_STATE);
+      expect(state.center).toEqual([0.0, 0.5]);
+    });
+
+    it("updates sizeInMeters", () => {
+      const state = updateState({ sizeInMeters: true }, DEFAULT_BASE_STATE);
+      expect(state.sizeInMeters).toBe(true);
+    });
+
+    it("updates addHeight", () => {
+      const state = updateState({ addHeight: 100 }, DEFAULT_BASE_STATE);
+      expect(state.addHeight).toBe(100);
+    });
+
+    it("updates offsetDepth", () => {
+      const state = updateState({ offsetDepth: false }, DEFAULT_BASE_STATE);
+      expect(state.offsetDepth).toBe(false);
+    });
+
+    it("converts outlineWidth using the current quality's range (SDF default)", () => {
+      const state = updateState({ outlineWidth: 2.0 }, DEFAULT_BASE_STATE);
+      expect(state.outlineWidth).toBeCloseTo(
+        2.0 / sdfRadiusFor(DEFAULT_BASE_STATE.useMsdf),
+      );
+    });
+
+    it("updates outlineColor from hex", () => {
+      const state = updateState({ outlineColor: 0x00ff00 }, DEFAULT_BASE_STATE);
+      expect(state.outlineColor.getHex()).toBe(0x00ff00);
+    });
+
+    it("updates outlineOpacity", () => {
+      const state = updateState({ outlineOpacity: 0.5 }, DEFAULT_BASE_STATE);
+      expect(state.outlineOpacity).toBe(0.5);
+    });
+
+    it("updates showBackground", () => {
+      const state = updateState({ showBackground: true }, DEFAULT_BASE_STATE);
+      expect(state.showBackground).toBe(true);
+    });
+
+    it("updates backgroundColor from hex", () => {
+      const state = updateState(
+        { backgroundColor: 0x0000ff },
+        DEFAULT_BASE_STATE,
+      );
+      expect(state.backgroundColor.getHex()).toBe(0x0000ff);
+    });
+
+    it("updates backgroundOutlineColor from hex", () => {
+      const state = updateState(
+        { backgroundOutlineColor: 0xffff00 },
+        DEFAULT_BASE_STATE,
+      );
+      expect(state.backgroundOutlineColor.getHex()).toBe(0xffff00);
+    });
+
+    it("updates backgroundOutlineWidth", () => {
+      const state = updateState(
+        { backgroundOutlineWidth: 0.5 },
+        DEFAULT_BASE_STATE,
+      );
+      expect(state.backgroundOutlineWidth).toBe(0.5);
+    });
+
+    it("updates pickable", () => {
+      const state = updateState({ pickable: true }, DEFAULT_BASE_STATE);
+      expect(state.pickable).toBe(true);
+    });
+
+    it("updates depthTest", () => {
+      const state = updateState({ depthTest: false }, DEFAULT_BASE_STATE);
+      expect(state.depthTest).toBe(false);
+    });
+
+    it("falls back to currentState for missing props", () => {
+      const currentState = {
+        ...DEFAULT_BASE_STATE,
+        fontSize: 42,
+        center: [1, 2] as [number, number],
+      };
+      const state = updateState({}, currentState);
+      expect(state.fontSize).toBe(42);
+      expect(state.center).toEqual([1, 2]);
+    });
+  });
+});

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/state.ts

@@ -0,0 +1,107 @@
+import { Color } from "three";
+
+import {
+  sdfRadiusFor,
+  type SdfTextBaseProps,
+  type SdfTextBaseState,
+} from "./types";
+
+const hexToColor = (hex: number): Color => {
+  return new Color().setHex(hex);
+};
+
+export const DEFAULT_BASE_PROPS: Required<
+  Omit<SdfTextBaseProps, "atlasTexture" | "rtcCenter">
+> = {
+  useRTE: false,
+  useMsdf: false,
+  color: 0xffffff,
+  opacity: 1.0,
+  fontSize: 16.0,
+  center: [0.5, 0.0],
+  sizeInMeters: true,
+  addHeight: 0.0,
+  offsetDepth: true,
+  outlineWidth: 0,
+  outlineColor: 0x000000,
+  outlineOpacity: 1.0,
+  showBackground: false,
+  backgroundColor: 0xff0000,
+  backgroundOutlineColor: 0xff0000,
+  backgroundOutlineWidth: 0.1,
+  pickable: false,
+  depthTest: true,
+  transparent: true,
+};
+
+/** Default state derived from DEFAULT_BASE_PROPS */
+export const DEFAULT_BASE_STATE: SdfTextBaseState = {
+  useRTE: DEFAULT_BASE_PROPS.useRTE,
+  useMsdf: DEFAULT_BASE_PROPS.useMsdf,
+  color: hexToColor(DEFAULT_BASE_PROPS.color),
+  opacity: DEFAULT_BASE_PROPS.opacity,
+  fontSize: DEFAULT_BASE_PROPS.fontSize,
+  center: DEFAULT_BASE_PROPS.center,
+  sizeInMeters: DEFAULT_BASE_PROPS.sizeInMeters,
+  addHeight: DEFAULT_BASE_PROPS.addHeight,
+  offsetDepth: DEFAULT_BASE_PROPS.offsetDepth,
+  outlineWidth:
+    DEFAULT_BASE_PROPS.outlineWidth / sdfRadiusFor(DEFAULT_BASE_PROPS.useMsdf),
+  outlineColor: hexToColor(DEFAULT_BASE_PROPS.outlineColor),
+  outlineOpacity: DEFAULT_BASE_PROPS.outlineOpacity,
+  showBackground: DEFAULT_BASE_PROPS.showBackground,
+  backgroundColor: hexToColor(DEFAULT_BASE_PROPS.backgroundColor),
+  backgroundOutlineColor: hexToColor(DEFAULT_BASE_PROPS.backgroundOutlineColor),
+  backgroundOutlineWidth: DEFAULT_BASE_PROPS.backgroundOutlineWidth,
+  pickable: DEFAULT_BASE_PROPS.pickable,
+  depthTest: DEFAULT_BASE_PROPS.depthTest,
+  transparent: DEFAULT_BASE_PROPS.transparent,
+};
+
+/**
+ * Update mutable state from props.
+ * Props override currentState values; missing props fall back to currentState.
+ * Pass DEFAULT_BASE_STATE as currentState for initial mount.
+ */
+export const updateState = (
+  props: SdfTextBaseProps,
+  currentState: SdfTextBaseState,
+): SdfTextBaseState => {
+  return {
+    // Immutable after mount
+    useRTE: currentState.useRTE,
+    useMsdf: currentState.useMsdf,
+    // Mutable
+    color:
+      props.color !== undefined ? hexToColor(props.color) : currentState.color,
+    opacity: props.opacity ?? currentState.opacity,
+    fontSize: props.fontSize ?? currentState.fontSize,
+    center: props.center ?? currentState.center,
+    sizeInMeters: props.sizeInMeters ?? currentState.sizeInMeters,
+    addHeight: props.addHeight ?? currentState.addHeight,
+    offsetDepth: props.offsetDepth ?? currentState.offsetDepth,
+    outlineWidth:
+      props.outlineWidth !== undefined
+        ? props.outlineWidth / sdfRadiusFor(currentState.useMsdf)
+        : currentState.outlineWidth,
+    outlineColor:
+      props.outlineColor !== undefined
+        ? hexToColor(props.outlineColor)
+        : currentState.outlineColor,
+    outlineOpacity: props.outlineOpacity ?? currentState.outlineOpacity,
+    showBackground: props.showBackground ?? currentState.showBackground,
+    backgroundColor:
+      props.backgroundColor !== undefined
+        ? hexToColor(props.backgroundColor)
+        : currentState.backgroundColor,
+    backgroundOutlineColor:
+      props.backgroundOutlineColor !== undefined
+        ? hexToColor(props.backgroundOutlineColor)
+        : currentState.backgroundOutlineColor,
+    backgroundOutlineWidth:
+      props.backgroundOutlineWidth ?? currentState.backgroundOutlineWidth,
+    pickable: props.pickable ?? currentState.pickable,
+    depthTest: props.depthTest ?? currentState.depthTest,
+    transparent: props.transparent ?? currentState.transparent,
+  };
+};

package/src/material/enhancer/sdfText/sdfTextBaseEnhancer/types.ts

@@ -0,0 +1,184 @@
+import { atlasRangePx } from "@navaramap/font";
+import type { Color, DataTexture, Matrix4, Vector2, Vector3 } from "three";
+
+import type { UniformValue } from "../../../types";
+import type { Mutates } from "../../MaterialEnhancer";
+
+/** Pixel range covered by a quality's atlas distance field; defines how
+ *  outline-width pixels translate to a distance-value delta. SDF (`useMsdf=false`)
+ *  uses the classic 35 px radius from `sdf_glyph_renderer`; MSDF uses
+ *  `MSDF_RANGE_PX` (8 px). See [`atlasRangePx`] in `@navaramap/font`. */
+export const sdfRadiusFor = (useMsdf: boolean): number => atlasRangePx(useMsdf);
+
+/**
+ * Props for the sdfText base enhancer.
+ */
+export type SdfTextBaseProps = {
+  // Immutable after mount
+  useRTE?: boolean;
+  /** When `true` the fragment shader samples the atlas as 4-channel MTSDF
+   *  (median of RGB + true SDF in alpha) instead of single-channel R8. */
+  useMsdf?: boolean;
+
+  // Mutable state
+  color?: number; // hex color
+  opacity?: number;
+  fontSize?: number;
+  center?: [number, number];
+  sizeInMeters?: boolean;
+  addHeight?: number;
+  offsetDepth?: boolean;
+  outlineWidth?: number; // raw width, converted in state via sdfRadiusFor(useMsdf)
+  outlineColor?: number; // hex
+  outlineOpacity?: number;
+  showBackground?: boolean;
+  backgroundColor?: number; // hex
+  backgroundOutlineColor?: number; // hex
+  backgroundOutlineWidth?: number;
+  pickable?: boolean;
+
+  // Material properties (set directly on material, not via uniforms)
+  depthTest?: boolean;
+  transparent?: boolean;
+
+  // External uniform refs / values (may change over time)
+  rtcCenter?: [number, number, number];
+  atlasTexture?: UniformValue<DataTexture | null>;
+};
+
+/**
+ * Immutable state snapshot for the sdfText base enhancer.
+ */
+export type SdfTextBaseState = Readonly<{
+  // Immutable after mount
+  useRTE: boolean;
+  useMsdf: boolean;
+
+  // Mutable
+  color: Color;
+  opacity: number;
+  fontSize: number;
+  center: [number, number];
+  sizeInMeters: boolean;
+  addHeight: number;
+  offsetDepth: boolean;
+  outlineWidth: number; // pre-converted: raw / sdfRadiusFor(useMsdf)
+  outlineColor: Color;
+  outlineOpacity: number;
+  showBackground: boolean;
+  backgroundColor: Color;
+  backgroundOutlineColor: Color;
+  backgroundOutlineWidth: number;
+  pickable: boolean;
+
+  // Material properties
+  depthTest: boolean;
+  transparent: boolean;
+}>;
+
+/**
+ * Mutable references (uniforms) for the sdfText base enhancer.
+ * These are shared references with shader.uniforms.
+ * Internal type - not exposed externally.
+ */
+export type SdfTextBaseRefs = {
+  uColor: UniformValue<Color>;
+  uOpacity: UniformValue<number>;
+  uFontSize: UniformValue<number>;
+  uCenter: UniformValue<Vector2>;
+  uSizeInMeters: UniformValue<boolean>;
+  uAddHeight: UniformValue<number>;
+  uOffsetDepth: UniformValue<boolean>;
+  uSdfThreshold: UniformValue<number>;
+  uOutlineWidth: UniformValue<number>;
+  uOutlineColor: UniformValue<Color>;
+  uOutlineOpacity: UniformValue<number>;
+  uShowBackground: UniformValue<boolean>;
+  uBackgroundColor: UniformValue<Color>;
+  uBackgroundOutlineColor: UniformValue<Color>;
+  uBackgroundOutlineWidth: UniformValue<number>;
+  uFovRad: UniformValue<number>;
+  uScreenHeightPx: UniformValue<number>;
+  uFarPlane: UniformValue<number>;
+  uTextWidth: UniformValue<number>;
+  uTextHeight: UniformValue<number>;
+  uBgYBounds: UniformValue<Vector2>;
+  uRTCCenter: UniformValue<Vector3>;
+  uRTCCenterView: UniformValue<Vector3>;
+  uEyeRTELow: UniformValue<Vector3>;
+  uEyeRTEHigh: UniformValue<Vector3>;
+  nvr_uBatchId: UniformValue<number>;
+  nvr_uPickable: UniformValue<number>;
+  uAtlas: UniformValue<DataTexture | null>;
+  /** COLRv1 RGBA atlas. `null` when the font has no color glyphs. */
+  uColorAtlas: UniformValue<DataTexture | null>;
+  /** Current SDF atlas pixel dimensions; updated when the Rust atlas grows. */
+  uSdfAtlasSize: UniformValue<Vector2>;
+  /** Current color atlas pixel dimensions; updated when the color atlas grows. */
+  uColorAtlasSize: UniformValue<Vector2>;
+
+  // Conditional RTE/RTC position uniforms
+  uRTEPositionLOW?: UniformValue<Vector3>;
+  uRTEPositionHIGH?: UniformValue<Vector3>;
+  uRTCPosition?: UniformValue<Vector3>;
+};
+
+export type SdfTextBaseUniforms = Partial<SdfTextBaseRefs>;
+
+/**
+ * Mutation functions for the sdfText base enhancer.
+ */
+export type SdfTextBaseMutates = Mutates<
+  SdfTextBaseState,
+  SdfTextBaseUniforms,
+  {
+    /**
+     * Update per-frame camera uniforms (FOV, screen height, far plane, RTE eye).
+     */
+    updatePerFrame: (
+      fovRad: number,
+      screenHeightPx: number,
+      farPlane: number,
+      cameraX: number,
+      cameraY: number,
+      cameraZ: number,
+      viewMatrix: Matrix4,
+      state: SdfTextBaseState,
+    ) => void;
+    /**
+     * Update text dimension uniforms after text shaping.
+     */
+    updateTextDimensions: (
+      textWidth: number,
+      textHeight: number,
+      bgMinY: number,
+      bgMaxY: number,
+    ) => void;
+    /**
+     * Set the SDF atlas texture external ref.
+     */
+    setAtlasTexture: (texture: UniformValue<DataTexture | null>) => void;
+    /**
+     * Set the COLRv1 color atlas texture external ref.
+     */
+    setColorAtlasTexture: (texture: UniformValue<DataTexture | null>) => void;
+    /**
+     * Sync the atlas-size uniforms with the currently-bound atlas textures.
+     * Cheap to call every frame; the shader divides glyph pixel rects by these
+     * to derive UVs, so this is how atlas resizes propagate to existing meshes.
+     */
+    updateAtlasSizes: () => void;
+    /**
+     * Update position uniforms (RTE or RTC).
+     */
+    setPosition: (
+      position: Float32Array | { high: Float32Array; low: Float32Array },
+      useRTE: boolean,
+      rtcCenter?: [number, number, number],
+    ) => void;
+    /**
+     * Set the batch ID uniform (immutable after mount, but needed for batch creation).
+     */
+    setBatchId: (batchId: number) => void;
+  }
+>;

package/src/material/enhancer/sdfText/sdfTextMaterialEnhancer.ts

@@ -0,0 +1,100 @@
+/**
+ * SdfText Material Enhancer - Currently just the Base enhancer
+ *
+ * This module provides sdfText material functionality using the base enhancer.
+ * Structured for future composition if additional enhancers are needed.
+ */
+
+import type { MaterialEnhancer } from "../MaterialEnhancer";
+
+import {
+  createSdfTextBaseEnhancer,
+  type SdfTextBaseMutates,
+  type SdfTextBaseProps,
+  type SdfTextBaseState,
+  type SupportedMaterial,
+} from "./sdfTextBaseEnhancer";
+
+/**
+ * Props for the sdfText material enhancer.
+ * Currently just wraps the base props, but structured for future composition.
+ */
+export type SdfTextMaterialProps = {
+  base?: SdfTextBaseProps;
+};
+
+// 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 sdfText 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({ transparent: true });
+ * const enhancer = createSdfTextMaterialEnhancer(material);
+ *
+ * // Mount with base props
+ * enhancer.mount({
+ *   base: { color: 0xffffff, fontSize: 16, useRTE: true },
+ * });
+ *
+ * // Get state directly via states() - refresh after updates
+ * const state = enhancer.states();
+ *
+ * // Update per-frame via mutates()
+ * const mutates = enhancer.mutates();
+ * mutates.updatePerFrame(fov, screenHeight, farPlane, camX, camY, camZ, state);
+ *
+ * // Update props (then call states() again to get fresh state)
+ * enhancer.update({ base: { color: 0xff0000 } });
+ *
+ * // Use transformShader for onBeforeCompile
+ * material.onBeforeCompile = enhancer.transformShader;
+ * material.customProgramCacheKey = enhancer.programCacheKey;
+ * ```
+ */
+export function createSdfTextMaterialEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  SdfTextMaterialProps,
+  SdfTextBaseState,
+  SdfTextBaseMutates,
+  AVAILABLE_SHADERS
+> {
+  const baseEnhancer = createSdfTextBaseEnhancer(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 { SdfTextBaseMutates, SdfTextBaseProps, SdfTextBaseState };

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

@@ -0,0 +1,7 @@
+export {
+  createShadowMapDepthEnhancer,
+  type ShadowMapDepthMutates,
+  type ShadowMapDepthProps,
+  type ShadowMapDepthState,
+  type SupportedMaterial as ShadowMapDepthSupportedMaterial,
+} from "./shadowMapDepthEnhancer";

package/src/material/enhancer/shadowMap/shadowMapDepthEnhancer/index.ts

@@ -0,0 +1,97 @@
+import { defaults } from "lodash-es";
+import type { WebGLProgramParametersWithUniforms } from "three";
+import invariant from "tiny-invariant";
+
+import type { MaterialEnhancer } from "../../MaterialEnhancer";
+
+import { AVAILABLE_SHADERS, type SupportedMaterial } from "./material";
+import { createShadowMapDepthMutates } from "./mutates";
+import { transformShader } from "./shader";
+import {
+  DEFAULT_SHADOW_MAP_DEPTH_PROPS,
+  DEFAULT_SHADOW_MAP_DEPTH_STATE,
+  updateState,
+} from "./state";
+import type {
+  ShadowMapDepthMutates,
+  ShadowMapDepthProps,
+  ShadowMapDepthState,
+} from "./types";
+
+/**
+ * Factory function to create a shadow map depth enhancer.
+ *
+ * This enhancer handles shadow map depth shader injection.
+ * It's designed to be used with customDepthMaterial for shadow map generation.
+ *
+ * @param material - The Three.js material to enhance
+ */
+export function createShadowMapDepthEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  ShadowMapDepthProps,
+  ShadowMapDepthState,
+  ShadowMapDepthMutates,
+  typeof AVAILABLE_SHADERS
+> {
+  // Internal state - immutable, always replaced as a whole
+  let state: ShadowMapDepthState | null = null;
+  // Internal mutates object (refs are external, set via props)
+  let mutates: ShadowMapDepthMutates | null = null;
+
+  return {
+    material,
+    availableShaders: AVAILABLE_SHADERS,
+
+    transformShader: (shader: WebGLProgramParametersWithUniforms): void => {
+      invariant(
+        state && mutates,
+        "mount() must be called before transformShader",
+      );
+      transformShader(shader, state, mutates);
+    },
+
+    mount: (props: ShadowMapDepthProps): void => {
+      const mergedProps = defaults({}, props, DEFAULT_SHADOW_MAP_DEPTH_PROPS);
+      state = updateState(mergedProps, DEFAULT_SHADOW_MAP_DEPTH_STATE);
+      // Create mutates
+      mutates = createShadowMapDepthMutates();
+      mutates.update(state);
+    },
+
+    update: (props: ShadowMapDepthProps): void => {
+      invariant(state && mutates, "mount() must be called before update");
+      state = updateState(props, state);
+      mutates.update(state);
+    },
+
+    states: (): ShadowMapDepthState => {
+      invariant(state, "mount() must be called before states");
+      return state;
+    },
+
+    mutates: (): ShadowMapDepthMutates => {
+      invariant(mutates, "mount() must be called before mutates");
+      return mutates;
+    },
+
+    programCacheKey: (): string => {
+      invariant(state, "mount() must be called before programCacheKey");
+      // RTE is always enabled for this enhancer
+      return JSON.stringify({});
+    },
+  };
+}
+
+// Re-export public types
+export type { ShadowMapDepthMutates, ShadowMapDepthProps, ShadowMapDepthState };
+
+// Re-export SupportedMaterial
+export type { SupportedMaterial } from "./material";
+
+// Re-export marker types for composing enhancers
+export {
+  SHADOW_MAP_DEPTH_SHADER_MARKERS,
+  createShadowMapDepthShaderReplacer,
+} from "./markers";

package/src/material/enhancer/shadowMap/shadowMapDepthEnhancer/markers.ts

@@ -0,0 +1,10 @@
+import { type ShaderMarkers, createShaderReplacer } from "../../ShaderReplacer";
+
+export const SHADOW_MAP_DEPTH_SHADER_MARKERS = {
+  vertex: {},
+  fragment: {},
+} as const satisfies ShaderMarkers;
+
+export function createShadowMapDepthShaderReplacer(source: string) {
+  return createShaderReplacer<typeof SHADOW_MAP_DEPTH_SHADER_MARKERS>(source);
+}

package/src/material/enhancer/shadowMap/shadowMapDepthEnhancer/material.ts

@@ -0,0 +1,31 @@
+import type {
+  MeshBasicMaterial,
+  MeshLambertMaterial,
+  MeshPhongMaterial,
+  MeshPhysicalMaterial,
+  MeshStandardMaterial,
+} from "three";
+
+import type { ShaderName } from "../../MaterialEnhancer";
+
+/**
+ * Material types that can be enhanced by this enhancer.
+ * Supports all standard mesh materials for depth/shadow rendering.
+ */
+export type SupportedMaterial =
+  | MeshBasicMaterial
+  | MeshLambertMaterial
+  | MeshPhongMaterial
+  | MeshStandardMaterial
+  | MeshPhysicalMaterial;
+
+/**
+ * Shader types that this enhancer can transform.
+ */
+export const AVAILABLE_SHADERS = [
+  "basic",
+  "lambert",
+  "phong",
+  "standard",
+  "physical",
+] satisfies ShaderName[];