Vesper::EditorCamera Class Reference

#include <EditorCamera.h>

Inheritance diagram for Vesper::EditorCamera:

Public Member Functions
	EditorCamera ()
	EditorCamera (float fov, float aspectRation, float nearClip, float farClip)
void	OnUpdate (Timestep ts)
void	OnEvent (Event &e)
float	GetDistance () const
void	SetDistance (float distance)
void	SetViewportSize (float width, float height)
const glm::mat4 &	GetViewMatrix () const
const glm::mat4 &	GetViewProjection () const
glm::vec3	GetUpDirection () const
glm::vec3	GetRightDirection () const
glm::vec3	GetForwardDirection () const
glm::quat	GetOrientation () const
const glm::vec3 &	GetPosition () const
void	SetPosition (const glm::vec3 &position)
float	GetPitch () const
void	SetPitch (float pitch)
float	GetYaw () const
void	SetYaw (float yaw)
Public Member Functions inherited from Vesper::Camera
	Camera ()=default
	Camera (const glm::mat4 &projection)
	~Camera ()=default
const glm::mat4 &	GetProjection () const

Private Member Functions
void	UpdateProjection ()
void	UpdateView ()
bool	OnMouseScroll (MouseScrolledEvent &e)
void	MousePan (const glm::vec2 &delta)
void	MouseRotate (const glm::vec2 &delta)
void	MouseZoom (float delta)
glm::vec3	CalculatePosition () const
std::pair< float, float >	PanSpeed () const
float	RotationSpeed () const
float	ZoomSpeed () const

Private Attributes
float	m_FOV = 45.0f
float	m_AspectRatio = 1.778f
float	m_NearClip = 0.1f
float	m_FarClip = 1000.0f
glm::mat4	m_ViewMatrix
glm::vec3	m_Position = { 0.0f, 0.0f, 0.0f }
glm::vec3	m_FocalPoint = glm::vec3(1.0f)
glm::vec2	m_InitialMousePosition = { 0.0f, 0.0f }
float	m_Distance = 10.0f
float	m_Pitch = 0.0f
float	m_Yaw = 0.0f
float	m_ViewportWidth = 1280
float	m_ViewportHeight = 720

Additional Inherited Members
Protected Attributes inherited from Vesper::Camera
glm::mat4	m_Projection = glm::mat4(1.0f)

Constructor & Destructor Documentation

EditorCamera() [1/2]

Vesper::EditorCamera::EditorCamera

(

)

    {
    }

EditorCamera() [2/2]

Vesper::EditorCamera::EditorCamera	(	float	fov,
		float	aspectRation,
		float	nearClip,
		float	farClip )

        : m_FOV(fov), m_AspectRatio(aspectRatio), m_NearClip(nearClip), m_FarClip(farClip), Camera(glm::perspective(glm::radians(fov), aspectRatio, nearClip, farClip))
    {
        UpdateView();
    }

References EditorCamera(), m_AspectRatio, m_FarClip, m_FOV, m_NearClip, and UpdateView().

Referenced by EditorCamera().

Member Function Documentation

CalculatePosition()

glm::vec3 Vesper::EditorCamera::CalculatePosition ( ) const

private

    {
        return m_FocalPoint - GetForwardDirection() * m_Distance;
    }

GetDistance()

float Vesper::EditorCamera::GetDistance ( ) const

inline

{ return m_Distance; }

References m_Distance.

GetForwardDirection()

glm::vec3 Vesper::EditorCamera::GetForwardDirection

(

)

const

                                                    {
        return glm::rotate(GetOrientation(), glm::vec3(0.0f, 0.0f, -1.0f));
    }

GetOrientation()

glm::quat Vesper::EditorCamera::GetOrientation

(

)

const

                                               {
        return glm::quat(glm::vec3(-m_Pitch, -m_Yaw, 0.0f));
    }

GetPitch()

float Vesper::EditorCamera::GetPitch ( ) const

inline

{ return m_Pitch; }

References m_Pitch.

GetPosition()

const glm::vec3 & Vesper::EditorCamera::GetPosition ( ) const

inline

{ return m_Position; }

GetRightDirection()

glm::vec3 Vesper::EditorCamera::GetRightDirection

(

)

const

                                                  {
        return glm::rotate(GetOrientation(), glm::vec3(1.0f, 0.0f, 0.0f));
    }

GetUpDirection()

