@navaramap/three 0.0.0

package/src/material/enhancer/polygon/polygonBaseEnhancer/index.ts

@@ -0,0 +1,130 @@
+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 {
+  PolygonBaseMutates,
+  PolygonBaseProps,
+  PolygonBaseState,
+} from "./types";
+
+/**
+ * Factory function to create a polygon base enhancer.
+ *
+ * This enhancer handles:
+ * - Basic material properties (color, opacity, wireframe)
+ * - Height and extrusion
+ * - Clamp to ground
+ * - Picking
+ * - Reflectivity
+ * - RTE support
+ *
+ * Supports Lambert materials.
+ *
+ * @param material - The Three.js material to enhance
+ */
+export function createPolygonBaseEnhancer(
+  material: SupportedMaterial,
+): MaterialEnhancer<
+  SupportedMaterial,
+  PolygonBaseProps,
+  PolygonBaseState,
+  PolygonBaseMutates,
+  typeof AVAILABLE_SHADERS
+> {
+  // Internal state - immutable, always replaced as a whole
+  let state: PolygonBaseState | null = null;
+  // Internal mutates object (refs are hidden inside)
+  let mutates: PolygonBaseMutates | 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: PolygonBaseProps): 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);
+      // Handle external refs that are passed through props
+      if (props.batchDataTexture) {
+        mutates.setBatchDataTexture(props.batchDataTexture);
+      }
+      if (props.globeNormalTexture) {
+        mutates.setGlobeNormalTexture(props.globeNormalTexture);
+      }
+      updateMaterialProps(material, mergedProps);
+    },
+
+    update: (props: PolygonBaseProps): void => {
+      invariant(state && mutates, "mount() must be called before update");
+      state = updateState(props, state);
+      mutates.update(state);
+      // Handle external refs that are passed through props
+      if (props.batchDataTexture) {
+        mutates.setBatchDataTexture(props.batchDataTexture);
+      }
+      if (props.globeNormalTexture) {
+        mutates.setGlobeNormalTexture(props.globeNormalTexture);
+      }
+      updateMaterialProps(material, props);
+    },
+
+    states: (): PolygonBaseState => {
+      invariant(state, "mount() must be called before states");
+      return state;
+    },
+
+    mutates: (): PolygonBaseMutates => {
+      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 state that affects shader defines
+      return JSON.stringify({
+        useBatchTexture: state.useBatchTexture,
+        useBatchColorShow: state.useBatchColorShow,
+        useBatchHeight: state.useBatchHeight,
+        useBatchExtrudedHeight: state.useBatchExtrudedHeight,
+        isTexturized: state.isTexturized,
+        clampToGround: state.clampToGround,
+        useRTE: state.useRTE,
+      });
+    },
+  };
+}
+
+// Re-export public types
+export type { PolygonBaseMutates, PolygonBaseProps, PolygonBaseState };
+
+// Re-export SupportedMaterial for use by water enhancer
+export type { SupportedMaterial } from "./material";
+
+// Re-export marker types for composing enhancers
+export {
+  POLYGON_BASE_SHADER_MARKERS,
+  createPolygonBaseShaderReplacer,
+} from "./markers";

package/src/material/enhancer/polygon/polygonBaseEnhancer/markers.ts

@@ -0,0 +1,23 @@
+import { type ShaderMarkers, createShaderReplacer } from "../../ShaderReplacer";
+
+export const POLYGON_BASE_SHADER_MARKERS = {
+  vertex: {},
+  fragment: {
+    /** Start of polygon uniform declarations. */
+    UNIFORM_START: "// NVR_POLYGON_BASE_UNIFORM_START",
+    /** End of polygon uniform declarations. */
+    UNIFORM_END: "// NVR_POLYGON_BASE_UNIFORM_END",
+    /** Start of normal computation block. */
+    NORMAL_START: "// NVR_POLYGON_BASE_NORMAL_START",
+    /** End of normal computation block. */
+    NORMAL_END: "// NVR_POLYGON_BASE_NORMAL_END",
+    /** Start of the final normal assignment block (used for MRT output). */
+    FINAL_NORMAL_START: "// NVR_POLYGON_BASE_FINAL_NORMAL_START",
+    /** End of the final normal assignment block (used for MRT output). */
+    FINAL_NORMAL_END: "// NVR_POLYGON_BASE_FINAL_NORMAL_END",
+  },
+} as const satisfies ShaderMarkers;
+
+export function createPolygonBaseShaderReplacer(source: string) {
+  return createShaderReplacer<typeof POLYGON_BASE_SHADER_MARKERS>(source);
+}

