@realsee/dnalogel 2.6.4 → 2.6.7-dev.0

package/dist/shared-utils/Object3DHelper/Base/BaseController.d.ts

@@ -1,24 +1,39 @@
 import * as THREE from 'three';
 import { Subscribe } from '../../Subscribe';
-import type { HelperEventMap } from '../typings';
+import type { HelperEventMap, HelperOffset } from '../typings';
 import type { BaseHelper } from './BaseHelper';
 import DomEvents from '../utils/threex/domevents';
 export declare let originOpacity: {
     opacity: number;
 } | null;
 export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
-    hooks: Subscribe<HelperEventMap>;
-    helperObject3D: T;
     originObject3D: K;
+    hooks: Subscribe<HelperEventMap>;
+    protected readonly disposers: (() => void)[];
+    protected helperObject3D: T;
     protected camera: THREE.Camera;
     protected model: THREE.Object3D;
-    protected scene: THREE.Scene;
+    protected scene: THREE.Object3D;
     protected container: HTMLElement;
     protected domEvents: DomEvents;
     protected isDragging: boolean;
-    protected onRender: () => void;
     protected enabled: boolean;
-    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, onRender?: () => void);
+    protected name: string;
+    protected boundingBox?: THREE.Box3;
+    private offset?;
+    private onRender;
+    constructor(params: {
+        camera: THREE.Camera;
+        model: THREE.Object3D;
+        originObject3D: K;
+        helperObject3D: T;
+        container: HTMLElement;
+        scene: THREE.Object3D;
+        onRender?: () => void;
+        sharedHooks?: Subscribe<HelperEventMap>;
+    }, config?: {
+        offset?: HelperOffset;
+    });
     initialHelperPosition(): void;
     initialHelperQuaternion(): void;
     enable(): void;
@@ -26,23 +41,34 @@ export declare abstract class BaseController<T extends BaseHelper = BaseHelper,
     show(): void;
     hide(): void;
     dispose(): void;
-    setOpacity(opacity: number): void;
-    restoreOpacity(): void;
-    setOriginOpacityProperty(): void;
-    updateHelperPosition(): void;
-    updateHelperQuaternion(): void;
     applyHelperMatrix4(matrix4: THREE.Matrix4): void;
     applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
-    applyHelperScaleMatrix4(matrix4: THREE.Matrix4, params?: {
-        origin?: THREE.Vector3;
-        helperOrigin?: THREE.Vector3;
-    }): void;
+    applyHelperScaleMatrix4(matrix4: THREE.Matrix4, origin?: THREE.Vector3): void;
     onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
     onWantsGesture(type: 'press' | 'pan' | string, pointers: {
         x: number;
         y: number;
     }[], final: boolean): false | void;
+    onIntersectionOnModelUpdate(intersection: {
+        point: THREE.Vector3;
+    }): void;
+    protected onApplyOriginObjectScale(params: {
+        matrix4: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
+    protected onApplyOriginObjectRotate(params: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }): void;
+    protected onApplyOriginObjectPosition(params: {
+        matrix4: THREE.Matrix4;
+    }): void;
+    protected onSetOriginObjectScale(scale: THREE.Vector3): void;
+    protected onSetOriginObjectRotate(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    protected onSetOriginObjectPosition(position: THREE.Vector3): void;
     protected render(): void;
+    protected updateOffsetByScale(scale: THREE.Vector3): void;
     protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
     private getIntersectObject;
+    private calculateOffset;
 }

package/dist/shared-utils/Object3DHelper/Base/BaseHelper.d.ts

@@ -3,7 +3,12 @@ import type * as THREE from 'three';
 import { Mesh, Object3D, Vector3 } from 'three';
 import type { Direction, Direction4 } from '../typings';
 import type { tipsDom } from '../Helper/HTML/tipsDom';
-export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends Object3D {
+declare type NonVoid<T> = T extends void ? never : T;
+declare class IObject3D extends Object3D {
+    constructor();
+    removeFromParent(): this;
+}
+export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends IObject3D {
     protected originObject3D: OriginObject3D;
     protected onRender: () => any;
     get helperObject(): Object3D;
@@ -11,17 +16,16 @@ export declare abstract class BaseHelper<OriginObject3D extends Object3D = Objec
         onRender?: () => any;
     });
     render(): void;
+    enable(): void;
+    disable(): void;
     show(): void;
     hide(): void;
-    updatePosition(): void;
-    updateQuaternion(): void;
-    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
-        origin?: THREE.Vector3;
-        helperOrigin?: THREE.Vector3;
-    }): void;
-    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
-    abstract showDraggingHelper(directions?: Direction[]): void;
-    abstract dispose(): void;
+    initialPosition(): void;
+    initQuaternion(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: Vector3): void;
+    setHelperQuaternion(quaternion: THREE.Quaternion, origin?: Vector3): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: Vector3): void;
+    dispose(): void;
 }
 export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
     abstract xArrow?: Object3D & {
@@ -39,29 +43,32 @@ export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D
         line?: Object3D;
         direction: Direction;
     };
