@openglobus/og 0.28.7 → 1.0.0-rc10

package/lib/entity/polyline/PolylineBatchRenderer.d.ts

@@ -0,0 +1,443 @@
+import { Entity } from "../Entity";
+import { Extent } from "../../Extent";
+import { LonLat } from "../../LonLat";
+import { Vec3 } from "../../math/Vec3";
+import type { NumberArray3 } from "../../math/Vec3";
+import type { NumberArray4 } from "../../math/Vec4";
+import { PolylineHandler } from "./PolylineHandler";
+import { Scene } from "../../scene/Scene";
+import type { WebGLBufferExt } from "../../webgl/Handler";
+import type { TypedArray } from "../../utils/shared";
+import { Ellipsoid } from "../../ellipsoid/Ellipsoid";
+import type { HTMLImageElementExt } from "../../utils/ImagesCacheManager";
+import type { Cartesian, SegmentPath3vExt, SegmentPathLonLatExt, SegmentPathColor, SegmentPathLonLat } from "./Polyline";
+declare const F3V = 0;
+declare const FLONLAT = 1;
+declare const FDETECT = 2;
+export interface TexParam {
+    texOffset: number;
+    strokeSize: number;
+    texOffsetSpeed: number;
+}
+type IndexFormatMode = typeof F3V | typeof FLONLAT | typeof FDETECT;
+type LineSourceMode = typeof F3V | typeof FLONLAT;
+type StrokeSource = string | HTMLImageElement | null;
+export interface IPolylineBatchRendererParams {
+    altitude?: number;
+    thickness?: number;
+    opacity?: number;
+    color?: string[];
+    visibility?: boolean;
+    isTextured?: boolean;
+    isClosed?: boolean[];
+    pathColors?: SegmentPathColor[];
+    path3v?: SegmentPath3vExt[];
+    pathLonLat?: SegmentPathLonLatExt[];
+    visibleSpherePosition?: Cartesian;
+    visibleSphereRadius?: number;
+    src?: StrokeSource[];
+    texParams?: Partial<TexParam>[];
+}
+declare class PolylineBatchRenderer {
+    static __counter__: number;
+    protected static _defaultStrokeImage: HTMLImageElementExt | null;
+    /**
+     * Object uniq identifier.
+     * @protected
+     * @type {number}
+     */
+    protected __id: number;
+    altitude: number;
+    /**
+     * Polyline thickness in screen pixels.
+     * @type {number}
+     */
+    protected _thickness: number;
+    protected _opacity: number;
+    /**
+     * Polyline RGBA color.
+     * @protected
+     * @type {Float32Array}
+     */
+    protected _defaultColor: Float32Array | NumberArray4;
+    protected _pickingColor: Float32Array | NumberArray4;
+    /**
+     * Polyline visibility.
+     * @public
+     * @type {boolean}
+     */
+    visibility: boolean;
+    isTextured: boolean;
+    /**
+     * Polyline geometry ring type identification.
+     * @protected
+     * @type {Boolean}
+     */
+    protected _pathClosed: boolean[];
+    /**
+     * Polyline cartesian coordinates.
+     * @public
+     * @type {Array.<Vec3>}
+     */
+    _path3v: SegmentPath3vExt[];
+    protected _pathLengths: number[];
+    /**
+     * Polyline geodetic degrees coordinates.
+     * @private
+     * @type {Array.<LonLat>}
+     */
+    _pathLonLat: SegmentPathLonLatExt[];
+    /**
+     * Polyline geodetic mercator coordinates.
+     * @public
+     * @type {Array.<LonLat>}
+     */
+    _pathLonLatMerc: LonLat[][];
+    protected _pathColors: SegmentPathColor[];
+    protected _segmentOpacity: number[];
+    protected _segmentThickness: number[];
+    protected _segmentTexParams: (TexParam | undefined)[];
+    protected _pathPickingColors: NumberArray3[][];
+    /**
+     * Polyline geodetic extent.
+     * @protected
+     * @type {Extent}
+     */
+    _extent: Extent;
+    protected _verticesHigh: TypedArray | number[];
+    protected _verticesLow: TypedArray | number[];
+    protected _orders: TypedArray | number[];
+    protected _indexes: TypedArray | number[];
+    protected _colors: TypedArray | number[];
+    protected _thicknessArr: TypedArray | number[];
+    protected _pathTexParamArr: TypedArray | number[];
+    protected _pathPhaseArr: TypedArray | number[];
+    protected _boundingSphereArr: TypedArray | number[];
+    protected _texCoordArr: TypedArray | number[];
+    protected _pickingColors: TypedArray | number[];
+    protected _verticesHighBuffer: WebGLBufferExt | null;
+    protected _verticesLowBuffer: WebGLBufferExt | null;
+    protected _ordersBuffer: WebGLBufferExt | null;
+    protected _indexesBuffer: WebGLBufferExt | null;
+    protected _colorsBuffer: WebGLBufferExt | null;
+    protected _texCoordBuffer: WebGLBufferExt | null;
+    protected _thicknessBuffer: WebGLBufferExt | null;
+    protected _pathTexParamBuffer: WebGLBufferExt | null;
+    protected _pathPhaseBuffer: WebGLBufferExt | null;
+    protected _boundingSphereBuffer: WebGLBufferExt | null;
+    protected _pickingColorsBuffer: WebGLBufferExt | null;
+    protected _scene: Scene | null;
+    /**
+     * Entity instance that holds this Polyline.
+     * @public
+     * @type {Entity}
+     */
+    _entity: Entity | null;
+    /**
+     * Handler that stores and renders this Polyline object.
+     * @public
+     * @type {PolylineHandler | null}
+     */
+    _handler: PolylineHandler | null;
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    protected _visibleSphere: Float32Array;
+    protected _visibleSpherePosition: Vec3;
+    __doubleToTwoFloats: (pos: Vec3, highPos: Vec3, lowPos: Vec3) => void;
+    protected _src: StrokeSource[];
+    protected _image: ((HTMLImageElement & {
+        __nodeIndex?: number;
+    }) | null)[];
+    protected _defaultTexParam: TexParam;
+    constructor(handler: PolylineHandler, options?: IPolylineBatchRendererParams);
+    protected _normalizePathClosedInput(isClosed?: boolean[]): boolean[];
+    protected _normalizePathColorInput(color?: string[]): SegmentPathColor[];
+    protected _getDefaultStrokeSource(): StrokeSource;
+    protected _syncPathClosedLength(segCount: number): void;
+    protected _syncSrcLength(segCount: number): void;
+    protected _isSegmentClosed(segmentIndex: number): boolean;
+    protected _hasTexture(segmentIndex: number): boolean;
+    protected _hasAnyTextureSegments(): boolean;
+    setImage(image: HTMLImageElement): void;
+    getImage(): (HTMLImageElementExt | null)[];
+    protected _setSrcPerSegment(src: StrokeSource[], segCount: number, scene: Scene, textureAtlas: any): void;
+    protected _setSrcDisabled(segCount: number, scene: Scene): void;
+    protected _setTextureEnabled(segCount: number): void;
+    /**
+     * Sets stroke source per segment (null = color-only).
+     * @public
+     */
+    setSrc(src: StrokeSource[]): void;
+    /**
+     * Sets stroke source (string or `Image`) for a segment index.
+     * @public
+     */
+    setPathSrc(src: StrokeSource, segmentIndex?: number): void;
+    /**
+     * Sets closed/open state for one path segment.
+     * @public
+     */
+    setPathClosed(isClosed: boolean, segmentIndex?: number): void;
+    getSrc(): StrokeSource[];
+    _setTexCoordArr(tCoordArrs: (number[] | null)[]): void;
+    setTextureDisabled(): void;
+    /** Get atlas tex coords for segment (null = color-only) */
+    protected _getAtlasTexCoordsForSegment(segIndex: number): number[] | null;
+    protected _pushQuadVertices(position: Vec3, vHigh: Vec3, vLow: Vec3, outVerticesHigh: number[], outVerticesLow: number[]): void;
+    protected _resolveSegmentThickness(segIndex: number): number;
+    protected _resolveSegmentTexParams(segIndex: number): TexParam;
+    protected _recalculateExtentFromLonLatPaths(): void;
+    protected _normalizeSegmentPathColors(segmentLength: number, segColorsInput: SegmentPathColor | NumberArray4): SegmentPathColor;
+    protected _getSegmentAttrGroupStart(segmentIndex: number): number;
+    protected _getSegmentAttrGroupCount(segmentIndex: number): number;
+    protected _setPhaseQuad(groupIndex: number, phase: number, arr?: TypedArray | number[]): void;
+    protected _setBoundingSphereQuad(groupIndex: number, sphere: NumberArray4, arr?: TypedArray | number[]): void;
+    protected _getTotalAttrGroupCount(): number;
+    protected _cloneMetricArray(source: TypedArray | number[] | undefined, requiredLength: number): number[];
+    protected _rebuildPathPhaseArr(): void;
+    protected _calculateSegmentTextureScaleSphere(path: Vec3[], segmentIndex: number): NumberArray4;
+    protected _rebuildBoundingSphereArr(): void;
+    protected _updatePathPhaseSegment(segmentIndex: number): number;
+    protected _shiftPathPhaseTailAfterSegment(segmentIndex: number, phaseDelta: number): void;
+    protected _updateBoundingSphereSegment(segmentIndex: number): void;
+    protected _updateTextureMetrics(segmentIndex: number): void;
+    protected _updateAllTextureMetrics(): void;
+    protected _updateTextureMetricsAfterPointChange(segmentIndex: number): void;
+    protected _markGeometryBuffersChanged(includeTexCoords: boolean): void;
+    protected _applyForceEqualSegmentUpdate<TSegment extends any[]>(segmentPath: TSegment, segmentIndex: number, pathColors: SegmentPathColor | NumberArray4 | undefined, currentPaths: TSegment[], equalUpdate: (segmentPath: TSegment, segmentIndex: number, pathColors?: SegmentPathColor | NumberArray4) => void, recreateData: (nextPaths: TSegment[]) => void, includeTexCoords: boolean): boolean;
+    protected __appendLineDataCore(pathInput: SegmentPath3vExt[] | SegmentPathLonLatExt[], pathColors: SegmentPathColor[], pathPickingColors: NumberArray3[][], defaultColor: NumberArray4, opacity: number[], pathClosed: boolean[], outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], outTexCoords: number[], ellipsoid: Ellipsoid | null, outPath3v: SegmentPath3vExt[], outPathLonLat: SegmentPathLonLatExt[], outPathMerc: LonLat[][], outExtent: Extent, outColors: number[], outThickness: number[], outTexParams: number[], outBoundingSpheres: number[], outPickingColors: number[], sourceType: LineSourceMode, segmentOffset?: number, indexFormat?: IndexFormatMode, skipTexCoords?: boolean, resetExtent?: boolean): void;
+    /**
+     * Appends to the line array new cartesian coordinates line data.
+     */
+    protected __appendLineData3v(path3v: SegmentPath3vExt[], pathColors: SegmentPathColor[], pathPickingColors: NumberArray3[][], defaultColor: NumberArray4, opacity: number[], pathClosed: boolean[], outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], ellipsoid: Ellipsoid, outTransformedPathLonLat: SegmentPathLonLatExt[], outPath3v: SegmentPath3vExt[], outTransformedPathMerc: LonLat[][], outExtent: Extent, outColors: number[], outThickness: number[], outTexParams: number[], outTexCoords: number[], outBoundingSpheres: number[], outPickingColors: number[]): void;
+    /**
+
+     [1, -1, 2, -2] - orders for triangle strip line segment
+     t2        t3
+     (2)-------(-2)
+     |          |
+     |          |
+     |          |
+     |          |
+     (1)-------(-1)
+     t0        t1
+     */
+    static setPathTexCoords(path3v: SegmentPath3vExt[], tCoordArrs: (number[] | null)[], outTexCoords: number[]): void;
+    static setPathColors(pathLonLat: SegmentPathLonLatExt[], pathColors: SegmentPathColor[], defaultColor: NumberArray4, outColors: number[], opacity?: number): void;
+    /**
+     * Appends to the line array new geodetic coordinates line data.
+     * @static
+     */
+    protected __appendLineDataLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors: SegmentPathColor[], pathPickingColors: NumberArray3[][], defaultColor: NumberArray4, opacity: number[], pathClosed: boolean[], outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], outTexCoords: number[], ellipsoid: Ellipsoid, outTransformedPathCartesian: SegmentPath3vExt[], outPathLonLat: SegmentPathLonLatExt[], outTransformedPathMerc: LonLat[][], outExtent: Extent, outColors: number[], outThickness: number[], outTexParams: number[], outBoundingSpheres: number[], outPickingColors: number[]): void;
+    protected _setEqualPath3v(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    /**
+     * Sets one polyline segment with cartesian coordinates.
+     * @protected
+     * @param {SegmentPath3vExt} path3v - Cartesian coordinates for one segment.
+     * @param {number} segmentIndex - Segment index to update.
+     * @param {SegmentPathColor | NumberArray4} [pathColors] - Optional colors for the segment path.
+     */
+    protected _setSegmentEqualPath3v(path3v: SegmentPath3vExt, segmentIndex: number, pathColors?: SegmentPathColor | NumberArray4): void;
+    protected _setEqualPathLonLat(pathLonLat: SegmentPathLonLat[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    protected _setSegmentEqualLonLat(pathLonLat: SegmentPathLonLatExt, segmentIndex: number, pathColors?: SegmentPathColor | NumberArray4): void;
+    setPointLonLat(lonlat: LonLat, index: number, segmentIndex: number): void;
+    /**
+     * Changes cartesian point coordinates of the path
+     * @param {Vec3} coordinates - New coordinates
+     * @param {number} [index=0] - Path segment index
+     * @param {number} [segmentIndex=0] - Index of the point in the path segment
+     * @param {boolean} [skipLonLat=false] - Do not update geodetic coordinates
+     */
+    setPoint3v(coordinates: Vec3, index?: number, segmentIndex?: number, skipLonLat?: boolean): void;
+    protected _resizePathLengths(index?: number): void;
+    protected _rebuildIndexes(): void;
+    /**
+     * Remove multiline path segment
+     * @param {number} index - Segment index in multiline
+     */
+    removePath(index: number): void;
+    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[], opacity?: number): void;
+    appendPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: NumberArray4[], opacity?: number): void;
+    /**
+     * Remove point from the path
+     * @param {number} index - Point index in a path segment
+     * @param {number} [segmentIndex=0] - Segment path index
+     */
+    removePoint(index: number, segmentIndex?: number): void;
+    /**
+     * Insert point coordinates in a path segment
+     * @param {Vec3} point3v - Point coordinates
+     * @param {number} [index=0] - Index in the path
+     * @param {NumberArray4} [color] - Point color
+     * @param {number} [segmentIndex=0] - Path segment index
+     */
+    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number): void;
+    /**
+     * Append new point in the end of the path.
+     * @public
+     * @param {Vec3} point3v - New point coordinates.
+     * @param {number} [segmentIndex=0] - Path segment index, first by default.
+     * @param {NumberArray4} [color] - Point color.
+     * @param {number} [opacity=1] - Point opacity.
+     */
+    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4, opacity?: number): void;
+    /**
+     * Append new geodetic point in the end of the path.
+     * @public
+     * @param {LonLat} lonLat - New coordinate.
+     * @param {number} [segmentIndex=0] - Path segment index, first by default.
+     * @param {NumberArray4} [color] - Point color.
+     * @param {number} [opacity=1]
+     */
+    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4, opacity?: number): void;
+    /**
+     * Clear polyline data.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Change path point color
+     * @param {NumberArray4} color - New color
+     * @param {number} [index=0] - Point index
+     * @param {number} [segmentIndex=0] - Path segment index
+     * @param {number} [opacity=1.0]
+     */
+    setPointColor(color: NumberArray4, index?: number, segmentIndex?: number, opacity?: number): void;
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} altitude - ALtitude value.
+     */
+    setAltitude(altitude: number): void;
+    /**
+     * Sets polyline thickness in screen pixels.
+     * @public
+     * @param {number} thickness - Segment thickness.
+     * @param {number} [segmentIndex] - Segment index. If omitted, the last segment is used.
+     */
+    setThickness(thickness: number): void;
+    setThickness(thickness: number, segmentIndex: number): void;
+    /**
+     * Sets polyline segment color.
+     * @public
+     * @param {string} htmlColor - HTML color.
+     * @param {number} [segmentIndex] - Segment index. If omitted, the last segment is used.
+     * @param {number} [opacity=1] - Segment opacity.
+     */
+    setColor(htmlColor: string): void;
+    setColor(htmlColor: string, segmentIndex: number, opacity?: number): void;
+    setPathTexParams(texOffset: number | undefined, strokeSize: number | undefined, segmentIndex: number): void;
+    setPathTexParams(texOffset: number | undefined, strokeSize: number | undefined, texOffsetSpeed: number | undefined, segmentIndex: number): void;
+    setPathTexOffset(texOffset: number, segmentIndex: number): void;
+    setPathStrokeSize(strokeSize: number, segmentIndex: number): void;
+    setPathTexOffsetSpeed(texOffsetSpeed: number, segmentIndex: number): void;
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Polyline visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * Gets Polyline visibility.
+     * @public
+     * @returns {boolean} Polyline visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Assign with render node.
+     * @public
+     * @param {Scene} scene -
+     */
+    bindScene(scene: Scene): void;
+    protected _clearData(): void;
+    protected _createData3v(path3v: SegmentPath3vExt[]): void;
+    protected _createDataLonLat(pathLonlat: SegmentPathLonLatExt[]): void;
+    /**
+     * Removes from an entity.
+     * @public
+     */
+    remove(): void;
+    setPathPickingColor3v(color: Vec3, segmentIndex: number): void;
+    /**
+     * Returns polyline geodetic extent.
+     * @public
+     * @returns {Extent} Geodetic extent.
+     */
+    getExtent(): Extent;
+    /**
+     * Returns path cartesian coordinates.
+     * @returns {SegmentPath3vExt[]} Polyline path.
+     */
+    getPath3v(): SegmentPath3vExt[];
+    /**
+     * Returns geodetic path coordinates.
+     * @returns {SegmentPathLonLatExt[]} Polyline path.
+     */
+    getPathLonLat(): SegmentPathLonLatExt[];
+    getPathColors(): NumberArray4[][];
+    setPathOpacity(opacity: number): void;
+    setPathOpacity(opacity: number, segmentIndex: number): void;
+    setPathColors(pathColors: SegmentPathColor[]): void;
+    setPathColors(pathColors: SegmentPathColor, segmentIndex: number, opacity?: number): void;
+    setPathLonLatFast(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    setPath3vFast(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    protected _applyPathColorsFromInput(pathInput: SegmentPath3vExt[] | SegmentPathLonLatExt[], colorsInput: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
+    getSize(index?: number): number;
+    /**
+     * Sets Polyline cartesian coordinates.
+     * @public
+     * @param {SegmentPath3vExt[]} path3v - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {SegmentPathColor[]} [pathColors] - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {Boolean} [forceEqual=false] - Makes assigning faster for size equal coordinates array.
+     */
+    setPath3v(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[], forceEqual?: boolean): void;
+    setPath3v(path3v: SegmentPath3vExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
+    /**
+     * Sets polyline geodetic coordinates.
+     * @public
+     * @param {SegmentPathLonLat[]} pathLonLat - Polyline path cartesian coordinates.
+     * @param {SegmentPathColor[]} pathColors - Polyline path points colors.
+     * @param {Boolean} [forceEqual=false] - OPTIMIZATION FLAG: Makes assigning faster for size equal coordinates array.
+     */
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[], forceEqual?: boolean): void;
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
+    drawOpaque(): void;
+    drawTransparent(): void;
+    drawPicking(): void;
+    /**
+     * Refresh buffers.
+     * @protected
+     */
+    protected _refresh(): void;
+    /**
+     * Updates render buffers.
+     * @protected
+     */
+    protected _update(): void;
+    /**
+     * Clear GL buffers.
+     * @public
+     */
+    _deleteBuffers(): void;
+    /**
+     * Creates vertices buffers.
+     * @protected
+     */
+    protected _createVerticesBuffer(): void;
+    /**
+     * Creates gl index and order buffer.
+     * @protected
+     */
+    protected _createIndexBuffer(): void;
+    protected _createColorsBuffer(): void;
+    protected _createPickingColorsBuffer(): void;
+    protected _createThicknessBuffer(): void;
+    protected _createTexParamsBuffer(): void;
+    protected _createPathPhaseBuffer(): void;
+    protected _createBoundingSphereBuffer(): void;
+    _createTexCoordBuffer(): void;
+    setVisibleSphere(p: Vec3, r: number): void;
+    protected _updateVisibleSphereRTC(): void;
+    updateRTCPosition(): void;
+}
+export { PolylineBatchRenderer };

package/lib/entity/{PolylineHandler.d.ts → polyline/PolylineHandler.d.ts}

@@ -1,25 +1,36 @@
-import { EntityCollection } from "./EntityCollection";
+import { EntityCollection } from "../EntityCollection";
 import { Polyline } from "./Polyline";
-import { Renderer } from "../renderer/Renderer";
-import { RenderNode } from "../scene/RenderNode";
-import { Vec3 } from "../math/Vec3";
+import { Renderer } from "../../renderer/Renderer";
+import { Scene } from "../../scene/Scene";
+import { Vec3 } from "../../math/Vec3";
+import { PolylineBatchRenderer } from "./PolylineBatchRenderer";
 declare class PolylineHandler {
     static __counter__: number;
     protected __id: number;
     _entityCollection: EntityCollection;
     pickingEnabled: boolean;
     protected _renderer: Renderer | null;
-    protected _polylines: Polyline[];
     _relativeCenter: Vec3;
     _rtcEyePositionHigh: Float32Array;
     _rtcEyePositionLow: Float32Array;
+    _opaqueRenderer: PolylineBatchRenderer;
+    _transparentRenderer: PolylineBatchRenderer;
+    _opaqueTexRenderer: PolylineBatchRenderer;
+    _transparentTexRenderer: PolylineBatchRenderer;
+    protected _polylines: Polyline[];
     constructor(entityCollection: EntityCollection);
+    setVisibleSphere(p: Vec3, r: number): void;
     protected _initProgram(): void;
-    setRenderNode(renderNode: RenderNode): void;
+    bindScene(scene: Scene): void;
     add(polyline: Polyline): void;
     remove(polyline: Polyline): void;
+    getRenderer(opacity: number, textured: boolean): PolylineBatchRenderer;
+    reindexAfterRemoval(removedBatchIndex: number, renderer: PolylineBatchRenderer): void;
     reindexPolylineArray(startIndex: number): void;
-    draw(): void;
+    drawForward(): void;
+    drawOpaque(): void;
+    drawTransparent(): void;
+    drawTransparentForward(): void;
     drawPicking(): void;
     clear(): void;
     getRTCPosition(pos: Vec3, rtcPositionHigh: Vec3, rtcPositionLow: Vec3): void;
@@ -27,6 +38,7 @@ declare class PolylineHandler {
     protected _updateRTCEyePosition(): void;
     reloadTextures(): void;
     get polylines(): Polyline[];
+    protected _updateTexCoords(renderer: PolylineBatchRenderer): void;
     refreshTexCoordsArr(): void;
 }
 export { PolylineHandler };

package/lib/entity/{Ray.d.ts → ray/Ray.d.ts}

@@ -1,10 +1,10 @@
-import { Vec3 } from "../math/Vec3";
-import { Vec4 } from "../math/Vec4";
-import type { NumberArray3 } from "../math/Vec3";
-import type { NumberArray4 } from "../math/Vec4";
-import { Entity } from "./Entity";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
+import type { NumberArray3 } from "../../math/Vec3";
+import type { NumberArray4 } from "../../math/Vec4";
+import { Entity } from "../Entity";
 import { RayHandler } from "./RayHandler";
-import type { HTMLImageElementExt } from "../utils/ImagesCacheManager";
+import type { HTMLImageElementExt } from "../../utils/ImagesCacheManager";
 export interface IRayParams {
     thickness?: number;
     startPosition?: Vec3 | NumberArray3;
@@ -16,6 +16,7 @@ export interface IRayParams {
     image?: HTMLImageElement;
     texOffset?: number;
     strokeSize?: number;
+    opacity?: number;
 }
 /**
  * Ray class.
@@ -25,6 +26,7 @@ export interface IRayParams {
  * @param {Vec3|Array.<number>} [options.endPosition] - Ray end point position.
  * @param {Vec3|Array.<number>} [options.startColor] - Ray start point color.
  * @param {Vec3|Array.<number>} [options.endColor] - Ray end point color.
+ * @param {number} [options.opacity=1.0] - Ray opacity multiplier.
  * @param {boolean} [options.visibility] - Visibility.
  */
 declare class Ray {
@@ -79,12 +81,16 @@ declare class Ray {
      * @protected
      * @type {Object}
      */
-    protected _image: HTMLImageElement & {
+    protected _image: (HTMLImageElement & {
         __nodeIndex?: number;
-    } | null;
+    }) | null;
     protected _texOffset: number;
     protected _strokeSize: number;
+    protected _opacity: number;
+    protected _effectiveStartColor: Vec4;
+    protected _effectiveEndColor: Vec4;
     constructor(options?: IRayParams);
+    protected _updateEffectiveColors(): void;
     /**
      * Sets ray start position.
      * @public
@@ -108,6 +114,8 @@ declare class Ray {
      */
     setImage(image: HTMLImageElement): void;
     getImage(): HTMLImageElementExt | null;
+    protected _applyImageTexture(image: HTMLImageElementExt): void;
+    reloadTexture(): void;
     /**
      * Sets ray start position.
      * @public
@@ -153,6 +161,18 @@ declare class Ray {
      * @param {boolean} visibility - Visibility flag.
      */
     setVisibility(visibility: boolean): void;
+    /**
+     * Sets ray opacity.
+     * @public
+     * @param {number} opacity - Opacity value in range [0..1].
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * Returns ray opacity multiplier.
+     * @public
+     * @returns {number}
+     */
+    getOpacity(): number;
     /**
      * Returns visibility.
      * @public
@@ -165,7 +185,7 @@ declare class Ray {
      */
     remove(): void;
     /**
-     * Set picking color.
+     * Sets picking color.
      * @public
      * @param {Vec3} color - Picking color.
      */

package/lib/entity/{RayHandler.d.ts → ray/RayHandler.d.ts}

@@ -1,10 +1,11 @@
-import type { TypedArray } from "../utils/shared";
-import { EntityCollection } from "./EntityCollection";
+import type { TypedArray } from "../../utils/shared";
+import { EntityCollection } from "../EntityCollection";
 import { Ray } from "./Ray";
-import { Renderer } from "../renderer/Renderer";
-import { Vec3 } from "../math/Vec3";
-import { Vec4 } from "../math/Vec4";
-import type { WebGLBufferExt } from "../webgl/Handler";
+import { Renderer } from "../../renderer/Renderer";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4 } from "../../math/Vec4";
+import type { WebGLBufferExt } from "../../webgl/Handler";
+import type { ShaderProgram } from "../../webgl/ShaderProgram";
 declare class RayHandler {
     static __counter__: number;
     protected __id: number;
@@ -17,6 +18,7 @@ declare class RayHandler {
     _entityCollection: EntityCollection;
     protected _renderer: Renderer | null;
     protected _rays: Ray[];
+    protected _opaqueCounterIndex: number;
     protected _vertexBuffer: WebGLBufferExt | null;
     protected _startPositionHighBuffer: WebGLBufferExt | null;
     protected _startPositionLowBuffer: WebGLBufferExt | null;
@@ -43,6 +45,11 @@ declare class RayHandler {
     protected _changedBuffers: boolean[];
     constructor(entityCollection: EntityCollection);
     static concArr(dest: number[], curr: number[]): void;
+    protected _isRayOpaque(ray: Ray): boolean;
+    protected _swapArrayItems(arr: number[] | TypedArray, itemSize: number, firstIndex: number, secondIndex: number): void;
+    protected _swapRayData(firstIndex: number, secondIndex: number): void;
+    protected _insertRayByOpacity(rayIndex: number, isOpaque: boolean): void;
+    protected _updateRayOpacityState(rayIndex: number, isOpaque: boolean): boolean;
     reloadTextures(): void;
     get rays(): Ray[];
     initProgram(): void;
@@ -54,9 +61,12 @@ declare class RayHandler {
     update(): void;
     add(ray: Ray): void;
     protected _addRayToArrays(ray: Ray): void;
-    protected _displayPASS(): void;
+    protected _displayPASS(startRayIndex: number, endRayIndex: number, rayProgram: ShaderProgram): void;
     protected _pickingPASS(): void;
-    draw(): void;
+    drawForward(): void;
+    drawOpaque(): void;
+    drawTransparent(): void;
+    drawTransparentForward(): void;
     drawPicking(): void;
     reindexRaysArray(startIndex: number): void;
     protected _removeRay(ray: Ray): void;