The core application class that manages the main loop, window, layers, and event handling. More...

#include <Application.h>

Inheritance diagram for Muto::Application:

Public Member Functions
	Application (ApplicationSettings settings)
	Constructs the Application with the given settings.

	Application (const std::string &name="")
	Constructs the Application with the given name.

void	Close ()
	Closes the application.

ImGuiLayer *	GetImGuiLayer ()
	Retrieves the ImGui layer.

ApplicationSettings &	GetSettings ()
	Retrieves the application settings.

const ApplicationSettings &	GetSettings () const
	Retrieves the application settings as a const reference.

Window &	GetWindow ()
	Retrieves the application window.

void	OnEvent (Event &e)
	Handles incoming events and dispatches them to the appropriate handlers.

void	PushLayer (Layer *layer)
	Adds a layer to the application layer stack.

void	PushOverlay (Layer *overlay)
	Adds an overlay layer to the application layer stack.

std::string	ResolvePath (const std::string &Path, PathResolveMode Mode=PathResolveMode::AssetsDirectory) const
	Resolves the full path to a resource based on a relative path and the application's settings.

void	Run ()
	Starts the main application loop.

virtual	~Application ()

Static Public Member Functions
static Application &	Get ()
	Retrieves the singleton instance of the Application.

Private Member Functions
MutoResult	InitFileSystem ()
	Initializes the file system for the application.

MutoResult	InitFileSystem (ApplicationSettings &Settings)
	Initializes the file system for the application with the given settings.

bool	OnWindowClose (WindowCloseEvent &e)
	Event handler for window close events.

bool	OnWindowResize (WindowResizeEvent &e)
	Event handler for window resize events.

std::string	ResolvePath_AssetsDirectory (const std::string &Path) const
	Resolves the full path to a resource based on the application's assets directory.

std::string	ResolvePath_ProjectDirectory (const std::string &Path) const
	Resolves the full path to a resource based on the application's project directory.

std::string	ResolvePath_WorkingDirectory (const std::string &Path) const
	Resolves the full path to a resource based on the application's working directory.

Private Attributes
ImGuiLayer *	m_ImGuiLayer
	ImGui layer for rendering GUI elements.

float	m_LastFrameTime = 0.0f
	Time of the last frame, used for calculating timestep.

LayerStack	m_LayerStack
	Stack of layers managed by the application.

bool	m_Minimized = false
	Flag indicating whether the application is minimized.

bool	m_Running = true
	Flag indicating whether the application is running.

Scope< ApplicationSettings >	m_Settings
	Scoped pointer to the application settings.

Scope< Window >	m_Window
	Scoped pointer to the applications underlying window.

Static Private Attributes
static Application *	s_Instance = nullptr

Detailed Description

The core application class that manages the main loop, window, layers, and event handling.

Todo:

Update class to accept ApplicationSettings in constructor and verify its utility/use

Create a dedicated ResourceManager class to handle resource path resolution and management

Constructor & Destructor Documentation

◆ Application() [1/2]

Muto::Application::Application ( const std::string & name = "" )

Constructs the Application with the given name.

Parameters

name	The name of the application. Defaults to an empty string.

    {
        MU_PROFILE_FUNCTION();
        MU_CORE_ASSERT(!s_Instance, "Application already exists!");
        s_Instance = this;
 
        m_Window = Window::Create(WindowProps(name));
        m_Window->SetEventCallback(BIND_EVENT_FN(OnEvent));
        m_Window->SetVSync(false);
 
        m_ImGuiLayer = new ImGuiLayer();
        PushOverlay(m_ImGuiLayer);
 
        m_Settings = CreateScope<ApplicationSettings>(ApplicationSettings());
        m_Settings->ApplicationName = name;
        m_Settings->Width = m_Window->GetWidth();
        m_Settings->Height = m_Window->GetHeight();
 
        MutoResult result = InitFileSystem();
        if (!result.IsSuccess())
        {
            MU_CORE_ERROR("Application::InitFileSystem() was not successful. Message: {0}", result.ResultMessage);
            MU_CORE_ASSERT(false, result.ReturnError());
        }
 
        // Init the renderer at the end to ensure pathing has been setup correctly for any resources that may be needed during initialization.
        Renderer::Init();
    }

