@navaramap/three 0.0.6 → 0.0.7

package/src/mesh/nvLineGeometry.ts

@@ -0,0 +1,148 @@
+import {
+  Box3,
+  InstancedInterleavedBuffer,
+  InterleavedBufferAttribute,
+  Sphere,
+  Vector3,
+} from "three";
+import { LineGeometry, LineSegmentsGeometry } from "three-stdlib";
+
+export class NvLineGeometry extends LineGeometry {
+  setPositions(
+    array: Float32Array,
+    skipIdx: Uint32Array = new Uint32Array(),
+  ): this {
+    const positions: number[] = [];
+    const skipSet = new Set(skipIdx);
+
+    for (let i = 0; i < array.length - 3; i += 3) {
+      const currentIndex = i / 3;
+      if (skipSet.has(currentIndex)) {
+        continue;
+      }
+
+      // segment start
+      positions.push(array[i], array[i + 1], array[i + 2]);
+      // segment end
+      positions.push(array[i + 3], array[i + 4], array[i + 5]);
+    }
+
+    const points = new Float32Array(positions);
+
+    // This function is used to override LineGeometry's setPositions,
+    // so we don't call super.setPositions.
+    LineSegmentsGeometry.prototype.setPositions.call(this, points);
+    return this;
+  }
+
+  /**
+   * Attach RTE high/low positions as per-segment instanced attributes.
+   *
+   * Mirrors the segment expansion (and skip handling) of `setPositions` and
+   * the interleaved layout of `LineSegmentsGeometry.setPositions`
+   * (stride 6: start xyz at offset 0, end xyz at offset 3). The RTE shader
+   * reads only these attributes, so callers skip `setPositions` entirely —
+   * no unused `instanceStart`/`instanceEnd` buffer is uploaded to the GPU.
+   * Because `LineSegmentsGeometry.computeBoundingBox/Sphere` read
+   * `instanceStart`/`instanceEnd`, the bounds are computed here instead,
+   * from the reconstructed absolute (high + low) positions.
+   */
+  setPositionsHighLow(
+    high: Float32Array,
+    low: Float32Array,
+    skipIdx: Uint32Array = new Uint32Array(),
+  ): this {
+    const highSegments: number[] = [];
+    const lowSegments: number[] = [];
+    const skipSet = new Set(skipIdx);
+
+    const box = new Box3();
+    const point = new Vector3();
+
+    for (let i = 0; i < high.length - 3; i += 3) {
+      const currentIndex = i / 3;
+      if (skipSet.has(currentIndex)) {
+        continue;
+      }
+
+      // segment start + end
+      highSegments.push(
+        high[i],
+        high[i + 1],
+        high[i + 2],
+        high[i + 3],
+        high[i + 4],
+        high[i + 5],
+      );
+      lowSegments.push(
+        low[i],
+        low[i + 1],
+        low[i + 2],
+        low[i + 3],
+        low[i + 4],
+        low[i + 5],
+      );
+
+      box.expandByPoint(
+        point.set(
+          high[i] + low[i],
+          high[i + 1] + low[i + 1],
+          high[i + 2] + low[i + 2],
+        ),
+      );
+      box.expandByPoint(
+        point.set(
+          high[i + 3] + low[i + 3],
+          high[i + 4] + low[i + 4],
+          high[i + 5] + low[i + 5],
+        ),
+      );
+    }
+
+    const highBuffer = new InstancedInterleavedBuffer(
+      new Float32Array(highSegments),
+      6,
+      1,
+    );
+    const lowBuffer = new InstancedInterleavedBuffer(
+      new Float32Array(lowSegments),
+      6,
+      1,
+    );
+    this.setAttribute(
+      "instanceStartHigh",
+      new InterleavedBufferAttribute(highBuffer, 3, 0),
+    );
+    this.setAttribute(
+      "instanceEndHigh",
+      new InterleavedBufferAttribute(highBuffer, 3, 3),
+    );
+    this.setAttribute(
+      "instanceStartLow",
+      new InterleavedBufferAttribute(lowBuffer, 3, 0),
+    );
+    this.setAttribute(
+      "instanceEndLow",
+      new InterleavedBufferAttribute(lowBuffer, 3, 3),
+    );
+
+    // Exact-radius sphere (same behavior as LineSegmentsGeometry's own
+    // computeBoundingSphere, which cannot run without instanceStart/End).
+    this.boundingBox = box;
+    const sphere = this.boundingSphere ?? new Sphere();
+    const center = box.getCenter(sphere.center);
+    let maxRadiusSq = 0;
+    for (let i = 0; i < highSegments.length; i += 3) {
+      point.set(
+        highSegments[i] + lowSegments[i],
+        highSegments[i + 1] + lowSegments[i + 1],
+        highSegments[i + 2] + lowSegments[i + 2],
+      );
+      maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(point));
+    }
+    sphere.radius = Math.sqrt(maxRadiusSq);
+    this.boundingSphere = sphere;
+
+    return this;
+  }
+}

