Muto::WindowsWindow Class Reference

#include <WindowsWindow.h>

Inheritance diagram for Muto::WindowsWindow:

Classes
struct	WindowData

Public Member Functions
unsigned int	GetHeight () const override
	Retrieves the height of the window.
virtual void *	GetNativeWindow () const override
	Retrieves the native window handle.
unsigned int	GetWidth () const override
	Retrieves the width of the window.
bool	IsVSync () const override
	Checks if vertical synchronization (VSync) is enabled.
void	OnUpdate () override
	Called every frame to update the window.
void	SetEventCallback (const EventCallbackFn &callback) override
	Sets the callback function for window events.
void	SetVSync (bool enabled) override
	Sets whether vertical synchronization (VSync) is enabled.
	WindowsWindow (const WindowProps &props)
virtual	~WindowsWindow ()
Public Member Functions inherited from Muto::Window
virtual	~Window ()

Private Member Functions
virtual void	Init (const WindowProps &props)
virtual void	Shutdown ()

Private Attributes
GraphicsContext *	m_Context
WindowData	m_Data
GLFWwindow *	m_Window

Additional Inherited Members
Public Types inherited from Muto::Window
using	EventCallbackFn = std::function< void(Event &)>
Static Public Member Functions inherited from Muto::Window
static Scope< Window >	Create (const WindowProps &props=WindowProps())
	Creates a window instance with the specified properties.

---

Class Documentation

Muto::WindowsWindow::WindowData

struct Muto::WindowsWindow::WindowData

Class Members
EventCallbackFn	EventCallback
unsigned int	Height
string	Title
bool	VSync
unsigned int	Width

Constructor & Destructor Documentation

WindowsWindow()

Muto::WindowsWindow::WindowsWindow

(

const WindowProps &

props

)

    {
        MU_PROFILE_FUNCTION();
        Init(props);
    }

References Init().

~WindowsWindow()

Muto::WindowsWindow::~WindowsWindow ( )

virtual

    {
        Shutdown();
    }

References Shutdown().

Member Function Documentation

GetHeight()

unsigned int Muto::WindowsWindow::GetHeight ( ) const

inlineoverridevirtual

Retrieves the height of the window.

Implements Muto::Window.

{ return m_Data.Height; }

GetNativeWindow()

virtual void * Muto::WindowsWindow::GetNativeWindow ( ) const

inlineoverridevirtual

Retrieves the native window handle.

Implements Muto::Window.

{ return m_Window; }

GetWidth()

unsigned int Muto::WindowsWindow::GetWidth ( ) const

inlineoverridevirtual

Retrieves the width of the window.

Implements Muto::Window.

{ return m_Data.Width; }

Init()

void Muto::WindowsWindow::Init ( const WindowProps &  props )

