@navaramap/three 0.0.0

package/src/material/enhancer/polyline/polylineBaseEnhancer/shader.test.ts

@@ -0,0 +1,67 @@
+import FlatPolylineFragShader from "@shaders/glsl/flatPolyline.frag.glsl";
+import FlatPolylineVertShader from "@shaders/glsl/flatPolyline.vert.glsl";
+import PolylineFragShader from "@shaders/glsl/polyline.frag.glsl";
+import PolylineVertShader from "@shaders/glsl/polyline.vert.glsl";
+import { describe, it, expect } from "vitest";
+
+import { createPolylineBaseEnhancer, type SupportedMaterial } from ".";
+
+describe("polylineBaseEnhancer shader selection", () => {
+  it("should use FlatPolyline shaders when isTexturized is true", () => {
+    const material = {
+      type: "ShaderMaterial",
+      userData: {},
+    } as unknown as SupportedMaterial;
+
+    const enhancer = createPolylineBaseEnhancer(material);
+
+    // Mount with isTexturized = true
+    enhancer.mount({
+      isTexturized: true,
+    });
+
+    // Create a mock shader object
+    const shader = {
+      vertexShader: "",
+      fragmentShader: "",
+      uniforms: {},
+      defines: {},
+    };
+
+    // Transform the shader
+    enhancer.transformShader(shader as any);
+
+    // Verify that FlatPolyline shaders are used
+    expect(shader.vertexShader).toBe(FlatPolylineVertShader);
+    expect(shader.fragmentShader).toBe(FlatPolylineFragShader);
+  });
+
+  it("should use PolylineFragShader when isTexturized is false", () => {
+    const material = {
+      type: "ShaderMaterial",
+      userData: {},
+    } as unknown as SupportedMaterial;
+
+    const enhancer = createPolylineBaseEnhancer(material);
+
+    // Mount with isTexturized = false
+    enhancer.mount({
+      isTexturized: false,
+    });
+
+    // Create a mock shader object
+    const shader = {
+      vertexShader: "",
+      fragmentShader: "",
+      uniforms: {},
+      defines: {},
+    };
+
+    // Transform the shader
+    enhancer.transformShader(shader as any);
+
+    // Verify that PolylineVertShader and PolylineFragShader are used
+    expect(shader.vertexShader).toBe(PolylineVertShader);
+    expect(shader.fragmentShader).toContain(PolylineFragShader);
+  });
+});

package/src/material/enhancer/polyline/polylineBaseEnhancer/shader.ts

