three-stdlib 2.22.7 → 2.22.8

package/dist/cameras/CinematicCamera.d.ts

@@ -0,0 +1,34 @@
+import { PerspectiveCamera, ShaderMaterial, Scene, WebGLRenderer, OrthographicCamera, WebGLRenderTarget } from 'three'
+
+import { BokehShaderUniforms } from './../shaders/BokehShader2'
+
+export class CinematicCamera extends PerspectiveCamera {
+  constructor(fov: number, aspect: number, near: number, far: number)
+
+  postprocessing: {
+    enabled: boolean
+    scene: Scene
+    camera: OrthographicCamera
+    rtTextureDepth: WebGLRenderTarget
+    rtTextureColor: WebGLRenderTarget
+    bokeh_uniforms: BokehShaderUniforms
+  }
+  shaderSettings: {
+    rings: number
+    samples: number
+  }
+  materialDepth: ShaderMaterial
+  coc: number
+  aperture: number
+  fNumber: number
+  hyperFocal: number
+  filmGauge: number
+
+  linearize(depth: number): number
+  smoothstep(near: number, far: number, depth: number): number
+  saturate(x: number): number
+  focusAt(focusDistance: number): void
+  initPostProcessing(): void
+  renderCinematic(scene: Scene, renderer: WebGLRenderer): void
+  setLens(focalLength: number, frameHeight?: number, fNumber?: number, coc?: number): void
+}