References Muto::ImGuiLayer::ImGuiLayer(), Muto::Renderer::Init(), InitFileSystem(), Muto::MutoResult::IsSuccess(), m_ImGuiLayer, PushOverlay(), Muto::MutoResult::ResultMessage, and s_Instance.

◆ Application() [2/2]

Muto::Application::Application ( ApplicationSettings settings )

Constructs the Application with the given settings.

Parameters

settings The settings to configure the application.

    {
        MU_PROFILE_FUNCTION();
        MU_CORE_ASSERT(!s_Instance, "Application already exists!");
        s_Instance = this;
 
        m_Window = Window::Create(WindowProps(settings.ApplicationName, settings.Width, settings.Height));
        m_Window->SetEventCallback(BIND_EVENT_FN(OnEvent));
        m_Window->SetVSync(settings.EnableVSync);
 
        m_Settings = CreateScope<ApplicationSettings>(settings);
        if (m_Settings->RendererAPIType == RenderAPI::API::RAPI_None)
        {
            m_Settings->EnableImGui = false;
            MU_CORE_WARN("RenderAPI is set to None, disabling ImGui.");
        }
        if (m_Settings->EnableImGui)
        {
            m_ImGuiLayer = new ImGuiLayer();
            PushOverlay(m_ImGuiLayer);
        }
        else
        {
            m_ImGuiLayer = nullptr;
        }
 
        MutoResult result = InitFileSystem(*m_Settings);
        if (!result.IsSuccess())
        {
            MU_CORE_ERROR("Application::InitFileSystem( *m_Settings ) was not successful. Message: {0}", result.ResultMessage);
            MU_CORE_ASSERT(false, result.ReturnError());
        }
 
        // Init the renderer at the end to ensure pathing has been setup correctly for any resources that may be needed during initialization.
        Renderer::Init();
    }

References Muto::ImGuiLayer::ImGuiLayer(), Muto::Renderer::Init(), Muto::MutoResult::IsSuccess(), m_ImGuiLayer, PushOverlay(), Muto::MutoResult::ResultMessage, and s_Instance.

Referenced by SandboxApp::SandboxApp().

◆ ~Application()

Muto::Application::~Application ( )

virtual

86 {

87 }

Member Function Documentation

◆ Close()

void Muto::Application::Close ( )

Closes the application.

    {
        m_Running = false;
    }

References m_Running.

Referenced by Muto::EditorLayer::OnImGuiRender().

◆ Get()

static Application & Muto::Application::Get ( )

inlinestatic

Retrieves the singleton instance of the Application.

107{ return *s_Instance; }

References s_Instance.

Referenced by Muto::ImGuiLayer::End(), Muto::Input::GetMousePosition(), Muto::Renderer2D::Init(), Muto::Input::IsKeyPressed(), Muto::Input::IsMouseButtonPressed(), Muto::ImGuiLayer::OnAttach(), Muto::EditorLayer::OnImGuiRender(), and Sandbox2D::OnUpdate().

◆ GetImGuiLayer()

ImGuiLayer * Muto::Application::GetImGuiLayer ( )

inline

Retrieves the ImGui layer.

104{ return m_ImGuiLayer; }

References m_ImGuiLayer.

Referenced by Muto::EditorLayer::OnImGuiRender().

◆ GetSettings() [1/2]

ApplicationSettings & Muto::Application::GetSettings ( )

inline

Retrieves the application settings.

113{ return *m_Settings; }

◆ GetSettings() [2/2]

const ApplicationSettings & Muto::Application::GetSettings ( ) const

inline

Retrieves the application settings as a const reference.

116{ return *m_Settings; }

◆ GetWindow()

Window & Muto::Application::GetWindow ( )

inline

Retrieves the application window.

110{ return *m_Window; }

Referenced by Muto::ImGuiLayer::End(), Muto::Input::GetMousePosition(), Muto::Input::IsKeyPressed(), Muto::Input::IsMouseButtonPressed(), and Sandbox2D::OnUpdate().

◆ InitFileSystem() [1/2]

MutoResult Muto::Application::InitFileSystem ( )

private

Initializes the file system for the application.

Ensure working directory exists

Ensure project directory exists

Ensure assets directory exists

Ensure working directory exists

Ensure project directory exists

