@pixi/3d
    Preparing search index...

    Interface OrbitCameraOptions

    Constructor options for OrbitCamera

    Every field but view has a default. Every option is also a property on the instance, and all but view can be changed at runtime.

    const turntable: Omit<OrbitCameraOptions, 'view'> = {
      enablePan: false,
      autoRotate: true,
      maxPolarAngle: Math.PI / 2,
    };
    const orbit = new OrbitCamera({ view: view3d, ...turntable });
    interface OrbitCameraOptions {
        autoRotate?: boolean;
        autoRotateSpeed?: number;
        autoUpdate?: boolean;
        dampingFactor?: number;
        enabled?: boolean;
        enableDamping?: boolean;
        enablePan?: boolean;
        enableRotate?: boolean;
        enableZoom?: boolean;
        maxAzimuthAngle?: number;
        maxDistance?: number;
        maxPolarAngle?: number;
        maxZoom?: number;
        minAzimuthAngle?: number;
        minDistance?: number;
        minPolarAngle?: number;
        minZoom?: number;
        mouseButtons?: Partial<OrbitMouseButtons>;
        panSpeed?: number;
        preventContextMenu?: boolean;
        rotateSpeed?: number;
        screenSpacePanning?: boolean;
        target?: PointData3D;
        touches?: Partial<OrbitTouches>;
        up?: PointData3D;
        view: View3D;
        zoomSpeed?: number;
        zoomToCursor?: boolean;
    }
    Index
    autoRotate? autoRotateSpeed? autoUpdate? dampingFactor? enabled? enableDamping? enablePan? enableRotate? enableZoom? maxAzimuthAngle? maxDistance? maxPolarAngle? maxZoom? minAzimuthAngle? minDistance? minPolarAngle? minZoom? mouseButtons? panSpeed? preventContextMenu? rotateSpeed? screenSpacePanning? target? touches? up? view zoomSpeed? zoomToCursor?
    autoRotate?: boolean

    Orbit around the target on its own whenever no gesture is in progress

    false

    const orbit = new OrbitCamera({ view: view3d, autoRotate: true });
    autoRotateSpeed?: number

    Auto-rotate speed in revolutions per minute; negative values turn the other way

    2

    const orbit = new OrbitCamera({ view: view3d, autoRotate: true, autoRotateSpeed: 0.5 });
    autoUpdate?: boolean

    Run update() from Ticker.shared every frame

    Set false to drive updates yourself; OrbitCamera#autoUpdate says when that helps.

    true

    const orbit = new OrbitCamera({ view: view3d, autoUpdate: false });

    app.ticker.add((ticker) => orbit.update(ticker));
    dampingFactor?: number

    Share of the remaining motion applied each update while enableDamping is on

    0.05

    const orbit = new OrbitCamera({ view: view3d, enableDamping: true, dampingFactor: 0.1 });
    enabled?: boolean

    Whether the controller responds to input; OrbitCamera#enabled covers what keeps running

    true

    const orbit = new OrbitCamera({ view: view3d, enabled: false });

    startButton.on('pointertap', () => (orbit.enabled = true));
    enableDamping?: boolean

    Ease rotation and panning out after input stops; OrbitCamera#enableDamping has the details

    false

    const orbit = new OrbitCamera({ view: view3d, enableDamping: true });
    enablePan?: boolean

    Whether drags pan the camera

    true

    const orbit = new OrbitCamera({ view: view3d, enablePan: false });
    enableRotate?: boolean

    Whether drags rotate the camera

    true

    const orbit = new OrbitCamera({ view: view3d, enableRotate: false });
    enableZoom?: boolean

    Whether the wheel, pinches and any button set to 'zoom' zoom the camera

    true

    const orbit = new OrbitCamera({ view: view3d, enableZoom: false });
    maxAzimuthAngle?: number

    Largest azimuth the camera can reach, in radians

    Infinity

    const orbit = new OrbitCamera({ view: view3d, minAzimuthAngle: 0, maxAzimuthAngle: Math.PI / 2 });
    maxDistance?: number

    Maximum distance from target

    Infinity

    const orbit = new OrbitCamera({ view: view3d, maxDistance: 20 });
    maxPolarAngle?: number

    Largest polar angle the camera can reach, in radians

    Math.PI

    const orbit = new OrbitCamera({ view: view3d, maxPolarAngle: Math.PI / 2 });
    maxZoom?: number

    Maximum camera zoom (orthographic only)

    Infinity

    const orbit = new OrbitCamera({ view: view3d, maxZoom: 4 });
    minAzimuthAngle?: number

    Smallest azimuth the camera can reach, in radians; OrbitCamera#minAzimuthAngle covers how the pair of limits applies

    -Infinity

    const orbit = new OrbitCamera({ view: view3d, minAzimuthAngle: -Math.PI / 4, maxAzimuthAngle: Math.PI / 4 });
    minDistance?: number

    Minimum distance from target

    0

    const orbit = new OrbitCamera({ view: view3d, minDistance: 2 });
    minPolarAngle?: number

    Smallest polar angle the camera can reach, in radians

    0

    const orbit = new OrbitCamera({ view: view3d, minPolarAngle: Math.PI / 6 });
    minZoom?: number

    Minimum camera zoom (orthographic only)

    0

    const orbit = new OrbitCamera({ view: view3d, minZoom: 0.5 });
    mouseButtons?: Partial<OrbitMouseButtons>

    Mouse-button action assignments, merged over the defaults

    const orbit = new OrbitCamera({ view: view3d, mouseButtons: { left: 'pan', right: 'rotate' } });
    panSpeed?: number

    Multiplier on pan drags

    1

    const orbit = new OrbitCamera({ view: view3d, panSpeed: 2 });
    preventContextMenu?: boolean

    Keep the browser's context menu from opening over the View; OrbitCamera#preventContextMenu covers where it still opens

    true

    const orbit = new OrbitCamera({ view: view3d, preventContextMenu: false, mouseButtons: { right: 'none' } });
    rotateSpeed?: number

    Multiplier on rotate drags

    1

    const orbit = new OrbitCamera({ view: view3d, rotateSpeed: 0.5 });
    screenSpacePanning?: boolean

    true pans in the screen's plane; false pans across the plane at right angles to OrbitCamera#up, so vertical drags move over the ground like a map

    true

    const orbit = new OrbitCamera({ view: view3d, screenSpacePanning: false });
    target?: PointData3D

    World-space point to orbit around; (0, 0, 0) when omitted

    const orbit = new OrbitCamera({ view: view3d, target: { x: 0, y: 1.2, z: 0 } });
    touches?: Partial<OrbitTouches>

    Touch-gesture action assignments, merged over the defaults

    const orbit = new OrbitCamera({ view: view3d, touches: { one: 'pan', two: 'zoom-rotate' } });
    up?: PointData3D

    World-space up axis the orbit turns around; (0, 1, 0) when omitted

    const orbit = new OrbitCamera({ view: view3d, up: { x: 0, y: 0, z: 1 } });
    view: View3D

    The view whose camera the controller drives and whose pointer and wheel events it reads

    const orbit = new OrbitCamera({ view: view3d });
    zoomSpeed?: number

    Multiplier on zoom input from the wheel, pinches and zoom-button drags

    1

    const orbit = new OrbitCamera({ view: view3d, zoomSpeed: 0.5 });
    zoomToCursor?: boolean

    Zoom toward the point under the pointer instead of the target; OrbitCamera#zoomToCursor has the details

    false

    const orbit = new OrbitCamera({ view: view3d, zoomToCursor: true });

    Settings
    Member Visibility

    On This Page
    Properties