package/dist/cameras/CinematicCamera.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const BokehShader2 = require("../shaders/BokehShader2.js");
+class CinematicCamera extends THREE.PerspectiveCamera {
+  constructor(fov, aspect, near, far) {
+    super(fov, aspect, near, far);
+    this.type = "CinematicCamera";
+    this.postprocessing = { enabled: true };
+    this.shaderSettings = {
+      rings: 3,
+      samples: 4
+    };
+    const depthShader = BokehShader2.BokehDepthShader;
+    this.materialDepth = new THREE.ShaderMaterial({
+      uniforms: depthShader.uniforms,
+      vertexShader: depthShader.vertexShader,
+      fragmentShader: depthShader.fragmentShader
+    });
+    this.materialDepth.uniforms["mNear"].value = near;
+    this.materialDepth.uniforms["mFar"].value = far;
+    this.setLens();
+    this.initPostProcessing();
+  }
+  // providing fnumber and coc(Circle of Confusion) as extra arguments
+  setLens(focalLength, filmGauge, fNumber, coc) {
+    if (focalLength === void 0)
+      focalLength = 35;
+    if (filmGauge !== void 0)
+      this.filmGauge = filmGauge;
+    this.setFocalLength(focalLength);
+    if (fNumber === void 0)
+      fNumber = 8;
+    if (coc === void 0)
+      coc = 0.019;
+    this.fNumber = fNumber;
+    this.coc = coc;
+    this.aperture = focalLength / this.fNumber;
+    this.hyperFocal = focalLength * focalLength / (this.aperture * this.coc);
+  }
+  linearize(depth) {
+    const zfar = this.far;
+    const znear = this.near;
+    return -zfar * znear / (depth * (zfar - znear) - zfar);
+  }
+  smoothstep(near, far, depth) {
+    const x = this.saturate((depth - near) / (far - near));
+    return x * x * (3 - 2 * x);
+  }
+  saturate(x) {
+    return Math.max(0, Math.min(1, x));
+  }
+  // function for focusing at a distance from the camera
+  focusAt(focusDistance) {
+    if (focusDistance === void 0)
+      focusDistance = 20;
+    const focalLength = this.getFocalLength();
+    this.focus = focusDistance;
+    this.nearPoint = this.hyperFocal * this.focus / (this.hyperFocal + (this.focus - focalLength));
+    this.farPoint = this.hyperFocal * this.focus / (this.hyperFocal - (this.focus - focalLength));
+    this.depthOfField = this.farPoint - this.nearPoint;
+    if (this.depthOfField < 0)
+      this.depthOfField = 0;
+    this.sdistance = this.smoothstep(this.near, this.far, this.focus);
+    this.ldistance = this.linearize(1 - this.sdistance);
+    this.postprocessing.bokeh_uniforms["focalDepth"].value = this.ldistance;
+  }
+  initPostProcessing() {
+    if (this.postprocessing.enabled) {
+      this.postprocessing.scene = new THREE.Scene();
+      this.postprocessing.camera = new THREE.OrthographicCamera(
+        window.innerWidth / -2,
+        window.innerWidth / 2,
+        window.innerHeight / 2,
+        window.innerHeight / -2,
+        -1e4,
+        1e4
+      );
+      this.postprocessing.scene.add(this.postprocessing.camera);
+      this.postprocessing.rtTextureDepth = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight);
+      this.postprocessing.rtTextureColor = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight);
+      const bokeh_shader = BokehShader2.BokehShader2;
+      this.postprocessing.bokeh_uniforms = THREE.UniformsUtils.clone(bokeh_shader.uniforms);
+      this.postprocessing.bokeh_uniforms["tColor"].value = this.postprocessing.rtTextureColor.texture;
+      this.postprocessing.bokeh_uniforms["tDepth"].value = this.postprocessing.rtTextureDepth.texture;
+      this.postprocessing.bokeh_uniforms["manualdof"].value = 0;
+      this.postprocessing.bokeh_uniforms["shaderFocus"].value = 0;
+      this.postprocessing.bokeh_uniforms["fstop"].value = 2.8;
+      this.postprocessing.bokeh_uniforms["showFocus"].value = 1;
+      this.postprocessing.bokeh_uniforms["focalDepth"].value = 0.1;
+      this.postprocessing.bokeh_uniforms["znear"].value = this.near;
+      this.postprocessing.bokeh_uniforms["zfar"].value = this.near;
+      this.postprocessing.bokeh_uniforms["textureWidth"].value = window.innerWidth;
+      this.postprocessing.bokeh_uniforms["textureHeight"].value = window.innerHeight;
+      this.postprocessing.materialBokeh = new THREE.ShaderMaterial({
+        uniforms: this.postprocessing.bokeh_uniforms,
+        vertexShader: bokeh_shader.vertexShader,
+        fragmentShader: bokeh_shader.fragmentShader,
+        defines: {
+          RINGS: this.shaderSettings.rings,
+          SAMPLES: this.shaderSettings.samples,
+          DEPTH_PACKING: 1
+        }
+      });
+      this.postprocessing.quad = new THREE.Mesh(
+        new THREE.PlaneGeometry(window.innerWidth, window.innerHeight),
+        this.postprocessing.materialBokeh
+      );
+      this.postprocessing.quad.position.z = -500;
+      this.postprocessing.scene.add(this.postprocessing.quad);
+    }
+  }
+  renderCinematic(scene, renderer) {
+    if (this.postprocessing.enabled) {
+      const currentRenderTarget = renderer.getRenderTarget();
+      renderer.clear();
+      scene.overrideMaterial = null;
+      renderer.setRenderTarget(this.postprocessing.rtTextureColor);
+      renderer.clear();
+      renderer.render(scene, this);
+      scene.overrideMaterial = this.materialDepth;
+      renderer.setRenderTarget(this.postprocessing.rtTextureDepth);
+      renderer.clear();
+      renderer.render(scene, this);
+      renderer.setRenderTarget(null);
+      renderer.render(this.postprocessing.scene, this.postprocessing.camera);
+      renderer.setRenderTarget(currentRenderTarget);
+    }
+  }
+}
+exports.CinematicCamera = CinematicCamera;

package/dist/cameras/CinematicCamera.mjs

