gs-bim-air 1.6.1-cae.3 → 1.6.1-cae.5

package/types/longan/src/operators/cuttingPlane.d.ts

@@ -0,0 +1,55 @@
+import { CuttingPlanes, Geometry, PolyCylinder, Shell } from "../longan/geometry";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { Segment } from "../longan/segment";
+import { SelectionKey } from "../managers/selectionManager";
+import { ViewerOperator } from "./viewerOperator";
+export declare class CuttingPlane extends ViewerOperator {
+    typeName: string;
+    static counter: number;
+    _name: string;
+    _segment: Segment;
+    _length: number;
+    _points: Float32Array;
+    _plane: Shell;
+    _cuttingPlanes: CuttingPlanes;
+    _xAxis: PolyCylinder;
+    _yAxis: PolyCylinder;
+    _zAxis: PolyCylinder;
+    _rotateXy: Shell;
+    _rotateYz: Shell;
+    _rotateZx: Shell;
+    _cameraChange: any;
+    _xAxisVisible: boolean;
+    _yAxisVisible: boolean;
+    _zAxisVisible: boolean;
+    _rotateXyVisible: boolean;
+    _rotateYzVisible: boolean;
+    _rotateZxVisible: boolean;
+    _transform: Float32Array;
+    _downPos: Float32Array;
+    _prePos: Float32Array;
+    _selectionKey: SelectionKey;
+    _selectedGeometry: Geometry;
+    _planeVisible: boolean;
+    _planeSelectable: boolean;
+    get segment(): Segment;
+    get length(): number;
+    get planeVisible(): boolean;
+    set planeVisible(value: boolean);
+    get planeSelectable(): boolean;
+    set planeSelectable(value: boolean);
+    constructor();
+    init(): void;
+    fina(): void;
+    setLength(length: number): void;
+    setHandlers(xAxis: boolean, yAxis: boolean, zAxis: boolean, rotateXy: boolean, rotateYz: boolean, rotateZx: boolean): void;
+    setTransform(transform: Float32Array): void;
+    private createAxes;
+    private createPlane;
+    onMouseMove(e: ViewerEvent): void;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+}

package/types/longan/src/operators/earthCameraMouse.d.ts