Ensure assets directory exists

    {
        MutoResult result;
 
        if (GW::GReturn::SUCCESS != m_Settings->FileSystem.Create())
        {
            result = MutoResult(MU_RETURN::FAILURE, "Failed to create file system.");
            MU_CORE_ERROR("Failed to create file system.");
            return result;
        }
 
        char currentWorkingDirectory[255];
        if (GW::GReturn::SUCCESS != m_Settings->FileSystem.GetCurrentWorkingDirectory(currentWorkingDirectory, sizeof(currentWorkingDirectory)))
        {
            result = MutoResult(MU_RETURN::FAILURE, "Failed to get current working directory.");
            MU_CORE_ERROR("Failed to get current working directory.");
            return result;
        }
        else
        {
            m_Settings->WorkingDirectory = Muto::NormalizePath(currentWorkingDirectory);
            MU_CORE_INFO("Current working directory: {0}", m_Settings->WorkingDirectory);
        }
 
 
        std::filesystem::path workDir = m_Settings->WorkingDirectory;
        if (!std::filesystem::exists(workDir))
        {
            result = MutoResult(MU_RETURN::FAILURE, "Working directory does not exist.");
            MU_CORE_ERROR("Working directory does not exist: {0}", m_Settings->WorkingDirectory);
            return result;
        }
        else
        {
            MU_CORE_INFO("Working directory exists: {0}", m_Settings->WorkingDirectory);
        }
        if (!m_Settings->ProjectDirectory.empty() && !Muto::IsAbsolutePath(m_Settings->ProjectDirectory))
        {
            m_Settings->ProjectDirectory = Muto::JoinPaths(m_Settings->WorkingDirectory, m_Settings->ProjectDirectory);
            MU_CORE_INFO("Resolved relative Project directory to: {0}", m_Settings->ProjectDirectory);
        }
 
 
        if (!m_Settings->WorkingDirectory.empty())
        {
            if (m_Settings->ProjectDirectory.empty())
            {
                m_Settings->ProjectDirectory = Muto::JoinPaths(m_Settings->WorkingDirectory, "Project");
                MU_CORE_INFO("Project directory is: {0}", m_Settings->ProjectDirectory);
            }
 
            std::filesystem::path projDir = Muto::NormalizePath(m_Settings->ProjectDirectory);
            if (!std::filesystem::exists(projDir))
            {
                if (std::filesystem::create_directories(projDir))
                {
                    MU_CORE_INFO("Project directory created: {0}", m_Settings->ProjectDirectory);
                }
                else
                {
                    result = MutoResult(MU_RETURN::FAILURE, "Failed to create project directory.");
                    MU_CORE_ERROR("Failed to create project directory: {0}", m_Settings->ProjectDirectory);
                    return result;
                }
            }
            else
            {
                MU_CORE_INFO("Project directory already exists: {0}", m_Settings->ProjectDirectory);
            }
        }
        else
        {
            MU_CORE_WARN("Working directory is empty, cannot create project directory path.");
        }
        if (!m_Settings->AssetsDirectory.empty() && !Muto::IsAbsolutePath(m_Settings->AssetsDirectory))
        {
            m_Settings->AssetsDirectory = Muto::JoinPaths(m_Settings->WorkingDirectory, m_Settings->AssetsDirectory);
            MU_CORE_INFO("Resolved relative Assets directory to: {0}", m_Settings->AssetsDirectory);
        }
 
 
        if (m_Settings->AssetsDirectory.empty())
        {
            if (!m_Settings->ProjectDirectory.empty())
            {
                m_Settings->AssetsDirectory = Muto::JoinPaths(m_Settings->ProjectDirectory, "Assets");
                MU_CORE_INFO("Assets directory is: {0}", m_Settings->AssetsDirectory);
            }
            else
            {
                MU_CORE_WARN("Project directory is empty, cannot create assets directory path.");
            }
        }
 
        if (!m_Settings->AssetsDirectory.empty())
        {
            std::filesystem::path assetsDir = Muto::NormalizePath(m_Settings->AssetsDirectory);
            if (!std::filesystem::exists(assetsDir))
            {
                if (std::filesystem::create_directories(assetsDir))
                {
                    MU_CORE_INFO("Assets directory created: {0}", m_Settings->AssetsDirectory);
                }
                else
                {
                    result = MutoResult(MU_RETURN::FAILURE, "Failed to create assets directory.");
                    MU_CORE_ERROR("Failed to create assets directory: {0}", m_Settings->AssetsDirectory);
                    return result;
                }
            }
            else
            {
                MU_CORE_INFO("Assets directory already exists: {0}", m_Settings->AssetsDirectory);
            }
        }
        return result;
    }

