Camera Types
Example 1:
Camera.h
#ifndef CAMERA_H
#define CAMERA_H
#include <glm/glm.hpp>
class Camera
{
public:
Camera(const glm::vec3& position);
virtual ~Camera();
glm::vec3 Position() const;
glm::vec3 Forward() const;
glm::vec3 Back() const;
glm::vec3 Left() const;
glm::vec3 Right() const;
glm::vec3 Up() const;
glm::vec3 Down() const;
float FieldOfView() const;
float ZNear() const;
float ZFar() const;
glm::mat4 View() const;
glm::mat4 Projection(float aspectratio) const;
void SetPosition(const glm::vec3& position);
void Move(const glm::vec3& direction);
void Pitch(float angle);
void Yaw(float angle);
void Roll(float angle);
void ZoomIn(float angle);
void ZoomOut(float angle);
void SetClippingPlanes(float znear, float zfar);
private:
glm::vec3 m_position{ 0, 2, 5 };
glm::vec3 m_forward{ 0, 0, -1 };
glm::vec3 m_up{ 0, 1, 0 };
float m_fieldofview{ glm::radians(45.0f) };
float m_znear{ 0.1f };
float m_zfar{ 100.0f };
};
#endif // CAMERA_H
Camera.cpp
#include "Camera.h"
#include <glm/gtx/transform.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/rotate_vector.hpp>
using namespace glm;
Camera::Camera(const glm::vec3& position)
: m_position(position)
{}
Camera::~Camera()
{}
vec3 Camera::Position() const
{
return m_position;
}
vec3 Camera::Forward() const
{
return m_forward;
}
vec3 Camera::Back() const
{
return -m_forward;
}
vec3 Camera::Left() const
{
return -glm::normalize(glm::cross(m_forward, m_up));
}
vec3 Camera::Right() const
{
return glm::normalize(glm::cross(m_forward, m_up));
}
vec3 Camera::Up() const
{
return m_up;
}
vec3 Camera::Down() const
{
return -m_up;
}
float Camera::FieldOfView() const
{
return m_fieldofview;
}
float Camera::ZNear() const
{
return m_znear;
}
float Camera::ZFar() const
{
return m_zfar;
}
mat4 Camera::View() const
{
return lookAt(m_position, m_position + m_forward, m_up);
}
mat4 Camera::Projection(float aspectratio) const
{
return perspective(m_fieldofview, aspectratio, m_znear, m_zfar);
}
void Camera::SetPosition(const glm::vec3& position)
{
m_position = position;
}
void Camera::Move(const glm::vec3& direction)
{
m_position += direction;
}
void Camera::Pitch(float angle)
{
vec3 right = Right();
m_forward = rotate(m_forward, angle, right);
m_up = rotate(m_up, angle, right);
}
void Camera::Yaw(float angle)
{
m_forward = rotate(m_forward, angle, m_up);
}
void Camera::Roll(float angle)
{
m_up = rotate(m_up, angle, m_forward);
}
void Camera::ZoomIn(float angle)
{
m_fieldofview -= angle;
if (m_fieldofview < radians(1.0f))
m_fieldofview = radians(1.0f);
}
void Camera::ZoomOut(float angle)
{
m_fieldofview += angle;
if (m_fieldofview > radians(90.0f))
m_fieldofview = radians(90.0f);
}
void Camera::SetClippingPlanes(float znear, float zfar)
{
if (znear > 0 && zfar && 0 && zfar > znear)
{
m_znear = znear;
m_zfar = zfar;
}
}
Example 2:
#ifndef CAMERA_H
#define CAMERA_H
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
class Camera
{
public:
Camera(const glm::vec3& position);
virtual ~Camera();
glm::vec3 Position() const;
glm::vec3 Forward() const;
glm::vec3 Back() const;
glm::vec3 Left() const;
glm::vec3 Right() const;
glm::vec3 Up() const;
glm::vec3 Down() const;
float FieldOfView() const;
float ZNear() const;
float ZFar() const;
glm::mat4 View() const;
glm::mat4 Projection(float aspectratio) const;
void SetPosition(const glm::vec3& position);
void Move(const glm::vec3& direction);
void Pitch(float angle);
void Yaw(float angle);
void Roll(float angle);
void ZoomIn(float angle);
void ZoomOut(float angle);
void SetClippingPlanes(float znear, float zfar);
private:
glm::vec3 m_position{ 0, 2, 5 };
glm::quat m_rotation{ 1, 0, 0, 0 };
float m_fieldofview{ glm::radians(45.0f) };
float m_znear{ 0.1f };
float m_zfar{ 100.0f };
};
#endif // CAMERA_H
#include "Camera.h"
#include <glm/gtx/transform.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/quaternion.hpp>
#define DEFAULT_FORWARD (vec3(0, 0, -1))
#define DEFAULT_UP (vec3(0, 1, 0))
#define DEFAULT_RIGHT (vec3(1, 0, 0))
using namespace glm;
Camera::Camera(const glm::vec3& position)
: m_position(position)
{}
Camera::~Camera()
{}
vec3 Camera::Position() const
{
return m_position;
}
vec3 Camera::Forward() const
{
return rotate(m_rotation, DEFAULT_FORWARD);
}
vec3 Camera::Back() const
{
return -rotate(m_rotation, DEFAULT_FORWARD);
}
vec3 Camera::Left() const
{
return -rotate(m_rotation, DEFAULT_RIGHT);
}
vec3 Camera::Right() const
{
return rotate(m_rotation, DEFAULT_RIGHT);
}
vec3 Camera::Up() const
{
return rotate(m_rotation, DEFAULT_UP);
}
vec3 Camera::Down() const
{
return -rotate(m_rotation, DEFAULT_UP);
}
float Camera::FieldOfView() const
{
return m_fieldofview;
}
float Camera::ZNear() const
{
return m_znear;
}
float Camera::ZFar() const
{
return m_zfar;
}
mat4 Camera::View() const
{
return lookAt(m_position, m_position + Forward(), Up());
}
mat4 Camera::Projection(float aspectratio) const
{
return perspective(m_fieldofview, aspectratio, m_znear, m_zfar);
}
void Camera::SetPosition(const glm::vec3& position)
{
m_position = position;
}
void Camera::Move(const glm::vec3& direction)
{
m_position += direction;
}
void Camera::Pitch(float angle)
{
m_rotation = rotate(m_rotation, angle, DEFAULT_RIGHT);
}
void Camera::Yaw(float angle)
{
m_rotation = rotate(m_rotation, angle, DEFAULT_UP);
}
void Camera::Roll(float angle)
{
m_rotation = rotate(m_rotation, angle, DEFAULT_FORWARD);
}
void Camera::ZoomIn(float angle)
{
m_fieldofview -= angle;
if (m_fieldofview < radians(1.0f))
m_fieldofview = radians(1.0f);
}
void Camera::ZoomOut(float angle)
{
m_fieldofview += angle;
if (m_fieldofview > radians(90.0f))
m_fieldofview = radians(90.0f);
}
void Camera::SetClippingPlanes(float znear, float zfar)
{
if (znear > 0 && zfar > znear)
{
m_znear = znear;
m_zfar = zfar;
}
}
Example 3: Turret Camera
Camera.h
#ifndef CAMERA_H
#define CAMERA_H
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
class Camera
{
public:
Camera(const glm::vec3& position);
virtual ~Camera();
glm::vec3 Position() const;
glm::vec3 Forward() const;
glm::vec3 Back() const;
glm::vec3 Left() const;
glm::vec3 Right() const;
glm::vec3 Up() const;
glm::vec3 Down() const;
float FieldOfView() const;
float ZNear() const;
float ZFar() const;
glm::mat4 View() const;
glm::mat4 Projection(float aspectratio) const;
void SetPosition(const glm::vec3& position);
void Move(const glm::vec3& direction);
void Pitch(float angle);
void RotateY(float angle);
void ZoomIn(float angle);
void ZoomOut(float angle);
void SetClippingPlanes(float znear, float zfar);
private:
glm::vec3 m_position{ 0, 2, 5 };
float m_pitch{ 0.0f };
float m_yrotation{ 0.0f };
float m_fieldofview{ glm::radians(45.0f) };
float m_znear{ 0.1f };
float m_zfar{ 100.0f };
};
#endif // CAMERA_H
Camera.cpp
#include "Camera.h"
#include <glm/gtx/transform.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/quaternion.hpp>
#define PITCHMIN (radians(-89.0f))
#define PITCHMAX (radians(+89.0f))
using namespace glm;
Camera::Camera(const glm::vec3& position)
: m_position(position)
{}
Camera::~Camera()
{}
vec3 Camera::Position() const
{
return m_position;
}
vec3 Camera::Forward() const
{
float x = cos(m_yrotation) * cos(m_pitch);
float y = sin(m_pitch);
float z = sin(m_yrotation) * cos(m_pitch);
return vec3(x, y, z);
}
vec3 Camera::Back() const
{
return -Forward();
}
vec3 Camera::Left() const
{
return -Right();
}
vec3 Camera::Right() const
{
return normalize(cross(Forward(), vec3(0, 1, 0)));
}
vec3 Camera::Up() const
{
return normalize(cross(Right(), Forward()));
}
vec3 Camera::Down() const
{
return -Up();
}
float Camera::FieldOfView() const
{
return m_fieldofview;
}
float Camera::ZNear() const
{
return m_znear;
}
float Camera::ZFar() const
{
return m_zfar;
}
mat4 Camera::View() const
{
return lookAt(m_position, m_position + Forward(), Up());
}
mat4 Camera::Projection(float aspectratio) const
{
return perspective(m_fieldofview, aspectratio, m_znear, m_zfar);
}
void Camera::SetPosition(const glm::vec3& position)
{
m_position = position;
}
void Camera::Move(const glm::vec3& direction)
{
m_position += direction;
}
void Camera::Pitch(float angle)
{
m_pitch += angle;
if (m_pitch < PITCHMIN)
m_pitch = PITCHMIN;
if (m_pitch > PITCHMAX)
m_pitch = PITCHMAX;
}
void Camera::RotateY(float angle)
{
m_yrotation += angle;
}
void Camera::ZoomIn(float angle)
{
m_fieldofview -= angle;
if (m_fieldofview < radians(1.0f))
m_fieldofview = radians(1.0f);
}
void Camera::ZoomOut(float angle)
{
m_fieldofview += angle;
if (m_fieldofview > radians(90.0f))
m_fieldofview = radians(90.0f);
}
void Camera::SetClippingPlanes(float znear, float zfar)
{
if (znear > 0 && zfar > znear)
{
m_znear = znear;
m_zfar = zfar;
}
}