@polygonjs/polygonjs/dist/src/engine/viewers/_Base.d.ts

node-based WebGL 3D engine https://polygonjs.com

import { ApplicableControlsNode } from './../../core/camera/CoreCameraControlsController';
import { ViewerCamerasController } from './utils/ViewerCamerasController';
import { ViewerControlsController } from './utils/ViewerControlsController';
import { ViewerEventsController } from './utils/ViewerEventsController';
import { ViewerWebGLController } from './utils/ViewerWebglController';
import { ViewerAudioController } from './utils/ViewerAudioController';
import { Camera, Object3D, Vector2 } from 'three';
import { PolyScene } from '../scene/PolyScene';
import { PolyEngine } from '../Poly';
import { AbstractRenderer } from './Common';
import { ViewerRaycastersController } from './utils/ViewerRaycastersController';
import { ViewerPerformanceMonitor } from './utils/ViewerPerformanceMonitor';
import { AvailableRenderConfig } from '../../core/camera/CoreCameraRendererController';
type ViewerTickCallback = (delta: number) => void;
type ViewerRenderCallback = (delta: number, renderer: AbstractRenderer) => void;
type OnResizeCallback = (width: number, height: number) => void;
interface BaseViewerCallbackOptions {
    persistent?: boolean;
}
export interface HTMLElementWithViewer<C extends Camera> extends HTMLElement {
    scene: PolyScene;
    viewer: TypedViewer<C>;
    Poly: PolyEngine;
}
type UpdateCameraAspectCallback = (aspect: number, resolution: Vector2) => void;
export interface CreateViewerOptions {
    canvas?: HTMLCanvasElement;
    autoRender?: boolean;
    renderer?: AbstractRenderer;
    cameraMaskOverride?: string;
}
export interface TypedViewerOptions<C extends Camera> extends CreateViewerOptions {
    camera: C;
    scene: PolyScene;
    updateCameraAspect: UpdateCameraAspectCallback;
}
export interface TypedViewerInterectionObserverChangeOptions {
    root?: HTMLElement;
    rootMargin?: string;
    threshold?: number;
    playPauseScene?: boolean;
    onChange?: (isIntersecting: boolean) => void;
}
export interface BaseViewerMountOptions {
    updateAutoRenderOnIntersectionChange?: boolean;
}
type RenderFuncWithDelta = (delta: number) => void;
type RenderFunc = () => void;
/**
 *
 *
 * Base class to create a viewer. It is used for the [Threejs viewer](/docs/api/ThreejsViewer) as well as the [Mapbox Viewer](https://github.com/polygonjs/plugin-mapbox)
 *
 */