@@ -0,0 +1,131 @@
+import { PerspectiveCamera, ShaderMaterial, Scene, OrthographicCamera, WebGLRenderTarget, UniformsUtils, Mesh, PlaneGeometry } from "three";
+import { BokehDepthShader, BokehShader2 } from "../shaders/BokehShader2.mjs";
+class CinematicCamera extends PerspectiveCamera {
+  constructor(fov, aspect, near, far) {
+    super(fov, aspect, near, far);
+    this.type = "CinematicCamera";
+    this.postprocessing = { enabled: true };
+    this.shaderSettings = {
+      rings: 3,
+      samples: 4
+    };
+    const depthShader = BokehDepthShader;
+    this.materialDepth = new ShaderMaterial({
+      uniforms: depthShader.uniforms,
+      vertexShader: depthShader.vertexShader,
+      fragmentShader: depthShader.fragmentShader
+    });
+    this.materialDepth.uniforms["mNear"].value = near;
+    this.materialDepth.uniforms["mFar"].value = far;
+    this.setLens();
+    this.initPostProcessing();
+  }
+  // providing fnumber and coc(Circle of Confusion) as extra arguments
+  setLens(focalLength, filmGauge, fNumber, coc) {
+    if (focalLength === void 0)
+      focalLength = 35;
+    if (filmGauge !== void 0)
+      this.filmGauge = filmGauge;
+    this.setFocalLength(focalLength);
+    if (fNumber === void 0)
+      fNumber = 8;
+    if (coc === void 0)
+      coc = 0.019;
+    this.fNumber = fNumber;
+    this.coc = coc;
+    this.aperture = focalLength / this.fNumber;
+    this.hyperFocal = focalLength * focalLength / (this.aperture * this.coc);
+  }
+  linearize(depth) {
+    const zfar = this.far;
+    const znear = this.near;
+    return -zfar * znear / (depth * (zfar - znear) - zfar);
+  }
+  smoothstep(near, far, depth) {
+    const x = this.saturate((depth - near) / (far - near));
+    return x * x * (3 - 2 * x);
+  }
+  saturate(x) {
+    return Math.max(0, Math.min(1, x));
+  }
+  // function for focusing at a distance from the camera
+  focusAt(focusDistance) {
+    if (focusDistance === void 0)
+      focusDistance = 20;
+    const focalLength = this.getFocalLength();
+    this.focus = focusDistance;
+    this.nearPoint = this.hyperFocal * this.focus / (this.hyperFocal + (this.focus - focalLength));
+    this.farPoint = this.hyperFocal * this.focus / (this.hyperFocal - (this.focus - focalLength));
+    this.depthOfField = this.farPoint - this.nearPoint;
+    if (this.depthOfField < 0)
+      this.depthOfField = 0;
+    this.sdistance = this.smoothstep(this.near, this.far, this.focus);
+    this.ldistance = this.linearize(1 - this.sdistance);
+    this.postprocessing.bokeh_uniforms["focalDepth"].value = this.ldistance;
+  }
+  initPostProcessing() {
+    if (this.postprocessing.enabled) {
+      this.postprocessing.scene = new Scene();
+      this.postprocessing.camera = new OrthographicCamera(
+        window.innerWidth / -2,
+        window.innerWidth / 2,
+        window.innerHeight / 2,
+        window.innerHeight / -2,
+        -1e4,
+        1e4
+      );
+      this.postprocessing.scene.add(this.postprocessing.camera);
+      this.postprocessing.rtTextureDepth = new WebGLRenderTarget(window.innerWidth, window.innerHeight);
+      this.postprocessing.rtTextureColor = new WebGLRenderTarget(window.innerWidth, window.innerHeight);
+      const bokeh_shader = BokehShader2;
+      this.postprocessing.bokeh_uniforms = UniformsUtils.clone(bokeh_shader.uniforms);
+      this.postprocessing.bokeh_uniforms["tColor"].value = this.postprocessing.rtTextureColor.texture;
+      this.postprocessing.bokeh_uniforms["tDepth"].value = this.postprocessing.rtTextureDepth.texture;
+      this.postprocessing.bokeh_uniforms["manualdof"].value = 0;
+      this.postprocessing.bokeh_uniforms["shaderFocus"].value = 0;
+      this.postprocessing.bokeh_uniforms["fstop"].value = 2.8;
+      this.postprocessing.bokeh_uniforms["showFocus"].value = 1;
+      this.postprocessing.bokeh_uniforms["focalDepth"].value = 0.1;
+      this.postprocessing.bokeh_uniforms["znear"].value = this.near;
+      this.postprocessing.bokeh_uniforms["zfar"].value = this.near;
+      this.postprocessing.bokeh_uniforms["textureWidth"].value = window.innerWidth;
+      this.postprocessing.bokeh_uniforms["textureHeight"].value = window.innerHeight;
+      this.postprocessing.materialBokeh = new ShaderMaterial({
+        uniforms: this.postprocessing.bokeh_uniforms,
+        vertexShader: bokeh_shader.vertexShader,
+        fragmentShader: bokeh_shader.fragmentShader,
+        defines: {
+          RINGS: this.shaderSettings.rings,
+          SAMPLES: this.shaderSettings.samples,
+          DEPTH_PACKING: 1
+        }
+      });
+      this.postprocessing.quad = new Mesh(
+        new PlaneGeometry(window.innerWidth, window.innerHeight),
+        this.postprocessing.materialBokeh
+      );
+      this.postprocessing.quad.position.z = -500;
+      this.postprocessing.scene.add(this.postprocessing.quad);
+    }
+  }
+  renderCinematic(scene, renderer) {
+    if (this.postprocessing.enabled) {
+      const currentRenderTarget = renderer.getRenderTarget();
+      renderer.clear();
+      scene.overrideMaterial = null;
+      renderer.setRenderTarget(this.postprocessing.rtTextureColor);
+      renderer.clear();
+      renderer.render(scene, this);
+      scene.overrideMaterial = this.materialDepth;
+      renderer.setRenderTarget(this.postprocessing.rtTextureDepth);
+      renderer.clear();
+      renderer.render(scene, this);
+      renderer.setRenderTarget(null);
+      renderer.render(this.postprocessing.scene, this.postprocessing.camera);
+      renderer.setRenderTarget(currentRenderTarget);
+    }
+  }
+}
+export {
+  CinematicCamera
+};