References Muto::FAILURE.

Referenced by Application().

◆ InitFileSystem() [2/2]

MutoResult Muto::Application::InitFileSystem ( ApplicationSettings & Settings )

private

Initializes the file system for the application with the given settings.

Parameters

Settings The settings to configure the file system.

Ensure working directory exists

Ensure project directory exists

Ensure assets directory exists

Ensure working directory exists

Ensure project directory exists

Ensure assets directory exists

    {
        MutoResult result;
        if (GW::GReturn::SUCCESS != settings.FileSystem.Create())
        {
            result = MutoResult(MU_RETURN::FAILURE, "Failed to create file system.");
            MU_CORE_ERROR("Failed to create file system.");
            return result;
        }
 
        char currentWorkingDirectory[255];
        if (settings.WorkingDirectory.empty())
        {
            if (GW::GReturn::SUCCESS != settings.FileSystem.GetCurrentWorkingDirectory(currentWorkingDirectory, sizeof(currentWorkingDirectory)))
            {
                result = MutoResult(MU_RETURN::FAILURE, "Failed to get current working directory.");
                MU_CORE_ERROR("Failed to get current working directory.");
                return result;
            }
            else
            {
                settings.WorkingDirectory = Muto::NormalizePath(currentWorkingDirectory);
                MU_CORE_INFO("Current working directory: {0}", settings.WorkingDirectory);
            }
        }
        else
        {
            if (GW::GReturn::SUCCESS != settings.FileSystem.SetCurrentWorkingDirectory(Muto::NormalizePath(settings.WorkingDirectory).c_str()))
            {
                result = MutoResult(MU_RETURN::FAILURE, "Failed to set current working directory.");
                MU_CORE_ASSERT(false, "Failed to set current working directory.");
                return result;
            }
            else
            {
                MU_CORE_INFO("Current working directory: {0}", settings.WorkingDirectory);
            }
        }
 
        std::filesystem::path workDir = settings.WorkingDirectory;
        if (!std::filesystem::exists(workDir))
        {
            result = MutoResult(MU_RETURN::FAILURE, "Working directory does not exist.");
            MU_CORE_ERROR("Working directory does not exist: {0}", settings.WorkingDirectory);
            return result;
        }
        else
        {
            MU_CORE_INFO("Working directory exists: {0}", settings.WorkingDirectory);
        }
        if (!settings.ProjectDirectory.empty() && !Muto::IsAbsolutePath(settings.ProjectDirectory))
        {
            settings.ProjectDirectory = Muto::JoinPaths(settings.WorkingDirectory, settings.ProjectDirectory);
            MU_CORE_INFO("Resolved relative Project directory to: {0}", settings.ProjectDirectory);
        }
        if (settings.ProjectDirectory.empty())
        {
            settings.ProjectDirectory = Muto::JoinPaths(settings.WorkingDirectory, "Project");
            MU_CORE_INFO("Project Directory is: {0}", settings.ProjectDirectory);
        }
        else
        {
            MU_CORE_INFO("Project Directory is: {0}", settings.ProjectDirectory);
        }
 
        std::filesystem::path projDir = settings.ProjectDirectory;
        if (!std::filesystem::exists(projDir))
        {
            if (std::filesystem::create_directories(projDir))
            {
                MU_CORE_INFO("Project directory created: {0}", settings.ProjectDirectory);
            }
            else
            {
                result = MutoResult(MU_RETURN::FAILURE, "Failed to create project directory.");
                MU_CORE_ERROR("Failed to create project directory: {0}", settings.ProjectDirectory);
                return result;
            }
        }
        else
        {
            MU_CORE_INFO("Project directory already exists: {0}", settings.ProjectDirectory);
        }
        if (!settings.AssetsDirectory.empty() && !Muto::IsAbsolutePath(settings.AssetsDirectory))
        {
            settings.AssetsDirectory = Muto::JoinPaths(settings.WorkingDirectory, settings.AssetsDirectory);
            MU_CORE_INFO("Resolved relative Assets directory to: {0}", settings.AssetsDirectory);
        }
 
        if (settings.AssetsDirectory.empty())
        {
            settings.AssetsDirectory = Muto::JoinPaths(settings.ProjectDirectory, "Assets");
            MU_CORE_INFO("Assets Directory was empty. It defaulted to: {0}", settings.AssetsDirectory);
        }
        else
        {
            MU_CORE_INFO("Assets Directory is: {0}", settings.AssetsDirectory);
        }
        std::filesystem::path assetsDir = settings.AssetsDirectory;
        if (!std::filesystem::exists(assetsDir))
        {
            if (std::filesystem::create_directories(assetsDir))
            {
                MU_CORE_INFO("Assets directory created: {0}", settings.AssetsDirectory);
            }
            else
            {
                result = MutoResult(MU_RETURN::FAILURE, "Failed to create assets directory.");
                MU_CORE_ERROR("Failed to create assets directory: {0}", settings.AssetsDirectory);
                return result;
            }
        }
        else
        {
            MU_CORE_INFO("Assets directory already exists: {0}", settings.AssetsDirectory);
        }
 
        return result;
    }

