iTowns/itowns | Build 8966662600 | src/Renderer/Camera.js | Coveralls

1

import * as THREE from 'three';

1✔

2

import Coordinates from 'Core/Geographic/Coordinates';

1✔

3

import DEMUtils from 'Utils/DEMUtils';

1✔

4

import { OBB } from 'ThreeExtended/math/OBB';

1✔

5

// import { OBB } from 'three/addons/math/OBB';

1✔

6

1✔

7

/**

1✔

8

 * @typedef     {object}    Camera~CAMERA_TYPE

1✔

9

 * Stores the different types of camera usable in iTowns.

1✔

10

1✔

11

 * @property    {number}    PERSPECTIVE     Perspective type of camera

1✔

12

 * @property    {number}    ORTHOGRAPHIC    Orthographic type of camera

1✔

13

*/

1✔

14

export const CAMERA_TYPE = {

1✔

15

    PERSPECTIVE: 0,

1✔

16

    ORTHOGRAPHIC: 1,

1✔

17

};

1✔

18

1✔

19

const tmp = {

1✔

20

    frustum: new THREE.Frustum(),

1✔

21

    matrix: new THREE.Matrix4(),

1✔

22

    box3: new THREE.Box3(),

1✔

23

    obb: new OBB(),

1✔

24

};

1✔

25

1✔

26

const _vector3 = new THREE.Vector3();

1✔

27

1✔

28

const ndcBox3 = new THREE.Box3(

1✔

29

    new THREE.Vector3(-1, -1, -1),

1✔

30

    new THREE.Vector3(1, 1, 1),

1✔

31

);

1✔

32

const ndcObb = new OBB().fromBox3(ndcBox3);

1✔

33

116✔

34

