Wise&mystical  1.0
Project about Europe
Loading...
Searching...
No Matches
rcamera.h
Go to the documentation of this file.
1
44#ifndef RCAMERA_H
45#define RCAMERA_H
46
47//----------------------------------------------------------------------------------
48// Defines and Macros
49//----------------------------------------------------------------------------------
50//...
51
52//----------------------------------------------------------------------------------
53// Types and Structures Definition
54// NOTE: Below types are required for CAMERA_STANDALONE usage
55//----------------------------------------------------------------------------------
56#if defined(CAMERA_STANDALONE)
57 // Vector2 type
58 typedef struct Vector2 {
59 float x;
60 float y;
61 } Vector2;
62
63 // Vector3 type
64 typedef struct Vector3 {
65 float x;
66 float y;
67 float z;
68 } Vector3;
69
70 // Camera type, defines a camera position/orientation in 3d space
71 typedef struct Camera3D {
72 Vector3 position; // Camera position
73 Vector3 target; // Camera target it looks-at
74 Vector3 up; // Camera up vector (rotation over its axis)
75 float fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
76 int type; // Camera type, defines projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
77 } Camera3D;
78
79 typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D
80
81 // Camera system modes
82 typedef enum {
83 CAMERA_CUSTOM = 0,
84 CAMERA_FREE,
85 CAMERA_ORBITAL,
86 CAMERA_FIRST_PERSON,
87 CAMERA_THIRD_PERSON
88 } CameraMode;
89
90 // Camera projection modes
91 typedef enum {
92 CAMERA_PERSPECTIVE = 0,
93 CAMERA_ORTHOGRAPHIC
94 } CameraProjection;
95#endif
96
97//----------------------------------------------------------------------------------
98// Global Variables Definition
99//----------------------------------------------------------------------------------
100//...
101
102//----------------------------------------------------------------------------------
103// Module Functions Declaration
104//----------------------------------------------------------------------------------
105
106#ifdef __cplusplus
107extern "C" { // Prevents name mangling of functions
108#endif
109
110#if defined(CAMERA_STANDALONE)
111void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available)
112void UpdateCamera(Camera *camera); // Update camera position for selected mode
113
114void SetCameraPanControl(int keyPan); // Set camera pan key to combine with mouse movement (free camera)
115void SetCameraAltControl(int keyAlt); // Set camera alt key to combine with mouse movement (free camera)
116void SetCameraSmoothZoomControl(int szoomKey); // Set camera smooth zoom key to combine with mouse (free camera)
117void SetCameraMoveControls(int keyFront, int keyBack,
118 int keyRight, int keyLeft,
119 int keyUp, int keyDown); // Set camera move controls (1st person and 3rd person cameras)
120#endif
121
122#ifdef __cplusplus
123}
124#endif
125
126#endif // CAMERA_H
127
128
129
135#if defined(CAMERA_IMPLEMENTATION)
136
137#include <math.h> // Required for: sinf(), cosf(), sqrtf()
138
139//----------------------------------------------------------------------------------
140// Defines and Macros
141//----------------------------------------------------------------------------------
142#ifndef PI
143 #define PI 3.14159265358979323846
144#endif
145#ifndef DEG2RAD
146 #define DEG2RAD (PI/180.0f)
147#endif
148#ifndef RAD2DEG
149 #define RAD2DEG (180.0f/PI)
150#endif
151
152// Camera mouse movement sensitivity
153#define CAMERA_MOUSE_MOVE_SENSITIVITY 0.003f
154#define CAMERA_MOUSE_SCROLL_SENSITIVITY 1.5f
155
156// FREE_CAMERA
157#define CAMERA_FREE_MOUSE_SENSITIVITY 0.01f
158#define CAMERA_FREE_DISTANCE_MIN_CLAMP 0.3f
159#define CAMERA_FREE_DISTANCE_MAX_CLAMP 120.0f
160#define CAMERA_FREE_MIN_CLAMP 85.0f
161#define CAMERA_FREE_MAX_CLAMP -85.0f
162#define CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY 0.05f
163#define CAMERA_FREE_PANNING_DIVIDER 5.1f
164
165// ORBITAL_CAMERA
166#define CAMERA_ORBITAL_SPEED 0.01f // Radians per frame
167
168// FIRST_PERSON
169//#define CAMERA_FIRST_PERSON_MOUSE_SENSITIVITY 0.003f
170#define CAMERA_FIRST_PERSON_FOCUS_DISTANCE 25.0f
171#define CAMERA_FIRST_PERSON_MIN_CLAMP 89.0f
172#define CAMERA_FIRST_PERSON_MAX_CLAMP -89.0f
173
174#define CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER 8.0f
175#define CAMERA_FIRST_PERSON_STEP_DIVIDER 30.0f
176#define CAMERA_FIRST_PERSON_WAVING_DIVIDER 200.0f
177
178// THIRD_PERSON
179//#define CAMERA_THIRD_PERSON_MOUSE_SENSITIVITY 0.003f
180#define CAMERA_THIRD_PERSON_DISTANCE_CLAMP 1.2f
181#define CAMERA_THIRD_PERSON_MIN_CLAMP 5.0f
182#define CAMERA_THIRD_PERSON_MAX_CLAMP -85.0f
183#define CAMERA_THIRD_PERSON_OFFSET (Vector3){ 0.4f, 0.0f, 0.0f }
184
185// PLAYER (used by camera)
186#define PLAYER_MOVEMENT_SENSITIVITY 20.0f
187
188//----------------------------------------------------------------------------------
189// Types and Structures Definition
190//----------------------------------------------------------------------------------
191// Camera move modes (first person and third person cameras)
192typedef enum {
193 MOVE_FRONT = 0,
194 MOVE_BACK,
195 MOVE_RIGHT,
196 MOVE_LEFT,
197 MOVE_UP,
198 MOVE_DOWN
199} CameraMove;
200
201// Camera global state context data [56 bytes]
202typedef struct {
203 unsigned int mode; // Current camera mode
204 float targetDistance; // Camera distance from position to target
205 float playerEyesPosition; // Player eyes position from ground (in meters)
206 Vector2 angle; // Camera angle in plane XZ
207 Vector2 previousMousePosition; // Previous mouse position
208
209 // Camera movement control keys
210 int moveControl[6]; // Move controls (CAMERA_FIRST_PERSON)
211 int smoothZoomControl; // Smooth zoom control key
212 int altControl; // Alternative control key
213 int panControl; // Pan view control key
214} CameraData;
215
216//----------------------------------------------------------------------------------
217// Global Variables Definition
218//----------------------------------------------------------------------------------
219static CameraData CAMERA = { // Global CAMERA state context
220 .mode = 0,
221 .targetDistance = 0,
222 .playerEyesPosition = 1.85f,
223 .angle = { 0 },
224 .previousMousePosition = { 0 },
225 .moveControl = { 'W', 'S', 'D', 'A', 'E', 'Q' },
226 .smoothZoomControl = 341, // raylib: KEY_LEFT_CONTROL
227 .altControl = 342, // raylib: KEY_LEFT_ALT
228 .panControl = 2 // raylib: MOUSE_BUTTON_MIDDLE
229};
230
231//----------------------------------------------------------------------------------
232// Module specific Functions Declaration
233//----------------------------------------------------------------------------------
234#if defined(CAMERA_STANDALONE)
235// NOTE: Camera controls depend on some raylib input functions
236static void EnableCursor() {} // Unlock cursor
237static void DisableCursor() {} // Lock cursor
238
239static int IsKeyDown(int key) { return 0; }
240
241static int IsMouseButtonDown(int button) { return 0;}
242static float GetMouseWheelMove() { return 0.0f; }
243static Vector2 GetMousePosition() { return (Vector2){ 0.0f, 0.0f }; }
244#endif
245
246//----------------------------------------------------------------------------------
247// Module Functions Definition
248//----------------------------------------------------------------------------------
249
250// Select camera mode (multiple camera modes available)
251void SetCameraMode(Camera camera, int mode)
252{
253 Vector3 v1 = camera.position;
254 Vector3 v2 = camera.target;
255
256 float dx = v2.x - v1.x;
257 float dy = v2.y - v1.y;
258 float dz = v2.z - v1.z;
259
260 CAMERA.targetDistance = sqrtf(dx*dx + dy*dy + dz*dz); // Distance to target
261
262 // Camera angle calculation
263 CAMERA.angle.x = atan2f(dx, dz); // Camera angle in plane XZ (0 aligned with Z, move positive CCW)
264 CAMERA.angle.y = atan2f(dy, sqrtf(dx*dx + dz*dz)); // Camera angle in plane XY (0 aligned with X, move positive CW)
265
266 CAMERA.playerEyesPosition = camera.position.y; // Init player eyes position to camera Y position
267
268 CAMERA.previousMousePosition = GetMousePosition(); // Init mouse position
269
270 // Lock cursor for first person and third person cameras
271 if ((mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON)) DisableCursor();
272 else EnableCursor();
273
274 CAMERA.mode = mode;
275}
276
277// Update camera depending on selected mode
278// NOTE: Camera controls depend on some raylib functions:
279// System: EnableCursor(), DisableCursor()
280// Mouse: IsMouseButtonDown(), GetMousePosition(), GetMouseWheelMove()
281// Keys: IsKeyDown()
282void UpdateCamera(Camera *camera)
283{
284 static int swingCounter = 0; // Used for 1st person swinging movement
285
286 // TODO: Compute CAMERA.targetDistance and CAMERA.angle here (?)
287
288 // Mouse movement detection
289 Vector2 mousePositionDelta = { 0.0f, 0.0f };
290 Vector2 mousePosition = GetMousePosition();
291 float mouseWheelMove = GetMouseWheelMove();
292
293 // Keys input detection
294 // TODO: Input detection is raylib-dependant, it could be moved outside the module
295 bool keyPan = IsMouseButtonDown(CAMERA.panControl);
296 bool keyAlt = IsKeyDown(CAMERA.altControl);
297 bool szoomKey = IsKeyDown(CAMERA.smoothZoomControl);
298 bool direction[6] = { IsKeyDown(CAMERA.moveControl[MOVE_FRONT]),
299 IsKeyDown(CAMERA.moveControl[MOVE_BACK]),
300 IsKeyDown(CAMERA.moveControl[MOVE_RIGHT]),
301 IsKeyDown(CAMERA.moveControl[MOVE_LEFT]),
302 IsKeyDown(CAMERA.moveControl[MOVE_UP]),
303 IsKeyDown(CAMERA.moveControl[MOVE_DOWN]) };
304
305 if (CAMERA.mode != CAMERA_CUSTOM)
306 {
307 mousePositionDelta.x = mousePosition.x - CAMERA.previousMousePosition.x;
308 mousePositionDelta.y = mousePosition.y - CAMERA.previousMousePosition.y;
309
310 CAMERA.previousMousePosition = mousePosition;
311 }
312
313 // Support for multiple automatic camera modes
314 // NOTE: In case of CAMERA_CUSTOM nothing happens here, user must update it manually
315 switch (CAMERA.mode)
316 {
317 case CAMERA_FREE: // Camera free controls, using standard 3d-content-creation scheme
318 {
319 // Camera zoom
320 if ((CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
321 {
322 CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
323 if (CAMERA.targetDistance > CAMERA_FREE_DISTANCE_MAX_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MAX_CLAMP;
324 }
325
326 // Camera looking down
327 else if ((camera->position.y > camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
328 {
329 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
330 camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
331 camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
332 }
333 else if ((camera->position.y > camera->target.y) && (camera->target.y >= 0))
334 {
335 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
336 camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
337 camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
338
339 // if (camera->target.y < 0) camera->target.y = -0.001;
340 }
341 else if ((camera->position.y > camera->target.y) && (camera->target.y < 0) && (mouseWheelMove > 0))
342 {
343 CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
344 if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
345 }
346 // Camera looking up
347 else if ((camera->position.y < camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
348 {
349 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
350 camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
351 camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
352 }
353 else if ((camera->position.y < camera->target.y) && (camera->target.y <= 0))
354 {
355 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
356 camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
357 camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
358
359 // if (camera->target.y > 0) camera->target.y = 0.001;
360 }
361 else if ((camera->position.y < camera->target.y) && (camera->target.y > 0) && (mouseWheelMove > 0))
362 {
363 CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
364 if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
365 }
366
367 // Input keys checks
368 if (keyPan)
369 {
370 if (keyAlt) // Alternative key behaviour
371 {
372 if (szoomKey)
373 {
374 // Camera smooth zoom
375 CAMERA.targetDistance += (mousePositionDelta.y*CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY);
376 }
377 else
378 {
379 // Camera rotation
380 CAMERA.angle.x += mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY;
381 CAMERA.angle.y += mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY;
382
383 // Angle clamp
384 if (CAMERA.angle.y > CAMERA_FREE_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MIN_CLAMP*DEG2RAD;
385 else if (CAMERA.angle.y < CAMERA_FREE_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MAX_CLAMP*DEG2RAD;
386 }
387 }
388 else
389 {
390 // Camera panning
391 camera->target.x += ((mousePositionDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x) + (mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
392 camera->target.y += ((mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
393 camera->target.z += ((mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x) + (mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
394 }
395 }
396
397 // Update camera position with changes
398 camera->position.x = -sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
399 camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance + camera->target.y;
400 camera->position.z = -cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
401
402 } break;
403 case CAMERA_ORBITAL: // Camera just orbits around target, only zoom allowed
404 {
405 CAMERA.angle.x += CAMERA_ORBITAL_SPEED; // Camera orbit angle
406 CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY); // Camera zoom
407
408 // Camera distance clamp
409 if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
410
411 // Update camera position with changes
412 camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
413 camera->position.y = ((CAMERA.angle.y <= 0.0f)? 1 : -1)*sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
414 camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
415
416 } break;
417 case CAMERA_FIRST_PERSON: // Camera moves as in a first-person game, controls are configurable
418 {
419 camera->position.x += (sinf(CAMERA.angle.x)*direction[MOVE_BACK] -
420 sinf(CAMERA.angle.x)*direction[MOVE_FRONT] -
421 cosf(CAMERA.angle.x)*direction[MOVE_LEFT] +
422 cosf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
423
424 camera->position.y += (sinf(CAMERA.angle.y)*direction[MOVE_FRONT] -
425 sinf(CAMERA.angle.y)*direction[MOVE_BACK] +
426 1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])/PLAYER_MOVEMENT_SENSITIVITY;
427
428 camera->position.z += (cosf(CAMERA.angle.x)*direction[MOVE_BACK] -
429 cosf(CAMERA.angle.x)*direction[MOVE_FRONT] +
430 sinf(CAMERA.angle.x)*direction[MOVE_LEFT] -
431 sinf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
432
433 // Camera orientation calculation
434 CAMERA.angle.x += (mousePositionDelta.x*-CAMERA_MOUSE_MOVE_SENSITIVITY);
435 CAMERA.angle.y += (mousePositionDelta.y*-CAMERA_MOUSE_MOVE_SENSITIVITY);
436
437 // Angle clamp
438 if (CAMERA.angle.y > CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD;
439 else if (CAMERA.angle.y < CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD;
440
441 // Calculate translation matrix
442 Matrix matTranslation = { 1.0f, 0.0f, 0.0f, 0.0f,
443 0.0f, 1.0f, 0.0f, 0.0f,
444 0.0f, 0.0f, 1.0f, (CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER),
445 0.0f, 0.0f, 0.0f, 1.0f };
446
447 // Calculate rotation matrix
448 Matrix matRotation = { 1.0f, 0.0f, 0.0f, 0.0f,
449 0.0f, 1.0f, 0.0f, 0.0f,
450 0.0f, 0.0f, 1.0f, 0.0f,
451 0.0f, 0.0f, 0.0f, 1.0f };
452
453 float cosz = cosf(0.0f);
454 float sinz = sinf(0.0f);
455 float cosy = cosf(-(PI*2 - CAMERA.angle.x));
456 float siny = sinf(-(PI*2 - CAMERA.angle.x));
457 float cosx = cosf(-(PI*2 - CAMERA.angle.y));
458 float sinx = sinf(-(PI*2 - CAMERA.angle.y));
459
460 matRotation.m0 = cosz*cosy;
461 matRotation.m4 = (cosz*siny*sinx) - (sinz*cosx);
462 matRotation.m8 = (cosz*siny*cosx) + (sinz*sinx);
463 matRotation.m1 = sinz*cosy;
464 matRotation.m5 = (sinz*siny*sinx) + (cosz*cosx);
465 matRotation.m9 = (sinz*siny*cosx) - (cosz*sinx);
466 matRotation.m2 = -siny;
467 matRotation.m6 = cosy*sinx;
468 matRotation.m10= cosy*cosx;
469
470 // Multiply translation and rotation matrices
471 Matrix matTransform = { 0 };
472 matTransform.m0 = matTranslation.m0*matRotation.m0 + matTranslation.m1*matRotation.m4 + matTranslation.m2*matRotation.m8 + matTranslation.m3*matRotation.m12;
473 matTransform.m1 = matTranslation.m0*matRotation.m1 + matTranslation.m1*matRotation.m5 + matTranslation.m2*matRotation.m9 + matTranslation.m3*matRotation.m13;
474 matTransform.m2 = matTranslation.m0*matRotation.m2 + matTranslation.m1*matRotation.m6 + matTranslation.m2*matRotation.m10 + matTranslation.m3*matRotation.m14;
475 matTransform.m3 = matTranslation.m0*matRotation.m3 + matTranslation.m1*matRotation.m7 + matTranslation.m2*matRotation.m11 + matTranslation.m3*matRotation.m15;
476 matTransform.m4 = matTranslation.m4*matRotation.m0 + matTranslation.m5*matRotation.m4 + matTranslation.m6*matRotation.m8 + matTranslation.m7*matRotation.m12;
477 matTransform.m5 = matTranslation.m4*matRotation.m1 + matTranslation.m5*matRotation.m5 + matTranslation.m6*matRotation.m9 + matTranslation.m7*matRotation.m13;
478 matTransform.m6 = matTranslation.m4*matRotation.m2 + matTranslation.m5*matRotation.m6 + matTranslation.m6*matRotation.m10 + matTranslation.m7*matRotation.m14;
479 matTransform.m7 = matTranslation.m4*matRotation.m3 + matTranslation.m5*matRotation.m7 + matTranslation.m6*matRotation.m11 + matTranslation.m7*matRotation.m15;
480 matTransform.m8 = matTranslation.m8*matRotation.m0 + matTranslation.m9*matRotation.m4 + matTranslation.m10*matRotation.m8 + matTranslation.m11*matRotation.m12;
481 matTransform.m9 = matTranslation.m8*matRotation.m1 + matTranslation.m9*matRotation.m5 + matTranslation.m10*matRotation.m9 + matTranslation.m11*matRotation.m13;
482 matTransform.m10 = matTranslation.m8*matRotation.m2 + matTranslation.m9*matRotation.m6 + matTranslation.m10*matRotation.m10 + matTranslation.m11*matRotation.m14;
483 matTransform.m11 = matTranslation.m8*matRotation.m3 + matTranslation.m9*matRotation.m7 + matTranslation.m10*matRotation.m11 + matTranslation.m11*matRotation.m15;
484 matTransform.m12 = matTranslation.m12*matRotation.m0 + matTranslation.m13*matRotation.m4 + matTranslation.m14*matRotation.m8 + matTranslation.m15*matRotation.m12;
485 matTransform.m13 = matTranslation.m12*matRotation.m1 + matTranslation.m13*matRotation.m5 + matTranslation.m14*matRotation.m9 + matTranslation.m15*matRotation.m13;
486 matTransform.m14 = matTranslation.m12*matRotation.m2 + matTranslation.m13*matRotation.m6 + matTranslation.m14*matRotation.m10 + matTranslation.m15*matRotation.m14;
487 matTransform.m15 = matTranslation.m12*matRotation.m3 + matTranslation.m13*matRotation.m7 + matTranslation.m14*matRotation.m11 + matTranslation.m15*matRotation.m15;
488
489 camera->target.x = camera->position.x - matTransform.m12;
490 camera->target.y = camera->position.y - matTransform.m13;
491 camera->target.z = camera->position.z - matTransform.m14;
492
493 // If movement detected (some key pressed), increase swinging
494 for (int i = 0; i < 6; i++) if (direction[i]) { swingCounter++; break; }
495
496 // Camera position update
497 // NOTE: On CAMERA_FIRST_PERSON player Y-movement is limited to player 'eyes position'
498 camera->position.y = CAMERA.playerEyesPosition - sinf(swingCounter/CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER)/CAMERA_FIRST_PERSON_STEP_DIVIDER;
499
500 camera->up.x = sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
501 camera->up.z = -sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
502
503 } break;
504 case CAMERA_THIRD_PERSON: // Camera moves as in a third-person game, following target at a distance, controls are configurable
505 {
506 camera->position.x += (sinf(CAMERA.angle.x)*direction[MOVE_BACK] -
507 sinf(CAMERA.angle.x)*direction[MOVE_FRONT] -
508 cosf(CAMERA.angle.x)*direction[MOVE_LEFT] +
509 cosf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
510
511 camera->position.y += (sinf(CAMERA.angle.y)*direction[MOVE_FRONT] -
512 sinf(CAMERA.angle.y)*direction[MOVE_BACK] +
513 1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])/PLAYER_MOVEMENT_SENSITIVITY;
514
515 camera->position.z += (cosf(CAMERA.angle.x)*direction[MOVE_BACK] -
516 cosf(CAMERA.angle.x)*direction[MOVE_FRONT] +
517 sinf(CAMERA.angle.x)*direction[MOVE_LEFT] -
518 sinf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
519
520 // Camera orientation calculation
521 CAMERA.angle.x += (mousePositionDelta.x*-CAMERA_MOUSE_MOVE_SENSITIVITY);
522 CAMERA.angle.y += (mousePositionDelta.y*-CAMERA_MOUSE_MOVE_SENSITIVITY);
523
524 // Angle clamp
525 if (CAMERA.angle.y > CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD;
526 else if (CAMERA.angle.y < CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD;
527
528 // Camera zoom
529 CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
530
531 // Camera distance clamp
532 if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
533
534 camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
535
536 if (CAMERA.angle.y <= 0.0f) camera->position.y = sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
537 else camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
538
539 camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
540
541 } break;
542 case CAMERA_CUSTOM: break;
543 default: break;
544 }
545}
546
547// Set camera pan key to combine with mouse movement (free camera)
548void SetCameraPanControl(int keyPan) { CAMERA.panControl = keyPan; }
549
550// Set camera alt key to combine with mouse movement (free camera)
551void SetCameraAltControl(int keyAlt) { CAMERA.altControl = keyAlt; }
552
553// Set camera smooth zoom key to combine with mouse (free camera)
554void SetCameraSmoothZoomControl(int szoomKey) { CAMERA.smoothZoomControl = szoomKey; }
555
556// Set camera move controls (1st person and 3rd person cameras)
557void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown)
558{
559 CAMERA.moveControl[MOVE_FRONT] = keyFront;
560 CAMERA.moveControl[MOVE_BACK] = keyBack;
561 CAMERA.moveControl[MOVE_RIGHT] = keyRight;
562 CAMERA.moveControl[MOVE_LEFT] = keyLeft;
563 CAMERA.moveControl[MOVE_UP] = keyUp;
564 CAMERA.moveControl[MOVE_DOWN] = keyDown;
565}
566
567#endif // CAMERA_IMPLEMENTATION
PI
#define PI
Definition: easings.h:96
CameraProjection
CameraProjection
Definition: raylib.h:876
CAMERA_PERSPECTIVE
@ CAMERA_PERSPECTIVE
Definition: raylib.h:877
CAMERA_ORTHOGRAPHIC
@ CAMERA_ORTHOGRAPHIC
Definition: raylib.h:878
Camera
Camera3D Camera
Definition: raylib.h:307
SetCameraPanControl
RLAPI void SetCameraPanControl(int keyPan)
GetMouseWheelMove
RLAPI float GetMouseWheelMove(void)
Definition: rcore.c:3811
SetCameraSmoothZoomControl
RLAPI void SetCameraSmoothZoomControl(int keySmoothZoom)
IsMouseButtonDown
RLAPI bool IsMouseButtonDown(int button)
Definition: rcore.c:3709
UpdateCamera
RLAPI void UpdateCamera(Camera *camera)
IsKeyDown
RLAPI bool IsKeyDown(int key)
Definition: rcore.c:3505
SetCameraAltControl
RLAPI void SetCameraAltControl(int keyAlt)
GetMousePosition
RLAPI Vector2 GetMousePosition(void)
Definition: rcore.c:3761
CameraMode
CameraMode
Definition: raylib.h:867
CAMERA_ORBITAL
@ CAMERA_ORBITAL
Definition: raylib.h:870
CAMERA_THIRD_PERSON
@ CAMERA_THIRD_PERSON
Definition: raylib.h:872
CAMERA_FIRST_PERSON
@ CAMERA_FIRST_PERSON
Definition: raylib.h:871
CAMERA_FREE
@ CAMERA_FREE
Definition: raylib.h:869
CAMERA_CUSTOM
@ CAMERA_CUSTOM
Definition: raylib.h:868
DisableCursor
RLAPI void DisableCursor(void)
Definition: rcore.c:1966
SetCameraMoveControls
RLAPI void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown)
DEG2RAD
#define DEG2RAD
Definition: raylib.h:106
SetCameraMode
RLAPI void SetCameraMode(Camera camera, int mode)
EnableCursor
RLAPI void EnableCursor(void)
Definition: rcore.c:1953
Camera3D::up
Vector3 up
Definition: raylib.h:302
Camera3D::position
Vector3 position
Definition: raylib.h:300
Camera3D::fovy
float fovy
Definition: raylib.h:303
Camera3D::target
Vector3 target
Definition: raylib.h:301
Matrix
Definition: raylib.h:212
Matrix::m14
float m14
Definition: raylib.h:215
Matrix::m11
float m11
Definition: raylib.h:216
Matrix::m5
float m5
Definition: raylib.h:214
Matrix::m15
float m15
Definition: raylib.h:216
Matrix::m3
float m3
Definition: raylib.h:216
Matrix::m1
float m1
Definition: raylib.h:214
Matrix::m9
float m9
Definition: raylib.h:214
Matrix::m0
float m0
Definition: raylib.h:213
Matrix::m2
float m2
Definition: raylib.h:215
Matrix::m6
float m6
Definition: raylib.h:215
Matrix::m4
float m4
Definition: raylib.h:213
Matrix::m13
float m13
Definition: raylib.h:214
Matrix::m8
float m8
Definition: raylib.h:213
Matrix::m12
float m12
Definition: raylib.h:213
Matrix::m7
float m7
Definition: raylib.h:216
Matrix::m10
float m10
Definition: raylib.h:215
Vector2::x
float x
Definition: physac.h:130
Vector2::y
float y
Definition: physac.h:131
Vector3::x
float x
Definition: raylib.h:195
Vector3::y
float y
Definition: raylib.h:196
Vector3::z
float z
Definition: raylib.h:197