summaryrefslogtreecommitdiff
path: root/gfx/gl/camera.cpp
blob: 15f76c4add9e46c0488d26d5368e581a95831ee0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "camera.h"
#include <collections.h>
#include <glm/gtx/intersect.hpp> // IWYU pragma: keep
#include <glm/gtx/transform.hpp> // IWYU pragma: keep
#include <math.h>
#include <maths.h>
#include <ray.h>

Camera::Camera(Position3D pos, Angle fov, Angle aspect, Distance zNear, Distance zFar) :
	position {pos}, forward {::north}, up {::up}, near {zNear}, far {zFar},
	projection {glm::perspective(fov, aspect, zNear, zFar)}, viewProjection {}, inverseViewProjection {}
{
	updateView();
}

Ray
Camera::unProject(const ScreenRelCoord & mouse) const
{
	static constexpr const glm::vec4 screen {0, 0, 1, 1};
	const auto mouseProjection = glm::lookAt(::origin, forward, up);
	return {position, glm::normalize(glm::unProject(mouse ^ 1, mouseProjection, projection, screen))};
}

void
Camera::updateView()
{
	viewProjection = projection * glm::lookAt(origin, forward, up);
	inverseViewProjection = glm::inverse(projection * glm::lookAt(position, position + forward, up));
}

Direction3D
Camera::upFromForward(const Direction3D & forward)
{
	const auto right = glm::cross(forward, ::down);
	return glm::cross(forward, right);
}

std::array<glm::vec4, 4>
Camera::extentsAtDist(const float dist) const
{
	const auto clampToSeaFloor = [this, dist](const Position3D & target) {
		if (target.z < -1.5F) {
			const auto vec = glm::normalize(target - position);
			constexpr Position3D seafloor {0, 0, -1.5F};
			float outdist {};
			if (glm::intersectRayPlane(position, vec, seafloor, ::up, outdist)) {
				return (vec * outdist + position) ^ outdist;
			}
		}
		return target ^ dist;
	};
	const auto depth = -(2.F * (dist - near) * far) / (dist * (near - far)) - 1.F;
	static constexpr const std::array extents {-1.F, 1.F};
	static constexpr const auto cartesianExtents = extents * extents;
	return cartesianExtents * [&depth, this, &clampToSeaFloor](const auto & extent) {
		const glm::vec4 in {extent.first, extent.second, depth, 1.F};
		return clampToSeaFloor(perspective_divide(inverseViewProjection * in));
	};
}