box3d/samples/camera.cpp
2026-05-10 13:36:52 -07:00

330 lines
8.5 KiB
C++

// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include <glad/glad.h>
// prevent clang format sorting glad.h with glfw3.h
#include <GLFW/glfw3.h>
// ImGui
#include <imgui.h>
#include <imgui_internal.h>
Matrix4 MakeOrthographicMatrix( float left, float right, float bottom, float top, float near, float far)
{
Matrix4 m;
m.cx = Vector4{ 2.0f / (right - left), 0.0f, 0.0f, 0.0f };
m.cy = Vector4{ 0.0f, 2.0f / (top - bottom), 0.0f, 0.0f };
m.cz = Vector4{ 0.0f, 0.0f, -2.0f / (far - near), 0.0f };
m.cw.x = -(right + left) / (right - left);
m.cw.y = -(top + bottom) / (top - bottom);
m.cw.z = -(far + near) / (far - near);
m.cw.w = 1.0f;
return m;
}
Camera::Camera()
{
m_yaw = 0.0f;
m_pitch = 0.0f;
m_radius = 1.0f;
m_speed = 20.0f;
m_pivot = b3Vec3_zero;
m_nearPlane = 0.02f;
m_farPlane = 100000.0f;
m_fovY = 50.0f;
m_tanY = tanf( 0.5f * B3_DEG_TO_RAD * m_fovY );
m_thirdPerson = false;
m_bufferWidth = 1920;
m_bufferHeight = 1080;
Resize(1920, 1080);
UpdateTransform();
}
void Camera::Resize( int width, int height )
{
m_width = b3MaxInt(width, 1 );
m_height = b3MaxInt(height, 1 );
m_ratio = float( m_width ) / float( m_height );
m_nearHeight = 2.0f * m_nearPlane * m_tanY;
m_nearWidth = m_ratio * m_nearHeight;
m_farHeight = m_farPlane * ( m_nearHeight / m_nearPlane );
m_farWidth = m_farPlane * ( m_nearWidth / m_nearPlane );
}
b3Vec3 Camera::GetRight() const
{
return m_right;
}
b3Vec3 Camera::GetUp() const
{
return m_up;
}
b3Vec3 Camera::GetForward() const
{
return m_forward;
}
b3Vec3 Camera::GetPosition() const
{
return m_position;
}
void Camera::Frame( b3AABB bounds)
{
b3Vec3 center = b3AABB_Center(bounds);
b3Vec3 extent = b3AABB_Extents(bounds);
float height = 2.0f * b3MaxFloat(extent.x, b3MaxFloat(extent.y, extent.z ) );
float radius = 0.5f * height / tanf( 0.5f * B3_DEG_TO_RAD * m_fovY );
m_pivot = center;
m_radius = 1.25f * radius;
}
void Camera::SetView( float yaw, float pitch, float radius, b3Vec3 pivot)
{
m_yaw = yaw;
m_pitch = pitch;
m_radius = radius;
m_pivot = pivot;
UpdateTransform();
}
Matrix4 Camera::GetWorldMatrix() const
{
Matrix4 m;
m.cx = { m_right.x, m_right.y, m_right.z, 0.0f };
m.cy = { m_up.x, m_up.y, m_up.z, 0.0f };
m.cz = { m_forward.x, m_forward.y, m_forward.z, 0.0f };
m.cw = { m_position.x, m_position.y, m_position.z, 1.0f };
return m;
}
static Matrix4 InvertOrtho( const Matrix4& m)
{
// [ R | t ]
// M = [ --+-- ]
// [ 0 | 1 ]
//
// y = M * x -> y = R * x + t -> x = R^-1 * (y - t) -> x = R^-1 * y - R^-1 * t
//
// [ R | t ]-1 [ R^-1 | -R^-1 * t ]
// M^-1 = [ --+-- ] = [ -----+---------- ]
// [ 0 | 1 ] [ 0 | 1 ]
b3Matrix3 r;
r.cx = {m.cx.x, m.cx.y, m.cx.z };
r.cy = {m.cy.x, m.cy.y, m.cy.z };
r.cz = {m.cz.x, m.cz.y, m.cz.z };
b3Matrix3 invR = b3InvertMatrix(r);
b3Vec3 t{m.cw.x, m.cw.y, m.cw.z };
b3Vec3 invRXT = invR * t;
Matrix4 out;
out.cx = {invR.cx.x, invR.cx.y, invR.cx.z, 0.0f };
out.cy = {invR.cy.x, invR.cy.y, invR.cy.z, 0.0f };
out.cz = {invR.cz.x, invR.cz.y, invR.cz.z, 0.0f };
out.cw = { -invRXT.x, -invRXT.y, -invRXT.z, 1.0f };
return out;
}
Matrix4 Camera::GetViewMatrix() const
{
Matrix4 v = GetWorldMatrix();
v = InvertOrtho(v);
return v;
}
// http://www.songho.ca/opengl/gl_projectionmatrix.html
// https://unspecified.wordpress.com/2012/06/21/calculating-the-gluperspective-matrix-and-other-opengl-matrix-maths/
// https://software.intel.com/en-us/articles/alternatives-to-using-z-bias-to-fix-z-fighting-issues
static Matrix4 Perspective( float fieldOfViewY, float aspectRatio, float nearPlane, float farPlane)
{
float cot = 1.0f / tanf( 0.5f * fieldOfViewY);
float depth = farPlane - nearPlane;
Matrix4 out;
out.cx = {cot / aspectRatio, 0.0f, 0.0f, 0.0f };
out.cy = { 0.0f, cot, 0.0f, 0.0f };
out.cz = { 0.0f, 0.0f, -(nearPlane + farPlane) / depth, -1.0f };
out.cw = { 0.0f, 0.0f, -2.0f * nearPlane * farPlane / depth, 0.0f };
return out;
}
Matrix4 Camera::GetProjectionMatrix() const
{
return Perspective( B3_DEG_TO_RAD * m_fovY, m_ratio, m_nearPlane, m_farPlane );
}
PickRay Camera::BuildPickRay( float x, float y) const
{
// Use similar triangles to build pick ray
// Scale, flip, shift into frustum coordinates
float xRatio = x / m_width - 0.5f;
float yRatio = 0.5f - y / m_height;
// Near plane coordinates using ratio
float xNear = xRatio * m_nearWidth;
float yNear = yRatio * m_nearHeight;
// Far plane coordinates using ratio
float xFar = xRatio * m_farWidth;
float yFar = yRatio * m_farHeight;
// Coordinates of near and far plane points in camera space
Vector4 nearPoint{xNear, yNear, -m_nearPlane, 1.0f };
Vector4 farPoint{xFar, yFar, -m_farPlane, 1.0f };
// Convert to world space
Matrix4 m = GetWorldMatrix();
nearPoint = MulMV(m, nearPoint);
farPoint = MulMV(m, farPoint);
PickRay ray;
ray.origin = {nearPoint.x, nearPoint.y, nearPoint.z };
ray.translation = b3Vec3{farPoint.x, farPoint.y, farPoint.z } - ray.origin;
return ray;
}
bool Camera::WorldToScreen( float& xScreen, float& yScreen, b3Vec3 worldPoint) const
{
Matrix4 view = GetViewMatrix();
Vector4 cameraPoint = MulMV(view, Vector4{ worldPoint.x, worldPoint.y, worldPoint.z, 1.0f });
float x = cameraPoint.x;
float y = cameraPoint.y;
float z = cameraPoint.z;
// Frustum comes out the back of the camera
if (z > -m_nearPlane || z < -m_farPlane )
{
return false;
}
// Find the frustum size at depth Z
float heightAtZ = -2.0f * z * m_tanY;
float widthAtZ = m_ratio * heightAtZ;
// Compute ratios of the point within the frustum rectangle at Z
float xRatio = x / widthAtZ;
float yRatio = y / heightAtZ;
// Shift, flip, and scale
xScreen = (xRatio + 0.5f ) * m_width;
yScreen = ( 0.5f - yRatio) * m_height;
return true;
}
void Camera::Update( GLFWwindow* window, float elapsedTime)
{
ImGuiIO& io = ImGui::GetIO();
if ( m_thirdPerson )
{
const float sensitivity = 1.0f;
m_radius -= sensitivity * io.MouseWheel;
m_radius = b3MaxFloat( 0.25f, m_radius );
return;
}
if (io.KeyAlt )
{
// Orbit
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Left ) )
{
const float sensitivity = 0.2f;
m_yaw -= sensitivity * io.MouseDelta.x;
m_pitch += sensitivity * io.MouseDelta.y;
m_pitch = b3ClampFloat( m_pitch, -85.0f, 85.0f );
}
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Middle ) )
{
const float sensitivity = 0.01f;
m_pivot -= sensitivity * io.MouseDelta.x * m_right;
m_pivot += sensitivity * io.MouseDelta.y * m_up;
}
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Right ) )
{
const float sensitivity = 0.02f;
m_radius -= sensitivity * io.MouseDelta.y;
m_radius = b3MaxFloat( 0.001f, m_radius );
}
const float sensitivity = 1.0f;
m_radius -= sensitivity * io.MouseWheel;
m_radius = b3MaxFloat( 0.001f, m_radius );
UpdateTransform();
}
else if ( ImGui::IsMouseDown( ImGuiMouseButton_Right ) )
{
m_speed += io.MouseWheel;
m_speed = b3ClampFloat( m_speed, 0.001f * 60.0f, 500.0f * 60.0f );
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Right ) )
{
const float sensitivity = 0.2f;
m_yaw -= sensitivity * io.MouseDelta.x;
m_pitch += sensitivity * io.MouseDelta.y;
m_pitch = b3ClampFloat( m_pitch, -85.0f, 85.0f );
float sinYaw = sinf( B3_DEG_TO_RAD * m_yaw ), cosYaw = cosf( B3_DEG_TO_RAD * m_yaw );
float sinPitch = sinf( B3_DEG_TO_RAD * m_pitch ), cosPitch = cosf( B3_DEG_TO_RAD * m_pitch );
m_forward = {sinYaw * cosPitch, sinPitch, cosYaw * cosPitch};
m_up = { 0.0f, 1.0f, 0.0f };
m_up = b3Normalize( m_up - b3Dot( m_forward, m_up ) * m_forward );
m_right = b3Normalize( b3Cross( m_up, m_forward ) );
}
// Smoother with GLFW
if ( glfwGetKey(window, GLFW_KEY_W ) )
{
m_position -= m_speed * elapsedTime * m_forward;
}
if ( glfwGetKey(window, GLFW_KEY_S ) )
{
m_position += m_speed * elapsedTime * m_forward;
}
if ( glfwGetKey(window, GLFW_KEY_A ) )
{
m_position -= m_speed * elapsedTime * m_right;
}
if ( glfwGetKey(window, GLFW_KEY_D ) )
{
m_position += m_speed * elapsedTime * m_right;
}
m_pivot = m_position - m_radius * m_forward;
}
}
void Camera::UpdateTransform()
{
m_yaw = B3_RAD_TO_DEG * b3UnwindAngle( B3_DEG_TO_RAD * m_yaw );
float sinYaw = sinf( B3_DEG_TO_RAD * m_yaw ), cosYaw = cosf( B3_DEG_TO_RAD * m_yaw );
float sinPitch = sinf( B3_DEG_TO_RAD * m_pitch ), cosPitch = cosf( B3_DEG_TO_RAD * m_pitch );
m_forward = {sinYaw * cosPitch, sinPitch, cosYaw * cosPitch};
m_up = { 0.0f, 1.0f, 0.0f };
m_up = b3Normalize( m_up - b3Dot( m_forward, m_up ) * m_forward );
m_right = b3Normalize( b3Cross( m_up, m_forward ) );
m_position = m_pivot + m_radius * m_forward;
}