@navaramap/three 0.0.0

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

@@ -0,0 +1,157 @@
+import { ShaderMaterial, type WebGLProgramParametersWithUniforms } from "three";
+import { beforeEach, describe, expect, it } from "vitest";
+
+import type { PolylineBaseProps } from "./types";
+
+import { createPolylineBaseEnhancer } from "./index";
+
+describe("polylineBaseEnhancer", () => {
+  let enhancer: ReturnType<typeof createPolylineBaseEnhancer>;
+
+  beforeEach(() => {
+    enhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+  });
+
+  describe("lifecycle", () => {
+    it("transformShader() should throw if called before mount", () => {
+      const freshEnhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+
+      const shader = {
+        uniforms: {},
+        vertexShader: "",
+        fragmentShader: "",
+        defines: {},
+      } as WebGLProgramParametersWithUniforms;
+
+      expect(() => freshEnhancer.transformShader(shader)).toThrow(
+        "mount() must be called before transformShader",
+      );
+    });
+
+    it("states() should throw if called before mount", () => {
+      const freshEnhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+
+      expect(() => freshEnhancer.states()).toThrow(
+        "mount() must be called before states",
+      );
+    });
+
+    it("mutates() should throw if called before mount", () => {
+      const freshEnhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+
+      expect(() => freshEnhancer.mutates()).toThrow(
+        "mount() must be called before mutates",
+      );
+    });
+
+    it("update() should throw if called before mount", () => {
+      const freshEnhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+
+      expect(() => freshEnhancer.update({})).toThrow(
+        "mount() must be called before update",
+      );
+    });
+
+    it("programCacheKey() should throw if called before mount", () => {
+      const freshEnhancer = createPolylineBaseEnhancer(new ShaderMaterial());
+
+      expect(() => freshEnhancer.programCacheKey()).toThrow(
+        "mount() must be called before programCacheKey",
+      );
+    });
+
+    it("should initialize state on mount", () => {
+      const props: PolylineBaseProps = {
+        color: 0xff0000,
+        width: 2,
+        pickable: true,
+      };
+
+      enhancer.mount(props);
+
+      const state = enhancer.states();
+      expect(state.color).toBe(0xff0000);
+      expect(state.width).toBe(2);
+      expect(state.pickable).toBe(true);
+      expect(state.useRTE).toBe(false);
+    });
+
+    it("should update state on update", () => {
+      enhancer.mount({ width: 2 });
+
+      const stateBefore = enhancer.states();
+      expect(stateBefore.width).toBe(2);
+
+      enhancer.update({ width: 5 });
+
+      const stateAfter = enhancer.states();
+      expect(stateAfter.width).toBe(5);
+    });
+
+    it("should allow transformShader after mount", () => {
+      enhancer.mount({ width: 2 });
+
+      const shader = {
+        uniforms: {},
+        vertexShader: "",
+        fragmentShader: "",
+        defines: {},
+      } as WebGLProgramParametersWithUniforms;
+
+      // Should not throw
+      expect(() => enhancer.transformShader(shader)).not.toThrow();
+
+      // Should have assigned uniforms
+      expect(shader.uniforms.minMaxHeightAndWidth).toBeDefined();
+      expect(shader.uniforms.color).toBeDefined();
+      expect(shader.uniforms.nvr_uPickable).toBeDefined();
+    });
+  });
+
+  describe("programCacheKey", () => {
+    it("should return cache key based on shader-affecting state", () => {
+      enhancer.mount({
+        useBatchTexture: true,
+        useBatchColorShow: false,
+        useBatchHeight: true,
+        useBatchLineWidth: false,
+        isTexturized: true,
+        useRTE: true,
+      });
+
+      const cacheKey = enhancer.programCacheKey();
+      const parsed = JSON.parse(cacheKey);
+
+      expect(parsed).toEqual({
+        useBatchTexture: true,
+        useBatchColorShow: false,
+        useBatchHeight: true,
+        useBatchLineWidth: false,
+        isTexturized: true,
+        useRTE: true,
+      });
+    });
+
+    it("should return different cache keys for different shader-affecting states", () => {
+      enhancer.mount({ useBatchTexture: false });
+      const cacheKey1 = enhancer.programCacheKey();
+
+      const enhancer2 = createPolylineBaseEnhancer(new ShaderMaterial());
+      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, width: 2, color: 0xff0000 });
+      const cacheKey1 = enhancer.programCacheKey();
+
+      const enhancer2 = createPolylineBaseEnhancer(new ShaderMaterial());
+      enhancer2.mount({ useBatchTexture: true, width: 10, color: 0x00ff00 });
+      const cacheKey2 = enhancer2.programCacheKey();
+
+      expect(cacheKey1).toBe(cacheKey2);
+    });
+  });
+});

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

