@openglobus/og 0.26.3 → 0.26.5

package/lib/camera/Camera.d.ts

@@ -10,7 +10,9 @@ import type { NumberArray2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Sphere } from "../bv/Sphere";
 import { Quat } from "../math/Quat";
-export type CameraEvents = ["viewchange", "moveend"];
+import { EasingFunction } from "../utils/easing";
+import { LonLat } from "../LonLat";
+export type CameraEvents = ["viewchange", "moveend", "flystart", "flyend", "flystop"];
 export interface ICameraParams {
     eye?: Vec3;
     viewAngle?: number;
@@ -20,6 +22,30 @@ export interface ICameraParams {
     width?: number;
     height?: number;
 }
+export interface IFlyCartesianParams extends IFlyBaseParams {
+    look?: Vec3 | LonLat;
+    up?: Vec3;
+}
+export interface IFlyBaseParams {
+    duration?: number;
+    ease?: EasingFunction;
+    completeCallback?: Function;
+    startCallback?: Function;
+    frameCallback?: Function;
+}
+export declare const DEFAULT_FLIGHT_DURATION = 800;
+export declare const DEFAULT_EASING: EasingFunction;
+type CameraFrame = {
+    eye: Vec3;
+    n: Vec3;
+    u: Vec3;
+    v: Vec3;
+};
+type CameraFlight = {
+    fly: (progress: number) => CameraFrame;
+    duration: number;
+    startedAt: number;
+};
 /**
  * Camera class.
  * @class
@@ -123,8 +149,35 @@ declare class Camera {
     isFirstPass: boolean;
     _width: number;
     _height: number;
+    protected _flight: CameraFlight | null;
+    protected _completeCallback: Function | null;
+    protected _frameCallback: Function | null;
+    protected _flying: boolean;
     constructor(options?: ICameraParams);
     get id(): number;
+    /**
+     * Flies to the cartesian coordinates.
+     * @public
+     * @param {Vec3} [cartesian] - Finish cartesian coordinates.
+     * @param {IFlyCartesianParams} [params] - Flight parameters
+     */
+    flyCartesian(cartesian: Vec3, params?: IFlyCartesianParams): void;
+    /**
+     * Breaks the flight.
+     * @public
+     */
+    stopFlying(): void;
+    /**
+     * Prepare camera to the frame. Used in render node frame function.
+     * @public
+     */
+    checkFly(): void;
+    /**
+     * Returns camera is flying.
+     * @public
+     * @returns {boolean}
+     */
+    isFlying(): boolean;
     checkMoveEnd(): void;
     bindFrustumsPickingColors(renderer: Renderer): void;
     /**

package/lib/camera/PlanetCamera.d.ts

@@ -1,34 +1,20 @@
-import { Camera, CameraEvents, type ICameraParams } from "./Camera";
+import { Camera, type IFlyCartesianParams, type ICameraParams } from "./Camera";
 import { Key } from "../Lock";
 import { LonLat } from "../LonLat";
 import { Planet } from "../scene/Planet";
 import { Vec3 } from "../math/Vec3";
 import { Extent } from "../Extent";
 import { Segment } from "../segment/Segment";
-import { EventsHandler } from "../Events";
-import { EasingFunction } from "../utils/easing";
 export interface IPlanetCameraParams extends ICameraParams {
     minAltitude?: number;
     maxAltitude?: number;
 }
-export type PlanetCameraEventsList = [
-    "flystart",
-    "flyend",
-    "flystop"
-];
-export declare const DEFAULT_FLIGHT_DURATION = 800;
-export declare const DEFAULT_EASING: EasingFunction;
-type CameraFrame = {
-    eye: Vec3;
-    n: Vec3;
-    u: Vec3;
-    v: Vec3;
-};
-type CameraFlight = {
-    fly: (progress: number) => CameraFrame;
-    duration: number;
-    startedAt: number;
-};
+export interface IPlanetFlyCartesianParams extends IFlyCartesianParams {
+    amplitude?: number;
+}
+export interface IPlanetFlyDistanceParams extends IPlanetFlyCartesianParams {
+    distance?: number;
+}
 /**
  * Planet camera.
  * @class
@@ -46,9 +32,9 @@ type CameraFlight = {
  * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
  * @fires og.Camera#viewchange
  * @fires og.Camera#moveend
- * @fires og.PlanetCamera#flystart
- * @fires og.PlanetCamera#flyend
- * @fires og.PlanetCamera#flystop
+ * @fires og.Camera#flystart
+ * @fires og.Camera#flyend
+ * @fires og.Camera#flystop
  */
 declare class PlanetCamera extends Camera {
     /**
@@ -57,7 +43,6 @@ declare class PlanetCamera extends Camera {
      * @type {Planet}
      */
     planet: Planet;
-    events: EventsHandler<PlanetCameraEventsList> & EventsHandler<CameraEvents>;
     /**
      * Minimal altitude that camera can reach over the terrain.
      * @public
@@ -102,10 +87,6 @@ declare class PlanetCamera extends Camera {
     _insideSegment: Segment | null;
     slope: number;
     protected _keyLock: Key;
-    protected _flight: CameraFlight | null;
-    protected _completeCallback: Function | null;
-    protected _frameCallback: Function | null;
-    protected _flying: boolean;
     protected _checkTerrainCollision: boolean;
     eyeNorm: Vec3;
     constructor(planet: Planet, options?: IPlanetCameraParams);
@@ -168,56 +149,20 @@ declare class PlanetCamera extends Camera {
      * @public
      * @param {Extent} extent - Current extent.
      * @param {number} [height] - Destination height.
-     * @param {Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
-     * @param {Number} [ampl] - Altitude amplitude factor.
-     * @param {Number} [duration] - Animation duration
-     * @param {EasingFunction} [ease] - Animation easing
-     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
-     * @param {Function} [startCallback] - Callback that calls before the flying begins.
-     * @param {Function} [frameCallback] - Each frame callback
+     * @param {IPlanetFlyCartesianParams} [params] - Flight parameters
      */
-    flyExtent(extent: Extent, height?: number | null, up?: Vec3 | null, ampl?: number | null, duration?: number, ease?: EasingFunction, completeCallback?: Function | null, startCallback?: Function | null, frameCallback?: Function | null): void;
+    flyExtent(extent: Extent, height?: number | null, params?: IPlanetFlyCartesianParams): void;
     viewDistance(cartesian: Vec3, distance?: number): void;
-    flyDistance(cartesian: Vec3, distance?: number, ampl?: number, duration?: number, ease?: EasingFunction, completeCallback?: Function, startCallback?: Function, frameCallback?: Function): void;
-    /**
-     * Flies to the cartesian coordinates.
-     * @public
-     * @param {Vec3} cartesian - Finish cartesian coordinates.
-     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
-     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
-     * @param {Number} [ampl=1.0] - Altitude amplitude factor.
-     * @param {Number} [duration] - Animation duration
-     * @param {EasingFunction} [ease] - Animation easing
-     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
-     * @param {Function} [startCallback] - Callback that calls before the flying begins.
-     * @param {Function} [frameCallback] - Each frame callback
-     */
-    flyCartesian(cartesian: Vec3, look?: Vec3 | LonLat | null, up?: Vec3 | null, ampl?: number, duration?: number, ease?: EasingFunction, completeCallback?: Function | null, startCallback?: Function | null, frameCallback?: Function | null): void;
     /**
      * Flies to the geo coordinates.
      * @public
      * @param {LonLat} lonlat - Finish coordinates.
-     * @param {Vec3 | LonLat} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
-     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
-     * @param {number} [ampl] - Altitude amplitude factor.
-     * @param {Number} [duration] - Animation duration
-     * @param {EasingFunction} [ease] - Animation easing
-     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
-     * @param {Function} [startCallback] - Callback that calls befor the flying begins.
-     * @param {Function} [frameCallback] - each frame callback
-     */
-    flyLonLat(lonlat: LonLat, look?: Vec3 | LonLat, up?: Vec3, ampl?: number, duration?: number, ease?: EasingFunction, completeCallback?: Function, startCallback?: Function, frameCallback?: Function): void;
-    /**
-     * Breaks the flight.
-     * @public
+     * @param {IPlanetFlyCartesianParams} [params] - Flight parameters
      */
+    flyLonLat(lonlat: LonLat, params?: IPlanetFlyCartesianParams): void;
+    flyDistance(cartesian: Vec3, distance?: number, params?: IPlanetFlyCartesianParams): void;
+    flyCartesian(cartesian: Vec3, params?: IPlanetFlyCartesianParams): void;
     stopFlying(): void;
-    /**
-     * Returns camera is flying.
-     * @public
-     * @returns {boolean}
-     */
-    isFlying(): boolean;
     /**
      * Rotates around planet to the left.
      * @public
@@ -245,11 +190,6 @@ declare class PlanetCamera extends Camera {
      */
     rotateDown(angle: number): void;
     rotateVertical(angle: number, center: Vec3, minSlope?: number): void;
-    /**
-     * Prepare camera to the frame. Used in render node frame function.
-     * @public
-     */
-    checkFly(): void;
     checkTerrainCollision(): Vec3 | undefined;
     getSurfaceVisibleDistance(d: number): number;
     /**

package/lib/control/MouseNavigation.d.ts

@@ -5,12 +5,36 @@ import { Quat } from "../math/Quat";
 import { Sphere } from "../bv/Sphere";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
-interface IEarthNavigationParams extends IControlParams {
-    speed?: number;
+import { type EventsHandler } from "../Events";
+interface IMouseNavigationParams extends IControlParams {
     fixedUp?: boolean;
+    inertia?: number;
+    dragInertia?: number;
+    minSlope?: number;
+    mass?: number;
+    zoomSpeed?: number;
 }
+export type MouseNavigationEventsList = [
+    "drag",
+    "zoom",
+    "rotate"
+];
+/**
+ * Mouse navigation.
+ * @class
+ * @extends {Control}
+ * @param {IMouseNavigationParams} [options] - Mouse navigation options:
+ * @param {boolean} [options.fixedUp] - fix up at north pole
+ * @param {number} [options.inertia] - inertia factor
+ * @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.zoomSpeed] - zoom speed factor. Default is 1
+ * @fires og.MouseNavigation#drag
+ * @fires og.MouseNavigation#zoom
+ * @fires og.MouseNavigation#rotate
+ */
 export declare class MouseNavigation extends Control {
-    speed: number;
     force: Vec3;
     force_h: number;
     force_v: number;
@@ -18,8 +42,13 @@ export declare class MouseNavigation extends Control {
     vel_h: number;
     vel_v: number;
     mass: number;
+    minSlope: number;
+    inertia: number;
+    dragInertia: number;
+    zoomSpeed: number;
     vel_roll: number;
     force_roll: number;
+    events: EventsHandler<MouseNavigationEventsList>;
     protected _lookPos: Vec3 | undefined;
     protected _grabbedPoint: Vec3 | null;
     protected _targetZoomPoint: Vec3 | null;
@@ -46,8 +75,7 @@ export declare class MouseNavigation extends Control {
     protected _screenPosIsChanged: boolean;
     protected _rotHDir: number;
     protected _rotVDir: number;
-    protected _dragInertia: number;
-    constructor(options?: IEarthNavigationParams);
+    constructor(options?: IMouseNavigationParams);
     oninit(): void;
     onadd(): void;
     onremove(): void;
@@ -75,6 +103,7 @@ export declare class MouseNavigation extends Control {
     protected _updateVel_v(): void;
     protected _updateVel_roll(): void;
     protected get dt(): number;
+    protected get velocityInertia(): number;
     stop(): void;
 }
 export {};

package/lib/control/TouchNavigation.d.ts

@@ -6,8 +6,15 @@ import { Sphere } from "../bv/Sphere";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import type { ITouchState } from "../renderer/RendererEvents";
+import { EventsHandler } from "../Events";
 interface ITouchNavigationParams extends IControlParams {
+    inertia?: number;
 }
+export type TouchNavigationEventsList = [
+    "inertiamove",
+    "drag",
+    "doubletapzoom"
+];
 declare class TouchExt {
     x: number;
     y: number;
@@ -25,10 +32,18 @@ declare class TouchExt {
 }
 /**
  * Touch pad planet camera dragging control.
+ * @class
+ * @extends {Control}
+ * @param {ITouchNavigationParams} [options] - Mouse navigation options:
+ * @param {number} [options.inertia] - inertia factor. Default is 0.007
+ * @fires og.TouchNavigation#inertiamove
+ * @fires og.TouchNavigation#drag
+ * @fires og.TouchNavigation#doubletapzoom
  */
 export declare class TouchNavigation extends Control {
     grabbedPoint: Vec3;
     inertia: number;
+    events: EventsHandler<TouchNavigationEventsList>;
     protected grabbedSpheroid: Sphere;
     protected qRot: Quat;
     protected scaleRot: number;

package/lib/entity/Entity.d.ts

@@ -264,6 +264,7 @@ declare class Entity {
     protected _qFrame: Quat;
     protected _qRot: Quat;
     _absoluteQRot: Quat;
+    protected _useDirectQuaternion: boolean;
     constructor(options?: IEntityParams);
     get isEmpty(): boolean;
     /**
@@ -401,6 +402,13 @@ declare class Entity {
      * @param {Quat} rot - The new rotation quaternion.
      */
     setRotation(rot: Quat): void;
+    /**
+     * Sets rotation directly from glTF quaternion with common coordinate system conversion.
+     * This method avoids current pitch/yaw/roll airplane like conversion.
+     * @public
+     * @param {Quat} rot - Quaternion from glTF
+     */
+    setDirectQuaternionRotation(rot: Quat): void;
     /**
      * Sets the pitch rotation of the entity.
      * @param {number} val - The new pitch angle in radians.