8276409027

Committed 14 Mar 2024 06:24AM UTC coverage: 84.064% (-0.01%) from 84.074%

Build # 8276409027

Build Type

Pull #8166

github

Committed by

web-flow

Commit Message

Merge d52caced0 into b1e0ba79d

Pull Request Pull Request #8166: Implement panning in FirstPersonController

Run Details

5317 of 6001 branches covered (88.6%)

Branch coverage included in aggregate %.

45 of 72 new or added lines in 1 file covered. (62.5%)

3 existing lines in 1 file now uncovered.

47856 of 57252 relevant lines covered (83.59%)

2371.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.49

/modules/core/src/controllers/first-person-controller.ts

import Controller from './controller';
import ViewState from './view-state';
import {mod} from '../utils/math-utils';
import type Viewport from '../viewports/viewport';
import LinearInterpolator from '../transitions/linear-interpolator';

import {Vector3, _SphericalCoordinates as SphericalCoordinates, clamp} from '@math.gl/core';

const MOVEMENT_SPEED = 20;
const PAN_SPEED = 500;

type FirstPersonStateProps = {
  width: number;
  height: number;

  position?: number[];
  bearing?: number;
  pitch?: number;

  // Geospatial anchor
  longitude?: number | null;
  latitude?: number | null;

  maxPitch?: number;
  minPitch?: number;
};

type FirstPersonStateInternal = {
  startRotatePos?: [number, number];
  startBearing?: number;
  startPitch?: number;
  startZoomPosition?: number[];
  startPanPos?: [number, number];
  startPanPosition?: number[];
};

class FirstPersonState extends ViewState<
  FirstPersonState,
  FirstPersonStateProps,
  FirstPersonStateInternal
