jsgui3-server 0.0.134 → 0.0.135

package/examples/controls/14d) window, canvas globe/RenderingPipeline.js

@@ -0,0 +1,43 @@
+// RenderingPipeline.js (modular version)
+// Always loads fresh (removed previous idempotent caching to allow stage changes like ClippingStage).
+
+const BaseStage = require('./pipeline/BaseStage');
+const TransformStage = require('./pipeline/TransformStage');
+const ShadeSphereStage = require('./pipeline/ShadeSphereStage');
+const GridStage = require('./pipeline/GridStage');
+const ClippingStage = require('./pipeline/ClippingStage');
+const ContinentsStage = require('./pipeline/ContinentsStage');
+const ComposeStage = require('./pipeline/ComposeStage');
+const HUDStage = require('./pipeline/HUDStage');
+
+class RenderingPipeline {
+    constructor(renderer, stages){
+      this.r=renderer;
+      this.setStages(stages && stages.length ? stages : [
+        new TransformStage(renderer),
+        new ShadeSphereStage(renderer),
+  new GridStage(renderer),
+  new ClippingStage(renderer),
+        new ContinentsStage(renderer),
+        new ComposeStage(renderer),
+        new HUDStage(renderer)
+      ]);
+      this._rs={ renderer, ctx:renderer.ctx, width:0,height:0,cx:0,cy:0,radius:0,interactive:false,time:0,qualityScale:1 };
+    }
+    setStages(stages){ this.stages=stages; }
+    run({interactive=false}={}){
+      const r=this.r; const ctx=r.ctx; const rect=r.canvas.getBoundingClientRect();
+      const width=rect.width||r.canvas.width/r.opts.dpr; const height=rect.height||r.canvas.height/r.opts.dpr;
+      ctx.clearRect(0,0,width,height);
+      if(r.opts.background){ ctx.fillStyle=r.opts.background; ctx.fillRect(0,0,width,height); }
+      const rs=this._rs; rs.interactive=interactive; rs.time=performance.now(); rs.ctx=ctx; rs.width=width; rs.height=height;
+      for(const s of this.stages) if(s.prepare) s.prepare(rs);
+      for(const s of this.stages) s.execute(rs);
+    }
+    insertStageBefore(stage, Type){ const i=this.stages.findIndex(s=>s instanceof Type); if(i===-1) this.stages.push(stage); else this.stages.splice(i,0,stage); }
+    removeStage(Type){ const i=this.stages.findIndex(s=>s instanceof Type); if(i!==-1) this.stages.splice(i,1); }
+  }
+
+const exportsObj = { RenderingPipeline, BaseStage, TransformStage, ShadeSphereStage, GridStage, ClippingStage, ContinentsStage, ComposeStage, HUDStage };
+if (typeof globalThis !== 'undefined') globalThis.__EG_RENDERING_PIPELINE_EXPORTS__ = exportsObj; // still update for debugging
+module.exports = exportsObj;

package/examples/controls/14d) window, canvas globe/pipeline/BaseStage.js

@@ -0,0 +1,46 @@
+
+/**
+ * @typedef {Object} RenderState
+ * @property {CanvasRenderingContext2D} ctx - Destination 2D context.
+ * @property {number} width - Canvas width in CSS pixels.
+ * @property {number} height - Canvas height in CSS pixels.
+ * @property {number} radius - Globe screen-space radius (px).
+ * @property {number} cx - Globe center X in canvas coordinates.
+ * @property {number} cy - Globe center Y in canvas coordinates.
+ * @property {boolean} interactive - True if frame triggered by interaction (may raise quality scale).
+ */
+
+/**
+ * @typedef {Object} Continent
+ * @property {string} name
+ * @property {Float32Array} polyXYZ - Original great-circle densified polygon vertices (triplets).
+ * @property {Uint16Array|null} tri - Triangulated index list (ear clipping) referencing polygon vertex order.
+ * @property {Float32Array} [_rotated] - Per-frame rotated vertices (camera space).
+ * @property {Uint16Array} [_visTris] - Front-facing triangle indices (subset of tri).
+ * @property {number} [_visTrisLen] - Number of used indices in _visTris.
+ * @property {{idx:number[]}[]} [_strokeRuns] - Contiguous front-facing edge runs for outline stroking.
+ * @property {string|null} [fill]
+ * @property {string|null} [stroke]
+ * @property {number|null} [lineWidth]
+ */
+
+/**
+ * BaseStage
+ * Lightweight interface each pipeline stage implements. Stages may override
+ * prepare (optional) and must implement execute. Keeping the interface tiny
+ * avoids overhead inside the render loop.
+ */
+class BaseStage {
+	/**
+	 * @param {any} r - Renderer instance.
+	 */
+	constructor(r) {
+		this.r = r;
+	}
+	/** @param {RenderState} _rs */
+	prepare(_rs) {}
+	/** @param {RenderState} _rs */
+	execute(_rs) {}
+}
+
+module.exports = BaseStage;

