velo-plot 1.11.1

package/dist/plugins/3d/index.d.ts

@@ -0,0 +1,50 @@
+import { ChartPlugin } from '../types';
+/**
+ * SciPlot Engine - 3D Visualization Plugin
+ *
+ * This plugin provides 3D rendering capabilities including:
+ * - Line3D, Area3D, Bubble3D, Impulse3D renderers
+ * - Surface mesh and waterfall visualizations
+ * - 3D axes with depth perspective
+ * - Camera controls and raycasting
+ *
+ * @module plugins/3d
+ */
+export * from './Area3DRenderer';
+export * from './Bubble3DRenderer';
+export * from './Impulse3DRenderer';
+export * from './Line3DRenderer';
+export * from './PointCloud3DRenderer';
+export * from './Ribbon3DRenderer';
+export * from './SurfaceBar3DRenderer';
+export * from './SurfaceMesh3DRenderer';
+export * from './VectorField3DRenderer';
+export * from './Voxel3DRenderer';
+export * from './Waterfall3DRenderer';
+export * from './Axes3D';
+export * from './Tooltip3D';
+export * from './Raycaster3D';
+export * from './math';
+export * from './camera';
+export * from './controls';
+export * from './colorThemes';
+export * from './series';
+export interface Plugin3DConfig {
+    /** Enable WebGL2 features if available (default: true) */
+    preferWebGL2?: boolean;
+    /** Default camera configuration */
+    camera?: {
+        position?: [number, number, number];
+        target?: [number, number, number];
+        fov?: number;
+    };
+    /** Enable orbit controls (default: true) */
+    enableOrbitControls?: boolean;
+}
+/**
+ * SciPlot 3D Plugin
+ *
+ * Provides interactive 3D charts, surfaces, and meshes.
+ */
+export declare function Plugin3D(config?: Plugin3DConfig): ChartPlugin<Plugin3DConfig>;
+export default Plugin3D;

