scichart-engine 0.4.2 → 1.0.0

package/dist/core/3d/Area3DRenderer.d.ts

@@ -0,0 +1,117 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+
+export interface AreaSeriesData {
+    /** X coordinates */
+    x: Float32Array;
+    /** Y coordinates (top of area) */
+    y: Float32Array;
+    /** Z coordinates */
+    z: Float32Array;
+    /** Base Y value (bottom of area, default: 0) */
+    baseY?: number;
+    /** Color per vertex (optional, RGB) */
+    colors?: Float32Array;
+    /** Single area color [r, g, b] */
+    color?: [number, number, number];
+}
+export interface Area3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Opacity of areas (default: 0.8) */
+    opacity?: number;
+    /** Enable tooltips (default: true) */
+    enableTooltip?: boolean;
+    tooltip?: Tooltip3DOptions;
+}
+export declare class Area3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private backgroundColor;
+    private showAxes;
+    private opacity;
+    private areas;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: Area3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        seriesIndex: number;
+        pointIndex: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private initBuffers;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set area data (single area or array of areas)
+     */
+    setData(areas: AreaSeriesData | AreaSeriesData[]): void;
+    /**
+     * Add a single area
+     */
+    addArea(area: AreaSeriesData): void;
+    /**
+     * Clear all areas
+     */
+    clearAreas(): void;
+    private buildAreaGeometry;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    getStats(): RenderStats3D;
+    getCamera(): OrbitCamera;
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): Float32Array;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    on(event: string, callback: Renderer3DEventCallback): void;
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/core/3d/Axes3D.d.ts