function updatePreSse(camera, height, fov) {

116✔

35

    // sse = projected geometric error on screen plane from distance

116✔

36

    // We're using an approximation, assuming that the geometric error of all

116✔

37

    // objects is perpendicular to the camera view vector (= we always compute

116✔

38

    // for worst case).

116✔

39

//

116✔

40

    //            screen plane             object

116✔

41

    //               |                         __

116✔

42

    //               |                        /  \

116✔

43

    //               |             geometric{|

116✔

44

    //  < fov angle  . } sse          error {|    |

116✔

45

    //               |                        \__/

116✔

46

    //               |

116✔

47

    //               |<--------------------->

116✔

48

    //               |        distance

116✔

49

//

116✔

50

    //              geometric_error * screen_width      (resp. screen_height)

116✔

51

    //     =  ---------------------------------------

116✔

52

    //        2 * distance * tan (horizontal_fov / 2)   (resp. vertical_fov)

116✔

53

//

116✔

54

//

116✔

55

    // We pre-compute the preSSE (= constant part of the screen space error formula) once here

116✔

56

116✔

57

    // Note: the preSSE for the horizontal FOV is the same value

116✔

58

    // focal = (this.height * 0.5) / Math.tan(verticalFOV * 0.5);

116✔

59

    // horizontalFOV = 2 * Math.atan(this.width * 0.5 / focal);

116✔

60

    // horizontalPreSSE = this.width / (2.0 * Math.tan(horizontalFOV * 0.5)); (1)

116✔

61

    // => replacing horizontalFOV in Math.tan(horizontalFOV * 0.5)

116✔

62

    // Math.tan(horizontalFOV * 0.5) = Math.tan(2 * Math.atan(this.width * 0.5 / focal) * 0.5)

116✔

63

    //                               = Math.tan(Math.atan(this.width * 0.5 / focal))

116✔

64

    //                               = this.width * 0.5 / focal

116✔

65

    // => now replacing focal

116✔

66

    //                               = this.width * 0.5 / (this.height * 0.5) / Math.tan(verticalFOV * 0.5)

116✔

67

    //                               = Math.tan(verticalFOV * 0.5) * this.width / this.height

116✔

68

    // => back to (1)

116✔

69

    // horizontalPreSSE = this.width / (2.0 * Math.tan(verticalFOV * 0.5) * this.width / this.height)

116✔

70

    //                  = this.height / 2.0 * Math.tan(verticalFOV * 0.5)

116✔

71

    //                  = verticalPreSSE

116✔

72

109✔

73

    if (camera.camera3D.isOrthographicCamera) {

109✔

74

        camera._preSSE = height;

109✔

75

    } else {

109✔

76

        const verticalFOV = THREE.MathUtils.degToRad(fov);

1✔

77

        camera._preSSE = height / (2.0 * Math.tan(verticalFOV * 0.5));

1✔

78

1✔

79

1✔

80

1✔

81

/**

1✔

82

 * Wrapper around Three.js camera to expose some geographic helpers.

1✔

83

1✔

84

 * @property    {string}    crs             The camera's coordinate projection system.

1✔

85

 * @property    {THREE.Camera}    camera3D        The Three.js camera that is wrapped around.

1✔

86

 * @property    {number}    width           The width of the camera.

1✔

87

 * @property    {number}    height          The height of the camera.

1✔

88

 * @property    {number}    _preSSE         The precomputed constant part of the screen space error.

1✔

89

*/

50✔

90

class Camera {

50✔

91

    #_viewMatrixNeedsUpdate = true;

50✔

92

    #_viewMatrix = new THREE.Matrix4();

50✔

93

50✔

94

/**

50✔

95

     * @param   {string}                crs                                     The camera's coordinate projection system.

50✔

96

     * @param   {number}                width                                   The width (in pixels) of the view the

50✔

97

        * camera is associated to.

50✔

98

     * @param   {number}                height                                  The height (in pixels) of the view the

50✔

99

        * camera is associated to.

50✔

100

     * @param   {Object}                [options]                               Options for the camera.

50✔

101

     * @param   {THREE.Camera}          [options.cameraThree]                   A custom Three.js camera object to wrap

50✔

102

        * around.

50✔

103

     * @param   {Camera~CAMERA_TYPE}    [options.type=CAMERA_TYPE.PERSPECTIVE]  The type of the camera. See {@link

50✔

104

        * CAMERA_TYPE}.

42✔

105

     * @constructor

50✔

106

*/

50✔

112

                'camera as a parameter. See the documentation of Camera.');

50✔

113

            this.camera3D = options;

50✔

114

        } else if (options.cameraThree) {

49✔

115

            this.camera3D = options.cameraThree;

4✔

116

        } else {

4✔

117

            switch (options.type) {

4✔

119

                    this.camera3D = new THREE.OrthographicCamera();

45✔

120

                    break;

49✔

121

                case CAMERA_TYPE.PERSPECTIVE:

50✔

122

                default:

50✔

123

                    this.camera3D = new THREE.PerspectiveCamera(30);

50✔

124

                    break;

50✔

125

50✔

126

50✔

127

        this.camera3D.aspect = this.camera3D.aspect ?? 1;

50✔

128

46✔

129

        this.width = width;

46✔

130

        this.height = height;

46✔

131

        this.resize(width, height);

46✔

132

3✔

133

        this._preSSE = Infinity;

3✔

134

3✔

135

        if (this.camera3D.isPerspectiveCamera) {

3✔

136

            let fov = this.camera3D.fov;

50✔

137

            Object.defineProperty(this.camera3D, 'fov', {

50✔

138

                get: () => fov,

50✔

139

                set: (newFov) => {

50✔

140

                    fov = newFov;

50✔

141

                    updatePreSse(this, this.height, fov);

50✔

142

},

50✔

143

});

50✔

144

50✔

145

50✔

146

50✔

147

/**

50✔

148

     * Resize the camera to a given width and height.

50✔

149

113✔

151

     * @param {number} height The height to resize the camera to. Must be strictly positive, won't resize otherwise.

113✔

152

*/

113✔

153

    resize(width, height) {

113✔

154

        if (!width || width <= 0 || !height || height <= 0) {

51✔

155

            console.warn(`Trying to resize the Camera with invalid height (${height}) or width (${width}). Skipping resize.`);

5✔

156

            return;

5✔

157

5✔

158

        const ratio = width / height;

51✔

159

        if (this.camera3D.aspect !== ratio) {

46✔

160

            if (this.camera3D.isOrthographicCamera) {

45✔

161

                this.camera3D.zoom *= this.width / width;

45✔

162

                const halfH = this.camera3D.top * this.camera3D.aspect / ratio;

113✔

163

                this.camera3D.bottom = -halfH;

113✔

164

                this.camera3D.top = halfH;

113✔

165

            } else if (this.camera3D.isPerspectiveCamera) {

113✔

166

                this.camera3D.fov = 2 * THREE.MathUtils.radToDeg(Math.atan(

112✔

167

                    (height / this.height) * Math.tan(THREE.MathUtils.degToRad(this.camera3D.fov) / 2),

50✔

168

));

2✔

169

50✔

170

            this.camera3D.aspect = ratio;

50✔

171

50✔

172

50✔

173

        this.width = width;

50✔

174

        this.height = height;

50✔

175

        updatePreSse(this, this.height, this.camera3D.fov);

50✔

176

50✔

177

        if (this.camera3D.updateProjectionMatrix) {

50✔

178

            this.camera3D.updateProjectionMatrix();

50✔

179

            this.#_viewMatrixNeedsUpdate = true;

50✔

180

18✔

181

18✔

182

18✔

183

    update() {

18✔

184

        // update matrix

18✔

185

        this.camera3D.updateMatrixWorld();

50✔

186

        this.#_viewMatrixNeedsUpdate = true;

50✔

187

50✔

188

50✔

189

/**

50✔

190

     * Return the position in the requested CRS, or in camera's CRS if undefined.

50✔

191

50✔

192

     * @param   {string}        [crs]   If defined (e.g 'EPSG:4326'), the camera position will be returned in this CRS.

50✔

193

1✔

194

     * @return  {Coordinates}   Coordinates object holding camera's position.

50✔

195

*/

2✔

196

    position(crs) {

2✔

197

        return new Coordinates(this.crs, this.camera3D.position).as(crs || this.crs);

50✔

198

3✔

199

3✔

200

/**

3✔

201

     * Set the position of the camera using a Coordinates object.

3✔

202

     * If you want to modify the position directly using x,y,z values then use `camera.camera3D.position.set(x, y, z)`

50✔

218

    isSphereVisible(sphere, matrixWorld) {

50✔

219

        if (this.#_viewMatrixNeedsUpdate) {

2✔

220

            // update visibility testing matrix

2✔

222

            this.#_viewMatrixNeedsUpdate = false;

2✔

223

2✔

224

        if (matrixWorld) {

2✔

225

            tmp.matrix.multiplyMatrices(this.#_viewMatrix, matrixWorld);

2✔

226

            tmp.frustum.setFromProjectionMatrix(tmp.matrix);

50✔

227

        } else {

3✔

228

            tmp.frustum.setFromProjectionMatrix(this.#_viewMatrix);

3✔

229

3✔

230

        return tmp.frustum.intersectsSphere(sphere);

3✔

231

3✔

232

1✔

233

    box3SizeOnScreen(box3, matrixWorld) {

1✔

234

        const pts = projectBox3PointsInCameraSpace(this, box3, matrixWorld);

3✔

235

2✔

236

        // All points are in front of the near plane -> box3 is invisible

3✔

237

        if (!pts) {

2✔

238

            return tmp.box3.makeEmpty();

50✔

239

50✔

240

50✔

241

        // Project points on screen

50✔

242

        for (let i = 0; i < 8; i++) {

50✔

243

            pts[i].applyMatrix4(this.camera3D.projectionMatrix);

50✔

244

50✔

245

50✔

246

        return tmp.box3.setFromPoints(pts);

50✔

247

50✔

248

50✔

249

    obbSizeOnScreen(obb, matrixWorld) {

50✔

250

        const pts = projectObbPointsInCameraSpace(this, obb, matrixWorld);

50✔

251

50✔

252

        // All points are in front of the near plane -> box3 is invisible

50✔

253

        if (!pts) {

50✔

254

            tmp.obb.halfSize = _vector3;

50✔

255

            return tmp.obb;

50✔

256

50✔

257

50✔

258

        // Project points on screen

50✔

259

        for (let i = 0; i < 8; i++) {

50✔

260

            pts[i].applyMatrix4(this.camera3D.projectionMatrix);

50✔

261

50✔

262

50✔

263

        return tmp.obb.fromBox3(tmp.box3.setFromPoints(pts));

50✔

264

50✔

265

50✔

266

/**

50✔

267

     * Test for collision between camera and a geometry layer (DTM/DSM) to adjust camera position.

15✔

268

     * It could be modified later to handle an array of geometry layers.

15✔

269

     * TODO Improve Coordinates class to handle altitude for any coordinate system (even projected one)

15✔

270

15✔

271

     * @param   {View}              view                    The view where we test the collision between geometry layers

15✔

272

     * and the camera

15✔

279

        // We put the camera location in geographic by default to easily handle altitude.

1✔

280

        // (Should be improved in Coordinates class for all ref)

1✔

281

        const camLocation = view.camera.position().as('EPSG:4326');

1✔

282

        if (elevationLayer !== undefined) {

1✔

283

            const elevationUnderCamera = DEMUtils.getElevationValueAt(elevationLayer, camLocation);

2✔

284

            if (elevationUnderCamera !== undefined) {

2✔

285

                const difElevation = camLocation.altitude - (elevationUnderCamera + minDistanceCollision);

2✔

286

                // We move the camera to avoid collision if too close to terrain

2✔

287

                if (difElevation < 0) {

2✔

288

                    camLocation.altitude = elevationUnderCamera + minDistanceCollision;

2✔

289

                    view.camera3D.position.copy(camLocation.as(view.referenceCrs));

2✔

290

                    view.notifyChange(this.camera3D);

2✔

291

2✔

292

2✔

293

2✔

294

2✔

295

2✔

296

2✔

297

2✔

298

const points = [

2✔

299

    new THREE.Vector3(),

2✔

300

    new THREE.Vector3(),

2✔

301

    new THREE.Vector3(),

2✔

302

    new THREE.Vector3(),

2✔

303

    new THREE.Vector3(),

2✔

304

    new THREE.Vector3(),

2✔

305

    new THREE.Vector3(),

2✔

306

    new THREE.Vector3(),

2✔

307

];

2✔

308

2✔

309

function projectBox3PointsInCameraSpace(camera, box3, matrixWorld) {

2✔

310

    // Projects points in camera space

2✔

311

    // We don't project directly on screen to avoid artifacts when projecting

2✔

312

    // points behind the near plane.

2✔

313

    let m = camera.camera3D.matrixWorldInverse;

16✔

314

    if (matrixWorld) {

14✔

315

        m = tmp.matrix.multiplyMatrices(camera.camera3D.matrixWorldInverse, matrixWorld);

16✔

316

2✔

318

    points[1].set(box3.min.x, box3.min.y, box3.max.z).applyMatrix4(m);

1✔

319

    points[2].set(box3.min.x, box3.max.y, box3.min.z).applyMatrix4(m);

3✔

320

    points[3].set(box3.min.x, box3.max.y, box3.max.z).applyMatrix4(m);

3✔

321

    points[4].set(box3.max.x, box3.min.y, box3.min.z).applyMatrix4(m);

3✔

322

    points[5].set(box3.max.x, box3.min.y, box3.max.z).applyMatrix4(m);

3✔

323

    points[6].set(box3.max.x, box3.max.y, box3.min.z).applyMatrix4(m);

3✔

324

    points[7].set(box3.max.x, box3.max.y, box3.max.z).applyMatrix4(m);

3✔

325

3✔

326

    // In camera space objects are along the -Z axis

3✔

327

    // So if min.z is > -near, the object is invisible

3✔

328

    let atLeastOneInFrontOfNearPlane = false;

3✔

329

    for (let i = 0; i < 8; i++) {

3✔

330

        if (points[i].z <= -camera.camera3D.near) {

3✔

331

            atLeastOneInFrontOfNearPlane = true;

3✔

332

        } else {

3✔

333

            // Clamp to near plane

3✔

334

            points[i].z = -camera.camera3D.near;

3✔

335

3✔

336

3✔

337

3✔

338

    return atLeastOneInFrontOfNearPlane ? points : undefined;

3✔

339

3✔

340

3✔

341

function projectObbPointsInCameraSpace(camera, obb, matrixWorld) {

3✔

342

    // Projects points in camera space

3✔

343

    // We don't project directly on screen to avoid artifacts when projecting

3✔

344

    // points behind the near plane.

3✔

345

    let m = camera.camera3D.matrixWorldInverse;

3✔

346

    if (matrixWorld) {

3✔

347

        m = tmp.matrix.multiplyMatrices(camera.camera3D.matrixWorldInverse, matrixWorld);

3✔

348

3✔

349

    points[0].set(obb.center.x + obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z + obb.halfSize.z)

3✔

350

        .applyMatrix3(obb.rotation)

3✔

351

        .add(obb.position)

3✔

352

        .applyMatrix4(m);

3✔

353

    points[1].set(obb.center.x + obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z - obb.halfSize.z)

3✔

354

        .applyMatrix3(obb.rotation)

3✔

355

        .add(obb.position)

3✔

356

        .applyMatrix4(m);

3✔

357

    points[2].set(obb.center.x + obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z + obb.halfSize.z)

3✔

358

        .applyMatrix3(obb.rotation)

3✔

359

        .add(obb.position)

3✔

360

        .applyMatrix4(m);

24✔

361

    points[3].set(obb.center.x + obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z - obb.halfSize.z)

24✔

362

        .applyMatrix3(obb.rotation)

8✔

363

        .add(obb.position)

3✔

364

        .applyMatrix4(m);

3✔

365

    points[4].set(obb.center.x - obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z + obb.halfSize.z)

1✔

366

        .applyMatrix3(obb.rotation)

1✔

367

        .add(obb.position)

1✔

368

        .applyMatrix4(m);

1✔

369

    points[5].set(obb.center.x - obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z - obb.halfSize.z)

1✔

370

        .applyMatrix3(obb.rotation)

1✔

371

        .add(obb.position)

1✔

372

        .applyMatrix4(m);

1✔

373

    points[6].set(obb.center.x - obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z + obb.halfSize.z)

1✔

374

        .applyMatrix3(obb.rotation)

1✔

375

        .add(obb.position)

1✔

376

        .applyMatrix4(m);

1✔

377

    points[7].set(obb.center.x - obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z - obb.halfSize.z)

1✔

378

        .applyMatrix3(obb.rotation)

1✔

379

        .add(obb.position)

1✔

380

        .applyMatrix4(m);

1✔

381

1✔

382

    // In camera space objects are along the -Z axis

1✔

383

    // So if min.z is > -near, the object is invisible

1✔

384

    let atLeastOneInFrontOfNearPlane = false;

1✔

385

    for (let i = 0; i < 8; i++) {

1✔

386

        if (points[i].z <= -camera.camera3D.near) {

1✔

387

            atLeastOneInFrontOfNearPlane = true;

1✔

388

        } else {

1✔

389

            // Clamp to near plane

1✔

390

            points[i].z = -camera.camera3D.near;

1✔

391

1✔

392

1✔

393

1✔

394

    return atLeastOneInFrontOfNearPlane ? points : undefined;

1✔

395

1✔

396

1✔

397

1✔

398

export default Camera;

1✔

iTowns / itowns / 8966662600

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

1	import * as THREE from 'three';	1✔
2	import Coordinates from 'Core/Geographic/Coordinates';	1✔
3	import DEMUtils from 'Utils/DEMUtils';	1✔
4	import { OBB } from 'ThreeExtended/math/OBB';	1✔
5	// import { OBB } from 'three/addons/math/OBB';	1✔
6		1✔
7	/**	1✔
8	* @typedef {object} Camera~CAMERA_TYPE	1✔
9	* Stores the different types of camera usable in iTowns.	1✔
10	*	1✔
11	* @property {number} PERSPECTIVE Perspective type of camera	1✔
12	* @property {number} ORTHOGRAPHIC Orthographic type of camera	1✔
13	*/	1✔
14	export const CAMERA_TYPE = {	1✔
15	PERSPECTIVE: 0,	1✔
16	ORTHOGRAPHIC: 1,	1✔
17	};	1✔
18		1✔
19	const tmp = {	1✔
20	frustum: new THREE.Frustum(),	1✔
21	matrix: new THREE.Matrix4(),	1✔
22	box3: new THREE.Box3(),	1✔
23	obb: new OBB(),	1✔
24	};	1✔
25		1✔
26	const _vector3 = new THREE.Vector3();	1✔
27		1✔
28	const ndcBox3 = new THREE.Box3(	1✔
29	new THREE.Vector3(-1, -1, -1),	1✔
30	new THREE.Vector3(1, 1, 1),	1✔
31	);	1✔
32	const ndcObb = new OBB().fromBox3(ndcBox3);	1✔
33		116✔
34	function updatePreSse(camera, height, fov) {	116✔
35	// sse = projected geometric error on screen plane from distance	116✔
36	// We're using an approximation, assuming that the geometric error of all	116✔
37	// objects is perpendicular to the camera view vector (= we always compute	116✔
38	// for worst case).	116✔
39	//	116✔
40	// screen plane object	116✔
41	// \| __	116✔
42	// \| / \	116✔
43	// \| geometric{\|	116✔
44	// < fov angle . } sse error {\| \|	116✔
45	// \| \__/	116✔
46	// \|	116✔
47	// \|<--------------------->	116✔
48	// \| distance	116✔
49	//	116✔
50	// geometric_error * screen_width (resp. screen_height)	116✔
51	// = ---------------------------------------	116✔
52	// 2 * distance * tan (horizontal_fov / 2) (resp. vertical_fov)	116✔
53	//	116✔
54	//	116✔
55	// We pre-compute the preSSE (= constant part of the screen space error formula) once here	116✔
56		116✔
57	// Note: the preSSE for the horizontal FOV is the same value	116✔
58	// focal = (this.height * 0.5) / Math.tan(verticalFOV * 0.5);	116✔
59	// horizontalFOV = 2 * Math.atan(this.width * 0.5 / focal);	116✔
60	// horizontalPreSSE = this.width / (2.0 * Math.tan(horizontalFOV * 0.5)); (1)	116✔
61	// => replacing horizontalFOV in Math.tan(horizontalFOV * 0.5)	116✔
62	// Math.tan(horizontalFOV * 0.5) = Math.tan(2 * Math.atan(this.width * 0.5 / focal) * 0.5)	116✔
63	// = Math.tan(Math.atan(this.width * 0.5 / focal))	116✔
64	// = this.width * 0.5 / focal	116✔
65	// => now replacing focal	116✔
66	// = this.width * 0.5 / (this.height * 0.5) / Math.tan(verticalFOV * 0.5)	116✔
67	// = Math.tan(verticalFOV * 0.5) * this.width / this.height	116✔
68	// => back to (1)	116✔
69	// horizontalPreSSE = this.width / (2.0 * Math.tan(verticalFOV * 0.5) * this.width / this.height)	116✔
70	// = this.height / 2.0 * Math.tan(verticalFOV * 0.5)	116✔
71	// = verticalPreSSE	116✔
72		109✔
73	if (camera.camera3D.isOrthographicCamera) {	109✔
74	camera._preSSE = height;	109✔
75	} else {	109✔
76	const verticalFOV = THREE.MathUtils.degToRad(fov);	1✔
77	camera._preSSE = height / (2.0 * Math.tan(verticalFOV * 0.5));	1✔
78	}	1✔
79	}	1✔
80		1✔
81	/**	1✔
82	* Wrapper around Three.js camera to expose some geographic helpers.	1✔
83	*	1✔
84	* @property {string} crs The camera's coordinate projection system.	1✔
85	* @property {THREE.Camera} camera3D The Three.js camera that is wrapped around.	1✔
86	* @property {number} width The width of the camera.	1✔
87	* @property {number} height The height of the camera.	1✔
88	* @property {number} _preSSE The precomputed constant part of the screen space error.	1✔
89	*/	50✔
90	class Camera {	50✔
91	#_viewMatrixNeedsUpdate = true;	50✔
92	#_viewMatrix = new THREE.Matrix4();	50✔
93		50✔
94	/**	50✔
95	* @param {string} crs The camera's coordinate projection system.	50✔
96	* @param {number} width The width (in pixels) of the view the	50✔
97	* camera is associated to.	50✔
98	* @param {number} height The height (in pixels) of the view the	50✔
99	* camera is associated to.	50✔
100	* @param {Object} [options] Options for the camera.	50✔
101	* @param {THREE.Camera} [options.cameraThree] A custom Three.js camera object to wrap	50✔
102	* around.	50✔
103	* @param {Camera~CAMERA_TYPE} [options.type=CAMERA_TYPE.PERSPECTIVE] The type of the camera. See {@link	50✔
104	* CAMERA_TYPE}.	42✔
105	* @constructor	50✔
106	*/	50✔
107	constructor(crs, width, height, options = {}) {	50!
108	this.crs = crs;	×
109		×
110	if (options.isCamera) {	×
111	console.warn('options.camera parameter is deprecated. Use options.camera.cameraThree to place a custom ' +	×
112	'camera as a parameter. See the documentation of Camera.');	50✔
113	this.camera3D = options;	50✔
114	} else if (options.cameraThree) {	49✔
115	this.camera3D = options.cameraThree;	4✔
116	} else {	4✔
117	switch (options.type) {	4✔
118	case CAMERA_TYPE.ORTHOGRAPHIC:	49!
119	this.camera3D = new THREE.OrthographicCamera();	45✔
120	break;	49✔
121	case CAMERA_TYPE.PERSPECTIVE:	50✔
122	default:	50✔
123	this.camera3D = new THREE.PerspectiveCamera(30);	50✔
124	break;	50✔
125	}	50✔
126	}	50✔
127	this.camera3D.aspect = this.camera3D.aspect ?? 1;	50✔
128		46✔
129	this.width = width;	46✔
130	this.height = height;	46✔
131	this.resize(width, height);	46✔
132		3✔
133	this._preSSE = Infinity;	3✔
134		3✔
135	if (this.camera3D.isPerspectiveCamera) {	3✔
136	let fov = this.camera3D.fov;	50✔
137	Object.defineProperty(this.camera3D, 'fov', {	50✔
138	get: () => fov,	50✔
139	set: (newFov) => {	50✔
140	fov = newFov;	50✔
141	updatePreSse(this, this.height, fov);	50✔
142	},	50✔
143	});	50✔
144	}	50✔
145	}	50✔
146		50✔
147	/**	50✔
148	* Resize the camera to a given width and height.	50✔
149	*	113✔
150	* @param {number} width The width to resize the camera to. Must be strictly positive, won't resize otherwise.	113!
151	* @param {number} height The height to resize the camera to. Must be strictly positive, won't resize otherwise.	113✔
152	*/	113✔
153	resize(width, height) {	113✔
154	if (!width \|\| width <= 0 \|\| !height \|\| height <= 0) {	51✔
155	console.warn(`Trying to resize the Camera with invalid height (${height}) or width (${width}). Skipping resize.`);	5✔
156	return;	5✔
157	}	5✔
158	const ratio = width / height;	51✔
159	if (this.camera3D.aspect !== ratio) {	46✔
160	if (this.camera3D.isOrthographicCamera) {	45✔
161	this.camera3D.zoom *= this.width / width;	45✔
162	const halfH = this.camera3D.top * this.camera3D.aspect / ratio;	113✔
163	this.camera3D.bottom = -halfH;	113✔
164	this.camera3D.top = halfH;	113✔
165	} else if (this.camera3D.isPerspectiveCamera) {	113✔
166	this.camera3D.fov = 2 * THREE.MathUtils.radToDeg(Math.atan(	112✔
167	(height / this.height) * Math.tan(THREE.MathUtils.degToRad(this.camera3D.fov) / 2),	50✔
168	));	2✔
169	}	50✔
170	this.camera3D.aspect = ratio;	50✔
171	}	50✔
172		50✔
173	this.width = width;	50✔
174	this.height = height;	50✔
175	updatePreSse(this, this.height, this.camera3D.fov);	50✔
176		50✔
177	if (this.camera3D.updateProjectionMatrix) {	50✔
178	this.camera3D.updateProjectionMatrix();	50✔
179	this.#_viewMatrixNeedsUpdate = true;	50✔
180	}	18✔
181	}	18✔
182		18✔
183	update() {	18✔
184	// update matrix	18✔
185	this.camera3D.updateMatrixWorld();	50✔
186	this.#_viewMatrixNeedsUpdate = true;	50✔
187	}	50✔
188		50✔
189	/**	50✔
190	* Return the position in the requested CRS, or in camera's CRS if undefined.	50✔
191	*	50✔
192	* @param {string} [crs] If defined (e.g 'EPSG:4326'), the camera position will be returned in this CRS.	50✔
193	*	1✔
194	* @return {Coordinates} Coordinates object holding camera's position.	50✔
195	*/	2✔
196	position(crs) {	2✔
197	return new Coordinates(this.crs, this.camera3D.position).as(crs \|\| this.crs);	50✔
198	}	3✔
199		3✔
200	/**	3✔
201	* Set the position of the camera using a Coordinates object.	3✔
202	* If you want to modify the position directly using x,y,z values then use `camera.camera3D.position.set(x, y, z)`	50✔
203	*	×
204	* @param {Coordinates} position The new position of the camera.	×
205	*/	×
206	setPosition(position) {	×
207	this.camera3D.position.copy(position.as(this.crs));	×
208	}	×
209		×
210	isBox3Visible(box3, matrixWorld) {	×
211	return this.box3SizeOnScreen(box3, matrixWorld).intersectsBox(ndcBox3);	×
212	}	×
213		×
NEW 214	isObbVisible(obb, matrixWorld) {	×
NEW 215	return this.obbSizeOnScreen(obb, matrixWorld).intersectsOBB(ndcObb);	×
NEW 216	}	×
NEW 217		×
218	isSphereVisible(sphere, matrixWorld) {	50✔
219	if (this.#_viewMatrixNeedsUpdate) {	2✔
220	// update visibility testing matrix	2✔
221	this.#_viewMatrix.multiplyMatrices(this.camera3D.projectionMatrix, this.camera3D.matrixWorldInverse);	2!
222	this.#_viewMatrixNeedsUpdate = false;	2✔
223	}	2✔
224	if (matrixWorld) {	2✔
225	tmp.matrix.multiplyMatrices(this.#_viewMatrix, matrixWorld);	2✔
226	tmp.frustum.setFromProjectionMatrix(tmp.matrix);	50✔
227	} else {	3✔
228	tmp.frustum.setFromProjectionMatrix(this.#_viewMatrix);	3✔
229	}	3✔
230	return tmp.frustum.intersectsSphere(sphere);	3✔
231	}	3✔
232		1✔
233	box3SizeOnScreen(box3, matrixWorld) {	1✔
234	const pts = projectBox3PointsInCameraSpace(this, box3, matrixWorld);	3✔
235		2✔
236	// All points are in front of the near plane -> box3 is invisible	3✔
237	if (!pts) {	2✔
238	return tmp.box3.makeEmpty();	50✔
239	}	50✔
240		50✔
241	// Project points on screen	50✔
242	for (let i = 0; i < 8; i++) {	50✔
243	pts[i].applyMatrix4(this.camera3D.projectionMatrix);	50✔
244	}	50✔
245		50✔
246	return tmp.box3.setFromPoints(pts);	50✔
247	}	50✔
248		50✔
249	obbSizeOnScreen(obb, matrixWorld) {	50✔
250	const pts = projectObbPointsInCameraSpace(this, obb, matrixWorld);	50✔
251		50✔
252	// All points are in front of the near plane -> box3 is invisible	50✔
253	if (!pts) {	50✔
254	tmp.obb.halfSize = _vector3;	50✔
255	return tmp.obb;	50✔
256	}	50✔
257		50✔
258	// Project points on screen	50✔
259	for (let i = 0; i < 8; i++) {	50✔
260	pts[i].applyMatrix4(this.camera3D.projectionMatrix);	50✔
261	}	50✔
262		50✔
263	return tmp.obb.fromBox3(tmp.box3.setFromPoints(pts));	50✔
264	}	50✔
265		50✔
266	/**	50✔
267	* Test for collision between camera and a geometry layer (DTM/DSM) to adjust camera position.	15✔
268	* It could be modified later to handle an array of geometry layers.	15✔
269	* TODO Improve Coordinates class to handle altitude for any coordinate system (even projected one)	15✔
270	*	15✔
271	* @param {View} view The view where we test the collision between geometry layers	15✔
272	* and the camera	15✔
273	* @param {ElevationLayer} elevationLayer The elevation layer (DTM/DSM) used to test the collision	15!
274	* with the camera. Could be another geometry layer.	×
275	* @param {number} minDistanceCollision The minimum distance allowed between the camera and the	×
276	* surface.	×
277	*/	×
278	adjustAltitudeToAvoidCollisionWithLayer(view, elevationLayer, minDistanceCollision) {	×
279	// We put the camera location in geographic by default to easily handle altitude.	1✔
280	// (Should be improved in Coordinates class for all ref)	1✔
281	const camLocation = view.camera.position().as('EPSG:4326');	1✔
282	if (elevationLayer !== undefined) {	1✔
283	const elevationUnderCamera = DEMUtils.getElevationValueAt(elevationLayer, camLocation);	2✔
284	if (elevationUnderCamera !== undefined) {	2✔
285	const difElevation = camLocation.altitude - (elevationUnderCamera + minDistanceCollision);	2✔
286	// We move the camera to avoid collision if too close to terrain	2✔
287	if (difElevation < 0) {	2✔
288	camLocation.altitude = elevationUnderCamera + minDistanceCollision;	2✔
289	view.camera3D.position.copy(camLocation.as(view.referenceCrs));	2✔
290	view.notifyChange(this.camera3D);	2✔
291	}	2✔
292	}	2✔
293	}	2✔
294	}	2✔
295	}	2✔
296		2✔
297		2✔
298	const points = [	2✔
299	new THREE.Vector3(),	2✔
300	new THREE.Vector3(),	2✔
301	new THREE.Vector3(),	2✔
302	new THREE.Vector3(),	2✔
303	new THREE.Vector3(),	2✔
304	new THREE.Vector3(),	2✔
305	new THREE.Vector3(),	2✔
306	new THREE.Vector3(),	2✔
307	];	2✔
308		2✔
309	function projectBox3PointsInCameraSpace(camera, box3, matrixWorld) {	2✔
310	// Projects points in camera space	2✔
311	// We don't project directly on screen to avoid artifacts when projecting	2✔
312	// points behind the near plane.	2✔
313	let m = camera.camera3D.matrixWorldInverse;	16✔
314	if (matrixWorld) {	14✔
315	m = tmp.matrix.multiplyMatrices(camera.camera3D.matrixWorldInverse, matrixWorld);	16✔
316	}	2✔
317	points[0].set(box3.min.x, box3.min.y, box3.min.z).applyMatrix4(m);	2!
318	points[1].set(box3.min.x, box3.min.y, box3.max.z).applyMatrix4(m);	1✔
319	points[2].set(box3.min.x, box3.max.y, box3.min.z).applyMatrix4(m);	3✔
320	points[3].set(box3.min.x, box3.max.y, box3.max.z).applyMatrix4(m);	3✔
321	points[4].set(box3.max.x, box3.min.y, box3.min.z).applyMatrix4(m);	3✔
322	points[5].set(box3.max.x, box3.min.y, box3.max.z).applyMatrix4(m);	3✔
323	points[6].set(box3.max.x, box3.max.y, box3.min.z).applyMatrix4(m);	3✔
324	points[7].set(box3.max.x, box3.max.y, box3.max.z).applyMatrix4(m);	3✔
325		3✔
326	// In camera space objects are along the -Z axis	3✔
327	// So if min.z is > -near, the object is invisible	3✔
328	let atLeastOneInFrontOfNearPlane = false;	3✔
329	for (let i = 0; i < 8; i++) {	3✔
330	if (points[i].z <= -camera.camera3D.near) {	3✔
331	atLeastOneInFrontOfNearPlane = true;	3✔
332	} else {	3✔
333	// Clamp to near plane	3✔
334	points[i].z = -camera.camera3D.near;	3✔
335	}	3✔
336	}	3✔
337		3✔
338	return atLeastOneInFrontOfNearPlane ? points : undefined;	3✔
339	}	3✔
340		3✔
341	function projectObbPointsInCameraSpace(camera, obb, matrixWorld) {	3✔
342	// Projects points in camera space	3✔
343	// We don't project directly on screen to avoid artifacts when projecting	3✔
344	// points behind the near plane.	3✔
345	let m = camera.camera3D.matrixWorldInverse;	3✔
346	if (matrixWorld) {	3✔
347	m = tmp.matrix.multiplyMatrices(camera.camera3D.matrixWorldInverse, matrixWorld);	3✔
348	}	3✔
349	points[0].set(obb.center.x + obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z + obb.halfSize.z)	3✔
350	.applyMatrix3(obb.rotation)	3✔
351	.add(obb.position)	3✔
352	.applyMatrix4(m);	3✔
353	points[1].set(obb.center.x + obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z - obb.halfSize.z)	3✔
354	.applyMatrix3(obb.rotation)	3✔
355	.add(obb.position)	3✔
356	.applyMatrix4(m);	3✔
357	points[2].set(obb.center.x + obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z + obb.halfSize.z)	3✔
358	.applyMatrix3(obb.rotation)	3✔
359	.add(obb.position)	3✔
360	.applyMatrix4(m);	24✔
361	points[3].set(obb.center.x + obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z - obb.halfSize.z)	24✔
362	.applyMatrix3(obb.rotation)	8✔
363	.add(obb.position)	3✔
364	.applyMatrix4(m);	3✔
365	points[4].set(obb.center.x - obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z + obb.halfSize.z)	1✔
366	.applyMatrix3(obb.rotation)	1✔
367	.add(obb.position)	1✔
368	.applyMatrix4(m);	1✔
369	points[5].set(obb.center.x - obb.halfSize.x, obb.center.y + obb.halfSize.y, obb.center.z - obb.halfSize.z)	1✔
370	.applyMatrix3(obb.rotation)	1✔
371	.add(obb.position)	1✔
372	.applyMatrix4(m);	1✔
373	points[6].set(obb.center.x - obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z + obb.halfSize.z)	1✔
374	.applyMatrix3(obb.rotation)	1✔
375	.add(obb.position)	1✔
376	.applyMatrix4(m);	1✔
377	points[7].set(obb.center.x - obb.halfSize.x, obb.center.y - obb.halfSize.y, obb.center.z - obb.halfSize.z)	1✔
378	.applyMatrix3(obb.rotation)	1✔
379	.add(obb.position)	1✔
380	.applyMatrix4(m);	1✔
381		1✔
382	// In camera space objects are along the -Z axis	1✔
383	// So if min.z is > -near, the object is invisible	1✔
384	let atLeastOneInFrontOfNearPlane = false;	1✔
385	for (let i = 0; i < 8; i++) {	1✔
386	if (points[i].z <= -camera.camera3D.near) {	1✔
387	atLeastOneInFrontOfNearPlane = true;	1✔
388	} else {	1✔
389	// Clamp to near plane	1✔
390	points[i].z = -camera.camera3D.near;	1✔
391	}	1✔
392	}	1✔
393		1✔
394	return atLeastOneInFrontOfNearPlane ? points : undefined;	1✔
395	}	1✔
396		1✔
397		1✔
398	export default Camera;	1✔

iTowns / itowns / 8966662600

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