export declare abstract class TypedViewer<C extends Camera> {
    protected _domElement: HTMLElementWithViewer<C> | undefined;
    protected _active: boolean;
    private static _nextViewerId;
    private _id;
    protected _renderObjectOverride: Object3D | undefined;
    protected _canvas: HTMLCanvasElement | undefined;
    protected _camera: C;
    protected _scene: PolyScene;
    readonly updateCameraAspect: UpdateCameraAspectCallback;
    protected _doRender: boolean;
    protected _controlsNode: ApplicableControlsNode | undefined;
    protected _renderFunc: RenderFuncWithDelta | undefined;
    protected _renderCSSFunc: RenderFunc | undefined;
    protected _renderer: AbstractRenderer | undefined;
    constructor(options: TypedViewerOptions<C>);
    private static _nextId;
    createRaycaster(): import("three").Raycaster;
    abstract renderer(): AbstractRenderer | undefined;
    abstract rendererConfig(): AvailableRenderConfig | undefined;
    protected _mounted: boolean;
    /**
     * mounts the viewer onto an element
     *
     *
     */
    mount(element: HTMLElement, options?: BaseViewerMountOptions): void;
    /**
     * unmounts the viewer
     *
     *
     */
    unmount(): void;
    static _canvasIdPrefix(): string;
    static createCanvas(id?: string): HTMLCanvasElement;
    controlsNode(): ApplicableControlsNode | undefined;
    /**
     * return the canvas and create one if none yet
     *
     *
     */
    canvas(): HTMLCanvasElement;
    protected _tickAndRender(delta: number): void;
    protected _tick(delta: number): void;
    render(delta: number): void;
    protected _postRender(delta: number): void;
    setRenderObjectOverride(object?: Object3D | null): void;
    active(): boolean;
    activate(): void;
    deactivate(): void;
    protected _camerasController: ViewerCamerasController | undefined;
    camerasController(): ViewerCamerasController;
    protected _controlsController: ViewerControlsController<C>;
    controlsController(): ViewerControlsController<C>;
    protected _eventsController: ViewerEventsController | undefined;
    eventsController(): ViewerEventsController;
    protected _webGLController: ViewerWebGLController | undefined;
    webglController(): ViewerWebGLController;
    private _audioController;
    audioController(): ViewerAudioController;
    readonly raycastersController: ViewerRaycastersController;
    readonly performanceMonitor: ViewerPerformanceMonitor;
    domElement(): HTMLElementWithViewer<C> | undefined;
    scene(): PolyScene;
    /**
     * return the camera the viewer was created with
     *
     *
     */
    camera(): C;
    id(): string;
    protected _size: Vector2;
    size(target: Vector2): void;
    updateSize(): void;
    /**
     * disposes the viewer
     *
     *
     */
    dispose(): void;
    resetContainerClass(): void;
    setContainerClassHovered(): void;
    markAsReady(): void;
    /**
     * sets auto render state. If falls, the viewer will not render.
     *
     *
     */
    setAutoRender(state?: boolean): void;
    autoRenderState(): boolean;
    private _observer;
    /**
     * This sets the viewer to detect if it is visible, and to pause/unpause itself when its visibility changes.
     * This can be very useful to improve performance.
     *
     */
    updateAutoRenderOnIntersectionChange(_options: TypedViewerInterectionObserverChangeOptions): void;
    /**
     * Cancels the listening of the viewer's visibility.
     *
     */
    disableUpdateAutoRenderOnIntersectionChange(): void;
    protected _onResizeCallbacks: OnResizeCallback[] | undefined;
    registerOnResizeCallback(callback: OnResizeCallback): void;
    unregisterOnResizeCallback(callback: OnResizeCallback): void;
    protected _runOnResizeCallbacks(): void;
    private _onBeforeTickCallbacksMap;
    private _onAfterTickCallbacksMap;
    protected _onBeforeTickCallbacks: Array<ViewerTickCallback>;
    protected _onAfterTickCallbacks: Array<ViewerTickCallback>;
    private _onBeforeRenderCallbacksMap;
    private _onAfterRenderCallbacksMap;
    protected _onBeforeRenderCallbacks: Array<ViewerRenderCallback>;
    protected _onAfterRenderCallbacks: Array<ViewerRenderCallback>;
    /**
     * registers a BeforeTick callback. BeforeTick callbacks are run before updating the frame (and therefore before any time dependent node has changed)
     *
     */
    registerOnBeforeTick(callbackName: string, callback: ViewerTickCallback, options?: BaseViewerCallbackOptions): void;
    /**
     * unregisters BeforeTick callback
     *
     */
    unRegisterOnBeforeTick(callbackName: string): void;
    /**
     * Returns the list registered BeforeTick callback names
     *
     */
    registeredBeforeTickCallbacks(): Map<any, any>;
    /**
     * registers AfterTick callback. AfterTick callbacks are run after updating the frame (and therefore after any time dependent node has changed)
     *
     */
    registerOnAfterTick(callbackName: string, callback: ViewerTickCallback, options?: BaseViewerCallbackOptions): void;
    /**
     * unregisters AfterTick callback
     *
     */
    unRegisterOnAfterTick(callbackName: string): void;
    /**
     * Returns the list registered AfterTick callback names
     *
     */
    registeredAfterTickCallbacks(): Map<any, any>;
    /**
     * registers a BeforeRender callback. BeforeRender callbacks are run before the frame is rendered
     *
     */
    registerOnBeforeRender(callbackName: string, callback: ViewerRenderCallback, options?: BaseViewerCallbackOptions): void;
    /**
     * unregisters BeforeRender callback
     *
     */
    unRegisterOnBeforeRender(callbackName: string): void;
    /**
     * Returns the list registered BeforeRender callback names
     *
     */
    registeredBeforeRenderCallbacks(): Map<any, any>;
    /**
     * registers a AfterRender callback. AfterRender callbacks are run after the frame is rendered
     *
     */ registerOnAfterRender(callbackName: string, callback: ViewerRenderCallback, options?: BaseViewerCallbackOptions): void;
    /**
     * unregisters AfterRender callback
     *
     */
    unRegisterOnAfterRender(callbackName: string): void;
    /**
     * Returns the list AfterRender BeforeRender callback names
     *
     */
    registeredAfterRenderCallbacks(): Map<any, any>;
    private _registerCallback;
    private _unregisterCallback;
    private _updateCallbacks;
    private _runTickCallbacks;
    private _runRenderCallbacks;
    protected _runOnBeforeTickCallbacks(delta: number): void;
    protected _runOnAfterTickCallbacks(delta: number): void;
    protected _runOnBeforeRenderCallbacks(delta: number, renderer: AbstractRenderer): void;
    protected _runOnAfterRenderCallbacks(delta: number, renderer: AbstractRenderer): void;
}
export type BaseViewerType = TypedViewer<Camera>;
export {};