@@ -0,0 +1,75 @@
+import FlatPolylineFragShader from "@shaders/glsl/flatPolyline.frag.glsl";
+import FlatPolylineVertShader from "@shaders/glsl/flatPolyline.vert.glsl";
+import PolylineFragShader from "@shaders/glsl/polyline.frag.glsl";
+import PolylineVertShader from "@shaders/glsl/polyline.vert.glsl";
+import { packing } from "@takram/three-geospatial/shaders";
+import type { WebGLProgramParametersWithUniforms } from "three";
+
+import type { SupportedMaterial } from "./material";
+import type { PolylineBaseMutates, PolylineBaseState } from "./types";
+
+/**
+ * Select appropriate shaders based on polyline state.
+ *
+ * @param isTexturized - Whether the polyline is rendered as flat texturized tile
+ * @returns Object with vertexShader and fragmentShader code
+ */
+const selectShaders = (
+  isTexturized: boolean,
+): { vertexShader: string; fragmentShader: string } => {
+  if (isTexturized) {
+    // Flat polyline for texturized tile rendering
+    return {
+      vertexShader: FlatPolylineVertShader,
+      fragmentShader: FlatPolylineFragShader,
+    };
+  }
+
+  // 3D polyline for globe rendering
+  const fragmentShader = `${packing}\n` + PolylineFragShader;
+
+  return {
+    vertexShader: PolylineVertShader,
+    fragmentShader,
+  };
+};
+
+/**
+ * Transform shader with polyline base modifications.
+ *
+ * For polylines, the shaders are already provided as custom GLSL (polyline.vert.glsl, polyline.frag.glsl).
+ * This function primarily handles uniform assignment via mutates.updateUniforms().
+ *
+ * The shader transformation is minimal because:
+ * 1. Polyline shaders are custom ShaderMaterial shaders (not built-in Three.js shaders)
+ * 2. The shader code already contains all necessary features (RTE, batch texture, picking, etc.)
+ * 3. Features are controlled via #define flags set in onBeforeCompile (see PolylineMesh.initMaterial)
+ */
+export const transformShader = (
+  shader: WebGLProgramParametersWithUniforms,
+  state: PolylineBaseState,
+  mutates: PolylineBaseMutates,
+  material: SupportedMaterial,
+): void => {
+  // Select and set shaders based on state
+  const shaders = selectShaders(state.isTexturized);
+  shader.vertexShader = shaders.vertexShader;
+  shader.fragmentShader = shaders.fragmentShader;
+
+  // Set shader defines based on state
+  shader.defines ??= {};
+
+  if (state.useRTE) {
+    shader.defines.USE_RTE = true;
+  }
+
+  shader.defines.USE_SELECTIVE_EFFECT = 1;
+
+  // Merge defines from material.userData.defines (includes batch texture 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/polyline/polylineBaseEnhancer/state.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { DEFAULT_BASE_STATE, updateState } from "./state";
+import type { PolylineBaseProps } from "./types";
+
+describe("polylineBaseEnhancer/state", () => {
+  describe("updateState", () => {
+    it("should initialize state from props with defaults", () => {
+      const props: PolylineBaseProps = {
+        color: 0xff0000,
+        width: 2,
+      };
+
+      const state = updateState(props, DEFAULT_BASE_STATE);
+
+      expect(state.width).toBe(2);
+      expect(state.useRTE).toBe(false);
+      expect(state.pickable).toBe(false);
+    });
+
+    it("should update minMaxHeight from props", () => {
+      const props: PolylineBaseProps = {
+        minMaxHeight: [100, 200],
+      };
+
+      const state = updateState(props, DEFAULT_BASE_STATE);
+
+      expect(state.minMaxHeight).toEqual([100, 200]);
+    });
+
+    it("should update width from props", () => {
+      const props: PolylineBaseProps = {
+        width: 5,
+      };
+
+      const state = updateState(props, DEFAULT_BASE_STATE);
+
+      expect(state.width).toBe(5);
+    });
+
+    it("should update batch flags from props", () => {
+      const props: PolylineBaseProps = {
+        batchColorEnabled: true,
+        useBatchTexture: true,
+        useBatchColorShow: true,
+      };
+
+      const state = updateState(props, DEFAULT_BASE_STATE);
+
+      expect(state.batchColorEnabled).toBe(true);
+      expect(state.useBatchTexture).toBe(true);
+      expect(state.useBatchColorShow).toBe(true);
+    });
+  });
+});

package/src/material/enhancer/polyline/polylineBaseEnhancer/state.ts

@@ -0,0 +1,91 @@
+import type { PolylineBaseProps, PolylineBaseState } from "./types";
+
+export const DEFAULT_BASE_PROPS: Required<
+  Omit<
+    PolylineBaseProps,
+    | "batchDataTexture"
+    | "minMaxHeight"
+    | "viewportAndPixelRatio"
+    | "frustumNearFar"
+    | "frustumRatio"
+  >
+> = {
+  color: 0xffffff,
+  transparent: false,
+  opacity: 1.0,
+  depthWrite: true,
+  addHeight: 0,
+  width: 1,
+  maxWidth: 1000,
+  isTexturized: false,
+  pickable: false,
+  effectIdsMask: 0,
+  emissiveColor: 0,
+  emissiveIntensity: 0,
+  useRTE: false,
+  batchColorEnabled: false,
+  useBatchTexture: false,
+  useBatchColorShow: false,
+  useBatchHeight: false,
+  useBatchLineWidth: false,
+};
+
+/** Default state derived from DEFAULT_BASE_PROPS */
+export const DEFAULT_BASE_STATE: PolylineBaseState = {
+  useRTE: DEFAULT_BASE_PROPS.useRTE,
+  isTexturized: DEFAULT_BASE_PROPS.isTexturized,
+  pickable: DEFAULT_BASE_PROPS.pickable,
+  effectIdsMask: DEFAULT_BASE_PROPS.effectIdsMask,
+  emissiveColor: DEFAULT_BASE_PROPS.emissiveColor,
+  emissiveIntensity: DEFAULT_BASE_PROPS.emissiveIntensity,
+  minMaxHeight: [0, 0],
+  addHeight: DEFAULT_BASE_PROPS.addHeight,
+  width: DEFAULT_BASE_PROPS.width,
+  maxWidth: DEFAULT_BASE_PROPS.maxWidth,
+  color: DEFAULT_BASE_PROPS.color,
+  batchColorEnabled: DEFAULT_BASE_PROPS.batchColorEnabled,
+  useBatchTexture: DEFAULT_BASE_PROPS.useBatchTexture,
+  useBatchColorShow: DEFAULT_BASE_PROPS.useBatchColorShow,
+  useBatchHeight: DEFAULT_BASE_PROPS.useBatchHeight,
+  useBatchLineWidth: DEFAULT_BASE_PROPS.useBatchLineWidth,
+};
+
+/**
+ * Update immutable 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: PolylineBaseProps,
+  currentState: PolylineBaseState,
+): PolylineBaseState => {
+  const isTexturized = props.isTexturized ?? currentState.isTexturized;
+
+  return {
+    // RTE cannot change after mount - always preserve current value
+    useRTE: currentState.useRTE,
+    isTexturized,
+    pickable: props.pickable ?? currentState.pickable,
+    effectIdsMask: props.effectIdsMask ?? currentState.effectIdsMask,
+    emissiveColor: props.emissiveColor ?? currentState.emissiveColor,
+    emissiveIntensity:
+      props.emissiveIntensity ?? currentState.emissiveIntensity,
+    minMaxHeight: props.minMaxHeight ?? currentState.minMaxHeight,
+    addHeight: props.addHeight ?? currentState.addHeight,
+    width: props.width ?? currentState.width,
+    maxWidth: props.maxWidth ?? currentState.maxWidth,
+    color: props.color ?? currentState.color,
+    // Batch flags can only transition from false to true, never back
+    batchColorEnabled:
+      currentState.batchColorEnabled || !!props.batchColorEnabled,
+    useBatchTexture: currentState.useBatchTexture || !!props.useBatchTexture,
+    useBatchColorShow:
+      currentState.useBatchColorShow || !!props.useBatchColorShow,
+    useBatchHeight: currentState.useBatchHeight || !!props.useBatchHeight,
+    useBatchLineWidth:
+      currentState.useBatchLineWidth || !!props.useBatchLineWidth,
+  };
+};

package/src/material/enhancer/polyline/polylineBaseEnhancer/types.ts

@@ -0,0 +1,170 @@
+import type { Color, Matrix4, Texture, Vector2, Vector3 } from "three";
+
+import type { UniformValue } from "../../../types";
+import type { BatchTextureFlags } from "../../batchTexture";
+import type { Mutates } from "../../MaterialEnhancer";
+
+type PolylineBatchTextureFlags = Required<
+  Omit<BatchTextureFlags, "useBatchExtrudedHeight" | "useBatchSize">
+>;
+
+/**
+ * Props for the polyline base enhancer.
+ */
+export type PolylineBaseProps = {
+  // Basic material props
+  color?: number;
+
+  transparent?: boolean;
+  opacity?: number;
+  depthWrite?: boolean;
+
+  // Height/width
+  minMaxHeight?: [number, number];
+  addHeight?: number;
+  width?: number;
+  maxWidth?: number;
+
+  isTexturized?: boolean;
+
+  // Picking
+  pickable?: boolean;
+
+  // SelectiveEffect
+  effectIdsMask?: number;
+  emissiveColor?: number;
+  emissiveIntensity?: number;
+
+  // External uniforms (passed from CommonUniforms)
+  // Note: These use tuple types matching CommonUniforms, not Three.js Vector types
+  viewportAndPixelRatio?: {
+    value: [x: number, y: number, z: number] | undefined | null;
+  };
+  frustumNearFar?: { value: [x: number, y: number] | undefined | null };
+  frustumRatio?: {
+    value: [x: number, y: number, z: number, w: number] | undefined | null;
+  };
+
+  // Batch texture
+  batchDataTexture?: UniformValue<Texture | null>;
+
+  // Batch texture state flags - track when batch attributes are being used
+  batchColorEnabled?: boolean;
+
+  // RTE (Relative To Eye) support
+  useRTE?: boolean;
+} & Partial<PolylineBatchTextureFlags>;
+
+/**
+ * Immutable state for the polyline base enhancer.
+ * This state is always replaced as a whole (never mutated).
+ * Returned directly via states() - refresh after updates.
+ */
+export type PolylineBaseState = Readonly<
+  {
+    useRTE: boolean;
+    isTexturized: boolean;
+    pickable: boolean;
+    effectIdsMask: number;
+    emissiveColor: number;
+    emissiveIntensity: number;
+    minMaxHeight: [number, number];
+    addHeight: number;
+    width: number;
+    maxWidth: number;
+    color: number;
+    // Batch texture state - when true, material.color is white and colors come from batch texture
+    batchColorEnabled: boolean;
+  } & PolylineBatchTextureFlags
+>;
+
+/**
+ * Mutable references (uniforms) for the polyline base enhancer.
+ *
+ * These are shared references with shader.uniforms and can be mutated directly
+ * for efficient GPU uniform updates without shader recompilation.
+ * Internal type - not exposed externally.
+ */
+export type PolylineBaseRefs = {
+  // Core uniforms
+  minMaxHeightAndWidth: UniformValue<[number, number, number]>;
+  maxWidth: UniformValue<number>;
+  uAddHeight: UniformValue<number>;
+  color: UniformValue<Color>;
+  nvr_uPickable: UniformValue<number>;
+  uEffectIdsMask: UniformValue<number>;
+  uEmissiveColor: UniformValue<Vector3>;
+  uEmissiveIntensity: UniformValue<number>;
+  nvr_uPickingCoord: UniformValue<Vector2>;
+
+  // Optional uniforms
+  batchDataTexture?: UniformValue<Texture | null>;
+
+  // External shared uniforms (references passed from CommonUniforms)
+  // Note: These use tuple types matching CommonUniforms, not Three.js Vector types
+  viewportAndPixelRatio?: {
+    value: [x: number, y: number, z: number] | undefined | null;
+  };
+  frustumNearFar?: { value: [x: number, y: number] | undefined | null };
+  frustumRatio?: {
+    value: [x: number, y: number, z: number, w: number] | undefined | null;
+  };
+
+  // RTE uniforms (only present if useRTE is true)
+  modelViewMatrixRTE?: UniformValue<Matrix4>;
+  u_cameraPositionHigh?: UniformValue<Vector3>;
+  u_cameraPositionLow?: UniformValue<Vector3>;
+};
+
+export type PolylineBaseUniforms = Partial<PolylineBaseRefs>;
+
+/**
+ * Mutation functions for the polyline base enhancer.
+ * Includes `update(state)` to sync refs from state, plus additional methods.
+ */
+export type PolylineBaseMutates = Mutates<
+  PolylineBaseState,
+  PolylineBaseUniforms,
+  {
+    /**
+     * Update RTE (Relative-To-Eye) uniforms for high-precision rendering.
+     * Call this per-frame to update the model-view matrix and camera position.
+     * Does nothing if RTE is not enabled.
+     *
+     * @param modelViewMatrixRTE - The model-view matrix in RTE coordinates
+     * @param cameraPositionHigh - High-precision component of camera position
+     * @param cameraPositionLow - Low-precision component of camera position
+     * @param state - PolylineBaseState
+     */
+    updateRteUniforms: (
+      modelViewMatrixRTE: Matrix4,
+      cameraPositionHigh: Vector3,
+      cameraPositionLow: Vector3,
+      state: PolylineBaseState,
+    ) => void;
+    /**
+     * Set the batch data texture ref.
+     * This is needed because batchDataTexture is an external ref passed via props.
+     */
+    setBatchDataTexture: (texture: UniformValue<Texture | null>) => void;
+    /**
+     * Set the picking coordinate.
+     * This is needed to update the picking coordinate uniform.
+     */
+    setPickingCoord: (coord: Vector2) => void;
+    /**
+     * Set external uniform references shared across materials.
+     * These are typically passed from CommonUniforms and should be set once during mount.
+     */
+    setExternalRefs: (externalRefs: {
+      batchDataTexture?: UniformValue<Texture | null>;
+      viewportAndPixelRatio?: {
+        value: [x: number, y: number, z: number] | undefined | null;
+      };
+      frustumNearFar?: { value: [x: number, y: number] | undefined | null };
+      frustumRatio?: {
+        value: [x: number, y: number, z: number, w: number] | undefined | null;
+      };
+    }) => void;
+  }
+>;

package/src/material/enhancer/polyline/polylineMaterialEnhancer.ts

@@ -0,0 +1,102 @@
+/**
+ * Polyline Material Enhancer - Currently just the Base enhancer
+ *
+ * This module provides polyline material functionality using the base enhancer.
+ * Unlike polygon materials which have water effects, polyline materials currently
+ * only need the base functionality.
+ */
+
+import type { MaterialEnhancer } from "../MaterialEnhancer";
+
+import {
+  createPolylineBaseEnhancer,
+  type PolylineBaseMutates,
+  type PolylineBaseProps,
+  type PolylineBaseState,
+  type SupportedMaterial,
+} from "./polylineBaseEnhancer";
+
+/**
+ * Props for the polyline material enhancer.
+ * Currently just wraps the base props, but structured for future composition.
+ */
+export type PolylineMaterialProps = {
+  base?: PolylineBaseProps;
+};
+
+// 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 polyline 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 = createPolylineMaterialEnhancer(material);
+ *
+ * // Mount with base props
+ * enhancer.mount({
+ *   base: { color: 0xff0000, width: 2, useRTE: 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(modelViewMatrix, cameraHigh, cameraLow, state);
+ * }
+ *
+ * // Update props (then call states() again to get fresh state)
+ * enhancer.update({ base: { width: 3 } });
+ *
+ * // Use transformShader for onBeforeCompile
+ * material.onBeforeCompile = enhancer.transformShader;
+ * ```
+ */
+export function createPolylineMaterialEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  PolylineMaterialProps,
+  PolylineBaseState,
+  PolylineBaseMutates,
+  AVAILABLE_SHADERS
+> {
+  const baseEnhancer = createPolylineBaseEnhancer(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 { PolylineBaseMutates, PolylineBaseProps, PolylineBaseState };

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

@@ -0,0 +1,7 @@
+export { createSdfTextMaterialEnhancer } from "./sdfTextMaterialEnhancer";
+export type {
+  SdfTextBaseMutates,
+  SdfTextBaseProps,
+  SdfTextBaseState,
+  SdfTextMaterialProps,
+} from "./sdfTextMaterialEnhancer";

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

@@ -0,0 +1,125 @@
+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,
+  updateMaterialProps,
+} from "./material";
+import { createBaseMutates } from "./mutates";
+import { transformShader } from "./shader";
+import { DEFAULT_BASE_PROPS, DEFAULT_BASE_STATE, updateState } from "./state";
+import type {
+  SdfTextBaseMutates,
+  SdfTextBaseProps,
+  SdfTextBaseState,
+} from "./types";
+
+/**
+ * Factory function to create an sdfText base enhancer.
+ *
+ * This enhancer handles:
+ * - Text color, font size, centering
+ * - Outline (width, color, opacity)
+ * - Background quad (color, border)
+ * - Height offset, depth offset
+ * - Picking
+ * - RTE (Relative-To-Eye) support for high-precision coordinates
+ * - Billboard scaling by distance
+ * - SDF atlas texture management
+ *
+ * Supports ShaderMaterial with custom sdfText shaders.
+ *
+ * @param material - The Three.js ShaderMaterial to enhance
+ */
+export function createSdfTextBaseEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  SdfTextBaseProps,
+  SdfTextBaseState,
+  SdfTextBaseMutates,
+  typeof AVAILABLE_SHADERS
+> {
+  // Internal state - immutable, always replaced as a whole
+  let state: SdfTextBaseState | null = null;
+  // Internal mutates object (refs are hidden inside)
+  let mutates: SdfTextBaseMutates | 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: SdfTextBaseProps): void => {
+      const mergedProps = defaults({}, props, DEFAULT_BASE_PROPS);
+      // Create initial state with immutable fields from props
+      const initialState = {
+        ...DEFAULT_BASE_STATE,
+        useRTE: mergedProps.useRTE,
+        useMsdf: mergedProps.useMsdf,
+      };
+      state = updateState(mergedProps, initialState);
+      // Create mutates (refs are created inside with default values)
+      mutates = createBaseMutates(mergedProps.useRTE, mergedProps.rtcCenter);
+      mutates.update(state);
+
+      // Set atlas texture external ref if provided
+      if (props.atlasTexture) {
+        mutates.setAtlasTexture(props.atlasTexture);
+      }
+
+      updateMaterialProps(material, mergedProps);
+    },
+
+    update: (props: SdfTextBaseProps): void => {
+      invariant(state && mutates, "mount() must be called before update");
+
+      state = updateState(props, state);
+      mutates.update(state);
+
+      if (props.atlasTexture) {
+        mutates.setAtlasTexture(props.atlasTexture);
+      }
+
+      updateMaterialProps(material, props);
+    },
+
+    states: (): SdfTextBaseState => {
+      invariant(state, "mount() must be called before states");
+      return state;
+    },
+
+    mutates: (): SdfTextBaseMutates => {
+      invariant(mutates, "mount() must be called before mutates");
+      return mutates;
+    },
+
+    programCacheKey: (): string => {
+      invariant(state, "mount() must be called before programCacheKey");
+      return JSON.stringify({ useRTE: state.useRTE, useMsdf: state.useMsdf });
+    },
+  };
+}
+
+// Re-export public types
+export type { SdfTextBaseMutates, SdfTextBaseProps, SdfTextBaseState };
+
+// Re-export SupportedMaterial for use by composing enhancers
+export type { SupportedMaterial } from "./material";
+
+// Re-export marker types for composing enhancers
+export {
+  SDF_TEXT_BASE_SHADER_MARKERS,
+  createSdfTextBaseShaderReplacer,
+} from "./markers";