@@ -0,0 +1,154 @@
+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 { updateMaterialProps } from "./material";
+import { createBaseMutates } from "./mutates";
+import { transformShader } from "./shader";
+import { DEFAULT_BASE_PROPS, DEFAULT_BASE_STATE, updateState } from "./state";
+import type {
+  PolylineBaseMutates,
+  PolylineBaseProps,
+  PolylineBaseState,
+} from "./types";
+
+/**
+ * Factory function to create a polyline base enhancer.
+ *
+ * This enhancer handles:
+ * - Color (via shader uniforms)
+ * - Height (minMaxHeight) and width
+ * - Clamp to ground (with ground normals support)
+ * - Texturized rendering (draped on terrain)
+ * - Picking
+ * - Batch texture attributes (color, show, height, lineWidth)
+ * - RTE (Relative-To-Eye) support for high-precision coordinates
+ *
+ * Supports ShaderMaterial with custom polyline shaders.
+ * Note: Unlike polygon materials, polylines don't support opacity/transparent/wireframe
+ * as these are managed via shader uniforms and custom shader code.
+ *
+ * @param material - The Three.js ShaderMaterial to enhance
+ */
+export function createPolylineBaseEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  PolylineBaseProps,
+  PolylineBaseState,
+  PolylineBaseMutates,
+  typeof AVAILABLE_SHADERS
+> {
+  // Internal state - immutable, always replaced as a whole
+  let state: PolylineBaseState | null = null;
+  // Internal mutates object (refs are hidden inside)
+  let mutates: PolylineBaseMutates | null = null;
+
+  return {
+    material,
+    availableShaders: AVAILABLE_SHADERS,
+
+    transformShader: (shader: WebGLProgramParametersWithUniforms): void => {
+      invariant(
+        state && mutates,
+        "mount() must be called before transformShader",
+      );
+      transformShader(shader, state, mutates, material);
+    },
+
+    mount: (props: PolylineBaseProps): void => {
+      const mergedProps = defaults({}, props, DEFAULT_BASE_PROPS);
+      // Create initial state with useRTE from props (useRTE can't change after mount)
+      const initialState = {
+        ...DEFAULT_BASE_STATE,
+        useRTE: mergedProps.useRTE,
+      };
+      state = updateState(mergedProps, initialState);
+      // Create mutates (refs are created inside with default values)
+      mutates = createBaseMutates(mergedProps.useRTE);
+      mutates.update(state);
+      // Set all external refs at once
+      mutates.setExternalRefs({
+        batchDataTexture: props.batchDataTexture,
+        viewportAndPixelRatio: props.viewportAndPixelRatio,
+        frustumNearFar: props.frustumNearFar,
+        frustumRatio: props.frustumRatio,
+      });
+      updateMaterialProps(material, mergedProps);
+    },
+
+    update: (props: PolylineBaseProps): void => {
+      invariant(state && mutates, "mount() must be called before update");
+
+      // Capture previous state for shader-affecting properties
+      const prevIsTexturized = state.isTexturized;
+      const prevUseBatchTexture = state.useBatchTexture;
+      const prevUseBatchColorShow = state.useBatchColorShow;
+      const prevUseBatchHeight = state.useBatchHeight;
+      const prevUseBatchLineWidth = state.useBatchLineWidth;
+
+      state = updateState(props, state);
+      mutates.update(state);
+
+      // Trigger shader recompilation if shader-affecting state changed
+      const shaderStateChanged =
+        state.isTexturized !== prevIsTexturized ||
+        state.useBatchTexture !== prevUseBatchTexture ||
+        state.useBatchColorShow !== prevUseBatchColorShow ||
+        state.useBatchHeight !== prevUseBatchHeight ||
+        state.useBatchLineWidth !== prevUseBatchLineWidth;
+
+      if (shaderStateChanged) {
+        material.needsUpdate = true;
+      }
+
+      if (props.batchDataTexture) {
+        mutates.setBatchDataTexture(props.batchDataTexture);
+      }
+
+      updateMaterialProps(material, props);
+    },
+
+    states: (): PolylineBaseState => {
+      invariant(state, "mount() must be called before states");
+      return state;
+    },
+
+    mutates: (): PolylineBaseMutates => {
+      invariant(mutates, "mount() must be called before mutates");
+      return mutates;
+    },
+
+    programCacheKey: (): string => {
+      invariant(state, "mount() must be called before programCacheKey");
+      // Return cache key based on all state that affects shader sources/defines
+      return JSON.stringify({
+        // Batch-texture related flags
+        useBatchTexture: state.useBatchTexture,
+        useBatchColorShow: state.useBatchColorShow,
+        useBatchHeight: state.useBatchHeight,
+        useBatchLineWidth: state.useBatchLineWidth,
+        // Additional shader-affecting state used by transformShader
+        isTexturized: state.isTexturized,
+        useRTE: state.useRTE,
+        // Custom defines that may influence shader variants
+        userDataDefines: material.userData?.defines ?? undefined,
+      });
+    },
+  };
+}
+
+// Re-export public types
+export type { PolylineBaseMutates, PolylineBaseProps, PolylineBaseState };
+
+// Re-export SupportedMaterial for use by composing enhancers
+export type { SupportedMaterial } from "./material";
+
+// Re-export marker types for composing enhancers
+export {
+  POLYLINE_BASE_SHADER_MARKERS,
+  createPolylineBaseShaderReplacer,
+} from "./markers";

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

