​
Properties

​
aspect

get aspect(): number
Gets the current display aspect ratio Returns: number

​
controls

get controls(): SpeckleControls
Gets the current underlying SpeckleControls implementation. Returns: SpeckleControls

​
enabled

get enabled(): boolean
set enabled(val: boolean)
Gets or sets whether this extension is enabled.
Extensions typically need to support being turned on/off with no impact on potentially other active extensions.
Returns: boolean

​
fieldOfView

get fieldOfView(): number
set fieldOfView(value: number)
Gets or sets the perspective camera’s field of view. Returns: number

​
options

get options(): CameraControllerOptions
set options(value: CameraControllerOptions)
Gets or sets the current camera controller options. Returns: CameraControllerOptions

​
renderingCamera

get renderingCamera(): PerspectiveCamera | OrthographicCamera
set renderingCamera(value: PerspectiveCamera | OrthographicCamera)
Gets or sets the current rendering camera. Returns: number

​
Methods

​
disableRotations

disableRotations(): void
Disables all camera controls rotation capabilities. Returns: void

​
enableRotations

enableRotations(): void
Enables all camera controls rotation capabilities. Returns: void

​
on

on<T extends CameraEvent>(
  eventType: T,
  listener: (arg: CameraEventPayload[T]) => void
): void
Function for subscribing to camera events. Parameters Returns: void

​
removeListener

removeListener(e: CameraEvent, handler: (data: unknown) => void)
Function for un-subscribing from camera events. Parameters
  • e: CameraEvent
  • handler: The handler for the events to unsubscribe
Returns: void

​
setCameraPlanes

setCameraPlanes(targetVolume: Box3, offsetScale: number = 1)
Function that adapts the camera’s near and far clipping planes according to the current scene’s volume. Parameters
  • targetVolume: Box3
  • optional offsetScale: Works as a linear tolerance to the volume parameter
Returns: void

​
setCameraView

setCameraView(objectIds: string[], transition: boolean, fit?: number): void
Focuses the camera based on the volume defined by the received object ids list. Parameters
  • objectIds: The object ids that make up the volume
  • transition: Whether or not to make the transition animated
  • optional fit: Linear tolerance
setCameraView(
    view: CanonicalView | SpeckleView | InlineView | PolarView,
    transition: boolean,
    fit?: number
  ): void
Focuses the camera based on explicit view models provided. Parameters
  • view: Explicit view of different possible type: CanonicalView, SpeckleView, InlineView
  • transition: Whether or not to make the transition animated
  • optional fit: Linear tolerance
setCameraView(bounds: Box3, transition: boolean, fit?: number): void
Focuses the camera based on explicit volume provided as Box3. Parameters
  • bounds: Box3
  • transition: Whether or not to make the transition animated
  • optional fit: Linear tolerance
Returns: void

​
setOrthoCameraOn

setOrthoCameraOn(): void
Enables the orthographic camera. Returns: void

​
setPerspectiveCameraOn

setPerspectiveCameraOn(): void
Enables the perspective camera. Returns: void

​
toggleCameras

toggleCameras(): void
Switches between perspective and orthographic cameras. Returns: void

​
Typedefs

​
CameraEvent

enum CameraEvent {
  Stationary = 'stationary',
  Dynamic = 'dynamic',
  FrameUpdate = 'frame-update',
  ProjectionChanged = 'projection-changed',
}
Events the camera controller puts out.

​
CameraEventPayload

interface CameraEventPayload {
  [CameraEvent.Stationary]: void
  [CameraEvent.Dynamic]: void
  [CameraEvent.FrameUpdate]x: boolean
  [CameraEvent.ProjectionChanged]: CameraProjection
}
Mapping CameraEvent types to handler argument type

​
CameraControllerOptions

type CameraControllerOptions = SmoothOrbitControlsOptions & {
  nearPlaneCalculation?: NearPlaneCalculation;
};
The camera controller options. Defaults to 
export const DefaultOrbitControlsOptions: Required<CameraControllerOptions> = {
  enableOrbit: true,
  enableZoom: true,
  enablePan: true,
  orbitSensitivity: 1,
  zoomSensitivity: 1,
  panSensitivity: 1,
  inputSensitivity: 1,
  minimumRadius: 0,
  maximumRadius: Infinity,
  minimumPolarAngle: 0,
  maximumPolarAngle: Math.PI,
  minimumAzimuthalAngle: -Infinity,
  maximumAzimuthalAngle: Infinity,
  infiniteZoom: true,
  zoomToCursor: true,
  orbitAroundCursor: true,
  showOrbitPoint: true,
  damperDecay: 30,
  nearPlaneCalculation: NearPlaneCalculation.ACCURATE,
};

​
CameraProjection

enum CameraProjection {
  PERSPECTIVE,
  ORTHOGRAPHIC,
}
Camera projection types.

​
CanonicalView

type CanonicalView =
  | 'front'
  | 'back'
  | 'up'
  | 'top'
  | 'down'
  | 'bottom'
  | 'right'
  | 'left'
  | '3d'
  | '3D';
Supported cannonical views.

​
InlineView

type InlineView = {
  position: Vector3;
  target: Vector3;
};
Inline, on-demand camera view.
  • position: The position of the camera
  • target: The point in space where the camera looks at Returns: void

​
PolarView

type PolarView = {
  azimuth: number;
  polar: number;
  radius?: number;
  origin?: Vector3;
};
Camera view defined in polar coordinates.