scichart 3.1.348 → 3.2.0-beta

package/Charting3D/Visuals/RenderableSeries/PointLineRenderableSeries3D.d.ts

@@ -0,0 +1,64 @@
+import { TSciChart3D } from "../../../types/TSciChart3D";
+import { BaseRenderableSeries3D, IBaseRenderableSeries3DOptions } from "./BaseRenderableSeries3D";
+import { ESeriesType3D } from "./ESeriesType";
+export interface IPointLineRenderableSeries3DOptions extends IBaseRenderableSeries3DOptions {
+    /**
+     * The strokethickness of the 3D line series in world units. Set a strokeThickness of 0 to hide the line
+     */
+    strokeThickness?: number;
+    /**
+     * When true, creates a polyline, else each pair of points in {@link XyzDataSeries3D} will be connected with a line with a break before the next pair. Default true
+     */
+    isLineStrip?: boolean;
+    /**
+     * When true, the line will be anti-aliased. Default true
+     */
+    isAntiAliased?: boolean;
+}
+/**
+ * Defines a 3D poine-line series or 3D line chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript 3D Charts}
+ * @remarks
+ * To add a 3D line series to a {@link SciChart3DSurface} you need to declare both the {@link PointLineRenderableSeries3D}
+ * and a {@link XyzDataSeries3D}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChart3DSurface: SciChart3DSurface;
+ * const wasmContext: TSciChart3D;
+ * // Create and fill the dataseries
+ * const dataSeries = new XyzDataSeries3D(wasmContext);
+ * dataSeries.append(1,2,3);
+ * dataSeries.append(3,4,5);
+ * // Create the renderableSeries
+ * const lineSeries3D = new PointLineRenderableSeries3D(wasmContext);
+ * lineSeries3D.dataSeries = dataSeries;
+ * lineSeries3D.pointMarker = new SpherePointMarker3D(wasmContext, {
+ *     size: 3,
+ *     fill: "#FF0000"
+ * });
+ * // append to the SciChartSurface
+ * sciChart3DSurface.renderableSeries.add(lineSeries3D);
+ * ```
+ */
+export declare class PointLineRenderableSeries3D extends BaseRenderableSeries3D {
+    /**
+     * @inheritDoc
+     */
+    readonly type: ESeriesType3D;
+    private strokeThicknessProperty;
+    private isLineStripProperty;
+    private isAntiAliasedProperty;
+    /**
+     * Creates an instance of a {@link PointLineRenderableSeries3D}
+     * @param webAssemblyContext The {@link TSciChart3D | SciChart 3D WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options Optional parameters of type {@link IBaseRenderableSeries3DOptions} to configure the series
+     */
+    constructor(webAssemblyContext: TSciChart3D, options?: IPointLineRenderableSeries3DOptions);
+    get strokeThickness(): number;
+    set strokeThickness(value: number);
+    get isLineStrip(): boolean;
+    set isLineStrip(value: boolean);
+    get isAntiAliased(): boolean;
+    set isAntiAliased(value: boolean);
+}

package/Charting3D/Visuals/RenderableSeries/PointLineRenderableSeries3D.js