glm::vec3 Vesper::EditorCamera::GetUpDirection

(

)

const

                                               {
 
        return glm::rotate(GetOrientation(), glm::vec3(0.0f, 1.0f, 0.0f));
    }

GetViewMatrix()

const glm::mat4 & Vesper::EditorCamera::GetViewMatrix ( ) const

inline

{ return m_ViewMatrix; }

GetViewProjection()

const glm::mat4 & Vesper::EditorCamera::GetViewProjection ( ) const

inline

{ return m_Projection * m_ViewMatrix; }

GetYaw()

float Vesper::EditorCamera::GetYaw ( ) const

inline

{ return m_Yaw; }

References m_Yaw.

MousePan()

void Vesper::EditorCamera::MousePan ( const glm::vec2 & delta )

private

    {
        auto [xSpeed, ySpeed] = PanSpeed();
        m_FocalPoint += -GetRightDirection() * delta.x * xSpeed * m_Distance;
        m_FocalPoint += GetUpDirection() * delta.y * ySpeed * m_Distance;
    }

MouseRotate()

void Vesper::EditorCamera::MouseRotate ( const glm::vec2 & delta )

private

    {
        float yawSign = GetUpDirection().y < 0 ? -1.0f : 1.0f;
        m_Yaw += yawSign * delta.x * RotationSpeed();
        m_Pitch += delta.y * RotationSpeed();
    }

References m_Pitch, m_Yaw, and RotationSpeed().

MouseZoom()

void Vesper::EditorCamera::MouseZoom ( float delta )

private

    {
        m_Distance -= delta * ZoomSpeed();
        if (m_Distance < 1.0f)
        {
            m_FocalPoint += GetForwardDirection();
            m_Distance = 1.0f;
        }
    }

References m_Distance, and ZoomSpeed().

Referenced by OnMouseScroll(), and OnUpdate().

OnEvent()

void Vesper::EditorCamera::OnEvent

(

Event &

e

)

    {
        EventDispatcher dispatcher(e);
        dispatcher.Dispatch<MouseScrolledEvent>(VZ_BIND_EVENT_FN(EditorCamera::OnMouseScroll));
    }

References Vesper::EventDispatcher::EventDispatcher(), and OnMouseScroll().

OnMouseScroll()

bool Vesper::EditorCamera::OnMouseScroll ( MouseScrolledEvent & e )

private

    {
        float delta = e.GetYOffset() * 0.1f;
        MouseZoom(delta);
        UpdateView();
        return false;
    }

References Vesper::MouseScrolledEvent::GetYOffset(), MouseZoom(), and UpdateView().

Referenced by OnEvent().

OnUpdate()

void Vesper::EditorCamera::OnUpdate

(

Timestep

ts

)

    {
        if (Input::IsKeyPressed(Key::LeftAlt))
        {
            const glm::vec2& mouse{ Input::GetMouseX(), Input::GetMouseY() };
            glm::vec2 delta = (mouse - m_InitialMousePosition) * 0.003f;
            m_InitialMousePosition = mouse;
 
            if (Input::IsMouseButtonPressed(Mouse::ButtonMiddle))
                MousePan(delta);
            else if (Input::IsMouseButtonPressed(Mouse::ButtonLeft))
                MouseRotate(delta);
            else if (Input::IsMouseButtonPressed(Mouse::ButtonRight))
                MouseZoom(-delta.y);
        }
 
        UpdateView();
    }

References Vesper::Mouse::ButtonLeft, Vesper::Mouse::ButtonMiddle, Vesper::Mouse::ButtonRight, Vesper::Input::IsKeyPressed(), Vesper::Input::IsMouseButtonPressed(), Vesper::Key::LeftAlt, MouseZoom(), and UpdateView().

PanSpeed()

std::pair< float, float > Vesper::EditorCamera::PanSpeed ( ) const

private

    {
        float x = std::min(m_ViewportWidth / 1000.0f, 2.4f); // max = 2.4f
        float xFactor = 0.0366f * (x * x) - 0.1778f * x + 0.3021f;
 
        float y = std::min(m_ViewportHeight / 1000.0f, 2.4f); // max = 2.4f
        float yFactor = 0.0366f * (y * y) - 0.1778f * y + 0.3021f;
 
        return { xFactor, yFactor };
    }

RotationSpeed()

float Vesper::EditorCamera::RotationSpeed ( ) const