References Muto::ApplicationSettings::AssetsDirectory, Muto::FAILURE, Muto::IsAbsolutePath(), Muto::JoinPaths(), Muto::NormalizePath(), Muto::ApplicationSettings::ProjectDirectory, and Muto::ApplicationSettings::WorkingDirectory.

◆ OnEvent()

void Muto::Application::OnEvent ( Event & e )

Handles incoming events and dispatches them to the appropriate handlers.

    {
        MU_PROFILE_FUNCTION();
        EventDispatcher dispatcher(e);
        dispatcher.Dispatch<WindowCloseEvent>(BIND_EVENT_FN(OnWindowClose));
        dispatcher.Dispatch<WindowResizeEvent>(BIND_EVENT_FN(OnWindowResize));
 
        for (auto it = m_LayerStack.rbegin(); it != m_LayerStack.rend(); ++it)
        {
            if (e.Handled)
                break;
            (*it)->OnEvent(e);
        }
 
    }

References Muto::EventDispatcher::EventDispatcher(), Muto::Event::Handled, OnWindowClose(), and OnWindowResize().

◆ OnWindowClose()

bool Muto::Application::OnWindowClose ( WindowCloseEvent & e )

private

Event handler for window close events.

    {
        MU_PROFILE_FUNCTION();
        m_Running = false;
        return true;
    }

References m_Running.

Referenced by OnEvent().

◆ OnWindowResize()

bool Muto::Application::OnWindowResize ( WindowResizeEvent & e )

private

Event handler for window resize events.

    {
        MU_PROFILE_FUNCTION();
        if (e.GetWidth() == 0 || e.GetHeight() == 0)
        {
            m_Minimized = true;
            return false;
        }
 
        m_Minimized = false;
        Renderer::OnWindowResize(e.GetWidth(), e.GetHeight());
        m_Settings->Width = e.GetWidth();
        m_Settings->Height = e.GetHeight();
        return false;
    }

References Muto::WindowResizeEvent::GetHeight(), Muto::WindowResizeEvent::GetWidth(), m_Minimized, and Muto::Renderer::OnWindowResize().

Referenced by OnEvent().

◆ PushLayer()

void Muto::Application::PushLayer ( Layer * layer )

Adds a layer to the application layer stack.

    {
        MU_PROFILE_FUNCTION();
        m_LayerStack.PushLayer(layer);
        layer->OnAttach();
    }

References Muto::Layer::OnAttach().

Referenced by Muto::Mutare::Mutare(), SandboxApp::SandboxApp(), and SandboxApp::SandboxApp().

◆ PushOverlay()

void Muto::Application::PushOverlay ( Layer * overlay )

Adds an overlay layer to the application layer stack.

    {
        MU_PROFILE_FUNCTION();
        m_LayerStack.PushOverlay(overlay);
        overlay->OnAttach();
    }

References Muto::Layer::OnAttach().

Referenced by Application(), and Application().

◆ ResolvePath()

