@openglobus/og 0.28.7 → 1.0.0-rc2

package/lib/camera/Frustum.d.ts

@@ -9,6 +9,8 @@ interface IFrustumParams {
     aspect?: number;
     near?: number;
     far?: number;
+    reverseDepth?: boolean;
+    depthZeroToOne?: boolean;
 }
 /**
  * Frustum object, part of the camera object.
@@ -17,6 +19,11 @@ interface IFrustumParams {
  */
 declare class Frustum {
     protected _f: [NumberArray4, NumberArray4, NumberArray4, NumberArray4, NumberArray4, NumberArray4];
+    protected _isOrthographic: boolean;
+    protected _aspect: number;
+    protected _tanViewAngle_hrad: number;
+    protected _reverseDepth: boolean;
+    protected _depthZeroToOne: boolean;
     /**
      * Camera projection matrix.
      * @protected
@@ -67,6 +74,12 @@ declare class Frustum {
      * @public
      */
     near: number;
+    /**
+     * Near-plane safety value used by depth offset logic in shaders.
+     * Updated together with `near`.
+     * @public
+     */
+    depthOffsetNear: number;
     /**
      * Projection frustum far value.
      * @public
@@ -75,26 +88,92 @@ declare class Frustum {
     cameraFrustumIndex: number;
     _pickingColorU: Float32Array;
     constructor(options?: IFrustumParams);
+    /**
+     * Returns right clipping plane.
+     * @public
+     * @returns {NumberArray4} Right clipping plane coefficients.
+     */
     getRightPlane(): NumberArray4;
+    /**
+     * Returns left clipping plane.
+     * @public
+     * @returns {NumberArray4} Left clipping plane coefficients.
+     */
     getLeftPlane(): NumberArray4;
+    /**
+     * Returns bottom clipping plane.
+     * @public
+     * @returns {NumberArray4} Bottom clipping plane coefficients.
+     */
     getBottomPlane(): NumberArray4;
+    /**
+     * Returns top clipping plane.
+     * @public
+     * @returns {NumberArray4} Top clipping plane coefficients.
+     */
     getTopPlane(): NumberArray4;
+    /**
+     * Returns backward clipping plane.
+     * @public
+     * @returns {NumberArray4} Backward clipping plane coefficients.
+     */
     getBackwardPlane(): NumberArray4;
+    /**
+     * Returns forward clipping plane.
+     * @public
+     * @returns {NumberArray4} Forward clipping plane coefficients.
+     */
     getForwardPlane(): NumberArray4;
+    /**
+     * Returns projection-view matrix.
+     * @public
+     * @returns {NumberArray16} Projection-view matrix values.
+     */
     getProjectionViewMatrix(): NumberArray16;
+    /**
+     * Returns projection-view RTE matrix.
+     * @public
+     * @returns {NumberArray16} Projection-view RTE matrix values.
+     */
     getProjectionViewRTEMatrix(): NumberArray16;
+    /**
+     * Returns projection matrix.
+     * @public
+     * @returns {NumberArray16} Projection matrix values.
+     */
     getProjectionMatrix(): NumberArray16;
+    /**
+     * Returns inverse projection matrix.
+     * @public
+     * @returns {NumberArray16} Inverse projection matrix values.
+     */
     getInverseProjectionMatrix(): NumberArray16;
     /**
      * Sets up camera projection matrix.
      * @public
-     * @param {number} viewAngle - Camera's vertical fov view angle.
-     * @param {number} aspect - Screen aspect ratio.
-     * @param {number} near - Near camera distance.
-     * @param {number} far - Far camera distance.
+     * @param {number} viewAngle - Camera vertical field of view angle in degrees.
+     * @param {number} aspect - Viewport aspect ratio (`width / height`).
+     * @param {number} near - Near clipping plane distance.
+     * @param {number} far - Far clipping plane distance.
+     * @param {boolean} [isOrthographic=false] - Enables orthographic projection mode.
+     * @param {number} [focusDistance=10] - Reference distance used to compute orthographic frustum size.
+     * @param {boolean} [reverseDepth=false] - Enables reverse-Z infinite perspective projection.
+     * @param {boolean} [depthZeroToOne=false] - Uses `[0, 1]` NDC depth range for reverse-Z projection.
+     */
+    setProjectionMatrix(viewAngle: number, aspect: number, near: number, far: number, isOrthographic?: boolean, focusDistance?: number, reverseDepth?: boolean, depthZeroToOne?: boolean): void;
+    /**
+     * Updates near and far clipping planes.
+     * @public
+     * @param {number} near - Near clipping plane distance.
+     * @param {number} [far=this.far] - Far clipping plane distance.
      */
-    setProjectionMatrix(viewAngle: number, aspect: number, near: number, far: number, isOrthographic?: boolean, focusDistance?: number): void;
+    setNearFar(near: number, far?: number): void;
     protected _setFrustumParams(top: number, right: number, near: number, far: number): void;
+    /**
+     * Updates projection-view RTE matrix.
+     * @public
+     * @param {Mat4} viewRTEMatrix - View matrix in RTE coordinates.
+     */
     setProjectionViewRTEMatrix(viewRTEMatrix: Mat4): void;
     /**
      * Camera's projection matrix values.
@@ -103,40 +182,46 @@ declare class Frustum {
      */
     setViewMatrix(viewMatrix: Mat4): void;
     /**
-     * Returns true if a point in the frustum.
+     * Returns true if the point is inside the frustum.
      * @public
      * @param {Vec3} point - Cartesian point.
-     * @returns {boolean} -
+     * @returns {boolean} `true` when the point is inside.
      */
     containsPoint(point: Vec3): boolean;
     /**
-     * Returns true if the frustum contains a bonding sphere, but bottom plane exclude.
+     * Returns true if the sphere is inside the frustum, ignoring the bottom plane.
      * @public
      * @param {Sphere} sphere - Bounding sphere.
-     * @returns {boolean} -
+     * @returns {boolean} `true` when the sphere passes all checked planes.
      */
     containsSphereBottomExc(sphere: Sphere): boolean;
+    /**
+     * Checks sphere intersection with the bottom frustum plane only.
+     * @public
+     * @param {Sphere} sphere - Bounding sphere.
+     * @returns {boolean} `true` when the sphere is not clipped by the bottom plane.
+     */
     containsSphereButtom(sphere: Sphere): boolean;
     /**
-     * Returns true if the frustum contains a bonding sphere.
+     * Returns true if the sphere is inside the frustum.
      * @public
      * @param {Sphere} sphere - Bounding sphere.
-     * @returns {boolean} -
+     * @returns {boolean} `true` when the sphere is inside.
      */
     containsSphere(sphere: Sphere): boolean;
     /**
-     * Returns true if the frustum contains a bonding sphere.
+     * Returns true if the sphere is inside the frustum.
      * @public
      * @param {Vec3} center - Sphere center.
      * @param {number} radius - Sphere radius.
-     * @returns {boolean} -
+     * @returns {boolean} `true` when the sphere is inside.
      */
     containsSphere2(center: Vec3, radius: number): boolean;
     /**
-     * Returns true if the frustum contains a bounding box.
+     * Returns true if the box intersects or is inside the frustum.
      * @public
      * @param {Box} box - Bounding box.
-     * @returns {boolean} -
+     * @returns {boolean} `true` when the box is not fully outside.
      */
     containsBox(box: Box): boolean;
 }

