vim-web 0.3.44-dev.8 → 0.3.44-dev.80

package/README.md

@@ -11,11 +11,11 @@ https://www.npmjs.com/package/vim-web
 
 ### WebGL Viewer
 - **[Small - Residence](https://vimaec.github.io/vim-web/webgl)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/webgl?vim=https://vim.azureedge.net/samples/Medical_Tower.vim)**
+- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/webgl?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
 
 ### Ultra Viewer
 - **[Small - Residence](https://vimaec.github.io/vim-web/ultra)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/ultra?vim=https://vim.azureedge.net/samples/Medical_Tower.vim)**
+- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/ultra?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
 
 Find detailed camera controls here: [Camera Controls](https://docs.vimaec.com/docs/vim-cloud/webgl-navigation-and-controls-guide).
 

package/dist/style.css

@@ -733,6 +733,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-top-1 {
   top: 0.25rem;
 }
+.vc-top-10 {
+  top: 2.5rem;
+}
 .vc-top-4 {
   top: 1rem;
 }
@@ -785,6 +788,10 @@ video:where(.vim-component,.vim-component *) {
   margin-left: 0.5rem;
   margin-right: 0.5rem;
 }
+.vc-mx-auto {
+  margin-left: auto;
+  margin-right: auto;
+}
 .vc-my-1 {
   margin-top: 0.25rem;
   margin-bottom: 0.25rem;
@@ -824,6 +831,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-mt-2 {
   margin-top: 0.5rem;
 }
+.vc-mt-4 {
+  margin-top: 1rem;
+}
 .vc-mt-6 {
   margin-top: 1.5rem;
 }
@@ -845,6 +855,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-hidden {
   display: none;
 }
+.vc-h-1\/2 {
+  height: 50%;
+}
 .vc-h-2 {
   height: 0.5rem;
 }
@@ -854,18 +867,12 @@ video:where(.vim-component,.vim-component *) {
 .vc-h-\[49\%\] {
   height: 49%;
 }
-.vc-h-\[50\%\] {
-  height: 50%;
-}
 .vc-h-\[80\%\] {
   height: 80%;
 }
 .vc-h-full {
   height: 100%;
 }
-.vc-max-h-\[48px\] {
-  max-height: 48px;
-}
 .vc-max-h-\[80\%\] {
   max-height: 80%;
 }
@@ -929,6 +936,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-max-w-full {
   max-width: 100%;
 }
+.vc-max-w-md {
+  max-width: 28rem;
+}
 .vc-flex-1 {
   flex: 1 1 0%;
 }
@@ -982,6 +992,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-justify-evenly {
   justify-content: space-evenly;
 }
+.vc-gap-1 {
+  gap: 0.25rem;
+}
 .vc-gap-2 {
   gap: 0.5rem;
 }
@@ -1010,9 +1023,6 @@ video:where(.vim-component,.vim-component *) {
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-.vc-text-clip {
-  text-overflow: clip;
-}
 .vc-whitespace-nowrap {
   white-space: nowrap;
 }
@@ -1098,6 +1108,9 @@ video:where(.vim-component,.vim-component *) {
   --tw-bg-opacity: 1 !important;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity, 1)) !important;
 }
+.vc-bg-gray {
+  background-color: var(--c-gray);
+}
 .vc-bg-gray-light {
   background-color: var(--c-light-gray);
 }
@@ -1110,9 +1123,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-bg-gray-warm {
   background-color: var(--c-dark-gray-warm);
 }
-.vc-bg-overflow {
-  background-color: var(--c-overflow);
-}
 .vc-bg-primary {
   background-color: var(--c-primary);
 }
@@ -1257,6 +1267,9 @@ video:where(.vim-component,.vim-component *) {
 .vc-text-primary {
   color: var(--c-primary);
 }
+.vc-text-secondary-yellow {
+  color: var(--c-secondary-yellow);
+}
 .vc-text-white {
   --tw-text-opacity: 1;
   color: rgb(255 255 255 / var(--tw-text-opacity, 1));
@@ -1304,11 +1317,6 @@ video:where(.vim-component,.vim-component *) {
   --tw-saturate: saturate(0);
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
-.vc-backdrop-blur {
-  --tw-backdrop-blur: blur(8px);
-  -webkit-backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-  backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-}
 .\!vc-transition-opacity {
   transition-property: opacity !important;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1) !important;
@@ -1514,7 +1522,7 @@ video:where(.vim-component,.vim-component *) {
     padding-left:  min(2cqmin, 1rem);
     padding-right:  min(2cqmin, 1rem);
   }
-  
+
   .vim-control-bar-button {
     height: min(8cqmin, 2.5rem);
     width: min(8cqmin, 2.5rem);
@@ -1522,14 +1530,33 @@ video:where(.vim-component,.vim-component *) {
   .vim-control-bar-section {
     gap: min(2cqmin, 0.5rem)
   }
-  .vim-axes-panel{
+
+  .vim-rest-of-screen .vc-text-xs {
+    font-size: min(2.0cqmin, 0.75rem);
+    line-height: min(2.5cqmin, 0.85rem);
+  }
+
+  .vim-control-bar-counter{
+    margin-bottom: min(1cqmin, 0.5rem);
+    margin-right: min(2cqmin, 0.5rem);
+    margin-left: max(-2cqmin, -0.75rem);
+  }
+
+  .vim-axes-panel,
+  .vim-axes-panel-empty {
     border-radius: min(3cqmin, 1rem);
     top: min(2cqmin, 1.5rem);
     right: min(2cqmin, 1.5rem);
     width: min(22cqmin, 112px);
+  }
+  
+  .vim-axes-panel {
     height: min(28cqmin, 144px);
   }
-
+  
+  .vim-axes-panel-empty {
+    height: min(22cqmin, 112px);
+  }
   .vim-axes-panel-gizmo{
     top: min(1cqmin, 0.5rem);
     left: min(1cqmin, 0.5rem);
@@ -1896,27 +1923,14 @@ video:where(.vim-component,.vim-component *) {
   transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
 }
 
-.hover\:vc-border-primary-royal:hover {
-  border-color: var(--c-primary-royal);
-}
-
 .hover\:vc-bg-gray-lightest:hover {
   background-color: var(--c-lightest-gray);
 }
 
-.hover\:vc-bg-primary-royal:hover {
-  background-color: var(--c-primary-royal);
-}
-
 .hover\:vc-text-primary-royal:hover {
   color: var(--c-primary-royal);
 }
 
-.hover\:vc-text-white:hover {
-  --tw-text-opacity: 1;
-  color: rgb(255 255 255 / var(--tw-text-opacity, 1));
-}
-
 .hover\:vc-opacity-100:hover {
   opacity: 1;
 }

package/dist/types/core-viewers/index.d.ts

@@ -0,0 +1,3 @@
+export * as Webgl from './webgl';
+export * as Ultra from './ultra';
+export * from './shared';

package/dist/types/core-viewers/{webgl/viewer/inputs/inputHandler.d.ts → shared/baseInputHandler.d.ts}

@@ -1,16 +1,16 @@
 /**
  * @module viw-webgl-viewer/inputs
  */
-import { Viewer } from '../viewer';
 /**
+ * TODO: Use the same code for ULTRA and webgl.
  * Base class for various input handlers.
  * It provides convenience to register to and unregister from events.
  */
-export declare class InputHandler {
-    protected _viewer: Viewer;
-    protected _unregisters: Function[];
-    constructor(viewer: Viewer);
-    protected reg: (handler: Document | HTMLElement | Window, type: string, listener: (event: any) => void) => void;
+export declare class BaseInputHandler {
+    protected _canvas: HTMLCanvasElement;
+    protected _disconnect: Function[];
+    constructor(canvas: HTMLCanvasElement);
+    protected reg<T extends Event>(element: Document | HTMLElement | Window, eventType: string, callback: (event: T) => void): void;
     /**
      * Register handler to related browser events
      * Prevents double registrations

package/dist/types/core-viewers/shared/index.d.ts

@@ -0,0 +1,9 @@
+export * from './inputHandler';
+export type * from './baseInputHandler';
+export { PointerMode } from './inputHandler';
+export type * from './keyboardHandler';
+export type * from './mouseHandler';
+export type * from './raycaster';
+export type * from './selection';
+export type * from './touchHandler';
+export type * from './vim';

package/dist/types/core-viewers/shared/inputHandler.d.ts

@@ -0,0 +1,118 @@
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
+import { KeyboardHandler } from './keyboardHandler';
+import { MouseHandler } from './mouseHandler';
+import { TouchHandler } from './touchHandler';
+export declare enum PointerMode {
+    ORBIT = "orbit",
+    LOOK = "look",
+    PAN = "pan",
+    ZOOM = "zoom",
+    RECT = "rect"
+}
+export interface IInputAdapter {
+    init: () => void;
+    toggleOrthographic: () => void;
+    resetCamera: () => void;
+    clearSelection: () => void;
+    frameCamera: () => void;
+    moveCamera: (value: THREE.Vector3) => void;
+    orbitCamera: (value: THREE.Vector2) => void;
+    rotateCamera: (value: THREE.Vector2) => void;
+    panCamera: (value: THREE.Vector2) => void;
+    dollyCamera: (value: THREE.Vector2) => void;
+    keyDown: (keyCode: string) => boolean;
+    keyUp: (keyCode: string) => boolean;
+    mouseDown: (pos: THREE.Vector2, button: number) => void;
+    mouseUp: (pos: THREE.Vector2, button: number) => void;
+    mouseMove: (pos: THREE.Vector2) => void;
+    selectAtPointer: (pos: THREE.Vector2, add: boolean) => void;
+    frameAtPointer: (pos: THREE.Vector2) => void;
+    zoom: (value: number) => void;
+}
+interface InputSettings {
+    orbit: boolean;
+    scrollSpeed: number;
+    moveSpeed: number;
+    rotateSpeed: number;
+    orbitSpeed: number;
+}
+export declare class InputHandler extends BaseInputHandler {
+    /**
+     * Touch input handler
+     */
+    touch: TouchHandler;
+    /**
+     * Mouse input handler
+     */
+    mouse: MouseHandler;
+    /**
+     * Keyboard input handler
+     */
+    keyboard: KeyboardHandler;
+    scrollSpeed: number;
+    private _moveSpeed;
+    rotateSpeed: number;
+    orbitSpeed: number;
+    private _pointerActive;
+    private _pointerFallback;
+    private _pointerOverride;
+    private _onPointerOverrideChanged;
+    private _onPointerModeChanged;
+    private _onSettingsChanged;
+    private _adapter;
+    constructor(canvas: HTMLCanvasElement, adapter: IInputAdapter, settings?: Partial<InputSettings>);
+    getZoomValue(value: number): number;
+    init(): void;
+    get moveSpeed(): number;
+    set moveSpeed(value: number);
+    get onSettingsChanged(): import("ste-signals").ISignal;
+    /**
+     * Returns the last main mode (orbit, look) that was active.
+     */
+    get pointerFallback(): PointerMode;
+    /**
+     * Returns current pointer mode.
+     */
+    get pointerActive(): PointerMode;
+    /**
+     * A temporary pointer mode used for temporary icons.
+     */
+    get pointerOverride(): PointerMode;
+    set pointerOverride(value: PointerMode | undefined);
+    /**
+     * Changes pointer interaction mode. Look mode will set camera orbitMode to false.
+     */
+    set pointerActive(value: PointerMode);
+    /**
+     * Event called when pointer interaction mode changes.
+     */
+    get onPointerModeChanged(): import("ste-signals").ISignal;
+    /**
+     * Event called when the pointer is temporarily overriden.
+     */
+    get onPointerOverrideChanged(): import("ste-signals").ISignal;
+    private _onContextMenu;
+    /**
+     * Event called when when context menu could be displayed
+     */
+    get onContextMenu(): import("ste-simple-events").ISimpleEvent<THREE.Vector2>;
+    /**
+     * Calls context menu action
+     */
+    ContextMenu(position: THREE.Vector2 | undefined): void;
+    /**
+   * Register inputs handlers for default viewer behavior
+   */
+    registerAll(): void;
+    /**
+     * Unregisters all input handlers
+     */
+    unregisterAll: () => void;
+    /**
+     * Resets all input state
+     */
+    resetAll(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/core-viewers/shared/keyboardHandler.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
+type CallbackMode = 'replace' | 'append' | 'prepend';
+/**
+ * KeyboardHandler
+ *
+ * A modern keyboard handler that manages keyboard events using a stateful pattern.
+ * It supports separate handlers for key down, key up, and continuous key pressed events.
+ * The handler calculates a movement vector based on currently pressed keys.
+ */
+export declare class KeyboardHandler extends BaseInputHandler {
+    /**
+     * Callback invoked whenever the calculated movement vector is updated.
+     */
+    onMove: (value: THREE.Vector3) => void;
+    onKeyUp: (code: string) => boolean;
+    onKeyDown: (code: string) => boolean;
+    /**
+     * Speed multiplier applied when the Shift key is held.
+     * @private
+     */
+    private readonly SHIFT_MULTIPLIER;
+    /**
+     * Set of currently pressed key codes.
+     * @private
+     */
+    private pressedKeys;
+    /**
+     * Map of key down event handlers (invoked once on key down).
+     * @private
+     */
+    private keyDownHandlers;
+    /**
+     * Map of key up event handlers (invoked once on key up).
+     * @private
+     */
+    private keyUpHandlers;
+    /**
+     * Creates an instance of KeyboardHandler.
+     * @param canvas The HTMLCanvasElement to attach keyboard events to.
+     */
+    constructor(canvas: HTMLCanvasElement);
+    /**
+     * Registers the necessary keyboard event listeners.
+     * @protected
+     */
+    protected addListeners(): void;
+    private registerMovementHandlers;
+    /**
+     * Checks if a key is currently pressed.
+     * @param key The event.code of the key.
+     * @returns {boolean} True if the key is pressed, false otherwise.
+     * @private
+     */
+    isKeyPressed(key: string): boolean;
+    /**
+     * Resets the handler state by clearing all pressed keys and recalculating movement.
+     * @override
+     */
+    reset(): void;
+    /**
+     * Registers a handler for a key down event.
+     * @param code The event.code of the key.
+     * @param handler Callback invoked on key down.
+     */
+    registerKeyDown(code: string, mode: CallbackMode, handler: () => void): void;
+    /**
+     * Registers a handler for a key up event.
+     * @param code The event.code of the key.
+     * @param handler Callback invoked on key up.
+     */
+    registerKeyUp(code: string, mode: CallbackMode, handler: () => void): void;
+    private registerKey;
+    /**
+     * Internal key down event handler.
+     * @param event The KeyboardEvent object.
+     * @private
+     */
+    private _onKeyDown;
+    /**
+     * Internal key up event handler.
+     * @param event The KeyboardEvent object.
+     * @private
+     */
+    private _onKeyUp;
+    /**
+     * Calculates and applies the movement vector based on currently pressed keys.
+     * Also calls any continuous key pressed handlers for keys that are held down.
+     * @private
+     */
+    private applyMove;
+}
+export {};

package/dist/types/core-viewers/shared/mouseHandler.d.ts

@@ -0,0 +1,26 @@
+import { BaseInputHandler } from "./baseInputHandler";
+import * as THREE from 'three';
+type DragCallback = (delta: THREE.Vector2, button: number) => void;
+export declare class MouseHandler extends BaseInputHandler {
+    private _lastMouseDownPosition;
+    private _capture;
+    private _dragHandler;
+    onButtonDown: (pos: THREE.Vector2, button: number) => void;
+    onButtonUp: (pos: THREE.Vector2, button: number) => void;
+    onMouseMove: (event: THREE.Vector2) => void;
+    onDrag: DragCallback;
+    onClick: (position: THREE.Vector2, ctrl: boolean) => void;
+    onDoubleClick: (position: THREE.Vector2) => void;
+    onWheel: (value: number, ctrl: boolean) => void;
+    constructor(canvas: HTMLCanvasElement);
+    protected addListeners(): void;
+    dispose(): void;
+    private onPointerDown;
+    private onPointerUp;
+    private handleMouseClick;
+    private onPointerMove;
+    private _onDoubleClick;
+    private onMouseScroll;
+    private relativePosition;
+}
+export {};

package/dist/types/core-viewers/shared/raycaster.d.ts

@@ -0,0 +1,13 @@
+import { THREE } from "../..";
+export interface IRaycastResult<T> {
+    /** The model Object hit */
+    object: T | undefined;
+    /** The 3D world position of the hit point */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: THREE.Vector3;
+}
+export interface IRaycaster<T> {
+    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T>>;
+    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T>>;
+}

package/dist/types/core-viewers/shared/selection.d.ts

@@ -0,0 +1,105 @@
+import { ISignal } from "ste-signals";
+import { IVimElement, IVim } from "./vim";
+import { THREE } from "../..";
+export interface ISelectionAdapter<T extends IVimElement> {
+    outline(target: T, state: boolean): void;
+}
+/**
+ * Represents a selection manager that supports adding, removing, toggling, and querying selected objects.
+ * The selection change signal is debounced to dispatch only once per animation frame.
+ */
+export declare class Selection<T extends IVimElement> {
+    private _onSelectionChanged;
+    private _selection;
+    private _adapter;
+    /**
+     * If true, reselecting the currently selected single target will toggle it instead of doing nothing.
+     */
+    toggleOnRepeatSelect: boolean;
+    /**
+     * If true, the selection manager is enabled and can modify the selection.
+     */
+    enabled: boolean;
+    /**
+     * Creates a new Selection manager.
+     * @param adapter - Adapter responsible for visual selection feedback.
+     */
+    constructor(adapter: ISelectionAdapter<T>);
+    /**
+     * Checks whether a specific object is currently selected.
+     * @param target - The target to check.
+     * @returns `true` if the object is selected; otherwise, `false`.
+     */
+    has(target: T): boolean;
+    /**
+     * Returns the number of selected objects.
+     * @returns The count of selected items.
+     */
+    count(): number;
+    /**
+     * Checks if there is at least one selected object.
+     * @returns `true` if the selection is not empty.
+     */
+    any(): boolean;
+    /**
+     * Signal that fires when the selection changes.
+     */
+    get onSelectionChanged(): ISignal;
+    /**
+     * Normalizes a value to an array of objects.
+     * @param oneOrMore - A single object or an array of objects.
+     * @returns An array of objects.
+     */
+    private toArray;
+    /**
+     * Replaces the current selection with the given object(s).
+     * If `toggleOnRepeatSelect` is true and the object is already the only selected one, it toggles it instead.
+     * @param objectOrObjects - Object(s) to select, or `undefined` to clear the selection.
+     */
+    select(object: T): void;
+    select(objects: T[]): void;
+    /**
+     * Toggles the selection state of the given object(s).
+     * @param objectOrObjects - Object(s) to toggle.
+     */
+    toggle(object: T): void;
+    toggle(objects: T[]): void;
+    /**
+     * Adds the given object(s) to the selection.
+     * @param objectOrObjects - Object(s) to add.
+     */
+    add(object: T): void;
+    add(objects: T[]): void;
+    /**
+     * Removes the given object(s) from the selection.
+     * @param objectOrObjects - Object(s) to remove.
+     */
+    remove(object: T): void;
+    remove(objects: T[]): void;
+    /**
+     * Clears the entire selection.
+     */
+    clear(): void;
+    /**
+     * Returns an array of all currently selected objects.
+     * @returns An array of selected objects.
+     */
+    getAll(): T[];
+    /**
+     * Returns all selected objects belonging to a specific VIM model.
+     * @param vim - The VIM instance to filter by.
+     * @returns An array of selected objects from the specified VIM.
+     */
+    getFromVim(vim: IVim<T>): T[];
+    /**
+     * Removes all selected objects that belong to a specific VIM model.
+     * @param vim - The VIM instance to remove selections from.
+     */
+    removeFromVim(vim: IVim<T>): void;
+    /**
+     * Computes the bounding box that contains all selected objects.
+     * Skips objects that do not implement `getBoundingBox()`.
+     * @returns A promise resolving to the combined bounding box.
+     */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}

package/dist/types/core-viewers/{webgl/viewer/inputs → shared}/touchHandler.d.ts

@@ -1,28 +1,23 @@
 /**
  * @module viw-webgl-viewer/inputs
  */
-import { InputHandler } from './inputHandler';
-import { Viewer } from '../viewer';
+import * as THREE from 'three';
+import { BaseInputHandler } from './baseInputHandler';
 /**
  * Manages user touch inputs.
  */
-export declare class TouchHandler extends InputHandler {
+export declare class TouchHandler extends BaseInputHandler {
     private readonly TAP_DURATION_MS;
     private readonly DOUBLE_TAP_DELAY_MS;
     private readonly TAP_MAX_MOVE_PIXEL;
     private readonly ZOOM_SPEED;
     private readonly MOVE_SPEED;
-    /**
-     * Speed factor for rotation movements
-     */
-    rotateSpeed: number;
-    /**
-     * Speed factor for orbit movements
-     */
-    orbitSpeed: number;
-    constructor(viewer: Viewer);
-    private get camera();
-    private get viewport();
+    onTap: (position: THREE.Vector2) => void;
+    onDoubleTap: (position: THREE.Vector2) => void;
+    onDrag: (delta: THREE.Vector2) => void;
+    onDoubleDrag: (delta: THREE.Vector2) => void;
+    onPinchOrSpread: (delta: number) => void;
+    constructor(canvas: HTMLCanvasElement);
     private _touch;
     private _touch1;
     private _touch2;
@@ -31,15 +26,17 @@ export declare class TouchHandler extends InputHandler {
     private _touchStart;
     protected addListeners(): void;
     reset: () => void;
-    private onTap;
+    private _onTap;
     private onTouchStart;
     private toRotation;
-    private onDrag;
-    private onDoubleDrag;
-    private onPinchOrSpread;
     private onTouchMove;
     private onTouchEnd;
     private isSingleTouch;
     private touchToVector;
     private average;
+    /**
+     * Returns the pixel size of the canvas.
+     * @returns {THREE.Vector2} The pixel size of the canvas.
+     */
+    getCanvasSize(): THREE.Vector2;
 }