Afredbilli commited on
Commit
137d252
·
verified ·
1 Parent(s): 9e5a980

Create src/camera.js

Browse files
Files changed (1) hide show
  1. src/camera.js +505 -0
src/camera.js ADDED
@@ -0,0 +1,505 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import * as THREE from "three";
2
+
3
+ // =============================================
4
+ // CAMERA CONFIGURATION
5
+ // =============================================
6
+
7
+ const CAMERA_CONFIG = {
8
+ distance: 7,
9
+ height: 3.2,
10
+ lookHeight: 1.5,
11
+
12
+ minDistance: 3,
13
+ maxDistance: 12,
14
+
15
+ minPitch: -0.15,
16
+ maxPitch: 0.8,
17
+
18
+ rotationSpeed: 0.004,
19
+ zoomSpeed: 0.8,
20
+
21
+ positionSmoothing: 8,
22
+ rotationSmoothing: 10,
23
+
24
+ fov: 65,
25
+ near: 0.1,
26
+ far: 250
27
+ };
28
+
29
+ // =============================================
30
+ // THIRD-PERSON CAMERA
31
+ // =============================================
32
+
33
+ export function createCamera(scene, renderer) {
34
+ const camera = new THREE.PerspectiveCamera(
35
+ CAMERA_CONFIG.fov,
36
+ window.innerWidth / window.innerHeight,
37
+ CAMERA_CONFIG.near,
38
+ CAMERA_CONFIG.far
39
+ );
40
+
41
+ camera.position.set(0, 5, 9);
42
+
43
+ const target = new THREE.Vector3(0, 1, 0);
44
+
45
+ const desiredPosition = new THREE.Vector3();
46
+ const desiredTarget = new THREE.Vector3();
47
+
48
+ const cameraDirection = new THREE.Vector3();
49
+
50
+ const spherical = new THREE.Spherical(
51
+ CAMERA_CONFIG.distance,
52
+ Math.PI / 2.8,
53
+ 0
54
+ );
55
+
56
+ let yaw = 0;
57
+ let pitch = 0.18;
58
+
59
+ let distance = CAMERA_CONFIG.distance;
60
+
61
+ let activeCharacter = null;
62
+
63
+ let isDragging = false;
64
+ let previousPointerX = 0;
65
+ let previousPointerY = 0;
66
+
67
+ let disposed = false;
68
+
69
+ // =========================================
70
+ // CHARACTER TARGET
71
+ // =========================================
72
+
73
+ function getCharacterPosition(character) {
74
+ if (!character) {
75
+ return new THREE.Vector3(0, 0, 0);
76
+ }
77
+
78
+ // Character controller objects may expose
79
+ // their own position directly.
80
+ if (character.root) {
81
+ return character.root.position;
82
+ }
83
+
84
+ if (character.position) {
85
+ return character.position;
86
+ }
87
+
88
+ return new THREE.Vector3(0, 0, 0);
89
+ }
90
+
91
+ function updateDesiredPosition(character) {
92
+ const characterPosition =
93
+ getCharacterPosition(character);
94
+
95
+ desiredTarget.set(
96
+ characterPosition.x,
97
+ characterPosition.y + CAMERA_CONFIG.lookHeight,
98
+ characterPosition.z
99
+ );
100
+
101
+ const horizontalDistance =
102
+ distance * Math.cos(pitch);
103
+
104
+ desiredPosition.set(
105
+ characterPosition.x +
106
+ Math.sin(yaw) * horizontalDistance,
107
+
108
+ characterPosition.y +
109
+ CAMERA_CONFIG.height +
110
+ distance * Math.sin(pitch),
111
+
112
+ characterPosition.z +
113
+ Math.cos(yaw) * horizontalDistance
114
+ );
115
+ }
116
+
117
+ // =========================================
118
+ // MOUSE CAMERA ROTATION
119
+ // =========================================
120
+
121
+ function handlePointerDown(event) {
122
+ if (event.button !== 2) {
123
+ return;
124
+ }
125
+
126
+ isDragging = true;
127
+
128
+ previousPointerX = event.clientX;
129
+ previousPointerY = event.clientY;
130
+
131
+ renderer.domElement.setPointerCapture?.(
132
+ event.pointerId
133
+ );
134
+ }
135
+
136
+ function handlePointerMove(event) {
137
+ if (!isDragging) {
138
+ return;
139
+ }
140
+
141
+ const deltaX =
142
+ event.clientX - previousPointerX;
143
+
144
+ const deltaY =
145
+ event.clientY - previousPointerY;
146
+
147
+ previousPointerX = event.clientX;
148
+ previousPointerY = event.clientY;
149
+
150
+ yaw -= deltaX * CAMERA_CONFIG.rotationSpeed;
151
+
152
+ pitch -= deltaY * CAMERA_CONFIG.rotationSpeed;
153
+
154
+ pitch = THREE.MathUtils.clamp(
155
+ pitch,
156
+ CAMERA_CONFIG.minPitch,
157
+ CAMERA_CONFIG.maxPitch
158
+ );
159
+ }
160
+
161
+ function handlePointerUp() {
162
+ isDragging = false;
163
+ }
164
+
165
+ function handleContextMenu(event) {
166
+ event.preventDefault();
167
+ }
168
+
169
+ // =========================================
170
+ // MOUSE WHEEL ZOOM
171
+ // =========================================
172
+
173
+ function handleWheel(event) {
174
+ distance +=
175
+ Math.sign(event.deltaY) *
176
+ CAMERA_CONFIG.zoomSpeed;
177
+
178
+ distance = THREE.MathUtils.clamp(
179
+ distance,
180
+ CAMERA_CONFIG.minDistance,
181
+ CAMERA_CONFIG.maxDistance
182
+ );
183
+ }
184
+
185
+ // =========================================
186
+ // TOUCH CAMERA ROTATION
187
+ // =========================================
188
+
189
+ function handleTouchStart(event) {
190
+ if (event.touches.length !== 1) {
191
+ return;
192
+ }
193
+
194
+ // Reserve the lower-left area for movement
195
+ // controls. Camera rotation starts elsewhere.
196
+ const touch = event.touches[0];
197
+
198
+ if (touch.clientX < window.innerWidth * 0.4) {
199
+ return;
200
+ }
201
+
202
+ isDragging = true;
203
+
204
+ previousPointerX = touch.clientX;
205
+ previousPointerY = touch.clientY;
206
+ }
207
+
208
+ function handleTouchMove(event) {
209
+ if (!isDragging || event.touches.length !== 1) {
210
+ return;
211
+ }
212
+
213
+ const touch = event.touches[0];
214
+
215
+ const deltaX =
216
+ touch.clientX - previousPointerX;
217
+
218
+ const deltaY =
219
+ touch.clientY - previousPointerY;
220
+
221
+ previousPointerX = touch.clientX;
222
+ previousPointerY = touch.clientY;
223
+
224
+ yaw -= deltaX * CAMERA_CONFIG.rotationSpeed;
225
+
226
+ pitch -= deltaY * CAMERA_CONFIG.rotationSpeed;
227
+
228
+ pitch = THREE.MathUtils.clamp(
229
+ pitch,
230
+ CAMERA_CONFIG.minPitch,
231
+ CAMERA_CONFIG.maxPitch
232
+ );
233
+ }
234
+
235
+ function handleTouchEnd() {
236
+ isDragging = false;
237
+ }
238
+
239
+ // =========================================
240
+ // CAMERA COLLISION
241
+ // =========================================
242
+
243
+ const raycaster = new THREE.Raycaster();
244
+
245
+ const cameraOffset = new THREE.Vector3();
246
+
247
+ function preventCameraClipping(character) {
248
+ if (!character || !character.root) {
249
+ return;
250
+ }
251
+
252
+ const origin = desiredTarget;
253
+
254
+ cameraOffset.subVectors(
255
+ desiredPosition,
256
+ origin
257
+ );
258
+
259
+ const desiredDistance = cameraOffset.length();
260
+
261
+ if (desiredDistance <= 0) {
262
+ return;
263
+ }
264
+
265
+ cameraOffset.normalize();
266
+
267
+ raycaster.set(origin, cameraOffset);
268
+
269
+ raycaster.far = desiredDistance;
270
+
271
+ // Future improvement:
272
+ // Raycast against dedicated collision geometry
273
+ // rather than every decorative scene object.
274
+ const hits = raycaster.intersectObjects(
275
+ scene.children,
276
+ true
277
+ );
278
+
279
+ for (const hit of hits) {
280
+ if (hit.object === character.root) {
281
+ continue;
282
+ }
283
+
284
+ if (
285
+ hit.object.isMesh &&
286
+ hit.distance > 0.2
287
+ ) {
288
+ const safeDistance = Math.max(
289
+ CAMERA_CONFIG.minDistance,
290
+ hit.distance - 0.3
291
+ );
292
+
293
+ desiredPosition.copy(origin).addScaledVector(
294
+ cameraOffset,
295
+ Math.min(desiredDistance, safeDistance)
296
+ );
297
+
298
+ break;
299
+ }
300
+ }
301
+ }
302
+
303
+ // =========================================
304
+ // EVENT REGISTRATION
305
+ // =========================================
306
+
307
+ const element = renderer.domElement;
308
+
309
+ element.addEventListener(
310
+ "pointerdown",
311
+ handlePointerDown
312
+ );
313
+
314
+ element.addEventListener(
315
+ "pointermove",
316
+ handlePointerMove
317
+ );
318
+
319
+ element.addEventListener(
320
+ "pointerup",
321
+ handlePointerUp
322
+ );
323
+
324
+ element.addEventListener(
325
+ "pointercancel",
326
+ handlePointerUp
327
+ );
328
+
329
+ element.addEventListener(
330
+ "contextmenu",
331
+ handleContextMenu
332
+ );
333
+
334
+ element.addEventListener(
335
+ "wheel",
336
+ handleWheel,
337
+ { passive: true }
338
+ );
339
+
340
+ element.addEventListener(
341
+ "touchstart",
342
+ handleTouchStart,
343
+ { passive: true }
344
+ );
345
+
346
+ element.addEventListener(
347
+ "touchmove",
348
+ handleTouchMove,
349
+ { passive: true }
350
+ );
351
+
352
+ element.addEventListener(
353
+ "touchend",
354
+ handleTouchEnd,
355
+ { passive: true }
356
+ );
357
+
358
+ element.addEventListener(
359
+ "touchcancel",
360
+ handleTouchEnd,
361
+ { passive: true }
362
+ );
363
+
364
+ // =========================================
365
+ // PUBLIC CAMERA API
366
+ // =========================================
367
+
368
+ function update(delta, character) {
369
+ if (disposed) {
370
+ return;
371
+ }
372
+
373
+ activeCharacter = character;
374
+
375
+ updateDesiredPosition(activeCharacter);
376
+
377
+ // Avoid making the camera jump when the game
378
+ // briefly drops frames.
379
+ const positionAlpha =
380
+ 1 - Math.exp(
381
+ -CAMERA_CONFIG.positionSmoothing * delta
382
+ );
383
+
384
+ const rotationAlpha =
385
+ 1 - Math.exp(
386
+ -CAMERA_CONFIG.rotationSmoothing * delta
387
+ );
388
+
389
+ preventCameraClipping(activeCharacter);
390
+
391
+ camera.position.lerp(
392
+ desiredPosition,
393
+ positionAlpha
394
+ );
395
+
396
+ target.lerp(
397
+ desiredTarget,
398
+ rotationAlpha
399
+ );
400
+
401
+ camera.lookAt(target);
402
+
403
+ cameraDirection.subVectors(
404
+ target,
405
+ camera.position
406
+ ).normalize();
407
+ }
408
+
409
+ function resize(width, height) {
410
+ camera.aspect = width / height;
411
+
412
+ camera.updateProjectionMatrix();
413
+ }
414
+
415
+ function rotate(horizontal, vertical) {
416
+ yaw -= horizontal * CAMERA_CONFIG.rotationSpeed;
417
+
418
+ pitch -= vertical * CAMERA_CONFIG.rotationSpeed;
419
+
420
+ pitch = THREE.MathUtils.clamp(
421
+ pitch,
422
+ CAMERA_CONFIG.minPitch,
423
+ CAMERA_CONFIG.maxPitch
424
+ );
425
+ }
426
+
427
+ function zoom(amount) {
428
+ distance = THREE.MathUtils.clamp(
429
+ distance + amount,
430
+ CAMERA_CONFIG.minDistance,
431
+ CAMERA_CONFIG.maxDistance
432
+ );
433
+ }
434
+
435
+ function reset() {
436
+ yaw = 0;
437
+ pitch = 0.18;
438
+ distance = CAMERA_CONFIG.distance;
439
+ }
440
+
441
+ function dispose() {
442
+ disposed = true;
443
+
444
+ element.removeEventListener(
445
+ "pointerdown",
446
+ handlePointerDown
447
+ );
448
+
449
+ element.removeEventListener(
450
+ "pointermove",
451
+ handlePointerMove
452
+ );
453
+
454
+ element.removeEventListener(
455
+ "pointerup",
456
+ handlePointerUp
457
+ );
458
+
459
+ element.removeEventListener(
460
+ "pointercancel",
461
+ handlePointerUp
462
+ );
463
+
464
+ element.removeEventListener(
465
+ "contextmenu",
466
+ handleContextMenu
467
+ );
468
+
469
+ element.removeEventListener(
470
+ "wheel",
471
+ handleWheel
472
+ );
473
+
474
+ element.removeEventListener(
475
+ "touchstart",
476
+ handleTouchStart
477
+ );
478
+
479
+ element.removeEventListener(
480
+ "touchmove",
481
+ handleTouchMove
482
+ );
483
+
484
+ element.removeEventListener(
485
+ "touchend",
486
+ handleTouchEnd
487
+ );
488
+
489
+ element.removeEventListener(
490
+ "touchcancel",
491
+ handleTouchEnd
492
+ );
493
+ }
494
+
495
+ return {
496
+ camera,
497
+
498
+ update,
499
+ resize,
500
+ rotate,
501
+ zoom,
502
+ reset,
503
+ dispose
504
+ };
505
+ }