@@ -0,0 +1,38 @@
+import { ViewerEvent } from "../longan/gs.viewer";
+import { CameraMouse } from "./cameraMouse";
+import * as LonganCore from "../longan/gs.viewer";
+export declare class EarthCameraMouse extends CameraMouse {
+    typeName: string;
+    private movePos;
+    private mButtonPos;
+    static HKPoint: Float64Array;
+    static offsetMatrixOfHK: Float64Array;
+    static cameraOffset: number;
+    static newCameraUp: any;
+    static rotateDegOfGrivityX: number;
+    static rotateDegOfGrivityY: number;
+    private renderTimeout;
+    private mouseWheelDowned;
+    static xRotateSpeed: number;
+    static yRotateSpeed: number;
+    static longitude: number;
+    static latitude: number;
+    static heightToEarthSurface: number;
+    constructor();
+    init(): void;
+    fina(): void;
+    onMouseWheel(e: ViewerEvent): void;
+    onRButtonUp(e: LonganCore.ViewerEvent): void;
+    onLButtonUp(e: LonganCore.ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onMButtonDownAndMove(e: ViewerEvent): void;
+    rotateAtGrivity(tempcamPosOf2D: Float64Array, newTarget: Float64Array): void;
+    onMButtonUp(e: LonganCore.ViewerEvent): void;
+    onLButtonDown(e: LonganCore.ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: LonganCore.ViewerEvent): void;
+    onMouseMove(e: LonganCore.ViewerEvent): void;
+    getMousePosition(e: ViewerEvent): Float64Array;
+    getMouseLonLat(worldPos: Float64Array): void;
+    getCameraHeightToEarthSurface(): void;
+}

package/types/longan/src/operators/intersectionGraph.d.ts

@@ -0,0 +1,94 @@
+import { Geometry, PolyCylinder, Shell, TriangularShell } from "../longan/geometry";
+import { List } from "../longan/gs.collections";
+import { DWcs } from "../longan/gs.math";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { Segment } from "../longan/segment";
+import { SelectionKey } from "../managers/selectionManager";
+import { LightModel } from "../objects/lightModel";
+import { ViewerOperator } from "./viewerOperator";
+export declare class IntersectionGraph extends ViewerOperator {
+    typeName: string;
+    static counter: number;
+    _name: string;
+    _segment: Segment;
+    _length: number;
+    _plane: Shell;
+    _points: Float32Array;
+    _xAxis: PolyCylinder;
+    _yAxis: PolyCylinder;
+    _zAxis: PolyCylinder;
+    _rotateXy: Shell;
+    _rotateYz: Shell;
+    _rotateZx: Shell;
+    _cameraChange: any;
+    _xAxisVisible: boolean;
+    _yAxisVisible: boolean;
+    _zAxisVisible: boolean;
+    _rotateXyVisible: boolean;
+    _rotateYzVisible: boolean;
+    _rotateZxVisible: boolean;
+    _transform: Float64Array;
+    _downPos: Float32Array;
+    _prePos: Float32Array;
+    _lButtonMoved: boolean;
+    _selectionKey: SelectionKey;
+    _selectedGeometry: Geometry;
+    _planeVisible: boolean;
+    _planeSelectable: boolean;
+    _lightModel: LightModel;
+    _graphs: List<{
+        positions: Float64Array;
+        indexes: Int32Array;
+    }>;
+    _createGraphByMouseMove: boolean;
+    _intersectionGeometryCount: number;
+    get segment(): Segment;
+    set lightModel(value: LightModel);
+    get lightModel(): LightModel;
+    get planeVisible(): boolean;
+    set planeVisible(value: boolean);
+    get createGraphByMouseMove(): boolean;
+    set createGraphByMouseMove(value: boolean);
+    get intersectionGeometryCount(): number;
+    set intersectionGeometryCount(value: number);
+    get wcs(): DWcs;
+    constructor();
+    init(): void;
+    fina(): void;
+    setLength(length: number): void;
+    setHandlers(xAxis: boolean, yAxis: boolean, zAxis: boolean, rotateXy: boolean, rotateYz: boolean, rotateZx: boolean): void;
+    setTransform(transform: Float64Array): void;
+    setPosition(root: Float64Array, normal: Float64Array, xAxis?: Float32Array): void;
+    getPolylines(): List<Float64Array>;
+    getClosedPolylines(): List<Float32Array>;
+    getContinuousPolylines(mergeTolerance: number): List<Float64Array>;
+    CreatePolylinesByShell(geom: Shell | TriangularShell): List<Float64Array>;
+    createContinuousPolylinesByShell(geom: Shell | TriangularShell, mergeTolerance: number): List<Float64Array>;
+    private createAxes;
+    private createPlane;
+    createGraph(): void;
+    getPolygons(boundary: Float64Array): {
+        positions: Float64Array;
+        indexes: Int32Array;
+    } | null;
+    polygonsToArrays(polygons: {
+        positions: Float64Array;
+        indexes: Int32Array;
+    }, closed?: boolean): List<Float64Array>;
+    polylinesToArrays(polylines: {
+        positions: Float64Array;
+        indexes: Int32Array;
+    }): List<Float64Array>;
+    arraysToPolygons(polygons: List<Float64Array>): {
+        positions: Float64Array;
+        indexes: Int32Array;
+    };
+    private createPolylinesByGraph;
+    private createClosedPolylinesByGraph;
+    onMouseMove(e: ViewerEvent): void;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+}

package/types/longan/src/operators/objectPreSelector.d.ts

@@ -0,0 +1,69 @@
+import { List } from "../longan/gs.collections";
+import { ElementType, ViewerEvent } from "../longan/gs.viewer";
+import { IKey } from "../longan/utility";
+import { SelectionKey } from "../managers/selectionManager";
+import { ViewerOperator } from "./viewerOperator";
+export declare class ObjectPreSelector extends ViewerOperator {
+    typeName: string;
+    _selectedKey: SelectionKey;
+    _faceSelection: boolean;
+    _edgeSelection: boolean;
+    _vertexSelection: boolean;
+    _snapElementType: ElementType;
+    _snapPosition: Float32Array;
+    _snapNormal: Float32Array;
+    _enable: boolean;
+    keySelected: List<(sender: ObjectPreSelector) => void>;
+    keyUnSelected: List<(sender: ObjectPreSelector) => void>;
+    /**
+     * 获取顶点可选性
+     */
+    get vertexSelection(): boolean;
+    /**
+     * 设置顶点可选性
+     */
+    set vertexSelection(onoff: boolean);
+    /**
+     * 获取顶点可选性
+     */
+    get edgeSelection(): boolean;
+    /**
+     * 设置边可选性
+     */
+    set edgeSelection(onoff: boolean);
+    /**
+     * 获取面可选性
+     */
+    get faceSelection(): boolean;
+    /**
+     * 设置面可选性
+     */
+    set faceSelection(onoff: boolean);
+    /**
+     * 获取选择信息
+     */
+    get selectedKey(): SelectionKey;
+    /**
+     * 获取选择对象
+     */
+    get selectedObject(): IKey;
+    /**
+     * 获取预选择元素类型
+     */
+    get snapElementType(): ElementType;
+    /**
+     * 获取预选择位置
+     */
+    get snapPosition(): ArrayLike<number>;
+    /**
+     * 获取预选择法向
+     */
+    get snapNormal(): ArrayLike<number>;
+    get enable(): boolean;
+    set enable(value: boolean);
+    constructor();
+    init(): void;
+    fina(): void;
+    clearSelection(): void;
+    onMouseMove(e: ViewerEvent): void;
+}

package/types/longan/src/operators/objectSelector.d.ts

@@ -0,0 +1,54 @@
+import { List } from "../longan/gs.collections";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { SelectionKey } from "../managers/selectionManager";
+import { ViewerOperator } from "./viewerOperator";
+export declare class ObjectSelector extends ViewerOperator {
+    typeName: string;
+    protected _selectionKey: SelectionKey;
+    protected _isMultiSelect: boolean;
+    protected _isAreaSelect: boolean;
+    protected _faceSelection: boolean;
+    protected _edgeSelection: boolean;
+    protected _vertexSelection: boolean;
+    get selectionKey(): SelectionKey;
+    /**
+     * 获取顶点可选性
+     */
+    get vertexSelection(): boolean;
+    /**
+     * 设置顶点可选性
+     */
+    set vertexSelection(onoff: boolean);
+    /**
+     * 获取顶点可选性
+     */
+    get edgeSelection(): boolean;
+    /**
+     * 设置边可选性
+     */
+    set edgeSelection(onoff: boolean);
+    /**
+     * 获取面可选性
+     */
+    get faceSelection(): boolean;
+    /**
+     * 设置面可选性
+     */
+    set faceSelection(onoff: boolean);
+    get isMultiSelect(): boolean;
+    set isMultiSelect(isMultiSelect: boolean);
+    downPos: Float32Array;
+    get clickPos(): Float32Array;
+    get isAreaSelect(): boolean;
+    set isAreaSelect(value: boolean);
+    constructor();
+    objectSelected: List<() => void>;
+    objectUnSelected: List<() => void>;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onWindowKeyDown(e: ViewerEvent): void;
+    onWindowKeyUp(e: ViewerEvent): void;
+    selectByArea(downPos: any, upPos: any): void;
+    selectByPoint(pos: any): void;
+    protected isEqual(arr: any, arr1: any, tolerance?: number): boolean;
+}

package/types/longan/src/operators/panoramaCameraMouse.d.ts

@@ -0,0 +1,24 @@
+import { List } from "../longan/gs.collections";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { CameraMouse } from "./cameraMouse";
+export declare class PanoramaCameraMouse extends CameraMouse {
+    typeName: string;
+    rButtonUp: List<() => void>;
+    private mButtonPos;
+    private movePos;
+    private mouseWheelDowned;
+    xAxis: Float32Array;
+    constructor();
+    init(): void;
+    fina(): void;
+    onMouseWheel(e: ViewerEvent): void;
+    onRButtonUp(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onMButtonDownAndMove(e: ViewerEvent): void;
+    onMButtonUp(e: ViewerEvent): void;
+    onLButtonDown(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: ViewerEvent): void;
+    computeNewTarget(target: Float32Array): void;
+}

package/types/longan/src/operators/perspectiveCameraMouse.d.ts

@@ -0,0 +1,13 @@
+import { CameraMouse } from "./cameraMouse";
+import { ViewerEvent } from "../longan/gs.viewer";
+export declare class PerspectiveCameraMouse extends CameraMouse {
+    typeName: string;
+    winPos: any;
+    downPos: Float64Array;
+    constructor();
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonUp(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: ViewerEvent): void;
+}

package/types/longan/src/operators/viewerOperator.d.ts

@@ -0,0 +1,68 @@
+import { List } from "../longan/gs.collections";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { Viewer } from "../viewer";
+export declare enum CameraOperateState {
+    None = 0,
+    Pan = 1,
+    Scale = 2,
+    Rotate = 3
+}
+export declare enum MoveButtonType {
+    Left = 0,
+    Middle = 1,
+    Right = 2
+}
+export declare class ViewerOperator {
+    typeName: string;
+    protected _viewer: Viewer;
+    protected _enable: boolean;
+    lButtonDown: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    lButtonUp: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    rButtonDown: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    rButtonUp: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    mButtonDown: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    mButtonUp: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    mouseWheel: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    mouseMove: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    lButtonDownAndMove: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    mButtonDownAndMove: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    rButtonDownAndMove: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    touchStart: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    touchMove: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    touchEnd: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    touchCancel: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    keyDown: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    keyPress: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    keyUp: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    windowKeyDown: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    windowKeyPress: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    windowKeyUp: List<(sender: ViewerOperator, event: ViewerEvent) => void>;
+    get viewer(): Viewer;
+    set viewer(viewer: Viewer);
+    get enable(): boolean;
+    set enable(enable: boolean);
+    constructor();
+    init(): void;
+    fina(): void;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onMButtonUp(e: ViewerEvent): void;
+    onMouseWheel(e: ViewerEvent): void;
+    onMouseMove(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+    onMButtonDownAndMove(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: ViewerEvent): void;
+    onTouchStart(e: ViewerEvent): void;
+    onTouchMove(e: ViewerEvent): void;
+    onTouchEnd(e: ViewerEvent): void;
+    onTouchCancel(e: ViewerEvent): void;
+    onKeyDown(e: ViewerEvent): void;
+    onKeyUp(e: ViewerEvent): void;
+    onKeyPress(e: ViewerEvent): void;
+    onWindowKeyDown(e: ViewerEvent): void;
+    onWindowKeyUp(e: ViewerEvent): void;
+    onWindowKeyPress(e: ViewerEvent): void;
+}

package/types/longan/src/process.d.ts

@@ -0,0 +1,76 @@
+import { List, NumberKeyList } from "./longan/gs.collections";
+import { AnimationManager } from "./managers/animationManager";
+import { CollisionManager } from "./managers/collisionManager";
+import { CommandManager } from "./managers/commandManager";
+import { HistoryManager } from "./managers/historyManager";
+import { PersistenceManager } from "./managers/persistenceManager";
+import { TaskManager } from "./managers/taskManager";
+import { RenderObject } from "./objects/renderObject";
+import { Viewer } from "./viewer";
+import { ViewModel } from "./viewModel";
+import { StatePack } from "./history/statePack";
+import { CloneManager } from "./managers/cloneManager";
+import { ReferenceObject } from "./objects/referenceObject";
+export declare enum RenderObjectProcessState {
+    Add = 0,
+    Remove = 1
+}
+export declare class Process {
+    static processList: List<Process>;
+    static activeProcess: Process;
+    static statusChanged: List<(msg: string) => void>;
+    viewers: List<Viewer>;
+    viewModel: ViewModel;
+    protected _activeViewer: Viewer;
+    protected _renderObjects: NumberKeyList<RenderObject>;
+    protected _referenceObjects: NumberKeyList<List<RenderObject>>;
+    protected _renderObject: RenderObject;
+    commandManager: CommandManager;
+    historyManager: HistoryManager;
+    persistenceManager: PersistenceManager;
+    cloneManager: CloneManager;
+    animationManager: AnimationManager;
+    collisionManager: CollisionManager;
+    taskManager: TaskManager;
+    modelChanged: List<(process: Process, ro: RenderObject, state: RenderObjectProcessState) => void>;
+    get renderObject(): RenderObject;
+    set renderObject(value: RenderObject);
+    get renderObjects(): NumberKeyList<RenderObject>;
+    get referenceList(): NumberKeyList<List<RenderObject>>;
+    get activeViewer(): Viewer;
+    set activeViewer(vi: Viewer);
+    constructor();
+    initManagers(): void;
+    dispose(): void;
+    activate(): void;
+    addViewer(viewer: Viewer): void;
+    removeViewer(viewer: Viewer | string): void;
+    findViewer(name: string): Viewer;
+    /**
+     * 将ro添加到parent节点下
+     * @param parent 父节点
+     * @param ro 要添加的节点
+     * @returns
+     */
+    addRenderObject(parent: RenderObject, ro: RenderObject): StatePack;
+    removeRenderObject(ro: RenderObject): StatePack;
+    clearRenderObjects(disposeRenderObjects?: boolean): void;
+    addReference(parent: ReferenceObject, ro: RenderObject): void;
+    /**
+     * 通过对象名查找对象
+     * @param name 对象名
+     * @returns
+     */
+    findRenderObjectByName(name: string): RenderObject;
+    findRenderObjectByNameInChildObject(parentRO: RenderObject, name: string): RenderObject;
+    findRenderObjectsHasString(string: string): RenderObject[];
+    findRenderObjectByType<T extends RenderObject>(type: string): T;
+    findRenderObjectsByType<T extends RenderObject>(type: string): T[];
+    findModelRenderObjects(): RenderObject[];
+    findRenderObjectsById<T extends RenderObject>(type: string): T[];
+    findRenderObjectById(id: string): RenderObject;
+    private renderModelItem;
+    protected internalAddRo(self: Process, ro: RenderObject): void;
+    private internalRemoveRo;
+    getRenderObjectBySegmentKey(key: number): any;
+}

package/types/longan/src/propertyComponents/baseShader.d.ts

@@ -0,0 +1,26 @@
+import { Shader } from "./shader";
+export declare class BaseShader extends Shader {
+    get vertexOut(): string;
+    get fragmentIn(): string;
+    get vertexVoid(): string;
+    get vertexUniform(): string;
+    get fragmentUniform(): string;
+    get fragmentVoid(): string;
+    get customBlinnPhong(): string;
+    get customTextureSampling(): string;
+    get customEdgeFragment(): string;
+    get customVertexPos(): string;
+    get vertexMain(): string;
+    get fragmentMain(): string;
+    lambert_face: string;
+    half_lambert_face: string;
+    phong_face: string;
+    blinn_phong_face: string;
+    blinn_phong_face_custom: string;
+    blinn_phong_double_face: string;
+    banded_face: string;
+    pbr_face: string;
+    get vertex(): string;
+    get fragment(): string;
+    constructor();
+}

package/types/longan/src/propertyComponents/propertyComponent.d.ts

@@ -0,0 +1,17 @@
+import { Segment } from "../longan/segment";
+import { RenderObject } from "../objects/renderObject";
+export declare class PropertyComponent {
+    typeName: string;
+    _name: string;
+    _image: string;
+    _owner: RenderObject;
+    _segment: Segment;
+    get name(): string;
+    set name(value: string);
+    get image(): string;
+    set image(value: string);
+    get owner(): RenderObject;
+    constructor();
+    initComponent(): void;
+    finaComponent(): void;
+}

package/types/longan/src/propertyComponents/shader.d.ts

@@ -0,0 +1,50 @@
+import { PropertyComponent } from "./propertyComponent";
+export declare class vertexArrayObjectInfo {
+    vao: WebGLVertexArrayObject;
+    length: number;
+    type: number;
+    isElement: boolean;
+    constructor(vao: WebGLVertexArrayObject, length: number, type: number, isElement: boolean);
+}
+export declare class Shader extends PropertyComponent {
+    typeName: string;
+    _name: string;
+    _image: string;
+    _gl: WebGL2RenderingContext;
+    _program: WebGLProgram;
+    _vertex: string;
+    _fragment: string;
+    private _setting;
+    private _listUniformLocations;
+    private _listSetPropertyEvents;
+    isLog: boolean;
+    get name(): string;
+    set name(value: string);
+    get image(): string;
+    set image(value: string);
+    get gl(): WebGLRenderingContext;
+    get program(): WebGLProgram;
+    get vertex(): string;
+    get fragment(): string;
+    constructor();
+    initComponent(): void;
+    protected setSource(): void;
+    protected setObject(): void;
+    protected init(): void;
+    protected update(time?: number): void;
+    getAttribLocation(name: string): number;
+    getUniformLocation(name: string): WebGLUniformLocation;
+    private getGLTypeForTypedArray;
+    createBuffer(attrName: string, data: BufferSource, attrSize: number): WebGLBuffer;
+    createIndexBuffer(indices: BufferSource): WebGLBuffer;
+    createVertexArray(vaoInfo: any): vertexArrayObjectInfo;
+    renderVao(vaoInfo: vertexArrayObjectInfo): void;
+    setInt(name: string, value: number): void;
+    setFloat(name: string, value: number): void;
+    setFloat2v(name: string, value: Float32Array): void;
+    setFloat3v(name: string, value: Float32Array): void;
+    setFloat4v(name: string, value: Float32Array): void;
+    setFloatv(name: string, value: Float32Array): void;
+    setMat4(name: string, value: Float32Array): void;
+    getUniform(name: string): Promise<any>;
+}

package/types/longan/src/utility.d.ts

@@ -0,0 +1,11 @@
+export declare class DevModule {
+    static onReady: () => void;
+}
+export declare class TypeHelper {
+    static typeName(ctor: {
+        typeName: string;
+    }): string;
+}
+export declare class SegmentHelper {
+    static Route(key: number): void;
+}

package/types/longan/src/utils/cookie.d.ts

@@ -0,0 +1,2 @@
+export declare function setCookie(name: string, value: string, seconds: number): void;
+export declare function getCookie(name: string): string;

package/types/longan/src/utils/utility.d.ts

@@ -0,0 +1,3 @@
+export default function loadScript(src: any): Promise<void>;
+export declare function isSupportH2(): boolean;
+export declare function isPC(): boolean;

package/types/longan/src/utils/uuid.d.ts

@@ -0,0 +1 @@
+export default function uuid(): string;

package/types/longan/src/viewModel.d.ts

@@ -0,0 +1,26 @@
+import { RenderObject } from "./objects/renderObject";
+import { Process } from "./process";
+import { Viewer } from "./viewer";
+export declare class ViewModel {
+    process: Process;
+    fileId: string;
+    filePath: string;
+    userId: string;
+    private _modelServiceHost;
+    constructor();
+    dispose(): void;
+    get viewer(): Viewer;
+    set viewer(value: Viewer);
+    modelServiceHost(host?: string): string;
+    getModel(id: string): any;
+    getModelByPath(userId: string, filePath: string): any;
+    getFileName(id: string): any;
+    renameFile(id: string, name: string): boolean;
+    loadModel(id: string): void;
+    loadModelByObject(model: any): void;
+    loadModelByPath(userId: string, filePath: string): void;
+    findObjectByType<T extends RenderObject>(name: string): T;
+    findObjectByName(name: string): RenderObject;
+    locateComponent(id: string): void;
+    locateComponents(ids: ArrayLike<string>): void;
+}