@@ -0,0 +1,104 @@
+import { Bounds3D, Axis3DConfig } from './types';
+
+/** Axis label info for text overlay rendering */
+export interface AxisLabel3D {
+    text: string;
+    worldPosition: [number, number, number];
+    axis: 'x' | 'y' | 'z' | 'title';
+    color: [number, number, number];
+}
+/** Full axis configuration with defaults applied */
+export interface Axes3DOptions {
+    /** X-axis configuration */
+    xAxis?: Axis3DConfig & {
+        label?: string;
+        tickFormat?: (v: number) => string;
+    };
+    /** Y-axis configuration */
+    yAxis?: Axis3DConfig & {
+        label?: string;
+        tickFormat?: (v: number) => string;
+    };
+    /** Z-axis configuration */
+    zAxis?: Axis3DConfig & {
+        label?: string;
+        tickFormat?: (v: number) => string;
+    };
+    /** Show axis lines */
+    showAxes?: boolean;
+    /** Show wall grids */
+    showWallGrids?: boolean;
+    /** Show floor grid (XZ plane) */
+    showFloorGrid?: boolean;
+    /** Grid line color */
+    gridColor?: [number, number, number];
+    /** Grid line opacity */
+    gridOpacity?: number;
+    /** Wall grid opacity (slightly more transparent) */
+    wallGridOpacity?: number;
+    /** Number of ticks per axis */
+    tickCount?: number;
+    /** Axis line width */
+    lineWidth?: number;
+    /** Box wireframe color */
+    boxColor?: [number, number, number];
+    /** Box wireframe opacity */
+    boxOpacity?: number;
+}
+export declare class Axes3D {
+    private gl;
+    private axisVAO;
+    private axisPositionBuffer;
+    private axisColorBuffer;
+    private gridVAO;
+    private gridPositionBuffer;
+    private gridColorBuffer;
+    private boxVAO;
+    private boxPositionBuffer;
+    private boxColorBuffer;
+    private lineProgram;
+    private lineUniforms;
+    private axisVertexCount;
+    private gridVertexCount;
+    private boxVertexCount;
+    private bounds;
+    private labels;
+    private options;
+    constructor(gl: WebGL2RenderingContext, options?: Axes3DOptions);
+    private initLineShader;
+    private initBuffers;
+    /**
+     * Update axes geometry based on data bounds
+     */
+    updateBounds(bounds: Bounds3D): void;
+    private buildBoxGeometry;
+    private buildGridGeometry;
+    private buildAxisGeometry;
+    private buildLabels;
+    /**
+     * Render axes and grid
+     */
+    render(viewProjectionMatrix: Float32Array): void;
+    private renderLines;
+    /**
+     * Get labels for 2D text overlay rendering.
+     * Returns world positions that need to be projected to screen coordinates.
+     */
+    getLabels(): AxisLabel3D[];
+    /**
+     * Project a 3D world position to 2D screen coordinates.
+     */
+    projectToScreen(worldPos: [number, number, number], viewProjectionMatrix: Float32Array, canvasWidth: number, canvasHeight: number): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    /**
+     * Update options
+     */
+    setOptions(options: Partial<Axes3DOptions>): void;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/core/3d/Bubble3DRenderer.d.ts

@@ -0,0 +1,194 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitController, OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Ray3D, HitResult } from './Raycaster3D';
+import { Bubble3DData, Bubble3DStyle, Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+import { Tooltip3DOptions, Tooltip3DData } from './Tooltip3D';
+
+export interface Bubble3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    style?: Bubble3DStyle;
+    autoRender?: boolean;
+    /** Axes configuration */
+    axes?: Axes3DOptions;
+    /** Show axes (default: true) */
+    showAxes?: boolean;
+    /** Enable tooltips on hover (default: true) */
+    enableTooltip?: boolean;
+    /** Tooltip configuration */
+    tooltip?: Tooltip3DOptions;
+    /** Custom tooltip formatter */
+    tooltipFormatter?: (data: Tooltip3DData) => string;
+}
+export declare class Bubble3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private mesh;
+    private camera;
+    private controller;
+    private axes;
+    private backgroundColor;
+    private style;
+    private showAxes;
+    private instanceData;
+    private bounds;
+    private animationFrameId;
+    private autoRender;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove;
+    private boundHandleMouseLeave;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: Bubble3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    private createGeometry;
+    private handleResize;
+    /**
+     * Resize canvas to match display size.
+     */
+    resize(): void;
+    /**
+     * Set bubble data for rendering.
+     */
+    setData(data: Bubble3DData): void;
+    private calculateBounds;
+    /**
+     * Fit camera to view all data.
+     */
+    fitToData(): void;
+    /**
+     * Render a single frame.
+     */
+    render(): void;
+    /**
+     * Start automatic render loop.
+     */
+    startRenderLoop(): void;
+    /**
+     * Stop automatic render loop.
+     */
+    stopRenderLoop(): void;
+    /**
+     * Request a render on next frame.
+     */
+    requestRender(): void;
+    /**
+     * Get render statistics.
+     */
+    getStats(): RenderStats3D;
+    /**
+     * Get camera instance for direct manipulation.
+     */
+    getCamera(): OrbitCamera;
+    /**
+     * Get controller instance for configuration.
+     */
+    getController(): OrbitController;
+    /**
+     * Update style options.
+     */
+    setStyle(style: Partial<Bubble3DStyle>): void;
+    /**
+     * Set background color.
+     */
+    setBackgroundColor(r: number, g: number, b: number, a?: number): void;
+    /**
+     * Add event listener.
+     */
+    on(event: string, callback: Renderer3DEventCallback): void;
+    /**
+     * Remove event listener.
+     */
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    /**
+     * Get axis labels for 2D text overlay rendering.
+     * Returns labels with world positions that need to be projected to screen.
+     */
+    getAxisLabels(): {
+        text: string;
+        worldPosition: [number, number, number];
+        axis: string;
+        color: [number, number, number];
+    }[];
+    /**
+     * Project world coordinates to screen coordinates.
+     * Useful for positioning 2D overlay text.
+     */
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    /**
+     * Get the current view-projection matrix.
+     */
+    getViewProjectionMatrix(): Float32Array;
+    /**
+     * Get canvas dimensions.
+     */
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get WebGL context info.
+     */
+    getContextInfo(): Record<string, any>;
+    /**
+     * Pick a bubble at screen coordinates.
+     * @param screenX X coordinate relative to canvas
+     * @param screenY Y coordinate relative to canvas
+     * @returns Hit result with bubble index, or null if no hit
+     */
+    pickAtScreen(screenX: number, screenY: number): HitResult | null;
+    /**
+     * Create a ray from screen coordinates.
+     * Useful for custom picking logic.
+     */
+    createRay(screenX: number, screenY: number): Ray3D;
+    /**
+     * Get data for a specific bubble by index.
+     */
+    getBubbleData(index: number): {
+        position: [number, number, number];
+        color: [number, number, number];
+        scale: number;
+    } | null;
+    /**
+     * Export the current view as an image.
+     * @param format Image format ('png' | 'jpeg' | 'webp')
+     * @param quality Quality for jpeg/webp (0-1)
+     * @param transparent Use transparent background (only for 'png')
+     * @returns Data URL of the image
+     */
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    /**
+     * Export the current view as a Blob.
+     * @param format Image format ('png' | 'jpeg' | 'webp')
+     * @param quality Quality for jpeg/webp (0-1)
+     * @returns Promise that resolves to Blob
+     */
+    exportImageBlob(format?: 'png' | 'jpeg' | 'webp', quality?: number): Promise<Blob | null>;
+    /**
+     * Download the current view as an image file.
+     * @param filename Filename without extension
+     * @param format Image format
+     * @param quality Quality for jpeg/webp
+     */
+    downloadImage(filename?: string, format?: 'png' | 'jpeg' | 'webp', quality?: number): void;
+    /**
+     * Clean up all resources.
+     */
+    destroy(): void;
+}

