@navaramap/three 0.0.5 → 0.0.6

package/src/material/overrideMaterialsForMRT.ts

@@ -1,13 +1,62 @@
 // Ref: https://github.com/takram-design-engineering/three-geospatial/blob/main/packages/effects/src/setupMaterialsForGeometryPass.ts
 
 import { packing } from "@takram/three-geospatial/shaders";
-import { ShaderLib, ShaderMaterial, type ShaderLibShader } from "three";
+import {
+  ShaderLib,
+  ShaderMaterial,
+  type Material,
+  type ShaderLibShader,
+} from "three";
 import { LineMaterial } from "three-stdlib";
 
 import { createReplacer } from "../utils";
 
+import {
+  GBUFFER_EFFECT_WRITE_BUILTIN,
+  GBUFFER_EFFECT_WRITE_ID_ONLY,
+  GBUFFER_EFFECT_WRITE_SHADER_MATERIAL,
+  GBUFFER_EFFECT_WRITE_ZERO,
+  GBUFFER_NORMAL_WRITE_BASIC,
+  GBUFFER_NORMAL_WRITE_PHYSICAL,
+  GBUFFER_PARS_FRAGMENT,
+} from "./gbufferLayout";
+
 const SETUP = Symbol("SETUP");
 
+/** `lit: true` – wins over {@link NVR_UNLIT_SCENE_DEFINE}. */
+export const NVR_LIT_DEFINE = "NVR_LIT";
+/** `lit: false` – only the lighting equation is bypassed; the lit pipeline
+ * still runs, so normals and the shadow G-buffer keep being written. */
+export const NVR_UNLIT_DEFINE = "NVR_UNLIT";
+/** Scene-level default, stamped by `CustomRenderPass` from `view.lit`. */
+export const NVR_UNLIT_SCENE_DEFINE = "NVR_UNLIT_SCENE";
+/**
+ * Stamped from `material.transparent`. Under blending, `normalBuffer.a` is
+ * the attachment's blend factor, so a blended material must write 1.0 there
+ * instead of roughness or it keeps the normal of whatever lies behind.
+ */
+export const NVR_BLENDED_DEFINE = "NVR_BLENDED";
+
+/** Applies a material's three-state `lit` option. */
+export function applyLitOption(
+  material: Material,
+  lit: boolean | undefined,
+): void {
+  // `false` is three's "absent" define value, avoiding a delete.
+  const forceLit = lit === true ? 1 : false;
+  const forceUnlit = lit === false ? 1 : false;
+  material.defines ??= {};
+  if (
+    (material.defines[NVR_LIT_DEFINE] ?? false) === forceLit &&
+    (material.defines[NVR_UNLIT_DEFINE] ?? false) === forceUnlit
+  ) {
+    return;
+  }
+  material.defines[NVR_LIT_DEFINE] = forceLit;
+  material.defines[NVR_UNLIT_DEFINE] = forceUnlit;
+  material.needsUpdate = true;
+}
+
 declare module "three" {
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   interface ShaderLibShader {
@@ -94,27 +143,20 @@ function injectGBuffer(
   const normalBufferWrite =
     type === "physical"
       ? /* glsl */ `
-          normalBuffer = vec4(packNormalToVec2(normal), metalnessFactor, roughnessFactor)
+          ${GBUFFER_NORMAL_WRITE_PHYSICAL}
         `
       : /* glsl */ `
           #ifdef USE_ROUGHNESS
             float roughnessFactor = roughness;
           #else
-            float roughnessFactor = 0.0;
+            // Not just a default: 0.0 here would leak the normal behind a
+            // blended surface (see NVR_BLENDED_DEFINE).
+            float roughnessFactor = 1.0;
           #endif
-          normalBuffer = vec4(packNormalToVec2(normal), reflectivity, roughnessFactor);
+          ${GBUFFER_NORMAL_WRITE_BASIC}
         `;
   shader.fragmentShader = /* glsl */ `
-    // MRT layout:
-    //   location 0: gl_FragColor (color)
-    //   location 1: normalBuffer (normal + material props)
-    //   location 2: effectIdBuffer (effectIds: R=bitmask)       — SelectiveEffect only
-    //   location 3: emissiveBuffer (emissive: RGB=diffuseColor×intensity+emissive additive, A=unused) — SelectiveEffect only
-    #ifndef USE_SHADOWMAP_DEPTH
-      layout(location = 1) out vec4 normalBuffer;
-      layout(location = 2) out vec4 effectIdBuffer;
-      layout(location = 3) out vec4 emissiveBuffer;
-    #endif
+    ${GBUFFER_PARS_FRAGMENT}
 
     #if !defined(USE_ENVMAP)
       uniform float reflectivity;
@@ -131,23 +173,35 @@ function injectGBuffer(
 
     ${packing}
     ${
-      createReplacer(shader.fragmentShader).replace(
-        /}\s*$/, // Assume the last curly brace is of main()
-        /* glsl */ `
+      createReplacer(shader.fragmentShader)
+        .replace(
+          /* glsl */ `#include <opaque_fragment>`,
+          /* glsl */ `
+            #if !defined(${NVR_LIT_DEFINE}) && (defined(${NVR_UNLIT_DEFINE}) || defined(${NVR_UNLIT_SCENE_DEFINE}))
+              // Overwrite rather than skip the lighting: the G-buffer writes
+              // below still need the lit pipeline to have run.
+              outgoingLight = diffuseColor.rgb;
+            #endif
+            #include <opaque_fragment>
+          `,
+        )
+        .replace(
+          /}\s*$/, // Assume the last curly brace is of main()
+          /* glsl */ `
           #ifndef USE_SHADOWMAP_DEPTH
-            ${normalBufferWrite};
+            ${normalBufferWrite}
 
             #ifdef USE_SELECTIVE_EFFECT
-              effectIdBuffer = vec4(uEffectIdsMask, 0.0, 0.0, 1.0);
-              emissiveBuffer = vec4(diffuseColor.rgb * uEmissiveIntensity + emissive, 1.0);
+              ${GBUFFER_EFFECT_WRITE_BUILTIN}
             #else
-              effectIdBuffer = vec4(0.0);
-              emissiveBuffer = vec4(0.0);
+              ${GBUFFER_EFFECT_WRITE_ZERO}
             #endif
+
+            GBUFFER_WRITE_SHADOW
           #endif
         }
       `,
-      ).source
+        ).source
     }
   `;
   shader[SETUP] = true;
@@ -173,9 +227,7 @@ function injectGBufferToSpriteMaterial(shader: ShaderLibShader) {
   `;
 
   shader.fragmentShader = /* glsl */ `
-    layout(location = 1) out vec4 normalBuffer;
-    layout(location = 2) out vec4 effectIdBuffer;
-    layout(location = 3) out vec4 emissiveBuffer;
+    ${GBUFFER_PARS_FRAGMENT}
 
     #ifdef USE_SELECTIVE_EFFECT
       uniform float uEffectIdsMask;
@@ -189,22 +241,21 @@ function injectGBufferToSpriteMaterial(shader: ShaderLibShader) {
       createReplacer(shader.fragmentShader).replace(
         /}\s*$/, // Assume the last curly brace is of main()
         /* glsl */ `