private

    {
        return 0.8f;
    }

Referenced by MouseRotate().

SetDistance()

void Vesper::EditorCamera::SetDistance ( float distance )

inline

{ m_Distance = distance; }

References m_Distance.

SetPitch()

void Vesper::EditorCamera::SetPitch ( float pitch )

inline

{ m_Pitch = pitch; }

References m_Pitch.

SetPosition()

void Vesper::EditorCamera::SetPosition

(

const glm::vec3 &

position

)

SetViewportSize()

void Vesper::EditorCamera::SetViewportSize ( float width, float height )

inline

{ m_ViewportWidth = width, m_ViewportHeight = height; UpdateProjection(); }

References m_ViewportHeight, m_ViewportWidth, and UpdateProjection().

SetYaw()

void Vesper::EditorCamera::SetYaw ( float yaw )

inline

{ m_Yaw = yaw; }

References m_Yaw.

UpdateProjection()

void Vesper::EditorCamera::UpdateProjection ( )

private

    {
        m_AspectRatio = m_ViewportWidth / m_ViewportHeight;
        m_Projection = glm::perspective(glm::radians(m_FOV), m_AspectRatio, m_NearClip, m_FarClip);
    }

References m_AspectRatio, m_ViewportHeight, and m_ViewportWidth.

Referenced by SetViewportSize().

UpdateView()

void Vesper::EditorCamera::UpdateView ( )

private

    {
        //m_Yaw = m_Pitch = 0.0f; // Lock the camera's rotation
        m_Position = CalculatePosition();
 
        glm::quat orientation = GetOrientation();
        m_ViewMatrix = glm::translate(glm::mat4(1.0f), m_Position) * glm::toMat4(orientation);
        m_ViewMatrix = glm::inverse(m_ViewMatrix);
    }

Referenced by EditorCamera(), OnMouseScroll(), and OnUpdate().

ZoomSpeed()

float Vesper::EditorCamera::ZoomSpeed ( ) const

private

    {
        float distance = m_Distance * 0.2f;
        distance = std::max(distance, 0.0f);
        float speed = distance * distance;
        speed = std::min(speed, 100.0f); // max speed = 100
        return speed;
    }

References m_Distance.

Referenced by MouseZoom().

Member Data Documentation

m_AspectRatio

float Vesper::EditorCamera::m_AspectRatio = 1.778f

private

Referenced by EditorCamera(), and UpdateProjection().

m_Distance

float Vesper::EditorCamera::m_Distance = 10.0f

private

Referenced by GetDistance(), MouseZoom(), SetDistance(), and ZoomSpeed().

m_FarClip

float Vesper::EditorCamera::m_FarClip = 1000.0f

private

Referenced by EditorCamera().

m_FocalPoint

glm::vec3 Vesper::EditorCamera::m_FocalPoint = glm::vec3(1.0f)

private

m_FOV

float Vesper::EditorCamera::m_FOV = 45.0f

private

Referenced by EditorCamera().

m_InitialMousePosition

glm::vec2 Vesper::EditorCamera::m_InitialMousePosition = { 0.0f, 0.0f }

private

{ 0.0f, 0.0f };

m_NearClip

float Vesper::EditorCamera::m_NearClip = 0.1f

private

Referenced by EditorCamera().

m_Pitch

float Vesper::EditorCamera::m_Pitch = 0.0f

private

Referenced by GetPitch(), MouseRotate(), and SetPitch().

m_Position

glm::vec3 Vesper::EditorCamera::m_Position = { 0.0f, 0.0f, 0.0f }

private

{ 0.0f, 0.0f, 0.0f };

m_ViewMatrix

glm::mat4 Vesper::EditorCamera::m_ViewMatrix

private

m_ViewportHeight

float Vesper::EditorCamera::m_ViewportHeight = 720

private

Referenced by SetViewportSize(), and UpdateProjection().

m_ViewportWidth

float Vesper::EditorCamera::m_ViewportWidth = 1280

private

Referenced by SetViewportSize(), and UpdateProjection().

m_Yaw

float Vesper::EditorCamera::m_Yaw = 0.0f

private

Referenced by GetYaw(), MouseRotate(), and SetYaw().

---

The documentation for this class was generated from the following files:

• Vesper/src/Vesper/Renderer/EditorCamera.h
• Vesper/src/Vesper/Renderer/EditorCamera.cpp