package/src/mesh/polygonOutline.ts

@@ -2,19 +2,25 @@ import {
   PolygonMesh as NavaraPolygonMesh,
   PolygonMaterial,
 } from "@navaramap/engine";
+import { RTE_ONE_UNIFORM } from "@navaramap/three-api";
 import BatchTextureParsVertex from "@shaders/glsl/chunks/batch_texture_pars_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 { Color, type DataTexture, InstancedBufferAttribute } from "three";
 import {
-  Line2,
-  LineGeometry,
-  LineMaterial,
-  LineSegmentsGeometry,
-} from "three-stdlib";
+  Color,
+  type DataTexture,
+  InstancedBufferAttribute,
+  type Intersection,
+  Matrix4,
+  type Object3D,
+  type Raycaster,
+  Vector3,
+  Vector4,
+} from "three";
+import { Line2, LineGeometry, LineMaterial } from "three-stdlib";
 
 import type { EventContext } from "../event/context";
 import { setupMaterialForMRT } from "../material";
@@ -23,39 +29,14 @@ import { createReplacer } from "../utils/replacer";
 import { POLYGON_BATCH_TEXTURE_ROWS } from "./batchedFeature";
 import { initBatchedMaterial } from "./batchTexture";
 import type { FeatureMesh } from "./featureMesh";
-
-class NvLineGeometry extends LineGeometry {
-  setPositions(
-    array: Float32Array,
-    skipIdx: Uint32Array = new Uint32Array(),
-  ): this {
-    const positions: number[] = [];
-    const skipSet = new Set(skipIdx);
-
-    for (let i = 0; i < array.length - 3; i += 3) {
-      const currentIndex = i / 3;
-      if (skipSet.has(currentIndex)) {
-        continue;
-      }
-
-      // segment start
-      positions.push(array[i], array[i + 1], array[i + 2]);
-      // segment end
-      positions.push(array[i + 3], array[i + 4], array[i + 5]);
-    }
-
-    const points = new Float32Array(positions);
-
-    // This function is used to override LineGeometry's setPositions,
-    // so we don't call super.setPositions.
-    LineSegmentsGeometry.prototype.setPositions.call(this, points);
-    return this;
-  }
-}
+import { NvLineGeometry } from "./nvLineGeometry";
+import { setupRTECallback } from "./rtcRteHelper";
 
 export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
   readonly ctx: EventContext;
   private resizeEventUnsubscribe?: () => void;
+  /** True when the geometry carries RTE high/low positions (GeoJSON path). */
+  private useRTE = false;
 
   constructor(ctx: EventContext, mesh: NavaraPolygonMesh) {
     super(new NvLineGeometry(), new LineMaterial());
@@ -64,6 +45,13 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
     this.initMaterial(mesh);
   }
 