@@ -0,0 +1,19 @@
+import type { ShaderMarkers } from "../../ShaderReplacer";
+import { createShaderReplacer } from "../../ShaderReplacer";
+
+/**
+ * Shader markers for the polyline base enhancer.
+ * These markers are placed in the shader code to allow composing enhancers to inject their own code.
+ */
+export const POLYLINE_BASE_SHADER_MARKERS = {
+  vertex: {},
+  fragment: {},
+} as const satisfies ShaderMarkers;
+
+/**
+ * Factory function to create a ShaderReplacer restricted to polyline base markers.
+ * Used by composing enhancers to safely modify shaders.
+ */
+export function createPolylineBaseShaderReplacer(source: string) {
+  return createShaderReplacer<typeof POLYLINE_BASE_SHADER_MARKERS>(source);
+}

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

@@ -0,0 +1,42 @@
+import { ShaderMaterial } from "three";
+import { describe, expect, it } from "vitest";
+
+import { updateMaterialProps } from "./material";
+
+describe("polylineBaseEnhancer/material", () => {
+  describe("updateMaterialProps", () => {
+    it("should not update properties when props are undefined", () => {
+      const material = new ShaderMaterial();
+      material.transparent = true;
+      material.depthWrite = false;
+
+      updateMaterialProps(material, {});
+
+      expect(material.transparent).toBe(true);
+      expect(material.depthWrite).toBe(false);
+    });
+
+    it("should update transparent when provided", () => {
+      const material = new ShaderMaterial();
+      material.transparent = false;
+
+      updateMaterialProps(material, { transparent: true });
+      expect(material.transparent).toBe(true);
+    });
+
+    it("should update depthWrite when provided", () => {
+      const material = new ShaderMaterial();
+      material.depthWrite = true;
+
+      updateMaterialProps(material, { depthWrite: false });
+      expect(material.depthWrite).toBe(false);
+    });
+
+    it("should update opacity when provided", () => {
+      const material = new ShaderMaterial();
+      material.opacity = 1.0;
+      updateMaterialProps(material, { opacity: 0.5 });
+      expect(material.opacity).toBe(0.5);
+    });
+  });
+});

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

