436 lines
11 KiB
C++
436 lines
11 KiB
C++
/*
|
||
* Basic camera class
|
||
*
|
||
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
|
||
*
|
||
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
||
*/
|
||
|
||
#define GLM_FORCE_RADIANS
|
||
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||
//#define GLM_FORCE_LEFT_HANDED
|
||
|
||
#include <glm/glm.hpp>
|
||
#include <glm/gtc/quaternion.hpp>
|
||
#include <glm/gtc/matrix_transform.hpp>
|
||
|
||
class Camera
|
||
{
|
||
private:
|
||
float fov;
|
||
float znear, zfar;
|
||
|
||
void updateViewMatrix()
|
||
{
|
||
glm::mat4 rotM =rotationMatrix;
|
||
|
||
glm::mat4 transM;
|
||
/*
|
||
rotM = glm::rotate(rotM, glm::radians(rotation.x * (flipY ? -1.0f : 1.0f)), glm::vec3(1.0f, 0.0f, 0.0f));
|
||
rotM = glm::rotate(rotM, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
|
||
rotM = glm::rotate(rotM, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
|
||
*/
|
||
glm::vec3 translation = position;
|
||
|
||
if (flipY) {
|
||
translation.y *= -1.0f;
|
||
}
|
||
transM = glm::translate(glm::mat4(1.0f), translation);
|
||
|
||
if (type == CameraType::firstperson)
|
||
{
|
||
matrices.view = rotM * transM;
|
||
}
|
||
else
|
||
{
|
||
//matrices.view = lookAt(position, lookAtPoint);
|
||
//matrices.view = transM * rotM ;
|
||
// matrices.view = transM * glm::inverse(glm::transpose(rotationMatrix));//LookAt(position, to, up, false, true);//transM * glm::transpose(glm::inverse(rotationMatrix));
|
||
matrices.view = LookAt(position, lookAtPoint, up, false, true);
|
||
}
|
||
|
||
viewPos = glm::vec4(position, 0.0f) * glm::vec4(-1.0f, 1.0f, -1.0f, 1.0f);
|
||
|
||
updated = true;
|
||
};
|
||
public:
|
||
enum CameraType { lookat, firstperson };
|
||
CameraType type = CameraType::lookat;
|
||
|
||
glm::vec3 rotation = glm::vec3();
|
||
glm::vec3 position = glm::vec3();
|
||
glm::vec4 viewPos = glm::vec4();
|
||
glm::vec3 lookAtPoint = glm::vec3();
|
||
glm::vec3 up = glm::vec3();
|
||
glm::mat4 rotationMatrix = glm::mat4();
|
||
|
||
float rotationSpeed = 1.0f;
|
||
float movementSpeed = 1.0f;
|
||
|
||
|
||
bool updated = false;
|
||
bool flipY = false;
|
||
|
||
struct
|
||
{
|
||
glm::mat4 perspective;
|
||
glm::mat4 view;
|
||
} matrices;
|
||
|
||
struct
|
||
{
|
||
bool left = false;
|
||
bool right = false;
|
||
bool up = false;
|
||
bool down = false;
|
||
} keys;
|
||
|
||
bool moving()
|
||
{
|
||
return keys.left || keys.right || keys.up || keys.down;
|
||
}
|
||
|
||
float getNearClip() {
|
||
return znear;
|
||
}
|
||
|
||
float getFarClip() {
|
||
return zfar;
|
||
}
|
||
|
||
void setLookAtPoint(glm::vec3 lookAtPoint)
|
||
{
|
||
this->lookAtPoint = lookAtPoint;
|
||
}
|
||
|
||
void setUp(glm::vec3 up)
|
||
{
|
||
this->up = up;
|
||
}
|
||
/*
|
||
<09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>
|
||
https://zhuanlan.zhihu.com/p/635801612
|
||
*/
|
||
|
||
glm::mat4 GetProjectionMatrixFromClip(float zleft, float zright, float zbottom, float ztop, float znear, float zfar, bool zPositive)
|
||
{
|
||
if (zPositive)
|
||
{
|
||
float A = -(zfar + znear) / (znear - zfar);
|
||
float B = 2 * (zfar * znear) / (znear - zfar);
|
||
glm::mat4 T = glm::mat4(
|
||
2 * znear / (zright - zleft), 0, -(zright + zleft) / (zright - zleft), 0,
|
||
0, 2 * znear / (ztop - zbottom), -(ztop + zbottom) / (ztop - zbottom), 0,
|
||
0, 0, A, B,
|
||
0, 0, 1, 0);
|
||
T = glm::transpose(T); // let's transpose it back to column major
|
||
return T;
|
||
}
|
||
else
|
||
{
|
||
float A = (zfar + znear) / (znear - zfar);
|
||
float B = 2 * (zfar * znear) / (znear - zfar);
|
||
glm::mat4 T = glm::mat4(
|
||
2 * znear / (zright - zleft), 0, (zright + zleft) / (zright - zleft), 0,
|
||
0, 2 * znear / (ztop - zbottom), (ztop + zbottom) / (ztop - zbottom), 0,
|
||
0, 0, A, B,
|
||
0, 0, -1, 0);
|
||
T = glm::transpose(T); // let's transpose it back to column major
|
||
return T;
|
||
}
|
||
}
|
||
|
||
void setProjectionMatrix(float fx, float fy, float u0, float v0, float znear, float zfar, float viewWidth, float viewHeight, bool zPositive, bool rightHand)
|
||
{
|
||
float l = -u0 / fx * znear;
|
||
float r = (viewWidth - u0) / fx * znear;
|
||
float t = -v0 / fy * znear;
|
||
float b = (viewHeight - v0) / fy * znear;
|
||
glm::mat4 perspective = glm::mat4();
|
||
if (rightHand)
|
||
{
|
||
if (zPositive)
|
||
{ // right hand system and z positive, usually used in 3d reconstruction/SFM/SLAM
|
||
perspective = GetProjectionMatrixFromClip(l, r, b, t, znear, zfar, zPositive);
|
||
}
|
||
else
|
||
{ // right hand system, z negative, usually used in OpenGL
|
||
perspective = GetProjectionMatrixFromClip(l, r, -b, -t, znear, zfar, zPositive);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (zPositive)
|
||
{ // left hand system, z positive
|
||
perspective = GetProjectionMatrixFromClip(l, r, -b, -t, znear, zfar, zPositive);
|
||
}
|
||
else
|
||
{ // left hand system, z negative
|
||
perspective = GetProjectionMatrixFromClip(l, r, b, t, znear, zfar, zPositive);
|
||
}
|
||
}
|
||
matrices.perspective = perspective;
|
||
}
|
||
|
||
glm::mat4 LookAt(const glm::vec3& from, const glm::vec3& to, const glm::vec3& up, bool zPositive, bool rightHand)
|
||
{
|
||
//this->position = from;
|
||
//this->lookAtPoint = to;
|
||
//this->up = up;
|
||
// we stands on "from" and look at "to"
|
||
// if zPositive = true, the destination is in the area of the positive half-axis of z, otherwise it is negative
|
||
// if rightHand = true, the coordinate system is right-handed, otherwise it is left-handed
|
||
glm::vec3 zAxis = glm::normalize(to - from);
|
||
glm::vec3 yAxis = glm::normalize(up);
|
||
glm::vec3 xAxis;
|
||
|
||
if (rightHand)
|
||
{
|
||
if (zPositive)
|
||
{ // rightHand = true and zPositive = true, usually used in 3d reconstruction
|
||
yAxis = -yAxis;
|
||
|
||
}
|
||
else
|
||
{ // rightHand = true and zPositive = false, usually used in OpenGL
|
||
zAxis = -zAxis;
|
||
|
||
}
|
||
}
|
||
else
|
||
{ // left-hand
|
||
if (!zPositive)
|
||
{
|
||
zAxis = -zAxis;
|
||
yAxis = -yAxis;
|
||
}
|
||
}
|
||
|
||
xAxis = glm::normalize(glm::cross(yAxis, zAxis));
|
||
yAxis = glm::normalize(glm::cross(zAxis, xAxis));
|
||
|
||
// glm matrix is column major, so if you set like this, you will notice that the matrix is transposed when you use it.
|
||
glm::mat3 R = glm::mat3(
|
||
xAxis.x, xAxis.y, xAxis.z,
|
||
yAxis.x, yAxis.y, yAxis.z,
|
||
zAxis.x, zAxis.y, zAxis.z
|
||
);
|
||
//R = rotationMatrix;
|
||
R = glm::transpose(R); // Let's transpose it back
|
||
//R = glm::inverse(R);
|
||
|
||
glm::vec3 t = -R * from; // t = -R * from;
|
||
|
||
//R = glm::transpose(R);
|
||
|
||
glm::mat4 m = glm::mat4(
|
||
xAxis.x, xAxis.y, xAxis.z, t.x,
|
||
yAxis.x, yAxis.y, yAxis.z, t.y,
|
||
zAxis.x, zAxis.y, zAxis.z, t.z,
|
||
0, 0, 0, 1);
|
||
/**/
|
||
/*
|
||
//R = glm::transpose(R);
|
||
glm::mat4 m = glm::mat4(
|
||
R[0][0], R[0][1],R[0][2], t.x,
|
||
R[1][0], R[1][1],R[1][2], t.y,
|
||
R[2][0], R[2][1],R[2][2], t.z,
|
||
0, 0, 0, 1);
|
||
|
||
glm::mat4 m = glm::mat4(
|
||
1, 0, 0,0 ,
|
||
0, 1, 0,0 ,
|
||
0, 0, 1, 0,
|
||
0, 0, 0, 1);
|
||
*/
|
||
m = glm::transpose(m); // Let's transpose it back
|
||
//m = glm::inverse(m);
|
||
return m;
|
||
}
|
||
|
||
|
||
glm::mat4 lookAt(glm::vec3 position, glm::vec3 lookAtPoint)
|
||
{
|
||
glm::vec3 translate = position - this->position;
|
||
glm::vec3 forward = glm::normalize(lookAtPoint - position);
|
||
glm::vec3 right = glm::normalize(glm::cross(glm::vec3(0, 1, 0), forward));
|
||
glm::vec3 up = glm::cross(forward, right);
|
||
glm::mat4 rotationMatrix = glm::mat4(glm::vec4(right, 0.0f),
|
||
glm::vec4(up, 0.0f),
|
||
glm::vec4(-forward, 0.0f),
|
||
glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
|
||
glm::mat4 viewMatrix = glm::translate(rotationMatrix, translate);
|
||
this->position = position;
|
||
return viewMatrix;
|
||
}
|
||
|
||
/*
|
||
GDC2007<30><37><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Koshy George
|
||
*/
|
||
void setPerspective(float fx, float fy, float cx, float cy, float znear, float zfar)
|
||
{
|
||
this->znear = znear;
|
||
this->zfar = zfar;
|
||
float A = -(zfar + znear) / (znear - zfar);
|
||
float B = -2 * (zfar * znear) / (znear - zfar);
|
||
glm::mat4 persepctive = glm::mat4(glm::vec4(fx / cx, 0, 0, 0),
|
||
glm::vec4(0, fy / cy, 0, 0),
|
||
glm::vec4(0, 0, A, B),
|
||
glm::vec4(0, 0, -1, 0));
|
||
matrices.perspective = persepctive;
|
||
|
||
}
|
||
|
||
|
||
void setPerspective(float fov, float aspect, float znear, float zfar)
|
||
{
|
||
this->fov = fov;
|
||
this->znear = znear;
|
||
this->zfar = zfar;
|
||
matrices.perspective = glm::perspective(glm::radians(fov), aspect, znear, zfar);
|
||
if (flipY) {
|
||
matrices.perspective[1][1] *= -1.0f;
|
||
}
|
||
};
|
||
|
||
void updateAspectRatio(float aspect)
|
||
{
|
||
matrices.perspective = glm::perspective(glm::radians(fov), aspect, znear, zfar);
|
||
if (flipY) {
|
||
matrices.perspective[1][1] *= -1.0f;
|
||
}
|
||
}
|
||
|
||
void setPosition(glm::vec3 position)
|
||
{
|
||
this->position = position;
|
||
updateViewMatrix();
|
||
}
|
||
|
||
void setRotation(glm::mat3 rotaionMatrix)
|
||
{
|
||
this->rotationMatrix = rotaionMatrix;
|
||
updateViewMatrix();
|
||
}
|
||
|
||
void rotate(glm::vec3 delta)
|
||
{
|
||
this->rotation += delta;
|
||
updateViewMatrix();
|
||
}
|
||
|
||
void setTranslation(glm::vec3 translation)
|
||
{
|
||
this->position = translation;
|
||
updateViewMatrix();
|
||
};
|
||
|
||
void translate(glm::vec3 delta)
|
||
{
|
||
this->position += delta;
|
||
updateViewMatrix();
|
||
}
|
||
|
||
void setRotationSpeed(float rotationSpeed)
|
||
{
|
||
this->rotationSpeed = rotationSpeed;
|
||
}
|
||
|
||
void setMovementSpeed(float movementSpeed)
|
||
{
|
||
this->movementSpeed = movementSpeed;
|
||
}
|
||
|
||
void update(float deltaTime)
|
||
{
|
||
updated = false;
|
||
if (type == CameraType::firstperson)
|
||
{
|
||
if (moving())
|
||
{
|
||
glm::vec3 camFront;
|
||
camFront.x = -cos(glm::radians(rotation.x)) * sin(glm::radians(rotation.y));
|
||
camFront.y = sin(glm::radians(rotation.x));
|
||
camFront.z = cos(glm::radians(rotation.x)) * cos(glm::radians(rotation.y));
|
||
camFront = glm::normalize(camFront);
|
||
|
||
float moveSpeed = deltaTime * movementSpeed;
|
||
|
||
if (keys.up)
|
||
position += camFront * moveSpeed;
|
||
if (keys.down)
|
||
position -= camFront * moveSpeed;
|
||
if (keys.left)
|
||
position -= glm::normalize(glm::cross(camFront, glm::vec3(0.0f, 1.0f, 0.0f))) * moveSpeed;
|
||
if (keys.right)
|
||
position += glm::normalize(glm::cross(camFront, glm::vec3(0.0f, 1.0f, 0.0f))) * moveSpeed;
|
||
}
|
||
}
|
||
updateViewMatrix();
|
||
};
|
||
|
||
// Update camera passing separate axis data (gamepad)
|
||
// Returns true if view or position has been changed
|
||
bool updatePad(glm::vec2 axisLeft, glm::vec2 axisRight, float deltaTime)
|
||
{
|
||
bool retVal = false;
|
||
|
||
if (type == CameraType::firstperson)
|
||
{
|
||
// Use the common console thumbstick layout
|
||
// Left = view, right = move
|
||
|
||
const float deadZone = 0.0015f;
|
||
const float range = 1.0f - deadZone;
|
||
|
||
glm::vec3 camFront;
|
||
camFront.x = -cos(glm::radians(rotation.x)) * sin(glm::radians(rotation.y));
|
||
camFront.y = sin(glm::radians(rotation.x));
|
||
camFront.z = cos(glm::radians(rotation.x)) * cos(glm::radians(rotation.y));
|
||
camFront = glm::normalize(camFront);
|
||
|
||
float moveSpeed = deltaTime * movementSpeed * 2.0f;
|
||
float rotSpeed = deltaTime * rotationSpeed * 50.0f;
|
||
|
||
// Move
|
||
if (fabsf(axisLeft.y) > deadZone)
|
||
{
|
||
float pos = (fabsf(axisLeft.y) - deadZone) / range;
|
||
position -= camFront * pos * ((axisLeft.y < 0.0f) ? -1.0f : 1.0f) * moveSpeed;
|
||
retVal = true;
|
||
}
|
||
if (fabsf(axisLeft.x) > deadZone)
|
||
{
|
||
float pos = (fabsf(axisLeft.x) - deadZone) / range;
|
||
position += glm::normalize(glm::cross(camFront, glm::vec3(0.0f, 1.0f, 0.0f))) * pos * ((axisLeft.x < 0.0f) ? -1.0f : 1.0f) * moveSpeed;
|
||
retVal = true;
|
||
}
|
||
|
||
// Rotate
|
||
if (fabsf(axisRight.x) > deadZone)
|
||
{
|
||
float pos = (fabsf(axisRight.x) - deadZone) / range;
|
||
rotation.y += pos * ((axisRight.x < 0.0f) ? -1.0f : 1.0f) * rotSpeed;
|
||
retVal = true;
|
||
}
|
||
if (fabsf(axisRight.y) > deadZone)
|
||
{
|
||
float pos = (fabsf(axisRight.y) - deadZone) / range;
|
||
rotation.x -= pos * ((axisRight.y < 0.0f) ? -1.0f : 1.0f) * rotSpeed;
|
||
retVal = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// todo: move code from example base class for look-at
|
||
}
|
||
|
||
if (retVal)
|
||
{
|
||
updateViewMatrix();
|
||
}
|
||
|
||
return retVal;
|
||
}
|
||
|
||
}; |