aboutsummaryrefslogtreecommitdiff
path: root/deps/raylib/src/rcamera.h
diff options
context:
space:
mode:
Diffstat (limited to 'deps/raylib/src/rcamera.h')
-rw-r--r--deps/raylib/src/rcamera.h555
1 files changed, 555 insertions, 0 deletions
diff --git a/deps/raylib/src/rcamera.h b/deps/raylib/src/rcamera.h
new file mode 100644
index 0000000..bd2b36e
--- /dev/null
+++ b/deps/raylib/src/rcamera.h
@@ -0,0 +1,555 @@
+/*******************************************************************************************
+*
+* rcamera - Basic camera system with support for multiple camera modes
+*
+* CONFIGURATION:
+* #define RCAMERA_IMPLEMENTATION
+* Generates the implementation of the library into the included file.
+* If not defined, the library is in header only mode and can be included in other headers
+* or source files without problems. But only ONE file should hold the implementation.
+*
+* #define RCAMERA_STANDALONE
+* If defined, the library can be used as standalone as a camera system but some
+* functions must be redefined to manage inputs accordingly.
+*
+* CONTRIBUTORS:
+* Ramon Santamaria: Supervision, review, update and maintenance
+* Christoph Wagner: Complete redesign, using raymath (2022)
+* Marc Palau: Initial implementation (2014)
+*
+*
+* LICENSE: zlib/libpng
+*
+* Copyright (c) 2022-2024 Christoph Wagner (@Crydsch) & Ramon Santamaria (@raysan5)
+*
+* This software is provided "as-is", without any express or implied warranty. In no event
+* will the authors be held liable for any damages arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose, including commercial
+* applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not claim that you
+* wrote the original software. If you use this software in a product, an acknowledgment
+* in the product documentation would be appreciated but is not required.
+*
+* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
+* as being the original software.
+*
+* 3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+#ifndef RCAMERA_H
+#define RCAMERA_H
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+// Function specifiers definition
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+#if defined(_WIN32)
+#if defined(BUILD_LIBTYPE_SHARED)
+#if defined(__TINYC__)
+#define __declspec(x) __attribute__((x))
+#endif
+#define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll)
+#elif defined(USE_LIBTYPE_SHARED)
+#define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll)
+#endif
+#endif
+
+#ifndef RLAPI
+ #define RLAPI // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+#if defined(RCAMERA_STANDALONE)
+ #define CAMERA_CULL_DISTANCE_NEAR 0.01
+ #define CAMERA_CULL_DISTANCE_FAR 1000.0
+#else
+ #define CAMERA_CULL_DISTANCE_NEAR RL_CULL_DISTANCE_NEAR
+ #define CAMERA_CULL_DISTANCE_FAR RL_CULL_DISTANCE_FAR
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+// NOTE: Below types are required for standalone usage
+//----------------------------------------------------------------------------------
+#if defined(RCAMERA_STANDALONE)
+ // Vector2, 2 components
+ typedef struct Vector2 {
+ float x; // Vector x component
+ float y; // Vector y component
+ } Vector2;
+
+ // Vector3, 3 components
+ typedef struct Vector3 {
+ float x; // Vector x component
+ float y; // Vector y component
+ float z; // Vector z component
+ } Vector3;
+
+ // Matrix, 4x4 components, column major, OpenGL style, right-handed
+ typedef struct Matrix {
+ float m0, m4, m8, m12; // Matrix first row (4 components)
+ float m1, m5, m9, m13; // Matrix second row (4 components)
+ float m2, m6, m10, m14; // Matrix third row (4 components)
+ float m3, m7, m11, m15; // Matrix fourth row (4 components)
+ } Matrix;
+
+ // Camera type, defines a camera position/orientation in 3d space
+ typedef struct Camera3D {
+ Vector3 position; // Camera position
+ Vector3 target; // Camera target it looks-at
+ Vector3 up; // Camera up vector (rotation over its axis)
+ float fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
+ int projection; // Camera projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+ } Camera3D;
+
+ typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D
+
+ // Camera projection
+ typedef enum {
+ CAMERA_PERSPECTIVE = 0, // Perspective projection
+ CAMERA_ORTHOGRAPHIC // Orthographic projection
+ } CameraProjection;
+
+ // Camera system modes
+ typedef enum {
+ CAMERA_CUSTOM = 0, // Camera custom, controlled by user (UpdateCamera() does nothing)
+ CAMERA_FREE, // Camera free mode
+ CAMERA_ORBITAL, // Camera orbital, around target, zoom supported
+ CAMERA_FIRST_PERSON, // Camera first person
+ CAMERA_THIRD_PERSON // Camera third person
+ } CameraMode;
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+extern "C" { // Prevents name mangling of functions
+#endif
+
+RLAPI Vector3 GetCameraForward(Camera *camera);
+RLAPI Vector3 GetCameraUp(Camera *camera);
+RLAPI Vector3 GetCameraRight(Camera *camera);
+
+// Camera movement
+RLAPI void CameraMoveForward(Camera *camera, float distance, bool moveInWorldPlane);
+RLAPI void CameraMoveUp(Camera *camera, float distance);
+RLAPI void CameraMoveRight(Camera *camera, float distance, bool moveInWorldPlane);
+RLAPI void CameraMoveToTarget(Camera *camera, float delta);
+
+// Camera rotation
+RLAPI void CameraYaw(Camera *camera, float angle, bool rotateAroundTarget);
+RLAPI void CameraPitch(Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp);
+RLAPI void CameraRoll(Camera *camera, float angle);
+
+RLAPI Matrix GetCameraViewMatrix(Camera *camera);
+RLAPI Matrix GetCameraProjectionMatrix(Camera* camera, float aspect);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // RCAMERA_H
+
+/***********************************************************************************
+*
+* CAMERA IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RCAMERA_IMPLEMENTATION)
+
+#include "raymath.h" // Required for vector maths:
+ // Vector3Add()
+ // Vector3Subtract()
+ // Vector3Scale()
+ // Vector3Normalize()
+ // Vector3Distance()
+ // Vector3CrossProduct()
+ // Vector3RotateByAxisAngle()
+ // Vector3Angle()
+ // Vector3Negate()
+ // MatrixLookAt()
+ // MatrixPerspective()
+ // MatrixOrtho()
+ // MatrixIdentity()
+
+// raylib required functionality:
+ // GetMouseDelta()
+ // GetMouseWheelMove()
+ // IsKeyDown()
+ // IsKeyPressed()
+ // GetFrameTime()
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#define CAMERA_MOVE_SPEED 5.4f // Units per second
+#define CAMERA_ROTATION_SPEED 0.03f
+#define CAMERA_PAN_SPEED 0.2f
+
+// Camera mouse movement sensitivity
+#define CAMERA_MOUSE_MOVE_SENSITIVITY 0.003f
+
+// Camera orbital speed in CAMERA_ORBITAL mode
+#define CAMERA_ORBITAL_SPEED 0.5f // Radians per second
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+// Returns the cameras forward vector (normalized)
+Vector3 GetCameraForward(Camera *camera)
+{
+ return Vector3Normalize(Vector3Subtract(camera->target, camera->position));
+}
+
+// Returns the cameras up vector (normalized)
+// Note: The up vector might not be perpendicular to the forward vector
+Vector3 GetCameraUp(Camera *camera)
+{
+ return Vector3Normalize(camera->up);
+}
+
+// Returns the cameras right vector (normalized)
+Vector3 GetCameraRight(Camera *camera)
+{
+ Vector3 forward = GetCameraForward(camera);
+ Vector3 up = GetCameraUp(camera);
+
+ return Vector3Normalize(Vector3CrossProduct(forward, up));
+}
+
+// Moves the camera in its forward direction
+void CameraMoveForward(Camera *camera, float distance, bool moveInWorldPlane)
+{
+ Vector3 forward = GetCameraForward(camera);
+
+ if (moveInWorldPlane)
+ {
+ // Project vector onto world plane
+ forward.y = 0;
+ forward = Vector3Normalize(forward);
+ }
+
+ // Scale by distance
+ forward = Vector3Scale(forward, distance);
+
+ // Move position and target
+ camera->position = Vector3Add(camera->position, forward);
+ camera->target = Vector3Add(camera->target, forward);
+}
+
+// Moves the camera in its up direction
+void CameraMoveUp(Camera *camera, float distance)
+{
+ Vector3 up = GetCameraUp(camera);
+
+ // Scale by distance
+ up = Vector3Scale(up, distance);
+
+ // Move position and target
+ camera->position = Vector3Add(camera->position, up);
+ camera->target = Vector3Add(camera->target, up);
+}
+
+// Moves the camera target in its current right direction
+void CameraMoveRight(Camera *camera, float distance, bool moveInWorldPlane)
+{
+ Vector3 right = GetCameraRight(camera);
+
+ if (moveInWorldPlane)
+ {
+ // Project vector onto world plane
+ right.y = 0;
+ right = Vector3Normalize(right);
+ }
+
+ // Scale by distance
+ right = Vector3Scale(right, distance);
+
+ // Move position and target
+ camera->position = Vector3Add(camera->position, right);
+ camera->target = Vector3Add(camera->target, right);
+}
+
+// Moves the camera position closer/farther to/from the camera target
+void CameraMoveToTarget(Camera *camera, float delta)
+{
+ float distance = Vector3Distance(camera->position, camera->target);
+
+ // Apply delta
+ distance += delta;
+
+ // Distance must be greater than 0
+ if (distance <= 0) distance = 0.001f;
+
+ // Set new distance by moving the position along the forward vector
+ Vector3 forward = GetCameraForward(camera);
+ camera->position = Vector3Add(camera->target, Vector3Scale(forward, -distance));
+}
+
+// Rotates the camera around its up vector
+// Yaw is "looking left and right"
+// If rotateAroundTarget is false, the camera rotates around its position
+// Note: angle must be provided in radians
+void CameraYaw(Camera *camera, float angle, bool rotateAroundTarget)
+{
+ // Rotation axis
+ Vector3 up = GetCameraUp(camera);
+
+ // View vector
+ Vector3 targetPosition = Vector3Subtract(camera->target, camera->position);
+
+ // Rotate view vector around up axis
+ targetPosition = Vector3RotateByAxisAngle(targetPosition, up, angle);
+
+ if (rotateAroundTarget)
+ {
+ // Move position relative to target
+ camera->position = Vector3Subtract(camera->target, targetPosition);
+ }
+ else // rotate around camera.position
+ {
+ // Move target relative to position
+ camera->target = Vector3Add(camera->position, targetPosition);
+ }
+}
+
+// Rotates the camera around its right vector, pitch is "looking up and down"
+// - lockView prevents camera overrotation (aka "somersaults")
+// - rotateAroundTarget defines if rotation is around target or around its position
+// - rotateUp rotates the up direction as well (typically only usefull in CAMERA_FREE)
+// NOTE: angle must be provided in radians
+void CameraPitch(Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp)
+{
+ // Up direction
+ Vector3 up = GetCameraUp(camera);
+
+ // View vector
+ Vector3 targetPosition = Vector3Subtract(camera->target, camera->position);
+
+ if (lockView)
+ {
+ // In these camera modes we clamp the Pitch angle
+ // to allow only viewing straight up or down.
+
+ // Clamp view up
+ float maxAngleUp = Vector3Angle(up, targetPosition);
+ maxAngleUp -= 0.001f; // avoid numerical errors
+ if (angle > maxAngleUp) angle = maxAngleUp;
+
+ // Clamp view down
+ float maxAngleDown = Vector3Angle(Vector3Negate(up), targetPosition);
+ maxAngleDown *= -1.0f; // downwards angle is negative
+ maxAngleDown += 0.001f; // avoid numerical errors
+ if (angle < maxAngleDown) angle = maxAngleDown;
+ }
+
+ // Rotation axis
+ Vector3 right = GetCameraRight(camera);
+
+ // Rotate view vector around right axis
+ targetPosition = Vector3RotateByAxisAngle(targetPosition, right, angle);
+
+ if (rotateAroundTarget)
+ {
+ // Move position relative to target
+ camera->position = Vector3Subtract(camera->target, targetPosition);
+ }
+ else // rotate around camera.position
+ {
+ // Move target relative to position
+ camera->target = Vector3Add(camera->position, targetPosition);
+ }
+
+ if (rotateUp)
+ {
+ // Rotate up direction around right axis
+ camera->up = Vector3RotateByAxisAngle(camera->up, right, angle);
+ }
+}
+
+// Rotates the camera around its forward vector
+// Roll is "turning your head sideways to the left or right"
+// Note: angle must be provided in radians
+void CameraRoll(Camera *camera, float angle)
+{
+ // Rotation axis
+ Vector3 forward = GetCameraForward(camera);
+
+ // Rotate up direction around forward axis
+ camera->up = Vector3RotateByAxisAngle(camera->up, forward, angle);
+}
+
+// Returns the camera view matrix
+Matrix GetCameraViewMatrix(Camera *camera)
+{
+ return MatrixLookAt(camera->position, camera->target, camera->up);
+}
+
+// Returns the camera projection matrix
+Matrix GetCameraProjectionMatrix(Camera *camera, float aspect)
+{
+ if (camera->projection == CAMERA_PERSPECTIVE)
+ {
+ return MatrixPerspective(camera->fovy*DEG2RAD, aspect, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR);
+ }
+ else if (camera->projection == CAMERA_ORTHOGRAPHIC)
+ {
+ double top = camera->fovy/2.0;
+ double right = top*aspect;
+
+ return MatrixOrtho(-right, right, -top, top, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR);
+ }
+
+ return MatrixIdentity();
+}
+
+#if !defined(RCAMERA_STANDALONE)
+// Update camera position for selected mode
+// Camera mode: CAMERA_FREE, CAMERA_FIRST_PERSON, CAMERA_THIRD_PERSON, CAMERA_ORBITAL or CUSTOM
+void UpdateCamera(Camera *camera, int mode)
+{
+ Vector2 mousePositionDelta = GetMouseDelta();
+
+ bool moveInWorldPlane = ((mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON));
+ bool rotateAroundTarget = ((mode == CAMERA_THIRD_PERSON) || (mode == CAMERA_ORBITAL));
+ bool lockView = ((mode == CAMERA_FREE) || (mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON) || (mode == CAMERA_ORBITAL));
+ bool rotateUp = false;
+
+ // Camera speeds based on frame time
+ float cameraMoveSpeed = CAMERA_MOVE_SPEED*GetFrameTime();
+ float cameraRotationSpeed = CAMERA_ROTATION_SPEED*GetFrameTime();
+ float cameraPanSpeed = CAMERA_PAN_SPEED*GetFrameTime();
+ float cameraOrbitalSpeed = CAMERA_ORBITAL_SPEED*GetFrameTime();
+
+ if (mode == CAMERA_CUSTOM) {}
+ else if (mode == CAMERA_ORBITAL)
+ {
+ // Orbital can just orbit
+ Matrix rotation = MatrixRotate(GetCameraUp(camera), cameraOrbitalSpeed);
+ Vector3 view = Vector3Subtract(camera->position, camera->target);
+ view = Vector3Transform(view, rotation);
+ camera->position = Vector3Add(camera->target, view);
+ }
+ else
+ {
+ // Camera rotation
+ if (IsKeyDown(KEY_DOWN)) CameraPitch(camera, -cameraRotationSpeed, lockView, rotateAroundTarget, rotateUp);
+ if (IsKeyDown(KEY_UP)) CameraPitch(camera, cameraRotationSpeed, lockView, rotateAroundTarget, rotateUp);
+ if (IsKeyDown(KEY_RIGHT)) CameraYaw(camera, -cameraRotationSpeed, rotateAroundTarget);
+ if (IsKeyDown(KEY_LEFT)) CameraYaw(camera, cameraRotationSpeed, rotateAroundTarget);
+ if (IsKeyDown(KEY_Q)) CameraRoll(camera, -cameraRotationSpeed);
+ if (IsKeyDown(KEY_E)) CameraRoll(camera, cameraRotationSpeed);
+
+ // Camera movement
+ // Camera pan (for CAMERA_FREE)
+ if ((mode == CAMERA_FREE) && (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE)))
+ {
+ const Vector2 mouseDelta = GetMouseDelta();
+ if (mouseDelta.x > 0.0f) CameraMoveRight(camera, cameraPanSpeed, moveInWorldPlane);
+ if (mouseDelta.x < 0.0f) CameraMoveRight(camera, -cameraPanSpeed, moveInWorldPlane);
+ if (mouseDelta.y > 0.0f) CameraMoveUp(camera, -cameraPanSpeed);
+ if (mouseDelta.y < 0.0f) CameraMoveUp(camera, cameraPanSpeed);
+ }
+ else
+ {
+ // Mouse support
+ CameraYaw(camera, -mousePositionDelta.x*CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget);
+ CameraPitch(camera, -mousePositionDelta.y*CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp);
+ }
+
+ // Keyboard support
+ if (IsKeyDown(KEY_W)) CameraMoveForward(camera, cameraMoveSpeed, moveInWorldPlane);
+ if (IsKeyDown(KEY_A)) CameraMoveRight(camera, -cameraMoveSpeed, moveInWorldPlane);
+ if (IsKeyDown(KEY_S)) CameraMoveForward(camera, -cameraMoveSpeed, moveInWorldPlane);
+ if (IsKeyDown(KEY_D)) CameraMoveRight(camera, cameraMoveSpeed, moveInWorldPlane);
+
+ // Gamepad movement
+ if (IsGamepadAvailable(0))
+ {
+ // Gamepad controller support
+ CameraYaw(camera, -(GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_X)*2)*CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget);
+ CameraPitch(camera, -(GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_Y)*2)*CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp);
+
+ if (GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y) <= -0.25f) CameraMoveForward(camera, cameraMoveSpeed, moveInWorldPlane);
+ if (GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X) <= -0.25f) CameraMoveRight(camera, -cameraMoveSpeed, moveInWorldPlane);
+ if (GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y) >= 0.25f) CameraMoveForward(camera, -cameraMoveSpeed, moveInWorldPlane);
+ if (GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X) >= 0.25f) CameraMoveRight(camera, cameraMoveSpeed, moveInWorldPlane);
+ }
+
+ if (mode == CAMERA_FREE)
+ {
+ if (IsKeyDown(KEY_SPACE)) CameraMoveUp(camera, cameraMoveSpeed);
+ if (IsKeyDown(KEY_LEFT_CONTROL)) CameraMoveUp(camera, -cameraMoveSpeed);
+ }
+ }
+
+ if ((mode == CAMERA_THIRD_PERSON) || (mode == CAMERA_ORBITAL) || (mode == CAMERA_FREE))
+ {
+ // Zoom target distance
+ CameraMoveToTarget(camera, -GetMouseWheelMove());
+ if (IsKeyPressed(KEY_KP_SUBTRACT)) CameraMoveToTarget(camera, 2.0f);
+ if (IsKeyPressed(KEY_KP_ADD)) CameraMoveToTarget(camera, -2.0f);
+ }
+}
+#endif // !RCAMERA_STANDALONE
+
+// Update camera movement, movement/rotation values should be provided by user
+void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom)
+{
+ // Required values
+ // movement.x - Move forward/backward
+ // movement.y - Move right/left
+ // movement.z - Move up/down
+ // rotation.x - yaw
+ // rotation.y - pitch
+ // rotation.z - roll
+ // zoom - Move towards target
+
+ bool lockView = true;
+ bool rotateAroundTarget = false;
+ bool rotateUp = false;
+ bool moveInWorldPlane = true;
+
+ // Camera rotation
+ CameraPitch(camera, -rotation.y*DEG2RAD, lockView, rotateAroundTarget, rotateUp);
+ CameraYaw(camera, -rotation.x*DEG2RAD, rotateAroundTarget);
+ CameraRoll(camera, rotation.z*DEG2RAD);
+
+ // Camera movement
+ CameraMoveForward(camera, movement.x, moveInWorldPlane);
+ CameraMoveRight(camera, movement.y, moveInWorldPlane);
+ CameraMoveUp(camera, movement.z);
+
+ // Zoom target distance
+ CameraMoveToTarget(camera, zoom);
+}
+
+#endif // RCAMERA_IMPLEMENTATION
generated by cgit v1.2.3-70-g09d2 (git 2.50.1) at 2025-10-10 10:55:17 +0000