package/examples/controls/14d) window, canvas globe/pipeline/ClippingStage.js

@@ -0,0 +1,29 @@
+const BaseStage = require('./BaseStage');
+const frontFace = require('./clipping/FrontFaceStrategy');
+const planeClip = require('./clipping/PlaneClipStrategy');
+
+// Strategy registry (extensible)
+const strategies = {
+  frontFace,
+  planeClip
+};
+
+class ClippingStage extends BaseStage {
+  constructor(r){
+    super(r);
+  }
+  /** @param {RenderState} _rs */
+  execute(_rs){
+    const r = this.r;
+    if(!r._continents) return;
+  // Choose best default strategy; allow override via opts.clipping.mode
+  const mode = r.opts.clipping?.mode || 'planeClip';
+    const strat = strategies[mode] || strategies.frontFace;
+    const R = r.R;
+    for(const c of r._continents){
+      strat.process(r, c, R);
+    }
+  }
+}
+
+module.exports = ClippingStage;

package/examples/controls/14d) window, canvas globe/pipeline/ComposeStage.js

@@ -0,0 +1,15 @@
+const BaseStage = require('./BaseStage');
+
+class ComposeStage extends BaseStage {
+  /** @param {RenderState} rs */
+  execute(rs) {
+    const ctx = rs.ctx;
+    ctx.beginPath();
+    ctx.arc(rs.cx, rs.cy, rs.radius, 0, Math.PI * 2);
+    ctx.strokeStyle = 'rgba(0,0,0,0.14)';
+    ctx.lineWidth = 1.1;
+    ctx.stroke();
+  }
+}
+
+module.exports = ComposeStage;

package/examples/controls/14d) window, canvas globe/pipeline/ContinentsStage.js

@@ -0,0 +1,116 @@
+const BaseStage = require('./BaseStage');
+
+class ContinentsStage extends BaseStage {
+  /** @param {RenderState} rs */
+  execute(rs) {
+    const rInst = this.r;
+    if (!rInst._continents) return;
+    const ctx = rInst.ctx;
+    const clippingEnabled = !!rInst.opts.clipping.enabled; // currently front-face only
+
+    for (const c of rInst._continents) {
+  const rot = c._rotated;
+  if (!rot) continue;
+
+      const fillStyle = c.fill || rInst.opts.antarcticaFill;
+      const strokeStyle = c.stroke || rInst.opts.antarcticaStroke;
+      const lw = c.lineWidth || rInst.opts.antarcticaLineWidth;
+
+  // Fill: draw a solid path when available (prevents triangle AA seams)
+      if (c._clipFillPathXY && c._clipFillPathXY.length >= 6) {
+        const path = c._clipFillPathXY;
+        ctx.save();
+        ctx.fillStyle = fillStyle;
+        ctx.beginPath();
+        ctx.moveTo(rs.cx + rs.radius * path[0], rs.cy - rs.radius * path[1]);
+        for (let i = 2; i < path.length; i += 2) {
+          const x = path[i], y = path[i+1];
+          ctx.lineTo(rs.cx + rs.radius * x, rs.cy - rs.radius * y);
+        }
+        ctx.closePath();
+        ctx.fill();
+        ctx.restore();
+      } else if (c._clipFillTris && c._clipFillTrisLen) {
+        const buf = c._clipFillTris;
+        ctx.save();
+        ctx.fillStyle = fillStyle;
+        for (let i = 0; i < c._clipFillTrisLen * 2; i += 6) {
+          const ax = buf[i], ay = buf[i + 1];
+          const bx = buf[i + 2], by = buf[i + 3];
+          const cx = buf[i + 4], cy = buf[i + 5];
+          ctx.beginPath();
+          ctx.moveTo(rs.cx + rs.radius * ax, rs.cy - rs.radius * ay);
+          ctx.lineTo(rs.cx + rs.radius * bx, rs.cy - rs.radius * by);
+          ctx.lineTo(rs.cx + rs.radius * cx, rs.cy - rs.radius * cy);
+          ctx.closePath();
+          ctx.fill();
+        }
+        ctx.restore();
+      } else if (c._visTrisLen) {
+        ctx.save();
+        ctx.fillStyle = fillStyle;
+        ctx.beginPath();
+        const len = c._visTrisLen;
+        for (let i = 0; i < len; i += 3) {
+          const ia = c._visTris[i];
+          const ib = c._visTris[i + 1];
+          const ic = c._visTris[i + 2];
+          const a = ia * 3, b = ib * 3, d = ic * 3;
+          const ax = rot[a], ay = rot[a + 1];
+          const bx = rot[b], by = rot[b + 1];
+          const cx = rot[d], cy = rot[d + 1];
+          ctx.moveTo(rs.cx + rs.radius * ax, rs.cy - rs.radius * ay);
+          ctx.lineTo(rs.cx + rs.radius * bx, rs.cy - rs.radius * by);
+          ctx.lineTo(rs.cx + rs.radius * cx, rs.cy - rs.radius * cy);
+        }
+        ctx.fill();
+        ctx.restore();
+      }
+
+      // Stroke: prefer clipped runs if present, else legacy runs, else legacy polyline
+      if (c._clipStrokeRuns && c._clipStrokeRuns.length) {
+        ctx.save();
+        ctx.strokeStyle = strokeStyle;
+        ctx.lineWidth = lw;
+        for (const buf of c._clipStrokeRuns) {
+          if (!buf || buf.length < 4) continue;
+          ctx.beginPath();
+          let sx = rs.cx + rs.radius * buf[0];
+          let sy = rs.cy - rs.radius * buf[1];
+          ctx.moveTo(sx, sy);
+          for (let i = 2; i < buf.length; i += 2) {
+            sx = rs.cx + rs.radius * buf[i];
+            sy = rs.cy - rs.radius * buf[i + 1];
+            ctx.lineTo(sx, sy);
+          }
+          ctx.stroke();
+        }
+        ctx.restore();
+      } else if (c._strokeRuns && c._strokeRuns.length) {
+        ctx.save();
+        ctx.strokeStyle = strokeStyle;
+        ctx.lineWidth = lw;
+        for (const run of c._strokeRuns) {
+          if (run.idx.length < 2) continue;
+          ctx.beginPath();
+          for (let i = 0; i < run.idx.length; i++) {
+            const vi = run.idx[i] * 3;
+            const x = rot[vi];
+            const y = rot[vi + 1];
+            const sx = rs.cx + rs.radius * x;
+            const sy = rs.cy - rs.radius * y;
+            if (!i) ctx.moveTo(sx, sy); else ctx.lineTo(sx, sy);
+          }
+          ctx.stroke();
+        }
+        ctx.restore();
+      }
+
+      // Placeholder: if future partial clipping is added, use original + rot arrays here
+      void clippingEnabled;
+    }
+  }
+  // Triangulation handled in ClippingStage
+}
+
+module.exports = ContinentsStage;

package/examples/controls/14d) window, canvas globe/pipeline/GridStage.js

@@ -0,0 +1,105 @@
+const BaseStage = require('./BaseStage');
+
+// Precompute constant to avoid repeated division inside loops.
+const DEG = Math.PI / 180;
+
+class GridStage extends BaseStage {
+  /** @param {RenderState} rs */
+  execute(rs) {
+    const rInst = this.r;
+    if (!rInst.opts.grid?.enabled) return;
+
+    const g = rInst.opts.grid;
+    const params = rInst._gridCache?.params;
+
+    const unchanged = (
+      params &&
+      params.stepLat === g.stepLat &&
+      params.stepLon === g.stepLon &&
+      params.sampleStepDeg === g.sampleStepDeg
+    );
+
+    if (!unchanged) {
+      const parallels = [];
+    for (let lat = -80; lat <= 80; lat += g.stepLat) {
+        const pts = [];
+        for (let lon = -180; lon <= 180; lon += g.sampleStepDeg) {
+      const φ = lat * DEG;
+      const λ = lon * DEG;
+          const cφ = Math.cos(φ), sφ = Math.sin(φ);
+          const sλ = Math.sin(λ), cλ = Math.cos(λ);
+          pts.push(cφ * sλ, sφ, cφ * cλ);
+        }
+        parallels.push(new Float32Array(pts));
+      }
+
+      const meridians = [];
+    for (let lon = -180; lon < 180; lon += g.stepLon) {
+        const pts = [];
+        for (let lat = -90; lat <= 90; lat += g.sampleStepDeg) {
+      const φ = lat * DEG;
+      const λ = lon * DEG;
+      const cφ = Math.cos(φ), sφ = Math.sin(φ);
+      const sλ = Math.sin(λ), cλ = Math.cos(λ);
+      pts.push(cφ * sλ, sφ, cφ * cλ);
+        }
+        meridians.push(new Float32Array(pts));
+      }
+
+      rInst._gridCache = {
+        parallels,
+        meridians,
+        params: {
+          stepLat: g.stepLat,
+          stepLon: g.stepLon,
+          sampleStepDeg: g.sampleStepDeg
+        }
+      };
+    }
+
+    const cache = rInst._gridCache;
+    if (!cache) return;
+    const ctx = rInst.ctx;
+    const R = rInst.R;
+    const R00 = R[0], R01 = R[3], R02 = R[6];
+    const R10 = R[1], R11 = R[4], R12 = R[7];
+    const R20 = R[2], R21 = R[5], R22 = R[8];
+
+    ctx.save();
+    ctx.strokeStyle = g.color;
+    ctx.globalAlpha = g.alpha;
+    ctx.lineWidth = g.lineWidth;
+    ctx.lineCap = 'round';
+
+  const drawLines = (lines) => {
+      for (const L of lines) {
+        let drawing = false;
+        ctx.beginPath();
+        for (let i = 0; i < L.length; i += 3) {
+          const vx = L[i], vy = L[i + 1], vz = L[i + 2];
+          const xw = R00 * vx + R01 * vy + R02 * vz;
+          const yw = R10 * vx + R11 * vy + R12 * vz;
+          const zw = R20 * vx + R21 * vy + R22 * vz;
+          if (zw >= 0) {
+            const sx = rs.cx + rs.radius * xw;
+            const sy = rs.cy - rs.radius * yw;
+            if (!drawing) { ctx.moveTo(sx, sy); drawing = true; }
+            else ctx.lineTo(sx, sy);
+          } else if (drawing) {
+            ctx.stroke();
+            ctx.beginPath();
+            drawing = false;
+          }
+        }
+        if (drawing) ctx.stroke();
+      }
+    };
+
+  // Parallels first (visual layering), then meridians.
+  drawLines(cache.parallels);
+  drawLines(cache.meridians);
+    ctx.restore();
+  }
+}
+
+module.exports = GridStage;

package/examples/controls/14d) window, canvas globe/pipeline/HUDStage.js

@@ -0,0 +1,10 @@
+const BaseStage = require('./BaseStage');
+
+class HUDStage extends BaseStage {
+		/** @param {RenderState} _rs */
+		execute(_rs) {
+		if (this.r.opts.showFPS) this.r._drawFPS();
+	}
+}
+
+module.exports = HUDStage;

package/examples/controls/14d) window, canvas globe/pipeline/ShadeSphereStage.js