package/dist/controls/ArcballControls.d.ts

@@ -0,0 +1,374 @@
+import { Scene, PerspectiveCamera, OrthographicCamera, EventDispatcher } from 'three';
+declare type Camera = OrthographicCamera | PerspectiveCamera;
+/**
+ *
+ * @param {CamOrthographicCamera | PerspectiveCameraera} camera Virtual camera used in the scene
+ * @param {HTMLElement=null} domElement Renderer's dom element
+ * @param {Scene=null} scene The scene to be rendered
+ */
+declare class ArcballControls extends EventDispatcher {
+    private camera;
+    private domElement;
+    private scene;
+    private mouseActions;
+    private _mouseOp;
+    private _v2_1;
+    private _v3_1;
+    private _v3_2;
+    private _m4_1;
+    private _m4_2;
+    private _quat;
+    private _translationMatrix;
+    private _rotationMatrix;
+    private _scaleMatrix;
+    private _rotationAxis;
+    private _cameraMatrixState;
+    private _cameraProjectionState;
+    private _fovState;
+    private _upState;
+    private _zoomState;
+    private _nearPos;
+    private _farPos;
+    private _gizmoMatrixState;
+    private _up0;
+    private _zoom0;
+    private _fov0;
+    private _initialNear;
+    private _nearPos0;
+    private _initialFar;
+    private _farPos0;
+    private _cameraMatrixState0;
+    private _gizmoMatrixState0;
+    private _button;
+    private _touchStart;
+    private _touchCurrent;
+    private _input;
+    private _switchSensibility;
+    private _startFingerDistance;
+    private _currentFingerDistance;
+    private _startFingerRotation;
+    private _currentFingerRotation;
+    private _devPxRatio;
+    private _downValid;
+    private _nclicks;
+    private _downEvents;
+    private _clickStart;
+    private _maxDownTime;
+    private _maxInterval;
+    private _posThreshold;
+    private _movementThreshold;
+    private _currentCursorPosition;
+    private _startCursorPosition;
+    private _grid;
+    private _gridPosition;
+    private _gizmos;
+    private _curvePts;
+    private _timeStart;
+    private _animationId;
+    focusAnimationTime: number;
+    private _timePrev;
+    private _timeCurrent;
+    private _anglePrev;
+    private _angleCurrent;
+    private _cursorPosPrev;
+    private _cursorPosCurr;
+    private _wPrev;
+    private _wCurr;
+    adjustNearFar: boolean;
+    scaleFactor: number;
+    dampingFactor: number;
+    wMax: number;
+    enableAnimations: boolean;
+    enableGrid: boolean;
+    cursorZoom: boolean;
+    minFov: number;
+    maxFov: number;
+    enabled: boolean;
+    enablePan: boolean;
+    enableRotate: boolean;
+    enableZoom: boolean;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    private target;
+    private _currentTarget;
+    private _tbRadius;
+    private _state;
+    constructor(camera: Camera | null, domElement?: HTMLElement | null | undefined, scene?: Scene | null | undefined);
+    private onWindowResize;
+    private onContextMenu;
+    private onPointerCancel;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onWheel;
+    private onSinglePanStart;
+    private onSinglePanMove;
+    private onSinglePanEnd;
+    private onDoubleTap;
+    private onDoublePanStart;
+    private onDoublePanMove;
+    private onDoublePanEnd;
+    private onRotateStart;
+    private onRotateMove;
+    private onRotateEnd;
+    private onPinchStart;
+    private onPinchMove;
+    private onPinchEnd;
+    private onTriplePanStart;
+    private onTriplePanMove;
+    private onTriplePanEnd;
+    /**
+     * Set _center's x/y coordinates
+     * @param {Number} clientX
+     * @param {Number} clientY
+     */
+    private setCenter;
+    /**
+     * Set default mouse actions
+     */
+    private initializeMouseActions;
+    /**
+     * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of conflict, replaces the existing one
+     * @param {String} operation The operation to be performed ('PAN', 'ROTATE', 'ZOOM', 'FOV)
+     * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
+     * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
+     * @returns {Boolean} True if the mouse action has been successfully added, false otherwise
+     */
+    private setMouseAction;
+    /**
+     * Return the operation associated to a mouse/keyboard combination
+     * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
+     * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
+     * @returns The operation if it has been found, null otherwise
+     */
+    private getOpFromAction;
+    /**
+     * Get the operation associated to mouse and key combination and returns the corresponding FSA state
+     * @param {Number} mouse Mouse button
+     * @param {String} key Keyboard modifier
+     * @returns The FSA state obtained from the operation associated to mouse/keyboard combination
+     */
+    private getOpStateFromAction;
+    /**
+     * Calculate the angle between two pointers
+     * @param {PointerEvent} p1
+     * @param {PointerEvent} p2
+     * @returns {Number} The angle between two pointers in degrees
+     */
+    private getAngle;
+    /**
+     * Update a PointerEvent inside current pointerevents array
+     * @param {PointerEvent} event
+     */
+    private updateTouchEvent;
+    /**
+     * Apply a transformation matrix, to the camera and gizmos
+     * @param {Object} transformation Object containing matrices to apply to camera and gizmos
+     */
+    private applyTransformMatrix;
+    /**
+     * Calculate the angular speed
+     * @param {Number} p0 Position at t0
+     * @param {Number} p1 Position at t1
+     * @param {Number} t0 Initial time in milliseconds
+     * @param {Number} t1 Ending time in milliseconds
+     */
+    private calculateAngularSpeed;
+    /**
+     * Calculate the distance between two pointers
+     * @param {PointerEvent} p0 The first pointer
+     * @param {PointerEvent} p1 The second pointer
+     * @returns {number} The distance between the two pointers
+     */
+    private calculatePointersDistance;
+    /**
+     * Calculate the rotation axis as the vector perpendicular between two vectors
+     * @param {Vector3} vec1 The first vector
+     * @param {Vector3} vec2 The second vector
+     * @returns {Vector3} The normalized rotation axis
+     */
+    private calculateRotationAxis;
+    /**
+     * Calculate the trackball radius so that gizmo's diamater will be 2/3 of the minimum side of the camera frustum
+     * @param {Camera} camera
+     * @returns {Number} The trackball radius
+     */
+    private calculateTbRadius;
+    /**
+     * Focus operation consist of positioning the point of interest in front of the camera and a slightly zoom in
+     * @param {Vector3} point The point of interest
+     * @param {Number} size Scale factor
+     * @param {Number} amount Amount of operation to be completed (used for focus animations, default is complete full operation)
+     */
+    private focus;
+    /**
+     * Draw a grid and add it to the scene
+     */
+    private drawGrid;
+    connect: (domElement: HTMLElement) => void;
+    /**
+     * Remove all listeners, stop animations and clean scene
+     */
+    dispose: () => void;
+    /**
+     * remove the grid from the scene
+     */
+    private disposeGrid;
+    /**
+     * Compute the easing out cubic function for ease out effect in animation
+     * @param {Number} t The absolute progress of the animation in the bound of 0 (beginning of the) and 1 (ending of animation)
+     * @returns {Number} Result of easing out cubic at time t
+     */
+    private easeOutCubic;
+    /**
+     * Make rotation gizmos more or less visible
+     * @param {Boolean} isActive If true, make gizmos more visible
+     */
+    private activateGizmos;
+    /**
+     * Calculate the cursor position in NDC
+     * @param {number} x Cursor horizontal coordinate within the canvas
+     * @param {number} y Cursor vertical coordinate within the canvas
+     * @param {HTMLElement} canvas The canvas where the renderer draws its output
+     * @returns {Vector2} Cursor normalized position inside the canvas
+     */
+    private getCursorNDC;
+    /**
+     * Calculate the cursor position inside the canvas x/y coordinates with the origin being in the center of the canvas
+     * @param {Number} x Cursor horizontal coordinate within the canvas
+     * @param {Number} y Cursor vertical coordinate within the canvas
+     * @param {HTMLElement} canvas The canvas where the renderer draws its output
+     * @returns {Vector2} Cursor position inside the canvas
+     */
+    private getCursorPosition;
+    /**
+     * Set the camera to be controlled
+     * @param {Camera} camera The virtual camera to be controlled
+     */
+    private setCamera;
+    /**
+     * Set gizmos visibility
+     * @param {Boolean} value Value of gizmos visibility
+     */
+    setGizmosVisible(value: boolean): void;
+    /**
+     * Creates the rotation gizmos matching trackball center and radius
+     * @param {Vector3} tbCenter The trackball center
+     * @param {number} tbRadius The trackball radius
+     */
+    private makeGizmos;
+    /**
+     * Perform animation for focus operation
+     * @param {Number} time Instant in which this function is called as performance.now()
+     * @param {Vector3} point Point of interest for focus operation
+     * @param {Matrix4} cameraMatrix Camera matrix
+     * @param {Matrix4} gizmoMatrix Gizmos matrix
+     */
+    private onFocusAnim;
+    /**
+     * Perform animation for rotation operation
+     * @param {Number} time Instant in which this function is called as performance.now()
+     * @param {Vector3} rotationAxis Rotation axis
+     * @param {number} w0 Initial angular velocity
+     */
+    private onRotationAnim;
+    /**
+     * Perform pan operation moving camera between two points
+     * @param {Vector3} p0 Initial point
+     * @param {Vector3} p1 Ending point
+     * @param {Boolean} adjust If movement should be adjusted considering camera distance (Perspective only)
+     */
+    private pan;
+    /**
+     * Reset trackball
+     */
+    reset: () => void;
+    /**
+     * Rotate the camera around an axis passing by trackball's center
+     * @param {Vector3} axis Rotation axis
+     * @param {number} angle Angle in radians
+     * @returns {Object} Object with 'camera' field containing transformation matrix resulting from the operation to be applied to the camera
+     */
+    private rotate;
+    copyState: () => void;
+    pasteState: () => void;
+    /**
+     * Save the current state of the control. This can later be recovered with .reset
+     */
+    saveState: () => void;
+    /**
+     * Perform uniform scale operation around a given point
+     * @param {Number} size Scale factor
+     * @param {Vector3} point Point around which scale
+     * @param {Boolean} scaleGizmos If gizmos should be scaled (Perspective only)
+     * @returns {Object} Object with 'camera' and 'gizmo' fields containing transformation matrices resulting from the operation to be applied to the camera and gizmos
+     */
+    private applyScale;
+    /**
+     * Set camera fov
+     * @param {Number} value fov to be setted
+     */
+    private setFov;
+    /**
+     * Set the trackball's center point
+     * @param {Number} x X coordinate
+     * @param {Number} y Y coordinate
+     * @param {Number} z Z coordinate
+     */
+    setTarget: (x: number, y: number, z: number) => void;
+    /**
+     * Set values in transformation object
+     * @param {Matrix4} camera Transformation to be applied to the camera
+     * @param {Matrix4} gizmos Transformation to be applied to gizmos
+     */
+    private setTransformationMatrices;
+    /**
+     * Rotate camera around its direction axis passing by a given point by a given angle
+     * @param {Vector3} point The point where the rotation axis is passing trough
+     * @param {Number} angle Angle in radians
+     * @returns The computed transormation matix
+     */
+    private zRotate;
+    /**
+     * Unproject the cursor on the 3D object surface
+     * @param {Vector2} cursor Cursor coordinates in NDC
+     * @param {Camera} camera Virtual camera
+     * @returns {Vector3} The point of intersection with the model, if exist, null otherwise
+     */
+    private unprojectOnObj;
+    /**
+     * Unproject the cursor on the trackball surface
+     * @param {Camera} camera The virtual camera
+     * @param {Number} cursorX Cursor horizontal coordinate on screen
+     * @param {Number} cursorY Cursor vertical coordinate on screen
+     * @param {HTMLElement} canvas The canvas where the renderer draws its output
+     * @param {number} tbRadius The trackball radius
+     * @returns {Vector3} The unprojected point on the trackball surface
+     */
+    private unprojectOnTbSurface;
+    /**
+     * Unproject the cursor on the plane passing through the center of the trackball orthogonal to the camera
+     * @param {Camera} camera The virtual camera
+     * @param {Number} cursorX Cursor horizontal coordinate on screen
+     * @param {Number} cursorY Cursor vertical coordinate on screen
+     * @param {HTMLElement} canvas The canvas where the renderer draws its output
+     * @param {Boolean} initialDistance If initial distance between camera and gizmos should be used for calculations instead of current (Perspective only)
+     * @returns {Vector3} The unprojected point on the trackball plane
+     */
+    private unprojectOnTbPlane;
+    /**
+     * Update camera and gizmos state
+     */
+    private updateMatrixState;
+    /**
+     * Update the trackball FSA
+     * @param {STATE} newState New state of the FSA
+     * @param {Boolean} updateMatrices If matriices state should be updated
+     */
+    private updateTbState;
+    update: () => void;
+    private setStateFromJSON;
+}
+export { ArcballControls };