package/lib/camera/PlanetCamera.d.ts

@@ -12,6 +12,7 @@ export interface IPlanetCameraParams extends ICameraParams {
 export interface IPlanetFlyCartesianParams extends IFlyCartesianParams {
     amplitude?: number;
     preventLock?: boolean;
+    linearPath?: boolean;
 }
 export interface IPlanetFlyDistanceParams extends IPlanetFlyCartesianParams {
     distance?: number;
@@ -28,14 +29,15 @@ export interface IPlanetFlyDistanceParams extends IPlanetFlyCartesianParams {
  * @param {number} [options.far] - Camera far plane distance. Default is og.math.MAX
  * @param {number} [options.minAltitude] - Minimal altitude for the camera. Default is 5
  * @param {number} [options.maxAltitude] - Maximal altitude for the camera. Default is 20000000
+ * @param {boolean} [options.reverseDepth=true] - Enables reverse-Z depth in perspective mode.
  * @param {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
  * @param {Vec3} [options.look] - Camera look position. Default (0,0,0)
  * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
- * @fires og.Camera#viewchange
- * @fires og.Camera#moveend
- * @fires og.Camera#flystart
- * @fires og.Camera#flyend
- * @fires og.Camera#flystop
+ * @fires viewchange
+ * @fires moveend
+ * @fires flystart
+ * @fires flyend
+ * @fires flystop
  */
 declare class PlanetCamera extends Camera {
     /**
@@ -86,11 +88,15 @@ declare class PlanetCamera extends Camera {
      * @type {Segment}
      */
     _insideSegment: Segment | null;
-    slope: number;
     protected _keyLock: Key;
     protected _checkTerrainCollision: boolean;
     eyeNorm: Vec3;
     constructor(planet: Planet, options?: IPlanetCameraParams);
+    /**
+     * Enables or disables terrain collision checks.
+     * @public
+     * @param {boolean} isActive - Terrain collision flag.
+     */
     setTerrainCollisionActivity(isActive: boolean): void;
     /**
      * Updates camera view space.
@@ -98,6 +104,10 @@ declare class PlanetCamera extends Camera {
      * @virtual
      */
     update(): void;
+    /**
+     * Updates camera geographic coordinates from current cartesian position.
+     * @public
+     */
     updateGeodeticPosition(): void;
     /**
      * Sets altitude over the terrain.
@@ -153,6 +163,12 @@ declare class PlanetCamera extends Camera {
      * @param {IPlanetFlyCartesianParams} [params] - Flight parameters
      */
     flyExtent(extent: Extent, height?: number | null, params?: IPlanetFlyCartesianParams): void;
+    /**
+     * Places camera at a fixed distance from a target point and looks at it.
+     * @public
+     * @param {Vec3} cartesian - Target cartesian point.
+     * @param {number} [distance=10000.0] - Distance from the target.
+     */
     viewDistance(cartesian: Vec3, distance?: number): void;
     /**
      * Flies to the geo coordinates.
@@ -161,6 +177,13 @@ declare class PlanetCamera extends Camera {
      * @param {IPlanetFlyCartesianParams} [params] - Flight parameters
      */
     flyLonLat(lonlat: LonLat, params?: IPlanetFlyCartesianParams): void;
+    /**
+     * Flies camera to a position at a fixed distance from the target point.
+     * @public
+     * @param {Vec3} cartesian - Target cartesian point.
+     * @param {number} [distance=10000.0] - Distance from the target.
+     * @param {IPlanetFlyCartesianParams} [params] - Flight parameters.
+     */
     flyDistance(cartesian: Vec3, distance?: number, params?: IPlanetFlyCartesianParams): void;
     flyCartesian(cartesian: Vec3, params?: IPlanetFlyCartesianParams): void;
     stopFlying(): void;
@@ -190,23 +213,85 @@ declare class PlanetCamera extends Camera {
      * @param {number} angle - Rotation angle.
      */
     rotateDown(angle: number): void;
+    /**
+     * Rotates camera vertically around the given center.
+     * @public
+     * @param {number} angle - Rotation angle in radians.
+     * @param {Vec3} center - Rotation center.
+     * @param {number} [minSlope=0] - Minimum allowed slope limit.
+     */
     rotateVertical(angle: number, center: Vec3, minSlope?: number): void;
+    /**
+     * Updates terrain altitude and keeps camera above minimum altitude.
+     * @public
+     * @returns {Vec3 | undefined} Terrain point under camera when available.
+     */
     checkTerrainCollision(): Vec3 | undefined;
+    /**
+     * Returns visible surface arc distance from current altitude.
+     * @public
+     * @param {number} d - Additional height offset.
+     * @returns {number} Visible surface distance.
+     */
     getSurfaceVisibleDistance(d: number): number;
     /**
-     * should be yje same as getYaw
+     * Returns heading angle in degrees.
+     * Should match `getYaw()` in most cases.
+     * @public
+     * @returns {number} Heading in `[0, 360)` degrees.
      */
     getHeading(): number;
+    /**
+     * Checks whether a cartesian point is visible above the horizon.
+     * @public
+     * @param {Vec3} poi - Point in cartesian coordinates.
+     * @returns {boolean} `true` when the point is visible.
+     */
     isVisible(poi: Vec3): boolean;
+    /**
+     * Returns pitch angle in local planet frame.
+     * @public
+     * @returns {number} Pitch angle in radians.
+     */
     getPitch(): number;
     /**
-     * should be the same as getHeading
+     * Returns yaw angle in local planet frame.
+     * Should match `getHeading()` in most cases.
+     * @public
+     * @returns {number} Yaw angle in radians.
      */
     getYaw(): number;
+    /**
+     * Returns roll angle in local planet frame.
+     * @public
+     * @returns {number} Roll angle in radians.
+     */
     getRoll(): number;
+    /**
+     * Sets pitch angle in local planet frame.
+     * @public
+     * @param {number} a - Pitch angle in radians.
+     */
     setPitch(a: number): void;
+    /**
+     * Sets yaw angle in local planet frame.
+     * @public
+     * @param {number} a - Yaw angle in radians.
+     */
     setYaw(a: number): void;
+    /**
+     * Sets roll angle in local planet frame.
+     * @public
+     * @param {number} a - Roll angle in radians.
+     */
     setRoll(a: number): void;
+    /**
+     * Sets orientation from pitch, yaw and roll in local planet frame.
+     * @public
+     * @param {number} pitch - Pitch angle in radians.
+     * @param {number} yaw - Yaw angle in radians.
+     * @param {number} roll - Roll angle in radians.
+     */
     setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
 }
 export { PlanetCamera };

package/lib/camera/index.d.ts

@@ -1,3 +1,3 @@
-import { Camera } from './Camera';
-import { PlanetCamera } from './PlanetCamera';
+import { Camera } from "./Camera";
+import { PlanetCamera } from "./PlanetCamera";
 export { Camera, PlanetCamera };

package/lib/control/CameraFrameComposer.d.ts

@@ -1,14 +1,14 @@
 import { Control, IControlParams } from "./Control";
 import { CameraFrameHandler } from "./CameraFrameHandler";
 import { EntityCollection } from "../entity";
-import { RenderNode } from '../scene/RenderNode';
+import { Scene } from "../scene/Scene";
 export interface ICameraFrameComposerParams extends IControlParams {
     frameHandlers?: CameraFrameHandler[];
 }
 export declare class CameraFrameComposer extends Control {
     readonly _frameHandlers: CameraFrameHandler[];
     protected _cameraLayer: EntityCollection;
-    protected _cameraScene: RenderNode;
+    protected _cameraScene: Scene;
     constructor(params?: ICameraFrameComposerParams);
     get frameHandlers(): CameraFrameHandler[];
     add(handler: CameraFrameHandler): void;

package/lib/control/CameraFrameHandler.d.ts

@@ -16,7 +16,7 @@ export declare class CameraFrameHandler {
     frameHandler: FrameHandlerFunc | null;
     protected _composer: CameraFrameComposer | null;
     protected _composerIndex: number;
-    readonly cameraEntity: Entity;
+    readonly cameraEntity: Entity | null;
     showFrustum: boolean;
     constructor(params: ICameraFrameHadler);
     get frustumScale(): Vec3;

package/lib/control/CompassButton.d.ts

@@ -6,11 +6,11 @@ interface ICompasButtonParams extends IControlParams {
  */
 export declare class CompassButton extends Control {
     protected _heading: number;
-    protected _svg: HTMLElement | null;
+    protected _icon: HTMLElement | null;
     constructor(options?: ICompasButtonParams);
     oninit(): void;
     protected _onClick(): void;
-    protected _draw(): void;
+    protected _draw: () => void;
     setHeading(heading: number): void;
 }
 export {};

package/lib/control/EarthCoordinates.d.ts

@@ -1,5 +1,5 @@
-import { Control, type IControlParams } from './Control';
-import { LonLat } from '../LonLat';
+import { Control, type IControlParams } from "./Control";
+import { LonLat } from "../LonLat";
 import type { IMouseState } from "../renderer/RendererEvents";
 interface IEarthCoordinatesParams extends IControlParams {
     heightMode?: string;
@@ -34,6 +34,9 @@ export declare class EarthCoordinates extends Control {
     protected _createCenterEl(): HTMLElement;
     protected _updateUnits(): void;
     protected _refreshCoordinates(): void;
+    protected _getClipboardCoordinates(): string;
+    protected _copyCoordinates(): Promise<void>;
+    protected _onPanelClick: (event: MouseEvent) => void;
     oninit(): void;
     protected _grabCoordinates(e: IMouseState): void;
     protected _showHeight(): Promise<void>;

package/lib/control/FramebufferPreview.d.ts

@@ -1,13 +1,13 @@
 import { Dialog } from "../ui/Dialog";
 import { Framebuffer } from "../webgl/Framebuffer";
 import { Control, IControlParams } from "./Control";
-import { Program } from "../webgl/Program";
+import { ShaderProgram } from "../webgl/ShaderProgram";
 export interface IFramebufferDialogParams extends IControlParams {
     framebuffer?: Framebuffer;
     title?: string;
     common?: string;
     image?: string;
-    flippedUV?: boolean;
+    flippedY?: boolean;
 }
 export declare class FramebufferPreview extends Control {
     protected _dialog: Dialog<null>;
@@ -15,7 +15,7 @@ export declare class FramebufferPreview extends Control {
     protected _framebuffer: Framebuffer | null;
     protected _screenFramebuffer: Framebuffer | null;
     framebufferCurrentTexture: number;
-    protected _program: Program;
+    protected _program: ShaderProgram;
     constructor(params: IFramebufferDialogParams);
     bindFramebuffer(framebuffer: Framebuffer): void;
     oninit(): void;

package/lib/control/GeoImageDragControl.d.ts

@@ -1,4 +1,4 @@
-import { Control, type IControlParams } from './Control';
+import { Control, type IControlParams } from "./Control";
 import { Layer } from "../layer/Layer";
 import { ToggleButton } from "../ui/ToggleButton";
 import type { IMouseState } from "../renderer/RendererEvents";

package/lib/control/LayerAnimation.d.ts

@@ -1,5 +1,5 @@
-import { type EventsHandler } from '../Events';
-import { Layer } from '../layer/Layer';
+import { type EventsHandler } from "../Events";
+import { Layer } from "../layer/Layer";
 import { Control, type IControlParams } from "./Control";
 type LayerAnimationEventsList = ["change", "idle", "play", "pause", "stop"];
 interface ILayerAnimationParams extends IControlParams {

package/lib/control/LayerSwitcher.d.ts

@@ -30,6 +30,9 @@ export declare class LayerSwitcher extends Control {
     oninit(): void;
     protected _initLayers(): void;
     protected _createLayerButton(layer: Layer): LayerButtonView;
+    protected _findLayerView(layer: Layer): LayerButtonView | null;
+    protected _placeLayerView(layerView: LayerButtonView): void;
+    protected _onLayerBaseLayerChange: (layer: Layer) => void;
     addLayer: (layer: Layer) => void;
     removeLayer: (layer: Layer) => void;
     onactivate(): void;

package/lib/control/Lighting.d.ts

@@ -1,10 +1,10 @@
 import { Control } from "./Control";
 import type { IControlParams } from "./Control";
-import { Dialog } from '../ui/Dialog';
+import { Dialog } from "../ui/Dialog";
 import { Layer } from "../layer/Layer";
 import { Slider } from "../ui/Slider";
 import { ToggleButton } from "../ui/ToggleButton";
-import { View } from '../ui/View';
+import { View } from "../ui/View";
 import { Color } from "../ui/Color";
 interface ILightingParams extends IControlParams {
 }
@@ -47,6 +47,8 @@ export declare class Lighting extends Control {
     bindLayer(layer: Layer): void;
     oninit(): void;
     protected _update(): void;
+    protected _setSliderValue(slider: Slider, value: number): void;
+    protected _syncSelectedBaseLayerLighting(): void;
     protected _fetchLayers(): void;
     protected _onLayerAdd(e: Layer): void;
     protected _onLayerRemove(e: Layer): void;

package/lib/control/Navigation.d.ts

@@ -1,14 +1,15 @@
-import { Control } from "./Control";
 import type { IControlParams } from "./Control";
+import { Control } from "./Control";
 import type { IMouseState } from "../renderer/RendererEvents";
 import { Quat } from "../math/Quat";
 import { Sphere } from "../bv/Sphere";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { type EventsHandler } from "../Events";
-export type NavigationMode = "lockNorth" | "adaptive" | "free";
+export type NavigationMode = "north" | "adaptive" | "free";
 export interface INavigationParams extends IControlParams {
     inertia?: number;
+    velInertia?: number;
     dragInertia?: number;
     minSlope?: number;
     mass?: number;
@@ -18,27 +19,24 @@ export interface INavigationParams extends IControlParams {
     disableRotation?: boolean;
     disableTilt?: boolean;
 }
-export type NavigationEventsList = [
-    "drag",
-    "zoom",
-    "rotate"
-];
+export type NavigationEventsList = ["drag", "zoom", "rotate"];
 /**
  * Navigation.
  * @class
  * @extends {Control}
  * @param {INavigationParams} [options] - Navigation options:
- * @param {NavigationMode} [options.mode] - Navigation mode: "lockNorth" (keeps north fixed), "adaptive" (default, auto-detects arc mode), "free" (arc rotation mode)
+ * @param {NavigationMode} [options.mode] - Navigation mode: "north" (keeps north fixed), "adaptive" (default, auto-detects arc mode), "free" (arc rotation mode)
  * @param {number} [options.inertia] - inertia factor
+ * @param {number} [options.velInertia] - base velocity inertia factor. Default is 0.89
  * @param {number} [options.dragInertia] - drag inertia
  * @param {number} [options.mass] - camera mass, affects velocity. Default is 1
  * @param {number} [options.minSlope] - minimal slope for vertical camera movement. Default is 0.35
  * @param {number} [options.poleThreshold] - Vertical rotation is reduced when camera is close to poles
  * @param {boolean} [options.disableRotation] - Disables horizontal rotation controls (right mouse button and touchpad). Default is false
  * @param {boolean} [options.disableTilt] - Disables vertical tilt controls (right mouse button and touchpad). Default is false
- * @fires og.Navigation#drag
- * @fires og.Navigation#zoom
- * @fires og.Navigation#rotate
+ * @fires drag
+ * @fires zoom
+ * @fires rotate
  */
 export declare class Navigation extends Control {
     force: Vec3;
@@ -80,6 +78,7 @@ export declare class Navigation extends Control {
     protected _grabbedCameraHeight: number;
     protected _newEye: Vec3;
     protected _isTouchPad: boolean;
+    protected _defaultVelInertia: number;
     protected _velInertia: number;
     protected _hold: boolean;
     protected _rotHDir: number;
@@ -107,6 +106,11 @@ export declare class Navigation extends Control {
     get freeMode(): boolean;
     setMode(mode: NavigationMode): void;
     protected _modeToNumber(mode: NavigationMode): number;
+    protected _getSurfaceDragAxes(eyeNorm: Vec3, fallbackAxis: Vec3): {
+        north: Vec3;
+        east: Vec3;
+    } | null;
+    protected _transportDragInertiaVelocity(velocity: Vec3, fromEyeNorm: Vec3, toEyeNorm: Vec3, fallbackAxis: Vec3): Vec3 | null;
     protected _handleDrag(): void;
     protected _corrRoll(): void;
     protected _handleZoom(): void;

package/lib/control/OrthoSwitcher.d.ts

@@ -0,0 +1,18 @@
+import type { Camera } from "../camera/Camera";
+import { ToggleButton } from "../ui/ToggleButton";
+import { Control, type IControlParams } from "./Control";
+interface IOrthoSwitcherParams extends IControlParams {
+    name?: string;
+}
+/**
+ * Orthographic projection switch button.
+ */
+export declare class OrthoSwitcher extends Control {
+    protected _toggleBtn: ToggleButton;
+    constructor(options?: IOrthoSwitcherParams);
+    oninit(): void;
+    onremove(): void;
+    protected _onToggle: (isActive: boolean) => void;
+    protected _onProjectionChanged: (camera: Camera) => void;
+}
+export {};

package/lib/control/SimpleTouchNavigation.d.ts

@@ -0,0 +1,44 @@
+import { Control, type IControlParams } from "../control/Control";
+import type { ITouchState } from "../renderer/RendererEvents";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+import { Plane } from "../math/Plane";
+export declare class SimpleTouchNavigation extends Control {
+    protected _grabbedPoint: Vec3 | undefined;
+    protected _grabbedScreenPoint: Vec2;
+    protected _eye0: Vec3;
+    protected _prev_t0: Vec2;
+    protected _prev_t1: Vec2;
+    protected _dead: number;
+    protected _orthoMinFocusDistance: number;
+    protected _twoFingerTiltMinMove: number;
+    protected _twoFingerTiltAlignDot: number;
+    protected _twoFingerTiltVerticalRatio: number;
+    protected _twoFingerTiltHorizontalLineRatio: number;
+    protected _twoFingerTiltStrength: number;
+    protected _twoFingerTiltActive: boolean;
+    constructor(options?: IControlParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected onTouchEnd: (e: ITouchState) => void;
+    protected _pointerToScreenPoint(pointer: PointerEvent, sys: NonNullable<ITouchState["sys"]>): Vec2;
+    protected _getGrabbedPoint(screenPoint: Vec2): Vec3;
+    protected _updateGrabbedScreenPoint(screenPoint: Vec2): void;
+    protected _startSingleFingerGesture(pointer: PointerEvent, sys: NonNullable<ITouchState["sys"]>): void;
+    protected _startTwoFingerGesture(pointer0: PointerEvent, pointer1: PointerEvent, sys: NonNullable<ITouchState["sys"]>, skipPointGrabbing: boolean): void;
+    protected _getPerspectiveDragPlane(anchor: Vec3): Plane;
+    protected _applyOrthographicDrag(screenPoint: Vec2): void;
+    protected _applyPerspectiveDrag(screenPoint: Vec2, anchor: Vec3): void;
+    protected _applyDragGesture(screenPoint: Vec2): void;
+    protected _moveSingleFingerGesture(pointer: PointerEvent, sys: NonNullable<ITouchState["sys"]>): void;
+    protected _applyTwoFingerZoom(vPrev: Vec2, vCurr: Vec2, middle: Vec2): void;
+    protected _applyTwoFingerRotation(vPrev: Vec2, vCurr: Vec2): void;
+    protected _isTwoFingerTiltGesture(d0: Vec2, d1: Vec2, touchLine: Vec2): boolean;
+    protected _applyTwoFingerTilt(d0: Vec2, d1: Vec2, touchLine: Vec2): boolean;
+    protected _isTwoFingerTiltHoldGesture(d0: Vec2, d1: Vec2, touchLine: Vec2): boolean;
+    protected _moveTwoFingerGesture(e: ITouchState, pointer0: PointerEvent, pointer1: PointerEvent, sys: NonNullable<ITouchState["sys"]>): void;
+    protected onTouchStart: (e: ITouchState, skipPointGrabbing?: boolean) => void;
+    protected onTouchMove: (e: ITouchState) => void;
+    protected onDraw(): void;
+}

package/lib/control/Sun.d.ts

@@ -1,7 +1,7 @@
 import { Control } from "./Control";
 import type { IControlParams } from "./Control";
 import { Clock } from "../Clock";
-import { LightSource } from "../light/LightSource";
+import { Vec3 } from "../math/Vec3";
 interface ISunParams extends IControlParams {
     activationHeight?: number;
     offsetVertical?: number;
@@ -15,7 +15,6 @@ export declare class Sun extends Control {
     activationHeight: number;
     offsetVertical: number;
     offsetHorizontal: number;
-    sunlight: LightSource;
     protected _currDate: number;
     protected _prevDate: number;
     protected _clockPtr: Clock | null;
@@ -23,12 +22,15 @@ export declare class Sun extends Control {
     protected _stopped: boolean;
     protected _f: number;
     protected _k: number;
+    protected _sunlightPosition: Vec3;
     constructor(options?: ISunParams);
     oninit(): void;
     stop(): void;
     start(): void;
     onactivate(): void;
     bindClock(clock: Clock): void;
+    getPosition(): Vec3;
+    protected _setSunPosition3v(position: Vec3): void;
     protected _draw(): void;
 }
 export {};