+  raycast(raycaster: Raycaster, intersects: Intersection[]): void {
+    // RTE geometry carries no instanceStart/End attributes, which
+    // LineSegments2.raycast requires — picking is GPU-based, so skip.
+    if (this.useRTE) return;
+    super.raycast(raycaster, intersects);
+  }
+
   private initGeometry(mesh: NavaraPolygonMesh) {
     const g = mesh.outline_geometry;
     if (!g || !g.position) {
@@ -74,6 +62,15 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
       return;
     }
 
+    const position3dHigh =
+      g.position_3d_high && g.position_3d_high.size > 0
+        ? this.ctx.buf.removeF32(g.position_3d_high.data)
+        : undefined;
+    const position3dLow =
+      g.position_3d_low && g.position_3d_low.size > 0
+        ? this.ctx.buf.removeF32(g.position_3d_low.data)
+        : undefined;
+
     const scale_normal_and_cap = g.scale_normal_and_cap
       ? this.ctx.buf.removeF32(g.scale_normal_and_cap.data)
       : undefined;
@@ -88,7 +85,17 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
 
     // Convert position buffer to Line2 format
     const lineGeometry = this.geometry as NvLineGeometry;
-    lineGeometry.setPositions(position, skipIdx);
+
+    if (position3dHigh && position3dLow) {
+      // RTE mode: upload only the high/low pairs — the RTE shader never
+      // reads instanceStart/End, so calling setPositions would leave an
+      // unused buffer resident on the GPU. setPositionsHighLow also sets
+      // the bounds that setPositions would have computed.
+      lineGeometry.setPositionsHighLow(position3dHigh, position3dLow, skipIdx);
+      this.useRTE = true;
+    } else {
+      lineGeometry.setPositions(position, skipIdx);
+    }
 
     // Add scale_normal_and_cap attributes if available
     if (g.scale_normal_and_cap && scale_normal_and_cap) {
@@ -192,6 +199,47 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
       batchLength: 0,
     });
 
+    if (this.useRTE) {
+      material.userData.defines ??= {};
+      material.userData.defines.USE_RTE = true;
+      material.userData.modelViewMatrixRTE = { value: new Matrix4() };
+      material.userData.uCameraPositionHigh = { value: new Vector3() };
+      material.userData.uCameraPositionLow = { value: new Vector3() };
+
+      // The outline mesh sits directly in the scene with an identity
+      // matrixWorld (positions are absolute ECEF), so pass identity matrices
+      // like PolylineMesh does.
+      const rteCallback = setupRTECallback(
+        this,
+        (modelViewMatrixRTE, cameraPositionHigh, cameraPositionLow) => {
+          material.userData.modelViewMatrixRTE.value.copy(modelViewMatrixRTE);
+          material.userData.uCameraPositionHigh.value.copy(cameraPositionHigh);
+          material.userData.uCameraPositionLow.value.copy(cameraPositionLow);
+        },
+        new Matrix4(),
+        new Matrix4(),
+      );
+      // LineSegments2.prototype.onBeforeRender refreshes the `resolution`
+      // uniform from the viewport every frame; assigning our own callback
+      // shadows it, so replicate that update here — otherwise resolution
+      // stays at the (1,1) default and line widths blow up to viewport size.
+      const updateRTE: Object3D["onBeforeRender"] = rteCallback;
+      const viewport = new Vector4();
+      this.onBeforeRender = (renderer, scene, camera, geometry, mat, group) => {
+        renderer.getViewport(viewport);
+        material.resolution.set(viewport.z, viewport.w);
+        updateRTE(renderer, scene, camera, geometry, mat, group);
+      };
+      this.onBeforeShadow = rteCallback;
+    }
+
+    // The defines are stamped in onBeforeCompile (not via material.defines),
+    // so they must be part of the program cache key — otherwise RTE and
+    // non-RTE outlines (or different batch-define sets) would share one
+    // compiled program.
+    material.customProgramCacheKey = () =>
+      `nvr-polygon-outline:${JSON.stringify(material.userData.defines ?? {})}`;
+
     material.onBeforeCompile = (shader) => {
       // Merge user-defined defines (batch texture, color/show, height, etc.)
       shader.defines ??= {};
@@ -206,6 +254,17 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
         shader.uniforms.batchDataTexture = material.userData.batchDataTexture;
       }
 