> {
  makeViewport: (props: Record<string, any>) => Viewport;

  constructor(
    options: FirstPersonStateProps &
      FirstPersonStateInternal & {
        makeViewport: (props: Record<string, any>) => Viewport;
      }
  ) {
    const {
      /* Viewport arguments */
      width, // Width of viewport
      height, // Height of viewport

      // Position and orientation
      position = [0, 0, 0], // typically in meters from anchor point

      bearing = 0, // Rotation around y axis
      pitch = 0, // Rotation around x axis

      // Geospatial anchor
      longitude = null,
      latitude = null,

      maxPitch = 90,
      minPitch = -90,

      // Model state when the rotate operation first started
      startRotatePos,
      startBearing,
      startPitch,
      startZoomPosition,
      startPanPos,
      startPanPosition
    } = options;

    super(
      {
        width,
        height,
        position,
        bearing,
        pitch,
        longitude,
        latitude,
        maxPitch,
        minPitch
      },
      {
        startRotatePos,
        startBearing,
        startPitch,
        startZoomPosition,
        startPanPos,
        startPanPosition
      }
    );

    this.makeViewport = options.makeViewport;
  }

  /* Public API */

  /**
   * Start panning
   * @param {[Number, Number]} pos - position on screen where the pointer grabs
   */
  panStart({pos}): FirstPersonState {
    const {position} = this.getViewportProps();
    return this._getUpdatedState({
      startPanPos: pos,
      startPanPosition: position
    });
  }

  /**
   * Pan
   * @param {[Number, Number]} pos - position on screen where the pointer is
   */
  pan({pos}): FirstPersonState {
    if (!pos) {
      return this;
    }
    const {startPanPos = [0, 0], startPanPosition = [0, 0]} = this.getState();
    const {width, height, bearing, pitch} = this.getViewportProps();
    const deltaScaleX = (PAN_SPEED * (pos[0] - startPanPos[0])) / width;
    const deltaScaleY = (PAN_SPEED * (pos[1] - startPanPos[1])) / height;

    const up = new SphericalCoordinates({bearing, pitch});
    const forward = new SphericalCoordinates({bearing, pitch: -90});
    const yDirection = up.toVector3().normalize();
    const xDirection = forward.toVector3().cross(yDirection).normalize();

    return this._getUpdatedState({
      position: new Vector3(startPanPosition)
        .add(xDirection.scale(deltaScaleX))
        .add(yDirection.scale(deltaScaleY))
    });
  }

  /**
   * End panning
   * Must call if `panStart()` was called
   */
  panEnd(): FirstPersonState {
    return this._getUpdatedState({
      startPanPos: null,
      startPanPosition: null
    });
  }

  /**
   * Start rotating
   * @param {[Number, Number]} pos - position on screen where the pointer grabs
   */
  rotateStart({pos}: {pos: [number, number]}): FirstPersonState {
    return this._getUpdatedState({
      startRotatePos: pos,
      startBearing: this.getViewportProps().bearing,
      startPitch: this.getViewportProps().pitch
    });
  }

  /**
   * Rotate
   * @param {[Number, Number]} pos - position on screen where the pointer is
   */
  rotate({
    pos,
    deltaAngleX = 0,
    deltaAngleY = 0
  }: {
    pos?: [number, number];
    deltaAngleX?: number;
    deltaAngleY: number;
  }): FirstPersonState {
    const {startRotatePos, startBearing, startPitch} = this.getState();
    const {width, height} = this.getViewportProps();

    if (!startRotatePos || startBearing === undefined || startPitch === undefined) {
      return this;
    }

    let newRotation;
    if (pos) {
      const deltaScaleX = (pos[0] - startRotatePos[0]) / width;
      const deltaScaleY = (pos[1] - startRotatePos[1]) / height;
      newRotation = {
        bearing: startBearing - deltaScaleX * 180,
        pitch: startPitch - deltaScaleY * 90
      };
    } else {
      newRotation = {
        bearing: startBearing - deltaAngleX,
        pitch: startPitch - deltaAngleY
      };
    }

    return this._getUpdatedState(newRotation);
  }

  /**
   * End rotating
   * Must call if `rotateStart()` was called
   */
  rotateEnd(): FirstPersonState {
    return this._getUpdatedState({
      startRotatePos: null,
      startBearing: null,
      startPitch: null
    });
  }

  /**
   * Start zooming
   * @param {[Number, Number]} pos - position on screen where the pointer grabs
   */
  zoomStart(): FirstPersonState {
    return this._getUpdatedState({
      startZoomPosition: this.getViewportProps().position
    });
  }

  /**
   * Zoom
   * @param {[Number, Number]} pos - position on screen where the current center is
   * @param {[Number, Number]} startPos - the center position at
   *   the start of the operation. Must be supplied of `zoomStart()` was not called
   * @param {Number} scale - a number between [0, 1] specifying the accumulated
   *   relative scale.
   */
  zoom({pos, scale}: {pos: [number, number]; scale: number}): FirstPersonState {
    const viewportProps = this.getViewportProps();
    const startZoomPosition = this.getState().startZoomPosition || viewportProps.position;
    const viewport = this.makeViewport(viewportProps);
    const {projectionMatrix, width} = viewport;
    const fovxRadians = 2.0 * Math.atan(1.0 / projectionMatrix[0]);
    const angle = fovxRadians * (pos[0] / width - 0.5);

    const direction = this.getDirection(true);
    return this._move(
      direction.rotateZ({radians: -angle}),
      Math.log2(scale) * MOVEMENT_SPEED,
      startZoomPosition
    );
  }

  /**
   * End zooming
   * Must call if `zoomStart()` was called
   */
  zoomEnd(): FirstPersonState {
    return this._getUpdatedState({
      startZoomPosition: null
    });
  }

  moveLeft(speed: number = MOVEMENT_SPEED): FirstPersonState {
    const direction = this.getDirection(true);
    return this._move(direction.rotateZ({radians: Math.PI / 2}), speed);
  }

  moveRight(speed: number = MOVEMENT_SPEED): FirstPersonState {
    const direction = this.getDirection(true);
    return this._move(direction.rotateZ({radians: -Math.PI / 2}), speed);
  }

  // forward
  moveUp(speed: number = MOVEMENT_SPEED): FirstPersonState {
    const direction = this.getDirection(true);
    return this._move(direction, speed);
  }

  // backward
  moveDown(speed: number = MOVEMENT_SPEED): FirstPersonState {
    const direction = this.getDirection(true);
    return this._move(direction.negate(), speed);
  }

  rotateLeft(speed: number = 15): FirstPersonState {
    return this._getUpdatedState({
      bearing: this.getViewportProps().bearing - speed
    });
  }

  rotateRight(speed: number = 15): FirstPersonState {
    return this._getUpdatedState({
      bearing: this.getViewportProps().bearing + speed
    });
  }

  rotateUp(speed: number = 10): FirstPersonState {
    return this._getUpdatedState({
      pitch: this.getViewportProps().pitch + speed
    });
  }

  rotateDown(speed: number = 10): FirstPersonState {
    return this._getUpdatedState({
      pitch: this.getViewportProps().pitch - speed
    });
  }

  zoomIn(speed: number = MOVEMENT_SPEED): FirstPersonState {
    return this._move(new Vector3(0, 0, 1), speed);
  }

  zoomOut(speed: number = MOVEMENT_SPEED): FirstPersonState {
    return this._move(new Vector3(0, 0, -1), speed);
  }

  // shortest path between two view states
  shortestPathFrom(viewState: FirstPersonState) {
    const fromProps = viewState.getViewportProps();
    const props = {...this.getViewportProps()};
    const {bearing, longitude} = props;

    if (Math.abs(bearing - fromProps.bearing) > 180) {
      props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;
    }
    if (
      longitude !== null &&
      fromProps.longitude !== null &&
      Math.abs(longitude - fromProps.longitude) > 180
    ) {
      props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;
    }
    return props;
  }

  /* Private methods */
  _move(
    direction: Vector3,
    speed: number,
    fromPosition: number[] = this.getViewportProps().position
  ) {
    const delta = direction.scale(speed);
    return this._getUpdatedState({
      position: new Vector3(fromPosition).add(delta)
    });
  }

  getDirection(use2D: boolean = false): Vector3 {
    const spherical = new SphericalCoordinates({
      bearing: this.getViewportProps().bearing,
      pitch: use2D ? 90 : 90 + this.getViewportProps().pitch
    });
    const direction = spherical.toVector3().normalize();
    return direction;
  }

  _getUpdatedState(newProps: Record<string, any>): FirstPersonState {
    // Update _viewportProps
    return new FirstPersonState({
      makeViewport: this.makeViewport,
      ...this.getViewportProps(),
      ...this.getState(),
      ...newProps
    });
  }

  // Apply any constraints (mathematical or defined by _viewportProps) to map state
  applyConstraints(props: Required<FirstPersonStateProps>): Required<FirstPersonStateProps> {
    // Ensure pitch and zoom are within specified range
    const {pitch, maxPitch, minPitch, longitude, bearing} = props;
    props.pitch = clamp(pitch, minPitch, maxPitch);

    // Normalize degrees
    if (longitude !== null && (longitude < -180 || longitude > 180)) {
      props.longitude = mod(longitude + 180, 360) - 180;
    }
    if (bearing < -180 || bearing > 180) {
      props.bearing = mod(bearing + 180, 360) - 180;
    }

    return props;
  }
}