@@ -0,0 +1,153 @@
+const BaseStage = require('./BaseStage');
+
+class ShadeSphereStage extends BaseStage {
+  /**
+   * Per-pixel shading of the sphere into an offscreen buffer, then composited.
+   * Performance note: inner loop kept monolithic to encourage engine inlining
+   * and avoid function call overhead per pixel.
+   * @param {RenderState} rs
+   */
+  execute(rs) {
+    const rInst = this.r;
+
+    const q = rInst.opts.quality * (
+      rs.interactive ? rInst.opts.interactiveQualityScale : 1
+    );
+    const d = Math.max(2, (2 * rs.radius * q) | 0);
+    const off = rInst._getOff(d, d);
+
+    if (rInst._mapSize !== d) {
+      rInst._buildNormalMap(d);
+    }
+    if (!rInst._imgData || rInst._imgData.width !== d) {
+      rInst._imgData = off.ctx.createImageData(d, d);
+    }
+
+    const data = rInst._imgData.data;
+    const base = rInst.opts.baseColor;
+    const amb = rInst.opts.ambient;
+    const kd = rInst.opts.diffuse;
+    const ks = rInst.opts.specular;
+    const shin = rInst.opts.shininess;
+    const termSoft = rInst.opts.terminatorSoftness;
+    const atm = rInst.opts.atmosphere;
+    const back = rInst.opts.backlight;
+    const Lx = rInst.sun[0], Ly = rInst.sun[1], Lz = rInst.sun[2];
+
+    // Half vector (approx: light + view(0,0,1))
+    let Hx = Lx, Hy = Ly, Hz = Lz + 1;
+    {
+      const invH = 1 / Math.hypot(Hx, Hy, Hz);
+      Hx *= invH; Hy *= invH; Hz *= invH;
+    }
+
+    const Rt = rInst.Rt;
+    const Rt00 = Rt[0], Rt01 = Rt[1], Rt02 = Rt[2];
+    const Rt10 = Rt[3], Rt11 = Rt[4], Rt12 = Rt[5];
+    const Rt20 = Rt[6], Rt21 = Rt[7], Rt22 = Rt[8];
+
+    const Nx = rInst._Nx, Ny = rInst._Ny, Nz = rInst._Nz, A8 = rInst._A8;
+    const texAlb = rInst.tex.albedo, texWater = rInst.tex.water, texIce = rInst.tex.ice;
+    const needTex = !!(texAlb || texWater || texIce);
+
+    const toneLUT = rInst._toneLUT;
+    const sLinToSRGB = rInst._lin2sU8;
+    const toneScale = (toneLUT.length - 1) / 4;
+
+    const nPix = d * d;
+    let p = 0;
+  for (let i = 0; i < nPix; i++) { // hot loop
+      const nz = Nz[i];
+      if (nz < 0) {
+        data[p] = data[p + 1] = data[p + 2] = data[p + 3] = 0;
+        p += 4;
+        continue;
+      }
+
+      const nx = Nx[i];
+      const ny = Ny[i];
+      const NL = nx * Lx + ny * Ly + nz * Lz;
+      const NV = nz; // view = (0,0,1)
+      const NH = nx * Hx + ny * Hy + nz * Hz;
+
+      let t = (NL + termSoft) / (2 * termSoft);
+      if (t < 0) t = 0; else if (t > 1) t = 1;
+      const dayMask = (3 - 2 * t) * t * t * (NL > 0 ? NL : 0);
+
+      let albR = base[0], albG = base[1], albB = base[2];
+      let oceanW = 1, iceW = 0;
+
+      if (needTex) {
+        const Wx = Rt00 * nx + Rt01 * ny + Rt02 * nz;
+        const Wy = Rt10 * nx + Rt11 * ny + Rt12 * nz;
+        const Wz = Rt20 * nx + Rt21 * ny + Rt22 * nz;
+        const lon = Math.atan2(Wx, Wz);
+        const WyC = Wy < -1 ? -1 : (Wy > 1 ? 1 : Wy);
+        const lat = Math.asin(WyC);
+        if (texAlb) {
+          const s = rInst._sampleSRGB(texAlb, lon, lat);
+            const lut = rInst._s2l;
+            albR = lut[s.r]; albG = lut[s.g]; albB = lut[s.b];
+        }
+        if (texWater) {
+          const sw = rInst._sampleSRGB(texWater, lon, lat);
+          oceanW = (sw.r + sw.g + sw.b) / 765;
+        }
+        if (texIce) {
+          const si = rInst._sampleSRGB(texIce, lon, lat);
+          iceW = (si.r + si.g + si.b) / 765;
+        }
+      }
+
+      const diff = kd * dayMask;
+      const specW = oceanW * (1 - 0.9 * iceW);
+      const spec = NL > 0 ? ks * specW * Math.pow(NH > 0 ? NH : 0, shin) : 0;
+      const NVc = NV < 0 ? 0 : (NV > 1 ? 1 : NV);
+      const rimDay = atm * Math.pow(1 - NVc, 2.4) * (NL + 0.15 > 0 ? NL + 0.15 : 0);
+      let rimBack = 0;
+      if (Lz < 0 && NL < 0) {
+        rimBack = back * Math.pow(1 - NVc, 3.2) * (-NL);
+      }
+
+      let rLin = albR * (amb + diff) + spec + 0.40 * rimDay + 0.25 * rimBack;
+      let gLin = albG * (amb + diff) + spec + 0.65 * rimDay + 0.40 * rimBack;
+      let bLin = albB * (amb + diff) + spec + 1.00 * rimDay + 0.80 * rimBack;
+
+      if (rLin < 0) rLin = 0; else if (rLin > 4) rLin = 4;
+      if (gLin < 0) gLin = 0; else if (gLin > 4) gLin = 4;
+      if (bLin < 0) bLin = 0; else if (bLin > 4) bLin = 4;
+
+      rLin = toneLUT[(rLin * toneScale) | 0];
+      gLin = toneLUT[(gLin * toneScale) | 0];
+      bLin = toneLUT[(bLin * toneScale) | 0];
+
+      if (rLin > 1) rLin = 1;
+      if (gLin > 1) gLin = 1;
+      if (bLin > 1) bLin = 1;
+
+  data[p]     = sLinToSRGB[(rLin * 4095) | 0];
+      data[p + 1] = sLinToSRGB[(gLin * 4095) | 0];
+      data[p + 2] = sLinToSRGB[(bLin * 4095) | 0];
+      data[p + 3] = A8[i];
+      p += 4;
+    }
+
+    off.ctx.putImageData(rInst._imgData, 0, 0);
+    const drawSize = d / q;
+    const ctx = rInst.ctx;
+    ctx.save();
+    ctx.beginPath();
+    ctx.arc(rs.cx, rs.cy, rs.radius, 0, Math.PI * 2);
+    ctx.clip();
+    ctx.drawImage(
+      off.canvas,
+      rs.cx - drawSize / 2,
+      rs.cy - drawSize / 2,
+      drawSize,
+      drawSize
+    );
+    ctx.restore();
+  }
+}
+
+module.exports = ShadeSphereStage;