+      // RTE uniforms (updated per-frame via setupRTECallback)
+      if (material.userData.defines?.USE_RTE) {
+        shader.uniforms.modelViewMatrixRTE =
+          material.userData.modelViewMatrixRTE;
+        shader.uniforms.u_cameraPositionHigh =
+          material.userData.uCameraPositionHigh;
+        shader.uniforms.u_cameraPositionLow =
+          material.userData.uCameraPositionLow;
+        shader.uniforms.u_rteOne = RTE_ONE_UNIFORM;
+      }
+
       shader.vertexShader = createReplacer(shader.vertexShader)
         .replace(
           "attribute vec3 instanceEnd;",
@@ -215,6 +274,16 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
         attribute vec4 scaleNormalAndCapEnd;
         varying float nvr_vShow;
         uniform vec2 uMinMaxHeight;
+        #ifdef USE_RTE
+          attribute vec3 instanceStartHigh;
+          attribute vec3 instanceStartLow;
+          attribute vec3 instanceEndHigh;
+          attribute vec3 instanceEndLow;
+          uniform vec3 u_cameraPositionHigh;
+          uniform vec3 u_cameraPositionLow;
+          uniform float u_rteOne;
+          uniform mat4 modelViewMatrixRTE;
+        #endif
         ${ExtrudedHeightParsVertex}
         ${HeightParsVertex}
         ${BranchFreeTernary}
@@ -243,25 +312,40 @@ export class PolygonOutlineMesh extends Line2 implements FeatureMesh {
           #endif
         #endif
 
-        vec3 adjustedInstanceStart = instanceStart;
-        adjustedInstanceStart.xyz += scaleNormalAndCapStart.xyz * nvr_branchFreeTernary(
+        vec3 nvr_heightOffsetStart = scaleNormalAndCapStart.xyz * nvr_branchFreeTernary(
           scaleNormalAndCapStart.w == 0.0,
           uMinMaxHeight.x + addHeight,
           uMinMaxHeight.y + addExtrudedHeight
         );
-        vec4 start = modelViewMatrix * vec4( adjustedInstanceStart, 1.0 );
+        #ifdef USE_RTE
+          // Reconstruct the camera-relative position from high/low pairs to
+          // avoid f32 jitter at globe scale. u_rteOne (always 1.0) blocks
+          // fast-math reassociation of the high-difference term.
+          vec3 nvr_startHighDiff = (instanceStartHigh - u_cameraPositionHigh) * u_rteOne;
+          vec3 nvr_startLowDiff = instanceStartLow - u_cameraPositionLow;
+          vec4 start = modelViewMatrixRTE * vec4( nvr_startHighDiff + nvr_startLowDiff + nvr_heightOffsetStart, 1.0 );
+        #else
+          vec3 adjustedInstanceStart = instanceStart + nvr_heightOffsetStart;
+          vec4 start = modelViewMatrix * vec4( adjustedInstanceStart, 1.0 );
+        #endif
         `,
         )
         .replace(
           "vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );",
           `
-        vec3 adjustedInstanceEnd = instanceEnd;
-        adjustedInstanceEnd.xyz += scaleNormalAndCapEnd.xyz * nvr_branchFreeTernary(
+        vec3 nvr_heightOffsetEnd = scaleNormalAndCapEnd.xyz * nvr_branchFreeTernary(
           scaleNormalAndCapEnd.w == 0.0,
           uMinMaxHeight.x + addHeight,
           uMinMaxHeight.y + addExtrudedHeight
         );
-        vec4 end = modelViewMatrix * vec4( adjustedInstanceEnd, 1.0 );
+        #ifdef USE_RTE
+          vec3 nvr_endHighDiff = (instanceEndHigh - u_cameraPositionHigh) * u_rteOne;
+          vec3 nvr_endLowDiff = instanceEndLow - u_cameraPositionLow;
+          vec4 end = modelViewMatrixRTE * vec4( nvr_endHighDiff + nvr_endLowDiff + nvr_heightOffsetEnd, 1.0 );
+        #else
+          vec3 adjustedInstanceEnd = instanceEnd + nvr_heightOffsetEnd;
+          vec4 end = modelViewMatrix * vec4( adjustedInstanceEnd, 1.0 );
+        #endif
         `,
         ).source;