Vesper::WindowsWindow Class Reference

#include <WindowsWindow.h>

Inheritance diagram for Vesper::WindowsWindow:

Classes
struct	WindowData

Public Member Functions
	WindowsWindow (const WindowProps &props)
virtual	~WindowsWindow ()
void	OnUpdate () override
	Called every frame to update the window.
unsigned int	GetWidth () const override
	Retrieves the width of the window.
unsigned int	GetHeight () const override
	Retrieves the height of 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.
bool	IsVSync () const override
	Checks if vertical synchronization (VSync) is enabled.
virtual void *	GetNativeWindow () const override
	Retrieves the native window handle.
Public Member Functions inherited from Vesper::Window
virtual	~Window ()

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

Private Attributes
GLFWwindow *	m_Window
GraphicsContext *	m_Context
WindowData	m_Data

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

---

Class Documentation

Vesper::WindowsWindow::WindowData

struct Vesper::WindowsWindow::WindowData

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

Constructor & Destructor Documentation

WindowsWindow()

Vesper::WindowsWindow::WindowsWindow

(

const WindowProps &

props

)

    {
        VZ_PROFILE_FUNCTION();
        Init(props);
    }

References Init().

~WindowsWindow()

Vesper::WindowsWindow::~WindowsWindow ( )

virtual

    {
        Shutdown();
    }

References Shutdown().

Member Function Documentation

GetHeight()

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

inlineoverridevirtual

Retrieves the height of the window.

Implements Vesper::Window.

{ return m_Data.Height; }

GetNativeWindow()

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

inlineoverridevirtual

Retrieves the native window handle.

Implements Vesper::Window.

{ return m_Window; }

GetWidth()

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

inlineoverridevirtual

Retrieves the width of the window.

Implements Vesper::Window.

{ return m_Data.Width; }

Init()

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

privatevirtual

    {
        VZ_PROFILE_FUNCTION();
        m_Data.Title = props.Title;
        m_Data.Width = props.Width;
        m_Data.Height = props.Height;
 
        VZ_CORE_INFO("Creating window {0} ({1}, {2})", props.Title, props.Width, props.Height);
 
 
        if (!s_GLFWInitialized)
        {
            int success = glfwInit();
            VZ_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);
                VZ_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 Vesper::GLFWErrorCallback(), Vesper::WindowProps::Height, Vesper::GraphicsContext::Init(), m_Context, Vesper::s_GLFWInitialized, SetVSync(), and Vesper::WindowProps::Width.

Referenced by WindowsWindow().

IsVSync()

bool Vesper::WindowsWindow::IsVSync ( ) const

overridevirtual

Checks if vertical synchronization (VSync) is enabled.

Implements Vesper::Window.

    {
        return m_Data.VSync;
    }

OnUpdate()

void Vesper::WindowsWindow::OnUpdate ( )

overridevirtual

Called every frame to update the window.

Implements Vesper::Window.

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

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

SetEventCallback()

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

inlineoverridevirtual

Sets the callback function for window events.

Implements Vesper::Window.

{ m_Data.EventCallback = callback; }

SetVSync()

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

overridevirtual

Sets whether vertical synchronization (VSync) is enabled.

Implements Vesper::Window.

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

Referenced by Init().

Shutdown()

void Vesper::WindowsWindow::Shutdown ( )

privatevirtual

    {
        VZ_PROFILE_FUNCTION();
        glfwDestroyWindow(m_Window);
    }

Referenced by ~WindowsWindow().

Member Data Documentation

m_Context

GraphicsContext* Vesper::WindowsWindow::m_Context

private

Referenced by Init(), and OnUpdate().

m_Data

WindowData Vesper::WindowsWindow::m_Data

private

m_Window

GLFWwindow* Vesper::WindowsWindow::m_Window

private

---

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

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