@expofp/renderer 2.3.1 → 3.0.0

package/dist/index.d.ts

@@ -145,7 +145,7 @@ export declare interface EngineEvents {
     /** Mouse click */
     "pointer:click": MouseEventData;
     /** Viewport pixel to svg scale */
-    "viewport:ptscale": number;
+    "viewport:ptscale": PtScaleEventData;
 }
 
 export declare type EventHandler<Payload> = (payload: Payload) => void;
@@ -294,10 +294,8 @@ export declare interface LineDef extends SharedDef {
 export declare interface MouseEventData {
     /** Original mouse event */
     event: MouseEvent;
-    /** Point in svg coordinates */
-    point: Vector2Like;
-    /** Intersected defs */
-    defs: RenderableDef[];
+    /** Translated pointer data for each loaded scene */
+    data: PointWithinSceneData[];
 }
 
 /**
@@ -316,6 +314,16 @@ export declare interface PitchHandlerOptions {
     maxPitch?: number;
 }
 
+/** Point within a scene coupled with the scene identifier and intersected defs */
+export declare interface PointWithinSceneData {
+    /** Point in SVG/model coordinates. */
+    point: Vector2Like;
+    /** Identifier of the scene that contains the point. Undefined in case of default scene. */
+    sceneId?: string;
+    /** Intersected defs */
+    defs: RenderableDef[];
+}
+
 /** Polygon shape instance. */
 export declare class Polygon {
     private _indices;
@@ -367,6 +375,14 @@ export declare class Polygon {
     private computeBoundingRect;
 }
 
+/** Data for ptScale events */
+export declare interface PtScaleEventData {
+    /** Scene identifier, undefined for default scene */
+    sceneId?: string;
+    /** Pixel to SVG scale factor */
+    ptScale: number;
+}
+
 /** Rectangle shape instance. */
 export declare class Rect {
     /** Optional rotation of the rectangle. In radians, around center. Positive values rotate clockwise. */
@@ -433,19 +449,20 @@ export declare class Renderer {
     readonly canvas: HTMLCanvasElement;
     private ui?;
     private gl?;
+    private ctx;
+    private clock;
+    private renderer;
+    private memoryInfoExtension;
+    private memoryInfo?;
     private eventSystem;
     private layerSystem;
     private viewportSystem;
+    private updatesSystem;
     private interactionsSystem;
-    private controlsSystem;
+    private controlsSystem?;
     private controlsAPI?;
     private eventsAPI?;
     private viewportAPI?;
-    private clock;
-    private renderer;
-    private visibleRectValue?;
-    private memoryInfoExtension;
-    private memoryInfo?;
     private initialized;
     private disposed;
     private needsRedraw;
@@ -453,24 +470,27 @@ export declare class Renderer {
      * @param opts {@link RendererOptions}
      */
     constructor(opts: RendererOptions);
-    /**
-     * {@link ControlsAPI} instance for controlling the viewport
-     */
-    get controls(): ControlsAPI;
     /**
      * {@link EventsAPI} instance for subscribing to internal events
      */
     get events(): EventsAPI;
     /**
-     * {@link ViewportAPI} instance for view transforms and external transforms.
+     * {@link ControlsAPI} instance for controlling the viewport
+     */
+    get controls(): ControlsAPI;
+    /**
+     * {@link ViewportAPI} instance for view transforms and coordinate conversion.
      */
     get viewport(): ViewportAPI;
     /**
-     * Optional sub-rectangle of the viewport that is used for positioning scene's viewbox
+     * Optional CSS-pixel sub-rectangle of the viewport used for positioning the scene's viewbox.
      */
     get visibleRect(): Rect | undefined;
     /**
-     * Optional sub-rectangle of the viewport that is used for positioning scene's viewbox
+     * Sets the CSS-pixel visible sub-rectangle.
+     * Triggers a viewport transform recompute (and schedules a redraw) only if the renderer
+     * is already initialized and not disposed; otherwise the value is stored and applied on the
+     * next {@link init} or {@link addScene} call.
      */
     set visibleRect(rect: Rect);
     /**
@@ -482,7 +502,8 @@ export declare class Renderer {
      * Returns true if the renderer is in external mode, meaning that webgl context is managed outside of the renderer
      * (for example, when using Mapbox GL JS as a host context). In this mode renderer will not clear the canvas before
      * rendering, and will not automatically compute scene and camera transformations. Clients are responsible for setting
-     * the matrices manually by using {@link Renderer.viewport} methods.
+     * the transform matrix manually by using {@link SceneDef.staticTransform} and passing camera projection matrix
+     * to {@link render} as an optional argument.
      */
     get isExternalMode(): boolean;
     /**
@@ -498,20 +519,29 @@ export declare class Renderer {
      * Should be called once on startup. Repeated calls will produce console warnings.
      * @param sceneDef {@link SceneDef} to render
      */
-    init(sceneDef: SceneDef): void;
+    init(sceneDef?: SceneDef): void;
+    /**
+     * Add a scene to the renderer. Note that this method is untested in internal mode. Use {@link Renderer.init} instead.
+     * @param sceneDef {@link SceneDef} to render
+     * @param sceneId identifier of the scene (map key)
+     */
+    addScene(sceneDef: SceneDef, sceneId: string): void;
     /**
      * Start the rendering loop
      */
     start(): void;
     /**
-     * Update the given defs to make them reflect the current state
+     * Update the given defs to make them reflect the current state.
+     * Defs are queued for processing and will be applied during the next render frame,
+     * with frustum culling deferring off-screen text and image updates.
      * @param defs {@link RenderableDef} array to update
      */
     update(...defs: RenderableDef[]): void;
     /**
      * Render a single frame
+     * @param cameraProjection optional camera projection matrix. Ignored in internal mode, required in external mode.
      */
-    render(): void;
+    render(cameraProjection?: number[]): void;
     /**
      * Stop the rendering loop
      */
@@ -522,16 +552,13 @@ export declare class Renderer {
      * will result in a console warning and no-op methods. If you need to re-initialize the renderer, create a new instance.
      */
     dispose(): void;
+    private initScene;
     private resizeCanvasToDisplaySize;
-    private updateMemoryInfo;
+    private createRendererContext;
     private onContextLost;
     private onContextRestored;
     private initStatsContext;
-    private assertNotDisposed;
-    private assertInitialized;
-    private assertNotInitialized;
-    private assertNotExternalMode;
-    private assertExternalMode;
+    private updateMemoryInfo;
 }
 
 /**
@@ -576,6 +603,8 @@ export declare interface SceneDef {
     viewbox: Rect;
     /** Textures memory limit in megabytes */
     memoryLimit?: number;
+    /** Static transform matrix */
+    staticTransform?: number[];
 }
 
 export declare type Shape = Rect | Polygon;
@@ -662,19 +691,12 @@ export declare interface ViewportAPI {
     /**
      * Convert canvas coordinates (CSS pixels, relative to canvas top-left) to SVG coordinates.
      * @param point point in canvas space (CSS pixels)
-     * @returns point in SVG coordinates or undefined if point is outside the SVG plane
-     */
-    canvasToSvg: (point: Vector2Like) => Vector2Like | undefined;
-    /**
-     * Set static part of an svg -> px transform matrix
-     * @param staticTransformMatrix static transform matrix to apply to the scene
-     */
-    setStaticTransform: (staticTransformMatrix: number[]) => void;
-    /**
-     * Set dynamic part of an svg -> px transform matrix. Should be called every frame.
-     * @param dynamicTransformMatrix dynamic transform matrix (changes every frame)
+     * @returns Array of points in SVG coordinates of all loaded scenes
      */
-    setDynamicTransform: (dynamicTransformMatrix: number[]) => void;
+    canvasToSvg: (point: Vector2Like) => {
+        point: Vector2Like;
+        sceneId?: string;
+    }[];
     /**
      * Set the maximum zoom factor. Default is 35.
      * @param maxZoom Maximum zoom factor