CameraController

The default camera controller extension that comes with the viewer package. Includes toggleable perspective and orthographic camera projections.

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:

• eventType: CameraEvent
• listener: The handler for the events with CameraEventPayload arguments

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

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,
  minimumFieldOfView: 40,
  maximumFieldOfView: 60,
  touchAction: 'none',
  infiniteZoom: true,
  zoomToCursor: true,
  orbitAroundCursor: true,
  showOrbitPoint: true,
  lookSpeed: 1,
  moveSpeed: 1,
  damperDecay: 30,
  enableLook: true,
  relativeUpDown: false,
  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.