scichart-engine 0.4.1

package/dist/gpu/adapter/seriesAdapter.d.ts

@@ -0,0 +1,88 @@
+import { DrawList } from '../drawList';
+import { GpuBackend, RGBA } from '../types';
+
+/**
+ * Series style from the original renderer
+ */
+export interface SeriesStyle {
+    color?: string | RGBA;
+    opacity?: number;
+    lineWidth?: number;
+    pointSize?: number;
+    symbol?: string;
+}
+/**
+ * Series render data from the chart system
+ */
+export interface SeriesData {
+    id: string;
+    type: "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "bar" | "heatmap";
+    visible: boolean;
+    /** Main vertex data */
+    data: Float32Array;
+    /** Style properties */
+    style: SeriesStyle;
+    /** For step charts */
+    stepData?: Float32Array;
+    /** Y-axis bounds for multi-axis support */
+    yBounds?: {
+        min: number;
+        max: number;
+    };
+    /** For heatmaps */
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormapData?: Uint8Array;
+    colormap?: string;
+}
+/**
+ * Mutable color tuple for internal use
+ */
+type MutableRGBA = [number, number, number, number];
+/**
+ * Parse color from various formats to RGBA
+ */
+export declare function parseColorToRGBA(color: string | RGBA | undefined): MutableRGBA;
+/**
+ * Series Adapter class
+ *
+ * Manages the conversion of chart series to GPU resources and draw calls.
+ */
+export declare class SeriesAdapter {
+    private backend;
+    private seriesBufferMap;
+    private seriesStepBufferMap;
+    private seriesTextureMap;
+    constructor(backend: GpuBackend);
+    /**
+     * Get buffer ID for a series
+     */
+    private getBufferId;
+    /**
+     * Get step buffer ID for a series
+     */
+    private getStepBufferId;
+    /**
+     * Get texture ID for a series
+     */
+    private getTextureId;
+    /**
+     * Update series data in GPU buffers
+     */
+    updateSeries(series: SeriesData): void;
+    /**
+     * Remove a series from GPU resources
+     */
+    removeSeries(seriesId: string): void;
+    /**
+     * Build draw list from series array
+     */
+    buildDrawList(seriesArray: SeriesData[]): DrawList;
+    /**
+     * Cleanup all resources
+     */
+    destroy(): void;
+}
+export {};

package/dist/gpu/backends/webgl/WebGLBackend.d.ts

@@ -0,0 +1,42 @@
+import { BufferDescriptor, BufferId, GpuBackend, GpuBackendInfo, GpuViewport, Texture1DDescriptor, TextureId } from '../../types';
+import { DrawList } from '../../drawList';
+import { FrameUniforms } from '../../frame';
+
+export interface WebGLBackendOptions {
+    antialias?: boolean;
+    preserveDrawingBuffer?: boolean;
+    powerPreference?: "default" | "low-power" | "high-performance";
+}
+export declare class WebGLBackend implements GpuBackend {
+    readonly info: GpuBackendInfo;
+    private canvas;
+    private opts;
+    private gl;
+    private viewport;
+    private dpr;
+    private programs;
+    private buffers;
+    private textures;
+    constructor(canvas: HTMLCanvasElement, opts?: WebGLBackendOptions);
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    setViewport(viewport: GpuViewport): void;
+    createOrUpdateBuffer(id: BufferId, data: ArrayBufferView, desc?: Partial<BufferDescriptor>): void;
+    deleteBuffer(id: BufferId): void;
+    createOrUpdateTexture1D(id: TextureId, data: Uint8Array, desc?: Partial<Texture1DDescriptor>): void;
+    deleteTexture(id: TextureId): void;
+    render(drawList: DrawList, frame: FrameUniforms): void;
+    renderWithBounds(drawList: DrawList, frame: FrameUniforms, bounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }): void;
+    private renderDrawCall;
+    private renderLine;
+    private renderPoints;
+    private renderBand;
+    private renderTriangles;
+    private renderHeatmap;
+    destroy(): void;
+}

package/dist/gpu/backends/webgl/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * WebGL Backend Index
+ */
+export { WebGLBackend } from './WebGLBackend';
+export type { WebGLBackendOptions } from './WebGLBackend';

package/dist/gpu/backends/webgl/programFactory.d.ts

