/// <reference path="../library/typings/pixi.js.d.ts" />
/// <reference path="../library/typings/native.d.ts" />
/// <reference path="../library/typings/cross-editor.d.ts" />
/// <reference path="../typings/private/foundation-editor-base.d.ts" />
/// <reference path="../typings/private/foundation-editor-view.d.ts" />
declare module "copyright" {
    export class SystemCopyright {
        static toString(): string;
    }
}
declare module "sk/editor/render/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/editor/render/pixi/IPixiObject" {
    import { V2dCanvasContext } from 'foundation/editor/view/view2d/V2dCanvasContext';
    export interface IPixiObject {
        className: string;
        context: V2dCanvasContext;
        optionWorker: boolean;
        name: string;
        hashCode: number;
        handle: any;
        statusBatch: boolean;
    }
}
declare module "sk/editor/render/util/CrossCollision2dUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    class CrossCollision2d {
        protected _input: SkNative.FClipperInput;
        protected _output: SkNative.FClipperOutput;
        constructor();
        wrtieInputPath(input: SkNative.FClipperInput, points: Array<Value2>): void;
        readOutputPath(output: SkNative.FClipperOutput): Array<Vector2>;
        readOutputPaths(output: SkNative.FClipperOutput): Array<Array<Vector2>>;
        simplifyPolygon(data: Array<Value2>, scale?: number): Array<Array<Vector2>>;
    }
    export class CrossCollision2dUtil {
        protected static _handle: CrossCollision2d;
        protected static get handle(): CrossCollision2d;
        static simplifyPolygon(data: Array<Value2>, scale?: number): Array<Array<Vector2>>;
    }
}
declare module "sk/editor/render/pixi/PixiUtil" {
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class PixiUtil {
        protected static _buffer: ByteStream;
        static get buffer(): ByteStream;
        static setVisible(item: IPixiObject, value: boolean): void;
        static setLocation(item: IPixiObject, x: number, y: number): void;
        static setSize(item: IPixiObject, width: number, height: number): void;
        static setRotation(item: IPixiObject, value: number): void;
        static setScale(item: IPixiObject, x: number, y: number): void;
        static setAnchor(item: IPixiObject, x: number, y: number): void;
        static setAlpha(item: IPixiObject, value: number): void;
        static setInteractive(item: IPixiObject, value: any): void;
        static setCursor(item: IPixiObject, value: any): void;
        static setMask(item: IPixiObject, value: any): void;
        static sendBatch(item: IPixiObject): void;
    }
}
declare module "sk/editor/render/pixi/PixiText" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
    import { V2dGraphicTextStyle } from 'foundation/editor/view/view2d/render/V2dGraphicTextStyle';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class PixiText extends V2dGraphicText implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.Text;
        options: any;
        protected _style: V2dGraphicTextStyle;
        constructor(text?: string, options?: any);
        initialize(): void;
        set parent(value: any);
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        get y(): number;
        setLocation(x: number, y: number): void;
        get width(): number;
        get height(): number;
        setSize(width: number, height: number): void;
        get rotation(): number;
        set rotation(value: number);
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        get anchor(): Readonly<Value2>;
        setAnchor(x: number, y: number): void;
        get alpha(): number;
        set alpha(value: number);
        get style(): any;
        set style(value: any);
        get text(): string;
        set text(value: string);
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiGraphics" {
    import { Rect } from 'foundation/runtime/math/Rect';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dCanvasContext } from 'foundation/editor/view/view2d/V2dCanvasContext';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class LinearOption {
        lengthArr: Array<number>;
        constructor();
    }
    export class PixiGraphics extends V2dGraphicDrawing implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.Graphics;
        constructor();
        initialize(): void;
        set parent(value: any);
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        get y(): number;
        setLocation(x: number, y: number): void;
        get width(): number;
        get height(): number;
        setSize(width: number, height: number): void;
        get rotation(): number;
        set rotation(value: number);
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        get alpha(): number;
        set alpha(value: number);
        set interactive(value: any);
        set cursor(value: any);
        toGlobal(point: any, side?: any): any;
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        lineStyle(lineWidth?: number, color?: number, alpha?: number, alignment?: number, native?: boolean): void;
        beginFill(color: number, alpha?: number): void;
        beginHole(): void;
        endHole(): void;
        endFill(): void;
        moveTo(x: number, y: number): void;
        lineTo(x: number, y: number): void;
        closePath(): void;
        arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean, scale?: number, lineTypeOption?: LinearOption): void;
        drawRect(x: number, y: number, width: number, height: number): void;
        drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): void;
        drawCircle(x: any, y: any, radius: any): void;
        drawPolygon(points: any, lineTypeOption?: LinearOption): void;
        drawDimension(point1: Vector2, point2: Vector2, angle: number, dimPoint: Vector2): void;
        drawDottedLine(start: Vector2, end: Vector2, scale?: number, segmentLength?: number, rect?: Rect, lineTypeOption?: LinearOption): void;
        private drawLineByLinearType;
        drawGraph(context: V2dCanvasContext, nodes: Curve2dNode[]): void;
        addChild(content: any): void;
        removeChild(content: any): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiSprite" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicSprite } from 'foundation/editor/view/view2d/render/V2dGraphicSprite';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class PixiSprite extends V2dGraphicSprite implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.Sprite;
        protected texUrl: string;
        protected renderer: any;
        constructor();
        initialize(): void;
        set parent(value: any);
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        set x(value: number);
        get y(): number;
        set y(value: number);
        setLocation(x: number, y: number): void;
        get width(): number;
        set width(value: number);
        get height(): number;
        set height(value: number);
        setSize(width: number, height: number): void;
        get rotation(): number;
        set rotation(value: number);
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        get alpha(): number;
        set alpha(value: number);
        set anchor(value: any);
        get texture(): any;
        set texture(value: any);
        get textureUrl(): any;
        set textureUrl(value: any);
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiContainer" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicContentParemetersType } from 'foundation/editor/view/view2d/render/V2dGraphicContent';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class PixiContainer extends V2dGraphicContainer implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.Container;
        hitInvoker: any;
        constructor();
        setup(): void;
        contains(x: number, y: number): boolean;
        initialize(): void;
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        get y(): number;
        setLocation(x: number, y: number): void;
        get width(): number;
        get height(): number;
        setSize(width: number, height: number): void;
        get rotation(): number;
        set rotation(value: number);
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        get alpha(): number;
        set alpha(value: number);
        set mask(value: any);
        get interactive(): boolean;
        set interactive(value: boolean);
        get interactiveChildren(): boolean;
        set interactiveChildren(value: boolean);
        set cursor(value: any);
        set(parameters: V2dGraphicContentParemetersType): void;
        toGlobal(point: any, side?: any): any;
        hitTest(invoker: any): void;
        setHitReactangle(x: number, y: number, width: number, height: number): void;
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        addChild(content: any): void;
        addChildAt(content: any, index: number): void;
        setChildIndex(content: any, index: number): void;
        removeChild(content: any): void;
        getChildrenCount(): number;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiHookEvent" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
    import InteractionEvent = PIXI.interaction.InteractionEvent;
    export class PixiHookEvent extends V2dHookEvent {
        protected _handle: InteractionEvent;
        attachEvent(event: InteractionEvent): void;
        getLocalPosition(container: V2dGraphicContainer): Vector2;
        stopPropagation(): void;
        free(): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiHook" {
    import { V2dHook } from 'foundation/editor/view/view2d/render/V2dHook';
    import InteractionEvent = PIXI.interaction.InteractionEvent;
    export class PixiHook extends V2dHook {
        optionWorker: boolean;
        element: PIXI.DisplayObject;
        elementHandle: PIXI.DisplayObject;
        constructor();
        setup(): void;
        testTargetElement(event: InteractionEvent): boolean;
        active(): void;
        deactive(): void;
        onClick(event: InteractionEvent): void;
        onMouseOver(event: InteractionEvent): void;
        onMouseOut(event: InteractionEvent): void;
        onMouseDown(event: InteractionEvent): void;
        onMouseMove(event: InteractionEvent): void;
        onMouseUp(event: InteractionEvent): void;
        onDragStart(event: InteractionEvent): void;
        onDragMove(event: InteractionEvent): void;
        onDragEnd(event: InteractionEvent): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiPicker" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dPicker } from 'foundation/editor/view/view2d/render/V2dPicker';
    import { V2dCanvas } from 'foundation/editor/view/view2d/V2dCanvas';
    import { V2dLayer } from 'foundation/editor/view/view2d/V2dLayer';
    export class PixiPicker extends V2dPicker {
        factory: any;
        name: any;
        className: string;
        interactionManager: PIXI.interaction.InteractionManager;
        constructor();
        initialize(): void;
        get resolution(): any;
        pointerClick(event: any): any;
        pick2(point: Vector2, canvas: V2dCanvas, layers?: Array<V2dLayer>): Array<any>;
    }
}
declare module "sk/editor/render/pixi/PixiTextStyle" {
    import { V2dGraphicTextStyle } from 'foundation/editor/view/view2d/render/V2dGraphicTextStyle';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    export class PixiTextStyle extends V2dGraphicTextStyle implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.TextStyle;
        options: any;
        constructor(sytle?: any);
        initialize(): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiTexture" {
    import { V2dTexture } from 'foundation/editor/view/view2d/asset/V2dTexture';
    export class PixiTexture extends V2dTexture {
        optionWorker: boolean;
        handle: PIXI.Texture;
        loadUrl(url: string, onLoaded?: any): void;
    }
}
declare module "sk/editor/render/pixi/PixiRenderFactory" {
    import { V2dGraphicRenderer } from 'foundation/editor/view/view2d/render/V2dGraphicRenderer';
    import { V2dGraphicRenderFactory } from 'foundation/editor/view/view2d/render/V2dGraphicRenderFactory';
    import { V2dPicker } from 'foundation/editor/view/view2d/render/V2dPicker';
    import { V2dScene } from 'foundation/editor/view/view2d/V2dScene';
    import { PixiContainer } from "sk/editor/render/pixi/PixiContainer";
    import { PixiGraphics } from "sk/editor/render/pixi/PixiGraphics";
    import { PixiHook } from "sk/editor/render/pixi/PixiHook";
    import { PixiMesh } from "sk/editor/render/pixi/PixiMesh";
    import { PixiSprite } from "sk/editor/render/pixi/PixiSprite";
    import { PixiText } from "sk/editor/render/pixi/PixiText";
    import { PixiTextStyle } from "sk/editor/render/pixi/PixiTextStyle";
    import { PixiTexture } from "sk/editor/render/pixi/PixiTexture";
    export class PixiRenderFactory extends V2dGraphicRenderFactory {
        createRenderer(options: any): V2dGraphicRenderer;
        createPicker(name?: string): V2dPicker;
        createScene(name?: string): V2dScene;
        createContainer(name?: string): PixiContainer;
        createGraphics(name?: string): PixiGraphics;
        createSprite(name?: string): PixiSprite;
        createTexture(name?: string): PixiTexture;
        createMesh(name?: string): PixiMesh;
        createText(name?: string, text?: string, options?: any, style?: PixiTextStyle): PixiText;
        createTextStyle(name?: string, options?: any): PixiTextStyle;
        createHook(name?: string, owner?: any, element?: any, torlerance?: number): PixiHook;
    }
}
declare module "sk/editor/render/pixi/PixiRenderer" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { UnlockPipe } from 'cross/runtime/module/pipe/UnlockPipe';
    import { WorkerEvent } from 'cross/core/device/worker/WorkerEvent';
    import { WorkerMessage } from 'cross/core/device/worker/WorkerMessage';
    import { WorkerPipeProxy } from 'cross/core/device/worker/WorkerPipeProxy';
    import { WorkerProxy } from 'cross/core/device/worker/WorkerProxy';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { IRenderContext } from 'foundation/editor/view/base/render/IRenderContext';
    import { RenderParameters } from 'foundation/editor/view/base/render/RenderParameters';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicRenderer } from 'foundation/editor/view/view2d/render/V2dGraphicRenderer';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    import { PixiRenderFactory } from "sk/editor/render/pixi/PixiRenderFactory";
    export class PixiRenderer extends V2dGraphicRenderer {
        static SPACE_NAME: string;
        static PIPE_SIZE: number;
        factory: PixiRenderFactory;
        optionWorker: boolean;
        htmlCanvas: any;
        backgroundColor: number;
        backgroundOpacity: number;
        protected _pipe: UnlockPipe;
        protected _proxy: WorkerPipeProxy;
        protected _statusReady: boolean;
        constructor();
        get proxy(): WorkerProxy;
        setup(): void;
        createMessage(code?: string): WorkerMessage;
        sendMessage(message: WorkerMessage): void;
        onStartupComplete(sender: ListenerContext, event: WorkerEvent): void;
        getCanvasSize(): Readonly<Size2>;
        setCanvasSize(width: number, height: number): void;
        setClearColor(color: number, opacity?: number): void;
        hitTest(point: Value2, container?: V2dGraphicContainer): PIXI.DisplayObject;
        render(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
        processCreate(object: IPixiObject, code: string, name: string, args?: any): void;
        propertySet(object: IPixiObject, name: string, value: any): void;
        propertySetObject(object: IPixiObject, name: string, value: any): void;
        processAction(object: IPixiObject, type: string, args?: any, memory?: any, data?: any): void;
        processDestroy(object: IPixiObject): void;
    }
}
declare module "sk/editor/render/pixi/PixiMesh" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicMesh } from 'foundation/editor/view/view2d/render/V2dGraphicMesh';
    import { IPixiObject } from "sk/editor/render/pixi/IPixiObject";
    import { PixiTexture } from "sk/editor/render/pixi/PixiTexture";
    export class PixiMesh extends V2dGraphicMesh implements IPixiObject {
        className: string;
        optionWorker: boolean;
        handle: PIXI.SimpleMesh;
        protected _ptexture: PixiTexture;
        protected _textureReady: boolean;
        protected _geometryReady: boolean;
        onReady: any;
        protected texUrl: string;
        protected renderer: any;
        constructor();
        initialize(): void;
        set parent(value: any);
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        get y(): number;
        setLocation(x: number, y: number): void;
        get width(): number;
        get height(): number;
        setSize(width: number, height: number): void;
        get rotation(): number;
        set rotation(value: number);
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        get alpha(): number;
        set alpha(value: number);
        get drawMode(): number;
        set drawMode(value: number);
        get texture(): any;
        set texture(value: any);
        get textureUrl(): any;
        set textureUrl(value: any);
        protected onTextureLoaded: () => void;
        protected checkShow(): void;
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        updateFillMeshWithHole(points: Vector2[], indices: any[], canvasPoint?: boolean, width?: number, height?: number): void;
        updateFillMeshGeometry(geometry: Vector2[], uvLen?: number, canvasPoint?: boolean, width?: number, height?: number): void;
        protected genBufferGeometry(vertexCount: number, posArray: Float32Array, uvArray: Float32Array, indexArray: Uint16Array): any;
        updateFillMeshImg(imgUrl: string): void;
        endBatch(): void;
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PixiBatchMeshDisplay" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { PixiMesh } from "sk/editor/render/pixi/PixiMesh";
    export class PixiBatchMeshDisplay extends PixiMesh {
        optionWorker: boolean;
        protected mergeGeometries: Types<PIXI.Geometry>;
        constructor(name: string);
        reset(): void;
        addGeometry(geometry: PIXI.Geometry): void;
        removeGeometry(): void;
        clearGeometries(): void;
        set material(material: any);
        get material(): any;
        set isVisible(isVisible: boolean);
        get isVisible(): boolean;
        updateMerge(): void;
    }
}
declare module "sk/editor/render/pixi/PixiDynamicMesh" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { PixiBatchMeshMerger } from "sk/editor/render/pixi/PIxiBatchMeshMerger";
    export class PixiDynamicMesh extends InstanceObject {
        optionWorker: boolean;
        layer: any;
        merger: PixiBatchMeshMerger;
        geometry: PIXI.Geometry;
        material: PIXI.MeshMaterial | PIXI.Shader;
        texture: PIXI.Texture;
        protected _isVisible: boolean;
        constructor();
        dirty(): void;
        get isVisible(): boolean;
        set isVisible(visible: boolean);
        dispose(): void;
    }
}
declare module "sk/editor/render/pixi/PIxiBatchMeshMerger" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { V2dCanvasContext } from 'foundation/editor/view/view2d/V2dCanvasContext';
    import { PixiBatchMeshDisplay } from "sk/editor/render/pixi/PixiBatchMeshDisplay";
    import { PixiDynamicMesh } from "sk/editor/render/pixi/PixiDynamicMesh";
    export class PixiBatchMeshMerger extends Dispatcher {
        optionWorker: boolean;
        context: V2dCanvasContext;
        name: string;
        protected meshes: Types<PixiDynamicMesh>;
        protected _dirty: boolean;
        protected _displays: Dictionary<PixiBatchMeshDisplay>;
        constructor(name?: string);
        setup(): void;
        add(mesh: PixiDynamicMesh): void;
        remove(mesh: PixiDynamicMesh): void;
        dirty(): void;
        process(): void;
        update(): void;
        private getMaterialCode;
        getDisplay(mesh: PixiDynamicMesh): PixiBatchMeshDisplay;
        removeDisplay(display: PixiBatchMeshDisplay): void;
        protected updateMeshes(): void;
        clear(): void;
        dispose(): void;
    }
    export type PixiBatchMeshMergerMap = {
        [key: string]: PixiBatchMeshMerger;
    };
}
declare module "sk/editor/render/pixi/PixiBatchMeshManager" {
    import { ObjectPool } from 'cross/runtime/lang/ObjectPool';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { Manager } from 'cross/runtime/framework/Manager';
    import { V2dCanvasContext } from 'foundation/editor/view/view2d/V2dCanvasContext';
    import { PixiBatchMeshMerger, PixiBatchMeshMergerMap } from "sk/editor/render/pixi/PIxiBatchMeshMerger";
    import { PixiDynamicMesh } from "sk/editor/render/pixi/PixiDynamicMesh";
    export class PixiBatchMeshManager extends Manager {
        optionWorker: boolean;
        context: V2dCanvasContext;
        pool: ObjectPool<PixiBatchMeshMerger>;
        mergers: PixiBatchMeshMergerMap;
        constructor();
        alloc(): PixiBatchMeshMerger;
        freeMesh(mesh: PixiBatchMeshMerger): void;
        register(name: string, mesh?: PixiBatchMeshMerger): PixiBatchMeshMerger;
        unregister(code: string): void;
        unregisterMesh(name: string, mesh: PixiDynamicMesh): PixiBatchMeshMerger;
        process(viewContext: ViewContext): void;
        find(id: string): PixiBatchMeshMerger;
        registerMesh(name: string, mesh: PixiDynamicMesh): PixiBatchMeshMerger;
    }
}