-          // Flat shading
-          vec3 fdx = dFdx( vViewPosition );
-          vec3 fdy = dFdy( vViewPosition );
-          vec3 normal = normalize( cross( fdx, fdy ) );
-          normalBuffer = vec4(
-            packNormalToVec2(normal),
-            0.0,
-            0.0
-          );
-
-          #ifdef USE_SELECTIVE_EFFECT
-            effectIdBuffer = vec4(uEffectIdsMask, 0.0, 0.0, 1.0);
-            emissiveBuffer = vec4(0.0);
-          #else
-            effectIdBuffer = vec4(0.0);
-            emissiveBuffer = vec4(0.0);
+          #ifndef USE_SHADOWMAP_DEPTH
+            // Flat shading
+            vec3 fdx = dFdx( vViewPosition );
+            vec3 fdy = dFdy( vViewPosition );
+            vec3 normal = normalize( cross( fdx, fdy ) );
+            // A=1.0 replaces the normal behind under blending.
+            GBUFFER_WRITE_NORMAL(normal, 0.0, 1.0)
+
+            #ifdef USE_SELECTIVE_EFFECT
+              ${GBUFFER_EFFECT_WRITE_ID_ONLY}
+            #else
+              ${GBUFFER_EFFECT_WRITE_ZERO}
+            #endif
+
+            GBUFFER_WRITE_SHADOW_ZERO
           #endif
         }
       `,
@@ -269,18 +320,12 @@ function injectGBufferToShaderMaterial(
   const logdepthParsFrag = "#include <logdepthbuf_pars_fragment>";
   const logdepthFrag = "#include <logdepthbuf_fragment>";
   const normalBufferWrite = /* glsl */ `