package/dist/plugins/3d/math/Mat4.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Minimal 4x4 Matrix math for WebGL 3D rendering.
+ * Column-major order (OpenGL/WebGL convention).
+ * No external dependencies.
+ */
+export type Mat4 = Float32Array;
+export type Vec3 = [number, number, number];
+/** Create identity matrix */
+export declare function create(): Mat4;
+/** Set matrix to identity */
+export declare function identity(out: Mat4): Mat4;
+/** Copy matrix a to out */
+export declare function copy(out: Mat4, a: Mat4): Mat4;
+/** Multiply two matrices: out = a * b */
+export declare function multiply(out: Mat4, a: Mat4, b: Mat4): Mat4;
+/** Create perspective projection matrix */
+export declare function perspective(out: Mat4, fovY: number, aspect: number, near: number, far: number): Mat4;
+/** Create view matrix looking at target from eye position */
+export declare function lookAt(out: Mat4, eye: Vec3, center: Vec3, up: Vec3): Mat4;
+/** Translate matrix by vector v */
+export declare function translate(out: Mat4, a: Mat4, v: Vec3): Mat4;
+/** Scale matrix by vector v */
+export declare function scale(out: Mat4, a: Mat4, v: Vec3): Mat4;
+/** Rotate matrix around X axis */
+export declare function rotateX(out: Mat4, a: Mat4, rad: number): Mat4;
+/** Rotate matrix around Y axis */
+export declare function rotateY(out: Mat4, a: Mat4, rad: number): Mat4;
+/** Rotate matrix around Z axis */
+export declare function rotateZ(out: Mat4, a: Mat4, rad: number): Mat4;
+/** Invert matrix */
+export declare function invert(out: Mat4, a: Mat4): Mat4 | null;
+/** Create orthographic projection matrix */
+export declare function ortho(out: Mat4, left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;

package/dist/plugins/3d/math/Vec3.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Minimal Vec3 utilities for 3D math.
+ * No external dependencies.
+ */
+export type Vec3 = [number, number, number];
+/** Create a new Vec3 */
+export declare function create(x?: number, y?: number, z?: number): Vec3;
+/** Clone a Vec3 */
+export declare function clone(a: Vec3): Vec3;
+/** Copy Vec3 a to out */
+export declare function copy(out: Vec3, a: Vec3): Vec3;
+/** Set Vec3 values */
+export declare function set(out: Vec3, x: number, y: number, z: number): Vec3;
+/** Add two Vec3: out = a + b */
+export declare function add(out: Vec3, a: Vec3, b: Vec3): Vec3;
+/** Subtract two Vec3: out = a - b */
+export declare function subtract(out: Vec3, a: Vec3, b: Vec3): Vec3;
+/** Scale Vec3: out = a * scalar */
+export declare function scale(out: Vec3, a: Vec3, s: number): Vec3;
+/** Normalize Vec3 */
+export declare function normalize(out: Vec3, a: Vec3): Vec3;
+/** Dot product of two Vec3 */
+export declare function dot(a: Vec3, b: Vec3): number;
+/** Cross product: out = a × b */
+export declare function cross(out: Vec3, a: Vec3, b: Vec3): Vec3;
+/** Length of Vec3 */
+export declare function length(a: Vec3): number;
+/** Squared length of Vec3 */
+export declare function squaredLength(a: Vec3): number;
+/** Distance between two Vec3 */
+export declare function distance(a: Vec3, b: Vec3): number;
+/** Linear interpolation: out = a + t * (b - a) */
+export declare function lerp(out: Vec3, a: Vec3, b: Vec3, t: number): Vec3;
+/** Negate Vec3: out = -a */
+export declare function negate(out: Vec3, a: Vec3): Vec3;
+/** Transform Vec3 by Mat4 (assumes w=1) */
+export declare function transformMat4(out: Vec3, a: Vec3, m: Float32Array): Vec3;

package/dist/plugins/3d/math/index.d.ts

@@ -0,0 +1,4 @@
+export * as Mat4 from './Mat4';
+export * as Vec3 from './Vec3';
+export type { Mat4 as Mat4Type } from './Mat4';
+export type { Vec3 as Vec3Type } from './Vec3';

package/dist/plugins/3d/mesh/InstancedMesh.d.ts

@@ -0,0 +1,42 @@
+import { GeometryData } from './geometry';
+import { ShaderProgram3D } from '../shader/programs';
+
+export interface InstanceData {
+    positions: Float32Array;
+    scales: Float32Array;
+    colors: Float32Array;
+}
+export interface InstancedMeshOptions {
+    geometry: GeometryData;
+    maxInstances?: number;
+}
+export declare class InstancedMesh {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private indexBuffer;
+    private instancePosBuffer;
+    private instanceScaleBuffer;
+    private instanceColorBuffer;
+    private geometry;
+    private maxInstances;
+    private instanceCount;
+    constructor(gl: WebGL2RenderingContext, options: InstancedMeshOptions);
+    private initBuffers;
+    /**
+     * Update instance data. Call before render.
+     */
+    updateInstances(data: InstanceData): void;
+    /**
+     * Render all instances with given shader program.
+     */
+    render(program: ShaderProgram3D): void;
+    /**
+     * Get current instance count.
+     */
+    getInstanceCount(): number;
+    /**
+     * Clean up WebGL resources.
+     */
+    destroy(): void;
+}

package/dist/plugins/3d/mesh/geometry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Procedural geometry generation for 3D primitives.
+ * Generates vertex positions and indices for instanced rendering.
+ */
+export interface GeometryData {
+    positions: Float32Array;
+    indices: Uint16Array;
+    vertexCount: number;
+    indexCount: number;
+}
+/**
+ * Generate icosphere geometry (subdivided icosahedron).
+ * Good for spherical bubbles with uniform vertex distribution.
+ */
+export declare function createIcosphere(subdivisions?: number): GeometryData;
+/**
+ * Generate UV sphere geometry.
+ * Good for textured spheres, less uniform distribution.
+ */
+export declare function createUVSphere(segments?: number, rings?: number): GeometryData;
+/**
+ * Generate low-poly cube geometry.
+ * Fastest option, good for distant/small bubbles.
+ */
+export declare function createCube(): GeometryData;
+/**
+ * Generate billboard quad (always faces camera).
+ * Most efficient for large numbers of small points.
+ */
+export declare function createBillboardQuad(): GeometryData;
+/**
+ * Generate a standard AABB cube for voxels.
+ */
+export declare function createVoxelCube(): GeometryData;

package/dist/plugins/3d/mesh/index.d.ts

@@ -0,0 +1,2 @@
+export * from './geometry';
+export * from './InstancedMesh';

package/dist/plugins/3d/series/Area3D.d.ts

@@ -0,0 +1,17 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Area3DData } from './types';
+
+export declare class Area3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private fillOpacity;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Area3DData): void;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Column3D.d.ts

