Muto::EditorCamera Class Reference

#include <EditorCamera.h>

Inheritance diagram for Muto::EditorCamera:

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

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

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

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

Constructor & Destructor Documentation

EditorCamera() [1/2]

Muto::EditorCamera::EditorCamera

(

)

    {
    }

EditorCamera() [2/2]

Muto::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 Muto::EditorCamera::CalculatePosition ( ) const

private

    {
        return m_FocalPoint - GetForwardDirection() * m_Distance;
    }

GetDistance()

float Muto::EditorCamera::GetDistance ( ) const

inline

{ return m_Distance; }

References m_Distance.

GetForwardDirection()

glm::vec3 Muto::EditorCamera::GetForwardDirection

(

)

const

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

GetOrientation()

glm::quat Muto::EditorCamera::GetOrientation

(

)

const

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

GetPitch()

float Muto::EditorCamera::GetPitch ( ) const

inline

{ return m_Pitch; }

References m_Pitch.

GetPosition()

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

inline

{ return m_Position; }

GetRightDirection()

glm::vec3 Muto::EditorCamera::GetRightDirection

(

)

const

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

GetUpDirection()

glm::vec3 Muto::EditorCamera::GetUpDirection

(

)

const

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

GetViewMatrix()

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

inline

{ return m_ViewMatrix; }

GetViewProjection()

glm::mat4 Muto::EditorCamera::GetViewProjection ( ) const

inline

{ return m_Projection * m_ViewMatrix; }

GetYaw()

float Muto::EditorCamera::GetYaw ( ) const

inline

{ return m_Yaw; }

References m_Yaw.

MousePan()

void Muto::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 Muto::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 Muto::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 Muto::EditorCamera::OnEvent

(

Event &

e

)

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

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

OnMouseScroll()

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

private

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

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

Referenced by OnEvent().

OnUpdate()

void Muto::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::MBC_ButtonMiddle))
                MousePan(delta);
            else if (Input::IsMouseButtonPressed(Mouse::MBC_ButtonLeft))
                MouseRotate(delta);
            else if (Input::IsMouseButtonPressed(Mouse::MBC_ButtonRight))
                MouseZoom(-delta.y);
        }
 
        UpdateView();
    }

References Muto::Input::IsKeyPressed(), Muto::Input::IsMouseButtonPressed(), Muto::Key::LeftAlt, Muto::Mouse::MBC_ButtonLeft, Muto::Mouse::MBC_ButtonMiddle, Muto::Mouse::MBC_ButtonRight, MouseZoom(), and UpdateView().

PanSpeed()

std::pair< float, float > Muto::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 };
    }

References m_ViewportHeight, and m_ViewportWidth.

RotationSpeed()

float Muto::EditorCamera::RotationSpeed ( ) const

private

    {
        return 0.8f;
    }

Referenced by MouseRotate().

SetDistance()

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

inline

{ m_Distance = distance; }

References m_Distance.

SetPitch()

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

inline

{ m_Pitch = pitch; }

References m_Pitch.

SetPosition()

void Muto::EditorCamera::SetPosition

(

const glm::vec3 &

position

)

SetViewportSize()

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

inline

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

References m_ViewportHeight, m_ViewportWidth, and UpdateProjection().

SetYaw()

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

inline

{ m_Yaw = yaw; }

References m_Yaw.

UpdateProjection()

void Muto::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 Muto::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 Muto::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 Muto::EditorCamera::m_AspectRatio = 1.778f

private

Referenced by EditorCamera(), and UpdateProjection().

m_Distance

float Muto::EditorCamera::m_Distance = 10.0f

private

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

m_FarClip

float Muto::EditorCamera::m_FarClip = 1000.0f

private

Referenced by EditorCamera().

m_FocalPoint

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

private

m_FOV

float Muto::EditorCamera::m_FOV = 45.0f

private

Referenced by EditorCamera().

m_InitialMousePosition

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

private

{ 0.0f, 0.0f };

m_NearClip

float Muto::EditorCamera::m_NearClip = 0.1f

private

Referenced by EditorCamera().

m_Pitch

float Muto::EditorCamera::m_Pitch = 0.0f

private

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

m_Position

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

private

{ 0.0f, 0.0f, 0.0f };

m_ViewMatrix

glm::mat4 Muto::EditorCamera::m_ViewMatrix

private

m_ViewportHeight

float Muto::EditorCamera::m_ViewportHeight = 720

private

Referenced by PanSpeed(), SetViewportSize(), and UpdateProjection().

m_ViewportWidth

float Muto::EditorCamera::m_ViewportWidth = 1280

private

Referenced by PanSpeed(), SetViewportSize(), and UpdateProjection().

m_Yaw

float Muto::EditorCamera::m_Yaw = 0.0f

private

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

---

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

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