package/src/material/enhancer/polygon/polygonBaseEnhancer/material.test.ts

@@ -0,0 +1,19 @@
+import { MeshLambertMaterial } from "three";
+import { describe, expect, it } from "vitest";
+
+import { updateMaterialProps } from "./material";
+
+describe("polygonBaseEnhancer/material", () => {
+  describe("updateMaterialProps", () => {
+    it("should not update properties when props are undefined", () => {
+      const material = new MeshLambertMaterial();
+      material.color.set(0xff0000);
+      material.opacity = 0.5;
+
+      // Empty props should not change anything
+      updateMaterialProps(material, {});
+      expect(material.color.getHex()).toBe(0xff0000);
+      expect(material.opacity).toBe(0.5);
+    });
+  });
+});

package/src/material/enhancer/polygon/polygonBaseEnhancer/material.ts

@@ -0,0 +1,38 @@
+import type { MaterialsFromShaders, ShaderName } from "../../MaterialEnhancer";
+
+import type { PolygonBaseProps } from "./types";
+
+// Shaders this enhancer supports
+export const AVAILABLE_SHADERS = ["lambert"] satisfies ShaderName[];
+export type SupportedMaterial = MaterialsFromShaders<typeof AVAILABLE_SHADERS>;
+
+/**
+ * Update Three.js material properties from props and state.
+ * Side effect function - mutates material directly.
+ */
+export const updateMaterialProps = (
+  material: SupportedMaterial,
+  props: PolygonBaseProps,
+): void => {
+  if (props.color !== undefined) {
+    material.color.set(props.color);
+  }
+  if (props.opacity !== undefined) {
+    material.opacity = props.opacity;
+  }
+  if (props.transparent !== undefined) {
+    material.transparent = props.transparent;
+  }
+  if (props.wireframe !== undefined) {
+    material.wireframe = props.wireframe;
+  }
+  if (props.emissiveColor !== undefined) {
+    material.emissive.set(props.emissiveColor);
+  }
+  if (props.emissiveIntensity !== undefined) {
+    material.emissiveIntensity = props.emissiveIntensity;
+  }
+  if (props.reflectivity !== undefined) {
+    material.reflectivity = props.reflectivity;
+  }
+};