@@ -0,0 +1,30 @@
+/**
+ * WebGL Program Factory
+ *
+ * Utilities for compiling and linking WebGL shader programs.
+ */
+export interface ShaderProgram {
+    program: WebGLProgram;
+    attributes: Record<string, number>;
+    uniforms: Record<string, WebGLUniformLocation | null>;
+}
+/**
+ * Create a shader program from source
+ */
+export declare function createProgram(gl: WebGLRenderingContext, vertSource: string, fragSource: string, attributeNames: string[], uniformNames: string[]): ShaderProgram;
+/**
+ * All programs used by the WebGL backend
+ */
+export interface ProgramBundle {
+    line: ShaderProgram;
+    point: ShaderProgram;
+    heatmap: ShaderProgram;
+}
+/**
+ * Create all shader programs
+ */
+export declare function createAllPrograms(gl: WebGLRenderingContext): ProgramBundle;
+/**
+ * Destroy all programs
+ */
+export declare function destroyPrograms(gl: WebGLRenderingContext, bundle: ProgramBundle): void;

package/dist/gpu/backends/webgl/shaders.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WebGL Shader Sources
+ *
+ * GLSL shaders for the WebGL backend.
+ * These match the functionality of the WebGPU WGSL shaders.
+ */
+export declare const LINE_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n}\n";
+export declare const LINE_FRAG_GLSL = "\nprecision highp float;\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n";
+export declare const POINT_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nuniform float uPointSize;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  gl_PointSize = uPointSize;\n}\n";
+export declare const POINT_FRAG_GLSL = "\nprecision highp float;\nuniform vec4 uColor;\nuniform int uSymbol;\n\nfloat sdCircle(vec2 p, float r) {\n  return length(p) - r;\n}\n\nfloat sdBox(vec2 p, vec2 b) {\n  vec2 d = abs(p) - b;\n  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);\n}\n\nfloat sdTriangle(vec2 p, float r) {\n  const float k = sqrt(3.0);\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  p.x -= clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfloat sdDiamond(vec2 p, float r) {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfloat sdCross(vec2 p, float r, float thickness) {\n  vec2 d = abs(p);\n  float s1 = sdBox(d, vec2(r, thickness));\n  float s2 = sdBox(d, vec2(thickness, r));\n  return min(s1, s2);\n}\n\nfloat sdX(vec2 p, float r, float thickness) {\n  float c = cos(0.785398);\n  float s = sin(0.785398);\n  mat2 m = mat2(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfloat sdStar(vec2 p, float r, float rf) {\n  const vec2 k1 = vec2(0.80901699, -0.58778525);\n  const vec2 k2 = vec2(-k1.x, k1.y);\n  p.x = abs(p.x);\n  p -= 2.0 * max(dot(k1, p), 0.0) * k1;\n  p -= 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y -= r;\n  vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0, 1);\n  float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\nvoid main() {\n  vec2 p = gl_PointCoord - vec2(0.5);\n  float d = 0.0;\n\n  if (uSymbol == 0) {\n    d = sdCircle(p, 0.45);\n  } else if (uSymbol == 1) {\n    d = sdBox(p, vec2(0.35));\n  } else if (uSymbol == 2) {\n    d = sdDiamond(p, 0.45);\n  } else if (uSymbol == 3) {\n    d = sdTriangle(vec2(p.x, p.y + 0.1), 0.4);\n  } else if (uSymbol == 4) {\n    d = sdTriangle(vec2(p.x, -p.y + 0.1), 0.4);\n  } else if (uSymbol == 5) {\n    d = sdCross(p, 0.45, 0.15);\n  } else if (uSymbol == 6) {\n    d = sdX(p, 0.45, 0.15);\n  } else if (uSymbol == 7) {\n    d = sdStar(p, 0.45, 0.4);\n  }\n\n  if (d > 0.02) discard;\n\n  float alpha = 1.0 - smoothstep(0.0, 0.02, d);\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\n}\n";
+export declare const HEATMAP_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nattribute float aValue;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nvarying float vValue;\n\nvoid main() {\n  gl_Position = vec4(aPosition * uScale + uTranslate, 0.0, 1.0);\n  vValue = aValue;\n}\n";
+export declare const HEATMAP_FRAG_GLSL = "\nprecision highp float;\nvarying float vValue;\nuniform float uMinValue;\nuniform float uMaxValue;\nuniform sampler2D uColormap;\n\nvoid main() {\n  float range = uMaxValue - uMinValue;\n  float t = (vValue - uMinValue) / (range != 0.0 ? range : 1.0);\n  t = clamp(t, 0.0, 1.0);\n  gl_FragColor = texture2D(uColormap, vec2(t, 0.5));\n}\n";
+export declare const TRIANGLE_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nattribute vec4 aColor;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nvarying vec4 vColor;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  vColor = aColor;\n}\n";
+export declare const TRIANGLE_FRAG_GLSL = "\nprecision highp float;\nvarying vec4 vColor;\n\nvoid main() {\n  gl_FragColor = vColor;\n}\n";