@@ -0,0 +1,20 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Column3DData } from './types';
+
+export declare class Column3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private columnCount;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Column3DData): void;
+    private generateBoxVertices;
+    private setQuad;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Heatmap3D.d.ts

@@ -0,0 +1,17 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Heatmap3DData } from './types';
+
+export declare class Heatmap3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Heatmap3DData): void;
+    private applyColormap;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Impulse3D.d.ts

@@ -0,0 +1,16 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Impulse3DData } from './types';
+
+export declare class Impulse3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private vertexCount;
+    private showMarkers;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Impulse3DData): void;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/PointLine3D.d.ts

@@ -0,0 +1,20 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { PointLine3DData } from './types';
+
+export declare class PointLine3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private pointCount;
+    private showPoints;
+    private showLines;
+    private lineWidth;
+    private pointSize;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: PointLine3DData): void;
+    private generateDefaultColors;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Ribbon3D.d.ts

@@ -0,0 +1,17 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Ribbon3DData } from './types';
+
+export declare class Ribbon3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Ribbon3DData): void;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Scatter3D.d.ts

@@ -0,0 +1,21 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Scatter3DData } from './types';
+
+export declare class Scatter3D {
+    private gl;
+    private vao;
+    private geometryPosBuffer;
+    private geometryIndexBuffer;
+    private instancePosBuffer;
+    private instanceColorBuffer;
+    private instanceSizeBuffer;
+    private geometry;
+    private instanceCount;
+    private symbol;
+    constructor(gl: WebGL2RenderingContext);
+    private initBuffers;
+    updateData(data: Scatter3DData): void;
+    private generateDefaultColors;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/SurfaceMesh3D.d.ts

@@ -0,0 +1,35 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { SurfaceMesh3DData } from './types';
+
+export interface SurfaceMeshOptions {
+    maxVertices?: number;
+}
+export declare class SurfaceMesh3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private wireframeIndexBuffer;
+    private vertexCount;
+    private indexCount;
+    private wireframeIndexCount;
+    private cols;
+    private rows;
+    constructor(gl: WebGL2RenderingContext, _options?: SurfaceMeshOptions);
+    private initBuffers;
+    /**
+     * Update mesh data from surface data.
+     */
+    updateData(data: SurfaceMesh3DData): void;
+    private calculateNormals;
+    private generateHeightColors;
+    private generateTriangleIndices;
+    private generateWireframeIndices;
+    /**
+     * Render the surface mesh.
+     */
+    render(program: ShaderProgram3D, wireframe?: boolean): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/Waterfall3D.d.ts

@@ -0,0 +1,38 @@
+import { ShaderProgram3D } from '../shader/programs';
+import { Waterfall3DData } from './types';
+
+export interface WaterfallOptions {
+    maxSlices?: number;
+}
+export declare class Waterfall3D {
+    private gl;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private vertexCount;
+    private indexCount;
+    private sliceCount;
+    private pointsPerSlice;
+    private fillMode;
+    constructor(gl: WebGL2RenderingContext, _options?: WaterfallOptions);
+    private initBuffers;
+    /**
+     * Update waterfall data.
+     * Each slice is a row of Y values at increasing Z positions.
+     */
+    updateData(data: Waterfall3DData): void;
+    private buildWireframe;
+    private buildSolid;
+    private applyColormap;
+    private viridisColormap;
+    private jetColormap;
+    private hotColormap;
+    /**
+     * Add a new slice to the waterfall (for realtime updates).
+     * Shifts existing slices back and adds new one at front.
+     */
+    pushSlice(yValues: Float32Array, data: Waterfall3DData): void;
+    render(program: ShaderProgram3D): void;
+    destroy(): void;
+}

package/dist/plugins/3d/series/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 3D Series renderers for various chart types.
+ */
+export * from './types';
+export { SurfaceMesh3D } from './SurfaceMesh3D';
+export { PointLine3D } from './PointLine3D';
+export { Column3D } from './Column3D';
+export { Waterfall3D } from './Waterfall3D';
+export { Scatter3D } from './Scatter3D';
+export { Ribbon3D } from './Ribbon3D';
+export { Area3D } from './Area3D';
+export { Heatmap3D } from './Heatmap3D';
+export { Impulse3D } from './Impulse3D';

package/dist/plugins/3d/series/types.d.ts

@@ -0,0 +1,143 @@
+import { Vec3 } from '../math/Mat4';
+
+/** Base interface for all 3D series */
+export interface Series3DBase {
+    id: string;
+    visible: boolean;
+    opacity: number;
+}
+/** 3D Bubble series data */
+export interface Bubble3DSeriesData extends Series3DBase {
+    type: 'bubble';
+    positions: Float32Array;
+    scales?: Float32Array;
+    colors?: Float32Array;
+}
+/** Surface mesh data (grid-based height map) */
+export interface SurfaceMesh3DData extends Series3DBase {
+    type: 'surface';
+    xValues: Float32Array;
+    zValues: Float32Array;
+    yValues: Float32Array;
+    colors?: Float32Array;
+    wireframe?: boolean;
+    colormap?: string;
+}
+/** Point-line 3D data (connected points in 3D space) */
+export interface PointLine3DData extends Series3DBase {
+    type: 'pointline';
+    positions: Float32Array;
+    colors?: Float32Array;
+    lineWidth?: number;
+    pointSize?: number;
+    showPoints?: boolean;
+    showLines?: boolean;
+}
+/** Column/Bar 3D data */
+export interface Column3DData extends Series3DBase {
+    type: 'column';
+    xValues: Float32Array;
+    zValues: Float32Array;
+    yValues: Float32Array;
+    colors?: Float32Array;
+    columnWidth?: number;
+    columnDepth?: number;
+}
+/** Waterfall 3D data (spectral/time series cascading) */
+export interface Waterfall3DData extends Series3DBase {
+    type: 'waterfall';
+    slices: Float32Array[];
+    xValues: Float32Array;
+    zStep: number;
+    zStart?: number;
+    colormap?: string;
+    fillMode?: 'solid' | 'wireframe' | 'gradient';
+    strokeColor?: [number, number, number];
+}
+/** Scatter 3D data (points without connections) */
+export interface Scatter3DData extends Series3DBase {
+    type: 'scatter';
+    positions: Float32Array;
+    colors?: Float32Array;
+    sizes?: Float32Array;
+    symbol?: 'sphere' | 'cube' | 'diamond' | 'point';
+}
+/** Contour 3D data (iso-lines on surface) */
+export interface Contour3DData extends Series3DBase {
+    type: 'contour';
+    xValues: Float32Array;
+    zValues: Float32Array;
+    yValues: Float32Array;
+    levels: number[];
+    colors?: Float32Array;
+    lineWidth?: number;
+}
+/** Ribbon 3D data (extruded line with width) */
+export interface Ribbon3DData extends Series3DBase {
+    type: 'ribbon';
+    positions: Float32Array;
+    widths?: Float32Array;
+    colors?: Float32Array;
+    defaultWidth?: number;
+}
+/** Area 3D data (filled area under line) */
+export interface Area3DData extends Series3DBase {
+    type: 'area';
+    positions: Float32Array;
+    baseY?: number;
+    colors?: Float32Array;
+    fillOpacity?: number;
+}
+/** Heatmap 3D data (colored grid on XZ plane) */
+export interface Heatmap3DData extends Series3DBase {
+    type: 'heatmap';
+    xValues: Float32Array;
+    zValues: Float32Array;
+    values: Float32Array;
+    colormap?: string;
+    minValue?: number;
+    maxValue?: number;
+}
+/** Impulse/Stem 3D data (vertical lines from base) */
+export interface Impulse3DData extends Series3DBase {
+    type: 'impulse';
+    positions: Float32Array;
+    baseY?: number;
+    colors?: Float32Array;
+    lineWidth?: number;
+    showMarkers?: boolean;
+}
+/** Union type for all series data */
+export type Series3DData = Bubble3DSeriesData | SurfaceMesh3DData | PointLine3DData | Column3DData | Waterfall3DData | Scatter3DData | Contour3DData | Ribbon3DData | Area3DData | Heatmap3DData | Impulse3DData;
+/** Series type string literals */
+export type Series3DType = Series3DData['type'];
+/** Colormap definitions */
+export type ColormapName = 'viridis' | 'plasma' | 'inferno' | 'magma' | 'jet' | 'rainbow' | 'grayscale' | 'hot' | 'cool' | 'spring' | 'summer' | 'autumn' | 'winter' | 'ocean' | 'terrain';
+/** Axis 3D configuration */
+export interface Axis3DOptions {
+    label?: string;
+    min?: number;
+    max?: number;
+    autoRange?: boolean;
+    gridLines?: boolean;
+    gridColor?: [number, number, number];
+    tickCount?: number;
+    visible?: boolean;
+}
+/** Scene 3D configuration */
+export interface Scene3DOptions {
+    xAxis?: Axis3DOptions;
+    yAxis?: Axis3DOptions;
+    zAxis?: Axis3DOptions;
+    showAxes?: boolean;
+    showGrid?: boolean;
+    gridPlane?: 'xz' | 'xy' | 'yz' | 'all';
+    backgroundColor?: [number, number, number, number];
+}
+/** Light configuration */
+export interface Light3DOptions {
+    direction?: Vec3;
+    color?: [number, number, number];
+    intensity?: number;
+    ambient?: number;
+}

package/dist/plugins/3d/shader/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sources';
+export * from './programs';

package/dist/plugins/3d/shader/programs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * WebGL shader program compilation and management for 3D rendering.
+ */
+export interface ShaderProgram3D {
+    program: WebGLProgram;
+    attributes: Record<string, number>;
+    uniforms: Record<string, WebGLUniformLocation | null>;
+}
+export interface ProgramBundle3D {
+    bubbleProgram: ShaderProgram3D;
+    bubbleFlatProgram: ShaderProgram3D;
+    axisProgram: ShaderProgram3D;
+    surfaceProgram: ShaderProgram3D;
+    linePointProgram: ShaderProgram3D;
+    waterfallProgram: ShaderProgram3D;
+    vectorFieldProgram: ShaderProgram3D;
+    pointCloudProgram: ShaderProgram3D;
+    voxelProgram: ShaderProgram3D;
+    ribbonProgram: ShaderProgram3D;
+    surfaceBarProgram: ShaderProgram3D;
+}
+export declare function createProgramBundle3D(gl: WebGL2RenderingContext, useWebGL1Fallback?: boolean): ProgramBundle3D;
+export declare function deleteProgram(gl: WebGL2RenderingContext | WebGLRenderingContext, program: ShaderProgram3D): void;
+export declare function deleteProgramBundle(gl: WebGL2RenderingContext | WebGLRenderingContext, bundle: ProgramBundle3D): void;

package/dist/plugins/3d/shader/sources.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GLSL shader sources for 3D instanced rendering.
+ * WebGL2 / GLSL ES 3.00
+ */
+export declare const BUBBLE_VERT = "#version 300 es\nprecision highp float;\n\n// Base geometry vertex\nin vec3 a_position;\n\n// Per-instance attributes\nin vec3 a_instancePos;\nin float a_scale;\nin vec3 a_color;\n\n// Uniforms\nuniform mat4 u_viewProjection;\nuniform float u_opacity;\n\n// Varyings\nout vec3 v_color;\nout vec3 v_normal;\nout vec3 v_worldPos;\n\nvoid main() {\n  // Scale and translate instance\n  vec3 worldPos = (a_position * a_scale) + a_instancePos;\n  \n  gl_Position = u_viewProjection * vec4(worldPos, 1.0);\n  \n  v_color = a_color;\n  v_normal = normalize(a_position); // For sphere, normal = normalized position\n  v_worldPos = worldPos;\n}\n";
+export declare const BUBBLE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\nin vec3 v_worldPos;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\nvoid main() {\n  // Simple diffuse lighting\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  \n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  \n  vec3 color = v_color * lighting;\n  fragColor = vec4(color, u_opacity);\n}\n";
+export declare const BUBBLE_FLAT_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\nin vec3 v_worldPos;\n\nuniform float u_opacity;\n\nout vec4 fragColor;\n\nvoid main() {\n  fragColor = vec4(v_color, u_opacity);\n}\n";
+export declare const BUBBLE_VERT_WEBGL1 = "\nprecision highp float;\n\n// Base geometry vertex\nattribute vec3 a_position;\n\n// Per-instance attributes\nattribute vec3 a_instancePos;\nattribute float a_scale;\nattribute vec3 a_color;\n\n// Uniforms\nuniform mat4 u_viewProjection;\nuniform float u_opacity;\n\n// Varyings\nvarying vec3 v_color;\nvarying vec3 v_normal;\nvarying vec3 v_worldPos;\n\nvoid main() {\n  vec3 worldPos = (a_position * a_scale) + a_instancePos;\n  \n  gl_Position = u_viewProjection * vec4(worldPos, 1.0);\n  \n  v_color = a_color;\n  v_normal = normalize(a_position);\n  v_worldPos = worldPos;\n}\n";
+export declare const BUBBLE_FRAG_WEBGL1 = "\nprecision highp float;\n\nvarying vec3 v_color;\nvarying vec3 v_normal;\nvarying vec3 v_worldPos;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  \n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  \n  vec3 color = v_color * lighting;\n  gl_FragColor = vec4(color, u_opacity);\n}\n";
+export declare const AXIS_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_color;\n\nuniform mat4 u_viewProjection;\n\nout vec3 v_color;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  v_color = a_color;\n}\n";
+export declare const AXIS_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nout vec4 fragColor;\n\nvoid main() {\n  fragColor = vec4(v_color, 1.0);\n}\n";
+export declare const SURFACE_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_normal;\nin vec3 a_color;\n\nuniform mat4 u_viewProjection;\n\nout vec3 v_color;\nout vec3 v_normal;\nout vec3 v_worldPos;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  v_color = a_color;\n  v_normal = a_normal;\n  v_worldPos = a_position;\n}\n";
+export declare const SURFACE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\nin vec3 v_worldPos;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  \n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  \n  vec3 color = v_color * lighting;\n  fragColor = vec4(color, u_opacity);\n}\n";
+export declare const LINE_POINT_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_color;\n\nuniform mat4 u_viewProjection;\nuniform float u_pointSize;\n\nout vec3 v_color;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  gl_PointSize = u_pointSize;\n  v_color = a_color;\n}\n";
+export declare const LINE_POINT_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nuniform float u_opacity;\n\nout vec4 fragColor;\n\nvoid main() {\n  fragColor = vec4(v_color, u_opacity);\n}\n";
+export declare const WATERFALL_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_color;\nin vec3 a_normal;\n\nuniform mat4 u_viewProjection;\n\nout vec3 v_color;\nout float v_depth;\nout vec3 v_normal;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  v_color = a_color;\n  v_depth = a_position.z;\n  v_normal = a_normal;\n}\n";
+export declare const WATERFALL_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin float v_depth;\nin vec3 v_normal;\n\nuniform float u_opacity;\nuniform float u_fadeStart;\nuniform float u_fadeEnd;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\nvoid main() {\n  // Lighting\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  \n  // Fade based on depth (Z position)\n  float fade = 1.0;\n  if (u_fadeEnd > u_fadeStart) {\n    fade = 1.0 - smoothstep(u_fadeStart, u_fadeEnd, v_depth);\n  }\n  \n  fragColor = vec4(v_color * lighting, u_opacity * fade);\n}\n";
+export declare const VECTOR_FIELD_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;    // Base geometry (e.g., arrow)\nin vec3 a_instancePos; // Origin of the vector\nin vec3 a_direction;   // Direction vector [dx, dy, dz]\nin vec3 a_color;\nin vec3 a_normal;\n\nuniform mat4 u_viewProjection;\nuniform float u_scaleMultiplier;\n\nout vec3 v_color;\nout vec3 v_normal;\n\nvoid main() {\n  float mag = length(a_direction);\n  vec3 dir = normalize(a_direction);\n  \n  // Construct rotation matrix to align with direction\n  vec3 up = abs(dir.y) < 0.99 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);\n  vec3 right = normalize(cross(up, dir));\n  vec3 actualUp = cross(dir, right);\n  mat3 rotation = mat3(right, actualUp, dir);\n  \n  v_normal = rotation * a_normal;\n  \n  // Scale based on magnitude\n  vec3 scaledPos = a_position * mag * u_scaleMultiplier;\n  \n  // Rotate and translate\n  vec3 worldPos = (rotation * scaledPos) + a_instancePos;\n  \n  gl_Position = u_viewProjection * vec4(worldPos, 1.0);\n  v_color = a_color;\n}\n";
+export declare const VECTOR_FIELD_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\nout vec4 fragColor;\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  fragColor = vec4(v_color * lighting, u_opacity);\n}\n";
+export declare const POINT_CLOUD_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_color;\nin float a_size;\n\nuniform mat4 u_viewProjection;\nuniform float u_globalSize;\n\nout vec3 v_color;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  gl_PointSize = a_size * u_globalSize;\n  v_color = a_color;\n  \n  // Basic depth attenuation (points get smaller with distance)\n  gl_PointSize /= gl_Position.w * 0.5;\n}\n";
+export declare const POINT_CLOUD_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nuniform float u_opacity;\nuniform bool u_circular;\n\nout vec4 fragColor;\n\nvoid main() {\n  if (u_circular) {\n    vec2 dist = gl_PointCoord - vec2(0.5);\n    if (dot(dist, dist) > 0.25) discard;\n  }\n  \n  fragColor = vec4(v_color, u_opacity);\n}\n";
+export declare const VOXEL_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;    // Base cube vertex\nin vec3 a_instancePos; // Voxel center\nin float a_value;      // Voxel intensity [0, 1]\n\nuniform mat4 u_viewProjection;\nuniform float u_voxelSize;\nuniform float u_threshold;\n\nout float v_value;\nout vec3 v_normal;\n\nvoid main() {\n  if (a_value < u_threshold) {\n    // Hide voxel if below threshold\n    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n    return;\n  }\n  \n  vec3 worldPos = (a_position * u_voxelSize) + a_instancePos;\n  gl_Position = u_viewProjection * vec4(worldPos, 1.0);\n  v_value = a_value;\n  v_normal = normalize(a_position);\n}\n";
+export declare const VOXEL_FRAG = "#version 300 es\nprecision highp float;\n\nin float v_value;\nin vec3 v_normal;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\n// Simple heatmap coloring\nvec3 heatmap(float t) {\n    return vec3(t, 1.0 - t, 0.5 + sin(t * 3.14159) * 0.5);\n}\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  \n  // Spectral colormap\n  vec3 color = vec3(v_value, 0.2, 1.0 - v_value);\n  if (v_value > 0.5) color = vec3(1.0, 1.0 - (v_value-0.5)*2.0, 0.0);\n  \n  fragColor = vec4(color * lighting, u_opacity * v_value);\n}\n";
+export declare const RIBBON_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin vec3 a_normal;\nin vec3 a_color;\n\nuniform mat4 u_viewProjection;\n\nout vec3 v_color;\nout vec3 v_normal;\n\nvoid main() {\n  gl_Position = u_viewProjection * vec4(a_position, 1.0);\n  v_color = a_color;\n  v_normal = a_normal;\n}\n";
+export declare const RIBBON_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  fragColor = vec4(v_color * lighting, u_opacity);\n}\n";
+export declare const SURFACE_BAR_VERT = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;    // Base cube vertex [-0.5, 0.5]\nin vec3 a_instancePos; // Column base\nin float a_height;     // Column height\nin vec3 a_color;\n\nuniform mat4 u_viewProjection;\nuniform float u_barWidth;\nuniform float u_barDepth;\n\nout vec3 v_color;\nout vec3 v_normal;\n\nvoid main() {\n  vec3 pos = a_position;\n  pos.x *= u_barWidth;\n  pos.z *= u_barDepth;\n  pos.y = (pos.y + 0.5) * a_height; \n  \n  vec3 worldPos = pos + a_instancePos;\n  gl_Position = u_viewProjection * vec4(worldPos, 1.0);\n  \n  v_color = a_color;\n  // Normals for a cube are essentially the vertex positions normalized if centered at 0\n  // But since we offset Y, we just use the original sign for flat shading or simple lighting\n  v_normal = normalize(a_position);\n}\n";
+export declare const SURFACE_BAR_FRAG = "#version 300 es\nprecision highp float;\n\nin vec3 v_color;\nin vec3 v_normal;\n\nuniform float u_opacity;\nuniform vec3 u_lightDir;\nuniform float u_ambient;\n\nout vec4 fragColor;\n\nvoid main() {\n  vec3 normal = normalize(v_normal);\n  vec3 lightDir = normalize(u_lightDir);\n  float diff = max(dot(normal, lightDir), 0.0);\n  float lighting = u_ambient + (1.0 - u_ambient) * diff;\n  fragColor = vec4(v_color * lighting, u_opacity);\n}\n";