@@ -0,0 +1,38 @@
+import { ShaderMaterial } from "three";
+
+import type { ShaderName } from "../../MaterialEnhancer";
+
+import type { PolylineBaseProps } from "./types";
+
+/**
+ * Shaders that the polyline base enhancer supports.
+ * Polylines use ShaderMaterial with custom shaders, not built-in shaders like lambert or phong.
+ */
+export const AVAILABLE_SHADERS = ["shader"] satisfies ShaderName[];
+
+/**
+ * Material types that the polyline base enhancer supports.
+ * Polylines use ShaderMaterial exclusively.
+ */
+export type SupportedMaterial = ShaderMaterial;
+
+/**
+ * Update material properties that affect the Three.js material directly.
+ * These properties are not handled by shader uniforms.
+ * @param material - The material to update
+ * @param props - The props to apply
+ */
+export function updateMaterialProps(
+  material: SupportedMaterial,
+  props: PolylineBaseProps,
+): void {
+  if (props.transparent !== undefined) {
+    material.transparent = props.transparent;
+  }
+  if (props.opacity !== undefined) {
+    material.opacity = props.opacity;
+  }
+  if (props.depthWrite !== undefined) {
+    material.depthWrite = props.depthWrite;
+  }
+}

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

@@ -0,0 +1,120 @@
+import { Vector2 } from "three";
+import { describe, expect, it } from "vitest";
+
+import type { ShaderUniforms } from "../../MaterialEnhancer";
+
+import { createBaseMutates } from "./mutates";
+import { DEFAULT_BASE_STATE } from "./state";
+import type { PolylineBaseState } from "./types";
+
+describe("polylineBaseEnhancer/mutates", () => {
+  describe("RTE uniforms", () => {
+    it("should assign RTE refs to shader.uniforms when useRTE=true", () => {
+      const state: PolylineBaseState = { ...DEFAULT_BASE_STATE, useRTE: true };
+      const mutates = createBaseMutates(true);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      expect(uniforms.modelViewMatrixRTE).toBeDefined();
+      expect(uniforms.u_cameraPositionHigh).toBeDefined();
+      expect(uniforms.u_cameraPositionLow).toBeDefined();
+    });
+
+    it("should not assign RTE refs to shader.uniforms when useRTE=false", () => {
+      const state: PolylineBaseState = { ...DEFAULT_BASE_STATE, useRTE: false };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      expect(uniforms.modelViewMatrixRTE).toBeUndefined();
+      expect(uniforms.u_cameraPositionHigh).toBeUndefined();
+      expect(uniforms.u_cameraPositionLow).toBeUndefined();
+    });
+  });
+
+  describe("update syncs refs from state", () => {
+    it("should sync core refs from state", () => {
+      const state: PolylineBaseState = {
+        ...DEFAULT_BASE_STATE,
+        pickable: true,
+        minMaxHeight: [10, 100],
+        width: 3,
+      };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      expect(uniforms.minMaxHeightAndWidth?.value).toEqual([10, 100, 3]);
+      expect(uniforms.nvr_uPickable?.value).toBe(1);
+    });
+  });
+
+  describe("emissiveColor uniform passthrough", () => {
+    it("should pass emissiveColor=0 as vec3(0,0,0) — shader handles fallback", () => {
+      const state: PolylineBaseState = {
+        ...DEFAULT_BASE_STATE,
+        color: 0xff9900,
+        emissiveColor: 0,
+        effectIdsMask: 1,
+      };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      const vec = uniforms.uEmissiveColor as {
+        value: { x: number; y: number; z: number };
+      };
+      expect(vec.value.x).toBe(0);
+      expect(vec.value.y).toBe(0);
+      expect(vec.value.z).toBe(0);
+    });
+
+    it("should pass explicit emissiveColor through to uniform", () => {
+      const state: PolylineBaseState = {
+        ...DEFAULT_BASE_STATE,
+        color: 0xff9900,
+        emissiveColor: 0x0000ff,
+        effectIdsMask: 1,
+      };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      const vec = uniforms.uEmissiveColor as {
+        value: { x: number; y: number; z: number };
+      };
+      // 0x0000ff → R=0.0, G=0.0, B=1.0
+      expect(vec.value.x).toBeCloseTo(0.0);
+      expect(vec.value.y).toBeCloseTo(0.0);
+      expect(vec.value.z).toBeCloseTo(1.0);
+    });
+  });
+
+  describe("setPickingCoord", () => {
+    it("should update picking coordinate uniform", () => {
+      const state: PolylineBaseState = { ...DEFAULT_BASE_STATE };
+      const mutates = createBaseMutates(false);
+
+      const pickingCoord = new Vector2(100, 200);
+      mutates.update(state);
+      mutates.setPickingCoord(pickingCoord);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      const coord = uniforms.nvr_uPickingCoord as { value: Vector2 };
+      expect(coord.value.x).toBe(100);
+      expect(coord.value.y).toBe(200);
+    });
+  });
+});

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