package/dist/gpu/backends/webgpu/MassiveDataRenderer.d.ts

@@ -0,0 +1,111 @@
+/**
+ * MassiveDataRenderer - Optimized renderer for 100M+ points
+ *
+ * Features:
+ * - Chunked buffer upload with progress
+ * - Batched draw calls to avoid GPU timeout
+ * - LOD (Level of Detail) with GPU downsampling
+ * - Storage buffers for instanced rendering
+ * - Streaming data generation
+ */
+export interface MassiveDataConfig {
+    maxPointsPerBatch: number;
+    chunkSizeBytes: number;
+    enableLOD: boolean;
+    lodLevels: number;
+    onProgress?: (phase: string, progress: number) => void;
+    onStats?: (stats: RenderStats) => void;
+}
+export interface RenderStats {
+    totalPoints: number;
+    renderedPoints: number;
+    bufferSizeMB: number;
+    uploadTimeMs: number;
+    frameTimeMs: number;
+    fps: number;
+    lodLevel: number;
+    batchCount: number;
+}
+export interface LODLevel {
+    buffer: any;
+    pointCount: number;
+    factor: number;
+}
+export declare class MassiveDataRenderer {
+    private device;
+    private context;
+    private format;
+    private config;
+    private linePipeline;
+    private lineBindGroupLayout;
+    private uniformBuffer;
+    private storageBuffer;
+    private bindGroup;
+    private totalPoints;
+    private lodLevels;
+    private currentLOD;
+    private lastFrameTime;
+    private frameCount;
+    private lastFpsTime;
+    private currentFps;
+    private viewport;
+    constructor(device: any, // GPUDevice
+    context: any, // GPUCanvasContext
+    format: any, // GPUTextureFormat
+    config?: Partial<MassiveDataConfig>);
+    /**
+     * Initialize render pipelines
+     */
+    init(): Promise<void>;
+    /**
+     * Set viewport dimensions
+     */
+    setViewport(width: number, height: number): void;
+    /**
+     * Upload data with chunked progress
+     */
+    uploadData(data: Float32Array): Promise<void>;
+    /**
+     * Build LOD levels using GPU downsampling
+     */
+    private buildLOD;
+    /**
+     * Select appropriate LOD level based on visible range
+     */
+    selectLOD(visibleRange: number, totalRange: number): number;
+    /**
+     * Render frame with batching
+     */
+    render(options: {
+        bounds: {
+            xMin: number;
+            xMax: number;
+            yMin: number;
+            yMax: number;
+        };
+        color?: [number, number, number, number];
+        lineWidth?: number;
+        time?: number;
+        lodLevel?: number;
+    }): void;
+    /**
+     * Generate streaming sine wave data
+     */
+    static generateSineWaveData(pointCount: number, onProgress?: (progress: number) => void): Promise<Float32Array>;
+    /**
+     * Get current stats
+     */
+    getStats(): RenderStats;
+    /**
+     * Get available LOD levels
+     */
+    getLODLevels(): {
+        level: number;
+        pointCount: number;
+        factor: number;
+    }[];
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/gpu/backends/webgpu/WebGPUBackend.d.ts

@@ -0,0 +1,58 @@
+import { BufferDescriptor, BufferId, GpuBackend, GpuBackendInfo, GpuViewport, Texture1DDescriptor, TextureId } from '../../types';
+import { DrawList } from '../../drawList';
+import { FrameUniforms } from '../../frame';
+
+export interface WebGPUBackendOptions {
+    powerPreference?: "low-power" | "high-performance";
+    preferredFormat?: string;
+}
+export declare class WebGPUBackend implements GpuBackend {
+    readonly info: GpuBackendInfo;
+    private canvas;
+    private opts;
+    private viewport;
+    private adapter;
+    private device;
+    private context;
+    private format;
+    private buffers;
+    private textures;
+    private trianglePipeline;
+    private linePipeline;
+    private pointPipeline;
+    private bandPipeline;
+    private heatmapPipeline;
+    private heatmapBindGroups;
+    constructor(canvas: HTMLCanvasElement, opts?: WebGPUBackendOptions);
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    setViewport(viewport: GpuViewport): void;
+    createOrUpdateBuffer(id: BufferId, data: ArrayBufferView, desc?: Partial<BufferDescriptor>): void;
+    deleteBuffer(id: BufferId): void;
+    createOrUpdateTexture1D(id: TextureId, data: Uint8Array, desc?: Partial<Texture1DDescriptor>): void;
+    deleteTexture(id: TextureId): void;
+    /**
+     * Initialize all pipelines lazily
+     */
+    private ensurePipelines;
+    render(drawList: DrawList, frame: FrameUniforms): void;
+    /**
+     * Render with explicit bounds (for integration with chart system)
+     */
+    renderWithBounds(drawList: DrawList, frame: FrameUniforms, bounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }): void;
+    /**
+     * Render a single draw call
+     */
+    private renderDrawCall;
+    private renderTriangles;
+    private renderLine;
+    private renderPoints;
+    private renderBand;
+    private renderHeatmap;
+    destroy(): void;
+}