+    abstract showDraggingHelper(directions?: Direction[]): void;
+}
+export declare abstract class BoundingBoxHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
 }
 export declare abstract class RotateHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
-    abstract xyCircle: Mesh & {
+    abstract xyCircle?: Mesh & {
         direction: Direction;
     };
-    abstract xzCircle: Mesh & {
+    abstract xzCircle?: Mesh & {
         direction: Direction;
     };
-    abstract yzCircle: Mesh & {
+    abstract yzCircle?: Mesh & {
         direction: Direction;
     };
-    abstract xRingHelper: Object3D;
-    abstract yRingHelper: Object3D;
-    abstract zRingHelper: Object3D;
-    abstract xAngleHelper: Object3D & {
+    abstract xRingHelper?: Object3D;
+    abstract yRingHelper?: Object3D;
+    abstract zRingHelper?: Object3D;
+    abstract xAngleHelper?: Object3D & {
         baseAxes: Vector3;
         direction: Direction;
     };
-    abstract yAngleHelper: Object3D & {
+    abstract yAngleHelper?: Object3D & {
         baseAxes: Vector3;
         direction: Direction;
     };
-    abstract zAngleHelper: Object3D & {
+    abstract zAngleHelper?: Object3D & {
         baseAxes: Vector3;
         direction: Direction;
     };
@@ -71,7 +78,6 @@ export declare abstract class RotateHelperAbstract<OriginObject3D extends Object
 }
 export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
 }
-declare type NonVoid<T> = T extends void ? never : T;
 export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends ScaleHelperAbstract<OriginObject3D> {
     abstract points: PointType extends Object3D ? {
         point: PointType;
@@ -84,6 +90,7 @@ export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extend
     abstract cornerPositions: Vector3[];
     abstract css3DInstance?: NonVoid<Create3DElementReturnType>;
     abstract plane?: THREE.Mesh;
+    abstract showDraggingHelper(directions?: Direction[]): void;
     abstract updatePoints(): void;
     abstract enable(): void;
     abstract disable(): void;

package/dist/shared-utils/Object3DHelper/Controller/BoundingBoxController.d.ts

@@ -0,0 +1,7 @@
+import { BaseController } from '../Base/BaseController';
+import type { BoundingBoxHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+export declare class BoundingBoxController<OriginObject3D extends THREE.Object3D = THREE.Object3D> extends BaseController<BoundingBoxHelperAbstract<OriginObject3D>> {
+    protected name: string;
+    constructor(...params: ConstructorParameters<typeof BaseController<BoundingBoxHelperAbstract<OriginObject3D>>>);
+}

package/dist/shared-utils/Object3DHelper/Controller/CSS3DScaleController.d.ts

@@ -1,6 +1,7 @@
 import type { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
 import { RectangleScaleController } from './RectangleScaleController';
 export declare class CSS3DScaleController extends RectangleScaleController<CSS3DObject, HTMLElement> {
+    protected name: string;
     constructor(...params: ConstructorParameters<typeof RectangleScaleController<CSS3DObject, HTMLElement>>);
     private addHTMLEventListener;
 }

package/dist/shared-utils/Object3DHelper/Controller/MoveController.d.ts

@@ -1,8 +1,32 @@
 import { BaseController } from '../Base/BaseController';
+import * as THREE from 'three';
 import type { MoveHelperAbstract } from '../Helper';
 export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    get moveByMouseEnable(): boolean;
+    protected name: string;
     private startInfo?;
+    private _moveByMouseEnable;
+    private mouseInfo?;
+    private mousedownEventListenerDisposer;
     constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    dispose(): void;
+    /**
+     * @description: 跟随鼠标移动
+     */
+    moveByMouse(): void;
+    /**
+     * @description: 禁用跟随鼠标移动
+     */
+    disableMoveByMouse(): void;
+    onIntersectionOnModelUpdate(intersection: {
+        point: THREE.Vector3;
+    }): void;
+    protected onApplyOriginObjectScale(params: {
+        matrix4: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
+    private handleMouseDown;
+    private handleMouseUp;
     /**
      * @description: 拖动开始，找出拖的Direction
      */

package/dist/shared-utils/Object3DHelper/Controller/RectangleScaleController.d.ts

@@ -12,13 +12,18 @@ interface StartInfo {
     dragPointInCenterLeft?: boolean | null;
     plane: THREE.Plane;
 }
-export declare abstract class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
+export declare class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
     protected startInfo?: StartInfo;
+    protected name: string;
     constructor(...params: ConstructorParameters<typeof BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>>>);
     enable(): void;
     disable(): void;
     show(): void;
     hide(): void;
+    protected onApplyOriginObjectScale(params: {
+        matrix4: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
     protected getDragPlane(): THREE.Plane;
     protected dragStart(mousePoint: {
         x: number;

package/dist/shared-utils/Object3DHelper/Controller/RotateController.d.ts

@@ -1,12 +1,26 @@
 import { BaseController } from '../Base/BaseController';
 import type { RotateHelperAbstract } from '../Helper';
+import * as THREE from 'three';
 export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    protected name: string;
+    private get rotateCenter();
     private startInfo?;
     private lastRotation?;
     private rotations;
     private helperObject3DQuaternion;
+    private removeListener;
     constructor(...params: ConstructorParameters<typeof BaseController<T>>);
     initialHelperQuaternion(): void;
+    setRotateAngle(angle: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): void;
+    dispose(): void;
+    protected onApplyOriginObjectScale(params: {
+        matrix4: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
     /**
      * @description: 拖动开始，找出拖的Direction
      */

package/dist/shared-utils/Object3DHelper/Controller/ScaleController.d.ts

@@ -0,0 +1,12 @@
+import { BaseController } from '../Base/BaseController';
+import type { ScaleHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+export declare class ScaleController<OriginObject3D extends THREE.Object3D = THREE.Object3D> extends BaseController<ScaleHelperAbstract<OriginObject3D>> {
+    protected name: string;
+    constructor(...params: ConstructorParameters<typeof BaseController<ScaleHelperAbstract<OriginObject3D>>>);
+    setScale(scale: number | {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): void;
+}

package/dist/shared-utils/Object3DHelper/Helper/{OutlineHelper.d.ts → BoundingBoxHelper.d.ts}

@@ -1,10 +1,11 @@
 import * as THREE from 'three';
-export declare class OutlineHelper extends THREE.Group {
+import { BoundingBoxHelperAbstract } from '../Base/BaseHelper';
+export declare class BoundingBoxHelper<T extends THREE.Object3D = THREE.Object3D> extends BoundingBoxHelperAbstract<T> {
     box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
     outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
     private originObject;
     private positionAttribute;
-    constructor(obj: THREE.Object3D);
+    constructor(originObject: T);
     private update;
     private createOutline;
     private createBox;

package/{libs/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts → dist/shared-utils/Object3DHelper/Helper/CSS3DScaleHelper.d.ts}

@@ -2,11 +2,9 @@ import * as THREE from 'three';
 import { RectangleScaleHelperAbstract } from '.';
 import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
 import type { Vector3 } from 'three';
-import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
 import type { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/three/CSS3DObject';
 declare type NonVoid<T> = T extends void ? never : T;
-declare type OriginObjectType = CSS3DObject | THREE.Object3D;
-export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObjectType> extends RectangleScaleHelperAbstract<T, HTMLElement> {
+export declare class CSS3DScaleHelper<T extends CSS3DObjectPlus = CSS3DObjectPlus> extends RectangleScaleHelperAbstract<T, HTMLElement> {
     points: RectangleScaleHelperAbstract<THREE.Object3D, HTMLElement>['points'];
     cornerPositions: Vector3[];
     css3DInstance?: NonVoid<Create3DElementReturnType>;
@@ -22,12 +20,9 @@ export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObj
     updateQuaternion(): void;
     applyMatrix4(matrix: THREE.Matrix4): void;
     showDraggingHelper(): void;
-    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
-        origin?: Vector3;
-        helperOrigin?: Vector3;
-    }): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: Vector3): void;
     updatePoints(): void;
-    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: Vector3): void;
     enable(): void;
     disable(): void;
     show(): void;

package/dist/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -4,19 +4,22 @@ import { RotateHelperAbstract } from '../Base/BaseHelper';
 import type { Color, Direction } from '../typings';
 import { tipsDom } from './HTML/tipsDom';
 export declare class RotateHelper extends RotateHelperAbstract {
-    yzCircle: Circle;
-    xzCircle: Circle;
-    xyCircle: Circle;
-    xRingHelper: AxesDashedRing;
-    yRingHelper: AxesDashedRing;
-    zRingHelper: AxesDashedRing;
-    xAngleHelper: Sector;
-    yAngleHelper: Sector;
-    zAngleHelper: Sector;
+    yzCircle?: Circle;
+    xzCircle?: Circle;
+    xyCircle?: Circle;
+    xRingHelper?: AxesDashedRing;
+    yRingHelper?: AxesDashedRing;
+    zRingHelper?: AxesDashedRing;
+    xAngleHelper?: Sector;
+    yAngleHelper?: Sector;
+    zAngleHelper?: Sector;
     angleTips?: ReturnType<typeof tipsDom>;
     private container?;
-    constructor(originObject3D: Object3D, angleTipsParams?: {
-        container: HTMLElement;
+    constructor(originObject3D: Object3D, config?: {
+        container?: HTMLElement;
+        yzCircleEnable?: boolean;
+        xzCircleEnable?: boolean;
+        xyCircleEnable?: boolean;
     });
     updateAngleHelperQuaternion(): void;
     applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;

package/dist/shared-utils/Object3DHelper/Helper/ScaleHelper.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+import { ScaleHelperAbstract } from '../Base/BaseHelper';
+export declare class ScaleHelper<T extends THREE.Object3D = THREE.Object3D> extends ScaleHelperAbstract<T> {
+    constructor(originObject3D: T);
+}

package/dist/shared-utils/Object3DHelper/Helper/index.d.ts

@@ -1,5 +1,5 @@
 export * from '../Base/BaseHelper';
 export * from './MoveHelper';
 export * from './RotateHelper';
-export * from './RectangleScaleHelper';
-export * from './OutlineHelper';
+export * from './CSS3DScaleHelper';
+export * from './BoundingBoxHelper';

package/dist/shared-utils/Object3DHelper/index.d.ts

@@ -1,24 +1,12 @@
-import type { OutlineHelper } from './Helper';
 import type { Object3DHelperEventMap, Object3DHelperState } from './typings';
-import type { MoveController } from './Controller/MoveController';
-import type { RotateController } from './Controller/RotateController';
-import type { BaseController } from './Base/BaseController';
+import type { ObjectHelperControllers } from './typings';
 import { Subscribe } from '../Subscribe';
-interface Controllers {
-    moveController?: MoveController;
-    rotateController?: RotateController;
-    scaleController?: BaseController;
-}
-interface Helpers {
-    outlineHelper?: OutlineHelper;
-}
 export declare class Object3DHelper {
-    controllers: Controllers;
+    controllers: ObjectHelperControllers;
     state: Object3DHelperState;
     hooks: Subscribe<Object3DHelperEventMap>;
-    private helpers;
     private eventListener;
-    constructor(controllers?: Controllers, helpers?: Helpers);
+    constructor(controllers?: ObjectHelperControllers);
     /**
      * @description Show guide line
      */
@@ -50,22 +38,11 @@ export declare class Object3DHelper {
     setState(state: Partial<Object3DHelperState>, options?: {
         userAction?: boolean;
     } & Record<string, any>): void;
-    addControllers(controllers: Controllers): void;
-    addHelpers(helpers: Partial<{
-        [K in keyof Helpers]: Helpers[K];
-    }>): void;
+    addControllers(controllers: ObjectHelperControllers): void;
     getCurrentState(): Object3DHelperState;
-    private addEventListener;
-    private handleEnd;
-    private handleStart;
-    private setOtherHelpersVisible;
-    private handlePositionUpdate;
-    private handleScaleUpdate;
-    private handleRotateUpdate;
     private handleEnable;
     private handleVisible;
     private everyControllerDo;
     private handleDispose;
     private actionIfStateIsEnabled;
 }
-export {};

package/dist/shared-utils/Object3DHelper/typings/Hooks.d.ts

@@ -1,23 +1,33 @@
 import type * as THREE from 'three';
 export declare type HelperEventMap = {
+    wantToMove: (position: THREE.Vector3) => void;
+    wantToRotate: (quaternion: THREE.Quaternion) => void;
+    wantToScale: (scale: THREE.Vector3) => void;
+    move: (position: THREE.Vector3) => void;
+    rotate: (quaternion: THREE.Quaternion) => void;
+    scale: (scale: THREE.Vector3) => void;
     moveStart: () => void;
     rotateStart: () => void;
     scaleStart: () => void;
-    positionUpdate: (position: {
-        matrix4?: THREE.Matrix4;
-    } | undefined) => void;
-    rotateUpdate: (rotate: {
-        quaternion?: THREE.Quaternion;
-        origin: THREE.Vector3;
-    } | undefined) => void;
-    scaleUpdate: (scale: {
-        matrix4?: THREE.Matrix4;
-        origin?: THREE.Vector3;
-        helperOrigin: THREE.Vector3;
-    } | undefined) => void;
     moveEnd: () => void;
     rotateEnd: () => void;
     scaleEnd: () => void;
+    setObjectPosition: (position: THREE.Vector3) => void;
+    setObjectRotate: (quaternion: THREE.Quaternion, origin: THREE.Vector3) => void;
+    setObjectScale: (scale: THREE.Vector3) => void;
+    applyObjectPosition: (position: {
+        matrix4: THREE.Matrix4;
+    }) => void;
+    applyObjectRotate: (rotate: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }) => void;
+    applyObjectScale: (scale: {
+        matrix4: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }) => void;
+    moveByMouseEnable: () => void;
+    moveByMouseDisable: () => void;
 };
 export interface Object3DHelperState {
     enabled: boolean;

package/dist/shared-utils/Object3DHelper/typings/index.d.ts

@@ -1,5 +1,27 @@
 import type * as THREE from 'three';
+import type { MoveController } from '../Controller/MoveController';
+import type { RotateController } from '../Controller/RotateController';
+import type { BoundingBoxController } from '../Controller/BoundingBoxController';
+import { ScaleController } from '../Controller/ScaleController';
 export * from './Scissor';
 export * from './Direction';
 export * from './Hooks';
+export interface HelperOffset {
+    x: number | {
+        percents: number;
+    };
+    y: number | {
+        percents: number;
+    };
+    z: number | {
+        percents: number;
+    };
+}
 export declare type Color = THREE.Color | string | number;
+export declare type ClassFunctionParameters<C extends new (...params: any[]) => any, F extends keyof InstanceType<C>> = Parameters<InstanceType<C>[F]>;
+export interface ObjectHelperControllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: ScaleController;
+    boundingBoxController?: BoundingBoxController;
+}

package/dist/shared-utils/Object3DHelper/utils/boundingBox.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export default function boundingBox(object3D: THREE.Object3D): THREE.Box3 | undefined;

package/dist/shared-utils/three/GLTFLoader.d.ts

@@ -0,0 +1,2 @@
+import { GLTF } from '@realsee/five/gltf-loader';
+export default function loadGLTF(url: string): Promise<GLTF>;