@visactor/vrender 0.16.0-alpha.3 → 0.16.0-alpha.5

package/cjs/core/stage.d.ts

@@ -0,0 +1,145 @@
+import type { IAABBBounds, IBounds, IBoundsLike, IMatrix } from '@visactor/vutils';
+import { AABBBounds } from '@visactor/vutils';
+import type { IExportType, IStage, IStageParams, ILayer, IColor, IOption3D, ICamera, vec3, IDirectionLight, ITicker, IRenderService, IPickerService, IPluginService, ISyncHook, IDrawContext, IWindow, ILayerService, ITimeline, IOptimizeType, PickResult } from '../interface';
+import type { Layer } from './layer';
+import { Group } from '../graphic';
+export declare class Stage extends Group implements IStage {
+    parent: IStage | null;
+    protected _viewBox: AABBBounds;
+    private _background;
+    private _subView;
+    protected nextFrameRenderLayerSet: Set<Layer>;
+    protected willNextFrameRender: boolean;
+    protected _cursor: string;
+    renderCount: number;
+    dirtyBounds: IBounds | null;
+    option3d?: IOption3D;
+    light?: IDirectionLight;
+    camera?: ICamera;
+    renderStyle?: string;
+    hooks: {
+        beforeRender: ISyncHook<[IStage]>;
+        afterRender: ISyncHook<[IStage]>;
+    };
+    set viewBox(b: IBoundsLike);
+    get viewBox(): AABBBounds;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    get width(): number;
+    set width(w: number);
+    get viewWidth(): number;
+    set viewWidth(w: number);
+    get viewHeight(): number;
+    set viewHeight(h: number);
+    get height(): number;
+    set height(h: number);
+    get dpr(): number;
+    set dpr(r: number);
+    get background(): string | IColor;
+    set background(b: string | IColor);
+    get defaultLayer(): ILayer;
+    ticker: ITicker;
+    autoRender: boolean;
+    _enableLayout: boolean;
+    htmlAttribute: boolean | string | any;
+    increaseAutoRender: boolean;
+    view3dTranform: boolean;
+    readonly window: IWindow;
+    private readonly global;
+    readonly renderService: IRenderService;
+    readonly pickerService: IPickerService;
+    readonly pluginService: IPluginService;
+    readonly layerService: ILayerService;
+    private readonly eventSystem?;
+    protected _beforeRender?: (stage: IStage) => void;
+    protected _afterRender?: (stage: IStage) => void;
+    protected _skipRender?: number;
+    protected _afterNextRenderCbs?: ((stage: IStage) => void)[];
+    protected lastRenderparams?: Partial<IDrawContext>;
+    protected interactiveLayer?: ILayer;
+    protected supportInteractiveLayer: boolean;
+    protected timeline: ITimeline;
+    params: Partial<IStageParams>;
+    constructor(params: Partial<IStageParams>);
+    optmize(params?: IOptimizeType): void;
+    protected optmizeRender(skipRenderWithOutRange?: boolean): void;
+    getTimeline(): ITimeline;
+    get3dOptions(options: IOption3D): {
+        center: {
+            x?: number;
+            y?: number;
+            z?: number;
+            dx?: number;
+            dy?: number;
+            dz?: number;
+        };
+        light: {
+            dir?: vec3;
+            color?: string;
+            ambient?: number;
+        };
+        alpha: number;
+        beta: number;
+        camera: any;
+        fieldRatio: number;
+        fieldDepth: number;
+        enableView3dTransform?: boolean;
+        gama?: number;
+    };
+    set3dOptions(options: IOption3D): void;
+    protected beforeRender: (stage: IStage) => void;
+    protected afterRender: (stage: IStage) => void;
+    setBeforeRender(cb: (stage: IStage) => void): void;
+    setAfterRender(cb: (stage: IStage) => void): void;
+    afterNextRender(cb: (stage: IStage) => void): void;
+    enableView3dTransform(): void;
+    disableView3dTranform(): void;
+    enableAutoRender(): void;
+    disableAutoRender(): void;
+    enableIncrementalAutoRender(): void;
+    disableIncrementalAutoRender(): void;
+    enableDirtyBounds(): void;
+    disableDirtyBounds(): void;
+    enableLayout(): void;
+    disableLayout(): void;
+    enableHtmlAttribute(container?: any): void;
+    disableHtmlAttribute(): void;
+    protected tryUpdateAABBBounds(): AABBBounds;
+    combineLayer(ILayer1: ILayer, ILayer2: ILayer): ILayer;
+    createLayer(canvasId?: string): ILayer;
+    sortLayer(cb: (ILayer1: ILayer, layer2: ILayer) => number): void;
+    removeLayer(ILayerId: number): ILayer | false;
+    tryInitInteractiveLayer(): void;
+    clearViewBox(color?: string): void;
+    render(layers?: ILayer[], params?: Partial<IDrawContext>): void;
+    protected combineLayersToWindow(): void;
+    renderNextFrame(layers?: ILayer[]): void;
+    _doRenderInThisFrame(): void;
+    resizeWindow(w: number, h: number, rerender?: boolean): void;
+    resize(w: number, h: number, rerender?: boolean): void;
+    resizeView(w: number, h: number, rerender?: boolean): void;
+    setViewBox(viewBox: IBoundsLike, rerender: boolean): void;
+    setViewBox(x: number, y: number, w: number, h: number, rerender: boolean): void;
+    setDpr(dpr: number, rerender?: boolean): void;
+    setOrigin(x: number, y: number): void;
+    export(type: IExportType): HTMLCanvasElement | ImageData;
+    pick(x: number, y: number): PickResult | false;
+    startAnimate(t: number): void;
+    setToFrame(t: number): void;
+    release(): void;
+    setStage(stage?: IStage): void;
+    dirty(b: IBounds, matrix?: IMatrix): void;
+    getLayer(name: string): undefined | ILayer;
+    renderTo(window: IWindow, params: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    renderToNewWindow(fullImage?: boolean, viewBox?: IAABBBounds): IWindow;
+    toCanvas(fullImage?: boolean, viewBox?: IAABBBounds): HTMLCanvasElement | null;
+    setCursor(mode?: string): void;
+    getCursor(): string;
+}

package/cjs/core/stage.js

@@ -0,0 +1,435 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.Stage = void 0;
+
+const vutils_1 = require("@visactor/vutils"), window_1 = require("./window"), event_1 = require("../event"), container_1 = require("../container"), render_1 = require("../render"), graphic_1 = require("../graphic"), picker_service_1 = require("../picker/picker-service"), constants_1 = require("../plugins/constants"), auto_render_plugin_1 = require("../plugins/builtin-plugin/auto-render-plugin"), _3dview_transform_plugin_1 = require("../plugins/builtin-plugin/3dview-transform-plugin"), incremental_auto_render_plugin_1 = require("../plugins/builtin-plugin/incremental-auto-render-plugin"), html_attribute_plugin_1 = require("../plugins/builtin-plugin/html-attribute-plugin"), dirty_bounds_plugin_1 = require("../plugins/builtin-plugin/dirty-bounds-plugin"), flex_layout_plugin_1 = require("../plugins/builtin-plugin/flex-layout-plugin"), default_ticker_1 = require("../animate/default-ticker"), tapable_1 = require("../tapable"), light_1 = require("./light"), camera_1 = require("./camera"), constants_2 = require("../constants"), constants_3 = require("./constants"), animate_1 = require("../animate"), DefaultConfig = {
+    WIDTH: 500,
+    HEIGHT: 500,
+    X: 0,
+    Y: 0,
+    BACKGROUND: "white"
+};
+
+class Stage extends graphic_1.Group {
+    set viewBox(b) {
+        this._viewBox.setValue(b.x1, b.y1, b.x2, b.y2);
+    }
+    get viewBox() {
+        return this._viewBox;
+    }
+    get x() {
+        return this._viewBox.x1;
+    }
+    set x(x) {
+        this._viewBox.translate(x - this._viewBox.x1, 0);
+    }
+    get y() {
+        return this._viewBox.y1;
+    }
+    set y(y) {
+        this._viewBox.translate(0, y - this._viewBox.y1);
+    }
+    get width() {
+        return this.window.width;
+    }
+    set width(w) {
+        this.resize(w, this.height);
+    }
+    get viewWidth() {
+        return this._viewBox.width();
+    }
+    set viewWidth(w) {
+        this.resizeView(w, this.viewHeight);
+    }
+    get viewHeight() {
+        return this._viewBox.height();
+    }
+    set viewHeight(h) {
+        this.resizeView(this.viewWidth, h);
+    }
+    get height() {
+        return this.window.height;
+    }
+    set height(h) {
+        this.resize(this.width, h);
+    }
+    get dpr() {
+        return this.window.dpr;
+    }
+    set dpr(r) {
+        this.setDpr(r);
+    }
+    get background() {
+        var _a;
+        return null !== (_a = this._background) && void 0 !== _a ? _a : DefaultConfig.BACKGROUND;
+    }
+    set background(b) {
+        this._background = b;
+    }
+    get defaultLayer() {
+        return this.at(0);
+    }
+    constructor(params) {
+        var _a;
+        super({}), this.beforeRender = stage => {
+            this._beforeRender && this._beforeRender(stage);
+        }, this.afterRender = stage => {
+            this.renderCount++, this._afterRender && this._afterRender(stage), this._afterNextRenderCbs && this._afterNextRenderCbs.forEach((cb => cb(stage))), 
+            this._afterNextRenderCbs = null;
+        }, this.params = params, this.theme = new graphic_1.Theme, this.hooks = {
+            beforeRender: new tapable_1.SyncHook([ "stage" ]),
+            afterRender: new tapable_1.SyncHook([ "stage" ])
+        }, this.global = container_1.container.get(constants_2.VGlobal), this.window = container_1.container.get(window_1.VWindow), 
+        this.renderService = container_1.container.get(render_1.RenderService), this.pickerService = container_1.container.get(picker_service_1.PickerService), 
+        this.pluginService = container_1.container.get(constants_1.PluginService), this.layerService = container_1.container.get(constants_3.LayerService), 
+        this.pluginService.active(this, params), this.window.create({
+            width: params.width,
+            height: params.height,
+            container: params.container,
+            dpr: params.dpr || this.global.devicePixelRatio,
+            canvasControled: !1 !== params.canvasControled,
+            title: params.title || "",
+            canvas: params.canvas
+        }), this._viewBox = new vutils_1.AABBBounds, params.viewBox ? this._viewBox.setValue(params.viewBox.x1, params.viewBox.y1, params.viewBox.x2, params.viewBox.y2) : this._viewBox.setValue(0, 0, this.width, this.height), 
+        this.renderCount = 0, this._subView = !(this._viewBox.width() === this.width && this._viewBox.height() === this.height), 
+        this._background = null !== (_a = params.background) && void 0 !== _a ? _a : DefaultConfig.BACKGROUND, 
+        this.appendChild(this.layerService.createLayer(this, {
+            main: !0
+        })), this.nextFrameRenderLayerSet = new Set, this.willNextFrameRender = !1, this.stage = this, 
+        this.renderStyle = params.renderStyle, this.global.supportEvent && (this.eventSystem = new event_1.EventSystem({
+            targetElement: this.window,
+            resolution: this.window.dpr || this.global.devicePixelRatio,
+            rootNode: this,
+            global: this.global,
+            viewport: {
+                viewBox: this._viewBox,
+                get x() {
+                    return this.viewBox.x1;
+                },
+                get y() {
+                    return this.viewBox.y1;
+                },
+                get width() {
+                    return this.viewBox.width();
+                },
+                get height() {
+                    return this.viewBox.height();
+                }
+            }
+        })), params.autoRender && this.enableAutoRender(), !1 === params.disableDirtyBounds && this.enableDirtyBounds(), 
+        params.enableHtmlAttribute && this.enableHtmlAttribute(params.enableHtmlAttribute), 
+        params.enableLayout && this.enableLayout(), this.hooks.beforeRender.tap("constructor", this.beforeRender), 
+        this.hooks.afterRender.tap("constructor", this.afterRender), this._beforeRender = params.beforeRender, 
+        this._afterRender = params.afterRender, this.ticker = params.ticker || default_ticker_1.defaultTicker, 
+        this.supportInteractiveLayer = !1 !== params.interactiveLayer, this.timeline = new animate_1.DefaultTimeline, 
+        this.ticker.addTimeline(this.timeline), this.timeline.pause(), this.optmize(params.optimize);
+    }
+    optmize(params) {
+        this.optmizeRender(null == params ? void 0 : params.skipRenderWithOutRange);
+    }
+    optmizeRender(skipRenderWithOutRange = !0) {
+        skipRenderWithOutRange && (this._skipRender = this.window.isVisible() ? 0 : 1, this.window.onVisibleChange((visible => {
+            visible ? (this.dirtyBounds && this.dirtyBounds.setValue(0, 0, this._viewBox.width(), this._viewBox.height()), 
+            this._skipRender > 1 && this.renderNextFrame(), this._skipRender = 0) : this._skipRender = 1;
+        })));
+    }
+    getTimeline() {
+        return this.timeline;
+    }
+    get3dOptions(options) {
+        const {center: center = {
+            x: this.width / 2,
+            y: this.height / 2,
+            z: 0,
+            dx: 0,
+            dy: 0,
+            dz: 0
+        }, light: light = {}, alpha: alpha = 0, beta: beta = 0, camera: camera, fieldRatio: fieldRatio = 1, fieldDepth: fieldDepth} = options;
+        return Object.assign(Object.assign({}, options), {
+            center: center,
+            light: light,
+            alpha: alpha,
+            beta: beta,
+            camera: camera,
+            fieldRatio: fieldRatio,
+            fieldDepth: fieldDepth
+        });
+    }
+    set3dOptions(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this.option3d = options;
+        const options3d = this.get3dOptions(options), {light: light, center: center, camera: camera, alpha: alpha, beta: beta, fieldRatio: fieldRatio, fieldDepth: fieldDepth} = options3d, {dir: dir = [ 1, 1, -1 ], color: color = "white", ambient: ambient} = light, centerX = (null !== (_a = center.x) && void 0 !== _a ? _a : this.width / 2) + (null !== (_b = center.dx) && void 0 !== _b ? _b : 0), centerY = (null !== (_c = center.y) && void 0 !== _c ? _c : this.height / 2) + (null !== (_d = center.dy) && void 0 !== _d ? _d : 0), centerVec3 = [ centerX, centerY, (null !== (_e = center.z) && void 0 !== _e ? _e : 0) + (null !== (_f = center.dz) && void 0 !== _f ? _f : 0) ];
+        let cameraX = 0, cameraY = 0, cameraZ = 0;
+        camera || (cameraX = Math.sin(alpha) + centerX, cameraY = Math.sin(beta) + centerY, 
+        cameraZ = Math.cos(alpha) * Math.cos(beta) * 1), this.light = new light_1.DirectionalLight(dir, color, ambient);
+        const cameraParams = {
+            left: 0,
+            right: this.width,
+            top: 0,
+            bottom: this.height,
+            fieldRatio: fieldRatio,
+            fieldDepth: fieldDepth,
+            viewParams: {
+                pos: [ cameraX, cameraY, cameraZ ],
+                center: centerVec3,
+                up: [ 0, 1, 0 ]
+            }
+        };
+        this.camera ? this.camera.params = cameraParams : this.camera = new camera_1.OrthoCamera(cameraParams), 
+        options.enableView3dTransform && this.enableView3dTransform();
+    }
+    setBeforeRender(cb) {
+        this._beforeRender = cb;
+    }
+    setAfterRender(cb) {
+        this._afterRender = cb;
+    }
+    afterNextRender(cb) {
+        this._afterNextRenderCbs || (this._afterNextRenderCbs = []), this._afterNextRenderCbs.push(cb);
+    }
+    enableView3dTransform() {
+        this.view3dTranform || (this.view3dTranform = !0, this.pluginService.register(new _3dview_transform_plugin_1.ViewTransform3dPlugin));
+    }
+    disableView3dTranform() {
+        this.view3dTranform && (this.view3dTranform = !1, this.pluginService.findPluginsByName("ViewTransform3dPlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    enableAutoRender() {
+        this.autoRender || (this.autoRender = !0, this.pluginService.register(new auto_render_plugin_1.AutoRenderPlugin));
+    }
+    disableAutoRender() {
+        this.autoRender && (this.autoRender = !1, this.pluginService.findPluginsByName("AutoRenderPlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    enableIncrementalAutoRender() {
+        this.increaseAutoRender || (this.increaseAutoRender = !0, this.pluginService.register(new incremental_auto_render_plugin_1.IncrementalAutoRenderPlugin));
+    }
+    disableIncrementalAutoRender() {
+        this.increaseAutoRender && (this.increaseAutoRender = !1, this.pluginService.findPluginsByName("IncrementalAutoRenderPlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    enableDirtyBounds() {
+        if (this.dirtyBounds) return;
+        this.dirtyBounds = new vutils_1.Bounds;
+        let plugin = this.pluginService.findPluginsByName("DirtyBoundsPlugin")[0];
+        plugin || (plugin = new dirty_bounds_plugin_1.DirtyBoundsPlugin, this.pluginService.register(plugin)), 
+        plugin.activate(this.pluginService);
+    }
+    disableDirtyBounds() {
+        this.dirtyBounds && (this.dirtyBounds = null, this.pluginService.findPluginsByName("DirtyBoundsPlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    enableLayout() {
+        this._enableLayout || (this._enableLayout = !0, this.pluginService.register(new flex_layout_plugin_1.FlexLayoutPlugin));
+    }
+    disableLayout() {
+        this._enableLayout && (this._enableLayout = !1, this.pluginService.findPluginsByName("FlexLayoutPlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    enableHtmlAttribute(container) {
+        this.htmlAttribute || (this.htmlAttribute = container, this.pluginService.register(new html_attribute_plugin_1.HtmlAttributePlugin));
+    }
+    disableHtmlAttribute() {
+        this.htmlAttribute && (this.htmlAttribute = !1, this.pluginService.findPluginsByName("HtmlAttributePlugin").forEach((plugin => {
+            plugin.deactivate(this.pluginService);
+        })));
+    }
+    tryUpdateAABBBounds() {
+        const viewBox = this._viewBox;
+        return this._AABBBounds.setValue(viewBox.x1, viewBox.y1, viewBox.x2, viewBox.y2), 
+        this._AABBBounds;
+    }
+    combineLayer(ILayer1, ILayer2) {
+        throw new Error("暂不支持");
+    }
+    createLayer(canvasId) {
+        const layer = this.layerService.createLayer(this, {
+            main: !1,
+            canvasId: canvasId
+        });
+        return this.appendChild(layer), layer;
+    }
+    sortLayer(cb) {
+        const children = this.children;
+        children.sort(cb), this.removeAllChild(), children.forEach((c => {
+            this.appendChild(c);
+        }));
+    }
+    removeLayer(ILayerId) {
+        return this.removeChild(this.findChildByUid(ILayerId));
+    }
+    tryInitInteractiveLayer() {
+        this.supportInteractiveLayer && !this.interactiveLayer && (this.interactiveLayer = this.createLayer(), 
+        this.interactiveLayer.name = "_builtin_interactive", this.nextFrameRenderLayerSet.add(this.interactiveLayer));
+    }
+    clearViewBox(color) {
+        this.window.clearViewBox(this._viewBox, color);
+    }
+    render(layers, params) {
+        this.ticker.start(), this.timeline.resume(), this._skipRender || (this.lastRenderparams = params, 
+        this.hooks.beforeRender.call(this), (layers || this).forEach(((layer, i) => {
+            layer.render({
+                renderService: this.renderService,
+                background: layer === this.defaultLayer ? this.background : void 0,
+                updateBounds: !!this.dirtyBounds
+            }, Object.assign({
+                renderStyle: this.renderStyle
+            }, params));
+        })), this.combineLayersToWindow(), this.nextFrameRenderLayerSet.clear(), this.hooks.afterRender.call(this)), 
+        this._skipRender && this._skipRender++;
+    }
+    combineLayersToWindow() {
+        this.forEach(((layer, i) => {
+            layer.combineTo(this.window, {
+                clear: 0 === i,
+                x: this.x,
+                y: this.y,
+                width: this.viewWidth,
+                height: this.viewHeight,
+                renderService: this.renderService,
+                background: layer === this.defaultLayer ? this.background : void 0,
+                updateBounds: !!this.dirtyBounds
+            });
+        }));
+    }
+    renderNextFrame(layers) {
+        this.nextFrameRenderLayerSet.size !== this.childrenCount && (layers || this).forEach((layer => {
+            this.nextFrameRenderLayerSet.add(layer);
+        })), this.willNextFrameRender || (this.willNextFrameRender = !0, this.global.getRequestAnimationFrame()((() => {
+            this._doRenderInThisFrame(), this.willNextFrameRender = !1;
+        })));
+    }
+    _doRenderInThisFrame() {
+        this.timeline.resume(), this.ticker.start(), this.nextFrameRenderLayerSet.size && !this._skipRender && (this.hooks.beforeRender.call(this), 
+        this.forEach((layer => {
+            this.nextFrameRenderLayerSet.has(layer) && layer.render({
+                renderService: this.renderService,
+                background: layer === this.defaultLayer ? this.background : void 0,
+                updateBounds: !!this.dirtyBounds
+            }, Object.assign({
+                renderStyle: this.renderStyle
+            }, this.lastRenderparams || {}));
+        })), this.combineLayersToWindow(), this.hooks.afterRender.call(this), this.nextFrameRenderLayerSet.clear()), 
+        this._skipRender && this._skipRender++;
+    }
+    resizeWindow(w, h, rerender = !0) {
+        this.window.resize(w, h), rerender && this.render();
+    }
+    resize(w, h, rerender = !0) {
+        this.window.resize(w, h), this.forEachChildren((c => {
+            c.resize(w, h);
+        })), this._subView || this.viewBox.setValue(this.viewBox.x1, this.viewBox.y1, this.viewBox.x1 + w, this.viewBox.y1 + h), 
+        this.camera && this.option3d && this.set3dOptions(this.option3d), rerender && this.render();
+    }
+    resizeView(w, h, rerender = !0) {
+        this.viewBox.setValue(this.viewBox.x1, this.viewBox.y1, this.viewBox.x1 + w, this.viewBox.y1 + h), 
+        this.forEachChildren((c => {
+            c.resizeView(w, h);
+        })), this.camera && (this.camera.params = Object.assign(Object.assign({}, this.camera.params), {
+            right: this.width,
+            bottom: this.height
+        })), rerender && this.render();
+    }
+    setViewBox(x, y, w, h, rerender) {
+        let isRerender = !0;
+        "object" == typeof x ? (this.viewBox.setValue(x.x1, x.y1, x.x2, x.y2), !1 === y && (isRerender = !1)) : (this.viewBox.setValue(x, y, x + w, y + h), 
+        !1 === rerender && (isRerender = !1)), this.forEachChildren((c => {
+            c.resizeView(this.viewBox.width(), this.viewBox.height());
+        })), isRerender && this.render();
+    }
+    setDpr(dpr, rerender = !0) {
+        this.forEachChildren((c => {
+            c.setDpr(dpr);
+        })), rerender && this.render();
+    }
+    setOrigin(x, y) {
+        throw new Error("暂不支持");
+    }
+    export(type) {
+        throw new Error("暂不支持");
+    }
+    pick(x, y) {
+        const result = this.pickerService.pick(this.children, new vutils_1.Point(x, y), {
+            bounds: this.AABBBounds
+        });
+        return !(!(null == result ? void 0 : result.graphic) && !(null == result ? void 0 : result.group)) && result;
+    }
+    startAnimate(t) {
+        throw new Error("暂不支持");
+    }
+    setToFrame(t) {
+        throw new Error("暂不支持");
+    }
+    release() {
+        super.release(), this.eventSystem && this.eventSystem.release(), this.pluginService.release(), 
+        this.forEach((layer => {
+            layer.release();
+        })), this.interactiveLayer && this.interactiveLayer.release(), this.window.release();
+    }
+    setStage(stage) {}
+    dirty(b, matrix) {
+        matrix && b.transformWithMatrix(matrix), this.dirtyBounds.empty() && this.dirtyBounds.setValue(b.x1, b.y1, b.x2, b.y2), 
+        this.dirtyBounds.union(b);
+    }
+    getLayer(name) {
+        return this.children.filter((layer => layer.name === name))[0];
+    }
+    renderTo(window, params) {
+        this.forEachChildren(((layer, i) => {
+            layer.drawTo(window, Object.assign(Object.assign({}, params), {
+                renderService: this.renderService,
+                background: layer === this.defaultLayer ? this.background : void 0,
+                clear: 0 === i,
+                updateBounds: !!this.dirtyBounds
+            }));
+        }));
+    }
+    renderToNewWindow(fullImage = !0, viewBox) {
+        const window = container_1.container.get(window_1.VWindow);
+        if (fullImage) window.create({
+            width: this.viewWidth,
+            height: this.viewHeight,
+            dpr: this.window.dpr,
+            canvasControled: !0,
+            offscreen: !0,
+            title: ""
+        }); else {
+            const width = viewBox ? viewBox.width() : Math.min(this.viewWidth, this.window.width - this.x), height = viewBox ? viewBox.height() : Math.min(this.viewHeight, this.window.height - this.y);
+            window.create({
+                width: width,
+                height: height,
+                dpr: this.window.dpr,
+                canvasControled: !0,
+                offscreen: !0,
+                title: ""
+            });
+        }
+        const x = viewBox ? -viewBox.x1 : 0, y = viewBox ? -viewBox.y1 : 0;
+        return this.renderTo(window, {
+            x: x,
+            y: y,
+            width: viewBox ? viewBox.x2 : window.width,
+            height: viewBox ? viewBox.y2 : window.height
+        }), window;
+    }
+    toCanvas(fullImage = !0, viewBox) {
+        const c = this.renderToNewWindow(fullImage, viewBox).getNativeHandler();
+        return c.nativeCanvas ? c.nativeCanvas : null;
+    }
+    setCursor(mode) {
+        this._cursor = mode, this.eventSystem.setCursor(mode);
+    }
+    getCursor() {
+        return this._cursor;
+    }
+}
+
+exports.Stage = Stage;
+//# sourceMappingURL=stage.js.map