package/dist/gpu/backends/webgpu/pipelines/bandPipeline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Band Pipeline - WebGPU pipeline for rendering band/area fills
+ *
+ * Uses triangle-strip topology for efficient area rendering.
+ * Reuses the line shader with different primitive topology.
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface BandPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    vertexStride: number;
+}
+export interface BandUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+}
+export declare function createBandPipeline(device: any, // GPUDevice
+format: string): BandPipelineBundle;
+export declare function updateBandUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: BandUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/heatmapPipeline.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Heatmap Pipeline - WebGPU pipeline for rendering heatmaps with colormap textures
+ *
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface HeatmapPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    sampler: any;
+    vertexStride: number;
+}
+export interface HeatmapUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    minValue: number;
+    maxValue: number;
+}
+export declare function createHeatmapPipeline(device: any, // GPUDevice
+format: string): HeatmapPipelineBundle;
+export declare function createHeatmapBindGroup(device: any, // GPUDevice
+layout: any, // GPUBindGroupLayout
+uniformBuffer: any, // GPUBuffer
+sampler: any, // GPUSampler
+colormapTexture: any): any;
+export declare function updateHeatmapUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: HeatmapUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pipeline Index - Export all WebGPU pipelines
+ */
+export { createTrianglePipeline, type TrianglePipelineBundle, } from './trianglePipeline';
+export { createLinePipeline, updateLineUniforms, type LinePipelineBundle, type LineUniforms, } from './linePipeline';
+export { createPointPipeline, updatePointUniforms, SYMBOL_MAP, type PointPipelineBundle, type PointUniforms, } from './pointPipeline';
+export { createHeatmapPipeline, createHeatmapBindGroup, updateHeatmapUniforms, type HeatmapPipelineBundle, type HeatmapUniforms, } from './heatmapPipeline';
+export { createBandPipeline, updateBandUniforms, type BandPipelineBundle, type BandUniforms, } from './bandPipeline';
+export { createInstancedLinePipeline, createInstancedLineBindGroup, updateInstancedLineUniforms, type InstancedLinePipelineBundle, type InstancedLineUniforms, } from './instancedLinePipeline';
+export { createInstancedPointPipeline, createInstancedPointBindGroup, updateInstancedPointUniforms, SYMBOL_TYPE_MAP, type InstancedPointPipelineBundle, type InstancedPointUniforms, } from './instancedPointPipeline';