@@ -0,0 +1,105 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointLineRenderableSeries3D = void 0;
+var PointLine3DSceneEntity_1 = require("../Primitives/PointLine3DSceneEntity");
+var BaseRenderableSeries3D_1 = require("./BaseRenderableSeries3D");
+var Constants_1 = require("./Constants");
+var ESeriesType_1 = require("./ESeriesType");
+/**
+ * Defines a 3D poine-line series or 3D line chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript 3D Charts}
+ * @remarks
+ * To add a 3D line series to a {@link SciChart3DSurface} you need to declare both the {@link PointLineRenderableSeries3D}
+ * and a {@link XyzDataSeries3D}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChart3DSurface: SciChart3DSurface;
+ * const wasmContext: TSciChart3D;
+ * // Create and fill the dataseries
+ * const dataSeries = new XyzDataSeries3D(wasmContext);
+ * dataSeries.append(1,2,3);
+ * dataSeries.append(3,4,5);
+ * // Create the renderableSeries
+ * const lineSeries3D = new PointLineRenderableSeries3D(wasmContext);
+ * lineSeries3D.dataSeries = dataSeries;
+ * lineSeries3D.pointMarker = new SpherePointMarker3D(wasmContext, {
+ *     size: 3,
+ *     fill: "#FF0000"
+ * });
+ * // append to the SciChartSurface
+ * sciChart3DSurface.renderableSeries.add(lineSeries3D);
+ * ```
+ */
+var PointLineRenderableSeries3D = /** @class */ (function (_super) {
+    __extends(PointLineRenderableSeries3D, _super);
+    /**
+     * Creates an instance of a {@link PointLineRenderableSeries3D}
+     * @param webAssemblyContext The {@link TSciChart3D | SciChart 3D WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options Optional parameters of type {@link IBaseRenderableSeries3DOptions} to configure the series
+     */
+    function PointLineRenderableSeries3D(webAssemblyContext, options) {
+        var _this = this;
+        var _a, _b, _c;
+        _this = _super.call(this, webAssemblyContext, options) || this;
+        /**
+         * @inheritDoc
+         */
+        _this.type = ESeriesType_1.ESeriesType3D.PointLineRenderableSeries3D;
+        _this.strokeThicknessProperty = (_a = options === null || options === void 0 ? void 0 : options.strokeThickness) !== null && _a !== void 0 ? _a : 2;
+        _this.isLineStripProperty = (_b = options === null || options === void 0 ? void 0 : options.isLineStrip) !== null && _b !== void 0 ? _b : true;
+        _this.isAntiAliasedProperty = (_c = options === null || options === void 0 ? void 0 : options.isAntiAliased) !== null && _c !== void 0 ? _c : true;
+        _this.setSceneEntity(new PointLine3DSceneEntity_1.PointLine3DSceneEntity(webAssemblyContext, _this));
+        return _this;
+    }
+    Object.defineProperty(PointLineRenderableSeries3D.prototype, "strokeThickness", {
+        get: function () {
+            return this.strokeThicknessProperty;
+        },
+        set: function (value) {
+            this.strokeThicknessProperty = value;
+            this.notifyPropertyChanged(Constants_1.PROPERTY.STROKE_THICKNESS);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PointLineRenderableSeries3D.prototype, "isLineStrip", {
+        get: function () {
+            return this.isLineStripProperty;
+        },
+        set: function (value) {
+            this.isLineStripProperty = value;
+            this.notifyPropertyChanged(Constants_1.PROPERTY.IS_LINE_STRIP);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PointLineRenderableSeries3D.prototype, "isAntiAliased", {
+        get: function () {
+            return this.isAntiAliasedProperty;
+        },
+        set: function (value) {
+            this.isAntiAliasedProperty = value;
+            this.notifyPropertyChanged(Constants_1.PROPERTY.IS_ANTIALIASED);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PointLineRenderableSeries3D;
+}(BaseRenderableSeries3D_1.BaseRenderableSeries3D));
+exports.PointLineRenderableSeries3D = PointLineRenderableSeries3D;

package/Charting3D/Visuals/RenderableSeries/SeriesInfo3D.d.ts

@@ -0,0 +1,51 @@
+import { EDataSeriesType3D } from "../../Model/DataSeries/BaseDataSeries3D";
+import { Vector3 } from "../../Vector3";
+import { IRenderableSeries3D } from "./BaseRenderableSeries3D";
+import { HitTestInfo3D } from "./HitTestInfo3D";
+/**
+ * SeriesInfo3D is a data-structure which provides enriched information about a hit-test operation in SciChart 3D.
+ * It's derived by calling {@link BaseRenderableSeries3D.hitTest}. There is a class hierachy for {@link SeriesInfo3D} which
+ * is a different class depending on series type, e.g. 3D Scatter series has {@link XyzSeriesInfo3D},
+ * 3D Surface mesh series has {@link SurfaceMeshSeriesInfo3D} etc.
+ */
+export declare class SeriesInfo3D {
+    /**
+     * The default empty {@link HitTestInfo3D} instance
+     */
+    static empty(): SeriesInfo3D;
+    /**
+     * When true, the {@link SeriesInfo3D} is empty
+     */
+    isEmpty: boolean;
+    /**
+     * When {@link isHit} is true, this is the X-value of the data-point in the {@link XyzDataSeries3D} that was hit
+     */
+    xValue: number;
+    /**
+     * When {@link isHit} is true, this is the Y-value of the data-point in the {@link XyzDataSeries3D} that was hit
+     */
+    yValue: number;
+    /**
+     * When {@link isHit} is true, this is the Z-value of the data-point in the {@link XyzDataSeries3D} that was hit
+     */
+    zValue: number;
+    /**
+     * When {@link isHit} is true, this is the {@link Vector3} 3D World Coordinates of the data-point that was hit
+     */
+    hitWorldCoords: Vector3;
+    /**
+     * The name of the associated {@link BaseDataSeries3D | DataSeries}
+     */
+    dataSeriesName: string;
+    dataSeriesType: EDataSeriesType3D;
+    /**
+     * The associated {@link IRenderableSeries3D | RenderableSeries}
+     */
+    renderableSeries: IRenderableSeries3D;
+    /**
+     * When true, the result of the hit-test operation is hit (mouse over data-point)
+     */
+    isHit: boolean;
+    protected hitTestInfo: HitTestInfo3D;
+    constructor(series: IRenderableSeries3D, hitTestInfo: HitTestInfo3D);
+}

package/Charting3D/Visuals/RenderableSeries/SeriesInfo3D.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriesInfo3D = void 0;
+/**
+ * SeriesInfo3D is a data-structure which provides enriched information about a hit-test operation in SciChart 3D.
+ * It's derived by calling {@link BaseRenderableSeries3D.hitTest}. There is a class hierachy for {@link SeriesInfo3D} which
+ * is a different class depending on series type, e.g. 3D Scatter series has {@link XyzSeriesInfo3D},
+ * 3D Surface mesh series has {@link SurfaceMeshSeriesInfo3D} etc.
+ */
+var SeriesInfo3D = /** @class */ (function () {
+    function SeriesInfo3D(series, hitTestInfo) {
+        var _a;
+        /**
+         * When true, the {@link SeriesInfo3D} is empty
+         */
+        this.isEmpty = false;
+        this.renderableSeries = series;
+        this.dataSeriesName = (_a = series === null || series === void 0 ? void 0 : series.dataSeries) === null || _a === void 0 ? void 0 : _a.dataSeriesName;
+        this.isHit = hitTestInfo.isHit;
+        this.hitTestInfo = hitTestInfo;
+    }
+    /**
+     * The default empty {@link HitTestInfo3D} instance
+     */
+    SeriesInfo3D.empty = function () {
+        var si = new SeriesInfo3D(undefined, undefined);
+        si.isEmpty = true;
+        return si;
+    };
+    return SeriesInfo3D;
+}());
+exports.SeriesInfo3D = SeriesInfo3D;

package/Charting3D/Visuals/RenderableSeries/SurfaceMeshSeriesInfo3D.d.ts

@@ -0,0 +1,15 @@
+import { IRenderableSeries3D } from "./BaseRenderableSeries3D";
+import { HitTestInfo3D } from "./HitTestInfo3D";
+import { SeriesInfo3D } from "./SeriesInfo3D";
+export declare class SurfaceMeshSeriesInfo3D extends SeriesInfo3D {
+    /**
+     * When {@link isHit} is true, this is the index to the Z-cell in the {@link UniformGridDataSeries3D} that was hit
+     */
+    zIndex: number;
+    /**
+     * When {@link isHit} is true, this is the index to the X-cell in the {@link UniformGridDataSeries3D} that was hit
+     */
+    xIndex: number;
+    constructor(series: IRenderableSeries3D, hitTestInfo: HitTestInfo3D);
+    private enrichSeriesInfo;
+}

package/Charting3D/Visuals/RenderableSeries/SurfaceMeshSeriesInfo3D.js

@@ -0,0 +1,112 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SurfaceMeshSeriesInfo3D = void 0;
+var pointUtil_1 = require("../../../utils/pointUtil");
+var BaseDataSeries3D_1 = require("../../Model/DataSeries/BaseDataSeries3D");
+var Vector3_1 = require("../../Vector3");
+var SeriesInfo3D_1 = require("./SeriesInfo3D");
+var SurfaceMeshSeriesInfo3D = /** @class */ (function (_super) {
+    __extends(SurfaceMeshSeriesInfo3D, _super);
+    function SurfaceMeshSeriesInfo3D(series, hitTestInfo) {
+        var _this = _super.call(this, series, hitTestInfo) || this;
+        _this.dataSeriesType = BaseDataSeries3D_1.EDataSeriesType3D.UniformGrid3D;
+        _this.enrichSeriesInfo();
+        return _this;
+    }
+    SurfaceMeshSeriesInfo3D.prototype.enrichSeriesInfo = function () {
+        // We know the cell that was hit. We need to get the four corners of the cell in
+        // data space. Then convert to world space. Then convert to screen space
+        // Using this, figure out which corner the pointer was closest to and report that
+        // as the hit-test value
+        if (!this.isHit || !this.renderableSeries) {
+            // console.log(`not a hit apparently`);
+            return;
+        }
+        var ds = this.renderableSeries.dataSeries;
+        if (!ds)
+            return;
+        // Get the x0z0 index of the cell that was hit
+        var x0z0 = { x: this.hitTestInfo.selectionIjIndices.x, z: this.hitTestInfo.selectionIjIndices.y };
+        // Convert x0z0 and four corners of quad-hit to data-values
+        // nomenclature: d (data values at), x0 (x index + 0), z0 (z index + 0)
+        var dx0z0 = { x: ds.getX(x0z0.x), y: ds.getYValue(x0z0.z, x0z0.x), z: ds.getZ(x0z0.z) };
+        var dx1z0 = { x: ds.getX(x0z0.x + 1), y: ds.getYValue(x0z0.z, x0z0.x + 1), z: ds.getZ(x0z0.z) };
+        var dx0z1 = { x: ds.getX(x0z0.x), y: ds.getYValue(x0z0.z + 1, x0z0.x), z: ds.getZ(x0z0.z + 1) };
+        var dx1z1 = { x: ds.getX(x0z0.x + 1), y: ds.getYValue(x0z0.z + 1, x0z0.x + 1), z: ds.getZ(x0z0.z + 1) };
+        var scs = this.renderableSeries.parentSurface;
+        if (!scs || !scs.xAxis || !scs.yAxis || !scs.zAxis)
+            return;
+        var xCalc = scs.xAxis.getCurrentCoordinateCalculator();
+        var yCalc = scs.yAxis.getCurrentCoordinateCalculator();
+        var zCalc = scs.zAxis.getCurrentCoordinateCalculator();
+        // convert data-values to world coordinates
+        // nomenclature: w (world coord at), x0 (x index + 0), y, z0 (z index + 0)
+        var wx0z0 = new Vector3_1.Vector3(xCalc.getCoordinate(dx0z0.x), yCalc.getCoordinate(dx0z0.y), zCalc.getCoordinate(dx0z0.z));
+        var wx1z0 = new Vector3_1.Vector3(xCalc.getCoordinate(dx1z0.x), yCalc.getCoordinate(dx1z0.y), zCalc.getCoordinate(dx1z0.z));
+        var wx0z1 = new Vector3_1.Vector3(xCalc.getCoordinate(dx0z1.x), yCalc.getCoordinate(dx0z1.y), zCalc.getCoordinate(dx0z1.z));
+        var wx1z1 = new Vector3_1.Vector3(xCalc.getCoordinate(dx1z1.x), yCalc.getCoordinate(dx1z1.y), zCalc.getCoordinate(dx1z1.z));
+        // Transform all to screen space
+        // nomenclature: s (screenspace 2d coordinate) for data at x0 (x index + 0), z0 (z index + 0)
+        var sx0z0 = scs.worldToScreenCoord(wx0z0);
+        var sx1z0 = scs.worldToScreenCoord(wx1z0);
+        var sx0z1 = scs.worldToScreenCoord(wx0z1);
+        var sx1z1 = scs.worldToScreenCoord(wx1z1);
+        // calculate euclidean distance from hit-test point to each corner in screen space
+        var x0z0distance = (0, pointUtil_1.calcDistance)(sx0z0.x, sx0z0.y, this.hitTestInfo.hitTestPoint.x, this.hitTestInfo.hitTestPoint.y);
+        var x1z0distance = (0, pointUtil_1.calcDistance)(sx1z0.x, sx1z0.y, this.hitTestInfo.hitTestPoint.x, this.hitTestInfo.hitTestPoint.y);
+        var x0z1distance = (0, pointUtil_1.calcDistance)(sx0z1.x, sx0z1.y, this.hitTestInfo.hitTestPoint.x, this.hitTestInfo.hitTestPoint.y);
+        var x1z1distance = (0, pointUtil_1.calcDistance)(sx1z1.x, sx1z1.y, this.hitTestInfo.hitTestPoint.x, this.hitTestInfo.hitTestPoint.y);
+        var xOffset = scs.worldDimensions.x * 0.5;
+        var zOffset = scs.worldDimensions.z * 0.5;
+        var minDistance = Math.min(x0z0distance, x1z0distance, x0z1distance, x1z1distance);
+        if (minDistance === x0z0distance) {
+            this.xIndex = x0z0.x;
+            this.zIndex = x0z0.z;
+            this.xValue = dx0z0.x;
+            this.yValue = dx0z0.y;
+            this.zValue = dx0z0.z;
+            this.hitWorldCoords = new Vector3_1.Vector3(wx0z0.x - xOffset, wx0z0.y, wx0z0.z - zOffset);
+        }
+        if (minDistance === x0z1distance) {
+            this.xIndex = x0z0.x;
+            this.zIndex = x0z0.z + 1;
+            this.xValue = dx0z1.x;
+            this.yValue = dx0z1.y;
+            this.zValue = dx0z1.z;
+            this.hitWorldCoords = new Vector3_1.Vector3(wx0z1.x - xOffset, wx0z1.y, wx0z1.z - zOffset);
+        }
+        if (minDistance === x1z0distance) {
+            this.xIndex = x0z0.x + 1;
+            this.zIndex = x0z0.z;
+            this.xValue = dx1z0.x;
+            this.yValue = dx1z0.y;
+            this.zValue = dx1z0.z;
+            this.hitWorldCoords = new Vector3_1.Vector3(wx1z0.x - xOffset, wx1z0.y, wx1z0.z - zOffset);
+        }
+        if (minDistance === x1z1distance) {
+            this.xIndex = x0z0.x + 1;
+            this.zIndex = x0z0.z + 1;
+            this.xValue = dx1z1.x;
+            this.yValue = dx1z1.y;
+            this.zValue = dx1z1.z;
+            this.hitWorldCoords = new Vector3_1.Vector3(wx1z1.x - xOffset, wx1z1.y, wx1z1.z - zOffset);
+        }
+    };
+    return SurfaceMeshSeriesInfo3D;
+}(SeriesInfo3D_1.SeriesInfo3D));
+exports.SurfaceMeshSeriesInfo3D = SurfaceMeshSeriesInfo3D;

package/Charting3D/Visuals/RenderableSeries/XyzSeriesInfo3D.d.ts

@@ -0,0 +1,20 @@
+import { IPointMetadata3D } from "../../Model/DataSeries/IPointMetadata3D";
+import { IRenderableSeries3D } from "./BaseRenderableSeries3D";
+import { HitTestInfo3D } from "./HitTestInfo3D";
+import { SeriesInfo3D } from "./SeriesInfo3D";
+/**
+ * XyzSeriesInfo3D is a data-structure which provides enriched information about a hit-test operation on an XYZ series in SciChart 3D.
+ * It's derived by calling {@link BaseRenderableSeries3D.hitTest}.
+ */
+export declare class XyzSeriesInfo3D extends SeriesInfo3D {
+    /**
+     * When {@link isHit} is true, this is the index of the data-point in the {@link XyzDataSeries3D} that was hit
+     */
+    dataSeriesIndex: number;
+    /**
+     * When {@link isHit} is true, this metadata on the data-point in the {@link XyzDataSeries3D} that was hit
+     */
+    pointMetadata: IPointMetadata3D;
+    constructor(series: IRenderableSeries3D, hitTestInfo: HitTestInfo3D);
+    private enrichSeriesInfo;
+}

package/Charting3D/Visuals/RenderableSeries/XyzSeriesInfo3D.js

@@ -0,0 +1,60 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XyzSeriesInfo3D = void 0;
+var BaseDataSeries3D_1 = require("../../Model/DataSeries/BaseDataSeries3D");
+var Vector3_1 = require("../../Vector3");
+var SeriesInfo3D_1 = require("./SeriesInfo3D");
+/**
+ * XyzSeriesInfo3D is a data-structure which provides enriched information about a hit-test operation on an XYZ series in SciChart 3D.
+ * It's derived by calling {@link BaseRenderableSeries3D.hitTest}.
+ */
+var XyzSeriesInfo3D = /** @class */ (function (_super) {
+    __extends(XyzSeriesInfo3D, _super);
+    function XyzSeriesInfo3D(series, hitTestInfo) {
+        var _this = _super.call(this, series, hitTestInfo) || this;
+        _this.dataSeriesType = BaseDataSeries3D_1.EDataSeriesType3D.Xyz3D;
+        _this.enrichSeriesInfo();
+        return _this;
+    }
+    XyzSeriesInfo3D.prototype.enrichSeriesInfo = function () {
+        if (!this.isHit || !this.renderableSeries)
+            return;
+        this.dataSeriesIndex = this.hitTestInfo.selectionIndex - 1;
+        var xyzDataSeries = this.renderableSeries.dataSeries;
+        if (xyzDataSeries) {
+            this.xValue = xyzDataSeries.getNativeXValues().get(this.dataSeriesIndex);
+            this.yValue = xyzDataSeries.getNativeYValues().get(this.dataSeriesIndex);
+            this.zValue = xyzDataSeries.getNativeZValues().get(this.dataSeriesIndex);
+            var metadatas = xyzDataSeries.getMetadataValues();
+            if (metadatas && metadatas.length > this.dataSeriesIndex) {
+                this.pointMetadata = metadatas[this.dataSeriesIndex];
+            }
+            var scs = this.renderableSeries.parentSurface;
+            if (scs) {
+                var xOffset = scs.worldDimensions.x * 0.5;
+                var zOffset = scs.worldDimensions.z * 0.5;
+                var x = scs.xAxis.getCurrentCoordinateCalculator().getCoordinate(this.xValue) - xOffset;
+                var y = scs.yAxis.getCurrentCoordinateCalculator().getCoordinate(this.yValue);
+                var z = scs.zAxis.getCurrentCoordinateCalculator().getCoordinate(this.zValue) - zOffset;
+                this.hitWorldCoords = new Vector3_1.Vector3(x, y, z);
+            }
+        }
+    };
+    return XyzSeriesInfo3D;
+}(SeriesInfo3D_1.SeriesInfo3D));
+exports.XyzSeriesInfo3D = XyzSeriesInfo3D;

package/Charting3D/Visuals/RootSceneEntity.d.ts

@@ -26,10 +26,6 @@ export declare class RootSceneEntity extends BaseSceneEntity3D<SCRTSceneEntity>
      * access to our WebGL2 Engine and WebAssembly numerical methods
      */
     constructor(webAssemblyContext: TSciChart3D, parentSurface: SciChart3DSurface);
-    /**
-     * @inheritDoc
-     */
-    delete(): void;
     /**
      * @inheritDoc
      */

package/Charting3D/Visuals/RootSceneEntity.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RootSceneEntity = void 0;
 var SceneEntityType_1 = require("../../types/SceneEntityType");
 var BaseSceneEntity3D_1 = require("./Primitives/BaseSceneEntity3D");
+var EntityIdProvider_1 = require("./Primitives/EntityIdProvider");
 var Guard_1 = require("../../Core/Guard");
 /**
  * @summary Defines a special {@link BaseSceneEntity3D} type which is the root of the entire scene in
@@ -43,24 +44,18 @@ var RootSceneEntity = /** @class */ (function (_super) {
         _this.type = SceneEntityType_1.ESceneEntityType.RootSceneEntity;
         Guard_1.Guard.notNull(parentSurface, "parentSurface");
         _this.parentSurface = parentSurface;
+        _this.entityIdProvider = new EntityIdProvider_1.DefaultEntityIdProvider();
         return _this;
     }
-    /**
-     * @inheritDoc
-     */
-    RootSceneEntity.prototype.delete = function () {
-        _super.prototype.delete.call(this);
-    };
     /**
      * @inheritDoc
      */
     RootSceneEntity.prototype.attachChild = function (childEntity) {
-        // TODO: entity.EntityIdProvider = this.EntityIdProvider;
-        // console.log("Adding child entity to the root!");
         var parentEntity = this;
         if (childEntity === null || childEntity === void 0 ? void 0 : childEntity.nativeEntity) {
             this.world.AddEntity(childEntity.nativeEntity);
         }
+        childEntity.entityIdProvider = this.entityIdProvider;
         childEntity.parent = parentEntity;
         childEntity.onAttached();
     };

package/Charting3D/Visuals/SciChart3DRenderer.d.ts

@@ -25,12 +25,14 @@ export declare class SciChart3DRenderer {
     static tryPerformAutoRangeOn(axis: AxisBase3D, scs: SciChart3DSurface): void;
     private readonly scs;
     private wasmContext;
+    private prevRect;
     private previousTime;
     constructor(scs: SciChart3DSurface, wasmContext: TSciChart3D);
     /**
      * The main render loop
      */
     render(): void;
+    private updateSvgCanvasSize;
     private updateWatermark;
     private isSurfaceValid;
     private prepareAxes;

package/Charting3D/Visuals/SciChart3DRenderer.js

@@ -1,8 +1,20 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SciChart3DRenderer = void 0;
+var IAnnotation_1 = require("../../Charting/Visuals/Annotations/IAnnotation");
+var DpiHelper_1 = require("../../Charting/Visuals/TextureManager/DpiHelper");
 var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
+var Rect_1 = require("../../Core/Rect");
 var AutoRange_1 = require("../../types/AutoRange");
 var WatermarkPosition_1 = require("../../types/WatermarkPosition");
 var AxisCubeDescriptor_1 = require("./Primitives/AxisCubeDescriptor");
@@ -83,6 +95,10 @@ var SciChart3DRenderer = /** @class */ (function () {
         var tsrCamera = sceneWorld.GetMainCamera();
         var typescriptCamera = this.scs.camera;
         typescriptCamera.updateEngineCamera(tsrCamera);
+        var _a = this.scs.viewportManager, width = _a.width, height = _a.height;
+        var viewRect = new Rect_1.Rect(0, 0, width, height);
+        this.scs.setSeriesViewRect(viewRect);
+        this.updateSvgCanvasSize(viewRect);
         // Animation Step
         var timeElapsed = this.previousTime ? Date.now() - this.previousTime : undefined;
         this.previousTime = Date.now();
@@ -96,6 +112,15 @@ var SciChart3DRenderer = /** @class */ (function () {
         // Step 5: Prepare the Axis Cube
         // Viewport3D already checked to be not null in IsSurfaceValid
         this.scs.rootEntity.visitEntities(function (e) { return e.setRenderPassData(rpd); });
+        var userAnnotations = this.scs.annotations.asArray();
+        var modifierAnnotations = this.scs.modifierAnnotations.asArray();
+        var annotations = __spreadArray(__spreadArray([], userAnnotations, true), modifierAnnotations, true);
+        var svgAnnotations = annotations.filter(function (el) {
+            return el.type === IAnnotation_1.EAnnotationType.SVG ||
+                el.type === IAnnotation_1.EAnnotationType.SVGTextAnnotation ||
+                el.type === IAnnotation_1.EAnnotationType.SVGCustomAnnotation;
+        });
+        svgAnnotations.forEach(function (svg) { return svg.update(undefined, undefined, 0, 0); });
         // We add the same padding as we have for 2D 6px
         this.updateWatermark();
         // Step 6: Notify that scene is about to be drawn
@@ -105,6 +130,30 @@ var SciChart3DRenderer = /** @class */ (function () {
             setTimeout(this.scs.invalidateElement, 0);
         }
     };
+    SciChart3DRenderer.prototype.updateSvgCanvasSize = function (seriesViewRect) {
+        // Convert seriesViewRect back to device pixels
+        // e.g. at Retina display canvas size may be 400x300 but seriesViewRect size would be 800x600
+        var viewRectInDevicePixels = new Rect_1.Rect(seriesViewRect.x / DpiHelper_1.DpiHelper.PIXEL_RATIO, seriesViewRect.y / DpiHelper_1.DpiHelper.PIXEL_RATIO, seriesViewRect.width / DpiHelper_1.DpiHelper.PIXEL_RATIO, seriesViewRect.height / DpiHelper_1.DpiHelper.PIXEL_RATIO);
+        if (!this.prevRect) {
+            this.prevRect = viewRectInDevicePixels;
+        }
+        else if (Rect_1.Rect.isEqual(this.prevRect, viewRectInDevicePixels)) {
+            return;
+        }
+        var svgRootElement = this.scs.domSvgContainer;
+        if (svgRootElement) {
+            svgRootElement.style.marginLeft = "".concat(viewRectInDevicePixels.x, "px");
+            svgRootElement.style.marginTop = "".concat(viewRectInDevicePixels.y, "px");
+            // Set width, height
+            svgRootElement.setAttribute("width", viewRectInDevicePixels.width.toString());
+            svgRootElement.setAttribute("height", viewRectInDevicePixels.height.toString());
+            // Set display width, height
+            svgRootElement.style.width = viewRectInDevicePixels.width + "px";
+            svgRootElement.style.height = viewRectInDevicePixels.height + "px";
+            // Set scaling so annotations, tooltips etc are in right position after DPI Scaling
+            svgRootElement.currentScale = 1;
+        }
+    };
     SciChart3DRenderer.prototype.updateWatermark = function () {
         var chartHeight = this.scs.getMainCanvas().clientHeight;
         var chartWidth = this.scs.getMainCanvas().clientWidth;