package/examples/controls/14d) window, canvas globe/pipeline/TransformStage.js

@@ -0,0 +1,23 @@
+const BaseStage = require('./BaseStage');
+
+class TransformStage extends BaseStage {
+  /** @param {RenderState} rs */
+  execute(rs) {
+    const r = this.r;
+    r._updateRot();
+
+    const rect = r.canvas.getBoundingClientRect();
+    const width = rect.width || r.canvas.width / r.opts.dpr;
+    const height = rect.height || r.canvas.height / r.opts.dpr;
+    rs.width = width;
+    rs.height = height;
+
+    const pad = r.opts.padding;
+    const minSide = Math.min(width, height);
+    rs.radius = Math.max(1, minSide / 2 - pad);
+  rs.cx = width * 0.5;
+  rs.cy = height * 0.5;
+  }
+}
+
+module.exports = TransformStage;

package/examples/controls/14d) window, canvas globe/pipeline/clipping/FrontFaceStrategy.js

@@ -0,0 +1,46 @@
+// FrontFaceStrategy: current simple hemisphere clipping (z >= 0 fully)
+// Exports a process(renderer, continent, R) function.
+
+function ensureTriangulated(continent) {
+  if (continent.tri) return;
+  const polyXYZ = continent.polyXYZ;
+  const n = polyXYZ.length / 3;
+  if (n < 3) { continent.tri = null; return; }
+  // Simple average normal basis projection + ear clipping (duplicated lightweight version)
+  let nx=0, ny=0, nz=0; for (let i=0;i<n;i++){ const k=i*3; nx+=polyXYZ[k]; ny+=polyXYZ[k+1]; nz+=polyXYZ[k+2]; }
+  const nlen = Math.hypot(nx,ny,nz) || 1; nx/=nlen; ny/=nlen; nz/=nlen;
+  let ax = Math.abs(nx) < 0.8 ? 1 : 0; let ay = ax?0:1; let az = 0;
+  let ux = ny*az - nz*ay, uy = nz*ax - nx*az, uz = nx*ay - ny*ax; const ulen = Math.hypot(ux,uy,uz)||1; ux/=ulen; uy/=ulen; uz/=ulen;
+  let vx = ny*uz - nz*uy, vy = nz*ux - nx*uz, vz = nx*uy - ny*ux;
+  const px = new Array(n), py = new Array(n);
+  for (let i=0;i<n;i++){ const k=i*3; const x=polyXYZ[k], y=polyXYZ[k+1], z=polyXYZ[k+2]; px[i]=x*ux+y*uy+z*uz; py[i]=x*vx+y*vy+z*vz; }
+  const V = []; for (let i=0;i<n;i++) V.push(i);
+  function area(){ let a=0; for (let i=0;i<V.length;i++){ const i0=V[i], i1=V[(i+1)%V.length]; a+=px[i0]*py[i1]-px[i1]*py[i0]; } return a*0.5; }
+  const orientCW = area()<0;
+  function isConvex(a,b,c){ const ax=px[a], ay=py[a], bx=px[b], by=py[b], cx=px[c], cy=py[c]; const cross=(bx-ax)*(cy-ay)-(by-ay)*(cx-ax); return orientCW? cross<0: cross>0; }
+  function inTri(a,b,c,p){ const x=px[p], y=py[p]; const ax=px[a], ay=py[a], bx=px[b], by=py[b], cx=px[c], cy=py[c]; const v0x=cx-ax,v0y=cy-ay,v1x=bx-ax,v1y=by-ay,v2x=x-ax,v2y=y-ay; const den=v0x*v1y-v1x*v0y; if(Math.abs(den)<1e-12) return false; const inv=1/den; const A=(v2x*v1y-v1x*v2y)*inv; const B=(v0x*v2y-v2x*v0y)*inv; const C=1-A-B; return A>0&&B>0&&C>0; }
+  const out=[]; let guard=0;
+  while (V.length>3 && guard<10000){ let ear=false; for (let i=0;i<V.length;i++){ const iPrev=V[(i+V.length-1)%V.length], iCurr=V[i], iNext=V[(i+1)%V.length]; if(!isConvex(iPrev,iCurr,iNext)) continue; let inside=false; for (let k=0;k<V.length;k++){ const idx=V[k]; if(idx===iPrev||idx===iCurr||idx===iNext) continue; if(inTri(iPrev,iCurr,iNext,idx)){ inside=true; break; } } if(inside) continue; out.push(iPrev,iCurr,iNext); V.splice(i,1); ear=true; break; } if(!ear) break; guard++; }
+  if (V.length===3) out.push(V[0],V[1],V[2]);
+  continent.tri = new Uint16Array(out);
+}
+
+function process(renderer, continent, R){
+  const poly = continent.polyXYZ; if(!poly || poly.length < 9) { continent._visTrisLen=0; continent._strokeRuns=[]; return; }
+  ensureTriangulated(continent);
+  const nVerts = poly.length/3;
+  if(!continent._rotated || continent._rotated.length !== poly.length){ continent._rotated = new Float32Array(poly.length); }
+  const rot = continent._rotated;
+  const R00=R[0],R01=R[3],R02=R[6]; const R10=R[1],R11=R[4],R12=R[7]; const R20=R[2],R21=R[5],R22=R[8];
+  for(let i=0;i<poly.length;i+=3){ const x=poly[i], y=poly[i+1], z=poly[i+2]; rot[i]=R00*x+R01*y+R02*z; rot[i+1]=R10*x+R11*y+R12*z; rot[i+2]=R20*x+R21*y+R22*z; }
+  // Mask
+  let mask = continent._frontMask; if(!mask || mask.length!==nVerts) mask = continent._frontMask = new Uint8Array(nVerts);
+  let front=0; for(let v=0,off=2; v<nVerts; v++, off+=3){ const f = rot[off] >= 0 ? 1:0; mask[v]=f; front+=f; }
+  if(front===0){ continent._visTrisLen=0; continent._strokeRuns=[]; return; }
+  const allFront = front===nVerts; const tri = continent.tri;
+  if(tri){ if(!continent._visTris || continent._visTris.length !== tri.length) continent._visTris = new Uint16Array(tri.length); if(allFront){ continent._visTris.set(tri); continent._visTrisLen=tri.length; } else { let w=0; for(let i=0;i<tri.length;i+=3){ const a=tri[i], b=tri[i+1], c=tri[i+2]; if(mask[a]&mask[b]&mask[c]){ continent._visTris[w++]=a; continent._visTris[w++]=b; continent._visTris[w++]=c; } } continent._visTrisLen=w; } }
+  if(allFront){ continent._strokeRuns=[{ idx: Array.from({length:nVerts}, (_,i)=>i) }]; return; }
+  const runs=[]; let curr=null; for(let i=0;i<=nVerts;i++){ const idx=i % nVerts; if(mask[idx]){ if(!curr) curr={idx:[]}; curr.idx.push(idx); } else if(curr){ if(curr.idx.length>1) runs.push(curr); curr=null; } } if(curr && curr.idx.length>1) runs.push(curr); continent._strokeRuns=runs;
+}
+
+module.exports = { process, name:'frontFace' };