package/dist/gpu/backends/webgpu/pipelines/instancedLinePipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Instanced Line Pipeline - For rendering large datasets efficiently
+ *
+ * Uses storage buffers and instancing to render millions of line segments.
+ * Each instance represents one line segment between consecutive points.
+ */
+export interface InstancedLinePipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    vertexStride: number;
+}
+export interface InstancedLineUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    lineWidth: number;
+    aspectRatio: number;
+    pointCount: number;
+}
+export declare function createInstancedLinePipeline(device: any, format: string): InstancedLinePipelineBundle;
+export declare function createInstancedLineBindGroup(device: any, layout: any, uniformBuffer: any, pointBuffer: any): any;
+export declare function updateInstancedLineUniforms(device: any, uniformBuffer: any, uniforms: InstancedLineUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/instancedPointPipeline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Instanced Point Pipeline - For rendering large scatter datasets
+ *
+ * Uses storage buffers and instancing to render millions of points.
+ */
+export interface InstancedPointPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    vertexStride: number;
+}
+export interface InstancedPointUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    pointSize: number;
+    symbolType: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    pointCount: number;
+}
+export declare function createInstancedPointPipeline(device: any, format: string): InstancedPointPipelineBundle;
+export declare function createInstancedPointBindGroup(device: any, layout: any, uniformBuffer: any, pointBuffer: any): any;
+export declare function updateInstancedPointUniforms(device: any, uniformBuffer: any, uniforms: InstancedPointUniforms): void;
+export declare const SYMBOL_TYPE_MAP: Record<string, number>;

package/dist/gpu/backends/webgpu/pipelines/linePipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Line Pipeline - WebGPU pipeline for rendering lines with uniform buffer
+ *
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types
+ * (following the pattern of the original WebGPUBackend.ts)
+ */
+export interface LinePipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    vertexStride: number;
+}
+export interface LineUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+}
+export declare function createLinePipeline(device: any, // GPUDevice
+format: string): LinePipelineBundle;
+export declare function updateLineUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: LineUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/pointPipeline.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Point Pipeline - WebGPU pipeline for rendering scatter points with SDF symbols
+ *
+ * Uses instanced rendering where each point is rendered as a quad (2 triangles).
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface PointPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    quadBuffer: any;
+    vertexStride: number;
+}
+export interface PointUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    pointSize: number;
+    symbol: number;
+    viewport: [number, number];
+}
+export declare function createPointPipeline(device: any, // GPUDevice
+format: string): PointPipelineBundle;
+export declare function updatePointUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: PointUniforms): void;
+export declare const SYMBOL_MAP: Record<string, number>;

package/dist/gpu/backends/webgpu/pipelines/trianglePipeline.d.ts

@@ -0,0 +1,5 @@
+export interface TrianglePipelineBundle {
+    pipeline: any;
+    vertexStride: number;
+}
+export declare function createTrianglePipeline(device: any, format: string): TrianglePipelineBundle;

package/dist/gpu/backends/webgpu/pipelines/triangleShader.d.ts

@@ -0,0 +1 @@
+export declare const TRIANGLE_SHADER_WGSL = "\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) color: vec4<f32>,\n};\n\n@vertex\nfn vs_main(\n  @location(0) position: vec2<f32>,\n  @location(1) color: vec4<f32>\n) -> VSOut {\n  var out: VSOut;\n  out.pos = vec4<f32>(position, 0.0, 1.0);\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  return in.color;\n}\n";

package/dist/gpu/backends/webgpu/shaders/heatmap.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Heatmap Shader - WGSL for WebGPU
+ *
+ * Renders heatmap cells with colormap texture lookup.
+ * Each vertex has position (x, y) and value (z) for color mapping.
+ */
+export declare const HEATMAP_SHADER_WGSL = "\n// Uniform buffer for transforms and value range\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  minValue: f32,\n  maxValue: f32,\n  _padding: vec2<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\n@group(0) @binding(1)\nvar colormapSampler: sampler;\n\n@group(0) @binding(2)\nvar colormapTexture: texture_1d<f32>;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n  @location(1) value: f32,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) value: f32,\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  out.value = in.value;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  let range = uniforms.maxValue - uniforms.minValue;\n  var t: f32;\n  if (range != 0.0) {\n    t = (in.value - uniforms.minValue) / range;\n  } else {\n    t = 0.0;\n  }\n  t = clamp(t, 0.0, 1.0);\n  \n  return textureSample(colormapTexture, colormapSampler, t);\n}\n";
+export declare const HEATMAP_VERTEX_STRIDE: number;

