/// <reference path="../library/typings/native.d.ts" />
/// <reference path="../library/typings/cross-editor.d.ts" />
/// <reference path="../typings/private/foundation-editor-view.d.ts" />
declare module "copyright" {
    export class FoundationEditorRenderCopyright {
        static toString(): string;
    }
}
declare module "foundation/editor/render/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "foundation/editor/render/gpu/GpuScene" {
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { V3dGraphicNode } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicNode';
    import { V3dGraphicScene } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicScene';
    import { V3dPickerItem } from 'foundation/editor/view/view3d/selection/V3dPickerItem';
    import { GpuCamera } from "foundation/editor/render/gpu/GpuCamera";
    import { GpuLayer } from "foundation/editor/render/gpu/GpuLayer";
    import { GpuLayerGroup } from "foundation/editor/render/gpu/GpuLayerGroup";
    import { GpuRenderer } from "foundation/editor/render/gpu/GpuRenderer";
    export class GpuSelectPickInfo extends V3dPickerItem {
    }
    export class GpuScene extends V3dGraphicScene {
        camera: GpuCamera;
        mainCamera: GpuCamera;
        slaveCamera: GpuCamera;
        backgroundColor: Color3;
        pickInfo: GpuSelectPickInfo;
        renderer: GpuRenderer;
        renderablesSet: Set<V3dGraphicNode>;
        handle: SkNative.FStageScene;
        constructor();
        initialize(): void;
        setMainCamera(camera: GpuCamera): void;
        setSecondCamera(camera: GpuCamera): void;
        appendNode(node: any): void;
        removeNode(node: any): void;
        addLayerGroup(layerGroup: GpuLayerGroup): void;
        removeLayerGroup(layerGroup: GpuLayerGroup): void;
        addLayer(layer: GpuLayer): void;
        removeLayer(layer: GpuLayer): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuUtil" {
    import { V3dGraphicTextureWrapEnum } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum';
    export class GpuUtil {
        static convertFromTextureWrap(wrapCd: SkNative.StageTextureWrapEnum): V3dGraphicTextureWrapEnum;
        static convertToTextureWrap(wrapCd: V3dGraphicTextureWrapEnum): SkNative.StageTextureWrapEnum;
        static disposeEntity(handle: SkNative.FStageEntity): any;
        static checkLayerLevel(layerLevel: number): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLayerGroup" {
    import { V3dGraphicLayerGroup } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup';
    import { GpuScene } from "foundation/editor/render/gpu/GpuScene";
    export class GpuLayerGroup extends V3dGraphicLayerGroup {
        handle: SkNative.FStageLayerGroup;
        protected _parent: GpuScene;
        initialize(): void;
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionDepthClear(): boolean;
        set optionDepthClear(value: boolean);
        get level(): number;
        set level(value: number);
        get parent(): GpuScene;
        set parent(parent: GpuScene);
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLineMaterial" {
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { V3dGraphicLineMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial';
    export class GpuLineMaterial extends V3dGraphicLineMaterial {
        _color: Color3;
        handle: SkNative.FStageLinesMaterial;
        constructor();
        initialize(): void;
        get optionTransparent(): boolean;
        set optionTransparent(value: boolean);
        get optionDepthTest(): boolean;
        set optionDepthTest(value: boolean);
        get optionDepthWrite(): boolean;
        set optionDepthWrite(value: boolean);
        get disableDepthWrite(): boolean;
        set disableDepthWrite(value: boolean);
        get sortLevel(): number;
        set sortLevel(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        get alpha(): number;
        set alpha(value: number);
        get color(): Color3;
        setColor(r: number, g: number, b: number): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuMeshInstance" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicContentUsageEnum } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContentUsageEnum';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { GpuMesh } from "foundation/editor/render/gpu/GpuMesh";
    export class GpuMeshInstance extends V3dGraphicMeshInstance {
        handle: SkNative.FStageMeshInstance;
        mesh: GpuMesh;
        protected _parent: V3dGraphicContent;
        protected _worldMatrix: Matrix4;
        initialize(): void;
        get parent(): any;
        set parent(parent: any);
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get optionCulling(): boolean;
        set optionCulling(value: boolean);
        get groupLevel(): number;
        set groupLevel(value: number);
        get layerLevel(): number;
        set layerLevel(value: number);
        get level(): number;
        set level(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        setUseageCd(useageCd: V3dGraphicContentUsageEnum): void;
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        setPivotMatrix(matrix: Matrix4): void;
        getWorldMatrix(): Matrix4;
        freezeWorldMatrix(): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuEventEnum" {
    export class GpuEventEnum {
        static NodeChanged: string;
        static MaterialReady: string;
        static TextureReady: string;
        static DataChanged: string;
    }
}
declare module "foundation/editor/render/gpu/GpuTexture2d" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { HostDeviceService } from 'cross/core/device/host/HostDeviceService';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { V3dGraphicTexture2d } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTexture2d';
    import { V3dGraphicTextureWrapEnum } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum';
    export class GpuTexture2d extends V3dGraphicTexture2d {
        handle: SkNative.FStageFlatTexture;
        protected _uScale: number;
        protected _vScale: number;
        protected _hostService: HostDeviceService;
        protected _httpService: HttpDeviceService;
        constructor();
        setup(): void;
        get optionInvertY(): boolean;
        set optionInvertY(value: boolean);
        get wrapAuCd(): V3dGraphicTextureWrapEnum;
        set wrapAuCd(value: V3dGraphicTextureWrapEnum);
        get wrapAvCd(): V3dGraphicTextureWrapEnum;
        set wrapAvCd(value: V3dGraphicTextureWrapEnum);
        get wrapAwCd(): V3dGraphicTextureWrapEnum;
        set wrapAwCd(value: V3dGraphicTextureWrapEnum);
        get uScale(): number;
        get vScale(): number;
        setScale(uScale: number, vScale: number): void;
        loadImageAsync(url: string, onLoad?: Function): Promise<ResultObject>;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuMeshMaterial" {
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dGraphicTexture } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTexture';
    export class GpuMeshMaterial extends V3dGraphicMeshMaterial {
        handle: SkNative.FStageMeshMaterial;
        _normal: Vector3;
        _bentNormal: Vector3;
        _clearCoatNormal: Vector3;
        _anisotropyDirection: Vector3;
        _baseColor: Color4;
        _albedoColor: Color4;
        _ambientColor: Color4;
        _diffuseColor: Color4;
        _specularColor: Color4;
        _emissiveColor: Color4;
        _sheenColor: Color4;
        _postLightingColor: Color4;
        _absorption: Color4;
        protected _diffuseTexture: V3dGraphicTexture;
        protected _opacityTexture: V3dGraphicTexture;
        protected _specularTexture: V3dGraphicTexture;
        protected _reflectionTexture: V3dGraphicTexture;
        protected _environmentTexture: V3dGraphicTexture;
        protected _albedoTexture: V3dGraphicTexture;
        protected _normalTexture: V3dGraphicTexture;
        protected _metallicTexture: V3dGraphicTexture;
        protected _roughnessTexture: V3dGraphicTexture;
        protected _aoTexture: V3dGraphicTexture;
        constructor(name?: string);
        get className(): string;
        initialize(): void;
        get optionLighting(): boolean;
        set optionLighting(value: boolean);
        get optionFaceFront(): boolean;
        set optionFaceFront(value: boolean);
        get optionFaceBack(): boolean;
        set optionFaceBack(value: boolean);
        get optionReceiveShadows(): boolean;
        set optionReceiveShadows(value: boolean);
        get optionTransparent(): boolean;
        set optionTransparent(value: boolean);
        get optionDepthTest(): boolean;
        set optionDepthTest(value: boolean);
        get optionDepthWrite(): boolean;
        set optionDepthWrite(value: boolean);
        get disableDepthWrite(): boolean;
        set disableDepthWrite(value: boolean);
        get optionDepthOffset(): boolean;
        set optionDepthOffset(value: boolean);
        get sortLevel(): number;
        set sortLevel(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasSlopeOffset(): number;
        set depthBiasSlopeOffset(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        get alpha(): number;
        set alpha(value: number);
        get alphaBase(): number;
        set alphaBase(value: number);
        get ambientColor(): Color4;
        setAmbientColor(r: number, g: number, b: number, p?: number): void;
        get baseColor(): any;
        setBaseColor(r: number, g: number, b: number, p?: number): void;
        get absorption(): any;
        setabsorption(r: number, g: number, b: number, a?: number): void;
        get postLightingColor(): Color4;
        setPostLightingColor(r: number, g: number, b: number, p?: number): void;
        get albedoColor(): Color4;
        setAlbedoColor(r: number, g: number, b: number, p?: number): void;
        get diffuseColor(): Color4;
        setDiffuseColor(r: number, g: number, b: number, p?: number): void;
        get diffuseTexture(): V3dGraphicTexture;
        set diffuseTexture(texture: V3dGraphicTexture);
        get opacityTexture(): V3dGraphicTexture;
        set opacityTexture(texture: V3dGraphicTexture);
        get specularColor(): any;
        setSpecularColor(r: number, g: number, b: number, p?: number): void;
        get specularPower(): number;
        set specularPower(value: number);
        get specularTexture(): V3dGraphicTexture;
        set specularTexture(texture: V3dGraphicTexture);
        get reflectionTexture(): V3dGraphicTexture;
        set reflectionTexture(texture: V3dGraphicTexture);
        get emissiveColor(): any;
        setEmissiveColor(r: number, g: number, b: number, p?: number): void;
        setSheenColor(r: number, g: number, b: number, p?: number): void;
        get sheenColor(): any;
        get anisotropyDirection(): Vector3;
        setAnisotropyDirection(x: number, y: number, z: number): void;
        setNormal(x: number, y: number, z: number): void;
        get normal(): Vector3;
        setBentNormal(x: number, y: number, z: number): void;
        get bentNormal(): Vector3;
        setclearCoatNormal(x: number, y: number, z: number): void;
        get clearCoatNormal(): Vector3;
        set sheenRoughness(value: number);
        get sheenRoughness(): number;
        set anisotropy(value: number);
        get anisotropy(): number;
        set ambientOcclusion(value: number);
        get ambientOcclusion(): number;
        set ior(value: number);
        get ior(): number;
        set transmission(value: number);
        get transmission(): number;
        set clearCoat(value: number);
        get clearCoat(): number;
        set clearCoatRoughness(value: number);
        get clearCoatRoughness(): number;
        set reflectance(value: number);
        get reflectance(): number;
        set metallic(value: number);
        get metallic(): number;
        set roughness(value: number);
        get roughness(): number;
        set microThickness(value: number);
        get microThickness(): number;
        set thickness(value: number);
        get thickness(): number;
        set environmentTexture(texture: V3dGraphicTexture);
        set albedoTexture(texture: V3dGraphicTexture);
        set normalTexture(texture: V3dGraphicTexture);
        set metallicTexture(texture: V3dGraphicTexture);
        set aoTexture(texture: V3dGraphicTexture);
        setEffectName(name: string): void;
        setTransformName(name: string): void;
        setEffectCode(code: string): void;
        set roughnessTexture(texture: V3dGraphicTexture);
        get backFaceCulling(): boolean;
        set backFaceCulling(value: boolean);
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuMesh" {
    import { TypeSet } from 'cross/runtime/lang/collection/TypeSet';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicContentUsageEnum } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContentUsageEnum';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshInstanceOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { V3dGraphicNode } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicNode';
    import { GpuMeshInstance } from "foundation/editor/render/gpu/GpuMeshInstance";
    import { GpuMeshMaterial } from "foundation/editor/render/gpu/GpuMeshMaterial";
    export class GpuMesh extends V3dGraphicMesh {
        handle: SkNative.FStageMesh;
        protected _parent: V3dGraphicNode;
        protected _pivotMatrix: Matrix4;
        protected _worldMatrix: Matrix4;
        protected _material: GpuMeshMaterial;
        protected _mergeParent: V3dGraphicContent;
        protected _instances: TypeSet<GpuMeshInstance>;
        initialize(): void;
        get parent(): V3dGraphicNode;
        set parent(parent: V3dGraphicNode);
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get optionBack(): boolean;
        set optionBack(value: boolean);
        get optionDynamic(): boolean;
        set optionDynamic(value: boolean);
        get optionReserve(): boolean;
        set optionReserve(value: boolean);
        get optionStatic(): boolean;
        set optionStatic(value: boolean);
        get optionStaticTransform(): boolean;
        set optionStaticTransform(value: boolean);
        get optionBoundary(): boolean;
        set optionBoundary(value: boolean);
        get optionBoundaryDepth(): boolean;
        set optionBoundaryDepth(value: boolean);
        get groupLevel(): number;
        set groupLevel(value: number);
        get layerLevel(): number;
        set layerLevel(value: number);
        get level(): number;
        set level(value: number);
        get pickLevel(): number;
        set pickLevel(value: number);
        get optionGenerateShadow(): boolean;
        set optionGenerateShadow(value: boolean);
        get optionReceiveShadows(): boolean;
        set optionReceiveShadows(value: boolean);
        get mergeNumber(): number;
        set mergeNumber(value: number);
        get mergeParent(): V3dGraphicContent;
        set mergeParent(parent: V3dGraphicContent);
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        setUseageCd(useageCd: V3dGraphicContentUsageEnum): void;
        get pivotMatrix(): Matrix4;
        setPivotMatrix(matrix: Matrix4): void;
        get material(): GpuMeshMaterial;
        set material(material: GpuMeshMaterial);
        get instanceCount(): number;
        get instances(): TypeSet<GpuMeshInstance>;
        createInstance(name?: string, options?: V3dGraphicMeshInstanceOption): GpuMeshInstance;
        removeInstance(instance: GpuMeshInstance): void;
        bakeTransformIntoVertices(transform: Matrix4): V3dGraphicMesh;
        updateBufferData(data: BufferGeometry): void;
        getWorldMatrix(): Matrix4;
        computeWorldMatrix(force?: boolean): void;
        freezeWorldMatrix(force?: boolean): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuModel" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicModel } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicModel';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    export class GpuModel extends V3dGraphicModel {
        handle: SkNative.FStageContainer;
        protected _parent: V3dGraphicContent;
        initialize(): void;
        setup(): void;
        get parent(): any;
        set parent(parent: any);
        computeModelMatrix(content: ContentNode): Matrix4;
        setContentTransform(content: ContentNode): void;
        setVisible(visible: boolean): void;
        setSelectable(value: boolean): void;
        upadteDynamicMesh(dynamicMesh: V3dDynamicMesh, parentNode: any): void;
        freezeWorldMatrix(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLinesInstance" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { GpuLines } from "foundation/editor/render/gpu/GpuLines";
    export class GpuLinesInstance extends V3dGraphicMesh {
        handle: SkNative.FStageLinesInstance;
        lines: GpuLines;
        protected _parent: any;
        initialize(): void;
        get parent(): any;
        set parent(parent: any);
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get groupLevel(): number;
        set groupLevel(value: number);
        get level(): number;
        set level(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        setPivotMatrix(matrix: Matrix4): void;
        freezeWorldMatrix(): void;
        freeze(): void;
        dirty(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLinesUtil" {
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    export class GpuLinesUtil {
        static createDashLinePosList(start: Value3, end: Value3, pattern: Array<number>, positions?: Array<number>): Array<number>;
        static toBabylonSpace(vec: Vector3): Vector3;
        static isDashPatternValid(pattern: Array<number>): boolean;
        static getLinesFromBox(box: BoxSolid, lineColor?: number): Lines;
        static getDashLinesFromBox(box: BoxSolid, dashPattern: any, lineColor?: number): Lines;
    }
}
declare module "foundation/editor/render/gpu/GpuLines" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { PlaneEnum } from 'foundation/runtime/graphics/shape/PlaneEnum';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dRenderingGroupIdEnum } from 'foundation/editor/view/view3d/render/V3dRenderingGroupIdEnum';
    import { GpuLineMaterial } from "foundation/editor/render/gpu/GpuLineMaterial";
    import { GpuLinesInstance } from "foundation/editor/render/gpu/GpuLinesInstance";
    export class GpuLines extends V3dGraphicLines {
        handle: SkNative.FStageLines;
        protected _color: Color3;
        protected _parent: V3dGraphicContent;
        protected _material: GpuLineMaterial;
        protected _instances: Types<GpuLinesInstance>;
        protected _mergeParent: V3dGraphicContent;
        protected _worldMatrix: Matrix4;
        protected _lineMesh: BufferGeometry;
        initialize(): void;
        get parent(): any;
        set parent(parent: any);
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get optionDynamic(): boolean;
        set optionDynamic(value: boolean);
        get optionReserve(): boolean;
        set optionReserve(value: boolean);
        get optionBack(): boolean;
        set optionBack(value: boolean);
        get optionStatic(): boolean;
        set optionStatic(value: boolean);
        get optionStaticTransform(): boolean;
        set optionStaticTransform(value: boolean);
        get mergeNumber(): number;
        set mergeNumber(value: number);
        get mergeParent(): V3dGraphicContent;
        set mergeParent(parent: V3dGraphicContent);
        get intersectionThreshold(): number;
        set intersectionThreshold(value: number);
        get renderingGroupId(): V3dRenderingGroupIdEnum;
        set renderingGroupId(value: V3dRenderingGroupIdEnum);
        bakeTransformIntoVertices(transform: Matrix4): V3dGraphicLines;
        get groupLevel(): number;
        set groupLevel(value: number);
        get layerLevel(): number;
        set layerLevel(value: number);
        get level(): number;
        set level(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        setPivotMatrix(matrix: Matrix4): void;
        get alpha(): number;
        set alpha(value: number);
        get color(): Color3;
        setColor(red: number, green: number, blue: number): void;
        createInstance(name?: string): GpuLinesInstance;
        removeInstance(instance: GpuLinesInstance): void;
        get material(): GpuLineMaterial;
        set material(material: GpuLineMaterial);
        updateBufferData(data: BufferGeometry): void;
        updateLines(lines: Lines, segmentsMode?: boolean): void;
        updateDashLine(start: Value3, end: Value3, pattern: Array<number>): boolean;
        private genDashLinesBufferGeometry;
        updateLinesDash(lines: Lines, pattern: Array<number>, segmentsMode?: boolean): void;
        private genBufferGeometry;
        updatePolygon(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4, color?: number): void;
        updatePolygonDash(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4, pattern: Array<number>): void;
        private genDashLineBufferGeometry;
        setLineMesh(lineMesh: BufferGeometry): void;
        updateAllColor(lineColor: number): void;
        getWorldMatrix(): any;
        freezeWorldMatrix(force?: boolean): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLayer" {
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicLayer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLayer';
    import { Display } from 'foundation/editor/view/base/Display';
    import { GpuContainer } from "foundation/editor/render/gpu/GpuContainer";
    import { GpuLayerGroup } from "foundation/editor/render/gpu/GpuLayerGroup";
    import { GpuLines } from "foundation/editor/render/gpu/GpuLines";
    import { GpuMesh } from "foundation/editor/render/gpu/GpuMesh";
    import { GpuScene } from "foundation/editor/render/gpu/GpuScene";
    export type GpuLayerParentType = GpuScene | GpuLayer | GpuLayer;
    export class GpuLayer extends V3dGraphicLayer {
        protected _parent: V3dGraphicContent;
        handle: SkNative.FStageLayer;
        protected _levelGroup: GpuLayerGroup;
        initialize(): void;
        set parent(parent: any);
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get parent(): any;
        get levelGroup(): GpuLayerGroup;
        set levelGroup(layerGroup: GpuLayerGroup);
        get layerLevel(): number;
        set layerLevel(value: number);
        set level(value: number);
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        appendNode(node: GpuContainer | GpuMesh | GpuLines): void;
        removeNode(node: GpuContainer | GpuMesh | GpuLines): void;
        protected onAppendChild(child: Display): void;
        protected onRemoveChild(child: Display): void;
        freezeWorldMatrix(force?: boolean): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuContainer" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { GpuLayer } from "foundation/editor/render/gpu/GpuLayer";
    import { GpuScene } from "foundation/editor/render/gpu/GpuScene";
    export type GpuContainerParentType = GpuScene | GpuLayer | GpuLayer;
    export class GpuContainer extends V3dGraphicContainer {
        handle: SkNative.FStageContainer;
        protected _parent: V3dGraphicContent;
        protected _worldMatrix: Matrix4;
        get className(): string;
        initialize(): void;
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get parent(): GpuContainerParentType;
        set parent(parent: GpuContainerParentType);
        setPosition(x: number, y: number, z: number): void;
        setLocation: (x: number, y: number, z: number) => void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        setPivotMatrix(matrix: Matrix4): void;
        getWorldMatrix(): Matrix4;
        computeWorldMatrix(force?: boolean): void;
        freezeWorldMatrix(force?: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuDynamicMesh" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    import { GpuMesh } from "foundation/editor/render/gpu/GpuMesh";
    export class GpuDynamicMesh extends GpuMesh {
        isLighting: boolean;
        mergeGeometry: BufferGeometry;
        mergeGeometries: Types<BufferGeometry>;
        mergeMatrixs: Types<Matrix4>;
        constructor();
        initialize(): void;
        isValidGemetry(): boolean;
        set parent(parent: any);
        addMesh(mesh: V3dDynamicMesh, matrix: Matrix4): void;
        updateMerge(): void;
        reset(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuLightManager" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicLightManager } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLightManager';
    export class GpuLightManager extends V3dGraphicLightManager {
        handleScene: any;
        handleDirectionalLight: SkNative.FStageDirectionalLight;
        handleShadowGenerator: SkNative.FStageShadowGenerator;
        handleLights: Types<SkNative.FStageLight>;
        constructor();
        setup(): void;
        addShadow(content: V3dGraphicContent): void;
        removeShadow(content: V3dGraphicContent): void;
        addMirrow(content: V3dGraphicContent): void;
        removeMirrow(content: V3dGraphicContent): void;
        addLightExcluded(content: V3dGraphicContent): void;
        removeLightExcluded(content: V3dGraphicContent): void;
    }
}
declare module "foundation/editor/render/gpu/GpuRendererCapability" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    export class GpuRendererCapability extends BaseObject {
        supportLoadImage: boolean;
        supportLoadModel: boolean;
        constructor();
        info(): string;
    }
}
declare module "foundation/editor/render/gpu/GpuDeviceService" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class GpuDeviceResult extends ResultObject {
        nativeAdapter: any;
        nativeDevice: any;
    }
    export class GpuDeviceService extends InstanceObject {
        nativeAdapter: any;
        nativeDevice: any;
        getAsync(parameters?: any): Promise<GpuDeviceResult>;
    }
}
declare module "foundation/editor/render/gpu/GpuRendererContext" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { GpuDevice } from "foundation/editor/render/gpu/GpuDevice";
    import { GpuRendererEngine } from "foundation/editor/render/gpu/GpuRendererEngine";
    export class GpuRendererContext extends InstanceObject {
        htmlCanvas: HTMLCanvasElement;
        size: Size2;
        ratio: number;
        renderer: GpuRendererEngine;
        device: GpuDevice;
        engine: SkNative.FRenderEngine;
        engineContext: SkNative.FRenderEngineContext;
        parameters: any;
        extensions: any;
        statusDirty: boolean;
        constructor();
        dirty(): void;
        get statusInitialized(): boolean;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuDevice" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { GpuDeviceService } from "foundation/editor/render/gpu/GpuDeviceService";
    import { GpuRendererContext } from "foundation/editor/render/gpu/GpuRendererContext";
    export class GpuDevice extends InstanceObject {
        context: GpuRendererContext;
        handle: SkNative.FBackendDevice;
        native: any;
        statusInitialized: boolean;
        protected _deviceService: GpuDeviceService;
        constructor();
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuRendererEngineOption" {
    import { OptionValueDeclare } from 'cross/runtime/module/option/OptionValueDeclare';
    import { OptionValueItem } from 'cross/runtime/module/option/OptionValueItem';
    import { StorageDeviceService } from 'cross/core/device/storage/StorageDeviceService';
    export class GpuRendererEngineOption extends OptionValueDeclare {
        static Name: string;
        static OpenglProcess: string;
        static OpenglThread: string;
        static WebgpuProcess: string;
        static WebgpulThread: string;
        static Filament: string;
        protected _storageService: StorageDeviceService;
        constructor();
        makeOptions(): OptionValueItem[];
        mount(): void;
        unmount(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuRendererParameters" {
    import { ICanvasDevice } from 'cross/editor/device/canvas/ICanvasDevice';
    export class GpuRendererParameters {
        canvasDevice: ICanvasDevice;
        context: WebGLRenderingContext;
        version: number;
        pixelRatio: number;
        technique: any;
        constructor();
    }
}
declare module "foundation/editor/render/gpu/GpuRendererThreadOption" {
    import { OptionValueDeclare } from 'cross/runtime/module/option/OptionValueDeclare';
    import { StorageDeviceService } from 'cross/core/device/storage/StorageDeviceService';
    export class GpuRendererThreadOption extends OptionValueDeclare {
        static Name: string;
        protected _storageService: StorageDeviceService;
        constructor();
        mount(): void;
        unmount(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuRendererEngine" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { OptionService } from 'cross/runtime/module/option/OptionService';
    import { HostDeviceService } from 'cross/core/device/host/HostDeviceService';
    import { StorageDeviceService } from 'cross/core/device/storage/StorageDeviceService';
    import { ScreenDeviceService } from 'cross/editor/device/screen/ScreenDeviceService';
    import { GpuDevice } from "foundation/editor/render/gpu/GpuDevice";
    import { GpuDeviceService } from "foundation/editor/render/gpu/GpuDeviceService";
    import { GpuRendererCapability } from "foundation/editor/render/gpu/GpuRendererCapability";
    import { GpuRendererContext } from "foundation/editor/render/gpu/GpuRendererContext";
    import { GpuRendererParameters } from "foundation/editor/render/gpu/GpuRendererParameters";
    export class GpuRendererEngine extends InstanceObject {
        optionThreading: boolean;
        optionGpu: boolean;
        renderMode: string;
        engineName: string;
        canvasId: string;
        parameters: GpuRendererParameters;
        context: GpuRendererContext;
        device: GpuDevice;
        handleStage: SkNative.FStageEngine;
        handle: SkNative.FRenderEngine;
        capability: GpuRendererCapability;
        statusInitialized: boolean;
        protected _optionService: OptionService;
        protected _hosteService: HostDeviceService;
        protected _deviceService: GpuDeviceService;
        protected _storageService: StorageDeviceService;
        protected _screenDeviceService: ScreenDeviceService;
        constructor();
        setupAsync(parameters: GpuRendererParameters): Promise<ResultObject>;
        process(): void;
        flush(): void;
        active(): void;
        dirtyFrame(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuRenderer" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { QualityEnum } from 'cross/runtime/framework/quality/QualityEnum';
    import { WorkerPipeProxy } from 'cross/core/device/worker/WorkerPipeProxy';
    import { ICanvasDevice } from 'cross/editor/device/canvas/ICanvasDevice';
    import { ScreenDeviceService } from 'cross/editor/device/screen/ScreenDeviceService';
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { V3dGraphicRenderer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicRenderer';
    import { RenderDirtyEnum } from 'foundation/editor/view/base/render/RenderDirtyEnum';
    import { RenderParameters } from 'foundation/editor/view/base/render/RenderParameters';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    import { GpuCamera } from "foundation/editor/render/gpu/GpuCamera";
    import { GpuLightManager } from "foundation/editor/render/gpu/GpuLightManager";
    import { GpuRendererCapability } from "foundation/editor/render/gpu/GpuRendererCapability";
    import { GpuRendererEngine } from "foundation/editor/render/gpu/GpuRendererEngine";
    import { GpuScene } from "foundation/editor/render/gpu/GpuScene";
    export class GpuRenderer extends V3dGraphicRenderer {
        static SPACE_NAME: string;
        statusConnected: boolean;
        statusReady: boolean;
        canvasDevice: ICanvasDevice;
        techniqueName: string;
        qualityCd: QualityEnum;
        capability: GpuRendererCapability;
        handleParameters: SkNative.SRenderEngineRenderParameters;
        handleStage: SkNative.FStageEngine;
        handle: SkNative.FStageEngine;
        protected _renderSize: Size2;
        protected _backgroundColor: Color4;
        protected _proxy: WorkerPipeProxy;
        protected _lightManager: GpuLightManager;
        protected _handleContentScene: GpuScene;
        protected _handlePickerScene: GpuScene;
        protected _camera: GpuCamera;
        protected _engine: GpuRendererEngine;
        protected _cameras: Types<GpuCamera>;
        protected _scenes: Dictionary<GpuScene>;
        protected _screenDeviceService: ScreenDeviceService;
        protected _viewHandle: SkNative.FStageView;
        constructor();
        get statusInitialized(): boolean;
        get lightManager(): GpuLightManager;
        get engine(): GpuRendererEngine;
        get renderSize(): Size2;
        get cameras(): Types<GpuCamera>;
        setupAsync(): Promise<ResultObject>;
        setContentScene(scene: GpuScene): void;
        setPickerScene(scene: GpuScene): void;
        setCanvasSize(width: number, height: number, ratio?: number): void;
        setClearColor(color: number, opacity?: number): void;
        update(context: V3dCanvasContext): void;
        onConnect(): void;
        connect(): void;
        disconnect(): void;
        render(context: V3dCanvasContext, stage?: any, parameters?: RenderParameters): void;
        process(context: V3dCanvasContext): void;
        renderFinish(): void;
        dirty(dirtyCd?: RenderDirtyEnum): void;
        clear(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuCamera" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicCamera } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicCamera';
    export class GpuCamera extends V3dGraphicCamera {
        _target: Vector3;
        protected _viewMatrix: Matrix4;
        protected _projectionMatrix: Matrix4;
        handle: SkNative.FStageCamera;
        handleOrtho: SkNative.FStageOrthoCamera;
        constructor();
        get className(): string;
        initialize(): void;
        setPosition(x: any, y: number, z: number): void;
        get target(): Vector3;
        setTarget(x: any, y: number, z: number): void;
        getViewMatrix(): Matrix4;
        getProjectionMatrix(): Matrix4;
        set mode(value: any);
        get minZ(): number;
        set minZ(value: number);
        get maxZ(): number;
        set maxZ(value: number);
        get fov(): number;
        set fov(value: number);
        set orthoLeft(value: number);
        set orthoTop(value: number);
        set orthoRight(value: number);
        set orthoBottom(value: number);
        setUpAxis(x: any, y: number, z: number): void;
        set inertia(value: any);
        set wheelPrecision(value: any);
        set upperBetaLimit(value: any);
        set lowerRadiusLimit(value: any);
        set upperRadiusLimit(value: any);
        set allowUpsideDown(value: any);
        set lowerBetaLimit(value: any);
        set alpha(value: any);
        set beta(value: any);
        set radius(value: any);
        computeWorldMatrix(): void;
        update(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuDynamicLines" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { V3dDynamicLinesMesh } from 'foundation/editor/view/view3d/render/V3dDynamicLinesMesh';
    import { GpuLines } from "foundation/editor/render/gpu/GpuLines";
    export class GpuDynamicLines extends GpuLines {
        mergeGeometry: BufferGeometry;
        mergeGeometries: Types<Lines>;
        mergeMatrixs: Types<Matrix4>;
        constructor();
        initialize(): void;
        set parent(parent: any);
        addMesh(mesh: V3dDynamicLinesMesh, matrix: Matrix4): void;
        updateMerge(): void;
        reset(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuDynamicTexture" {
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicDynamicTexture } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicTexture';
    export class GpuDynamicTexture extends V3dGraphicDynamicTexture {
        handle: SkNative.FStageFlatTexture;
        protected _parent: V3dGraphicContent;
        protected _isEnabled: boolean;
        protected _spriteWidth: number;
        protected _spriteHeight: number;
        protected _value: number;
        protected _textFont: string;
        protected _textFontSize: number;
        protected _textColor: string;
        protected _textStrokeColor: string;
        protected _textStrokeWidth: number;
        protected _canvas: any;
        protected _canvasContext: any;
        constructor();
        initialize(): void;
        get value(): number;
        set value(value: number);
        protected drawTextValue(context: CanvasRenderingContext2D, text: string, x: number, y: number, color: string, stokeColor?: string, shadowColor?: string): void;
        fillTextValue(value: number): void;
        updateTextValue(value: number): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuFrameSort" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class GpuFrameSort {
        constructor();
        private array;
        private readonly stepSpan;
        private readonly intervalTime;
        private steps;
        private timer;
        private sortFrame;
        private compare;
        sortAsync(array: Array<any>, compareFn?: (a: any, b: any) => number): Promise<ResultObject>;
        private sort;
        protected doFrame: (resolve: (value?: unknown) => void) => void;
        protected selectSort(a: Array<number>): Array<number>;
        protected insertSort(arr: Array<number>): Array<number>;
        protected bubbleSort(arr: Array<number>): Array<number>;
        protected shellSort(arr: Array<number>): Array<number>;
        protected insertI(arr: Array<number>, h: number, i: number): void;
        protected quickSort(arr: Array<number>, left: number, right: number): number[];
        protected partition(arr: Array<number>, left: number, right: number): number;
    }
}
declare module "foundation/editor/render/gpu/GpuLight" {
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dGraphicLight } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLight';
    export class GpuLight extends V3dGraphicLight {
        handle: any;
        light: SkNative.FStageLight;
        protected _parent: V3dGraphicContent;
        get className(): string;
        initialize(): void;
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        setPosition(x: number, y: number, z: number): void;
        setDirection(x: number, y: number, z: number): void;
        setIntensity(value: number): void;
        setShadowGenerator(shadowGeneral: SkNative.FStageShadowGenerator): void;
        setTarget(x: number, y: number, z: number): void;
        lookAt(x: number, y: number, z: number): void;
        setCaseLight(value: boolean): void;
        setFalloff(value: number): void;
        setConeInnerAngle(value: number): void;
        setConeOuterAngle(value: number): void;
        setDiffuseColor(r: number, g: number, b: number): void;
        setSpecularColor(r: number, g: number, b: number): void;
        get optionPickable(): boolean;
        set optionPickable(able: boolean);
        get optionVisible(): boolean;
        set optionVisible(visible: boolean);
        dirty(): void;
        freeze(): void;
        set parent(parent: any);
        set optionShadow(value: boolean);
        get optionShadow(): boolean;
        freezeWorldMatrix(force?: boolean): void;
        reset(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuSprite" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicNode } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicNode';
    import { MouseEnterCallback, V3dGraphicSprite } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicSprite';
    export class GpuSprite extends V3dGraphicSprite {
        handle: SkNative.FStageSpriteInstance;
        mouseEnterCallback: MouseEnterCallback;
        protected _parent: V3dGraphicNode;
        protected _worldMatrix: Matrix4;
        initialize(): void;
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionLockSize(): boolean;
        set optionLockSize(value: boolean);
        get groupLevel(): number;
        set groupLevel(value: number);
        get layerLevel(): number;
        set layerLevel(value: number);
        get parent(): V3dGraphicNode;
        set parent(parent: V3dGraphicNode);
        get width(): number;
        set width(value: number);
        get height(): number;
        set height(value: number);
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        get layerMask(): number;
        set layerMask(value: number);
        show(): void;
        hide(): void;
        freezeWorldMatrix(force?: boolean): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuPicker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { V3dGraphicContent } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContent';
    import { V3dPicker } from 'foundation/editor/view/view3d/selection/V3dPicker';
    import { V3dPickerItem } from 'foundation/editor/view/view3d/selection/V3dPickerItem';
    import { Display } from 'foundation/editor/view/base/Display';
    import { Layer } from 'foundation/editor/view/base/Layer';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    import { GpuContainer } from "foundation/editor/render/gpu/GpuContainer";
    import { GpuLines } from "foundation/editor/render/gpu/GpuLines";
    import { GpuMesh } from "foundation/editor/render/gpu/GpuMesh";
    export class GpuSelectPickInfo extends V3dPickerItem {
    }
    export class GpuPicker extends V3dPicker {
        optionWorker: boolean;
        protected _selects: Array<V3dPickerItem>;
        protected _selectItem: V3dPickerItem;
        protected _trackingDisplays: Map<number, Display>;
        protected _trackingMeshLayerMap: Map<number, string>;
        protected _filterLayers: Types<any>;
        protected _skipEntity: ContentNode;
        protected _lastPickerDisplay: any;
        protected _lastPosition: Vector2;
        protected _lastGroundPosition: Vector2;
        protected _lastTick: number;
        pickInfo: GpuSelectPickInfo;
        handlePicker: SkNative.FStageSelectPicker;
        forceOutPick: boolean;
        constructor(context?: V3dCanvasContext);
        setup(): void;
        enable(): void;
        disable(): void;
        protected setTrackingMeshHandle(layer: Layer, display: Display, mesh: V3dGraphicContent, isTrack: boolean): void;
        setTrackingMesh(layer: Layer, display: Display, mesh: GpuLines | GpuMesh | GpuContainer, isTrack: boolean): void;
        addTrackingMesh(layer: Layer, display: Display, handle: any): void;
        removeTrackingMesh(layer: Layer, display: Display, handle: any): void;
        get statusPicking(): boolean;
        pickSingle(x: number, y: number, layers: Types<any>, skipEntity?: ContentNode, force?: boolean): V3dPickerItem;
        pick(x: number, y: number, layers: Types<any>, multiPicking: boolean): Array<V3dPickerItem>;
        canvasToXZPlanePoint(x: number, y: number, contentHeight: number, i?: any): Vector3;
        clear(): void;
        pickerA(): void;
        pickerB(): void;
        pickerC(): void;
        dumpScene(): void;
        pickTest(x: number, y: number): V3dPickerItem;
    }
}
declare module "foundation/editor/render/gpu/GpuSpriteManager" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicSpriteManager } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteManager';
    export class GpuSpriteManager extends V3dGraphicSpriteManager {
        handle: SkNative.FStageSprite;
        handleMaterial: SkNative.FStageMeshSpriteMaterial;
        textTexture: any;
        protected _parent: any;
        protected _worldMatrix: Matrix4;
        protected _spriteWidth: number;
        protected _spriteHeight: number;
        initialize(): void;
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get parent(): any;
        set parent(parent: any);
        get layerMask(): number;
        set layerMask(value: number);
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuSpriteMaterial" {
    import { V3dGraphicDynamicTexture } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicTexture';
    import { V3dGraphicSpriteMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteMaterial';
    export class GpuSpriteMaterial extends V3dGraphicSpriteMaterial {
        className: string;
        handle: SkNative.FStageMeshSpriteMaterial;
        protected _dynamicTexture: V3dGraphicDynamicTexture;
        constructor(name?: string);
        initialize(): void;
        get optionTransparent(): boolean;
        set optionTransparent(value: boolean);
        get optionDepthWrite(): boolean;
        set optionDepthWrite(value: boolean);
        get disableDepthWrite(): boolean;
        set disableDepthWrite(value: boolean);
        get zOffset(): number;
        set zOffset(value: number);
        get alphaMode(): number;
        set alphaMode(value: number);
        get dynamicTexture(): V3dGraphicDynamicTexture;
        set dynamicTexture(texture: V3dGraphicDynamicTexture);
        get backFaceCulling(): boolean;
        set backFaceCulling(value: boolean);
        get disableLighting(): boolean;
        set disableLighting(value: boolean);
        dirty(): void;
        freeze(): void;
    }
}
declare module "foundation/editor/render/gpu/GpuTextureCube" {
    import { V3dGraphicTextureCube } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTextureCube';
    export class GpuTextureCube extends V3dGraphicTextureCube {
        className: string;
        handle: any;
        constructor();
    }
}
declare module "foundation/editor/render/gpu/GpuTextureHdr" {
    import { V3dGraphicTextureHdr } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTextureHdr';
    export class GpuTextureHdr extends V3dGraphicTextureHdr {
    }
}
declare module "foundation/editor/render/gpu/GpuRenderFactory" {
    import { V3dGraphicContainerOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicDynamicTexture, V3dGraphicDynamicTextureOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicTexture';
    import { V3dGraphicLayerGroupOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup';
    import { V3dGraphicLineMaterialOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial';
    import { V3dGraphicLinesOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMaterial, V3dGraphicMaterialOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial';
    import { V3dGraphicMeshOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterialOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dGraphicRenderer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicRenderer';
    import { V3dGraphicRenderFactory } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicRenderFactory';
    import { V3dGraphicSceneOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicScene';
    import { V3dGraphicSpriteOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicSprite';
    import { V3dGraphicSpriteManagerOption } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteManager';
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicTexture';
    import { V3dPicker } from 'foundation/editor/view/view3d/selection/V3dPicker';
    import { GpuCamera } from "foundation/editor/render/gpu/GpuCamera";
    import { GpuContainer } from "foundation/editor/render/gpu/GpuContainer";
    import { GpuDynamicTexture } from "foundation/editor/render/gpu/GpuDynamicTexture";
    import { GpuLayer } from "foundation/editor/render/gpu/GpuLayer";
    import { GpuLayerGroup } from "foundation/editor/render/gpu/GpuLayerGroup";
    import { GpuLight } from "foundation/editor/render/gpu/GpuLight";
    import { GpuLineMaterial } from "foundation/editor/render/gpu/GpuLineMaterial";
    import { GpuLines } from "foundation/editor/render/gpu/GpuLines";
    import { GpuMesh } from "foundation/editor/render/gpu/GpuMesh";
    import { GpuMeshMaterial } from "foundation/editor/render/gpu/GpuMeshMaterial";
    import { GpuModel } from "foundation/editor/render/gpu/GpuModel";
    import { GpuScene } from "foundation/editor/render/gpu/GpuScene";
    import { GpuSprite } from "foundation/editor/render/gpu/GpuSprite";
    import { GpuSpriteManager } from "foundation/editor/render/gpu/GpuSpriteManager";
    import { GpuSpriteMaterial } from "foundation/editor/render/gpu/GpuSpriteMaterial";
    import { GpuTexture2d } from "foundation/editor/render/gpu/GpuTexture2d";
    import { GpuTextureCube } from "foundation/editor/render/gpu/GpuTextureCube";
    import { GpuTextureHdr } from "foundation/editor/render/gpu/GpuTextureHdr";
    export class GpuRenderFactory extends V3dGraphicRenderFactory {
        materials: Array<V3dGraphicMaterial>;
        textures: Array<V3dGraphicTexture | V3dGraphicDynamicTexture>;
        constructor();
        createRenderer(options: any): V3dGraphicRenderer;
        createPicker(name?: string): V3dPicker;
        createScene(name?: string, options?: V3dGraphicSceneOptions): GpuScene;
        createLayerGroup(name?: string, options?: V3dGraphicLayerGroupOptions): GpuLayerGroup;
        createLayer(name?: string, options?: any): GpuLayer;
        createCamera(name?: string, type?: string): GpuCamera;
        createLight(name?: string, type?: string): GpuLight;
        createContainer(name?: string, options?: V3dGraphicContainerOptions): GpuContainer;
        createModel(name?: string): GpuModel;
        createLineMaterial(name?: string, typeName?: string, options?: V3dGraphicLineMaterialOptions): GpuLineMaterial;
        createLines(name?: string, options?: V3dGraphicLinesOption): GpuLines;
        createMeshMaterial(name?: string, typeName?: string, options?: V3dGraphicMeshMaterialOptions): GpuMeshMaterial;
        createMesh(name?: string, options?: V3dGraphicMeshOption): GpuMesh;
        createDynamicTexture(name?: string, options?: V3dGraphicDynamicTextureOption): GpuDynamicTexture;
        createSpriteMaterial(name?: string, options?: V3dGraphicMaterialOptions): GpuSpriteMaterial;
        createSpriteManager(name?: string, options?: V3dGraphicSpriteManagerOption): GpuSpriteManager;
        createSprite(name?: string, options?: V3dGraphicSpriteOption): GpuSprite;
        createTexture2d(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): GpuTexture2d;
        createTetureHdr(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): GpuTextureHdr;
        createTetureCube(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): GpuTextureCube;
    }
}
declare module "foundation/editor/render/gpu/GpuSetting" {
    export class GpuSetting {
        alpha: boolean;
        antialias: boolean;
        depth: boolean;
        stencil: boolean;
        premultipliedAlpha: boolean;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dContainer" {
    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';
    export class Gpu2dContainer extends V2dGraphicContainer {
        className: string;
        optionWorker: boolean;
        handle: any;
        hitInvoker: any;
        constructor();
        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;
        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;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dHook" {
    import { V2dHook } from 'foundation/editor/view/view2d/render/V2dHook';
    export class Gpu2dHook extends V2dHook {
        element: any;
        elementHandle: any;
        constructor();
        setup(): void;
        testTargetElement(event: any): boolean;
        active(): void;
        deactive(): void;
        onClick(event: any): void;
        onMouseOver(event: any): void;
        onMouseOut(event: any): void;
        onMouseDown(event: any): void;
        onMouseMove(event: any): void;
        onMouseUp(event: any): void;
        onDragStart(event: any): void;
        onDragMove(event: any): void;
        onDragEnd(event: any): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dMesh" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicMesh } from 'foundation/editor/view/view2d/render/V2dGraphicMesh';
    export class Gpu2dMesh extends V2dGraphicMesh {
        className: string;
        optionWorker: boolean;
        handle: 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);
        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;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dSprite" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicSprite } from 'foundation/editor/view/view2d/render/V2dGraphicSprite';
    export class Gpu2dSprite extends V2dGraphicSprite {
        className: string;
        optionWorker: boolean;
        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;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dText" {
    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';
    export class Gpu2dText extends V2dGraphicText {
        className: string;
        optionWorker: boolean;
        handle: any;
        options: any;
        _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 "foundation/editor/render/gpu/g2d/Gpu2dTextStyle" {
    import { V2dGraphicTextStyle } from 'foundation/editor/view/view2d/render/V2dGraphicTextStyle';
    export class Gpu2dTextStyle extends V2dGraphicTextStyle {
        className: string;
        optionWorker: boolean;
        handle: any;
        options: any;
        constructor(sytle?: any);
        initialize(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/render/gpu/g2d/Gpu2dTexutre" {
    import { V2dTexture } from 'foundation/editor/view/view2d/asset/V2dTexture';
    export class Gpu2dTexutre extends V2dTexture {
        optionWorker: boolean;
        loadUrl(url: string): void;
    }
}
declare module "foundation/editor/render/gpu/g2d/GpuGraphic2d" {
    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';
    export class GpuGraphic2d extends V2dGraphicDrawing {
        className: string;
        optionWorker: boolean;
        handle: 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);
        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?: any): 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?: any): void;
        drawDimension(point1: Vector2, point2: Vector2, angle: number, dimPoint: Vector2): void;
        drawDottedLine(start: Vector2, end: Vector2, scale?: number, segmentLength?: number, rect?: any, lineTypeOption?: any): void;
        private drawLineByLinearType;
        drawGraph(context: V2dCanvasContext, nodes: Curve2dNode[]): void;
        addChild(content: any): void;
        removeChild(content: any): void;
        clear(): void;
    }
}
declare module "foundation/editor/render/gpu/g2d/GpuRender2dFactory" {
    import { V2dTexture } from 'foundation/editor/view/view2d/asset/V2dTexture';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dGraphicMesh } from 'foundation/editor/view/view2d/render/V2dGraphicMesh';
    import { V2dGraphicRenderer } from 'foundation/editor/view/view2d/render/V2dGraphicRenderer';
    import { V2dGraphicRenderFactory } from 'foundation/editor/view/view2d/render/V2dGraphicRenderFactory';
    import { V2dGraphicSprite } from 'foundation/editor/view/view2d/render/V2dGraphicSprite';
    import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
    import { V2dGraphicTextStyle } from 'foundation/editor/view/view2d/render/V2dGraphicTextStyle';
    import { V2dHook } from 'foundation/editor/view/view2d/render/V2dHook';
    import { V2dPicker } from 'foundation/editor/view/view2d/render/V2dPicker';
    import { V2dScene } from 'foundation/editor/view/view2d/V2dScene';
    export class GpuRender2dFactory extends V2dGraphicRenderFactory {
        createRenderer(options: any): V2dGraphicRenderer;
        createPicker(name?: string): V2dPicker;
        createScene(name?: string): V2dScene;
        createLayer(name?: string): any;
        createContainer(name?: string, options?: any): V2dGraphicContainer;
        createGraphics(name?: string): V2dGraphicDrawing;
        createSprite(name?: string): V2dGraphicSprite;
        createTexture(name?: string): V2dTexture;
        createMesh(name?: string): V2dGraphicMesh;
        createText(name?: string, text?: string, options?: any, style?: any): V2dGraphicText;
        createTextStyle(name?: string, options?: any): V2dGraphicTextStyle;
        createHook(name?: string, owner?: any, element?: any, torlerance?: number): V2dHook;
    }
}