import type * as BABYLON from "@babylonjs/core"; import type { Base } from "./base-inputs"; /** * Parameters for cameras: position, target, field of view, near and far clipping planes, and the * settings specific to free, target and arc-rotate cameras. */ export declare namespace BabylonCamera { /** * Feeds `babylon.camera.arcRotate.create`: where the orbiting camera starts around its target, * how far it can zoom and orbit, and how fast it reacts. */ class ArcRotateCameraDto { constructor(radius?: number, alpha?: number, beta?: number, lowerRadiusLimit?: number, upperRadiusLimit?: number, lowerAlphaLimit?: number, upperAlphaLimit?: number, lowerBetaLimit?: number, upperBetaLimit?: number, angularSensibilityX?: number, angularSensibilityY?: number, panningSensibility?: number, wheelPrecision?: number, maxZ?: number); /** * Distance from the target the camera starts at, in scene units * @default 20 * @minimum 0 * @maximum Infinity * @step 1 */ radius?: number | undefined; /** * The point the camera looks at and orbits around * @default [0, 0, 0] */ target?: Base.Point3 | undefined; /** * The camera's angle around the vertical axis, in degrees * @default 45 * @minimum -Infinity * @maximum Infinity * @step 1 */ alpha?: number | undefined; /** * The camera's angle down from straight above, in degrees; 90 is level with the target * @default 70 * @minimum 0 * @maximum 180 * @step 1 */ beta?: number | undefined; /** * The closest the camera may zoom to the target, in scene units; left out, there is no * limit * @default undefined * @minimum 0 * @maximum Infinity * @step 1 * @optional true */ lowerRadiusLimit?: number | undefined; /** * The farthest the camera may zoom from the target, in scene units; left out, there is no * limit * @default undefined * @minimum 0 * @maximum Infinity * @step 1 * @optional true */ upperRadiusLimit?: number | undefined; /** * The smallest angle around the vertical axis the camera may orbit to, in degrees; left * out, it orbits freely * @default undefined * @minimum -Infinity * @maximum Infinity * @step 1 * @optional true */ lowerAlphaLimit?: number | undefined; /** * The largest angle around the vertical axis the camera may orbit to, in degrees; left out, * it orbits freely * @default undefined * @minimum -Infinity * @maximum Infinity * @step 1 * @optional true */ upperAlphaLimit?: number | undefined; /** * How close to straight above the camera may go, in degrees down from the top; 0 would look * straight down * @default 1 * @minimum 0 * @maximum 180 * @step 1 */ lowerBetaLimit?: number | undefined; /** * How close to straight below the camera may go, in degrees down from the top; 180 would * look straight up * @default 179 * @minimum 0 * @maximum 180 * @step 1 */ upperBetaLimit?: number | undefined; /** * How much pointer movement a horizontal orbit takes; lower turns faster * @default 1000 * @minimum 0 * @maximum Infinity * @step 10 */ angularSensibilityX?: number | undefined; /** * How much pointer movement a vertical orbit takes; lower turns faster * @default 1000 * @minimum 0 * @maximum Infinity * @step 10 */ angularSensibilityY?: number | undefined; /** * How much pointer movement a pan takes; lower pans faster, so lower it for large models * @default 1000 * @minimum 0 * @maximum Infinity * @step 100 */ panningSensibility?: number | undefined; /** * How much wheel movement a zoom step takes; lower zooms faster, so lower it for large * models * @default 3 * @minimum 0 * @maximum Infinity * @step 0.1 */ wheelPrecision?: number | undefined; /** * The farthest distance the camera draws, in scene units; anything beyond is not rendered * @default 1000 * @minimum 0 * @maximum Infinity * @step 10 */ maxZ?: number | undefined; } /** * Feeds `babylon.camera.free.create` with where the flying camera starts and what it looks at. */ class FreeCameraDto { constructor(position?: Base.Point3, target?: Base.Point3); /** * Where the camera starts * @default [20, 20, 20] */ position?: Base.Point3 | undefined; /** * The point the camera looks at to begin with * @default [0, 0, 0] */ target?: Base.Point3 | undefined; } /** * Feeds `babylon.camera.target.create` with where the fixed camera sits and what it looks at. */ class TargetCameraDto { constructor(position?: Base.Point3, target?: Base.Point3); /** * Where the camera sits * @default [20, 20, 20] */ position?: Base.Point3 | undefined; /** * The point the camera looks at * @default [0, 0, 0] */ target?: Base.Point3 | undefined; } /** * Feeds `babylon.camera.setPosition` and the camera getters with a camera and the point to move * it to. */ class PositionDto { constructor(camera?: BABYLON.TargetCamera, position?: Base.Point3); /** * The camera to move or read */ camera: BABYLON.TargetCamera; /** * Where to move the camera * @default [20, 20, 20] */ position?: Base.Point3 | undefined; } /** * Feeds `babylon.camera.setSpeed` with a camera and how fast its controls move it. */ class SpeedDto { constructor(camera?: BABYLON.TargetCamera, speed?: number); /** * The camera to change */ camera: BABYLON.TargetCamera; /** * How fast the controls move the camera; 1 is the default pace * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ speed?: number | undefined; } /** * Feeds `babylon.camera.setTarget` with a camera and the point to look at. */ class TargetDto { constructor(camera?: BABYLON.TargetCamera, target?: Base.Point3); /** * The camera to turn */ camera: BABYLON.TargetCamera; /** * The point the camera is turned to look at * @default [0, 0, 0] */ target?: Base.Point3 | undefined; } /** * Feeds `babylon.camera.setMinZ` with a camera and its near clipping distance. */ class MinZDto { constructor(camera?: BABYLON.Camera, minZ?: number); /** * The camera to change */ camera: BABYLON.Camera; /** * The distance below which nothing is drawn, in scene units; keep it above 0 on large * scenes for depth precision * @default 0 * @minimum 0 * @maximum Infinity * @step 0.01 */ minZ?: number | undefined; } /** * Feeds `babylon.camera.setMaxZ` with a camera and its far clipping distance. */ class MaxZDto { constructor(camera?: BABYLON.Camera, maxZ?: number); /** * The camera to change */ camera: BABYLON.Camera; /** * The distance beyond which nothing is drawn, in scene units * @default 1000 * @minimum 0 * @maximum Infinity * @step 1 */ maxZ?: number | undefined; } /** * Feeds `babylon.camera.makeCameraOrthographic` with a camera and the four edges of its flat, * distance-free view. */ class OrthographicDto { constructor(camera?: BABYLON.Camera, orthoLeft?: number, orthoRight?: number, orthoTop?: number, orthoBottom?: number); /** * The camera to switch to orthographic projection */ camera: BABYLON.Camera; /** * The left edge of the view, in scene units from the camera's axis; 0 falls back to -1 * @default -1 * @minimum -Infinity * @maximum Infinity * @step 1 */ orthoLeft?: number | undefined; /** * The right edge of the view, in scene units from the camera's axis; 0 falls back to 1 * @default 1 * @minimum -Infinity * @maximum Infinity * @step 1 */ orthoRight?: number | undefined; /** * The bottom edge of the view, in scene units from the camera's axis; 0 falls back to -1 * @default -1 * @minimum -Infinity * @maximum Infinity * @step 1 */ orthoBottom?: number | undefined; /** * The top edge of the view, in scene units from the camera's axis; 0 falls back to 1 * @default 1 * @minimum -Infinity * @maximum Infinity * @step 1 */ orthoTop?: number | undefined; } /** * Feeds `babylon.camera.makeCameraPerspective`, `freezeProjectionMatrix` and * `unfreezeProjectionMatrix` with the one camera to change. */ class CameraDto { constructor(camera?: BABYLON.Camera); /** * The camera to change */ camera: BABYLON.Camera; } }