package/dist/gpu/backends/webgpu/shaders/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shader Index - Export all WGSL shaders
+ */
+export { TRIANGLE_SHADER_WGSL } from '../pipelines/triangleShader';
+export { LINE_SHADER_WGSL, LINE_VERTEX_STRIDE } from './line.wgsl';
+export { POINT_SHADER_WGSL, POINT_QUAD_SHADER_WGSL, POINT_VERTEX_STRIDE, } from './point.wgsl';
+export { HEATMAP_SHADER_WGSL, HEATMAP_VERTEX_STRIDE, } from './heatmap.wgsl';
+export { INSTANCED_LINE_SHADER_WGSL, INSTANCED_POINT_SHADER_WGSL, INSTANCED_LINE_VERTEX_STRIDE, INSTANCED_POINT_VERTEX_STRIDE, } from './instanced.wgsl';

package/dist/gpu/backends/webgpu/shaders/instanced.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Instanced Line Shader - For ultra-large datasets
+ *
+ * Uses instancing to render line segments efficiently.
+ * Each instance renders a line segment between two consecutive points.
+ */
+export declare const INSTANCED_LINE_SHADER_WGSL = "\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  lineWidth: f32,\n  aspectRatio: f32,\n  pointCount: u32,\n  padding: u32,\n}\n\nstruct Point {\n  x: f32,\n  y: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n@group(0) @binding(1) var<storage, read> points: array<Point>;\n\nstruct VertexOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) @interpolate(flat) segment_index: u32,\n}\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vertex_index: u32,\n  @builtin(instance_index) instance_index: u32\n) -> VertexOut {\n  var out: VertexOut;\n  out.segment_index = instance_index;\n  \n  // Skip if beyond point count\n  if (instance_index >= uniforms.pointCount - 1u) {\n    out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n    return out;\n  }\n  \n  // Get the two points for this segment\n  let p0 = points[instance_index];\n  let p1 = points[instance_index + 1u];\n  \n  // Transform points to clip space\n  let pos0 = vec2<f32>(p0.x * uniforms.scale.x + uniforms.translate.x,\n                       p0.y * uniforms.scale.y + uniforms.translate.y);\n  let pos1 = vec2<f32>(p1.x * uniforms.scale.x + uniforms.translate.x,\n                       p1.y * uniforms.scale.y + uniforms.translate.y);\n  \n  // Calculate line direction and perpendicular\n  let dir = normalize(pos1 - pos0);\n  let perp = vec2<f32>(-dir.y, dir.x);\n  \n  // Adjust for aspect ratio\n  let width = uniforms.lineWidth / 500.0; // Normalized width\n  let offset = perp * width;\n  \n  // Each segment is a quad (2 triangles, 6 vertices)\n  // vertex_index: 0,1,2 = first triangle, 3,4,5 = second triangle\n  var pos: vec2<f32>;\n  \n  switch (vertex_index % 6u) {\n    case 0u: { pos = pos0 - offset; } // bottom-left of start\n    case 1u: { pos = pos0 + offset; } // top-left of start\n    case 2u: { pos = pos1 - offset; } // bottom-left of end\n    case 3u: { pos = pos1 - offset; } // bottom-left of end\n    case 4u: { pos = pos0 + offset; } // top-left of start\n    case 5u: { pos = pos1 + offset; } // top-left of end\n    default: { pos = pos0; }\n  }\n  \n  out.position = vec4<f32>(pos, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VertexOut) -> @location(0) vec4<f32> {\n  return uniforms.color;\n}\n";
+/**
+ * Instanced Point Shader - For ultra-large scatter datasets
+ *
+ * Uses instancing with a quad per point.
+ * Supports SDF-based symbols.
+ */
+export declare const INSTANCED_POINT_SHADER_WGSL = "\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbolType: i32,\n  viewportWidth: f32,\n  viewportHeight: f32,\n  pointCount: u32,\n  padding: vec3<u32>,\n}\n\nstruct Point {\n  x: f32,\n  y: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n@group(0) @binding(1) var<storage, read> points: array<Point>;\n\nstruct VertexOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n}\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vertex_index: u32,\n  @builtin(instance_index) instance_index: u32\n) -> VertexOut {\n  var out: VertexOut;\n  \n  if (instance_index >= uniforms.pointCount) {\n    out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n    out.uv = vec2<f32>(0.0, 0.0);\n    return out;\n  }\n  \n  let pt = points[instance_index];\n  \n  // Transform point center to clip space\n  let center = vec2<f32>(\n    pt.x * uniforms.scale.x + uniforms.translate.x,\n    pt.y * uniforms.scale.y + uniforms.translate.y\n  );\n  \n  // Calculate point size in clip space\n  let sizeX = uniforms.pointSize / uniforms.viewportWidth * 2.0;\n  let sizeY = uniforms.pointSize / uniforms.viewportHeight * 2.0;\n  \n  // Quad vertices (6 for 2 triangles)\n  var offset: vec2<f32>;\n  var uv: vec2<f32>;\n  \n  switch (vertex_index % 6u) {\n    case 0u: { offset = vec2<f32>(-sizeX, -sizeY); uv = vec2<f32>(-1.0, -1.0); }\n    case 1u: { offset = vec2<f32>( sizeX, -sizeY); uv = vec2<f32>( 1.0, -1.0); }\n    case 2u: { offset = vec2<f32>(-sizeX,  sizeY); uv = vec2<f32>(-1.0,  1.0); }\n    case 3u: { offset = vec2<f32>(-sizeX,  sizeY); uv = vec2<f32>(-1.0,  1.0); }\n    case 4u: { offset = vec2<f32>( sizeX, -sizeY); uv = vec2<f32>( 1.0, -1.0); }\n    case 5u: { offset = vec2<f32>( sizeX,  sizeY); uv = vec2<f32>( 1.0,  1.0); }\n    default: { offset = vec2<f32>(0.0, 0.0); uv = vec2<f32>(0.0, 0.0); }\n  }\n  \n  out.position = vec4<f32>(center + offset, 0.0, 1.0);\n  out.uv = uv;\n  return out;\n}\n\n// SDF functions\nfn sdCircle(p: vec2<f32>) -> f32 {\n  return length(p) - 0.8;\n}\n\nfn sdSquare(p: vec2<f32>) -> f32 {\n  let d = abs(p) - vec2<f32>(0.7);\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>) -> f32 {\n  return (abs(p.x) + abs(p.y)) - 0.8;\n}\n\n@fragment\nfn fs_main(in: VertexOut) -> @location(0) vec4<f32> {\n  var d: f32;\n  \n  switch (uniforms.symbolType) {\n    case 0: { d = sdCircle(in.uv); }  // circle\n    case 1: { d = sdSquare(in.uv); }  // square\n    case 2: { d = sdDiamond(in.uv); } // diamond\n    default: { d = sdCircle(in.uv); }\n  }\n  \n  if (d > 0.05) {\n    discard;\n  }\n  \n  let alpha = 1.0 - smoothstep(0.0, 0.05, d);\n  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);\n}\n";
+export declare const INSTANCED_LINE_VERTEX_STRIDE = 8;
+export declare const INSTANCED_POINT_VERTEX_STRIDE = 8;