export default class FirstPersonController extends Controller<FirstPersonState> {
  ControllerState = FirstPersonState;

  transition = {
    transitionDuration: 300,
    transitionInterpolator: new LinearInterpolator(['position', 'pitch', 'bearing'])
  };
}

1	import Controller from './controller';	1✔
2	import ViewState from './view-state';	1✔
3	import {mod} from '../utils/math-utils';	1✔
4	import type Viewport from '../viewports/viewport';	1✔
5	import LinearInterpolator from '../transitions/linear-interpolator';	1✔
6		1✔
7	import {Vector3, _SphericalCoordinates as SphericalCoordinates, clamp} from '@math.gl/core';	1✔
8		1✔
9	const MOVEMENT_SPEED = 20;	1✔
10	const PAN_SPEED = 500;	1✔
11		1✔
12	type FirstPersonStateProps = {	1✔
13	width: number;	1✔
14	height: number;	1✔
15		1✔
16	position?: number[];	1✔
17	bearing?: number;	1✔
18	pitch?: number;	1✔
19		1✔
20	// Geospatial anchor	1✔
21	longitude?: number \| null;	1✔
22	latitude?: number \| null;	1✔
23		1✔
24	maxPitch?: number;	1✔
25	minPitch?: number;	1✔
26	};	1✔
27		1✔
28	type FirstPersonStateInternal = {	1✔
29	startRotatePos?: [number, number];	1✔
30	startBearing?: number;	1✔
31	startPitch?: number;	1✔
32	startZoomPosition?: number[];	1✔
33	startPanPos?: [number, number];	1✔
34	startPanPosition?: number[];	1✔
35	};	1✔
36		1✔
37	class FirstPersonState extends ViewState<	1✔
38	FirstPersonState,	1✔
39	FirstPersonStateProps,	1✔
40	FirstPersonStateInternal	1✔
41	> {	1✔
42	makeViewport: (props: Record<string, any>) => Viewport;	1✔
43		1✔
44	constructor(	1✔
45	options: FirstPersonStateProps &	149✔
46	FirstPersonStateInternal & {	149✔
47	makeViewport: (props: Record<string, any>) => Viewport;	149✔
48	}	149✔
49	) {	149✔
50	const {	149✔
51	/* Viewport arguments */	149✔
52	width, // Width of viewport	149✔
53	height, // Height of viewport	149✔
54		149✔
55	// Position and orientation	149✔
56	position = [0, 0, 0], // typically in meters from anchor point	149✔
57		149✔
58	bearing = 0, // Rotation around y axis	149✔
59	pitch = 0, // Rotation around x axis	149✔
60		149✔
61	// Geospatial anchor	149✔
62	longitude = null,	149✔
63	latitude = null,	149✔
64		149✔
65	maxPitch = 90,	149✔
66	minPitch = -90,	149✔
67		149✔
68	// Model state when the rotate operation first started	149✔
69	startRotatePos,	149✔
70	startBearing,	149✔
71	startPitch,	149✔
72	startZoomPosition,	149✔
73	startPanPos,	149✔
74	startPanPosition	149✔
75	} = options;	149✔
76		149✔
77	super(	149✔
78	{	149✔
79	width,	149✔
80	height,	149✔
81	position,	149✔
82	bearing,	149✔
83	pitch,	149✔
84	longitude,	149✔
85	latitude,	149✔
86	maxPitch,	149✔
87	minPitch	149✔
88	},	149✔
89	{	149✔
90	startRotatePos,	149✔
91	startBearing,	149✔
92	startPitch,	149✔
93	startZoomPosition,	149✔
94	startPanPos,	149✔
95	startPanPosition	149✔
96	}	149✔
97	);	149✔
98		149✔
99	this.makeViewport = options.makeViewport;	149✔
100	}	149✔
101		1✔
102	/* Public API */	1✔
103		1✔
104	/**	1✔
105	* Start panning	1✔
106	* @param {[Number, Number]} pos - position on screen where the pointer grabs	1✔
107	*/	1✔
108	panStart({pos}): FirstPersonState {	1✔
NEW 109	const {position} = this.getViewportProps();	×
NEW 110	return this._getUpdatedState({	×
NEW 111	startPanPos: pos,	×
NEW 112	startPanPosition: position	×
NEW 113	});	×
UNCOV 114	}	×
115		1✔
116	/**	1✔
117	* Pan	1✔
118	* @param {[Number, Number]} pos - position on screen where the pointer is	1✔
119	*/	1✔
120	pan({pos}): FirstPersonState {	1✔
NEW 121	if (!pos) {	×
NEW 122	return this;	×
NEW 123	}	×
NEW 124	const {startPanPos = [0, 0], startPanPosition = [0, 0]} = this.getState();	×
NEW 125	const {width, height, bearing, pitch} = this.getViewportProps();	×
NEW 126	const deltaScaleX = (PAN_SPEED * (pos[0] - startPanPos[0])) / width;	×
NEW 127	const deltaScaleY = (PAN_SPEED * (pos[1] - startPanPos[1])) / height;	×
NEW 128		×
NEW 129	const up = new SphericalCoordinates({bearing, pitch});	×
NEW 130	const forward = new SphericalCoordinates({bearing, pitch: -90});	×
NEW 131	const yDirection = up.toVector3().normalize();	×
NEW 132	const xDirection = forward.toVector3().cross(yDirection).normalize();	×
NEW 133		×
NEW 134	return this._getUpdatedState({	×
NEW 135	position: new Vector3(startPanPosition)	×
NEW 136	.add(xDirection.scale(deltaScaleX))	×
NEW 137	.add(yDirection.scale(deltaScaleY))	×
NEW 138	});	×
UNCOV 139	}	×
140		1✔
141	/**	1✔
142	* End panning	1✔
143	* Must call if `panStart()` was called	1✔
144	*/	1✔
145	panEnd(): FirstPersonState {	1✔
NEW 146	return this._getUpdatedState({	×
NEW 147	startPanPos: null,	×
NEW 148	startPanPosition: null	×
NEW 149	});	×
UNCOV 150	}	×
151		1✔
152	/**	1✔
153	* Start rotating	1✔
154	* @param {[Number, Number]} pos - position on screen where the pointer grabs	1✔
155	*/	1✔
156	rotateStart({pos}: {pos: [number, number]}): FirstPersonState {	1✔
157	return this._getUpdatedState({	6✔
158	startRotatePos: pos,	6✔
159	startBearing: this.getViewportProps().bearing,	6✔
160	startPitch: this.getViewportProps().pitch	6✔
161	});	6✔
162	}	6✔
163		1✔
164	/**	1✔
165	* Rotate	1✔
166	* @param {[Number, Number]} pos - position on screen where the pointer is	1✔
167	*/	1✔
168	rotate({	1✔
169	pos,	3✔
170	deltaAngleX = 0,	3✔
171	deltaAngleY = 0	3✔
172	}: {	3✔
173	pos?: [number, number];	3✔
174	deltaAngleX?: number;	3✔
175	deltaAngleY: number;	3✔
176	}): FirstPersonState {	3✔
177	const {startRotatePos, startBearing, startPitch} = this.getState();	3✔
178	const {width, height} = this.getViewportProps();	3✔
179		3✔
180	if (!startRotatePos \|\| startBearing === undefined \|\| startPitch === undefined) {	3!
181	return this;	×
182	}	×
183		3✔
184	let newRotation;	3✔
185	if (pos) {	3✔
186	const deltaScaleX = (pos[0] - startRotatePos[0]) / width;	2✔
187	const deltaScaleY = (pos[1] - startRotatePos[1]) / height;	2✔
188	newRotation = {	2✔
189	bearing: startBearing - deltaScaleX * 180,	2✔
190	pitch: startPitch - deltaScaleY * 90	2✔
191	};	2✔
192	} else {	3✔
193	newRotation = {	1✔
194	bearing: startBearing - deltaAngleX,	1✔
195	pitch: startPitch - deltaAngleY	1✔
196	};	1✔
197	}	1✔
198		3✔
199	return this._getUpdatedState(newRotation);	3✔
200	}	3✔
201		1✔
202	/**	1✔
203	* End rotating	1✔
204	* Must call if `rotateStart()` was called	1✔
205	*/	1✔
206	rotateEnd(): FirstPersonState {	1✔
207	return this._getUpdatedState({	6✔
208	startRotatePos: null,	6✔
209	startBearing: null,	6✔
210	startPitch: null	6✔
211	});	6✔
212	}	6✔
213		1✔
214	/**	1✔
215	* Start zooming	1✔
216	* @param {[Number, Number]} pos - position on screen where the pointer grabs	1✔
217	*/	1✔
218	zoomStart(): FirstPersonState {	1✔
219	return this._getUpdatedState({	2✔
220	startZoomPosition: this.getViewportProps().position	2✔
221	});	2✔
222	}	2✔
223		1✔
224	/**	1✔
225	* Zoom	1✔
226	* @param {[Number, Number]} pos - position on screen where the current center is	1✔
227	* @param {[Number, Number]} startPos - the center position at	1✔
228	* the start of the operation. Must be supplied of `zoomStart()` was not called	1✔
229	* @param {Number} scale - a number between [0, 1] specifying the accumulated	1✔
230	* relative scale.	1✔
231	*/	1✔
232	zoom({pos, scale}: {pos: [number, number]; scale: number}): FirstPersonState {	1✔
233	const viewportProps = this.getViewportProps();	3✔
234	const startZoomPosition = this.getState().startZoomPosition \|\| viewportProps.position;	3✔
235	const viewport = this.makeViewport(viewportProps);	3✔
236	const {projectionMatrix, width} = viewport;	3✔
237	const fovxRadians = 2.0 * Math.atan(1.0 / projectionMatrix[0]);	3✔
238	const angle = fovxRadians * (pos[0] / width - 0.5);	3✔
239		3✔
240	const direction = this.getDirection(true);	3✔
241	return this._move(	3✔
242	direction.rotateZ({radians: -angle}),	3✔
243	Math.log2(scale) * MOVEMENT_SPEED,	3✔
244	startZoomPosition	3✔
245	);	3✔
246	}	3✔
247		1✔
248	/**	1✔
249	* End zooming	1✔
250	* Must call if `zoomStart()` was called	1✔
251	*/	1✔
252	zoomEnd(): FirstPersonState {	1✔
253	return this._getUpdatedState({	2✔
254	startZoomPosition: null	2✔
255	});	2✔
256	}	2✔
257		1✔
258	moveLeft(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
259	const direction = this.getDirection(true);	1✔
260	return this._move(direction.rotateZ({radians: Math.PI / 2}), speed);	1✔
261	}	1✔
262		1✔
263	moveRight(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
264	const direction = this.getDirection(true);	1✔
265	return this._move(direction.rotateZ({radians: -Math.PI / 2}), speed);	1✔
266	}	1✔
267		1✔
268	// forward	1✔
269	moveUp(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
270	const direction = this.getDirection(true);	1✔
271	return this._move(direction, speed);	1✔
272	}	1✔
273		1✔
274	// backward	1✔
275	moveDown(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
276	const direction = this.getDirection(true);	1✔
277	return this._move(direction.negate(), speed);	1✔
278	}	1✔
279		1✔
280	rotateLeft(speed: number = 15): FirstPersonState {	1✔
281	return this._getUpdatedState({	1✔
282	bearing: this.getViewportProps().bearing - speed	1✔
283	});	1✔
284	}	1✔
285		1✔
286	rotateRight(speed: number = 15): FirstPersonState {	1✔
287	return this._getUpdatedState({	1✔
288	bearing: this.getViewportProps().bearing + speed	1✔
289	});	1✔
290	}	1✔
291		1✔
292	rotateUp(speed: number = 10): FirstPersonState {	1✔
293	return this._getUpdatedState({	1✔
294	pitch: this.getViewportProps().pitch + speed	1✔
295	});	1✔
296	}	1✔
297		1✔
298	rotateDown(speed: number = 10): FirstPersonState {	1✔
299	return this._getUpdatedState({	1✔
300	pitch: this.getViewportProps().pitch - speed	1✔
301	});	1✔
302	}	1✔
303		1✔
304	zoomIn(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
305	return this._move(new Vector3(0, 0, 1), speed);	3✔
306	}	3✔
307		1✔
308	zoomOut(speed: number = MOVEMENT_SPEED): FirstPersonState {	1✔
309	return this._move(new Vector3(0, 0, -1), speed);	3✔
310	}	3✔
311		1✔
312	// shortest path between two view states	1✔
313	shortestPathFrom(viewState: FirstPersonState) {	1✔
314	const fromProps = viewState.getViewportProps();	15✔
315	const props = {...this.getViewportProps()};	15✔
316	const {bearing, longitude} = props;	15✔
317		15✔
318	if (Math.abs(bearing - fromProps.bearing) > 180) {	15✔
319	props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;	1!
320	}	1✔
321	if (	15✔
322	longitude !== null &&	15✔
323	fromProps.longitude !== null &&	15✔
324	Math.abs(longitude - fromProps.longitude) > 180	15✔
325	) {	15✔
326	props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;	1!
327	}	1✔
328	return props;	15✔
329	}	15✔
330		1✔
331	/* Private methods */	1✔
332	_move(	1✔
333	direction: Vector3,	13✔
334	speed: number,	13✔
335	fromPosition: number[] = this.getViewportProps().position	13✔
336	) {	13✔
337	const delta = direction.scale(speed);	13✔
338	return this._getUpdatedState({	13✔
339	position: new Vector3(fromPosition).add(delta)	13✔
340	});	13✔
341	}	13✔
342		1✔
343	getDirection(use2D: boolean = false): Vector3 {	1✔
344	const spherical = new SphericalCoordinates({	7✔
345	bearing: this.getViewportProps().bearing,	7✔
346	pitch: use2D ? 90 : 90 + this.getViewportProps().pitch	7!
347	});	7✔
348	const direction = spherical.toVector3().normalize();	7✔
349	return direction;	7✔
350	}	7✔
351		1✔
352	_getUpdatedState(newProps: Record<string, any>): FirstPersonState {	1✔
353	// Update _viewportProps	36✔
354	return new FirstPersonState({	36✔
355	makeViewport: this.makeViewport,	36✔
356	...this.getViewportProps(),	36✔
357	...this.getState(),	36✔
358	...newProps	36✔
359	});	36✔
360	}	36✔
361		1✔
362	// Apply any constraints (mathematical or defined by _viewportProps) to map state	1✔
363	applyConstraints(props: Required<FirstPersonStateProps>): Required<FirstPersonStateProps> {	1✔
364	// Ensure pitch and zoom are within specified range	149✔
365	const {pitch, maxPitch, minPitch, longitude, bearing} = props;	149✔
366	props.pitch = clamp(pitch, minPitch, maxPitch);	149✔
367		149✔
368	// Normalize degrees	149✔
369	if (longitude !== null && (longitude < -180 \|\| longitude > 180)) {	149✔
370	props.longitude = mod(longitude + 180, 360) - 180;	1✔
371	}	1✔
372	if (bearing < -180 \|\| bearing > 180) {	149✔
373	props.bearing = mod(bearing + 180, 360) - 180;	1✔
374	}	1✔
375		149✔
376	return props;	149✔
377	}	149✔
378	}	1✔
379		1✔
380	export default class FirstPersonController extends Controller<FirstPersonState> {	2✔
381	ControllerState = FirstPersonState;	2✔
382		2✔
383	transition = {	2✔
384	transitionDuration: 300,	2✔
385	transitionInterpolator: new LinearInterpolator(['position', 'pitch', 'bearing'])	2✔
386	};	2✔
387	}	1✔

visgl / deck.gl / 8276409027

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous