@chartts/gl 0.1.4 → 0.1.5

package/dist/{chunk-JCECG2KY.cjs → chunk-OTQKQDB6.cjs}

@@ -1840,6 +1840,7 @@ function createGlobe3DPlugin() {
   let sphereIBO = null;
   let sphereIndexCount = 0;
   const modelMatrix = mat4();
+  let locationColors = /* @__PURE__ */ new Map();
   const normalMatrix = new Float32Array(9);
   let screenPoints = [];
   let seriesInfo = [];
@@ -1856,34 +1857,49 @@ function createGlobe3DPlugin() {
         [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
         MESH_VERT_ATTRIBUTES
       );
-      const patches = [];
-      let maxVal = 0;
-      for (const s of series) for (const v of s.values) if (Math.abs(v) > maxVal) maxVal = Math.abs(v);
-      if (maxVal === 0) maxVal = 1;
+      const locationMap = /* @__PURE__ */ new Map();
       seriesInfo = [];
       screenPoints = [];
       for (let sIdx = 0; sIdx < series.length; sIdx++) {
         const s = series[sIdx];
         const colorHex = s.color ?? theme.colors[sIdx % theme.colors.length];
-        const color = hexToRGB(colorHex);
         seriesInfo.push({ name: s.name, color: colorHex });
         for (let di = 0; di < s.values.length; di++) {
           const lat = s.y?.[di] ?? 0, lng = s.x?.[di] ?? 0, value = s.values[di];
-          const normValue = Math.abs(value) / maxVal;
-          patches.push({ lat, lng, value, normValue, color, si: sIdx, di, name: s.name, label: data.categories?.[di] ?? "" });
+          const label = data.categories?.[di] ?? "";
+          const key = `${lat.toFixed(1)}_${lng.toFixed(1)}`;
+          let loc = locationMap.get(key);
+          if (!loc) {
+            loc = { lat, lng, totalValue: 0, label, entries: [] };
+            locationMap.set(key, loc);
+          }
+          loc.totalValue += Math.abs(value);
+          loc.entries.push({ si: sIdx, di, value });
           const [wx, wy, wz] = latLngToXYZ(lat, lng, GLOBE_RADIUS);
-          screenPoints.push({ si: sIdx, di, lat, lng, wx, wy, wz, value, name: s.name, label: data.categories?.[di] ?? "" });
+          screenPoints.push({ si: sIdx, di, lat, lng, wx, wy, wz, value, name: s.name, label });
         }
       }
+      const patches = [];
+      locationColors = /* @__PURE__ */ new Map();
+      let maxVal = 0;
+      for (const loc of locationMap.values()) if (loc.totalValue > maxVal) maxVal = loc.totalValue;
+      if (maxVal === 0) maxVal = 1;
+      let locIdx = 0;
+      for (const loc of locationMap.values()) {
+        const colorHex = theme.colors[locIdx % theme.colors.length];
+        locationColors.set(loc.label, colorHex);
+        const color = hexToRGB(colorHex);
+        const normValue = loc.totalValue / maxVal;
+        patches.push({ lat: loc.lat, lng: loc.lng, value: loc.totalValue, normValue, color, si: 0, di: locIdx, name: loc.label, label: loc.label });
+        locIdx++;
+      }
       const baseColor = [0.03, 0.05, 0.12];
       const patchRadius = 0.8;
       const gratLatStep = 30, gratLngStep = 30;
       const gratWidth = 0.015;
       const gratColor = [0.08, 0.12, 0.22];
-      console.log(`[Globe3D] Building sphere ${SEGMENTS}x${RINGS}, ${patches.length} data patches`);
       const verts = [];
       const indices = [];
-      let patchedVerts = 0;
       for (let ring = 0; ring <= RINGS; ring++) {
         const phi = ring / RINGS * Math.PI;
         const lat = 90 - ring / RINGS * 180;
@@ -1917,7 +1933,6 @@ function createGlobe3DPlugin() {
             }
           }
           if (ar > 0.01 || ag > 0.01 || ab > 0.01) {
-            patchedVerts++;
             r = Math.min(1, r + ar);
             g = Math.min(1, g + ag);
             b = Math.min(1, b + ab);
@@ -1935,12 +1950,11 @@ function createGlobe3DPlugin() {
           );
         }
       }
-      console.log(`[Globe3D] ${patchedVerts} / ${(RINGS + 1) * (SEGMENTS + 1)} vertices colored by data`);
       for (let ring = 0; ring < RINGS; ring++) {
         for (let seg = 0; seg < SEGMENTS; seg++) {
           const a = ring * (SEGMENTS + 1) + seg;
           const b = a + SEGMENTS + 1;
-          indices.push(a, b, a + 1, a + 1, b, b + 1);
+          indices.push(a, a + 1, b, a + 1, b + 1, b);
         }
       }
       const vertArr = new Float32Array(verts);
@@ -1965,6 +1979,7 @@ function createGlobe3DPlugin() {
       setLightUniforms(prog, defaultLightConfig(), camera.position);
       prog.setFloat("u_opacity", progress);
       if (sphereVBO && sphereIBO) {
+        gl.disable(gl.CULL_FACE);
         sphereVBO.bind();
         const layout = createVertexLayout([
           { location: prog.attributes["a_position"], size: 3 },
@@ -1976,6 +1991,7 @@ function createGlobe3DPlugin() {
         const indexType = gl.UNSIGNED_SHORT;
         gl.drawElements(gl.TRIANGLES, sphereIndexCount, indexType, 0);
         disableVertexLayout(gl, layout);
+        gl.enable(gl.CULL_FACE);
       }
     },
     renderOverlay(ctx, ctx2d) {
@@ -1995,38 +2011,17 @@ function createGlobe3DPlugin() {
         );
         if (!screen || screen.z < -1 || screen.z > 1 || screen.z > 0.97) continue;
         seenLabels.add(sp.label);
-        ctx2d.fillStyle = theme.textColor;
-        ctx2d.globalAlpha = 0.7;
+        const locColor = locationColors.get(sp.label) ?? theme.textColor;
+        ctx2d.fillStyle = locColor;
+        ctx2d.globalAlpha = 0.9;
         ctx2d.beginPath();
-        ctx2d.arc(screen.x, screen.y, 2.5, 0, Math.PI * 2);
+        ctx2d.arc(screen.x, screen.y, 3, 0, Math.PI * 2);
         ctx2d.fill();
         ctx2d.fillStyle = theme.textColor;
         ctx2d.globalAlpha = 0.85;
         ctx2d.textAlign = "left";
         ctx2d.fillText(sp.label, screen.x + 8, screen.y);
       }
-      if (seriesInfo.length > 1) {
-        const lx = 12, ly = height - 14 - seriesInfo.length * 18;
-        ctx2d.fillStyle = "rgba(0,0,0,0.45)";
-        ctx2d.globalAlpha = 1;
-        ctx2d.beginPath();
-        ctx2d.roundRect(lx - 6, ly - 8, 120, seriesInfo.length * 18 + 12, 6);
-        ctx2d.fill();
-        ctx2d.textAlign = "left";
-        ctx2d.textBaseline = "top";
-        ctx2d.font = `${theme.fontSize - 1}px ${theme.fontFamily}`;
-        for (let i = 0; i < seriesInfo.length; i++) {
-          const s = seriesInfo[i];
-          const y = ly + i * 18;
-          ctx2d.fillStyle = s.color;
-          ctx2d.globalAlpha = 0.9;
-          ctx2d.beginPath();
-          ctx2d.arc(lx + 4, y + 6, 4, 0, Math.PI * 2);
-          ctx2d.fill();
-          ctx2d.fillStyle = "rgba(255,255,255,0.8)";
-          ctx2d.fillText(s.name, lx + 14, y);
-        }
-      }
       ctx2d.restore();
     },
     needsLoop() {
@@ -3495,6 +3490,230 @@ function createGraphGLPlugin() {
   };
 }
 
+// src/charts/torus3d/torus3d-type.ts
+var RADIAL_SEGMENTS = 64;
+var HEIGHT_STEPS = 200;
+var TOTAL_HEIGHT = 6;
+var MIN_RADIUS = 0.6;
+var MAX_RADIUS = 2;
+function createTorus3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let use32bit = false;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let labelPoints = [];
+  return {
+    type: "torus3d",
+    prepare(ctx) {
+      const { renderer, data, options, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      const s = series[0];
+      if (!s || s.values.length === 0) return;
+      const opts = options;
+      const intensity = opts.intensity ?? 1;
+      const numRings = s.values.length;
+      let maxVal = 0;
+      for (const v of s.values) if (Math.abs(v) > maxVal) maxVal = Math.abs(v);
+      if (maxVal === 0) maxVal = 1;
+      const ringRadii = [];
+      for (let i = 0; i < numRings; i++) {
+        const norm = Math.abs(s.values[i]) / maxVal;
+        ringRadii.push((MIN_RADIUS + norm * (MAX_RADIUS - MIN_RADIUS)) * intensity);
+      }
+      const ringColors = [];
+      const ringHexColors = [];
+      for (let i = 0; i < numRings; i++) {
+        const hex = theme.colors[i % theme.colors.length];
+        ringHexColors.push(hex);
+        ringColors.push(hexToRGB(hex));
+      }
+      function catmullRom(p0, p1, p2, p3, t) {
+        return 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t * t + (-p0 + 3 * p1 - 3 * p2 + p3) * t * t * t);
+      }
+      function radiusAt(t) {
+        const f = t * (numRings - 1);
+        const i = Math.max(0, Math.min(Math.floor(f), numRings - 2));
+        const frac = f - i;
+        const p0 = ringRadii[Math.max(0, i - 1)];
+        const p1 = ringRadii[i];
+        const p2 = ringRadii[Math.min(numRings - 1, i + 1)];
+        const p3 = ringRadii[Math.min(numRings - 1, i + 2)];
+        return Math.max(MIN_RADIUS * 0.5, catmullRom(p0, p1, p2, p3, frac));
+      }
+      function colorAt(t) {
+        const f = t * (numRings - 1);
+        const i = Math.max(0, Math.min(Math.floor(f), numRings - 2));
+        const frac = f - i;
+        const c0 = ringColors[Math.max(0, i - 1)];
+        const c1 = ringColors[i];
+        const c2 = ringColors[Math.min(numRings - 1, i + 1)];
+        const c3 = ringColors[Math.min(numRings - 1, i + 2)];
+        return [
+          Math.max(0, Math.min(1, catmullRom(c0[0], c1[0], c2[0], c3[0], frac))),
+          Math.max(0, Math.min(1, catmullRom(c0[1], c1[1], c2[1], c3[1], frac))),
+          Math.max(0, Math.min(1, catmullRom(c0[2], c1[2], c2[2], c3[2], frac)))
+        ];
+      }
+      const verts = [];
+      const indices = [];
+      labelPoints = [];
+      for (let h = 0; h <= HEIGHT_STEPS; h++) {
+        const t = h / HEIGHT_STEPS;
+        const y = (t - 0.5) * TOTAL_HEIGHT;
+        const radius = radiusAt(t);
+        const color = colorAt(t);
+        const eps = 2e-3;
+        const rPrev = radiusAt(Math.max(0, t - eps));
+        const rNext = radiusAt(Math.min(1, t + eps));
+        const drdy = (rNext - rPrev) / (2 * eps * TOTAL_HEIGHT);
+        for (let seg = 0; seg <= RADIAL_SEGMENTS; seg++) {
+          const theta = seg / RADIAL_SEGMENTS * Math.PI * 2;
+          const cosT = Math.cos(theta);
+          const sinT = Math.sin(theta);
+          const nx = cosT;
+          const ny = -drdy;
+          const nz = sinT;
+          const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+          verts.push(
+            radius * cosT,
+            y,
+            radius * sinT,
+            nx / nlen,
+            ny / nlen,
+            nz / nlen,
+            color[0],
+            color[1],
+            color[2]
+          );
+        }
+      }
+      for (let i = 0; i < numRings; i++) {
+        const t = (i + 0.5) / numRings;
+        const y = (t - 0.5) * TOTAL_HEIGHT;
+        const r = ringRadii[i];
+        labelPoints.push({
+          si: 0,
+          di: i,
+          wx: r + 0.4,
+          wy: y,
+          wz: 0,
+          value: s.values[i],
+          label: data.categories?.[i] ?? `${i + 1}`,
+          color: ringHexColors[i]
+        });
+      }
+      for (let h = 0; h < HEIGHT_STEPS; h++) {
+        for (let seg = 0; seg < RADIAL_SEGMENTS; seg++) {
+          const a = h * (RADIAL_SEGMENTS + 1) + seg;
+          const b = a + RADIAL_SEGMENTS + 1;
+          indices.push(a, a + 1, b, a + 1, b + 1, b);
+        }
+      }
+      const capStart = verts.length / 9;
+      const bottomColor = colorAt(0);
+      verts.push(0, -0.5 * TOTAL_HEIGHT, 0, 0, -1, 0, bottomColor[0], bottomColor[1], bottomColor[2]);
+      const topColor = colorAt(1);
+      verts.push(0, 0.5 * TOTAL_HEIGHT, 0, 0, 1, 0, topColor[0], topColor[1], topColor[2]);
+      for (let seg = 0; seg < RADIAL_SEGMENTS; seg++) {
+        indices.push(capStart, seg + 1, seg);
+        const topRow = HEIGHT_STEPS * (RADIAL_SEGMENTS + 1);
+        indices.push(capStart + 1, topRow + seg, topRow + seg + 1);
+      }
+      const vertArr = new Float32Array(verts);
+      use32bit = verts.length / 9 > 65535;
+      const idxArr = use32bit ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("mesh");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setMat4("u_model", modelMatrix);
+      mat3NormalFromMat4(normalMatrix, modelMatrix);
+      prog.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(prog, defaultLightConfig(), camera.position);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (vbo && ibo) {
+        gl.disable(gl.CULL_FACE);
+        vbo.bind();
+        const layout = createVertexLayout([
+          { location: prog.attributes["a_position"], size: 3 },
+          { location: prog.attributes["a_normal"], size: 3 },
+          { location: prog.attributes["a_color"], size: 3 }
+        ]);
+        applyVertexLayout(gl, layout);
+        ibo.bind();
+        gl.drawElements(gl.TRIANGLES, indexCount, use32bit ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT, 0);
+        disableVertexLayout(gl, layout);
+        gl.enable(gl.CULL_FACE);
+      }
+    },
+    renderOverlay(ctx, ctx2d) {
+      const { camera, width, height, theme, animationProgress } = ctx;
+      if (animationProgress < 0.3) return;
+      ctx2d.save();
+      ctx2d.font = `bold ${theme.fontSize}px ${theme.fontFamily}`;
+      ctx2d.textBaseline = "middle";
+      for (const lp of labelPoints) {
+        const screen = projectToScreen(new Float32Array([lp.wx, lp.wy, lp.wz]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        ctx2d.fillStyle = lp.color;
+        ctx2d.globalAlpha = 0.9;
+        ctx2d.beginPath();
+        ctx2d.arc(screen.x, screen.y, 4, 0, Math.PI * 2);
+        ctx2d.fill();
+        ctx2d.fillStyle = theme.textColor;
+        ctx2d.globalAlpha = 0.85;
+        ctx2d.textAlign = "left";
+        ctx2d.fillText(`${lp.label}: ${lp.value}`, screen.x + 10, screen.y);
+      }
+      ctx2d.restore();
+    },
+    needsLoop() {
+      return false;
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 30;
+      for (const lp of labelPoints) {
+        const screen = projectToScreen(new Float32Array([lp.wx, lp.wy, lp.wz]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: lp.si, dataIndex: lp.di, value: lp.value, x: screen.x, y: screen.y, seriesName: lp.label };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      labelPoints = [];
+    }
+  };
+}
+
 // src/api/factory.ts
 function Scatter3D(container, opts) {
   const { data, ...options } = opts;
@@ -3571,6 +3790,11 @@ function GraphGL(container, opts) {
   const { data, ...options } = opts;
   return createGLChart(container, createGraphGLPlugin(), data, options);
 }
+function Torus3D(container, opts) {
+  const { data, ...options } = opts;
+  if (!options.camera) options.camera = { position: [4, 2, 6], target: [0, 0, 0] };
+  return createGLChart(container, createTorus3DPlugin(), data, options);
+}
 
 exports.Bar3D = Bar3D;
 exports.DEFAULT_GL_THEME = DEFAULT_GL_THEME;
@@ -3585,6 +3809,7 @@ exports.Map3D = Map3D;
 exports.Scatter3D = Scatter3D;
 exports.ScatterGL = ScatterGL;
 exports.Surface3D = Surface3D;
+exports.Torus3D = Torus3D;
 exports.applyVertexLayout = applyVertexLayout;
 exports.compileShader = compileShader;
 exports.createBar3DPlugin = createBar3DPlugin;
@@ -3606,6 +3831,7 @@ exports.createScatter3DPlugin = createScatter3DPlugin;
 exports.createScatterGLPlugin = createScatterGLPlugin;
 exports.createShaderProgram = createShaderProgram;
 exports.createSurface3DPlugin = createSurface3DPlugin;
+exports.createTorus3DPlugin = createTorus3DPlugin;
 exports.createVertexBuffer = createVertexBuffer;
 exports.createVertexLayout = createVertexLayout;
 exports.defaultLightConfig = defaultLightConfig;
@@ -3623,5 +3849,5 @@ exports.toRad = toRad;
 exports.updateCamera = updateCamera;
 exports.updateOrbitControls = updateOrbitControls;
 exports.vec3 = vec3;
-//# sourceMappingURL=chunk-JCECG2KY.cjs.map
-//# sourceMappingURL=chunk-JCECG2KY.cjs.map
+//# sourceMappingURL=chunk-OTQKQDB6.cjs.map
+//# sourceMappingURL=chunk-OTQKQDB6.cjs.map