std::string Muto::Application::ResolvePath	(	const std::string &	Path,
		PathResolveMode	Mode = `PathResolveMode::AssetsDirectory`
	)		const

Resolves the full path to a resource based on a relative path and the application's settings.

Parameters

Path	The path to the resource.
Mode	The mode to use for resolving the path. Defaults to PathResolveMode::AssetsDirectory.

    {
        if (path.empty())
        {
            MU_CORE_WARN("ResolvePath called with empty path.");
            return std::string();
        }
 
        std::string resolvedPath;
        switch (mode)
        {
            case PathResolveMode::WorkingDirectory:
                resolvedPath = ResolvePath_WorkingDirectory(path);
                break;
            case PathResolveMode::ProjectDirectory:
                resolvedPath = ResolvePath_ProjectDirectory(path);
                break;
            case PathResolveMode::AssetsDirectory:
                resolvedPath = ResolvePath_AssetsDirectory(path);
                break;
            default:
                MU_CORE_WARN("ResolvePath called with unknown PathResolveMode.");
                resolvedPath = std::string();
                break;
        }
        return resolvedPath;
    }

References Muto::AssetsDirectory, Muto::ProjectDirectory, ResolvePath_AssetsDirectory(), ResolvePath_ProjectDirectory(), ResolvePath_WorkingDirectory(), and Muto::WorkingDirectory.

Referenced by Muto::Renderer2D::Init(), and Muto::ImGuiLayer::OnAttach().

◆ ResolvePath_AssetsDirectory()

std::string Muto::Application::ResolvePath_AssetsDirectory ( const std::string & Path ) const

private

Resolves the full path to a resource based on the application's assets directory.

Parameters

Path	The path to the resource.

    {
        std::string resultPath;
 
        if (m_Settings->AssetsDirectory.empty())
        {
            MU_CORE_WARN("AssetsDirectory is empty, cannot resolve path.");
            return std::string();
        }
 
        if (path.empty())
        {
            MU_CORE_WARN("ResolvePath_AssetsDirectory called with empty path.");
            return std::string();
        }
 
        if (Muto::IsAbsolutePath(path))
        {
            MU_CORE_WARN("ResolvePath_AssetsDirectory called with an absolute path: {0}", path);
            return Muto::NormalizePath(path);
        }
 
        resultPath = Muto::JoinPaths(m_Settings->AssetsDirectory, path);
        return resultPath;
    }

References Muto::IsAbsolutePath(), and Muto::NormalizePath().

Referenced by ResolvePath().

◆ ResolvePath_ProjectDirectory()

std::string Muto::Application::ResolvePath_ProjectDirectory ( const std::string & Path ) const

private

Resolves the full path to a resource based on the application's project directory.

Parameters

Path	The path to the resource.

    {
        std::string resultPath;
 
        if (m_Settings->ProjectDirectory.empty())
        {
            MU_CORE_WARN("ProjectDirectory is empty, cannot resolve path.");
            return std::string();
        }
 
        if (path.empty())
        {
            MU_CORE_WARN("ResolvePath_ProjectDirectory called with empty path.");
            return std::string();
        }
 
        if (Muto::IsAbsolutePath(path))
        {
            MU_CORE_WARN("ResolvePath_ProjectDirectory called with an absolute path: {0}", path);
            return Muto::NormalizePath(path);
        }
 
        resultPath = Muto::JoinPaths(m_Settings->ProjectDirectory, path);
        return resultPath;
    }

References Muto::IsAbsolutePath(), and Muto::NormalizePath().

Referenced by ResolvePath().

◆ ResolvePath_WorkingDirectory()

std::string Muto::Application::ResolvePath_WorkingDirectory ( const std::string & Path ) const

private

Resolves the full path to a resource based on the application's working directory.

Parameters

Path	The path to the resource.

    {
        std::string resultPath;
 
        if (m_Settings->WorkingDirectory.empty())
        {
            MU_CORE_WARN("WorkingDirectory is empty, cannot resolve path.");
            return std::string();
        }
 
        if (path.empty())
        {
            MU_CORE_WARN("ResolvePath_WorkingDirectory called with empty path.");
            return std::string();
        }
 
        if (Muto::IsAbsolutePath(path))
        {
            MU_CORE_WARN("ResolvePath_WorkingDirectory called with an absolute path: {0}", path);
            return Muto::NormalizePath(path);
        }
 
        resultPath = Muto::JoinPaths(m_Settings->WorkingDirectory, path);
        return resultPath;
    }