privatevirtual

    {
        MU_PROFILE_FUNCTION();
        m_Data.Title = props.Title;
        m_Data.Width = props.Width;
        m_Data.Height = props.Height;
 
        MU_CORE_INFO("Creating window {0} ({1}, {2})", props.Title, props.Width, props.Height);
 
 
        if (!s_GLFWInitialized)
        {
            int success = glfwInit();
            MU_CORE_ASSERT(success, "Could not initialize GLFW!");
            glfwSetErrorCallback(GLFWErrorCallback);
            s_GLFWInitialized = true;
        }
 
        m_Window = glfwCreateWindow((int)props.Width, (int)props.Height, m_Data.Title.c_str(), nullptr, nullptr);
 
        m_Context = new OpenGLContext(m_Window);
        m_Context->Init();
 
 
        glfwSetWindowUserPointer(m_Window, &m_Data);
        SetVSync(true);
 
        // Set GLFW callbacks
        glfwSetWindowSizeCallback(m_Window, [](GLFWwindow* window, int width, int height)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                data.Height = height;
                data.Width = width;
 
                WindowResizeEvent event(width, height);
                MU_CORE_WARN("Window resized to {0}, {1}", width, height);
                data.EventCallback(event);
        });
 
        glfwSetWindowCloseCallback(m_Window, [](GLFWwindow* window)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                WindowCloseEvent event;
                data.EventCallback(event);
        });
 
        glfwSetKeyCallback(m_Window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                switch (action)
                {
                    case GLFW_PRESS:
                    {
                        KeyPressedEvent event(key, 0);
                        data.EventCallback(event);
                        break;
                    }
                    case GLFW_RELEASE:
                    {
                        KeyReleasedEvent event(key);
                        data.EventCallback(event);
                        break;
                    }
                    case GLFW_REPEAT:
                    {
                        KeyPressedEvent event(key, 1);
                        data.EventCallback(event);
                        break;
                    }
                }
        });
 
        glfwSetCharCallback(m_Window, [](GLFWwindow* window, unsigned int keycode)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                KeyTypedEvent event(keycode);
                data.EventCallback(event);
        });
 
        glfwSetMouseButtonCallback(m_Window, [](GLFWwindow* window, int button, int action, int mods)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                switch (action)
                {
                    case GLFW_PRESS:
                    {
                        MouseButtonPressedEvent event(button);
                        data.EventCallback(event);
                        break;
                    }
                    case GLFW_RELEASE:
                    {
                        MouseButtonReleasedEvent event(button);
                        data.EventCallback(event);
                        break;
                    }
                }
        });
 
        glfwSetScrollCallback(m_Window, [](GLFWwindow* window, double xOffset, double yOffset)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                MouseScrolledEvent event((float)xOffset, (float)yOffset);
                data.EventCallback(event);
        });
 
        glfwSetCursorPosCallback(m_Window, [](GLFWwindow* window, double xPos, double yPos)
        {
                WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
                MouseMovedEvent event((float)xPos, (float)yPos);
                data.EventCallback(event);
        });
    }

References Muto::GLFWErrorCallback(), Muto::WindowProps::Height, Muto::GraphicsContext::Init(), m_Context, Muto::s_GLFWInitialized, SetVSync(), Muto::WindowProps::Title, and Muto::WindowProps::Width.

Referenced by WindowsWindow().

IsVSync()

bool Muto::WindowsWindow::IsVSync ( ) const

overridevirtual

Checks if vertical synchronization (VSync) is enabled.

Implements Muto::Window.

    {
        return m_Data.VSync;
    }

OnUpdate()

void Muto::WindowsWindow::OnUpdate ( )

overridevirtual

Called every frame to update the window.

Implements Muto::Window.

    {
        MU_PROFILE_FUNCTION();
        glfwPollEvents();
        m_Context->SwapBuffers();
    }

References m_Context, and Muto::GraphicsContext::SwapBuffers().

SetEventCallback()

void Muto::WindowsWindow::SetEventCallback ( const EventCallbackFn &  callback )

inlineoverridevirtual

Sets the callback function for window events.

Implements Muto::Window.

{ m_Data.EventCallback = callback; }

SetVSync()

void Muto::WindowsWindow::SetVSync ( bool  enabled )

overridevirtual

Sets whether vertical synchronization (VSync) is enabled.

Implements Muto::Window.

    {
        MU_PROFILE_FUNCTION();
 
        if (enabled)
            glfwSwapInterval(1);
        else
            glfwSwapInterval(0);
        m_Data.VSync = enabled;
    }

Referenced by Init().

Shutdown()

void Muto::WindowsWindow::Shutdown ( )

privatevirtual

    {
        MU_PROFILE_FUNCTION();
        glfwDestroyWindow(m_Window);
    }

Referenced by ~WindowsWindow().

Member Data Documentation

m_Context

GraphicsContext* Muto::WindowsWindow::m_Context

private

Referenced by Init(), and OnUpdate().

m_Data

WindowData Muto::WindowsWindow::m_Data

private

m_Window

GLFWwindow* Muto::WindowsWindow::m_Window

private

---

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

• Muto/src/Platform/Windows/WindowsWindow.h
• Muto/src/Platform/Windows/WindowsWindow.cpp