-          vec4(
-            packNormalToVec2(${normalVariableName}),
-            0.0,
-            0.0
-          );
+          GBUFFER_WRITE_NORMAL(${normalVariableName}, 0.0, 1.0)
         `;
   shader.fragmentShader = /* glsl */ `
-    #ifndef USE_SHADOWMAP_DEPTH
-      layout(location = 1) out vec4 normalBuffer;
-      layout(location = 2) out vec4 effectIdBuffer;
-      layout(location = 3) out vec4 emissiveBuffer;
+    ${GBUFFER_PARS_FRAGMENT}
 
+    #ifndef USE_SHADOWMAP_DEPTH
       #ifdef USE_SELECTIVE_EFFECT
         uniform float uEffectIdsMask;
         uniform vec3 uEmissiveColor;
@@ -299,15 +344,15 @@ function injectGBufferToShaderMaterial(
           ${shader.fragmentShader.includes(logdepthFrag) ? "" : logdepthFrag}
 
           #ifndef USE_SHADOWMAP_DEPTH
-            normalBuffer = ${normalBufferWrite};
+            ${normalBufferWrite};
 
             #ifdef USE_SELECTIVE_EFFECT
-              effectIdBuffer = vec4(uEffectIdsMask, 0.0, 0.0, 1.0);
-              emissiveBuffer = vec4((gl_FragColor.rgb + uEmissiveColor) * uEmissiveIntensity, 1.0);
+              ${GBUFFER_EFFECT_WRITE_SHADER_MATERIAL}
             #else
-              effectIdBuffer = vec4(0.0);
-              emissiveBuffer = vec4(0.0);
+              ${GBUFFER_EFFECT_WRITE_ZERO}
             #endif
+
+            GBUFFER_WRITE_SHADOW_ZERO
           #endif
         }
       `,
@@ -350,9 +395,7 @@ function injectGBufferToLineMaterial(lineMaterial: LineMaterial) {
   // LineMaterial already has proper vertex shader setup, so we only modify fragment shader
 
   lineMaterial.fragmentShader = /* glsl */ `
-    layout(location = 1) out vec4 normalBuffer;
-    layout(location = 2) out vec4 effectIdBuffer;
-    layout(location = 3) out vec4 emissiveBuffer;
+    ${GBUFFER_PARS_FRAGMENT}
 
     #ifdef USE_SELECTIVE_EFFECT
       uniform float uEffectIdsMask;