package/dist/gpu/backends/webgpu/shaders/line.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Line Shader - WGSL for WebGPU
+ *
+ * Renders simple line strips with uniform color.
+ * Uses uniform buffer for transform (scale + translate).
+ */
+export declare const LINE_SHADER_WGSL = "\n// Uniform buffer for transforms and color\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  return uniforms.color;\n}\n";
+export declare const LINE_VERTEX_STRIDE: number;

package/dist/gpu/backends/webgpu/shaders/point.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Point Shader - WGSL for WebGPU
+ *
+ * Renders scatter points with SDF-based symbols.
+ * Supports: circle, square, diamond, triangle, triangleDown, cross, x, star
+ */
+export declare const POINT_SHADER_WGSL = "\n// Uniform buffer for transforms, color, point properties\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbol: i32, // 0=circle, 1=square, 2=diamond, 3=triangle, 4=triangleDown, 5=cross, 6=x, 7=star\n  _padding: vec2<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) @interpolate(flat) pointSize: f32,\n  @location(1) @interpolate(flat) symbol: i32,\n};\n\n@vertex\nfn vs_main(in: VSInput, @builtin(vertex_index) vertexIndex: u32) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  out.pointSize = uniforms.pointSize;\n  out.symbol = uniforms.symbol;\n  return out;\n}\n\n// SDF functions for symbols\nfn sdCircle(p: vec2<f32>, r: f32) -> f32 {\n  return length(p) - r;\n}\n\nfn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {\n  let d = abs(p) - b;\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>, r: f32) -> f32 {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {\n  let k = sqrt(3.0);\n  var p = p_in;\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) {\n    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  }\n  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let d = abs(p);\n  let s1 = sdBox(d, vec2<f32>(r, thickness));\n  let s2 = sdBox(d, vec2<f32>(thickness, r));\n  return min(s1, s2);\n}\n\nfn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let c = cos(0.785398);\n  let s = sin(0.785398);\n  let m = mat2x2<f32>(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {\n  let k1 = vec2<f32>(0.80901699, -0.58778525);\n  let k2 = vec2<f32>(-k1.x, k1.y);\n  var p = p_in;\n  p.x = abs(p.x);\n  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;\n  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y = p.y - r;\n  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);\n  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  // Note: WebGPU doesn't have gl_PointCoord directly\n  // Points in WebGPU require rendering quads instead\n  // This shader needs instanced rendering with quads for proper point rendering\n  // For now, return the color directly\n  return uniforms.color;\n}\n";
+export declare const POINT_QUAD_SHADER_WGSL = "\n// Uniform buffer for transforms, color, point properties\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbol: i32,\n  viewport: vec2<f32>, // viewport dimensions for proper sizing\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,  // point center position\n  @location(1) quadOffset: vec2<f32>, // quad vertex offset (-1 to 1)\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>, // -0.5 to 0.5 for SDF\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  \n  // Transform point position to NDC\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  \n  // Calculate point size in NDC\n  let pointSizeNDC = vec2<f32>(\n    uniforms.pointSize / uniforms.viewport.x * 2.0,\n    uniforms.pointSize / uniforms.viewport.y * 2.0\n  );\n  \n  // Apply quad offset\n  let offset = in.quadOffset * pointSizeNDC * 0.5;\n  \n  out.pos = vec4<f32>(transformed + offset, 0.0, 1.0);\n  out.uv = in.quadOffset * 0.5; // -0.5 to 0.5\n  \n  return out;\n}\n\n// SDF functions\nfn sdCircle(p: vec2<f32>, r: f32) -> f32 {\n  return length(p) - r;\n}\n\nfn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {\n  let d = abs(p) - b;\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>, r: f32) -> f32 {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {\n  let k = sqrt(3.0);\n  var p = p_in;\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) {\n    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  }\n  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let d = abs(p);\n  let s1 = sdBox(d, vec2<f32>(r, thickness));\n  let s2 = sdBox(d, vec2<f32>(thickness, r));\n  return min(s1, s2);\n}\n\nfn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let c = cos(0.785398);\n  let s = sin(0.785398);\n  let m = mat2x2<f32>(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {\n  let k1 = vec2<f32>(0.80901699, -0.58778525);\n  let k2 = vec2<f32>(-k1.x, k1.y);\n  var p = p_in;\n  p.x = abs(p.x);\n  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;\n  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y = p.y - r;\n  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);\n  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  var d: f32 = 0.0;\n  \n  if (uniforms.symbol == 0) {\n    d = sdCircle(in.uv, 0.45);\n  } else if (uniforms.symbol == 1) {\n    d = sdBox(in.uv, vec2<f32>(0.35));\n  } else if (uniforms.symbol == 2) {\n    d = sdDiamond(in.uv, 0.45);\n  } else if (uniforms.symbol == 3) {\n    d = sdTriangle(vec2<f32>(in.uv.x, in.uv.y + 0.1), 0.4);\n  } else if (uniforms.symbol == 4) {\n    d = sdTriangle(vec2<f32>(in.uv.x, -in.uv.y + 0.1), 0.4);\n  } else if (uniforms.symbol == 5) {\n    d = sdCross(in.uv, 0.45, 0.15);\n  } else if (uniforms.symbol == 6) {\n    d = sdX(in.uv, 0.45, 0.15);\n  } else if (uniforms.symbol == 7) {\n    d = sdStar(in.uv, 0.45, 0.4);\n  }\n  \n  if (d > 0.02) {\n    discard;\n  }\n  \n  let alpha = 1.0 - smoothstep(0.0, 0.02, d);\n  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);\n}\n";
+export declare const POINT_VERTEX_STRIDE: number;