@types/three
Version:
TypeScript definitions for three
242 lines (234 loc) • 8.24 kB
TypeScript
import { JSONMeta, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
import { Vector2 } from "../math/Vector2.js";
import { Camera } from "./Camera.js";
export interface PerspectiveCameraJSONObject extends Object3DJSONObject {
fov: number;
zoom: number;
near: number;
far: number;
focus: number;
aspect: number;
view?: {
enabled: boolean;
fullWidth: number;
fullHeight: number;
offsetX: number;
offsetY: number;
width: number;
height: number;
};
filmGauge: number;
filmOffset: number;
}
export interface PerspectiveCameraJSON extends Object3DJSON {
object: PerspectiveCameraJSONObject;
}
/**
* Camera that uses [perspective projection](https://en.wikipedia.org/wiki/Perspective_(graphical)).
*
* This projection mode is designed to mimic the way the human eye sees. It
* is the most common projection mode used for rendering a 3D scene.
*
* ```js
* const camera = new THREE.PerspectiveCamera( 45, width / height, 1, 1000 );
* scene.add( camera );
* ```
*/
export class PerspectiveCamera extends Camera {
/**
* Constructs a new perspective camera.
*
* @param {number} [fov=50] - The vertical field of view.
* @param {number} [aspect=1] - The aspect ratio.
* @param {number} [near=0.1] - The camera's near plane.
* @param {number} [far=2000] - The camera's far plane.
*/
constructor(fov?: number, aspect?: number, near?: number, far?: number);
/**
* This flag can be used for type testing.
*
* @default true
*/
readonly isPerspectiveCamera: boolean;
/**
* The vertical field of view, from bottom to top of view,
* in degrees.
*
* @default 50
*/
fov: number;
/**
* The zoom factor of the camera.
*
* @default 1
*/
zoom: number;
/**
* The camera's near plane. The valid range is greater than `0`
* and less than the current value of {@link PerspectiveCamera#far}.
*
* Note that, unlike for the {@link OrthographicCamera}, `0` is <em>not</em> a
* valid value for a perspective camera's near plane.
*
* @default 0.1
*/
near: number;
/**
* The camera's far plane. Must be greater than the
* current value of {@link PerspectiveCamera#near}.
*
* @default 2000
*/
far: number;
/**
* Object distance used for stereoscopy and depth-of-field effects. This
* parameter does not influence the projection matrix unless a
* {@link StereoCamera} is being used.
*
* @default 10
*/
focus: number;
/**
* The aspect ratio, usually the canvas width / canvas height.
*
* @default 1
*/
aspect: number;
/**
* Represents the frustum window specification. This property should not be edited
* directly but via {@link PerspectiveCamera#setViewOffset} and {@link PerspectiveCamera#clearViewOffset}.
*
* @default null
*/
view: {
enabled: boolean;
fullWidth: number;
fullHeight: number;
offsetX: number;
offsetY: number;
width: number;
height: number;
} | null;
/**
* Film size used for the larger axis. Default is `35` (millimeters). This
* parameter does not influence the projection matrix unless {@link PerspectiveCamera#filmOffset}
* is set to a nonzero value.
*
* @default 35
*/
filmGauge: number;
/**
* Horizontal off-center offset in the same unit as {@link PerspectiveCamera#filmGauge}.
*
* @default 0
*/
filmOffset: number;
copy(source: PerspectiveCamera, recursive?: boolean): this;
/**
* Sets the FOV by focal length in respect to the current {@link PerspectiveCamera#filmGauge}.
*
* The default film gauge is 35, so that the focal length can be specified for
* a 35mm (full frame) camera.
*
* @param {number} focalLength - Values for focal length and film gauge must have the same unit.
*/
setFocalLength(focalLength: number): void;
/**
* Returns the focal length from the current {@link PerspectiveCamera#fov} and
* {@link PerspectiveCamera#filmGauge}.
*
* @return {number} The computed focal length.
*/
getFocalLength(): number;
/**
* Returns the current vertical field of view angle in degrees considering {@link PerspectiveCamera#zoom}.
*
* @return {number} The effective FOV.
*/
getEffectiveFOV(): number;
/**
* Returns the width of the image on the film. If {@link PerspectiveCamera#aspect} is greater than or
* equal to one (landscape format), the result equals {@link PerspectiveCamera#filmGauge}.
*
* @return {number} The film width.
*/
getFilmWidth(): number;
/**
* Returns the height of the image on the film. If {@link PerspectiveCamera#aspect} is greater than or
* equal to one (landscape format), the result equals {@link PerspectiveCamera#filmGauge}.
*
* @return {number} The film width.
*/
getFilmHeight(): number;
/**
* Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.
* Sets `minTarget` and `maxTarget` to the coordinates of the lower-left and upper-right corners of the view rectangle.
*
* @param {number} distance - The viewing distance.
* @param {Vector2} minTarget - The lower-left corner of the view rectangle is written into this vector.
* @param {Vector2} maxTarget - The upper-right corner of the view rectangle is written into this vector.
*/
getViewBounds(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
/**
* Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
*
* @param {number} distance - The viewing distance.
* @param {Vector2} target - The target vector that is used to store result where x is width and y is height.
* @returns {Vector2} The view size.
*/
getViewSize(distance: number, target: Vector2): Vector2;
/**
* Sets an offset in a larger frustum. This is useful for multi-window or
* multi-monitor/multi-machine setups.
*
* For example, if you have 3x2 monitors and each monitor is 1920x1080 and
* the monitors are in grid like this
* ```
* +---+---+---+
* | A | B | C |
* +---+---+---+
* | D | E | F |
* +---+---+---+
* ```
* then for each monitor you would call it like this:
* ```js
* const w = 1920;
* const h = 1080;
* const fullWidth = w * 3;
* const fullHeight = h * 2;
*
* // --A--
* camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
* // --B--
* camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
* // --C--
* camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
* // --D--
* camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
* // --E--
* camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
* // --F--
* camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
* ```
*
* Note there is no reason monitors have to be the same size or in a grid.
*
* @param {number} fullWidth - The full width of multiview setup.
* @param {number} fullHeight - The full height of multiview setup.
* @param {number} x - The horizontal offset of the subcamera.
* @param {number} y - The vertical offset of the subcamera.
* @param {number} width - The width of subcamera.
* @param {number} height - The height of subcamera.
*/
setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
/**
* Removes the view offset from the projection matrix.
*/
clearViewOffset(): void;
/**
* Updates the camera's projection matrix. Must be called after any change of
* camera properties.
*/
updateProjectionMatrix(): void;
toJSON(meta?: JSONMeta): PerspectiveCameraJSON;
}