References Muto::IsAbsolutePath(), and Muto::NormalizePath().

Referenced by ResolvePath().

◆ Run()

void Muto::Application::Run ( )

Starts the main application loop.

Todo:

Add Layer rendering into the main loop

Add separate threads for rendering and updating

Todo:: split the Run function into separate functions for update and render, and add a thread for each

Todo:: split the Run function into separate functions for update and render, and add a thread for each

Todo:: Platform::GetTime()

Todo:: Sort layers

Update layers

ImGui render layers

Todo:: Add a Layer render function and call it here for all Layers

Update window second

Todo:: Platform::GetTime()

Todo:: Sort layers

Update layers

ImGui render layers

Todo:: Add a Layer render function and call it here for all Layers

Update window second

    {
        MU_PROFILE_FUNCTION();
        while (m_Running)
        {
            MU_PROFILE_SCOPE("RunLoop");
            float time = (float)glfwGetTime();
            Timestep timestep = time - m_LastFrameTime;
            m_LastFrameTime = time;
 
            if (!m_Minimized)
            {
                MU_PROFILE_SCOPE("LayerStack OnUpdate");
 
 
                for (auto layer : m_LayerStack)
                    layer->OnUpdate(timestep);
            }
 
            {
                MU_PROFILE_SCOPE("ImGuiLayer OnImGuiRender");
                m_ImGuiLayer->Begin();
                for (auto layer : m_LayerStack)
                    layer->OnImGuiRender();
                m_ImGuiLayer->End();
            }
 
 
            {
                MU_PROFILE_SCOPE("Window OnUpdate");
                m_Window->OnUpdate();
            }
        };
    }

References Muto::ImGuiLayer::Begin(), Muto::ImGuiLayer::End(), m_ImGuiLayer, m_LastFrameTime, m_Minimized, and m_Running.

Member Data Documentation

◆ m_ImGuiLayer

ImGuiLayer* Muto::Application::m_ImGuiLayer

private

ImGui layer for rendering GUI elements.

Referenced by Application(), Application(), GetImGuiLayer(), and Run().

◆ m_LastFrameTime

float Muto::Application::m_LastFrameTime = 0.0f

private

Time of the last frame, used for calculating timestep.

Referenced by Run().

◆ m_LayerStack

LayerStack Muto::Application::m_LayerStack

private

Stack of layers managed by the application.

◆ m_Minimized

bool Muto::Application::m_Minimized = false

private

Flag indicating whether the application is minimized.

Referenced by OnWindowResize(), and Run().

◆ m_Running

bool Muto::Application::m_Running = true

private

Flag indicating whether the application is running.

Referenced by Close(), OnWindowClose(), and Run().

◆ m_Settings

Scope<ApplicationSettings> Muto::Application::m_Settings

private

Scoped pointer to the application settings.

◆ m_Window

Scope<Window> Muto::Application::m_Window

private

Scoped pointer to the applications underlying window.

◆ s_Instance

Application * Muto::Application::s_Instance = nullptr

staticprivate

Referenced by Application(), Application(), and Get().

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

Muto/src/App/Application.h
Muto/src/App/Application.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Application() [1/2]

◆ Application() [2/2]

◆ ~Application()

Member Function Documentation

◆ Close()

◆ Get()

◆ GetImGuiLayer()

◆ GetSettings() [1/2]

◆ GetSettings() [2/2]

◆ GetWindow()

◆ InitFileSystem() [1/2]

◆ InitFileSystem() [2/2]

◆ OnEvent()

◆ OnWindowClose()

◆ OnWindowResize()

◆ PushLayer()

◆ PushOverlay()

◆ ResolvePath()

◆ ResolvePath_AssetsDirectory()

◆ ResolvePath_ProjectDirectory()

◆ ResolvePath_WorkingDirectory()

◆ Run()

Member Data Documentation

◆ m_ImGuiLayer

◆ m_LastFrameTime

◆ m_LayerStack

◆ m_Minimized

◆ m_Running

◆ m_Settings

◆ m_Window

◆ s_Instance