package/dist/core/3d/Impulse3DRenderer.d.ts

@@ -0,0 +1,126 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+
+export interface ImpulseSeriesData {
+    /** X coordinates */
+    x: Float32Array;
+    /** Y coordinates (top of stems) */
+    y: Float32Array;
+    /** Z coordinates */
+    z: Float32Array;
+    /** Base Y value (default: 0) */
+    baseY?: number;
+    /** Color per point (RGB) */
+    colors?: Float32Array;
+    /** Single color for all stems */
+    color?: [number, number, number];
+}
+export interface Impulse3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Stem thickness (default: 0.03) */
+    stemWidth?: number;
+    /** Number of sides for cylinder (default: 6) */
+    stemSides?: number;
+    /** Show marker at top of stem (default: true) */
+    showMarkers?: boolean;
+    /** Marker size multiplier (default: 2) */
+    markerSize?: number;
+    /** Enable tooltips (default: true) */
+    enableTooltip?: boolean;
+    tooltip?: Tooltip3DOptions;
+}
+export declare class Impulse3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private stemVao;
+    private stemPositionBuffer;
+    private stemNormalBuffer;
+    private stemColorBuffer;
+    private stemIndexBuffer;
+    private stemIndexCount;
+    private markerVao;
+    private markerPositionBuffer;
+    private markerNormalBuffer;
+    private markerColorBuffer;
+    private markerIndexBuffer;
+    private markerIndexCount;
+    private backgroundColor;
+    private showAxes;
+    private stemWidth;
+    private stemSides;
+    private showMarkers;
+    private markerSize;
+    private impulseData;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: Impulse3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        index: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private initBuffers;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set impulse data
+     */
+    setData(data: ImpulseSeriesData): void;
+    private buildGeometry;
+    private buildStemGeometry;
+    private buildMarkerGeometry;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    private renderBuffers;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    getStats(): RenderStats3D;
+    getCamera(): OrbitCamera;
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): Float32Array;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    on(event: string, callback: Renderer3DEventCallback): void;
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/core/3d/Line3DRenderer.d.ts

@@ -0,0 +1,118 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+
+export interface Line3DData {
+    /** X coordinates */
+    x: Float32Array;
+    /** Y coordinates */
+    y: Float32Array;
+    /** Z coordinates */
+    z: Float32Array;
+    /** Color per vertex (optional, RGB) */
+    colors?: Float32Array;
+    /** Single line color [r, g, b] (used if colors not provided) */
+    color?: [number, number, number];
+}
+export interface Line3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Line thickness in world units (default: 0.05) */
+    lineWidth?: number;
+    /** Number of segments around the tube (default: 8) */
+    tubeSides?: number;
+    /** Enable tooltips (default: true) */
+    enableTooltip?: boolean;
+    tooltip?: Tooltip3DOptions;
+}
+export declare class Line3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private backgroundColor;
+    private showAxes;
+    private lineWidth;
+    private tubeSides;
+    private lines;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: Line3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        seriesIndex: number;
+        pointIndex: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private initBuffers;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set line data (single line or array of lines)
+     */
+    setData(lines: Line3DData | Line3DData[]): void;
+    /**
+     * Add a single line
+     */
+    addLine(line: Line3DData): void;
+    /**
+     * Clear all lines
+     */
+    clearLines(): void;
+    private buildTubeGeometry;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    getStats(): RenderStats3D;
+    getCamera(): OrbitCamera;
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): Float32Array;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    on(event: string, callback: Renderer3DEventCallback): void;
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}