package/src/material/enhancer/polygon/polygonBaseEnhancer/mutates.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+
+import type { ShaderUniforms } from "../../MaterialEnhancer";
+
+import { createBaseMutates } from "./mutates";
+import { DEFAULT_BASE_STATE } from "./state";
+import type { PolygonBaseState } from "./types";
+
+describe("polygonBaseEnhancer/mutates", () => {
+  describe("RTE uniforms", () => {
+    it("should assign RTE refs to shader.uniforms when useRTE=true", () => {
+      const state: PolygonBaseState = { ...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: PolygonBaseState = { ...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: PolygonBaseState = {
+        ...DEFAULT_BASE_STATE,
+        pickable: true,
+        clampToGround: true,
+        addHeight: 10,
+        addExtrudedHeight: 20,
+        minMaxHeight: [5, 50],
+      };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      expect(uniforms.nvr_uPickable?.value).toBe(1);
+      expect(uniforms.uClampToGround?.value).toBe(true);
+      expect(uniforms.uAddHeight?.value).toBe(10);
+      expect(uniforms.uAddExtrudedHeight?.value).toBe(20);
+      expect(uniforms.uMinMaxHeight?.value).toEqual([5, 50]);
+    });
+
+    it("should sync uEmissiveIntensity ref from state", () => {
+      const state: PolygonBaseState = {
+        ...DEFAULT_BASE_STATE,
+        emissiveIntensity: 0.3,
+      };
+      const mutates = createBaseMutates(false);
+      mutates.update(state);
+
+      const uniforms: ShaderUniforms = {};
+      mutates.updateUniforms(uniforms, state);
+
+      expect(uniforms.uEmissiveIntensity?.value).toBe(0.3);
+    });
+  });
+});

package/src/material/enhancer/polygon/polygonBaseEnhancer/mutates.ts

@@ -0,0 +1,122 @@
+import type { Matrix4, Texture, Vector3 } from "three";
+import { Matrix4 as ThreeMatrix4, Vector3 as ThreeVector3 } from "three";
+
+import type { UniformValue } from "../../../types";
+
+import type {
+  PolygonBaseMutates,
+  PolygonBaseRefs,
+  PolygonBaseState,
+} from "./types";
+
+/**
+ * Default refs with initial values.
+ * These are cloned in createBaseMutates and synced from state via update().
+ */
+const DEFAULT_BASE_REFS: PolygonBaseRefs = {
+  uMinMaxHeight: { value: undefined },
+  uAddExtrudedHeight: { value: 0 },
+  uAddHeight: { value: 0 },
+  uClampToGround: { value: false },
+  nvr_uPickable: { value: 0 },
+  uEffectIdsMask: { value: 0 },
+  uEmissiveIntensity: { value: 0 },
+  uIsTexturized: { value: false },
+  reflectivity: { value: 0 },
+  roughness: { value: 0 },
+};
+
+/**
+ * Create mutation functions for the polygon 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): PolygonBaseMutates => {
+  // Clone defaults so each enhancer instance gets independent ref objects
+  const refs = structuredClone(DEFAULT_BASE_REFS) as PolygonBaseRefs;
+
+  // 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.uMinMaxHeight.value = state.minMaxHeight;
+      refs.uAddExtrudedHeight.value = state.addExtrudedHeight;
+      refs.uAddHeight.value = state.addHeight;
+      refs.uClampToGround.value = state.clampToGround;
+      refs.nvr_uPickable.value = state.pickable ? 1 : 0;
+      refs.uEffectIdsMask.value = state.effectIdsMask;
+      refs.uEmissiveIntensity.value = state.emissiveIntensity;
+      refs.uIsTexturized.value = state.isTexturized;
+      refs.reflectivity.value = state.reflectivity;
+      refs.roughness.value = state.roughness;
+    },
+    updateUniforms: (uniforms, state) => {
+      // Assign core uniform refs to shader.uniforms
+      if (refs.uGlobeNormal) {
+        uniforms.uGlobeNormal = refs.uGlobeNormal;
+      }
+      uniforms.nvr_uPickable = refs.nvr_uPickable;
+      uniforms.uEffectIdsMask = refs.uEffectIdsMask;
+      uniforms.uEmissiveIntensity = refs.uEmissiveIntensity;
+      uniforms.reflectivity = refs.reflectivity;
+      uniforms.roughness = refs.roughness;
+
+      // 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;
+      }
+
+      // Height uniforms
+      if (refs.uMinMaxHeight.value) {
+        uniforms.uMinMaxHeight = refs.uMinMaxHeight;
+      }
+      uniforms.uAddExtrudedHeight = refs.uAddExtrudedHeight;
+      uniforms.uAddHeight = refs.uAddHeight;
+      uniforms.uClampToGround = refs.uClampToGround;
+
+      // Batch texture
+      if (refs.batchDataTexture) {
+        uniforms.batchDataTexture = refs.batchDataTexture;
+      }
+
+      uniforms.uIsTexturized = refs.uIsTexturized;
+    },
+    setBatchDataTexture: (texture: UniformValue<Texture | null>): void => {
+      refs.batchDataTexture = texture;
+    },
+    setGlobeNormalTexture: (texture: UniformValue<Texture | null>): void => {
+      refs.uGlobeNormal = texture;
+    },
+    updateRteUniforms: (
+      modelViewMatrixRTE: Matrix4,
+      cameraPositionHigh: Vector3,
+      cameraPositionLow: Vector3,
+      state: PolygonBaseState,
+    ): 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);
+      }
+    },
+  };
+};

package/src/material/enhancer/polygon/polygonBaseEnhancer/shader.test.ts

@@ -0,0 +1,25 @@
+import { testShaderCompatibility } from "../../test-utils/shaderCompatibility";
+
+import { POLYGON_BASE_SHADER_MARKERS } from "./markers";
+
+import { createPolygonBaseEnhancer, type SupportedMaterial } from ".";
+
+testShaderCompatibility(
+  "polygonBaseEnhancer",
+  (material) => createPolygonBaseEnhancer(material as SupportedMaterial),
+  [
+    {
+      name: "With RTE",
+      props: {
+        useRTE: true,
+      },
+    },
+    {
+      name: "Without RTE",
+      props: {
+        useRTE: false,
+      },
+    },
+  ],
+  POLYGON_BASE_SHADER_MARKERS,
+);

package/src/material/enhancer/polygon/polygonBaseEnhancer/shader.ts

@@ -0,0 +1,249 @@
+import BatchTextureParsVertex from "@shaders/glsl/chunks/batch_texture_pars_vertex.glsl";
+import BatchTextureVertex from "@shaders/glsl/chunks/batch_texture_vertex.glsl";
+import BranchFreeTernary from "@shaders/glsl/chunks/branchFreeTernary.glsl";
+import ExtrudedHeightParsVertex from "@shaders/glsl/chunks/extruded_height_pars_vertex.glsl";
+import ExtrudedHeightVertex from "@shaders/glsl/chunks/extruded_height_vertex.glsl";
+import HeightParsVertex from "@shaders/glsl/chunks/height_pars_vertex.glsl";
+import HeightVertex from "@shaders/glsl/chunks/height_vertex.glsl";
+import Pick from "@shaders/glsl/chunks/pick.glsl";
+import ProjectVertexRte from "@shaders/glsl/chunks/project_vertex_rte.glsl";
+import RteParsVertex from "@shaders/glsl/chunks/rte_pars_vertex.glsl";
+import RteVertex from "@shaders/glsl/chunks/rte_vertex.glsl";
+import ShadowMapDepthFragment from "@shaders/glsl/chunks/shadowmap_depth_fragment.glsl";
+import ShadowMapDepthParsFragment from "@shaders/glsl/chunks/shadowmap_depth_pars_fragment.glsl";
+import ShadowMapDepthParsVertex from "@shaders/glsl/chunks/shadowmap_depth_pars_vertex.glsl";
+import ShadowMapDepthVertex from "@shaders/glsl/chunks/shadowmap_depth_vertex.glsl";
+import ShowFragment from "@shaders/glsl/chunks/show_fragment.glsl";
+import ShowParsFragment from "@shaders/glsl/chunks/show_pars_fragment.glsl";
+import ShowParsVertex from "@shaders/glsl/chunks/show_pars_vertex.glsl";
+import SpecularParsFragment from "@shaders/glsl/chunks/spucular_pars_fragment.glsl";
+import { ShaderChunk } from "three";
+import type { WebGLProgramParametersWithUniforms } from "three";
+
+import { createReplacer } from "../../../../utils";
+
+import { POLYGON_BASE_SHADER_MARKERS } from "./markers";
+import type { SupportedMaterial } from "./material";
+import type { PolygonBaseMutates, PolygonBaseState } from "./types";
+
+/**
+ * Transform shader with core polygon modifications.
+ * Uniform assignment is handled by mutates.updateUniforms().
+ */
+export const transformShader = (
+  shader: WebGLProgramParametersWithUniforms,
+  state: PolygonBaseState,
+  mutates: PolygonBaseMutates,
+  material: SupportedMaterial,
+): void => {
+  const { useRTE } = state;
+
+  // Set core shader defines
+  shader.defines ??= {};
+  shader.defines.USE_ROUGHNESS = 1;
+  shader.defines.USE_SELECTIVE_EFFECT = 1;
+
+  // TODO: Handle batch texture defines in safe way.
+  // Merge defines from material.userData.defines (includes batch texture row defines)
+  // This is important for batch texture functionality which sets defines like:
+  // - BATCHED_TEXTURE_ROW_COLOR_SHOW, BATCHED_TEXTURE_ROW_HEIGHT, etc.
+  // - USE_BATCH_TEXTURE, USE_BATCH_COLOR_SHOW, USE_BATCH_HEIGHT, etc.
+  if (material.userData.defines) {
+    Object.assign(shader.defines, material.userData.defines);
+  }
+
+  // Assign uniform refs to shader.uniforms via mutates
+  mutates.updateUniforms(shader.uniforms, state);
+
+  // Transform vertex shader
+  shader.vertexShader = createReplacer(shader.vertexShader)
+    .replace(
+      "#include <common>",
+      `
+#include <common>
+#include <packing>
+
+in float attrBatchId;
+in vec4 scaleNormalAndCap;
+
+uniform vec2 uMinMaxHeight;
+out float nvr_vBatchId;
+
+${useRTE ? RteParsVertex : ""}
+${ShowParsVertex}
+${ExtrudedHeightParsVertex}
+${HeightParsVertex}
+${BatchTextureParsVertex}
+
+${BranchFreeTernary}
+
+${ShadowMapDepthParsVertex}
+
+varying vec3 vPosition;
+`,
+    )
+    .replace(
+      "#include <begin_vertex>",
+      `
+${useRTE ? RteVertex : "#include <begin_vertex>"}
+
+${ExtrudedHeightVertex}
+${HeightVertex}
+${BatchTextureVertex}
+
+transformed.xyz += scaleNormalAndCap.xyz * nvr_branchFreeTernary(
+  scaleNormalAndCap.w == 0.0,
+  uMinMaxHeight.x + addHeight,
+  uMinMaxHeight.y + addExtrudedHeight
+);
+
+// Use the original GlobalBatchId for picking, not the batch_index
+nvr_vBatchId = attrBatchId;
+`,
+    )
+    .replace(
+      "#include <clipping_planes_vertex>",
+      `
+#include <clipping_planes_vertex>
+${ShadowMapDepthVertex}
+`,
+    )
+    .replaceWithCondition("#include <project_vertex>", ProjectVertexRte, useRTE)
+    .replaceWithCondition(
+      "#include <envmap_vertex>",
+      `
+#include <envmap_vertex>
+
+vPosition = absTransformed.xyz;
+vViewPosition = -absMvPosition.xyz;
+`,
+      useRTE,
+    )
+    .replaceWithCondition(
+      "#include <worldpos_vertex>",
+      createReplacer(ShaderChunk.worldpos_vertex).replace(
+        "vec4 worldPosition = vec4( transformed, 1.0 );",
+        "vec4 worldPosition = vec4( absTransformed, 1.0 );",
+      ).source,
+      useRTE,
+    )
+    .replaceWithCondition(
+      "#include <envmap_vertex>",
+      `
+#include <envmap_vertex>
+
+vPosition = (modelMatrix * vec4(transformed, 1.0)).xyz;
+`,
+      !useRTE,
+    ).source;
+
+  // Transform fragment shader
+  shader.fragmentShader = createReplacer(shader.fragmentShader)
+    .replace(
+      "#include <common>",
+      `
+#include <common>
+#include <packing>
+`,
+    )
+    .replace(
+      "uniform vec3 diffuse;",
+      `
+${POLYGON_BASE_SHADER_MARKERS.fragment.UNIFORM_START}
+uniform vec3 diffuse;
+uniform bool uClampToGround;
+uniform sampler2D uGlobeNormal;
+uniform float nvr_uPickable;
+// uEffectIdsMask is declared by overrideMaterialsForMRT (#ifdef USE_SELECTIVE_EFFECT block)
+uniform bool uIsTexturized;
+${POLYGON_BASE_SHADER_MARKERS.fragment.UNIFORM_END}
+
+in float nvr_vBatchId;
+
+${ShowParsFragment}
+
+${Pick}
+
+${ShadowMapDepthParsFragment}
+`,
+    )
+    .replace(
+      "#include <lights_lambert_pars_fragment>",
+      `
+#include <lights_lambert_pars_fragment>
+
+${SpecularParsFragment}
+`,
+    )
+    .replace(
+      "void main() {",
+      `
+void main() {
+  ${ShowFragment}
+  ${ShadowMapDepthFragment}
+`,
+    )
+    .replace(
+      "#include <color_fragment>",
+      `
+#include <color_fragment>
+
+#ifdef USE_BATCH_COLOR_SHOW
+  diffuseColor.a *= nvr_vOpacity;
+#endif
+`,
+    )
+    .replace(
+      "#include <normal_fragment_maps>",
+      `
+${POLYGON_BASE_SHADER_MARKERS.fragment.NORMAL_START}
+
+vec3 origNormal = vec3(normal);
+vec3 specular;
+
+if(uClampToGround) {
+  vec2 uv = gl_FragCoord.xy / vec2(textureSize(uGlobeNormal, 0));
+  vec3 mapN = unpackVec2ToNormal(texture2D( uGlobeNormal, uv ).xy);
+  normal = normalize( mapN );
+} else {
+ #include <normal_fragment_maps>
+}
+
+${POLYGON_BASE_SHADER_MARKERS.fragment.NORMAL_END}
+`,
+    )
+    .replace(
+      "vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;",
+      `
+vec3 outgoingLight;
+if(uClampToGround) {
+  // Without lighting
+  outgoingLight = diffuseColor.xyz;
+} else {
+  outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+  if(!uIsTexturized) {
+    outgoingLight += specular;
+  }
+}
+`,
+    )
+    .replace(
+      "#include <dithering_fragment>",
+      `
+#include <dithering_fragment>
+if (nvr_uPickable > 0.0 && diffuseColor.a > 0.0) {
+  vec3 pickColor = nvr_batchIdToColor(nvr_vBatchId);
+  gl_FragColor = vec4(pickColor.xyz, 1.0);
+}
+`,
+    )
+    .replace(
+      "normalBuffer = vec4(packNormalToVec2(normal), reflectivity, roughnessFactor);",
+      `
+${POLYGON_BASE_SHADER_MARKERS.fragment.FINAL_NORMAL_START}
+vec3 finalNormal = origNormal;
+${POLYGON_BASE_SHADER_MARKERS.fragment.FINAL_NORMAL_END}
+normalBuffer = vec4(packNormalToVec2(finalNormal), reflectivity, roughnessFactor);
+`,
+    ).source;
+};