@@ -0,0 +1,169 @@
+import {
+  Color as ThreeColor,
+  Matrix4 as ThreeMatrix4,
+  Texture,
+  UniformsLib,
+  Vector2 as ThreeVector2,
+  Vector3 as ThreeVector3,
+} from "three";
+
+import type { UniformValue } from "../../../types";
+
+import type {
+  PolylineBaseMutates,
+  PolylineBaseRefs,
+  PolylineBaseState,
+} from "./types";
+
+/**
+ * Default refs with initial values.
+ * These are cloned in createBaseMutates and synced from state via update().
+ */
+const DEFAULT_BASE_REFS: PolylineBaseRefs = {
+  minMaxHeightAndWidth: { value: [0, 0, 1] },
+  maxWidth: { value: 10000 },
+  uAddHeight: { value: 0 },
+  color: { value: new ThreeColor(0xffffff) },
+  nvr_uPickable: { value: 0 },
+  uEffectIdsMask: { value: 0 },
+  uEmissiveColor: { value: new ThreeVector3(0, 0, 0) },
+  uEmissiveIntensity: { value: 0 },
+  nvr_uPickingCoord: { value: new ThreeVector2(-1, -1) },
+};
+
+/**
+ * Create mutation functions for the polyline base enhancer.
+ * Refs are created internally and captured via closure.
+ *
+ * @param useRTE - Whether RTE is enabled (determines if RTE refs are created)
+ */
+export const createBaseMutates = (useRTE: boolean): PolylineBaseMutates => {
+  // Clone defaults so each enhancer instance gets independent ref objects
+  const refs = structuredClone(DEFAULT_BASE_REFS) as PolylineBaseRefs;
+
+  // Restore Three.js objects (structuredClone creates plain objects for Three.js types)
+  refs.color.value = new ThreeColor(0xffffff);
+  refs.uEmissiveColor.value = new ThreeVector3(0, 0, 0);
+  refs.nvr_uPickingCoord.value = new ThreeVector2(-1, -1);
+
+  // Conditionally create RTE refs (useRTE can't change after mount)
+  if (useRTE) {
+    refs.modelViewMatrixRTE = { value: new ThreeMatrix4() };
+    refs.u_cameraPositionHigh = { value: new ThreeVector3() };
+    refs.u_cameraPositionLow = { value: new ThreeVector3() };
+  }
+
+  return {
+    update: (state) => {
+      // Sync refs from state
+      refs.minMaxHeightAndWidth.value = [
+        state.minMaxHeight[0],
+        state.minMaxHeight[1],
+        state.width,
+      ];
+      refs.maxWidth.value = state.maxWidth;
+      refs.uAddHeight.value = state.addHeight;
+      refs.nvr_uPickable.value = state.pickable ? 1 : 0;
+      refs.uEffectIdsMask.value = state.effectIdsMask;
+      const c = state.emissiveColor;
+      refs.uEmissiveColor.value.set(
+        ((c >> 16) & 0xff) / 255,
+        ((c >> 8) & 0xff) / 255,
+        (c & 0xff) / 255,
+      );
+      refs.uEmissiveIntensity.value = state.emissiveIntensity;
+
+      // Update color uniform using Color.setHex()
+      refs.color.value.setHex(state.color);
+    },
+    updateUniforms: (uniforms, state) => {
+      // Include Three.js lighting uniforms
+      Object.assign(uniforms, UniformsLib["lights"]);
+
+      // Assign core uniform refs to shader.uniforms
+      uniforms.minMaxHeightAndWidth = refs.minMaxHeightAndWidth;
+      uniforms.maxWidth = refs.maxWidth;
+      uniforms.uAddHeight = refs.uAddHeight;
+      uniforms.color = refs.color;
+      uniforms.nvr_uPickable = refs.nvr_uPickable;
+      uniforms.uEffectIdsMask = refs.uEffectIdsMask;
+      uniforms.uEmissiveColor = refs.uEmissiveColor;
+      uniforms.uEmissiveIntensity = refs.uEmissiveIntensity;
+      uniforms.nvr_uPickingCoord = refs.nvr_uPickingCoord;
+
+      // RTE uniforms
+      if (
+        state.useRTE &&
+        refs.modelViewMatrixRTE &&
+        refs.u_cameraPositionHigh &&
+        refs.u_cameraPositionLow
+      ) {
+        uniforms.u_cameraPositionHigh = refs.u_cameraPositionHigh;
+        uniforms.u_cameraPositionLow = refs.u_cameraPositionLow;
+        uniforms.modelViewMatrixRTE = refs.modelViewMatrixRTE;
+      }
+
+      // Batch texture
+      if (refs.batchDataTexture) {
+        uniforms.batchDataTexture = refs.batchDataTexture;
+      }
+
+      // External shared uniforms
+      if (refs.viewportAndPixelRatio) {
+        uniforms.viewportAndPixelRatio = refs.viewportAndPixelRatio;
+      }
+      if (refs.frustumNearFar) {
+        uniforms.frustumNearFar = refs.frustumNearFar;
+      }
+      if (refs.frustumRatio) {
+        uniforms.frustumRatio = refs.frustumRatio;
+      }
+    },
+    setBatchDataTexture: (texture: UniformValue<Texture | null>): void => {
+      refs.batchDataTexture = texture;
+    },
+    setPickingCoord: (coord: ThreeVector2): void => {
+      refs.nvr_uPickingCoord.value.copy(coord);
+    },
+    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 => {
+      if (externalRefs.batchDataTexture) {
+        refs.batchDataTexture = externalRefs.batchDataTexture;
+      }
+      if (externalRefs.viewportAndPixelRatio) {
+        refs.viewportAndPixelRatio = externalRefs.viewportAndPixelRatio;
+      }
+      if (externalRefs.frustumNearFar) {
+        refs.frustumNearFar = externalRefs.frustumNearFar;
+      }
+      if (externalRefs.frustumRatio) {
+        refs.frustumRatio = externalRefs.frustumRatio;
+      }
+    },
+    updateRteUniforms: (
+      modelViewMatrixRTE: ThreeMatrix4,
+      cameraPositionHigh: ThreeVector3,
+      cameraPositionLow: ThreeVector3,
+      state: PolylineBaseState,
+    ): void => {
+      if (!state.useRTE) return;
+      if (refs.modelViewMatrixRTE) {
+        refs.modelViewMatrixRTE.value.copy(modelViewMatrixRTE);
+      }
+      if (refs.u_cameraPositionHigh) {
+        refs.u_cameraPositionHigh.value.copy(cameraPositionHigh);
+      }
+      if (refs.u_cameraPositionLow) {
+        refs.u_cameraPositionLow.value.copy(cameraPositionLow);
+      }
+    },
+  };
+};