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;

}

}