@@ -378,18 +421,17 @@ function injectGBufferToLineMaterial(lineMaterial: LineMaterial) {
         .replace(
           /}\s*$/, // Assume the last curly brace is of main()
           /* glsl */ `
-          normalBuffer = vec4(
-            packNormalToVec2(normal),
-            0.0,
-            0.0
-          );
-
-          #ifdef USE_SELECTIVE_EFFECT
-            effectIdBuffer = vec4(uEffectIdsMask, 0.0, 0.0, 1.0);
-            emissiveBuffer = vec4(0.0);
-          #else
-            effectIdBuffer = vec4(0.0);
-            emissiveBuffer = vec4(0.0);
+          #ifndef USE_SHADOWMAP_DEPTH
+            // A=1.0 replaces the normal behind under blending.
+            GBUFFER_WRITE_NORMAL(normal, 0.0, 1.0)
+
+            #ifdef USE_SELECTIVE_EFFECT
+              ${GBUFFER_EFFECT_WRITE_ID_ONLY}
+            #else
+              ${GBUFFER_EFFECT_WRITE_ZERO}
+            #endif
+
+            GBUFFER_WRITE_SHADOW_ZERO
           #endif
         }
       `,

package/src/mesh/DrapedMesh.test.ts

@@ -0,0 +1,57 @@
+import { MeshLambertMaterial, ShaderLib, type WebGLRenderer } from "three";
+import { describe, expect, it } from "vitest";
+
+import { overrideMaterialsForMRT } from "../material";
+
+import { setupMaterialForDrape } from "./DrapedMesh";
+
+type ShaderStub = Parameters<MeshLambertMaterial["onBeforeCompile"]>[0];
+
+const compile = (material: MeshLambertMaterial): ShaderStub => {
+  const shader = {
+    name: "",
+    uniforms: {},
+    vertexShader: ShaderLib.lambert.vertexShader,
+    fragmentShader: ShaderLib.lambert.fragmentShader,
+    defines: {},
+  } as unknown as ShaderStub;
+  material.onBeforeCompile(shader, null as unknown as WebGLRenderer);
+  return shader;
+};
+
+describe("setupMaterialForDrape", () => {
+  it("substitutes the globe normal ahead of the lighting", () => {
+    overrideMaterialsForMRT();
+    const material = new MeshLambertMaterial();
+    const globeNormal = { value: null };
+
+    setupMaterialForDrape(material, globeNormal);
+    const shader = compile(material);
+
+    expect(shader.fragmentShader).toContain("nvrDrapeUv");
+    expect(shader.uniforms.uGlobeNormal).toBe(globeNormal);
+    expect(shader.fragmentShader.indexOf("nvrDrapeUv")).toBeLessThan(
+      shader.fragmentShader.indexOf("#include <lights_fragment_begin>"),
+    );
+  });
+
+  it("injects even when an earlier handler consumes the anchor", () => {
+    // navara_three_csm swaps `#include <lights_fragment_begin>` for its
+    // cascaded-lights chunk. Delegating to it first left nothing to anchor to,
+    // so the substitution silently never happened.
+    overrideMaterialsForMRT();
+    const material = new MeshLambertMaterial();
+    material.onBeforeCompile = (shader) => {
+      shader.fragmentShader = shader.fragmentShader.replace(
+        "#include <lights_fragment_begin>",
+        "// cascaded lights",
+      );
+    };
+
+    setupMaterialForDrape(material, { value: null });
+    const shader = compile(material);
+
+    expect(shader.fragmentShader).toContain("nvrDrapeUv");
+    expect(shader.fragmentShader).toContain("// cascaded lights");
+  });
+});

package/src/mesh/DrapedMesh.ts

@@ -12,8 +12,69 @@ import {
   type Material,
   type NormalBufferAttributes,
   type Object3DEventMap,
+  type Texture,
 } from "three";
 
+import { createReplacer } from "../utils";
+
+const DRAPE_SETUP = Symbol("DRAPE_SETUP");
+
+/**
+ * Shades a draped material with the terrain's normal instead of its own. The
+ * visible fragments are the back faces of a volume clipped to the ground by
+ * {@link DrapedMesh.process}, so the mesh's own normals point in an arbitrary
+ * direction while the ground's normal is what the lighting should use.
+ *
+ * The decoder (`unpackVec2ToNormal`) comes from the packing helpers that
+ * `overrideMaterialsForMRT` puts in every `ShaderLib` material, so a custom
+ * `ShaderMaterial` in the draped scene needs to bring its own. Idempotent.
+ *
+ * @param globeNormal - Uniform ref for the globe normal copy, kept alive by
+ *   the caller (see `CustomRenderPass`).
+ */
+export function setupMaterialForDrape(
+  material: Material,
+  globeNormal: { value: Texture | null },
+): void {
+  const target = material as Material & { [DRAPE_SETUP]?: boolean };
+  if (target[DRAPE_SETUP]) return;
+  target[DRAPE_SETUP] = true;
+
+  // Draped and undraped materials must not share a compiled program.
+  const previousCacheKey = material.customProgramCacheKey;
+  material.customProgramCacheKey = () =>
+    `${previousCacheKey ? previousCacheKey.call(material) : ""}_NvrDraped`;
+
+  const previousOnBeforeCompile = material.onBeforeCompile;
+  material.onBeforeCompile = (shader, renderer) => {
+    // Runs BEFORE the previous handler on purpose: navara_three_csm swaps
+    // `#include <lights_fragment_begin>` for its cascaded-lights chunk, so
+    // delegating first would leave nothing to anchor to. The include survives
+    // this replacement, so the CSM swap still finds it afterwards.
+    const hook = "#include <lights_fragment_begin>";
+    // Absent from unlit materials, where drape shading is moot.
+    if (shader.fragmentShader.includes(hook)) {
+      shader.uniforms.uGlobeNormal = globeNormal;
+      shader.fragmentShader = createReplacer(
+        `uniform sampler2D uGlobeNormal;\n${shader.fragmentShader}`,
+      ).replace(
+        hook,
+        `
+          {
+            vec2 nvrDrapeUv = gl_FragCoord.xy / vec2(textureSize(uGlobeNormal, 0));
+            normal = normalize(unpackVec2ToNormal(texture2D(uGlobeNormal, nvrDrapeUv).xy));
+          }
+          ${hook}
+        `,
+      ).source;
+    }
+
+    previousOnBeforeCompile?.call(material, shader, renderer);
+  };
+
+  material.needsUpdate = true;
+}
+
 export class DrapedMesh<
   TGeometry extends BufferGeometry = BufferGeometry<NormalBufferAttributes>,
   TMaterial extends Material | Material[] = Material | Material[],
@@ -24,6 +85,20 @@ export class DrapedMesh<
   constructor(geometry?: TGeometry, material?: TMaterial, enable = true) {
     super(geometry, material);
     this.drapedEnable = enable;
+
+    // Shadows are forced off while draped: see process() for why the shading
+    // must not depend on world position. Installed as an own accessor because
+    // Object3D declares `receiveShadow` as a plain property, which TypeScript
+    // refuses to let a subclass override with a getter/setter (TS2611).
+    let receiveShadow = false;
+    Object.defineProperty(this, "receiveShadow", {
+      get: () => (this.drapedEnable ? false : receiveShadow),
+      set: (value: boolean) => {
+        receiveShadow = value;
+      },
+      configurable: true,
+      enumerable: true,
+    });
   }
 
   enabled() {
@@ -34,6 +109,13 @@ export class DrapedMesh<
    * Run the stencil-test draping passes for this mesh.
    * The caller supplies a `render` callback that performs the actual draw call
    * (e.g. `renderer.render(scene, camera)`).
+   *
+   * The final pass draws every back face with the depth test off, so a pixel
+   * can be covered several times where the volume folds over a peak. The
+   * shading must therefore not depend on world position, or the far face
+   * shows through the near one — hence the screen-space normal from
+   * {@link setupMaterialForDrape} and the forced-off `receiveShadow`. The
+   * terrain underneath keeps its own shadows; only the drape stays lit.
    */
   process(render: () => void): void {
     if (!this.enabled()) return;

package/src/mesh/model.ts

@@ -24,6 +24,7 @@ import {
 import invariant from "tiny-invariant";
 
 import type { EventContext } from "../event/context";
+import { applyLitOption } from "../material";
 import {
   createModelMaterialEnhancer,
   createPntsEnhancer,
@@ -306,6 +307,7 @@ export class ModelMesh
 
     mesh.castShadow = !!meshMaterial.castShadow;
     mesh.receiveShadow = !!meshMaterial.receiveShadow;
+    applyLitOption(mesh.material, meshMaterial.lit);
 
     mesh.material.depthTest = true;
     mesh.material.depthWrite = true;
@@ -369,6 +371,7 @@ export class ModelMesh
       enhancer.update(updateProps);
       mesh.castShadow = !!material.castShadow;
       mesh.receiveShadow = !!material.receiveShadow;
+      applyLitOption(mesh.material, material.lit);
     }
 
     const pntsProps: PntsProps = {

package/src/mesh/polygon.ts

@@ -3,7 +3,6 @@ import {
   PolygonMesh as NavaraPolygonMesh,
   PolygonMaterial,
 } from "@navaramap/engine";
-import type { Texture } from "three";
 import {
   BufferAttribute,
   BufferGeometry,
@@ -19,6 +18,7 @@ import {
 
 import { PolygonOutlineMesh } from "..";
 import type { EventContext } from "../event/context";
+import { applyLitOption } from "../material";
 import type { PolygonMaterialProps } from "../material/enhancer/polygon";
 import { createPolygonMaterialEnhancer } from "../material/enhancer/polygon/polygonMaterialEnhancer";
 
@@ -286,6 +286,7 @@ export class PolygonMesh extends BatchedFeatureMesh<
 
     this.castShadow = !!meshMaterial.castShadow;
     this.receiveShadow = !!meshMaterial.receiveShadow;
+    applyLitOption(this.material, meshMaterial.lit);
 
     // This mesh is texturized if it has a tile handle (terrain attachment).
     // `!= null`, not truthiness: the root vector tile's handle is 0.
@@ -322,7 +323,6 @@ export class PolygonMesh extends BatchedFeatureMesh<
         roughness: meshMaterial.roughness,
         emissiveColor: meshMaterial.emissiveColor,
         emissiveIntensity: meshMaterial.emissiveIntensity,
-        globeNormalTexture: uniforms.tGlobeNormal as { value: Texture | null },
         useRTE,
       },
       water: {
@@ -411,6 +411,7 @@ export class PolygonMesh extends BatchedFeatureMesh<
     }
     this.castShadow = !!material.castShadow;
     this.receiveShadow = !!material.receiveShadow;
+    applyLitOption(this.material, material.lit);
 
     const { base } = enhancer.states();
 

package/src/mesh/polyline.ts

@@ -12,6 +12,7 @@ import {
 } from "three";
 
 import type { EventContext } from "../event/context";
+import { applyLitOption } from "../material";
 import { createPolylineMaterialEnhancer } from "../material/enhancer";
 
 import {
@@ -263,6 +264,7 @@ export class PolylineMesh extends BatchedFeatureMesh<
 
     this.castShadow = !!meshMaterial.castShadow;
     this.receiveShadow = !!meshMaterial.receiveShadow;
+    applyLitOption(this.material, meshMaterial.lit);
 
     const isTexturized = mesh.should_be_texturized;
 
@@ -422,6 +424,7 @@ export class PolylineMesh extends BatchedFeatureMesh<
     this.visible = enhancer.states().isTexturized ? shown : shown && active;
     this.castShadow = !!material.castShadow;
     this.receiveShadow = !!material.receiveShadow;
+    applyLitOption(this.material, material.lit);
 
     const base = enhancer.states();
 

package/src/mesh/sdfText/layout.ts

@@ -1,6 +1,7 @@
 import {
   COLOR_GLYPH_PX_SIZE,
   GlyphCharClass,
+  SDF_PX_SIZE,
   type GlyphMetrics,
   type ShapedGlyph,
   type ShapeTextResult,
@@ -14,9 +15,6 @@ import {
  * — the part with all the edge cases — unit-testable without a GL context.
  */
 
-/** Must match Rust `SDF_PX_SIZE` in `crates/navara_wasm_font_worker/src/atlas.rs`. */
-export const SDF_PX_SIZE = 64.0;
-
 /** Horizontal alignment of lines within a multi-line block, as the fraction
  *  of leftover width placed before each line. */
 export const ALIGN_FACTORS: Record<string, number> = {

package/src/mesh/tile/index.ts

@@ -42,6 +42,8 @@ import {
 import { setTransform } from "../../event";
 import type { EventContext, TileHandler } from "../../event/context";
 import {
+  GBUFFER_EFFECT_WRITE_BUILTIN,
+  GBUFFER_NORMAL_WRITE_BASIC,
   generateTileCommonInjection,
   generateTileMapFragment,
   generateTileNormalFragmentMaps,
@@ -49,6 +51,7 @@ import {
   TILE_NORMAL_BUFFER_REPLACEMENT,
   TILE_PICK_FRAGMENT_OVERRIDE,
   TILE_VERTEX_INJECTIONS,
+  applyLitOption,
 } from "../../material";
 import { deriveCompositeFeatures } from "../../material/enhancer/tileComposite";
 import type { CustomObject3DEventMap } from "../../object3DEvent";
@@ -564,6 +567,7 @@ export class TileMesh
       this.castShadow = !!mat.castShadow;
       this.receiveShadow = !!mat.receiveShadow;
     }
+    applyLitOption(this.material, mat.lit);
 
     this.visible = false;
     this.renderOrder = mesh.render_order;
@@ -813,7 +817,7 @@ ${generateTileCommonInjection(maxTextures)}
         )
         .replace(
           "#include <map_fragment>",
-          generateTileMapFragment(maxTextures),
+          generateTileMapFragment(maxTextures, features),
         )
         .replaceWithCondition(
           "#include <normal_fragment_maps>",
@@ -845,13 +849,12 @@ ${generateTileCommonInjection(maxTextures)}
           ${TILE_PICK_FRAGMENT_OVERRIDE}`,
         )
         .replaceWithCondition(
-          "normalBuffer = vec4(packNormalToVec2(normal), reflectivity, roughnessFactor);",
+          GBUFFER_NORMAL_WRITE_BASIC,
           TILE_NORMAL_BUFFER_REPLACEMENT,
           useNormal,
         )
         .replace(
-          `effectIdBuffer = vec4(uEffectIdsMask, 0.0, 0.0, 1.0);
-              emissiveBuffer = vec4(diffuseColor.rgb * uEmissiveIntensity + emissive, 1.0);`,
+          GBUFFER_EFFECT_WRITE_BUILTIN,
           TILE_EMISSIVE_EFFECT_BUFFER_REPLACEMENT,
         ).source;
     };
@@ -923,6 +926,7 @@ ${generateTileCommonInjection(maxTextures)}
     if (this.receiveShadow !== changedMaterial.receiveShadow) {
       this.receiveShadow = !!changedMaterial.receiveShadow;
     }
+    applyLitOption(this.material, changedMaterial.lit);
     if (this.material.color.getHex() !== globe.color) {
       this.material.color.setHex(globe.color);
     }