@itwin/core-frontend/lib/cjs/render/RenderTarget.d.ts

iTwin.js frontend components

/** @packageDocumentation
 * @module Rendering
 */
import { Id64String } from "@itwin/core-bentley";
import { ImageBuffer } from "@itwin/core-common";
import { XAndY } from "@itwin/core-geometry";
import { IModelConnection } from "../IModelConnection";
import { HiliteSet } from "../SelectionSet";
import { SceneContext } from "../ViewContext";
import { ReadImageBufferArgs, Viewport } from "../Viewport";
import { ViewRect } from "../common/ViewRect";
import { CanvasDecoration } from "./CanvasDecoration";
import { Decorations } from "./Decorations";
import { FeatureSymbology } from "./FeatureSymbology";
import { FrameStatsCollector } from "../internal/render/FrameStatsCollector";
import { AnimationBranchStates } from "../internal/render/AnimationBranchState";
import { CustomGraphicBuilderOptions, ViewportGraphicBuilderOptions } from "./GraphicBuilder";
import { Pixel } from "./Pixel";
import { GraphicList } from "./RenderGraphic";
import { RenderMemory } from "./RenderMemory";
import { RenderPlan } from "../internal/render/RenderPlan";
import { RenderPlanarClassifier } from "../internal/render/RenderPlanarClassifier";
import { RenderSystem } from "./RenderSystem";
import { Scene } from "./Scene";
import { QueryTileFeaturesOptions, QueryVisibleFeaturesCallback } from "./VisibleFeature";
import { ActiveSpatialClassifier } from "../SpatialClassifiersState";
import { _implementationProhibited } from "../common/internal/Symbols";
import { RenderTextureDrape } from "../internal/render/RenderTextureDrape";
import { RenderTargetDebugControl } from "../internal/render/RenderTargetDebugControl";
/** Connects a [[Viewport]] to a graphics renderer such as a [WebGLRenderingContext](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext)
 * to enable the viewport's contents to be rendered to the screen or to an off-screen buffer.
 * Application code never interacts directly with a `RenderTarget` - it interacts with the `Viewport`'s API which forwards requests to the `RenderTarget`.
 * @public
 */
export declare abstract class RenderTarget implements Disposable, RenderMemory.Consumer {
    /** @internal */
    protected abstract readonly [_implementationProhibited]: unknown;
    /** @internal */
    pickOverlayDecoration(_pt: XAndY): CanvasDecoration | undefined;
    /** @internal */
    abstract get renderSystem(): RenderSystem;
    /** NB: *Device pixels*, not CSS pixels! */
    /** @internal */
    abstract get viewRect(): ViewRect;
    /** @internal */
    get devicePixelRatio(): number;
    /** @internal */
    cssPixelsToDevicePixels(cssPixels: number, floor?: boolean): number;
    /** Given the size of a logical pixel in meters, convert it to the size of a physical pixel in meters, if [[RenderSystem.dpiAwareLOD]] is `true`.
     * Used when computing LOD for graphics.
     */
    /** @internal */
    adjustPixelSizeForLOD(cssPixelSize: number): number;
    /** @internal */
    abstract get wantInvertBlackBackground(): boolean;
    /** @internal */
    abstract get analysisFraction(): number;
    abstract set analysisFraction(fraction: number);
    /** @internal */
    get animationBranches(): AnimationBranchStates | undefined;
    set animationBranches(_transforms: AnimationBranchStates | undefined);
    /** @internal */
    get antialiasSamples(): number;
    set antialiasSamples(_numSamples: number);
    /** @internal */
    assignFrameStatsCollector(_collector: FrameStatsCollector): void;
    /** Update the solar shadow map. If a SceneContext is supplied, shadows are enabled; otherwise, shadows are disabled. */
    /** @internal */
    updateSolarShadows(_context: SceneContext | undefined): void;
    /** @internal */
    getPlanarClassifier(_id: string): RenderPlanarClassifier | undefined;
    /** @internal */
    createPlanarClassifier(_properties?: ActiveSpatialClassifier): RenderPlanarClassifier | undefined;
    /** @internal */
    getTextureDrape(_id: Id64String): RenderTextureDrape | undefined;
    /** @internal */
    createGraphicBuilder(options: CustomGraphicBuilderOptions | ViewportGraphicBuilderOptions): import("./GraphicBuilder").GraphicBuilder;
    /** @internal */
    [Symbol.dispose](): void;
    /** @internal */
    reset(_realityMapLayerChanged?: boolean): void;
    /** @internal */
    abstract changeScene(scene: Scene): void;
    /** @internal */
    abstract changeDynamics(foreground: GraphicList | undefined, overlay: GraphicList | undefined): void;
    /** @internal */
    abstract changeDecorations(decorations: Decorations): void;
    /** @internal */
    abstract changeRenderPlan(plan: RenderPlan): void;
    /** @internal */
    abstract drawFrame(sceneMilSecElapsed?: number): void;
    /** @internal */
    overrideFeatureSymbology(_ovr: FeatureSymbology.Overrides): void;
    /** @internal */
    setHiliteSet(_hilited: HiliteSet): void;
    /** @internal */
    setFlashed(_elementId: Id64String, _intensity: number): void;
    /** @internal */
    onBeforeRender(_viewport: Viewport, _setSceneNeedRedraw: (redraw: boolean) => void): void;
    /** @internal */
    abstract setViewRect(_rect: ViewRect, _temporary: boolean): void;
    /** @internal */
    onResized(): void;
    /** @internal */
    abstract updateViewRect(): boolean;
    /** `rect` is specified in *CSS* pixels. */
    /** @internal */
    abstract readPixels(rect: ViewRect, selector: Pixel.Selector, receiver: Pixel.Receiver, excludeNonLocatable: boolean, excludedElements?: Iterable<Id64String>): void;
    /** @internal */
    readImageBuffer(_args?: ReadImageBufferArgs): ImageBuffer | undefined;
    /** @internal */
    readImageToCanvas(_overlayCanvas?: HTMLCanvasElement): HTMLCanvasElement;
    /** @internal */
    collectStatistics(_stats: RenderMemory.Statistics): void;
    /** Specify whether webgl content should be rendered directly to the screen.
     * If rendering to screen becomes enabled, returns the canvas to which to render the webgl content.
     * Returns undefined if rendering to screen becomes disabled, or is not supported by this RenderTarget.
     */
    /** @internal */
    setRenderToScreen(_toScreen: boolean): HTMLCanvasElement | undefined;
    /** @internal */
    get debugControl(): RenderTargetDebugControl | undefined;
    /** An ordered list of names of screen-space post-processing effects to be applied to the image produced by this target.
     * The effects are applied in the order in which they appear in the list. Any names not corresponding to a registered effect are ignored.
     * This may have no effect if this target does not support screen-space effects.
     * @see [[RenderSystem.createScreenSpaceEffectBuilder]] to create and register new effects.
     */
    /** @internal */
    abstract get screenSpaceEffects(): Iterable<string>;
    abstract set screenSpaceEffects(_effectNames: Iterable<string>);
    /** Implementation for [[Viewport.queryVisibleFeatures]]. Not intended for direct usage. The returned iterable remains valid only for the duration of the
     * Viewport.queryVisibleFeatures call.
     */
    /** @internal */
    queryVisibleTileFeatures(_options: QueryTileFeaturesOptions, _iModel: IModelConnection, callback: QueryVisibleFeaturesCallback): void;
}
//# sourceMappingURL=RenderTarget.d.ts.map